дорожка · 04.11.2026 · начальные веса

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

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

Все дорожки — /put. Прошлая — выходной слой.

1 Почему начальный размах весов решает, дойдёт ли сигнал через глубину

Зачем это в работе. Если обучение новой сети с первого шага выдаёт потерю «NaN» (не число — признак переполнения) или потеря стоит на месте, первым делом проверяют не данные и не скорость обучения, а начальный масштаб весов. Его задают одной строкой в коде модели, и ошибка в этой строке делает глубокую сеть необучаемой ещё до первого шага. Понимать, откуда берутся формулы вида 1/√d, нужно и тогда, когда меняешь ширину модели или функцию активации: старое число перестаёт подходить.

Как это устроено. Полносвязный слой берёт вектор x из d чисел и выдаёт новый вектор, где каждое число — сумма d произведений «вход × вес». Если входы и веса независимы, со средним ноль, то разброс суммы растёт пропорционально числу слагаемых: дисперсия (средний квадрат отклонения от среднего) выхода равна d × дисперсия веса × дисперсия входа. Значит, чтобы размах сигнала не менялся от слоя к слою, дисперсия веса должна быть около 1/d, а стандартное отклонение («стд», типичный размах) — около 1/√d. При d = 512 это примерно 0.044.

Дальше слой пропускает сумму через функцию активации, и она тоже меняет размах. Функция ReLU (выпрямитель: отрицательное заменяет нулём) обнуляет примерно половину чисел, поэтому средний квадрат после неё падает вдвое. Чтобы это компенсировать, Хе и соавторы в статье «Delving Deep into Rectifiers» (2015) предложили дисперсию веса 2/d — это инициализация Хе (He initialization). Для симметричных функций вроде tanh (гиперболический тангенс, гладко сжимает число в диапазон от −1 до 1) раньше Глоро и Бенжио (2010) вывели вариант, учитывающий и вход, и выход слоя, — инициализация Ксавье (Xavier, она же Glorot); для квадратного слоя она тоже даёт 1/√d.

Ограничение. Ошибка в масштабе умножается на каждом слое. Если каждый слой делает сигнал в 0.7 раза меньше, через 50 слоёв от него остаётся 0.750, около одной десятимиллионной: сигнал гаснет (vanishing). Если в 1.3 раза больше — 1.350, примерно полмиллиона: сигнал взрывается (exploding). Обратный проход идёт через те же матрицы, поэтому с градиентами происходит то же самое. Чем это отличается от нормализации: нормализация (LayerNorm, RMSNorm) насильно возвращает размах к единице внутри модели и сильно смягчает проблему, а инициализация задаёт размах на старте, до нормализации и в тех местах, где её нет, например в остаточном потоке (о нём — ступень 3).

Подробный пример. Пропустим 256 случайных векторов через 50 полносвязных слоёв по 512 нейронов без нормализации и посмотрим средний размах сигнала после слоёв 1, 10, 25 и 50 при пяти вариантах начальных весов.

import numpy as np
# 50 полносвязных слоёв по 512 нейронов: как меняется размах сигнала при разных начальных весах
rng = np.random.default_rng(0); d, depth = 512, 50
x0 = rng.standard_normal((256, d))                      # 256 примеров, размах (стд) около 1
relu = lambda z: np.maximum(z, 0)
setups = {"стд 0.01, ReLU": (0.01, relu), "Ксавье 1/√d, tanh": (1/np.sqrt(d), np.tanh),
          "Ксавье 1/√d, ReLU": (1/np.sqrt(d), relu), "Хе √(2/d), ReLU": (np.sqrt(2/d), relu),
          "стд 0.1, ReLU": (0.1, relu)}
for name, (s, f) in setups.items():
    x = x0; row = []
    for l in range(1, depth + 1):
        x = f(x @ (rng.standard_normal((d, d)) * s))
        if l in (1, 10, 25, 50): row.append(f"{np.sqrt((x**2).mean()):.3g}")
    print(f"{name:20s} слой 1 / 10 / 25 / 50:", " / ".join(row))

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

стд 0.01, ReLU       слой 1 / 10 / 25 / 50: 0.16 / 1.08e-08 / 1.13e-20 / 1.18e-40
Ксавье 1/√d, tanh    слой 1 / 10 / 25 / 50: 0.628 / 0.23 / 0.142 / 0.0981
Ксавье 1/√d, ReLU    слой 1 / 10 / 25 / 50: 0.706 / 0.031 / 0.000152 / 2.2e-08
Хе √(2/d), ReLU      слой 1 / 10 / 25 / 50: 1 / 1.08 / 0.87 / 1.09
стд 0.1, ReLU        слой 1 / 10 / 25 / 50: 1.6 / 104 / 1.23e+05 / 1.12e+10

Со стд 0.01 сигнал к 50-му слою уменьшился в 1040 раз — для компьютера это ноль, и сеть ничего не выучит. Со стд 0.1 он вырос в 1010 раз. Ксавье с ReLU — коварный случай: на первом слое всё выглядит прилично (0.7), но каждый слой теряет половину, и к 50-му остаётся 2·10−8. Инициализация Хе с ReLU держит размах около единицы на всей глубине: 1, 1.08, 0.87, 1.09. Ксавье с tanh медленно гаснет (до 0.1), потому что tanh сжимает большие значения. Повтори: замени ReLU на свою функцию, например GELU, и подбери множитель, при котором размах держится около единицы на 50-м слое.

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

  • Берут «стандартное» число вроде 0.01 или 0.02 из чужого кода и применяют его к сети другой ширины. Правильный масштаб зависит от d: число, хорошее для d = 768, для d = 8192 даст сигнал в три с лишним раза больше на каждом слое.
  • Меняют функцию активации и не меняют инициализацию. Переход с tanh на ReLU без перехода с Ксавье на Хе даёт ровно тот провал, что виден в примере.
  • Считают по первому слою, что всё в порядке. Проблема видна только по глубине: смотреть надо размах на последних слоях и норму градиента на первых.

Инициализация (initialization). Выбор начальных значений весов перед первым шагом обучения.

Дисперсия (variance). Средний квадрат отклонения чисел от их среднего; корень из неё — стандартное отклонение.

Стандартное отклонение (standard deviation, стд). Типичный размах чисел вокруг среднего, в тех же единицах, что и сами числа.

Инициализация Ксавье (Xavier, Glorot). Случайные веса с дисперсией около 2/(вход + выход), рассчитанные на симметричные функции активации.

Инициализация Хе (He, Kaiming). Случайные веса с дисперсией 2/вход, которые компенсируют потерю половины сигнала в ReLU.

Затухание градиента (vanishing gradient). Уменьшение сигнала обучения при проходе назад через много слоёв, из-за которого ранние слои почти не учатся.

Взрыв градиента (exploding gradient). Обратная беда: сигнал растёт от слоя к слою до переполнения и NaN.

2 Зачем веса случайные: разрушение симметрии

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

Как это устроено. Возьмём скрытый слой из 16 нейронов. Каждый нейрон — строка весов, которая смотрит на тот же вход. Если все строки одинаковы, все 16 нейронов выдают одно и то же число. На обратном проходе каждый получает градиент — поправку, которая зависит от его входа, его выхода и веса, связывающего его со следующим слоем. Раз всё это одинаково, одинаковы и поправки. После шага нейроны снова одинаковы, и так навсегда. Слой из 16 нейронов работает как один нейрон, скопированный 16 раз. Это называют симметрией весов, а случайный старт — её разрушением (symmetry breaking).

Нули — худший частный случай. Если веса и первого, и второго слоя нулевые, градиент по первому слою пропорционален весам второго, то есть равен нулю: первый слой не сдвинется вообще. Второй слой получает градиент, пропорциональный выходам первого, а tanh(0) = 0 — значит, и он стоит. Учится только смещение на выходе, то есть сеть сможет выучить лишь «самый частый ответ».

Ограничение и тонкости. Нули безопасны там, где несимметричность приходит из другого места. Смещения (bias) почти всегда начинают с нуля: их различает то, что веса уже случайны. Некоторые рецепты намеренно обнуляют вклад остаточного блока на старте: в работе Fixup (2019) ставят в ноль последний слой ветки блока, в ReZero (2020) — множитель перед всей веткой. Тогда в начале блок ничего не прибавляет к потоку и модель стартует как «почти тождественная», но градиент по этому нулевому элементу не нулевой, потому что входы в него уже разные. Чем это отличается от ступени 1: там речь о размахе случайности, здесь — о самом факте, что она есть.

Подробный пример. Обучим сеть «2 входа → 16 нейронов с tanh → 1 выход» отличать точки внутри круга от точек снаружи. 512 случайных точек, 3000 шагов обычного градиентного спуска, градиенты выписаны вручную. Сравним три старта: все веса нули, все веса 0.5 и случайные со стд 0.5. После обучения считаем точность и сколько из 16 скрытых нейронов действительно разные.

import numpy as np
# Сеть 2→16→1 учит функцию «по кругу»: y = 1, если точка внутри круга. Сравним нулевое и случайное начало
rng = np.random.default_rng(3)
X = rng.uniform(-1, 1, (512, 2)); y = ((X**2).sum(1) < 0.5).astype(float)[:, None]
def train(W1, b1, W2, b2, steps=3000, lr=0.5):
    for _ in range(steps):
        h = np.tanh(X @ W1 + b1); p = 1/(1+np.exp(-(h @ W2 + b2)))
        g = (p - y) / len(X)                               # градиент кросс-энтропии по логиту
        gW2 = h.T @ g; gb2 = g.sum(0); gh = g @ W2.T * (1 - h**2)
        W1 -= lr * X.T @ gh; b1 -= lr * gh.sum(0); W2 -= lr * gW2; b2 -= lr * gb2
    acc = ((p > 0.5) == y).mean()
    distinct = len({tuple(np.round(c, 4)) for c in W1.T})
    return acc, distinct
for name, W1, W2 in [("все нули", np.zeros((2, 16)), np.zeros((16, 1))),
                     ("все 0.5", np.full((2, 16), 0.5), np.full((16, 1), 0.5)),
                     ("случайные стд 0.5", rng.standard_normal((2, 16))*0.5, rng.standard_normal((16, 1))*0.5)]:
    acc, k = train(W1.copy(), np.zeros(16), W2.copy(), np.zeros(1))
    print(f"{name:18s}: точность {acc:.2f} | разных скрытых нейронов из 16: {k}")
print("доля точек внутри круга:", round(y.mean(), 2))

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

все нули          : точность 0.58 | разных скрытых нейронов из 16: 1
все 0.5           : точность 0.58 | разных скрытых нейронов из 16: 1
случайные стд 0.5 : точность 0.99 | разных скрытых нейронов из 16: 16
доля точек внутри круга: 0.42

Нулевой и одинаковый старт дали точность 0.58 — это ровно доля точек снаружи круга (внутри 0.42): сеть выучила «всегда отвечай снаружи». И в обоих случаях все 16 нейронов остались одним нейроном. Случайный старт за те же шаги дал точность 0.99 и 16 разных нейронов: каждый выучил свою прямую, и вместе они очертили круг. Повтори: дай одинаковым весам крошечный шум, например 0.5 + 10−6 × случайное число, и посмотри, хватит ли его, чтобы нейроны разошлись за 3000 шагов.

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

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

Разрушение симметрии (symmetry breaking). Случайный старт, который делает нейроны одного слоя разными, чтобы обучение могло их развести.

Смещение (bias). Число, которое нейрон прибавляет к взвешенной сумме входов; его обычно начинают с нуля.

Градиентный спуск (gradient descent). Шаг обучения: сдвинуть каждый вес против направления роста ошибки.

Скрытый слой (hidden layer). Слой между входом и выходом, значения которого не видны снаружи сети.

Тождественное отображение (identity). Преобразование, которое возвращает вход без изменений.

Нулевая инициализация последнего слоя (zero-init). Приём, при котором блок на старте ничего не добавляет к потоку и включается постепенно.

3 Почему остаточный поток растёт с глубиной и как его держит поправка 1/√(2N)

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

Как это устроено. В схеме с нормализацией перед блоком (pre-norm) каждый блок делает x ← x + f(норм(x)). Вход в f всегда стандартного размаха, значит и вклад f на старте примерно одного и того же размера, назовём его σ. Вклады разных блоков на старте почти независимы, а дисперсии независимых слагаемых складываются. После N блоков дисперсия потока около N·σ2, а стд — около √N·σ: поток растёт как корень из глубины.

Поправка. В статье GPT-2 (Radford и соавторы, 2019) сказано, что веса остаточных слоёв при старте умножают на 1/√N, где N — число остаточных слоёв. В блоке трансформера их два — внимание и полносвязный блок, — поэтому в открытых переписках кода GPT-2, например в nanoGPT Андрея Карпаты, выходные матрицы блоков начинают со стд 0.02/√(2·число блоков). Тогда N вкладов размера σ/√N в сумме дают стд около σ при любой глубине. Остальные матрицы в этом рецепте — со стд 0.02, независимо от ширины; это эмпирическое число из кода GPT-2, а не вывод из формулы ступени 1.

Чем это отличается от соседнего понятия. Нормализация внутри блока защищает вход каждого блока, но не сам поток. Масштабирование при старте защищает поток, но только в начале: дальше обучение меняет веса, и размах потока определяется уже ими. В схемах вроде DeepNet (2022) для моделей в сотни и тысячи слоёв поправку делают ещё и внутри самой формулы остатка, умножая x на коэффициент; это отдельный приём, а не замена инициализации.

Подробный пример. Смоделируем остаточный поток: на входе векторы размера 768 со стд около 0.028 (как эмбеддинг токена плюс эмбеддинг позиции со стд 0.02 каждый), затем N блоков «нормализация → слой 768→3072 → ReLU → слой 3072→768». Все веса стд 0.02, а во втором варианте выходной слой блока дополнительно умножен на 1/√(2N). Для простоты в каждом блоке один остаточный слой, а не два, поэтому поправка здесь немного сильнее, чем нужно, — нам важен рост с глубиной.

import numpy as np
# Остаточный поток: x += блок(норм(x)). Блок — два слоя с ReLU, веса стд 0.02 (как в GPT-2), d = 768
rng = np.random.default_rng(1); d = 768
def norm(x): return (x - x.mean(-1, keepdims=True)) / x.std(-1, keepdims=True)
def stream(n_blocks, scale_last):
    x = rng.standard_normal((64, d)) * 0.02 * np.sqrt(2)   # вход: эмбеддинг токена + позиции, стд ~0.028
    for _ in range(n_blocks):
        W1 = rng.standard_normal((d, 4*d)) * 0.02
        W2 = rng.standard_normal((4*d, d)) * 0.02 * scale_last
        x = x + np.maximum(norm(x) @ W1, 0) @ W2
    return x.std()
for N in (12, 24, 48, 96):
    a = stream(N, 1.0); b = stream(N, 1/np.sqrt(2*N))
    print(f"блоков {N:3d}: стд потока без поправки {a:.3f} | с поправкой 1/√(2N) {b:.3f}")

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

блоков  12: стд потока без поправки 1.500 | с поправкой 1/√(2N) 0.313
блоков  24: стд потока без поправки 2.165 | с поправкой 1/√(2N) 0.308
блоков  48: стд потока без поправки 3.021 | с поправкой 1/√(2N) 0.309
блоков  96: стд потока без поправки 4.216 | с поправкой 1/√(2N) 0.311

Без поправки стд потока растёт 1.5 → 2.2 → 3.0 → 4.2 при глубине 12 → 24 → 48 → 96: каждое удвоение глубины умножает размах примерно на 1.4, то есть на √2, ровно как предсказывает сложение независимых вкладов. С поправкой поток держится около 0.31 при любой глубине. Заметь и другое: без поправки уже после 12 блоков вклад слоёв в 50 раз больше исходного эмбеддинга (1.5 против 0.028), то есть информация о самом токене на старте почти утоплена. Повтори: замени ReLU на GELU и добавь второй остаточный слой в каждый блок, чтобы проверить, что поправка 1/√(2N) тогда даёт ровный размах.

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

  • Переписывают модель на новом фреймворке и инициализируют все матрицы одинаково, потеряв особую метку для выходных слоёв блоков. Модель учится, но глубокие варианты нестабильнее, и причину долго ищут в скорости обучения.
  • Считают N как число блоков, а не число остаточных слоёв, или наоборот. Разница — множитель √2, небольшая, но её стоит знать при сравнении с чужими результатами.
  • Думают, что раз есть нормализация, масштаб весов неважен. Нормализация делает неважным масштаб входа в блок, но не размах потока и не размер шага обучения относительно весов.

Остаточный поток (residual stream). Вектор токена, к которому каждый блок прибавляет свой вклад, не заменяя его.

Pre-norm. Схема блока, в которой нормализацию ставят перед вниманием и полносвязным слоем, а не после сложения.

Остаточный слой. Слой, чей выход прибавляется к потоку; в блоке трансформера их два.

Поправка 1/√(2N). Уменьшение начальных весов выходных слоёв блоков, чтобы сумма N вкладов не росла с глубиной.

nanoGPT. Небольшая открытая реализация GPT-2 Андрея Карпаты, по которой часто изучают и проверяют детали обучения.

DeepNet. Работа 2022 года, где для сверхглубоких трансформеров дополнительно масштабируют сам остаток в формуле блока.

4 Какой должна быть потеря на первом шаге и как это ловит ошибки

Зачем это в работе. Первое число в журнале обучения — потеря на шаге ноль — бесплатно проверяет половину кода. У необученной языковой модели правильная стартовая потеря известна заранее: если она сильно отличается, значит, неправильно инициализирован выходной слой, перепутаны метки, или модель случайно «видит» правильный ответ. Опытные инженеры смотрят на это число раньше, чем на график; его разбор есть, например, в рецепте Андрея Карпаты «A Recipe for Training Neural Networks» (2019).

Как это устроено. Потеря языковой модели — кросс-энтропия: минус логарифм вероятности, которую модель дала правильному следующему токену (подробно — в дорожке про функцию потерь). Модель, которая честно ничего не знает, должна дать всем V токенам равную вероятность 1/V, и её потеря равна ln V. Для словаря GPT-2 (50 257 токенов) это 10.825. Если стартовая потеря близка к ln V, модель на старте «скромна». Если заметно выше — она на старте уверенно ошибается.

Откуда берётся уверенность. Логиты — оценки токенов перед softmax — это скалярные произведения вектора длины d на строки выходной матрицы. Вектор после финальной нормализации имеет стд около 1, поэтому стд логитов примерно равна стд весов выхода × √d. При стд 0.02 и d = 768 это около 0.55: логиты почти одинаковые, распределение почти равномерное. При стд 1 это около 28: один токен получает почти всю вероятность, причём случайный, и потеря на правильном токене огромна. Модель с самого начала тратит шаги не на обучение, а на то, чтобы «разучиться» ложной уверенности; часто это выглядит как резкий спад потери на первых сотнях шагов, похожий на успех, но означающий лишь исправление старта.

Ограничение. Проверка ln V работает для честной равномерной неопределённости. Если в задаче классы заметно несбалансированы, правильный старт другой: смещение выходного слоя можно сразу поставить равным логарифмам частот классов, тогда потеря на старте равна энтропии частот. Чем это отличается от перплексии: перплексия — это e в степени потери; при старте с ln V она равна размеру словаря, и это та же проверка в других единицах.

Подробный пример. Возьмём 32 случайных вектора размера 768 (как после финальной нормализации), случайные правильные токены и выходную матрицу 768×50 257 с разной стд. Посчитаем стд логитов, среднюю потерю и среднюю вероятность первого места.

import numpy as np
# Потеря на первом шаге: случайный вектор размера 768 после нормализации × случайная выходная матрица
rng = np.random.default_rng(2); V, d, T = 50257, 768, 32
h = rng.standard_normal((T, d))                          # вектор после финальной нормализации
y = rng.integers(0, V, T)                                # «правильные» следующие токены
print("ln V =", round(np.log(V), 3), "— потеря модели, которая честно не знает ничего")
for s in (0.0, 0.02, 0.1, 1.0):
    z = h @ (rng.standard_normal((d, V)).astype(np.float32) * s)
    z = z - z.max(-1, keepdims=True); lp = z - np.log(np.exp(z).sum(-1, keepdims=True))
    p = np.exp(lp)
    print(f"стд выхода {s:<4}: стд логитов {z.std():6.2f} | потеря {-lp[np.arange(T), y].mean():7.2f} | "
          f"средняя вероятность первого места {p.max(-1).mean():.3f}")

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

ln V = 10.825 — потеря модели, которая честно не знает ничего
стд выхода 0.0 : стд логитов   0.00 | потеря   10.82 | средняя вероятность первого места 0.000
стд выхода 0.02: стд логитов   0.57 | потеря   10.96 | средняя вероятность первого места 0.000
стд выхода 0.1 : стд логитов   2.89 | потеря   14.42 | средняя вероятность первого места 0.086
стд выхода 1.0 : стд логитов  28.55 | потеря  118.52 | средняя вероятность первого места 0.880

При стд 0.02 потеря 10.96 — на 0.14 выше идеальных 10.82, это нормальный старт. При стд 0.1 потеря уже 14.4, а первое место получает в среднем 8.6% вероятности: модель «уверена» в случайном токене. При стд 1 потеря 118, первое место забирает 88%. Если ты видишь на шаге ноль потерю 14 и выше для словаря в 50 тысяч, ищи ошибку в выходном слое раньше, чем в данных. Повтори: найди в журнале любого своего обучения потерю на первом шаге и сравни её с ln размера словаря или числа классов.

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

  • Не логируют потерю на шаге ноль, а начинают с усреднённой за первые сто шагов; к этому моменту плохой старт уже частично исправлен и незаметен.
  • Видят стартовую потерю заметно ниже ln V и радуются. Для необученной модели это почти всегда утечка ответа: например, маска внимания пропускает будущие токены или метки не сдвинуты на одну позицию.
  • Инициализируют выходной слой так же, как скрытые, по формуле Хе. Для скрытого слоя важно сохранить размах, а для выхода — наоборот, сделать логиты маленькими.

Кросс-энтропия (cross-entropy). Потеря, равная минус логарифму вероятности правильного ответа.

ln V. Потеря модели, равномерно размазавшей вероятность по V вариантам; эталон для шага ноль.

Логит (logit). Оценка варианта до превращения в вероятность через softmax.

Утечка ответа (leakage). Ситуация, когда модель при обучении видит то, что должна предсказать.

Перплексия (perplexity). e в степени потери: «среди скольких вариантов модель в среднем колеблется».

Энтропия частот. Наименьшая потеря модели, знающей только частоты классов и ничего о входе.

5 Что осталось от старта в обученной GPT-2 и как переносят настройки между размерами: μP

Зачем это в работе. Лаборатории не подбирают скорость обучения и масштаб весов прямо на модели в сотни миллиардов параметров: это слишком дорого. Их подбирают на маленьких моделях и переносят на большую. Работает ли перенос, зависит от того, как инициализация и скорость обучения масштабируются с шириной. Понимание этого объясняет, почему в отчётах о моделях упоминают μP и почему «лучшая скорость обучения» из статьи про маленькую модель не годится для большой.

Как это устроено. Рецепт «стд 0.02 для всех и 1/√(2N) для выходов блоков» задаёт только старт. После обучения от него мало что остаётся: обучение двигает веса гораздо дальше, чем их начальный размах. Но старт определяет, в какой области пространства весов начнёт работать оптимизатор, и вместе со скоростью обучения — насколько большие изменения получит каждый слой. В стандартной схеме («стандартная параметризация») при увеличении ширины d вклад одного шага в выход слоя растёт с d, поэтому оптимальная скорость обучения уменьшается по мере роста модели, и её приходится подбирать заново.

μP — параметризация максимального обновления (maximal update parametrization) из работы Ян, Ху и соавторов «Tensor Programs V» (2022) — меняет правила так, чтобы при росте ширины размах активаций и размер обновлений в каждом слое оставались постоянными. Для этого масштаб начальных весов, множители выхода и скорость обучения для разных типов слоёв задают как функции ширины, по-разному для входного, скрытых и выходного слоя. Авторы показали, что тогда оптимальные гиперпараметры (настройки обучения, которые не учатся сами) маленькой модели переносятся на широкую без перебора — это называют μTransfer. Насколько это используют конкретные лаборатории, в публичных отчётах указано не всегда; здесь только суть метода из статьи.

Ограничение. μP решает перенос по ширине; перенос по глубине и по длине обучения — отдельные вопросы, по которым есть более поздние работы, но не одна общепринятая схема. Чем это отличается от ступени 3: поправка 1/√(2N) держит размах на старте при росте глубины, а μP — размах и шаги обучения при росте ширины.

Подробный пример. Возьмём настоящие веса GPT-2 small (12 блоков, d = 768) и посмотрим стд нескольких матриц после обучения, сравнив с рецептом старта. Затем прогоним короткий текст и измерим размах остаточного потока после блоков 0, 3, 6, 9 и 12.

from gpt2np import *
# Какой размах у весов обученной GPT-2 small и что было бы при старте по рецепту статьи (стд 0.02, выходы блоков / √(2·12))
print("рецепт старта: обычные слои 0.02, выходы блоков 0.02/√24 =", round(0.02/np.sqrt(24), 4))
for name in ["wte.weight", "wpe.weight", "h.0.attn.c_attn.weight", "h.0.attn.c_proj.weight",
             "h.0.mlp.c_fc.weight", "h.0.mlp.c_proj.weight", "h.11.mlp.c_fc.weight", "h.11.mlp.c_proj.weight"]:
    w = W[name]; print(f"{name:24s} форма {str(w.shape):13s} стд {w.std():.4f}")
ids, st = run("The cat sat on the mat. The dog slept on the rug.")
print("стд остаточного потока после блоков 0/3/6/9/12:", " / ".join(f"{st[i].std():.2f}" for i in (0, 3, 6, 9, 12)))

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

рецепт старта: обычные слои 0.02, выходы блоков 0.02/√24 = 0.0041
wte.weight               форма (50257, 768)  стд 0.1437
wpe.weight               форма (1024, 768)   стд 0.1227
h.0.attn.c_attn.weight   форма (768, 2304)   стд 0.1996
h.0.attn.c_proj.weight   форма (768, 768)    стд 0.1475
h.0.mlp.c_fc.weight      форма (768, 3072)   стд 0.1412
h.0.mlp.c_proj.weight    форма (3072, 768)   стд 0.0880
h.11.mlp.c_fc.weight     форма (768, 3072)   стд 0.1300
h.11.mlp.c_proj.weight   форма (3072, 768)   стд 0.1982
стд остаточного потока после блоков 0/3/6/9/12: 0.20 / 24.82 / 28.98 / 30.24 / 16.77

Обученные матрицы имеют стд от 0.09 до 0.20 — в 4–10 раз больше стартовых 0.02, а выходы блоков, начавшие с 0.004, выросли в 20–50 раз. Старт — не «приблизительный ответ», а точка, из которой удобно начать движение. Остаточный поток в обученной модели тоже не держится около единицы: после трёх блоков его стд около 25, хотя на входе 0.2. Мы не проверяли, где именно сосредоточен этот рост; в литературе для GPT-2 описаны отдельные координаты потока с очень большими значениями, но по одной этой цифре это не видно, и выводов отсюда не делаем. Повтори: посчитай для каждой из 768 координат потока после блока 3 средний модуль и посмотри, равномерно ли распределён рост.

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

  • Сравнивают обученные веса с рецептом старта и делают вывод, что «инициализация была другой». По обученным весам старт не восстановить.
  • Берут оптимальную скорость обучения из статьи про модель другой ширины в стандартной параметризации и удивляются расхождению или нестабильности.
  • Включают μP частично — например, меняют только инициализацию, но не множители скорости обучения по слоям. Перенос гиперпараметров тогда не работает, а сравнение с базовой схемой становится нечестным.

Параметризация (parametrization). Набор правил, как масштаб весов, множители и скорость обучения зависят от размера модели.

μP (maximal update parametrization). Параметризация, при которой размах активаций и обновлений в каждом слое не меняется с шириной.

μTransfer. Перенос гиперпараметров, подобранных на узкой модели, на широкую в рамках μP без нового перебора.

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

Ширина модели (width). Размер вектора d внутри модели, в отличие от глубины — числа слоёв.

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

Скорость обучения (learning rate). Множитель, определяющий, насколько далеко сдвигаются веса за один шаг.

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