Machine Learning с нуля: от основ программирования до своих ИИ-моделей

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

1. Введение в программирование на Python для ML

Введение в программирование на Python для ML

Зачем вам Python в Machine Learning

Python — основной язык в прикладном Machine Learning (ML), потому что он:

  • Прост в освоении и читаем
  • Имеет огромную экосистему библиотек для данных, математики и моделей
  • Подходит для быстрого прототипирования: от идеи до работающего эксперимента
  • В ML вы будете постоянно делать три вещи:

  • Загружать и чистить данные
  • Превращать данные в числовой вид (признаки)
  • Обучать модели и оценивать качество
  • Python хорошо подходит для каждого из этих шагов.

    !Упрощённая схема, где именно Python используется в типичном ML-проекте

    Что нужно установить

    Есть два удобных пути. Выберите один.

    Вариант A: Anaconda (проще для новичка)

    Anaconda — это пакет, который ставит Python и популярные инструменты для работы с данными.

  • Установите Anaconda: Anaconda Distribution
  • Откройте Anaconda Navigator и запустите Jupyter Notebook или JupyterLab
  • Вариант B: Обычный Python + venv (ближе к индустрии)

  • Установите Python с официального сайта: Python
  • Установите редактор кода: Visual Studio Code
  • Создайте папку проекта и виртуальное окружение
  • Активируйте окружение
  • Поставьте базовые библиотеки
  • Зачем нужно виртуальное окружение

    Виртуальное окружение (через venv) — это отдельный набор библиотек для конкретного проекта.

  • Без окружений разные проекты могут требовать разные версии библиотек
  • С окружением вы не “ломаете” систему и другие проекты
  • Как мы будем писать и запускать код

    В курсе будут два формата.

  • Скрипты .py — хорошо для привычки писать “настоящие” программы
  • Ноутбуки Jupyter — удобно для экспериментов, графиков и пошагового анализа
  • Чтобы запустить Jupyter после установки:

    Откроется вкладка в браузере, где вы создадите новый Notebook.

    Базовый синтаксис Python, который нужен для ML

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

    Переменные

    Переменная — это имя, которое ссылается на значение.

    Важно: в Python не нужно заранее объявлять тип — он определяется по значению.

    Типы данных, с которыми вы будете работать чаще всего

    | Тип | Пример | Где пригодится в ML | |---|---|---| | int | 42 | счётчики, размеры, индексы | | float | 0.25 | числа с дробью: средние, веса, метрики | | str | "cat" | названия колонок, пути к файлам | | bool | True | фильтрация, условия | | list | [1, 2, 3] | наборы значений, строки таблицы | | dict | { "age": 20 } | параметры моделей, метаданные |

    Числа и операции

    В ML вы часто будете получать дробные значения (например, средние и вероятности), поэтому важно различать / и //.

    Условия: if, elif, else

    Ключевой момент: Python использует отступы (обычно 4 пробела), чтобы понимать, какие строки относятся к блоку.

    Циклы: for и while

    while нужен реже, но важно знать:

    Функции: как “упаковывать” логику

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

    В ML почти всё строится на функциях: предобработка, обучение, оценка.

    Ошибки и исключения

    Если Python не может выполнить код, он выдаёт исключение (exception) — сообщение об ошибке.

    Пример: деление на ноль.

    Чтобы программа не падала “внезапно”, можно обработать ошибку:

    В ML это полезно при чтении файлов, обработке “грязных” данных и проверках.

    Импорт библиотек: как подключать инструменты для ML

    Python становится ML-инструментом благодаря библиотекам.

    Пример импорта:

  • import ... as ... задаёт короткое имя (псевдоним), чтобы писать код быстрее
  • np и pd — общепринятые сокращения
  • Минимальный набор библиотек для старта

  • NumPy — быстрые массивы и математика
  • pandas — таблицы данных (как Excel, но в коде)
  • Matplotlib — графики
  • scikit-learn — классические ML-модели
  • Первое знакомство с данными: pandas

    В реальном ML вы почти всегда начинаете с таблицы.

    Создадим небольшую таблицу прямо в коде:

    Полезные операции:

    На следующих этапах курса мы научимся:

  • Загружать данные из CSV
  • Обрабатывать пропуски
  • Превращать текстовые значения (например, город) в числовые признаки
  • Числа для моделей: NumPy

    Модели “понимают” числа, поэтому в ML постоянно используются массивы.

  • mean() — среднее значение
  • shape — размерность (очень важное понятие в ML, позже разберём глубже)
  • Стиль кода: почему это важно

    В ML-проектах код быстро разрастается. Понятный стиль экономит время.

    Основные привычки:

  • Используйте понятные имена: salary, age, model, а не a1, x2
  • Делайте небольшие функции вместо огромных простыней кода
  • Соблюдайте единый стиль отступов (4 пробела)
  • Официальные рекомендации по стилю Python: PEP 8

    > "Beautiful is better than ugly." — из The Zen of Python (PEP 20) (PEP 20)

    Что дальше по курсу

    После этой статьи вы должны уверенно:

  • Понимать, что такое переменные, типы данных, условия, циклы и функции
  • Уметь запускать Python-код (скрипт или ноутбук)
  • Понимать, что библиотека подключается через import
  • Иметь установленную среду для работы с данными
  • В следующих материалах мы перейдём к практической работе с данными: загрузка файлов, очистка, базовая аналитика и подготовка признаков — это фундамент перед обучением первой модели.

    2. Математика и статистика, необходимые для машинного обучения

    Математика и статистика, необходимые для машинного обучения

    Связь с предыдущей статьёй

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

    Зачем математика в Machine Learning

    Большая часть классического ML сводится к двум идеям:

  • Данные представляются числами в виде векторов и матриц
  • Обучение модели означает подобрать параметры, чтобы ошибка была как можно меньше
  • Математика помогает вам понимать:

  • что именно подаётся в модель на вход
  • почему одна модель «лучше» другой
  • как интерпретировать качество и неопределённость
  • Минимальный набор тем, который реально нужен на старте

    | Тема | Простыми словами | Где встречается в ML | |---|---|---| | Векторы и матрицы | как хранить числа для объектов и признаков | признаки, датасет, веса модели | | Функции | правило превращения входа в выход | модель как функция | | Производная и градиент | в какую сторону менять параметры, чтобы улучшить результат | обучение нейросетей и многих моделей | | Вероятности | насколько событие правдоподобно | классификация, вероятностные модели | | Описательная статистика | среднее и разброс | анализ данных, нормализация | | Распределения | «форма» случайных данных | шум, ошибки, оценка неопределённости |

    Линейная алгебра: векторы и матрицы

    Скаляр, вектор, матрица

  • Скаляр — одно число, например температура
  • Вектор — упорядоченный набор чисел, например признаки одного объекта
  • Матрица — таблица чисел, например признаки всех объектов
  • В ML обычно используют такую схему:

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

    !Как матрица признаков превращается в предсказания с помощью весов

    Скалярное произведение: как модель «смешивает» признаки

    Одна из самых частых операций в ML — скалярное произведение (dot product). Оно превращает два вектора одинаковой длины в одно число.

    Формула:

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

  • — вектор признаков одного объекта
  • — вектор весов (параметры модели)
  • — число признаков
  • — значение i-го признака
  • — вес i-го признака
  • — знак суммирования по всем признакам от до
  • На основе этого строится простейшая модель (линейная):

  • — предсказание модели
  • — свободный член (сдвиг), тоже параметр модели
  • В NumPy это выглядит как x @ w или np.dot(x, w).

    Функции: модель как преобразование входа в выход

    Функция — это правило: вход выход.

    В ML вы постоянно встречаете функции разных типов:

  • модель как функция , которая выдаёт предсказание
  • функция ошибки (loss), которая говорит, насколько плохо предсказание
  • преобразования признаков, например стандартизация
  • Пример идеи функции ошибки на уровне смысла: если модель сильно ошиблась, ошибка большая; если почти угадала, ошибка маленькая.

    Производная и градиент: как модели учатся

    Интуиция производной

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

    Приближённая оценка производной:

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

  • — значение функции в точке
  • — маленький шаг
  • — «наклон» функции в точке
  • Градиент для многих параметров

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

    Ключевая практическая идея:

  • чтобы уменьшать ошибку, параметры обычно двигают в сторону, противоположную градиенту
  • Это лежит в основе градиентного спуска.

    Вероятности: уверенность и неопределённость

    Вероятность события

    Вероятность — число от до :

  • означает «невозможно»
  • означает «точно произойдёт»
  • Условная вероятность

    Условная вероятность отвечает на вопрос: «какова вероятность события , если мы знаем, что произошло ?»

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

  • — вероятность при условии
  • — вероятность того, что случились и , и одновременно
  • — вероятность события (важно, что )
  • Теорема Байеса

    Теорема Байеса позволяет «перевернуть» условие:

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

  • — априорная вероятность (что мы думаем про до наблюдения )
  • — насколько типично, если правда
  • — насколько вообще часто встречается
  • В ML это особенно полезно в вероятностных классификаторах, например в наивном Байесе.

    Описательная статистика: среднее и разброс

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

    Среднее значение

    Среднее (математическое ожидание для набора данных) часто обозначают :

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

  • — i-е наблюдение (например, зарплата i-го человека)
  • — количество наблюдений
  • — среднее значение
  • Дисперсия и стандартное отклонение

    Дисперсия показывает «разброс» значений вокруг среднего:

  • — отклонение значения от среднего
  • квадрат делает вклад всегда неотрицательным и сильнее штрафует большие отклонения
  • — дисперсия (в квадратных единицах измерения)
  • Стандартное отклонение — корень из дисперсии:

  • имеет те же единицы измерения, что и исходные данные
  • Медиана и выбросы

  • Медиана — значение «посередине» после сортировки
  • Выбросы — редкие экстремальные значения
  • Практически важное правило:

  • медиана обычно устойчивее к выбросам, чем среднее
  • Распределения: форма случайности

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

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

    !Нормальное распределение и смысл параметров μ и σ

    Важно не заучивать формулы плотности, а понимать смысл:

  • задаёт центр распределения
  • задаёт ширину (разброс)
  • Как это выглядит в Python (без сложной математики)

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

    Скалярное произведение и линейное предсказание:

    Что важно унести из этой статьи

  • Данные в ML почти всегда превращаются в матрицу и вектор ответов
  • Линейные модели базируются на операции и добавлении
  • Статистика отвечает на вопросы «где центр данных?» (среднее, медиана) и «какой разброс?» (дисперсия, стандартное отклонение)
  • Вероятности и условные вероятности нужны, чтобы говорить про уверенность и делать вероятностные выводы
  • Производные и градиент нужны, чтобы понимать принцип обучения через уменьшение ошибки
  • Куда углубляться при необходимости

  • Khan Academy: Линейная алгебра
  • Khan Academy: Статистика и вероятность
  • Khan Academy: Дифференциальное исчисление
  • 3. Данные: сбор, очистка, визуализация и подготовка признаков

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

    Связь с предыдущими статьями

    Ранее вы:

  • Настроили Python и познакомились с pandas и NumPy
  • Узнали, что данные в ML обычно представляют как матрицу признаков и вектор ответов
  • Теперь соберём это в практический рабочий процесс: где брать данные, как их загрузить, как понять, что в них не так, как привести их в аккуратный числовой вид, чтобы позже можно было обучить модель.

    !Общая карта шагов от сырых данных до готовых признаков

    Что такое данные в задачах ML

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

  • Строка — один объект (например, один клиент)
  • Колонки — свойства объекта (например, возраст, город)
  • Одна из колонок (или отдельный столбец) — цель (то, что хотим предсказать)
  • Термины, которые будем использовать:

  • Признак — входная переменная, которую даём модели (например, age)
  • Целевая переменная — то, что предсказываем (например, will_buy)
  • Датасет — набор данных целиком
  • Сбор данных: откуда их берут

    Для обучения моделей чаще всего используют:

  • Файлы CSV и Excel
  • Выгрузки из баз данных
  • Данные из API (например, погода, курсы валют)
  • Логи приложений и сайтов
  • Публичные датасеты
  • Если вы хотите тренироваться на реальных датасетах, используйте:

  • Kaggle Datasets
  • UCI Machine Learning Repository
  • Загрузка данных в pandas

    Самый частый старт — чтение CSV.

    Полезные привычки при загрузке:

  • Сразу смотрите первые строки через df.head()
  • Смотрите размеры таблицы через df.shape
  • Смотрите типы колонок через df.dtypes
  • Если в файле разделитель не запятая (часто бывает ;), укажите sep.

    Документация: pandas.read_csv

    Первичный осмотр: понять, что вообще внутри

    Базовые вопросы к данным

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

  • Сколько строк и колонок
  • Есть ли пропуски
  • Есть ли дубликаты
  • Какие колонки числовые, а какие текстовые
  • Нет ли странных значений (например, возраст 999)
  • Команды, которые почти всегда нужны

    Что вы получаете:

  • info() показывает типы, количество непустых значений и примерную “плотность” пропусков
  • describe() даёт статистику по числам: среднее, минимум, максимум, квартильные значения
  • Очистка данных

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

    Пропуски: как найти и что с ними делать

    Найти пропуски по колонкам:

    Основные стратегии:

  • Удалить строки с пропусками, если их мало и они не важны
  • Заполнить разумным значением
  • Оставить пропуск, если модель и подход это поддерживают (позже разберём на практике)
  • Пример: заполнение числовых пропусков медианой, а текстовых — самым частым значением.

    Почему часто используют медиану:

  • Медиана устойчивее к выбросам, чем среднее
  • Дубликаты

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

    Типы данных: числа, даты, категории

    Частая проблема новичков: числа читаются как текст.

    Пример: колонка salary хранится как строки, потому что там есть пробелы или запятые.

  • errors="coerce" превращает “непарсабельные” значения в пропуски, которые потом нужно обработать
  • Для дат удобно использовать to_datetime.

    Выбросы: что это и почему они опасны

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

  • ломать статистики (например, среднее)
  • ухудшать обучение некоторых моделей
  • Простая и безопасная практика на старте:

  • Сначала визуализировать распределение
  • Проверить подозрительные строки
  • Только потом решать: удалить, ограничить (клиппинг) или оставить
  • Пример клиппинга (ограничения значений) по квантилям:

    Визуализация: увидеть проблемы глазами

    Визуализация помогает быстрее заметить:

  • странные распределения
  • выбросы
  • различия между группами
  • связи между признаками
  • Для графиков в Python обычно используют:

  • Matplotlib
  • Seaborn
  • Гистограмма для одного числового признака

    Boxplot для поиска выбросов

    Scatter plot для связи двух числовых признаков

    !Примеры базовых графиков, которые помогают быстро понять данные

    Подготовка признаков: превратить таблицу в то, что “понимает” модель

    Большинство моделей работают с числами, поэтому ваша задача — получить:

  • Матрицу признаков (только входы)
  • Вектор цели (то, что предсказываем)
  • Разделение на признаки и цель

    Допустим, мы предсказываем will_buy.

    Важно:

  • Нельзя случайно оставить целевую колонку внутри X, иначе модель “подсмотрит ответ”
  • Категориальные признаки: как работать с текстом

    Колонки вроде city или job_title называются категориальными: в них значения из набора категорий.

    Один из самых популярных способов для старта — one-hot кодирование:

  • создаём отдельную колонку на каждую категорию
  • ставим 1, если категория есть, иначе 0
  • В pandas:

  • drop_first=True убирает одну “лишнюю” колонку, чтобы не создавать полностью дублирующую информацию
  • Масштабирование чисел: почему иногда нужно

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

    Пример проблемы:

  • age лежит примерно в диапазоне 18–70
  • salary лежит в диапазоне 30000–300000
  • Тогда алгоритм может “считать”, что salary важнее только потому, что числа больше.

    Популярный подход — стандартизация: привести признак к виду со средним около 0 и стандартным отклонением около 1.

    Формула стандартизации:

    Объяснение:

  • — исходное значение признака (например, зарплата конкретного человека)
  • — среднее значение этого признака по обучающим данным
  • — стандартное отклонение признака по обучающим данным
  • — стандартизированное значение, которое будет подано в модель
  • На практике чаще используют готовые инструменты из scikit-learn (мы будем активно применять это дальше).

    Документация: sklearn.preprocessing.StandardScaler

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

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

  • train — на этих данных модель учится
  • test — на этих данных проверяем качество на “новых” примерах
  • В scikit-learn:

    Документация: sklearn.model_selection.train_test_split

    Главные ошибки новичков при подготовке данных

  • Смешивать цель и признаки
  • Заполнять пропуски и масштабировать по всем данным до разделения на train и test
  • Игнорировать типы данных и хранить числа как текст
  • Делать много сложных преобразований без проверки простыми графиками
  • > “Garbage in, garbage out.” — популярный принцип в информатике и анализе данных: качество результата ограничено качеством входных данных. Wikipedia: Garbage in, garbage out

    Что важно унести из статьи

  • Большая часть успеха ML-проекта начинается с аккуратных данных
  • pandas позволяет быстро загрузить таблицу, посмотреть типы, пропуски и базовую статистику
  • Очистка обычно включает пропуски, дубликаты, корректные типы данных и проверку выбросов
  • Визуализация помогает находить проблемы и связи, которые не видно в таблице
  • Подготовка признаков сводится к кодированию категорий, масштабированию чисел и разделению на train и test
  • Что дальше

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

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

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

    Связь с предыдущими статьями

    В прошлых материалах вы:

  • Настроили Python и базовые библиотеки
  • Разобрались, как данные превращаются в матрицу признаков и вектор цели
  • Научились чистить данные, кодировать категории и делать разбиение на train/test
  • Теперь вы сделаете следующий логичный шаг: возьмёте подготовленные признаки и обучите первые классические ML-модели с помощью scikit-learn, а также научитесь оценивать их качество честно и воспроизводимо.

    !Карта процесса: от таблицы до метрик качества

    Что такое классическое ML и чем оно отличается от нейросетей

    Классическое машинное обучение — это набор алгоритмов, которые хорошо работают на табличных данных и обычно:

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

    Типы задач: регрессия и классификация

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

  • Регрессия: предсказываем число (например, price квартиры)
  • Классификация: предсказываем класс (например, spam или not_spam)
  • Практический ориентир:

  • если в y много уникальных чисел и есть смысл “насколько больше/меньше” — это регрессия
  • если в y фиксированный набор меток — это классификация
  • Базовый рабочий цикл в scikit-learn

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

    Шаг 1: разделить данные на train/test

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

  • test_size=0.2 означает 20% данных на тест
  • random_state=42 фиксирует случайность, чтобы результаты повторялись
  • Шаг 2: выбрать модель

    В scikit-learn модель — это объект с методами:

  • fit(X_train, y_train) обучить
  • predict(X_test) предсказать
  • Шаг 3: обучить и получить предсказания

    Шаг 4: оценить качество метрикой

    Метрика зависит от типа задачи (регрессия или классификация). Ниже разберём основные.

    > "All models are wrong, but some are useful." — George E. P. Box (Wikiquote: George Box)

    Метрики качества: как понять, хороша ли модель

    Регрессия: MAE и MSE

    Две популярные метрики:

  • MAE (mean absolute error): средняя абсолютная ошибка, проще интерпретировать
  • MSE (mean squared error): средняя квадратичная ошибка, сильнее штрафует большие промахи
  • Формула MSE:

    Обозначения:

  • — количество объектов в тесте
  • — истинное значение цели для объекта
  • — предсказание модели для объекта
  • — квадрат, чтобы большие ошибки наказывались сильнее и не было компенсации “плюсов” и “минусов”
  • В коде:

    Классификация: accuracy, precision, recall, F1

    Если классы сбалансированы, accuracy (доля верных ответов) может быть нормальным стартом. Но при дисбалансе (например, 1% мошенничества) accuracy часто обманывает.

    Полезные метрики:

  • precision: среди предсказанных “положительных” сколько верных
  • recall: среди настоящих “положительных” сколько нашли
  • F1: баланс precision и recall
  • В коде:

    Если у вас классов больше двух, у метрик появляются варианты усреднения (average="macro", "weighted"). Это нормально: вы разберёте это глубже, когда начнёте работать с многоклассовыми задачами.

    Алгоритмы, которые стоит знать в самом начале

    Ниже — набор “первых моделей”, с которыми обычно начинают.

    Линейная регрессия

    Линейная регрессия пытается предсказать число как “взвешенную сумму” признаков. Она полезна как:

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

    Документация: LinearRegression

    Логистическая регрессия (для классификации)

    Несмотря на слово “регрессия”, логистическая регрессия — это классический алгоритм классификации.

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

  • даёт хорошую базу
  • быстро обучается
  • часто неплохо работает после грамотной подготовки признаков
  • Документация: LogisticRegression

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

    Идея kNN очень интуитивна: объект получает ответ “как у ближайших похожих”.

    Особенности:

  • очень чувствителен к масштабу признаков, часто требуется стандартизация
  • может быть медленным на больших данных (на предсказании)
  • Документация: KNeighborsClassifier

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

    Дерево решений учится задавать вопросы вида “признак порог?” и ветвиться.

    Плюсы:

  • легко объяснять (в общих чертах)
  • не требует масштабирования
  • Минусы:

  • легко переобучается (особенно без ограничений глубины)
  • Документация: DecisionTreeClassifier

    Случайный лес

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

    Документация: RandomForestClassifier

    Важная тема: утечка данных и зачем нужен Pipeline

    Что такое утечка данных

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

    Частый пример:

  • вы стандартизировали данные, используя среднее и стандартное отклонение, посчитанные по всему датасету
  • а потом сделали train/test
  • Это даёт завышенные метрики, потому что тест “подсмотрели”.

    Решение: Pipeline и ColumnTransformer

    Правильный подход: обучать предобработку только на X_train и применять к X_test уже готовые преобразования.

    Для этого в scikit-learn есть:

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

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

  • SimpleImputer заполняет пропуски внутри пайплайна
  • OneHotEncoder(handle_unknown="ignore") не ломается, если в тесте встретилась новая категория
  • stratify=y в train_test_split помогает сохранить долю классов в train и test (важно при дисбалансе)
  • Документация:

  • Pipeline
  • ColumnTransformer
  • OneHotEncoder
  • Как выбирать модель: baseline, сравнение и кросс-валидация

    Начинайте с baseline

    Baseline — простая отправная точка, которую легко превзойти.

    Примеры baseline:

  • для регрессии: предсказывать среднее значение на train
  • для классификации: всегда предсказывать самый частый класс
  • В scikit-learn есть готовый инструмент.

    Документация: DummyClassifier

    Сравнивайте несколько моделей одинаково

    Правило: одинаковое разбиение и одинаковая предобработка.

    Кросс-валидация

    Одна train/test проверка может быть нестабильной (особенно на малых данных). Кросс-валидация делает несколько разбиений и усредняет качество.

  • cv=5 означает 5 разбиений
  • scoring выбирает метрику
  • Документация: cross_val_score

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

  • Делайте Pipeline привычкой, чтобы не допускать утечки данных.
  • Сначала бейте baseline и только потом усложняйте.
  • Не сравнивайте модели по метрикам, если вы меняли тест или предобработку.
  • Если качество “слишком хорошее”, проверьте, не попала ли цель в признаки и нет ли утечки.
  • Для табличных данных часто сильные кандидаты: логистическая регрессия, случайный лес, градиентный бустинг (с ним вы познакомитесь дальше).
  • Что дальше по курсу

    Теперь у вас есть полный минимальный цикл классического ML:

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

    5. Оценка качества моделей и предотвращение переобучения

    Оценка качества моделей и предотвращение переобучения

    Связь с предыдущими статьями

    Ранее вы прошли весь минимальный цикл классического ML:

  • подготовили данные в pandas
  • разделили цель и признаки
  • сделали честное разбиение на train/test
  • обучили первые модели в scikit-learn
  • познакомились с метриками
  • увидели, зачем нужен Pipeline, чтобы избежать утечки данных
  • Теперь разберём две ключевые темы, без которых нельзя делать реальные проекты:

  • как правильно оценивать качество модели, чтобы понимать, будет ли она работать на новых данных
  • как замечать и предотвращать переобучение, чтобы модель не была “идеальной на train и плохой на test”
  • !Схема честной оценки: train для обучения, validation для настройки, test для финальной проверки

    Что значит “качество модели”

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

    Важно различать:

  • качество на обучении: как модель “выучила” train
  • качество на новых данных: как модель работает в реальности
  • Если вы измеряете качество на тех же данных, на которых обучались, это обычно даёт слишком оптимистичную картину.

    Разбиения данных: train, validation, test

    Зачем нужна validation

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

    Если вы:

  • попробовали 20 вариантов модели
  • выбрали лучший по качеству на test
  • то test фактически стал частью процесса настройки, и оценка перестала быть честной.

    Правильные роли трёх частей

  • train: обучение модели и всех преобразований
  • validation: выбор гиперпараметров, сравнение моделей, принятие решений
  • test: финальная оценка один раз, когда всё уже выбрано
  • На практике часто используют один из двух подходов:

  • train/validation/test, если данных достаточно
  • кросс-валидацию вместо validation, если данных мало
  • Пример разбиения train/validation/test

  • stratify=y важно для классификации, чтобы доля классов сохранилась
  • random_state=42 делает результат воспроизводимым
  • Документация: train_test_split

    Кросс-валидация: более стабильная оценка

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

    Идея:

  • вы делите данные на k частей
  • обучаетесь k раз, каждый раз оставляя одну часть “на проверку”
  • усредняете метрику
  • Пример с cross_val_score

    Лучше делать кросс-валидацию на пайплайне, чтобы не было утечки.

  • cv=5 означает 5 разбиений
  • scoring задаёт метрику
  • Документация: cross_val_score

    Метрики: почему одной accuracy часто недостаточно

    Метрика должна соответствовать задаче и цене ошибок.

    Классификация

    Полезный минимум:

  • accuracy: доля верных ответов
  • precision: насколько “чисты” ваши положительные предсказания
  • recall: насколько хорошо вы находите все положительные объекты
  • F1: баланс precision и recall
  • Когда классы несбалансированы (например, мошенничество 1%), accuracy может быть высокой даже у бесполезной модели.

    Практический инструмент для отчёта:

    Документация: classification_report

    Регрессия

    Часто используют:

  • MAE: средняя абсолютная ошибка
  • MSE: сильнее штрафует большие промахи
  • : доля объяснённой вариации, но интерпретация сложнее для новичка
  • Переобучение и недообучение

    Определения простыми словами

  • переобучение: модель слишком хорошо “запомнила” train, но плохо работает на новых данных
  • недообучение: модель слишком простая или плохо настроена, плохо работает даже на train
  • Как это выглядит по метрикам

    Очень полезная быстрая диагностика:

  • если качество на train высокое, а на validation/test заметно хуже, это сигнал переобучения
  • если качество низкое и на train, и на validation/test, это сигнал недообучения
  • Пример (классификация):

    Интуиция: компромисс “смещение и разброс”

    Есть полезная мыслительная модель:

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

    !Типичная картина: переобучение проявляется ростом ошибки на validation при усложнении модели

    Как обнаруживать переобучение системно

    Кривые обучения

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

  • если модель переобучается, то качество на train значительно выше, чем на validation, и разрыв держится
  • если данных мало, то добавление данных часто улучшает validation
  • В scikit-learn есть инструмент learning_curve.

    Документация: learning_curve

    Проверка утечки данных

    Переобучение иногда путают с утечкой, когда метрика “подозрительно хорошая”. Быстрые проверки:

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

    Способы предотвращения переобучения

    Ниже не “магические кнопки”, а практический набор рычагов.

    Сделать модель проще

    Примеры:

  • уменьшить max_depth у дерева решений
  • увеличить min_samples_leaf у дерева
  • уменьшить число признаков
  • увеличить k у kNN
  • Смысл: ограничить гибкость модели.

    Регуляризация

    Регуляризация добавляет штраф за слишком “сложные” параметры модели.

    Частый пример для линейных моделей:

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

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

    В scikit-learn регуляризация часто включена по умолчанию, например у LogisticRegression и Ridge.

    Документация: LogisticRegression

    Больше данных и аккуратнее признаки

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

  • собрать больше данных
  • уменьшить шум в разметке
  • исправить ошибки и выбросы
  • сделать признаки более устойчивыми и “смысловыми”
  • Подбор гиперпараметров только через validation или CV

    Если вы подбираете параметры по test, то test перестаёт быть честной проверкой.

    Практический инструмент в scikit-learnGridSearchCV.

  • важно, что model здесь может быть Pipeline
  • clf__C означает параметр C у шага пайплайна с именем clf
  • Документация: GridSearchCV

    Практический чеклист перед тем, как “верить” метрике

  • Делали ли вы разбиение до любой предобработки статистиками по данным
  • Используете ли вы Pipeline для заполнения пропусков, кодирования и масштабирования
  • Есть ли у вас baseline, который легко интерпретировать
  • Оценивали ли вы качество через validation или кросс-валидацию
  • Трогали ли вы test ровно один раз в конце
  • Сравнивали ли вы модели одной и той же метрикой на одном и том же протоколе
  • > "All models are wrong, but some are useful." — George E. P. Box. Источник: All models are wrong

    Что дальше по курсу

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

  • вы знаете, как устроена честная оценка
  • умеете диагностировать переобучение по разнице train и validation
  • понимаете, как кросс-валидация и GridSearchCV помогают выбирать модель
  • Следующий логичный шаг — углубиться в системное улучшение качества: работа с дисбалансом классов, анализ ошибок, подбор порога вероятности, более сильные модели и ансамбли.

    6. Нейросети и глубокое обучение: основы и первые модели

    Нейросети и глубокое обучение: основы и первые модели

    Связь с предыдущими темами курса

    В предыдущих статьях вы научились:

  • готовить данные и превращать таблицу в матрицу признаков и вектор цели
  • обучать классические модели через scikit-learn
  • честно оценивать качество и избегать переобучения с помощью правильных разбиений, кросс-валидации и Pipeline
  • Нейросети продолжают ту же логику, но дают более гибкий класс моделей. Чтобы не «прыгать в магию», мы будем опираться на уже знакомые идеи:

  • модель как функция
  • ошибка (loss), которую мы уменьшаем
  • разделение train/validation/test и борьба с переобучением
  • !Сравнение общего пайплайна классического ML и нейросетей

    Что такое нейросеть простыми словами

    Нейросеть — это модель с параметрами (числами), которая:

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

    Когда нейросети особенно полезны

    Нейросети чаще всего выигрывают, когда данные сложные и «непохожи на таблицу»:

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

    Нейрон: базовый строительный блок

    Один нейрон делает две вещи:

  • Считает взвешенную сумму признаков
  • Пропускает результат через нелинейную функцию (активацию)
  • Запишем это формулой:

    Где:

  • — вектор входных признаков одного объекта (например, возраст, доход, стаж)
  • — вектор весов (параметры модели, которые она подбирает при обучении)
  • — скалярное произведение, то есть сумма произведений
  • — смещение (ещё один параметр)
  • — «сырое» число на выходе до активации
  • Дальше применяется активация:

    Где:

  • — функция активации
  • — выход нейрона после активации
  • Зачем нужна активация

    Если убрать нелинейность и оставить только суммы, то сколько бы слоёв вы ни ставили, вся сеть будет эквивалентна одной линейной модели. Нелинейность делает нейросеть действительно мощной.

    Популярные функции активации

    | Активация | Идея | Где часто используют | |---|---|---| | ReLU | пропускает положительное, обрезает отрицательное | скрытые слои в большинстве сетей | | Sigmoid | сжимает число в диапазон от 0 до 1 | вероятности в бинарной классификации на выходе (не всегда) | | Tanh | сжимает в диапазон от -1 до 1 | реже, иногда в RNN и старых архитектурах |

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

    Слои и глубина: почему это называют глубоким обучением

    Слой — это набор нейронов, которые параллельно обрабатывают вход.

    Типичная сеть для табличной классификации:

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

    Как нейросеть учится

    Нейросеть учится так же «по смыслу», как и многие классические модели:

  • Делает предсказание
  • Считает ошибку (loss) между и истинным ответом
  • Меняет параметры, чтобы ошибка стала меньше
  • Loss: что это такое

    Loss-функция — число, которое показывает, насколько плохо модель предсказала.

    Примеры:

  • для регрессии часто используют MSE
  • для классификации часто используют кросс-энтропию
  • Важно практическое правило: вы выбираете loss под тип задачи.

    Обратное распространение ошибки и градиентный спуск

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

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

    Где:

  • — веса (параметры) модели
  • — loss-функция
  • — градиент loss по весам (вектор, который показывает, в какую сторону loss растёт быстрее всего)
  • learning rate (скорость обучения), то есть размер шага
  • — «присвоить новое значение»
  • Интуиция: мы вычитаем направление роста ошибки, чтобы уменьшать её.

    Batch, epoch и итерации

    Три термина, которые постоянно встречаются в deep learning:

  • batch — маленькая порция данных (например, 32 объекта), по которой считают loss и делают обновление весов
  • iteration (step) — одно обновление весов по одному batch
  • epoch — один полный проход по всему обучающему набору данных
  • !Что такое batch и epoch в процессе обучения

    Первая нейросеть без «тяжёлых» фреймворков: MLPClassifier в scikit-learn

    Хороший мост между классическим ML и нейросетями — это многослойный перцептрон в scikit-learn.

    Плюсы:

  • знакомый API fit/predict
  • можно сразу использовать Pipeline и не допускать утечки данных
  • Документация: MLPClassifier

    Пример для табличной бинарной классификации (шаблон, который вы адаптируете под свой датасет):

    Что важно:

  • hidden_layer_sizes=(64, 32) означает два скрытых слоя
  • Pipeline гарантирует, что заполнение пропусков и масштабирование делаются корректно (без утечки)
  • Первая нейросеть в фреймворке глубокого обучения: PyTorch

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

    Мы возьмём PyTorch, потому что он прозрачен и хорошо подходит для обучения.

    Официальный вводный учебник: PyTorch Tutorials: Learn the Basics

    Установка

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

    Если установка не проходит (особенно на Windows или с GPU), используйте официальную инструкцию: PyTorch: Get Started

    Минимальный пример: бинарная классификация на готовом датасете из scikit-learn

    Идея примера:

  • загрузим датасет
  • стандартизируем признаки
  • обучим простую полносвязную сеть
  • Что здесь важно понять на уровне смысла:

  • nn.Linear(a, b) создаёт слой, который переводит входных признаков в скрытых признаков
  • ReLU() добавляет нелинейность
  • Sigmoid() на выходе переводит число в «похоже на вероятность» от 0 до 1
  • loss.backward() считает, как нужно менять параметры
  • optimizer.step() реально обновляет параметры
  • Переобучение в нейросетях и как с ним бороться

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

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

  • Раннее останавливание (early stopping): прекращать обучение, когда качество на validation перестало улучшаться
  • Dropout: случайно «выключать» часть нейронов во время обучения, чтобы сеть не опиралась на узкие костыли
  • Weight decay (L2-регуляризация): штрафовать слишком большие веса через параметр оптимизатора
  • Больше данных или аугментации (особенно для изображений)
  • Связь с прошлой статьёй курса прямая: если вы подбираете архитектуру и гиперпараметры по test, вы «ломаете» честную оценку. Для нейросетей это особенно важно, потому что вариантов настроек очень много.

    Частые ошибки новичков в deep learning

  • Не масштабировать числовые признаки для табличных задач
  • Оценивать качество только на train
  • Делать слишком большую сеть для маленьких данных
  • Ставить слишком большой learning rate, из-за чего обучение становится нестабильным
  • Не фиксировать разбиение и случайность при сравнении экспериментов
  • Что дальше после этой статьи

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

  • обучение и сохранение моделей, воспроизводимые эксперименты
  • свёрточные сети для изображений
  • модели для текста (включая трансформеры)
  • перенос обучения (transfer learning), чтобы получать сильные результаты с небольшими данными
  • 7. Создание и запуск своей ИИ-модели: проект от идеи до результата

    Создание и запуск своей ИИ-модели: проект от идеи до результата

    Связь с предыдущими статьями

    К этому моменту вы уже умеете:

  • писать базовый Python-код
  • понимать, что такое матрица признаков и цель
  • загружать и чистить данные в pandas
  • строить Pipeline в scikit-learn, чтобы не было утечки данных
  • обучать классические модели и простые нейросети, оценивать качество и замечать переобучение
  • Теперь вы соберёте всё это в один законченный проект: от идеи и данных до модели, которую можно запустить на новых объектах.

    !Карта процесса от идеи до запуска модели

    Что значит "запустить свою ИИ-модель"

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

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

    Шаг проекта

    Ниже общий план, который подходит почти для любой табличной задачи.

    Выбор идеи и формулировка задачи

    Хорошая учебная идея должна удовлетворять двум условиям:

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

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

    Определение метрики качества

    Метрика это число, которое показывает, насколько хорошо модель предсказывает.

    Полезное правило выбора:

  • если предсказываете класс и важен баланс ошибок, используйте F1
  • если предсказываете число и важна интерпретируемость ошибки в единицах, используйте MAE
  • В scikit-learn метрики описаны в документации: Метрики и функции оценки scikit-learn

    Что будет считаться "готовым результатом"

    Заранее задайте критерии готовности, например:

  • baseline сделан
  • улучшенная модель лучше baseline на validation
  • финальная оценка на test зафиксирована
  • модель сохраняется и загружается
  • есть код, который делает предсказания на новых данных
  • Практический проект: табличная модель в scikit-learn с сохранением и запуском

    Ниже сквозной шаблон. Его можно адаптировать под любой CSV.

    Структура проекта

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

  • data/
  • models/
  • src/
  • README.md
  • Пример:

    Подготовка данных и разбиения

    Три части данных нужны, чтобы честно делать решения:

  • train для обучения
  • val для выбора модели и гиперпараметров
  • test для финальной проверки один раз
  • Пример кода разбиения:

    Зачем stratify=y:

  • при классификации он сохраняет доли классов в разбиениях
  • Пайплайн предобработки без утечки данных

    В табличных данных обычно есть числовые и категориальные колонки.

    Идея:

  • числа: заполнить пропуски медианой и масштабировать
  • категории: заполнить пропуски самым частым значением и сделать one-hot
  • Почему handle_unknown="ignore" важно:

  • если в новых данных появится категория, которой не было при обучении, модель не упадёт
  • Документация: OneHotEncoder

    Baseline: простая модель для ориентира

    Baseline нужен, чтобы понимать, что ваша сложная модель действительно даёт пользу.

    Пример baseline для классификации:

    Документация: DummyClassifier

    Улучшенная модель

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

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

  • LinearRegression или RandomForestRegressor
  • mean_absolute_error
  • Подбор гиперпараметров по validation или через CV

    Гиперпараметры это настройки модели, которые не обучаются автоматически, а выбираются вами.

    Пример подбора через GridSearchCV:

    Ключевая идея:

  • test не должен участвовать в подборе параметров
  • Документация: GridSearchCV

    Финальная проверка на test

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

    Сохранение и загрузка модели

    Чтобы реально запускать модель, её нужно сохранить вместе с предобработкой. Поэтому сохраняют целый Pipeline.

    Сохранение через joblib

    joblib стандартно используется в scikit-learn.

    Документация: joblib

    Пример сохранения:

    Загрузка и предсказание

    Пример загрузки:

    Важно:

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

    Чтобы проект был похож на реальную работу, удобно разделить код.

    Скрипт обучения src/train.py

    Что он обычно делает:

  • читает данные
  • строит пайплайн
  • обучает модель
  • печатает метрики
  • сохраняет модель
  • Скрипт предсказания src/predict.py

    Что он обычно делает:

  • загружает модель
  • читает новые данные (например, CSV)
  • пишет предсказания в файл
  • Пример predict.py, который читает CSV и сохраняет результат:

    Что такое predict_proba:

  • метод, который возвращает вероятности классов, если модель это поддерживает
  • Если вы делаете нейросеть в PyTorch: что считать "запуском"

    Для PyTorch минимально достаточно:

  • сохранить веса модели
  • сохранить код архитектуры (или параметры архитектуры)
  • повторить ту же предобработку признаков
  • Документация: Сохранение и загрузка моделей в PyTorch

    Практическая привычка:

  • сохраняйте не только веса, но и scaler или другой объект предобработки, если он есть
  • Частые причины, почему "всё работало в ноутбуке, а при запуске сломалось"

    Ниже типовые проблемы при переходе от эксперимента к запуску:

  • в новых данных другие названия колонок
  • типы данных изменились, числа пришли как строки
  • появились новые категории, а кодирование не умеет их обрабатывать
  • предобработка была сделана руками вне Pipeline и не сохранилась
  • модель обучалась на одном наборе колонок, а запускается на другом
  • Привычка, которая решает половину проблем:

  • обучайте и сохраняйте один объект Pipeline, в котором есть и предобработка, и модель
  • Мини-чеклист готового ML-проекта

    Перед тем как считать проект завершённым, проверьте:

  • есть baseline и понятно, чем вы его улучшили
  • вы не подбирали параметры по test
  • предобработка сделана внутри Pipeline
  • метрики на val и test сохранены
  • модель сохраняется на диск и загружается в отдельном файле
  • есть способ сделать предсказание на новых данных
  • Что дальше

    Когда вы умеете доводить идею до запуска, следующие естественные шаги:

  • сделать небольшой API для модели и подключить к приложению
  • настроить воспроизводимость экспериментов и логирование параметров
  • следить за качеством после запуска и обновлять модель при изменении данных
  • Для API часто используют FastAPI, но это уже отдельный слой инженерии: FastAPI