Курс LLM & VLMГлавная
1Трек 1: Основы · урок 1 из 15

Что такое большая языковая модель? Общая картина

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

Время: 3–4 часа (чтение 2 часа, упражнения 1–2 часа)Уровень: Начальный · старт курсаПререквизиты: Базовый Python и школьная алгебра

Чему вы научитесь

  • Что именно вычисляет языковая модель — в виде одной формулы вероятности, и почему задача «предскажи следующий токен» даёт так много
  • Полный путь внутри LLM: текст, токены, векторы, блоки трансформера, логиты, вероятности, следующий токен — с реальными формами тензоров и покадровой визуализацией каждого вектора мини-трансформера при обучении и inference
  • Как softmax и температура превращают оценки (logits) в выбор следующего токена
  • Как модель учится (cross-entropy loss, perplexity) и почему обучение идёт параллельно, а генерация — по одному токену за шаг
  • Жизненный цикл модели, три семейства трансформеров и как одна модель решает разные задачи — от тональности до поиска по видео
  • Цифры, которые спрашивают на собеседованиях: число параметров, вычислительная стоимость обучения, память, токенов в секунду

Почему это важно

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

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

Почему такая, казалось бы, примитивная задача даёт модели столько знаний? Посмотрите, что нужно понимать, чтобы правильно продолжить каждую из этих фраз:

Начало текстаУдачное продолжениеЧто нужно знать
«Она открыла дверь и вошла …»внутрь / в комнатуГрамматика
«Столица Франции — …»ПарижФакт о мире
«17 + 25 = …»42Арифметика
«Вратарь прыгает в левый угол и отбивает …»удар / пенальтиКак устроен футбол
«Все улики указывают на дворецкого, значит убийца — …»дворецкийПростое рассуждение по сюжету

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

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

Главная формула: предсказание следующего токена

LLM работает не с отдельными буквами и не с целыми словами, а с токенами — небольшими фрагментами текста вроде keeper или the. Токеном бывает целое слово, часть слова, пробел вместе со словом или знак препинания. Как именно текст режется на токены, мы разберём в уроке 8; пока достаточно считать, что токен — это частый кусочек слова.

Представим текст как последовательность токенов \(x_1, x_2, \dots, x_T\). Для каждого возможного следующего токена модель оценивает его вероятность, опираясь на всё, что было до него:

\[ p_\theta\left(x_t \mid x_1, x_2, \dots, x_{t-1}\right) \;=\; p_\theta\left(x_t \mid x_{\lt t}\right) \tag{1.1} \]
Обозначения
\(x_t\)
токен на позиции \(t\), который мы пытаемся предсказать
\(x_{\lt t}\)
все предыдущие токены (контекст)
\(p_\theta(\cdot \mid \cdot)\)
вероятность, зависящая от весов модели \(\theta\); черта «\(\mid\)» читается «при условии»
\(\theta\)
все обучаемые веса сети — обычно миллиарды чисел

То есть на выходе модель выдаёт не одно слово, а распределение вероятностей по всему словарю. Если в словаре 128 256 токенов, на выходе получится 128 256 чисел, дающих в сумме единицу.

От вероятности одного токена к вероятности всего текста

Умея оценивать каждый следующий токен, мы автоматически получаем вероятность целого предложения. По цепному правилу теории вероятностей достаточно перемножить вероятность первого токена, вероятность второго при условии первого и так далее:

\[ p_\theta(x_1, \dots, x_T) \;=\; \prod_{t=1}^{T} p_\theta\left(x_t \mid x_{\lt t}\right) \tag{1.2} \]

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

Разбор на числах

Допустим, для фразы “The keeper saves the shot” модель выдаёт такие вероятности:

\(p(\text{keeper}\mid\text{The}) = 0.02\), \(p(\text{saves}\mid\text{The keeper}) = 0.30\), \(p(\text{the}\mid\dots) = 0.60\), \(p(\text{shot}\mid\dots) = 0.40\).

Тогда вероятность всего продолжения после “The” составит:

\[ 0.02 \times 0.30 \times 0.60 \times 0.40 = 0.00144 \]

На длине 50 токенов вместо 4 произведение упадёт примерно до \(10^{-60}\). С такими крошечными числами арифметика с плавающей точкой не справляется (происходит underflow), поэтому на практике всегда переходят к логарифмам.

Логарифм превращает произведение в сумму — формула остаётся той же самой, но перестаёт терять точность:

\[ \log p_\theta(x_1, \dots, x_T) \;=\; \sum_{t=1}^{T} \log p_\theta\left(x_t \mid x_{\lt t}\right) \tag{1.3} \]

В нашем примере:

\[ \log 0.02 + \log 0.30 + \log 0.60 + \log 0.40 = -3.91 - 1.20 - 0.51 - 0.92 = -6.54, \qquad e^{-6.54} \approx 0.00144 \]

Результат тот же, а проблемы с крошечными числами больше нет. (Везде в курсе под \(\log\) понимается натуральный логарифм.)

Генерация текста: предсказать, дописать, повторить

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

Рисунок 1. Миниатюрная языковая модель про футбол. Она знает лишь пару сотен словосочетаний, но работает по тем же правилам, что и настоящая LLM: оценивает вероятности продолжений, выбирает один токен и повторяет шаг. Можно кликнуть по любой полоске, чтобы выбрать токен вручную.
Как читать рисунок 1

В сером поле показан уже набранный текст, а мелкое число под каждым токеном — вероятность, с которой модель его выбрала. Полоски ниже показывают распределение для следующего токена. «Добавить самый вероятный» — это greedy decoding, а «Сэмплировать токен» выбирает продолжение случайно, пропорционально длине полосок. Уменьшите температуру — лидер оторвётся от остальных, текст станет предсказуемым и однообразным; увеличьте — шансы выровняются, появятся неожиданные варианты. В нижней строке складываются log-probabilities — это формула (1.3) в деле.

Внутри машины: от текста к следующему токену

Заглянем под капот. Все decoder-only LLM (GPT, Llama, Qwen, Gemma, Mistral) устроены по одной схеме. На рисунке 2 показан весь путь с реальными формами тензоров — на примере батча из 1 фразы длиной 4 токена и размерностей Llama 3 8B. А чуть ниже, на рисунке 4, мы прогоним крошечную копию того же конвейера и посмотрим на каждое число.

Рисунок 2. Путь одного предложения через decoder-only LLM. Кликайте по блокам или нажмите «Пуск». Форма (shape) показывает размер тензора на текущем этапе: \(B\) — размер батча, \(T\) — число токенов, \(d\) — размерность вектора, \(|V|\) — размер словаря.
Как читать рисунок 2

Двигайтесь слева направо. Сначала текст режется на целочисленные ID токенов. По каждому ID из матрицы embeddings достаётся строка длиной \(d = 4096\). Дальше эти векторы проходят через 32 блока трансформера: внутри каждого блока токены сначала обмениваются контекстом (attention), а потом каждый вектор обрабатывается отдельно (MLP). Для предсказания следующего слова нам нужен только финальный вектор последней позиции: он сравнивается со всеми векторами словаря, выдавая по одному logit на токен. Наконец, softmax переводит logits в вероятности, из которых выбирается следующий токен.

Этап 1: текст → ID токенов

Токенизатор разбивает строку на токены и заменяет каждый его номером из фиксированного словаря размером \(|V|\) (у Llama 3 это \(|V| = 128{,}256\)). На выходе получается обычный массив целых чисел формы \((B, T)\).

Этап 2: ID токенов → векторы (embedding)

У модели есть большая таблица \(E\), где каждому токену словаря соответствует своя строка из \(d\) чисел. Достаём строку по индексу \(x_t\) — получаем начальный вектор токена:

\[ \mathbf{h}^{(0)}_t = E[x_t], \qquad E \in \R^{|V| \times d} \tag{1.4} \]

Математически это эквивалентно умножению one-hot вектора (нули везде, единица на позиции \(x_t\)) на матрицу \(E\) — просто выборка по индексу работает на порядки быстрее. Строки \(E\) подбираются при обучении, поэтому токены из похожих контекстов оказываются рядом в векторном пространстве (урок 11). Кроме самих токенов модели нужно знать их порядок: современные LLM задают его прямо внутри attention с помощью поворотных позиционных кодировок RoPE (урок 13 и урок 14).

Этап 3: блоки трансформера

Дальше векторы проходят через \(L\) одинаковых блоков (в Llama 3 8B их \(L = 32\)). Каждый блок состоит из двух шагов:

  • Attention: каждый токен смотрит на предыдущие и подтягивает из них нужный контекст — именно так местоимение «он» связывается со словом «мяч». Этому механизму целиком посвящён трек 2.
  • MLP (небольшая полносвязная сеть): обрабатывает вектор каждого токена по отдельности — словно каждый токен «переваривает» собранную информацию.

Оба подблока не затирают текущий вектор, а прибавляют к нему свою поправку. Этот сквозной поток называют residual stream (остаточным потоком). Если собрать все векторы токенов в матрицу \(\mathbf{H}\) формы \(T \times d\), один современный блок записывается так:

\[ \mathbf{U} = \mathbf{H} + \operatorname{Attn}\big(\operatorname{Norm}(\mathbf{H})\big), \qquad \mathbf{H}' = \mathbf{U} + \operatorname{MLP}\big(\operatorname{Norm}(\mathbf{U})\big) \tag{1.5} \]

На протяжении всех блоков форма тензора \((B, T, d)\) не меняется — меняется только начинка: векторы постепенно впитывают смысл фразы целиком.

Этап 4: последний вектор превращается в оценки (logits)

Чтобы предсказать следующий токен, берём итоговый вектор последней позиции \(\mathbf{h}^{(L)}_T\) и умножаем его на выходную матрицу \(W_U\) (unembedding). Получаем по одной сырой оценке на каждый токен словаря:

\[ \mathbf{z} = \mathbf{h}^{(L)}_T \, W_U, \qquad W_U \in \R^{d \times |V|}, \qquad \mathbf{z} \in \R^{|V|} \tag{1.6} \]

Каждая оценка \(z_i\) — это скалярное произведение финального вектора на столбец токена \(i\). Чем ближе направления векторов, тем выше результат, так что \(z_i\) буквально отвечает на вопрос «насколько хорошо сюда подходит токен \(i\)?». Эти сырые оценки называют logits; они могут быть любыми вещественными числами — и положительными, и отрицательными.

Этап 5: оценки → вероятности (softmax)

Чтобы выбирать следующий токен, сырые оценки нужно перевести в вероятности — числа от 0 до 1 с суммой 1. Этим занимается softmax:

\[ p_i = \softmax(\mathbf{z})_i = \frac{e^{z_i}}{\sum_{j=1}^{|V|} e^{z_j}} \tag{1.7} \]

Почему именно такая формула? Экспонента \(e^{z}\) делает любые числа положительными и сохраняет порядок (больше logit — больше вес), а деление на сумму нормирует вектор к единице. Плюс функция гладкая, так что через неё легко прогонять градиенты при обучении. Покрутите оценки на рисунке 3 и посмотрите, как ведут себя вероятности.

Разбор на числах

Возьмём оценки \(\mathbf{z} = (2.0,\ 1.0,\ 0.1)\). Экспоненты дадут \(e^{2.0} = 7.389\), \(e^{1.0} = 2.718\), \(e^{0.1} = 1.105\) при сумме \(11.212\). После деления получаем вероятности \((0.659,\ 0.242,\ 0.099)\). Удобная интуиция: разница в 1 по logit даёт перевес по вероятности примерно в \(e \approx 2{,}7\) раза.

Температура \(\tau\) просто делит logits перед softmax:

\[ p_i(\tau) = \frac{e^{z_i/\tau}}{\sum_{j} e^{z_j/\tau}} \tag{1.8} \]

При \(\tau = 0{,}5\) наши оценки превращаются в \((4, 2, 0{,}2)\), а вероятности заостряются до \((0{,}864,\ 0{,}117,\ 0{,}019)\). При \(\tau = 2\) распределение, наоборот, сглаживается до \((0{,}502,\ 0{,}304,\ 0{,}194)\). В пределе \(\tau \to 0\) вся вероятность схлопывается в максимум (greedy), а при \(\tau \to \infty\) все токены становятся равновероятными.

ТокенLogit \(z_i\) (ползунок)\(z_i/\tau\)\(e^{z_i/\tau - m}\)\(p_i\)
Рисунок 3. Softmax с температурой в реальном времени. В столбце \(e^{z_i/\tau - m}\) используется трюк численной устойчивости: \(m\) — максимум среди \(z/\tau\), поэтому у лидера до нормировки всегда ровно 1.
Как читать рисунок 3

Подвигайте любой ползунок — вероятности пересчитаются, сохраняя сумму 1. Прибавка +1 к оценке увеличивает вероятность примерно в \(e\) раз (до перенормировки). Затем покрутите температуру: низкая отдаёт почти всю массу лидеру, высокая выравнивает шансы. Энтропия внизу показывает разброс выбора: 0 означает полную уверенность.

Этап 6: выбор следующего токена

Осталось вытянуть из распределения один конкретный токен. Greedy всегда берёт самый вероятный; sampling выбирает случайно согласно вероятностям. Более аккуратные стратегии (top-k, top-p, min-p) предварительно отрезают длинный хвост маловероятных вариантов — подробно они разобраны в уроке 79. Выбранный токен дописывается в конец входа, и весь цикл повторяется.

Каждый вектор на виду: обучение и inference рядом

У реальных моделей векторы слишком огромны, чтобы разглядывать их глазами — в Llama 3 8B один вектор состоит из 4 096 чисел. Поэтому на рисунке 4 прямо в браузере работает крошечный decoder-only трансформер, где каждый вектор показан столбцом квадратиков (по квадратику на число), а матрица \(T \times D\) — как \(T\) стоящих рядом столбцов. Схема повторяет классическую иллюстрацию из статьи Vaswani et al. (2017) и читается снизу вверх. Несмотря на миниатюрность, внутри есть всё:

  • \(T = 5\) токенов: спецтокен начала текста <s> и фраза “The keeper saves the”; каждый вектор длиной \(D = 8\), итого поток размером \(T \times D = 5 \times 8\);
  • один блок трансформера (тёмные прямоугольники) с masked multi-head attention (2 головы по \(d_k = 4\)) и MLP шириной 32, оба с обходными residual-связями;
  • словарь из \(|V| = 12\) слов, так что столбцы logits и вероятностей содержат по 12 квадратиков.

Слева показано обучение (training), справа — инференс (inference). Блок и веса у них абсолютно одинаковые, а вся разница начинается на самом верху — ради неё эта схема и сделана. Для наглядности в игрушечной модели взяты три упрощения: позиции задаются фиксированными синусоидами поверх embeddings (как в оригинальном трансформере 2017 года, тогда как Llama вращает Q и K через RoPE); нормализация стоит до подблока — pre-norm с RMSNorm, как в Llama (в статье 2017 года нормализовали после residual add); в MLP используется GELU вместо SwiGLU.

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

Обучение (Training)все позиции сразу, loss на каждой позиции

Инференс (Inference)один новый токен за шаг

Одинаково в обоих режимах: токенизатор, таблица embeddings, блок и все его веса, а также causal mask. Шаги с 1 по 10 вычисляют абсолютно одни и те же числа на обеих панелях.

Разница: при обучении подаётся настоящий текст (teacher forcing), используются все позиции, считается loss и градиенты идут вниз для обновления весов. При inference используется только последняя позиция: выбирается токен, дописывается ко входу, а для старых токенов переиспользуются сохранённые в KV-cache ключи и значения.

Рисунок 4. Обучение (слева) и инференс (справа) в крошечном decoder-only трансформере, нарисованном снизу вверх в стиле исходной статьи: \(T = 5\), \(D = 8\), один блок (\(N = 1\)) с 2 головами по \(d_k = 4\), ширина MLP 32, \(|V| = 12\). Каждый столбец — один вектор; его квадратики — настоящие числа, вычисленные прямо в браузере. Веса игрушечные, подобранные ради наглядности, а не обученная модель: все матрицы — случайные числа с фиксированным seed, округлённые до 2 знаков, и только выходная матрица \(W_U\) подобрана так, чтобы каждая позиция предсказывала осмысленное следующее слово.
Как читать рисунок 4

Нажмите «Пуск» или листайте кнопками «Шаг» и «Назад» — обе панели двигаются синхронно. Пять столбцов — пять токенов; следите, как они поднимаются через тёмные блоки и меняют цвет по мере изменения чисел. Серые линии слева — residual-пути: они проносят вход в обход подблока к кружку «+» и пульсируют в момент сложения. Врезки справа от блока раскрывают чёрные ящики для выбранного токена: query, keys и values с толщиной линий пропорциональной весам attention (бледные ключи скрыты causal mask), а также столбец MLP, расширяющийся с 8 до 32 квадратиков и сжимающийся обратно. Наверху панели расходятся. Обучение превращает каждый столбец в вероятности, обводит целевой квадратик, показывает loss под каждым столбцом, затем обратный проход (малиновый) и обновление весов. Инференс берёт только последний столбец, выбирает “ball” и возвращает его на вход; далее вычисляется только новый столбец (зелёная рамка). Кликните по кнопке токена, чипу или столбцу, чтобы переключить отслеживаемый токен; наведите или нажмите на любой столбец, чтобы увидеть его числа. Синие ссылки «→ ур.» ведут к уроку, где эта часть разобрана подробно. Паттерны attention порождены случайными весами, поэтому не ищите в них смысла.

Каждое число, шаг за шагом

Рисунок 5 раскрывает те же вычисления и показывает каждое число. Это та же модель с теми же весами, поэтому все числа совпадают с рисунком 4 (и с шагами обучения 1–10, где вычисления идентичны). Здесь матрицы нарисованы в виде таблиц чисел (строки — токены, столбцы — признаки), каждому шагу соответствует строка алгоритма слева, а панель справа подставляет реальные числа прямо в формулу. Проследите за одним токеном через все 14 шагов и проверьте пару чисел вручную.

Следить за токеном:
  1. \(\mathbf{x} \leftarrow \operatorname{tokenize}(\text{text})\) // \(T = 5\) ID токенов
  2. \(X^{\text{tok}} \leftarrow E[\mathbf{x}]\) // \(5 \times 8\)
  3. \(X \leftarrow X^{\text{tok}} + P\) // синусоидальные позиции
  4. \(H \leftarrow \operatorname{RMSNorm}(X)\)
  5. \(Q, K, V \leftarrow H W_Q,\ H W_K,\ H W_V\) // 2 головы по 4 столбца
  6. for \(h = 1, 2\): \(S^{(h)} \leftarrow Q^{(h)} K^{(h)\top} / \sqrt{4} + M_{\text{causal}}\)
  7. \(A^{(h)} \leftarrow \softmax(S^{(h)})\) // построчно
  8. \(\text{Attn} \leftarrow [A^{(1)} V^{(1)},\ A^{(2)} V^{(2)}]\, W_O\)
  9. \(X' \leftarrow X + \text{Attn}\) // residual
  10. \(U \leftarrow \operatorname{RMSNorm}(X')\, W_1\) // \(5 \times 32\)
  11. \(X'' \leftarrow X' + \operatorname{GELU}(U)\, W_2\) // residual
  12. \(Z \leftarrow \operatorname{RMSNorm}(X'')\, W_U\) // \(5 \times 12\) logits
  13. \(\mathbf{p} \leftarrow \softmax(\mathbf{z}_5)\); \(\hat{x}_6 \leftarrow \argmax_i p_i\)
  14. дописать \(\hat{x}_6\); повторить, переиспользуя кэш \(K, V\)
Рисунок 5. Полный прямой проход (forward pass) крошечного decoder-only трансформера, вычисляемый прямо в браузере: \(T = 5\) токенов, \(D = 8\), один блок, 2 головы по \(d_k = 4\), ширина MLP 32, \(|V| = 12\). Каждое число на экране — реальный результат вычисления (округлён до 2 знаков). Веса игрушечные, подобранные для читаемости: все матрицы — случайные числа с фиксированным seed, и только \(W_U\) подобрана так, чтобы каждая позиция предсказывала осмысленное следующее слово.
Как читать рисунок 5

Нажмите «Пуск» или листайте кнопками «Шаг» и «Назад». Ряд карточек сверху — цепочка форм (shape trail): размер тензора после каждого шага (клик по карточке переводит к этому шагу). Каждая таблица — одна матрица со своей формой: строки — токены, столбцы — признаки. Цветная ячейка — положительное число, фиолетовая — отрицательное; чем насыщеннее цвет, тем больше модуль. Query — синие, key — оранжевые, value — зелёные. Заштрихованные ячейки скрыты causal mask. Кликните токен в «Следить за токеном» (или любую строку таблицы), чтобы обвести его во всех матрицах; панель формул подставит числа именно этой строки. Пронумерованные строки — весь forward pass; текущая строка подсвечена. Текст внизу в одном предложении объясняет шаг и указывает урок, где он разобран подробно (см. также карту ниже). Паттерны attention порождены случайными весами, поэтому не ищите смысла в том, на какой токен смотрит голова.

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

ШагЧто происходитПодробно разобрано в
текст \(\to\) \(T = 5\) ID токеновурок 8 (подсловная токенизация), урок 9 (спецтокены вроде <s>) и урок 10 (свой токенизатор)
\(E[\mathbf{x}]\): \(5 \times 8\)урок 11 (таблица embeddings)
\(X = X^{\text{tok}} + P\)урок 13 (абсолютные и синусоидальные позиции) и урок 14 (RoPE)
\(\operatorname{RMSNorm}(X)\)урок 22 (RMSNorm, LayerNorm, pre-norm)
\(H W_Q,\ H W_K,\ H W_V\)урок 16 (query, key, value), урок 17 (математика и формы) и урок 19 (разбиение на головы)
\(Q K^\top / \sqrt{d_k}\), causal mask: \(5 \times 5\)урок 17 (зачем делить на \(\sqrt{d_k}\)) и урок 18 (causal и другие маски)
\(A = \softmax(S)\), построчноурок 17 (веса attention) и урок 2 (softmax)
\([A^{(1)} V^{(1)}, A^{(2)} V^{(2)}]\, W_O\)урок 19 (конкатенация и выходная матрица)
\(X' = X + \text{Attn}\)урок 22 (residual stream) и урок 23 (весь блок)
\(5 \times 8 \to 5 \times 32\)урок 21 (MLP и его ширина)
GELU, \(5 \times 32 \to 5 \times 8\), residualурок 21 (GELU и SwiGLU) и урок 22 (второе сложение residual)
\(Z = \operatorname{RMSNorm}(X'') W_U\): \(5 \times 12\)урок 12 (hidden states и выходной слой)
\(\softmax\) последней строки: \(|V| = 12\) вероятностейурок 12 (выходной слой), урок 2 (softmax) и урок 79 (выбор токена)
дописать токен, \(T = 6\)урок 78 (prefill и decode) и урок 80 (переиспользование K и V)
Разбор на числах: последний токен на рисунках 4 и 5

Проследим за последним токеном, “the”. На шаге 7 рисунка 5 голова 1 отдаёт наибольший вес 0,42 токену “The”, а голова 2 — 0,63 самому “the” и 0,31 токену “keeper”. На шаге 12 его logits для тройки лидеров: \(z_{\text{ball}} = 3.2938\), \(z_{\text{penalty}} = 2.4813\), \(z_{\text{shot}} = 2.1932\). Считаем softmax (формула 1.7):

\[ p_{\text{ball}} = \frac{e^{3.2938}}{\sum_{j=1}^{12} e^{z_j}} = \frac{26.95}{57.21} = 0.471 \]

Следующие два варианта: \(p_{\text{penalty}} = 0.209\) и \(p_{\text{shot}} = 0.157\), поэтому greedy decoding выбирает “ball”. При обучении “ball” — целевой токен для этой позиции, значит его loss равен \(-\log 0.471 = 0.753\); средний loss по всем пяти позициям равен 0,543. При inference (рисунок 4, справа) “ball” дописывается ко входу; вычисляется только столбец 6, и модель даёт точке “.” вероятность 0,526, а затем “The” — 0,489. Столбцы 1–5 вообще не меняются благодаря causal mask: ровно поэтому и работает KV-cache.

Реальные размеры: Llama 3 8B

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

ЧастьФормаПараметры
Таблица embeddings \(E\)\(128{,}256 \times 4{,}096\)525 M
Attention на один блок (\(W_Q, W_K, W_V, W_O\); 32 головы query, 8 голов key/value, размер головы 128)\(4096{\times}4096 + 2 \cdot 4096{\times}1024 + 4096{\times}4096\)41,9 M
MLP на один блок (SwiGLU, скрытый размер 14 336: три матрицы)\(3 \times 4{,}096 \times 14{,}336\)176,2 M
Все 32 блока\(32 \times (41.9 + 176.2)\) M6,98 B
Выходная матрица \(W_U\) (в этой модели веса с \(E\) не разделяются)\(4{,}096 \times 128{,}256\)525 M
Итого (веса нормализаций пренебрежимо малы)около 8,03 B

Как учится LLM: обучение (training)

Откуда берутся нужные веса \(\theta\)? Стартуем со случайных чисел и шаг за шагом подкручиваем их так, чтобы реальные тексты получали всё более высокую вероятность.

Разметка достаётся бесплатно

Берём любой текст. На вход подаём сам текст, а в качестве цели (target) — его же, но сдвинутый влево на один токен: позиция 1 предсказывает токен 2, позиция 2 — токен 3 и так далее. Размечать ничего руками не надо — такой подход называется самообучением (self-supervised learning).

ВходThekeepersavestheshot
Цельkeepersavestheshot.

Функция потерь: cross-entropy

На каждой позиции смотрим, какую вероятность модель выдала правильному следующему токену, берём её отрицательный логарифм и усредняем по всей последовательности. Это cross-entropy loss:

\[ \mathcal{L}(\theta) = -\frac{1}{T} \sum_{t=1}^{T} \log p_\theta\left(x_t \mid x_{\lt t}\right) \tag{1.9} \]

По сути, это формула (1.3) с минусом, поделённая на \(T\). То есть минимизация loss равносильна максимизации вероятности реальных текстов (методу максимального правдоподобия, maximum likelihood).

Разбор на числах

Если правильному токену досталась вероятность 0,9, loss на этой позиции равен \(-\log 0.9 = 0.105\). При 0,25 — уже \(1.386\), а при 0,01 — \(4.61\): уверенная ошибка штрафуется очень жёстко. До начала обучения модель со словарём \(|V| = 128{,}256\) размазывает вероятности почти равномерно по \(1/|V|\), поэтому loss стартует с \(\log 128{,}256 \approx 11.8\).

Нагляднее воспринимается perplexity — экспонента от loss:

\[ \operatorname{PPL} = e^{\mathcal{L}} \tag{1.10} \]

Loss 2,0 соответствует perplexity \(e^2 \approx 7{,}4\): интуитивно это значит, что в среднем модель колеблется примерно между семью равновероятными вариантами. Чем меньше, тем лучше — но сравнивать perplexity имеет смысл только у моделей с одинаковым токенизатором и на одном и том же тестовом корпусе.

Рисунок 6. Loss на одной позиции равен \(-\log p\): он обнуляется при полной уверенности в правильном ответе (\(p = 1\)) и уходит в бесконечность при \(p \to 0\).
Как читать рисунок 6

Слева кривая взлетает почти вертикально: подняв вероятность с \(0{,}01\) до \(0{,}1\), мы снижаем loss на 2,3 — ровно на столько же, сколько даёт скачок с 0,1 до 1. Поэтому основную работу оптимизатор тратит на самые неожиданные для модели токены. Пунктир отмечает текущее \(p\).

Обновление весов

Обратное распространение ошибки (backpropagation) считает градиент \(\nabla_\theta \mathcal{L}\) — показывает, куда сдвинуть каждый вес, чтобы уменьшить loss. После этого мы делаем небольшой шаг в нужную сторону:

\[ \theta \leftarrow \theta - \eta \, \nabla_\theta \mathcal{L}(\theta) \tag{1.11} \]

Здесь \(\eta\) — learning rate (размер шага). В реальных LLM вместо простого шага стоит оптимизатор AdamW (урок 4), но принцип тот же. Этот цикл прогоняется миллионы раз — на батчах из миллионов токенов.

Почему обучение параллельно, а генерация — нет

При обучении весь текст уже лежит перед нами, поэтому предсказания для всех позиций можно посчитать за один forward pass. Главное — не дать позициям подглядывать в будущее; для этого внутри attention ставится causal mask. Подачу настоящих предыдущих токенов (а не догадок самой модели) называют teacher forcing.

Во время генерации будущего ещё нет — модель дописывает его сама. Токен 6 зависит от токена 5, который только что сгенерирован, поэтому приходится идти строго по одному токену за шаг. Оба режима показаны на рисунке 7.

Рисунок 7. Causal mask: строка — позиция, делающая предсказание; столбец — токен, на который она может смотреть. Цветные ячейки разрешены, серые закрыты. При обучении все строки считаются за один проход; при генерации на каждом шаге добавляется одна новая строка, а предыдущие берутся из KV-cache.
Как читать рисунок 7

Строка 3 (“saves”) видит столбцы 1–3 (“The”, “keeper”, “saves”) и предсказывает “the” — заглянуть в столбец 4 ей нельзя, там ответ. При обучении все пять предсказаний и потерь считаются за один проход. Переключитесь на генерацию и кликайте «Следующий шаг»: на каждом шаге появляется одна строка и один новый токен, а ключи и значения предыдущих строк переиспользуются из кэша — именно для этого и нужен KV-cache (урок 80).

Сколько вычислений требует обучение?

Удобная прикидка: один forward pass тратит около \(2N\) операций с плавающей точкой (FLOPs) на токен, где \(N\) — число параметров (по умножению и сложению на вес), а backward pass — примерно вдвое больше. В сумме обучение обходится примерно в:

\[ C_{\text{train}} \approx 6 \, N \, D \tag{1.12} \]

где \(D\) — общее число обучающих токенов.

Разбор на числах

Модель на 8B параметров, обучаемая на 15 триллионах токенов:

\[ C \approx 6 \times (8 \times 10^{9}) \times (15 \times 10^{12}) = 7.2 \times 10^{23} \text{ FLOPs} \]

Если одна GPU реально выдаёт \(4 \times 10^{14}\) FLOP/s, это займёт

\[ \frac{7.2 \times 10^{23}}{4 \times 10^{14}} = 1.8 \times 10^{9} \text{ GPU-секунд,} \]

то есть около 500 000 GPU-часов, или примерно 3 недели на 1 000 GPU. На практике требуется ещё больше, потому что GPU никогда не загружены на 100%. (Это учебная прикидка, а не официальный отчёт.)

Как пишет LLM: инференс (inference)

Генерация делится на две фазы, и нагрузку на GPU они создают совершенно разную:

  • Prefill: модель проглатывает весь промпт за один проход (как при обучении — все позиции параллельно). На каждый прочитанный байт приходится много арифметики, поэтому фаза упирается в вычислительную мощность (compute-bound).
  • Decode: модель выдаёт по одному новому токену за шаг. Вычислений на шаге мало, но из памяти каждый раз приходится прочитывать все веса целиком — поэтому скорость упирается в пропускную способность памяти (memory-bound).
Разбор на числах: почему decode медленный

Веса модели на 8B параметров в BF16 занимают \(8 \times 10^9 \times 2 = 16\) ГБ. Пропускная способность памяти у NVIDIA L4 — около 300 ГБ/с. При batch size 1 каждый новый токен заставляет прочитать все 16 ГБ, то есть на один токен уйдёт минимум \(16 / 300 \approx 0{,}053\) с — не быстрее 19 токенов в секунду, какими бы мощными ни были тензорные ядра. Если сжать веса до 4 бит (4 ГБ), потолок вырастет до ~75 токенов/с, а на H100 (~3 350 ГБ/с) та же модель способна выдать до ~200 токенов/с. Это теоретические верхние границы: в реальности время уходит ещё на чтение KV-cache и накладные расходы рантайма.

Производительность сервинга оценивают по трём метрикам: TTFT (time to first token — задержка до первого токена, в основном prefill), TPOT (time per output token — время на каждый следующий токен, скорость decode) и throughput (суммарная пропускная способность в токенах/с по всем пользователям). Их оптимизации посвящён весь трек 5.

Жизненный цикл модели

Продуктовая LLM проходит несколько стадий — со своими данными, функцией потерь и отдельным треком в этом курсе.

1. Pretrainingтриллионы токеновnext-token loss→ базовая · Трек 3 2. SFTпары вопрос–ответloss только на ответах→ следует инструкциям 3. Предпочтения, RL«A лучше, чем B»проверяемые наградыDPO, PPO, GRPO · Трек 4 4. Оценка (Eval)бенчмарки, судьи,свой тестовый наборТрек 6 5. Servingквантизация, батч, кэшvLLM, TensorRT-LLMТрек 5 найти ошибки, дообучить
Рисунок 8. Жизненный цикл модели. После pretraining получается базовая модель, умеющая только продолжать текст. SFT и обучение на предпочтениях превращают её в ассистента. Оценка вскрывает слабые места, а serving делает работу быстрой и дешёвой.

Разницу между базовой моделью и ассистентом проще всего показать на примере. Если спросить базовую модель «Какая столица у Франции?», она вполне может дописать: «Какая столица у Германии? Какая столица у Испании?» — в интернете полно списков вопросов. Ассистент же просто ответит «Париж». Архитектура при этом не меняется — отличаются только данные на последних этапах обучения.

Три семейства трансформеров

В основе всех LLM лежат одни и те же блоки трансформера, но различается маска attention — то есть какие токены имеют право видеть друг друга. На рисунке 9 показаны три основных семейства.

Рисунок 9. Маски attention. Закрашенная ячейка на пересечении строки \(i\) и столбца \(j\) означает, что токен \(i\) может смотреть на токен \(j\).
СемействоКто кого видитЗадача обученияГде сильныПримеры
Encoder-onlyВсе видят всехВосстановление скрытых слов (masked LM)Понимание текста: классификация, embeddings для поискаBERT, RoBERTa
Decoder-onlyТолько прошлое и сам себяПредсказание следующего токенаГенерация, чат, почти все современные LLM и VLMGPT, Llama, Qwen, Gemma
Encoder–decoderEncoder — всех; decoder — прошлое + весь encoderВосстановление скрытых фрагментов; переводПреобразование входа в выход: перевод, распознавание речиT5, BART, Whisper

Почему в большом масштабе победили именно decoder-only? Одной модели и одной функции потерь хватает на всё, каждый токен текста даёт обучающий сигнал, и одна и та же сеть умеет и читать, и писать. Подробный разбор компромиссов ждёт в уроке 23.

Одна модель — множество задач

Обученная LLM — универсальный движок, к которому можно прикрутить три разных «выхода» (рисунок 10).

Входные токенытекст, фото, видео Ствол трансформераL блоков attention + MLPскрытые векторы (B, T, d) Выход 1: LM head → генерациячат, суммаризация, QA, подписи, описания видео Выход 2: пулинг векторов → один embeddingпоиск по тексту и видео, поиск дубликатов, кластеризация Выход 3: голова-классификатор → меткатональность, тема, модерация, тип действия или удара
Рисунок 10. Три способа использовать одну обученную модель. Основной ствол общий — меняется только лёгкий выходной слой.

Классификация через выбор слова-метки

Чтобы определить тональность отзыва, достаточно подать промпт вроде «Отзыв: … Тональность:» и сравнить вероятности двух слов-меток:

\[ \hat{y} = \argmax_{c \in \{\text{positive},\,\text{negative}\}} \; \log p_\theta\left(\text{word}_c \mid \text{prompt}\right) \tag{1.13} \]

Обучать ничего не нужно. Если же у вас есть размеченные данные, дешевле и обычно точнее обучить небольшую голову-классификатор поверх hidden states (урок 55 и урок 144).

Поиск (retrieval) через сравнение векторов

Усреднив финальные hidden states текста, получим один вектор \(\mathbf{e}\) (embedding). У близких по смыслу текстов векторы смотрят примерно в одну сторону, и это сходство измеряют косинусом угла между ними (cosine similarity):

\[ \cos(\mathbf{a}, \mathbf{b}) = \frac{\mathbf{a} \cdot \mathbf{b}}{\lVert \mathbf{a} \rVert \, \lVert \mathbf{b} \rVert} \tag{1.14} \]

Единица означает совпадение направлений, ноль — независимость, \(-1\) — противоположность. Поисковые системы хранят миллионы таких векторов и мгновенно находят ближайшие к запросу (урок 150 и урок 151).

Изображения и видео тоже становятся токенами

Визуально-языковая модель (VLM) режет картинку на мелкие патчи, прогоняет их через vision encoder и подставляет получившиеся векторы перед текстовыми токенами. Для самой LLM ничего не меняется — она просто читает единую последовательность:

\[ \big[\, \underbrace{\mathbf{v}_1, \dots, \mathbf{v}_m}_{\text{патчи изображения}},\; \underbrace{\mathbf{e}_1, \dots, \mathbf{e}_n}_{\text{текстовые токены}} \,\big] \tag{1.15} \]

Видео — это серия кадров, то есть цепочка таких групп патчей во времени. И тот же самый механизм предсказания следующего токена начинает описывать сцены, отвечать на вопросы по матчу или выдавать таймкоды нужных моментов.

Задача по видеоВход → выходКакой выходГде в курсе
Поиск видео по тексту (Text-to-video retrieval)«угловой удар, приводящий к голу» → ранжированные клипыEmbeddings (выход 2)Урок 208
Распознавание действийклип → “shot”, “pass”, “foul”Классификатор (выход 3) или слова-метки (выход 1)Урок 203
Поиск ключевых моментоввесь матч → время начала и конца голов и сейвовКлассификатор по сегментам или таймкоды текстомУрок 207
Видео-фингерпринтингклип → «та же трансляция, что и клип 4 127?»Специальные copy-detection embeddings (не про смысл)Урок 209
Сегментация видеоклип + клик по игроку → маска в каждом кадреОтдельный декодер масок с памятью (SAM 2)Урок 204
Вопросы по видео (Video QA)клип + «кто последним коснулся мяча?» → ответГенерация (выход 1), часто с предварительным поискомУрок 210

Псевдокод

Весь урок можно уложить в два коротких алгоритма. Прочитайте их не спеша: каждая строчка соответствует одному блоку на рисунке 2.

Алгоритм 1: один шаг обучения языковой модели
  1. вход: батч последовательностей токенов \(X \in \{1..|V|\}^{B \times (T+1)}\), веса \(\theta\), learning rate \(\eta\)
  2. \(X_{\text{in}} \leftarrow X[:, 1{:}T]\), \(\;Y \leftarrow X[:, 2{:}T{+}1]\) // цели — входы, сдвинутые на 1
  3. \(H \leftarrow E[X_{\text{in}}]\) // выборка embeddings, форма \((B, T, d)\)
  4. for \(\ell = 1\) to \(L\) do
  5. \(H \leftarrow H + \operatorname{Attn}_\ell(\operatorname{Norm}(H))\) // с causal mask: без подглядывания
  6. \(H \leftarrow H + \operatorname{MLP}_\ell(\operatorname{Norm}(H))\)
  7. \(Z \leftarrow \operatorname{Norm}(H)\, W_U\) // logits для каждой позиции, форма \((B, T, |V|)\)
  8. \(\mathcal{L} \leftarrow -\frac{1}{BT}\sum_{b,t} \log \softmax(Z_{b,t})[Y_{b,t}]\) // cross-entropy (1.9)
  9. \(g \leftarrow \nabla_\theta \mathcal{L}\) // backpropagation
  10. \(\theta \leftarrow \theta - \eta\, g\) // на практике: AdamW с clipping и расписанием LR
Алгоритм 2: генерация текста с температурой
  1. вход: токены промпта \(x_{1..n}\), температура \(\tau\), максимум новых токенов \(K\)
  2. for \(k = 1\) to \(K\) do
  3. \(\mathbf{z} \leftarrow \text{model}(x_{1..n})[\text{последняя позиция}]\) // по одному logit на токен словаря
  4. if \(\tau = 0\) then \(x_{n+1} \leftarrow \argmax_i z_i\) // greedy
  5. else \(x_{n+1} \sim \softmax(\mathbf{z}/\tau)\) // сэмплирование, формула (1.8)
  6. \(n \leftarrow n + 1\)
  7. if \(x_n\) — токен конца текста (EOS) then break
  8. return \(x_{1..n}\)

А теперь те же идеи на настоящем PyTorch. Первый блок вычисляет loss обучения со сдвигом на один токен; второй — простой цикл генерации.

import torch
import torch.nn.functional as F

torch.manual_seed(0)
V, d, T = 1000, 64, 8                      # размер словаря, ширина вектора, длина последовательности
tokens = torch.randint(0, V, (2, T + 1))   # 2 последовательности по T+1 ID токенов
x, y = tokens[:, :-1], tokens[:, 1:]       # вход и цель, сдвинутые на единицу

emb = torch.nn.Embedding(V, d)             # таблица E, формула (1.4)
unemb = torch.nn.Linear(d, V, bias=False)  # матрица W_U, формула (1.6)
h = emb(x)                                 # (2, T, d); реальная модель прогоняет здесь L блоков
logits = unemb(h)                          # (2, T, V)
loss = F.cross_entropy(logits.reshape(-1, V), y.reshape(-1))   # формула (1.9)
loss.backward()
print(round(loss.item(), 2), round(torch.exp(loss).item()))    # около 7.0 и около 1100: близко к log V и V
@torch.no_grad()
def generate(model, ids, max_new=20, temperature=1.0, eos_id=None):
    for _ in range(max_new):
        logits = model(ids)[:, -1, :]                  # logits только для следующего токена
        if temperature == 0:
            nxt = logits.argmax(dim=-1, keepdim=True)  # greedy
        else:
            probs = torch.softmax(logits / temperature, dim=-1)
            nxt = torch.multinomial(probs, num_samples=1)
        ids = torch.cat([ids, nxt], dim=1)             # дописать и повторить
        if eos_id is not None and nxt.item() == eos_id:
            break
    return ids
# Этот цикл перечитывает всю последовательность на каждом шаге. Реальные системы хранят KV-cache (урок 80).

Частые ошибки и заблуждения

  • «Токен = слово». Нет: одно слово нередко дробится на несколько токенов, причём в разных языках их число сильно отличается. И цена, и скорость, и окно контекста всегда считаются именно в токенах.
  • «Высокая вероятность = правда». Нет: модель учит, какой текст типичен, а не что соответствует фактам. Выдуманный, но гладко звучащий ответ легко набирает высокую вероятность (галлюцинация).
  • «Greedy decoding всегда лучший выбор». При greedy текст часто сваливается в зацикленные повторы. Для свободной генерации лучше сэмплирование с отсечением хвоста, а низкую температуру стоит оставлять для точных задач (математика, код, классификация).
  • «Температура 0 гарантирует 100% детерминизм». Почти, но не всегда: при батчевом сервинге микроскопические погрешности floating-point способны поменять лидера, если два logit почти совпали. [Вероятно]
  • Exposure bias. На обучении модель всегда видит правильный контекст, а при генерации — собственные, порой ошибочные токены. На длинном ответе мелкие промахи могут накапливаться.
  • Лимит контекста. Модель видит ровно последние \(T_{\max}\) токенов (например, 8 192 у Llama 3 8B) — всё, что было раньше, для неё просто пропадает (про длинный контекст см. трек 2 и трек 5).

Вопросы с собеседований

Объясните, что такое LLM, в двух предложениях.база
LLM — это decoder-only трансформер, обученный на триллионах текстовых токенов предсказывать следующий токен через минимизацию cross-entropy. Генерирует он авторегрессивно: оценивает распределение по словарю, выбирает токен, дописывает его ко входу и повторяет цикл.
Зачем переходить к логарифмам вероятностей?база
Вероятность длинного текста — произведение множества чисел меньше 1, которое быстро уходит в underflow. Логарифм превращает произведение в устойчивую сумму (формула 1.3), даёт удобный для градиентов loss, а поскольку логарифм монотонно возрастает, максимум log-likelihood совпадает с максимумом likelihood.
Чем logits отличаются от вероятностей и зачем нужен softmax?база
Logits — сырые оценки из \((-\infty, \infty)\) (результат \(\mathbf{h} W_U\)), а вероятности лежат в \([0,1]\) и дают в сумме 1. Softmax переводит первые во вторые: экспонента делает числа положительными с сохранением порядка, а деление на сумму нормирует их. Кроме того, функция гладкая и инвариантна к сдвигу всех logits на константу — отсюда трюк с вычитанием максимума.
Почему обучение параллельно по позициям, а генерация — последовательна?основной
На обучении весь текст известен заранее, поэтому с teacher forcing и causal mask все \(T\) предсказаний считаются за один forward pass. При генерации токен \(t+1\) зависит от только что выданного токена \(t\), так что шаги не распараллелить. Prefill (обработка промпта) при этом остаётся параллельным — последователен именно decode. Вернуть часть параллелизма помогает speculative decoding (урок 128).
Сколько памяти и FLOPs нужно для сервинга 8B-модели в BF16?основной
Веса: \(8\times10^9 \times 2\) байта = 16 ГБ, плюс KV-cache, растущий с длиной контекста и батчем (у Llama 3 8B в BF16 это ~128 КиБ на токен, то есть 1 ГиБ на 8 192 токена), плюс активации и накладные расходы рантайма. По вычислениям: ~\(2N = 16\) GFLOPs на токен на матричные умножения, плюс меньший вклад attention, растущий с длиной контекста.
Оцените вычислительную стоимость предобучения 8B-модели на 15T токенов.основной
По правилу \(C \approx 6ND\): \(6 \times 8\times10^9 \times 15\times10^{12}\) \(= 7.2\times10^{23}\) FLOPs (2 на forward и 4 на backward). Чтобы перевести это в GPU-часы, делим на реальную производительность одной карты (пик × утилизация MFU).
Почему decode при batch size 1 упирается в память и как это лечить?продвинутый
За шаг decode выполняется ~\(2N\) FLOPs, но приходится перекачивать ~\(2N\) байт весов в BF16 — всего ~1 FLOP на байт. Чтобы загрузить тензорные ядра GPU, нужны сотни FLOP на байт, поэтому скорость ограничена пропускной способностью памяти: время ≥ байты весов / bandwidth. Решения: батчинг (читаем веса один раз на много запросов), квантизация весов (меньше байт), speculative decoding (проверка нескольких токенов за одно чтение весов) и GQA/MLA для сжатия KV-cache.
Как работает температура и что происходит при \(\tau \to 0\) и \(\tau \to \infty\)?база
Она делит logits перед softmax (формула 1.8). Малая \(\tau\) заостряет распределение и в пределе \(\tau \to 0\) сводит его к greedy (вся масса в лидере). Большая \(\tau\) выравнивает шансы и при \(\tau \to \infty\) даёт равномерное распределение по словарю. Порядок токенов при этом не меняется — только разрыв между ними.
Когда выбирать encoder-only, а когда decoder-only?основной
Encoder-only с двунаправленным attention даёт качественные представления при малом размере и низкой задержке — это выбор для классификации, теггинга и embeddings для поиска. Decoder-only необходим для генерации, а на больших масштабах отлично решает и задачи понимания через промптинг — это стандарт для чатов и VLM. Encoder–decoder хорошо ложится на задачи «вход → выход» вроде перевода и распознавания речи.
Что такое perplexity и всегда ли меньше — лучше?основной
Perplexity равна \(e^{\mathcal{L}}\) — экспоненте от средней cross-entropy; интуитивно это число равновероятных токенов, между которыми колеблется модель. Меньше — лучше, но только при сравнении на одном тексте и с одним токенизатором. К тому же perplexity не измеряет полезность, правдивость или следование инструкциям — для чат-моделей нужны прикладные бенчмарки и судьи.
Объясните галлюцинации, опираясь только на функцию потерь обучения.продвинутый
Функция потерь поощряет вероятный текст, а не истинный. Когда нужного факта нет в весах, гладкий и правдоподобный ответ всё равно получает более высокую вероятность, чем редкое в веб-текстах «Я не знаю». А если сэмплирование на одном шаге выберет неверный токен, дальше модель начнёт логично развивать уже эту ошибку. Помогают RAG, обучение отказу от ответа и калибровка (урок 152 и урок 156).
Как использовать генеративную LLM для классификации или поиска?основной
Для классификации — сравнить вероятности слов-меток после промпта (формула 1.13) или повесить небольшую линейную голову поверх hidden states. Для поиска — свернуть hidden states в один вектор (embedding) и сравнивать косинусным сходством (формула 1.14); под эту задачу модели обычно дообучают контрастивным loss (урок 60).

Упражнения

  1. Посчитайте \(\softmax(1, 2, 3)\) вручную.
  2. Модель дала правильному токену вероятность 0,5 — чему равен loss? А если средний loss модели равен 3,0 — какая у неё perplexity?
  3. Сколько параметров лежит в таблице embeddings модели Llama 3 8B?
  4. Оцените теоретический потолок скорости decode для 8B-модели на L4 (300 ГБ/с) при batch 1 в BF16 и в 4-битной квантизации.
  5. На рисунке 1 выкрутите температуру в минимум и жмите «Добавить самый вероятный» до конца фразы, потом повторите. Почему текст выходит идентичным? Теперь попробуйте «Сэмплировать токен» при температуре 2 — что меняется?
  6. На рисунке 4 откройте шаг 6 и выберите токен <s>. Почему из его query в каждой голове всегда выходит ровно одна линия с весом 1, независимо от значений весов модели?
Ответыпроверка
1. \(e^1 = 2.718\), \(e^2 = 7.389\), \(e^3 = 20.086\), сумма \(30.193\); итого \((0.090,\ 0.245,\ 0.665)\). 2. \(-\log 0.5 = 0.693\); \(e^{3} \approx 20.1\). 3. \(128{,}256 \times 4{,}096 = 525{,}336{,}576 \approx 0.53\)B. 4. В BF16: \(300/16 \approx 19\) токенов/с; в 4-bit: \(300/4 = 75\) токенов/с (верхние границы). 5. В greedy нет случайности, так что одинаковые вероятности всегда дают один и тот же выбор. При температуре 2 шансы выравниваются, и сэмплы становятся разнообразнее, вплоть до курьёзных (“the keeper sings”). 6. По causal mask первая позиция видит только сама себя: в её softmax ровно одно слагаемое \(e^{s}/e^{s} = 1\), а остальные замаскированы нулями. Поэтому первый токен никогда не подмешивает информацию от других.

Главные выводы

  • LLM моделирует \(p_\theta(x_t \mid x_{\lt t})\): по цепному правилу этого достаточно для вероятности всего текста (1.2), а логарифмы защищают от underflow (1.3).
  • Путь внутри модели: токены → embeddings → \(L\) блоков attention + MLP поверх residual stream → последний вектор × \(W_U\) → logits → softmax → выбор токена → повтор.
  • Обучение минимизирует cross-entropy (1.9) со сдвигом целей на 1 и идёт параллельно благодаря causal mask. Perplexity равна \(e^{\mathcal{L}}\).
  • Обучение обходится примерно в \(6ND\) FLOPs; генерация — в \(2N\) FLOPs на токен, но скорость decode упирается в пропускную способность памяти.
  • Один и тот же ствол работает на генерацию, embeddings (поиск) и классификацию, а с патчами изображений или видео превращается в VLM.

Ключевые формулы

\[ p_\theta(x_{1:T}) = \prod_t p_\theta(x_t \mid x_{\lt t}), \quad \mathcal{L} = -\tfrac{1}{T}\sum_t \log p_\theta(x_t \mid x_{\lt t}), \quad \operatorname{PPL} = e^{\mathcal{L}}, \quad p_i = \frac{e^{z_i/\tau}}{\sum_j e^{z_j/\tau}}, \quad C \approx 6ND \]

Источники к этому уроку

  1. Jurafsky & Martin, Speech and Language Processing, 3rd ed. draft, chapter 1: Introduction
  2. Zhao et al. (2023). A Survey of Large Language Models
  3. Raschka, Build a Large Language Model (From Scratch), chapter 1: Understanding large language models
  4. Noyan, Farré, Marafioti, Zohar, Vision Language Models (O’Reilly, 2026), chapter 1: Introduction to Vision and Language
  5. Vaswani et al. (2017). Attention Is All You Need