Ступень 22.1 Что такое машинное обучение

Обобщение, переобучение, регуляризация

Почему модель, выучившая train наизусть, проваливается на новых данных, и как это лечить — bias–variance, кривые обучения, L2, ранняя остановка, кросс-валидация и утечки данных.

УРОКstage-2/2-1-ml-basics/02-generalization.mdx2 чУрок 2 из 2

После урока вы сможете

Диагностировать недообучение и переобучение по ошибкам на train и validation и по кривым обучения
Разложить ошибку на смещение, разброс и шум и объяснить, как сложность модели сдвигает баланс между ними
Применить L2-регуляризацию, раннюю остановку и k-fold кросс-валидацию для выбора модели
Находить утечки данных — от нормализации по всей выборке до бенчмарков, попавших в обучающий корпус LLM

Зачем это нужно

Представьте: вы дообучаете Qwen на 500 вопросах службы поддержки. Ставите 10 эпох, loss на train падает до 0.05. Вы довольны, пока не задаёте вопрос, которого не было в данных. Модель отвечает хуже, чем до дообучения, зато обучающие ответы воспроизводит слово в слово. Она запомнила, но не научилась.

Цель машинного обучения — обобщение, обобщающая способность: хорошо работать на данных, которых модель не видела. Ошибка на train — лишь подсказка, и часто обманчивая. Сегодня разберём, почему так происходит, как это диагностировать и чем лечить. Эти инструменты понадобятся и при обучении LLM: дообучение на маленьких данных переобучается очень легко, а бенчмарки, «протёкшие» в обучающий корпус, дают красивые и бессмысленные цифры.

Урок длинный, но его ядро — пять идей: таблица «недообучение — норма — переобучение», смещение и разброс на интуитивном уровне (дартс), диагностика по ошибкам на train и validation, три лекарства (L2, ранняя остановка, кросс-валидация) и правило «предобработку учим только на train». На них построены задание и квиз. Точную формулу разложения ошибки, «вероятностный взгляд» на L2, двойной спуск и код на PyTorch при первом чтении можно пробежать глазами: к ним вы вернётесь на ступени 3, когда начнёте обучать нейросети.

Недообучение и переобучение

Возьмём задачу, где ответ знаем мы, но не модель: $y = \sin(2\pi x) + \varepsilon$ . Разберём запись.

$\sin$ — синус, школьная функция-«волна». Вам не нужно помнить тригонометрию: важна только форма. Пока $x$ идёт от 0 до 1, $\sin(2\pi x)$ делает ровно одну волну: поднимается от 0 до 1, опускается до −1 и возвращается в 0. Прямая такую кривую заведомо не повторит — это нам и нужно.
$\varepsilon$ («эпсилон») — случайный шум, своя небольшая случайная добавка к каждой точке. Его стандартное отклонение (урок 0.3.2) равно 0.2: типичное отклонение точки от волны — около 0.2. Дисперсия шума $0.2^2 = 0.04$ — это нижняя граница MSE: шум не предскажет никакая модель (как в практике прошлого урока).

Дадим модели 12 обучающих точек и будем подгонять к ним полиномы разных степеней. Качество проверим на 1000 новых точек.

Полином степени $d$ — это $\hat y = w_0 + w_1 x + w_2 x^2 + \dots + w_d x^d$ , у него $d + 1$ параметр. Удобный приём: составим матрицу признаков $X$ со столбцами $1, x, x^2, \dots, x^d$ . Например, при $d = 2$ точке $x = 3$ соответствует строка $(1, 3, 9)$ , и предсказание равно $w_0 \cdot 1 + w_1 \cdot 3 + w_2 \cdot 9$ . Это обычная взвешенная сумма признаков, как у прямой из прошлого урока, только признаков больше. Поэтому говорят, что модель линейна по весам, $\hat y = Xw$ (матрица на вектор — урок 1.1.2), хотя по $x$ она кривая.

Веса подбирает метод наименьших квадратов — минимизация MSE на train. У этой задачи есть готовая формула $w = (X^\top X)^{-1} X^\top y$ , где $^{-1}$ — обратная матрица из урока 1.1.3. Откуда эта формула берётся, разберём в уроке 2.2.1, а пока это одна строка np.polyfit(x, y, d).

Степень	Параметров	MSE на train	MSE на test	Самый большой коэффициент
0	1	0.3072	0.565	0.02
1	2	0.1540	0.267	1.4
3	4	0.0131	0.049	33
5	6	0.0125	0.048	56
9	10	0.0035	1.850	241 533
11	12	0.0000	143 039	2 790 689 858

Три режима видны сразу:

Степени 0–1 — недообучение. Прямая не может изогнуться в синусоиду. Ошибка велика и на train, и на test. Модели не хватает выразительности.
Степени 3–5 — норма. Ошибка на test ≈ 0.05 при шуме $0.2^2 = 0.04$ . Лучше почти невозможно.
Степени 9–11 — переобучение. На train почти ноль, на test катастрофа. У полинома 11-й степени 12 коэффициентов на 12 точек: он проходит через каждую точку, включая шум. Чтобы так извиваться, ему нужны коэффициенты в миллиарды.

Разность «ошибка на test − ошибка на train» называют разрывом обобщения (generalization gap). Растущий разрыв — главный симптом переобучения.

Смещение и разброс

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

Смещение (bias) — насколько средняя из этих кривых промахивается мимо истины. Прямая промахивается всегда, сколько данных ни дай: это систематическая ошибка.
Разброс (variance) — насколько кривые отличаются друг от друга. Полином 9-й степени на каждой выборке выдаёт что-то своё: он подстраивается под случайный шум.

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

Для квадратичной ошибки это разложение можно записать точно. Формулу ниже не нужно запоминать: достаточно понимать, что ошибка складывается из трёх частей. Значки — из урока 1.3.1: $\mathbb{E}$ — математическое ожидание (среднее по всем случайным исходам), $\mathrm{Var}$ — дисперсия (средний квадрат отклонения от среднего). Пусть $y = f(x) + \varepsilon$ , где $f$ — истинная зависимость (у нас синус), шум в среднем равен нулю ( $\mathbb{E}\,\varepsilon = 0$ ) и имеет дисперсию $\mathrm{Var}\,\varepsilon = \sigma^2$ , а $\hat f_D$ — модель, обученная на случайной выборке $D$ . Тогда в каждой точке $x$

\mathbb{E}_{D,\varepsilon}\big[(y - \hat f_D(x))^2\big] = \underbrace{\big(\mathbb{E}_D \hat f_D(x) - f(x)\big)^2}_{\text{смещение}^2} + \underbrace{\mathbb{E}_D\big[(\hat f_D(x) - \mathbb{E}_D \hat f_D(x))^2\big]}_{\text{разброс}} + \underbrace{\sigma^2}_{\text{шум}}.

Что здесь написано. $\mathbb{E}_D$ — среднее по всем возможным обучающим выборкам. $\mathbb{E}_D \hat f_D(x)$ — «средняя кривая» из нашего мысленного эксперимента. Слева — средний квадрат ошибки на новом примере. Справа три слагаемых: насколько средняя кривая промахивается мимо истины $f(x)$ , насколько отдельные кривые разбросаны вокруг средней, и шум, который не предскажет никто.

Посчитаем честно: 2000 раз сгенерируем по 20 точек, обучим полиномы и усредним слагаемые по сетке из 101 значения $x$ от 0 до 1. Например, у кубического полинома выходит $0.0055 + 0.017 + 0.04 \approx 0.063$ .

Степень	Смещение²	Разброс	Сумма + шум 0.04
0	0.495	0.027	0.562
1	0.205	0.032	0.276
3	0.0055	0.017	0.063
5	0.0001	0.15	0.19
7	0.04	75	75

С ростом сложности смещение падает, а разброс растёт. Минимум суммы — посередине, у степени 3. Это и есть компромисс смещения и разброса. Если нарисовать ошибку на новых данных в зависимости от сложности модели, получится кривая, похожая на букву U: слева высокая из-за смещения, справа — из-за разброса, внизу — золотая середина.

Разброс у степени 7 огромен, но почти весь (96%) его дают 1% самых неудачных выборок: на краю отрезка не оказалось точек, и полином там «взрывается». Поэтому от запуска к запуску это число меняется в разы. Те же взорвавшиеся выборки сдвигают и «среднюю кривую» — отсюда смещение 0.04 у степени 7 вместо почти нуля у степени 5. У степени 9 разброс уходит в десятки и сотни тысяч.

У GPT-3 175 млрд параметров — примерно в 15 миллиардов раз больше, чем коэффициентов у нашего полинома 11-й степени, а переобучается она не катастрофически. Классическая U-кривая — не вся правда. Белкин и соавторы (2019) описали двойной спуск: если увеличивать модель дальше точки, где она начинает идеально проходить через все обучающие примеры, ошибка на тесте может снова пойти вниз. Среди причин — неявная регуляризация градиентного спуска (что такое регуляризация, разберём ниже в этом уроке): из бесконечного множества решений, идеально подогнанных под train, он находит «гладкие». А при предобучении LLM переобучиться трудно по другой причине: каждый токен корпуса модель видит обычно один-два раза. Ещё один сюжет за пределами U-кривой — гроккинг: маленькая сеть сначала зазубривает обучающие примеры, а обобщать начинает в разы позже, если обучение не останавливать (урок 11.4.1).

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

Как понять, что именно происходит с вашей моделью? Нарисовать кривые обучения. Их два вида.

Ошибка в зависимости от размера выборки. Медианы по 200 повторам для того же синуса (в каждом повторе — новая обучающая выборка и 1000 новых тестовых точек):

Обучающих точек	Степень 1: train / test	Степень 9: train / test
15	0.193 / 0.261	0.013 / 7.047
30	0.217 / 0.253	0.027 / 0.082
100	0.233 / 0.240	0.036 / 0.045
1000	0.235 / 0.236	0.039 / 0.040

У прямой обе кривые быстро сходятся к ≈ 0.236 и дальше стоят. Это предел для прямой: 0.196 — промах лучшей возможной прямой мимо синусоиды (смещение²) плюс 0.04 шума. Больше данных не поможет — нужна модель сложнее. У полинома 9-й степени огромный разрыв при малых данных, но он закрывается с ростом выборки. Здесь больше данных — лучшее лекарство. Именно поэтому большие модели требуют больших корпусов.

Ошибка в зависимости от эпохи. При итеративном обучении (градиентный спуск, нейросети) модель улучшается шаг за шагом. Эпоха — один полный проход по всем обучающим данным (урок 1.4.1). После каждой эпохи считают loss на train и на validation:

оба падают — учим дальше;
train падает, validation остановился и пошёл вверх — началось переобучение, пора останавливаться;
train почти не падает — проблема в оптимизации (слишком большой или маленький learning rate, неудачные начальные значения весов, баг в коде) или модель слишком проста.

В схеме ниже встретится ещё одна причина плохого validation — сдвиг распределения: новые данные устроены иначе, чем обучающие. Например, модель учили на отзывах о фильмах, а проверяют на отзывах о ресторанах.

flowchart TD
A["Loss на train большой?"] -->|да| B["Модель слишком простая<br/>или плохая оптимизация"]
B --> B1["Сложнее модель, больше признаков;<br/>проверить lr и код"]
A -->|нет| C["Loss на validation большой?"]
C -->|да| D["Переобучение<br/>или сдвиг распределения"]
D --> D1["Больше данных, регуляризация,<br/>ранняя остановка, проще модель"]
C -->|нет| E["Готово — проверяем на test один раз"]

Порядок диагностики: сначала train, потом validation

L2-регуляризация

Переобученный полином выдаёт себя гигантскими коэффициентами. Идея регуляризации: штрафовать модель за сложность прямо в функции потерь. Самый популярный штраф — квадрат нормы весов:

L(w) = \lVert Xw - y \rVert^2 + \lambda \lVert w \rVert^2 .

Значок $\lVert v \rVert$ — длина (норма) вектора из урока 1.1.1, а квадрат длины — просто сумма квадратов его элементов. Поэтому первое слагаемое — знакомая сумма квадратов ошибок: $Xw - y$ — вектор ошибок на всех примерах. Второе — сумма квадратов весов $\sum_j w_j^2$ , умноженная на число $\lambda \ge 0$ («лямбда»). При $\lambda = 0$ штрафа нет; чем больше $\lambda$ , тем дороже модели обходятся большие веса.

Пример. Веса $w = (3, -4)$ , сумма квадратов ошибок равна 1.5, $\lambda = 0.1$ . Штраф: $0.1 \cdot (3^2 + 4^2) = 0.1 \cdot 25 = 2.5$ , и $L = 1.5 + 2.5 = 4$ . Другие веса $w = (1, -1)$ ошибаются чуть сильнее, сумма квадратов ошибок 2.0, зато штраф всего $0.1 \cdot 2 = 0.2$ , и $L = 2.2$ . С регуляризацией выигрывает вторая, более «скромная» модель.

Для линейной модели решение по-прежнему находится формулой: к $X^\top X$ из метода наименьших квадратов добавляется $\lambda I$ . Здесь $I$ — единичная матрица из урока 1.1.2 (единицы на диагонали, нули вне её), так что $+\lambda I$ означает «прибавить $\lambda$ к каждому диагональному элементу». Это гребневая регрессия (ridge), L2-регуляризация (ridge):

w = (X^\top X + \lambda I)^{-1} X^\top y .

Добавка $\lambda I$ заодно делает матрицу обратимой, даже когда признаков больше, чем примеров (подробнее — в уроке 2.2.1). Вот полином 9-й степени на тех же 12 точках:

$\lambda$	MSE на train	MSE на test	$\lVert w \rVert$
0	0.0035	1.850	361 661
$10^{-6}$	0.0085	0.074	137
$10^{-4}$	0.0139	0.052	20
$10^{-3}$	0.0228	0.077	10.8
$10^{-2}$	0.0436	0.118	4.6
1	0.1682	0.338	0.6

Ошибка на train с ростом $\lambda$ только растёт: модель теряет свободу. Ошибка на test описывает ту же U-кривую: $\lambda = 0$ — переобучение, $\lambda = 1$ — недообучение, оптимум около $10^{-4}$ . Крошечный штраф $10^{-6}$ уже уменьшил ошибку на test в 25 раз. Число $\lambda$ — гиперпараметр: градиентом его не найти, его выбирают по валидации.

Ещё три взгляда на тот же штраф:

Градиент. Производная $\lambda \lVert w \rVert^2$ равна $2\lambda w$ . Каждый шаг спуска сначала умножает веса на $(1 - 2\eta\lambda)$ , а потом делает обычный шаг ( $\eta$ , «эта», — learning rate из урока 1.4.1). Например, при $\eta = 0.1$ и $\lambda = 0.01$ веса на каждом шаге умножаются на $1 - 2 \cdot 0.1 \cdot 0.01 = 0.998$ . Веса «затухают» — отсюда название weight decay («затухание весов»). В AdamW из урока 1.4.2 это затухание отделено от адаптивного шага. При предобучении GPT-3 и Llama брали weight decay = 0.1.
Вероятность (для любознательных, можно пропустить). L2-штраф — это априорное убеждение «до всяких данных», что веса небольшие: априорное распределение (prior) весов — нормальное с центром в нуле. Обучение с ним — уже не чистый метод максимального правдоподобия из урока 1.3.2, а поиск самой вероятной модели с учётом prior по правилу Байеса из урока 1.3.1 (MAP-оценка).
Практика. Свободный член $b$ обычно не штрафуют: сдвиг всех ответов на константу сложности не добавляет. В задании ниже для простоты штрафуются все коэффициенты, включая $w_0$ . У L1-штрафа $\lambda \sum |w_j|$ (сумма модулей вместо суммы квадратов) другое свойство: он обнуляет часть весов, то есть отбирает признаки. Dropout — ещё один регуляризатор нейросетей, о нём в уроке 3.4.2.

Ранняя остановка

У итеративного обучения есть бесплатный регуляризатор — время. Веса стартуют с малых значений и растут по мере обучения. Если остановиться вовремя, они не успеют подстроиться под шум. Для линейных моделей можно показать, что ранняя остановка градиентного спуска действует почти как L2-штраф.

Алгоритм:

После каждой эпохи считаем loss на валидации.
Если он лучший за всё время — сохраняем веса (чекпоинт).
Если $p$ эпох подряд (patience) улучшений нет — останавливаемся и откатываемся к лучшему чекпоинту.

У LLM та же логика. Чекпоинты сохраняют регулярно, а при SFT главный рычаг — число эпох: на небольших датасетах обычно хватает одной-трёх. Код — в практике ниже.

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

Валидационная выборка из 20 примеров даёт шумную оценку: повезёт с разбиением — модель выглядит лучше, не повезёт — хуже. Когда данных мало, используют кросс-валидация, перекрёстная проверка по k блокам (k-fold):

Перемешать данные и разрезать на $k$ равных частей (обычно $k = 5$ или 10).
Для каждой части $j$ : обучить модель на остальных $k - 1$ частях, посчитать ошибку $E_j$ на части $j$ .
Оценка качества: $\mathrm{CV} = \frac{1}{k}\sum_{j=1}^{k} E_j$ .

Каждый пример ровно один раз побывал в валидации, и все данные поработали на обучение. Цена — $k$ обучений вместо одного. Выбираем степень полинома по 5-fold CV на 30 точках:

Степень	0	1	2	3	4	5	6	7	8	9
MSE на train	0.494	0.287	0.284	0.031	0.031	0.025	0.025	0.024	0.023	0.023
5-fold CV	0.532	0.376	0.425	0.049	0.049	0.039	0.047	0.042	0.052	0.170
Test (1000 точек)	0.547	0.252	0.255	0.046	0.046	0.045	0.045	0.045	0.048	0.051

Ошибка на train монотонно падает и выбрала бы степень 9. CV уверенно отбрасывает степени 0–2 и 9, а степени 3–7 для неё почти равны: разница в пределах шума. В таких случаях часто берут самую простую модель из почти равных. После выбора гиперпараметра модель обучают заново на всех данных.

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

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

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

Тест внутри train. Дубликаты и почти-дубликаты: одна и та же фотография в разном размере, один текст с разной разметкой.
Предобработка по всем данным. Среднее для нормализации, отбор признаков, заполнение пропусков, PCA посчитали до разбиения. Самый коварный вид — демонстрация ниже.
Утечка целевой переменной. Признак, который знает ответ. Предсказываем уход клиента, а среди признаков — «дата расторжения договора». На тесте блестяще, в продакшене бесполезно.
Время. Случайное разбиение временного ряда: модель учится на завтрашних данных, чтобы предсказать вчерашние.
Группы. Один пользователь в train и в test: модель узнаёт пользователя, а не закономерность.

Насколько это опасно? Возьмём 100 объектов, 5000 признаков чистого шума и случайные метки. Предсказывать нечего, честная точность — 50%, как у монетки. Отберём 20 признаков, сильнее всего коррелирующих с меткой, и обучим простой классификатор. Два новых слова:

Корреляция признака с меткой — число, которое показывает, насколько признак «ходит вместе» с меткой: у объектов с меткой 1 он в среднем заметно больше (или меньше), чем у объектов с меткой 0. Если связи нет, корреляция около нуля. В коде мы считаем её модуль, то есть силу связи без учёта направления.
Классификатор «ближайший центр» — самый простой из возможных. Усредняем точки каждого класса и получаем два «центра», а новый объект относим к классу, чей центр ближе. Похожую идею вы ещё встретите в k-means (урок 2.3.2).

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

import numpy as np

rng = np.random.default_rng(0)
n, p, top = 100, 5000, 20            # 100 объектов, 5000 признаков, отбираем 20 лучших
X = rng.normal(size=(n, p))          # 5000 признаков чистого шума: таблица 100 × 5000
y = rng.integers(0, 2, size=n)       # случайные метки 0/1: предсказывать НЕЧЕГО

def select(X, y, top):
    """Индексы признаков, сильнее всего коррелирующих с меткой."""
    Xc = (X - X.mean(0)) / X.std(0)                    # стандартизуем каждый столбец (среднее 0, std 1)
    corr = np.abs(Xc.T @ (y - y.mean())) / len(y)      # сила связи каждого признака с меткой: 5000 чисел
    return np.argsort(corr)[-top:]                     # argsort упорядочивает по возрастанию → берём 20 последних

def nearest_centroid(X_tr, y_tr, X_te):
    """Классификатор «ближайший центр»."""
    c0, c1 = X_tr[y_tr == 0].mean(0), X_tr[y_tr == 1].mean(0)   # центры классов 0 и 1 (маски — урок 0.3.1)
    d0 = ((X_te - c0) ** 2).sum(1)                     # квадрат расстояния каждого объекта до центра 0
    d1 = ((X_te - c1) ** 2).sum(1)                     # ... и до центра 1
    return (d1 < d0).astype(int)                       # ближе к центру 1 → класс 1, иначе 0

def cv_accuracy(leaky, k=5):
    """Точность по 5-fold кросс-валидации (см. раздел выше)."""
    folds = np.array_split(rng.permutation(n), k)     # перемешанные номера, разрезанные на 5 частей по 20
    feats_all = select(X, y, top)                     # ← отбор по ВСЕМ данным, включая валидацию (утечка)
    accs = []
    for i in range(k):
        va = folds[i]                                                # часть i — валидация
        tr = np.concatenate([folds[j] for j in range(k) if j != i])  # остальные четыре — train
        feats = feats_all if leaky else select(X[tr], y[tr], top)  # ← честно: отбираем только по train
        pred = nearest_centroid(X[tr][:, feats], y[tr], X[va][:, feats])
        accs.append((pred == y[va]).mean())           # доля верных ответов на валидации
    return np.mean(accs)

print(f"с утечкой:  accuracy = {cv_accuracy(leaky=True):.2f}")
print(f"честно:     accuracy = {cv_accuracy(leaky=False):.2f}")

с утечкой:  accuracy = 0.88
честно:     accuracy = 0.44

88% на чистом шуме. Среди 5000 случайных признаков всегда найдутся 20, которые случайно совпали с метками на этих 100 объектах, включая валидационные. Если отбирать признаки внутри каждого фолда, точность честно падает до уровня монетки. Правило: всё, что обучается, включая предобработку, обучается только на train. В scikit-learn для этого есть Pipeline (урок 2.4.4).

У языковых моделей самая громкая утечка — загрязнение данных. Бенчмарки публикуются в интернете, интернет попадает в корпус предобучения, и модель видела задачи из теста. Признаки: модель дословно продолжает условие задачи, а на перефразированных или свежих задачах точность резко падает. Защита: дедупликация корпуса против бенчмарков по n-граммам (из корпуса выбрасывают тексты, где встречаются те же цепочки из $n$ слов подряд, что и в задачах бенчмарка) и «живые» бенчмарки из задач, опубликованных после даты среза данных — момента, после которого тексты в корпус уже не попадали (например, LiveCodeBench). Подробно — в уроке 7.3.1.

Практика

Соберите полиномиальную регрессию с L2-регуляризацией и выбор степени по валидации. В заготовке четыре функции с # TODO: mse, poly_features, fit_ridge и select_degree (функция predict уже готова). Делайте их по одной в этом порядке и после каждой нажимайте «Запустить». Когда всё будет готово, кнопка напечатает ошибки на train и val для степеней 0, 1, 3, 5, 9 и лучшую степень по валидации среди 0–9. Посмотрите, где начинается переобучение.

Новая для вас функция NumPy — np.linalg.solve(A, b): она находит вектор $w$ , для которого $A w = b$ . Это то же самое, что $A^{-1} b$ , но считается точнее и быстрее, чем через обратную матрицу.

Полиномы: от недообучения к переобучениюnumpy · нужен интернет7 тестов

import numpy as np


def poly_features(x, degree):
    """Матрица [1, x, x², …, x^degree] формы (len(x), degree + 1).

    Пример: poly_features([2, 3], 2) → [[1, 2, 4], [1, 3, 9]]
    (строка — одна точка, столбец j — x в степени j).
    """
    # TODO: ваш код. Шаг 1: x = np.asarray(x, dtype=float) — на вход может прийти список.
    # Шаг 2: все степени сразу через broadcasting (урок 0.3.2).
    ...


def fit_ridge(x, y, degree, lam=0.0):
    """Коэффициенты полинома, минимизирующие ||Xw − y||² + lam·||w||².

    Решение в замкнутой форме: w = (XᵀX + lam·I)⁻¹ Xᵀy, где X = poly_features(x, degree).
    При lam = 0 это обычный метод наименьших квадратов.
    Пригодятся: np.eye(m) — единичная матрица m × m;
    np.linalg.solve(A, b) — решение уравнения A·w = b (то же, что inv(A) @ b, но точнее).
    """
    # TODO: ваш код
    ...


def predict(x, w):
    """Значения полинома с коэффициентами w в точках x (уже готово)."""
    return poly_features(x, len(w) - 1) @ w


def mse(y, y_hat):
    """Среднеквадратичная ошибка: среднее от (y − y_hat)². Верните float.

    Пример: mse([1, 2, 3], [1, 2, 5]) → (0 + 0 + 4) / 3 ≈ 1.3333
    """
    # TODO: ваш код
    ...


def select_degree(x_tr, y_tr, x_val, y_val, degrees, lam=0.0):
    """Обучите полином каждой степени из degrees на train и верните ту степень,
    у которой ошибка на ВАЛИДАЦИИ минимальна.

    План: для каждой степени d — w = fit_ridge(x_tr, y_tr, d, lam), ошибка mse(y_val, predict(x_val, w));
    затем верните ту d, у которой ошибка наименьшая (не номер в списке, а саму степень).
    """
    # TODO: ваш код
    ...


# «Запустить»: train- и val-ошибка для разных степеней
rng = np.random.default_rng(0)
x_tr = rng.uniform(0, 1, 15)
y_tr = np.sin(2 * np.pi * x_tr) + rng.normal(0, 0.2, 15)
x_val = rng.uniform(0, 1, 100)
y_val = np.sin(2 * np.pi * x_val) + rng.normal(0, 0.2, 100)
if poly_features([1.0], 1) is None or fit_ridge(x_tr, y_tr, 1) is None or mse([0.0], [0.0]) is None:
    print("Допишите poly_features, fit_ridge и mse — тогда здесь появится таблица ошибок.")
else:
    for d in [0, 1, 3, 5, 9]:
        w = fit_ridge(x_tr, y_tr, d)
        print(f"степень {d}: train {mse(y_tr, predict(x_tr, w)):.4f}   val {mse(y_val, predict(x_val, w)):.4f}")
    best = select_degree(x_tr, y_tr, x_val, y_val, list(range(10)))
    print("лучшая степень по валидации:", best if best is not None else "допишите select_degree")

После решения поэкспериментируйте: вызовите fit_ridge(x_tr, y_tr, 9, lam) для $\lambda$ из списка [0, 1e-8, 1e-6, 1e-4, 1e-2, 1] и найдите лучшее значение по валидации. Данные в задании другие (15 точек), поэтому точного совпадения с таблицей урока не ждите. Но картина та же: при $\lambda = 0$ ошибка на val почти в 20 раз больше, чем при крошечном штрафе $10^{-6}$ , а при $\lambda = 1$ модель уже недообучена.

Ранняя остановка на PyTorch

Запустите локально. Сеть на 66 тысяч параметров учится на 20 точках, шум со стандартным отклонением 0.3, то есть неустранимая ошибка $0.3^2 = 0.09$ . PyTorch и нейросети подробно разберём на ступени 3, а сейчас относитесь к сети как к «чёрному ящику» с настраиваемыми весами и следите только за логикой цикла: шаг обучения, замер на валидации, чекпоинт, счётчик терпения. Одна эпоха здесь — один шаг спуска по всем 20 точкам сразу. Строки, которые делают шаг обучения (zero_grad, backward, step), — стандартное заклинание PyTorch: вы встречали его в уроке 1.4.1, а разберёте до винтика в уроке 3.3.2.

import copy
import torch
from torch import nn

torch.set_num_threads(1)          # для крошечной сети один поток быстрее
torch.manual_seed(2)              # сид: при каждом запуске одни и те же «случайные» числа
f = lambda x: torch.sin(2 * torch.pi * x)                          # истинная зависимость — синус
x_tr = torch.rand(20, 1);  y_tr = f(x_tr) + 0.3 * torch.randn(20, 1)   # 20 обучающих точек с шумом
x_va = torch.rand(200, 1); y_va = f(x_va) + 0.3 * torch.randn(200, 1)  # 200 валидационных

# «Чёрный ящик»: нейросеть из трёх линейных слоёв (ступень 3), ~66 тысяч весов
model = nn.Sequential(nn.Linear(1, 256), nn.ReLU(),
                      nn.Linear(256, 256), nn.ReLU(), nn.Linear(256, 1))
opt = torch.optim.Adam(model.parameters(), lr=1e-3)   # оптимизатор Adam из урока 1.4.2
loss_fn = nn.MSELoss()                                 # функция потерь — MSE

best_val, best_epoch, best_state = float("inf"), 0, None   # inf — «бесконечность»: любой loss будет лучше
patience, bad = 1000, 0                    # сколько эпох терпим без улучшения; счётчик неудачных эпох
for epoch in range(1, 3001):
    model.train()                          # режим обучения
    opt.zero_grad()                        # стереть градиенты с прошлого шага
    loss = loss_fn(model(x_tr), y_tr)      # предсказания на train и их MSE
    loss.backward()                        # посчитать градиенты по всем весам
    opt.step()                             # сделать шаг спуска

    model.eval()                           # режим оценки
    with torch.no_grad():                  # при замере градиенты не нужны
        val = loss_fn(model(x_va), y_va).item()   # .item() превращает тензор из одного числа в float
    if val < best_val:                     # новый рекорд — запоминаем веса
        best_val, best_epoch, bad = val, epoch, 0
        best_state = copy.deepcopy(model.state_dict())   # копия всех весов — это и есть чекпоинт
    else:
        bad += 1                           # ещё одна эпоха без улучшения
    if epoch in (1, 50, 100, 150) or epoch % 250 == 0:   # печатаем выборочно
        print(f"эпоха {epoch:4d}: train {loss.item():.3f}   val {val:.3f}")
    if bad >= patience:                    # терпение кончилось — останавливаемся
        print(f"стоп на эпохе {epoch}: лучшая была {best_epoch} (val {best_val:.3f})")
        break

model.load_state_dict(best_state)          # откатываемся к лучшим весам

эпоха    1: train 0.558   val 0.604
эпоха   50: train 0.131   val 0.185
эпоха  100: train 0.052   val 0.113
эпоха  150: train 0.046   val 0.102
эпоха  250: train 0.045   val 0.103
эпоха  500: train 0.041   val 0.107
эпоха  750: train 0.036   val 0.111
эпоха 1000: train 0.031   val 0.124
стоп на эпохе 1138: лучшая была 138 (val 0.102)

Первые полторы сотни эпох падают оба loss: модель выучивает саму синусоиду. Дальше train продолжает снижаться до 0.031 — это ниже уровня шума 0.09. Модель заучивает шум конкретных 20 точек, и val loss растёт. Лучшей была 138-я эпоха, к ней мы и откатились. Числа на другой версии PyTorch могут немного отличаться, картина — нет. Попробуйте добавить weight_decay=1e-2 в torch.optim.AdamW вместо Adam и сравните.

Китайский угол: «прохождение игры» от Ли Хунъи и покемоны

Самый популярный китаеязычный курс ML — лекции Ли Хунъи (Национальный университет Тайваня). В курсе ML 2021 есть лекция «Прохождение задач машинного обучения» (в названии стоит слово, которым называют гайды к компьютерным играм). Порядок диагностики из неё стал стандартом для китайских студентов:

Сначала смотрите на loss на train. Если он большой, причин две. Model bias: в выбранном семействе функций хорошей нет, «ищем иголку в море, а её там нет». Лечится более гибкой моделью. Или optimization issue: хорошая функция есть, но спуск её не нашёл. Различить помогает сравнение с моделью поменьше. Классический пример — статья о ResNet из Microsoft Research Asia: 56-слойная сеть давала большую ошибку на train, чем 20-слойная. Значит, виновата оптимизация, а не переобучение.
Если train в порядке, а test плохой — переобучение (больше данных, аугментация, ограничения модели, ранняя остановка, регуляризация) или mismatch: тестовые данные устроены иначе, чем обучающие.

Схема выше в этом уроке — пересказ этого рецепта. А в версиях курса 2016–2017 годов переобучение показывали на покемонах: по боевой силе (CP) покемона предсказывали его CP после эволюции полиномами степеней от 1 до 5. С 4-й степени ошибка на тесте начинала расти, а на 5-й взлетала. Одним из лекарств была L2-регуляризация — как в нашем задании.

В учебнике d2l-zh (раздел 4.4, Apache-2.0) тот же эксперимент: данные из полинома $5 + 1.2x - 3.4\frac{x^2}{2!} + 5.6\frac{x^3}{3!}$ с шумом, по 100 точек в train и test, и три модели — кубическая (норма), линейная (недообучение) и с 20 признаками (переобучение). Следующий раздел 4.5 называется «Затухание весов» — weight decay.

Сленг на заметку: подгонку модели под лидерборд в китайском AI-сообществе называют «шуабан» (примерно «накручивать рейтинг»). Это переобучение на тестовую выборку целого сообщества.

Проверь себя

Проверь себя6 вопросов

1 MSE на train = 0.30, на validation = 0.31, уровень шума в данных ≈ 0.04. Что происходит?Переобучение: нужна регуляризацияНедообучение: модель слишком проста, нужна более гибкая модель или лучшие признакиВсё отлично: ошибки почти равныУтечка данных

2 Модель переобучилась: train loss 0.01, validation loss 0.9. Что из этого поможет?Можно выбрать несколько ответовСобрать больше обучающих данныхУвеличить

\lambda

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

3 В точке

x

смещение² = 0.01, разброс = 0.05, дисперсия шума

\sigma^2

= 0.04. Чему равна ожидаемая квадратичная ошибка на новых данных?

4 Признаки стандартизировали (вычли среднее, поделили на стандартное отклонение) по всему датасету, а потом разбили его на train и test. В чём проблема?Никакой проблемы: стандартизация не использует меткиУтечка: статистики тестовых объектов повлияли на обработку train, оценка на test оптимистичнаСтандартизация вообще не нужнаНужно было стандартизировать только test

5 В датасете 1000 примеров, используем 5-fold кросс-валидацию. Сколько примеров в обучающей части каждого из пяти обучений?

6 Что будет с ridge-регрессией, если

\lambda \to \infty

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

\lambda

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

Итоги

Цель — обобщение. Недообучение: обе ошибки высоки. Переобучение: train низкая, validation высокая.
Ожидаемая ошибка = смещение² + разброс + шум. Сложность модели переливает одно в другое. Большие нейросети живут за пределами классической U-кривой (двойной спуск).
Кривые обучения подсказывают лекарство: при высоком смещении — сложнее модель, при высоком разбросе — больше данных и регуляризация.
L2 / weight decay, ранняя остановка и кросс-валидация — базовый набор против переобучения. $\lambda$ , степень и число эпох выбирают по валидации.
Утечки делают оценку красивой и ложной: предобработку учим только на train, а у LLM следим за загрязнением бенчмарков.

Дальше: модуль 2.2 — линейная регрессия, логистическая регрессия и метрики качества с нуля. А классические алгоритмы — kNN, деревья, бустинг — ждут в модуле 2.3.