дорожка · 07.11.2026 · EMA весов

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

Вчерашняя дорожка про расписание шага закончилась на том, что к концу обучения шаг уменьшают, чтобы веса меньше прыгали. Сегодня — другой способ получить спокойную копию весов: экспоненциальное скользящее среднее весов (exponential moving average of weights, EMA), иногда называют усреднением Поляка (Polyak averaging). Живые веса продолжают учиться с шумом пакета, а рядом ведётся «теневая» копия, которую берут для оценки и часто для финального чекпоинта. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения о статьях и рецептах лабораторий помечены как опубликованные, а не измеренные нами.

Все дорожки — /put. Прошлая — расписание шага.

1 Зачем усреднять веса: живая копия прыгает, теневая спокойнее

Зачем это в работе. В конце обучения вы смотрите на проверочную потерю (validation loss) — среднюю ошибку на данных, которые модель не видела при обновлении весов. Если каждый раз оценивать «живые» веса (те, что только что обновил оптимизатор), цифра прыгает: последний пакет данных слегка утащил веса в свою сторону. Из-за этого сложно сравнить два запуска, выбрать лучший чекпоинт и понять, улучшилась ли модель за последние тысячу шагов. Экспоненциальное скользящее среднее весов (EMA) ведёт рядом вторую копию — «тень» — и именно её обычно подставляют в оценку и в финальный файл модели.

Как это устроено. На каждом шаге оптимизатор меняет живые веса θ. Параллельно обновляют тень θ̄ по правилу θ̄ ← β·θ̄ + (1−β)·θ, где β (обычно 0,99…0,9999) — насколько сильно тень помнит прошлое. Это то же семейство скользящих средних, что первый и второй моменты в Adam, только здесь усредняют сами веса, а не градиенты. Тень не участвует в обратном проходе: градиент считают по живым весам. Цена — дополнительная копия параметров в памяти (ещё примерно столько же байт, сколько занимает сама модель в выбранной точности).

Ограничение: EMA не ускоряет обучение и не заменяет хороший шаг или расписание. Она сглаживает уже полученную траекторию. Если живые веса разлетелись в NaN, тень тоже испортится, только с задержкой. Чем это отличается от соседних понятий. Контрольная точка (checkpoint) — это снимок на диске в конкретный момент; EMA — постоянно обновляемая «мягкая» точка. Спад скорости обучения тоже успокаивает веса, но меняет сам шаг оптимизатора; EMA оставляет шаг как был и сглаживает отдельно.

Подробный пример. Линейная регрессия: 8000 примеров, 12 признаков, шум 0,35 даёт пол потери около 0,1225. Пакет 32, постоянная скорость 0,08, 4000 шагов, β = 0,995. Семь случайных стартов. Смотрим потерю живых весов и тени на одних и тех же шагах, плюс разброс потери на хвосте (шаги 3800–4000).

import numpy as np
rng = np.random.default_rng(0)
N, d = 8000, 12
X = rng.standard_normal((N, d))
w_true = rng.standard_normal(d)
y = X @ w_true + 0.35 * rng.standard_normal(N)
print(f"пол потери ≈ {0.35**2:.4f} (шум 0.35)")

def run(seed, T=4000, B=32, lr=0.08, beta=0.995):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = w.copy()
    hist = []
    for t in range(1, T + 1):
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        ema = beta * ema + (1 - beta) * w
        if t in (100, 500, 1000, 2000, 4000):
            L_live = float(np.mean((X @ w - y) ** 2))
            L_ema = float(np.mean((X @ ema - y) ** 2))
            hist.append((t, L_live, L_ema))
    return hist, float(np.mean((X @ w - y) ** 2)), float(np.mean((X @ ema - y) ** 2))

lives, emas = [], []
hists = []
for s in range(7):
    h, Ll, Le = run(s)
    lives.append(Ll); emas.append(Le); hists.append(h)
print(f"7 сидов, T=4000, B=32, lr=0.08, beta=0.995")
print(f"итог live (мед.)={np.median(lives):.4f}, ema (мед.)={np.median(emas):.4f}")
print("кривая (медианы по сидам):")
for i, t in enumerate((100, 500, 1000, 2000, 4000)):
    Lm = np.median([h[i][1] for h in hists])
    Em = np.median([h[i][2] for h in hists])
    print(f"  t={t:4d}  live={Lm:.4f}  ema={Em:.4f}")
# разброс хвоста
std_l, std_e = [], []
for s in range(7):
    r = np.random.default_rng(s)
    w = r.standard_normal(d) * 0.1; ema = w.copy()
    tl, te = [], []
    for t in range(1, 4001):
        idx = r.integers(0, N, 32)
        err = X[idx] @ w - y[idx]
        g = (2.0 / 32) * (X[idx].T @ err)
        w = w - 0.08 * g
        ema = 0.995 * ema + 0.005 * w
        if t > 3800 and t % 10 == 0:
            tl.append(float(np.mean((X @ w - y) ** 2)))
            te.append(float(np.mean((X @ ema - y) ** 2)))
    std_l.append(np.std(tl)); std_e.append(np.std(te))
print(f"σ потери на хвосте (мед.): live={np.median(std_l):.5f}, ema={np.median(std_e):.5f}")

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

пол потери ≈ 0.1225 (шум 0.35)
7 сидов, T=4000, B=32, lr=0.08, beta=0.995
итог live (мед.)=0.1259, ema (мед.)=0.1223
кривая (медианы по сидам):
  t= 100  live=0.1261  ema=6.1041
  t= 500  live=0.1255  ema=0.2346
  t=1000  live=0.1253  ema=0.1231
  t=2000  live=0.1257  ema=0.1223
  t=4000  live=0.1259  ema=0.1223
σ потери на хвосте (мед.): live=0.00179, ema=0.00003

К шагу 4000 живые веса дают медиану 0,1259, тень — 0,1223: ближе к полу 0,1225. На хвосте σ потери у живых около 0,0018, у тени около 0,00003 — почти в шестьдесят раз спокойнее. Важно: на шаге 100 сырая тень ещё «тяжёлая» от плохого старта (6,1), а живые уже около пола — об этом отдельно на ступени 4. Повтори: поставь β = 0,9 и сравни σ на хвосте.

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

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

Живые веса (online / training weights). Копия, которую обновляет оптимизатор на каждом шаге.

Тень / EMA-веса (EMA weights, shadow weights). Скользящее среднее живых весов; обычно её берут для оценки.

Проверочная потеря (validation loss). Ошибка на отложенных данных; по ней выбирают чекпоинт.

Чекпоинт (checkpoint). Сохранённые на диск веса (и часто состояние оптимизатора) на определённом шаге.

Пол потери. Нижняя граница ошибки из-за шума в данных; ниже неё устойчиво не уйти.

Шум пакета (batch noise). Случайный сдвиг градиента из-за того, что пакет — лишь кусок данных.

2 Коэффициент β и период полураспада: сколько прошлого помнит тень

Зачем это в работе. В конфиге EMA почти всегда одна цифра — decay или β. От неё зависит, за сколько шагов тень «забывает» половину старого состояния. Слишком маленькая β делает тень почти копией живых весов (сглаживание слабое). Слишком большая — тень месяцами тащит ранний старт и на оценке выглядит хуже живых. Подобрать β «на глаз» без понятия периода полураспада легко.

Как это устроено. Формула θ̄_t = β·θ̄_(t−1) + (1−β)·θ_t означает: вклад веса возрастом k шагов пропорционален β^k. Период полураспада (half-life) — число шагов k, за которое вес старого вклада падает вдвое: k = ln(0,5)/ln(β). При β = 0,995 получаем примерно 138 шагов; при β = 0,999 — около 693; при β = 0,9999 — около 6930. Это удобная шкала: сравнивайте полураспад с длиной разогрева, с длиной спада и с тем, как часто вы снимаете чекпоинт.

На практике лаборатории для больших языковых моделей часто ставят очень высокий decay (близко к 0,9999 и выше) и либо стартуют тень не с нуля обучения, либо применяют поправку смещения, либо держат отдельный «короткий» EMA для мониторинга. Точные цифры зависят от рецепта; важнее не число, а согласованность полураспада с бюджетом шагов.

Чем это отличается от β₁/β₂ в Adam. Там скользящие средние относятся к градиенту и его квадрату и живут внутри оптимизатора. Здесь усредняют параметры модели. Путаница возникает, потому что и там, и там буква β и «exponential moving average».

Подробный пример. Та же регрессия, 4000 шагов, семь сидов. Меняем только β и смотрим итоговую потерю тени. Полураспад считаем по формуле выше.

import numpy as np
rng = np.random.default_rng(0)
N, d = 8000, 12
X = rng.standard_normal((N, d))
w_true = rng.standard_normal(d)
y = X @ w_true + 0.35 * rng.standard_normal(N)

def final(seed, beta, T=4000, B=32, lr=0.08):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = w.copy()
    for t in range(1, T + 1):
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        ema = beta * ema + (1 - beta) * w
    return float(np.mean((X @ w - y) ** 2)), float(np.mean((X @ ema - y) ** 2))

print("T=4000, B=32, lr=0.08; период полураспада = ln(0.5)/ln(β)")
for beta in [0.9, 0.99, 0.995, 0.999, 0.9999]:
    half = np.log(0.5) / np.log(beta)
    lives, emas = [], []
    for s in range(7):
        Ll, Le = final(s, beta)
        lives.append(Ll); emas.append(Le)
    print(f"β={beta:<6}  half≈{half:7.1f}  live={np.median(lives):.4f}  ema={np.median(emas):.4f}")

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

T=4000, B=32, lr=0.08; период полураспада = ln(0.5)/ln(β)
β=0.9     half≈    6.6  live=0.1259  ema=0.1234
β=0.99    half≈   69.0  live=0.1259  ema=0.1224
β=0.995   half≈  138.3  live=0.1259  ema=0.1223
β=0.999   half≈  692.8  live=0.1259  ema=0.1276
β=0.9999  half≈ 6931.1  live=0.1259  ema=7.0543

β = 0,995 (half ≈ 138) дала лучшую тень: 0,1223. β = 0,9 почти не сглаживает (0,1234). β = 0,999 уже чуть хуже живых (0,1276): полураспад 693 при бюджете 4000 ещё терпим, но тень запаздывает. β = 0,9999 с half ≈ 6931 на 4000 шагах катастрофична (7,05): тень так и не отошла от плохого старта. Повтори: увеличь T до 20000 при β = 0,9999 и посмотри, догонит ли тень пол.

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

  • Копируют β из чужого рецепта с другим числом шагов и другим пакетом, не пересчитав полураспад.
  • Крутят β по обучающей потере живых весов — она почти не меняется, сигнал есть только на тени и на проверке.
  • Путают decay = β и decay = 1−β: в одних библиотеках параметр — «оставить прошлого», в других — «доля нового».

Коэффициент β (EMA decay). Доля прошлого в тени на каждом шаге; обычно близка к единице.

Период полураспада (half-life). Число шагов, за которое вклад старого состояния тени падает вдвое.

Бюджет шагов. Сколько обновлений вы реально делаете в этом прогоне.

Запаздывание тени. Отставание EMA от текущей хорошей области, когда β слишком велика.

Мониторинговая EMA. Отдельная тень с меньшим полураспадом только для графиков, не для финальной модели.

Параметр decay в библиотеке. Нужно читать документацию: это β или 1−β.

3 EMA рядом с расписанием и SWA: что сглаживает шаг, а что — траекторию

Зачем это в работе. Вчерашнее расписание уже умеет успокаивать веса к концу: косинусный спад уменьшает длину шага, и живая проверочная потеря становится ровнее. Возникает вопрос: зачем тогда ещё и EMA? И рядом часто упоминают SWA — стохастическое усреднение весов (Stochastic Weight Averaging), когда просто усредняют несколько чекпоинтов с хвоста обучения. Три инструмента решают похожую боль разными рычагами; путаница дорого стоит при выборе, что сохранять как «лучшую» модель.

Как это устроено. Спад скорости обучения меняет сам оптимизационный шаг: веса начинают меньше прыгать, потому что каждый пакет тянет слабее. EMA не трогает шаг: живые веса могут продолжать шуметь, а тень накапливает среднее. SWA делает равномерное среднее по выбранным снимкам (например, каждые N шагов на последних 10% обучения) — это среднее по конечной выборке точек, а не экспоненциальное с бесконечным хвостом памяти.

На коротких задачах с большим постоянным шагом EMA часто даёт почти тот же выигрыш, что и косинус без EMA. Когда шаг уже к концу маленький, добавка от EMA обычно скромнее: сглаживать почти нечего. SWA на хвосте близка к хорошей EMA, если снимков достаточно и они взяты из одной «чаши» потери. Ограничение наших цифр: линейная регрессия с квадратичной потерей — удобный стенд, не замена большой языковой модели; порядок эффектов смотрим здесь, абсолютные проценты на трансформере будут другими.

Чем это отличается от усреднения предсказаний (ensembling). Ансамбль нескольких моделей усредняет выходы; EMA/SWA усредняют веса одной траектории. Второе дешевле в памяти на выводе (одна модель), но требует, чтобы усредняемые точки лежали в совместимой области.

Подробный пример. Та же задача, семь сидов. Сравниваем: постоянный шаг без EMA; постоянный + EMA; косинус без EMA; косинус + EMA; постоянный + SWA (10 снимков за последние 500 шагов).

import numpy as np
rng = np.random.default_rng(0)
N, d = 8000, 12
X = rng.standard_normal((N, d))
w_true = rng.standard_normal(d)
y = X @ w_true + 0.35 * rng.standard_normal(N)

def run(seed, mode, T=4000, B=32, peak=0.08, floor=0.004, beta=0.995, tail=500, n_snap=10):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = w.copy()
    snaps = []
    step = max(1, tail // n_snap)
    for t in range(1, T + 1):
        if mode.startswith("cosine"):
            p = (t - 1) / (T - 1)
            lr = floor + 0.5 * (peak - floor) * (1 + np.cos(np.pi * p))
        else:
            lr = peak
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        ema = beta * ema + (1 - beta) * w
        if mode.endswith("+swa") and t > T - tail and (T - t) % step == 0:
            snaps.append(w.copy())
    def L(ww): return float(np.mean((X @ ww - y) ** 2))
    if mode.endswith("+swa"):
        return L(w), L(ema), L(np.mean(snaps, axis=0))
    if mode.endswith("+ema"):
        return L(w), L(ema)
    return L(w),

modes = [
    ("const, без EMA", "const"),
    ("const + EMA β=0.995", "const+ema"),
    ("cosine, без EMA", "cosine"),
    ("cosine + EMA", "cosine+ema"),
    ("const + SWA хвост 500", "const+swa"),
]
print("7 сидов; const peak=0.08; cosine peak→0.004; SWA=10 снимков за последние 500 шагов")
for label, mode in modes:
    rows = [run(s, mode) for s in range(7)]
    if mode.endswith("+swa"):
        live = np.median([r[0] for r in rows])
        ema = np.median([r[1] for r in rows])
        swa = np.median([r[2] for r in rows])
        print(f"{label}: live={live:.4f}, ema={ema:.4f}, swa={swa:.4f}")
    elif mode.endswith("+ema") or mode == "const+ema" or mode == "cosine+ema":
        live = np.median([r[0] for r in rows])
        ema = np.median([r[1] for r in rows])
        print(f"{label}: live={live:.4f}, ema={ema:.4f}")
    else:
        live = np.median([r[0] for r in rows])
        print(f"{label}: live={live:.4f}")

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

7 сидов; const peak=0.08; cosine peak→0.004; SWA=10 снимков за последние 500 шагов
const, без EMA: live=0.1259
const + EMA β=0.995: live=0.1259, ema=0.1223
cosine, без EMA: live=0.1224
cosine + EMA: live=0.1224, ema=0.1223
const + SWA хвост 500: live=0.1259, ema=0.1223, swa=0.1226

Постоянный шаг без сглаживания: 0,1259. Тот же шаг с EMA: тень 0,1223. Косинус без EMA уже даёт живым 0,1224 — почти пол. Косинус + EMA: 0,1223, прирост крошечный. SWA на хвосте: 0,1226 — рядом с EMA. Вывод для практики: если расписание уже сильно уменьшило шаг, EMA — страховка и стабильный монитор, а не главный источник качества; если шаг до конца большой (плато WSD, поздний спад), тень часто заметно лучше живых. Повтори: укороти хвост SWA до 50 шагов и двух снимков — среднее станет шумнее.

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

  • Включают и очень агрессивный спад, и сверхмедленную EMA, а потом не понимают, какой рычаг сработал.
  • Усредняют SWA-снимки с разных фаз расписания (ещё большой шаг и уже пол) и получают «размытую» модель.
  • Сравнивают «cosine» одного запуска с «EMA» другого при разном числе шагов и объявляют победителя.

Спад скорости (LR decay). Уменьшение длины шага оптимизатора к концу обучения.

SWA (Stochastic Weight Averaging). Равномерное среднее нескольких чекпоинтов, обычно с хвоста.

Плато WSD. Длинный отрезок с почти постоянным пиком скорости до короткого финального спада.

Ансамбль (ensemble). Усреднение предсказаний нескольких моделей, а не их весов.

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

Монитор качества. Стабильная кривая по тени, по которой решают, продолжать ли обучение.

4 Когда начинать тень и зачем поправка смещения

Зачем это в работе. Если инициализировать тень начальными (ещё плохими) весами и сразу оценивать сырую EMA, на графике первые сотни шагов будет катастрофа — хотя живая модель уже нормально учится. Отсюда две рабочие привычки: (1) начинать EMA не с шага 1, а после разогрева или с середины; (2) на ранней оценке делить тень на 1 − β^t — это поправка смещения (bias correction), та же идея, что у моментов Adam.

Как это устроено. Пока t мало, сумма весов в геометрической прогрессии не добрала до 1: сырая тень всё ещё тянет к инициализации. Поправка θ̄ / (1 − β^t) масштабирует среднее так, будто норма весов уже полная. Когда t велико, β^t ≈ 0, и поправка почти ничего не меняет. Альтернатива — в момент старта EMA просто скопировать текущие живые веса в тень (θ̄ ← θ) и дальше обновлять как обычно: тогда ранний мусор инициализации в тень не попадает.

На длинном прогоне старт тени на шаге 1, 25% или 50% бюджета часто даёт почти одинаковый финал — если полураспад заметно короче оставшегося хвоста. Опасно начинать слишком поздно относительно полураспада: тень не успеет набрать статистику. Ограничение: поправка смещения — про оценку и логи; для сохранения финального чекпоинта после тысяч шагов обычно достаточно сырой тени (или тени, стартовавшей копированием живых).

Чем это отличается от разогрева скорости обучения. Разогрев меняет длину шага в начале, чтобы не разнести сеть. Старт EMA и поправка смещения не защищают обучение — они делают тень честной для чтения. Их можно (и часто нужно) сочетать.

Подробный пример. Сначала оценка на шаге 200 при β = 0,995: сырая тень против тени с поправкой. Затем финал на шаге 4000 при старте EMA на шагах 1, 1000, 2000, 3000, 3600.

import numpy as np
rng = np.random.default_rng(0)
N, d = 8000, 12
X = rng.standard_normal((N, d))
w_true = rng.standard_normal(d)
y = X @ w_true + 0.35 * rng.standard_normal(N)

print("=== ранняя оценка t=200, β=0.995 ===")
def early(seed, T=200, B=32, lr=0.08, beta=0.995):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = w.copy()
    for t in range(1, T + 1):
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        ema = beta * ema + (1 - beta) * w
    corr = 1 - beta ** T
    def L(ww): return float(np.mean((X @ ww - y) ** 2))
    return L(w), L(ema), L(ema / corr), corr

rows = np.array([early(s) for s in range(9)])
print(f"поправка 1−β^t = {rows[0,3]:.4f}")
print(f"live (мед.)={np.median(rows[:,0]):.4f}")
print(f"сырая EMA (мед.)={np.median(rows[:,1]):.4f}")
print(f"EMA с поправкой (мед.)={np.median(rows[:,2]):.4f}")

print("\n=== старт EMA на разных шагах, оценка на t=4000 ===")
def late(seed, start_t, T=4000, B=32, lr=0.08, beta=0.995):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = None
    for t in range(1, T + 1):
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        if t < start_t:
            continue
        if ema is None:
            ema = w.copy()
        else:
            ema = beta * ema + (1 - beta) * w
    def L(ww): return float(np.mean((X @ ww - y) ** 2))
    return L(w), L(ema)

for start in [1, 1000, 2000, 3000, 3600]:
    arr = np.array([late(s, start) for s in range(7)])
    print(f"старт@{start:4d}: live={np.median(arr[:,0]):.4f}, ema={np.median(arr[:,1]):.4f}")

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

=== ранняя оценка t=200, β=0.995 ===
поправка 1−β^t = 0.6330
live (мед.)=0.1261
сырая EMA (мед.)=2.3360
EMA с поправкой (мед.)=0.1703

=== старт EMA на разных шагах, оценка на t=4000 ===
старт@   1: live=0.1259, ema=0.1223
старт@1000: live=0.1259, ema=0.1223
старт@2000: live=0.1259, ema=0.1223
старт@3000: live=0.1259, ema=0.1223
старт@3600: live=0.1259, ema=0.1224

На t = 200 поправка 1 − β^t ≈ 0,633. Сырая EMA даёт медиану 2,34 — бесполезно смотреть. С поправкой — 0,17: ещё хуже живых 0,13, но уже в том же порядке, а не «модель сломана». На финале старт с 1-го, 1000-го, 2000-го и даже 3000-го шага все дают тень ≈ 0,1223; старт на 3600 (осталось 400 шагов при half ≈ 138) чуть хуже: 0,1224. Повтори: на t = 200 поставь β = 0,9 и сравни сырую тень с поправленной — разрыв сузится.

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

  • Рисуют на дашборде сырую EMA с шага 1 и паникуют из-за горба в начале.
  • Стартуют сверхмедленную EMA за 1% бюджета до конца — тень не успевает.
  • Применяют поправку смещения к уже «прогретой» тени на миллионном шаге и думают, что это обязательный финальный трюк.

Поправка смещения (bias correction). Деление тени на 1 − β^t, чтобы раннее среднее не тянуло к инициализации.

Старт копированием. Приём θ̄ ← θ в момент включения EMA, без истории до этого шага.

Разогрев (warmup). Рост скорости обучения в начале; про шаг, не про тень.

Ранняя оценка. Проверочная метрика в первые сотни/тысячи шагов, где сырая EMA обманчива.

Оставшийся хвост. Число шагов после старта EMA; его сравнивают с полураспадом.

Дашборд. Графики метрик; на них должна быть либо поправленная тень, либо тень после старта копированием.

5 Где обычно ломают EMA: чекпоинт, β, оптимизатор и вывод

Зачем это в работе. EMA проста в формуле и коварна в обвязке. Типичный провал выглядит так: обучение «шло хорошо», а выложенная модель слабее внутренней оценки — потому что в файл записали живые веса, а графики рисовали по тени. Или наоборот: тень сохранили, но забыли выключить EMA-обновление на выводе и продолжили «усреднять» уже при инференсе. Ниже — диагностический набор: прыгучесть, слишком большой β, «забытая» тень.

Как это устроено на практике. (1) В чекпоинте явно хранят и live, и ema (или хотя бы ту копию, которую считают боевой), плюс флаг, какая из них шла в валидацию. (2) На выводе (inference) подставляют тень как обычные веса; состояние Adam к тени не прилагают — оно относится к живой траектории. (3) Если продолжают обучение с чекпоинта, решают заранее: восстанавливать обе копии или скопировать тень в live и сбросить оптимизатор (это уже другой режим, ближе к «начать заново из усреднённой точки»). (4) β согласуют с бюджетом: полураспад должен быть заметно меньше длины полезного хвоста.

Чем это отличается от обрезки градиента и отката. Обрезка лечит редкий взрыв градиента; откат возвращает live-веса к прошлому снимку. EMA не лечит взрыв — после NaN в live тень тоже отравится. Сначала стабилизируют шаг и обрезку, потом доверяют тени.

Подробный пример. Три проверки на той же задаче: насколько тень спокойнее по ||Δ|| на хвосте; что делает β = 0,9999; какова цена «забыли EMA» на одном и том же прогоне.

import numpy as np
rng = np.random.default_rng(0)
N, d = 8000, 12
X = rng.standard_normal((N, d))
w_true = rng.standard_normal(d)
y = X @ w_true + 0.35 * rng.standard_normal(N)

print("=== прыжки весов на хвосте (средняя ||Δ|| за последние 100 шагов) ===")
def jump(seed, T=2000, B=32, lr=0.08, beta=0.995):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = w.copy()
    dw, de = [], []
    prev_w, prev_e = w.copy(), ema.copy()
    for t in range(1, T + 1):
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        ema = beta * ema + (1 - beta) * w
        if t > T - 100:
            dw.append(float(np.linalg.norm(w - prev_w)))
            de.append(float(np.linalg.norm(ema - prev_e)))
        prev_w, prev_e = w.copy(), ema.copy()
    return np.mean(dw), np.mean(de)

rows = np.array([jump(s) for s in range(7)])
print(f"||Δw|| (мед.)={np.median(rows[:,0]):.5f}, ||Δema|| (мед.)={np.median(rows[:,1]):.5f}")
print(f"отношение ≈ {np.median(rows[:,0])/np.median(rows[:,1]):.0f}×")

print("\n=== слишком большой β: EMA не успевает догнать ===")
def final(seed, beta, T=4000, B=32, lr=0.08):
    r = np.random.default_rng(seed)
    w = r.standard_normal(d) * 0.1
    ema = w.copy()
    for t in range(1, T + 1):
        idx = r.integers(0, N, B)
        err = X[idx] @ w - y[idx]
        g = (2.0 / B) * (X[idx].T @ err)
        w = w - lr * g
        ema = beta * ema + (1 - beta) * w
    return float(np.mean((X @ w - y) ** 2)), float(np.mean((X @ ema - y) ** 2))

for beta in [0.5, 0.995, 0.9999]:
    half = np.log(0.5) / np.log(beta)
    lives, emas = zip(*[final(s, beta) for s in range(7)])
    print(f"β={beta:<6} half≈{half:7.1f}  live={np.median(lives):.4f}  ema={np.median(emas):.4f}")

print("\n=== «забыли EMA»: оценили live вместо тени на том же прогоне ===")
lives, emas = zip(*[final(s, 0.995) for s in range(7)])
print(f"live={np.median(lives):.4f} vs ema={np.median(emas):.4f}  (разница {np.median(lives)-np.median(emas):.4f})")

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

=== прыжки весов на хвосте (средняя ||Δ|| за последние 100 шагов) ===
||Δw|| (мед.)=0.03493, ||Δema|| (мед.)=0.00031
отношение ≈ 113×

=== слишком большой β: EMA не успевает догнать ===
β=0.5    half≈    1.0  live=0.1259  ema=0.1251
β=0.995  half≈  138.3  live=0.1259  ema=0.1223
β=0.9999 half≈ 6931.1  live=0.1259  ema=7.0543

=== «забыли EMA»: оценили live вместо тени на том же прогоне ===
live=0.1259 vs ema=0.1223  (разница 0.0036)

На хвосте средний скачок живых весов ≈ 0,035, у тени ≈ 0,00031 — примерно в 113 раз меньше. β = 0,5 почти не сглаживает (0,1251). β = 0,995 даёт 0,1223. β = 0,9999 оставляет тень у старта (7,05). «Забыли EMA»: на том же прогоне live 0,1259 против ema 0,1223 — разница 0,0036, то есть вы откатываетесь от почти пола назад к шумной точке, хотя обучение прошло нормально. Повтори: сохрани оба набора весов и оцени их на одной проверочной выборке — это и есть минимальный тест обвязки.

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

  • В репозиторий и на сайт кладут live-веса, а в отчёте цитируют метрику по EMA.
  • Тащат в продолжение обучения состояние Adam от live, но подставляют веса тени — масштаб шага больше не совпадает с историей моментов.
  • Ставят β с полураспадом длиннее всего обучения и решают, что «EMA не работает».

Инференс (inference). Режим, когда модель только отвечает, веса не обновляют.

Боевой чекпоинт. Файл весов, который реально отдают в сервис или в сравнение.

Состояние оптимизатора. Буферы Adam/SGD (m, v, …), привязанные к живой траектории.

Отравление тени. Порча EMA после разлёта live-весов (NaN/Inf).

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

Полураспад vs длина прогона. Практический тест: half-life должна быть заметно меньше числа шагов, которые тень реально живёт.

Сброс оптимизатора. Обнуление m/v при старте из усреднённой точки; отдельное решение, не часть обычного EMA.

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