Что такое большая языковая модель? Общая картина
Через весь курс проходит одна идея: модель читает токены и предсказывает следующий. Проведём одно предложение через реальную LLM — от текста до следующего слова. Затем разберём, как модель учится, как генерирует текст и почему одна модель справляется с множеством задач.
Чему вы научитесь
- Что именно вычисляет языковая модель — в виде одной формулы вероятности, и почему задача «предскажи следующий токен» даёт так много
- Полный путь внутри LLM: текст, токены, векторы, блоки трансформера, логиты, вероятности, следующий токен — с реальными формами тензоров и покадровой визуализацией каждого вектора мини-трансформера при обучении и inference
- Как softmax и температура превращают оценки (logits) в выбор следующего токена
- Как модель учится (cross-entropy loss, perplexity) и почему обучение идёт параллельно, а генерация — по одному токену за шаг
- Жизненный цикл модели, три семейства трансформеров и как одна модель решает разные задачи — от тональности до поиска по видео
- Цифры, которые спрашивают на собеседованиях: число параметров, вычислительная стоимость обучения, память, токенов в секунду
Почему это важно
Ещё десять лет назад под каждую задачу в обработке языка делали отдельную модель: одна ловила спам, другая переводила, третья писала краткие выжимки. Для каждой приходилось собирать свой размеченный датасет и обучать всё с нуля.
Большие языковые модели (LLM) сломали этот подход одной простой идеей: взять одну крупную модель, обучить её на элементарной задаче поверх огромного корпуса текстов, а потом использовать почти для чего угодно. Задача сводится к одному — предсказать следующий кусочек текста. Ручная разметка при этом не нужна: в любом тексте правильный ответ уже лежит на месте — это просто следующее слово.
Почему такая, казалось бы, примитивная задача даёт модели столько знаний? Посмотрите, что нужно понимать, чтобы правильно продолжить каждую из этих фраз:
| Начало текста | Удачное продолжение | Что нужно знать |
|---|---|---|
| «Она открыла дверь и вошла …» | внутрь / в комнату | Грамматика |
| «Столица Франции — …» | Париж | Факт о мире |
| «17 + 25 = …» | 42 | Арифметика |
| «Вратарь прыгает в левый угол и отбивает …» | удар / пенальти | Как устроен футбол |
| «Все улики указывают на дворецкого, значит убийца — …» | дворецкий | Простое рассуждение по сюжету |
Чтобы стабильно угадывать продолжение на триллионах слов, модели приходится уложить в свои веса массу знаний о языке и об устройстве мира. Потом сверху добавляют немного дообучения — чтобы она следовала инструкциям и отвечала на вопросы, — и получается привычный чат-ассистент.
В этом уроке мы окинем взглядом всю систему целиком, а в следующих будем разбирать каждый её блок под микроскопом. Если дальше какая-то тема покажется оторванной от контекста — просто вернитесь сюда и посмотрите, где она лежит на общей карте.
Главная формула: предсказание следующего токена
LLM работает не с отдельными буквами и не с целыми словами, а с токенами — небольшими фрагментами текста вроде keeper или the. Токеном бывает целое слово, часть слова, пробел вместе со словом или знак препинания. Как именно текст режется на токены, мы разберём в уроке 8; пока достаточно считать, что токен — это частый кусочек слова.
Представим текст как последовательность токенов \(x_1, x_2, \dots, x_T\). Для каждого возможного следующего токена модель оценивает его вероятность, опираясь на всё, что было до него:
- Обозначения
- \(x_t\)
- токен на позиции \(t\), который мы пытаемся предсказать
- \(x_{\lt t}\)
- все предыдущие токены (контекст)
- \(p_\theta(\cdot \mid \cdot)\)
- вероятность, зависящая от весов модели \(\theta\); черта «\(\mid\)» читается «при условии»
- \(\theta\)
- все обучаемые веса сети — обычно миллиарды чисел
То есть на выходе модель выдаёт не одно слово, а распределение вероятностей по всему словарю. Если в словаре 128 256 токенов, на выходе получится 128 256 чисел, дающих в сумме единицу.
От вероятности одного токена к вероятности всего текста
Умея оценивать каждый следующий токен, мы автоматически получаем вероятность целого предложения. По цепному правилу теории вероятностей достаточно перемножить вероятность первого токена, вероятность второго при условии первого и так далее:
Знак \(\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” составит:
На длине 50 токенов вместо 4 произведение упадёт примерно до \(10^{-60}\). С такими крошечными числами арифметика с плавающей точкой не справляется (происходит underflow), поэтому на практике всегда переходят к логарифмам.
Логарифм превращает произведение в сумму — формула остаётся той же самой, но перестаёт терять точность:
В нашем примере:
Результат тот же, а проблемы с крошечными числами больше нет. (Везде в курсе под \(\log\) понимается натуральный логарифм.)
Генерация текста: предсказать, дописать, повторить
Во время генерации модель крутит формулу (1.1) в цикле: считает вероятности, выбирает один токен, дописывает его в конец входа и снова прогоняет последовательность. Это называется авторегрессивной генерацией (autoregressive generation): приставка «авто» как раз и означает, что модель опирается на собственные предыдущие выходы. Попробуйте покрутить этот цикл на рисунке 1.
Как читать рисунок 1
В сером поле показан уже набранный текст, а мелкое число под каждым токеном — вероятность, с которой модель его выбрала. Полоски ниже показывают распределение для следующего токена. «Добавить самый вероятный» — это greedy decoding, а «Сэмплировать токен» выбирает продолжение случайно, пропорционально длине полосок. Уменьшите температуру — лидер оторвётся от остальных, текст станет предсказуемым и однообразным; увеличьте — шансы выровняются, появятся неожиданные варианты. В нижней строке складываются log-probabilities — это формула (1.3) в деле.
Внутри машины: от текста к следующему токену
Заглянем под капот. Все decoder-only LLM (GPT, Llama, Qwen, Gemma, Mistral) устроены по одной схеме. На рисунке 2 показан весь путь с реальными формами тензоров — на примере батча из 1 фразы длиной 4 токена и размерностей Llama 3 8B. А чуть ниже, на рисунке 4, мы прогоним крошечную копию того же конвейера и посмотрим на каждое число.
Как читать рисунок 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\) — получаем начальный вектор токена:
Математически это эквивалентно умножению 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\), один современный блок записывается так:
На протяжении всех блоков форма тензора \((B, T, d)\) не меняется — меняется только начинка: векторы постепенно впитывают смысл фразы целиком.
Этап 4: последний вектор превращается в оценки (logits)
Чтобы предсказать следующий токен, берём итоговый вектор последней позиции \(\mathbf{h}^{(L)}_T\) и умножаем его на выходную матрицу \(W_U\) (unembedding). Получаем по одной сырой оценке на каждый токен словаря:
Каждая оценка \(z_i\) — это скалярное произведение финального вектора на столбец токена \(i\). Чем ближе направления векторов, тем выше результат, так что \(z_i\) буквально отвечает на вопрос «насколько хорошо сюда подходит токен \(i\)?». Эти сырые оценки называют logits; они могут быть любыми вещественными числами — и положительными, и отрицательными.
Этап 5: оценки → вероятности (softmax)
Чтобы выбирать следующий токен, сырые оценки нужно перевести в вероятности — числа от 0 до 1 с суммой 1. Этим занимается softmax:
Почему именно такая формула? Экспонента \(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:
При \(\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
Подвигайте любой ползунок — вероятности пересчитаются, сохраняя сумму 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.
Обучение (Training)все позиции сразу, loss на каждой позиции
Инференс (Inference)один новый токен за шаг
Одинаково в обоих режимах: токенизатор, таблица embeddings, блок и все его веса, а также causal mask. Шаги с 1 по 10 вычисляют абсолютно одни и те же числа на обеих панелях.
Разница: при обучении подаётся настоящий текст (teacher forcing), используются все позиции, считается loss и градиенты идут вниз для обновления весов. При inference используется только последняя позиция: выбирается токен, дописывается ко входу, а для старых токенов переиспользуются сохранённые в KV-cache ключи и значения.
Как читать рисунок 4
Нажмите «Пуск» или листайте кнопками «Шаг» и «Назад» — обе панели двигаются синхронно. Пять столбцов — пять токенов; следите, как они поднимаются через тёмные блоки и меняют цвет по мере изменения чисел. Серые линии слева — residual-пути: они проносят вход в обход подблока к кружку «+» и пульсируют в момент сложения. Врезки справа от блока раскрывают чёрные ящики для выбранного токена: query, keys и values с толщиной линий пропорциональной весам attention (бледные ключи скрыты causal mask), а также столбец MLP, расширяющийся с 8 до 32 квадратиков и сжимающийся обратно. Наверху панели расходятся. Обучение превращает каждый столбец в вероятности, обводит целевой квадратик, показывает loss под каждым столбцом, затем обратный проход (малиновый) и обновление весов. Инференс берёт только последний столбец, выбирает “ball” и возвращает его на вход; далее вычисляется только новый столбец (зелёная рамка). Кликните по кнопке токена, чипу или столбцу, чтобы переключить отслеживаемый токен; наведите или нажмите на любой столбец, чтобы увидеть его числа. Синие ссылки «→ ур.» ведут к уроку, где эта часть разобрана подробно. Паттерны attention порождены случайными весами, поэтому не ищите в них смысла.
Каждое число, шаг за шагом
Рисунок 5 раскрывает те же вычисления и показывает каждое число. Это та же модель с теми же весами, поэтому все числа совпадают с рисунком 4 (и с шагами обучения 1–10, где вычисления идентичны). Здесь матрицы нарисованы в виде таблиц чисел (строки — токены, столбцы — признаки), каждому шагу соответствует строка алгоритма слева, а панель справа подставляет реальные числа прямо в формулу. Проследите за одним токеном через все 14 шагов и проверьте пару чисел вручную.
- \(\mathbf{x} \leftarrow \operatorname{tokenize}(\text{text})\) // \(T = 5\) ID токенов
- \(X^{\text{tok}} \leftarrow E[\mathbf{x}]\) // \(5 \times 8\)
- \(X \leftarrow X^{\text{tok}} + P\) // синусоидальные позиции
- \(H \leftarrow \operatorname{RMSNorm}(X)\)
- \(Q, K, V \leftarrow H W_Q,\ H W_K,\ H W_V\) // 2 головы по 4 столбца
- for \(h = 1, 2\): \(S^{(h)} \leftarrow Q^{(h)} K^{(h)\top} / \sqrt{4} + M_{\text{causal}}\)
- \(A^{(h)} \leftarrow \softmax(S^{(h)})\) // построчно
- \(\text{Attn} \leftarrow [A^{(1)} V^{(1)},\ A^{(2)} V^{(2)}]\, W_O\)
- \(X' \leftarrow X + \text{Attn}\) // residual
- \(U \leftarrow \operatorname{RMSNorm}(X')\, W_1\) // \(5 \times 32\)
- \(X'' \leftarrow X' + \operatorname{GELU}(U)\, W_2\) // residual
- \(Z \leftarrow \operatorname{RMSNorm}(X'')\, W_U\) // \(5 \times 12\) logits
- \(\mathbf{p} \leftarrow \softmax(\mathbf{z}_5)\); \(\hat{x}_6 \leftarrow \argmax_i p_i\)
- дописать \(\hat{x}_6\); повторить, переиспользуя кэш \(K, V\)
Как читать рисунок 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) |
Проследим за последним токеном, “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{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)\) M | 6,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).
| Вход | The | keeper | saves | the | shot |
|---|---|---|---|---|---|
| Цель | keeper | saves | the | shot | . |
Функция потерь: cross-entropy
На каждой позиции смотрим, какую вероятность модель выдала правильному следующему токену, берём её отрицательный логарифм и усредняем по всей последовательности. Это cross-entropy loss:
По сути, это формула (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:
Loss 2,0 соответствует perplexity \(e^2 \approx 7{,}4\): интуитивно это значит, что в среднем модель колеблется примерно между семью равновероятными вариантами. Чем меньше, тем лучше — но сравнивать perplexity имеет смысл только у моделей с одинаковым токенизатором и на одном и том же тестовом корпусе.
Как читать рисунок 6
Слева кривая взлетает почти вертикально: подняв вероятность с \(0{,}01\) до \(0{,}1\), мы снижаем loss на 2,3 — ровно на столько же, сколько даёт скачок с 0,1 до 1. Поэтому основную работу оптимизатор тратит на самые неожиданные для модели токены. Пунктир отмечает текущее \(p\).
Обновление весов
Обратное распространение ошибки (backpropagation) считает градиент \(\nabla_\theta \mathcal{L}\) — показывает, куда сдвинуть каждый вес, чтобы уменьшить loss. После этого мы делаем небольшой шаг в нужную сторону:
Здесь \(\eta\) — learning rate (размер шага). В реальных LLM вместо простого шага стоит оптимизатор AdamW (урок 4), но принцип тот же. Этот цикл прогоняется миллионы раз — на батчах из миллионов токенов.
Почему обучение параллельно, а генерация — нет
При обучении весь текст уже лежит перед нами, поэтому предсказания для всех позиций можно посчитать за один forward pass. Главное — не дать позициям подглядывать в будущее; для этого внутри attention ставится causal mask. Подачу настоящих предыдущих токенов (а не догадок самой модели) называют teacher forcing.
Во время генерации будущего ещё нет — модель дописывает его сама. Токен 6 зависит от токена 5, который только что сгенерирован, поэтому приходится идти строго по одному токену за шаг. Оба режима показаны на рисунке 7.
Как читать рисунок 7
Строка 3 (“saves”) видит столбцы 1–3 (“The”, “keeper”, “saves”) и предсказывает “the” — заглянуть в столбец 4 ей нельзя, там ответ. При обучении все пять предсказаний и потерь считаются за один проход. Переключитесь на генерацию и кликайте «Следующий шаг»: на каждом шаге появляется одна строка и один новый токен, а ключи и значения предыдущих строк переиспользуются из кэша — именно для этого и нужен KV-cache (урок 80).
Сколько вычислений требует обучение?
Удобная прикидка: один forward pass тратит около \(2N\) операций с плавающей точкой (FLOPs) на токен, где \(N\) — число параметров (по умножению и сложению на вес), а backward pass — примерно вдвое больше. В сумме обучение обходится примерно в:
где \(D\) — общее число обучающих токенов.
Модель на 8B параметров, обучаемая на 15 триллионах токенов:
Если одна GPU реально выдаёт \(4 \times 10^{14}\) FLOP/s, это займёт
то есть около 500 000 GPU-часов, или примерно 3 недели на 1 000 GPU. На практике требуется ещё больше, потому что GPU никогда не загружены на 100%. (Это учебная прикидка, а не официальный отчёт.)
Как пишет LLM: инференс (inference)
Генерация делится на две фазы, и нагрузку на GPU они создают совершенно разную:
- Prefill: модель проглатывает весь промпт за один проход (как при обучении — все позиции параллельно). На каждый прочитанный байт приходится много арифметики, поэтому фаза упирается в вычислительную мощность (compute-bound).
- Decode: модель выдаёт по одному новому токену за шаг. Вычислений на шаге мало, но из памяти каждый раз приходится прочитывать все веса целиком — поэтому скорость упирается в пропускную способность памяти (memory-bound).
Веса модели на 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 проходит несколько стадий — со своими данными, функцией потерь и отдельным треком в этом курсе.
Разницу между базовой моделью и ассистентом проще всего показать на примере. Если спросить базовую модель «Какая столица у Франции?», она вполне может дописать: «Какая столица у Германии? Какая столица у Испании?» — в интернете полно списков вопросов. Ассистент же просто ответит «Париж». Архитектура при этом не меняется — отличаются только данные на последних этапах обучения.
Три семейства трансформеров
В основе всех LLM лежат одни и те же блоки трансформера, но различается маска attention — то есть какие токены имеют право видеть друг друга. На рисунке 9 показаны три основных семейства.
| Семейство | Кто кого видит | Задача обучения | Где сильны | Примеры |
|---|---|---|---|---|
| Encoder-only | Все видят всех | Восстановление скрытых слов (masked LM) | Понимание текста: классификация, embeddings для поиска | BERT, RoBERTa |
| Decoder-only | Только прошлое и сам себя | Предсказание следующего токена | Генерация, чат, почти все современные LLM и VLM | GPT, Llama, Qwen, Gemma |
| Encoder–decoder | Encoder — всех; decoder — прошлое + весь encoder | Восстановление скрытых фрагментов; перевод | Преобразование входа в выход: перевод, распознавание речи | T5, BART, Whisper |
Почему в большом масштабе победили именно decoder-only? Одной модели и одной функции потерь хватает на всё, каждый токен текста даёт обучающий сигнал, и одна и та же сеть умеет и читать, и писать. Подробный разбор компромиссов ждёт в уроке 23.
Одна модель — множество задач
Обученная LLM — универсальный движок, к которому можно прикрутить три разных «выхода» (рисунок 10).
Классификация через выбор слова-метки
Чтобы определить тональность отзыва, достаточно подать промпт вроде «Отзыв: … Тональность:» и сравнить вероятности двух слов-меток:
Обучать ничего не нужно. Если же у вас есть размеченные данные, дешевле и обычно точнее обучить небольшую голову-классификатор поверх hidden states (урок 55 и урок 144).
Поиск (retrieval) через сравнение векторов
Усреднив финальные hidden states текста, получим один вектор \(\mathbf{e}\) (embedding). У близких по смыслу текстов векторы смотрят примерно в одну сторону, и это сходство измеряют косинусом угла между ними (cosine similarity):
Единица означает совпадение направлений, ноль — независимость, \(-1\) — противоположность. Поисковые системы хранят миллионы таких векторов и мгновенно находят ближайшие к запросу (урок 150 и урок 151).
Изображения и видео тоже становятся токенами
Визуально-языковая модель (VLM) режет картинку на мелкие патчи, прогоняет их через vision encoder и подставляет получившиеся векторы перед текстовыми токенами. Для самой LLM ничего не меняется — она просто читает единую последовательность:
Видео — это серия кадров, то есть цепочка таких групп патчей во времени. И тот же самый механизм предсказания следующего токена начинает описывать сцены, отвечать на вопросы по матчу или выдавать таймкоды нужных моментов.
| Задача по видео | Вход → выход | Какой выход | Где в курсе |
|---|---|---|---|
| Поиск видео по тексту (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.
- вход: батч последовательностей токенов \(X \in \{1..|V|\}^{B \times (T+1)}\), веса \(\theta\), learning rate \(\eta\)
- \(X_{\text{in}} \leftarrow X[:, 1{:}T]\), \(\;Y \leftarrow X[:, 2{:}T{+}1]\) // цели — входы, сдвинутые на 1
- \(H \leftarrow E[X_{\text{in}}]\) // выборка embeddings, форма \((B, T, d)\)
- for \(\ell = 1\) to \(L\) do
- \(H \leftarrow H + \operatorname{Attn}_\ell(\operatorname{Norm}(H))\) // с causal mask: без подглядывания
- \(H \leftarrow H + \operatorname{MLP}_\ell(\operatorname{Norm}(H))\)
- \(Z \leftarrow \operatorname{Norm}(H)\, W_U\) // logits для каждой позиции, форма \((B, T, |V|)\)
- \(\mathcal{L} \leftarrow -\frac{1}{BT}\sum_{b,t} \log \softmax(Z_{b,t})[Y_{b,t}]\) // cross-entropy (1.9)
- \(g \leftarrow \nabla_\theta \mathcal{L}\) // backpropagation
- \(\theta \leftarrow \theta - \eta\, g\) // на практике: AdamW с clipping и расписанием LR
- вход: токены промпта \(x_{1..n}\), температура \(\tau\), максимум новых токенов \(K\)
- for \(k = 1\) to \(K\) do
- \(\mathbf{z} \leftarrow \text{model}(x_{1..n})[\text{последняя позиция}]\) // по одному logit на токен словаря
- if \(\tau = 0\) then \(x_{n+1} \leftarrow \argmax_i z_i\) // greedy
- else \(x_{n+1} \sim \softmax(\mathbf{z}/\tau)\) // сэмплирование, формула (1.8)
- \(n \leftarrow n + 1\)
- if \(x_n\) — токен конца текста (EOS) then break
- 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, в двух предложениях.база
Зачем переходить к логарифмам вероятностей?база
Чем logits отличаются от вероятностей и зачем нужен softmax?база
Почему обучение параллельно по позициям, а генерация — последовательна?основной
Сколько памяти и FLOPs нужно для сервинга 8B-модели в BF16?основной
Оцените вычислительную стоимость предобучения 8B-модели на 15T токенов.основной
Почему decode при batch size 1 упирается в память и как это лечить?продвинутый
Как работает температура и что происходит при \(\tau \to 0\) и \(\tau \to \infty\)?база
Когда выбирать encoder-only, а когда decoder-only?основной
Что такое perplexity и всегда ли меньше — лучше?основной
Объясните галлюцинации, опираясь только на функцию потерь обучения.продвинутый
Как использовать генеративную LLM для классификации или поиска?основной
Упражнения
- Посчитайте \(\softmax(1, 2, 3)\) вручную.
- Модель дала правильному токену вероятность 0,5 — чему равен loss? А если средний loss модели равен 3,0 — какая у неё perplexity?
- Сколько параметров лежит в таблице embeddings модели Llama 3 8B?
- Оцените теоретический потолок скорости decode для 8B-модели на L4 (300 ГБ/с) при batch 1 в BF16 и в 4-битной квантизации.
- На рисунке 1 выкрутите температуру в минимум и жмите «Добавить самый вероятный» до конца фразы, потом повторите. Почему текст выходит идентичным? Теперь попробуйте «Сэмплировать токен» при температуре 2 — что меняется?
- На рисунке 4 откройте шаг 6 и выберите токен <s>. Почему из его query в каждой голове всегда выходит ровно одна линия с весом 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.
Ключевые формулы
Источники к этому уроку
- Jurafsky & Martin, Speech and Language Processing, 3rd ed. draft, chapter 1: Introduction
- Zhao et al. (2023). A Survey of Large Language Models
- Raschka, Build a Large Language Model (From Scratch), chapter 1: Understanding large language models
- Noyan, Farré, Marafioti, Zohar, Vision Language Models (O’Reilly, 2026), chapter 1: Introduction to Vision and Language
- Vaswani et al. (2017). Attention Is All You Need