дорожка · 06.11.2026 · расписание шага

Как менять шаг обучения по ходу тренировки: разгон, спад и где ломается расписание

Вчерашняя дорожка про размер пакета закончилась на связи пакета и скорости обучения, а дорожка про оптимизатор коротко показала разогрев и косинус. Сегодня — само расписание скорости обучения (learning rate schedule): когда и зачем менять шаг по ходу тренировки, как устроены разгон и спад, где линейное правило LR∝B ломается вместе с коротким разогревом, и как по кривой потери понять, что расписание плохое. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения о статьях и рецептах лабораторий помечены как опубликованные, а не измеренные нами.

Все дорожки — /put. Прошлая — размер пакета.

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

Зачем это в работе. Скорость обучения (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 — и сравни разброс постоянного шага с косинусом.

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

  • Сравнивают два запуска с разным расписанием по числу шагов, не глядя на итоговую потерю и на то, «шумит» ли кривая в конце.
  • Берут пик «из чужого рецепта» и держат его постоянным до конца: начало ещё терпит, финал недобирает.
  • Считают, что расписание — украшение, а главное — оптимизатор. На практике плохой косинус портит хороший Adam сильнее, чем замена Adam на SGD при том же расписании.

Скорость обучения (learning rate). Множитель длины шага обновления весов.

Расписание скорости обучения (learning rate schedule). Правило, по которому скорость меняется от шага к шагу.

Пиковая скорость (peak learning rate). Наибольшее значение скорости в расписании.

Пол потери (loss floor). Нижняя граница потери из-за шума в данных; ниже неё модель в среднем не опустится.

Кривизна (curvature). Насколько быстро меняется наклон потери; большая кривизна требует более короткого шага.

Предел устойчивости. Наибольшая скорость, при которой спуск ещё не раскачивается; для квадратичной потери это 2/λmax.

Разброс потери в конце. Насколько прыгает кривая потери, когда обучение уже должно «сесть» в минимум.

2 Разгон в начале: зачем стартовать с малого шага

Зачем это в работе. Разогрев (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 запусков выживет.

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

  • Ставят разогрев в 100 шагов «на всякий случай» при пике, который без разогрева разносит сеть за 5 шагов, — и думают, что разогрев не нужен, потому что «у соседа без него работает» на другом пике.
  • Переносят число шагов разогрева из рецепта с другим размером пакета и фактически разогреваются по данным в разы быстрее.
  • Ищут причину разлёта в данных или в коде потери, хотя хватает удлинить разогрев или снизить пик.

Разогрев (warmup). Начальный участок, где скорость растёт от почти нуля до пика.

Линейный разогрев (linear warmup). Скорость растёт пропорционально номеру шага до пика.

Адаптивный шаг Adam. Обновление, делённое на корень из оценки второго момента градиента.

Второй момент (second moment, v). Скользящая оценка среднего квадрата градиента по каждому весу.

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

Разлёт (divergence). Устойчивый рост потери и весов до бесконечности или NaN.

Начальные веса (initialization). Случайные значения параметров до первого шага; задают стартовый масштаб сигнала.

3 Спад после разгона: косинус, линейный и ступенчатый

Зачем это в работе. После разогрева скорость нужно снизить к концу обучения. Форма спада (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 и сравни долю шагов выше половины пика.

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

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

Затухание / спад (decay). Снижение скорости обучения после разогрева.

Косинусное затухание (cosine decay). Спад по форме половины косинуса от пика к полу.

Линейный спад (linear decay). Равномерное снижение скорости от пика к полу.

Ступенчатый спад (step decay). Умножение скорости на коэффициент в заданных долях обучения.

Пол скорости (min learning rate). Нижнее значение, ниже которого расписание не опускается.

Плато (stable phase). Участок с постоянной скоростью; основа расписания WSD.

Повторный разогрев (re-warmup). Короткий подъём скорости при продолжении из уже затухшей точки.

4 Расписание, размер пакета и оптимизатор: где правило LR∝B ломается

Зачем это в работе. Вчерашняя дорожка разобрала линейное правило: увеличил пакет в 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.

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

  • Увеличивают число видеокарт (и глобальный пакет), множат пик на k и оставляют разогрев «как в старом конфиге».
  • Применяют линейное правило к Adam без проверки на малой модели и ловят нестабильность только на полном прогоне.
  • Сравнивают итог при B×4 и тех же S шагах с базой и радуются «лучшей потере», не заметив, что просмотрели в 4 раза больше данных.

Линейное правило (linear scaling rule). Совет увеличить скорость во столько же раз, во сколько вырос пакет.

Правило корня (square-root scaling). Для адаптивных оптимизаторов: скорость растёт как √k при пакете ×k.

Глобальный пакет (global batch). Микропакет × накопление × число видеокарт; именно он входит в правило.

Разогрев в шагах. Длина разогрева как число обновлений, а не число примеров.

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

AdamW. Adam с отдельным уменьшением весов; его сила обычно масштабируется текущей скоростью из расписания.

Предел устойчивости. Потолок скорости, за которым спуск раскачивается независимо от разогрева.

5 Как понять, что расписание плохое: спайки, мёртвый прогресс, слишком быстрый спад

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

Как это устроено. Спайки в начале (резкий рост потери, 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.

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

  • Видят один удачный сид без разогрева и решают, что разогрев не нужен; у нас дошёл 1 из 7.
  • Крутят только пик, не глядя, на какой доле пути скорость уже у пола.
  • Лечат системный разлёт в начале обрезкой градиента, вместо того чтобы удлинить разогрев или снизить пик.

Спайк потери (loss spike). Резкий короткий рост потери; в начале часто предшествует разлёту.

«Мёртвый» прогресс. Потеря почти не падает при ещё большом остатке бюджета шагов.

Слишком быстрый спад. Скорость уходит к полу задолго до конца обучения.

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

Обрезка градиента (gradient clipping). Ограничение длины градиента; лечит редкие взрывы, неплохое расписание.

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

Пол скорости. Нижнее значение lr; если достигнуто слишком рано, оставшиеся шаги почти не учат.

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