Вчерашняя дорожка про расписание шага закончилась на том, что к концу обучения шаг уменьшают, чтобы веса меньше прыгали. Сегодня — другой способ получить спокойную копию весов: экспоненциальное скользящее среднее весов (exponential moving average of weights, EMA), иногда называют усреднением Поляка (Polyak averaging). Живые веса продолжают учиться с шумом пакета, а рядом ведётся «теневая» копия, которую берут для оценки и часто для финального чекпоинта. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения о статьях и рецептах лабораторий помечены как опубликованные, а не измеренные нами.
Все дорожки — /put. Прошлая — расписание шага.
Зачем это в работе. В конце обучения вы смотрите на проверочную потерю (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 и сравни σ на хвосте.
Где обычно ошибаются.
Живые веса (online / training weights). Копия, которую обновляет оптимизатор на каждом шаге.
Тень / EMA-веса (EMA weights, shadow weights). Скользящее среднее живых весов; обычно её берут для оценки.
Проверочная потеря (validation loss). Ошибка на отложенных данных; по ней выбирают чекпоинт.
Чекпоинт (checkpoint). Сохранённые на диск веса (и часто состояние оптимизатора) на определённом шаге.
Пол потери. Нижняя граница ошибки из-за шума в данных; ниже неё устойчиво не уйти.
Шум пакета (batch noise). Случайный сдвиг градиента из-за того, что пакет — лишь кусок данных.
Зачем это в работе. В конфиге 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 и посмотри, догонит ли тень пол.
Где обычно ошибаются.
Коэффициент β (EMA decay). Доля прошлого в тени на каждом шаге; обычно близка к единице.
Период полураспада (half-life). Число шагов, за которое вклад старого состояния тени падает вдвое.
Бюджет шагов. Сколько обновлений вы реально делаете в этом прогоне.
Запаздывание тени. Отставание EMA от текущей хорошей области, когда β слишком велика.
Мониторинговая EMA. Отдельная тень с меньшим полураспадом только для графиков, не для финальной модели.
Параметр decay в библиотеке. Нужно читать документацию: это β или 1−β.
Зачем это в работе. Вчерашнее расписание уже умеет успокаивать веса к концу: косинусный спад уменьшает длину шага, и живая проверочная потеря становится ровнее. Возникает вопрос: зачем тогда ещё и 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 шагов и двух снимков — среднее станет шумнее.
Где обычно ошибаются.
Спад скорости (LR decay). Уменьшение длины шага оптимизатора к концу обучения.
SWA (Stochastic Weight Averaging). Равномерное среднее нескольких чекпоинтов, обычно с хвоста.
Плато WSD. Длинный отрезок с почти постоянным пиком скорости до короткого финального спада.
Ансамбль (ensemble). Усреднение предсказаний нескольких моделей, а не их весов.
Совместимая область. Участок траектории, где усреднение весов не смешивает разные режимы.
Монитор качества. Стабильная кривая по тени, по которой решают, продолжать ли обучение.
Зачем это в работе. Если инициализировать тень начальными (ещё плохими) весами и сразу оценивать сырую 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 и сравни сырую тень с поправленной — разрыв сузится.
Где обычно ошибаются.
Поправка смещения (bias correction). Деление тени на 1 − β^t, чтобы раннее среднее не тянуло к инициализации.
Старт копированием. Приём θ̄ ← θ в момент включения EMA, без истории до этого шага.
Разогрев (warmup). Рост скорости обучения в начале; про шаг, не про тень.
Ранняя оценка. Проверочная метрика в первые сотни/тысячи шагов, где сырая EMA обманчива.
Оставшийся хвост. Число шагов после старта 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, то есть вы откатываетесь от почти пола назад к шумной точке, хотя обучение прошло нормально. Повтори: сохрани оба набора весов и оцени их на одной проверочной выборке — это и есть минимальный тест обвязки.
Где обычно ошибаются.
Инференс (inference). Режим, когда модель только отвечает, веса не обновляют.
Боевой чекпоинт. Файл весов, который реально отдают в сервис или в сравнение.
Состояние оптимизатора. Буферы Adam/SGD (m, v, …), привязанные к живой траектории.
Отравление тени. Порча EMA после разлёта live-весов (NaN/Inf).
Согласованность метрики. Правило: график, выбор чекпоинта и выложенный файл используют одну и ту же копию весов.
Полураспад vs длина прогона. Практический тест: half-life должна быть заметно меньше числа шагов, которые тень реально живёт.
Сброс оптимизатора. Обнуление m/v при старте из усреднённой точки; отдельное решение, не часть обычного EMA.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.