Последние дорожки разобрали трансформер по частям: нормализация и остаточные связи, полносвязный блок, выходной слой, а дорожка про оптимизатор — как делается каждый шаг обучения. Сегодня — момент до первого шага: какими числами заполнить веса модели, которая ещё ничего не знает (инициализация, initialization). Плохой старт не исправляется «потом само»: сигнал гаснет или взрывается уже на первом проходе, нейроны остаются близнецами, потеря начинается с бессмысленного значения. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения о статьях и рецептах лабораторий помечены как опубликованные, а не измеренные нами.
Все дорожки — /put. Прошлая — выходной слой.
Зачем это в работе. Если обучение новой сети с первого шага выдаёт потерю «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-м слое.
Где обычно ошибаются.
Инициализация (initialization). Выбор начальных значений весов перед первым шагом обучения.
Дисперсия (variance). Средний квадрат отклонения чисел от их среднего; корень из неё — стандартное отклонение.
Стандартное отклонение (standard deviation, стд). Типичный размах чисел вокруг среднего, в тех же единицах, что и сами числа.
Инициализация Ксавье (Xavier, Glorot). Случайные веса с дисперсией около 2/(вход + выход), рассчитанные на симметричные функции активации.
Инициализация Хе (He, Kaiming). Случайные веса с дисперсией 2/вход, которые компенсируют потерю половины сигнала в ReLU.
Затухание градиента (vanishing gradient). Уменьшение сигнала обучения при проходе назад через много слоёв, из-за которого ранние слои почти не учатся.
Взрыв градиента (exploding gradient). Обратная беда: сигнал растёт от слоя к слою до переполнения и NaN.
Зачем это в работе. Кажется, что проще и «честнее» начать с одинаковых весов, например нулей, и дать обучению всё решить. Это не работает, и причина та же, что встречается позже в более тонких формах: если два нейрона одинаково устроены и одинаково начинают, обучение никогда их не разведёт. Отсюда правила, которые встречаются в реальных моделях: веса заполняют случайно, а нулями — только смещения и некоторые специальные слои, и всегда понимая, откуда придёт несимметричный градиент.
Как это устроено. Возьмём скрытый слой из 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). Приём, при котором блок на старте ничего не добавляет к потоку и включается постепенно.
Зачем это в работе. В трансформере нормализация стоит на входе каждого блока, а сам остаточный поток (вектор токена, к которому каждый блок прибавляет свой вклад) не нормализуется до самого верха. Поэтому сколько бы ни было нормализаций, размах потока определяется тем, сколько блоков и какой величины вклад каждый прибавил. При удвоении числа слоёв без поправки поток на старте раздувается, вклад первых слоёв тонет, и обучение глубокой модели становится менее устойчивым. Эту поправку легко потерять при переписывании модели «своими руками».
Как это устроено. В схеме с нормализацией перед блоком (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) тогда даёт ровный размах.
Где обычно ошибаются.
Остаточный поток (residual stream). Вектор токена, к которому каждый блок прибавляет свой вклад, не заменяя его.
Pre-norm. Схема блока, в которой нормализацию ставят перед вниманием и полносвязным слоем, а не после сложения.
Остаточный слой. Слой, чей выход прибавляется к потоку; в блоке трансформера их два.
Поправка 1/√(2N). Уменьшение начальных весов выходных слоёв блоков, чтобы сумма N вкладов не росла с глубиной.
nanoGPT. Небольшая открытая реализация GPT-2 Андрея Карпаты, по которой часто изучают и проверяют детали обучения.
DeepNet. Работа 2022 года, где для сверхглубоких трансформеров дополнительно масштабируют сам остаток в формуле блока.
Зачем это в работе. Первое число в журнале обучения — потеря на шаге ноль — бесплатно проверяет половину кода. У необученной языковой модели правильная стартовая потеря известна заранее: если она сильно отличается, значит, неправильно инициализирован выходной слой, перепутаны метки, или модель случайно «видит» правильный ответ. Опытные инженеры смотрят на это число раньше, чем на график; его разбор есть, например, в рецепте Андрея Карпаты «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 размера словаря или числа классов.
Где обычно ошибаются.
Кросс-энтропия (cross-entropy). Потеря, равная минус логарифму вероятности правильного ответа.
ln V. Потеря модели, равномерно размазавшей вероятность по V вариантам; эталон для шага ноль.
Логит (logit). Оценка варианта до превращения в вероятность через softmax.
Утечка ответа (leakage). Ситуация, когда модель при обучении видит то, что должна предсказать.
Перплексия (perplexity). e в степени потери: «среди скольких вариантов модель в среднем колеблется».
Энтропия частот. Наименьшая потеря модели, знающей только частоты классов и ничего о входе.
Зачем это в работе. Лаборатории не подбирают скорость обучения и масштаб весов прямо на модели в сотни миллиардов параметров: это слишком дорого. Их подбирают на маленьких моделях и переносят на большую. Работает ли перенос, зависит от того, как инициализация и скорость обучения масштабируются с шириной. Понимание этого объясняет, почему в отчётах о моделях упоминают μ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 средний модуль и посмотри, равномерно ли распределён рост.
Где обычно ошибаются.
Параметризация (parametrization). Набор правил, как масштаб весов, множители и скорость обучения зависят от размера модели.
μP (maximal update parametrization). Параметризация, при которой размах активаций и обновлений в каждом слое не меняется с шириной.
μTransfer. Перенос гиперпараметров, подобранных на узкой модели, на широкую в рамках μP без нового перебора.
Гиперпараметр (hyperparameter). Настройка обучения, например скорость или масштаб весов, которую задают вручную, а не учат.
Ширина модели (width). Размер вектора d внутри модели, в отличие от глубины — числа слоёв.
Стандартная параметризация. Обычная схема, где масштаб весов и скорость обучения не согласованы с шириной, поэтому настройки приходится подбирать заново.
Скорость обучения (learning rate). Множитель, определяющий, насколько далеко сдвигаются веса за один шаг.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.