дорожка · 03.11.2026 · выходной слой

Выходной слой языковой модели: от вектора к логитам, связанные веса и логит-линза

Последние три дорожки шли по слою трансформера снизу вверх: нормализация, полносвязный блок. Сегодня — самый верх модели: выходной слой (output layer, его ещё называют LM head — «голова» языковой модели), который превращает последний вектор в оценку для каждого из десятков тысяч токенов словаря. В нём лежит заметная часть весов, на нём чаще всего кончается память при обучении, и через него же исследователи заглядывают внутрь модели. Все примеры запускались на настоящей GPT-2 small (124 млн параметров, открытые веса OpenAI 2019 года), переписанной на numpy; выводы — из этих запусков. Остальное — формулы и опубликованные работы, и это сказано прямо.

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

1 Как последний вектор превращается в оценки токенов и почему эта матрица такая большая

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

Как это устроено. После последнего слоя вектор каждого токена размера d ещё раз нормализуют (финальная нормализация, в GPT-2 она называется ln_f) и умножают на матрицу выхода размера V×d, где V — число токенов в словаре (vocabulary size). Получается V чисел — логиты (logits): ненормированные оценки, по одной на каждый возможный следующий токен. Логит — это просто скалярное произведение вектора модели на строку матрицы, то есть мера того, насколько вектор «смотрит в сторону» этого токена. Затем softmax превращает логиты в вероятности: ez каждого логита делят на сумму ez всех логитов. Как из вероятностей выбирают слово (жадно, с температурой, с отсечением), разобрано в первой дорожке; сегодня — всё, что до softmax.

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

Почему матрица такая большая. Её размер V·d растёт линейно и по словарю, и по размеру модели, а остальная модель растёт примерно как число слоёв × d². Значит, у маленьких моделей с большим словарём выходной слой — заметная доля, а у больших — малая. Ограничение подсчёта: если вход и выход делят одну таблицу (ступень 2), матрицу считают один раз.

Чем это отличается от соседнего понятия. Таблица эмбеддингов (embedding table) на входе тоже имеет размер V×d, но работает наоборот: по номеру токена достаёт его строку, умножения нет. Выходной слой, наоборот, сравнивает вектор со всеми строками сразу. Это две разные операции над матрицей одной формы.

Подробный пример. Все примеры сегодня идут на настоящей GPT-2 small. Сначала — сама модель на numpy, около тридцати строк: она загружает веса из файла model.safetensors и токенизатор из tokenizer.json (оба лежат в открытом репозитории openai-community/gpt2 на Hugging Face) и прогоняет текст через 12 слоёв, сохраняя состояние после каждого. Функция logits — это и есть выходной слой.

# GPT-2 small на чистом numpy: веса из model.safetensors, токенизатор из tokenizer.json
import numpy as np, json
from safetensors.numpy import load_file
from tokenizers import Tokenizer
W = load_file("gpt2/model.safetensors"); tok = Tokenizer.from_file("gpt2/tokenizer.json")
W = {k.removeprefix("transformer."): v.astype(np.float32) for k, v in W.items()}
L, H, d = 12, 12, 768
def ln(x, p): m = x.mean(-1, keepdims=True); v = x.var(-1, keepdims=True); return (x-m)/np.sqrt(v+1e-5)*W[p+".weight"]+W[p+".bias"]
def gelu(x): return 0.5*x*(1+np.tanh(0.7978845608*(x+0.044715*x**3)))
def block(x, i):
    p = f"h.{i}."; T = len(x)
    q, k, v = np.split(ln(x, p+"ln_1") @ W[p+"attn.c_attn.weight"] + W[p+"attn.c_attn.bias"], 3, -1)
    q, k, v = (a.reshape(T, H, 64).transpose(1, 0, 2) for a in (q, k, v))
    s = q @ k.transpose(0, 2, 1) / 8 + np.triu(np.full((T, T), -1e9), 1)
    a = np.exp(s - s.max(-1, keepdims=True)); a /= a.sum(-1, keepdims=True)
    x = x + (a @ v).transpose(1, 0, 2).reshape(T, d) @ W[p+"attn.c_proj.weight"] + W[p+"attn.c_proj.bias"]
    h = gelu(ln(x, p+"ln_2") @ W[p+"mlp.c_fc.weight"] + W[p+"mlp.c_fc.bias"])
    return x + h @ W[p+"mlp.c_proj.weight"] + W[p+"mlp.c_proj.bias"]
def run(text):
    ids = tok.encode(text).ids; x = W["wte.weight"][ids] + W["wpe.weight"][:len(ids)]
    states = [x]
    for i in range(L): x = block(x, i); states.append(x)
    return ids, states
def logits(x): return ln(x, "ln_f") @ W["wte.weight"].T   # выходной слой = та же таблица эмбеддингов
def dec(i): return repr(tok.decode([int(i)]))

Теперь посчитаем долю выходной матрицы в GPT-2 small по файлу весов, для сравнения — по опубликованным размерам Llama-2 7B (V = 32000, d = 4096) и Llama 3 8B (V = 128256, d = 4096), и проверим, что модель на numpy работает.

from gpt2np import *
names = sorted(W); print("тензоров в файле:", len(names), "| есть отдельный lm_head:", any("lm_head" in n for n in names))
mask = [n for n in W if n.split(".")[-2:] == ["attn", "bias"]]  # это причинная маска 1024×1024, а не обучаемые веса
total = sum(v.size for n, v in W.items() if n not in mask); wte = W["wte.weight"]
print("таблица эмбеддингов", wte.shape, f"= {wte.size/1e6:.1f} млн из {total/1e6:.1f} млн ({wte.size/total:.0%})")
for name, V, dd, tied, all_ in [("GPT-2 small", 50257, 768, True, 124.4e6), ("Llama-2 7B", 32000, 4096, False, 6.74e9), ("Llama 3 8B", 128256, 4096, False, 8.03e9)]:
    out = V*dd; print(f"{name:12s} V={V:6d} d={dd}: матрица выхода {out/1e6:6.1f} млн, связана с входом: {tied}, вход+выход = {(out if tied else 2*out)/all_:.1%} модели")
ids, st = run("The capital of France is")
lg = logits(st[-1][-1]); top = np.argsort(-lg)[:5]
print("логиты последней позиции:", lg.shape, "| топ-5:", [dec(t) for t in top])

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

тензоров в файле: 160 | есть отдельный lm_head: False
таблица эмбеддингов (50257, 768) = 38.6 млн из 124.4 млн (31%)
GPT-2 small  V= 50257 d=768: матрица выхода   38.6 млн, связана с входом: True, вход+выход = 31.0% модели
Llama-2 7B   V= 32000 d=4096: матрица выхода  131.1 млн, связана с входом: False, вход+выход = 3.9% модели
Llama 3 8B   V=128256 d=4096: матрица выхода  525.3 млн, связана с входом: False, вход+выход = 13.1% модели
логиты последней позиции: (50257,) | топ-5: ["' the'", "' now'", "' a'", "' France'", "' Paris'"]

В файле GPT-2 нет отдельной матрицы выхода: таблица эмбеддингов 50257×768 = 38,6 млн параметров и есть выходной слой, и это 31% всей модели. У Llama-2 7B вход и выход — две отдельные матрицы по 131 млн, вместе всего 3,9% модели. У Llama 3 8B словарь вырос в четыре раза, и вход с выходом — уже 13,1%, больше миллиарда параметров. Модель на numpy работает: «Paris» в пятёрке, хотя первым GPT-2 small ставит « the» — это маленькая модель 2019 года. Обрати внимание, что в файле есть тензоры attn.bias размером 1024×1024: это маска, а не веса, и если их не исключить, получится 137 млн вместо 124. Повтори: замени текст на свой и посмотри топ-5 — так ты проверишь, что понимаешь, где кончается модель и начинается выбор слова.

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

  • Путают логиты с вероятностями. Логит может быть −100 (у GPT-2 так и есть, см. ступень 4), а вероятность при этом высокой — важна только разница между логитами.
  • Считают параметры модели по числу слоёв и забывают словарь. Для модели на 1 млрд параметров со словарём 128 тысяч одни эмбеддинги могут занять заметную долю бюджета.
  • Считают параметры по всем тензорам файла, включая буферы вроде масок, и получают неверный размер модели.

Выходной слой (output layer, LM head). Матрица V×d, которая превращает последний вектор токена в V оценок — по одной на каждый токен словаря.

Логит (logit). Ненормированная оценка токена: скалярное произведение вектора модели на строку выходной матрицы.

Размер словаря (vocabulary size, V). Число разных токенов, которые модель умеет читать и выдавать.

Softmax. Функция, которая превращает вектор логитов в вероятности: экспонента каждого, делённая на сумму экспонент.

Финальная нормализация (ln_f). Последняя нормализация перед выходным слоем, приводящая вектор к стандартному масштабу.

Таблица эмбеддингов (embedding table). Матрица на входе модели, из которой по номеру токена достают его вектор.

Safetensors. Формат файла с весами модели, который хранит только числа и не может выполнить код при загрузке.

2 Связанные веса: одна таблица на вход и выход

Зачем это в работе. В конфигурации открытых моделей есть флаг tie_word_embeddings — «связать эмбеддинги». Он решает, будет ли у модели одна таблица V×d на вход и выход или две разные. От него зависит размер файла, способ загрузки весов (при связанных весах в файле нет отдельной матрицы выхода, и загрузчик, который её ищет, падает) и то, что происходит, когда дообучаешь только выходной слой: при связанных весах ты одновременно меняешь и вход.

Как это устроено. Связанные веса (weight tying) означают, что выходная матрица — это та же таблица эмбеддингов: логит токена j равен скалярному произведению вектора модели на эмбеддинг токена j. Идею для языковых моделей описали Press и Wolf в работе «Using the Output Embedding to Improve Language Models» (2017) и одновременно Inan и соавторы (2016): обе таблицы учат похожее — токены со схожим смыслом должны иметь похожие строки, — и одна общая таблица экономит параметры и получает градиент с двух сторон. GPT-2 веса связывает, Llama-2 и Llama 3 — нет, Gemma — связывает.

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

Ограничение. Связывание выгодно, когда словарь велик относительно d: экономия — целая матрица V×d. У больших моделей экономия меньше одного-двух процентов, а свобода иметь разные таблицы ценнее, поэтому большие модели обычно веса не связывают. Чем это отличается от соседнего понятия: связывание — это общие веса внутри одной модели, а не перенос эмбеддингов из другой модели и не замораживание таблицы при дообучении.

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

from gpt2np import *
E = W["wte.weight"]; rng = np.random.default_rng(0); idx = rng.choice(len(E), 2000, replace=False)
# 1) «прямой путь»: эмбеддинг токена сразу через выходной слой, без единого блока
lg = logits(E[idx])                                   # 2000 × 50257
rank_self = (lg > lg[np.arange(2000), idx][:, None]).sum(1)   # сколько токенов выше самого себя
print("прямой путь: токен на 1-м месте у самого себя:", f"{(rank_self == 0).mean():.0%}", "| медиана места:", int(np.median(rank_self)) + 1)
# 2) то же после всей модели: часто ли модель ставит на 1-е место токен, который только что был
text = "The cat sat on the mat. The dog slept on the rug. Paris is the capital of France and Berlin is the capital of Germany."
ids, st = run(text); out = logits(st[-1]); top1 = out.argmax(-1)
print("токенов в тексте:", len(ids), "| полная модель повторяет текущий токен на 1-м месте:", int((top1 == np.array(ids)).sum()), "раз")
for t in ["cat", " cat", " Paris"]:
    i = tok.encode(t).ids[0]; s = E @ E[i]; nb = np.argsort(-s)[:4]
    print(f"соседи {t!r} по скалярному произведению эмбеддингов:", [dec(j) for j in nb])

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

прямой путь: токен на 1-м месте у самого себя: 100% | медиана места: 1
токенов в тексте: 28 | полная модель повторяет текущий токен на 1-м месте: 0 раз
соседи 'cat' по скалярному произведению эмбеддингов: ["'cat'", "'cats'", "'Cat'", "' cat'"]
соседи ' cat' по скалярному произведению эмбеддингов: ["' cat'", "'Cat'", "' cats'", "' Cat'"]
соседи ' Paris' по скалярному произведению эмбеддингов: ["' Paris'", "'Paris'", "' Copenhagen'", "'France'"]

Прямой путь в 100% случаев ставит сам токен на первое место: без слоёв GPT-2 «предсказывала» бы бесконечный повтор. Полная модель на тексте из 28 токенов не повторила текущий токен ни разу — слои эту тягу полностью перебивают. Соседи «cat» — «cats», «Cat», « cat»: таблица действительно собирает родственные токены, а у « Paris» в соседях и «France», и «Copenhagen». Обрати внимание, что «cat» без пробела и « cat» с пробелом — разные токены с разными строками. Повтори: найди соседей для слова на русском и посмотри, на сколько токенов его разрезал токенизатор GPT-2 (tok.encode(слово).ids).

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

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

Связанные веса (weight tying). Одна и та же таблица служит и входными эмбеддингами, и матрицей выходного слоя.

tie_word_embeddings. Флаг в конфигурации модели, который включает связывание входной и выходной таблиц.

Прямой путь (direct path). Путь от входного эмбеддинга к выходу по остаточному потоку, минуя вклады всех блоков.

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

Косинусная близость (cosine similarity). Скалярное произведение, делённое на длины векторов: показывает только направление.

Расширение словаря (vocabulary extension). Добавление новых токенов в готовую модель с новыми строками в таблицах.

3 Почему логиты большого словаря не влезают в память и как считают потерю по кускам

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

Как это устроено. На каждом шаге обучения батч из B последовательностей длины T даёт B·T векторов, и для каждого выходной слой считает V логитов. Тензор B×T×V хранится, пока считается функция потерь — перекрёстная энтропия (cross-entropy, подробно в дорожке про функцию потерь), а для обратного прохода нужен ещё и его градиент того же размера. Потеря на одной позиции равна logsumexp логитов (логарифм суммы экспонент) минус логит правильного токена, то есть из всех V чисел для ответа нужны лишь две величины: эта сумма и один логит.

Отсюда приём счёта по кускам. Словарь режут на куски по C токенов, для каждого куска считают логиты, обновляют «бегущий» максимум и сумму экспонент (тот же приём устойчивого онлайн-softmax, что и в быстром внимании) и, если правильный токен попал в этот кусок, запоминают его логит. Кусок выбрасывают и переходят к следующему. Одновременно в памяти лежит только B·T×C логитов. Ответ совпадает с полным расчётом до округления. В обратном проходе логиты пересчитывают кусками заново. На этом построены опубликованные реализации: «Cut Your Losses in Large-Vocabulary Language Models» (Wijmans и соавторы, Apple, 2024) и слитое ядро линейного слоя с перекрёстной энтропией в библиотеке Liger Kernel (LinkedIn, 2024).

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

Подробный пример. Сначала чистая арифметика: сколько гигабайт занимают логиты float32 (4 байта на число) для двух словарей и двух длин. Потом на случайных данных со словарём 50257 посчитаем потерю целиком и по кускам в 8192 токена и сравним.

import numpy as np
# 1) сколько памяти занимают логиты одного шага обучения (только арифметика)
for name, V in [("GPT-2, V=50257", 50257), ("Llama 3, V=128256", 128256)]:
    for B, T in [(8, 2048), (8, 8192)]:
        print(f"{name:18s} батч {B}×{T}: логиты в float32 = {B*T*V*4/2**30:5.1f} ГиБ")
# 2) потеря по кускам словаря даёт то же число, что и по всему словарю сразу
rng = np.random.default_rng(1); T, d, V = 256, 64, 50257
h = rng.standard_normal((T, d)).astype(np.float32); Wout = (rng.standard_normal((V, d)) * 0.1).astype(np.float32)
y = rng.integers(0, V, T)
full = h @ Wout.T; m = full.max(1)
loss_full = (m + np.log(np.exp(full - m[:, None]).sum(1)) - full[np.arange(T), y]).mean()
run_max = np.full(T, -np.inf, np.float32); run_sum = np.zeros(T, np.float32); target = np.zeros(T, np.float32)
C = 8192
for s in range(0, V, C):                       # в памяти одновременно только T×C логитов
    z = h @ Wout[s:s+C].T
    new_max = np.maximum(run_max, z.max(1))
    run_sum = run_sum * np.exp(run_max - new_max) + np.exp(z - new_max[:, None]).sum(1); run_max = new_max
    hit = (y >= s) & (y < s + C); target[hit] = z[hit, y[hit] - s]
loss_chunk = (run_max + np.log(run_sum) - target).mean()
print(f"потеря целиком {loss_full:.5f} | по кускам {loss_chunk:.5f} | самый большой временный массив: {T*V*4/2**20:.1f} МиБ против {T*C*4/2**20:.1f} МиБ")

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

GPT-2, V=50257     батч 8×2048: логиты в float32 =   3.1 ГиБ
GPT-2, V=50257     батч 8×8192: логиты в float32 =  12.3 ГиБ
Llama 3, V=128256  батч 8×2048: логиты в float32 =   7.8 ГиБ
Llama 3, V=128256  батч 8×8192: логиты в float32 =  31.3 ГиБ
потеря целиком 11.15024 | по кускам 11.15024 | самый большой временный массив: 49.1 МиБ против 8.0 МиБ

Для словаря Llama 3 и батча 8×8192 одни логиты занимают 31,3 ГиБ, и ещё столько же нужно под их градиент, а это больше всей памяти многих видеокарт. Потеря по кускам совпала с полной до пятого знака (11,15024), а самый большой временный массив уменьшился с 49,1 до 8,0 МиБ — ровно в V/C ≈ 6 раз. Число 11,15 близко к ln 50257 ≈ 10,8, как и должно быть для случайной модели, которая ничего не знает. Повтори: поменяй C на 1000 и на 50257 и убедись, что ответ не меняется, а размер временного массива меняется.

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

  • Хранят логиты в 16-битном формате, чтобы сэкономить память, и считают по ним softmax: при большом словаре сумма экспонент теряет точность. Потерю принято считать в float32, даже если всё остальное в bfloat16.
  • Считают логиты для всех позиций при генерации текста, хотя нужна только последняя; на длинном запросе это лишние гигабайты.
  • Видят нехватку памяти и сразу режут длину последовательности, не проверив, какой тензор на самом деле самый большой.

Перекрёстная энтропия (cross-entropy). Потеря на позиции: минус логарифм вероятности, которую модель дала правильному токену.

Logsumexp. Логарифм суммы экспонент всех логитов; знаменатель softmax в логарифмической форме.

Онлайн-softmax (online softmax). Приём, при котором максимум и сумму экспонент обновляют по кускам, не держа все числа сразу.

Батч (batch). Набор последовательностей, которые модель обрабатывает за один шаг обучения.

Пересчёт (recomputation). Экономия памяти: промежуточное значение не хранят, а вычисляют заново в обратном проходе.

Слитое ядро (fused kernel). Программа для видеокарты, которая делает несколько операций за один проход, не записывая промежуточный результат в память.

ГиБ и МиБ. Гибибайт — 230 байт, мебибайт — 220 байт.

4 Сдвиг логитов, z-потеря и мягкий кэп: как держат выходной слой в рамках

Зачем это в работе. В отчётах о больших моделях встречаются строки «z-loss 1e-4» и «final logit soft-capping 30». Это способы не дать логитам разрастись при долгом обучении: огромные логиты делают softmax численно хрупким, особенно в 16-битной арифметике, и обучение может «взорваться». Когда запускаешь такую модель у себя, кэп обязан стоять и при выводе, иначе распределение будет не тем, на котором модель училась.

Как это устроено. Softmax не меняется, если ко всем логитам прибавить одно и то же число: оно сокращается в числителе и знаменателе. Значит, у модели есть «бесплатное» направление, по которому логиты могут уплывать сколько угодно, не меняя предсказаний, и обучение его никак не держит. Z-потеря (z-loss) добавляет к основной потере маленький штраф, пропорциональный квадрату logsumexp: в отчёте о PaLM (Chowdhery и соавторы, 2022) коэффициент 10−4, и цель там описана так — держать logsumexp около нуля ради устойчивости. На вероятности она не влияет, только прижимает общий уровень логитов.

Мягкий кэп (soft-capping) действует иначе: каждый логит z заменяют на c·tanh(z/c). Для небольших z это почти z, а по мере роста значение плавно упирается в c и никогда его не превышает. Порядок токенов сохраняется, потому что tanh монотонна, но разница между очень большими логитами сжимается, и модель не может стать бесконечно уверенной. В отчёте о Gemma 2 (Google DeepMind, 2024) кэп 30,0 стоит на финальных логитах и 50,0 — на оценках внимания.

Чем они отличаются. Z-потеря — штраф при обучении, при выводе её нет. Кэп — часть формулы модели: он есть и при обучении, и при выводе. И то, и другое — не температура: температура при выборе слова делит все логиты на одно число по желанию пользователя, а кэп сжимает только большие и задан самой моделью.

Подробный пример. GPT-2 обучали без z-потери и без кэпа, и на ней хорошо видно оба эффекта. Посмотрим на её логиты, сдвинем их на разные числа и проверим, что вероятность « Paris» не меняется, а z-штраф меняется. Затем посмотрим, как кэп 30 сжимает ряд чисел, и что будет, если надеть кэп на модель, которую с ним не обучали.

from gpt2np import *
def softcap(z, c): return c * np.tanh(z / c)
def lse(z): return z.max() + np.log(np.exp(z - z.max()).sum())
def p_of(z, word): return np.exp(z[tok.encode(word).ids[0]] - lse(z))
ids, st = run("The capital of France is"); z = logits(st[-1][-1])
print(f"GPT-2: логиты от {z.min():.1f} до {z.max():.1f}, logsumexp {lse(z):.2f}, p(' Paris') = {p_of(z, ' Paris'):.4f}")
# 1) сдвиг всех логитов на одно число не меняет вероятности, но меняет logsumexp — его и штрафует z-потеря
for shift in [0, 97.78, 200]:
    zz = z + shift
    print(f"сдвиг {shift:6.2f}: p(' Paris') = {p_of(zz, ' Paris'):.4f} | logsumexp {lse(zz):7.2f} | z-потеря 1e-4·lse² = {1e-4*lse(zz)**2:.4f}")
# 2) мягкий кэп сохраняет порядок, но сжимает разницу между логитами у края
a = np.array([5., 20., 29., 40., 80.])
print("до кэпа:", a, "| после кэпа 30:", np.round(softcap(a, 30), 2))
# 3) кэп на модели, которую с ним не обучали, ломает распределение
zc = z - lse(z)   # сначала уберём общий сдвиг, чтобы кэп резал только разницу
for c in [None, 30.0, 5.0]:
    zz = zc if c is None else softcap(zc, c)
    print(f"кэп {str(c):5s}: p(' Paris') = {p_of(zz, ' Paris'):.4f} | топ-3 {[dec(t) for t in np.argsort(-zz)[:3]]}")

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

GPT-2: логиты от -129.9 до -100.2, logsumexp -97.78, p(' Paris') = 0.0322
сдвиг   0.00: p(' Paris') = 0.0322 | logsumexp  -97.78 | z-потеря 1e-4·lse² = 0.9561
сдвиг  97.78: p(' Paris') = 0.0322 | logsumexp    0.00 | z-потеря 1e-4·lse² = 0.0000
сдвиг 200.00: p(' Paris') = 0.0322 | logsumexp  102.22 | z-потеря 1e-4·lse² = 1.0449
до кэпа: [ 5. 20. 29. 40. 80.] | после кэпа 30: [ 4.95 17.48 22.42 26.1  29.71]
кэп None : p(' Paris') = 0.0322 | топ-3 ["' the'", "' now'", "' a'"]
кэп 30.0 : p(' Paris') = 0.0283 | топ-3 ["' the'", "' now'", "' a'"]
кэп 5.0  : p(' Paris') = 0.0001 | топ-3 ["' the'", "' now'", "' a'"]

У GPT-2 все логиты лежат между −130 и −100, а logsumexp равен −97,78: модель «уплыла» почти на сто единиц по бесплатному направлению, и ничего не сломалось, потому что вероятности от сдвига не зависят — p(« Paris») = 0,0322 при любом сдвиге. Z-потеря с коэффициентом 10−4 дала бы на этой точке штраф 0,956, а при сдвиге ровно на 97,78 — ноль; именно туда она и тянет. Кэп 30 оставил 5 почти как есть (4,95), а 40 и 80 превратил в 26,1 и 29,71: порядок сохранился, разница сжалась. Кэп 30 на чужой модели почти не повредил (0,0322 → 0,0283), а кэп 5 обнулил « Paris» до 0,0001. Повтори: найди наименьший кэп, при котором топ-3 и p(« Paris») меняются меньше чем на 10%.

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

  • Запускают Gemma 2 в движке вывода, который не поддерживает кэп логитов, и получают немного другое распределение; ошибок при этом нет, качество тихо падает.
  • Принимают отрицательные логиты за поломку модели. Важна только разность между логитами; абсолютный уровень без z-потери ничем не закреплён.
  • Путают мягкий кэп с жёсткой обрезкой min(z, c). Жёсткая обрезка делает все большие логиты одинаковыми и обнуляет их градиент; мягкая сохраняет порядок и градиент.

Z-потеря (z-loss). Маленький штраф за квадрат logsumexp, который удерживает общий уровень логитов около нуля.

Мягкий кэп логитов (logit soft-capping). Замена логита z на c·tanh(z/c), чтобы он плавно упирался в c.

Tanh (гиперболический тангенс). Гладкая возрастающая функция, значения которой лежат между −1 и 1.

Инвариантность к сдвигу (shift invariance). Свойство softmax: прибавление одного числа ко всем логитам не меняет вероятностей.

Численная устойчивость (numerical stability). Способность расчёта не терять точность и не переполняться на больших или маленьких числах.

Температура (temperature). Число, на которое делят все логиты при выборе слова: больше единицы — выбор разнообразнее, меньше — увереннее.

5 Логит-линза: читаем промежуточные слои тем же выходным слоем

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

Как это устроено. Остаточный поток (residual stream) — это вектор токена, к которому каждый слой прибавляет свой вклад. Значит, после любого слоя у нас вектор той же размерности, что и в конце. Логит-линза (logit lens, описана автором под ником nostalgebraist на LessWrong в 2020 году) берёт состояние после слоя k, применяет к нему финальную нормализацию и выходной слой — так, будто модель кончилась на слое k, — и смотрит, какие токены получились сверху. Ничего не обучается: используется готовый выходной слой.

Ограничение. Выходной слой обучен читать только последний слой, и нет гарантии, что ранние слои говорят «на том же языке». В GPT-2 линза работает хорошо, а в некоторых других моделях на ранних слоях даёт бессмыслицу. Поэтому предложили настраиваемую линзу (tuned lens, Belrose и соавторы, 2023): для каждого слоя обучают маленькое линейное преобразование перед выходным слоем, и ответ читается надёжнее. Чем линза отличается от зонда (probe): зонд — отдельный классификатор, обученный искать в векторе конкретное свойство, а линза задаёт один вопрос — «какой следующий токен ты бы выдал сейчас?».

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

Подробный пример. Возьмём два запроса — факт («столица Франции — город…») и счёт («один, два, три, четыре, пять,») — и после каждого второго слоя посмотрим топ-1, место ожидаемого ответа и его вероятность. Слой 0 — это просто эмбеддинг токена плюс эмбеддинг позиции.

from gpt2np import *
def lse(z): return z.max() + np.log(np.exp(z - z.max()).sum())
for text, ans in [("The capital of France is the city of", " Paris"), ("One, two, three, four, five,", " six")]:
    ids, st = run(text); a = tok.encode(ans).ids[0]
    print(f"{text!r} → ждём {ans!r}")
    for layer in [0, 2, 4, 6, 8, 10, 11, 12]:
        z = logits(st[layer][-1])                        # промежуточное состояние читаем тем же выходным слоем
        rank = int((z > z[a]).sum()) + 1
        print(f"  после слоя {layer:2d}: топ-1 {dec(z.argmax()):10s} | место {ans!r}: {rank:5d} | p = {np.exp(z[a]-lse(z)):.3f}")

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

'The capital of France is the city of' → ждём ' Paris'
  после слоя  0: топ-1 ' destro'  | место ' Paris': 21156 | p = 0.000
  после слоя  2: топ-1 ' the'     | место ' Paris':  2991 | p = 0.000
  после слоя  4: топ-1 ' the'     | место ' Paris':  1162 | p = 0.000
  после слоя  6: топ-1 ' the'     | место ' Paris':   854 | p = 0.000
  после слоя  8: топ-1 ' the'     | место ' Paris':   256 | p = 0.000
  после слоя 10: топ-1 ' Marse'   | место ' Paris':     2 | p = 0.271
  после слоя 11: топ-1 ' Marse'   | место ' Paris':     2 | p = 0.204
  после слоя 12: топ-1 ' Marse'   | место ' Paris':     2 | p = 0.111
'One, two, three, four, five,' → ждём ' six'
  после слоя  0: топ-1 ' mathemat' | место ' six': 18375 | p = 0.000
  после слоя  2: топ-1 ' which'   | место ' six':   408 | p = 0.000
  после слоя  4: топ-1 ' etc'     | место ' six':   127 | p = 0.000
  после слоя  6: топ-1 ' etc'     | место ' six':   159 | p = 0.000
  после слоя  8: топ-1 ' etc'     | место ' six':    23 | p = 0.000
  после слоя 10: топ-1 ' six'     | место ' six':     1 | p = 0.887
  после слоя 11: топ-1 ' six'     | место ' six':     1 | p = 0.952
  после слоя 12: топ-1 ' six'     | место ' six':     1 | p = 0.686

На счёте « six» поднимается с места 18375 после эмбеддингов до 127 после слоя 4, до 23 после слоя 8 и выходит на первое место после слоя 10 с вероятностью 0,887; к слою 11 она растёт до 0,952, а последний слой снижает её до 0,686 — финальный слой делает распределение осторожнее. На факте « Paris» долго в глубине (2991, 1162, 854, 256) и лишь после слоя 10 выходит на второе место, уступая « Marse» — первому токену слова «Marseille». То есть GPT-2 small «знает», что нужен французский город, но первым ставит не тот. На ранних слоях топ-1 — служебные слова вроде « the» и « etc»: модель сначала предсказывает самое частое, и лишь потом — конкретное. Повтори: возьми запрос, на который GPT-2 отвечает неверно, и найди слой, после которого правильный ответ начинает проседать.

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

  • Забывают финальную нормализацию и умножают сырой промежуточный вектор на выходную матрицу; результат выглядит как шум, и делают ложный вывод, что слой «ничего не знает».
  • Читают только первое место. Место и вероятность нужного токена по слоям говорят гораздо больше.
  • Переносят выводы линзы с GPT-2 на любую модель. Где сырая линза не работает, нужна настраиваемая, и это видно по тому, что даже на поздних слоях её ответы не похожи на финальный.

Логит-линза (logit lens). Чтение промежуточного состояния модели готовой финальной нормализацией и выходным слоем.

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

Настраиваемая линза (tuned lens). Логит-линза с обученным линейным преобразованием для каждого слоя.

Зонд (probe). Небольшой классификатор, обученный находить в векторах модели одно заданное свойство.

Интерпретируемость (interpretability). Направление исследований, которое выясняет, как модель приходит к ответу внутри.

Ранний выход (early exit). Приём ускорения: выдать ответ после части слоёв, если промежуточное предсказание уже уверенное.

Эмбеддинг позиции (position embedding). Вектор номера позиции, который GPT-2 прибавляет к эмбеддингу токена на входе.

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