«Большие языковые модели», главы 4–6: данные, архитектура и предобучение

О конспекте

Пересказ своими словами глав 4–6 книги «Большие языковые модели» (часть «Предобучение») по электронной версии PDF. У книги нет открытой лицензии, поэтому таблицы, рисунки и код книги мы не воспроизводим; формулы общеизвестны и записаны в наших обозначениях, код на странице — наш. Числа из книги помечены, наши расчёты — тоже. Общий обзор книги — в путеводителе.

Коротко

• Глава 4 — данные. Качество предобучения на три четверти определяется данными. Конвейер: сбор → фильтрация качества (правила + классификаторы) → удаление токсичного и персональных данных → дедупликация → токенизация → расписание данных (пропорции источников и порядок). Сквозной пример — собственная модель авторов YuLan.
• Глава 5 — архитектура. «Рецепт» современного декодера: Pre-RMSNorm + SwiGLU + RoPE (или ALiBi), плюс GQA для быстрого вывода и MoE для роста параметров без роста вычислений. Отдельно — как растянуть контекст (интерполяция позиций, NTK, ReRoPE) и что такое модели пространства состояний.
• Глава 6 — предобучение. Задачи (LM, денойзинг, UL2), типичные гиперпараметры, 3D-параллелизм и ZeRO, и самое ценное — §6.4: как посчитать параметры, FLOPs, дни обучения и видеопамять по одной конфигурации модели.

Как читать вместе с курсом

Раздел книги	Урок курса	Что даёт книга сверх урока
§4.2–4.4 данные	5.1.2 Данные для предобучения	конкретные правила фильтрации и опыт подбора смеси на YuLan
§4.3 токенизация	4.2.2 BPE	WordPiece и Unigram рядом с BPE, метрика сжатия
§5.2 конфигурация	4.5.3 Современный блок, 4.5.2 Позиции	сводка вариантов нормализации, активаций и позиций с выбором
§5.2.5–5.2.6 внимание и MoE	5.2.1 MQA и GQA, 5.3.1 MoE	— (в курсе глубже)
§5.4 длинный контекст	5.5.1 Масштабирование RoPE	единая запись $f(t,i) = g(t)\,h(i)$ для всех методов
§5.5 SSM	5.5.3 Линейное внимание	таблица сложностей Transformer/SSM/Mamba/RWKV/RetNet/Hyena
§6.2–6.3 обучение	5.4.3 Распределённое обучение, 5.4.4 Оптимизаторы и стабильность	таблица гиперпараметров ~20 известных моделей
§6.4 оценка затрат	5.6.2 Проект предобучения	готовые формулы памяти для ZeRO-1/2/3, TP, PP и пересчёта активаций

Глава 4. Подготовка данных

Источники

Книга делит данные на общие (веб-страницы, книги, диалоги и форумы) и специальные (многоязычные тексты, научные статьи, код). Специальные данные учат конкретным способностям: код — рассуждению и работе с длинными зависимостями, научные тексты — формулам и терминам.

Фильтрация качества

Два подхода, которые на практике комбинируют.

Правила (эвристики). Авторы собрали правила из отчётов Dolma, RefinedWeb и Gopher. Примеры:

• язык — оставить целевые языки, но не выбрасывать хороший английский даже для китайской модели (в LLaMA-2 английского около 90%); многоязычную Википедию YuLan взяла целиком;
• статистика — выбросить веб-документы, где одно слово или предложение повторяется больше 100 раз (Dolma), где отношение символов-«мусора» к токенам больше 0,1 (Gopher); фильтровать по перплексии маленькой LM;
• ключевые слова — удалить HTML-разметку; выбросить англоязычные документы без единого из частых служебных слов (the, be, to, of, and…; Gopher); выбросить страницы Википедии короче 25 слов (Dolma); на форумах — комментарии с менее чем тремя «лайками».

Классификаторы. Положительные примеры — заведомо качественные тексты (Википедия), отрицательные — мусор из веба. Три класса моделей: лёгкие (FastText) — быстро, но грубо; дообученные BERT/LLaMA — точнее, но хуже обобщаются; закрытые API (GPT-4, Claude 3) — сильные, но дорогие. Две полезные мысли: классификатор может «по ошибке» выкинуть редкие, но ценные тексты (книга приводит пример текстов на вэньяне — классическом китайском письменном языке), и последние два класса моделей могут не только выбрасывать, но и переписывать почти хорошие документы. Практичная схема — каскад: дешёвые правила → лёгкий классификатор → дорогой классификатор на остатке.

Токсичность и персональные данные. Классификатор токсичности учат на наборе Jigsaw (≈160 тыс. комментариев, шесть меток). Порог — компромисс: Dolma взяла высокий порог 0,4 и выбросила на этом шаге лишь около 30% Common Crawl, рассчитывая, что остальное отсеют последующие фильтры. Персональные данные Dolma ищет правилами (почта, IP, телефоны): если их в документе мало — заменяет спецтокенами вида |||EMAIL_ADDRESS|||, если шесть и больше — удаляет документ целиком (много найденного — признак, что есть и ненайденное). В книге напомнен случай ноября 2023 года, когда просьба бесконечно повторять слово «poem» заставляла ChatGPT выдавать куски обучающих данных с контактами людей.

Дедупликация

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

Идея MinHash: оценить сходство Жаккара двух множеств $J(A,B) = |A\cap B|/|A\cup B|$, не сравнивая их целиком. Для случайной хеш-функции вероятность того, что минимумы хешей по $A$ и по $B$ совпадут, равна ровно $J(A,B)$; берём $k$ хеш-функций и считаем долю совпадений. Наш минимальный пример:

import hashlib

def shingles(text, n=5):
    """Множество n-грамм символов (работает для любого языка, даже без пробелов между словами)."""
    text = "".join(text.split())
    return {text[i:i + n] for i in range(len(text) - n + 1)}

def minhash(sh, k=128):
    """Подпись из k чисел: минимум k разных хеш-функций по элементам множества."""
    return [min(int(hashlib.md5(f"{seed}:{s}".encode()).hexdigest(), 16) for s in sh)
            for seed in range(k)]

def est_jaccard(a, b):
    return sum(x == y for x, y in zip(a, b)) / len(a)

d1 = ("Большие языковые модели обычно предобучают на огромных корпусах текста, а затем инструктивным "
      "дообучением и выравниванием приспосабливают к прикладным задачам.")
d2 = ("Большие языковые модели обычно предобучают на огромных корпусах текста, после чего инструктивным "
      "дообучением и выравниванием приспосабливают к разным прикладным задачам.")
d3 = "Вращательное позиционное кодирование записывает позицию в угол поворота запросов и ключей."
s1, s2, s3 = shingles(d1), shingles(d2), shingles(d3)
exact = len(s1 & s2) / len(s1 | s2)
m1, m2, m3 = minhash(s1), minhash(s2), minhash(s3)
print(f"Жаккар d1-d2: точно {exact:.2f}, оценка {est_jaccard(m1, m2):.2f}")  # 0.77 и 0.77
print(f"Жаккар d1-d3: оценка {est_jaccard(m1, m3):.2f}")                     # 0.00

В настоящих системах подписи ещё режут на «полосы» (LSH), чтобы сравнивать только документы-кандидаты, а не все пары.

Как данные влияют на результат (§4.2.4)

Книга собирает несколько показательных результатов из литературы:

• Количество. Chinchilla (70B, 1,4T токенов, ≈20 токенов на параметр) обошла Gopher (280B, 300B токенов); LLaMA-2 7B учили уже на 2T токенов, и предел для маленьких моделей не найден.
• Качество. Phi-1 (1,3B) на «учебниках», частично сгенерированных GPT-3.5, получила 50,6% pass@1 на HumanEval.
• Повторы. Если 0,1% данных повторить 100 раз, модель на 800M параметров опускается до уровня модели на 400M, обученной без повторов.
• Утечка тестов. В экстремальном случае полной утечки модель на 1,3B обгоняла честно оценённую модель на 65B.

Несогласованность внутри книги

Здесь же сказано, что GPT-3 учили на 500B токенов, а в §2.2 — на 300B. Верно 300B: столько токенов модель увидела за обучение; около 500B — размер собранного корпуса, часть которого сэмплировалась с повторами, часть — недобрана. А соотношение Chinchilla здесь дано правильно (20:1), в отличие от «пятикратного» в §2.2.

Токенизация (§4.3)

Рядом с BPE (подробно — в уроке 4.2.2) книга описывает:

• WordPiece (BERT): тоже сливает пары, но выбирает не самую частую пару, а пару с максимальным $\dfrac{\text{freq}(ab)}{\text{freq}(a)\cdot\text{freq}(b)}$ — то есть ту, чьи части редко встречаются порознь;
• Unigram (T5, mBART): идёт обратным путём — начинает с большого словаря и выкидывает токены, чьё удаление меньше всего уменьшает правдоподобие корпуса; вероятности оценивает EM-алгоритмом, лучшее разбиение ищет алгоритмом Витерби.

Требования к токенизатору: обратимость без потерь и высокое сжатие — среднее число байт UTF-8 на токен (пример книги: 1 МиБ текста в 200 000 токенов даёт $1\,048\,576 / 200\,000 \approx 5{,}24$). Две практические ловушки: английский токенизатор LLaMA плохо режет китайский (длиннее последовательности, медленнее вывод), а BPE режет числа непоследовательно — по примеру книги, «7,481» → «7 481», а «74,815» → «748 15», что мешает арифметике; поэтому многие модели режут числа поцифренно.

Расписание данных (§4.4)

Смесь. Ориентир, который долго копировали все: в LLaMA больше 80% веба, 6,5% кода (GitHub, StackExchange), 4,5% книг, 2,5% arXiv. Правила подбора: разнообразие источников полезно; пропорции можно подбирать автоматически — например, DoReMi учит маленькую прокси-модель и повышает вес тех доменов, где она отстаёт от эталонной; или просто учат несколько маленьких моделей на разных смесях и берут лучшую (с риском, что маленькие ведут себя не как большие).

Учебный план (data curriculum). Порядок данных тоже важен, особенно при продолжении предобучения. Примеры книги: CodeLLaMA — 2T общих токенов → 500B кода (→ ещё 100B Python для CodeLLaMA-Python); Llemma — поверх этого ещё 50–200B математики, причём 5% общих данных подмешано как «регуляризация» против забывания; длинный контекст CodeLLaMA — 2,5T токенов с окном 4K → 20B токенов с окном 16K.

Пример YuLan. Как авторы готовили данные своей модели на 12B:

1. Сбор: Common Crawl, книги (Books3, Gutenberg), Чжиху и Википедия для знаний; ближе к концу — математика (Proof-Pile) и код (GitHub).
2. Очистка: эвристики на уровне документов → на уровне предложений (повторы, персональные данные) → MinHash-дедупликация между источниками.
3. Словарь: словарь LLaMA плюс BPE-токены, обученные на китайском, — всего 51 200.
4. Смесь: прокси-модель на 1,3B, каждый эксперимент — 50B токенов с нуля. Сначала подобрали соотношение китайского к английскому (1:8), затем от пропорций LLaMA меняли по одному типу данных.
5. Ручная коррекция: способности росли неравномерно (генерация — быстро, математика — долго никак), и смесь подправляли по ходу обучения.

Итог: 1 680B токенов — 1 380B английских, 280B китайских, 20B на других языках.

Глава 5. Архитектура

Конфигурация блока (§5.2)

Нормализация. LayerNorm вычитает среднее и делит на стандартное отклонение; RMSNorm только делит на среднеквадратичное $\mathrm{RMS}(x)=\sqrt{\tfrac1H\sum_i x_i^2}$ — быстрее и не хуже (Gopher, Chinchilla, LLaMA); DeepNorm масштабирует остаточную ветвь, $\mathrm{LN}(\alpha x + f(x))$, и позволил учить Transformer в 1000 слоёв (использован в GLM-130B).

Место нормализации. Post-Norm $\mathrm{Norm}(x + f(x))$ — как в исходном Transformer: хорошее качество, но нестабильна на больших моделях. Pre-Norm $x + f(\mathrm{Norm}(x))$ — стабильна, немного проигрывает в качестве, но стала стандартом. Sandwich-Norm добавляет вторую нормализацию на выходе подслоя — и всё равно иногда «взрывается».

Активации. ReLU → GELU/Swish → вентильные SwiGLU и GeGLU: $\mathrm{SwiGLU}(x) = \mathrm{Swish}(xW_G)\odot(xW_U)$. Две матрицы вместо одной, зато стабильно лучше качество.

Позиционные кодировки. Абсолютные (синусоиды, обучаемые) → относительные (Transformer-XL, скалярные смещения T5) → RoPE: запрос и ключ на позиции $t$ поворачиваются в каждой паре координат $i$ на угол $t\theta_i$, $\theta_i = b^{-2(i-1)/H}$, $b=10\,000$, и скалярное произведение зависит только от разности позиций. ALiBi вообще не трогает векторы, а вычитает из оценки внимания штраф $m\,(i-j)$ с фиксированным наклоном $m$ для каждой головы — без обучаемых параметров и с хорошей экстраполяцией (BLOOM).

Тонкость реализации RoPE

Текст книги говорит, что RoPE поворачивает соседние координаты $(x_1,x_2), (x_3,x_4), \dots$, а приведённая там же функция rotate_half из Hugging Face Transformers склеивает первую половину вектора со второй, то есть поворачивает пары $(x_i, x_{i+H/2})$. Противоречия нет: это та же операция с переставленными координатами, а перестановку «поглощают» матрицы $W_Q, W_K$ (поэтому скрипты конвертации весов LLaMA в формат Hugging Face переставляют строки этих матриц). Но смешивать две конвенции в одной модели нельзя.

Внимание. Полное — $O(T^2)$; скользящее окно ширины $w$ — $O(wT)$, а дальние зависимости передаются через слои; MQA/GQA — головы делят ключи и значения, что уменьшает KV-кэш и ускоряет декодирование (GQA в LLaMA-2); FlashAttention и PagedAttention — оптимизации под железо (подробно — в главе 9).

MoE. Маршрутизатор выбирает $k$ лучших экспертов из $K$: $G(x) = \mathrm{softmax}(\mathrm{topk}(xW_G))$, выход — взвешенная сумма выходов выбранных FFN. Пример книги — Mixtral 8×7B: 8 экспертов в каждом слое, по 2 на токен, около 13B активных параметров, качество выше LLaMA-2 70B. Уточним формулировку книги «8 экспертов по 7B»: эксперт — это FFN одного слоя, а не модель на 7B; внимание и эмбеддинги общие, поэтому всего в Mixtral около 47B параметров, а не 56B.

Итоговая рекомендация главы: Pre-RMSNorm, SwiGLU или GeGLU, RoPE или ALiBi. Ровно это и собрано в LLaMA, чей код авторы разбирают построчно (§5.2.7).

Три семейства архитектур (§5.3)

Кодировщик–декодировщик (T5, BART, Flan-T5), каузальный декодер (GPT, LLaMA, BLOOM, Mistral — подавляющее большинство) и префиксный декодер (GLM-130B, U-PaLM): префикс читается двунаправленным вниманием, продолжение генерируется слева направо, параметры общие. Префиксный декодер можно получить дообучением каузального — так U-PaLM сделан из PaLM.

Длинный контекст (§5.4)

Хорошая находка книги — общая запись. Угол поворота в RoPE — $f(t,i) = t\cdot\theta_i$; все методы расширения окна с $T_{\max}$ до $T'_{\max}$ меняют либо функцию расстояния $g(t)$, либо базу $h(i)$:

$$f(t,i) = g(t)\cdot h(i).$$

Метод	Что меняется	Суть
прямое дообучение	ничего	работает, но медленно сходится: углы выходят за обученный диапазон
интерполяция позиций	$g(t) = \tfrac{T_{\max}}{T'_{\max}}\,t$	сжимаем позиции; LLaMA-33B растянули с 2048 до 8192 примерно за 1000 шагов
ReRoPE / LeakyReRoPE	$g(t)$ обрезается после окна $w$	близкие позиции точные, дальние — «срезанные»; без обучения, но внимание считается дважды
NTK-RoPE, динамический NTK	$h(i)$: основание $b \to \alpha b$	для NTK $\alpha = (T'_{\max}/T_{\max})^{H/(H-2)}$; при дообучении на длинных текстах берут очень большое основание, вплоть до $10^8$
обрезка базы	$h(i)$ обнуляется или фиксируется для низких частот	убирает непривычные углы ценой различимости позиций

Ключевое понятие — критические подпространства: пары координат, у которых длина волны $\lambda_i = 2\pi/\theta_i$ больше обученного окна, так что модель ни разу не видела их полного оборота. Наш расчёт для головы размера $H=128$ и $b=10^4$: при окне 4096 критических пар 18 из 64 (начиная с 47-й), при окне 2048 — 23. Именно их и «чинят» методы из нижней половины таблицы.

Кроме смены кодировки, окно меняют маской внимания: параллельные окна (куски кодируются независимо с одинаковыми позициями), Λ-образная маска StreamingLLM (видим начало последовательности и недавние токены — почти бесконечная генерация, но середина теряется) и отбор токенов (внимание только к немногим самым релевантным).

Опечатка в формуле (5.42)

В PDF основание после масштабирования записано как $h(i) = (\alpha b)^{-(i-1)/H}$, а исходная база — как $\theta_i = b^{-2(i-1)/H}$. Двойка в показателе потерялась: должно быть $h(i) = (\alpha b)^{-2(i-1)/H}$, иначе при $\alpha = 1$ формула не совпадает с обычным RoPE.

Новые архитектуры (§5.5)

Модели пространства состояний (SSM): $S_t = A S_{t-1} + B x_t,\; y_t = C S_t$. Развернув рекуррентность, получаем свёртку входа с ядром $(CB, CAB, CA^2B, \dots)$: учить можно параллельно (свёртка через БПФ), а генерировать — как RNN, за $O(1)$ на токен по длине. Варианты: Mamba (матрицы $B$, $C$ и шаг дискретизации зависят от входа — «селективность»; из-за этого фиксированного свёрточного ядра больше нет, и в таблице книги Mamba помечена как непараллелизуемая — на практике её учат параллельным сканированием), RWKV, RetNet, Hyena. Книга сводит их сложность обучения и декодирования в одну таблицу и честно пишет, что качество этих архитектур ещё предстоит подтвердить.

Глава 6. Предобучение

Задачи (§6.1)

1. Языковое моделирование — максимизировать $\sum_t \log P(u_t \mid u_{<t})$. Авторы приводят метафору Ильи Суцкевера про детектив: чтобы угадать имя убийцы на последней странице, нужно понять весь роман. И напоминают, что предсказание следующего токена — неявное многозадачное обучение.
2. Денойзинг (BERT, T5): испортить спаны и восстановить их.
3. Смесь денойзеров UL2 (UL2, PaLM 2): S-денойзер = префиксное LM; R-денойзер — короткие спаны 3–5 токенов, ~15% текста; X-денойзер — длинные спаны (12+ токенов) или порча ~50% текста. Режим задаётся спецтокеном [R], [S], [X].

Гиперпараметры и стабильность (§6.2)

• Батч — 1–4 млн токенов, часто растущий по ходу обучения (GPT-3: от 32K до 3,2M токенов; PaLM: от 1M до 4M).
• Скорость обучения — линейный разогрев на 0,1–0,5% шагов, пик обычно $5\cdot10^{-5}$…$10^{-4}$ (GPT-3 — $6\cdot10^{-5}$, LLaMA — $1{,}5\cdot10^{-4}$), затем косинусное (или линейное, или обратно-корневое) затухание до ~10% от пика.
• Оптимизатор — Adam/AdamW с $\beta_1 = 0{,}9$, $\beta_2 = 0{,}95$, $\epsilon = 10^{-8}$; Adafactor экономит память (PaLM, T5).
• Стабильность — обрезка градиента по норме 1,0; weight decay 0,1; dropout почти не используют; при всплеске потерь — откат к чекпоинту с пропуском «виноватых» батчей.

Таблица 6.1 книги сводит эти настройки для двух десятков моделей. Для ориентира: у LLaMA-2 батч 4M и пик $1{,}5\cdot10^{-4}$, у Qwen-1.5 — 4M и $3\cdot10^{-4}$, у DeepSeek LLM — 18M и $3{,}2\cdot10^{-4}$, у YuLan — 4,5M и $3\cdot10^{-4}$.

Масштабируемое обучение (§6.3)

Данные-параллелизм (копия модели на каждой GPU, усреднение градиентов), конвейерный (слои по GPU; без накопления градиентов GPU простаивают, поэтому батч режут на микробатчи), тензорный (матрица $W$ режется по столбцам, $[W_1H, W_2H]$ считаются на разных GPU — Megatron-LM). ZeRO (DeepSpeed) и его аналог FSDP в PyTorch убирают дублирование состояний между копиями; пересчёт активаций хранит только входы слоёв; смешанная точность — FP16/BF16 для вычислений, FP32-копия весов в оптимизаторе.

6.4. Сколько стоит модель: параметры, FLOPs, время и память

Лучший раздел главы. Обозначения: словарь $V$, слоёв $L$, скрытый размер $H$, размер FFN $H'$, параметров $P$, обучающих токенов $C$, батч $B$, длина $T$, голов $N$.

Параметры LLaMA-подобной модели (без GQA, вход и выход не связаны):

$$P = \underbrace{2VH}_{\text{вход и выход}} + \underbrace{H}_{\text{финальный RMSNorm}} + L\,(\underbrace{4H^2}_{Q,K,V,O} + \underbrace{3HH'}_{\text{SwiGLU}} + \underbrace{2H}_{\text{два RMSNorm}}).$$

Для LLaMA-7B ($V=32\,000$, $L=32$, $H=4096$, $H'=11\,008$) получается ровно 6 738 415 616 — как в опубликованной модели.

FLOPs. Умножение матриц $n\times m$ на $m\times p$ стоит $2nmp$ операций, обратный проход — примерно вдвое дороже прямого. Для линейных слоёв это даёт $6C\cdot P_{\text{lin}}$, а поскольку линейные слои — больше 95% параметров:

$$\text{FLOPs} \approx 6\,C\,P \quad (\approx 8\,C\,P \text{ с пересчётом активаций}).$$

Внимание добавляет $12\,C\,T\,L\,(H+N)$, то есть примерно $T/(6H)$ от линейной части: при $T \le H$ — не больше шестой доли.

Время: $\text{FLOPs} / (\text{число GPU}\times\text{реальная производительность})$, где реальная — 30–70% паспортной. Пример книги: LLaMA-65B, 1,4T токенов, пересчёт активаций → $8CP \approx 7{,}28\cdot10^{23}$; 2048 A100 по $2\cdot10^{14}$ FLOP/с → около 20,6 дня, в статье LLaMA — 21 день.

Память на параметры и оптимизатор при смешанной точности: веса FP16 (2 байта) + градиенты FP16 (2) + FP32-копия весов, первый и второй моменты Adam (4 + 4 + 4) = 16 байт на параметр. ZeRO делит эти куски на $N_D$ копий данных-параллелизма:

Схема	Байт на GPU
без ZeRO	$16P$
ZeRO-1 (делится оптимизатор)	$4P + 12P/N_D$
ZeRO-2 (+ градиенты)	$2P + 14P/N_D$
ZeRO-3 (+ веса)	$16P/N_D$

Тензорный и конвейерный параллелизм делят результат ещё на $N_T \cdot N_P$.

Активации LLaMA без оптимизаций: $(16BTH + 6BTH' + 2BT^2N)\,L + 4BTH + 4BTV$ байт; FlashAttention убирает член $2BT^2N$, пересчёт активаций сводит всё к $(4+2L)BTH + 4BTV$. Пример книги: LLaMA-7B на двух A800 80G с ZeRO-3, FlashAttention и пересчётом, $B=8$, $T=2048$: 50,2 ГБ на состояния + 6,2 ГБ активаций + 3,9 ГБ промежуточного softmax + ~6 ГБ прочего ≈ 66 ГБ на GPU. Отсюда правило большого пальца: для полного дообучения нужно не меньше $16P$ байт видеопамяти, например для 13B — от 208 ГБ (три карты по 80 ГБ).

Те же формулы в виде нашего калькулятора (с поправкой на GQA, которой в формуле книги нет):

def llama_params(V, L, H, Hf, kv_heads=None, n_heads=None, tied=False):
    """Число параметров LLaMA-подобной модели (формула 6.5 книги, с поправкой на GQA)."""
    attn = 4 * H * H
    if kv_heads and n_heads:                      # GQA: K и V меньше в n_heads/kv_heads раз
        attn = 2 * H * H + 2 * H * (H // n_heads) * kv_heads
    per_layer = attn + 3 * H * Hf + 2 * H         # внимание + SwiGLU-FFN + два RMSNorm
    emb = V * H if tied else 2 * V * H            # вход и выход (если не связаны)
    return emb + H + L * per_layer                # + финальный RMSNorm

def train_flops(P, tokens, recompute=False):
    return (8 if recompute else 6) * P * tokens   # формулы 6.9 и 6.8

def train_days(flops, n_gpu, flops_per_gpu):
    return flops / (n_gpu * flops_per_gpu) / 86400

def mem_states_gb(P, zero=0, n_dp=1):
    """Параметры + градиенты + состояние AdamW на одну GPU, ГиБ (смешанная точность)."""
    b = {0: 16 * P,
         1: 4 * P + 12 * P / n_dp,
         2: 2 * P + 14 * P / n_dp,
         3: 16 * P / n_dp}[zero]
    return b / 2**30

P7 = llama_params(V=32000, L=32, H=4096, Hf=11008)
print(f"LLaMA-7B: {P7:,}")                                        # 6,738,415,616
print(f"{train_days(train_flops(6.5e10, 1.4e12, True), 2048, 2e14):.1f} дн.")  # 20.6
print(f"{mem_states_gb(P7, zero=3, n_dp=2):.1f} ГиБ на GPU")      # 50.2
P8 = llama_params(V=128256, L=32, H=4096, Hf=14336, kv_heads=8, n_heads=32)
print(f"Llama-3-8B: {P8:,}")                                      # 8,030,261,248

Последняя строка — проверка на модели с GQA: Llama-3-8B официально имеет 8 030 261 248 параметров, и калькулятор это число воспроизводит.

Что сделать руками

1. Данные. Возьмите 10 000 строк любого веб-корпуса (например, кусок FineWeb из урока 5.1.2) и реализуйте три правила из §4.2.1: доля «мусорных» символов, повтор строки больше $N$ раз, отсутствие частых служебных слов. Сколько документов отсеяло каждое правило? Посмотрите глазами на 20 выброшенных — нет ли там хорошего текста?
2. Дедупликация. Добавьте к примеру MinHash разбиение подписи на полосы (например, 32 полосы по 4 значения) и найдите почти-дубликаты в том же корпусе без сравнения всех пар.
3. Сжатие токенизатора. Посчитайте байты UTF-8 на токен для токенизаторов GPT-2, LLaMA-2 и Qwen на одном русском и одном китайском абзаце. Какой токенизатор выгоднее для русского?
4. Критические подпространства. Повторите наш расчёт числа «недообученных» пар RoPE для своей модели из урока 5.6 и посмотрите, как оно меняется с основанием $b$.
5. Бюджет. С помощью калькулятора оцените, сколько дней на 8 картах по 80 ГБ (реально ~200 TFLOPS) займёт предобучение модели на 1B параметров на 20B и на 200B токенов, и какая схема ZeRO нужна, чтобы влезть в память.

Словарик

English	Русский
data preparation	подготовка данных
quality filtering	фильтрация по качеству
deduplication	дедупликация
privacy, PII	персональные данные, приватность
tokenization	токенизация
data mixture	пропорции (смесь) данных
data curriculum	учебный план данных (curriculum)
normalization	нормализация
activation function	функция активации
position encoding	позиционная кодировка
rotary position embedding	RoPE
mixture of experts	смесь экспертов (MoE)
position interpolation	интерполяция позиций
state space model	модель пространства состояний (SSM)
learning rate warmup	разогрев скорости обучения
gradient clipping	обрезка градиента
tensor / pipeline parallelism	тензорный / конвейерный параллелизм
zero redundancy optimizer	ZeRO
activation recomputation	пересчёт активаций
mixed precision training	обучение со смешанной точностью
GPU memory	видеопамять
compute, FLOPs	объём вычислений (FLOPs)