Машинное обучение на Python: от основ до практики

Введение в машинное обучение и экосистему Python

Что такое машинное обучение

Машинное обучение — это подход к решению задач, при котором мы не прописываем правила вручную, а обучаем программу находить закономерности в данных. На практике это выглядит так:

У нас есть данные (например, характеристики квартир).

Есть цель (например, предсказать цену).

Мы выбираем алгоритм и обучаем модель на примерах.

Затем используем модель для прогнозов на новых данных.

Машинное обучение особенно полезно там, где:

Правила слишком сложны или неизвестны заранее.

Данных много, и в них есть повторяющиеся закономерности.

Нужно автоматизировать прогнозы или классификацию.

Какие задачи решает машинное обучение

В курсе мы будем опираться на три основных типа задач.

Обучение с учителем

Обучение с учителем — это ситуация, когда для каждого примера в данных известен правильный ответ (его часто называют целевой переменной).

Классификация: ответ — категория.

- Примеры: спам или не спам; дефект или нет; клиент уйдёт или останется.

Регрессия: ответ — число.

- Примеры: цена квартиры; спрос на товар; время доставки.

Обучение без учителя

Обучение без учителя — это задачи, где правильных ответов нет, и мы пытаемся найти структуру в данных.

Кластеризация: группировка похожих объектов.

Снижение размерности: сжатие признаков с минимальной потерей информации (часто для визуализации и ускорения).

Обучение с подкреплением

Обучение с подкреплением — это когда агент учится действовать в среде, получая награды и штрафы.

Примеры: игры, робототехника, управление ресурсами.

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

Из чего состоит типичный ML-проект

Ниже — базовый жизненный цикл проекта, который мы будем повторять на практике много раз.

!Общая схема этапов ML-проекта от данных до использования модели

Данные и признаки

Признаки — это измеримые свойства объектов, которые мы подаём в модель (например, площадь, этаж, район). Целевая переменная — то, что мы хотим предсказать (например, цена).

Типичные проблемы с данными:

Пропуски (нет значений в части строк).

Ошибки и выбросы (некорректные или экстремальные значения).

Категориальные значения (например, "район"), которые нужно корректно представить численно.

Разделение на обучающую и тестовую выборки

Чтобы честно оценить качество модели, данные разделяют:

Train (обучающая выборка) — на ней модель учится.

Test (тестовая выборка) — на ней проверяют качество на данных, которые модель не видела.

Часто также выделяют:

Validation (валидационная выборка) — для подбора настроек модели (например, глубины дерева) без подглядывания в тест.

Ключевая идея: тестовую выборку используют как финальный экзамен модели.

Модель, обучение и ошибка

Модель — это функция, которая получает признаки и выдаёт предсказание.

Чтобы модель стала полезной, нужно настроить её параметры так, чтобы предсказания были близки к правильным ответам. Для этого выбирают функцию ошибки — число, показывающее, насколько модель ошибается.

Для регрессии популярна среднеквадратичная ошибка (Mean Squared Error, MSE):

Расшифровка:

— количество объектов, по которым считаем ошибку.

— истинное значение целевой переменной для объекта .

— предсказание модели для объекта .

— величина ошибки (насколько промахнулись).

Возведение в квадрат — делает ошибки положительными и сильнее штрафует большие промахи.

Сумма — складываем ошибки по всем объектам.

Деление на — получаем среднее значение ошибки.

Важно: в классификации чаще используют другие метрики (например, точность или F1), потому что там цель — правильно угадать класс.

Переобучение и недообучение

Две типичные ситуации при обучении:

Недообучение — модель слишком простая и не улавливает закономерности даже на train.

Переобучение — модель отлично запомнила train, но плохо работает на новых данных.

Интуитивно:

Недообучение — "не понял задачу".

Переобучение — "выучил ответы наизусть".

Утечка данных

Утечка данных — это когда в обучении (или предобработке) случайно используется информация, которая в реальной жизни недоступна на момент предсказания.

Примеры:

Нормализация по всем данным до разделения на train/test.

Признак, который напрямую содержит ответ (или его часть), например "факт просрочки" при прогнозе "будет ли просрочка".

В курсе мы будем постоянно следить за тем, чтобы оценка качества была честной.

Почему Python — основной язык для машинного обучения

Python стал стандартом де-факто в машинном обучении по нескольким причинам:

Простой синтаксис и быстрый старт.

Огромная экосистема библиотек.

Удобная среда для экспериментов (ноутбуки), визуализации и прототипирования.

Много готовых реализаций алгоритмов и инструментов для подготовки данных.

Экосистема Python для ML: ключевые инструменты

Ниже — набор библиотек, с которым вы будете сталкиваться чаще всего.

Среда работы

Python — язык программирования.

Jupyter — интерактивные ноутбуки для экспериментов, графиков и объяснений.

Работа с данными

NumPy — быстрые массивы и математика.

pandas — таблицы (DataFrame), фильтрация, агрегации, загрузка данных.

Визуализация

Matplotlib — базовые графики.

Seaborn — удобные статистические визуализации поверх Matplotlib.

Машинное обучение

scikit-learn — основной набор классических ML-алгоритмов, метрик и инструментов (пайплайны, кросс-валидация).

Дополнительно (по мере надобности)

SciPy — численные методы и научные вычисления.

Statsmodels — статистические модели и интерпретация результатов.

Минимальный пример: обучение модели в scikit-learn

Ниже пример, который показывает саму идею: загрузили данные, разделили, обучили, измерили качество.

Что здесь происходит:

load_iris даёт учебный набор данных.

train_test_split создаёт train и test.

fit обучает модель.

predict делает предсказания.

accuracy_score измеряет долю правильных ответов.

Как будет устроен курс

В следующих материалах мы постепенно соберём полный практический набор навыков:

Научимся уверенно работать с данными в pandas и NumPy.

Разберём предобработку: пропуски, категории, масштабирование.

Изучим базовые модели (линейные, деревья, ансамбли).

Научимся правильно оценивать качество (метрики, кросс-валидация) и избегать переобучения.

Соберём воспроизводимые пайплайны в scikit-learn и применим их к реальным задачам.

Итоги

Машинное обучение — способ строить модели, которые учатся на данных.

Основные типы задач: с учителем, без учителя, с подкреплением.

Типичный ML-процесс: данные → предобработка → train/test → обучение → оценка → улучшение.

Python удобен благодаря зрелой экосистеме: NumPy, pandas, Matplotlib/Seaborn, scikit-learn, Jupyter.

Подготовка данных: очистка, признаки и разбиение выборок

В прошлой статье мы разобрали общий цикл ML-проекта: данные → обучение → оценка качества. На практике почти всегда оказывается, что качество модели в первую очередь зависит не от «волшебного алгоритма», а от того, насколько аккуратно подготовлены данные.

В этой статье вы научитесь базовому, но критически важному набору навыков:

понимать, какие данные у вас в таблице и какие проблемы в них встречаются

очищать данные: пропуски, дубликаты, неверные значения

превращать «сырые» столбцы в признаки, которые умеют использовать модели

правильно делить данные на выборки и избегать утечки данных

!Общая схема этапов подготовки данных перед обучением модели

Что считать данными и что считать признаками

В табличных задачах обычно есть:

Признаки — столбцы, которые описывают объект.

Целевая переменная — то, что нужно предсказать.

Пример: прогноз цены квартиры.

Признаки: площадь, этаж, район, год постройки.

Цель: цена.

Важно не перепутать:

столбец может выглядеть «полезным», но быть недоступным в реальности на момент предсказания

столбец может напрямую содержать ответ (или его часть), и тогда модель «жульничает»

Это приводит к утечке данных, о которой поговорим ниже.

Быстрый аудит таблицы в pandas

Перед любыми преобразованиями сделайте краткую проверку.

Что полезно увидеть сразу:

сколько строк и столбцов

какие типы данных (int, float, object, datetime)

где много пропусков

есть ли странные типы (например, числа, которые прочитались как строки)

Очистка данных

Очистка не означает «сделать идеально». Цель — убрать очевидные проблемы, которые ломают обучение или сильно искажают закономерности.

Пропуски

Пропуски бывают по разным причинам: пользователь не заполнил поле, датчик не сработал, данные не собрали. Стратегия зависит от смысла столбца.

Базовые подходы:

удалить строки или столбцы, если пропусков слишком много и их восстановление сомнительно

заполнить числовые пропуски медианой или средним

заполнить категориальные пропуски отдельной категорией вроде "Unknown"

добавить бинарный признак «было ли пропущено значение», если сам факт пропуска может быть информативным

Пример простого заполнения в pandas:

На практике в ML-пайплайнах чаще используют инструменты scikit-learn, чтобы избежать утечки данных и корректно применять преобразования к train и test.

Ссылка: Документация pandas про пропуски

Дубликаты

Дубликаты могут появляться из-за повторной выгрузки или склейки источников.

Иногда дубликат — это не полностью одинаковая строка, а повтор по ключу (например, user_id). Тогда правила зависят от задачи.

Неверные значения и выбросы

Выброс — это значение, которое сильно отличается от остальных. Он может быть:

ошибкой (например, отрицательный возраст)

редким, но реальным случаем (очень дорогая квартира)

Минимальные проверки здравого смысла:

Если выбросы реальны, их не всегда нужно удалять. Иногда достаточно:

использовать робастные модели (например, деревья)

ограничить значения (клиппинг)

применить преобразование (например, логарифм для сильно перекошенных распределений)

Превращаем столбцы в признаки

Большинство моделей (особенно из scikit-learn) ожидают числовой массив. Значит, строки, даты и категории нужно корректно закодировать.

Числовые признаки и масштабирование

Некоторые модели чувствительны к масштабу признаков:

линейные модели

метод опорных векторов

k ближайших соседей

градиентные методы, где используется расстояние

Для них часто используют стандартизацию (StandardScaler) или нормализацию. Для деревьев решений масштабирование обычно не критично.

Ссылка: StandardScaler в scikit-learn

Категориальные признаки и кодирование

Частый случай: столбец city содержит значения вроде "Moscow", "Kazan". Модели не умеют работать со строками напрямую.

Базовый подход для небольшого числа категорий — one-hot кодирование.

Ссылка: OneHotEncoder в scikit-learn

Важно помнить:

если категорий очень много (например, user_id), one-hot создаст тысячи столбцов

для таких случаев применяют другие стратегии (частотное кодирование, target encoding), но их нужно делать особенно аккуратно, чтобы не создать утечку

Даты и время

Дата редко полезна «как строка». Обычно из неё извлекают признаки:

год, месяц, день недели

признак «выходной/будний»

время с момента события

Пример:

Простая инженерия признаков

Инженерия признаков — это осмысленное создание новых признаков из существующих. Часто самые простые идеи дают сильный эффект:

отношения и доли (например, rooms / area)

логарифм суммы или цены при сильной асимметрии

агрегаты по группе (например, средняя цена по району) — но такие признаки нужно строить особенно осторожно, чтобы не использовать информацию из test

Разбиение данных на выборки

Разбиение нужно, чтобы честно оценить обобщающую способность модели.

Базовая схема:

train: обучение

validation: подбор гиперпараметров и сравнение вариантов

test: финальная проверка, один раз в конце

!Наглядное разбиение данных на train/validation/test

Случайное разбиение и воспроизводимость

Самый частый вариант — случайно перемешать и разделить.

Зачем нужен random_state:

фиксирует случайность

результаты можно воспроизвести

проще сравнивать эксперименты

Ссылка: train_test_split в scikit-learn

Стратификация в классификации

Если классы несбалансированы (например, 95% не-спам и 5% спам), случайное разбиение может «перекосить» доли классов в test.

Тогда используют stratify=y.

Временные ряды и данные со временем

Если данные упорядочены по времени, случайное перемешивание часто запрещено.

Пример: прогноз спроса по дням.

Правильнее:

обучаться на прошлом

тестироваться на будущем

Иначе модель может случайно увидеть «будущие» закономерности в обучении.

Утечка данных и правильный порядок действий

Утечка данных — это когда в обучение попадает информация, недоступная при реальном предсказании. Классическая ошибка: сделать предобработку по всем данным, а потом разделить.

Примеры утечки:

масштабирование или заполнение пропусков по всей таблице до разбиения

построение агрегатов с использованием всей таблицы

признаки, которые появляются только после события (например, «факт оплаты» при прогнозе «оплатит ли клиент»)

Правило:

сначала разделяем на выборки

затем обучаем все преобразования только на train

затем применяем к validation и test

Как автоматизировать это в scikit-learn: Pipeline и ColumnTransformer

Чтобы не забывать порядок действий, используют пайплайны.

Ссылка: Pipeline в scikit-learn

Пример: числовые столбцы заполняем медианой и масштабируем, категориальные — заполняем и one-hot кодируем.

Почему это хороший стиль:

никакой утечки: имьютер, scaler и encoder обучаются только на train

один объект управляет всем процессом

такой код проще переносить в продакшн

Ссылка: ColumnTransformer в scikit-learn

Итоги

Подготовка данных — основа качества модели.

Минимальный набор очистки: пропуски, дубликаты, неверные значения.

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

Разбиение на выборки нужно для честной оценки.

Главная защита от утечки данных — правильный порядок действий и использование Pipeline.

Регрессия: линейные модели и метрики качества

В предыдущих статьях мы разобрали, что такое машинное обучение, как устроен типичный ML-проект и почему подготовка данных (пропуски, кодирование категорий, разбиение на выборки, защита от утечки) критически важна.

Теперь перейдём к первой «рабочей лошади» практического ML для числовых прогнозов: регрессии и, в частности, линейным моделям. Они простые, быстрые, часто дают хороший базовый результат и помогают понять, как признаки связаны с целевой переменной.

Что такое регрессия

Регрессия — это задача, где целевая переменная является числом.

Примеры:

прогноз цены квартиры

прогноз количества заказов на завтра

оценка времени доставки

Данные обычно выглядят так:

— таблица признаков (столбцы: площадь, этаж, район и т.д.)

— числовая цель (например, цена)

Линейная регрессия как модель

Идея линейной модели

Линейная регрессия предполагает, что целевая переменная выражается как взвешенная сумма признаков.

В одном наблюдении модель записывают так:

Разберём обозначения:

— предсказание модели для объекта

— свободный член (иногда говорят intercept), базовый уровень предсказания

— значения признаков объекта

— коэффициенты (веса) при признаках

— количество признаков

Интуиция: если положительный, то при росте предсказание обычно растёт; если отрицательный — уменьшается.

!Прямая как приближение зависимости между признаком и целевой переменной

Остатки и ошибка

Для каждого объекта есть ошибка предсказания (остаток):

Где:

— истинное значение цели

— предсказание модели

— насколько промахнулись на объекте

Как обучается линейная регрессия

Обучение — это подбор коэффициентов и так, чтобы модель в среднем ошибалась как можно меньше на обучающей выборке.

Самый распространённый критерий — среднеквадратичная ошибка (MSE).

Пояснение каждого элемента:

— число объектов, по которым считаем качество

— истинный ответ для объекта

— предсказание модели для объекта

— ошибка на объекте

— квадрат делает ошибки неотрицательными и сильнее штрафует большие промахи

— суммируем ошибки по всем объектам

деление на — берём среднее

В scikit-learn линейная регрессия реализована как модель, которая подбирает параметры автоматически.

Ссылка: LinearRegression в scikit-learn

Метрики качества регрессии

Оценивать качество нужно на данных, которые модель не видела при обучении (обычно на test, как мы обсуждали ранее). В регрессии нет одной «единственно правильной» метрики: выбор зависит от задачи.

MAE: средняя абсолютная ошибка

Что означают элементы:

— абсолютная величина ошибки (без знака)

остальное похоже на MSE: суммируем и усредняем по

Свойства:

измеряется в тех же единицах, что и цель (например, в рублях)

менее чувствительна к редким большим промахам, чем MSE

Ссылка: mean_absolute_error в scikit-learn

MSE и RMSE: ошибка с усиленным штрафом за большие промахи

Мы уже видели MSE. Часто удобнее интерпретировать корень из MSE — RMSE:

Пояснение:

— квадратный корень

RMSE снова выражается в единицах цели (как MAE), но сильнее реагирует на большие ошибки

Ссылки:

mean_squared_error в scikit-learn

: доля объяснённой вариации

показывает, насколько модель лучше простого базового предсказания «всем одно и то же». В scikit-learn это базовое предсказание соответствует константе, равной среднему значению на обучающей выборке.

Упрощённая интерпретация:

— идеальные предсказания

— не лучше, чем предсказывать среднее

— хуже, чем предсказывать среднее (такое бывает)

Ссылка: r2_score в scikit-learn

> Практический совет: для бизнес-интерпретации часто удобнее MAE (понятно «на сколько в среднем ошибаемся»), а для задач, где большие промахи особенно дороги, полезно смотреть RMSE.

Почему важен baseline

Перед усложнением модели полезно сделать baseline — простое решение, с которым вы сравниваете всё остальное.

Для регрессии типичный baseline:

предсказывать среднее значение (или медиану) для всех объектов

Если модель линейной регрессии почти не выигрывает у baseline, значит:

признаки слабые или подготовлены неправильно

есть сильные выбросы, и метрика «наказывает»

в данных недостаточно информации для точного прогноза

В scikit-learn есть готовая baseline-модель.

Ссылка: DummyRegressor в scikit-learn

Предобработка и линейные модели: что критично

Линейные модели чувствительнее к подготовке данных, чем деревья.

Обычно важно:

корректно обработать пропуски

закодировать категории (например, one-hot)

масштабировать числовые признаки, если планируются регуляризованные модели или сравнение коэффициентов

И главное: делать это без утечки — обучать преобразования только на train. Поэтому снова используем Pipeline и ColumnTransformer, как в прошлой статье.

Ссылки:

Pipeline в scikit-learn

ColumnTransformer в scikit-learn

Практический пример: линейная регрессия с пайплайном и метриками

Ниже шаблон, который можно адаптировать под свой датасет.

Почему это правильный стиль:

заполнение пропусков, масштабирование и one-hot обучаются только на X_train

к X_test применяется уже «выученная» предобработка, без утечки

метрики считаются на тесте, то есть имитируют качество на новых данных

Регуляризация: Ridge и Lasso (когда и зачем)

Иногда обычная линейная регрессия становится нестабильной:

много признаков

признаки сильно коррелируют друг с другом

модель переобучается (на train хорошо, на test хуже)

Тогда используют регуляризацию — мягкое ограничение на величину коэффициентов.

Ridge-регрессия

Ridge добавляет штраф за большие коэффициенты. В упрощённом виде:

Пояснение:

— итоговая функция, которую минимизируем при обучении

— ошибка на данных

— сумма квадратов коэффициентов (штраф)

— насколько сильный штраф; чем больше , тем сильнее «сжимаются» коэффициенты

Ridge обычно:

улучшает качество на тесте при переобучении

оставляет все признаки в модели, но делает их влияние более аккуратным

Ссылка: Ridge в scikit-learn

Lasso-регрессия

Lasso использует другой штраф и может занулять часть коэффициентов, то есть делать простой отбор признаков:

Пояснение:

— модуль коэффициента

при достаточно большом некоторые могут стать ровно нулём

Ссылка: Lasso в scikit-learn

> Важно: регуляризация особенно чувствительна к масштабу признаков, поэтому StandardScaler в пайплайне часто обязателен.

Частые ошибки в регрессии

обучение предобработки на всех данных до разбиения (утечка)

оценка качества на train вместо test

игнорирование baseline

использование без понимания масштаба ошибки (в бизнесе часто важнее MAE/RMSE)

попытка интерпретировать коэффициенты без учёта one-hot кодирования и масштабирования

Итоги

Регрессия — прогноз числа.

Линейная регрессия предсказывает как сумму признаков с весами.

Основные метрики: MAE (понятна в единицах цели), RMSE (сильнее штрафует большие промахи), (сравнение с предсказанием среднего).

Всегда делайте baseline и оценивайте на test.

Для честной оценки и защиты от утечки используйте Pipeline и ColumnTransformer.

Если линейная регрессия переобучается или признаков много, попробуйте Ridge или Lasso.

Классификация: базовые алгоритмы и оценка результатов

В предыдущих статьях мы разобрали жизненный цикл ML-проекта, подготовку данных (включая защиту от утечки с помощью Pipeline) и регрессию, где модель предсказывает число.

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

какие бывают задачи классификации

базовые алгоритмы в scikit-learn

как правильно оценивать результат (и почему одной accuracy часто недостаточно)

как работать с порогом решения и дисбалансом классов

Что такое классификация

Классификация — это задача, где целевая переменная принимает значения из набора классов.

Примеры:

спам / не спам

мошенническая операция / нормальная

клиент уйдёт / не уйдёт

тип цветка: setosa / versicolor / virginica

Основные типы задач классификации

Бинарная классификация: 2 класса (например, 0/1).

Многоклассовая классификация: 3 и более классов (например, 0/1/2).

Мульти-лейбл: у объекта может быть несколько меток сразу (например, у статьи несколько тем).

В этой статье основной фокус — на бинарной и многоклассовой классификации в scikit-learn.

Что именно выдаёт классификатор

Многие классификаторы умеют выдавать не только класс, но и оценку уверенности.

Чаще всего есть два метода:

predict(X) возвращает предсказанный класс

predict_proba(X) возвращает вероятности классов (если модель это поддерживает)

Для бинарной классификации обычно получают вероятность положительного класса , а затем сравнивают её с порогом.

Порог классификации

Идея простая:

если , предсказываем класс 1

иначе предсказываем класс 0

Где — порог (часто по умолчанию ).

Почему это важно:

при повышении порога модель реже ставит класс 1

при снижении порога модель чаще ставит класс 1

Это напрямую влияет на ошибки разных типов, о которых мы поговорим в метриках.

Базовые алгоритмы классификации

Ниже — несколько алгоритмов, с которых удобно начинать. Все они доступны в scikit-learn.

Логистическая регрессия

Несмотря на слово регрессия в названии, логистическая регрессия — это классификатор. Он строит линейную границу между классами и часто является отличным baseline.

Практические свойства:

хорошо работает на табличных данных

быстро обучается

часто требует масштабирования числовых признаков

поддерживает predict_proba

Документация: LogisticRegression в scikit-learn

k ближайших соседей

kNN классифицирует объект по классам ближайших соседей в пространстве признаков.

Практические свойства:

качество сильно зависит от масштаба признаков, обычно нужен StandardScaler

может быть медленным на больших датасетах

хорошо подходит как простой ориентир и для небольших задач

Документация: KNeighborsClassifier в scikit-learn

Дерево решений

Дерево решений строит набор правил вида если признак меньше/больше порога, идём влево/вправо.

Практические свойства:

не требует масштабирования

легко переобучается без ограничений (важны max_depth, min_samples_leaf)

умеет работать с нелинейными зависимостями

Документация: DecisionTreeClassifier в scikit-learn

Наивный Байес

Наивный Байес — семейство простых вероятностных моделей, часто используемых для текстов (например, спам-фильтры).

Практические свойства:

очень быстрый

хорошо работает на разреженных признаках (например, bag-of-words)

делает сильные упрощающие предположения, но иногда выигрывает благодаря устойчивости

Документация: Naive Bayes в scikit-learn

Baseline для классификации

Как и в регрессии, в классификации полезно начать с baseline.

Пример baseline-стратегий:

всегда предсказывать самый частый класс

предсказывать классы случайно с сохранением долей

В scikit-learn это реализовано в DummyClassifier.

Baseline помогает не обмануть себя: если ваша «умная» модель почти не лучше baseline, обычно проблема в признаках, утечке, разбиении или постановке задачи.

Оценка качества: почему accuracy недостаточно

В классификации важно понимать не только сколько ошибок, но и каких именно.

Матрица ошибок

Для бинарной классификации удобно использовать матрицу ошибок (confusion matrix). Она показывает, сколько объектов каждого истинного класса модель отнесла к каждому предсказанному.

истинный класс 1, предсказали 1: верно (часто называют true positives)

истинный класс 0, предсказали 0: верно (часто называют true negatives)

истинный класс 0, предсказали 1: ложная тревога (часто называют false positives)

истинный класс 1, предсказали 0: пропуск (часто называют false negatives)

!Матрица ошибок помогает понять типы ошибок модели

В scikit-learn: confusion_matrix.

Accuracy

Accuracy — доля правильных ответов.

Её удобно использовать, когда:

классы примерно сбалансированы

цена ошибок разных типов примерно одинаковая

Но при дисбалансе классов accuracy может быть обманчивой. Пример: если 99% объектов — класс 0, то модель, которая всегда говорит 0, даст accuracy 0.99, но будет бесполезной.

Precision, Recall, F1

Когда важен именно положительный класс (например, мошенничество, заболевание), часто смотрят precision и recall.

Определения (для положительного класса 1):

Где:

— число объектов класса 1, которые модель правильно предсказала как 1

— число объектов класса 0, которые модель ошибочно предсказала как 1

— сколько всего модель предсказала как класс 1

Интуиция: если модель сказала “1”, как часто она права.

Где:

— число объектов класса 1, которые модель ошибочно предсказала как 0

— сколько всего объектов действительно относится к классу 1

Интуиция: сколько настоящих “1” мы нашли.

F1 — одна из популярных сводных метрик, которая балансирует precision и recall:

Где:

и — значения метрик выше

произведение растёт, когда обе метрики высокие

сумма нормализует результат

множитель делает масштаб удобным: от 0 до 1

В scikit-learn часто используют готовый отчёт: classification_report.

ROC-AUC и PR-AUC

Если модель выдаёт вероятности, можно оценивать её качество на всех порогах сразу.

ROC-AUC полезен как универсальная метрика ранжирования, но при сильном дисбалансе может выглядеть слишком оптимистично.

PR-AUC (area under precision-recall curve) часто информативнее при редком положительном классе.

В scikit-learn:

roc_auc_score

RocCurveDisplay

PrecisionRecallDisplay

!ROC и PR кривые показывают качество модели при разных порогах

Дисбаланс классов и стратификация

Если классы распределены неравномерно, важно:

делать разбиение со стратификацией, чтобы доли классов в train и test были похожи

выбирать метрики, устойчивые к дисбалансу (часто F1, PR-AUC, recall)

внимательно подбирать порог (иногда 0.5 не подходит)

Разбиение: train_test_split с параметром stratify=y.

Практический пример: пайплайн, метрики, матрица ошибок

Ниже — пример для бинарной классификации на встроенном датасете о раке молочной железы. Он демонстрирует правильную структуру:

train/test split

pipeline (предобработка + модель)

оценка несколькими метриками

confusion matrix

ROC-AUC по вероятностям

Что важно в этом примере:

StandardScaler обучается только на X_train (пайплайн защищает от утечки)

ROC-AUC считается по y_proba, потому что метрике нужно ранжирование, а не жёсткий класс

одновременно считаются несколько метрик: так проще заметить перекосы

Как выбрать метрику под задачу

Удобное практическое правило:

если цена ошибок примерно одинаковая и классы сбалансированы, начните с accuracy

если ложные тревоги дорогие, повышайте precision и подбирайте порог

если пропуски дорогие, повышайте recall и подбирайте порог

если нужен баланс precision и recall, используйте F1

если модель выдаёт вероятности и важен ранжирующий смысл, добавьте ROC-AUC и PR-кривую

В прикладной задаче лучше заранее сформулировать, какая ошибка хуже:

назвать честного клиента мошенником

пропустить мошенника

Это решение определяет метрику и порог.

Частые ошибки в классификации

оценивать качество только по accuracy при дисбалансе классов

сравнивать модели по метрике, не соответствующей бизнес-стоимости ошибок

выбирать порог 0.5 по умолчанию и не проверять, что будет при других порогах

делать предобработку до разбиения на train/test (утечка данных)

подбирать гиперпараметры и порог, глядя на test (test должен быть финальным экзаменом)

Итоги

Классификация — предсказание класса (бинарного или многоклассового).

Многие модели выдают вероятности, а класс получается сравнением с порогом.

Базовые алгоритмы: логистическая регрессия, kNN, дерево решений, наивный Байес.

Для оценки качества важны не только accuracy, но и confusion matrix, precision, recall, F1, ROC-AUC и PR-кривые.

При дисбалансе классов используйте стратификацию и метрики, учитывающие редкий класс.

Для честной оценки и защиты от утечки используйте Pipeline.

Неподконтрольное обучение: кластеризация и снижение размерности

В предыдущих статьях курса мы работали с обучением с учителем: у нас были признаки и целевая переменная , а качество измерялось метриками на test.

В неподконтрольном обучении (его также называют обучением без учителя) целевой переменной нет: у нас есть только , и мы пытаемся найти структуру в данных. Два самых частых направления:

Кластеризация: разбить объекты на группы похожих.

Снижение размерности: сжать признаки так, чтобы сохранить максимум полезной информации.

!Схема двух основных задач неподконтрольного обучения

Когда неподконтрольное обучение особенно полезно

Сегментация: например, группы клиентов по похожему поведению.

Исследование данных: понять, есть ли естественные группы, насколько данные однородны.

Визуализация: свести много признаков к 2–3, чтобы увидеть структуру.

Предобработка для моделей: уменьшить число признаков или убрать шум.

Важно: в неподконтрольном обучении редко бывает одна “идеально правильная” разметка. Поэтому особенно важны здравый смысл, проверка устойчивости результата и интерпретация.

Кластеризация

Что такое кластер

Кластер — группа объектов, которые похожи друг на друга и не похожи на объекты из других групп. Похожесть обычно задают через расстояние в пространстве признаков.

Отсюда сразу следует практический вывод.

Если признаки в разных масштабах (например, age в годах и income в рублях), то расстояния будут доминировать тем признаком, где числа больше.

Поэтому для многих алгоритмов кластеризации критично масштабирование.

Ссылка: StandardScaler в scikit-learn

K-means

K-means разбивает данные на кластеров так, чтобы объекты были близки к центрам своих кластеров.

Ключевые идеи:

Нужно заранее задать число кластеров .

Алгоритм чувствителен к масштабу признаков, часто нужен StandardScaler.

Хорошо работает на “компактных” кластерах примерно круглой формы.

Ссылка: KMeans в scikit-learn

Минимальный пример (кластеризация на числовых признаках):

Что возвращает fit_predict:

labels — массив меток кластеров (0, 1, 2, …) для каждого объекта.

Иерархическая кластеризация

Иерархическая кластеризация строит объединения “снизу вверх”: сначала каждый объект сам по себе, затем похожие группы постепенно объединяются.

Практически полезно, когда:

вы не уверены в числе кластеров и хотите посмотреть, как данные “склеиваются” на разных уровнях;

важна интерпретация структуры объединений.

Ссылка: AgglomerativeClustering в scikit-learn

DBSCAN

DBSCAN — алгоритм плотностной кластеризации: он находит области высокой плотности и считает их кластерами.

Плюсы:

не нужно задавать число кластеров;

умеет помечать “шум” (объекты, которые не относятся ни к одному кластеру);

может находить кластеры сложной формы.

Главные параметры:

eps — радиус “соседства”;

min_samples — сколько соседей нужно, чтобы точка считалась “плотной”.

Ссылка: DBSCAN в scikit-learn

DBSCAN тоже чувствителен к масштабу, поэтому масштабирование часто обязательно.

Как оценивать качество кластеризации без “правильных ответов”

В отличие от классификации и регрессии, здесь обычно нет истинных меток. Поэтому используют внутренние метрики и проверку здравого смысла.

Inertia (для K-means)

В K-means есть величина inertia_: чем она меньше, тем плотнее объекты вокруг центров. Но сравнивать её корректно обычно можно только между моделями одного типа на одном и том же наборе признаков.

Популярный приём — метод локтя: перебрать разные и искать точку, где улучшение резко замедляется.

Silhouette score

Silhouette score измеряет, насколько объект ближе к своему кластеру, чем к соседним кластерам. Для одного объекта силуэт определяется так:

Пояснение обозначений:

— силуэт объекта (в диапазоне примерно от -1 до 1).

— среднее расстояние от объекта до объектов внутри своего кластера.

— минимальное среднее расстояние от объекта до объектов в ближайшем другом кластере.

— берём максимум, чтобы нормировать значение и удержать масштаб.

Интерпретация:

ближе к 1: объект хорошо “сидит” в своём кластере;

около 0: объект на границе;

меньше 0: объект скорее ближе к чужому кластеру.

Ссылка: silhouette_score в scikit-learn

Проверка устойчивости

Хорошая практика:

запустить алгоритм с разными random_state (где применимо) и посмотреть, меняется ли структура;

проверить результат на разных поднаборах признаков;

сопоставить кластеры с понятными агрегатами (например, средний чек, частота покупок), чтобы убедиться, что сегменты имеют смысл.

Снижение размерности

Зачем уменьшать число признаков

Визуализация: 2D/3D проекция помогает увидеть группы и выбросы.

Сжатие и ускорение: меньше признаков — быстрее обучение и проще модели.

Шум и мультиколлинеарность: некоторые признаки могут быть избыточны или сильно коррелировать.

!Иллюстрация идеи проекции многомерных данных в 2D

PCA (метод главных компонент)

PCA — линейный метод снижения размерности. Он строит новые признаки (их называют главными компонентами) как линейные комбинации исходных признаков.

Что важно понимать практику:

PCA ищет направления, вдоль которых разброс данных максимален.

Первые компоненты часто несут основную часть информации.

PCA чувствителен к масштабу, обычно используют StandardScaler.

Ссылка: PCA в scikit-learn

Полезная характеристика PCA — доля объяснённой дисперсии.

explained_variance_ratio_ показывает, какую долю “разброса” данных объясняет каждая компонента.

n_components можно выбрать так, чтобы суммарно объяснять, например, 95% дисперсии.

Пример пайплайна “масштабирование + PCA до 2D”:

t-SNE и UMAP (в основном для визуализации)

Есть и нелинейные методы, которые часто дают “красивые” 2D-карты данных.

t-SNE обычно используют для визуализации, а не как универсальную предобработку: он хорошо сохраняет локальные соседства, но глобальные расстояния на карте интерпретировать осторожно.

- Ссылка: t-SNE в scikit-learn

UMAP популярен как более быстрый и часто более стабильный метод визуализации, но он не входит в базовый scikit-learn.

- Ссылка: Документация umap-learn

Комбинации на практике: PCA + кластеризация

Частый рабочий сценарий:

сначала снизить размерность (например, PCA), чтобы убрать шум и корреляции;

затем кластеризовать уже сжатое представление.

Но здесь важно помнить правило из предыдущих статей про утечку данных.

Если вы делаете снижение размерности как часть пайплайна для дальнейшего обучения с учителем (например, сначала PCA, потом классификатор), то PCA нужно обучать только на X_train.

Самый простой способ не ошибиться — использовать Pipeline.

Ссылка: Pipeline в scikit-learn

Практический пример: PCA для 2D и K-means для сегментации

Ниже пример на датасете Iris. В реальной неподконтрольной задаче меток нет, но для учебной демонстрации удобно сравнить кластеры с известными видами.

Что здесь важно:

Мы масштабируем признаки перед PCA и K-means.

Silhouette score считаем по тем признакам, на которых реально кластеризуем (после PCA до 2D).

Массив y_true в коде не нужен для обучения, он только для учебного сравнения.

Типичные ошибки в неподконтрольном обучении

Кластеризовать числовые признаки без масштабирования, когда они в разных единицах.

Выбирать число кластеров “на глаз” без проверки устойчивости и интерпретации.

Пытаться интерпретировать кластеры, не посмотрев, чем они отличаются по исходным признакам.

Использовать t-SNE как “универсальное сжатие для модели”, хотя чаще это инструмент визуализации.

Обучать PCA или кластеризацию на всех данных, а потом использовать результат в модели с учителем, забыв про разделение на train/test.

Итоги

Неподконтрольное обучение работает только с и ищет структуру в данных.

Кластеризация: K-means (нужно ), иерархическая кластеризация (структура объединений), DBSCAN (кластеры по плотности и шум).

Для многих алгоритмов критично масштабирование признаков.

Оценка качества часто делается внутренними метриками (например, silhouette score) и проверкой интерпретации.

Снижение размерности помогает визуализировать и сжимать данные: PCA как базовый линейный метод, t-SNE и UMAP чаще для визуализации.

Если шаги неподконтрольного обучения используются внутри процесса с учителем, применяйте Pipeline, чтобы избежать утечки данных.

Настройка моделей: валидация, регуляризация и подбор гиперпараметров

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

Следующий шаг, без которого почти не бывает хороших решений на практике, это настройка модели:

корректно организовать валидацию, чтобы честно сравнивать варианты

использовать регуляризацию и ограничения, чтобы снижать переобучение

подбирать гиперпараметры (настройки алгоритма) системно и без утечки данных

!Наглядно показывает разницу между разбиением с отдельной валидацией и k-fold кросс-валидацией

Параметры и гиперпараметры

Важно различать два типа «чисел» в модели.

Параметры модели: то, что модель выучивает из данных при fit.

Гиперпараметры: то, что задаём мы перед обучением и что влияет на поведение обучения.

Примеры:

В линейной регрессии параметры это коэффициенты и свободный член .

В дереве решений параметры это сама структура дерева, но она определяется гиперпараметрами вроде max_depth.

В логистической регрессии коэффициенты это параметры, а сила регуляризации это гиперпараметр.

В scikit-learn гиперпараметры вы задаёте в конструкторе модели, например LogisticRegression(C=1.0).

Валидация: зачем нужна отдельная проверка

В прошлых статьях мы делили данные на train/test и оценивали качество на test. Это правильно, но есть проблема: если вы много раз пробуете разные модели и смотрите на test, вы начнёте неявно подгонять решения под тест.

Правило простое:

test это финальный экзамен, его трогают один раз в конце

для выбора модели и гиперпараметров нужна валидация

Holdout-схема train/validation/test

Один из базовых вариантов:

train: обучение модели

validation: выбор гиперпараметров и сравнение вариантов

test: финальная оценка

Плюсы:

быстро

просто объяснить

Минусы:

качество зависит от того, «удачно» ли разбились данные

при небольшом датасете жалко выделять много данных под validation

В scikit-learn отдельного готового разбиения на три части нет, но его легко собрать двумя вызовами train_test_split.

Ссылка: train_test_split (scikit-learn)

Кросс-валидация как более надёжная валидация

Кросс-валидация (обычно k-fold) делает оценку устойчивее.

Идея:

данные делятся на частей (fold)

модель обучается раз

каждый раз одна часть играет роль validation, остальные это train

затем качества усредняются

Ссылка: Cross-validation: evaluating estimator performance (scikit-learn)

Среднее качество по фолдам

Если на каждом фолде мы получили качество , то обычно сравнивают модели по среднему:

Разбор обозначений:

это число фолдов

это качество на -м фолде (например, accuracy, F1, MAE)

означает «сложить все качества по фолдам»

деление на даёт среднее качество

Практически полезно смотреть не только среднее, но и разброс значений, чтобы понимать стабильность.

Какая кросс-валидация подходит

Для классификации обычно используют StratifiedKFold, чтобы доли классов в каждом фолде были похожи.

Для регрессии и сбалансированных задач часто используют KFold.

Для временных рядов нужен подход без перемешивания, обычно TimeSeriesSplit.

Ссылки:

StratifiedKFold (scikit-learn)

KFold (scikit-learn)

TimeSeriesSplit (scikit-learn)

Регуляризация: как снижать переобучение

Переобучение мы уже обсуждали: модель слишком хорошо подстраивается под train и хуже работает на новых данных. Один из главных инструментов борьбы с этим это регуляризация.

Регуляризация означает: мы добавляем ограничение, которое делает модель проще или стабильнее.

Регуляризация в линейных моделях

В линейной регрессии и логистической регрессии регуляризация обычно штрафует большие коэффициенты.

Пример идеи для Ridge-регрессии:

Разбор:

это то, что минимизирует обучение

это ошибка на данных

это число признаков

это коэффициент при признаке

это квадрат коэффициента, он делает штраф всегда неотрицательным и сильнее наказывает большие веса

это «сумма штрафов» по всем коэффициентам

управляет силой регуляризации: чем больше , тем сильнее «сжимаются» коэффициенты

Ссылки:

Ridge (scikit-learn)

Lasso (scikit-learn)

Практическое следствие:

регуляризация особенно чувствительна к масштабу признаков

поэтому для линейных моделей часто нужен StandardScaler внутри пайплайна

Ссылка: StandardScaler (scikit-learn)

Регуляризация в логистической регрессии: параметр C

В LogisticRegression сила регуляризации задаётся параметром C.

меньше C означает сильнее регуляризация

больше C означает слабее регуляризация

Ссылка: LogisticRegression (scikit-learn)

Ограничения в деревьях и ансамблях

У деревьев решений «регуляризация» обычно выглядит как ограничения роста дерева:

max_depth ограничивает глубину

min_samples_leaf заставляет листья содержать минимум объектов

min_samples_split задаёт минимум объектов для разбиения

Если эти параметры не ограничивать, дерево легко переобучается.

Ссылка: DecisionTreeClassifier (scikit-learn)

Подбор гиперпараметров: как делать это правильно

Подбор гиперпараметров это выбор таких настроек модели, которые дают лучшее качество на валидации.

Главный принцип: не трогать test

Правильный порядок действий:

Разделить данные на train и test.

Подбирать гиперпараметры только внутри train, используя кросс-валидацию.

Зафиксировать лучшую конфигурацию.

Один раз оценить результат на test.

GridSearchCV и RandomizedSearchCV

В scikit-learn есть стандартные инструменты.

GridSearchCV перебирает все комбинации из заданной сетки.

RandomizedSearchCV пробует случайные комбинации из заданных распределений или списков.

Ссылки:

GridSearchCV (scikit-learn)

RandomizedSearchCV (scikit-learn)

Когда что выбирать:

GridSearchCV удобен, когда параметров мало и сетка небольшая.

RandomizedSearchCV удобен, когда параметров много и полный перебор слишком дорог.

Выбор метрики для подбора

Гиперпараметры нужно подбирать по той метрике, которая соответствует задаче.

Примеры:

классификация при дисбалансе: часто f1 или average_precision

регрессия: часто neg_mean_absolute_error или neg_root_mean_squared_error

В scikit-learn некоторые регрессионные метрики в scoring идут со знаком минус, потому что внутри оптимизация устроена как «чем больше, тем лучше».

Ссылка: scoring parameter: model evaluation rules (scikit-learn)

Защита от утечки при подборе: Pipeline обязателен

Мы уже обсуждали утечку данных в статьях про подготовку. При подборе гиперпараметров утечка встречается ещё чаще.

Типичная ошибка:

сначала масштабировали или закодировали признаки на всей таблице

потом делали кросс-валидацию

Это неправильно, потому что валидационные фолды влияют на преобразования.

Правильный подход:

вся предобработка должна быть внутри Pipeline

GridSearchCV должен получать пайплайн целиком

Ссылки:

Pipeline (scikit-learn)

ColumnTransformer (scikit-learn)

Практический пример: подбор гиперпараметров для классификации

Ниже пример, который показывает правильную структуру:

делим на train/test

строим пайплайн

подбираем гиперпараметры через кросс-валидацию внутри train

оцениваем на test

Что важно в этом коде:

StandardScaler находится внутри Pipeline, поэтому на каждом фолде он обучается только на train-части этого фолда.

search.best_score_ это качество на кросс-валидации внутри train.

test используется только для финального честного измерения.

Как интерпретировать результаты подбора

Практические рекомендации:

Сравнивайте модели по кросс-валидации, но ожидайте, что test-качество будет чуть ниже.

Смотрите не только на средний результат, но и на стабильность, если вы сохраняете результаты по фолдам.

Если выигрыш от подбора гиперпараметров минимален, часто выгоднее улучшать признаки и качество данных.

Чтобы глубже анализировать перебор, можно смотреть cv_results_.

Типичные ошибки при настройке моделей

Подбирать гиперпараметры, измеряя качество на test.

Делать предобработку до кросс-валидации, а не внутри Pipeline.

Использовать метрику, которая не отражает реальную стоимость ошибок.

Делать слишком большую сетку и «сжигать» время, хотя сначала нужен baseline и разумный диапазон.

Игнорировать дисбаланс классов и не использовать стратификацию.

Итоги

Валидация нужна, чтобы выбирать модель и настройки, не «подглядывая» в test.

Кросс-валидация делает оценку устойчивее, чем одно разбиение.

Регуляризация и ограничения снижают переобучение и делают модели стабильнее.

Гиперпараметры подбирают через GridSearchCV или RandomizedSearchCV.

Чтобы не допустить утечку, предобработка должна быть внутри Pipeline, который передаётся в поиск.

Практика: построение ML-пайплайна и финальный мини-проект

В предыдущих статьях курса вы последовательно собрали «кирпичики» практического ML:

поняли жизненный цикл ML-проекта

научились готовить данные и защищаться от утечки с помощью Pipeline и ColumnTransformer

разобрали регрессию и классификацию, метрики и дисбаланс

познакомились с неподконтрольным обучением (кластеризация, PCA)

научились валидировать решения и подбирать гиперпараметры через кросс-валидацию

Теперь соберём всё в единый практический сценарий: от загрузки данных до финальной оценки и сохранения готового пайплайна.

!Схема полного цикла: разбиение, кросс-валидация, предобработка внутри пайплайна, финальный тест и сохранение модели

Что вы сделаете в мини-проекте

Итогом будет воспроизводимый шаблон, который применим к большинству табличных задач.

Соберёте baseline и честно сравните модели.

Построите полноценный Pipeline: предобработка + модель.

Настроите гиперпараметры через GridSearchCV без утечки.

Проведёте финальную оценку на test (как «экзамен»).

Сохраните готовый пайплайн для использования на новых данных.

Мини-проект: предсказание дохода по анкетным данным

Возьмём классический датасет Adult (Census Income) из OpenML: по характеристикам человека (возраст, образование, семейное положение, профессия и т.д.) нужно предсказать, превышает ли доход порог.

Тип задачи: бинарная классификация.

Особенность: есть категориальные признаки и возможен дисбаланс классов.

Источник данных загружается из scikit-learn через OpenML.

Ссылки:

fetch_openml (scikit-learn)

Pipeline (scikit-learn)

ColumnTransformer (scikit-learn)

GridSearchCV (scikit-learn)

Model persistence (scikit-learn)

Шаг 1: загрузка данных и первичный аудит

Важно сразу понять:

какие столбцы числовые, какие категориальные

есть ли пропуски

как выглядит целевая переменная

Практические замечания:

as_frame=True даёт pandas.DataFrame, это удобно для отбора типов.

В некоторых версиях Adult пропуски могут быть закодированы строкой "?" в категориальных столбцах. Это не NaN, и такие значения нужно привести к пропускам.

Пример замены "?" на пропуски для строковых столбцов:

Шаг 2: отделяем признаки от цели и делаем train/test split

Правило курса остаётся прежним:

test не участвует ни в выборе модели, ни в подборе гиперпараметров

в классификации обычно используем стратификацию, чтобы доли классов в train и test были похожи

Шаг 3: baseline, чтобы не обмануть себя

Сначала делаем простой baseline, например «предсказывать самый частый класс».

Почему здесь используется F1:

если классы несбалансированы, accuracy может выглядеть хорошо даже у бесполезной модели

F1 даёт компромисс между точностью по положительному классу и полнотой

Если у вас другая стоимость ошибок, на практике можно выбрать другую метрику (например, recall для задачи «лучше поймать больше положительных случаев, даже ценой ложных тревог»).

Шаг 4: собираем предобработку через ColumnTransformer

Нам нужно:

числовые: заполнить пропуски, масштабировать

категориальные: заполнить пропуски, one-hot кодировать

Ключевая идея: всё это должно быть внутри пайплайна, чтобы при кросс-валидации и на тесте не возникало утечки данных.

Практический смысл handle_unknown="ignore":

на новых данных может появиться категория, которой не было в train

без этого модель может упасть с ошибкой

Шаг 5: первая «серьёзная» модель в пайплайне

Возьмём логистическую регрессию как сильный baseline для табличных данных.

Преимущество такого подхода:

вы обучаете и применяете преобразования «правильно» одним объектом

тот же пайплайн можно сохранить и использовать в продакшне

Шаг 6: подбор гиперпараметров без утечки (GridSearchCV)

Подбор делаем только внутри train, используя кросс-валидацию.

Пояснение к scoring:

f1_macro усредняет F1 по классам равномерно

если вы хотите оптимизировать метрику именно по положительному классу, можно настроить scoring иначе, но на практике важно согласовать это с постановкой задачи

Далее делаем честную финальную оценку на test.

Шаг 7: минимальный анализ ошибок

Даже в мини-проекте полезно посмотреть, где модель ошибается.

false positives: модель предсказала высокий доход, но на самом деле нет

false negatives: модель пропустила высокий доход

Пример: вывести несколько ошибочных объектов.

Важно: не «подкручивайте» модель, глядя на test. Анализ ошибок нужен, чтобы сформулировать гипотезы для следующей итерации.

!Памятка: два типа ошибок в бинарной классификации и зачем их различать

Шаг 8: сохранение готового пайплайна

Сохранять стоит именно весь пайплайн, а не только классификатор, потому что на новых данных вам нужна ровно та же предобработка.

Перед использованием в реальном приложении обязательно прочитайте рекомендации по безопасному сохранению моделей.

Ссылка: Model persistence (scikit-learn)

Чек-лист качества для мини-проекта

Данные разделены на train/test, test не используется в подборе.

Предобработка полностью внутри Pipeline.

Baseline посчитан и не игнорируется.

Метрики выбраны под задачу, а не «по привычке».

Гиперпараметры подбирались через кросс-валидацию.

Финальная оценка сделана один раз на test.

Сохранён полный пайплайн, есть пример инференса.

Зафиксирован random_state, чтобы результат был воспроизводим.

Итоги

Вы собрали end-to-end ML-решение для табличной классификации: от данных до сохранённого пайплайна.

Главный практический принцип курса подтвердился: предобработка должна быть внутри Pipeline, особенно при GridSearchCV.

Baseline и честная валидация защищают от самообмана.

Мини-проект можно адаптировать под любую задачу классификации или регрессии, заменив датасет, метрику и модель.