Вчерашняя дорожка про размер пакета закончилась на связи пакета и скорости обучения, а дорожка про оптимизатор коротко показала разогрев и косинус. Сегодня — само расписание скорости обучения (learning rate schedule): когда и зачем менять шаг по ходу тренировки, как устроены разгон и спад, где линейное правило LR∝B ломается вместе с коротким разогревом, и как по кривой потери понять, что расписание плохое. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения о статьях и рецептах лабораторий помечены как опубликованные, а не измеренные нами.
Все дорожки — /put. Прошлая — размер пакета.
Зачем это в работе. Скорость обучения (learning rate) — множитель, который говорит оптимизатору, насколько далеко сдвинуть веса за один шаг. Её почти никогда не держат одной цифрой от первого шага до последнего: в рецептах пишут «пик 3·10−4, разогрев 2000 шагов, косинус до 10%». Расписание скорости обучения (learning rate schedule) — это как раз программа, по которой эта цифра меняется со временем. Ошибка здесь не всегда роняет обучение громко: оно может «идти», но застрять выше достижимой потери или разъезжаться в конце, когда шаг ещё слишком большой.
Как это устроено. Пока модель далеко от хорошей области, большой шаг полезен: каждый пакет данных тянет веса заметно, и потеря быстро падает. Ближе к хорошей области тот же большой шаг мешает: пакеты тянут в разные стороны, веса прыгают вокруг минимума, и итоговая потеря остаётся выше, чем могла бы. Уменьшение шага к концу сужает эти прыжки. Постоянный маленький шаг тоже плох: до хорошей области просто долго идти. Расписание совмещает оба режима — сначала достаточно большой шаг, потом всё меньший.
Ограничение: «хорошая» длина шага зависит от кривизны потери (насколько круто она изгибается) и от шума градиента по пакету. Оба меняются по ходу обучения, поэтому одна фиксированная скорость — компромисс, который редко бывает лучшим и в начале, и в конце. Чем это отличается от соседних понятий. Оптимизатор (Adam, SGD с импульсом) решает, куда и с какой поправкой шагать; расписание решает, какой множитель длины подставить в этот шаг. Их путают, потому что в логах часто видна только итоговая длина обновления.
Подробный пример. Линейная регрессия: 50 000 примеров, 16 признаков разного масштаба, неустранимый шум даёт пол потери 0.16. Пакет 64, 3000 шагов, пик скорости 0.08 (ниже предела устойчивости 0.388). Сравниваем постоянный пик, постоянную половину пика и косинусный спад от пика до 5% за те же 3000 шагов. Смотрим итоговую потерю и разброс потери на последних 500 шагах (медиана пяти запусков).
import numpy as np
# Constant LR vs cosine: итоговая потеря и разброс потери на последних 500 шагах
rng = np.random.default_rng(0); N, d = 50_000, 16
X = rng.standard_normal((N, d)) * np.linspace(0.4, 1.6, d)
w_true = rng.standard_normal(d); y = X @ w_true + 0.4 * rng.standard_normal(N)
loss = lambda w: float(((X @ w - y)**2).mean())
floor = 0.16
B, peak, T = 64, 0.08, 3000 # peak ближе к пределу устойчивости → constant шумит сильнее
def cosine_lr(t, peak, T, floor_frac=0.05):
if t >= T: return peak * floor_frac
return floor_frac * peak + 0.5 * (1 - floor_frac) * peak * (1 + np.cos(np.pi * t / T))
def run(schedule, seed, max_steps=3000):
r = np.random.default_rng(seed); w = np.zeros(d)
last = []
for t in range(max_steps):
lr = schedule(t)
idx = r.integers(0, N, B)
g = 2 * X[idx].T @ (X[idx] @ w - y[idx]) / B
w -= lr * g
if not np.isfinite(w).all() or np.abs(w).max() > 1e4:
return None, None, None
if t >= max_steps - 500 and t % 10 == 0:
last.append(loss(w))
return loss(w), float(np.mean(last)), float(np.std(last))
H = 2 * X.T @ X / N; lim = 2 / np.linalg.eigvalsh(H).max()
print(f"пол={floor:.3f}, B={B}, peak={peak}, предел устойчивости 2/λ_max={lim:.3f}, шагов={T}")
for name, sch in [
("constant peak", lambda t: peak),
("constant 0.5·peak", lambda t: peak * 0.5),
("cosine → 5% за 3000", lambda t: cosine_lr(t, peak, T, 0.05)),
]:
finals, means, stds = [], [], []
for s in range(5):
f, m, sd = run(sch, s)
if f is None: finals.append(None); continue
finals.append(f); means.append(m); stds.append(sd)
if None in finals:
print(f"{name:22s} расходится")
else:
print(f"{name:22s} итоговая: {np.median(finals):.4f} "
f"средняя за последние 500: {np.median(means):.4f} "
f"разброс (σ): {np.median(stds):.4f}")
У нас этот код напечатал:
пол=0.160, B=64, peak=0.08, предел устойчивости 2/λ_max=0.388, шагов=3000
constant peak итоговая: 0.1677 средняя за последние 500: 0.1660 разброс (σ): 0.0016
constant 0.5·peak итоговая: 0.1641 средняя за последние 500: 0.1637 разброс (σ): 0.0007
cosine → 5% за 3000 итоговая: 0.1619 средняя за последние 500: 0.1621 разброс (σ): 0.0001
Постоянный пик закончил с потерей 0.1677 и разбросом σ = 0.0016: веса всё ещё прыгают. Половина пика тише (σ = 0.0007) и чуть лучше по итогу. Косинус подошёл к полу потери ближе всех (0.1619) и почти перестал шуметь (σ = 0.0001). Повтори: поставь пик 0.3 — ближе к пределу 0.388 — и сравни разброс постоянного шага с косинусом.
Где обычно ошибаются.
Скорость обучения (learning rate). Множитель длины шага обновления весов.
Расписание скорости обучения (learning rate schedule). Правило, по которому скорость меняется от шага к шагу.
Пиковая скорость (peak learning rate). Наибольшее значение скорости в расписании.
Пол потери (loss floor). Нижняя граница потери из-за шума в данных; ниже неё модель в среднем не опустится.
Кривизна (curvature). Насколько быстро меняется наклон потери; большая кривизна требует более короткого шага.
Предел устойчивости. Наибольшая скорость, при которой спуск ещё не раскачивается; для квадратичной потери это 2/λmax.
Разброс потери в конце. Насколько прыгает кривая потери, когда обучение уже должно «сесть» в минимум.
Зачем это в работе. Разогрев (warmup) — первые сотни или тысячи шагов, когда скорость растёт от почти нуля до пика, обычно линейно. Без него большой пик, выбранный «под размер пакета» или «под Adam», часто разносит обучение в первые же шаги: потеря улетает в бесконечность, веса становятся NaN, и откатываться уже некуда. С разогревом тот же пик проходит. Это особенно важно после инициализации, когда веса ещё случайные, и вместе с адаптивными моментами Adam, которые в начале ещё не накоплены.
Как это устроено. В начале градиенты крупные и направление неустойчивое: модель ещё не «поняла» масштаб признаков и слоёв. Длинный шаг в этой точке уводит веса туда, откуда простой спуск уже не возвращается — особенно в глубокой сети с нелинейностями. Разогрев даёт короткие шаги, пока сигнал и статистика оптимизатора не стабилизируются, и только потом выходит на рабочий пик.
Связь с Adam. Adam делит шаг на скользящую оценку размаха градиента (второй момент, v). Пока v собран по нескольким шагам, оценка шумная, и даже с поправкой смещения адаптивный шаг в первые итерации заметно больше «типичного». Разогрев как раз перекрывает этот опасный отрезок. Связь с инициализацией: если начальный размах весов уже на грани (см. дорожку про начальные веса), большой первый шаг добивает сеть; маленький разогрев это маскирует, но не лечит плохую инициализацию.
Ограничение: разогрев измеряют в шагах, а не в примерах. Если вы увеличили пакет в 4 раза и оставили разогрев «200 шагов», по данным вы разогрелись в 4 раза быстрее — и снова рискуете. Об этом подробнее в ступени 4.
Подробный пример. Двухслойная сеть с ReLU: 12 000 примеров, вход 20, скрытый слой 32, учитель — такая же маленькая сеть плюс шум. SGD, пик 0.15, пакет 64, 3000 шагов. Без разогрева — сразу пик; с разогревом — линейный рост за 250 шагов до того же пика. Девять случайных начальных весов.
import numpy as np
# 2-слойная ReLU: peak=0.15 без разогрева разлетается; с линейным разогревом 250 — доходит.
rng = np.random.default_rng(4)
N, d_in, d_h, d_out = 12_000, 20, 32, 1
X = rng.standard_normal((N, d_in)).astype(np.float64)
W1t = rng.standard_normal((d_in, d_h)) * 0.4
W2t = rng.standard_normal((d_h, d_out)) * 0.4
y = (np.maximum(0, X @ W1t) @ W2t).ravel() + 0.1 * rng.standard_normal(N)
def loss_and_grads(Xb, yb, W1, W2):
z1 = Xb @ W1; h = np.maximum(0, z1); out = (h @ W2).ravel()
err = out - yb; L = float(np.mean(err**2))
dout = (2.0 / len(yb)) * err[:, None]
gW2 = h.T @ dout; dz1 = (dout @ W2.T) * (z1 > 0); gW1 = Xb.T @ dz1
return L, gW1, gW2
def init(seed):
r = np.random.default_rng(seed)
return (r.standard_normal((d_in, d_h)) * np.sqrt(2 / d_in),
r.standard_normal((d_h, d_out)) * np.sqrt(2 / d_h))
B, peak, wu, T = 64, 0.15, 250, 3000
def eval_loss(W1, W2):
idx = np.arange(0, N, max(1, N // 2000))
L, _, _ = loss_and_grads(X[idx], y[idx], W1, W2)
return L
def run(use_warmup, seed, max_steps=T):
r = np.random.default_rng(seed + 100)
W1, W2 = init(seed)
trail = []
for t in range(1, max_steps + 1):
lr = peak * min(1.0, t / wu) if use_warmup else peak
idx = r.integers(0, N, B)
Lbatch, g1, g2 = loss_and_grads(X[idx], y[idx], W1, W2)
W1 = W1 - lr * g1; W2 = W2 - lr * g2
if not (np.isfinite(W1).all() and np.isfinite(W2).all()) or Lbatch > 1e6 or np.abs(W1).max() > 1e3:
trail.append((t, float("inf"), lr))
return "расходится", None, trail
if t in (1, 2, 3, 5, 10, 25, 100, 250, 1000, 3000):
trail.append((t, eval_loss(W1, W2), lr))
return "ок", eval_loss(W1, W2), trail
print(f"2-слойная ReLU, SGD peak={peak}, warmup={wu}, B={B}, T={T}")
print(f"потеря на старте (сид 0)={eval_loss(*init(0)):.4f}")
for use, label in [(False, "без разогрева"), (True, "с разогревом 250")]:
oks, fins, sample = 0, [], None
div_at = []
for s in range(9):
st, fin, trail = run(use, s)
if st == "ок":
oks += 1; fins.append(fin)
if sample is None: sample = trail
else:
div_at.append(trail[-1][0])
if sample is None: sample = trail
if oks == 0:
print(f"{label}: 0/9 дошли, разлёт на шагах {sorted(div_at)}")
else:
print(f"{label}: дошли {oks}/9, итоговая потеря (мед.)={np.median(fins):.4f}")
print(" шаг потеря lr")
for t, L, lr in sample:
print(f" {t:4d} {L:10.4f} {lr:.4f}")
print("\n--- Adam на той же сети, lr=1e-4: норма адаптивного шага (все веса) ---")
beta1, beta2, eps = 0.9, 0.999, 1e-8
r = np.random.default_rng(0)
W1, W2 = init(0)
m1, v1 = np.zeros_like(W1), np.zeros_like(W1)
m2, v2 = np.zeros_like(W2), np.zeros_like(W2)
for t in range(1, 301):
idx = r.integers(0, N, B)
_, g1, g2 = loss_and_grads(X[idx], y[idx], W1, W2)
m1 = beta1 * m1 + (1 - beta1) * g1
v1 = beta2 * v1 + (1 - beta2) * (g1 * g1)
m2 = beta1 * m2 + (1 - beta1) * g2
v2 = beta2 * v2 + (1 - beta2) * (g2 * g2)
mh1 = m1 / (1 - beta1**t); vh1 = v1 / (1 - beta2**t)
mh2 = m2 / (1 - beta1**t); vh2 = v2 / (1 - beta2**t)
step = np.concatenate([(mh1 / (np.sqrt(vh1) + eps)).ravel(),
(mh2 / (np.sqrt(vh2) + eps)).ravel()])
W1 = W1 - 1e-4 * mh1 / (np.sqrt(vh1) + eps)
W2 = W2 - 1e-4 * mh2 / (np.sqrt(vh2) + eps)
if t in (1, 2, 5, 10, 50, 100, 200, 300):
print(f" t={t:3d} |адапт.шаг|={np.linalg.norm(step):7.3f} "
f"mean√v̂={np.mean(np.sqrt(np.concatenate([vh1.ravel(), vh2.ravel()]))):.4f}")
У нас этот код напечатал:
2-слойная ReLU, SGD peak=0.15, warmup=250, B=64, T=3000
потеря на старте (сид 0)=8.9368
без разогрева: 0/9 дошли, разлёт на шагах [5, 5, 6, 6, 6, 6, 6, 7, 8]
шаг потеря lr
1 14.5873 0.1500
2 53.4944 0.1500
3 120.9413 0.1500
5 240.1860 0.1500
8 inf 0.1500
с разогревом 250: дошли 9/9, итоговая потеря (мед.)=0.0572
шаг потеря lr
1 8.8485 0.0006
2 8.6558 0.0012
3 8.3640 0.0018
5 7.5647 0.0030
10 5.7270 0.0060
25 3.1931 0.0150
100 0.9300 0.0600
250 0.3462 0.1500
1000 0.0932 0.1500
3000 0.0632 0.1500
--- Adam на той же сети, lr=1e-4: норма адаптивного шага (все веса) ---
t= 1 |адапт.шаг|= 25.923 mean√v̂=0.1735
t= 2 |адапт.шаг|= 20.596 mean√v̂=0.1984
t= 5 |адапт.шаг|= 17.733 mean√v̂=0.2097
t= 10 |адапт.шаг|= 17.607 mean√v̂=0.2402
t= 50 |адапт.шаг|= 15.609 mean√v̂=0.2333
t=100 |адапт.шаг|= 16.742 mean√v̂=0.2301
t=200 |адапт.шаг|= 15.449 mean√v̂=0.2205
t=300 |адапт.шаг|= 15.645 mean√v̂=0.2126
Без разогрева все 9 запусков разлетелись на шагах 5–8: потеря уже на шаге 3 превысила 120. С разогревом все 9 дошли, итоговая потеря (медиана) 0.0572; к шагу 250, где скорость впервые равна пику, потеря уже 0.35, а не сотни. Отдельно по Adam на той же сети с крошечным lr = 10−4: норма адаптивного шага на t = 1 была 25.9 и к t = 50 упала примерно до 15.6 — первые шаги «сырее» даже при поправке смещения. Повтори: укороти разогрев до 50 шагов при том же пике 0.15 и посмотри, сколько из 9 запусков выживет.
Где обычно ошибаются.
Разогрев (warmup). Начальный участок, где скорость растёт от почти нуля до пика.
Линейный разогрев (linear warmup). Скорость растёт пропорционально номеру шага до пика.
Адаптивный шаг Adam. Обновление, делённое на корень из оценки второго момента градиента.
Второй момент (second moment, v). Скользящая оценка среднего квадрата градиента по каждому весу.
Поправка смещения (bias correction). Деление моментов Adam на (1 − βt), чтобы в начале они не были занижены.
Разлёт (divergence). Устойчивый рост потери и весов до бесконечности или NaN.
Начальные веса (initialization). Случайные значения параметров до первого шага; задают стартовый масштаб сигнала.
Зачем это в работе. После разогрева скорость нужно снизить к концу обучения. Форма спада (decay) решает, сколько времени модель проведёт почти на пике и насколько «мягко» сядет в конец. В отчётах чаще всего встречается косинусное затухание (cosine decay); рядом живут линейный спад и ступенчатый (step decay), когда скорость умножают на коэффициент в заданных точках. Путаница между ними дорогая: контрольная точка с середины косинуса — это не та же модель, что доученная коротким запуском до этой точки.
Как это устроено. Косинус после разогрева идёт от пика к полу (min learning rate) по половине косинуса: сначала почти плоско, потом всё круче к концу. Линейный спад режет скорость равномерно. Ступенчатый держит пик долго и скачками опускает его (например, ×0.1 на 33% и 66% пути). Пол — нижнее значение, ниже которого скорость не опускают: полный ноль иногда мешает доучиванию и связанному с расписанием уменьшению весов в AdamW.
Ограничение косинуса: его форма привязана к заранее известной длине T. Если запланировали 100 000 шагов, а остановились на 50 000, вы оказались на середине косинуса, а не в «половине обучения» в смысле качества. Авторы Chinchilla (Хоффманн и соавторы, 2022) отмечали, что промежуточная точка длинного косинуса не равна короткому запуску со своим расписанием — это их опубликованный вывод. Расписание WSD (warmup–stable–decay), коротко разобранное в дорожке про оптимизатор, держит плато на пике и спускается только в конце, как раз чтобы контрольные точки с плато можно было продолжать.
Чем формы отличаются на практике. Косинус дольше остаётся «почти на пике», чем кажется по картинке; ступенчатый с множителем 0.1 резко уходит вниз и потом долго сидит на низкой скорости. Выбор пола типично 5–10% пика в языковых моделях (в описании GPT-3 пол был 10% пика — опубликованный рецепт).
Подробный пример. Посчитаем сами значения скорости на одних и тех же шагах: пик 3·10−4, разогрев 500, всего 10 000 шагов, пол 10% пика. Три формы — косинус, линейный спад, ступенчатый с двумя умножениями на 0.1.
import numpy as np
# Значения скорости обучения по шагам: cosine, linear, step decay (после общего разогрева)
peak, wu, T, floor_frac = 3e-4, 500, 10_000, 0.1
floor = peak * floor_frac
milestones = [0, 250, 499, 500, 2000, 5000, 7500, 9000, 9999]
def cosine(t):
if t < wu: return peak * (t + 1) / wu # t с 0 → на шаге 0 уже не ноль
if t >= T: return floor
p = (t - wu) / (T - wu)
return floor + 0.5 * (peak - floor) * (1 + np.cos(np.pi * p))
def linear(t):
if t < wu: return peak * (t + 1) / wu
if t >= T: return floor
p = (t - wu) / (T - wu)
return peak + (floor - peak) * p
def step_decay(t, drops=(0.33, 0.66), gamma=0.1):
# после разогрева держим peak, в 33% и 66% пути после wu умножаем на gamma
if t < wu: return peak * (t + 1) / wu
progress = (t - wu) / (T - wu)
lr = peak
for d in drops:
if progress >= d: lr *= gamma
return max(lr, floor) # не ниже пола для сравнения; если gamma^2*peak < floor — пол
print(f"peak={peak}, warmup={wu}, T={T}, пол={floor}")
print(f"{'шаг':>6} {'cosine':>12} {'linear':>12} {'step×0.1':>12}")
for t in milestones:
print(f"{t:6d} {cosine(t):12.6e} {linear(t):12.6e} {step_decay(t):12.6e}")
# доля шагов, где lr > 0.5*peak (сколько времени «почти на пике»)
def frac_high(fn, thr=0.5*peak):
xs = np.array([fn(t) for t in range(T)])
return float(np.mean(xs > thr))
print("\nдоля шагов с lr > 0.5·peak:")
for name, fn in [("cosine", cosine), ("linear", linear), ("step×0.1", step_decay)]:
print(f" {name:10s} {frac_high(fn):.3f}")
У нас этот код напечатал:
peak=0.0003, warmup=500, T=10000, пол=2.9999999999999997e-05
шаг cosine linear step×0.1
0 6.000000e-07 6.000000e-07 6.000000e-07
250 1.506000e-04 1.506000e-04 1.506000e-04
499 3.000000e-04 3.000000e-04 3.000000e-04
500 3.000000e-04 3.000000e-04 3.000000e-04
2000 2.837290e-04 2.573684e-04 3.000000e-04
5000 1.761482e-04 1.721053e-04 3.000000e-05
7500 7.356699e-05 1.010526e-04 3.000000e-05
9000 3.731467e-05 5.842105e-05 3.000000e-05
9999 3.000001e-05 3.002842e-05 3.000000e-05
доля шагов с lr > 0.5·peak:
cosine 0.534
linear 0.553
step×0.1 0.339
До конца разогрева все три совпадают: на шаге 0 скорость 6·10−7, на шаге 499 — пик. К шагу 5000 косинус и линейный уже около 1.7·10−4, а ступенчатый после первого дропа сидит на 3·10−5 (пол). Доля шагов с скоростью выше половины пика: косинус 0.534, линейный 0.553, ступенчатый только 0.339 — ступеньки «съедают» время на пике. Повтори: поставь у ступенчатого gamma = 0.5 вместо 0.1 и сравни долю шагов выше половины пика.
Где обычно ошибаются.
Затухание / спад (decay). Снижение скорости обучения после разогрева.
Косинусное затухание (cosine decay). Спад по форме половины косинуса от пика к полу.
Линейный спад (linear decay). Равномерное снижение скорости от пика к полу.
Ступенчатый спад (step decay). Умножение скорости на коэффициент в заданных долях обучения.
Пол скорости (min learning rate). Нижнее значение, ниже которого расписание не опускается.
Плато (stable phase). Участок с постоянной скоростью; основа расписания WSD.
Повторный разогрев (re-warmup). Короткий подъём скорости при продолжении из уже затухшей точки.
Зачем это в работе. Вчерашняя дорожка разобрала линейное правило: увеличил пакет в k раз — увеличь скорость в k раз. В рецептах это почти всегда делают вместе с расписанием: растет не только пик, но и (по идее) длина разогрева. На практике чаще всего забывают именно разогрев в шагах — и получают разлёт или тихую деградацию итога, хотя «формула LR∝B соблюдена». Для Adam опубликовано более мягкое правило корня (скорость ∝ √k); оба правила — отправная точка, а не закон.
Как это устроено. Линейное правило опирается на то, что k маленьких шагов с пакетом B примерно равны одному большому шагу с пакетом kB, если градиент между ними почти не меняется. В начале обучения градиент как раз меняется быстро — поэтому Гоял и соавторы (2017) в работе про большой пакет для ResNet специально добавляли разогрев. Если вы подняли пик в k раз, а разогрев оставили тем же числом шагов, первые шаги после «короткого» разогрева уже несут опасный большой шаг на ещё сырых весах.
Где правило ломается. Во-первых, когда новый пик переходит предел устойчивости — дальше помогает только снизить пик, а не удлинять разогрев. Во-вторых, когда шум градиента уже мал (большой пакет выше критического): дополнительные примеры не дают пропорционального ускорения, и высокий LR только раскачивает. В-третьих, у Adam часть нормировки шума уже внутри оптимизатора, поэтому линейное k часто оказывается слишком агрессивным — отсюда правило корня.
Чем это отличается от «просто поставить warmup побольше». Удлинение разогрева спасает старт, но не отменяет потолок по кривизне и не заменяет пересчёт числа шагов: при пакете ×4 за те же S шагов вы пропускаете через модель в 4 раза больше данных. Честное сравнение — по числу примеров (токенов) и по итоговой потере.
Подробный пример. Та же двухслойная ReLU-сеть. База: пакет 64, пик 0.05, разогрев 200, 2000 шагов. Дальше увеличиваем пакет и пик по линейному правилу, меняем длину разогрева и пробуем правило корня. Семь сидов; дополнительно смотрим максимальную потерю пакета за первые 50 шагов.
import numpy as np
# 2-слойная ReLU: LR∝B. Без разогрева при увеличенном пике — разлёт;
# линейное ×8 ломается; √-правило на ×4 здесь устойчивее.
rng = np.random.default_rng(5)
N, d_in, d_h = 12_000, 20, 32
X = rng.standard_normal((N, d_in))
W1t = rng.standard_normal((d_in, d_h)) * 0.4
W2t = rng.standard_normal((d_h, 1)) * 0.4
y = (np.maximum(0, X @ W1t) @ W2t).ravel() + 0.1 * rng.standard_normal(N)
def loss_grads(Xb, yb, W1, W2):
z1 = Xb @ W1; h = np.maximum(0, z1); out = (h @ W2).ravel()
err = out - yb; L = float(np.mean(err**2))
dout = (2.0 / len(yb)) * err[:, None]
gW2 = h.T @ dout; gW1 = Xb.T @ ((dout @ W2.T) * (z1 > 0))
return L, gW1, gW2
def init(seed):
r = np.random.default_rng(seed)
return (r.standard_normal((d_in, d_h)) * np.sqrt(2/d_in),
r.standard_normal((d_h, 1)) * np.sqrt(2/d_h))
def eval_L(W1, W2):
idx = np.arange(0, N, max(1, N//2000))
L, _, _ = loss_grads(X[idx], y[idx], W1, W2)
return L
def run(B, peak, wu, T, seed):
r = np.random.default_rng(seed + 77)
W1, W2 = init(seed)
max_early = 0.0
for t in range(1, T + 1):
lr = peak * min(1.0, t / max(wu, 1))
idx = r.integers(0, N, B)
Lb, g1, g2 = loss_grads(X[idx], y[idx], W1, W2)
W1 -= lr * g1; W2 -= lr * g2
if t <= 50:
max_early = max(max_early, Lb if np.isfinite(Lb) else 1e9)
if not (np.isfinite(W1).all() and np.isfinite(W2).all()) or Lb > 1e6 or np.abs(W1).max() > 1e3:
return "расходится", t, None, max_early
return "ок", T, eval_L(W1, W2), max_early
print("2-слойная ReLU; база B=64 peak=0.05 warmup=200 T=2000")
configs = [
("база B=64 peak=0.05 wu=200", dict(B=64, peak=0.05, wu=200, T=2000)),
("B×4 LR×4, без разогрева", dict(B=256, peak=0.20, wu=1, T=2000)),
("B×4 LR×4, wu=200 (как у базы)", dict(B=256, peak=0.20, wu=200, T=2000)),
("B×4 LR×4, wu=800", dict(B=256, peak=0.20, wu=800, T=2000)),
("B×4 LR×√4=0.10, wu=800", dict(B=256, peak=0.10, wu=800, T=2000)),
("B×8 LR×8=0.40, wu=200", dict(B=512, peak=0.40, wu=200, T=2000)),
]
for name, cfg in configs:
rows = [run(seed=s, **cfg) for s in range(7)]
n_ok = sum(1 for st, *_ in rows if st == "ок")
early = float(np.median([e for *_, e in rows]))
if n_ok == 0:
divs = sorted(t for st, t, _, _ in rows if st != "ок")
print(f"{name:36s} 0/7 дошли, разлёт {divs[0]}–{divs[-1]}, "
f"макс.потеря за 50 шагов (мед.)={early:.1f}")
else:
med = float(np.median([f for st, _, f, _ in rows if st == "ок"]))
print(f"{name:36s} дошли {n_ok}/7, итог (мед.)={med:.4f}, "
f"макс.потеря за 50 шагов (мед.)={early:.2f}")
У нас этот код напечатал:
2-слойная ReLU; база B=64 peak=0.05 warmup=200 T=2000
база B=64 peak=0.05 wu=200 дошли 7/7, итог (мед.)=0.1445, макс.потеря за 50 шагов (мед.)=11.43
B×4 LR×4, без разогрева 0/7 дошли, разлёт 5–7, макс.потеря за 50 шагов (мед.)=50033347.8
B×4 LR×4, wu=200 (как у базы) дошли 7/7, итог (мед.)=0.4268, макс.потеря за 50 шагов (мед.)=8.98
B×4 LR×4, wu=800 дошли 7/7, итог (мед.)=0.3352, макс.потеря за 50 шагов (мед.)=9.33
B×4 LR×√4=0.10, wu=800 дошли 7/7, итог (мед.)=0.0877, макс.потеря за 50 шагов (мед.)=9.42
B×8 LR×8=0.40, wu=200 дошли 7/7, итог (мед.)=1.9498, макс.потеря за 50 шагов (мед.)=8.56
База дошла во всех 7 запусках с итогом 0.1445. То же линейное ×4 без разогрева: 0/7, разлёт на шагах 5–7, «макс. потеря за 50 шагов» в десятках миллионов. С разогревом 200 или 800 линейное ×4 уже не разлетается, но итог хуже базы (0.43 и 0.34): пик 0.20 здесь на грани. Правило корня (пик 0.10) с разогревом 800 дало лучший итог в этой серии — 0.0877. Линейное ×8 с пиком 0.40 формально дошло, но итог 1.95 — обучение «идёт» и бесполезно. Повтори: для ×4 поставь пик 0.12 и разогрев 800 — это между линейным и корнем — и сравни итог с 0.10 и 0.20.
Где обычно ошибаются.
Линейное правило (linear scaling rule). Совет увеличить скорость во столько же раз, во сколько вырос пакет.
Правило корня (square-root scaling). Для адаптивных оптимизаторов: скорость растёт как √k при пакете ×k.
Глобальный пакет (global batch). Микропакет × накопление × число видеокарт; именно он входит в правило.
Разогрев в шагах. Длина разогрева как число обновлений, а не число примеров.
Критический размер пакета. Пакет, выше которого увеличение почти не сокращает число шагов (см. вчерашнюю дорожку).
AdamW. Adam с отдельным уменьшением весов; его сила обычно масштабируется текущей скоростью из расписания.
Предел устойчивости. Потолок скорости, за которым спуск раскачивается независимо от разогрева.
Зачем это в работе. Расписание редко настраивают с нуля на полной модели: слишком дорого. Обычно берут чужой рецепт, переносят на свой пакет и свой оптимизатор и смотрят на кривую потери. Три типичных поломки видны по этой кривой ещё до конца обучения: спайки и разлёт в начале, «мёртвый» прогресс при слишком малом шаге, и слишком быстрый спад, после которого кривая почти не двигается, хотя шагов ещё много. Ниже — как их отличить и что проверить в первую очередь.
Как это устроено. Спайки в начале (резкий рост потери, NaN, разлёт) почти всегда говорят: пик слишком большой для старта или разогрев слишком короткий. «Мёртвый» прогресс — потеря после сотен шагов всё ещё далеко от ожидаемого пола и падает медленно: пик занижен или пол скорости выставлен слишком рано. Слишком быстрый спад — потеря хорошо падала, потом скорость ушла к полу, и оставшаяся половина бюджета почти ничего не даёт: длина спада (или T косинуса) не совпала с реальным бюджетом шагов.
Что проверить на практике. (1) Число шагов разогрева относительно пика и пакета — не в примерах, а в обновлениях. (2) Пик относительно вчерашнего линейного/корневого правила и относительно того, что уже стабильно на малой модели. (3) Пол и момент, когда скорость впервые почти равна полу: если это случилось на 20% пути, вы «доучили» слишком рано. (4) Согласованность с AdamW: на очень низком lr уменьшение весов тоже слабеет. (5) Не путать всплеск от плохой порции данных с системным разлётом: первый редок и лечится обрезкой градиента и откатом, второй повторяется при перезапуске.
Чем это отличается от диагностики оптимизатора. Обрезка градиента и β₂ лечат редкие взрывы по ходу ровного обучения. Если же кривая ломается однотипно в первых десятках шагов или одинаково «мертвеет» на каждом перезапуске — сначала смотрят расписание, не ε в Adam.
Подробный пример. Снова двухслойная ReLU, пакет 64, 3000 шагов, семь сидов. Четыре расписания: нормальное (разогрев 250 + косинус, пик 0.08), «спайки» (пик 0.15 без разогрева), «мёртвый» (постоянные 0.002), «быстрый спад» (разогрев 50 и косинус, который к шагу 400 уже на полу).
import numpy as np
# Три плохих расписания vs нормальное на 2-слойной ReLU.
rng = np.random.default_rng(6)
N, d_in, d_h = 12_000, 20, 32
X = rng.standard_normal((N, d_in))
W1t = rng.standard_normal((d_in, d_h)) * 0.4
W2t = rng.standard_normal((d_h, 1)) * 0.4
y = (np.maximum(0, X @ W1t) @ W2t).ravel() + 0.1 * rng.standard_normal(N)
def loss_grads(Xb, yb, W1, W2):
z1 = Xb @ W1; h = np.maximum(0, z1); out = (h @ W2).ravel()
err = out - yb; L = float(np.mean(err**2))
dout = (2.0 / len(yb)) * err[:, None]
gW2 = h.T @ dout; gW1 = Xb.T @ ((dout @ W2.T) * (z1 > 0))
return L, gW1, gW2
def init(seed):
r = np.random.default_rng(seed)
return (r.standard_normal((d_in, d_h)) * np.sqrt(2/d_in),
r.standard_normal((d_h, 1)) * np.sqrt(2/d_h))
def eval_L(W1, W2):
idx = np.arange(0, N, max(1, N//2000))
L, _, _ = loss_grads(X[idx], y[idx], W1, W2)
return L
B, T = 64, 3000
def lr_of(kind, t):
if kind == "норма: wu250+cosine peak=0.08":
peak, wu, floor = 0.08, 250, 0.004
if t <= wu: return peak * t / wu
p = (t - wu) / (T - wu)
return floor + 0.5 * (peak - floor) * (1 + np.cos(np.pi * min(p, 1)))
if kind == "спайки: peak=0.15 без wu":
return 0.15
if kind == "мёртвый: peak=0.002 constant":
return 0.002
if kind == "быстрый спад: wu50 + cosine к шагу 400":
peak, wu, Tfast, floor = 0.08, 50, 400, 0.004
if t <= wu: return peak * t / wu
if t >= Tfast: return floor
p = (t - wu) / (Tfast - wu)
return floor + 0.5 * (peak - floor) * (1 + np.cos(np.pi * p))
raise ValueError(kind)
def run(kind, seed):
r = np.random.default_rng(seed + 11)
W1, W2 = init(seed)
hist = []
for t in range(1, T + 1):
lr = lr_of(kind, t)
idx = r.integers(0, N, B)
Lb, g1, g2 = loss_grads(X[idx], y[idx], W1, W2)
W1 -= lr * g1; W2 -= lr * g2
if not (np.isfinite(W1).all() and np.isfinite(W2).all()) or Lb > 1e6:
return "расходится", t, hist
if t in (1, 50, 250, 400, 1000, 1500, 3000):
hist.append((t, eval_L(W1, W2), lr))
return "ок", eval_L(W1, W2), hist
kinds = list(dict.fromkeys([
"норма: wu250+cosine peak=0.08",
"спайки: peak=0.15 без wu",
"мёртвый: peak=0.002 constant",
"быстрый спад: wu50 + cosine к шагу 400",
]))
print(f"T={T}, B={B}")
for kind in kinds:
rows = [run(kind, s) for s in range(7)]
n_ok = sum(1 for st, *_ in rows if st == "ок")
print(f"\n{kind}")
if n_ok == 0:
divs = sorted(t for st, t, _ in rows if st != "ок")
print(f" 0/7 дошли, разлёт на шагах {divs}")
hist = next(h for st, _, h in rows if h)
for t, L, lr in hist:
print(f" t={t:4d} L={L:.4f} lr={lr:.4f}")
else:
finals = [fin for st, fin, _ in rows if st == "ок"]
# падение от t=1500 к t=3000 (вторая половина «активного» хвоста)
d2 = []
for st, fin, hist in rows:
if st != "ок": continue
by = {t: L for t, L, _ in hist}
if 1500 in by and 3000 in by:
d2.append(by[1500] - by[3000])
print(f" дошли {n_ok}/7" + (f", разлёт у {7-n_ok}" if n_ok < 7 else "") +
f", итог (мед.)={np.median(finals):.4f}" +
(f", падение 1500→3000 (мед.)={np.median(d2):.4f}" if d2 else ""))
hist = next(h for st, _, h in rows if st == "ок")
for t, L, lr in hist:
print(f" t={t:4d} L={L:.4f} lr={lr:.4f}")
У нас этот код напечатал:
T=3000, B=64
норма: wu250+cosine peak=0.08
дошли 7/7, итог (мед.)=0.0953, падение 1500→3000 (мед.)=0.0216
t= 1 L=5.9202 lr=0.0003
t= 50 L=2.2015 lr=0.0160
t= 250 L=0.4287 lr=0.0800
t= 400 L=0.2149 lr=0.0794
t=1000 L=0.1379 lr=0.0669
t=1500 L=0.1157 lr=0.0474
t=3000 L=0.0984 lr=0.0040
спайки: peak=0.15 без wu
дошли 1/7, разлёт у 6, итог (мед.)=0.0934, падение 1500→3000 (мед.)=-0.0394
t= 1 L=9.4796 lr=0.1500
t= 50 L=0.5191 lr=0.1500
t= 250 L=0.1422 lr=0.1500
t= 400 L=0.1112 lr=0.1500
t=1000 L=0.0583 lr=0.1500
t=1500 L=0.0541 lr=0.1500
t=3000 L=0.0934 lr=0.1500
мёртвый: peak=0.002 constant
дошли 7/7, итог (мед.)=0.5664, падение 1500→3000 (мед.)=0.2406
t= 1 L=5.8474 lr=0.0020
t= 50 L=4.0550 lr=0.0020
t= 250 L=2.0256 lr=0.0020
t= 400 L=1.5484 lr=0.0020
t=1000 L=1.0631 lr=0.0020
t=1500 L=0.8690 lr=0.0020
t=3000 L=0.5647 lr=0.0020
быстрый спад: wu50 + cosine к шагу 400
дошли 7/7, итог (мед.)=0.1805, падение 1500→3000 (мед.)=0.0311
t= 1 L=5.8645 lr=0.0016
t= 50 L=2.9627 lr=0.0800
t= 250 L=0.2879 lr=0.0335
t= 400 L=0.2365 lr=0.0040
t=1000 L=0.2148 lr=0.0040
t=1500 L=0.2018 lr=0.0040
t=3000 L=0.1769 lr=0.0040
Нормальное: 7/7, итог 0.0953, за вторую половину (1500→3000) потеря ещё упала на 0.022. Без разогрева: дошёл только 1 из 7, остальные разлетелись; у выжившего во второй половине потеря даже выросла (−0.039). «Мёртвый» шаг: все дошли, но итог 0.566 — в шесть раз хуже нормы, хотя формально кривая ещё ползёт. Быстрый спад: к шагу 400 скорость уже 0.004, итог 0.1805; с 1500 до 3000 падение всего 0.031 при том, что скорость давно на полу — бюджет шагов сгорел впустую. Повтори: у «быстрого спада» растяни косинус до 3000 и сравни итог с нормой при том же пике 0.08.
Где обычно ошибаются.
Спайк потери (loss spike). Резкий короткий рост потери; в начале часто предшествует разлёту.
«Мёртвый» прогресс. Потеря почти не падает при ещё большом остатке бюджета шагов.
Слишком быстрый спад. Скорость уходит к полу задолго до конца обучения.
Бюджет шагов. Сколько обновлений вы реально готовы потратить на этот прогон.
Обрезка градиента (gradient clipping). Ограничение длины градиента; лечит редкие взрывы, неплохое расписание.
Контрольная точка (checkpoint). Сохранённые веса на определённом шаге; её качество зависит от того, где на расписании вы её сняли.
Пол скорости. Нижнее значение lr; если достигнуто слишком рано, оставшиеся шаги почти не учат.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.