дорожка · 25.10.2026 · потеря и обучение

Как модель учится угадывать следующий токен: функция потерь, перплексия и шаг обучения

Всё, что умеет языковая модель, выросло из одной скромной задачи: по началу текста угадать следующий токен. Модель выдаёт вероятности для всех токенов словаря, мы смотрим, сколько она поставила на тот, что действительно идёт дальше, и чуть-чуть сдвигаем веса, чтобы в следующий раз ставила больше. Число, которое при этом уменьшают, называется функцией потерь, и его же, в другом виде, печатают в отчётах как перплексию. Разберём, откуда берётся эта формула, как читать перплексию и почему её цифры легко сравнить неправильно, как устроен шаг обучения, как по двум кривым отличить настоящее обучение от зубрёжки и какие две ошибки чаще всего портят потерю при дообучении. Примеры — крошечная модель на numpy, которая угадывает следующую букву; весь код на странице мы запускали, выводы взяты из этих запусков.

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

1 Что модель минимизирует: минус логарифм вероятности верного токена

Зачем это в работе. Кривая потерь — главный прибор при любом обучении и дообучении, от огромной модели до адаптера на тысячу примеров. Когда в логе написано «loss 2.1», надо понимать, что это за число, какой у него «нулевой уровень» и что значит его падение на 0,1. Без этого невозможно ни заметить, что обучение пошло не так, ни объяснить, почему модель ошибается уверенно, а не просто ошибается.

Напомним из дорожки о выборе слова: на каждом шаге модель выдаёт для каждого токена словаря число-оценку (logit), а функция softmax превращает эти оценки в вероятности, которые в сумме дают единицу. При обучении мы знаем, какой токен на самом деле шёл дальше в тексте. Берём вероятность, которую модель поставила именно на него, — назовём её p — и считаем потерю как минус натуральный логарифм: −ln p. Эту величину называют кросс-энтропией (cross-entropy), а в применении к одному правильному ответу — отрицательным логарифмом правдоподобия (negative log-likelihood).

Почему логарифм, а не, скажем, 1 − p. Во-первых, вероятность всего текста — это произведение вероятностей каждого токена, а логарифм превращает произведение в сумму; поэтому потерю всего текста можно считать как сумму потерь токенов и делить на их число. Во-вторых, логарифм жестоко наказывает уверенную ошибку: при p = 0,9 потеря около 0,1, при p = 0,35 около 1, а при p = 0,02 почти 4, и чем ближе p к нулю, тем быстрее потеря уходит в бесконечность. Модели невыгодно ставить почти ноль на что-либо, что может встретиться.

У потери есть естественная точка отсчёта. Если модель ничего не знает и делит вероятность поровну между V токенами, то p = 1/V и потеря равна ln V. Для словаря в 50 тысяч токенов это около 10,8. Поэтому в начале обучения потеря обычно стоит рядом с ln размера словаря, и если она стартует сильно выше, веса инициализированы неудачно. Нижняя граница — не ноль: в настоящем тексте следующее слово часто действительно непредсказуемо, и даже идеальная модель платит за эту неопределённость.

Отличие от точности, которую считают в дорожке о проверке качества. Точность спрашивает только «угадал ли самый вероятный токен», а потеря учитывает, сколько уверенности поставлено на правильный ответ. Две модели с одинаковой точностью могут сильно различаться по потере: одна ошибается в сомнениях, другая уверенно. Потерю удобно уменьшать, потому что она гладко меняется при малом сдвиге весов, а точность меняется скачками.

Подробный пример. Словарь из пяти токенов, правильный — номер 2. Сравним три ответа модели: уверенно верный, колеблющийся и уверенно неверный, — и две точки отсчёта для равномерного угадывания.

import numpy as np
# правильный следующий токен — номер 2 из пяти вариантов
cases = {"уверенно верно":   [0.02, 0.03, 0.90, 0.03, 0.02],
         "колеблется":       [0.10, 0.30, 0.35, 0.20, 0.05],
         "уверенно неверно": [0.01, 0.95, 0.02, 0.01, 0.01]}
for name, p in cases.items():
    print(f"{name:17s} p(верного)={p[2]:.2f}  потеря=-ln p={-np.log(p[2]):.3f}")
print("равномерно по 5:     ", round(np.log(5), 3))
print("равномерно по 50000: ", round(np.log(50000), 3))

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

уверенно верно    p(верного)=0.90  потеря=-ln p=0.105
колеблется        p(верного)=0.35  потеря=-ln p=1.050
уверенно неверно  p(верного)=0.02  потеря=-ln p=3.912
равномерно по 5:      1.609
равномерно по 50000:  10.82

Колеблющийся ответ, где верный токен всё же самый вероятный, стоит 1,05; уверенный промах — 3,91, почти в четыре раза дороже. Равномерное угадывание из пяти даёт 1,609: значит, модель с потерей выше этого уровня на таком словаре хуже простого подбрасывания кубика. А 10,82 — это ориентир для словаря в 50 тысяч, с которого начинается кривая обучения настоящей модели.

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

  • Сравнивают потери, посчитанные с разным основанием логарифма. Фреймворки обычно используют натуральный логарифм (наты), а в статьях о сжатии и в некоторых отчётах пишут биты; одно переводится в другое делением на ln 2 ≈ 0,693.
  • Ждут, что потеря дойдёт до нуля. На настоящих текстах ноль на обучающих данных означает зубрёжку, а не мастерство (четвёртая ступень).
  • Путают потерю с точностью и радуются, что точность не изменилась, хотя потеря выросла: модель стала увереннее ошибаться, и при случайной выборке слов это проявится.

Функция потерь (loss). число, которое показывает, насколько плохо модель предсказала правильный ответ; обучение его уменьшает.

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

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

Softmax. функция, превращающая набор оценок в вероятности, которые в сумме дают единицу.

Правдоподобие (likelihood). вероятность, которую модель приписывает настоящему тексту.

Нат и бит. единицы потери при натуральном и двоичном логарифме; бит = нат, делённый на ln 2.

ln V. потеря равномерного угадывания из V вариантов, естественный стартовый уровень.

2 Перплексия: «из скольких вариантов модель выбирает» и почему её легко сравнить неправильно

Зачем это в работе. Перплексию печатают в статьях о новых моделях, в отчётах о квантовании (как в дорожке о квантовании) и в сравнениях дообученных вариантов. Это та же потеря, только в другой шкале. Нужно уметь переводить одно в другое и, главное, знать условие, без которого две перплексии сравнивать нельзя: одинаковые тексты и одинаковый способ резать их на токены.

Определение: перплексия (perplexity) — это e в степени средней потери на токен. Если средняя потеря равна ln 5, перплексия равна 5. Отсюда наглядный смысл: модель в среднем так же неуверенна, как если бы честно выбирала из 5 равновероятных вариантов. Перплексия 1 означает полную уверенность и всегда правильный ответ, перплексия, равная размеру словаря, — полное незнание.

Шкала нелинейная. Падение потери на 0,1 нат уменьшает перплексию примерно на 10 процентов при любом исходном уровне, потому что e^(−0,1) ≈ 0,905. Поэтому разница «перплексия 6,0 против 6,2» и «20 против 20,7» означает одинаковое улучшение потери. Сравнивать удобнее потерю или отношение перплексий, а не их разность.

Главная ловушка — нормировка. Перплексия считается «на токен», а токены у разных моделей разные, о чём шла речь в дорожке о токенах. Общая потеря на один и тот же текст — сумма по всем токенам — не зависит от того, как мы её поделим, но если модель режет текст на более крупные куски, токенов меньше и потеря на каждый больше. Модель с крупными токенами получит перплексию хуже, хотя предсказывает текст не хуже. Поэтому для сравнения моделей с разными токенизаторами потерю делят не на число токенов, а на число байтов или символов текста: получают биты на байт (bits per byte). Такую единицу использовали, например, авторы набора данных The Pile (Gao и соавторы, 2020).

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

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

import numpy as np
TRAIN = ("кот сидел на окне и смотрел на улицу. на улице шёл дождь, и кот не хотел выходить. "
         "хозяйка налила коту молока, и кот пошёл на кухню. на кухне было тепло и сухо. "
         "дождь шёл весь день, а кот спал на окне и слушал, как вода стучит по стеклу. ")
VALID = "вечером дождь кончился, и кот вышел на улицу. на улице было мокро и тихо. "
chars = sorted(set(TRAIN + VALID))
idx = {c: i for i, c in enumerate(chars)}
V = len(chars)
def ids(text): return np.array([idx[c] for c in text])
def pairs(text):
    t = ids(text); return t[:-1], t[1:]   # вход и правильный следующий символ
def softmax(z):
    z = z - z.max(axis=-1, keepdims=True); e = np.exp(z); return e / e.sum(axis=-1, keepdims=True)
def loss(W, text):
    x, y = pairs(text); p = softmax(W[x]); return -np.log(p[np.arange(len(y)), y]).mean()
import numpy as np
from common import *
# модель пар символов: считаем, какой символ за каким шёл в обучающем тексте (+1, чтобы не было нулей)
counts = np.ones((V, V))
x, y = pairs(TRAIN); np.add.at(counts, (x, y), 1)
W = np.log(counts / counts.sum(1, keepdims=True))
uni = np.ones(V); np.add.at(uni, ids(TRAIN), 1); Wu = np.tile(np.log(uni / uni.sum()), (V, 1))
for name, M in [("частоты символов", Wu), ("пары символов", W)]:
    L = loss(M, VALID)
    print(f"{name:17s} потеря {L:.3f} нат/символ, перплексия {np.exp(L):5.2f}, {L/np.log(2):.2f} бит/символ")
L = loss(W, VALID); n_chars = len(VALID) - 1; n_words = len(VALID.split())
total = L * n_chars
print(f"всего {total:.1f} нат на {n_chars} символов и {n_words} слов")
print(f"перплексия на символ {np.exp(total/n_chars):.2f}, на слово {np.exp(total/n_words):.0f}")

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

частоты символов  потеря 3.086 нат/символ, перплексия 21.90, 4.45 бит/символ
пары символов     потеря 2.754 нат/символ, перплексия 15.71, 3.97 бит/символ
всего 201.1 нат на 73 символов и 14 слов
перплексия на символ 15.71, на слово 1727766

Знание пар букв снизило перплексию с 21,9 до 15,7 — модель стала выбирать как бы из 16 вариантов вместо 22. Теперь последние строки: одна и та же модель, одна и та же общая потеря 201,1 ната, но на символ перплексия 15,7, а на слово — около 1,7 миллиона. Ничего в предсказаниях не поменялось, поменялся только знаменатель. Именно так выглядит неправильное сравнение моделей с разными токенизаторами, только там разница в разы, а не в сотни тысяч раз, и её легче не заметить.

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

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

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

Нормировка. на что делят общую потерю текста: на токены, символы, байты или слова.

Биты на байт (bits per byte). общая потеря в битах, делённая на длину текста в байтах; не зависит от токенизатора.

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

Модель пар символов (bigram model). простейшая модель, предсказывающая следующий символ только по предыдущему.

Сглаживание. прибавка к счётчикам, чтобы ни одно продолжение не получило нулевую вероятность и бесконечную потерю.

3 Градиент и шаг обучения: как потеря двигает веса

Зачем это в работе. Самая частая настройка при дообучении — шаг обучения (learning rate), и самая частая поломка — неудачный шаг: потеря стоит на месте, уходит в бесконечность или становится «не числом» (NaN). Если понимать, что именно делает один шаг обучения и откуда берётся направление, по форме кривой видно, что поправить, и не приходится перебирать настройки вслепую.

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

Для последнего слоя у кросс-энтропии с softmax градиент получается удивительно простым: для каждого токена словаря это его вероятность минус единица, если токен правильный, и минус ноль, если нет. То есть модель тянут поднять оценку правильного токена ровно на столько, сколько вероятности ей не хватило, и опустить каждый неправильный на столько, сколько вероятности на него ушло. Уверенный промах даёт большой градиент, почти верный ответ — почти нулевой.

Ограничение — размер шага. Градиент описывает потерю только рядом с текущей точкой. Слишком маленький шаг — обучение идёт, но очень медленно. Слишком большой — веса перескакивают яму, где потеря мала, оказываются там, где она больше, и следующий градиент ещё больше; потеря скачет или растёт. В настоящих моделях вместо простого вычитания используют оптимизатор Adam (Kingma и Ba, 2014) и его вариант AdamW: они подстраивают размер шага для каждого веса по истории его градиентов. Шаг обучения обычно сначала плавно поднимают (разогрев, warmup), а к концу уменьшают — но сама логика «сдвинуть против градиента» остаётся.

Отличие от выбора слова при генерации. Температура и top-p из дорожки о выборе слова меняют только то, как из готовых вероятностей выбирается токен, веса при этом не трогаются. Шаг обучения, наоборот, меняет сами веса и поэтому меняет вероятности навсегда.

Подробный пример. Модель пар символов теперь не считает частоты, а учится: у неё таблица оценок размером V×V, и мы двигаем её против градиента. Сначала проверим формулу «вероятность минус единица» численно: чуть сдвинем один вес в обе стороны и посмотрим, как изменилась потеря. Потом запустим обучение с тремя шагами: 1, 30 и 3000.

import numpy as np
from common import *
rng = np.random.default_rng(0)
x, y = pairs(TRAIN)
def grad(W):
    p = softmax(W[x]); p[np.arange(len(y)), y] -= 1      # p − (1 у верного)
    G = np.zeros_like(W); np.add.at(G, x, p); return G / len(y)
# проверка формулы численно: сдвигаем одно число на 1e-5
W = rng.normal(0, 0.1, (V, V)); i, j = x[3], y[3]
E = np.zeros_like(W); E[i, j] = 1e-5
print("формула:", round(grad(W)[i, j], 6), " численно:", round((loss(W + E, TRAIN) - loss(W - E, TRAIN)) / 2e-5, 6))
for lr in [1, 30, 3000]:
    W = np.zeros((V, V)); hist = []
    for step in range(301):
        if step in (0, 10, 100, 300): hist.append(f"{loss(W, TRAIN):.3f}")
        W -= lr * grad(W)
    print(f"шаг обучения {lr:5}: потеря на шагах 0/10/100/300 = {' / '.join(hist)}")

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

формула: -0.022352  численно: -0.022352
шаг обучения     1: потеря на шагах 0/10/100/300 = 3.434 / 3.306 / 2.525 / 1.978
шаг обучения    30: потеря на шагах 0/10/100/300 = 3.434 / 1.965 / 1.519 / 1.494
шаг обучения  3000: потеря на шагах 0/10/100/300 = 3.434 / 46.726 / 97.728 / 80.548

Формула и численная проверка совпали до шестого знака — так проверяют любой самописный градиент. Старт у всех запусков 3,434: это ln размера словаря нашего примера, ровно та точка отсчёта, о которой говорила первая ступень. С шагом 1 потеря за 300 шагов дошла только до 1,978 и всё ещё падает. С шагом 30 уже к десятому шагу 1,965, а к трёхсотому 1,494. С шагом 3000 потеря за десять шагов выросла до 46,7 и дальше скачет: это и есть «разлетевшееся» обучение, которое в настоящей модели обычно заканчивается NaN.

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

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

Градиент (gradient). для каждого веса — насколько и в какую сторону изменится потеря при его малом увеличении.

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

Градиентный спуск (gradient descent). повторение шагов «вычесть градиент, умноженный на шаг».

Обратный проход (backpropagation). способ посчитать градиенты всех слоёв за один проход от потери назад.

Оптимизатор Adam / AdamW. правило шага, подстраивающее размер сдвига для каждого веса по истории его градиентов.

Разогрев (warmup). плавное увеличение шага обучения в первые шаги, чтобы не разнести веса в самом начале.

NaN. «не число»: результат переполнения, после которого обучение обычно уже не спасти.

4 Обучение или зубрёжка: обучающая и проверочная потеря

Зачем это в работе. При дообучении на собственных данных, о котором шла речь в дорожке о дообучении, данных почти всегда мало, и модель легко их заучивает. Потеря на обучающих примерах при этом падает красиво, а на новых запросах модель становится хуже. Единственный надёжный способ это заметить — держать отдельные примеры, на которых не учат, и смотреть на две кривые сразу.

Устройство. Данные делят на обучающую часть и проверочную (validation). Обучение видит только первую, а проверочную потерю периодически считают без изменения весов. Пока модель выучивает общие закономерности, падают обе кривые. Когда закономерности исчерпаны, модель начинает подстраиваться под случайные особенности обучающих примеров: обучающая потеря продолжает падать или стоит, а проверочная разворачивается вверх. Этот разворот и называют переобучением (overfitting).

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

Ограничение у проверки: проверочная часть должна быть похожа на то, что модель встретит в работе, и не должна пересекаться с обучающей. Если одинаковые или почти одинаковые примеры попали в обе части, проверочная потеря будет такой же оптимистичной, как обучающая. Отличие от проверочного набора из дорожки о качестве: там оценивают готовые ответы по задачам, здесь следят за потерей во время обучения; нужны оба.

Подробный пример. Учим ту же модель пар символов с шагом 30 очень долго — 20 тысяч шагов — на нескольких предложениях и следим за потерей на проверочной фразе, которой в обучении не было. Затем повторяем то же со штрафом за большие веса 0,003.

import numpy as np
from common import *
x, y = pairs(TRAIN)
def grad(W, wd):
    p = softmax(W[x]); p[np.arange(len(y)), y] -= 1
    G = np.zeros_like(W); np.add.at(G, x, p); return G / len(y) + wd * W
for wd in [0.0, 0.003]:
    W = np.zeros((V, V)); best = (9, 0); rows = []
    for step in range(20001):
        if step in (0, 300, 1000, 3000, 10000, 20000):
            rows.append(f"{step:>5}: обуч {loss(W, TRAIN):.3f} пров {loss(W, VALID):.3f}")
        v = loss(W, VALID)
        if v < best[0]: best = (v, step)
        W -= 30 * grad(W, wd)
    print(f"штраф за большие веса {wd}:"); print("\n".join("  " + r for r in rows))
    print(f"  лучшая проверочная потеря {best[0]:.3f} на шаге {best[1]}")

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

штраф за большие веса 0.0:
      0: обуч 3.434 пров 3.434
    300: обуч 1.494 пров 2.878
   1000: обуч 1.487 пров 3.166
   3000: обуч 1.485 пров 3.424
  10000: обуч 1.484 пров 3.706
  20000: обуч 1.484 пров 3.868
  лучшая проверочная потеря 2.372 на шаге 23
штраф за большие веса 0.003:
      0: обуч 3.434 пров 3.434
    300: обуч 2.082 пров 2.511
   1000: обуч 2.082 пров 2.511
   3000: обуч 2.082 пров 2.511
  10000: обуч 2.082 пров 2.511
  20000: обуч 2.082 пров 2.511
  лучшая проверочная потеря 2.511 на шаге 293

Без штрафа обучающая потеря быстро опустилась до 1,49 и почти не меняется, а проверочная лучше всего была уже на 23-м шаге (2,372) и потом росла до 3,868 — выше стартовых 3,434, то есть на новой фразе модель стала хуже, чем ничего не знающая. Причина видна по механизму: пары букв, которых в обучающем тексте не было, модель продолжает «закапывать» всё глубже, а в проверочной фразе они встречаются, и каждая стоит всё дороже. Со штрафом обучающая потеря выше (2,082), зато проверочная стабильно держится на 2,511 и не уползает. Ранняя остановка на 23-м шаге дала бы ещё лучше — но только потому, что мы смотрели на проверочную кривую.

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

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

Проверочная потеря (validation loss). потеря на примерах, которые модель не видит при обучении.

Переобучение (overfitting). модель подстраивается под случайные особенности обучающих примеров и хуже работает на новых.

Ранняя остановка (early stopping). сохранение весов в момент лучшей проверочной потери и прекращение обучения.

Штраф за большие веса (weight decay). на каждом шаге веса немного тянут к нулю, ограничивая излишнюю уверенность.

Эпоха (epoch). один полный проход по всем обучающим данным.

Утечка между частями. одинаковые или почти одинаковые примеры в обучающей и проверочной частях.

5 Потеря при дообучении: сдвиг на один токен и маска вопроса

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

Сдвиг на один. Модель на позиции t должна предсказывать токен t+1. Поэтому цели — это тот же текст, сдвинутый на одну позицию влево: входы — все токены, кроме последнего, цели — все, кроме первого. В библиотеке Hugging Face Transformers для моделей, пишущих слева направо, в поле labels обычно кладут тот же список токенов, что и на вход, а сдвиг модель делает внутри себя. Если сдвинуть ещё и вручную, модель будет учиться предсказывать токен через один; если не сдвинуть нигде, она будет учиться повторять текущий токен — задача, которую маска будущего не запрещает, но которая бесполезна.

Маска вопроса. В паре «вопрос — ответ» нам обычно не нужно, чтобы модель училась писать вопросы пользователя; нужно, чтобы она училась отвечать. Поэтому целям на позициях вопроса ставят особое значение, которое функция потерь пропускает. В PyTorch у функции кросс-энтропии для этого есть параметр ignore_index, и по умолчанию он равен −100; библиотеки дообучения пользуются именно этим числом. Потеря тогда усредняется только по токенам ответа.

Ограничение и следствие: от маски зависит не только чему учат, но и само число в логе. Потеря только по ответу и потеря по всему тексту — разные величины, и при смене способа маскирования кривые нельзя сравнивать с прошлыми запусками. Ещё одна тонкость — усреднение: если среднее считать отдельно по каждому примеру, а потом между примерами, короткие ответы получают больший вес, чем при общем усреднении по всем токенам порции. Отличие от маски будущего: та запрещает токену смотреть вправо при вычислении внимания, а маска вопроса ничего не запрещает видеть — модель читает вопрос полностью, просто за его предсказание не начисляется потеря.

Подробный пример. Возьмём модель пар символов из второй ступени и пару «вопрос, что делал кот. ответ, » + «кот спал на окне.». Посчитаем три числа: потерю по всему тексту с правильным сдвигом, потерю только по ответу, где цели вопроса заменены на −100, и потерю при забытом сдвиге, когда целью служит тот же символ.

import numpy as np
from common import *
counts = np.ones((V, V)); x, y = pairs(TRAIN); np.add.at(counts, (x, y), 1)
W = np.log(counts / counts.sum(1, keepdims=True))
prompt, answer = "вопрос, что делал кот. ответ, ", "кот спал на окне."
text = prompt + answer
t = ids(text)
logp = np.log(softmax(W[t[:-1]]))
right = -logp[np.arange(len(t) - 1), t[1:]]          # верно: цель — следующий символ
wrong = -logp[np.arange(len(t) - 1), t[:-1]]         # ошибка: цель — тот же символ
labels = t[1:].copy(); labels[:len(prompt) - 1] = -100  # вопрос не учим, как ignore_index
keep = labels != -100
print(f"символов-целей всего {len(labels)}, из них в ответе {keep.sum()}")
print(f"потеря по всему тексту      {right.mean():.3f}")
print(f"потеря только по ответу     {right[keep].mean():.3f}")
print(f"без сдвига на один символ   {wrong.mean():.3f}")

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

символов-целей всего 46, из них в ответе 17
потеря по всему тексту      2.739
потеря только по ответу     2.367
без сдвига на один символ   3.858

Из 46 целей только 17 принадлежат ответу — в настоящих диалогах с длинным системным промптом доля ответа бывает ещё меньше, и без маски большая часть сигнала уходила бы на заучивание вопросов. Потеря по ответу (2,367) отличается от потери по всему тексту (2,739), хотя модель одна и та же: вот почему кривые с разной маской нельзя класть на один график. Забытый сдвиг даёт 3,858 — заметно хуже, но не катастрофа, и в обучении такую ошибку легко принять за «просто трудные данные». Признак, по которому её ловят: при правильной разметке потеря на старте дообучения готовой модели обычно невысокая, ведь модель уже умеет продолжать текст, а при сломанном сдвиге она стартует необъяснимо высоко.

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

  • Сдвигают цели вручную, когда модель уже сдвигает их сама, или наоборот. Перед обучением стоит прогнать один пример и убедиться, что стартовая потеря правдоподобна.
  • Забывают замаскировать системный промпт и вопрос. Модель тратит обучение на повторение служебного текста, и потеря выглядит лучше, чем качество ответов.
  • Маскируют вместе с вопросом и конечный служебный токен ответа. Тогда модель не учится заканчивать ответ и продолжает писать после него.

Сдвиг на один токен. выравнивание, при котором целью для позиции t служит токен t+1.

labels. поле с целями обучения в библиотеках Hugging Face; для моделей, пишущих слева направо, сдвиг делается внутри модели.

ignore_index. значение цели, которое функция потерь пропускает; в PyTorch по умолчанию −100.

Маска вопроса (loss masking). исключение токенов вопроса и служебного текста из подсчёта потери.

Системный промпт. служебная инструкция в начале диалога, которую при дообучении обычно маскируют.

Конечный токен (end-of-sequence). служебный токен, которым модель обозначает, что ответ закончен.

Порция примеров (batch). группа примеров, по которой считают одну среднюю потерю и делают один шаг.

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