дорожка · 10.11.2026 · отсев

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

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

Все дорожки — /put. Прошлая — пересчёт активаций.

1 Переобучение и что с ним делает отсев

Зачем это в работе. Когда вы дообучаете модель на своих данных, их почти всегда мало: сотни или тысячи примеров против миллиардов токенов предобучения. На маленьком наборе сеть быстро начинает запоминать конкретные примеры вместе с их случайным шумом, и ошибка на обучении падает, а на новых данных растёт. Отсев нейронов (dropout) — один из самых дешёвых способов это сдержать: одна строчка в коде, никакой лишней памяти для весов. Чтобы решать, включать ли его и с какой силой, нужно понимать, с какой именно болезнью он борется.

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

Отсев действует так: на каждом шаге обучения каждый нейрон выбранного слоя с вероятностью p временно обнуляется, и на следующем шаге выбор делается заново. Сеть не может рассчитывать, что конкретный нейрон будет на месте, поэтому ей невыгодно строить решение на хрупкой комбинации нескольких признаков, которые вместе «узнают» один обучающий пример. Авторы метода (Srivastava, Hinton и соавторы, журнал JMLR, 2014) описывают это как обучение огромного числа «прореженных» подсетей с общими весами, которые при проверке усредняются в одну.

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

Чем это отличается от соседей. Затухание весов (weight decay) тянет сами веса к нулю и делает функцию глаже; ранняя остановка (early stopping) просто прекращает обучение, когда проверочная ошибка перестала падать; расширение данных (data augmentation) добавляет примеры. Отсев единственный из них вносит в обучение шум внутрь сети, а не в данные или в правило обновления. Подробнее о соседях — в ступени 4.

Подробный пример. Тридцать точек синусоиды на отрезке от −3 до 3 с шумом (стандартное отклонение 0,3, значит, даже идеальная модель получит среднюю квадратичную ошибку около 0,09). Сеть с одним скрытым слоем на 512 нейронов — заведомо слишком большая для 30 точек. Обучаем Adam 6000 шагов без отсева и с отсевом p = 0,2 и p = 0,5 на скрытом слое, по три запуска с разной случайностью, и меряем ошибку на 1000 новых точках.

import numpy as np
rng = np.random.default_rng(1)
def data(n):
    x = rng.uniform(-3, 3, (n, 1))
    return x, np.sin(x) + rng.normal(0, 0.3, (n, 1))
xtr, ytr = data(30); xte, yte = data(1000)
H = 512

def train(p, steps=6000, lr=0.01, seed=0):
    r = np.random.default_rng(seed)
    W1 = r.normal(0, 1.0, (1, H)); b1 = r.normal(0, 1.0, H)
    W2 = r.normal(0, 1/np.sqrt(H), (H, 1)); b2 = np.zeros(1)
    P = [W1, b1, W2, b2]; m = [np.zeros_like(a) for a in P]; v = [np.zeros_like(a) for a in P]
    for t in range(1, steps + 1):
        h = np.tanh(xtr @ W1 + b1)
        mask = (r.random(h.shape) >= p) / (1 - p) if p > 0 else 1.0
        hd = h * mask
        out = hd @ W2 + b2
        g = 2 * (out - ytr) / len(xtr)
        gW2 = hd.T @ g; gb2 = g.sum(0)
        gh = (g @ W2.T) * mask * (1 - h**2)
        gW1 = xtr.T @ gh; gb1 = gh.sum(0)
        for i, gr in enumerate([gW1, gb1, gW2, gb2]):     # Adam
            m[i] = 0.9*m[i] + 0.1*gr; v[i] = 0.999*v[i] + 0.001*gr**2
            P[i] -= lr * (m[i]/(1-0.9**t)) / (np.sqrt(v[i]/(1-0.999**t)) + 1e-8)
    return P

def predict(P, x):          # режим проверки: отсев выключен
    W1, b1, W2, b2 = P
    return np.tanh(x @ W1 + b1) @ W2 + b2

for p in [0.0, 0.2, 0.5]:
    tr, te = [], []
    for seed in range(3):                    # три запуска с разной случайностью
        P = train(p, seed=seed)
        tr.append(np.mean((predict(P, xtr) - ytr)**2)); te.append(np.mean((predict(P, xte) - yte)**2))
    print(f"p={p:.1f}  обучение {np.round(tr, 3)}   новые точки {np.round(te, 3)}")
print(f"шум в данных сам по себе: {0.3**2:.3f}")

У нас этот код напечатал:

p=0.0  обучение [0.041 0.061 0.041]   новые точки [0.161 0.148 0.141]
p=0.2  обучение [0.055 0.054 0.065]   новые точки [0.108 0.12  0.128]
p=0.5  обучение [0.066 0.068 0.063]   новые точки [0.122 0.142 0.124]
шум в данных сам по себе: 0.090

Без отсева ошибка на обучении (0,04–0,06) ниже уровня шума 0,09 — это прямой признак того, что сеть выучила шум конкретных точек. На новых точках она 0,14–0,16. С p = 0,2 ошибка на обучении выросла, а на новых точках упала до 0,11–0,13 во всех трёх запусках. С p = 0,5 выигрыш меньше: слишком сильный шум уже мешает выучить сам синус. Сила отсева — настройка, а не «чем больше, тем лучше».

Где обычно ошибаются.

  • Судят о пользе отсева по ошибке на обучении. Она с отсевом почти всегда выше — это ожидаемо; смотреть нужно только на проверочную выборку.
  • Включают отсев, когда модель ещё не выучила даже обучающие данные. Если обе ошибки высокие, проблема в ёмкости, шаге обучения или данных, а не в переобучении.
  • Сравнивают варианты по одному запуску. На маленьком наборе разброс между запусками сопоставим с эффектом — в примере выше разница между зёрнами доходит до 0,02.

Словарь ступени.

Переобучение (overfitting). Подгонка модели под шум и особенности обучающих примеров в ущерб новым данным.

Недообучение (underfitting). Модель не может хорошо описать даже обучающие примеры: слишком слабая или мало обучалась.

Проверочная выборка (validation set). Отложенные примеры, на которых не учатся, а только меряют ошибку.

Отсев нейронов (dropout). Случайное временное обнуление части нейронов на каждом шаге обучения.

Вероятность отсева p (dropout rate). Доля нейронов, которые в среднем обнуляются; типичные значения в опубликованных конфигурациях — от 0 до 0,5.

Ёмкость модели (capacity). Насколько сложные зависимости модель способна выучить; чем больше параметров, тем больше ёмкость.

Регуляризация (regularization). Общее название приёмов, которые мешают модели заучивать обучающие данные.

2 Маска, поправка 1/(1-p) и два режима работы

Зачем это в работе. Почти все ошибки с отсевом — не в идее, а в механике: забыли переключить режим, дважды применили поправку, сравнили выходы модели в разных режимах. Если понимать, что именно делает слой отсева с числами при обучении и при проверке, такие ошибки находятся за минуту, а не за день.

Как это устроено. Шаг первый: для каждого числа на выходе слоя генерируется случайное число от 0 до 1, и если оно меньше p, нейрон выключается. Получается маска (mask) — массив из нулей и единиц той же формы, что выход слоя. Шаг второй: выход умножают на маску. Шаг третий: оставшиеся значения делят на 1 − p. При обратном проходе градиент проходит через ту же маску: выключенный нейрон на этом шаге не получает никакого обновления по своим исходящим связям.

Зачем деление. Если просто обнулить 30% нейронов, среднее значение выхода упадёт на 30%, и следующий слой при обучении привыкнет к «ослабленному» сигналу. При проверке отсев выключают, сигнал снова полный — и следующий слой получает не то, к чему привык. Деление на 1 − p при обучении возвращает среднее к исходному уровню, и тогда при проверке слой можно просто пропустить. Такой вариант называется обратным отсевом (inverted dropout); именно так работает, например, nn.Dropout в PyTorch. В исходной статье 2014 года поправку делали наоборот — умножали веса на 1 − p при проверке; результат по среднему тот же.

Отсюда два режима. В режиме обучения (training mode) маска случайная, выход каждый раз разный. В режиме проверки и генерации (evaluation mode) слой отсева ничего не делает, выход детерминирован. В PyTorch режим переключают model.train() и model.eval(); это флаг на всей модели, а не на отдельном вызове.

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

Подробный пример. Берём 100 000 × 64 «выходов нейронов» со средним 1 и разбросом 0,25, выключаем 30% и сравниваем среднее с поправкой и без неё. Затем проверяем строку из восьми весов внимания после отсева с p = 0,1.

import numpy as np
rng = np.random.default_rng(0)
h = rng.normal(1.0, 0.5, (100_000, 64))      # «выходы нейронов» одного слоя
p = 0.3
keep = rng.random(h.shape) >= p              # маска: True = нейрон оставлен
print("доля оставленных:", round(keep.mean(), 4))
plain    = h * keep                          # отсев без поправки
inverted = h * keep / (1 - p)                # обратный отсев (inverted dropout)
print("среднее без отсева      :", round(h.mean(), 4))
print("среднее, отсев без 1/(1-p):", round(plain.mean(), 4))
print("среднее, обратный отсев  :", round(inverted.mean(), 4))
print("разброс без отсева      :", round(h.var(), 4))
print("разброс, обратный отсев  :", round(inverted.var(), 4))
# строка вероятностей внимания: после отсева сумма уже не 1
r = np.random.default_rng(5)
att = np.exp(r.normal(size=8)); att /= att.sum()
m = (r.random(8) >= 0.1) / 0.9
print("сумма весов внимания до/после:", round(att.sum(), 3), round((att * m).sum(), 3))
sums = [(att * ((r.random(8) >= 0.1) / 0.9)).sum() for _ in range(100_000)]
print("средняя сумма по 100000 масок:", round(np.mean(sums), 3))

У нас этот код напечатал:

доля оставленных: 0.6998
среднее без отсева      : 1.0
среднее, отсев без 1/(1-p): 0.6998
среднее, обратный отсев  : 0.9997
разброс без отсева      : 0.2499
разброс, обратный отсев  : 0.7855
сумма весов внимания до/после: 1.0 1.051
средняя сумма по 100000 масок: 1.001

Без поправки среднее упало до 0,70 — ровно на долю выключенных. С делением на 1 − p оно вернулось к 1,00. Но разброс (дисперсия) вырос с 0,25 до 0,79: среднее сохранили, форму распределения — нет. Строка внимания после отсева в одном конкретном случае дала в сумме 1,051, а не 1; в среднем по 100 000 масок — 1,001. Это не ошибка: так и задумано, но об этом надо помнить, если код где-то проверяет, что веса внимания суммируются в единицу.

Где обычно ошибаются.

  • Пишут отсев вручную и забывают деление на 1 − p либо делят и при обучении, и при проверке. Модель при этом не падает, а просто тихо работает хуже.
  • Используют одну маску на весь пакет или на все шаги. Маска должна быть новой для каждого примера и каждого шага, иначе это не шум, а постоянное удаление нейронов.
  • Ждут, что отсев сохранит разброс значений. Он сохраняет только среднее.

Словарь ступени.

Маска (mask). Массив из нулей и единиц, который говорит, какие нейроны на этом шаге оставлены.

Обратный отсев (inverted dropout). Вариант, где оставшиеся значения при обучении делят на 1 − p, чтобы при проверке слой можно было просто пропустить.

Режим обучения (training mode). Состояние модели, в котором отсев и подобные слои ведут себя случайно и собирают статистики.

Режим проверки (evaluation mode). Состояние модели для оценки и генерации, в котором отсев выключен и выход детерминирован.

model.train() / model.eval(). Методы PyTorch, переключающие всю модель между двумя режимами.

Математическое ожидание (expectation). Среднее значение случайной величины по всем её возможным исходам.

Дисперсия (variance). Мера разброса значений вокруг среднего: среднее квадрата отклонения.

3 Где отсев стоит в трансформере и почему его часто выключают

Зачем это в работе. Когда вы берёте открытую модель и дообучаете её, в файле настроек (config.json) уже есть поля с вероятностями отсева. Нужно понимать, на что каждое из них влияет и почему у одних моделей там 0,1, а у других 0, — чтобы не включить отсев туда, где он вреден, и не забыть там, где он полезен.

Как это устроено. В классическом трансформере отсев ставят в трёх местах. Первое — после сложения векторов токенов и позиций на входе (embedding dropout). Второе — на весах внимания после softmax, то есть случайно выключаются отдельные связи «токен смотрит на токен» (attention dropout). Третье — на выходе каждого подблока, внимания и полносвязного блока, перед тем как результат прибавляется к остаточному пути (residual dropout; про остаточный путь — в дорожке про нормализацию).

Это видно в опубликованных конфигурациях. У GPT-2 в config.json на Hugging Face стоят три поля: embd_pdrop = 0.1, attn_pdrop = 0.1 и resid_pdrop = 0.1 — по одному на каждое место. У Qwen2.5-0.5B есть только attention_dropout, и он равен 0.0. Это мы прочитали в самих файлах настроек, а не измеряли.

Почему в новых моделях отсев нередко нулевой. Переобучение возникает, когда модель много раз видит одни и те же примеры. При предобучении на огромном корпусе модель проходит данные примерно один раз или чуть больше, и каждая новая порция текста для неё новая. Заучивать шум конкретного примера, который больше не повторится, сеть не успевает, а отсев продолжает делать своё — вносить шум и отбирать часть ёмкости. Тогда он только замедляет обучение. Это рассуждение, а не закон: отдельные лаборатории в своих отчётах по-разному описывают, где и с какой силой они его оставляют.

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

Подробный пример. Та же сеть и та же синусоида, что в ступени 1, но теперь меняем число обучающих точек: 30, 300 и 3000. Для каждого размера обучаем без отсева и с p = 0,2 и сравниваем ошибку на новых точках. Набор из 30 точек здесь сгенерирован заново, поэтому число без отсева немного отличается от ступени 1.

import numpy as np
exec(open('overfit.py').read().split("for p in")[0])   # та же сеть и обучение
for n in [30, 300, 3000]:
    xtr, ytr = data(n)                       # больше обучающих точек
    res = {}
    for p in [0.0, 0.2]:
        P = train(p, seed=0)
        res[p] = np.mean((predict(P, xte) - yte)**2)
    print(f"n={n:5d}  без отсева {res[0.0]:.3f}   p=0.2 {res[0.2]:.3f}")

У нас этот код напечатал:

n=   30  без отсева 0.169   p=0.2 0.122
n=  300  без отсева 0.098   p=0.2 0.100
n= 3000  без отсева 0.095   p=0.2 0.095

На 30 точках отсев снижает ошибку с 0,169 до 0,122. На 300 точках разницы почти нет (0,098 против 0,100), на 3000 — ровно никакой (0,095 и 0,095), и обе близки к уровню шума 0,09. Когда данных достаточно, сети просто нечего заучивать сверх закономерности, и отсев становится лишним шумом. Это маленькая модель того же рассуждения, по которому его отключают в больших предобучениях.

Где обычно ошибаются.

  • Переносят вероятность отсева из предобучения в дообучение без раздумий. Если в config.json стоит 0.0, а у вас 2000 примеров и пять эпох, имеет смысл попробовать ненулевое значение и посмотреть на проверочную ошибку.
  • Меняют поле в config.json уже загруженной модели и думают, что отсев включился. Во многих реализациях вероятность читается при создании слоёв; менять надо до загрузки или в самих модулях.
  • Путают отсев на весах внимания с маской внимания (attention mask). Маска внимания детерминированно запрещает смотреть на будущие или пустые токены; отсев случайно выключает разрешённые связи только при обучении.

Словарь ступени.

Отсев на входе (embedding dropout). Отсев на векторах токенов перед первым блоком трансформера.

Отсев внимания (attention dropout). Случайное обнуление отдельных весов внимания после softmax.

Отсев на остаточном пути (residual dropout). Отсев на выходе подблока перед сложением с остаточным путём.

config.json. Файл настроек модели на Hugging Face, где записаны размеры слоёв и вероятности отсева.

Эпоха (epoch). Один полный проход по всем обучающим примерам.

lora_dropout. Параметр библиотеки PEFT: вероятность отсева на входе низкорангового адаптера.

Маска внимания (attention mask). Детерминированный запрет смотреть на определённые токены, например будущие; к отсеву отношения не имеет.

4 Отсев как оценка неуверенности и его соседи

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

Как это устроено. Отсев по методу Монте-Карло (Monte Carlo dropout) описали Gal и Ghahramani в статье на ICML 2016: оставляем отсев включённым при проверке, прогоняем один и тот же вход много раз с разными масками и смотрим на разброс ответов. Среднее служит прогнозом, а стандартное отклонение — мерой неуверенности. Логика такая: каждая маска — немного другая подсеть, и если подсети расходятся, значит, ответ держится на непрочном основании.

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

Соседи. Затухание весов (weight decay) на каждом шаге немного уменьшает веса; в AdamW оно отделено от градиента (дорожка про оптимизатор). Ранняя остановка (early stopping) сохраняет лучшую по проверочной ошибке точку и прекращает обучение, когда та перестала улучшаться. Сглаживание меток (label smoothing) не даёт модели ставить вероятность ровно 1 правильному ответу. Усреднение весов по времени (дорожка про EMA) сглаживает траекторию обучения. Всё это можно включать вместе с отсевом; выбирают по проверочной ошибке, а не по привычке.

Чем отсев отличается от ансамбля (ensemble). Настоящий ансамбль — несколько независимо обученных моделей, у каждой свои веса; он дороже в N раз и при обучении, и при хранении. Отсев имитирует ансамбль подсетей с общими весами почти бесплатно при обучении, но его подсети гораздо менее независимы, поэтому и разброс у них обычно меньше.

Подробный пример. Берём сеть из ступени 1, обученную с p = 0,2 на точках от −3 до 3. Делаем по 500 прогонов с включённым отсевом в четырёх точках: две внутри обучающего отрезка (0 и 2) и две снаружи (5 и 8), — и сравниваем разброс с настоящей ошибкой.

import numpy as np
exec(open('overfit.py').read().split("for p in")[0])
p = 0.2
W1, b1, W2, b2 = train(p, seed=0)
r = np.random.default_rng(42)
def stochastic(x):                           # отсев ОСТАВЛЕН включённым
    h = np.tanh(x @ W1 + b1)
    return (h * (r.random(h.shape) >= p) / (1 - p)) @ W2 + b2
for x in [0.0, 2.0, 5.0, 8.0]:
    xs = np.array([[x]])
    samples = np.array([stochastic(xs)[0, 0] for _ in range(500)])
    print(f"x={x:4.1f}  среднее {samples.mean():+.2f}  разброс (ст. откл.) {samples.std():.2f}  sin(x)={np.sin(x):+.2f}")

У нас этот код напечатал:

x= 0.0  среднее -0.08  разброс (ст. откл.) 0.12  sin(x)=+0.00
x= 2.0  среднее +0.86  разброс (ст. откл.) 0.13  sin(x)=+0.91
x= 5.0  среднее -0.21  разброс (ст. откл.) 0.17  sin(x)=-0.96
x= 8.0  среднее -0.36  разброс (ст. откл.) 0.16  sin(x)=+0.99

Внутри отрезка прогноз близок к правде (при x = 2: 0,86 против 0,91), разброс 0,12–0,13. Снаружи сеть ошибается сильно: при x = 5 она говорит −0,21 вместо −0,96, при x = 8 — −0,36 вместо +0,99. А разброс вырос лишь до 0,16–0,17. То есть неуверенность действительно растёт вне данных, но совсем не пропорционально ошибке: по разбросу 0,17 нельзя догадаться, что ошибка больше единицы. Это ровно тот случай «все подсети уверенно ошибаются», о котором шла речь выше.

Где обычно ошибаются.

  • Принимают разброс по отсеву за честную вероятность ошибки. Без проверки на реальных сбоях он может сильно недооценивать неуверенность, как в примере.
  • Включают отсев при проверке через model.train() целиком и заодно ломают слои, у которых в режиме обучения меняются статистики, например нормализацию по пакету. Включать нужно только сами слои отсева.
  • Складывают все виды регуляризации на максимум. Отсев, сильное затухание весов и сглаживание меток вместе легко переводят модель из переобучения в недообучение.

Словарь ступени.

Отсев по методу Монте-Карло (Monte Carlo dropout). Много прогонов одного входа с включённым отсевом, чтобы по разбросу ответов оценить неуверенность.

Стандартное отклонение (standard deviation). Корень из дисперсии; разброс в тех же единицах, что и сами значения.

Затухание весов (weight decay). Небольшое уменьшение всех весов на каждом шаге, которое мешает им разрастаться.

Ранняя остановка (early stopping). Прекращение обучения, когда проверочная ошибка перестала улучшаться, с сохранением лучшей точки.

Сглаживание меток (label smoothing). Замена жёсткой цели «правильный ответ с вероятностью 1» на чуть размытую, например 0,9.

Ансамбль (ensemble). Несколько независимо обученных моделей, чьи ответы усредняют.

Вне распределения (out-of-distribution). Входы, сильно непохожие на обучающие данные, на которых модель ведёт себя непредсказуемо.

5 Где отсев тихо ломается

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

Как это устроено. Первая ловушка — забытое переключение режима. Если перед оценкой или генерацией не вызвать model.eval(), отсев продолжает выключать нейроны: ответы на один и тот же вход каждый раз разные, а проверочная ошибка завышена и шумит от прогона к прогону. Обратная ошибка — забыть вернуть model.train() после промежуточной оценки — молча отключает регуляризацию на всё оставшееся обучение.

Вторая — двойная поправка. Если отсев написан вручную и деление на 1 − p сделано и при обучении, и при проверке, при проверке все значения оказываются в 1/(1 − p) раз больше, чем сеть привыкла видеть. Для p = 0,2 это на 25% больше.

Третья — сдвиг разброса (variance shift). Как мы видели в ступени 2, обратный отсев сохраняет среднее, но увеличивает разброс. Следующий слой при обучении видит один разброс, а при проверке — меньший. Большинству слоёв это почти безразлично, но если следом стоит нормализация по пакету (batch normalization), которая запоминает статистики при обучении, при проверке она нормализует уже по неверным числам. Этот эффект разобран в статье Li и соавторов на CVPR 2019 о «несовместимости отсева и нормализации по пакету»; практический вывод оттуда — ставить отсев после последней нормализации по пакету, а не перед ней.

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

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

import numpy as np
rng = np.random.default_rng(3)
W = rng.normal(0, 0.1, (16, 1)); h = rng.normal(1.0, 0.5, (1, 16))
p = 0.2
def forward(h, training):
    if training:
        h = h * (rng.random(h.shape) >= p) / (1 - p)
    return float((h @ W)[0, 0])
# 1. забыли переключить в режим проверки
print("один и тот же вход, режим обучения:", [round(forward(h, True), 3) for _ in range(3)])
print("один и тот же вход, режим проверки:", [round(forward(h, False), 3) for _ in range(3)])
# 2. поправку 1/(1-p) применили дважды: и при обучении, и при проверке
big = rng.normal(1.0, 0.5, (50_000, 16))
train_mean = (big * (rng.random(big.shape) >= p) / (1 - p)).mean()
print("среднее при обучении:", round(train_mean, 3),
      " при проверке правильно:", round(big.mean(), 3),
      " с лишним делением:", round((big / (1 - p)).mean(), 3))
# 3. сдвиг разброса: следующий слой при обучении видел другой разброс
tr = big * (rng.random(big.shape) >= p) / (1 - p)
print("разброс входа следующего слоя: обучение", round(tr.var(), 3), " проверка", round(big.var(), 3))

У нас этот код напечатал:

один и тот же вход, режим обучения: [-0.151, -0.319, -0.718]
один и тот же вход, режим проверки: [-0.179, -0.179, -0.179]
среднее при обучении: 1.001  при проверке правильно: 1.0  с лишним делением: 1.25
разброс входа следующего слоя: обучение 0.563  проверка 0.25

В режиме обучения три вызова на одном входе дали −0,151, −0,319 и −0,718 — разброс больше самого ответа. В режиме проверки все три дали −0,179. Лишнее деление подняло среднее с 1,00 до 1,25, ровно на 1/(1 − 0,2). Разброс входа следующего слоя при обучении 0,563, при проверке 0,25 — больше чем вдвое, и именно эту разницу «запомнит» нормализация по пакету, если стоит следом. Быстрый тест на первую ловушку: дважды прогоните одну и ту же проверку; если числа отличаются, где-то остался режим обучения.

Где обычно ошибаются.

  • Оценивают модель внутри цикла обучения и забывают вызвать model.eval() перед оценкой или model.train() после неё.
  • Ставят отсев прямо перед нормализацией по пакету и удивляются, что качество в режиме проверки хуже, чем в режиме обучения.
  • Сравнивают два прогона «с одинаковыми настройками», не зафиксировав зерно генератора, и принимают разницу от разных масок за эффект изменения.

Словарь ступени.

Сдвиг разброса (variance shift). Разница в дисперсии значений между режимами обучения и проверки, которую создаёт отсев.

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

Бегущая статистика (running statistics). Сглаженные среднее и дисперсия, накопленные при обучении и используемые при проверке.

Генератор случайных чисел (random number generator, RNG). Алгоритм, выдающий последовательность «случайных» чисел, полностью определённую начальным состоянием.

Зерно генератора (seed). Начальное значение генератора; одинаковое зерно даёт одинаковые маски.

Детерминированность (determinism). Свойство вычисления давать одинаковый результат при одинаковых входах.

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

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.