В дорожке о функции потерь шаг обучения выглядел просто: посчитали градиент и сдвинули веса против него. В настоящем обучении больших моделей между градиентом и изменением весов стоит отдельная программа — оптимизатор (optimizer). Она решает, в какую сторону и насколько сдвинуть каждый из миллиардов весов, помнит прошлые шаги и занимает в памяти больше места, чем сами веса. Разберём по порядку: импульс, Adam, уменьшение весов в AdamW, расписание скорости обучения и защиту от всплесков потери. Все примеры — маленькие расчёты на numpy; код на странице мы запускали, выводы взяты из этих запусков. Числа из чужих отчётов помечены, откуда они.
Все дорожки — /put. Прошлая — законы масштабирования.
Зачем это в работе. Когда обучение идёт медленно или вдруг разлетается, первым делом смотрят на скорость обучения и на настройки оптимизатора. Чтобы понимать, что ты крутишь, нужно видеть, как именно шаг превращается в движение весов. Импульс — первая и самая простая добавка к обычному спуску, и он живёт внутри Adam, которым учат почти все современные языковые модели, так что без него следующие ступени не читаются.
Как это устроено. Обычный градиентный спуск (gradient descent) на каждом шаге смотрит только на текущий градиент — направление, в котором потеря растёт быстрее всего, — и сдвигает веса против него на величину «скорость обучения × градиент». Скорость обучения (learning rate) — одно число, общее для всех весов. Беда в том, что поверхность потерь редко похожа на ровную чашу. Чаще это овраг: поперёк него стенки крутые, вдоль — дно почти плоское. Крутизну по направлению называют кривизной (curvature).
Один общий шаг не может подойти обоим направлениям сразу. Если взять его большим, на крутых стенках веса перескакивают через дно, и колебания растут — обучение разлетается. Предельный шаг задаёт самое крутое направление: для простой квадратичной потери он равен 2, делённому на наибольшую кривизну. Если же взять шаг маленьким, чтобы не разлетаться поперёк, движение вдоль пологого дна становится мучительно медленным.
Импульс (momentum), он же метод тяжёлого шара Поляка (1964), добавляет память. Оптимизатор хранит «скорость» v — накопленную сумму прошлых градиентов, где каждый старый градиент каждый шаг умножается на коэффициент β (обычно 0,9). Новый шаг делается по v, а не по сырому градиенту. Поперёк оврага градиенты меняют знак от шага к шагу и в сумме гасят друг друга. Вдоль дна они смотрят в одну сторону и складываются: при β = 0,9 устойчивое направление разгоняется примерно в 1/(1 − β) = 10 раз.
Ограничение: импульс не знает про масштаб отдельных весов. Он сглаживает направление, но вес с огромными градиентами по-прежнему шагает огромными шагами, а вес с крошечными — крошечными. Эту задачу решает уже Adam на следующей ступени. И не путай импульс с размером пакета (batch size): большой пакет усредняет градиент по многим примерам на одном шаге, а импульс усредняет по времени, по многим шагам.
Подробный пример. Возьмём овраг из двух координат: потеря 0,5·(100·x² + y²). Кривизна по x равна 100, по y — 1, значит предельный шаг для обычного спуска 2/100 = 0,02. Сравним три запуска по 100 шагов из точки (1, 1).
import numpy as np
# «Овраг»: потеря 0.5*(100*x**2 + y**2). По x стенки крутые, по y дно пологое.
curv = np.array([100.0, 1.0])
def grad(w): return curv * w
def run(lr, beta, steps=100):
w, v = np.array([1.0, 1.0]), np.zeros(2)
for t in range(steps):
v = beta * v + grad(w) # импульс: накопленное направление
w = w - lr * v
return 0.5 * np.sum(curv * w**2)
print(f"обычный спуск, шаг 0.019: потеря через 100 шагов {run(0.019, 0.0):.2e}")
print(f"обычный спуск, шаг 0.021: потеря через 100 шагов {run(0.021, 0.0):.2e}")
print(f"спуск с импульсом 0.9, шаг 0.019: потеря через 100 шагов {run(0.019, 0.9):.2e}")
У нас этот код напечатал:
обычный спуск, шаг 0.019: потеря через 100 шагов 1.08e-02
обычный спуск, шаг 0.021: потеря через 100 шагов 9.50e+09
спуск с импульсом 0.9, шаг 0.019: потеря через 100 шагов 1.34e-03
Шаг 0,019 чуть ниже предела, и обычный спуск за 100 шагов дошёл до потери около 0,01: поперёк оврага он сошёлся быстро, а вдоль дна каждую итерацию уменьшал y всего на 1,9%. Шаг 0,021 чуть выше предела, и потеря улетела к 1010: всего 10% разницы в шаге отделяют работу от взрыва. С импульсом 0,9 при том же шаге 0,019 потеря за 100 шагов стала в 8 раз меньше, чем без него. Повтори: поставь β = 0,99 и посмотри, как слишком длинная память начинает раскачивать веса.
Где обычно ошибаются.
Градиентный спуск (gradient descent). способ обучения, при котором веса сдвигают против градиента потери.
Скорость обучения (learning rate). множитель, определяющий длину шага; самая важная настройка обучения.
Кривизна (curvature). насколько быстро меняется наклон потери вдоль направления; крутое направление ограничивает допустимый шаг.
Овраг. поверхность потерь, крутая в одних направлениях и пологая в других; типичная причина медленного обучения.
Импульс (momentum). накопленная сумма прошлых градиентов, по которой делается шаг вместо сырого градиента.
Коэффициент β. доля старой «скорости», которая сохраняется на следующем шаге; при 0,9 память примерно на 10 шагов.
Разлёт обучения (divergence). ситуация, когда потеря растёт до огромных значений, потому что шаг слишком велик.
Зачем это в работе. Adam и его вариант AdamW — стандарт обучения и дообучения языковых моделей; именно его настройки ты увидишь в любом конфиге обучения, от полного предобучения до LoRA. Понимать, что делает каждый из его четырёх параметров, нужно, чтобы читать чужие отчёты, подбирать скорость обучения и считать память: состояние Adam занимает больше места, чем сами веса.
Как это устроено. Adam (Кингма и Ба, 2014) хранит для каждого веса две скользящие средние. Первая, m, — среднее градиента: это тот же импульс с коэффициентом β1 (по умолчанию 0,9). Вторая, v, — среднее квадрата градиента с коэффициентом β2 (по умолчанию 0,999): грубая оценка того, насколько велики и разбросаны градиенты этого веса. Скользящая средняя (exponential moving average) — это среднее, где каждое старое значение каждый шаг умножается на β, так что недавние значения весят больше.
Шаг Adam равен «скорость обучения × m / (√v + ε)». Деление на √v — главная идея: вес, у которого градиенты всегда огромные, получает тот же порядок шага, что и вес с крошечными градиентами. Если градиент устойчиво смотрит в одну сторону, отношение m/√v близко к 1, и шаг примерно равен скорости обучения. Если градиент скачет то плюс, то минус, m близко к нулю, а v нет — и шаг сам становится маленьким. Малое число ε (по умолчанию 10−8) защищает от деления на ноль.
Поправка смещения (bias correction). В начале обучения m и v стартуют с нуля, и первые средние занижены. Adam делит их на (1 − β1t) и (1 − β2t), где t — номер шага. Поправка сильнее влияет на v, потому что β2 ближе к 1 и v «прогревается» дольше. Без неё отношение m/√v на первых шагах оказывается не меньше, а больше нормы — это видно в примере ниже.
Ограничение — память. Для каждого веса нужны m и v, обычно в 32-битном формате. В расчёте из работы ZeRO (Раджбхандари и соавторы, 2019) обучение со смешанной точностью тратит 16 байт на параметр: 2 байта на веса, 2 на градиенты и 12 на 32-битную копию весов и два состояния Adam. Для модели в 7 миллиардов параметров это 112 ГБ ещё до активаций — больше, чем память одного ускорителя на 80 ГБ. Поэтому при дообучении так популярна LoRA из дорожки о дообучении: состояние оптимизатора нужно только для маленьких добавочных матриц. В отличие от квантования, которое ужимает веса для работы модели, здесь речь о памяти именно на время обучения.
Подробный пример. Проверим три свойства Adam на одном весе: шаг не зависит от масштаба градиента, поправка смещения меняет первые шаги, а шумный градиент без направления даёт маленький шаг.
import numpy as np
def adam_steps(grads, lr=1e-3, b1=0.9, b2=0.999, eps=1e-8, correct=True):
m = v = 0.0; out = []
for t, g in enumerate(grads, 1):
m = b1 * m + (1 - b1) * g # скользящее среднее градиента
v = b2 * v + (1 - b2) * g * g # скользящее среднее квадрата
mh, vh = (m / (1 - b1**t), v / (1 - b2**t)) if correct else (m, v)
out.append(lr * mh / (np.sqrt(vh) + eps))
return out
for scale in [1e-4, 1.0, 1e4]:
print(f"градиент {scale:>7g}: первые три шага Adam", [f"{s:.2e}" for s in adam_steps([scale]*3)])
print("без поправки смещения, градиент 1:", [f"{s:.2e}" for s in adam_steps([1.0]*3, correct=False)])
rng = np.random.default_rng(0)
noisy = rng.choice([-1.0, 1.0], 2000) # градиент без устойчивого направления
print(f"шумный градиент ±1, средний шаг за последние 1000: {np.mean(np.abs(adam_steps(noisy)[-1000:])):.2e}")
У нас этот код напечатал:
градиент 0.0001: первые три шага Adam ['1.00e-03', '1.00e-03', '1.00e-03']
градиент 1: первые три шага Adam ['1.00e-03', '1.00e-03', '1.00e-03']
градиент 10000: первые три шага Adam ['1.00e-03', '1.00e-03', '1.00e-03']
без поправки смещения, градиент 1: ['3.16e-03', '4.25e-03', '4.95e-03']
шумный градиент ±1, средний шаг за последние 1000: 1.86e-04
При градиентах 0,0001, 1 и 10 000 шаг один и тот же: 0,001, ровно скорость обучения. Обычному спуску пришлось бы менять скорость обучения в сто миллионов раз между этими случаями. Без поправки смещения первые шаги были 0,0032–0,005, то есть в 3–5 раз больше задуманного: на старте m занижено в 10 раз, а √v — примерно в 32 раза. Когда градиент случайно равен то +1, то −1, средний шаг за последние 1000 итераций около 0,00019, в пять с лишним раз меньше скорости обучения: Adam сам притормозил там, где направления нет.
Где обычно ошибаются.
Adam. оптимизатор, который делит сглаженный градиент на оценку его типичной величины, отдельно для каждого веса.
Первый момент m. скользящее среднее градиента; работает как импульс.
Второй момент v. скользящее среднее квадрата градиента; задаёт масштаб шага для веса.
Скользящая средняя (exponential moving average). среднее, где старые значения постепенно забываются с множителем β.
Поправка смещения (bias correction). деление средних на (1 − βt), чтобы убрать занижение из-за старта с нуля.
ε (эпсилон). крошечная добавка в знаменателе против деления на ноль.
Состояние оптимизатора (optimizer state). m, v и другие данные, которые оптимизатор хранит между шагами и сохраняет в контрольной точке.
Смешанная точность (mixed precision). обучение, где вычисления идут в 16-битных числах, а точная копия весов хранится в 32-битных.
Зачем это в работе. В конфиге почти любого обучения есть строка weight_decay, например 0,1. Это одна из немногих мер против того, чтобы веса бесконтрольно росли, и от неё зависит устойчивость долгого обучения. Если не понимать разницу между «уменьшением весов» и «штрафом L2», легко взять не тот оптимизатор или не тот параметр и получить модель, которая учится хуже без видимой причины.
Как это устроено. Идея уменьшения весов (weight decay) проста: на каждом шаге каждый вес немного тянут к нулю, умножая на (1 − скорость обучения × λ), где λ — сила уменьшения. Веса, которые данным не нужны, постепенно сжимаются, а нужные поддерживаются градиентом. Для обычного спуска это ровно то же самое, что добавить к потере штраф L2 (L2 regularization) — слагаемое λ/2 × сумма квадратов весов: его градиент равен λ × w, и шаг выходит тем же самым.
В Adam эта равносильность ломается. Если подмешать λ × w в градиент, то эта добавка тоже пройдёт через деление на √v. У веса с крупными градиентами v велико, и штраф после деления становится ничтожным. У веса с мелкими градиентами v мало, и штраф раздувается. Получается, что сильнее всего «сжимаются» как раз веса, которые данные трогают слабо, а самые активные почти не сжимаются. Это заметили Лощилов и Хуттер в работе «Decoupled Weight Decay Regularization» (2017).
Их решение назвали AdamW: уменьшение весов делают отдельно, после шага Adam, просто умножая вес на (1 − скорость обучения × λ), минуя деление на √v. Тогда все веса сжимаются с одной и той же относительной силой, независимо от величины их градиентов. Именно так устроен torch.optim.AdamW в PyTorch, а обычный torch.optim.Adam с параметром weight_decay делает старый вариант со штрафом L2.
Ограничение: уменьшение весов обычно не применяют к смещениям (bias) и параметрам нормализации — масштабам слоёв нормализации. Их мало, они задают масштаб сигнала, и тянуть их к нулю вредно. Ещё одна тонкость: в AdamW сила уменьшения умножается на текущую скорость обучения, поэтому когда расписание из следующей ступени снижает шаг к концу обучения, ослабевает и уменьшение весов. По описанию в статье GPT-3 (Браун и соавторы, 2020) там использовали силу уменьшения весов 0,1.
Подробный пример. Два веса стоят в 1,0. Данные постоянно толкают оба вверх: первый с градиентом 10, второй с градиентом 0,01. Сделаем 1000 шагов Adam со скоростью обучения 0,001 в трёх вариантах: без уменьшения, со штрафом L2 силой 0,1 в градиенте и с отдельным уменьшением, как в AdamW.
import numpy as np
# Два веса стоят в 1.0. Потеря тянет их к нулю по-разному: у первого градиент крупный, у второго мелкий.
# Сравним, как они уменьшаются за 1000 шагов Adam при двух способах «уменьшения весов».
def run(mode, lr=1e-3, wd=0.1, steps=1000):
w = np.array([1.0, 1.0]); m = np.zeros(2); v = np.zeros(2)
data_grad = np.array([10.0, 0.01]) # постоянный «полезный» градиент, толкает веса вверх
for t in range(1, steps + 1):
g = -data_grad.copy() # данные хотят увеличить веса
if mode == "L2": g = g + wd * w # штраф подмешан в градиент
m = 0.9*m + 0.1*g; v = 0.999*v + 0.001*g*g
mh, vh = m/(1-0.9**t), v/(1-0.999**t)
w = w - lr * mh/(np.sqrt(vh)+1e-8)
if mode == "AdamW": w = w - lr * wd * w # уменьшение отдельно от градиента
return w
for mode in ["none", "L2", "AdamW"]:
w = run(mode); print(f"{mode:>5}: вес с крупным градиентом {w[0]:.3f}, вес с мелким {w[1]:.3f}")
У нас этот код напечатал:
none: вес с крупным градиентом 2.000, вес с мелким 2.000
L2: вес с крупным градиентом 1.998, вес с мелким 0.289
AdamW: вес с крупным градиентом 1.856, вес с мелким 1.856
Без уменьшения оба веса выросли до 2,0: Adam нормирует шаг, и оба шагали одинаково. Со штрафом L2 вес с крупным градиентом почти не заметил штрафа (1,998), а вес с мелким градиентом штраф перетянул: он упал до 0,289, хотя данные толкали его вверх. С AdamW оба веса притормозились одинаково, до 1,856. Повтори: увеличь второй градиент до 0,1 и посмотри, как в варианте L2 он перестаёт проваливаться.
Где обычно ошибаются.
Уменьшение весов (weight decay). небольшое сжатие каждого веса к нулю на каждом шаге.
Сила уменьшения λ. число, задающее, насколько сильно веса тянут к нулю; часто 0,1 при предобучении.
Штраф L2 (L2 regularization). слагаемое в потере, пропорциональное сумме квадратов весов.
AdamW. Adam с уменьшением весов, вынесенным из градиента в отдельный шаг.
Развязанное уменьшение (decoupled weight decay). уменьшение весов, которое не проходит через деление на √v.
Смещение (bias). добавочное число в слое, которое сдвигает выход; обычно без уменьшения весов.
Параметры нормализации. масштабы в слоях нормализации, задающие величину сигнала; к ним уменьшение весов не применяют.
Зачем это в работе. Скорость обучения почти никогда не держат постоянной: её поднимают в начале и опускают в конце. От формы этой кривой заметно зависит итоговая потеря, а от её длины — можно ли продолжить обучение, когда пришли новые данные. Когда в отчёте пишут «пиковая скорость 3·10−4, косинус до 10%, разогрев 2000 шагов», это и есть расписание.
Как это устроено. Разогрев (warmup) — первые сотни или тысячи шагов, когда скорость обучения растёт от почти нуля до пика, обычно линейно. Причина в начале обучения: веса случайные, градиенты крупные и неустойчивые, а у Adam оценка v ещё собрана по нескольким шагам и шумная. Полный шаг в этот момент легко отправляет веса в плохую область, откуда обучение уже не выбирается. Разогрев даёт статистике оптимизатора накопиться, прежде чем делать большие шаги.
Затухание (decay) — снижение скорости к концу. На большом шаге веса прыгают вокруг хорошей области, потому что каждый пакет данных тянет их в свою сторону. Когда шаг уменьшается, прыжки сужаются, и потеря заметно опускается в последние проценты обучения. Самая частая форма — косинусное затухание (cosine decay): скорость плавно идёт от пика к нижнему значению по половине косинуса. По описанию в статье GPT-3 скорость там снижали косинусом до 10% от пика, а разогрев длился первые 375 миллионов токенов.
Ограничение косинуса: его форма привязана к заранее известной длине обучения. Авторы Chinchilla (Хоффманн и соавторы, 2022) отмечали, что если цикл косинуса задать длиннее фактического обучения, потеря на промежуточных точках получается завышенной; поэтому промежуточная контрольная точка длинного запуска не равна полноценно обученной короткой модели. Это прямо касается законов масштабирования: для честной точки нужен свой запуск со своим расписанием.
Расписание WSD (warmup-stable-decay, разогрев — плато — затухание), подробно описанное в работе о моделях MiniCPM (2024), решает эту проблему иначе: после разогрева скорость долго держат на пике, а резкое снижение делают только в последние примерно 10–20% шагов. Контрольную точку с плато можно продолжить на новых данных, а при необходимости в любой момент отрезать короткую ветку затухания и получить готовую модель. Цена — нужно дополнительно потратить шаги на эту ветку.
Подробный пример. Сравним два расписания на 10 000 шагов: разогрев 500 шагов до пика 3·10−4, нижнее значение 3·10−5. Пиковое значение мы взяли как типичное для порядка величины, а не из конкретного отчёта.
import math
TOTAL, WARM, PEAK, FLOOR = 10000, 500, 3e-4, 3e-5
def cosine(s):
if s < WARM: return PEAK * (s + 1) / WARM
p = (s - WARM) / (TOTAL - WARM)
return FLOOR + 0.5 * (PEAK - FLOOR) * (1 + math.cos(math.pi * p))
def wsd(s, decay_frac=0.1):
if s < WARM: return PEAK * (s + 1) / WARM
start = TOTAL * (1 - decay_frac)
if s < start: return PEAK
return PEAK - (PEAK - FLOOR) * (s - start) / (TOTAL - start)
print("шаг косинус WSD")
for s in [0, 250, 499, 2000, 5000, 8000, 9000, 9500, 9999]:
print(f"{s:>5} {cosine(s):.2e} {wsd(s):.2e}")
У нас этот код напечатал:
шаг косинус WSD
0 6.00e-07 6.00e-07
250 1.51e-04 1.51e-04
499 3.00e-04 3.00e-04
2000 2.84e-04 3.00e-04
5000 1.76e-04 3.00e-04
8000 5.85e-05 3.00e-04
9000 3.73e-05 3.00e-04
9500 3.18e-05 1.65e-04
9999 3.00e-05 3.03e-05
Разогрев у обоих одинаковый: на шаге 0 скорость в 500 раз меньше пика, на шаге 499 — пик. Дальше косинус к середине обучения опустился до 1,76·10−4, а к шагу 8000 — уже до 5,85·10−5. WSD до шага 9000 держит полный пик и только за последнюю тысячу шагов линейно спускается к тому же нижнему значению. Если на шаге 8000 решили учить дальше, контрольная точка WSD стоит на плато и продолжается естественно, а косинусная уже почти «доучена» и требует нового разогрева. Повтори: поменяй decay_frac на 0,2 и посмотри, где начинается спуск.
Где обычно ошибаются.
Расписание скорости обучения (learning rate schedule). правило, по которому скорость обучения меняется от шага к шагу.
Разогрев (warmup). начальный участок, где скорость растёт от почти нуля до пика.
Пиковая скорость. наибольшее значение скорости обучения в расписании.
Затухание (decay). снижение скорости обучения к концу, которое даёт последнее заметное падение потери.
Косинусное затухание (cosine decay). плавное снижение скорости по форме половины косинуса.
WSD (warmup-stable-decay). расписание с долгим плато на пике и коротким спуском в конце.
Плато. участок расписания с постоянной скоростью обучения.
Повторный разогрев (re-warmup). короткий подъём скорости при продолжении обучения из уже затухшей точки.
Зачем это в работе. На графике потери долгого обучения иногда видны резкие пики: потеря за несколько шагов подскакивает в разы, а потом либо возвращается, либо обучение ломается насовсем. На большом запуске каждый такой случай стоит часов работы тысяч ускорителей. Обрезка градиента, слежение за его нормой и откат к контрольной точке — стандартные средства, и их настройки есть в каждом серьёзном конфиге.
Как это устроено. Норма градиента (gradient norm) — длина градиента как одного вектора по всем весам модели сразу: корень из суммы квадратов всех его чисел. Обрезка градиента (gradient clipping) по норме работает так: если норма больше порога, весь градиент умножают на «порог / норма», то есть укорачивают до порога, не меняя направления. Если меньше — не трогают. По описанию в статье GPT-3 там обрезали по норме 1,0. Обрезку делают до шага оптимизатора, по общей норме всех весов; обрезка каждого числа по отдельности существует, но меняет направление и встречается реже.
Ограничение обрезки: она ограничивает длину шага, но не исправляет его направление. Если плохой пакет данных дал огромный градиент в немногих весах, после обрезки шаг всё равно почти целиком направлен туда, куда тянет этот пакет. В Adam есть ещё одна ловушка: огромный градиент попадает в v и надолго увеличивает его, после чего шаги этого веса на сотни итераций становятся меньше нормы. Поэтому обрезка смягчает удар, но не делает плохой шаг хорошим.
Когда обрезки мало, используют откат. Команда PaLM (Чоудхери и соавторы, 2022) описывала, что при всплеске перезапускала обучение с контрольной точки примерно за 100 шагов до него и пропускала около 200–500 пакетов данных вокруг этого места. Повторный прогон тех же пакетов из другого состояния модели всплеска не давал, поэтому авторы заключили, что виновато сочетание конкретных данных и состояния модели, а не «плохие данные» сами по себе. Контрольная точка (checkpoint) — сохранённые веса вместе с состоянием оптимизатора и позицией в данных.
Чем это отличается от разлёта из первой ступени: разлёт — устойчивый рост потери из-за слишком большого шага, он повторяется при каждом перезапуске с теми же настройками. Всплеск — редкое событие посреди нормального обучения. Лечение разное: при разлёте уменьшают скорость обучения или удлиняют разогрев, при редких всплесках — обрезают, откатываются и пропускают данные, а при частых всплесках смотрят на β2, ε и формат чисел.
Подробный пример. Сымитируем градиент модели в миллион весов. Обычный пакет даёт мелкие градиенты с нормой около 0,5. В «плохом» пакете сотня весов получила градиент 50. Порог обрезки — 1,0.
import numpy as np
rng = np.random.default_rng(1)
def clip(g, max_norm=1.0):
n = np.linalg.norm(g) # норма всего градиента, по всем весам сразу
return (g * (max_norm / n) if n > max_norm else g), n
normal = rng.normal(0, 0.0005, 1_000_000) # обычный шаг: миллион весов, мелкие градиенты
spike = normal.copy(); spike[:100] += 50.0 # редкий плохой пакет: сотня весов получила огромный градиент
for name, g in [("обычный пакет", normal), ("пакет со всплеском", spike)]:
c, n = clip(g)
print(f"{name}: норма до {n:.1f}, после {np.linalg.norm(c):.1f}, "
f"доля «больших» весов в шаге {np.sum(c[:100]**2)/np.sum(c**2):.3f}")
У нас этот код напечатал:
обычный пакет: норма до 0.5, после 0.5, доля «больших» весов в шаге 0.000
пакет со всплеском: норма до 500.0, после 1.0, доля «больших» весов в шаге 1.000
Обычный пакет с нормой 0,5 обрезка не тронула. У плохого пакета норма 500, и обрезка честно укоротила шаг до 1,0 — в 500 раз. Но доля этой сотни весов в шаге осталась 1,000: весь шаг по-прежнему ушёл на те же 100 весов, а остальные 999 900 практически не сдвинулись. То есть обрезка спасла от прыжка, но этот шаг всё равно потрачен на всплеск. Повтори: замени 50 на 0,05 и посмотри, когда обрезка перестаёт срабатывать.
Где обычно ошибаются.
Норма градиента (gradient norm). длина всего градиента как одного вектора; главный показатель здоровья шага.
Обрезка градиента (gradient clipping). укорачивание градиента до порога, если его норма больше порога.
Порог обрезки. наибольшая допустимая норма градиента, например 1,0.
Всплеск потери (loss spike). резкий кратковременный подскок потери посреди нормального обучения.
Контрольная точка (checkpoint). сохранённые веса, состояние оптимизатора и позиция в данных, с которых можно продолжить.
Откат (rollback). перезапуск обучения с более ранней контрольной точки.
Пропуск пакетов. отказ от обучения на пакетах данных вокруг места всплеска при повторном прогоне.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.