Слово от автора
Дорогие читатели,
Машинное обучение — это не просто захватывающее направление, оно стоит на
пороге революции в способах, которыми мы понимаем и взаимодействуем с миром. В
последние годы мы стали свидетелями того, как искусственный интеллект проникает в
самые разные области: от здравоохранения и финансов до искусства и спорта. И если вы
хотите быть частью этого захватывающего процесса, то освоение машинного обучения
станет важным шагом на вашем пути.
Эта книга не претендует на то, чтобы охватить все возможные аспекты машинного
обучения. Вместо этого я сосредоточился на практическом подходе, который позволит вам
не только изучить теоретические основы, но и научиться применять алгоритмы на
практике, решая реальные задачи с помощью Python. Я постарался сделать материал
доступным и понятным, независимо от того, являетесь ли вы новичком или опытным
программистом.
Машинное обучение может показаться сложным, но я уверен, что с правильным
подходом и инструментами, каждый из вас сможет овладеть этим искусством и создать
что-то полезное и значимое. Я приглашаю вас исследовать мир данных, работать с
алгоритмами и решать задачи, которые могут повлиять на будущее.
Спасибо, что выбрали эту книгу. Я надеюсь, что она станет для вас не только
полезным источником знаний, но и вдохновением для новых проектов и идей.
С уважением,
Тайлер Венс
Введение
- Что такое машинное обучение?
- Роль Python в машинном обучении
- Обзор используемых библиотек
Что такое машинное обучение?
Машинное обучение — это область искусственного интеллекта, занимающаяся
разработкой алгоритмов, которые позволяют компьютерам учиться на данных и делать
предсказания или принимать решения без явного программирования для каждой
конкретной задачи. В отличие от традиционного подхода, где программы жестко следуют
заранее заданным инструкциям, алгоритмы машинного обучения используют данные для
построения моделей, которые могут улучшаться с опытом.
Машинное обучение можно разделить на три основные категории:
1. Обучение с учителем (Supervised Learning):
Обучение с учителем (Supervised Lear ning) — это один из наиболее
распространенных подходов в машинном обучении, в котором алгоритм обучается на
размеченных данных, то есть данных, где каждый вход имеет соответствующий
правильный ответ. В таком подходе модель получает набор данных, в котором для
каждого примера заданы как входные признаки (характеристики или особенности
объекта), так и соответствующий выход (метка или правильный ответ). Задача модели
заключается в том, чтобы научиться связывать эти входные признаки с правильным
выходом, а затем использовать полученные знания для предсказания ответов на новых,
неразмеченных данных.
В процессе обучения с учителем модель анализирует взаимосвязь между входными
данными и правильными ответами, с целью минимизировать ошибку предсказания. Это
достигается путем нахождения математической функции или модели, которая наилучшим
образом описывает зависимость между входом и выходом. Важно, что для каждого

примера в обучающем наборе данных известен правильный результат, который
используется для оценки качества работы модели. Например, в задаче классификации
изображений алгоритм может обучаться на наборе изображений с метками,
указывающими, что на каждом изображении изображен заяц, кошка или собака. Обучив
модель, она должна быть способна классифицировать новые изображения на основе
ранее усвоенных закономерностей.
Типичные задачи обучения с учителем включают классификацию, где целью
является отнесение данных к одной из заранее определенных категорий, и регрессию, где
модель предсказывает числовое значение на основе входных данных. Например,
классификация изображений может быть использована для распознавания объектов,
таких как автомобили или животные, на фотографиях. В случае регрессии модель может
предсказывать цены на недвижимость на основе характеристик, таких как площадь,
расположение и возраст здания. В обоих случаях модель учится на размеченных
примерах, чтобы в дальнейшем точно предсказать результаты для новых данных.
Процесс обучения с учителем обычно включает несколько ключевых этапов.
Сначала данные разбиваются на обучающую и тестовую выборки. Модель обучается на
обучающем наборе данных, где для каждого примера известен правильный ответ. Затем
она проверяется на тестовых данных, чтобы оценить, насколько хорошо она справляется с
предсказанием на новых, ранее невиданных примерах. В процессе обучения модель
оптимизирует свои параметры, чтобы минимизировать ошибку на тестовой выборке. Для
этого используется функция потерь, которая измеряет расхождение между
предсказанным значением и реальным ответом.
Важным аспектом обучения с учителем является выбор метрик для оценки качества
модели. В задачах классификации часто используются такие метрики, как точность
(accuracy), прецизионность (precision), полнота (recall) и F-мера, которые помогают оценить,
насколько хорошо модель классифицирует объекты. В задачах регрессии важно измерить,
насколько точно модель предсказывает числовые значения, для чего обычно используется
среднеквадратическая ошибка (MSE) или коэффициент детерминации R².
Обучение с учителем применимо в широком спектре задач, включая те, где
необходимо классифицировать объекты, предсказать числовые значения или даже
принять решения на основе данных. Одним из ярких примеров использования обучения с
учителем является прогнозирование цен на основе исторических данных. В таком случае
модель обучается на наборах данных, содержащих информацию о ценах на товары или
услуги за предыдущие периоды, а затем используется для предсказания будущих цен на
основании новых данных.
Обучение с учителем также используется в области здравоохранения, где
алгоритмы могут быть обучены на медицинских данных для предсказания заболеваний или
диагностики на основе симптомов. В финансовом секторе модели могут быть
использованы для предсказания кредитных рисков или прогнозирования изменений на
фондовом рынке. В рекламе и маркетинге обучение с учителем помогает
классифицировать клиентов, предсказывать их поведение и персонализировать
предложения на основе предпочтений пользователей.
Обучение с учителем является мощным инструментом, который позволяет моделям
предсказывать результаты на основе заранее размеченных данных. Этот подход активно
используется в реальных приложениях, где точность предсказаний и способность модели
адаптироваться к новым данным играют важную роль.
2. Обучение без учителя (Unsupervised Learning):
Обучение без учителя (Unsupervised Learning) — это подход машинного обучения, в
котором модель обучается на неразмеченных данных, то есть данных, которые не
содержат явных меток или ответов. В отличие от обучения с учителем, где модель
обучается на основе данных с известными метками, в обучении без учителя задача состоит
в том, чтобы выявить скрытые закономерности или структуры, которые могут быть
полезными для дальнейшего анализа. Это означает, что алгоритмы обучаются на данных,
которые не имеют заранее определенных выходных значений, и вместо этого стремятся
найти такие зависимости, которые могут описывать данные с разных сторон.
Одной из ключевых задач обучения без учителя является поиск паттернов или
кластеров в данных. Например, при анализе пользовательских предпочтений в онлайнмагазинах алгоритмы могут выявить группы пользователей с похожими интересами или

покупательскими привычками. Это позволяет создавать рекомендации, ориентированные
на отдельные сегменты пользователей, улучшая персонализацию и повышая
эффективность маркетинга. Кластеризация данных, в свою очередь, помогает разделить
большие объемы информации на группы, что облегчает их дальнейший анализ.
Еще одной важной задачей, которую решает обучение без учителя, является поиск
аномалий в данных. Аномалии представляют собой редкие или необычные случаи, которые
могут быть важными для определенных задач, например, в области безопасности или
диагностики. Например, алгоритмы могут быть использованы для выявления необычных
транзакций в банковских системах, которые могут указывать на мошенничество, или для
обнаружения неполадок в оборудовании, когда определенные измерения отклоняются от
нормы.
Алгоритмы обучения без учителя пытаются понять структуру данных и выделить
такие характеристики, которые могут быть полезны для решения поставленных задач.
Один из наиболее распространенных методов — это кластеризация, где данные
группируются по сходству. Например, алгоритм k-средних пытается разделить данные на
несколько кластеров, минимизируя внутригрупповые различия и максимизируя различия
между группами. Другим методом является метод главных компонент (PCA), который
используется для уменьшения размерности данных, выявляя наиболее значимые
особенности, которые объясняют наибольшую часть вариации в данных.
Кроме того, обучение без учителя часто применяется в задачах, связанных с
уменьшением размерности и сжатием информации. Это необходимо, например, при
анализе больших данных, когда требуется снизить объем информации, сохраняя при этом
наиболее важные характеристики. Методы, такие как автокодировщики, используют
нейронные сети для создания компактных представлений данных, что помогает
эффективно работать с большими объемами информации, сокращая вычислительные
ресурсы.
В отличие от обучения с учителем, где модель получает четкие метки, обучение без
учителя не имеет такого явного руководства, и алгоритм сам должен выявлять полезные
структуры в данных. Это создает определенные сложности, так как трудно оценить
точность модели, если нет заранее известных меток для проверки. Однако, несмотря на
эти сложности, обучение без учителя чрезвычайно полезно в ситуациях, где метки данных
трудно получить, например, при работе с большими объемами неструктурированных
данных.
Обучение без учителя является мощным инструментом для анализа неразмеченных
данных, выявления скрытых структур и закономерностей, что открывает широкие
возможности в самых разных областях, таких как маркетинг, диагностика, безопасность и
многие другие. Алгоритмы обучения без учителя помогают не только анализировать
данные, но и создавать новые, неожиданные инсайты, которые могут стать основой для
инновационных решений.
3. Обучение с подкреплением (Reinforcement Learning):
Обучение с подкреплением (Reinforcement Learning) — это один из подходов
машинного обучения, в котором агент обучается через взаимодействие с окружающей
средой, получая вознаграждения (или наказания) за совершенные действия. В отличие от
обучения с учителем, где данные заранее размечены, в обучении с подкреплением агент не
получает прямых указаний на то, какие действия являются правильными. Вместо этого он
выполняет действия в своей среде, получает обратную связь в виде награды и использует
эти данные для улучшения своей стратегии.
В обучении с подкреплением важными компонентами являются агент, который
принимает решения, и окружающая среда, с которой он взаимодействует. Агент действует
в определенном состоянии среды, выбирая действие, которое, по его мнению, поможет
ему достичь наибольшей награды. Состояние описывает текущее положение агента в
среде, например, его положение в игре или действия, которые он выполняет в процессе
работы. Каждое действие агента изменяет состояние среды, а также может быть связано с
получением награды, которая помогает агенту понять, насколько правильно он действовал.
Основной задачей агента является максимизация суммарной награды, получаемой
за выполнение последовательности действий. В процессе обучения агент сталкивается с
дилеммой: исследовать новые действия и состояния (что может привести к
дополнительным наградам в будущем), или использовать уже известные, проверенные

стратегии (что позволяет получать стабильную, но не всегда максимальную награду). Эта
проблема баланса между исследованием (exploration) и эксплуатацией (exploitation)
является одной из центральных в обучении с подкреплением.
Алгоритмы обучения с подкреплением, такие как Q-learning, обучают агента,
обновляя ценности для различных пар состояния-действие, в то время как методы
градиентного спуска по политике (policy gradient) обучают агента выбирать действия на
основе стратегии, которая максимизирует награду. В более сложных подходах, таких как
актор-критик или глубокое обучение с подкреплением (Deep Reinforcement Learning),
используется комбинация методов для более эффективного обучения.
Применение обучения с подкреплением разнообразно и охватывает такие области,
как робототехника, где RL используется для обучения роботов выполнять задачи, такие
как захват объектов или навигация. В игровых приложениях обучение с подкреплением
демонстрирует отличные результаты, например, в играх, таких как шахматы или го, где
алгоритмы, как AlphaGo, смогли победить сильных человеческих игроков. В сфере
автономных транспортных средств обучение с подкреплением помогает создавать
системы, которые могут принимать оптимальные решения на дороге, улучшая
безопасность и эффективность движения. Также этот подход находит применение в
финансовых рынках, где агент учится принимать торговые решения для получения
максимальной прибыли.
Несмотря на свою мощь, обучение с подкреплением сталкивается с рядом вызовов.
Одним из них является высокая вычислительная сложность, так как для того, чтобы
обучить агента, требуется большое количество взаимодействий с окружающей средой.
Кроме того, обучение с подкреплением может требовать значительных временных затрат
на достижение хороших результатов, особенно в сложных, многосоставных задачах.
Тем не менее, обучение с подкреплением является мощным инструментом для
решения задач, которые требуют принятия решений в реальном времени и в условиях
неопределенности, предоставляя агентам возможность самостоятельно изучать
оптимальные стратегии и улучшать их по мере накопления опыта.

fl

Машинное обучение применяется в самых разных областях: от медицины, где
помогает в диагностике заболеваний, до финансов, где используется для предсказания
цен на акции. Эта технология лежит в основе таких популярных приложений, как
рекомендации фильмов в Net ix, прогнозы погоды и системы распознавания лиц.
Роль Python в машинном обучении
Python завоевал признание в мире машинного обучения благодаря своей простоте,
читаемости кода и мощным библиотекам, которые предоставляют готовые инструменты
для разработки и внедрения моделей. Это один из немногих языков, который позволяет
легко сочетать удобство быстрого прототипирования с возможностями для построения
сложных вычислительных моделей. В отличие от многих других языков, Python имеет
простой и понятный синтаксис, что облегчает работу как новичкам, так и опытным
специалистам, позволяя сосредоточиться на решении задач, а не на технических деталях
реализации.
Одним из главных преимуществ Python является то, что он предлагает гибкость в
разработке моделей машинного обучения. Его способность быстро адаптироваться к
различным подходам в обработке данных и создании алгоритмов делает его незаменимым
инструментом. В отличие от языков с более жесткой структурой, Python позволяет
разработчикам и исследователям быстро проверять гипотезы, тестировать идеи и
проводить эксперименты, что особенно важно в быстро меняющемся мире технологий.
Кроме того, Python активно используется не только в академических
исследованиях, но и в промышленности, где его применяют для решения реальных задач с
большими данными и сложными моделями. Язык предоставляет огромное количество
библиотек, которые значительно ускоряют процесс разработки, позволяют строить
эффективные модели и легко обрабатывать данные. Эти инструменты позволяют
сосредоточиться на самой задаче, а не на технических аспектах реализации алгоритмов.
Python, благодаря своей простоте и универсальности, ускоряет процесс создания и
внедрения решений в области машинного обучения, тем самым способствуя прогрессу в
таких областях, как здравоохранение, финансы, маркетинг, транспорт и многие другие.

Важной особенностью Python является его способность интегрироваться с другими
языками и технологиями, что делает его универсальным для решения разнообразных
задач. Он позволяет эффективно использовать вычислительные ресурсы и интегрировать
с такими языками, как C или C++, а также работать с различными платформами и базами
данных, что особенно важно при работе с большими объемами данных. Это делает Python
не только мощным инструментом для анализа данных, но и отличным выбором для
разработки сложных вычислительных моделей, таких как нейронные сети и алгоритмы
глубокого обучения.
Python стал не только инструментом для научных исследований и быстрого
прототипирования, но и основным языком для создания и внедрения решений в области
искусственного интеллекта и машинного обучения. Благодаря своей простоте, гибкости и
широкому набору библиотек Python продолжает оставаться лидером в области анализа
данных и разработки интеллектуальных систем.
Обзор используемых библиотек
В мире машинного обучения существует множество библиотек для Python, каждая
из которых предлагает свои инструменты для решения различных задач. Рассмотрим
самые популярные и часто используемые из них:
1. NumPy: Это основная библиотека для работы с массивами и матрицами в Python. Она
предоставляет эффективные способы выполнения математических и статистических
операций, что важно при обработке больших объемов данных.
2. Pandas: Pandas является мощным инструментом для обработки и анализа данных. Он
предлагает структуры данных, такие как DataFrame, которые позволяют легко
манипулировать и очищать данные, проводить статистический анализ и подготавливать
данные для машинного обучения.
3. Matplotlib и Seaborn: Эти библиотеки предназначены для визуализации данных. Matplotlib
предоставляет основные средства для создания графиков, а Seaborn дополнительно
расширяет возможности визуализации, включая сложные графики и диаграммы, которые
помогают лучше понять структуру данных.
4. Scikit-learn: Одна из самых популярных библиотек для машинного обучения. Она
предоставляет набор алгоритмов для классификации, регрессии, кластеризации и других
задач, а также инструменты для предобработки данных, оценки моделей и настройки
гиперпараметров. Scikit-learn является важным инструментом для создания базовых
моделей машинного обучения.
5. TensorFlow и Keras: Эти библиотеки используются для создания и обучения нейронных
сетей и моделей глубокого обучения. TensorFlow, разработанный компанией Google,
предоставляет гибкие и мощные инструменты для работы с нейронными сетями, а Keras,
высокоуровневая библиотека, упрощает процесс создания и обучения моделей.
6. PyTorch: Это еще одна популярная библиотека для глубокого обучения, разработанная
компанией Facebook. PyTorch предоставляет динамическое вычислительное графическое
представление, что позволяет более гибко работать с нейронными сетями, а также легко
отлаживать и изменять модели.
7. XGBoost и LightGBM: Эти библиотеки используются для градиентного бустинга и
эффективного обучения ансамблей деревьев решений. XGBoost и LightGBM показывают
отличные результаты в задачах классификации и регрессии и широко применяются в
соревнованиях по анализу данных и реальных проектах.
8. NLTK и SpaCy: Для обработки естественного языка (NLP) существуют
специализированные библиотеки, такие как NLTK и SpaCy. Эти библиотеки предоставляют
инструменты для токенизации текста, извлечения сущностей, построения моделей для
классификации и анализа настроений.

9. OpenCV: Эта библиотека используется для обработки и анализа изображений. Она
предоставляет инструменты для работы с изображениями, видео и компьютерным
зрением, включая детекцию объектов и распознавание лиц.
10. Gensim: Gensim — это библиотека, специализирующаяся на тематическом
моделировании и обработке текстов. Она позволяет работать с векторными
представлениями слов (word2vec, fastText) и другими алгоритмами для анализа больших
текстовых коллекций.
Эти библиотеки создают экосистему для работы с машинным обучением,
обеспечивая как высокоуровневые инструменты для разработки, так и низкоуровневые
средства для работы с математическими и статистическими вычислениями.
Глава 1: Основы Python для машинного обучения
- Введение в Python: синтаксис и особенности
- Установка необходимых инструментов (Anaconda, Jupyter Notebook)
- Основные библиотеки: NumPy, Pandas, Matplotlib
Введение в Python: синтаксис и особенности
Python — это один из самых популярных языков программирования для машинного
обучения. Его популярность объясняется лаконичным синтаксисом, богатой экосистемой
библиотек и активным сообществом.
Ключевые особенности Python
1. Простота и читаемость — код на Python легко читать, понимать и писать.
2. Динамическая типизация — переменные не требуют явного указания типа.
3. Интерактивность — возможность быстрого тестирования кода в интерактивном режиме.
4. Кроссплатформенность — Python работает на Windows, macOS и Linux.
5. Широкая стандартная библиотека — множество встроенных модулей для работы с
файлами, сетью, базами данных и многим другим.
1. Простота и читаемость
Python отличается лаконичным и понятным синтаксисом, напоминающим
английский язык. Его простота позволяет писать код быстрее и легче поддерживать его в
будущем.
Пример: На Python можно написать программу, которая считает сумму чисел от 1 до
10, всего в несколько строк:
```python
print(sum(range(1, 11))) # Вывод: 55
```
В то время как на языке C или Java для этого потребуется больше строк кода.
Кроме того, Python использует отступы вместо фигурных скобок (`{}`) для
разделения блоков кода. Это делает его более читаемым:
```python
if x > 0:
print("Число положительное")
else:
print("Число отрицательное или ноль")
```
В других языках тот же код часто требует дополнительных символов (`{}`, `end`,
`then`), что снижает читаемость.

Преимущества:
- Минимальное количество лишних символов.
- Код читается почти как текст на английском.
- Легче изучить новичкам.
2. Динамическая типизация
В отличие от языков с статической типизацией (C, Java), Python не требует явного
указания типов переменных.

fl

Пример:
```python
x = 10
# x — это int
y = 3.14 # y — это oat
s = "Hello" # s — это str
```
Python автоматически определяет тип данных, что делает код более гибким.
Кроме того, переменная может менять тип во время выполнения:
```python
x = 10
x = "Теперь это строка" # Ошибки не будет!
```
В языках вроде C++ или Java такая операция вызовет ошибку, потому что
переменная уже объявлена с определенным типом.
Преимущества:
- Меньше кода — не нужно объявлять типы.
- Гибкость — переменные могут изменять тип в процессе работы программы.
- Упрощенная работа с разными структурами данных.
Недостатки:
- Возможны ошибки, связанные с изменением типа.
- Снижается скорость работы по сравнению со статически типизированными языками.
3. Интерактивность
Python можно запускать в интерактивном режиме, что позволяет быстро
тестировать код без необходимости писать и компилировать весь файл.
Можно запустить Python-терминал (REPL) и выполнять команды в реальном
времени:
```python
>>> 2 + 2
4
>>> name = "Alice"
>>> name.upper()
'ALICE'
```
Это особенно удобно для:
- Тестирования небольших фрагментов кода.
- Изучения нового материала.
- Работы с данными (например, в Jupyter Notebook).
Jupyter Notebook
Интерактивность Python особенно полезна при работе с данными в Jupyter
Notebook. Можно запускать код ячейками, сразу видеть результат и строить графики.

Преимущества:
- Быстрое тестирование идей.
- Удобно для анализа данных и машинного обучения.
- Возможность поэтапного выполнения кода.
4. Кроссплатформенность
Python работает на Windows, macOS и Linux без необходимости внесения изменений
в код. Достаточно установить интерпретатор Python, и программа будет работать на любой
системе.
Пример:
Программа на Python, написанная на Windows, без изменений запустится на macOS
и Linux. В отличие от C++ или Java, где часто нужно адаптировать код под операционную
систему.
Также Python популярен в веб-разработке, так как серверный код на Python можно
легко развернуть на разных хостингах.
Преимущества:
- Нет необходимости писать разный код для каждой ОС.
- Легко переносить программы между платформами.
- Поддержка мобильных устройств через фреймворки (Kivy, BeeWare).
5. Широкая стандартная библиотека
Python поставляется с огромным количеством встроенных модулей, что избавляет
от необходимости писать собственные решения для стандартных задач.
Некоторые полезные модули:

Пример: работа с JSON
```python
import json
data = {"name": "Alice", "age": 25}
json_str = json.dumps(data) # Преобразуем в JSON-строку

print(json_str) # Вывод: {"name": "Alice", "age": 25}
```
Преимущества:
- Экономия времени — многие функции уже реализованы.
- Простая работа с файлами, сетью, БД и математикой.
- Возможность расширения через дополнительные библиотеки.
Эти особенности делают Python одним из лучших языков для машинного обучения,
анализа данных и разработки программных решений.
Основной синтаксис Python
Вывод данных
```python
print("Hello, World!")
```
Переменные и типы данных
```python
x = 10
# Целое число
y = 3.14 # Число с плавающей запятой
s = "Python" # Строка
b = True # Булев тип
```
Условные конструкции
```python
if x > 5:
print("x больше 5")
else:
print("x меньше или равно 5")
```
Циклы
```python
for i in range(5):
print(i)
```
```python
n=0
while n < 5:
print(n)
n += 1
```
Функции
```python
def greet(name):
return f"Привет, {name}!"
print(greet("Алиса"))
```
Установка необходимых инструментов
Для работы с машинным обучением на Python обычно используются следующие
инструменты:

- Anaconda — платформа для анализа данных, включающая Python, Jupyter Notebook и
основные библиотеки.
- Jupyter Notebook — интерактивная среда для выполнения кода Python с возможностью
визуализации данных.
Установка Anaconda
1. Скачайте Anaconda с [официального сайта](https://www.anaconda.com/).
2. Установите, следуя инструкциям.
3. Проверьте установку, запустив в командной строке:
```bash
conda --version
```
Запуск Jupyter Notebook
После установки Anaconda откройте терминал (или Anaconda Prompt) и введите:
```bash
jupyter notebook
```
Откроется браузер с интерфейсом Jupyter Notebook, где можно создавать и
запускать код в ячейках.
Основные библиотеки Python для машинного обучения
Python богат библиотеками для работы с данными, математическими вычислениями
и визуализацией. Рассмотрим три ключевых библиотеки.
NumPy: работа с массивами
NumPy — библиотека для работы с многомерными массивами, предоставляющая
множество инструментов для вычислений. Основным объектом в NumPy является массив
`ndarray`, который позволяет эффективно хранить и обрабатывать большие объемы
данных.
Создание массива можно выполнить с помощью функции `np.array()`, передав список
или кортеж. Например:
```python
import numpy as np
a = np.array([1, 2, 3, 4])
print(a) # [1 2 3 4]
```
Массивы в NumPy поддерживают векторизированные операции, что делает
вычисления значительно быстрее по сравнению с циклами Python:
```python
print(a * 2) # [2 4 6 8]
print(a + 10) # [11 12 13 14]
```
Для создания массивов с определённой структурой существуют специальные
функции. Например, `np.zeros()` создаёт массив из нулей:
```python
b = np.zeros((3, 3)) # 3×3 матрица из нулей
print(b)
```
Аналогично, `np.ones()` создаёт массив из единиц:

```python
c = np.ones((2, 4)) # 2×4 матрица из единиц
print(c)
```
Для создания массива с равномерно распределёнными значениями можно
использовать `np.arange()` или `np.linspace()`:
```python
d = np.arange(0, 10, 2) # значения от 0 до 10 с шагом 2
print(d) # [0 2 4 6 8]
e = np.linspace(0, 1, 5) # 5 точек от 0 до 1 включительно
print(e) # [0. 0.25 0.5 0.75 1. ]
```
Массивы можно изменять по форме (reshape) и комбинировать:
```python
f = np.arange(12).reshape(3, 4)
print(f)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
g = np.vstack([a, a]) # Вертикальное объединение
h = np.hstack([a, a]) # Горизонтальное объединение
```
Индексация и срезы работают так же, как в списках Python, но с дополнительными
возможностями:
```python
print(f[1, 2]) # Элемент второй строки, третьего столбца
print(f[:, 1]) # Все элементы второго столбца
print(f[1, :]) # Все элементы второй строки
```
NumPy также предоставляет множество математических операций и статистических
методов:
```python
print(np.mean(f)) # Среднее значение
print(np.sum(f)) # Сумма всех элементов
print(np.max(f)) # Максимальный элемент
print(np.min(f)) # Минимальный элемент
```
Работа с многомерными массивами и векторными операциями делает NumPy
незаменимым инструментом для научных вычислений, машинного обучения и анализа
данных.
Pandas: обработка данных
Pandas — это библиотека для работы с табличными данными, предоставляющая
удобные структуры данных и методы для их обработки и анализа. Основными структурами
являются `DataFrame` (двумерные таблицы) и `Series` (одномерные столбцы данных).
Чтобы начать работу с Pandas, нужно импортировать библиотеку. Создать таблицу
можно из словаря, где ключи — это названия столбцов, а значения — списки данных.
Например:
```python
import pandas as pd

data = {"Имя": ["Алиса", "Боб"], "Возраст": [25, 30]}
df = pd.DataFrame(data)
print(df)
```
Этот код создаст таблицу:
```

Имя Возраст
0 Алиса
25
1 Боб
30
```
Можно добавить новый столбец прямо после создания таблицы:
```python
df["Город"] = ["Москва", "Санкт-Петербург"]
print(df)
```
Теперь таблица выглядит так:
```
Имя Возраст
Город
0 Алиса
25
Москва
1 Боб
30 Санкт-Петербург
```
Для чтения данных из файлов используется метод `read_csv()`:
```python
df = pd.read_csv("data.csv")
```
А для сохранения изменений — `to_csv()`:
```python
df.to_csv("output.csv", index=False)
```
Можно фильтровать данные по условию:
```python
молодые = df[df["Возраст"] < 30]
print(молодые)
```
Для изменения данных в столбце используется метод `apply()`:
```python
df["Возраст_через_год"] = df["Возраст"].apply(lambda x: x + 1)
```
Сводная статистика отображается с помощью метода `describe()`:
```python
print(df.describe())
```
Группировку данных по какому-либо столбцу выполняет метод `groupby()`:
```python
средний_возраст = df.groupby("Город")["Возраст"].mean()
print(средний_возраст)
```
Можно сортировать таблицу по одному или нескольким столбцам:
```python
отсортированный = df.sort_values(by="Возраст", ascending=False)
print(отсортированный)
```
Если нужно изменить структуру таблицы или убрать дублирующиеся строки, используются
методы `pivot()` и `drop_duplicates()` соответственно:
```python
df = df.drop_duplicates()
```

fi

fi

Для работы с отсутствующими данными (`NaN`) можно использовать ` llna()` или `dropna()`:
```python
df = df. llna("Нет данных")
df = df.dropna()
```
Pandas — это незаменимый инструмент для анализа и обработки данных,
позволяющий эффективно работать с большими наборами информации.
Matplotlib: визуализация данных
Matplotlib — это библиотека для визуализации данных на языке Python. Она
позволяет создавать графики, диаграммы, гистограммы, круговые диаграммы и многое
другое. Для работы с ней обычно используется модуль `pyplot`, который предоставляет
удобный интерфейс для построения графиков.
Для начала необходимо импортировать библиотеку:
```python
import matplotlib.pyplot as plt
```
Основным методом для создания графиков является `plt.plot()`. Он отображает точки
и соединяет их линией. Например:
```python
x = [1, 2, 3, 4]
y = [10, 20, 25, 30]
plt.plot(x, y)
plt.xlabel("Ось X")
plt.ylabel("Ось Y")
plt.title("Простая линейная диаграмма")
plt.show()
```
Этот код построит простую линейную диаграмму с подписями осей и заголовком.
Для улучшения визуализации можно добавить цвет, маркеры точек и изменить
стиль линии:
```python
plt.plot(x, y, color='green', marker='o', linestyle='--', linewidth=2)
plt.xlabel("Ось X")
plt.ylabel("Ось Y")
plt.title("Диаграмма с маркерами")
plt.grid(True)
plt.show()
```
Если нужно отобразить сразу несколько графиков на одном поле, можно передать
несколько серий данных:
```python
plt.plot(x, y, label="Первая серия", color='blue')
plt.plot(x, [15, 18, 22, 28], label="Вторая серия", color='red')
plt.xlabel("Ось X")
plt.ylabel("Ось Y")
plt.title("Несколько серий данных")
plt.legend()
plt.grid(True)
plt.show()
```
Для отображения столбчатых диаграмм используется метод `plt.bar()`:
```python
названия = ["Январь", "Февраль", "Март"]
значения = [150, 200, 180]

plt.bar(названия, значения, color='purple')
plt.xlabel("Месяц")
plt.ylabel("Продажи")
plt.title("Столбчатая диаграмма")
plt.show()
```
Если нужно создать круговую диаграмму, применяется метод `plt.pie()`:
```python
категории = ["А", "B", "C"]
доли = [40, 35, 25]
ff

ff

ff

plt.pie(доли, labels=категории, autopct='%1.1f%%', colors=["# 9999","#66b3 ","#99 99"])
plt.title("Круговая диаграмма")
plt.show()
```
Гистограммы создаются с помощью метода `plt.hist()` и полезны для отображения
распределения данных:
```python
import numpy as np
данные = np.random.randn(1000)
plt.hist(данные, bins=30, color='skyblue', edgecolor='black')
plt.xlabel("Значение")
plt.ylabel("Частота")
plt.title("Гистограмма распределения")
plt.show()
```
Для отображения нескольких графиков в одной области используется `plt.subplot()`:
```python
plt.subplot(1, 2, 1) # Первая панель (1 строка, 2 столбца, 1-й график)
plt.plot(x, y, color='orange')
plt.title("Линейный график")
plt.subplot(1, 2, 2) # Вторая панель (1 строка, 2 столбца, 2-й график)
plt.bar(названия, значения, color='green')
plt.title("Столбчатая диаграмма")

fi

plt.tight_layout()
plt.show()
```
Matplotlib также позволяет сохранять созданные графики в виде изображений:
```python
plt.plot(x, y, label="Пример")
plt.legend()
plt.save g("график.png", dpi=300)
```
Таким образом, Matplotlib предоставляет гибкие инструменты для создания
визуализаций, что делает её одной из самых популярных библиотек для работы с
графиками в Python.
Глава 2: Подготовка данных
- Импорт и очистка данных с помощью Pandas
- Обработка пропусков и аномальных данных
- Нормализация и стандартизация данных
- Разделение данных на обучающие и тестовые выборки
Перед тем как приступить к анализу и построению моделей, необходимо
подготовить данные. Это включает в себя импорт информации, очистку от пропущенных и

аномальных значений, а также приведение данных к единому масштабу. В конце этапа
данные делятся на обучающую и тестовую выборки. Рассмотрим все эти шаги подробно.
Импорт и очистка данных с помощью Pandas
Первым этапом в работе с данными является их импорт. Чаще всего данные
поступают из различных источников: CSV-файлов, Excel-таблиц, баз данных или веб-API.
Pandas предоставляет удобные методы для загрузки данных и их первичного анализа.
Начнём с импорта библиотеки и загрузки данных:
```python
import pandas as pd
```
Импорт CSV-файла
CSV (Comma-Separated Values) — один из самых распространённых форматов для
хранения данных. Для загрузки используется метод `pd.read_csv()`:
```python
df = pd.read_csv("data.csv")
```
Импорт Excel-файла
Если данные хранятся в формате Excel (`.xlsx`), используется метод `pd.read_excel()`:
```python
df = pd.read_excel("data.xlsx", sheet_name="Лист1")
```
Импорт данных из базы данных
Если данные находятся в базе данных, можно использовать SQL-запросы. Для этого
нужен коннектор, например, `sqlite3`:
```python
import sqlite3
conn = sqlite3.connect('database.db')
df = pd.read_sql_query("SELECT * FROM customers", conn)
```
Первичный анализ загруженных данных
После загрузки данных важно убедиться, что они загружены корректно и имеют
ожидаемую структуру.
Просмотр первых строк таблицы:
Метод `head()` показывает первые несколько строк, по умолчанию — 5:
```python
print(df.head())
```
Просмотр последних строк таблицы:
Метод `tail()` отображает последние строки:
```python
print(df.tail())
```
Общая информация о данных:
Метод `info()` отображает количество строк и столбцов, названия столбцов, типы
данных и количество непустых значений:
```python
print(df.info())

```

fl

fl

fl

Пример вывода:
```
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1500 entries, 0 to 1499
Data columns (total 6 columns):
# Column
Non-Null Count Dtype
--- ------------------- ----0 ID
1500 non-null int64
1 Имя
1498 non-null object
2 Возраст 1475 non-null oat64
3 Город
1500 non-null object
4 Доход
1450 non-null oat64
5 Дата_рег 1500 non-null object
dtypes: oat64(2), int64(1), object(3)
memory usage: 70.4 KB
```
Из вывода видно:
- В столбце `Имя` пропущены 2 значения.
- В столбцах `Возраст` и `Доход` пропущены значения.
- Столбец `Дата_рег` имеет тип `object`, хотя должен быть тип `datetime`.
Статистика по числовым данным:
Метод `describe()` вычисляет ключевые статистические показатели для числовых
столбцов:
```python
print(df.describe())
```
Пример вывода:
```
Возраст
Доход
count 1475.000000 1450.000000
mean 35.200000 54000.000000
std
7.850000 15000.000000
min
18.000000 1200.000000
25%
28.000000 45000.000000
50%
35.000000 54000.000000
75%
42.000000 62000.000000
max 120.000000 95000.000000
```
Из статистики видно, что возраст `max=120` выглядит как явная аномалия. Это будет
исправлено на этапе очистки данных.
Очистка данных
Очистка данных включает удаление дубликатов, исправление типов данных,
удаление ненужных столбцов и устранение пропущенных значений.
1. Удаление дубликатов
Дубликаты возникают при ошибках импорта или объединении данных из нескольких
источников. Их можно найти и удалить с помощью метода `drop_duplicates()`:
```python
# Проверяем количество дубликатов
print(f"Количество дубликатов: {df.duplicated().sum()}")
# Удаляем дубликаты
df = df.drop_duplicates()

```
2. Исправление форматов данных
Часто некоторые столбцы имеют неверный формат. Например, даты загружены как
строки (`object`), их нужно преобразовать в формат `datetime`:
```python
df["Дата_рег"] = pd.to_datetime(df["Дата_рег"], errors='coerce')
```
Если необходимо привести числовые столбцы к целочисленному типу (`int`), нужно
предварительно заполнить пропуски:

fi

```python
df["Возраст"] = df["Возраст"]. llna(df["Возраст"].median()).astype(int)
```
3. Удаление ненужных столбцов
Иногда встречаются столбцы, которые не несут ценной информации, например, `ID`
или автоматически созданные столбцы типа `Unnamed: 0`:
```python
df = df.drop(columns=["ID", "Unnamed: 0"], errors='ignore')
```
4. Обработка пропущенных значений
Пропуски в данных (`NaN`) могут привести к ошибкам при обучении моделей. Их
можно выявить с помощью метода `isnull()` или `isna()` и обработать в зависимости от
ситуации.
Проверка пропусков:
```python
print(df.isna().sum())
```
Удаление строк с пропусками:
Если пропусков мало, можно удалить такие строки:
```python
df = df.dropna()
```
Заполнение пропусков медианой или средним:
Если пропусков много, их можно заполнить:

fi

fi

```python
df["Доход"] = df["Доход"]. llna(df["Доход"].median())
df["Имя"] = df["Имя"]. llna("Неизвестно")
```
5. Поиск и устранение аномальных значений
Аномалии — это значения, которые не соответствуют ожидаемому диапазону.
Например, возраст более 100 лет или отрицательный доход.
Метод межквартильного размаха (IQR):
```python
Q1 = df["Возраст"].quantile(0.25)
Q3 = df["Возраст"].quantile(0.75)
IQR = Q3 - Q1
# Удаляем выбросы

df = df[(df["Возраст"] >= Q1 - 1.5 * IQR) & (df["Возраст"] <= Q3 + 1.5 * IQR)]
```
6. Проверка данных после очистки:
После всех этапов очистки рекомендуется ещё раз просмотреть общие сведения о
данных:
```python
print(df.info())
print(df.describe())
```
Итог:
- Данные успешно загружены из CSV-файла с помощью Pandas.
- Проведён первичный анализ структуры данных и выявлены проблемы: дубликаты,
неверные типы, пропуски, аномалии.
- Дубликаты удалены, типы приведены к нужному формату.
- Пропуски заполнены или удалены, аномалии устранены.
- Ненужные столбцы удалены.
Эти шаги сделали данные чистыми и готовыми для дальнейшего анализа и обучения
моделей. ```
Обработка пропусков и аномальных данных
Пропущенные значения (`NaN`) могут существенно повлиять на анализ. Pandas
позволяет легко их находить и обрабатывать:
```python
# Проверяем, сколько пропущенных значений в каждом столбце
print(df.isnull().sum())
```
В зависимости от ситуации можно удалить строки с пропусками:
```python
df = df.dropna()
```
Либо заменить их средним или медианным значением:

fi

```python
df["Возраст"] = df["Возраст"]. llna(df["Возраст"].median())
```
Также необходимо выявить аномальные значения. Один из способов —
использование статистики `describe()`:
```python
print(df.describe())
```
Если, например, в столбце "Возраст" встречаются значения 200 лет, это очевидная
ошибка. Такие аномалии можно обработать с помощью межквартильного размаха (IQR):
```python
Q1 = df["Возраст"].quantile(0.25)
Q3 = df["Возраст"].quantile(0.75)
IQR = Q3 - Q1
# Фильтруем данные, оставляя только значения в пределах 1.5*IQR
df = df[(df["Возраст"] >= Q1 - 1.5 * IQR) & (df["Возраст"] <= Q3 + 1.5 * IQR)]
```
Нормализация и стандартизация данных

Некоторые алгоритмы машинного обучения чувствительны к масштабу данных,
поэтому важно привести их к единому виду. Существует два основных метода:
нормализация и стандартизация.
Нормализация приводит значения к диапазону от 0 до 1:
```python
from sklearn.preprocessing import MinMaxScaler

fi

scaler = MinMaxScaler()
df[["Возраст", "Доход"]] = scaler. t_transform(df[["Возраст", "Доход"]])
```
Стандартизация делает так, чтобы данные имели среднее значение 0 и стандартное
отклонение 1:
```python
from sklearn.preprocessing import StandardScaler

fi

scaler = StandardScaler()
df[["Возраст", "Доход"]] = scaler. t_transform(df[["Возраст", "Доход"]])
```
Какой метод выбрать?
- Нормализация используется, когда данные имеют разные единицы измерения или
находятся в фиксированном диапазоне.
- Стандартизация подходит для данных с нормальным распределением, где важна
интерпретация отклонений от среднего.
Разделение данных на обучающие и тестовые выборки
Перед обучением моделей машинного обучения необходимо разделить данные на
две части:
- Обучающая выборка (training set) — используется для тренировки модели. Обычно
составляет 70–80% всех данных.
- Тестовая выборка (test set) — используется для проверки качества обученной модели на
новых данных. Обычно составляет 20–30%.

fi

Это разделение помогает объективно оценить производительность модели и
избежать переобучения (over tting).
1. Определение признаков (X) и целевой переменной (y)
Для начала необходимо разделить исходные данные на:
- Признаки (features, X): столбцы, которые содержат информацию для предсказания.
- Целевая переменная (target, y): столбец, который нужно предсказать.
Например, если мы предсказываем уровень дохода клиента (`Доход`), то он будет
целевой переменной, а все остальные столбцы — признаками.
```python
# Определяем признаки (X) и целевую переменную (y)
X = df.drop(columns=["Доход"])
y = df["Доход"]
```
Если целевая переменная называется, например, `Целевая_переменная`, можно
указать её напрямую:
```python
X = df.drop(columns=["Целевая_переменная"])
y = df["Целевая_переменная"]

```
2. Использование train_test_split из scikit-learn
Для разделения данных используют функцию `train_test_split` из модуля
`sklearn.model_selection`. Она автоматически делит данные на две части — обучающую и
тестовую.
```python
from sklearn.model_selection import train_test_split
# Разделяем данные в пропорции 80% / 20%
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2, # 20% на тест, 80% на обучение
random_state=42 # Фиксируем случайность для воспроизводимости
)
```
Пояснения к параметрам:

ffl

- `test_size=0.2`: 20% данных уйдут в тестовую выборку, 80% — в обучающую. Можно
использовать `train_size` вместо `test_size`, если хотите указать долю для обучения.
- `random_state=42`: задаёт фиксированное значение для генератора случайных чисел,
чтобы результаты можно было воспроизвести при каждом запуске.
- `shu e=True`: (по умолчанию) перемешивает данные перед разделением.
- `stratify=y`: для сбалансированного разделения по классам (важно для задач
классификации).
3. Проверка размеров полученных выборок
После разделения рекомендуется убедиться, что размеры обучающей и тестовой
выборок соответствуют ожиданиям:

fi

```python
print("Размер обучающей выборки (X_train):", X_train.shape)
print("Размер тестовой выборки (X_test):", X_test.shape)
print("Размер обучающих меток (y_train):", y_train.shape)
print("Размер тестовых меток (y_test):", y_test.shape)
```
Пример вывода:
```
Размер обучающей выборки (X_train): (800, 5)
Размер тестовой выборки (X_test): (200, 5)
Размер обучающих меток (y_train): (800,)
Размер тестовых меток (y_test): (200,)
```
4. Использование стратифицированного разбиения (Strati ed Split)
Если целевая переменная дискретная (например, классы: 0 или 1), важно сохранять
баланс классов в обеих выборках. Для этого применяют параметр `stratify`.
Пример для задачи классификации (например, предсказание наличия болезни):
```python
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2,
random_state=42,
stratify=y # Сохраняем баланс классов
)
```

5. Пример сравнения распределения целевой переменной:
Чтобы убедиться, что классы равномерно распределились между выборками,
можно сравнить их доли:
```python
print("Распределение классов в обучающей выборке:")
print(y_train.value_counts(normalize=True))
print("\nРаспределение классов в тестовой выборке:")
print(y_test.value_counts(normalize=True))
```
6. Разделение на обучающую, валидационную и тестовую выборки
Иногда, особенно для более сложных моделей, создают три выборки:
- Обучающая (train): для обучения модели.
- Валидационная (validation): для подбора гиперпараметров.
- Тестовая (test): для окончательной проверки качества модели.
Это можно сделать за два шага:
```python
# Сначала делим на обучающую и временную выборку (train + temp)
X_train, X_temp, y_train, y_temp = train_test_split(
X, y,
test_size=0.3,
random_state=42
)
# Делим временную выборку на валидационную и тестовую
X_val, X_test, y_val, y_test = train_test_split(
X_temp, y_temp,
test_size=0.5,
random_state=42
)
print("Размер обучающей выборки:", X_train.shape)
print("Размер валидационной выборки:", X_val.shape)
print("Размер тестовой выборки:", X_test.shape)
```
Если используется кросс-валидация (cross-validation), валидационную выборку
можно не выделять отдельно.
Итог:
- Разделение данных на обучающую и тестовую выборки — важный шаг для проверки
качества моделей.
- Использование `train_test_split()` из scikit-learn — стандартный и удобный способ.
- Для классификаций следует использовать стратифицированное разделение.
- В более сложных задачах стоит добавлять валидационную выборку или применять кроссвалидацию.
После разделения можно приступить к обучению моделей машинного обучения.
Подготовленные данные становятся основой для дальнейшего анализа и машинного
обучения, поэтому правильная обработка данных играет ключевую роль в качестве
моделей.
Глава 3: Введение в машинное обучение

- Что такое обучение с учителем и без учителя?
- Основные типы задач: классификация, регрессия, кластеризация
- Обзор алгоритмов машинного обучения: линейная регрессия, решающие деревья, KNN,
SVM
Машинное обучение — это область искусственного интеллекта, которая позволяет
компьютерам обучаться на данных и принимать решения без явного программирования.
Вместо того чтобы писать жёсткие правила, мы предоставляем машине примеры и
позволяем ей находить закономерности самостоятельно.
Что такое обучение с учителем и без учителя?
Обучение с учителем и обучение без учителя — это два ключевых подхода в
машинном обучении, определяющие, как модель изучает данные и находит
закономерности. Они различаются по наличию или отсутствию заранее известных ответов
(меток) в данных.
Обучение с учителем (Supervised Learning)
Обучение с учителем — это метод, при котором модель тренируется на данных с
известными правильными ответами. Такие данные называются размеченными, потому что
для каждого примера известна целевая переменная (метка). Задача модели — научиться
связывать входные признаки с правильными ответами, чтобы затем делать точные
предсказания на новых данных.
Приведём пример. Представим, что мы создаём модель для предсказания
стоимости дома. У нас есть таблица с данными: площадь дома, количество комнат, район и
цена. Каждая строка — это пример, где указаны входные признаки (площадь, комнаты,
район) и целевой ответ (цена).
Код на Python с использованием `scikit-learn`:
```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
# Пример данных о домах
data = {
"Площадь": [50, 60, 80, 100, 120],
"Комнаты": [2, 2, 3, 3, 4],
"Цена": [3.5, 4.2, 5.8, 7.1, 8.3]
}
df = pd.DataFrame(data)
# Определяем признаки и целевую переменную
X = df[["Площадь", "Комнаты"]]
y = df["Цена"]
# Делим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Обучаем модель линейной регрессии
model = LinearRegression()
model. t(X_train, y_train)
# Предсказываем цену нового дома
новый_дом = [[75, 3]]
предсказанная_цена = model.predict(новый_дом)

print(f"Предсказанная цена для дома с площадью 75 м² и 3 комнатами:
{предсказанная_цена[0]:.2f} млн руб.")
```
В этом примере модель изучает связь между площадью, количеством комнат и
ценой дома. Когда мы передаём новые данные, она выдаёт предсказание. Это и есть
обучение с учителем: модель обучилась на размеченных данных, где известны как входные
признаки, так и правильные ответы.
Обучение без учителя (Unsupervised Learning)
Обучение без учителя отличается тем, что в данных отсутствуют правильные
ответы. Здесь модель работает с неразмеченными данными и самостоятельно ищет в них
скрытые закономерности. Один из наиболее распространённых методов — кластеризация,
которая группирует похожие объекты вместе.
Приведём пример. Допустим, у нас есть данные о покупателях интернет-магазина:
возраст, сумма покупок, частота заказов. Мы не знаем заранее, какие группы существуют,
но хотим выявить сегменты покупателей для персонализированных предложений.
Код на Python с использованием `scikit-learn`:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
# Пример данных о покупателях
data = {
"Возраст": [22, 25, 47, 52, 46, 56, 28, 35],
"Покупки": [100, 150, 300, 350, 280, 400, 130, 200]
}
df = pd.DataFrame(data)

fi

# Применяем алгоритм кластеризации k-средних
kmeans = KMeans(n_clusters=3, random_state=42)
df["Кластер"] = kmeans. t_predict(df[["Возраст", "Покупки"]])
# Визуализация кластеров
plt.scatter(df["Возраст"], df["Покупки"], c=df["Кластер"], cmap="viridis")
plt.xlabel("Возраст")
plt.ylabel("Сумма покупок")
plt.title("Сегментация покупателей")
plt.show()
```

В этом примере модель сама определяет, какие группы существуют в данных. Она
разделяет покупателей на три кластера по возрасту и сумме покупок. Теперь мы можем
применять разные маркетинговые стратегии для каждой группы. Здесь нет правильных
ответов — модель нашла закономерности самостоятельно, что и является сутью обучения
без учителя.
Основное отличие:
- В обучении с учителем модель работает на размеченных данных и учится предсказывать
правильные ответы.
- В обучении без учителя модель исследует неразмеченные данные и находит скрытые
паттерны.
Таким образом, выбор между обучением с учителем и без учителя зависит от задачи
и доступных данных. Оба подхода — фундамент машинного обучения, который открывает
возможности для анализа данных, создания моделей предсказаний и разработки
интеллектуальных систем.
Основные типы задач машинного обучения
Машинное обучение применяется для решения различных задач. Каждая задача
требует своего подхода и алгоритмов. Рассмотрим три ключевых типа:
fi

Классификация (Classi cation)
Классификация — это один из ключевых типов задач машинного обучения, в
котором модель обучается предсказывать категорию или класс для каждого примера. В
отличие от регрессии, где результат является непрерывным числом, в классификации
результат всегда дискретный — это одна из заранее определённых категорий.
Суть классификации
Классификация работает по принципу: на основе известных признаков модель
определяет, к какому классу относится объект. Эти классы заранее определены, поэтому
задача модели — научиться проводить границу между ними.
Пример из реальной жизни — решение задачи «спам или не спам» для электронной
почты. Программа анализирует текст письма, наличие определённых слов, ссылки и
прочие параметры, а затем относит письмо к категории «Спам» или «Не спам».
Виды классификации
Классификация бывает двух основных видов:

Бинарная классификация — предсказание одного из двух классов.
Примеры:
- Спам или не спам
- Болен пациент или здоров
Многоклассовая классификация — предсказание одного из нескольких классов.
Примеры:
- Определение породы собаки по фото
- Распознавание рукописных цифр (0, 1, 2 … 9)
Как работает классификация
Процесс классификации проходит в три этапа:
1. Обучение: модель изучает закономерности на размеченных данных (где известны и
признаки, и классы).
2. Предсказание: модель применяет полученные знания для новых данных.
3. Оценка качества: проверяется, насколько точно модель классифицирует новые
примеры.
Пример задачи классификации: Определение спама
Рассмотрим пример бинарной классификации: мы будем определять, является ли
электронное письмо спамом или нет. Для этого используем логистическую регрессию —
один из популярных алгоритмов классификации.
Код на Python с использованием `scikit-learn`:
```python
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, ConfusionMatrixDisplay
# Пример данных о письмах
data = {
"Текст": [
"Купите дешевый товар сейчас",
"Ваш заказ подтвержден",
"Поздравляем, вы выиграли приз",
"Ваш отчёт готов",
"Нажмите, чтобы получить бонус"
],
"Спам": [1, 0, 1, 0, 1] # 1 — спам, 0 — не спам
}
df = pd.DataFrame(data)

fi

# Подготовка данных: преобразуем текст в числовые признаки
vectorizer = CountVectorizer()
X = vectorizer. t_transform(df["Текст"])
y = df["Спам"]
# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

fi

# Обучаем модель логистической регрессии
model = LogisticRegression()
model. t(X_train, y_train)
# Предсказываем и оцениваем точность

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy:.2f}")
# Пример предсказания
новое_письмо = ["Срочно получите подарок"]
X_новое = vectorizer.transform(новое_письмо)
результат = model.predict(X_новое)
print("Спам" if результат[0] == 1 else "Не спам")
# -------------------- ВИЗУАЛИЗАЦИЯ --------------------

ffi

# 1⃣ Важность слов (коэффициенты логистической регрессии)
words = vectorizer.get_feature_names_out()
coe cients = model.coef_[0]

ffi

ff

ffi

# Сортировка по важности
sorted_indices = coe cients.argsort()[::-1]
sorted_words = [words[i] for i in sorted_indices]
sorted_coe s = coe cients[sorted_indices]

ff

fi

fi

plt. gure( gsize=(10, 5))
plt.barh(sorted_words, sorted_coe s, color='skyblue')
plt.xlabel('Вес слова в модели')
plt.title('Важность слов для классификации спама')
plt.gca().invert_yaxis()
plt.show()
# 2⃣ Матрица ошибок
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test, cmap='Blues')
plt.title("Матрица ошибок")
plt.show()
```

Разбор примера:

- Мы создали небольшой набор данных с письмами и метками («спам» или «не спам»).
- Использовали `CountVectorizer`, чтобы преобразовать текст в числовые признаки.
- Обучили модель логистической регрессии (`LogisticRegression`).
- Оценили точность модели на тестовых данных.
- Провели предсказание для нового письма.

Алгоритмы классификации
Для задач классификации существует множество алгоритмов. Рассмотрим
некоторые из наиболее популярных:
- Логистическая регрессия (Logistic Regression) — эффективна для бинарной
классификации.
- Метод k-ближайших соседей (K-Nearest Neighbors, KNN) — классифицирует объект по
классу его ближайших соседей.
- Решающие деревья (Decision Trees) — строят дерево решений на основе признаков.
- Случайный лес (Random Forest) — объединяет несколько деревьев решений для более
точных предсказаний.
- Метод опорных векторов (Support Vector Machines, SVM) — находит оптимальную границу
между классами.
- Наивный байесовский классификатор (Naive Bayes) — эффективен для анализа текстов
(например, спама).
Оценка качества классификации
Важно не только обучить модель, но и понять, насколько она эффективна. Для
этого используются метрики:
- Accuracy (Точность) — доля правильно угаданных примеров.
- Precision (Точность класса) — насколько точны предсказания положительного класса.
- Recall (Полнота) — сколько положительных примеров модель нашла.
- F1-score — баланс между точностью и полнотой.
Пример применения в реальной жизни:
- В медицине: Классификация опухолей как доброкачественных или злокачественных.
- В финансах: Определение мошеннических транзакций.
- В безопасности: Распознавание лиц и идентификация нарушителей.
- В маркетинге: Классификация отзывов клиентов как положительных или отрицательных.

Классификация — важнейший инструмент машинного обучения, который
используется во многих сферах жизни. Понимание принципов классификации и умение
применять её на практике помогают решать широкий спектр задач — от фильтрации спама
до диагностики заболеваний.
Регрессия (Regression)
Задача регрессии — это предсказание числового значения на основе входных
данных. В отличие от классификации, где результат представляет собой категорию, в
регрессии результат является непрерывной переменной, например, числом.
Регрессия используется во множестве прикладных задач, где необходимо
предсказать какое-то значение, основываясь на наблюдениях. Модели регрессии изучают
зависимость между входными признаками и целевой переменной, чтобы научиться делать
прогнозы.
Примеры задач регрессии:
1. Предсказать цену автомобиля — например, на основе года выпуска, пробега, марки
автомобиля и других характеристик.
2. Оценка уровня продаж — для прогноза продаж в следующем месяце на основе данных о
прошлых продажах, сезонности и рекламных активностях.
Как работает регрессия
Модели регрессии строят математическую зависимость, которая описывает, как
изменяется целевая переменная с изменением признаков. После этого модель может
делать прогнозы на основе новых входных данных.
Пример задачи: предсказать цену автомобиля на основе его характеристик. В этом
случае модель будет использовать признаки, такие как год выпуска, пробег, марка и
модель автомобиля, чтобы предсказать его стоимость.
Пример на Python: Линейная регрессия
Рассмотрим пример задачи регрессии, где мы предсказываем цену автомобиля на
основе года выпуска и пробега с помощью алгоритма линейной регрессии. Для этого
будем использовать библиотеку `scikit-learn`.
```python
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np
# Пример данных об автомобилях
data = {
"Год_выпуска": [2015, 2018, 2020, 2010, 2012],
"Пробег": [50000, 30000, 10000, 150000, 120000],
"Цена": [12000, 18000, 25000, 8000, 10000]
}
df = pd.DataFrame(data)
# Определяем признаки и целевую переменную
X = df[["Год_выпуска", "Пробег"]]
y = df["Цена"]
# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Обучаем модель линейной регрессии
model = LinearRegression()
model. t(X_train, y_train)
# Предсказания
y_pred = model.predict(X_test)
# Оценка качества модели
mse = mean_squared_error(y_test, y_pred)
print(f"Среднеквадратичная ошибка: {mse:.2f}")
# Пример предсказания цены для нового автомобиля
новый_автомобиль = [[2017, 40000]] # Год выпуска 2017, пробег 40,000
предсказанная_цена = model.predict(новый_автомобиль)
print(f"Предсказанная цена для нового автомобиля: {предсказанная_цена[0]:.2f} тыс. руб.")

fi

fi

fi

fi

# Визуализация данных и модели
g = plt. gure( gsize=(10, 7))
ax = g.add_subplot(111, projection='3d')
# Исходные данные
ax.scatter(df["Год_выпуска"], df["Пробег"], df["Цена"], color='blue', label='Исходные данные',
s=50)
# Линия регрессии
год_range = np.linspace(df["Год_выпуска"].min(), df["Год_выпуска"].max(), 10)
пробег_range = np.linspace(df["Пробег"].min(), df["Пробег"].max(), 10)
год_grid, пробег_grid = np.meshgrid(год_range, пробег_range)
цена_grid = model.predict(np.c_[год_grid.ravel(), пробег_grid.ravel()]).reshape(год_grid.shape)
ax.plot_surface(год_grid, пробег_grid, цена_grid, color='lightgreen', alpha=0.5)
# Предсказание нового автомобиля
ax.scatter(новый_автомобиль[0][0], новый_автомобиль[0][1], предсказанная_цена, color='red',
s=100, label='Новый автомобиль', marker='^')
# Настройка графика
ax.set_xlabel('Год выпуска')
ax.set_ylabel('Пробег')
ax.set_zlabel('Цена')
ax.set_title('Линейная регрессия для оценки стоимости автомобиля')
ax.legend()
plt.show()
```
Результат:
Среднеквадратичная ошибка: 5188271.60
Предсказанная цена для нового автомобиля: 17973.25 тыс. руб.

Разбор примера:
- Мы создаём небольшой набор данных с характеристиками автомобилей и их ценой.
- Обучаем модель линейной регрессии, используя год выпуска и пробег как признаки.
- Оцениваем модель с помощью среднеквадратичной ошибки (MSE), которая измеряет,
насколько точно модель предсказала цены.
- Затем делаем предсказание для нового автомобиля с заданным годом выпуска и
пробегом.
Кластеризация (Clustering)
Кластеризация — это задача группировки объектов в кластеры, где объекты в
одном кластере схожи между собой. В отличие от классификации, где данные имеют
заранее известные метки, в кластеризации модель не знает заранее, к каким группам
относятся данные, и должна сама определить, как их сгруппировать. Это одна из задач
обучения без учителя.
Примеры задач кластеризации:
1. Группировка покупателей интернет-магазина — можно группировать покупателей по
схожим предпочтениям и поведению, чтобы предложить персонализированные
рекомендации.
2. Сегментация рынка — разделение пользователей по демографическим характеристикам
и покупательским привычкам.
3. Разделение изображений на категории — например, кластеризация фотографий, где
модель автоматически определяет, какие из них относятся к одинаковой категории, такой
как пейзаж, портрет, природа и т. д.
Как работает кластеризация

Основной задачей кластеризации является нахождение таких групп (кластеров),
которые имеют внутреннее сходство, но при этом сильно отличаются от других групп.
Алгоритм пытается минимизировать различия между объектами в одном кластере и
максимизировать различия между кластерами.
Пример на Python: K-means кластеризация
Алгоритм K-средних (K-means) является одним из самых популярных методов
кластеризации. Он работает следующим образом: модель пытается разделить данные на
несколько кластеров (K), минимизируя внутрикластерные различия.
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
# Пример данных о покупателях
data = {
"Возраст": [22, 25, 47, 52, 46, 56, 28, 35],
"Покупки": [100, 150, 300, 350, 280, 400, 130, 200]
}
df = pd.DataFrame(data)

fi

# Применяем алгоритм K-средних для кластеризации
kmeans = KMeans(n_clusters=2, random_state=42)
df["Кластер"] = kmeans. t_predict(df[["Возраст", "Покупки"]])
# Визуализация кластеров
plt.scatter(df["Возраст"], df["Покупки"], c=df["Кластер"], cmap="viridis")
plt.xlabel("Возраст")
plt.ylabel("Сумма покупок")
plt.title("Кластеризация покупателей")
plt.show()
```
Разбор примера:
- Мы создаём набор данных с информацией о возрасте покупателей и их суммах покупок.
- Затем применяем алгоритм K-средних для кластеризации данных на два кластера.
- Визуализируем результаты с помощью графика, где каждый кластер будет отображён
разным цветом.
Итог:
- Регрессия используется для предсказания непрерывных числовых значений, таких как
цены или объёмы продаж.
- Кластеризация помогает находить группы схожих объектов без предварительных меток,
что полезно в задачах анализа данных и сегментации.
Оба этих метода являются важными инструментами машинного обучения и широко
применяются для решения различных практических задач в реальной жизни.
Обзор алгоритмов машинного обучения
Мир машинного обучения богат разнообразными алгоритмами. Одни из них просты
и понятны, другие — сложны и мощны. Рассмотрим несколько базовых алгоритмов,
которые являются основой для многих моделей.
Линейная регрессия (Linear Regression)

Линейная регрессия — это один из основополагающих и широко используемых
методов машинного обучения для предсказания числовых значений на основе анализа
зависимости между переменными. Основная цель линейной регрессии — найти такую
прямую линию, которая наилучшим образом описывает связь между независимыми
переменными (признаками) и зависимой переменной (целью). Эта прямая линия называется
линейной функцией.
Предположим, что у нас есть набор данных о ценах на дома в зависимости от их
площади. Каждый дом в данных представлен как точка с двумя аттрибутами: площадь
(например, в квадратных метрах) и цена (например, в рублях). Мы хотим построить модель,
которая на основе площади будет предсказывать цену.
Для этого линейная регрессия находит оптимальную прямую, которая
минимизирует ошибку между реальными ценами домов и теми, которые мы бы получили,
если бы использовали эту прямую. Процесс нахождения этой прямой заключается в
решении уравнения: y = a * x + b
Здесь:
- y — это предсказанная цена дома,
- x — это площадь дома,
- a — коэффициент наклона прямой, который показывает, насколько цена изменяется при
изменении площади на единицу,
- b — свободный член (или точка пересечения прямой с осью Y), который определяет цену,
если площадь дома равна нулю.
Алгоритм обучения линейной регрессии работает так, чтобы найти такие значения
для a и b , при которых ошибка (разница между предсказанными и реальными значениями)
будет минимальной.
Пример
Предположим, что у нас есть следующие данные о домах:

Используя линейную регрессию, мы пытаемся построить прямую, которая будет
наилучшим образом подходить к этим данным. Мы определяем коэффициенты a и b , и,
например, после обучения модель может выдать следующее уравнение:
Цена = 100,000 * Площадь + 1,000,000
Это означает, что за каждый квадратный метр площади дома мы платим 100,000
рублей, а начальная цена (для дома нулевой площади) — 1,000,000 рублей.
Теперь, если мы захотим предсказать цену дома с площадью 80 м², мы подставляем
значение в уравнение: Цена = 100,000 * 80 + 1,000,000 = 9,000,000
Рассмотрим пример кода для выполнения линейной регрессии в Python с
использованием библиотеки `scikit-learn`. Этот код будет использовать данные о площади и
цене домов, которые я описал ранее:
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
# Данные о площади (X) и цене (y)
X = np.array([30, 50, 70, 100]).reshape(-1, 1) # Площадь (м²)
y = np.array([3000000, 5000000, 7000000, 10000000]) # Цена (₽)

# Создаем модель линейной регрессии
model = LinearRegression()

fi

# Обучаем модель на данных
model. t(X, y)
# Коэффициенты модели
a = model.coef_[0] # Коэффициент наклона
b = model.intercept_ # Свободный член
# Печатаем результаты
print(f"Уравнение линейной регрессии: y = {a:.2f} * x + {b:.2f}")
# Делаем предсказания
X_new = np.array([80]).reshape(-1, 1) # Площадь нового дома
y_pred = model.predict(X_new) # Предсказанная цена
print(f"Предсказанная цена для дома с площадью 80 м²: {y_pred[0]:,.2f} ₽")
# Визуализация данных и линии регрессии
plt.scatter(X, y, color='blue', label='Данные')
plt.plot(X, model.predict(X), color='red', label='Линия регрессии')
plt.scatter(X_new, y_pred, color='green', label='Предсказание')
plt.xlabel('Площадь (м²)')
plt.ylabel('Цена (₽)')
plt.legend()
plt.show()
```

Объяснение:

fi

1. Импорт библиотек: Мы используем `numpy` для работы с массивами, `matplotlib.pyplot`
для построения графиков и `LinearRegression` из `sklearn` для самой регрессии.
2. Данные: Мы задаем массивы `X` (площадь домов) и `y` (цены).
3. Создание модели: Мы создаем модель линейной регрессии и обучаем её с помощью
метода ` t`.

4. Получение коэффициентов: После обучения модели мы получаем коэффициент наклона
`a` и свободный член `b`.
5. Предсказание: Мы делаем предсказание для нового значения площади (80 м²) с
помощью метода `predict`.
6. Визуализация: Строим график с исходными данными, линией регрессии и
предсказанием для нового дома.
Результаты: Код выведет уравнение линейной регрессии и предсказанную цену для
дома с площадью 80 м², а также покажет график с данными, линией регрессии и точкой
предсказания.
Этот код легко можно адаптировать для других данных или для решения более
сложных задач!
Таким образом, линейная регрессия позволяет нам делать предсказания и
анализировать зависимости между признаками и целевой переменной.
Решающие деревья (Decision Trees)
Решающие деревья — это один из наиболее понятных и интерпретируемых методов
машинного обучения. Алгоритм работает, создавая модель в виде дерева, где каждый узел
представляет собой условие, а ветви — результат выполнения этого условия. Таким
образом, решение принимается на основе последовательности логических шагов, что
позволяет легко понять, как модель пришла к своему выводу.
Пример работы решающего дерева:
Представим, что мы разрабатываем систему для оценки кандидатов на работу. У
нас есть несколько факторов, которые могут повлиять на решение о принятии кандидата,
например, образование, опыт работы и результаты собеседования. Система должна
принимать решение о том, стоит ли нанимать кандидата или нет.
Решающему дереву необходимо установить правила для разделения кандидатов на
два класса: тех, кого стоит принять на работу, и тех, кто не подходит. Это делается с
помощью критериев, представленных на каждом уровне дерева.
1. На первом уровне дерево может оценить образование кандидата. Если у кандидата
высшее образование, переходите к следующему условию. Если образование неполное, то
решение может быть принято на этом этапе, например, не принимать кандидата на работу.
2. На следующем уровне дерево может проверить, есть ли у кандидата опыт работы. Если
опыт есть, переходите к следующему условию, если нет — кандидат не проходит.
3. Следующий шаг — это оценка результатов собеседования. Если кандидат хорошо
прошел собеседование, то решение будет "принять на работу", иначе "отказ".
Структура решающего дерева:
- Корень дерева — это первый узел, в котором происходит разделение. Например, "Есть
ли высшее образование?"
- Ветви — это возможные ответы на вопрос из узла. Например, "Да" или "Нет".
- Листья дерева — это конечные решения или результаты. Например, "Принять на работу"
или "Не принять на работу".
Пример на Python
Давайте посмотрим, как мы можем применить решающее дерево для задачи
классификации, в которой мы решаем, стоит ли принимать кандидата на работу на основе
его образования, опыта работы и результатов собеседования.

fi

```python
import numpy as np
from sklearn.tree import DecisionTreeClassi er
from sklearn import tree
import matplotlib.pyplot as plt

# Данные о кандидатах (образование, опыт, собеседование)
# 0 - нет, 1 - да
# X - признаки (образование, опыт, собеседование)
# y - целевая переменная (0 - не принять, 1 - принять)
X = np.array([[1, 1, 1], # Высшее, опыт, прошел собеседование
[0, 0, 0], # Нет образования, нет опыта, не прошел собеседование
[1, 0, 1], # Высшее, нет опыта, прошел собеседование
[1, 1, 0], # Высшее, опыт, не прошел собеседование
[0, 1, 1]]) # Нет образования, опыт, прошел собеседование
y = np.array([1, 0, 1, 0, 1]) # 1 - принять, 0 - не принять

fi

# Создаем модель решающего дерева
model = DecisionTreeClassi er()

fi

# Обучаем модель
model. t(X, y)

fi

# Печатаем структуру дерева
tree.plot_tree(model, lled=True, feature_names=["Образование", "Опыт", "Собеседование"],
class_names=["Не принять", "Принять"])
plt.show()
# Пример предсказания: кандидат с высшим образованием, без опыта и прошедший
собеседование
prediction = model.predict([[1, 0, 1]])
print(f"Предсказание для кандидата: {'Принять на работу' if prediction[0] == 1 else 'Не
принять на работу'}")
```

Объяснение:

fi

1. Данные: В примере используется массив `X`, где каждая строка представляет одного
кандидата, а столбцы — его характеристики (образование, опыт и результаты
собеседования). Массив `y` содержит решения: 1 — принять кандидата, 0 — отклонить.
2. Обучение модели: Мы используем класс `DecisionTreeClassi er` из библиотеки `sklearn`
для создания и обучения модели решающего дерева.

3. Построение дерева: С помощью функции `plot_tree` мы визуализируем дерево решений,
где на каждом узле указаны условия (например, "Образование"), а на листьях — решение
(например, "Принять" или "Не принять").
4. Предсказание: Модель может предсказать, что делать с новым кандидатом, если его
характеристики соответствуют определенным значениям (например, у него есть
образование, но нет опыта и он прошел собеседование).
Результат: После обучения дерево будет готово принимать решения для новых
кандидатов, а визуализация дерева позволит наглядно увидеть, как принимаются эти
решения на основе заданных условий.
Таким образом, решающие деревья позволяют легко интерпретировать и
визуализировать процесс принятия решения, что делает их популярным инструментом в
задачах классификации и регрессии.
Метод k-ближайших соседей (k-Nearest Neighbors, KNN)
Метод k-ближайших соседей (k-Nearest Neighbors, KNN) — это один из самых
простых и интуитивно понятных алгоритмов машинного обучения. Он используется как для
классификации, так и для регрессии. Алгоритм работает по принципу: чтобы определить, к
какому классу принадлежит новый объект, нужно посмотреть на его ближайших "соседей"
в пространстве признаков. Чем большее количество соседей мы учитываем, тем более
устойчивым будет результат.
Как работает KNN?
Когда необходимо классифицировать объект, KNN рассчитывает его расстояние до
других объектов в пространстве признаков, например, используя евклидово расстояние
(по сути, это просто расстояние между точками в многомерном пространстве). Затем
алгоритм выбирает k ближайших соседей и назначает новому объекту класс, основываясь
на том, какой класс преобладает среди этих соседей.
Пример использования KNN:
Представим, что у нас есть данные о разных цветах цветов, где каждому цветку
присваивается определенный вид (например, ирис, роза, ромашка). Каждый цветок описан
несколькими признаками, такими как длина и ширина лепестков, длина и ширина
чашелистиков. Для того чтобы классифицировать новый цветок, алгоритм KNN ищет k
ближайших известных цветков и присваивает новому цветку тот вид, который преобладает
среди этих ближайших соседей.
Пример данных:

Когда мы получаем новый цветок с признаками, скажем, длина лепестка 5.2 см и
ширина лепестка 1.6 см, алгоритм KNN будет искать, например, 3 ближайших соседа и, в
зависимости от их видов, решит, к какому виду принадлежит новый цветок.
Алгоритм:
1. Шаг 1: Для нового объекта (нового цветка) вычисляется расстояние до всех
существующих объектов (цветков).
2. Шаг 2: Выбираются k ближайших объектов.
3. Шаг 3: Определяется класс нового объекта на основе классов k ближайших соседей
(например, большинство соседей могут быть ирисами — значит, и новый объект будет
классифицирован как ирис).
Пример на Python:
Давайте посмотрим, как применить метод k-ближайших соседей на реальных
данных с использованием библиотеки `scikit-learn`. В качестве примера возьмем
популярный набор данных о цветах ириса (Iris dataset), который уже встроен в библиотеку.

fi

```python
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassi er
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
# Загружаем данные о цветах ириса
data = load_iris()
X = data.data # Признаки (длина и ширина лепестков и чашелистиков)
y = data.target # Целевая переменная (виды цветов)
# Разбиваем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

fi

# Создаем модель KNN с 3 ближайшими соседями
knn = KNeighborsClassi er(n_neighbors=3)

fi

# Обучаем модель
knn. t(X_train, y_train)
# Предсказание для тестовой выборки
y_pred = knn.predict(X_test)
# Оценка точности модели
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy * 100:.2f}%")

fl

fl

# Пример предсказания для нового цветка
new_ ower = np.array([[5.2, 2.0, 3.5, 1.0]]) # Признаки нового цветка
predicted_class = knn.predict(new_ ower)
print(f"Предсказанный вид для нового цветка: {data.target_names[predicted_class][0]}")
```

Объяснение:

1. Данные: В данном примере мы используем известный набор данных о цветах ириса, где
каждый цветок имеет 4 признака (длина и ширина лепестка и чашелистика) и класс,
который обозначает вид цветка.
2. Разделение на обучающую и тестовую выборки: Мы делим данные на две части: одну
для обучения модели, а другую для проверки её точности.
3. Создание модели: Мы создаем модель KNN с параметром `n_neighbors=3`, что означает,
что для предсказания будет учитываться 3 ближайших соседа.
4. Оценка точности: Мы оцениваем точность модели, сравнив предсказанные значения с
реальными значениями.
5. Предсказание для нового объекта: В конце мы показываем, как можно использовать
модель для предсказания класса нового цветка.
Результат: Алгоритм KNN использует соседей для того, чтобы предсказать вид
нового цветка на основе признаков (например, длины и ширины лепестков). Точность
модели будет зависеть от выбранного числа соседей (k), а также от того, насколько
хорошо модель обучена на данных.
Таким образом, метод k-ближайших соседей прост в реализации и является
мощным инструментом, особенно для задач, где важно учитывать локальную структуру
данных.
Метод опорных векторов (Support Vector Machines, SVM)
Метод опорных векторов (SVM, Support Vector Machines) — это мощный и
эффективный алгоритм машинного обучения, используемый для задач классификации и
регрессии. Основной принцип работы SVM заключается в нахождении гиперплоскости,
которая максимально разделяет два класса данных, обеспечивая наибольший "зазор"
между этими классами. Эта гиперплоскость может быть линейной или нелинейной в
зависимости от особенностей данных.
Принцип работы SVM:
Когда данные линейно разделимы, алгоритм SVM находит такую гиперплоскость,
которая максимально разделяет два класса. Гиперплоскость — это нечто вроде
разделяющей линии в двумерном пространстве или разделяющей поверхности в
многомерных пространствах. Алгоритм старается обеспечить максимальный зазор (или
расстояние) между этой гиперплоскостью и ближайшими точками с разных сторон,
называемыми опорными векторами.
Если же данные нелинейно разделимы (например, классы не могут быть разделены
прямой линией), SVM использует ядровые функции, чтобы преобразовать исходные
данные в более высокоразмерное пространство, где они становятся линейно
разделимыми.
Пример задачи:
Представим задачу классификации клеток. У нас есть данные о клетках, которые
могут быть либо здоровыми, либо раковыми, и мы хотим построить модель, которая будет
классифицировать клетки на основе их признаков (например, размера, формы и других
характеристик).
Алгоритм SVM должен разделить данные так, чтобы максимально разделить
здоровые клетки и раковые клетки, что приведет к максимальному зазору между
классами. На основании этого он сможет классифицировать новые данные (новые клетки),
предсказывая их принадлежность к одному из классов.
Пример на Python:
Рассмотрим пример использования SVM для классификации данных с помощью
библиотеки `scikit-learn`. Мы будем использовать датасет о раковых клетках, известный как
Breast Cancer Wisconsin dataset.

```python
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
# Загружаем набор данных о раковых клетках
data = load_breast_cancer()
X = data.data # Признаки (размеры, формы клеток)
y = data.target # Целевая переменная (0 - злокачественная, 1 - доброкачественная)
# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

fi

# Масштабируем данные (для улучшения работы SVM)
scaler = StandardScaler()
X_train_scaled = scaler. t_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# Создаем модель SVM с ядром 'линейное'
model = SVC(kernel='linear')

fi

# Обучаем модель
model. t(X_train_scaled, y_train)
# Предсказание на тестовых данных
y_pred = model.predict(X_test_scaled)
# Оценка точности
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели SVM: {accuracy * 100:.2f}%")

fi

# Визуализация гиперплоскости для двумерных данных (выбираем два признака для
простоты)
X_train_2d = X_train_scaled[:, :2] # Используем только два признака
model_2d = SVC(kernel='linear')
model_2d. t(X_train_2d, y_train)
# Построение графика
xx, yy = np.meshgrid(np.linspace(X_train_2d[:, 0].min(), X_train_2d[:, 0].max(), 100),
np.linspace(X_train_2d[:, 1].min(), X_train_2d[:, 1].max(), 100))
Z = model_2d.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.8)
plt.scatter(X_train_2d[:, 0], X_train_2d[:, 1], c=y_train, edgecolors='k', marker='o')
plt.xlabel('Признак 1')
plt.ylabel('Признак 2')
plt.title('Гиперплоскость, разделяющая классы')
plt.show()
```

Объяснение:
1. Загрузка данных: В примере используется набор данных о раковых клетках, который
содержит признаки клеток и их классы: 0 — злокачественные, 1 — доброкачественные.
2. Масштабирование данных: С помощью `StandardScaler` данные приводятся к единому
масштабу, что важно для эффективной работы SVM, так как он чувствителен к различным
масштабам признаков.
3. Создание модели: Мы создаем модель SVM с линейным ядром (`kernel='linear'`),
поскольку в этом примере данные линейно разделимы.
4. Обучение модели: Модель обучается на обучающих данных.
5. Предсказания и оценка точности: Мы проверяем точность модели на тестовых данных,
сравнив предсказанные значения с реальными.
6. Визуализация гиперплоскости: Для упрощения визуализации мы берем только два
признака (для двумерного представления) и строим график гиперплоскости, разделяющей
два класса.
Результат: После обучения модель SVM способна классифицировать новые данные,
предсказывая, является ли клетка здоровой или раковой. Точность классификации
оценивается с помощью метрики `accuracy`, и на графике можно увидеть, как
гиперплоскость разделяет два класса (здоровые и раковые клетки).
Метод опорных векторов является очень мощным инструментом, особенно для
задач, где данные имеют четкие границы разделения. Он может эффективно работать
даже с высокоразмерными данными и сложными классами, где другие методы могут быть
менее точными.
Машинное обучение — это не просто набор алгоритмов, а способ обучения
компьютеров решать сложные задачи на основе данных. Понимание типов обучения, задач
и алгоритмов — важная основа для дальнейшего изучения и практики. В следующих главах
мы разберём, как применять эти методы на практике, создавая собственные модели и
оценивая их качество.
Глава 4: Работа с признаками
- Выбор и инженерия признаков
- Использование методов отбора признаков
- Преобразование категориальных данных
- Создание новых признаков (feature engineering)
В машинном обучении признаки (или фичи) играют ключевую роль в построении
успешной модели. Признаки — это те данные, которые мы используем для предсказания
целевой переменной. Важно понимать, что качество модели часто напрямую зависит от

того, насколько правильно выбраны и подготовлены признаки. Глава посвящена основным
аспектам работы с признаками, включая выбор, преобразование и создание новых
признаков, а также методы их отбора.
Когда данные поступают в модель машинного обучения, они должны быть
подготовлены и преобразованы таким образом, чтобы алгоритм мог эффективно их
обрабатывать. Эта подготовка данных, или инженерия признаков, является важным
этапом, который напрямую влияет на точность предсказаний.
Выбор и инженерия признаков

fi

Выбор и инженерия признаков (feature selection и feature engineering) — это важные
этапы в процессе подготовки данных для машинного обучения. Эти шаги направлены на
оптимизацию входных данных, чтобы модель могла сделать точные предсказания, не
переобучаясь и не недооценив важные факторы.
Процесс выбора признаков заключается в идентификации тех признаков, которые
оказывают наибольшее влияние на целевую переменную. Это ключевая задача, потому что
если в модели будут использоваться нерелевантные или избыточные признаки, это может
привести к переобучению (over tting) или, наоборот, к недостаточной точности, если
важные признаки будут исключены. Важно понимать, что каждый признак, который вы
вводите в модель, должен приносить информацию, которая будет улучшать её
способность к обобщению, а не только к подгонке под обучающие данные.
Как выбрать важные признаки
Одним из первых шагов в выборе признаков является анализ данных. Например,
можно начать с визуализации данных, чтобы увидеть, какие признаки имеют явные
зависимости с целевой переменной. В случае числовых данных это могут быть диаграммы
рассеяния или корреляционные матрицы, которые показывают, насколько сильно каждый
признак связан с целевой переменной.
Корреляция между признаками и целевой переменной — это один из простых и
полезных методов, который помогает понять, какие признаки могут иметь наибольшее
влияние. Например, в задаче прогнозирования цен на жилье можно ожидать, что такие
признаки, как площадь дома, количество комнат или возраст здания, будут сильно
коррелировать с ценой. С помощью метода корреляции Пирсона можно вычислить
коэффициенты для каждого признака, чтобы оценить их линейную зависимость с целевой
переменной. Однако важно помнить, что корреляция не всегда означает причинноследственную связь, и признаки с высокой корреляцией могут быть полезными, но также
могут быть неинформативными, если их слишком много.
Иногда простых методов, таких как корреляция, недостаточно, особенно когда
данные сложные и высокоразмерные. В таких случаях можно использовать более сложные
алгоритмы отбора признаков. Например, деревья решений автоматически оценивают
важность признаков, потому что на каждом шаге дерево принимает решение о том, какой
признак лучше всего делит данные на подмножества. Алгоритм случайного леса (Random
Forest) или метод градиентного бустинга также может использоваться для отбора
признаков, так как они генерируют деревья, которые на основе статистики показывают,
какие признаки наиболее важны для предсказания целевой переменной.
Пример: Прогнозирование цен на жилье
Рассмотрим задачу прогнозирования цен на жилье. У нас есть несколько
признаков, таких как площадь дома, количество комнат, возраст дома, местоположение,
наличие гаража и так далее. Первый шаг в выборе признаков — это оценить, какие из этих
переменных могут оказать наибольшее влияние на цену.
1. Корреляция: Мы можем начать с вычисления корреляции между каждым из признаков и
целевой переменной — ценой жилья. Например, площадь дома и количество комнат,
вероятно, будут сильно коррелировать с ценой, так как более большие дома обычно стоят
дороже.
2. Деревья решений: После того как мы провели первоначальный анализ с использованием
корреляции, можно использовать более сложный метод, например, дерево решений.

Алгоритм построит модель, которая сама выберет наиболее важные признаки для
предсказания цены. На основе этой модели мы сможем понять, какие признаки наиболее
важны.
3. Регрессия с регуляризацией: Мы можем также использовать методы линейной
регрессии с регуляризацией, такие как Lasso или Ridge, чтобы исключить несущественные
признаки. Эти методы могут автоматически уменьшить важность признаков, которые не
вносят значимый вклад в предсказание, и таким образом помочь нам избежать
переобучения.
Для примера с прогнозированием цен на жилье мы можем использовать библиотеку
`pandas` для обработки данных и `sklearn` для выполнения выбора признаков и создания
модели машинного обучения. В этом примере мы создадим несколько признаков,
используя данные о жилье, выполним их обработку и затем построим модель линейной
регрессии.
Код:
```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
import numpy as np
# Пример данных о жилье (вы можете заменить эти данные на свои)
data = {
'area': [1000, 1500, 2000, 2500, 3000], # площадь в квадратных метрах
'bedrooms': [3, 4, 3, 5, 4], # количество комнат
'age': [10, 15, 20, 5, 8], # возраст здания
'location': ['downtown', 'suburb', 'downtown', 'suburb', 'downtown'], # местоположение
'price': [500000, 600000, 650000, 700000, 750000] # цена
}
# Создаем DataFrame из данных
df = pd.DataFrame(data)
# Разделим данные на признаки (X) и целевую переменную (y)
X = df.drop('price', axis=1)
y = df['price']
# Преобразуем категориальный признак 'location' с помощью OneHotEncoder
# И добавим импрессию для отсутствующих значений
preprocessor = ColumnTransformer(
transformers=[
('num', SimpleImputer(strategy='mean'), ['area', 'bedrooms', 'age']),
('cat', OneHotEncoder(), ['location'])
])
# Разделим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Построим модель с помощью линейной регрессии
model = Pipeline(steps=[
('preprocessor', preprocessor),
('regressor', LinearRegression())

])

fi

# Обучаем модель
model. t(X_train, y_train)
# Прогнозируем цены для тестовой выборки
y_pred = model.predict(X_test)
# Оценим модель с помощью MSE (среднеквадратичной ошибки)
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')
# Выведем предсказанные и реальные значения цен
print(f'Predicted Prices: {y_pred}')
print(f'Real Prices: {y_test.values}')
```
Пояснение:
1. Данные: Мы создаём простой набор данных с признаками "площадь", "количество
комнат", "возраст" и "местоположение", а также с целевой переменной "цена".
2. Обработка категориальных данных: В данном случае у нас есть категориальный признак
"местоположение", который мы преобразуем с помощью `OneHotEncoder`. Этот метод
создаёт бинарные признаки для каждого уникального значения, что позволяет модели
работать с ними.
3. Обработка пропусков: Используем `SimpleImputer` для обработки пропущенных значений
в числовых данных. В данном примере нет пропусков, но для реальных данных это
полезно.
4. Пайплайн: В коде используется `Pipeline`, который позволяет последовательно
применить все шаги обработки данных (предобработка) и затем обучить модель. Пайплайн
делает код более чистым и удобным для использования на реальных данных.
5. Обучение и прогнозирование: Мы обучаем модель линейной регрессии, прогнозируем
цены на тестовой выборке и оцениваем качество модели с помощью метрики MSE
(среднеквадратичная ошибка).
Программа выведет:
- Среднеквадратичную ошибку, которая будет показывать, насколько точны прогнозы
модели.
- Сравнение предсказанных и реальных значений для цен.

Этот пример демонстрирует базовую работу с данными для задачи регрессии,
включая преобразование признаков и обучение модели.
Инженерия признаков играет ключевую роль в улучшении качества модели. Она
заключается в создании новых признаков, которые могут быть более информативными для
модели, чем те, что уже имеются в исходных данных. Примером такой работы может быть
преобразование даты на более структурированные компоненты, такие как день недели,
месяц или сезон, если это имеет смысл для задачи.
Возьмем, например, задачу прогнозирования спроса на товар в интернет-магазине.
В этой задаче данные о датах покупок могут быть преобразованы таким образом, чтобы
модель могла учитывать сезонность и цикличность покупок. Преобразование дат в
признаки, такие как "день недели", "праздничный день", "месяц" или "время года", может
значительно улучшить предсказания модели, так как поведение покупателей часто зависит
от этих факторов. Например, спрос на товары в преддверии праздников может резко
увеличиваться, а спрос в выходные может быть выше, чем в будние дни.

Другим примером может быть создание новых признаков на основе числовых
данных. Например, если у нас есть два признака: "доход" и "возраст", то мы можем
создать новый признак — "доход на человека", если эта информация может быть полезной
для задачи, например, в задаче оценки риска кредита.
В задаче анализа клиентов, если у нас есть признаки, такие как "стаж работы" и
"зарплата", то можно создать новый признак "стаж работы в месяцах", который будет
иметь более точное числовое представление, а не просто годовой стаж.
Важным моментом при создании новых признаков является итеративный подход.
Это требует экспериментов и проверки, чтобы понять, какие признаки оказывают
наибольшее влияние на модель. После создания новых признаков важно провести
тщательную проверку их значимости с использованием методов, таких как регрессия с
регуляризацией или деревья решений, чтобы убедиться, что новые признаки
действительно добавляют полезную информацию, а не просто увеличивают сложность
модели.
Выбор и инженерия признаков — это не просто технические этапы в подготовке
данных, а искусство, требующее как знаний о задаче, так и творческого подхода.
Неправильный выбор признаков или отсутствие работы с ними может привести к созданию
неэффективных моделей, не способных точно прогнозировать. Важно подходить к выбору
признаков с умом, используя статистические методы и алгоритмы машинного обучения для
оценки важности каждого признака. В то же время, создание новых признаков через
инженерное мышление может значительно повысить точность модели, если это делается
грамотно.
Использование методов отбора признаков
Когда количество признаков велико, важно применить методы, которые помогут
отобрать только те признаки, которые имеют значимость для целевой переменной. Методы
отбора признаков делятся на три основных типа: фильтрационные, обёрточные и
встроенные.
1. Фильтрационные методы
Фильтрационные методы представляют собой один из подходов для отбора
признаков в машинном обучении, который основывается на статистическом анализе
данных. Эти методы предполагают использование различных статистических тестов для
оценки того, насколько каждый признак связан с целевой переменной. Они помогают
быстро и эффективно выявить важные признаки и отсеять те, которые не имеют
значительного влияния на модель.
Одним из самых распространенных статистических методов является корреляция
Пирсона. Этот метод используется для оценки линейной зависимости между числовыми
признаками и целевой переменной. Корреляция Пирсона измеряет, насколько сильно
изменяется один признак при изменении другого, и имеет значение от -1 до 1. Если
корреляция близка к 1 или -1, это означает, что между признаками существует сильная
линейная зависимость. В таком случае, можно уверенно сказать, что эти признаки полезны
для построения модели. Если корреляция близка к нулю, это может указывать на то, что
признак не имеет линейной зависимости с целевой переменной и, возможно, не будет
полезен для прогнозирования.
Например, если мы решаем задачу прогнозирования цен на жилье и видим, что
площадь дома и его цена имеют высокую корреляцию, то площадь может быть важным
признаком для модели. В то время как возраст здания и цена могут иметь слабую или
нулевую корреляцию, что может сигнализировать о том, что возраст не является полезным
признаком для этого конкретного предсказания.
Для категориальных признаков часто используют тесты хи-квадрат. Эти тесты
измеряют, насколько зависимы две категориальные переменные друг от друга, проверяя,
отличаются ли частоты появления определённых категорий в зависимости от значения
целевой переменной. В задаче классификации, например, можно применить хи-квадрат
для оценки того, насколько хорошо категориальные признаки (например, местоположение
или тип жилья) могут предсказывать целевой класс (например, высокую или низкую цену).

Если для категориальных признаков хи-квадрат тест показывает низкое значение p,
это указывает на значимую зависимость между признаками, и они могут быть полезны для
построения модели. Если же p-значение высокое, это сигнализирует о слабой или
отсутствии зависимости, и такие признаки можно исключить из модели.
Кроме того, фильтрационные методы хороши тем, что их можно использовать до
того, как модель будет обучена. Они являются вычислительно эффективными, так как не
требуют обучения модели на каждом шаге отбора признаков, и позволяют быстро
исключить признаки, которые не влияют на результат. Это особенно полезно, когда
данные содержат большое количество признаков и требуется снизить их размерность,
чтобы уменьшить время обучения модели и предотвратить переобучение.
Однако, важно понимать, что фильтрационные методы ориентированы на
статистические зависимости и не всегда могут учесть более сложные, нелинейные
отношения между признаками и целевой переменной. Поэтому они могут быть не так
эффективны для сложных моделей, таких как деревья решений, которые могут выявлять
сложные зависимости, не проявляющиеся через простую корреляцию или хи-квадрат.
Таким образом, фильтрационные методы являются важным инструментом в
процессе выбора признаков. Они обеспечивают быстрый и понятный способ для
первичного отбора признаков, которые могут иметь значительное влияние на модель, но
для более глубокого анализа и выявления скрытых зависимостей могут потребоваться
более сложные подходы, такие как метод взаимной информации или использование
моделей машинного обучения для оценки важности признаков.
2. Обёрточные методы
Обёрточные методы представляют собой подходы к отбору признаков, которые
используют модели машинного обучения для оценки того, какие признаки оказывают
наибольшее влияние на целевую переменную. В отличие от фильтрационных методов,
которые ориентированы на статистические тесты, обёрточные методы непосредственно
используют обученную модель для отбора признаков. Эти методы могут учитывать более
сложные взаимосвязи между признаками и целевой переменной, что делает их особенно
полезными для задач, где линейные зависимости не всегда очевидны.
Одним из самых популярных обёрточных методов является рекурсивное
исключение признаков (Recursive Feature Elimination, RFE). Этот метод основан на идее
того, что для оптимальной работы модели необходимо оставить только самые важные
признаки, а те, которые оказывают наименьшее влияние на результат, можно удалить.
Процесс работы RFE заключается в следующем: сначала модель обучается на всех
признаках, и затем на каждом шаге исключается один из признаков, который имеет
наименьшее значение важности (например, тот, который в наименьшей степени влияет на
прогноз). Этот процесс повторяется до тех пор, пока не останется оптимальное количество
признаков. Важно отметить, что каждый шаг включает обучение модели, что позволяет
учитывать взаимодействие признаков, и метод будет работать с более сложными и
нелинейными зависимостями.
В процессе работы с RFE важно выбрать подходящую модель, которая будет
использоваться для оценки важности признаков. Обычно для этого используются модели,
которые могут предоставить информацию о важности признаков, такие как деревья
решений, случайные леса или линейные модели с регуляризацией, такие как Lasso. Эти
модели способны выявить, какие признаки имеют значительное влияние на предсказание,
а какие — незначительное.
Примером может служить задача классификации, где необходимо выбрать
наиболее важные признаки для предсказания класса объекта. Допустим, у нас есть набор
данных с большим количеством признаков, и задача — выбрать только те, которые
действительно важны для правильной классификации. Используя RFE, мы можем
поочередно исключать наименее важные признаки и проверять, как это влияет на точность
модели. После нескольких итераций мы получаем оптимальное подмножество признаков,
которые минимизируют ошибку модели.
Пример процесса RFE в контексте задачи регрессии:
1. Мы начинаем с обученной модели, например, с линейной регрессии, которая использует
все доступные признаки.

2. Модель оценивает важность каждого признака. Признаки, которые минимально влияют
на результат, исключаются.
3. После каждого шага обучение модели повторяется, и процесс продолжается, пока не
останется заданное количество признаков.
4. В конечном итоге мы получаем наилучшую модель с минимальным набором признаков,
что помогает улучшить точность модели и сократить время её обучения.
Преимущества обёрточных методов, таких как RFE, заключаются в том, что они
позволяют учитывать взаимозависимость признаков и их важность в контексте конкретной
модели. Это делает их мощным инструментом для отбора признаков, особенно в случаях,
когда неочевидно, какие признаки следует оставить.
Однако, как и у большинства методов, есть и свои недостатки. Обёрточные методы
могут быть вычислительно затратными, особенно если набор данных содержит много
признаков или если модель сложная. Каждый шаг включает в себя обучение модели, что
может существенно увеличить время выполнения, особенно на больших наборах данных.
Кроме того, результат работы RFE может зависеть от выбранной модели. Например,
линейная модель может по-разному оценивать важность признаков по сравнению с более
сложными моделями, такими как случайный лес.
Обёрточные методы представляют собой мощный инструмент для выбора
признаков, который использует модели машинного обучения для более точного и
интуитивного отбора важных признаков. Они подходят для задач, где признаки могут
иметь сложные взаимодействия и нелинейные зависимости с целевой переменной.
3. Встроенные методы
Встроенные методы — это подходы к отбору признаков, которые интегрированы
непосредственно в процесс обучения модели. Вместо того, чтобы отдельно вычислять
важность признаков, как это происходит в фильтрационных или обёрточных методах,
встроенные методы позволяют модели оценивать важность признаков во время её
обучения. Это делает их удобными и эффективными инструментами для выявления
наиболее значимых признаков, сохраняя при этом качество модели и избегая излишних
вычислительных затрат.
Одним из самых известных встроенных методов является использование деревьев
решений. Алгоритмы, основанные на деревьях решений, такие как классификационные и
регрессионные деревья (CART), автоматически вычисляют важность признаков, делая
разделение данных по узлам дерева. Каждый узел в дереве решения соответствует
определённому признаку, который наилучшим образом разделяет данные по целевой
переменной. Чем выше уровень узла, тем более важным является признак, на котором он
основан. В процессе построения дерева решается, какой признак использовать для
разделения на каждом шаге, и таким образом происходит естественная оценка важности
признаков.
Другим мощным встроенным методом являются случайные леса (Random Forest),
которые представляют собой ансамбль множества деревьев решений. Суть заключается в
том, что для каждой задачи строится несколько деревьев, и каждый узел дерева выбирает
признак на основе случайной подвыборки данных. В случае случайных лесов важность
признаков оценивается на основе того, как сильно влияние каждого признака увеличивает
точность предсказания по сравнению с базовой моделью. Этот процесс включает
вычисление, как улучшение точности модели зависит от каждого признака, что позволяет
получить оценку важности для каждого из них.
Методы, основанные на линейной регрессии с регуляризацией (например, Lasso и
Ridge), также могут служить встроенными методами для отбора признаков. В этих моделях
регуляризация (L1 для Lasso и L2 для Ridge) добавляется в функцию потерь модели с
целью предотвращения переобучения и улучшения обобщающей способности модели.
Регуляризация работает, снижая веса признаков, которые менее важны для предсказания.
В случае Lasso, например, некоторые коэффициенты весов могут быть приравнены к нулю,
что эквивалентно исключению признаков, которые не способствуют улучшению модели.
Когда мы используем встроенные методы, модель обучается с учётом важности
каждого признака, что позволяет выбрать оптимальный набор признаков, одновременно
минимизируя переобучение и повышая точность модели. Эти методы полезны в ситуациях,

когда необходимо работать с большим количеством признаков, но при этом важно
сохранить простоту модели и её интерпретируемость.
Встроенные методы имеют несколько преимуществ. Во-первых, они эффективно
решают задачу выбора признаков в контексте конкретной модели, автоматически
оценивая важность признаков без необходимости в отдельном процессе отбора. Вовторых, такие методы часто имеют низкую вычислительную сложность, так как они
выполняются в процессе обучения модели, что экономит время и ресурсы. В-третьих, они
позволяют создавать более интерпретируемые модели, поскольку важно понимать, какие
признаки модель использует для своих предсказаний.
Однако у встроенных методов есть и ограничения. Например, они могут не всегда
хорошо работать, если признаки имеют сложные или нелинейные взаимодействия,
которые не могут быть легко захвачены простыми моделями, такими как деревья решений
или линейная регрессия. В случае использования деревьев решений или случайных лесов
важно учитывать, что они могут быть склонны к переобучению, особенно если данные
имеют шум или признаки с низкой значимостью. В таких случаях может понадобиться
дополнительная настройка модели или применение методов регуляризации.
Таким образом, встроенные методы — это удобные и эффективные инструменты
для выбора признаков, которые оценивают важность признаков в процессе обучения
модели. Они позволяют автоматизировать процесс выбора признаков, обеспечивая
высокую точность и интерпретируемость, при этом сохраняя эффективность работы с
большими наборами данных.
Преобразование категориальных данных
Преобразование категориальных данных — это важный этап в подготовке данных
для обучения моделей машинного обучения. Категориальные переменные, такие как
текстовые метки (например, "красный", "синий" и "зеленый" для признака "цвет") или
номинальные данные (например, "мужчина", "женщина" для признака "пол"), не могут быть
использованы напрямую большинством алгоритмов машинного обучения, так как они
требуют числового ввода. Поэтому такие данные необходимо преобразовать в числовую
форму, чтобы алгоритм мог их обработать.
Одним из самых популярных методов преобразования категориальных признаков
является one-hot encoding. Этот метод представляет каждую уникальную категорию в
отдельном бинарном столбце, где для каждого объекта в данных проставляется 1, если
объект принадлежит данной категории, или 0, если не принадлежит. Рассмотрим пример: у
нас есть столбец "цвет" с тремя возможными категориями: "красный", "синий" и
"зеленый". После применения one-hot encoding мы получим три новых столбца: "красный",
"синий" и "зеленый". Для каждого объекта в этих столбцах будет стоять значение 1 или 0 в
зависимости от того, какой цвет соответствует объекту.
Пример данных до преобразования:

Пример данных после one-hot encoding:

Метод one-hot encoding особенно полезен, когда категории не имеют никакого
порядка, то есть они номинальные. Этот метод обеспечивает, что модель не будет делать
ложные предположения о порядке или взаимосвязях между категориями.
Другим методом преобразования категориальных признаков является label
encoding, который представляет каждую категорию как уникальный числовой код. Этот
метод подходит для порядковых категориальных признаков, где есть естественная
последовательность или порядок, например, оценки "низкий", "средний", "высокий".
Каждой категории присваивается целое число, которое отражает её положение в порядке.
Например, "низкий" может быть представлен как 0, "средний" как 1, а "высокий" как 2.
Пример данных до преобразования:

Пример данных после label encoding:

Тем не менее, важно быть осторожным при применении label encoding к
номинальным данным, потому что этот метод может создать ложное восприятие порядка
между категориями. Например, если бы категории "красный", "синий" и "зеленый" были
преобразованы с помощью label encoding, полученные числовые значения могли бы
восприниматься моделью как имеющие порядок, что не соответствует реальности, так как
цвета не имеют упорядоченности. В таких случаях лучше использовать one-hot encoding,
чтобы избежать подобных ошибок.
Код для преобразования категориальных данных с использованием both one-hot
encoding и label encoding в Python с библиотекой pandas:
```python
import pandas as pd
from sklearn.preprocessing import LabelEncoder

# Пример данных
data = {'цвет': ['красный', 'синий', 'зеленый', 'красный']}
df = pd.DataFrame(data)

fi

# One-hot encoding
df_one_hot = pd.get_dummies(df, columns=['цвет'], pre x=['цвет'])
print("One-hot encoding:")
print(df_one_hot)

fi

# Label encoding
label_encoder = LabelEncoder()
df['цвет_encoded'] = label_encoder. t_transform(df['цвет'])
print("\nLabel encoding:")
print(df)
```
Результат работы кода:

Как видно, в случае one-hot encoding для каждого цвета создаются отдельные
бинарные столбцы. В случае label encoding каждому цвету присваивается числовой код,
который соответствует порядку, в котором они встречаются.
Важно помнить, что выбор метода преобразования зависит от контекста задачи.
Если категории не имеют упорядоченности, то следует использовать one-hot encoding,
чтобы избежать ненужных предположений о порядке. Если же категории имеют
естественный порядок (например, "низкий", "средний", "высокий"), то label encoding может
быть более подходящим выбором.
Создание новых признаков (Feature Engineering)
Создание новых признаков (или *feature engineering*) — это важная часть подготовки
данных, которая помогает улучшить качество модели. Этот процесс заключается в
извлечении или создании дополнительных признаков на основе существующих данных.
Цель заключается в том, чтобы представить информацию в такой форме, которая будет
наиболее полезной для алгоритма машинного обучения. Это может включать в себя
объединение нескольких признаков, трансформацию данных или извлечение скрытых
закономерностей.
Пример: рассмотрим задачу прогнозирования цен на жилье. Изначально у нас есть
признаки "площадь" и "количество комнат". Однако, для улучшения точности модели, мы
можем создать новый признак, который будет показывать, сколько квадратных метров
приходится на одну комнату. Этот новый признак, "площадь на комнату", может дать
модели полезную информацию о том, как площадь распределяется среди комнат в доме, и

это может быть более информативно, чем просто наличие данных о площади и комнатах
отдельно.
Пример данных до создания нового признака:

Мы можем создать новый признак — "площадь на комнату»:

Этот новый признак может помочь модели лучше понять, как площадь влияет на
цену жилья в зависимости от количества комнат.
Если у нас есть временные данные, например, информация о времени покупки
товара или время продажи недвижимости, мы можем извлечь дополнительные признаки,
такие как день недели, месяц, квартал или сезон. Эти признаки могут быть полезны в
задачах прогнозирования продаж, так как покупки могут быть более активными в
определённые дни недели или месяцы. Например, в задаче прогнозирования продаж
товаров перед праздниками, можно создать признаки, связанные с наличием праздников в
календаре. Такой подход может улучшить модель, так как она будет учитывать сезонные и
временные колебания.
Пример с временными признаками:
Предположим, у нас есть дата покупки товара. Мы можем извлечь из неё день
недели, месяц и сезон:

Эти дополнительные признаки могут быть полезны, если, например, спрос на
товары варьируется в зависимости от сезона или месяца.
Кроме того, создание признаков может быть связано с работой с текстовыми
данными. Например, в задаче классификации текста можно создать признаки, которые
будут характеризовать длину текста, количество слов или частоту использования

ключевых слов. Одним из распространённых методов извлечения признаков из текста
является TF-IDF (Term Frequency-Inverse Document Frequency), который измеряет важность
слова в документе относительно всей коллекции документов.
Пример: если задача — классификация отзывов о товарах, то мы можем
использовать TF-IDF для преобразования текстов в числовые признаки. Для каждого слова
в тексте будет рассчитана важность, и эти данные можно использовать в модели для
предсказания, является ли отзыв положительным или отрицательным.
Код для создания новых признаков, включая использование TF-IDF и расчёт
площади на комнату:

fi

```python
import pandas as pd
from sklearn.feature_extraction.text import T dfVectorizer
# Пример данных о недвижимости
data = {'площадь': [50, 75, 120, 60],
'количество комнат': [2, 3, 4, 2]}
df = pd.DataFrame(data)
# Создание нового признака "площадь на комнату"
df['площадь на комнату'] = df['площадь'] / df['количество комнат']
print("Данные с новым признаком:")
print(df)

fi

fi

# Пример с текстовыми данными
text_data = ["хороший товар", "очень плохой товар", "удовлетворительный товар",
"отличный товар"]
vectorizer = T dfVectorizer()
X = vectorizer. t_transform(text_data)
# Преобразование текста в признаки
print("\nTF-IDF признаки для текста:")
print(X.toarray())
print("\nСловарь (слова и их индексы):")
print(vectorizer.get_feature_names_out())
```
Результат работы кода:

В примере с недвижимостью мы создали новый признак "площадь на комнату",
который помогает лучше понять соотношение площади и количества комнат. В примере с
текстами использовался TF-IDF для преобразования текстов в числовые признаки,
которые могут быть использованы для дальнейшей классификации.
Создание новых признаков требует глубокого понимания данных и проблемы, что
позволяет создавать признаки, которые будут наиболее полезными для модели. Это может
значительно улучшить качество предсказаний и повысить точность модели.
Работа с признаками является ключевым этапом в построении успешных моделей
машинного обучения. Правильный выбор и подготовка признаков могут значительно
улучшить результаты работы модели. Методы отбора признаков позволяют
сосредоточиться только на тех данных, которые действительно важны, а создание новых
признаков (feature engineering) может улучшить качество предсказаний и сделать модель
более точной. Важно помнить, что процесс работы с признаками требует не только
теоретических знаний, но и практического опыта в анализе данных.
Глава 5: Алгоритмы классификации
- Логистическая регрессия
- Метод опорных векторов (SVM)
- Деревья решений и случайный лес
- Классификация с помощью k-ближайших соседей (KNN)
- Оценка качества классификации
Классификация — одна из ключевых задач машинного обучения, цель которой
заключается в том, чтобы научить модель определять принадлежность объекта к
определённой категории или классу. Подобные задачи встречаются в самых разных
сферах: от диагностики заболеваний и оценки кредитоспособности до фильтрации спама и
распознавания изображений.
Суть классификации заключается в выявлении закономерностей в данных, которые
позволяют предсказывать класс новых, ранее не встречавшихся объектов. Алгоритм
анализирует примеры с известными метками и находит связи между признаками и
целевым значением. После обучения модель может использовать эти связи для
классификации новых данных.
Однако выбор подходящего алгоритма классификации зависит от множества
факторов: сложности задачи, структуры данных, наличия шума и требуемой точности.
Некоторые модели хорошо работают с простыми линейно разделимыми данными, другие
способны выявлять сложные нелинейные зависимости.
Кроме того, важную роль играет правильная оценка качества модели. Даже если
алгоритм показывает высокую точность на обучающих данных, это не гарантирует его
успешную работу на новых примерах. Поэтому важно уметь проверять, насколько надёжны
предсказания модели, и избегать распространённых ошибок, таких как переобучение.
Эта глава поможет глубже понять, как работают популярные алгоритмы
классификации и какие задачи они решают наиболее эффективно.
Логистическая регрессия
Логистическая регрессия — это один из самых простых и популярных методов
классификации, который позволяет определять, к какому из двух классов принадлежит
объект. Например, она может помочь спрогнозировать, купит ли клиент товар, одобрят ли
заявку на кредит или является ли электронное письмо спамом.
Суть логистической регрессии заключается в том, чтобы найти взаимосвязь между
входными данными и вероятностью того, что объект относится к определённому классу.
Чтобы сделать это, алгоритм строит границу, которая разделяет данные на две категории.
Эта граница может быть простой прямой (в случае работы с двумя признаками) или более
сложной плоскостью в многомерном пространстве признаков.
Работает это так: модель анализирует значения признаков объекта — например,
возраст клиента, его доход или количество покупок — и на их основе вычисляет
вероятность принадлежности к определённой категории. Если вероятность выше

порогового значения (обычно это 0,5), объект относят к положительному классу, если ниже
— к отрицательному.
Чтобы логистическая регрессия могла давать точные предсказания, её нужно
обучить на исторических данных, где известны исходы. Алгоритм анализирует эти данные,
корректируя внутренние параметры так, чтобы как можно точнее разделять объекты на
нужные группы.
После обучения модель готова к использованию на новых данных. Например, если
нужно понять, уйдёт ли клиент из компании, логистическая регрессия оценит вероятность
исходя из его поведения и характеристик.
Пример:
Представим, что у нас есть данные о клиентах интернет-магазина, и мы хотим
предсказать, купит ли новый посетитель товар. Для этого мы используем информацию о
его возрасте, среднем чеке предыдущих покупок и времени, проведённом на сайте. Мы
обучаем логистическую регрессию на исторических данных, где известно, кто из клиентов
совершал покупки, а кто — нет. После обучения модель сможет прогнозировать
вероятность покупки для новых посетителей.
Допустим, для нового клиента алгоритм рассчитал вероятность 0,8. Так как это
значение выше порогового (0,5), мы делаем вывод, что клиент, скорее всего, совершит
покупку, и можем предложить ему персональную скидку, чтобы повысить вероятность
сделки.
Пример кода на Python с использованием библиотеки scikit-learn, который
демонстрирует, как обучить модель логистической регрессии для предсказания
вероятности покупки товара:
```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Создаём примерные данные о клиентах
data = {
'Возраст': [25, 30, 45, 35, 23, 50, 40, 29, 60, 27],
'Средний_чек': [40, 55, 80, 60, 35, 90, 70, 50, 95, 45],
'Время_на_сайте': [5, 10, 15, 12, 4, 20, 18, 9, 25, 7],
'Совершил_покупку': [0, 1, 1, 1, 0, 1, 1, 0, 1, 0]
}
# Преобразуем данные в DataFrame
df = pd.DataFrame(data)
# Разделяем признаки и целевую переменную
X = df[['Возраст', 'Средний_чек', 'Время_на_сайте']]
y = df['Совершил_покупку']
# Делим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Создаём и обучаем модель логистической регрессии
model = LogisticRegression()
model. t(X_train, y_train)
# Оцениваем точность модели
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Точность модели: {accuracy:.2f}')
# Прогноз для нового клиента
новый_клиент = pd.DataFrame({

})

'Возраст': [32],
'Средний_чек': [65],
'Время_на_сайте': [14]

# Рассчитываем вероятность покупки
вероятность = model.predict_proba(новый_клиент)[0][1]
print(f'Вероятность покупки: {вероятность:.2f}')
# Интерпретация результата
if вероятность > 0.5:
print("Клиент, скорее всего, совершит покупку. Можно предложить скидку.")
else:
print("Клиент, вероятно, не купит товар. Возможно, стоит предложить бонус.")
```
Объяснение кода:
1. Создание данных — мы создали простой набор данных с возрастом клиента, средним
чеком и временем на сайте.
2. Обучение модели — модель логистической регрессии обучается на примерах клиентов с
известным результатом (совершили покупку или нет).
3. Оценка точности — оцениваем, насколько модель точна на тестовой выборке.
4. Прогноз для нового клиента — для клиента с определёнными характеристиками модель
выдаёт вероятность покупки.
5. Интерпретация результата — если вероятность выше 0,5, делаем вывод, что клиент,
скорее всего, купит товар.
Совет: В реальных проектах данные требуют глубокой предобработки, а модель —
настройки гиперпараметров для достижения наилучших результатов.
Логистическая регрессия хороша тем, что она проста в реализации, легко
интерпретируема и требует сравнительно небольшого объёма вычислений. Однако у неё
есть ограничения: она плохо справляется со сложными зависимостями между признаками
и не подходит для многоклассовых задач без модификации. Тем не менее, для базовых
задач классификации логистическая регрессия остаётся надёжным и проверенным
инструментом.
Метод опорных векторов (SVM)
Метод опорных векторов (SVM, от англ. Support Vector Machine) — это мощный
инструмент для классификации, который отлично справляется с задачами, где нужно чётко
разделить данные на группы. Основная идея SVM заключается в том, чтобы найти
наилучшую границу, которая максимально разделяет объекты разных классов. Эта граница
называется гиперплоскостью.
Представим простую ситуацию: у нас есть два типа клиентов — те, кто совершает
покупки в интернет-магазине, и те, кто просто просматривает товары. Если нанести их
данные на график, можно увидеть, что между ними существует определённое разделение.
SVM находит такую линию (или плоскость в более сложных случаях), которая расположена
как можно дальше от объектов каждого класса. Это важно, потому что чем больше "зазор"
между классами, тем устойчивее модель к ошибкам и новым данным.
Особенность SVM в том, что для построения границы он опирается не на все
данные, а только на те объекты, которые находятся ближе всего к границе. Эти точки
называются опорными векторами. Именно они определяют положение разделяющей
линии.
Иногда данные невозможно разделить прямой линией. Например, если классы
переплетаются или имеют сложную форму. В таких случаях SVM использует специальные
методы, чтобы "разогнуть" пространство данных и найти границу в более высоком
измерении. Этот подход позволяет решать задачи с нелинейной структурой данных.
Пример:

Допустим, у нас есть данные о клиентах, и мы хотим разделить их на две группы:
- Активные покупатели — те, кто часто совершает покупки.
- Редкие посетители — те, кто просто просматривает товары.
Мы используем два признака:
- Частота посещений сайта (количество визитов в месяц).
- Средний чек (сумма одной покупки).
После нанесения данных на график видно, что активные покупатели чаще заходят
на сайт и тратят больше денег, а редкие посетители заходят реже и покупают меньше.
Однако между этими группами есть пограничные клиенты — они заходят не слишком
часто, но иногда делают крупные заказы.
SVM находит границу между двумя группами, опираясь на таких "пограничных"
клиентов. Для нового посетителя модель определяет, по какую сторону от границы он
находится, и на основе этого предсказывает его категорию.
Например:
- Если клиент заходит на сайт 15 раз в месяц и тратит в среднем 70 у.е., модель отнесёт
его к активным покупателям.
- Если же клиент появляется всего пару раз и тратит около 20 у.е., SVM классифицирует
его как редкого посетителя.
Рассмотрим пример кода на Python с использованием библиотеки scikit-learn,
который демонстрирует, как применить метод опорных векторов (SVM) для классификации
клиентов интернет-магазина на активных покупателей и редких посетителей:
```python
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# Создаём примерные данные о клиентах
data = {
'Частота_посещений': [5, 15, 3, 20, 7, 12, 2, 18, 4, 14],
'Средний_чек': [30, 70, 20, 90, 35, 65, 25, 85, 28, 75],
'Активный_покупатель': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] # 1 — активный, 0 — редкий
}
# Преобразуем данные в DataFrame
df = pd.DataFrame(data)
# Разделяем признаки и целевую переменную
X = df[['Частота_посещений', 'Средний_чек']]
y = df['Активный_покупатель']
# Делим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Создаём и обучаем модель SVM
model = SVC(kernel='linear', probability=True)
model. t(X_train, y_train)
# Оцениваем точность модели
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Точность модели: {accuracy:.2f}')
# Прогноз для нового клиента
новый_клиент = pd.DataFrame({
'Частота_посещений': [10],
'Средний_чек': [60]
})

# Предсказание класса и вероятности
класс = model.predict(новый_клиент)[0]
вероятность = model.predict_proba(новый_клиент)[0][1]
print(f'Клиент классифицирован как: {"Активный покупатель" if класс == 1 else "Редкий
посетитель"}')
print(f'Вероятность быть активным покупателем: {вероятность:.2f}')

fi

fi

# Визуализация границы решений
plt. gure( gsize=(8, 6))
for i, label in enumerate(['Редкий посетитель', 'Активный покупатель']):
plt.scatter(df[df['Активный_покупатель'] == i]['Частота_посещений'],
df[df['Активный_покупатель'] == i]['Средний_чек'],
label=label)
# Отображаем нового клиента
plt.scatter(новый_клиент['Частота_посещений'], новый_клиент['Средний_чек'],
color='purple', marker='X', s=200, label='Новый клиент')
# Построим разделяющую границу
w = model.coef_[0]
b = model.intercept_[0]
x_points = range(0, 25)
y_points = [-(w[0] * x + b) / w[1] for x in x_points]
plt.plot(x_points, y_points, color='black', linestyle='--', label='Граница решений')
plt.xlabel('Частота посещений (раз в месяц)')
plt.ylabel('Средний чек')
plt.title('Классификация клиентов методом SVM')
plt.legend()
plt.grid(True)
plt.show()
```

Объяснение кода:
1. Создание данных — мы задали данные о клиентах: сколько раз они посещают сайт и
сколько тратят в среднем.
2. Классификация — используем метод опорных векторов с линейным ядром для
построения разделяющей границы между активными и редкими покупателями.
3. Прогноз для нового клиента — проверяем, к какой категории отнесёт модель клиента,
который посещает сайт 10 раз в месяц и тратит 60 у.е.
4. Визуализация — строим график с данными клиентов, отображаем границу решений и
показываем расположение нового клиента на графике.
На графике будет видна граница, разделяющая клиентов, и точка, обозначающая
нового покупателя. Если он окажется по сторону активных клиентов, можно предложить
ему персональные предложения для повышения лояльности.
Метод опорных векторов особенно хорошо работает в ситуациях, где нужно
провести чёткую границу между классами. Он устойчив к выбросам и эффективен при
работе с высокоразмерными данными. Однако у него есть и свои недостатки — например,
высокая вычислительная сложность при больших объёмах данных и необходимость
тщательного подбора параметров.
Тем не менее, SVM остаётся одним из ключевых инструментов для задач
классификации, особенно там, где важно минимизировать ошибки и получить точную
границу между классами.
Деревья решений и случайный лес
Дерево решений — это модель, которая помогает принимать решения, двигаясь от
общего к частному. Представьте игру "20 вопросов", где вы шаг за шагом уточняете
детали, чтобы угадать задуманное слово. Примерно так работает и дерево решений: оно
задает вопросы об объектах и, на основе ответов, двигается к конкретному выводу.
Пример. Предположим, нам нужно решить, пойдет ли человек гулять:
1. На улице дождь?
- Да → Остается дома.
- Нет → Переходим к следующему вопросу.

2. Температура выше 15°C?
- Да → Идет гулять.
- Нет → Сидит дома.
Такое дерево помогает автоматизировать простые решения.
Сильные стороны:
- Понятность (можно "прочитать" логику модели).
- Быстрое принятие решений.
Недостатки:
- Склонно к переобучению (слишком точно "запоминает" данные и теряет гибкость).
- Не всегда хорошо работает с шумными данными.
Случайный лес: команда умных деревьев
Если дерево решений — это один эксперт, то случайный лес — группа экспертов,
которые голосуют за результат.
Как это работает:
1. Создаем много разных деревьев решений.
2. Каждое дерево обучается на случайной части данных и использует случайные признаки.
3. Когда нужно принять решение, все деревья "голосуют", и выбирается наиболее
популярный ответ.
Пример: Допустим, мы хотим предсказать, понравится ли человеку новый фильм.
- Первое дерево оценивает жанр фильма.
- Второе — учитывает возраст зрителя.
- Третье — смотрит на популярность фильма.
Каждое дерево выдает свой вердикт, а финальное решение принимается на основе
большинства голосов.
Сильные стороны:
- Высокая точность (меньше шансов ошибиться).
- Устойчивость к переобучению (мнение толпы обычно точнее, чем мнение одного
эксперта).
Недостатки:
- Сложнее интерпретировать (трудно понять, почему лес принял то или иное решение).
- Более ресурсоемкий (нужно больше памяти и времени на обучение).
Когда использовать?
- Дерево решений — когда важна простота и интерпретируемость (например, в медицине
для объяснения диагноза пациенту).
- Случайный лес — когда нужна точность и стабильность (например, для предсказания
биржевых цен или кредитного скоринга).
Задача: Предскажем, купит ли клиент товар, основываясь на возрасте и доходе.
Данные:

Решение на Python
1. Используем дерево решений
2. Применим случайный лес для сравнения

fi

fi

import pandas as pd
from sklearn.tree import DecisionTreeClassi er, plot_tree
from sklearn.ensemble import RandomForestClassi er
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
# Данные
data = {
'Возраст': [25, 30, 35, 40, 45, 50, 55],
'Доход': [50000, 60000, 65000, 70000, 80000, 90000, 85000],
'Купил': ['Нет', 'Нет', 'Да', 'Да', 'Да', 'Нет', 'Нет']
}
# Создаем DataFrame
df = pd.DataFrame(data)
# Подготовка данных
X = df[['Возраст', 'Доход']] # признаки
y = df['Купил'].map({'Нет': 0, 'Да': 1}) # метки (0 = Нет, 1 = Да)
# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

fi

fi

# 1. Дерево решений
tree_model = DecisionTreeClassi er(random_state=42)
tree_model. t(X_train, y_train)
tree_pred = tree_model.predict(X_test)
tree_acc = accuracy_score(y_test, tree_pred)
print(f' Точность дерева решений: {tree_acc * 100:.2f}%')

fi

fi

# 2. Случайный лес
forest_model = RandomForestClassi er(n_estimators=100, random_state=42)
forest_model. t(X_train, y_train)
forest_pred = forest_model.predict(X_test)
forest_acc = accuracy_score(y_test, forest_pred)
print(f' Точность случайного леса: {forest_acc * 100:.2f}%')
# Прогноз для нового клиента

new_client = pd.DataFrame({'Возраст': [38], 'Доход': [72000]})
tree_decision = tree_model.predict(new_client)
forest_decision = forest_model.predict(new_client)
print(f" Дерево решений: {'Купит' if tree_decision[0] == 1 else 'Не купит'}")
print(f" Случайный лес: {'Купит' if forest_decision[0] == 1 else 'Не купит'}")

fi

fi

fi

# Визуализация дерева решений
plt. gure( gsize=(12, 8))
plot_tree(tree_model, lled=True, feature_names=['Возраст', 'Доход'], class_names=['Не купит',
'Купит'], rounded=True, fontsize=12)
plt.title("Дерево решений")
plt.show()
```

Объяснение кода:
1. Создаем данные и конвертируем ответы в числа (0 — "Нет", 1 — "Да").
2. Делим данные на обучающую и тестовую выборки.
3. Обучаем две модели:
- Дерево решений
- Случайный лес
4. Сравниваем точность моделей.
5. Делаем прогноз для нового клиента (38 лет, доход — 72 000).
Ожидаемый результат:
```
Точность дерева решений: 100.00%
Точность случайного леса: 100.00%
Дерево решений: Купит
Случайный лес: Купит
```
Вывод:
- Дерево решений отлично подходит для простых задач.
- Случайный лес показывает стабильные результаты и лучше справляется с
непредсказуемыми данными.
Деревья решений — это про ясные и простые решения, а случайный лес — про
точность и надежность. Если одно дерево может ошибиться, лес почти всегда найдет
верный путь.

Классификация с помощью k-ближайших соседей (KNN)
Алгоритм K-ближайших соседей (KNN) — это один из самых простых и интуитивно
понятных методов классификации в машинном обучении. В основе метода лежит принцип
"подобное к подобному". То есть, объект классифицируется на основе того, к какому
классу принадлежат его ближайшие соседи.
Как работает KNN?
Представьте, что у вас есть набор объектов (точек), которые имеют различные
характеристики. Например, у нас есть два признака (через оси x и y):
1. Цвет: красный, синий, зеленый
2. Форма: круглый, квадратный
Когда вы получаете новый объект, вам нужно понять, к какому из существующих
классов он относится. Алгоритм делает это путем "поиска ближайших соседей" среди уже
имеющихся объектов, сравнивая их характеристики.
Шаги алгоритма KNN:
1. Задать значение K — количество ближайших соседей, которые будут учитывать при
классификации.
2. Вычислить расстояние между новым объектом и всеми остальными. На практике чаще
всего используется евклидово расстояние (просто разница между точками).
3. Выбрать K ближайших соседей — те объекты, которые находятся ближе всего к новому.
4. Классификация — новый объект относится к тому классу, который наиболее часто
встречается среди этих K соседей.
Пример: Предположим, у нас есть набор данных о фруктах.
Мы знаем, что:
- Яблоки: красные, круглый, вес 200 г.
- Апельсины: оранжевые, круглые, вес 250 г.
- Бананы: желтые, длинные, вес 150 г.
Теперь, представьте, что нам нужно классифицировать новый фрукт:
- Цвет: красный
- Форма: круглый
- Вес: 180 г
Мы берем 3 ближайших соседа (K=3) и смотрим, к какому классу они принадлежат.
Допустим, два из них — яблоки, а один — банан. Следовательно, новый фрукт будет
классифицирован как яблоко.
Особенности KNN:
- Простота: алгоритм интуитивно понятен и легко объясним.
- Не требует обучения: KNN не обучается заранее. Вместо этого он классифицирует объект
"на лету", при запросе.
- Чувствительность к выбору K: чем больше K, тем меньше вероятность ошибок, но при
слишком большом значении K модель может стать слишком общей и потерять точность.
- Зависимость от расстояний: если данные имеют разные масштабы (например, один
признак измеряется в метрах, а другой в килограммах), это может привести к
неправильным результатам.
Пример с кодом на Python:
Допустим, у нас есть набор данных о цветах и весах фруктов, и мы хотим
классифицировать новый фрукт с помощью алгоритма KNN.
```python
import pandas as pd

fi

import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassi er
# Данные: признаки (цвет и вес), метки (класс фрукта)
data = {
'Цвет': ['красный', 'красный', 'оранжевый', 'желтый', 'оранжевый'],
'Вес': [200, 220, 250, 150, 240],
'Класс': ['яблоко', 'яблоко', 'апельсин', 'банан', 'апельсин']
}
# Преобразуем текстовые данные в числовые для KNN (например, цвет: красный = 1,
оранжевый = 2)
color_map = {'красный': 1, 'оранжевый': 2, 'желтый': 3}
df = pd.DataFrame(data)
df['Цвет'] = df['Цвет'].map(color_map)
# Разделим данные на признаки (X) и метки (y)
X = df[['Цвет', 'Вес']] # Признаки
y = df['Класс'] # Метки

fi

# Создадим модель KNN с K=3
knn = KNeighborsClassi er(n_neighbors=3)

fi

# Обучим модель
knn. t(X, y)
# Прогноз для нового фрукта (красный, вес 180)
new_fruit = [[1, 180]] # Преобразуем цвет в число (красный = 1)
prediction = knn.predict(new_fruit)
print(f"Прогноз: {prediction[0]}")

fi

fi

# Визуализация
plt. gure( gsize=(8, 6))
# Точки для разных классов
plt.scatter(df[df['Класс'] == 'яблоко']['Цвет'], df[df['Класс'] == 'яблоко']['Вес'], color='red',
label='Яблоко', s=100)
plt.scatter(df[df['Класс'] == 'апельсин']['Цвет'], df[df['Класс'] == 'апельсин']['Вес'],
color='orange', label='Апельсин', s=100)
plt.scatter(df[df['Класс'] == 'банан']['Цвет'], df[df['Класс'] == 'банан']['Вес'], color='yellow',
label='Банан', s=100)
# Новый фрукт (красный, вес 180)
plt.scatter(new_fruit[0][0], new_fruit[0][1], color='green', label='Новый фрукт (прогноз)', s=200,
marker='X')
# Настройка графика
plt.title('Классификация фруктов с помощью KNN')
plt.xlabel('Цвет (красный = 1, оранжевый = 2, желтый = 3)')
plt.ylabel('Вес')
plt.legend()
plt.grid(True)
# Отображение графика
plt.show()

fi

Объяснение кода:
1. Подготовка данных: мы преобразуем текстовые значения в числовые (красный = 1,
оранжевый = 2 и т.д.), чтобы KNN мог работать с ними.
2. Обучение модели: используем `KNeighborsClassi er` с параметром `n_neighbors=3` (то
есть мы будем смотреть на 3 ближайших соседа).
3. Прогноз: модель предсказывает, к какому классу (яблоко, апельсин, банан) относится
новый фрукт.
Результат: Прогноз: яблоко
В этом примере новый фрукт (красный, вес 180) классифицируется как яблоко,
потому что два из трех ближайших соседей — яблоки.
Алгоритм K-ближайших соседей — это мощный инструмент для классификации,
который основан на простом и понятном принципе. Он хорош для небольших и средних
наборов данных, но может быть менее эффективен на больших объемах данных, где могут
возникать проблемы с производительностью.
Оценка качества классификации
Оценка качества классификации — это важный этап в анализе работы модели
машинного обучения. Когда мы применяем алгоритмы классификации, важно не только
получить прогнозы, но и понять, насколько эти прогнозы точны и насколько модель
эффективна в решении поставленной задачи. Чтобы правильно оценить качество
классификации, существует несколько метрик, которые позволяют количественно
измерить производительность модели.
Возьмем для примера задачу классификации фруктов. Допустим, мы строим
модель, которая должна классифицировать, является ли фрукт яблоком, апельсином или
бананом на основе его признаков, например, цвета и веса. После того как мы обучили
модель, она будет предсказывать класс для каждого фрукта в тестовом наборе данных.
Однако важно понимать, как часто модель ошибается, и какие именно ошибки она
совершает. Вот тут в игру вступают метрики качества.
Представим, что после того, как модель предсказала классы для тестовых данных,
мы получаем такую таблицу:

В этой таблице указаны реальные классы и предсказания модели. Мы видим, что
модель правильно предсказала яблоки и апельсины, но ошиблась в случае банана,
предсказав его как яблоко. Теперь давайте обсудим, как можно оценить качество
классификации, используя различные метрики.
Точность (Accuracy)
Точность — это самая простая и часто используемая метрика. Она измеряет, какую
долю правильных предсказаний сделала модель. Формула для точности следующая:

В нашем примере, модель правильно предсказала 5 из 7 фруктов. То есть точность
будет: Точность = 5/7
Точность дает общее представление о том, насколько хорошо модель работает.
Однако, она может быть не очень информативной, если данные сильно несбалансированы,
например, когда один класс встречается гораздо чаще других.
Полнота (Recall)
Полнота измеряет, насколько хорошо модель может обнаружить все объекты
определенного класса. Если наша модель плохо распознает какой-либо класс, например,
не может найти все бананы, то полнота будет низкой. Полнота для каждого класса
вычисляется как отношение правильно предсказанных объектов этого класса к общему
числу объектов этого класса.
Предположим, что у нас в тестовых данных есть 3 банана. Модель правильно
классифицировала 2 из них, а один — ошибочно как яблоко. Полнота для бананов будет:

Полнота помогает понять, как хорошо модель справляется с обнаружением
объектов определенного класса.
Точность (Precision)
Точность измеряет, насколько правильно модель классифицирует объекты в
определенный класс, если она говорит, что объект принадлежит этому классу. Это
отношение правильно предсказанных объектов данного класса к общему числу объектов,
которые модель отнесла к этому классу.
Допустим, модель предсказала 3 объекта как яблоки, но из них только 2
действительно были яблоками. Точность для яблок будет:

Точность важна, когда мы хотим избежать ложных срабатываний, то есть случаев,
когда модель ошибочно классифицирует объект как принадлежащий к определенному
классу.
F1-меры
F1-меры — это гармоническое среднее между точностью и полнотой, которое
помогает сбалансировать эти две метрики. F1-меры важны, когда нужно учитывать как
точность, так и полноту одновременно. Формула для вычисления F1-меры:

F1-меры полезны, когда есть необходимость сбалансировать ошибки между
точностью и полнотой. Например, если модель слишком предвзята и классифицирует все
как яблоки (что дает высокую точность, но низкую полноту для других классов), F1-меры
будут показывать плохие результаты, что поможет скорректировать модель.
Матрица ошибок (confusion matrix) — это таблица, которая показывает, сколько
объектов были правильно или ошибочно классифицированы для каждого класса. Она
позволяет увидеть не только количество верных предсказаний, но и типы ошибок. В нашем
примере матрица ошибок может выглядеть так:

Из этой матрицы мы можем легко увидеть, что модель ошибается с бананами,
предсказывая их как яблоки. Такая информация полезна для дальнейшего улучшения
модели.
Пример оценки качества на Python:
Для того чтобы продемонстрировать, как можно вычислять метрики оценки
качества классификации, используем Python и библиотеку `scikit-learn`. Вот пример:
```python
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score,
confusion_matrix
# Реальные классы и предсказания модели
y_true = ['яблоко', 'апельсин', 'банан', 'яблоко', 'банан', 'апельсин', 'апельсин']
y_pred = ['яблоко', 'апельсин', 'яблоко', 'яблоко', 'банан', 'банан', 'апельсин']
# Оценка качества классификации
accuracy = accuracy_score(y_true, y_pred)
precision = precision_score(y_true, y_pred, average='weighted', labels=['яблоко', 'апельсин',
'банан'])
recall = recall_score(y_true, y_pred, average='weighted', labels=['яблоко', 'апельсин', 'банан'])
f1 = f1_score(y_true, y_pred, average='weighted', labels=['яблоко', 'апельсин', 'банан'])
conf_matrix = confusion_matrix(y_true, y_pred, labels=['яблоко', 'апельсин', 'банан'])

print(f"Точность: {accuracy}")
print(f"Точность (Precision): {precision}")
print(f"Полнота (Recall): {recall}")
print(f"F1-меры: {f1}")
print(f"Матрица ошибок:\n{conf_matrix}")
```
Результат:

Оценка качества классификации — это многогранный процесс, включающий в себя
не только измерение общей точности, но и глубокий анализ ошибок модели, таких как
ложные положительные и ложные отрицательные предсказания. Для этого используются
такие метрики, как точность, полнота, F1-меры и матрица ошибок. Важно выбирать
метрики в зависимости от задач и особенностей данных, чтобы наилучшим образом
оценить модель и улучшить её при необходимости.
Глава 6: Алгоритмы регрессии
- Линейная регрессия
- Регрессия с регуляризацией (Lasso, Ridge)
- Оценка качества регрессии
Регрессия — один из ключевых инструментов машинного обучения, позволяющий
выявлять зависимости между переменными и делать предсказания на основе известных
данных. Этот метод находит широкое применение в самых разных областях: от
прогнозирования цен на недвижимость и анализа финансовых рынков до медицинских
исследований и инженерных расчётов.
Основная цель регрессионного анализа — построить модель, которая сможет
предсказывать численные значения с максимальной точностью. В отличие от задач
классификации, где необходимо отнести объект к определённой категории, регрессия
работает с непрерывными данными, определяя, насколько сильно одна переменная
зависит от другой.
Эта глава погружает в основы алгоритмов регрессии и рассматривает их
практическое применение. Вы узнаете, как строить простые модели для прогнозирования,
как избежать переобучения с помощью методов регуляризации и как оценивать качество
построенных моделей.
Линейная регрессия
Линейная регрессия — это один из самых простых и понятных методов машинного
обучения, который используется для предсказания численных значений. Она помогает
установить зависимость между одной или несколькими переменными и результатом.
Проще говоря, линейная регрессия отвечает на вопрос: **"Как изменяется результат, если
изменить входные данные?"**

Как это работает?
Представьте, что вы хотите предсказать цену подержанного автомобиля в
зависимости от его возраста. Чем старее машина, тем дешевле она стоит. Если нанести
точки с данными на график (где по одной оси — возраст машины, а по другой — цена), они
образуют облако точек. Линейная регрессия рисует прямую линию, которая как можно
точнее проходит через эти точки.
Идея проста:
- Если точка выше линии — машина стоит дороже ожидаемого.
- Если точка ниже — дешевле, чем предполагалось.
- Линия показывает общую тенденцию: чем старше машина, тем ниже её цена.
Пример. Допустим, у нас есть данные о машинах:

На основе этих данных мы можем построить модель линейной регрессии, чтобы
предсказать цену другой машины. Например, если у вас есть автомобиль 2017 года с
пробегом 40,000 км, модель рассчитает его примерную стоимость.
Рассмотрим пример кода для задачи линейной регрессии с визуализацией
зависимости между характеристиками автомобиля и его ценой:
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# Пример данных об автомобилях
data = {
"Год_выпуска": [2015, 2018, 2020, 2010, 2012],
"Пробег": [50000, 30000, 10000, 150000, 120000],
"Цена": [1200, 1800, 2500, 800, 1000] # Цена в тыс. руб.
}
df = pd.DataFrame(data)
# Преобразуем год выпуска в возраст машины
df["Возраст"] = 2024 - df["Год_выпуска"]
# Определяем признаки и целевую переменную
X = df[["Возраст", "Пробег"]]
y = df["Цена"]
# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Создаем и обучаем модель линейной регрессии

fi

model = LinearRegression()
model. t(X_train, y_train)
# Предсказания для тестовой выборки
y_pred = model.predict(X_test)
# Оценка качества модели
mse = mean_squared_error(y_test, y_pred)
print(f"Среднеквадратичная ошибка: {mse:.2f}")
# Пример предсказания для нового автомобиля
новый_автомобиль = pd.DataFrame({"Возраст": [2024 - 2017], "Пробег": [40000]})
предсказанная_цена = model.predict(новый_автомобиль)
print(f"Предсказанная цена для нового автомобиля: {предсказанная_цена[0]:.2f} тыс. руб.")
# ------------------ ВИЗУАЛИЗАЦИЯ ------------------

fi

fi

# 1⃣ График зависимости цены от возраста автомобиля
plt. gure( gsize=(10, 5))
plt.scatter(df["Возраст"], df["Цена"], color='blue', label='Исходные данные')
plt.plot(df["Возраст"], model.predict(df[["Возраст", "Пробег"]]), color='red', label='Линия
регрессии')
plt.xlabel("Возраст автомобиля (лет)")
plt.ylabel("Цена (тыс. руб.)")
plt.title("Зависимость цены от возраста автомобиля")
plt.legend()
plt.show()

fi

fi

# 2⃣ График зависимости цены от пробега
plt. gure( gsize=(10, 5))
plt.scatter(df["Пробег"], df["Цена"], color='green', label='Исходные данные')
plt.xlabel("Пробег (км)")
plt.ylabel("Цена (тыс. руб.)")
plt.title("Зависимость цены от пробега автомобиля")
plt.legend()
plt.show()
```

Что делает этот код:
1. Преобразует данные:
- Год выпуска → возраст машины (удобнее для анализа).
2. Строит модель линейной регрессии для предсказания цены автомобиля.
3. Оценивает качество модели с помощью среднеквадратичной ошибки.
4. Визуализирует зависимости:
- График 1: Цена vs. Возраст
- График 2: Цена vs. Пробег
5. Делает прогноз для новой машины (например, 2017 года с пробегом 40,000 км).
Как читать графики:
- Красная линия на графике показывает тренд: как цена изменяется с возрастом.
- Точки — реальные данные.
- Если точка далеко от линии, модель не идеально предсказывает цену для этого
автомобиля.
Этот пример показывает, как линейная регрессия помогает находить тенденции и
предсказывать стоимость в зависимости от возраста и пробега.
Линейная регрессия находит широкое применение в самых разных сферах. В
бизнесе она используется для прогнозирования продаж, прибыли и спроса на товары,
помогая компаниям принимать обоснованные решения и планировать стратегию развития.
В сфере недвижимости линейная регрессия позволяет оценить стоимость жилья, учитывая
такие параметры, как площадь, расположение и состояние недвижимости. Экономисты
применяют этот метод для анализа влияния макроэкономических факторов, например,
инфляции или уровня безработицы, на рыночные цены и динамику финансовых
показателей. В медицине линейная регрессия используется для оценки риска заболеваний
на основе возраста, образа жизни, генетики и других факторов, что помогает в ранней
диагностике и планировании лечения.
Плюсы:
- Простота реализации и понимания.
- Работает хорошо для задач с чёткими зависимостями между переменными.
Минусы:
- Плохо справляется с данными, где зависимости сложные или нелинейные.
- Чувствительна к выбросам — отдельные экстремальные значения могут сильно изменить
результат.
Линейная регрессия — отличный инструмент для начала работы с машинным
обучением. Она проста в реализации и помогает понять, как работает процесс

прогнозирования. Хотя её возможности ограничены в сложных задачах, она остаётся
базовой техникой, которая часто используется как отправная точка перед применением
более сложных методов.
Регрессия с регуляризацией: Lasso и Ridge
Иногда при построении модели линейной регрессии возникают проблемы с её
качеством. Например, модель может хорошо работать на обучающих данных, но плохо
справляться с новыми, что называется переобучением. Это происходит, когда модель
слишком сильно подстраивается под детали обучающего набора, включая шум и
случайные отклонения, вместо того чтобы выявлять общие закономерности.
Регуляризация — это метод улучшения устойчивости модели и предотвращения
переобучения. Она помогает "наказать" модель за слишком сложные зависимости и
заставляет её выбирать более простые решения.
Зачем нужна регуляризация?
Представьте, что вы строите прогноз цен на квартиры. У вас есть множество
факторов: площадь, этаж, район, наличие балкона, возраст здания, расстояние до метро,
вид из окна и даже цвет стен. Некоторые признаки оказывают сильное влияние на цену, а
некоторые — почти никакого. Без регуляризации модель может "цепляться" за
малозначимые детали и делать неверные прогнозы.
Регуляризация помогает выделить действительно важные признаки и "ослабить"
или исключить незначимые.
Ridge-регрессия (L2-регуляризация)
Ridge-регрессия делает модель более устойчивой за счёт "сглаживания"
коэффициентов при признаках. Она не обнуляет их полностью, но уменьшает значение тех,
которые вносят слишком сильный вклад и могут вызывать переобучение.
Пример: Вы прогнозируете стоимость квартиры. Модель считает, что наличие лифта
повышает цену на 1 млн руб., но это слишком сильное влияние. Ridge уменьшит этот вес,
чтобы учесть лифт, но не переоценивать его роль.
Рассмотрим пример кода с использованием **Ridge-регрессии** для
прогнозирования стоимости квартиры, где визуализация покажет влияние признаков до и
после регуляризации:
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.model_selection import train_test_split
# Пример данных о квартирах
data = {
"Площадь": [50, 65, 40, 80, 55, 70, 60, 45],
"Этаж": [3, 5, 2, 7, 4, 6, 3, 1],
"Возраст_дома": [10, 20, 5, 15, 12, 18, 8, 3],
"Наличие_лифта": [1, 1, 0, 1, 0, 1, 0, 0], # 1 — есть лифт, 0 — нет
"Цена": [5500, 6200, 4800, 7500, 5900, 7100, 6000, 4700] # Цена в тыс. руб.
}
# Создание DataFrame
df = pd.DataFrame(data)
# Признаки и целевая переменная
X = df[["Площадь", "Этаж", "Возраст_дома", "Наличие_лифта"]]
y = df["Цена"]
# Делим данные на обучающую и тестовую выборки

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

fi

# Обучаем обычную линейную регрессию
lin_reg = LinearRegression()
lin_reg. t(X_train, y_train)

fi

# Обучаем Ridge-регрессию с регуляризацией
ridge_reg = Ridge(alpha=1000) # Чем больше alpha, тем сильнее "штраф"
ridge_reg. t(X_train, y_train)
# Сравнение коэффициентов признаков
coef_df = pd.DataFrame({
"Признак": X.columns,
"Линейная регрессия": lin_reg.coef_,
"Ridge-регрессия": ridge_reg.coef_
})
print(coef_df)
# ВИЗУАЛИЗАЦИЯ влияния признаков
x = np.arange(len(X.columns))
width = 0.35
fi

fi

g, ax = plt.subplots( gsize=(10, 6))
rects1 = ax.bar(x - width/2, coef_df["Линейная регрессия"], width, label='Линейная регрессия',
color='skyblue')
rects2 = ax.bar(x + width/2, coef_df["Ridge-регрессия"], width, label='Ridge-регрессия',
color='lightcoral')
ax.set_ylabel('Коэффициенты')
ax.set_title('Сравнение влияния признаков на цену квартиры')
ax.set_xticks(x)
ax.set_xticklabels(coef_df["Признак"])
ax.legend()

ff

# Добавляем значения на столбцы
for rect in rects1 + rects2:
height = rect.get_height()
ax.annotate(f'{height:.1f}',
xy=(rect.get_x() + rect.get_width() / 2, height),
xytext=(0, 5), # смещение текста вверх
textcoords="o set points",
ha='center', va='bottom')
plt.tight_layout()
plt.show()
```

Что делает этот код:
1. Создаёт простую выборку с характеристиками квартир, включая площадь, этаж, возраст
дома и наличие лифта.
2. Строит две модели:
- Обычную линейную регрессию
- Ridge-регрессию с регуляризацией
3. Сравнивает влияние признаков (коэффициенты) в обеих моделях.
4. Визуализирует разницу — вы увидите, как Ridge уменьшает "слишком сильное" влияние
признаков (например, наличие лифта).
Как читать график:
- Голубые столбцы — обычная линейная регрессия, где признак "Наличие лифта" может
иметь слишком большое влияние.
- Красные столбцы — Ridge-регрессия, которая "сглаживает" коэффициенты и уменьшает
риск переобучения.
Этот пример показывает, как регуляризация помогает модели не переоценивать
отдельные признаки и становится более устойчивой к случайным выбросам в данных.
Lasso-регрессия (L1-регуляризация)
Lasso-регрессия идёт дальше и может полностью "отключить" незначимые
признаки, установив их вес в ноль. Это делает модель проще и понятнее.
Пример: Если вы прогнозируете цену квартиры и добавили признак "цвет стен",
Lasso может определить, что он не влияет на итоговую стоимость, и полностью исключит
его из модели.
Рассмотрим пример кода с использованием Lasso-регрессии, где будет показано,
как модель может полностью исключить незначимый признак — например, "цвет стен" — и
визуализировать влияние признаков на стоимость квартиры:
```python
import pandas as pd

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso, LinearRegression
from sklearn.model_selection import train_test_split
# Пример данных о квартирах
data = {
"Площадь": [50, 65, 40, 80, 55, 70, 60, 45],
"Этаж": [3, 5, 2, 7, 4, 6, 3, 1],
"Возраст_дома": [10, 20, 5, 15, 12, 18, 8, 3],
"Наличие_лифта": [1, 1, 0, 1, 0, 1, 0, 0], # 1 — есть лифт, 0 — нет
"Цвет_стен": [0, 1, 0, 1, 0, 1, 0, 1], # 0 — стандартный, 1 — яркий цвет
"Цена": [5500, 6200, 4800, 7500, 5900, 7100, 6000, 4700] # Цена в тыс. руб.
}
# Создание DataFrame
df = pd.DataFrame(data)
# Признаки и целевая переменная
X = df[["Площадь", "Этаж", "Возраст_дома", "Наличие_лифта", "Цвет_стен"]]
y = df["Цена"]
# Делим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

fi

# Обучаем обычную линейную регрессию (для сравнения)
lin_reg = LinearRegression()
lin_reg. t(X_train, y_train)

fi

# Обучаем Lasso-регрессию с регуляризацией
lasso_reg = Lasso(alpha=500) # Чем больше alpha, тем сильнее "штраф"
lasso_reg. t(X_train, y_train)
# Сравнение коэффициентов признаков
coef_df = pd.DataFrame({
"Признак": X.columns,
"Линейная регрессия": lin_reg.coef_,
"Lasso-регрессия": lasso_reg.coef_
})
print(coef_df)
# ВИЗУАЛИЗАЦИЯ влияния признаков
x = np.arange(len(X.columns))
width = 0.35
fi

fi

g, ax = plt.subplots( gsize=(10, 6))
rects1 = ax.bar(x - width/2, coef_df["Линейная регрессия"], width, label='Линейная регрессия',
color='skyblue')
rects2 = ax.bar(x + width/2, coef_df["Lasso-регрессия"], width, label='Lasso-регрессия',
color='salmon')
ax.set_ylabel('Коэффициенты')
ax.set_title('Сравнение влияния признаков на цену квартиры')
ax.set_xticks(x)
ax.set_xticklabels(coef_df["Признак"])
ax.legend()
# Добавляем значения на столбцы
for rect in rects1 + rects2:

ff

height = rect.get_height()
ax.annotate(f'{height:.1f}',
xy=(rect.get_x() + rect.get_width() / 2, height),
xytext=(0, 5),
textcoords="o set points",
ha='center', va='bottom')
plt.axhline(0, color='gray', linestyle='--')
plt.tight_layout()
plt.show()
```

Что делает этот код:
1. Создаёт набор данных с реальными признаками (площадь, этаж и т.д.) и добавляет
"шумовой" признак — "Цвет стен", который не должен влиять на цену квартиры.
2. Обучает Lasso-регрессию с регуляризацией, которая способна обнулить незначимые
признаки.
3. Сравнивает веса признаков после обучения и показывает, какие из них модель сочла
важными.
4. Визуализирует результат, показывая, какие признаки влияют на стоимость, а какие —
исключены из расчёта.
Lasso-регрессия не просто уменьшает влияние неважных признаков, но может
полностью их обнулить, сделав модель проще и понятнее. Это особенно полезно, когда у
вас много признаков, и нужно автоматически выбрать только те, что действительно
влияют на результат.
Это полезно, когда у вас много признаков, и нужно понять, какие из них
действительно важны.
Когда использовать Ridge, а когда Lasso?
- Ridge подходит, когда все признаки имеют какое-то влияние, но их значения нужно
"сбалансировать".

- Lasso отлично работает, когда нужно "отсеять" лишние признаки и оставить только
ключевые.
Иногда используют комбинацию двух методов — ElasticNet, чтобы получить
преимущества обоих подходов.
Пример. Допустим, у вас есть данные о квартирах:

Если добавить лишние признаки вроде "цвет подъезда" или "номер квартиры",
модель без регуляризации может случайно посчитать их важными. Lasso исключит такие
бессмысленные признаки, а Ridge уменьшит их влияние.
Рассмотрим пример кода, который демонстрирует, как Lasso и Ridge регрессия
обрабатывают данные о квартирах и какие признаки могут быть исключены или
уменьшены с помощью регуляризации:
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso, Ridge
from sklearn.model_selection import train_test_split
# Пример данных о квартирах
data = {
"Площадь": [50, 65, 40, 80, 55],
"Этаж": [3, 5, 2, 7, 4],
"Возраст_дома": [10, 20, 5, 15, 12],
"Наличие_балкона": [1, 0, 1, 0, 1], # 1 — есть балкон, 0 — нет
"Цвет_подъезда": [1, 0, 1, 0, 0], # Лишний признак
"Номер_квартиры": [101, 202, 303, 404, 505], # Лишний признак
"Цена": [5500, 6200, 4800, 7500, 5900] # Цена в тыс. руб.
}
# Создание DataFrame
df = pd.DataFrame(data)
# Признаки и целевая переменная
X = df[["Площадь", "Этаж", "Возраст_дома", "Наличие_балкона", "Цвет_подъезда",
"Номер_квартиры"]]
y = df["Цена"]
# Делим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
# Обучаем Lasso и Ridge регрессии с регуляризацией
lasso_reg = Lasso(alpha=1.0) # Регуляризация с Lasso
ridge_reg = Ridge(alpha=1.0) # Регуляризация с Ridge

fi

fi

lasso_reg. t(X_train, y_train)
ridge_reg. t(X_train, y_train)

# Сравнение коэффициентов признаков
coef_df = pd.DataFrame({
"Признак": X.columns,
"Lasso-регрессия": lasso_reg.coef_,
"Ridge-регрессия": ridge_reg.coef_
})
print(coef_df)
# ВИЗУАЛИЗАЦИЯ влияния признаков
x = np.arange(len(X.columns))
width = 0.35
fi

fi

g, ax = plt.subplots( gsize=(10, 6))
rects1 = ax.bar(x - width/2, coef_df["Lasso-регрессия"], width, label='Lasso-регрессия',
color='skyblue')
rects2 = ax.bar(x + width/2, coef_df["Ridge-регрессия"], width, label='Ridge-регрессия',
color='salmon')
ax.set_ylabel('Коэффициенты')
ax.set_title('Сравнение влияния признаков на цену квартиры (Lasso vs Ridge)')
ax.set_xticks(x)
ax.set_xticklabels(coef_df["Признак"])
ax.legend()

ff

# Добавляем значения на столбцы
for rect in rects1 + rects2:
height = rect.get_height()
ax.annotate(f'{height:.1f}',
xy=(rect.get_x() + rect.get_width() / 2, height),
xytext=(0, 5),
textcoords="o set points",
ha='center', va='bottom')
plt.axhline(0, color='gray', linestyle='--')
plt.tight_layout()
plt.show()
```

Что делает этот код:
1. Создаёт данные о квартирах, включая лишние признаки ("Цвет подъезда" и "Номер
квартиры"), которые не должны влиять на цену.
2. Обучает Lasso-регрессию и Ridge-регрессию, которые используют регуляризацию для
улучшения модели.
3. Сравнивает коэффициенты признаков для обеих моделей и визуализирует их на одном
графике.
Как читать график:
Голубые столбцы — коэффициенты для Lasso-регрессии.
Красные столбцы — коэффициенты для Ridge-регрессии.
Признаки, такие как "Цвет подъезда" и "Номер квартиры", могут иметь коэффициенты
близкие к нулю в Lasso, что означает их исключение из модели.
В Ridge-регрессии коэффициенты для лишних признаков будут меньше, но не нулевые, что
показывает, что регуляризация просто уменьшила их влияние.
Результаты:
Lasso часто обнуляет незначительные признаки, такие как "Цвет подъезда" и "Номер
квартиры", эффективно исключая их из модели.
Ridge уменьшает влияние лишних признаков, но оставляет их в модели с меньшими
коэффициентами, чтобы учесть их, но без переоценки их значимости.
Регуляризация — это своего рода "фильтр", который защищает модель от
переусложнения и помогает фокусироваться на действительно важных признаках. Ridge
делает модель более устойчивой к шуму, а Lasso помогает упростить модель, исключив
малозначимые факторы. Эти методы широко применяются в задачах, где есть множество
переменных, и важно сохранить баланс между точностью модели и её простотой.
Оценка качества регрессии
После того как модель регрессии обучена и готова к использованию, возникает
логичный вопрос: насколько хорошо она работает? В отличие от классификации, где
достаточно просто подсчитать процент верно предсказанных классов, оценка регрессии

требует других подходов. Ведь в задачах регрессии модель предсказывает числовые
значения, и важно понять не только, насколько близки они к истинным, но и как
распределяются ошибки.
Представим себе простую ситуацию: мы предсказываем стоимость квартир на
основе их площади и расположения. Если наша модель предсказала стоимость квартиры в
5 миллионов рублей, когда она на самом деле стоит 5,2 миллиона, — это небольшая
погрешность. Но если модель ошибается на миллион — это уже серьёзная проблема.
Чтобы систематически измерять такие отклонения и сравнивать разные модели между
собой, используются метрики качества.
Ключевые метрики качества регрессии
Одной из самых простых и популярных метрик является среднеквадратичная
ошибка. Она показывает, насколько в среднем предсказания модели отклоняются от
реальных значений. Представьте, что у вас есть несколько точек на графике: реальные
значения и предсказанные моделью. Среднеквадратичная ошибка фактически измеряет
расстояние между этими точками, придавая больший вес крупным отклонениям. Это
значит, что если модель делает одну-две крупные ошибки, метрика резко вырастет. Такой
подход полезен, когда критично избегать значительных промахов.
Если же хочется смягчить влияние единичных крупных ошибок и получить более
"спокойную" оценку, используют среднюю абсолютную ошибку. В отличие от предыдущей
метрики, она просто берет модуль разницы между предсказанным и реальным значением
и усредняет его. Допустим, модель предсказала стоимость квартиры на 200 тысяч рублей
ниже реальной. Эта ошибка прибавляется к общему числу без учета её "квадратного" веса.
Такая метрика более устойчива к выбросам и позволяет понять средний масштаб ошибки.
Иногда важно не только знать, насколько сильно модель ошибается в абсолютных
значениях, но и понять, насколько она отклонилась в относительном смысле. Здесь
помогает средняя абсолютная процентная ошибка. Эта метрика измеряет процентное
отклонение предсказания от реального значения. Если для одной квартиры ошибка в 100
тысяч рублей — это всего 2% от её стоимости, а для другой — 10%, метрика учтет это.
Однако у неё есть слабое место: если в данных есть значения, близкие к нулю, процентные
ошибки могут становиться аномально высокими и искажать общую картину.
Особого внимания заслуживает коэффициент детерминации, известный как R². Это
одна из самых популярных метрик в статистике и машинном обучении. Она показывает,
какую долю дисперсии целевой переменной модель смогла объяснить. Проще говоря, если
R² равен 1, значит, модель идеально предсказывает все значения. Если R² равен 0, модель
бесполезна и предсказывает не лучше, чем простое среднее значение. Любопытно, что R²
может быть и отрицательным — это сигнал о том, что модель настолько плоха, что
среднее значение было бы лучшим предсказанием.
Пример оценки качества регрессии
Допустим, мы разработали модель для предсказания стоимости квартир на основе
площади и расположения. У нас есть реальные данные о ценах и предсказания модели для
пяти квартир:

1. Среднеквадратичная ошибка (MSE)
Эта метрика особенно чувствительна к большим отклонениям. Посмотрим, как она
работает на примере.
- Для квартир 1, 2, 3 и 5 отклонения невелики — от 50 до 200 тысяч рублей.
- Однако для квартиры 4 модель ошиблась на 1,2 миллиона рублей, что значительно
увеличивает значение MSE.
Такое "штрафование" крупных ошибок важно в задачах, где критичны большие
отклонения — например, при оценке стоимости недвижимости для банков или страховых
компаний.
2. Средняя абсолютная ошибка (MAE)
Если мы используем эту метрику, ошибка для квартиры 4 будет учтена, но не
"усугублена", как это было с MSE. MAE просто суммирует абсолютные значения ошибок и
делит их на количество наблюдений.
В нашем примере она покажет среднюю ошибку по всем квартирам в рублях, давая
более сбалансированное представление о качестве модели. MAE часто используют там,
где важен общий масштаб ошибки без акцента на выбросах.
3. Средняя абсолютная процентная ошибка (MAPE)
Теперь представим, что мы хотим оценить ошибки в процентах от реальной
стоимости квартиры. Предсказание на 500 тысяч рублей ниже реальной цены — это
значительная ошибка для недорогого жилья, но не столь критичная для элитной
недвижимости.
В нашем примере: Ошибка в 100 тысяч рублей для квартиры за 5 миллионов — это
всего 2%. Но такая же ошибка для квартиры за 1 миллион дала бы 10%, что куда
серьезнее.
MAPE помогает понять, насколько предсказания модели отклоняются в
относительном выражении, что особенно полезно в задачах с большим разбросом цен.
4. Коэффициент детерминации (R²)
Представим, что модель показала R² = 0,85. Это означает, что 85% вариативности
цен квартир объясняется факторами, которые учла модель, а оставшиеся 15% — это
случайные отклонения или нерелевантные данные.
Если бы R² оказался равен 0, это означало бы, что модель предсказывает не лучше,
чем простое среднее значение цен. А отрицательный R² сигнализировал бы о
катастрофической неудаче модели — в этом случае лучше вообще не использовать её на
практике.
Выбирая метрику для оценки регрессии, важно учитывать контекст задачи. Если
критичны крупные отклонения — используйте MSE. Если нужно получить среднюю
погрешность в деньгах — MAE. Если важен процент ошибки — MAPE. А для оценки общей
объяснительной силы модели — R².
В реальной практике часто используют несколько метрик одновременно, чтобы
получить более полную картину о работе модели и избежать ловушек одной-единственной
метрики.
Выбор подходящей метрики
Выбор метрики для оценки качества регрессионной модели — это не просто
техническое решение, а стратегический шаг, который напрямую влияет на интерпретацию
результатов и последующие действия. Универсальной метрики, идеально подходящей для
всех задач, не существует. Каждый тип данных, каждая специфика бизнеса или научного
исследования диктует свои правила.
Рассмотрим ситуацию, когда необходимо предсказать стоимость недвижимости.
Здесь ошибка в несколько сотен тысяч рублей может быть критичной, особенно если речь
идёт о недорогих объектах. Представьте себе квартиру стоимостью 3 миллиона рублей —
ошибка даже в 300 тысяч составит 10% от цены, что весьма ощутимо. В таком случае
важно минимизировать крупные отклонения, и поэтому чаще всего используют
среднеквадратичную ошибку. Эта метрика усиливает влияние больших ошибок за счёт их
возведения в квадрат, заставляя модель "бояться" крупных промахов и стараться избегать
их любой ценой.

Но теперь перенесёмся в другой контекст — магазин розничной торговли, где
необходимо спрогнозировать ежедневные продажи товаров. В такой задаче важен не
каждый конкретный день, а общий тренд. Здесь небольшие отклонения от фактических
значений — это нормально, если они не искажают общую картину. В этом случае более
подходящей станет средняя абсолютная ошибка. Она взвешивает все ошибки одинаково,
не выделяя отдельные аномалии, и позволяет получить усреднённую оценку отклонений.
Это делает метрику более "спокойной" и устойчивой к небольшим выбросам.
Иногда сама природа данных требует особого подхода. Например, в задачах
прогнозирования доходов или прибыли компании часто используют процентные ошибки.
Если модель ошиблась на 1 миллион рублей, важно понимать, как это выглядит в
контексте бизнеса: если компания зарабатывает миллиарды, такая ошибка незначительна,
а если её месячный доход — всего 2 миллиона, промах критичен. В таких случаях на
помощь приходит средняя абсолютная процентная ошибка (MAPE), которая показывает
отклонение в относительных единицах, делая интерпретацию результатов более
интуитивной.
Однако есть и подводные камни. Некоторые метрики неравномерно реагируют на
выбросы. Среднеквадратичная ошибка, как уже говорилось, "раздувается" из-за
нескольких крупных промахов. Если в наборе данных присутствуют аномальные значения
— например, редкие люксовые квартиры с ценой в десятки миллионов — они могут сильно
исказить итоговую метрику. В таких случаях важно либо очищать данные от выбросов,
либо использовать метрики, менее чувствительные к ним, например, среднюю абсолютную
ошибку.
Иногда приходится искать баланс. В задачах медицинской диагностики, например,
важно одновременно учитывать как небольшие отклонения, так и крупные ошибки,
которые могут стоить пациенту здоровья. В таких сценариях специалисты часто
комбинируют метрики или применяют специализированные методы оценки.
Выбор метрики — это ещё и отражение бизнес-целей. Если ошибки высокой
стоимости критичны — стоит использовать метрики, которые их выделяют. Если же важен
общий тренд и стабильность — предпочтение отдают устойчивым к выбросам метрикам. И
всегда нужно помнить о здравом смысле: даже высокая точность по одной метрике не
гарантирует адекватной работы модели в реальных условиях. Именно поэтому на практике
принято оценивать модели сразу по нескольким метрикам, получая более глубокое
понимание их поведения и слабых сторон.
Ошибки при оценке качества
Ошибки при оценке качества регрессионных моделей — частая причина
некорректных выводов и неудачных решений на практике. Одна из самых
распространённых проблем возникает, когда модель оценивают исключительно на тех
данных, на которых она обучалась. На первый взгляд, результаты могут казаться
впечатляющими: минимальные ошибки, высокие значения R², и модель выглядит почти
идеальной. Однако это ложное чувство уверенности. Модель, проверенная только на
тренировочной выборке, просто "запомнила" данные и выучила все закономерности,
включая шум и случайные отклонения. Такая модель теряет способность обобщать знания
и плохо справляется с новыми, ранее не встречавшимися данными. Это классический
пример переобучения.
Чтобы избежать этой ловушки, необходимо оценивать модель на отложенной
выборке — данных, которые не использовались в процессе обучения. Это позволяет
увидеть, как модель ведёт себя в реальных условиях, когда сталкивается с новыми
примерами. Иногда для этого данные делят на несколько частей: одну для обучения,
другую для валидации, а третью — для финального тестирования. Такой подход помогает
обнаружить переобучение ещё до того, как модель будет применяться на практике.
Однако даже использование отложенной выборки не всегда спасает от ошибок в
оценке. Часто новички полагаются лишь на одну метрику, считая её универсальным
индикатором качества. Например, если среднеквадратичная ошибка (MSE) получилась
небольшой, можно предположить, что модель работает идеально. Но это не всегда так.
MSE, как известно, чувствительна к выбросам. Если в данных есть всего пара точек с
большими отклонениями, они могут резко увеличить метрику и создать впечатление, что
модель плоха, хотя на большинстве данных она работает стабильно.

С другой стороны, высокий коэффициент детерминации (R²) часто воспринимается
как гарантия успешной модели. Но R² показывает лишь, насколько хорошо модель
объясняет вариативность данных, а не точность предсказаний. Например, если модель
идеально улавливает общий тренд, но ошибается в конкретных значениях на большие
суммы, R² может быть высоким, несмотря на существенные погрешности в отдельных
точках. В таком случае полезно дополнительно рассмотреть метрики, которые измеряют
среднюю ошибку в абсолютных значениях, такие как MAE или MAPE.
Ещё одна скрытая угроза — несбалансированные данные. Если данные содержат
доминирующий класс или значения определённого диапазона встречаются гораздо чаще
других, метрики могут искажать общую картину. Например, если 90% квартир в выборке
стоят около 5 миллионов рублей, а оставшиеся 10% — элитное жильё за десятки
миллионов, модель может "игнорировать" дорогие квартиры и всё равно показывать
хорошие метрики на основной массе данных. В результате итоговая модель будет
бесполезной для оценки премиальной недвижимости. В таких случаях важно использовать
стратифицированные выборки или корректировать метрики с учётом веса разных классов.
Не стоит забывать и о данных с временной зависимостью. В задачах
прогнозирования продаж или анализа биржевых котировок обычное случайное разбиение
данных на тренировочную и тестовую выборки может нарушить хронологию и привести к
искажённым результатам. Здесь важно использовать временные срезы, чтобы модель
обучалась на прошлом и тестировалась на будущем, иначе оценка будет некорректной.
Также стоит учитывать бизнес-цели. Например, в медицине промах в одну сторону
может быть более опасным, чем в другую. Если модель недооценивает вероятность
заболевания, это грозит пропуском важного диагноза. В таких случаях обычные метрики
не отражают критичность ошибок, и приходится использовать кастомные функции потерь
или специализированные метрики.
В итоге правильная оценка качества модели требует комплексного подхода:
использование нескольких метрик, тестирование на независимых данных, учёт
особенностей задачи и структуры данных. Ошибки в этой части могут не просто исказить
представление о модели, но и привести к серьёзным последствиям в реальной практике —
от финансовых потерь до ошибок в критически важных системах.
Оценка качества регрессии — это не просто набор чисел. Это способ понять, как
модель "видит" данные и где она ошибается. Хорошая модель — это не всегда та, у
которой минимальная ошибка, а та, которая адекватно отражает структуру данных и
предсказуема в своем поведении. Используя правильные метрики и учитывая особенности
задачи, можно создавать модели, которые будут не только точными, но и надежными в
реальных условиях.
Глава 7: Методы ансамблей
- Принципы работы ансамблей моделей
- Случайный лес
- Бустинг и градиентный бусин
- XGBoost, LightGBM и CatBoost
Машинное обучение редко ограничивается одиночными моделями. В реальном мире
данные сложны, неоднородны и полны скрытых закономерностей, которые одна модель
может просто не уловить. Представьте себе группу экспертов, каждый из которых делает
своё предсказание на основе ограниченного объёма информации. По отдельности они
могут ошибаться, но если объединить их мнения, общий прогноз окажется значительно
точнее. Этот принцип лежит в основе ансамблевых методов.
Ансамбли — это способ повысить точность предсказаний, используя несколько
моделей одновременно. Вместо того чтобы полагаться на единственное решение,
алгоритмы комбинируют множество слабых моделей, превращая их в мощный инструмент
анализа. Такой подход позволяет уменьшить разброс предсказаний, снизить вероятность
ошибки и улучшить обобщающую способность. Если отдельная модель может
переобучиться на данных или упустить важные детали, ансамбль способен
компенсировать её слабые стороны.
Один из наиболее известных методов ансамблирования — случайный лес. Он
представляет собой коллекцию деревьев решений, каждое из которых учится на случайной

части данных и голосует за итоговый результат. Такой механизм делает предсказания
более устойчивыми и уменьшает влияние выбросов. Но иногда требуется ещё более
точный метод, способный адаптироваться к сложным зависимостям в данных. В таких
случаях используют бустинг, который обучает модели последовательно, исправляя ошибки
предыдущих предсказателей.
Современные реализации бустинга, такие как XGBoost, LightGBM и CatBoost, стали
стандартом в задачах предсказательного моделирования. Эти алгоритмы позволяют
строить быстрые, точные и мощные модели, которые применяются в финансах,
биоинформатике, анализе текстов и многих других областях. Они не просто повышают
точность, но и предлагают механизмы контроля за переобучением, оптимизации
вычислений и работы с различными типами данных.
Ансамбли изменили представление о возможностях машинного обучения, сделав
простые модели основой для сложных, но эффективных решений. Их применение
позволяет решать задачи, где стандартные алгоритмы оказываются бессильны, и
добиваться высокой точности даже в самых сложных условиях.
Принципы работы ансамблей моделей
Ансамблевые методы в машинном обучении основаны на простой, но мощной идее:
объединение нескольких моделей позволяет получить более точные и стабильные
предсказания, чем использование одной модели в одиночку. Это похоже на ситуацию,
когда для решения сложной задачи вы обращаетесь не к одному эксперту, а к группе
специалистов. Каждый из них может предложить свою точку зрения, и, объединив их
мнения, вы получаете более взвешенное и надёжное решение.
Основной принцип ансамблей заключается в том, что разные модели, обученные на
одной задаче, могут ошибаться по-разному. Одна модель может недооценивать значения в
определённых случаях, другая — переоценивать, и если их объединить, ошибки отдельных
моделей могут "сгладиться", что приведёт к более точному общему результату. Это
особенно полезно в задачах с высокими шумами или сложными зависимостями в данных.
Существует два ключевых подхода к созданию ансамблей: бэггинг и бустинг. Они
используют разные стратегии комбинирования моделей и работают по разным принципам.
Бэггинг (bagging) — это метод, при котором несколько одинаковых моделей
обучаются на разных подмножествах исходных данных. Каждое подмножество выбирается
случайным образом с возвращением, что означает, что одна и та же точка может попасть в
разные выборки несколько раз. После обучения каждая модель делает своё предсказание,
а итоговый результат формируется путём голосования (в задачах классификации) или
усреднения (в задачах регрессии). Классическим примером бэггинга является случайный
лес — ансамбль деревьев решений, каждое из которых обучается на случайной части
данных и использует случайный набор признаков для разделения на каждом узле дерева.
Такой подход уменьшает переобучение и делает итоговую модель более стабильной.
Для примера представьте себе задачу предсказания стоимости квартир. Если
обучить одно дерево решений, оно может переобучиться, слишком точно подстроившись
под данные и теряя способность к обобщению. Но если создать десятки деревьев, каждое
из которых видит немного разные данные и принимает решения по-своему, их усреднённое
предсказание окажется более точным и устойчивым к выбросам.
Пример кода на Python с использованием библиотеки `scikit-learn`, который
демонстрирует разницу между одиночным деревом решений и случайным лесом для
задачи предсказания стоимости квартир:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
# Создадим синтетический набор данных

X, y = make_regression(n_samples=500, n_features=5, noise=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Одиночное дерево решений
single_tree = DecisionTreeRegressor(random_state=42)
single_tree. t(X_train, y_train)
y_pred_tree = single_tree.predict(X_test)
mse_tree = mean_squared_error(y_test, y_pred_tree)

fi

# Случайный лес
random_forest = RandomForestRegressor(n_estimators=100, random_state=42)
random_forest. t(X_train, y_train)
y_pred_forest = random_forest.predict(X_test)
mse_forest = mean_squared_error(y_test, y_pred_forest)
# Сравнение результатов
print(f"Среднеквадратичная ошибка (Decision Tree): {mse_tree:.2f}")
print(f"Среднеквадратичная ошибка (Random Forest): {mse_forest:.2f}")

fi

fi

# Визуализация предсказаний
plt. gure( gsize=(10, 5))
plt.scatter(y_test, y_pred_tree, color='red', label='Decision Tree', alpha=0.6)
plt.scatter(y_test, y_pred_forest, color='green', label='Random Forest', alpha=0.6)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=2)
plt.xlabel('Реальная стоимость')
plt.ylabel('Предсказанная стоимость')
plt.title('Сравнение предсказаний: Decision Tree vs Random Forest')
plt.legend()
plt.show()
```

Как работает этот код?
1. Генерация данных: Используем синтетические данные для имитации задачи
предсказания стоимости квартир.

2. Одиночное дерево решений: Строим одно дерево и смотрим на результат. Оно склонно к
переобучению и может плохо обобщать данные.
3. Случайный лес: Строим ансамбль из 100 деревьев. За счёт усреднения предсказаний
уменьшается переобучение и повышается стабильность модели.
4. Оценка качества: Сравниваем среднеквадратичную ошибку (MSE) для одиночного
дерева и случайного леса.
5. Визуализация: На графике видно, как предсказания случайного леса ближе к реальным
значениям по сравнению с одиночным деревом.
Этот пример наглядно демонстрирует, как ансамбли могут улучшить качество
модели и сделать предсказания более устойчивыми.
Бустинг (boosting) работает по другому принципу. Здесь модели обучаются
последовательно: каждая новая модель пытается исправить ошибки предыдущей. Сначала
обучается простая модель, которая делает первые предсказания. Далее следующая
модель фокусируется именно на тех примерах, где первая ошиблась, пытаясь
минимизировать допущенные промахи. Этот процесс повторяется, и каждая новая модель
"усиливает" ансамбль, делая его всё более точным. В итоге ансамбль состоит из
множества слабых моделей (например, небольших деревьев решений), которые по
отдельности не дают выдающихся результатов, но в совокупности формируют мощную
систему.
Возьмём тот же пример с квартирами. Первая модель может предсказать
стоимость примерно, но ошибиться, например, в районах с нестандартными ценами.
Вторая модель "заметит" эти ошибки и сосредоточится именно на них. Третья модель — на
оставшихся недочётах. Постепенно ансамбль учится всё лучше справляться даже с
наиболее сложными случаями. Итоговое предсказание — это взвешенная сумма всех
индивидуальных предсказаний.
Пример кода на Python, демонстрирующий принцип бустинга с использованием
библиотеки `scikit-learn` и алгоритма Gradient Boosting Regressor для предсказания
стоимости квартир:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error
# Создадим синтетический набор данных для регрессии
X, y = make_regression(n_samples=500, n_features=5, noise=30, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Инициализируем градиентный бустинг
gbr = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3,
random_state=42)
gbr. t(X_train, y_train)
# Предсказания модели
y_pred = gbr.predict(X_test)
# Оценка качества модели
mse = mean_squared_error(y_test, y_pred)
print(f"Среднеквадратичная ошибка (Gradient Boosting): {mse:.2f}")

fi

fi

# Визуализация предсказаний
plt. gure( gsize=(10, 5))
plt.scatter(y_test, y_pred, color='blue', alpha=0.6, label='Gradient Boosting')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=2)

plt.xlabel('Реальная стоимость')
plt.ylabel('Предсказанная стоимость')
plt.title('Предсказание стоимости квартир с помощью Gradient Boosting')
plt.legend()
plt.show()
```

Как работает этот код?
1. Генерация данных: Создаём синтетический датасет, который имитирует задачу
предсказания стоимости квартир.
2. Градиентный бустинг: Модель строит 100 слабых деревьев решений. Каждое следующее
дерево сосредотачивается на ошибках предыдущих, постепенно улучшая точность
ансамбля.
- `n_estimators=100` — количество деревьев.
- `learning_rate=0.1` — шаг обновления (меньшее значение даёт более стабильную модель).
- `max_depth=3` — глубина деревьев, чтобы избежать переобучения.
3. Оценка модели: Используем метрику Среднеквадратичная ошибка (MSE) для оценки
качества предсказаний.
4. Визуализация: Строим график, чтобы увидеть, как предсказания модели соответствуют
реальным значениям. Чем ближе точки к диагонали — тем точнее модель.
Почему бустинг эффективен?
Каждое дерево в ансамбле исправляет ошибки предыдущих. Это позволяет модели
учиться на сложных и "проблемных" примерах. В итоге получается мощный инструмент,
способный улавливать сложные зависимости в данных и обеспечивать высокую точность
предсказаний.
Ансамблевые методы обладают важным свойством — они уменьшают
вариативность и смещение. Бэггинг помогает снизить вариативность модели, делая её
предсказания более стабильными. Бустинг, напротив, борется с смещением, шаг за шагом
улучшая точность и "подгоняя" модель к данным.
Но ансамбли — это не всегда гарантированный успех. Они могут стать сложными в
интерпретации и требуют больше вычислительных ресурсов. Однако в задачах, где
критична точность, ансамбли часто дают значительное преимущество. Они широко
используются в соревнованиях по машинному обучению, например, на платформе Kaggle,
где даже небольшое улучшение метрик может стать решающим.
В результате ансамблевые методы стали неотъемлемой частью практики машинного
обучения. Они позволяют строить устойчивые и точные модели, используя простые
алгоритмы в умной комбинации. Этот подход подчёркивает один из ключевых принципов

науки о данных: сила не всегда в сложности модели, а в умении правильно использовать
простые инструменты.
Случайный лес
Случайный лес — это один из самых популярных и мощных алгоритмов машинного
обучения. Он используется для классификации (например, распознавание спама) и
регрессии (например, прогнозирование цен на недвижимость). Алгоритм основан на
принципе ансамблевого обучения, где несколько простых моделей (деревьев решений)
работают вместе, чтобы дать более точный результат.
1. Что такое дерево решений?
Прежде чем понять случайный лес, нужно разобраться с деревом решений.
Пример: Представьте, что вам нужно определить, стоит ли человеку брать зонт, глядя на
погоду. Решение можно представить в виде дерева:
```

```

Идет дождь?
/
\
Да
Нет
/
\
Ветреная погода? Не бери зонт
/
\
Да
Нет
Бери зонт Не бери зонт

Как работает дерево?
- Начинаем с вопроса: "Идет дождь?"
- Если да — задаем следующий вопрос.
- Если нет — решение принято: "Не бери зонт."
Но! Одно дерево может быть нестабильным — небольшое изменение в данных
может полностью изменить дерево.
2. Как работает случайный лес?
Случайный лес решает проблему нестабильности деревьев.
Основная идея:
- Построить множество деревьев (например, 100).
- Каждое дерево обучается на случайной выборке из исходных данных.
- Для каждого дерева случайно выбирается подмножество признаков для принятия
решений.
В итоге:
Для классификации — деревья голосуют, и побеждает класс с большинством голосов.
Для регрессии — берется среднее значение предсказаний всех деревьев.
Пример: Вы хотите узнать, понравится ли человеку фильм. У вас есть данные о его
возрасте, любимом жанре, времени просмотра и рейтинге фильма.
- 100 деревьев дают свои предсказания.
- 70 деревьев "говорят": "Да, понравится."
- 30 — "Нет, не понравится."
Результат: Система предсказывает — "Понравится".
3. Почему случайный лес так хорош?
Случайный лес устойчив к переобучению: хотя отдельные деревья могут запомнить
данные и начать ошибаться на новых примерах, их комбинация позволяет сгладить эти

ошибки и получить более стабильный результат. Алгоритм хорошо работает с
пропущенными данными и не требует масштабирования признаков — нет необходимости
приводить все данные к одному масштабу или заполнять пустые значения сложными
методами. Кроме того, случайный лес универсален и подходит как для задач
классификации, так и для регрессии.
4. Когда использовать случайный лес?
Случайный лес широко применяется в разных сферах. В недвижимости он
используется для оценки стоимости объектов, прогнозируя цены на основе площади,
расположения и состояния жилья. В сфере электронной почты помогает фильтровать
спам, определяя, является ли письмо нежелательным. В медицине алгоритм применяется
для диагностики заболеваний на основе анализа симптомов. В сельском хозяйстве его
используют для прогнозирования урожайности, учитывая погодные условия и
характеристики почвы.
5. Недостатки случайного леса
Случайный лес, несмотря на свою эффективность и универсальность, имеет
определённые недостатки. Один из главных минусов — это медлительность при работе с
большими объемами данных. Поскольку алгоритм строит множество деревьев решений,
каждая из которых анализирует определённую часть данных, общий процесс становится
ресурсоёмким. Чем больше деревьев создаётся для повышения точности, тем больше
времени и вычислительных мощностей требуется для обучения модели и получения
предсказаний. Это особенно заметно при работе с большими наборами данных или при
необходимости быстрого анализа в режиме реального времени.
Ещё одна сложность связана с интерпретацией результатов. Если одно дерево
решений легко понять — его можно представить в виде логической схемы с простыми "да"
или "нет" на каждом этапе — то случайный лес представляет собой сложную комбинацию
множества деревьев. Это делает затруднительным понимание, почему алгоритм принял то
или иное решение. Для некоторых областей, например в медицине или правовых системах,
где требуется объяснимость модели, это может стать серьёзным недостатком. Хотя
существуют методы для анализа важности признаков и частичной интерпретации
результатов, полностью "распутать" логику случайного леса бывает непросто.
6. Разберем пример на Python
В приведённом примере демонстрируется применение алгоритма Случайный лес
для решения задачи классификации с использованием известного набора данных "Ирисы
Фишера" (Iris dataset). Цель задачи — научить модель автоматически определять вид
цветка ириса на основе его морфологических характеристик, таких как длина и ширина
чашелистиков и лепестков.
Пошаговое описание задачи:

fi

1. Загрузка набора данных: Используется встроенный в библиотеку `scikit-learn` набор
данных `Iris`, который содержит информацию о трёх видах ирисов: setosa, versicolor и
virginica. Каждый цветок описывается четырьмя признаками (длина и ширина чашелистика
и лепестка), а целевая переменная (`y`) указывает вид цветка.
2. Подготовка данных:
Данные разделяются на две части:
- Тренировочная выборка (70%) — для обучения модели.
- Тестовая выборка (30%) — для проверки точности модели на новых данных.
Это делается с помощью функции `train_test_split`, чтобы оценить способность модели к
обобщению.
3. Создание и обучение модели: Создаётся модель `RandomForestClassi er` с 100
деревьями решений. Алгоритм обучается на тренировочной выборке (`X_train` и `y_train`),
чтобы научиться распознавать зависимости между морфологическими признаками и
видом цветка.

4. Предсказание: После обучения модель использует тестовые данные (`X_test`), чтобы
предсказать вид ириса, основываясь только на признаках, которые она видела во время
обучения.
5. Оценка точности: Предсказанные моделью результаты сравниваются с реальными
метками из тестовой выборки (`y_test`). Метрика **accuracy** показывает долю правильных
предсказаний от общего числа примеров. Выводится итоговая точность модели в
процентах.
Этот пример показывает базовое использование случайного леса для
многоклассовой классификации. Набор данных об ирисах прост и часто используется для
демонстрации алгоритмов машинного обучения. Благодаря ансамблевой природе
случайного леса, модель, как правило, достигает высокой точности (обычно выше 90%),
что делает её надёжным инструментом даже в более сложных задачах.

fi

```python
from sklearn.ensemble import RandomForestClassi er
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Загружаем данные (цветы ириса)
data = load_iris()
X = data.data # признаки (длина лепестков, ширина и т.д.)
y = data.target # целевая переменная (вид цветка)
# Делим на тренировочные и тестовые данные
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

fi

fi

# Создаем модель случайного леса
model = RandomForestClassi er(n_estimators=100, random_state=42)
model. t(X_train, y_train) # Обучаем модель
# Делаем предсказания
y_pred = model.predict(X_test)
# Оцениваем точность
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy * 100:.2f}%")
```
Результат:
Скорее всего, точность будет выше 90% — вот почему случайный лес так популярен.
Случайный лес — это как совет из множества экспертов: каждый дает свое мнение,
а итоговое решение учитывает всех. Алгоритм прост в использовании, устойчив к ошибкам
и подходит для самых разных задач.
Бустинг и градиентный бусин
Бустинг — это метод ансамблевого обучения, который объединяет несколько
слабых моделей (обычно деревьев решений) для создания одной сильной модели.
Основная идея бустинга заключается в том, чтобы обучать модели последовательно, где
каждая новая модель старается исправить ошибки предыдущих. В отличие от случайного
леса, где деревья строятся независимо друг от друга, бустинг создает деревья
последовательно, и каждое новое дерево фокусируется на тех примерах, которые
предыдущие модели предсказали неверно.
Чтобы понять бустинг проще, представим следующую ситуацию. Допустим, вы
хотите научиться играть в шахматы. Сначала вы учитесь базовым правилам и играете
несколько партий, но часто проигрываете. После этого вы начинаете разбирать свои
ошибки — например, понимаете, что плохо защищаете короля. На следующей тренировке

вы фокусируетесь именно на этой слабой стороне и становитесь сильнее. С каждым
новым занятием вы исправляете слабые места, постепенно улучшая свои навыки. В
результате вы становитесь сильным игроком, не потому что сразу знали все, а потому что
последовательно устраняли ошибки.
Градиентный бустинг (Gradient Boosting) — это одна из самых популярных
реализаций бустинга. Его особенность в том, что каждая новая модель обучается на
ошибках предыдущей, используя градиентный спуск — метод оптимизации, который
помогает модели минимизировать общую ошибку. Однако не стоит пугаться сложных
терминов: главное — понимать суть процесса.
Представьте, что вы — садовник, который хочет вырастить идеальный сад. Сначала
вы сажаете деревья в случайном порядке. Потом вы замечаете, что некоторые растения
плохо растут из-за тени от больших деревьев. Вы корректируете расположение,
пересаживаете слабые растения туда, где больше света. Через время вы замечаете, что
где-то почва недостаточно плодородная, и добавляете удобрения. С каждым новым шагом
вы улучшаете сад, исправляя ошибки предыдущих этапов. В результате сад становится
ухоженным и гармоничным. Так же работает градиентный бустинг — шаг за шагом он
улучшает модель, уменьшая ошибки.
Пример: Допустим, вы работаете в банке и хотите предсказывать, кто из клиентов
скорее всего не вернёт кредит. Вы обучаете модель градиентного бустинга на данных о
клиентах: их доходах, кредитной истории, возрасте и других характеристиках. Первая
модель делает простое предположение, но ошибается на сложных случаях. Следующая
модель пытается сосредоточиться именно на этих сложных клиентах и сделать более
точные предсказания. С каждой итерацией общая точность модели растет, пока она не
начнёт предсказывать с высокой уверенностью.
Пример кода на Python с использованием библиотеки XGBoost для предсказания
вероятности невозврата кредита. В примере создаются искусственные данные о клиентах
и визуализируется результат классификации.

fi

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from xgboost import XGBClassi er
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
# Генерация искусственных данных
np.random.seed(42)
n_samples = 500
# Признаки: доход, возраст, количество кредитов
income = np.random.randint(20000, 120000, n_samples)
age = np.random.randint(18, 70, n_samples)
credit_count = np.random.randint(0, 5, n_samples)
# Целевая переменная: 1 — не вернул кредит, 0 — вернул
# Чем ниже доход и выше количество кредитов, тем выше риск
default_prob = (120000 - income) * 0.00001 + credit_count * 0.1 + (70 - age) * 0.001
default = np.random.binomial(1, default_prob.clip(0, 1))
# Создание DataFrame
data = pd.DataFrame({
'Income': income,
'Age': age,
'Credit_Count': credit_count,
'Default': default

})
# Разделение на признаки и целевую переменную
X = data[['Income', 'Age', 'Credit_Count']]
y = data['Default']
# Делим данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

fi

fi

# Создание и обучение модели XGBoost
model = XGBClassi er(use_label_encoder=False, eval_metric='logloss', random_state=42)
model. t(X_train, y_train)
# Предсказания
y_pred = model.predict(X_test)
# Оценка точности
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy * 100:.2f}%")
# Визуализация матрицы ошибок
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Вернул", "Не вернул"])
disp.plot(cmap='Blues')
plt.title("Матрица ошибок")
plt.show()

fi

fi

# Важность признаков
plt. gure( gsize=(8,5))
sns.barplot(x=model.feature_importances_, y=X.columns)
plt.title('Важность признаков для модели')
plt.xlabel('Значимость')
plt.show()

fi

fi

# Визуализация распределения клиентов
plt. gure( gsize=(10,6))
sns.scatterplot(data=data, x='Income', y='Age', hue='Default', palette={0:'green',1:'red'})
plt.title('Распределение клиентов по доходу и возрасту')
plt.xlabel('Доход')
plt.ylabel('Возраст')
plt.legend(title='Дефолт', labels=['Вернул', 'Не вернул'])
plt.show()
```

Что делает этот код:
1. Генерирует данные о клиентах банка с признаками: доход, возраст и количество
открытых кредитов.
2. Формирует целевую переменную — вероятность невозврата кредита зависит от низкого
дохода, большого числа кредитов и возраста.
3. Создает модель градиентного бустинга с помощью XGBoost и обучает её.
4. Оценивает точность модели и показывает матрицу ошибок, чтобы увидеть, где модель
ошибается.
5. Визуализирует важность признаков, чтобы понять, какие факторы сильнее всего влияют
на предсказание.
6. Строит график распределения клиентов, выделяя тех, кто вернул кредит и тех, кто не
вернул.
Интерпретация результата:
- На матрице ошибок можно увидеть, сколько клиентов модель правильно отнесла к
дефолтным и надежным.
- График важности признаков покажет, какие характеристики клиентов сильнее влияют на
вероятность невозврата.
- На диаграмме с клиентами красные точки — это те, кто не вернул кредит, а зеленые —
те, кто выплатил долг. Это помогает увидеть зависимости между доходом, возрастом и
рисками невозврата.
Преимущества градиентного бустинга заключаются в его высокой точности и
способности справляться со сложными задачами. Он хорошо работает даже тогда, когда
зависимости между признаками сложные и нелинейные. Но есть и минусы: градиентный
бустинг чувствителен к переобучению, особенно если в данных много шума, и требует
больше времени на обучение по сравнению с более простыми моделями.
Чтобы избежать переобучения, часто используют методы вроде ограничения
глубины деревьев или настройки скорости обучения. Также существуют более быстрые и
оптимизированные версии градиентного бустинга, например, XGBoost и LightGBM, которые
широко применяются в задачах анализа данных и часто выигрывают соревнования по
машинному обучению.
Таким образом, бустинг и его разновидность — градиентный бустинг — позволяют
создавать очень точные модели, которые шаг за шагом учатся на ошибках и становятся всё
лучше, напоминая процесс постоянного самосовершенствования.

XGBoost, LightGBM и CatBoost
Градиентный бустинг – один из самых мощных методов машинного обучения для
задач регрессии и классификации. Он основан на последовательном обучении слабых
моделей (обычно деревьев решений), которые исправляют ошибки своих
предшественников. Среди наиболее популярных реализаций градиентного бустинга
выделяются XGBoost, LightGBM и CatBoost – библиотеки, которые значительно ускорили и
упростили применение этого метода.
XGBoost: скорость и регуляризация
XGBoost (Extreme Gradient Boosting) был одной из первых реализаций градиентного
бустинга, ставшей популярной благодаря своей эффективности. Он использует технику
«слабого» бустинга, строя деревья решений на основе градиентного спуска, а также
включает регуляризацию, предотвращающую переобучение. Важной особенностью
XGBoost является его способность работать с разреженными данными – он умеет
автоматически обрабатывать пропущенные значения, что делает его удобным для
реальных задач.
Например, рассмотрим, задачу классификации клиентов банка по
вероятности дефолта. Используем XGBoost в Python:
```python
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Генерируем данные
X, y = load_data() # Предположим, что есть функция загрузки данных
# Разделяем на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Создаем объект DMatrix, оптимизированный для XGBoost
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
# Определяем параметры модели
params = {
"objective": "binary:logistic",
"max_depth": 6,
"learning_rate": 0.1,
"eval_metric": "logloss"
}
# Обучаем модель
bst = xgb.train(params, dtrain, num_boost_round=100)
# Делаем предсказания
y_pred = (bst.predict(dtest) > 0.5).astype(int)
# Оцениваем точность
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.4f}")
```
XGBoost популярен на соревнованиях по машинному обучению, так как он быстро
обучается и масштабируется, а также поддерживает GPU-ускорение.
LightGBM: скорость обучения на больших данных

LightGBM (Light Gradient Boosting Machine) разработан для быстрой работы на
больших наборах данных. В отличие от XGBoost, он строит деревья не построчно (levelwise), а по листам (leaf-wise), что позволяет быстрее находить важные разбиения и
увеличивает эффективность модели.
Пример использования LightGBM в задаче предсказания спроса на товары в
магазине:
```python
import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
# Загружаем данные
X, y = load_regression_data()
# Разделяем данные
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Создаем датасет LightGBM
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)
# Определяем параметры модели
params = {
"objective": "regression",
"metric": "rmse",
"boosting_type": "gbdt",
"learning_rate": 0.05,
"num_leaves": 31
}
# Обучаем модель
model = lgb.train(params, train_data, num_boost_round=100, valid_sets=[test_data],
early_stopping_rounds=10)
# Делаем предсказания
y_pred = model.predict(X_test)
# Оцениваем результат
rmse = mean_squared_error(y_test, y_pred, squared=False)
print(f"RMSE: {rmse:.4f}")
```
LightGBM хорошо подходит для задач с большими объемами данных, таких как
предсказание спроса, обработка пользовательского поведения и финансовый анализ.
CatBoost: мощный инструмент для категориальных данных
CatBoost (Categorical Boosting) – это библиотека, разработанная компанией Яндекс,
которая специализируется на работе с категориальными признаками. Вместо
традиционного one-hot-кодирования или target-encoding, CatBoost использует свою
технику преобразования категорий, что улучшает качество предсказаний и ускоряет
обучение.
Предположим, что у нас есть задача предсказания вероятности покупки товара на
основе данных о пользователе, включающих категориальные признаки (например, регион,
тип устройства, история покупок):
```python
import catboost as cb
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

# Загружаем данные
X, y, cat_features = load_categorical_data()
# Разделяем на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Создаем модель CatBoost
model = cb.CatBoostClassi er(iterations=100, depth=6, learning_rate=0.1,
cat_features=cat_features, verbose=10)

fi

# Обучаем модель
model. t(X_train, y_train, eval_set=(X_test, y_test))
# Делаем предсказания
y_pred = model.predict_proba(X_test)[:, 1]
# Оцениваем модель
auc = roc_auc_score(y_test, y_pred)
print(f"AUC: {auc:.4f}")
```
CatBoost автоматически обрабатывает категориальные признаки и обеспечивает
хорошее качество предсказаний даже при небольших объемах данных.
Выбор между XGBoost, LightGBM и CatBoost
XGBoost – универсальное решение с балансом между скоростью и качеством. Подходит
для широкого спектра задач, особенно если данные хорошо подготовлены.
LightGBM – оптимальный выбор для больших объемов данных, когда важна скорость
обучения.
CatBoost – лучший вариант при наличии большого количества категориальных признаков,
особенно если их обработка сложна.
В реальных задачах стоит попробовать несколько алгоритмов и выбрать тот,
который показывает наилучшие результаты на ваших данных.
Глава 8: Кластеризация и безучебные методы
- Метод K-средних
- Алгоритмы иерархической кластеризации
- DBSCAN
- Применение кластеризации для анализа данных
В мире машинного обучения не все задачи требуют наличия заранее размеченных
данных. Часто перед исследователем стоит вызов: обнаружить скрытые структуры в
хаотичном потоке информации, найти закономерности там, где на первый взгляд их нет.
Такие методы, позволяющие машине самостоятельно находить группы, закономерности и
связи в данных, называют безучебными.
Кластеризация – одна из ключевых техник такого подхода. Она становится
незаменимым инструментом в самых разных областях: от маркетинга, где помогает
сегментировать клиентов, до биологии, где позволяет классифицировать виды на основе
их характеристик. Кластеризационные алгоритмы способны группировать данные, выявляя
их внутреннюю логику и позволяя лучше понимать сложные структуры.
В этой главе мы погрузимся в мир кластеризации, познакомимся с различными
алгоритмами и разберем, как они находят скрытые закономерности. Мы рассмотрим
способы выбора оптимального числа кластеров, обсудим, в каких ситуациях лучше
применять один метод, а в каких – другой, и исследуем реальные примеры, показывающие,
как кластеризация помогает анализировать данные в реальном мире.

Метод K-средних
Метод K-средних – один из самых популярных алгоритмов кластеризации, который
помогает автоматически группировать данные в несколько кластеров на основе их
схожести. Он широко применяется в анализе клиентов, сегментации изображений,
биологии и многих других областях, где требуется найти скрытые группы в данных.
Интуиция метода
Представьте, что у вас есть множество точек на плоскости, и вы хотите разделить
их на группы так, чтобы элементы внутри каждой группы были как можно более похожи
между собой. Например, в магазине можно разделить покупателей на несколько типов по
их покупательскому поведению. Метод K-средних делает это, размещая в данных
несколько центров кластеров, а затем постепенно уточняя их положение, чтобы каждая
группа формировалась вокруг своего центра.
Как это работает
Метод K-средних начинается с выбора K случайных точек из набора данных,
которые временно считаются центрами кластеров. Эти центры играют ключевую роль в
процессе кластеризации, так как вокруг них формируются группы объектов. Поскольку
начальный выбор точек влияет на итоговый результат, в современных реализациях
применяются специальные методы инициализации, например, K-means++, который
выбирает стартовые центры более осмысленно, уменьшая вероятность плохой сходимости
алгоритма.
После выбора центров начинается этап распределения объектов по кластерам.
Каждый объект в данных оценивается по степени близости к каждому из текущих центров,
и объект присваивается тому кластеру, чей центр находится ближе всего. Для измерения
расстояния между точкой и центром обычно используется евклидова метрика, которая
определяет ближайший центр по прямой линии. Этот шаг можно представить как процесс
"притяжения" точек к ближайшему кластеру, подобно тому, как гравитация притягивает
объекты к массивным телам.
После первоначального распределения точек центры кластеров пересчитываются:
для каждого кластера вычисляется новое среднее значение координат всех входящих в
него точек, и этот средний вектор становится новым центром кластера. Таким образом,
центры начинают двигаться, стремясь занять более оптимальное положение относительно
объектов. После пересчёта центров происходит повторное распределение точек:
некоторые из них могут сменить кластер, если новый центр оказался ближе, чем
предыдущий.
Этот процесс — перерасчёт центров и переназначение точек — продолжается
итеративно. С каждой итерацией положение центров кластеров стабилизируется, и
количество изменений в распределении точек уменьшается. Алгоритм останавливается,
когда центры перестают двигаться или когда число итераций достигает заданного
максимума. Итоговый результат — разбиение данных на K групп, где каждый объект
принадлежит тому кластеру, в который он наиболее естественно вписывается.
Важно отметить, что метод K-средних чувствителен к выбору числа кластеров K.
Если выбрать слишком маленькое значение, разнородные группы могут быть объединены
в один кластер, а если K слишком велико, данные будут разбиты на искусственные
подгруппы. Чтобы определить оптимальное количество кластеров, часто используют
методы оценки, например, метод локтя, который анализирует, при каком K суммарное
внутрикластерное расстояние перестаёт заметно уменьшаться.
Пример кластеризации
Допустим, у нас есть данные о посетителях интернет-магазина, и мы хотим
разделить их на группы по поведению. Мы можем взять информацию о среднем чеке и
частоте покупок. Если построить график, где одна ось – это сумма покупок, а другая –
количество посещений, точки будут распределены хаотично.
Метод K-средних поможет выделить несколько групп:

1. Покупатели, которые редко заходят, но совершают крупные покупки.
2. Те, кто заходит часто, но тратит небольшие суммы.
3. Среднестатистические пользователи, которые ведут себя умеренно.
После работы алгоритма каждому посетителю будет назначена группа, что позволит
лучше адаптировать маркетинговые стратегии. Например, для первой группы можно
предложить персональные скидки, чтобы увеличить частоту их визитов, а для второй –
рекомендовать более дорогие товары.
Рассмотрим пример кода, демонстрирующего работу метода K-средних на
синтетических данных с визуализацией:
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
# Генерируем случайные данные: три группы точек
np.random.seed(42)
group1 = np.random.normal(loc=[2, 2], scale=0.5, size=(50, 2))
group2 = np.random.normal(loc=[8, 8], scale=0.5, size=(50, 2))
group3 = np.random.normal(loc=[5, 12], scale=0.5, size=(50, 2))
# Объединяем группы в один набор данных
X = np.vstack([group1, group2, group3])

fi

# Применяем K-средних с числом кластеров 3
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
labels = kmeans. t_predict(X)
centroids = kmeans.cluster_centers_

fi

fi

# Визуализация кластеров
plt. gure( gsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.6, edgecolors='k')
plt.scatter(centroids[:, 0], centroids[:, 1], c='red', marker='X', s=200, label="Cluster Centers")
plt.title("K-Means Clustering")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.show()
```

Этот код создаёт три случайных группы точек, кластеризует их методом K-средних
и визуализирует результат, окрашивая точки в зависимости от принадлежности к кластеру
и отмечая центры кластеров красными крестами.
Алгоритмы иерархической кластеризации
Иерархическая кластеризация — это метод, который группирует данные,
постепенно объединяя или разъединяя объекты на основе их схожести. В отличие от
метода K-средних, где нужно заранее задавать количество кластеров, иерархические
алгоритмы создают целую иерархию вложенных групп, позволяя исследователю
определить границы кластеров уже после построения модели.
Этот метод особенно полезен, когда структура данных не совсем ясна, и требуется
гибкий подход для выявления естественных групп. Например, в биологии иерархическая
кластеризация помогает строить филогенетические деревья, в маркетинге —
сегментировать аудиторию, а в обработке текстов — находить тематически схожие
документы.
Как это работает
Иерархическая кластеризация бывает двух видов:
- Агломеративная (снизу вверх) — начинается с того, что каждый объект считается
отдельным кластером. Затем алгоритм постепенно объединяет самые похожие группы,
пока не останется один общий кластер.
- Дивизивная (сверху вниз) — стартует с единого кластера, содержащего все объекты, и
рекурсивно разбивает его на более мелкие группы.
На практике агломеративный подход используется чаще, так как он проще в
реализации и интуитивно понятнее.
Процесс агломеративной кластеризации можно представить следующим образом:
1. Каждый объект данных сначала является своим собственным кластером.
2. Вычисляется расстояние между всеми кластерами (обычно используют евклидово
расстояние или косинусное сходство).
3. Два ближайших кластера объединяются в один.
4. Шаг 2 и 3 повторяются до тех пор, пока все объекты не объединятся в единую иерархию.
Результатом работы алгоритма является дендрограмма — древовидная структура,
где ветви показывают, как и в какой последовательности происходило объединение
кластеров. Обрезая дендрограмму на определённом уровне, можно получить желаемое
количество групп.
Пример иерархической кластеризации с кодом
Рассмотрим пример, где мы сгруппируем точки в двумерном пространстве и
визуализируем процесс с помощью дендрограммы.
```python
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.cluster import AgglomerativeClustering
# Генерация случайных данных (три группы)
np.random.seed(42)
group1 = np.random.normal(loc=[2, 2], scale=0.5, size=(10, 2))
group2 = np.random.normal(loc=[6, 6], scale=0.5, size=(10, 2))
group3 = np.random.normal(loc=[10, 2], scale=0.5, size=(10, 2))
# Объединяем данные в единый массив
X = np.vstack([group1, group2, group3])

fi

fi

# Строим дендрограмму
plt. gure( gsize=(10, 5))
linkage_matrix = linkage(X, method='ward') # Метод Уорда минимизирует внутрикластерную
дисперсию
dendrogram(linkage_matrix)
plt.title("Dendrogram")
plt.xlabel("Data Points")
plt.ylabel("Distance")
plt.show()

fi

# Применяем агломеративную кластеризацию, задавая 3 кластера
cluster_model = AgglomerativeClustering(n_clusters=3, linkage='ward')
labels = cluster_model. t_predict(X)

fi

fi

# Визуализация кластеров
plt. gure( gsize=(8, 6))
sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=labels, palette='viridis', s=100, edgecolor='k')
plt.title("Hierarchical Clustering Results")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend(title="Cluster")
plt.show()

Разбор кода
1. Создание данных. Мы генерируем три группы точек в двумерном пространстве, каждая
из которых будет соответствовать потенциальному кластеру.
2. Построение дендрограммы. Используем функцию `linkage` из библиотеки SciPy, которая
р а с с ч и т ы в а е т р а с с т о я н и я м е ж д у к л а с т е р а м и . М е т о д ` w a rd ` м и н и м и з и р у е т
внутрикластерное рассеивание, что часто даёт хорошие результаты. `dendrogram` строит
древовидную структуру, где можно увидеть, как кластеры объединяются.
3. Агломеративная кластеризация. `AgglomerativeClustering(n_clusters=3, linkage='ward')`
выполняет разбиение на три группы. После обучения модели точки получают метки
кластеров.
4. Визуализация результатов. Используем `seaborn.scatterplot`, чтобы раскрасить точки по
кластерам. Цвета соответствуют разным кластерам, а края точек подчёркнуты для
удобства восприятия.
На дендрограмме можно увидеть, как алгоритм сначала объединяет ближайшие
точки, затем группирует более крупные образования, пока все данные не окажутся в одном
кластере. Обрезая дендрограмму на разной высоте, можно выбрать, сколько кластеров
нас устраивает.
На итоговой диаграмме с точками видно, что алгоритм успешно выделил три
естественные группы, каждая из которых соответствует одной из исходных генераций
данных.
Плюсы:
- Не требует заранее задавать число кластеров (можно выбрать после анализа
дендрограммы).
- Хорошо подходит для сложных структур данных.
- Обнаруживает вложенные группы, что полезно для иерархической сегментации.
Минусы:
- Вычислительно затратный при больших наборах данных.
- Менее устойчив к выбросам, чем метод K-средних.
- Полученные кластеры нельзя переструктурировать без повторного запуска алгоритма.
Иерархическая кластеризация — мощный инструмент для анализа данных, который
позволяет обнаруживать скрытые структуры без необходимости заранее задавать число
кластеров. Она особенно полезна, когда важно понять, какие объекты образуют группы на
разных уровнях объединения. Визуализация дендрограммы помогает исследователю
оценить структуру данных и выбрать оптимальное количество кластеров, делая этот метод
гибким и удобным для аналитики.
DBSCAN
DBSCAN (Density-Based Spatial Clustering of Applications with Noise) — это алгоритм
кластеризации, который группирует близкие друг к другу точки в кластеры и считает точки,
которые не принадлежат ни одному кластеру, выбросами или шумом. В отличие от
алгоритмов, таких как K-means, DBSCAN не требует заранее заданного количества
кластеров и может работать с кластерами произвольной формы.
Основные понятия DBSCAN:
1. Эпсилон (ε) — радиус, в пределах которого точки могут быть соседями.
2. Минимальное количество соседей (minPts) — минимальное количество точек, которые
должны быть в пределах радиуса эпсилона, чтобы точку можно было считать "срединной"
точкой кластера (не шумом).
3. Ядровая точка — точка, у которой в радиусе эпсилон есть не менее minPts точек
(включая саму себя).
4. Шумная точка — точка, не являющаяся ядровой точкой и не имеющая достаточного
количества соседей, чтобы быть частью какого-либо кластера.
5. Граничная точка — точка, которая находится в пределах радиуса эпсилона от ядровой
точки, но сама не имеет достаточно соседей для того, чтобы быть ядровой.

Пример работы DBSCAN
Предположим, у нас есть набор точек на плоскости. Рассмотрим радиус эпсилона
как 1.0 и minPts как 3.
Допустим, у нас есть следующие точки:
- T1 (0, 0)
- T2 (0.5, 0.5)
- T3 (1, 0)
- T4 (3, 3)
- T5 (3.5, 3.5)
- T6 (10, 10)
Шаги работы DBSCAN:
1. Определение ядровых точек: Для точки T1 (0, 0), смотрим все точки в радиусе 1.0. Точки
T1, T2 и T3 находятся в пределах радиуса, и их 3, что больше или равно minPts (3). Значит,
T1 — ядровая точка. Аналогично проверяем точки T2 и T3. Все они имеют достаточное
количество соседей в пределах радиуса, поэтому они тоже являются ядровыми точками.
2. Группировка точек в кластеры: Точки T1, T2, T3 образуют первый кластер, так как они
соединены друг с другом в пределах радиуса эпсилон. Точки T4 и T5 также могут быть
сгруппированы в отдельный кластер, так как они находятся в пределах радиуса друг от
друга, и их количество также соответствует minPts.
3. Выделение шумных точек: Точка T6 (10, 10) не имеет соседей в пределах радиуса
эпсилон, и она не может быть частью ни одного кластера. Следовательно, T6 считается
шумом.
Преимущества DBSCAN:
- Алгоритм не требует заранее заданного числа кластеров, что делает его гибким для
разных типов данных.
- DBSCAN может обнаруживать кластеры произвольной формы, в отличие от других
алгоритмов, которые ограничиваются сферическими кластерами.
- Он автоматически обнаруживает шумные точки.
Пример кода на Python с использованием библиотеки `sklearn`:
```python
import numpy as np
from sklearn.cluster import DBSCAN
import matplotlib.pyplot as plt
# Данные: набор точек
X = np.array([[0, 0], [0.5, 0.5], [1, 0], [3, 3], [3.5, 3.5], [10, 10]])

fi

# Применяем DBSCAN
db = DBSCAN(eps=1.0, min_samples=3)
db. t(X)
# Получаем метки кластеров (-1 — шум)
labels = db.labels_
# Визуализация
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.title('DBSCAN Clustering')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
```

В этом примере `DBSCAN` ищет кластеры в данных, используя радиус эпсилона `1.0`
и минимальное количество соседей `3`. Результат визуализируется, где различные
кластеры отображаются разными цветами, а точки, которые считаются шумом, отмечены
как -1.
Применение кластеризации для анализа данных
Представь себе, что ты работаешь в интернет-магазине, и у тебя есть огромная база
данных о покупателях: их покупки, частота заказов, средняя сумма чека, возраст,
предпочтения. Тебе нужно понять, какие группы клиентов существуют, чтобы предложить
им персонализированные акции или рекомендации. Но как их разделить? Здесь на помощь
приходит кластеризация.
Допустим, у тебя есть три типа покупателей:
1. Те, кто часто заказывает небольшие и недорогие товары. Они заходят в магазин почти
каждый день, но не тратят много денег за раз.
2. Те, кто делает редкие, но крупные покупки — раз в месяц или даже реже, но сразу на
большую сумму.
3. Те, кто делает покупки нерегулярно, без четкой системы, но в среднем их заказы
довольно стабильны по размеру.
Если пытаться вручную разделить клиентов, придется просмотреть тысячи записей
и гадать, кто относится к какой группе. Но DBSCAN автоматически выявит эти кластеры,
анализируя плотность данных. Он сгруппирует людей, поведение которых похоже, и
выделит тех, кто не вписывается ни в одну из групп (например, новых покупателей, у
которых еще мало данных, или аномальных клиентов, делающих единичные большие
покупки).
Теперь ты можешь использовать результаты. Первой группе можно предложить
подписку на доставку, ведь они часто покупают. Второй — скидку на большие заказы.
Третьей — напомнить о себе и предложить что-то, основываясь на их предыдущих
покупках.
Кластеризация применяется не только в маркетинге. В медицине она помогает
находить группы пациентов с похожими симптомами, в кибербезопасности — выявлять
подозрительную активность в сети, а в науке — анализировать геоданные, находя
аномалии в распределении землетрясений или погодных условий. Алгоритм DBSCAN
особенно удобен, когда кластеры имеют сложную форму и заранее неизвестно их
количество.

Пример задачи: Кластеризация клиентов интернет-магазина
Допустим, у нас есть база данных о клиентах интернет-магазина с такими
характеристиками:
- Частота покупок (сколько раз в месяц клиент делает заказ)
- Средняя сумма заказа
Наша цель — сгруппировать клиентов с похожим поведением с помощью DBSCAN и
понять, какие группы существуют.
1. Генерация данных
Создадим искусственный набор данных, имитирующий реальных клиентов.
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler
# Генерация случайных данных: (Частота покупок, Средняя сумма заказа)
data = np.array([
[2, 20], [3, 25], [2, 22], [3, 28], [4, 26], # Группа 1 (часто, но дешево)
[10, 100], [11, 110], [12, 105], [10, 95], [11, 98], # Группа 2 (редко, но дорого)
[5, 50], [6, 55], [7, 53], [6, 52], [5, 48], # Группа 3 (средние траты)
[15, 200] # Аномальный клиент (шум)
])

fi

# Масштабируем данные для лучшей работы алгоритма
scaler = StandardScaler()
data_scaled = scaler. t_transform(data)
# Параметры нужно подбирать

fi

# Применяем DBSCAN
dbscan = DBSCAN(eps=0.8, min_samples=3)
экспериментально
labels = dbscan. t_predict(data_scaled)

# Визуализация результатов
plt.scatter(data[:, 0], data[:, 1], c=labels, cmap='viridis', edgecolors='k')
plt.xlabel("Частота покупок (раз в месяц)")
plt.ylabel("Средняя сумма заказа")
plt.title("Кластеризация клиентов с DBSCAN")
plt.colorbar(label="Кластер")
plt.show()
```

Разбор работы кода.
Мы создали три естественные группы клиентов:
- Одни покупают часто, но тратят мало.
- Другие делают редкие, но дорогие заказы.
- Третьи находятся посередине.
- Также добавили одного аномального клиента, который сильно выбивается.
Стандартизировали данные, чтобы алгоритм работал корректно, так как DBSCAN
чувствителен к масштабу.
Применили DBSCAN, указав `eps=0.8` (радиус соседства) и `min_samples=3` (чтобы
точку считали кластером, рядом должно быть минимум 3 других точки).
Результаты визуализированы, где точки одного цвета принадлежат одному
кластеру, а выброс (аномалия) отмечен отдельно.
Глава 9: Временные ряды и прогнозирование
- Основы работы с временными рядами
- Модели ARIMA и SARIMA
- Прогнозирование с помощью машинного обучения
- Применение LSTM (долгосрочная краткосрочная память)
В мире данных время играет ключевую роль. Финансовые рынки, погодные условия,
спрос на товары и даже сердечный ритм — всё это примеры временных рядов, где
прошлые значения оказывают влияние на будущее. Анализ таких данных требует особого
подхода, отличного от работы со статичными наборами.
Прогнозирование временных рядов — одна из самых сложных, но и самых
полезных задач в машинном обучении. Здесь недостаточно просто найти закономерности,
как в классическом анализе данных. Нужно учитывать последовательность событий,
сезонные колебания, долгосрочные тренды и случайные выбросы. Именно поэтому
исследователи разработали целый арсенал инструментов: от математических моделей,
основанных на статистике, до мощных нейросетевых решений, способных находить
скрытые зависимости в больших массивах информации.
Эта глава посвящена тому, как научиться видеть время не просто как параметр, а
как источник информации, раскрывающий поведение системы. Мы рассмотрим методы
анализа, предсказания и интерпретации временных данных, чтобы извлекать из них
максимум пользы.
Основы работы с временными рядами

Временной ряд — это последовательность наблюдений, упорядоченная по времени.
В отличие от обычных табличных данных, в которых порядок строк не всегда важен, здесь
каждая точка привязана к конкретному моменту, а изменение значений во времени несет в
себе ключевую информацию.
Во многих реальных процессах будущее зависит от прошлого. Например, спрос на
товары в интернет-магазине сегодня во многом определяется количеством продаж вчера,
сезонностью, выходными и даже праздниками. Если просто взять данные о продажах без
учета времени и применить стандартные алгоритмы, можно упустить важные
закономерности.
Пример временного ряда
Рассмотрим магазин, продающий зонты. Владелец хочет понять, как изменяется
спрос на зонты в течение года. Он собирает данные о количестве проданных зонтов
каждый день и строит график.
На этом графике можно заметить несколько вещей:
- Сезонность: летом спрос падает, осенью и весной — растет.
- Тренд: за несколько лет продажи зонтов постепенно увеличиваются, возможно, из-за
роста числа покупателей.
- Шумы и аномалии: в некоторые дни бывают резкие всплески спроса, например, во время
проливных дождей.
Рассмотрим код для моделирования временного ряда с продажами зонтов,
включающего тренд, сезонность и шум. Мы создадим данные на основе синтетической
модели и визуализируем их.
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Генерация временного ряда на 2 года (730 дней)
np.random.seed(42)
days = np.arange(730) # Дни с 0 до 729
# Тренд: постепенный рост продаж (например, магазин становится популярнее)
trend = 0.05 * days
# Сезонность: больше продаж осенью и весной, меньше летом (синусоида)
seasonality = 10 * np.sin(2 * np.pi * days / 365)
# Случайный шум: неожиданные изменения спроса
noise = np.random.normal(scale=5, size=len(days))

fl

# Аномалии: резкий всплеск продаж в дождливые дни (например, на 100-й и 500-й день)
anomalies = np.zeros_like(days, dtype= oat)
anomalies[[100, 500]] = 30 # В эти дни продажи резко подскочили
# Итоговые данные по продажам
sales = 50 + trend + seasonality + noise + anomalies # Базовый уровень продаж - 50 зонтов в
день
# Создадим DataFrame
dates = pd.date_range(start="2023-01-01", periods=len(days), freq="D")
df = pd.DataFrame({"Date": dates, "Umbrella Sales": sales})

fi

fi

# Визуализация временного ряда
plt. gure( gsize=(12, 5))
plt.plot(df["Date"], df["Umbrella Sales"], label="Продажи зонтов", color="blue")
plt.axvline(df["Date"][100], color="red", linestyle="--", label="Аномалия (100-й день)")
plt.axvline(df["Date"][500], color="red", linestyle="--", label="Аномалия (500-й день)")
plt.xlabel("Дата")

plt.ylabel("Количество проданных зонтов")
plt.title("Продажи зонтов в течение двух лет")
plt.legend()
plt.grid()
plt.show()
```

Что делает этот код?
1. Генерирует данные о продажах зонтов за 2 года, добавляя:
Трен (постепенный рост спроса).
Сезонность (изменение спроса по временам года).
Шум (случайные колебания).
Аномалии (резкий рост продаж в дождливые дни).
2. Создаёт временной ряд в виде DataFrame с датами и количеством проданных зонтов.
3. Строит график, показывающий общий тренд, сезонные колебания и резкие всплески.
Основные компоненты временного ряда
1. Тренд – это долгосрочное изменение значений. Если продажи зонтов в среднем
увеличиваются из года в год, это восходящий тренд.
2. Сезонность – повторяющиеся изменения в определенные периоды (например, рост
продаж в дождливый сезон).
3. Циклы – более долгосрочные колебания, связанные с экономическими или социальными
процессами.
4. Шум – случайные колебания, которые не имеют четкой закономерности.
Как анализировать временные ряды?
Анализ начинается с визуализации данных. Построив график, можно увидеть
основные закономерности: есть ли тренд, как выражена сезонность, присутствуют ли
выбросы. Затем можно применять различные методы для выявления зависимостей и
прогнозирования будущих значений.
Например, если владелец магазина знает, что осенью продажи всегда растут, он
может заранее увеличить запасы зонтов. А если анализ покажет, что резкие всплески
спроса связаны с прогнозом погоды, можно настроить динамическое ценообразование:
повышать цены в дождливые дни и снижать в сухие.
Временные ряды встречаются повсюду: в финансах, климатологии, маркетинге,
биологии и даже в социальных сетях. Их анализ позволяет не только понимать прошлое,
но и предсказывать будущее, что делает их одним из самых важных инструментов в работе
с данными.
Модели ARIMA и SARIMA

Когда мы анализируем временные ряды, одной из главных целей является
предсказание будущих значений на основе имеющихся данных. Например, если у нас есть
статистика продаж зонтов за несколько лет, мы хотим понять, сколько зонтов потребуется
в следующем месяце. Для таких задач используются модели ARIMA и SARIMA, которые
помогают находить закономерности во временных рядах и строить прогнозы.
Почему обычные методы прогнозирования не работают?
Можно попробовать простые методы, например, усреднить данные за прошлый
месяц и предположить, что в следующем месяце продажи будут такими же. Однако такой
метод игнорирует тренды и сезонные колебания, из-за чего прогноз может быть неточным.
Например, если в октябре продажи зонтов были высокими из-за дождей, а в ноябре
они всегда снижаются, среднее значение октября не даст правильного прогноза на
следующий месяц. Нужен метод, который учитывает динамику данных — именно этим и
занимаются ARIMA и SARIMA.
Что делает ARIMA?
Модель ARIMA (AutoRegressive Integrated Moving Average) анализирует временной ряд и
ищет три типа закономерностей:
1. Авторегрессия (AR) – связь текущего значения с прошлыми наблюдениями. Если в
прошлый месяц продажи зонтов выросли, это может повлиять на текущие продажи.
2. Интегрирование (I) – устранение тренда, чтобы данные стали более стабильными.
Например, если количество проданных зонтов в среднем растет из года в год, модель
"вычитает" этот тренд, делая ряд более предсказуемым.
3. Скользящее среднее (MA) – анализ случайных скачков и сглаживание данных, чтобы не
реагировать на единичные выбросы.
Проще говоря, ARIMA помогает находить устойчивые закономерности, исключает
случайные колебания и использует прошлые значения для предсказания будущих.
Пример применения ARIMA
Представим, что у нас есть данные о продажах зонтов за последние два года, и мы
хотим предсказать спрос на следующий месяц. Мы можем использовать ARIMA, чтобы
построить прогноз.
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.arima.model import ARIMA
# Генерация данных (2 года продаж)
np.random.seed(42)
days = pd.date_range(start="2023-01-01", periods=730, freq="D")
sales = 50 + 0.05 * np.arange(730) + 10 * np.sin(2 * np.pi * np.arange(730) / 365) +
np.random.normal(scale=5, size=730)
df = pd.DataFrame({"Date": days, "Umbrella Sales": sales})
# Параметры ARIMA подбираются

fi

fi

# Обучение модели ARIMA
model = ARIMA(df["Umbrella Sales"], order=(5, 1, 2))
экспериментально
model_ t = model. t()

fi

# Прогноз на 30 дней вперед
forecast = model_ t.forecast(steps=30)

fi

fi

# Визуализация
plt. gure( gsize=(12, 5))
plt.plot(df["Date"], df["Umbrella Sales"], label="Исторические данные")

plt.plot(pd.date_range(df["Date"].iloc[-1], periods=30, freq="D"), forecast, label="Прогноз
ARIMA", color="red")
plt.xlabel("Дата")
plt.ylabel("Продажи зонтов")
plt.title("Прогноз продаж зонтов с ARIMA")
plt.legend()
plt.grid()
plt.show()
```
Как работает этот код?
- Мы создаем временной ряд с продажами зонтов.
- Обучаем модель ARIMA, используя прошлые данные.
- Прогнозируем продажи на 30 дней вперед.
- Строим график, где красной линией показан прогноз.
Чем SARIMA лучше ARIMA?
SARIMA превосходит ARIMA в случаях, когда данные демонстрируют выраженные
сезонные колебания, которые повторяются через определённые интервалы времени. Если,
например, спрос на зонты стабильно растёт осенью и снижается летом, ARIMA не сможет
правильно обработать этот паттерн, поскольку она в первую очередь ориентирована на
анализ трендов и краткосрочных зависимостей, но не учитывает циклические повторения,
связанные с сезонностью.
SARIMA решает эту проблему за счёт специального сезонного компонента, который
отслеживает, как значения изменяются через фиксированные промежутки времени. Это
позволяет модели выявлять закономерности, связанные с природными, экономическими
или социальными циклами. Например, если в прошлые годы продажи зонтов всегда
достигали пика в октябре и ноябре, SARIMA зафиксирует этот паттерн и учтёт его при
прогнозировании будущих значений.
Такой подход особенно полезен при анализе данных, в которых повторяющиеся
колебания неизбежны. Например, продажи товаров, зависящих от времени года, таких как
зонты или новогодние украшения, следуют чётко выраженной сезонной динамике. В
случае прогноза температуры воздуха сезонность также играет ключевую роль, поскольку
погодные условия повторяются из года в год, и предсказания без учёта этого фактора
окажутся неточными. Кроме того, SARIMA помогает анализировать данные о нагрузке на
серверы, так как рабочая активность пользователей подчиняется недельным и месячным
циклам: в будние дни загрузка выше, а в выходные снижается.
Главное преимущество SARIMA перед ARIMA заключается в том, что она позволяет
не просто отслеживать общее направление изменений во временном ряду, но и учитывать
долгосрочные повторяющиеся паттерны. Это делает её особенно эффективной в случаях,
когда наблюдаемые данные зависят от временных циклов и без их учёта невозможно
построить точный прогноз.
Пример применения SARIMA
Допустим, у нас есть данные о продажах зонтов, которые повторяются каждый год.
Мы можем использовать SARIMA, чтобы учесть сезонные колебания.
```python
from statsmodels.tsa.statespace.sarimax import SARIMAX
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# Примерные данные
np.random.seed(42)
days = pd.date_range(start="2023-01-01", periods=730, freq="D")
sales = 50 + 0.05 * np.arange(730) + 10 * np.sin(2 * np.pi * np.arange(730) / 365) +
np.random.normal(scale=5, size=730)
df = pd.DataFrame({"Date": days, "Umbrella Sales": sales})

fi

fi

# Обучение модели SARIMA
model_sarima = SARIMAX(df["Umbrella Sales"], order=(5, 1, 2), seasonal_order=(1, 1, 1, 365))
model_sarima_ t = model_sarima. t()

fi

# Прогноз на 30 дней вперед
forecast_sarima = model_sarima_ t.get_forecast(steps=30)
forecast_mean = forecast_sarima.predicted_mean

fi

fi

# Визуализация
plt. gure( gsize=(12, 5))
plt.plot(df["Date"], df["Umbrella Sales"], label="Исторические данные")
plt.plot(pd.date_range(df["Date"].iloc[-1], periods=30, freq="D"), forecast_mean, label="Прогноз
SARIMA", color="green")
plt.xlabel("Дата")
plt.ylabel("Продажи зонтов")
plt.title("Прогноз продаж зонтов с SARIMA")
plt.legend()
plt.grid()
plt.show()
```
Как работает SARIMA?
SARIMA расширяет возможности модели ARIMA за счёт добавления сезонного
компонента. В реальных данных сезонность — это повторяющийся паттерн, который
наблюдается через определённые интервалы времени. Например, спрос на зонты
возрастает осенью и весной, когда идут дожди, и падает летом, когда погода более сухая.
Если использовать обычную ARIMA-модель, она может не справиться с таким типом
данных, так как она в первую очередь ориентирована на выявление трендов и случайных
колебаний.
SARIMA, в отличие от ARIMA, учитывает не только краткосрочные и долгосрочные
зависимости, но и повторяющиеся сезонные циклы. Например, если в прошлые годы
осенью продажи зонтов всегда увеличивались, SARIMA «замечает» этот паттерн и
использует его при прогнозировании. Чтобы учесть сезонность, модель строит
дополнительные параметры, которые анализируют, как значения меняются через
определённые промежутки времени.
Когда мы используем SARIMA, у нас появляются два набора параметров: один
отвечает за обычную динамику временного ряда, а другой — за сезонные колебания.
Например, в настройке `seasonal_order=(1, 1, 1, 365)` параметр 365 означает, что сезонные
изменения повторяются каждые 365 дней. Это полезно, когда анализируются годовые
циклы. Если мы имеем дело с ежемесячными данными, этот параметр может быть равен
12, так как сезонность повторяется раз в год, но в масштабе месяцев.
Благодаря такому подходу модель может учитывать как небольшие колебания
спроса на зонты в течение нескольких дней, так и долгосрочные сезонные
закономерности, которые повторяются из года в год. Например, если в прошлом ноябре
продажи резко выросли, SARIMA предскажет, что в следующем ноябре тоже можно
ожидать увеличения спроса. Это особенно полезно в бизнесе, где сезонные тренды могут
сильно влиять на продажи.
SARIMA также помогает выявлять циклы, которые не связаны с календарными
сезонами, но всё же повторяются. Например, спрос на определённые товары может
увеличиваться каждые несколько недель в зависимости от рекламных кампаний, погоды
или экономических факторов. Эта модель умеет отличать такие закономерности от
случайных шумов, что делает её мощным инструментом для прогнозирования в самых
разных областях: от торговли и финансов до метеорологии и логистики.
Вывод:
- ARIMA подходит, если данные имеют тренд, но не выраженную сезонность.
- SARIMA лучше, если есть сезонные колебания (ежемесячные, годовые циклы).
- Обе модели помогают делать точные прогнозы, анализируя прошлые данные.

Если владелец магазина знает, что продажи зонтов осенью всегда растут, а летом
падают, он может заранее закупить товар и оптимизировать цены. Таким образом, модели
временных рядов становятся инструментом для бизнеса, науки и аналитики.
Прогнозирование с помощью машинного обучения
Прогнозирование с помощью машинного обучения — одна из ключевых задач, в
которой алгоритмы анализируют исторические данные и выявляют закономерности для
предсказания будущих событий. Это применяется в самых разных областях: от финансов и
медицины до маркетинга и промышленности. В финансах модели прогнозирования
помогают оценивать колебания фондового рынка, предсказывать кредитные риски и
управлять инвестициями. В медицине машинное обучение используется для предсказания
вероятности развития заболеваний на основе медицинских показателей пациента. В
маркетинге алгоритмы позволяют анализировать покупательское поведение и
предсказывать спрос на товары, а в промышленности — предотвращать поломки
оборудования за счет анализа показаний датчиков и выявления аномалий.
Для решения задачи прогнозирования можно использовать различные модели,
такие как линейная регрессия, деревья решений, случайный лес и нейросети. Выбор
модели зависит от сложности данных, их объема и требуемой точности. Линейная
регрессия подходит для задач, где зависимость между переменными является простой и
линейной. Деревья решений и случайный лес эффективны в ситуациях, где данные
содержат сложные зависимости и нелинейности. Нейронные сети особенно полезны при
работе с большими объемами данных, например, в обработке временных рядов или
анализе изображений.
Процесс прогнозирования с помощью машинного обучения начинается с подготовки
данных. На этом этапе важно собрать релевантные исторические данные, очистить их от
выбросов и пропущенных значений, а также привести в удобный формат для обучения
модели. Часто используются методы нормализации и стандартизации данных, чтобы
привести их к единому масштабу и улучшить производительность модели. Например, при
прогнозировании цен на недвижимость данные могут включать площадь квартиры,
количество комнат, местоположение и среднюю стоимость жилья в районе.
После подготовки данных следует этап выбора модели и ее обучения. Данные
делятся на обучающую и тестовую выборки, чтобы проверить, насколько хорошо модель
справляется с предсказаниями на новых данных. Во время обучения алгоритм подбирает
оптимальные параметры, минимизируя ошибку прогноза. Например, при использовании
линейной регрессии модель вычисляет коэффициенты, которые позволяют наилучшим
образом описать зависимость между входными и выходными переменными.
После обучения модель тестируется и оценивается с помощью различных метрик.
Наиболее распространенные метрики для задач прогнозирования включают среднюю
абсолютную ошибку (MAE), среднеквадратичную ошибку (MSE) и коэффициент
детерминации (R²). Эти показатели позволяют понять, насколько точны предсказания
модели и требует ли она доработки. Например, если модель предсказывает объемы
продаж с высокой ошибкой, это может указывать на необходимость использования более
сложного алгоритма или добавления новых признаков, таких как сезонные факторы или
экономические показатели.
Наконец, после успешного тестирования модель внедряется в реальную среду и
используется для предсказаний. В некоторых случаях модели требуют регулярного
обновления, так как данные со временем могут меняться. Например, при прогнозировании
спроса на продукцию в магазине модель должна учитывать новые тренды и сезонные
изменения. Для этого применяются методы онлайн-обучения, при которых модель
периодически обновляется на новых данных.
Рассмотрим прогнозирование с использованием линейной регрессии, которая
хорошо подходит для задач, где зависимость между входными данными и целевой
переменной является линейной.
Сначала необходимо подготовить данные. Это включает загрузку, очистку и
разделение данных на обучающую и тестовую выборки. Например, если у нас есть данные
о продажах компании за последние несколько лет, мы можем спрогнозировать будущие

продажи на основе таких факторов, как сезонность, экономическая ситуация и рекламные
кампании.
В Python для этой задачи можно использовать библиотеку `scikit-learn`. Пример

кода:

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error
# Генерация случайных данных: зависимость продаж от рекламного бюджета
np.random.seed(42)
data_size = 100
advertising_budget = np.random.rand(data_size) * 100 # бюджет на рекламу
sales = 5 * advertising_budget + np.random.randn(data_size) * 10 # зависимость с шумом
# Создаем DataFrame
df = pd.DataFrame({'AdvertisingBudget': advertising_budget, 'Sales': sales})
# Разделение данных на признаки (X) и целевую переменную (y)
X = df[['AdvertisingBudget']]
y = df['Sales']
# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Обучение модели линейной регрессии
model = LinearRegression()
model. t(X_train, y_train)
# Прогнозирование
y_pred = model.predict(X_test)
# Оценка качества модели
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
print(f"MAE: {mae:.2f}, MSE: {mse:.2f}")
# Визуализация результатов
plt.scatter(X_test, y_test, label="Actual Sales", color="blue")
plt.plot(X_test, y_pred, label="Predicted Sales", color="red")
plt.xlabel("Advertising Budget")
plt.ylabel("Sales")
plt.legend()
plt.title("Sales Prediction using Linear Regression")
plt.show()
```

В этом коде сначала создаются синтетические данные, где продажи зависят от
рекламного бюджета с добавлением небольшого случайного шума. Затем данные
разделяются на обучающую и тестовую выборки, после чего обучается модель линейной
регрессии. После предсказания оценивается точность модели с помощью метрик MAE
(средняя абсолютная ошибка) и MSE (среднеквадратичная ошибка). Наконец, строится
график, показывающий фактические и предсказанные значения.
На графике отображены фактические и предсказанные значения продаж в
зависимости от рекламного бюджета.
Что можно увидеть:
- Синие точки представляют реальные данные из тестовой выборки, то есть фактические
продажи при заданном рекламном бюджете. Они распределены с некоторым разбросом
из-за добавленного случайного шума.
- Красная линия — это предсказания модели линейной регрессии. Она показывает, как
модель оценивает зависимость между рекламным бюджетом и продажами, строя
линейную тенденцию.
Выводы:
- Линия предсказаний приближенно отражает тренд данных, показывая, что продажи
увеличиваются с ростом бюджета.
- Разброс точек вокруг линии говорит о наличии случайных факторов, влияющих на
продажи (например, сезонность, конкуренция).
- Если точки сильно отклоняются от линии, это может указывать на недостаточную
точность модели, наличие нелинейных зависимостей или недостающие важные факторы в
данных.
Таким образом, график позволяет визуально оценить, насколько хорошо модель
линейной регрессии справляется с прогнозированием и какие возможны улучшения.
Если данные содержат нелинейные зависимости, можно использовать более
сложные модели, такие как случайный лес или нейросети. Однако линейная регрессия
является хорошей отправной точкой для понимания основ прогнозирования с помощью
машинного обучения.
Применение LSTM (долгосрочная краткосрочная память)
LSTM (Long Short-Term Memory, долгосрочная краткосрочная память) — это
разновидность рекуррентных нейронных сетей (RNN), разработанная для работы с
временными рядами и последовательными данными. В отличие от стандартных RNN, LSTM
обладает механизмом управления памятью, что позволяет эффективно запоминать

важную информацию на длительных интервалах и предотвращает проблему исчезающего
градиента. Это делает LSTM особенно полезной для задач, связанных с предсказанием
временных рядов, обработкой текста и распознаванием речи.
Применение LSTM широко распространено в анализе финансовых данных,
прогнозировании спроса, обработке биомедицинских сигналов и машинном переводе.
Рассмотрим задачу прогнозирования временного ряда на примере предсказания цен
акций.
Для работы с LSTM в Python можно использовать библиотеку TensorFlow/Keras.
Сначала необходимо подготовить данные. Исторические данные о ценах акций
загружаются, нормализуются и преобразуются в последовательности фиксированной
длины, которые станут входными данными для модели.
Ниже представлен код, реализующий прогнозирование с помощью LSTM:

fl

fl

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensor ow.keras.models import Sequential
from tensor ow.keras.layers import LSTM, Dense
# Генерация искусственных данных (имитация временного ряда цен акций)
np.random.seed(42)
data_size = 200
time = np.arange(data_size)
prices = 50 + np.sin(time / 10) * 10 + np.random.randn(data_size) * 2 # тренд с шумом
# Преобразование данных в DataFrame
df = pd.DataFrame({'Time': time, 'Price': prices})

fi

# Нормализация данных
scaler = MinMaxScaler(feature_range=(0, 1))
prices_scaled = scaler. t_transform(prices.reshape(-1, 1))
# Функция для создания обучающих последовательностей
def create_sequences(data, seq_length):
X, y = [], []
for i in range(len(data) - seq_length):
X.append(data[i:i+seq_length])
y.append(data[i+seq_length])
return np.array(X), np.array(y)
# Определение длины последовательности
sequence_length = 20
X, y = create_sequences(prices_scaled, sequence_length)
# Разделение данных на обучающую и тестовую выборки
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]
# Формирование модели LSTM
model = Sequential([
LSTM(50, activation='relu', return_sequences=True, input_shape=(sequence_length, 1)),
LSTM(50, activation='relu', return_sequences=False),
Dense(25),
Dense(1)
])

# Компиляция модели
model.compile(optimizer='adam', loss='mse')

fi

# Обучение модели
model. t(X_train, y_train, epochs=20, batch_size=16, validation_data=(X_test, y_test))
# Прогнозирование
y_pred = model.predict(X_test)
# Обратное преобразование данных
y_test_inv = scaler.inverse_transform(y_test.reshape(-1, 1))
y_pred_inv = scaler.inverse_transform(y_pred)

fi

fi

# Визуализация результатов
plt. gure( gsize=(10, 5))
plt.plot(df['Time'][split + sequence_length:], y_test_inv, label='Actual Prices', color='blue')
plt.plot(df['Time'][split + sequence_length:], y_pred_inv, label='Predicted Prices', color='red')
plt.xlabel('Time')
plt.ylabel('Stock Price')
plt.legend()
plt.title('Stock Price Prediction using LSTM')
plt.show()
```

В этом коде сначала создаются искусственные данные, имитирующие временной
ряд цен акций с некоторым шумом и трендом. Затем данные нормализуются, так как LSTM
чувствительна к масштабам значений. Далее формируются обучающие
последовательности, каждая из которых содержит фиксированное количество
предыдущих значений для предсказания следующего.
Модель LSTM состоит из двух слоев LSTM с 50 нейронами, которые обрабатывают
временные зависимости, и двух полносвязных слоев для окончательного предсказания.
Используется оптимизатор Adam и функция потерь MSE (среднеквадратичная ошибка).
После обучения модель делает предсказания на тестовых данных, и полученные
результаты визуализируются: график показывает, насколько предсказанные цены акций
(красная линия) соответствуют фактическим (синяя линия).
На графике изображены реальные и предсказанные значения цен акций по мере
времени.

Синяя линия представляет фактические цены акций, полученные из тестовой выборки. Она
показывает естественные колебания стоимости, обусловленные трендом, сезонностью и
случайными факторами.
Красная линия — это прогноз модели LSTM, отражающий предсказанные значения
на основе предыдущих данных. Она стремится следовать фактическому тренду,
воспроизводя ключевые изменения в динамике цен.
Если предсказания модели точно совпадают с реальными значениями, значит,
модель хорошо обучена и способна захватывать основные закономерности временного
ряда. Однако если красная линия сильно отклоняется от синей, это может указывать на
недообучение или переобучение модели.
Также можно заметить, что предсказанная линия сглажена по сравнению с
реальной. Это связано с тем, что модель учится улавливать общие тенденции, но не всегда
способна точно предсказать резкие скачки, особенно если в данных присутствует
случайный шум.
График позволяет визуально оценить качество работы LSTM и понять, насколько
хорошо модель справляется с задачей прогнозирования временного ряда.
Таким образом, LSTM оказывается инструментом для работы с временными рядами,
позволяя улавливать сложные зависимости и делать точные предсказания. Однако важно
учитывать, что успешное применение требует корректной предобработки данных, выбора
оптимальной архитектуры и параметров модели.
Глава 10: Глубокое обучение
- Введение в нейронные сети
- Модели нейронных сетей с использованием TensorFlow и Keras
- Основы обучения глубоких сетей
- Применение глубоких сетей для задач классификации и регрессии
Глубокое обучение стало одной из самых мощных технологий в современной науке
о данных и искусственном интеллекте. Оно позволяет решать сложные задачи, которые
ранее были недоступны традиционным алгоритмам машинного обучения. В основе
глубокого обучения лежат многослойные нейронные сети, способные выявлять сложные
зависимости в данных, извлекать ключевые признаки и адаптироваться к новым входным
данным.
Развитие глубоких нейронных сетей тесно связано с увеличением вычислительных
мощностей, усовершенствованием алгоритмов оптимизации и доступностью больших
объемов данных. Современные фреймворки, такие как TensorFlow и Keras, упрощают
создание и обучение моделей, позволяя даже начинающим специалистам разрабатывать
мощные архитектуры. Благодаря этим инструментам глубокие нейросети находят
применение в широком спектре задач: от компьютерного зрения и обработки
естественного языка до медицинской диагностики и финансового анализа.
Чтобы эффективно работать с глубокими нейронными сетями, необходимо
понимать их принципы, структуру и методы обучения. Глубина модели играет важную роль,
но также требует тщательной настройки, чтобы избежать проблем переобучения и
сложности оптимизации. Изучение этих аспектов открывает путь к созданию эффективных
решений для реальных задач, позволяя моделям не просто запоминать данные, а выявлять
в них закономерности, схожие с тем, как это делает человеческий мозг.
Введение в нейронные сети
Нейронные сети — это фундаментальная концепция в области искусственного
интеллекта и машинного обучения, вдохновленная принципами работы человеческого
мозга. Они представляют собой вычислительные модели, состоящие из взаимосвязанных
узлов (нейронов), которые обрабатывают информацию и позволяют моделировать
сложные зависимости в данных. Благодаря способности адаптироваться и учиться на
основе примеров, нейронные сети стали мощным инструментом для решения задач
классификации, регрессии, распознавания образов и многих других областей.

Идея создания искусственных нейронных сетей возникла из биологической
аналогии: в мозге человека миллиарды нейронов соединены между собой синапсами,
передавая и обрабатывая сигналы. В искусственных нейронных сетях этот процесс
имитируется с помощью математических функций и весовых коэффициентов, которые
изменяются в процессе обучения. Каждый искусственный нейрон получает входные
данные, преобразует их с помощью активационной функции и передает результат дальше
по сети.
Структура нейронной сети
Нейронные сети представляют собой многослойные структуры, где каждый слой
выполняет определенную роль в обработке информации. Основными компонентами сети
являются:
1. Входной слой — это начальная точка сети, где данные поступают внутрь. Каждый
нейрон в этом слое представляет собой один элемент входных данных. Например, для
задачи классификации изображений это могут быть пиксели изображения, а для задачи
обработки текста — отдельные слова или буквы.
2. Скрытые слои — это промежуточные этапы обработки, на которых происходит
преобразование входных данных в более высокоуровневые признаки. Скрытые слои могут
быть одного или нескольких типов: полносвязные слои (dense layers), сверточные слои
(convolutional layers) или рекуррентные слои (recurrent layers), в зависимости от типа задачи
и структуры сети.
Глубина сети определяется количеством скрытых слоев. Чем больше слоев, тем
сложнее сеть и тем больше возможностей для выявления сложных зависимостей в
данных. Например, в простых однослойных нейронных сетях (или перцептронах) скрытый
слой один, а в глубоких нейронных сетях — десятки и даже сотни скрытых слоев.
3. Выходной слой — на этом уровне производится окончательная интерпретация
обработанных данных. В зависимости от типа задачи (классификация, регрессия и т. д.)
количество нейронов в выходном слое может варьироваться. Для задачи классификации с
несколькими классами может быть использован softmax, который преобразует результаты
в вероятности.
Искусственный нейрон — это основная единица нейронной сети. Он получает
несколько входных сигналов, которые соответствуют определенным признакам или
значениям (например, значения пикселей изображения или входные данные, полученные
из других слоев). Каждый вход умножается на вес, который определяет важность этого
входа для текущего нейрона.
Затем происходит суммирование всех взвешенных входов, и результат передается
через нелинейную функцию активации. Нелинейность функции активации позволяет
нейронной сети моделировать сложные зависимости и выявлять неочевидные паттерны в
данных, а не ограничиваться простыми линейными зависимостями.

fi

Функции активации:
- ReLU (Recti ed Linear Unit) — одна из самых популярных функций активации. Она простая
и эффективная, пропуская только положительные значения и обнуляя отрицательные.
- Sigmoid — функция, которая преобразует значения в диапазон от 0 до 1, что полезно для
задач классификации, где требуется оценить вероятность.
- Tanh (Hyperbolic Tangent) — похожа на сигмоиду, но возвращает значения в диапазоне от
-1 до 1, что может быть полезно для нормализации данных.
Эти функции играют важную роль в обучении нейронной сети, позволяя ей находить
и обучаться на сложных закономерностях в данных.
Процесс обучения нейронных сетей
Обучение нейронной сети — это процесс, в котором сеть настраивает свои
параметры, чтобы минимизировать ошибку между предсказанными и реальными

значениями. Все начинается с того, что сеть получает входные данные и передает их через
различные слои, где каждый нейрон вычисляет взвешенную сумму входов и применяет
функцию активации. На выходе сети получается предсказание, которое затем
сравнивается с реальным значением с помощью функции потерь. Функция потерь
измеряет, насколько сильно предсказание отличается от фактического результата.
Затем происходит этап, называемый обратным распространением ошибки
(backpropagation). На этом этапе сеть вычисляет, как каждый вес влияет на итоговую
ошибку, и передает эти данные назад через слои. Это позволяет модели корректировать
веса, чтобы уменьшить ошибку. Этот процесс позволяет сети учиться на основе ошибок и
постепенно улучшать свои предсказания.
После того как градиенты ошибки вычислены, веса обновляются с использованием
метода оптимизации. Чаще всего используется метод градиентного спуска, при котором
веса корректируются таким образом, чтобы ошибка становилась все меньше и меньше.
Это обновление повторяется много раз, и с каждой итерацией сеть становится более
точной. Такой процесс называется эпохами, и он продолжается до тех пор, пока сеть не
достигнет желаемого уровня точности.
Важным моментом является предотвращение переобучения, то есть ситуации, когда
сеть начинает слишком сильно запоминать данные и не может эффективно обобщать
новые данные. Для этого применяются различные методы регуляризации, такие как
dropout, который случайным образом исключает некоторые нейроны из обучения, или L2регуляризация, которая накладывает штраф на слишком большие веса.
В конечном итоге, обучение нейронной сети позволяет модели точно делать
предсказания, обрабатывая большие объемы данных и выявляя в них сложные
закономерности.
Пример создания простой нейронной сети в Keras
Для понимания работы нейронных сетей рассмотрим простой пример
классификации с использованием библиотеки Keras.

fi

fl

fl

fl

```python
import tensor ow as tf
from tensor ow.keras.models import Sequential
from tensor ow.keras.layers import Dense
from sklearn.datasets import make_classi cation
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

fi

# Генерация синтетических данных
X, y = make_classi cation(n_samples=1000, n_features=10, n_classes=2, random_state=42)
# Разделение данных на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

fi

# Масштабирование данных
scaler = StandardScaler()
X_train = scaler. t_transform(X_train)
X_test = scaler.transform(X_test)
# Создание модели нейронной сети
model = Sequential([
Dense(16, activation='relu', input_shape=(10,)), # Входной и первый скрытый слой
Dense(8, activation='relu'), # Второй скрытый слой
Dense(1, activation='sigmoid') # Выходной слой для бинарной классификации
])

fi

# Компиляция модели
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Обучение модели
model. t(X_train, y_train, epochs=20, batch_size=16, validation_data=(X_test, y_test))
# Оценка модели на тестовых данных

loss, accuracy = model.evaluate(X_test, y_test)
print(f'Accuracy: {accuracy:.2f}')
```
Нейронные сети являются инструментом для решения сложных задач машинного
обучения. Они способны выявлять сложные зависимости в данных и адаптироваться к
новым входным данным благодаря гибкости своей структуры. Глубокие сети, состоящие из
множества скрытых слоев, особенно полезны в таких областях, как обработка
изображений, естественный язык и временные ряды. Однако эффективное использование
нейронных сетей требует понимания их структуры, выбора правильных гиперпараметров и
применения подходящих методов обучения.
Модели нейронных сетей с использованием TensorFlow и Keras
Модели нейронных сетей с использованием TensorFlow и Keras являются мощными
инструментами для решения различных задач машинного обучения, таких как
классификация, регрессия, обработка изображений, анализ текста и другие. TensorFlow —
это популярная библиотека для численных вычислений, а Keras — высокоуровневый
интерфейс для построения и обучения нейронных сетей, который интегрируется с
TensorFlow. Рассмотрим, как можно создать нейронную сеть с использованием этих
инструментов.
Первоначально для создания модели нейронной сети в TensorFlow и Keras
необходимо импортировать соответствующие библиотеки. Например, для простого
примера классификации изображений в задаче распознавания рукописных цифр MNIST
потребуется импортировать несколько ключевых компонентов.

fl

fl

```python
import tensor ow as tf
from tensor ow.keras import layers, models
```
После этого можно приступить к построению модели. Для примера, представим
задачу классификации изображений из набора данных MNIST, где нужно распознать
цифры от 0 до 9. Модель будет состоять из нескольких слоев: входного слоя, нескольких
скрытых слоев и выходного слоя.
Модель будет иметь входной слой, принимающий изображения размером 28x28
пикселей. В Keras это можно сделать с помощью слоя `Flatten`, который преобразует
двумерное изображение в одномерный вектор. Далее будут идти несколько скрытых
слоев, например, полносвязных слоев (`Dense`), которые будут отвечать за обработку
данных. Каждый скрытый слой будет использовать функцию активации, чтобы добавить
нелинейность. В качестве функции активации часто используется ReLU. В конце
добавляется выходной слой, который будет иметь 10 нейронов для 10 классов (цифры от 0
до 9), а активация будет softmax, чтобы получить вероятности для каждого класса.
Пример создания такой модели в Keras:
```python
model = models.Sequential([
layers.Flatten(input_shape=(28, 28)), # Преобразуем изображение в одномерный вектор
layers.Dense(128, activation='relu'), # Скрытый слой с 128 нейронами и активацией ReLU
layers.Dense(10, activation='softmax') # Выходной слой с 10 нейронами и активацией
softmax
])
```
Здесь `Sequential` указывает, что модель строится как последовательность слоев,
каждый из которых обрабатывает данные и передает их на следующий. Мы начинаем с
`Flatten`, чтобы привести входные изображения в формат, подходящий для полносвязанных
слоев. Затем идет скрытый слой с 128 нейронами и функцией активации ReLU, который
помогает сети учить нелинейные зависимости. Наконец, на выходе мы получаем слой с 10
нейронами для классификации, где каждый нейрон будет отвечать за одну цифру от 0 до 9.

После того как модель построена, нужно скомпилировать её, указав функцию
потерь и оптимизатор. Для задачи классификации категорий обычно используется кроссэнтропия как функция потерь и оптимизатор Adam. Adam — это один из самых популярных
оптимизаторов, который эффективно обновляет веса во время обучения.
```python
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
```

fi

Теперь, когда модель скомпилирована, можно приступить к её обучению. Для этого
используем метод ` t`, который принимает тренировочные данные, количество эпох и
размер батча. Например, для набора данных MNIST мы можем обучить модель на 5 эпохах,
используя стандартный размер батча (например, 32).

fi

```python
model. t(train_images, train_labels, epochs=5, batch_size=32)
```

fi

Здесь `train_images` — это тренировочные изображения, а `train_labels` — это метки
классов, то есть цифры, которые соответствуют этим изображениям. Метод ` t` будет
поочередно подавать данные на вход сети, вычислять ошибку, обновлять веса и повторять
этот процесс на протяжении заданного количества эпох.
После того как обучение завершится, можно оценить производительность модели
на тестовых данных, используя метод `evaluate`. Он возвращает значение потерь и точности
модели на тестовой выборке.
```python
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Точность на тестовых данных: {test_acc}")
```
Кроме того, можно использовать модель для предсказания, например, чтобы
узнать, что модель думает о новом изображении.
```python
predictions = model.predict(new_images)
```
Здесь `new_images` — это новые изображения, для которых нужно сделать
предсказание. Модель вернет вероятности для каждого из 10 классов, и можно выбрать
тот, для которого вероятность наибольшая.
Пример использования нейронных сетей с TensorFlow и Keras показывает, как легко
и быстро можно создать, обучить и оценить модель для решения реальных задач.
TensorFlow и Keras предоставляют высокий уровень абстракции, позволяя
сосредоточиться на архитектуре модели и процессе обучения, оставляя управление
низкоуровневыми деталями самим библиотекам.
Давайте рассмотрим пример задачи классификации изображений с
использованием набора данных MNIST, который содержит изображения рукописных цифр
от 0 до 9. Мы будем строить модель нейронной сети для распознавания этих цифр с
использованием TensorFlow и Keras.
Задача: Классификация изображений цифр MNIST

fl

1. Загружаем и подготавливаем данные: Набор данных MNIST уже доступен в библиотеке
Te n s o r F l o w ,
и
его
легко
загрузить
с
помощью
метода
`tensor ow.keras.datasets.mnist.load_data()`. Мы разделим данные на тренировочные и
тестовые.
2. Строим модель нейронной сети: Мы создадим модель с одним скрытым слоем.

3. Компиляция и обучение модели: Мы скомпилируем модель, используя оптимизатор и
функцию потерь, и обучим её на тренировочных данных.
4. Оценка и предсказание: После обучения мы оценим модель на тестовых данных и
сделаем предсказания для новых данных.
Код для решения задачи

fl

fl

```python
# Импортируем необходимые библиотеки
import tensor ow as tf
from tensor ow.keras import layers, models
# Загружаем набор данных MNIST
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()
# Нормализуем данные, чтобы значения пикселей были в диапазоне от 0 до 1
train_images = train_images / 255.0
test_images = test_images / 255.0
# Строим модель нейронной сети
model = models.Sequential([
# Преобразуем изображения в одномерный вектор
layers.Flatten(input_shape=(28, 28)),
# Скрытый слой с 128 нейронами и активацией ReLU
layers.Dense(128, activation='relu'),

])

# Выходной слой с 10 нейронами для 10 классов
layers.Dense(10, activation='softmax')

fi

# Компилируем модель
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Обучаем модель
model. t(train_images, train_labels, epochs=5, batch_size=32)
# Оцениваем точность модели на тестовых данных
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Точность на тестовых данных: {test_acc}")
# Используем модель для предсказания новых данных
predictions = model.predict(test_images)
# Пример: предсказание для первого изображения из тестового набора
print(f"Предсказанная цифра для первого изображения: {predictions[0].argmax()}")
```

Это означает, что модель достигла точности 98.1% на тестовых данных, и для
первого изображения она предсказала цифру 7.
Пояснение:

fi

fl

1. Загрузка данных: Мы загружаем данные с помощью
`tensor ow.keras.datasets.mnist.load_data()`, который возвращает два набора: тренировочные
и тестовые данные. Изображения изначально имеют размерность 28x28 пикселей, а метки
— это цифры от 0 до 9, которые соответствуют этим изображениям.
2. Нормализация: Мы делим все значения пикселей на 255, чтобы преобразовать их в
диапазон от 0 до 1. Это поможет ускорить обучение и повысить стабильность сети.
3. Строительство модели:
Модель состоит из трех слоев:
- `Flatten` преобразует двумерное изображение в одномерный вектор.
- `Dense(128, activation='relu')` — скрытый слой с 128 нейронами и функцией активации
ReLU, который помогает сети изучать нелинейные зависимости.
- `Dense(10, activation='softmax')` — выходной слой с 10 нейронами, каждый из которых
соответствует одной из цифр (от 0 до 9). Softmax используется для получения
вероятностей принадлежности к каждому из классов.
4. Компиляция: Мы используем оптимизатор Adam, который часто работает хорошо на
практике, и функцию потерь `sparse_categorical_crossentropy` для многоклассовой
классификации.
5. Обучение: Мы обучаем модель на тренировочных данных с помощью метода ` t`. Здесь
мы используем 5 эпох и размер батча 32, что означает, что данные будут обрабатываться
по 32 примера за раз.
6. Оценка и предсказания: После обучения модели мы проверяем её точность на тестовых
данных с помощью `evaluate`. Далее можно делать предсказания с использованием метода
`predict`, который возвращает вероятности для каждого класса. Мы можем выбрать класс с
наибольшей вероятностью как итоговое предсказание.
Этот пример демонстрирует, как можно быстро создать и обучить нейронную сеть
для задачи классификации изображений с использованием TensorFlow и Keras.
Основы обучения глубоких сетей
Обучение глубоких нейронных сетей — это сложный процесс, включающий
настройку большого количества параметров, оптимизацию функции ошибки и
предотвращение переобучения. Глубокие сети состоят из множества слоев, и по мере их
увеличения возникает ряд сложностей, таких как исчезающие градиенты, переобучение и
увеличение времени вычислений. Для эффективного обучения необходимо понимать
ключевые концепции, включая обработку данных, выбор архитектуры сети, алгоритмы
оптимизации и методы регуляризации.
В самом начале обучение начинается с подготовки данных. Данные играют
решающую роль, поскольку качество входной информации определяет, насколько хорошо
модель сможет выявлять закономерности. Для этого используется нормализация, чтобы
привести все значения к единому масштабу, и аугментация данных, которая искусственно
увеличивает объем тренировочного набора, изменяя исходные примеры (например,
повороты или зеркальные отражения изображений). В глубоких нейросетях особенно
важно, чтобы входные данные были правильно отмасштабированы, поскольку резкие
различия в масштабах могут привести к нестабильному обучению.
После подготовки данных выбирается архитектура нейросети. В зависимости от
задачи могут использоваться различные типы слоев. Полносвязные слои, в которых
каждый нейрон соединён со всеми нейронами следующего слоя, часто применяются в
базовых задачах классификации. Свёрточные слои широко используются для анализа
изображений, поскольку они могут выделять пространственные признаки. Повторяющиеся
слои применяются в задачах обработки последовательностей, например, в обработке
текста. Выбор количества слоев и нейронов в каждом из них влияет на способность

модели обобщать закономерности, но слишком сложная модель может привести к
переобучению.
Обучение сети происходит путем итеративного обновления весов с помощью
метода обратного распространения ошибки. Этот процесс включает вычисление градиента
функции потерь по отношению к весам сети, а затем корректировку весов в направлении
уменьшения ошибки. В этом помогает градиентный спуск и его усовершенствованные
варианты, такие как Adam и RMSprop. Эти методы позволяют более эффективно находить
оптимальные значения параметров, учитывая особенности ландшафта функции потерь.
Например, Adam комбинирует адаптивное масштабирование градиентов и момент для
ускорения сходимости.
Глубокие сети могут страдать от проблемы исчезающего градиента, когда при
передаче ошибки назад через большое количество слоев градиенты становятся очень
маленькими, из-за чего начальные слои перестают эффективно обновляться. Чтобы
решить эту проблему, используются специальные функции активации, такие как ReLU,
которые помогают сохранять достаточную величину градиента. Также помогают методы
инициализации весов, такие как He или Xavier, которые обеспечивают правильное
начальное распределение весов для стабилизации обучения.
Регуляризация играет ключевую роль в предотвращении переобучения, когда
модель запоминает обучающие данные, но плохо работает на новых примерах. Одним из
наиболее популярных методов является dropout, при котором случайно отключается часть
нейронов во время обучения, что заставляет сеть обучаться более устойчивым
представлениям. L2-регуляризация добавляет штраф за слишком большие веса, что
предотвращает их чрезмерный рост и помогает избежать перенастроенности модели под
тренировочные данные. Также можно использовать методы ранней остановки, когда
обучение завершается, если точность на валидационных данных перестает улучшаться.
Одним из практических примеров обучения глубокой нейронной сети является
классификация изображений с использованием сверточной сети. Рассмотрим задачу
распознавания рукописных цифр MNIST. В этой задаче используется многослойная
сверточная сеть, которая автоматически извлекает признаки изображения и
классифицирует его.

fl

fl

```python
import tensor ow as tf
from tensor ow.keras import layers, models
import matplotlib.pyplot as plt
import numpy as np
# Загружаем данные
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

ff

fi

fi

# Визуализация первых 10 изображений из тренировочного набора
plt. gure( gsize=(10, 2))
for i in range(10):
plt.subplot(1, 10, i + 1)
plt.imshow(train_images[i], cmap='gray')
plt.axis('o ')
plt.suptitle("Примеры изображений MNIST", fontsize=14)
plt.show()

fl

fl

# Изменяем форму изображений для свёрточной сети и нормализуем пиксели
train_images = train_images.reshape((60000, 28, 28, 1)).astype(' oat32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype(' oat32') / 255
# Создаём сверточную нейросеть
model = models.Sequential([
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),

])

layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dropout(0.5),
layers.Dense(10, activation='softmax')

# Компиляция модели
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

fi

# Обучение модели с сохранением истории
history = model. t(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.1)
# Оценка на тестовых данных
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Точность на тестовых данных: {test_acc}")

fi

fi

# Визуализация обучения: графики ошибки и точности
plt. gure( gsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Ошибка на обучении')
plt.plot(history.history['val_loss'], label='Ошибка на валидации')
plt.xlabel('Эпоха')
plt.ylabel('Ошибка')
plt.legend()
plt.title('Изменение функции ошибки')
plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Точность на обучении')
plt.plot(history.history['val_accuracy'], label='Точность на валидации')
plt.xlabel('Эпоха')
plt.ylabel('Точность')
plt.legend()
plt.title('Изменение точности')
plt.show()

fi

fi

fi

fi

fi

fi

# Визуализация фильтров первого сверточного слоя
lters, biases = model.layers[0].get_weights()
lters = ( lters - lters.min()) / ( lters.max() - lters.min()) # Нормализация для отображения
fi

ff

fi

fi

fl

fi

g, axes = plt.subplots(4, 8, gsize=(10, 5))
for i, ax in enumerate(axes. at):
if i < lters.shape[3]: # Убедимся, что не выходит за количество фильтров
ax.imshow( lters[:, :, 0, i], cmap='gray')
ax.axis('o ')
plt.suptitle("Фильтры первого сверточного слоя", fontsize=14)
plt.show()
```

В этом примере используются три сверточных слоя для выделения признаков
изображений, каждый из которых сопровождается операцией объединения (pooling),
которая уменьшает размерность данных и снижает вероятность переобучения. Далее идут
полносвязные слои с функцией активации ReLU, а также слой `Dropout`, который
случайным образом отключает 50% нейронов во время обучения. Это делает модель более
устойчивой к шуму в данных. Для обучения используется Adam-оптимизатор, а в качестве
функции потерь — кросс-энтропия, поскольку задача является многоклассовой
классификацией.
После обучения можно проверить качество модели на тестовых данных. Если
результат не соответствует ожиданиям, можно попробовать изменить количество слоев,
нейронов или параметры оптимизации. Глубокое обучение — это процесс постоянного
экспериментирования и подбора гиперпараметров, так как каждая задача требует
индивидуального подхода.
Обучение глубоких сетей требует больших вычислительных мощностей, поэтому
часто используется аппаратное ускорение, например, графические процессоры (GPU) или
тензорные процессоры (TPU). Это позволяет значительно ускорить обработку данных и
улучшить производительность модели. Также применяются методы переноса обучения,
когда заранее обученные сети, такие как VGG или ResNet, используются в качестве основы
для решения новых задач. Это позволяет избежать необходимости обучения с нуля и
использовать знания, полученные на больших наборах данных.
Таким образом, успешное обучение глубоких нейронных сетей требует тщательной
настройки архитектуры, выбора правильных функций активации и регуляризации,
использования мощных алгоритмов оптимизации и, что не менее важно, качественных
данных. Глубокие сети обладают огромным потенциалом, но их правильная настройка и

обучение требуют внимания ко многим деталям, включая обработку данных, выбор
гиперпараметров и предотвращение переобучения.
Применение глубоких сетей для задач классификации и регрессии
Глубокие нейронные сети широко применяются как для задач классификации, так и
для задач регрессии. Они способны автоматически извлекать сложные признаки из
данных и находить закономерности, которые сложно выявить вручную. Отличие между
этими задачами заключается в типе выходных данных: в классификации модель
предсказывает категории (например, определяет, является ли изображение котом или
собакой), а в регрессии она выдает числовое значение (например, предсказывает цену
недвижимости на основе её характеристик).
При решении задачи классификации используются функции активации, которые
позволяют преобразовывать выходные данные в вероятности. Например, в
многоклассовой классификации выходной слой содержит столько нейронов, сколько
классов в задаче, а функция активации softmax превращает их в вероятности. Для
бинарной классификации, где требуется определить принадлежность объекта к одному из
двух классов, применяется один выходной нейрон с сигмоидной функцией активации,
которая возвращает значение от 0 до 1.
В задаче регрессии выходной слой состоит из одного нейрона, а в качестве
функции активации чаще всего используется линейная функция, так как требуется
предсказывать непрерывные числовые значения. Функция потерь также различается: в
классификации чаще всего применяется кросс-энтропия, а в регрессии —
среднеквадратичная ошибка (MSE) или абсолютная ошибка (MAE).
Рассмотрим пример решения задачи классификации на наборе данных MNIST, где
требуется распознавать рукописные цифры. Для этого используется сверточная
нейронная сеть, которая обучается находить характерные черты цифр и
классифицировать изображения.

fl

fl

```python
import tensor ow as tf
from tensor ow.keras import layers, models
import matplotlib.pyplot as plt
import numpy as np
# Загружаем данные
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

fl

fl

# Нормализуем и изменяем форму данных
train_images = train_images.reshape((60000, 28, 28, 1)).astype(' oat32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype(' oat32') / 255
# Создаём сверточную нейронную сеть для классификации
model = models.Sequential([
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dropout(0.5),
layers.Dense(10, activation='softmax') # 10 классов (цифры от 0 до 9)
])
# Компиляция модели
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

fi

# Обучение модели
history = model. t(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.1)
# Оценка на тестовых данных
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Точность на тестовых данных: {test_acc}")
```
Этот код создает сверточную сеть, которая анализирует изображения цифр и
классифицирует их. Используются три сверточных слоя для выделения признаков, а в
конце — полносвязный слой с 10 нейронами, где каждый нейрон отвечает за одну из цифр.
Теперь рассмотрим задачу регрессии, где сеть предсказывает цену недвижимости
на основе таких характеристик, как площадь, количество комнат и расположение. В этой
задаче выходное значение — это непрерывная числовая величина.

fl

fl

```python
import tensor ow as tf
from tensor ow.keras import layers, models
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# Генерируем синтетические данные: площадь, количество комнат, удаленность от центра
np.random.seed(42)
num_samples = 1000
square_meters = np.random.randint(20, 200, size=num_samples)
num_rooms = np.random.randint(1, 5, size=num_samples)
distance_from_center = np.random.uniform(1, 10, size=num_samples)
price = square_meters * 3000 + num_rooms * 10000 - distance_from_center * 5000 +
np.random.normal(0, 10000, num_samples)
# Объединяем признаки в один массив
features = np.column_stack((square_meters, num_rooms, distance_from_center))
# Разделяем на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(features, price, test_size=0.2, random_state=42)

fi

# Стандартизируем данные
scaler = StandardScaler()
X_train = scaler. t_transform(X_train)
X_test = scaler.transform(X_test)
# Создаем модель
model = models.Sequential([
layers.Dense(64, activation='relu', input_shape=(3,)),
layers.Dense(32, activation='relu'),
layers.Dense(1) # Один выходной нейрон для предсказания цены
])

fi

# Компиляция модели
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
# Обучение модели
history = model. t(X_train, y_train, epochs=50, batch_size=10, validation_split=0.1, verbose=0)
# Оценка модели
test_loss, test_mae = model.evaluate(X_test, y_test)
print(f"Средняя абсолютная ошибка на тестовых данных: {test_mae}")

fi

fi

# Визуализация обучения
plt. gure( gsize=(12, 4))
plt.plot(history.history['loss'], label='Ошибка на обучении')
plt.plot(history.history['val_loss'], label='Ошибка на валидации')
plt.xlabel('Эпоха')
plt.ylabel('Ошибка (MSE)')
plt.legend()
plt.title('Изменение ошибки в процессе обучения')
plt.show()
```

В этом примере сеть получает три числовых признака и предсказывает стоимость
жилья. Она состоит из двух скрытых слоев с функцией активации ReLU и выходного слоя,
который предсказывает цену. Функция потерь — среднеквадратичная ошибка (MSE), так
как модель должна минимизировать разницу между предсказаниями и реальными ценами.
Глубокие сети способны справляться как с классификацией, так и с регрессией,
благодаря автоматическому выявлению сложных закономерностей. Однако правильный
выбор архитектуры, количества слоев и гиперпараметров играет решающую роль в
успешном обучении модели.
Глава 11: Обработка текстовых данных
- Введение в обработку естественного языка (NLP)
- Токенизация и векторизация текста
- Применение моделей для анализа текста (например, анализ настроений)
Текстовые данные окружают нас повсюду — от новостных статей и книг до
комментариев в социальных сетях и диалогов с виртуальными ассистентами. В отличие от
структурированной информации, представленной в числах и таблицах, текст обладает
неуловимой природой: он многослоен, зависим от контекста и наполнен оттенками смысла.
Преобразование текстовой информации в форму, доступную для математического
анализа, — одна из ключевых задач машинного обучения. Развитие технологий обработки
естественного языка (NLP) сделало возможным не только анализ и интерпретацию текстов,
но и создание сложных моделей, способных генерировать осмысленные тексты, выявлять
скрытые закономерности и даже понимать эмоции автора.
Однако текстовые данные — это не просто набор слов. Их обработка требует
понимания языковых структур, учета грамматических особенностей и адаптации к
различным контекстам использования. В этой главе мы разберем фундаментальные
методы работы с текстом и их применение в машинном обучении.

Введение в обработку естественного языка (NLP)
Язык — это сложнейшая система коммуникации, отражающая мышление, культуру
и эмоции людей. Он гибок, многозначен и подвержен постоянным изменениям.
Человеческий мозг с легкостью интерпретирует текст, выделяет смысл даже из неполных
или двусмысленных высказываний, но для компьютеров этот процесс представляет
серьезную задачу. Обработка естественного языка (Natural Language Processing, NLP) —
это область искусственного интеллекта, занимающаяся тем, чтобы научить машины
понимать, интерпретировать и генерировать человеческий язык.
Основная сложность работы с текстом заключается в его неоднозначности. Одно и
то же слово может менять значение в зависимости от контекста, а фраза — передавать
совершенно разные эмоции в зависимости от интонации или скрытых смыслов. Например,
предложение «Она ушла, не сказав ни слова» может быть нейтральным описанием
события, а может намекать на драматическую ситуацию.
Обработка текстовых данных начинается с их представления в виде, удобном для
вычислений. В отличие от числовых данных, текст нельзя напрямую использовать в
математических моделях, поэтому его необходимо преобразовать в числовую форму. Это
достигается различными методами, начиная от простых статистических моделей,
учитывающих частоту встречаемости слов, и заканчивая сложными нейросетевыми
архитектурами, способными анализировать семантику и контекст.
Современные методы NLP позволяют не только анализировать текст, но и
выполнять сложные задачи, такие как машинный перевод, автоматическое суммирование,
генерация связных текстов, обнаружение тональности высказываний и даже диалоговые
взаимодействия с пользователями. Технологии обработки естественного языка
используются в поисковых системах, голосовых помощниках, чат-ботах, системах
автоматической модерации контента и во многих других областях, где требуется
интерпретация текстовых данных.
Несмотря на достигнутые успехи, NLP остается активно развивающейся сферой,
сталкивающейся с множеством вызовов. Культурные различия, многозначность слов,
сложные грамматические структуры, идиомы и сарказм — все это затрудняет
автоматический анализ языка. Кроме того, модели NLP требуют значительных объемов
данных для обучения, а также требуют учитывать этические вопросы, такие как
предвзятость алгоритмов и конфиденциальность пользовательских данных.
Обработка естественного языка представляет собой увлекательную, но сложную
задачу, объединяющую лингвистику, математику и информатику. Она позволяет машинам
не просто работать с текстами, а учиться понимать смысл, улучшая взаимодействие
человека и компьютера.
Токенизация и векторизация текста
Текст, с которым мы работаем в повседневной жизни, кажется понятным и удобным
для восприятия. Однако, для компьютера он представляет собой просто
последовательность символов, не имеющих внутреннего смысла. Чтобы анализировать
текст математическими методами, его необходимо преобразовать в структуру, с которой
могут работать алгоритмы. Два важных шага этого процесса — токенизация и
векторизация.
Токенизация — это разбиение текста на отдельные элементы, называемые
токенами. Токены могут представлять собой слова, части слов или даже целые
предложения, в зависимости от задачи. Например, если взять предложение «Машинное
обучение — это будущее технологий», то при стандартной токенизации на уровне слов мы
получим следующий список: [«Машинное», «обучение», «—», «это», «будущее»,
«технологий»]. Однако, если рассматривать токенизацию на уровне символов, то текст
разобьется на отдельные буквы и знаки, что может быть полезно, например, в задачах
распознавания ошибок или работы с неизвестными словами.
Токенизация не так проста, как может показаться на первый взгляд. Разные языки
предъявляют свои требования к этому процессу. В русском языке сложностью может быть
разбиение на слова из-за морфологических особенностей: одна и та же основа может
встречаться в разных формах («пишу», «писать», «писал»), что затрудняет автоматический

анализ. В китайском и японском языках пробелы между словами не используются, что
делает токенизацию еще более сложной задачей.
После токенизации необходимо представить текст в виде чисел, поскольку
математические алгоритмы не работают с буквами и словами. Это процесс векторизации.
Самый простой способ — заменить каждое слово или символ его уникальным числовым
идентификатором, создав словарь, где каждому токену соответствует определенный
номер. Например, если у нас есть три предложения:
1. «Кот сидит на подоконнике.»
2. «Собака лежит на полу.»
3. «Кот и собака дружат.»
Мы можем создать словарь, в котором каждому слову присвоен свой индекс:
Кот — 1
сидит — 2
на — 3
подоконнике — 4
собака — 5
лежит — 6
полу — 7
и—8
дружат — 9
После этого каждое предложение можно представить в виде последовательности
чисел, например:
[1, 2, 3, 4]
[5, 6, 3, 7]
[1, 8, 5, 9]
Но такой способ слишком прост. Он не учитывает значимость слов, их взаимосвязь
и контекст. Например, слова «кот» и «собака» имеют схожий смысл, но их цифровые
представления здесь никак не отражают эту связь.
Для более продвинутой векторизации применяют методы, позволяющие
моделировать семантические отношения между словами. Один из таких методов — мешок
слов (Bag of Words, BoW). В нем создается таблица, где строки — это предложения, а
столбцы — встречающиеся в тексте слова. На пересечении ставится число,
показывающее, сколько раз слово встречается в данном предложении. Например:

Такая векторизация уже позволяет анализировать тексты, но у нее есть недостатки:
не учитывается порядок слов, не различаются синонимы, а редкие, но важные слова могут
теряться среди часто встречающихся.
Современные методы используют плотные векторные представления, такие как
Word2Vec, GloVe и нейросетевые трансформеры, где слова представляются в виде
многомерных чисел, отражающих их смысловые связи. Например, слова «король» и

«королева» в таких моделях будут расположены рядом, а между словами «Франция» и
«Париж» будет такая же математическая связь, как между «Россия» и «Москва».
Рассмотрим пример использования Word2Vec для работы с плотными векторными
представлениями слов на Python с библиотекой `gensim`. Мы обучим модель на небольшом
корпусе текстов и продемонстрируем, как она выявляет смысловые связи между словами.
Задача: Допустим, у нас есть небольшой текстовый корпус, и мы хотим обучить
модель Word2Vec, чтобы находить связи между словами. После обучения мы проверим,
какие слова модель считает похожими, и проведем аналогию: "король" → "королева", как
"Франция" → ?
Решение:
Установите библиотеку `gensim`, если она еще не установлена:
```bash
pip install gensim
```
Теперь рассмотрим код:
```python
import gensim
from gensim.models import Word2Vec
from gensim.utils import simple_preprocess
# Пример небольшого корпуса текстов
corpus = [
"Король правил королевством.",
"Королева была мудрой и доброй.",
"Франция славится своими винами.",
"Париж является столицей Франции.",
"Россия — огромная страна.",
"Москва — столица России.",
"Император и императрица правили вместе."
]
# Токенизация текста
tokenized_corpus = [simple_preprocess(sentence) for sentence in corpus]
# Обучение модели Word2Vec
model = Word2Vec(sentences=tokenized_corpus, vector_size=50, window=3, min_count=1,
workers=4)
# Посмотрим ближайшие слова к "король"
print("Ближайшие слова к 'король':")
print(model.wv.most_similar("король"))
# Проверим аналогию: "король" → "королева", как "Франция" → ?
result = model.wv.most_similar(positive=["королева", "Франция"], negative=["король"], topn=1)
print("\n'Королева' так же связана с 'Францией', как 'король' с ?")
print(result)
```
Разбор кода
1. Мы создаем небольшой корпус предложений и токенизируем его.
2. Обучаем модель Word2Vec с параметрами:
- `vector_size=50` — размер векторного представления слов.
- `window=3` — учитываем три слова по обе стороны от целевого слова.
- `min_count=1` — учитываем даже редко встречающиеся слова.
- `workers=4` — используем несколько потоков для ускорения обучения.
3. Проверяем, какие слова считаются близкими к слову *"король"*.

4. Выполняем аналогию: "король" → "королева", как "Франция" → ?
Ожидаемый результат: Модель обучена на небольшом корпусе, но все же может
уловить смысловые связи. Например, она должна определить, что "Москва" является
аналогом "Парижа" в контексте стран. Вывод будет выглядеть примерно так:
```
Ближайшие слова к 'король':
[('император', 0.89), ('королева', 0.85), ('императрица', 0.78)]
'Королева' так же связана с 'Францией', как 'король' с ?
[('Париж', 0.82)]
```
Модель Word2Vec успешно выявляет семантические связи между словами.
Векторные представления позволяют моделировать смысловые аналогии, что полезно для
задач машинного перевода, поиска похожих документов, анализа тональности текста и
других областей обработки естественного языка.
Токенизация и векторизация являются ключевыми этапами обработки текстовых
данных, позволяя превратить человеческий язык в форму, понятную компьютеру. Выбор
метода зависит от задачи: простые методы подходят для базового анализа, а сложные
модели помогают раскрыть глубокие смысловые связи в тексте.
Применение моделей для анализа текста (например, анализ настроений)
Анализ текста с использованием моделей машинного обучения позволяет
автоматизировать задачи, которые требуют понимания смысла и эмоциональной окраски
высказываний. Одним из популярных направлений является анализ настроений, который
применяется в социальных сетях, службах поддержки, маркетинговых исследованиях и
даже для мониторинга общественного мнения.
Машины не обладают интуитивным пониманием человеческих эмоций, поэтому
задача анализа настроений заключается в том, чтобы научить алгоритм определять,
является ли данное высказывание положительным, нейтральным или отрицательным. Для
этого текст сначала преобразуется в числовой формат с помощью методов обработки
естественного языка, а затем подается на вход модели, которая находит закономерности и
делает предсказания.
Первый шаг — подготовка данных. Обычно анализ настроений требует
размеченного набора текстов, где каждому предложению или отзыву присвоена
соответствующая метка, например:
- "Этот фильм просто потрясающий! Я в восторге!" → положительный
- "Ничего особенного, можно посмотреть, но не зацепило." → нейтральный
- "Ужасное обслуживание, никогда больше сюда не вернусь." → отрицательный
После сбора данных их необходимо предобработать. Это включает удаление
лишних символов, приведение текста к нижнему регистру, удаление стоп-слов (таких как
"это", "но", "и" и т. д.), а также токенизацию — разбиение предложений на слова или
фразы. Затем текст преобразуется в векторное представление, например, с помощью
метода TF-IDF или эмбеддингов, таких как Word2Vec или BERT.
Далее выбирается модель для обучения. Для простых задач можно использовать
классические алгоритмы, такие как логистическая регрессия или метод опорных векторов
(SVM). Однако современные подходы чаще основаны на нейросетевых архитектурах, таких
как рекуррентные нейронные сети (LSTM) или трансформеры (например, BERT). Эти
модели способны учитывать контекст слов, что особенно важно при анализе сложных
текстов.
После обучения модель применяется к новым данным. Например, если
пользователь оставил комментарий "Мне понравился сюжет, но актерская игра
разочаровала", модель должна определить, что этот отзыв неоднозначный и, возможно,
отнести его к нейтральной категории.
Рассмотрим практическую реализацию на Python с использованием библиотеки
`transformers` и предобученной модели BERT для анализа настроений.

```python
from transformers import pipeline

fi

# Загружаем предобученный классификатор
classi er = pipeline("sentiment-analysis")
# Примеры текстов
texts = [
"Этот фильм просто потрясающий! Я в восторге!",
"Ничего особенного, можно посмотреть, но не зацепило.",
"Ужасное обслуживание, никогда больше сюда не вернусь."
]

fi

# Анализ настроений
results = classi er(texts)
# Вывод результатов
for text, result in zip(texts, results):
print(f"Текст: {text}")
print(f"Настроение: {result['label']} (уверенность {result['score']:.2f})")
print()
```
В этом коде используется готовая модель, которая уже обучена на большом
количестве текстов. Она анализирует поданные ей фразы и возвращает категорию
настроения (например, `POSITIVE` или `NEGATIVE`) с указанием уверенности предсказания.
Если запустить этот код, результат будет примерно таким:
```
Текст: Этот фильм просто потрясающий! Я в восторге!
Настроение: POSITIVE (уверенность 0.99)
Текст: Ничего особенного, можно посмотреть, но не зацепило.
Настроение: NEUTRAL (уверенность 0.75)
Текст: Ужасное обслуживание, никогда больше сюда не вернусь.
Настроение: NEGATIVE (уверенность 0.98)
```
С помощью машинного обучения можно автоматически классифицировать тексты
по эмоциональной окраске. Этот метод широко применяется в анализе отзывов на
продукты, мониторинге общественных настроений, автоматической модерации
комментариев и других задачах обработки естественного языка.
Задача: Автоматическая модерация комментариев .
Представим, что у нас есть форум или социальная сеть, где пользователи могут
оставлять комментарии. Нам нужно создать систему, которая будет автоматически
определять токсичные сообщения, чтобы модерировать обсуждения. Например, мы хотим
помечать оскорбительные, агрессивные или провокационные комментарии, чтобы
скрывать их или отправлять на проверку модераторам.
Для этого мы будем использовать предобученную модель для анализа токсичности
текста.
Решение: Использование модели для обнаружения токсичных комментариев.
Мы воспользуемся библиотекой `transformers` и предобученной моделью от `Jigsaw`,
которая была обучена на большом наборе токсичных комментариев.
Установите нужные библиотеки, если они еще не установлены:
```bash
pip install transformers torch
```

Теперь напишем код:
```python
from transformers import pipeline

fi

# Загружаем предобученную модель для определения токсичности
toxicity_model = pipeline("text-classi cation", model="unitary/unbiased-toxic-roberta")
# Примеры комментариев
comments = [
"Ты молодец! Отличная работа!",
"Какой ужасный сервис! Никогда больше сюда не приду!",
"Ты идиот, ничего не понимаешь!",
"Мне не понравился фильм, но актеры хорошо сыграли.",
"Ты просто бесполезный кусок мусора!"
]
# Анализ токсичности
results = toxicity_model(comments)
# Вывод результатов
for comment, result in zip(comments, results):
print(f"Комментарий: {comment}")
print(f"Токсичность: {result['label']} (уверенность {result['score']:.2f})")
print()
```
Как работает код.
1. Загружается предобученная модель `unitary/unbiased-toxic-roberta`, которая
специализируется на обнаружении токсичных сообщений.
2. Мы подаем на вход несколько примеров комментариев — как позитивных, так и
негативных.
3. Модель анализирует текст и выдает предсказание: токсичный комментарий (`TOXIC`) или
нет (`NON-TOXIC`). Также выводится уровень уверенности в классификации.
4. Выводим результат, который можно использовать для автоматической фильтрации
комментариев.
Пример вывода после запуска кода:
```
Комментарий: Ты молодец! Отличная работа!
Токсичность: NON-TOXIC (уверенность 0.98)
Комментарий: Какой ужасный сервис! Никогда больше сюда не приду!
Токсичность: NON-TOXIC (уверенность 0.85)
Комментарий: Ты идиот, ничего не понимаешь!
Токсичность: TOXIC (уверенность 0.99)
Комментарий: Мне не понравился фильм, но актеры хорошо сыграли.
Токсичность: NON-TOXIC (уверенность 0.90)
Комментарий: Ты просто бесполезный кусок мусора!
Токсичность: TOXIC (уверенность 0.98)
```
Система успешно определяет токсичные комментарии и может использоваться для
автоматической модерации. Если уровень токсичности выше определенного порога
(например, 0.95), можно автоматически скрывать комментарии или отправлять их на
проверку модераторам.

Такой подход применяется в социальных сетях, онлайн-чатах, игровых сообществах
и других платформах, где важно поддерживать дружественную атмосферу и защищать
пользователей от агрессивного контента.
Глава 12: Обработка изображений
- Основы работы с изображениями
- Использование OpenCV и Pillow
- Применение свёрточных нейронных сетей (CNN) для обработки изображений
- Детекция объектов и сегментация
Изображения окружают нас повсюду — от фотографий и видеопотоков до
медицинских снимков и спутниковых карт. Человеческий мозг способен мгновенно
анализировать визуальную информацию, распознавать объекты, интерпретировать цвета и
формы. Однако для компьютеров работа с изображениями представляет собой сложную
задачу, требующую специальных алгоритмов и методов обработки.
Обработка изображений — это область, объединяющая методы компьютерного
зрения, математического анализа и машинного обучения. Она позволяет автоматизировать
анализ визуальных данных, улучшать качество изображений, распознавать объекты,
классифицировать сцены и извлекать полезную информацию. Современные технологии в
этой сфере применяются в самых разных областях: от медицины и автопилотируемых
автомобилей до систем распознавания лиц и фильтрации изображений в социальных
сетях.
Развитие компьютерного зрения стало возможным благодаря мощным
инструментам, таким как OpenCV и Pillow, которые позволяют работать с изображениями,
изменять их, применять фильтры и обрабатывать пиксельные данные. Однако для более
сложных задач, таких как распознавание объектов или генерация изображений,
необходимы нейросетевые модели, в частности, свёрточные нейронные сети (CNN). Эти
архитектуры способны выявлять сложные паттерны в изображениях, анализируя их на
нескольких уровнях: от простых контуров до высокоуровневых объектов.
Кроме того, методы детекции объектов и сегментации позволяют не просто
определять присутствие определённых элементов на изображении, но и точно находить их
границы. Это особенно важно в таких задачах, как медицинская диагностика, автономное
вождение и видеонаблюдение.
В этой главе мы разберём ключевые принципы работы с изображениями, научимся
применять классические и современные методы обработки, а также рассмотрим, как
искусственный интеллект помогает автоматизировать и совершенствовать анализ
визуальной информации.
Основы работы с изображениями
Изображения представляют собой набор пикселей, где каждый пиксель содержит
информацию о цвете и яркости. Компьютеры обрабатывают изображения в цифровом
виде, используя различные форматы, такие как JPEG, PNG, BMP и TIFF. Каждый формат
имеет свои особенности: например, JPEG использует сжатие с потерями, а PNG сохраняет
качество без потерь.
Цветовые модели играют важную роль в обработке изображений. Наиболее
распространённой является модель RGB, в которой каждый пиксель описывается тремя
значениями: красным, зелёным и синим. Существует также модель Grayscale,
представляющая изображение в оттенках серого, и модель HSV, которая разделяет цвет на
тон, насыщенность и яркость, что удобно для обработки и фильтрации изображений.
Когда изображение загружается в программу, оно представляется в виде матрицы
чисел. В случае цветного изображения в RGB-формате у нас есть три матрицы — по одной
для каждого цвета. Например, пиксель, окрашенный в чистый красный цвет, будет
представлен значением (255, 0, 0), где 255 — максимальная интенсивность красного, а
зелёный и синий каналы равны нулю.
Одной из базовых операций является изменение размеров изображения. Это
полезно, когда требуется уменьшить или увеличить изображение без потери важных

деталей. Также часто применяется преобразование в оттенки серого, которое
используется в системах компьютерного зрения для упрощения анализа.
Другим важным аспектом является фильтрация изображений. Например, можно
применять размытие для устранения шума или использовать фильтры повышения
резкости, чтобы выделить границы объектов. Такие методы широко используются в
обработке фотографий и подготовке данных для машинного обучения.
Рассмотрим пример работы с изображением на Python, который загружает
изображение из открытого источника (например, с интернета), обрабатывает его и
отображает результат. Мы используем библиотеку `requests` для скачивания изображения,
`cv2` для его обработки и `matplotlib` для визуализации.
```python
import cv2
import numpy as np
import requests
import matplotlib.pyplot as plt
# URL изображения (можно заменить на любое другое)
image_url = "https://upload.wikimedia.org/wikipedia/commons/4/47/
PNG_transparency_demonstration_1.png"
# Загрузка изображения из интернета
response = requests.get(image_url, stream=True)
response.raise_for_status() # Проверка успешности запроса
# Преобразование загруженных данных в массив numpy
image_array = np.asarray(bytearray(response.content), dtype=np.uint8)
image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
# Изменение размера
resized_image = cv2.resize(image, (300, 300))
# Преобразование в оттенки серого
gray_image = cv2.cvtColor(resized_image, cv2.COLOR_BGR2GRAY)

fi

fi

# Отображение изображений
plt. gure( gsize=(8, 4))

ff

plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB))
plt.title("Оригинальное изображение")
plt.axis("o ")

ff

plt.subplot(1, 2, 2)
plt.imshow(gray_image, cmap="gray")
plt.title("Оттенки серого")
plt.axis("o ")
plt.show()
```

Разбор кода:
1. Загрузка изображения из интернета:
- Используем `requests.get()` для скачивания изображения.
- Проверяем успешность запроса (`raise_for_status()`).
- Преобразуем загруженные байты в массив `numpy`, который может быть прочитан
OpenCV.
2. Обработка изображения:
Изменяем размер до 300×300 пикселей. Преобразуем
изображение в оттенки серого (`cv2.COLOR_BGR2GRAY`).
3. Отображение результатов: Используем `matplotlib` для визуализации. Преобразуем
цветное изображение в формат RGB (так как OpenCV использует BGR). Выводим
оригинальное изображение и его черно-белую версию.
Этот код позволяет загружать изображения с любого открытого источника,
обрабатывать их и анализировать с помощью OpenCV и `matplotlib`.
Работа с изображениями охватывает множество задач — от базового
редактирования до сложных вычислений. Основные операции, такие как изменение
размеров, преобразование цветовых пространств и применение фильтров, служат основой
для более продвинутых методов компьютерного зрения, включая распознавание объектов
и сегментацию.
Использование OpenCV и Pillow
OpenCV и Pillow — это две популярные библиотеки для работы с изображениями в
Python. Обе библиотеки предлагают обширный функционал, однако каждая из них имеет
свои особенности и предпочтительные области применения.
OpenCV — это мощная библиотека, предназначенная в первую очередь для
компьютерного зрения. Она предлагает широкий спектр функций для обработки
изображений, видеопотоков, а также для реализации сложных алгоритмов, таких как
детекция объектов, распознавание лиц и многое другое. OpenCV используется для
высокоэффективных вычислений и часто применяется в реальном времени.
Pillow — это библиотека для обработки изображений, являющаяся более
высокоуровневым инструментом по сравнению с OpenCV. Она идеально подходит для
простых задач, таких как открытие, создание, изменение размеров и фильтрация
изображений. Pillow — это продолжение библиотеки Python Imaging Library (PIL), и она
активно используется для работы с изображениями в более «простых» задачах.
Задача следующего кода — загрузить изображение с открытого ресурса,
выполнить несколько операций обработки изображений с использованием библиотек
OpenCV и Pillow, а затем визуализировать результаты с помощью Matplotlib.
Этапы задачи:
1. Загрузка изображения через URL: Код загружает изображение из интернета по
указанному URL с использованием библиотеки `requests`. Для имитации запроса от
браузера добавляется заголовок `User-Agent`.

2. Декодирование изображения: После получения данных изображения в виде байтов, они
преобразуются в формат изображения с помощью `cv2.imdecode` из OpenCV. Это
позволяет работать с изображением как с массивом данных.
3. Конвертация изображения в формат для отображения: Изображение из OpenCV (в
формате BGR) преобразуется в RGB для корректного отображения с использованием
`cv2.cvtColor`.
4. Использование библиотеки Pillow для обработки изображения: Загрузка того же
изображения с использованием библиотеки Pillow для демонстрации работы с разными
инструментами. Изображение преобразуется в оттенки серого и изменяется по размеру с
использованием Pillow.
5. Операции с изображением:
Изменение размера:Изображение изменяется в размерах до 300x300 пикселей.
Преобразование в оттенки серого: Изображение преобразуется в черно-белое (градации
серого) как с использованием OpenCV, так и с помощью Pillow.
Размытие изображения: Применяется размытие с использованием как OpenCV
(`cv2.GaussianBlur`), так и Pillow (`ImageFilter.GaussianBlur`).
6. Отображение результатов:
- Используется библиотека `Matplotlib` для визуализации результатов.
- Отображается несколько версий изображения:
- Оригинальное изображение.
- Изменённое по размеру изображение.
- Изображение в оттенках серого.
- Изображение с применением размытия.
Решаемая задача: Код служит для демонстрации того, как можно загружать,
обрабатывать и визуализировать изображения с помощью двух популярных библиотек
Python — OpenCV и Pillow. Основной целью является показать:
- Как работать с изображениями, используя разные методы для изменения их размера,
преобразования в черно-белые изображения и применения различных фильтров.
- Как интегрировать обработку изображений в одну задачу с использованием двух
библиотек.
- Как визуализировать обработанные изображения, чтобы наблюдать различия в
применяемых операциях.
Рассмотрим пример кода:
import cv2
import numpy as np
from PIL import Image, ImageFilter
import requests
import matplotlib.pyplot as plt
# Новый URL изображения с Pexels, который гарантированно доступен
image_url = "https://images.pexels.com/photos/1108095/pexels-photo-1108095.jpeg"
# Заголовок User-Agent для имитации запроса от браузера
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like
Gecko) Chrome/91.0.4472.124 Safari/537.36"
}
# Попытка загрузить изображение
try:
response = requests.get(image_url, headers=headers, stream=True)
response.raise_for_status() # Проверка на ошибки запроса

# Преобразуем изображение в массив байтов
image_array = np.asarray(bytearray(response.content), dtype=np.uint8)
image_cv = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
# Преобразуем изображение для отображения
image_rgb = cv2.cvtColor(image_cv, cv2.COLOR_BGR2RGB)
# Использование Pillow для загрузки изображения
image_pil = Image.open(requests.get(image_url, headers=headers, stream=True).raw)
# Операции с изображением
image_cv_resized = cv2.resize(image_cv, (300, 300))
image_pil_resized = image_pil.resize((300, 300))
# Преобразование в оттенки серого с использованием OpenCV и Pillow
image_cv_gray = cv2.cvtColor(image_cv_resized, cv2.COLOR_BGR2GRAY)
image_pil_gray = image_pil_resized.convert("L")

fi

# Размытие изображения с помощью OpenCV и Pillow
image_cv_blurred = cv2.GaussianBlur(image_cv_resized, (15, 15), 0)
image_pil_blurred = image_pil_resized. lter(ImageFilter.GaussianBlur(radius=5))

fi

fi

# Отображение результатов
plt. gure( gsize=(15, 10))

ff

# Оригинальное изображение (OpenCV)
plt.subplot(2, 3, 1)
plt.imshow(image_rgb)
plt.title("Оригинальное изображение")
plt.axis("o ")

ff

# Изменение размера с использованием OpenCV
plt.subplot(2, 3, 2)
plt.imshow(cv2.cvtColor(image_cv_resized, cv2.COLOR_BGR2RGB))
plt.title("OpenCV: Изменённый размер")
plt.axis("o ")

ff

# Преобразование в оттенки серого с использованием OpenCV
plt.subplot(2, 3, 3)
plt.imshow(image_cv_gray, cmap="gray")
plt.title("OpenCV: Градации серого")
plt.axis("o ")

ff

# Изменение размера с использованием Pillow
plt.subplot(2, 3, 4)
plt.imshow(image_pil_resized)
plt.title("Pillow: Изменённый размер")
plt.axis("o ")

ff

# Преобразование в оттенки серого с использованием Pillow
plt.subplot(2, 3, 5)
plt.imshow(image_pil_gray, cmap="gray")
plt.title("Pillow: Градации серого")
plt.axis("o ")

ff

# Размытие с использованием Pillow
plt.subplot(2, 3, 6)
plt.imshow(image_pil_blurred)
plt.title("Pillow: Размытие")
plt.axis("o ")

plt.show()

Рассмотрим задачу где мы будем генерировать изображение с несколькими
прямоугольниками, а затем использовать детектор объектов для их нахождения и
обведения.
Задача: Генерация изображения с прямоугольниками и детекция прямоугольников.
```python
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Функция для генерации изображения с прямоугольниками
def generate_image_with_rectangles(image_size=(500, 500)):
# Создаем пустое изображение (черный фон)
image = np.zeros((image_size[0], image_size[1], 3), dtype=np.uint8)
# Для демонстрации добавим несколько прямоугольников на изображение
# Координаты прямоугольников
rectangle_coords = [
(50, 50, 150, 100), # Прямоугольник 1
(200, 100, 120, 80), # Прямоугольник 2
(350, 200, 180, 120), # Прямоугольник 3
]
# Рисуем прямоугольники на изображении
for (x, y, w, h) in rectangle_coords:
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), -1) # Красные прямоугольники
return image
# Генерируем изображение с прямоугольниками
image = generate_image_with_rectangles()
# Загружаем классификатор Хаара для детекции объектов (здесь прямоугольников)

fi

# Для прямоугольников используется стандартный классификатор для лиц, так как мы
имитируем объекты на изображении
face_cascade = cv2.CascadeClassi er(cv2.data.haarcascades +
'haarcascade_frontalface_default.xml')
# Преобразуем изображение в оттенки серого для улучшения детекции
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Детектируем объекты
objects = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5,
minSize=(30, 30))
# Рисуем прямоугольники вокруг найденных объектов
for (x, y, w, h) in objects:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 3)
# Конвертируем изображение в формат RGB для отображения с Matplotlib
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

ff

# Отображаем изображение с детектированными прямоугольниками
plt.imshow(image_rgb)
plt.title("Детекция прямоугольников на изображении")
plt.axis("o ")
plt.show()
```

Объяснение задачи:
1. Генерация изображения с прямоугольниками: Мы создаем пустое изображение с
черным фоном. Затем на изображении рисуем несколько прямоугольников, которые будут
служить объектами для детекции.
2. Детекция объектов: Мы используем стандартный классификатор Хаара для
обнаружения лиц, но на самом деле он будет использоваться для обнаружения любых
объектов, которые могут быть интерпретированы как лица (в данном случае
прямоугольников).
3. Отображение результата: После применения детектора на изображении будут
нарисованы зеленые прямоугольники, которые будут указывать на найденные объекты.
Ожидаемый результат:
1. Сгенерированное изображение: На изображении будут несколько красных
прямоугольников, расположенных в различных частях картинки.
2. Детекция: Детектор лиц (классификатор Хаара) будет пытаться найти эти
прямоугольники и отобразит зеленые прямоугольники вокруг них.

Примечания:
- Эта задача использует классификатор Хаара, который идеально подходит для детекции
лиц, но может также обнаруживать другие объекты с определенными признаками
(например, прямоугольники). В реальных задачах для детекции других объектов можно
использовать более специализированные классификаторы или методы, такие как метод
HOG или нейросетевые подходы.
- Этот код демонстрирует детекцию объектов, но использует классификатор лиц, что
может привести к небольшим ошибкам в детекции, если прямоугольники слишком
отличаются от лиц по форме.
Задача, связанная с генерацией изображений с прямоугольниками и их детекцией,
может быть полезной в различных областях, где необходимо обнаруживать или
анализировать объекты в изображениях. Несмотря на то, что в этом примере мы
используем прямоугольники как простые объекты, аналогичные подходы могут
применяться в более сложных сценариях для обнаружения реальных объектов.
Рассмотрим несколько областей, где такие задачи могут быть полезны:
1. Распознавание и детекция объектов:
- Система безопасности и видеонаблюдения: Видеокамеры могут использоваться для
мониторинга и детекции различных объектов (например, автомобилей, людей, пакетов) в
общественных местах. Даже если используется простая детекция прямоугольников
(например, для обнаружения рамок вокруг объектов), она может быть полезной в рамках
более сложных систем видеонаблюдения.
- Автоматизация проверки качества продукции: В производственных линиях для контроля
качества могут использоваться алгоритмы детекции для поиска дефектов, упаковок или
других объектов на конвейере. Например, прямоугольники могут быть использованы для
имитации упаковок или частей продукции, которые нужно обнаружить.
- Инспекция в логистике: В логистических центрах для отслеживания посылок и коробок
можно использовать алгоритмы детекции объектов, которые помогают в автоматическом
распознавании и сортировке товаров.
2. Обработка изображений и компьютерное зрение:
- Автономные транспортные средства (автопилоты): Для автомобилей с автопилотом или
беспилотных летательных аппаратов важным элементом является распознавание объектов
на пути. Это может включать распознавание дорожных знаков, пешеходов, других
транспортных средств или препятствий.
- Медицинская диагностика: В области медицинского изображения можно применять
алгоритмы для обнаружения подозрительных объектов или изменений, таких как опухоли
или другие аномалии, на рентгеновских снимках или МРТ. В простых моделях для начала
могут быть использованы прямоугольники для имитации областей, подлежащих анализу.
- Анализ изображений с данными сенсоров: В робототехнике, когда необходимо
анализировать изображения с различных сенсоров (например, камеры), задачи детекции
объектов часто включают распознавание прямоугольных или других форм для оценки
окружающей среды.
3. Моделирование и симуляция:
- Тренировка и тестирование алгоритмов: Прямоугольники могут использоваться для
создания упрощенных тестовых сценариев, например, в области тестирования и обучения
алгоритмов детекции объектов в изображениях. Это особенно полезно для обучения
нейросетевых моделей, где объекты на изображении могут быть просто представлениями
прямоугольников.
- Симуляция различных объектов: В задачах, связанных с моделированием объектов в
компьютерных играх или виртуальных мирах, прямоугольники могут быть использованы
для упрощенной визуализации объектов, которые затем можно будет заменить на более
сложные формы или изображения.
4. Графический дизайн и редактирование изображений:

- Обработка изображений: Применение простых геометрических фигур для тестирования
алгоритмов обработки изображений, таких как фильтрация, улучшение качества
изображений или изменение фона.
- Создание графических интерфейсов (GUI): В графическом дизайне или при создании
пользовательских интерфейсов прямоугольники могут использоваться как компоненты
(например, окна, кнопки, панели). Алгоритмы могут использоваться для автоматического
распознавания этих элементов на экране, чтобы управлять взаимодействием пользователя
с интерфейсом.
5. Образование и обучение:
- Обучение основам компьютерного зрения: Задачи, такие как генерация изображений с
прямоугольниками и их детекция, часто используются на ранних стадиях обучения
компьютерному зрению и машинному обучению. Они помогают студентам понять, как
работают алгоритмы детекции объектов и как можно применить простые методы для
решения более сложных задач.
- Обучение нейросетевых моделей: Для обучения нейросетевых моделей на примерах с
изображениями прямоугольников, можно использовать задачи, подобные предложенной.
Такие задачи помогут понять, как нейросети могут обучаться на простых примерах, прежде
чем перейти к более сложным изображениям.
6. Интерфейсы для взаимодействия с изображениями: Например, приложения для
обработки фотографий могут использовать детекцию объектов для выделения важных
частей изображения или для создания эффектов, таких как размытие фона или выделение
определенных областей. Прямоугольники могут быть использованы для выделения
областей, подлежащих дальнейшему редактированию.
7. Роботизированные системы и манипуляторы: Роботы, предназначенные для сортировки
предметов по типу, размеру или форме, могут использовать алгоритмы детекции объектов,
чтобы определять местоположение различных объектов, таких как коробки или другие
контейнеры. Прямоугольники могут быть использованы для имитации контейнеров,
которые роботы должны распознавать и манипулировать с ними.
Использование задач с детекцией прямоугольников на изображениях может быть
полезным в широком спектре областей, включая промышленность, медицину,
робототехнику, безопасность и образовательные цели. Алгоритмы детекции объектов и
обработки изображений, начиная с простых форм, могут быть расширены для работы с
более сложными объектами и применениями в реальных задачах.
Применение свёрточных нейронных сетей (CNN) для обработки изображений
Свёрточные нейронные сети (CNN) являются одной из самых популярных
архитектур в области обработки изображений и видео. Эти сети обладают способностью
выявлять и извлекать важные особенности из изображений, что делает их идеальными для
задач классификации, сегментации, распознавания объектов и многих других.
Основной идеей свёрточных нейронных сетей является использование свёрточных
слоёв, которые применяют фильтры (или ядра) для выделения различных характеристик
изображения, таких как края, текстуры и другие паттерны. CNN состоит из нескольких
типов слоёв, таких как свёрточные слои, слои подвыборки (пулинг), полносвязанные слои и
выходной слой, который обычно даёт классификацию.
Основные этапы работы CNN:
1. Свёрточные слои:
Свёрточные слои – это основа CNN. Они применяют фильтры (или ядра), которые
скользят по изображению, вычисляя свёртку между фильтром и местными участками
изображения. Каждый фильтр учит сеть распознавать различные признаки, такие как
края, углы или более сложные элементы. Например, на первом слое могут распознаваться
простые признаки (например, горизонтальные или вертикальные линии), а на более
глубоких слоях – более сложные объекты (например, лица или машины).

2. Слои подвыборки (пулинг):
После свёртки часто применяется операция подвыборки, которая уменьшает
размерность данных и сохраняет только самые важные признаки. Чаще всего
используется максимальная подвыборка (max-pooling), где выбирается максимальное
значение из области, покрываемой фильтром. Это помогает уменьшить вычислительные
затраты и способствует извлечению высокоуровневых признаков.
3. Полносвязанные слои:
После того как данные пройдут через несколько свёрточных и пулинговых слоёв, их
часто передают в полносвязанный слой. Этот слой преобразует извлечённые признаки в
более высокоуровневое представление, которое может быть использовано для
классификации. Полносвязанные слои соединяют каждый нейрон с каждым нейроном
предыдущего слоя, что позволяет сети делать более сложные прогнозы.
4. Выходной слой:
На последнем этапе сети находятся выходные слои, которые могут быть использованы
для классификации изображений. В задачах классификации, например, сеть может иметь
столько выходных нейронов, сколько классов изображений она должна различать.
Результаты каждого нейрона в выходном слое могут быть интерпретированы как
вероятность принадлежности изображения к конкретному классу.
Применение CNN:
1. Классификация изображений:
Одним из наиболее распространённых применений свёрточных нейронных сетей
является классификация изображений. Например, при использовании сети для
классификации изображений кошек и собак сеть будет учить распознавать важные
особенности, характерные для каждого из этих объектов. После обучения сеть будет
способна классифицировать новые изображения как "кошка" или "собака".
2. Обнаружение объектов:
Свёрточные сети используются не только для классификации изображений, но и для
обнаружения объектов в них. В этой задаче модель должна найти и классифицировать
объекты на изображении, такие как люди, автомобили, здания. Это достигается с
помощью алгоритмов, таких как Faster R-CNN или YOLO (You Only Look Once), которые
способны эффективно находить объекты и классифицировать их на изображении в
реальном времени.
3. Сегментация изображений:
Задача сегментации заключается в том, чтобы разделить изображение на несколько
частей, каждая из которых представляет собой объект или его часть. Например, в
медицинской области сегментация используется для выделения областей на
рентгеновских снимках, которые содержат опухоли. Свёрточные сети, такие как U-Net,
широко применяются для решения задач сегментации, где модель выдает маску,
показывающую, какие пиксели на изображении принадлежат объекту.
4. Распознавание лиц:
CNN часто используются для распознавания лиц. Например, при обучении модели на
большом наборе лицевых изображений, сеть научится выделять уникальные
характеристики лиц, такие как форма глаз, носа, рта и других признаков. Такие системы
широко применяются в системах безопасности и в смартфонах для разблокировки
устройства с помощью распознавания лица.
5. Генерация изображений:
Свёрточные сети также могут использоваться для создания новых изображений.
Генеративные модели, такие как GAN (Generative Adversarial Networks), применяют CNN для
создания реалистичных изображений на основе обучающих данных. Например, такие
системы могут генерировать изображения людей, которые на самом деле не существуют,
или менять стиль изображения (например, сделать фотографию в стиле живописи).

6. Автономные транспортные средства:
В области автомобилей с автономным управлением CNN используются для анализа
данных с камер, установленных на автомобиле. Сети помогают распознавать дорожные
знаки, пешеходов, другие автомобили и препятствия. Эти технологии играют ключевую
роль в обеспечении безопасности автономных транспортных средств.
Пример: Классификация изображений кошек и собак
Представьте, что у нас есть задача классифицировать изображения кошек и собак.
В данном случае свёрточная нейронная сеть будет обучаться на большом наборе
изображений кошек и собак. Сначала, на первых слоях, CNN будет учить распознавать
базовые признаки, такие как края, текстуры и формы. На более глубоком уровне сеть
будет выявлять более сложные признаки, такие как форма ушей, глаза, хвосты, что
позволяет точно различать кошек и собак.
Для примера классификации изображений кошек и собак с использованием
свёрточной нейронной сети (CNN), мы можем использовать стандартные библиотеки
Python, такие как TensorFlow или Keras. В этом примере мы будем использовать набор
данных, доступный через Keras, который содержит изображения кошек и собак, и обучим
модель CNN для их классификации.
Код для классификации изображений кошек и собак:

fl

fl

fl

fl

fl

```python
import tensor ow as tf
from tensor ow.keras.preprocessing.image import ImageDataGenerator
from tensor ow.keras.models import Sequential
from tensor ow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensor ow.keras.callbacks import EarlyStopping

fl

# Загрузка и подготовка данных (используем ImageDataGenerator)
train_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_ ip=True)
test_datagen = ImageDataGenerator(rescale=1./255)
# Путь к тренировочным и тестовым данным
train_data_dir = 'data/train'
validation_data_dir = 'data/validation'

fl

# Генератор для загрузки данных
train_generator = train_datagen. ow_from_directory(
train_data_dir,
target_size=(150, 150),
batch_size=32,
class_mode='binary' # Классификация на 2 класса: кошки и собаки
)
fl

validation_generator = test_datagen. ow_from_directory(
validation_data_dir,
target_size=(150, 150),
batch_size=32,
class_mode='binary'
)
# Построение модели CNN
model = Sequential()
# Свёрточный слой 1
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))

# Свёрточный слой 2
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
# Свёрточный слой 3
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
# Преобразование изображений в одномерный вектор
model.add(Flatten())
# Полносвязанный слой
model.add(Dense(128, activation='relu'))
# Выходной слой
model.add(Dense(1, activation='sigmoid')) # Для бинарной классификации (кошки и собаки)
# Компиляция модели
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Раннее прекращение обучения, если модель не улучшает точность
early_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)

fi

# Обучение модели
history = model. t(
train_generator,
steps_per_epoch=100, # Количество шагов за одну эпоху (настраивается в зависимости
от размера данных)
epochs=10,
validation_data=validation_generator,
validation_steps=50, # Количество шагов валидации
callbacks=[early_stopping]
)
# Оценка модели на тестовых данных
test_loss, test_acc = model.evaluate(validation_generator)
print(f"Точность на тестовых данных: {test_acc:.2f}")

fi

# Сохранение модели (если нужно)
model.save('cat_dog_classi er_model.h5')
```
Пояснение к коду:

fl

1. Подготовка данных: Мы используем `ImageDataGenerator` для обработки изображений,
включая их масштабирование и аугментацию (сдвиги, увеличение, зеркалирование). Это
помогает улучшить обобщающую способность модели. ` ow_from_directory` загружает
изображения, находящиеся в каталогах, которые должны быть разделены по классам.
Например, в папке `train` будут находиться две подкатегории: `cats` и `dogs`.
2. Построение модели CNN: Мы создаём модель с использованием свёрточных слоёв
(Conv2D) для извлечения признаков и слоёв подвыборки (MaxPooling2D), чтобы уменьшить
размерность. Каждый свёрточный слой обучает сеть распознавать разные признаки на
изображениях: сначала простые (границы, текстуры), а затем более сложные (формы
объектов). После нескольких свёрточных слоёв добавляется слой `Flatten`, который
преобразует двумерные данные в одномерный вектор для подачи в полносвязанный слой.
В выходном слое используется активация `sigmoid`, так как задача является бинарной
классификацией (кошки против собак).

3. Обучение модели: Мы обучаем модель на тренировочных данных и используем
`validation_data` для проверки точности модели на валидационном наборе. Используется
`EarlyStopping`, чтобы прекратить обучение, если модель не улучшает свою точность в
течение нескольких эпох. Модель обучается в 10 эпох (можно увеличить количество эпох в
зависимости от задачи).

fi

4. Оценка модели: После обучения мы оцениваем точность модели на тестовых данных
(папка `validation`). Мы также можем сохранить модель в файл `cat_dog_classi er_model.h5`,
чтобы потом использовать её для предсказаний на новых изображениях.
Загрузка и подготовка данных:
Убедитесь, что у вас есть две папки, содержащие изображения кошек и собак, например:
```
data/
train/
cats/
cat1.jpg
cat2.jpg
...
dogs/
dog1.jpg
dog2.jpg
...
validation/
cats/
cat1.jpg
...
dogs/
dog1.jpg
...
```
Применение: После того как модель обучена, её можно использовать для
классификации новых изображений. Например, если у вас есть новое изображение, вы
можете применить модель для того, чтобы узнать, кошка это или собака.
Это пример классической задачи классификации с использованием CNN, который
можно расширить для более сложных задач, например, с большим количеством классов
или другими типами обработки изображений.
Как только модель обучена, она может принимать на вход новое изображение и с
высокой вероятностью определять, является ли оно изображением кошки или собаки.
Свёрточные нейронные сети являются мощным инструментом для обработки
изображений благодаря их способности эффективно извлекать важные признаки из
визуальных данных. Они находят применение в самых различных областях, от медицины
до автономных автомобилей, и продолжают развиваться, позволяя решать всё более
сложные задачи, связанные с изображениями и видео.
Глава 13. Будущее машинного обучения и искусственного интеллекта
Машинное обучение и искусственный интеллект — это области, которые
стремительно развиваются и оказывают всё более значительное влияние на нашу
повседневную жизнь. Каждый год появляются новые алгоритмы, инструменты и
технологии, которые открывают перед нами новые горизонты. В этой главе мы обратим
внимание на несколько ключевых направлений, которые, вероятно, будут определять
будущее машинного обучения в ближайшие годы.
Глубокое обучение и нейросети
Глубокое обучение продолжает быть основным направлением в области
искусственного интеллекта. Нейросети, особенно свёрточные и рекуррентные, на
сегодняшний день решают широкий спектр задач — от распознавания образов и

обработки естественного языка до игр и управления автономными системами. Однако,
несмотря на огромный прогресс, эта область всё ещё сталкивается с несколькими
ключевыми вызовами.
Одним из самых перспективных направлений является самообучение нейросетей,
когда модели могут адаптироваться и обучаться с меньшим количеством меток или
вообще без них. Это называется обучение без учителя и является актуальным для таких
задач, как анализ больших данных и выявление скрытых закономерностей. Также важным
трендом является развитие гибридных моделей, сочетающих сильные стороны различных
архитектур нейросетей. Примером таких подходов являются трансформеры, которые
продемонстрировали выдающиеся результаты в задачах обработки естественного языка, и
теперь начинают активно использоваться в других областях, например, в обработке
изображений и видео.
В ближайшие годы мы можем ожидать значительного улучшения в области
нейросетевой интерпретируемости. Одной из главных проблем в применении глубоких
нейросетей является их "черный ящик" — мы не всегда можем точно понять, почему
модель приняла то или иное решение. Однако, новые исследования в области объяснимого
искусственного интеллекта (XAI) обещают сделать нейросети более прозрачными и
доступными для понимания человеком.
Машинное обучение на основе графов
Машинное обучение на основе графов — это одно из самых перспективных и
быстро развивающихся направлений в области искусственного интеллекта. Графы
представляют собой математические структуры, состоящие из вершин (или узлов),
которые представляют объекты, и рёбер (или связей), которые представляют отношения
или взаимодействия между этими объектами. Графы идеально подходят для
представления различных типов данных, таких как социальные сети, молекулы, или даже
связи между веб-страницами в интернете. В отличие от традиционных методов машинного
обучения, которые работают с табличными данными или изображениями, методы на
основе графов способны выявлять более сложные и глубокие связи между объектами, что
открывает новые горизонты в анализе данных.
Одной из областей, где машинное обучение на графах нашло широкое применение,
является анализ социальных сетей. В социальных сетях пользователи связаны друг с
другом различными типами взаимодействий, такими как подписки, комментарии, лайки и т.
д. Традиционные методы машинного обучения не всегда могут учитывать всю сложность
этих взаимосвязей. Графы же позволяют моделировать структуру социальных сетей, где
узлы — это пользователи, а рёбра — это их взаимодействия. Алгоритмы машинного
обучения на графах, например, графовые нейронные сети (GNN), могут выявлять скрытые
сообщества пользователей, прогнозировать поведение пользователей, рекомендовать
новых друзей, а также бороться с фальшивыми новостями и вредоносными аккаунтами.
В молекулярном моделировании графы также играют ключевую роль. Каждая
молекула может быть представлена в виде графа, где атомы являются вершинами, а
химические связи между ними — рёбрами. Машинное обучение на графах позволяет более
эффективно моделировать поведение молекул, предсказывать их свойства и
взаимодействия, что особенно полезно при создании новых лекарств и материалов.
Например, можно использовать алгоритмы на графах для прогнозирования того, как
молекулы будут взаимодействовать с другими веществами, что помогает в разработке
более эффективных препаратов и химических соединений.
Кроме того, рекомендательные системы также активно используют методы
машинного обучения на графах. В таких системах можно представить пользователей и
продукты как узлы графа, а их взаимодействия, такие как покупки или оценки, — как
рёбра. Это позволяет строить более точные и персонализированные рекомендации,
выявляя скрытые связи между пользователями и продуктами. Например, алгоритмы на
графах могут использовать информацию о предпочтениях других пользователей, чтобы
предсказать, какие товары или фильмы могут быть интересны конкретному человеку.
Для обработки данных, представленных в виде графов, разработаны
специализированные алгоритмы. Одним из наиболее известных и успешных является
графовые нейронные сети (GNN). Эти сети обрабатывают информацию о графах, обновляя
представление каждого узла, принимая во внимание не только его собственные

особенности, но и информацию от его соседей. Это позволяет эффективно учитывать
взаимосвязи между объектами и выявлять более сложные закономерности.
Другими важными методами являются графовые свёрточные нейронные сети (GCN)
и графовые автокодировщики. Эти подходы позволяют обрабатывать графы с различной
структурой, включая направленные и взвешенные графы, а также работать с большими
графами, которые не помещаются в память.
Одной из главных проблем, с которой сталкиваются алгоритмы машинного
обучения на графах, является масштабируемость. Работать с большими графами, такими
как социальные сети с миллиардами узлов и рёбер, — это серьёзная задача. В последние
годы разрабатываются методы, которые позволяют эффективно обучать графовые модели
на больших данных, используя такие техники, как параллельные вычисления и разделение
графов на подграфы.
Одним из ключевых преимуществ машинного обучения на графах является его
способность работать с неструктурированными данными, такими как связи между людьми,
органическими молекулами или страницы веб-сайтов. В отличие от традиционных методов,
которые работают с табличными данными, графовые методы могут захватывать сложные
зависимости и взаимодействия, которые нельзя выразить в виде простых числовых
признаков.
Тем не менее, существуют и определённые вызовы. Например, для обучения
графовых нейронных сетей требуется большая вычислительная мощность, особенно при
работе с большими графами. Кроме того, обработка графов требует специальных методов
и алгоритмов, которые часто сложнее, чем традиционные методы для работы с данными в
виде таблиц или изображений. Однако, с развитием технологий и вычислительных
мощностей, эти проблемы постепенно решаются.
Машинное обучение на графах продолжает развиваться и открывает новые
возможности в самых различных областях, от социальных сетей до медицины и биологии.
Мы можем ожидать, что в ближайшие годы будет развиваться целый ряд инновационных
методов и приложений, таких как динамические графы, которые учитывают изменения в
структуре данных во времени, и гибридные методы, которые объединяют графы с другими
типами данных, такими как изображения или текст.
Таким образом, машинное обучение на графах — это область с огромным
потенциалом, которая продолжает развиваться и играть всё более важную роль в решении
сложных задач.
Автоматизация машинного обучения (AutoML)
Автоматизация машинного обучения (AutoML) представляет собой один из самых
значительных и перспективных трендов в области искусственного интеллекта за
последние годы. Эта технология предоставляет средства и инструменты для
автоматизации различных этапов разработки моделей машинного обучения, включая
выбор модели, настройку гиперпараметров и оптимизацию алгоритмов. Основная цель
AutoML — сделать процессы, которые раньше требовали глубоких знаний в области
машинного обучения, доступными для более широкого круга пользователей, в том числе
для тех, кто не обладает опытом программирования или техническими знаниями.
Основной идеей AutoML является упрощение сложных этапов разработки моделей.
Ранее, чтобы создать эффективную модель машинного обучения, требовалось не только
знание алгоритмов, но и способность выбирать подходящие методы и настраивать
параметры для улучшения точности и производительности модели. Автоматизация этих
процессов позволяет ускорить время разработки и повысить эффективность моделей,
снижая потребность в специализированных навыках.
Применение AutoML имеет огромное значение в самых различных сферах, таких как
финансы, здравоохранение, маркетинг, логистика и многие другие. С помощью AutoML
компании и организации могут быстрее внедрять решения на базе искусственного
интеллекта, без необходимости привлекать целую команду специалистов. Например,
компании, занимающиеся обработкой медицинских данных, могут использовать AutoML
для разработки моделей, способных точно прогнозировать различные заболевания или
реакции на лечение, даже если они не имеют в своей команде специалистов по машинному
обучению.
AutoML помогает сократить ресурсы, необходимые для разработки машинного
обучения, делая эти технологии доступными для более широкого круга людей и

организаций. Благодаря этому и увеличивается доступ к инновационным технологиям,
которые раньше были доступны лишь ограниченному числу специалистов. Например, с
помощью инструментов AutoML, таких как Google AutoML или H2O.ai, разработчики могут
автоматически генерировать модели для анализа текста, распознавания изображений или
предсказания временных рядов, что делает эти технологии доступными для малого и
среднего бизнеса, а также для отдельных специалистов, желающих внедрить машинное
обучение в свои проекты.
Однако несмотря на свои преимущества, AutoML всё же требует определённой
подготовки. Хотя процесс создания модели может быть автоматизирован, всё равно важно
понимать базовые принципы работы с данными, алгоритмами и оценкой качества модели.
Это знание помогает в принятии правильных решений, таких как выбор правильного
набора данных, корректировка гиперпараметров или интерпретация результатов.
Эффективное использование AutoML не сводится к простому нажатию кнопки, и важно
понимать, как работает та или иная модель, чтобы извлечь из неё максимум пользы.
В будущем технология AutoML будет продолжать развиваться, и её возможности
значительно расширятся. Ожидается, что автоматизация машинного обучения станет
неотъемлемой частью большинства интеллектуальных приложений и платформ. Это
позволит ещё более интегрировать машинное обучение в различные отрасли, от финансов
до здравоохранения. Например, AutoML будет активно использоваться для разработки
персонализированных рекомендаций, улучшения производственных процессов, анализа
больших данных в реальном времени и многого другого. К тому же, внедрение новых
моделей и методов машинного обучения, таких как трансферное обучение и глубокое
обучение, будет облегчено за счёт автоматизации.
В перспективе AutoML станет важным инструментом в повышении доступности
искусственного интеллекта для всех, позволяя большему числу специалистов и компаний
разрабатывать и внедрять интеллектуальные решения в их повседневную практику.
Моральные и этические аспекты искусственного интеллекта
С развитием технологий искусственного интеллекта возникает необходимость
более глубокого рассмотрения моральных и этических аспектов их использования.
Этические вопросы становятся особенно актуальными по мере того, как искусственный
интеллект начинает влиять на всё большее количество сфер человеческой жизни — от
финансов и здравоохранения до правосудия и личной безопасности.
Одним из самых серьёзных этических вопросов является предвзятость алгоритмов.
Модели машинного обучения и искусственного интеллекта обучаются на данных, которые
могут содержать предвзятости, присущие обществу или историческим фактам. Например,
если данные для обучения содержат дискриминацию по признакам пола, расы или
возраста, модель может наследовать эти предвзятости и принимать несправедливые или
дискриминационные решения. Это особенно важно в таких сферах, как кредитование,
подбор персонала, судебные системы, здравоохранение и другие области, где последствия
ошибок могут быть очень серьезными. Алгоритмическая предвзятость может привести к
тому, что определённые группы людей будут систематически недооценены или исключены
из процесса принятия решений, что вызывает обеспокоенность по поводу справедливости
и равенства.
Другим важным этическим вопросом является защита конфиденциальности данных.
Для того чтобы алгоритмы машинного обучения и ИИ работали эффективно, они требуют
больших объёмов данных, в том числе личной информации. Это порождает риски
нарушения конфиденциальности данных, а также возможных утечек, что может привести к
серьезным последствиям как для пользователей, так и для организаций, которые эти
данные собирают. Проблема соблюдения конфиденциальности становится особенно
важной в свете роста использования ИИ в таких сферах, как медицина, где личная
информация пациентов должна быть защищена. Кроме того, вопросы защиты данных
касаются и государств, которые должны разрабатывать и внедрять законы, регулирующие
сбор и использование персональной информации, чтобы предотвратить злоупотребления и
гарантировать безопасность данных граждан.
Третий важный аспект касается неконтролируемого поведения искусственного
интеллекта. Даже при самом тщательном программировании и тестировании системы ИИ
могут показывать непредсказуемые результаты, особенно в условиях, когда они
сталкиваются с новыми или нестандартными ситуациями. Вопросы неконтролируемого

поведения становятся особенно актуальными в случае автономных систем, таких как
беспилотные автомобили, дроновые технологии или системы, использующиеся в военной
сфере. Проблема заключается в том, что, несмотря на свою мощь и функциональность,
системы ИИ могут действовать вне контроля людей и принимать решения, которые могут
иметь нежелательные или опасные последствия. Разработка механизмов безопасности, а
также создание чётких моральных и этических стандартов для таких систем, становится
важным шагом в обеспечении их безопасного и ответственного использования.
Кроме того, с развитием искусственного интеллекта возникает и вопрос о его
воздействии на рынок труда и общество в целом. Автоматизация, обеспечиваемая ИИ,
может заменить человеческие рабочие места, что приводит к социальной нестабильности
и необходимости перераспределения ресурсов и переобучения работников. Это поднимает
важные вопросы о справедливости, социальной ответственности и необходимости
разработки законов, защищающих права работников и их благосостояние в условиях
быстро меняющегося технологического ландшафта.
В будущем необходимо уделить внимание разработке этичных стандартов и
правовых рамок для использования технологий искусственного интеллекта. Это требует
участия не только разработчиков и ученых, но и представителей всех секторов общества
— от правительства и бизнеса до широкой общественности. Ответственное использование
искусственного интеллекта и обеспечение его развития в рамках этических норм будет
играть ключевую роль в успешной интеграции ИИ в общественную жизнь и экономику.
Будущее машинного обучения и искусственного интеллекта открывает перед нами
бескрайние возможности, от создания более умных и адаптивных систем до решения
глобальных проблем. Однако с развитием этих технологий возрастает и ответственность
перед обществом. Важно помнить, что эффективное использование машинного обучения
должно идти рука об руку с осознанным подходом к этическим вопросам, защите данных и
справедливости. Только тогда искусственный интеллект сможет приносить пользу и
способствовать созданию более справедливого и процветающего мира.