Законы масштабирования

Зачем это нужно

Финальный прогон предобученияпредобучение, претрейнEN pretraining DeepSeek-V3 занял около 2.7 млн GPU-часовGPU-часыEN GPU hoursЧисло ускорителей × часы работы. 2048 GPU за сутки — 49 152 GPU-часа.. При таком бюджете ошибка в выборе размера модели стоит миллионы долларов. И узнать о ней можно только через два месяца, когда обучение закончится.

Законы масштабированиязаконы масштабированияEN scaling laws позволяют ответить до запуска: какой loss получится при данном бюджете вычисленийвычислительные мощностиEN compute, какую модель и на скольких токенах учить, сколько это займёт дней. Они же объясняют решения, которые иначе выглядят странно: почему 8-миллиардную модель кормят 15 триллионами токенов и почему китайские лаборатории столько пишут об эффективности, а не просто «берут больше видеокарт».

В этом уроке вы привыкнете считать «на салфетке»: FLOPs → GPU-часы → дни → деньги. Это главный навык инженера, который планирует обучение, от маленькой модели в модуле 5.6 до фронтирной.

Степенной закон: прямая в логарифмических осях

Обучите десяток моделей разного размера и нарисуйте итоговый loss против числа параметров $N$. В обычных осях получится кривая, которая быстро падает и потом почти выходит на плато. В логарифмических осях по обеим координатам точки ложатся на прямую. Это и есть степенной законстепенной законEN power lawЗависимость вида y = a·x^(−α); в логарифмических осях — прямая.:

$$L(N) = \left(\frac{N_c}{N}\right)^{\alpha_N} \quad\Longleftrightarrow\quad \log L = \alpha_N \log N_c - \alpha_N \log N$$

Правая запись получается из левой логарифмированием: $\log(a/b)^{k} = k(\log a - \log b)$ (урок 1.0.2). Это уравнение прямой $y = \text{const} - \alpha_N x$, где $x = \log N$, $y = \log L$. Здесь $N_c$ — подгоночная константа, «масштаб» по оси параметров (у Kaplan $N_c \approx 8.8 \cdot 10^{13}$); отдельного физического смысла у неё нет. Главное — показатель степени $\alpha_N$: это наклон прямой, и он говорит, сколько даёт каждое удвоение. В работе Kaplan et al. (2020) получилось $\alpha_N \approx 0.076$:

• удвоили параметры — loss умножился на $2^{-0.076} \approx 0.949$, то есть упал примерно на 5%;
• увеличили в 10 раз — loss упал примерно на 16%;
• чтобы снизить loss вдвое только за счёт параметров, их нужно увеличить в $2^{1/0.076} \approx 9000$ раз.

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

Второе правило: у loss есть дно. Естественный текст сам по себе непредсказуем (какое слово автор выберет следующим, не знает никто), поэтому в реальных подгонках добавляют неустранимую частьнеустранимый lossEN irreducible lossЧасть loss, которую нельзя убрать никаким масштабом, — непредсказуемость самого текста (слагаемое E в формуле Chinchilla). $E$: $L(N) = E + (N_c / N)^{\alpha_N}$. Её нельзя побить никаким масштабом: она отражает энтропию самого языка (урок 1.3.3). Из-за $E$ прямая в логарифмических осях со временем изгибается и выходит на полку.

Сколько стоит обучение: C ≈ 6ND

Чтобы планировать, нужна единица измерения. Это FLOPs, число операций с плавающей точкойFLOPs, число операций с плавающей точкойEN floating-point operations (FLOPs)Не путайте FLOPs (сколько операций нужно сделать) и FLOP/s, FLOPS (сколько операций железо делает в секунду). — число операций с плавающей точкой за всё обучение. Удобная оценка для плотного трансформера:

$$C \approx 6 \cdot N \cdot D,$$

где $N$ — число параметров, $D$ — число токенов обучения.

Откуда шестёрка, видно на одном линейном слое $y = xW$, где $W$ — матрица $d_{in} \times d_{out}$:

1. Прямой проходпрямой проходEN forward passВычисление выхода и loss по графу от входов к выходу с запоминанием промежуточных значений для обратного прохода.. Каждый выход — это $d_{in}$ умножений и $d_{in}$ сложений. На один токен: $2 \cdot d_{in} \cdot d_{out}$ FLOPs, то есть 2 FLOPs на параметр.
2. Обратный проход. Нужно посчитать два градиента: по входу ($\partial L / \partial x = \partial L / \partial y \cdot W^\top$) и по весам ($\partial L / \partial W = x^\top \cdot \partial L / \partial y$, урок 1.2.3). Каждый — такое же умножение матриц, итого 4 FLOPs на параметр.

В трансформере почти все параметры сидят в таких матрицах, поэтому $2 + 4 = 6$ FLOPs на параметр на токен.

Модель	Параметры $N$	Токены $D$	Токенов на параметр	$C = 6ND$
GPT-3 (2020)	175B	300B	1.7	$3.2 \cdot 10^{23}$
Gopher (DeepMind, 2021)	280B	300B	1.1	$5.0 \cdot 10^{23}$
Chinchilla (DeepMind, 2022)	70B	1.4T	20	$5.9 \cdot 10^{23}$
Llama 3 8B (2024)	8B	15T	≈1900	$7.2 \cdot 10^{23}$
DeepSeek-V3 (2024)	37B активных из 671B	14.8T	≈400 на активный	$3.3 \cdot 10^{24}$

Для смесь экспертовсмесь экспертов (MoE)EN mixture of experts (MoE) в формулу подставляют активные параметрыактивные параметрыEN activated (active) parametersСколько параметров MoE-модели реально участвует в обработке одного токена. «A22B» в названии Qwen3-235B-A22B — 22 млрд активных из 235 млрд.: каждый токен проходит только через выбранных экспертов, остальные веса в его вычислениях не участвуют.

Чего не видит формула 6ND

Она не учитывает само внимание: умножения $QK^\top$ и весов внимания на $V$ не связаны с параметрами и растут с длиной контекста $n_{ctx}$. Грубая прикидка: в слое около $12 d_{model}^2$ параметров (урок 4.6.2), то есть на токен уходит около $2 \cdot 12 d_{model}^2$ FLOPs, а внимание к предыдущим токенам стоит порядка $2 \cdot n_{ctx} \cdot d_{model}$. Отсюда оценка Kaplan et al.: внимание добавляет к $6N$ примерно $n_{ctx} / (12 d_{model})$. Для $d_{model} = 4096$ и контекста 4096 это +8% — можно пренебречь. Для контекста 32 768 — уже +67%, поэтому при обучении на длинных контекстах (модуль 5.5) формулу приходится уточнять.

От FLOPs к дням и деньгам

Видеокарта не работает на паспортной скорости. Часть времени уходит на чтение памяти, обмен между картами, ожидание данных. Долю пика, которая реально тратится на полезные FLOPs модели, называют утилизация FLOPs моделиутилизация FLOPs модели (MFU)EN model FLOPs utilization (MFU)Доля пиковой производительности железа, которая уходит на полезные вычисления модели. Для больших распределённых обучений типичны 30–50 %. (Model FLOPs Utilization). Хорошее значение — 35–50%; у PaLM (Google, 2022) было около 46%.

$$\begin{gathered} \text{время} = \frac{C}{n_{GPU} \cdot \text{пик} \cdot \text{MFU}}, \\ \text{стоимость} = \frac{C}{\text{пик} \cdot \text{MFU} \cdot 3600} \cdot \text{цена GPU-часа} \end{gathered}$$

Здесь пик — в FLOP/с на одну карту, поэтому время получается в секундах, а деление на 3600 переводит GPU-секунды в GPU-часы. Пиковая производительность в BF16 (без учёта разреженности): A100 — 312 TFLOPS, H100 SXM — 989 TFLOPS. Обратите внимание: стоимость не зависит от числа карт. Тысяча карт на 17 дней стоит столько же, сколько две тысячи на 8.5 дня. Больше карт сокращают время, но не цену, и то лишь пока обучение хорошо параллелится: на тысячах карт MFU обычно падает из-за обмена данными.

Пример: Chinchilla на 1000 H100. $C = 5.88 \cdot 10^{23}$, MFU 40%:

$$\frac{5.88 \cdot 10^{23}}{1000 \cdot 989 \cdot 10^{12} \cdot 0.4} \approx 1.49 \cdot 10^{6}\ \text{с} \approx 17\ \text{дней}.$$

Это около 413 тыс. GPU-часов, то есть примерно 0.83 млн долл. при аренде по 2 долл. за час.

Проверка на DeepSeek-V3. В техотчёте указано около 2.66 млн GPU-часов H800 на предобучение (и 2.79 млн всего, вместе с расширением контекста и пост-обучением). Подставим: $3.3 \cdot 10^{24}$ FLOPs за $2.66 \cdot 10^6$ часов — это около 343 TFLOPS полезной работы на карту. H800 — версия H100 с урезанной межчиповой связью, но с теми же вычислительными блоками; 343 TFLOPS — это примерно 35% её пика в BF16. Цифры отчёта сходятся с оценкой «на салфетке». Оговорка: большую часть матричных умножений V3 считала в FP8, где пик карты вдвое выше (урок 5.4.1), а $6ND$ не учитывает внимание и модуль MTP. Так что точная загрузка другая, но порядок величины совпадает, и это главное. Знаменитые «5.6 млн долл.» — это 2.79 млн часов по 2 долл., только финальный прогон: без экспериментов, неудачных запусков и зарплат.

Посчитайте сами

Калькулятор ниже делает ровно этот расчёт: FLOPs ≈ 6·N·D → GPU-часы → дни → деньги. Выберите пресет «как DeepSeek-V3» и сравните результат с 2.788 млн GPU-часов из техотчёта. Потом выберите пресет «Ваша машина» (4× RTX 4080) и посмотрите, сколько займёт обучение модели на 30M параметров и на 0.5B.

Калькулятор стоимости обученияинтерактив

Модель и данные

Активных параметров N, млрдТокенов D, млрд

Железо и цена

MFU (доля пиковой мощности), %Число GPUЦена GPU-часа, долл.

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

Kaplan 2020: «растите модель»

Команда OpenAI обучила множество моделей — от 768 параметров до 1.5 млрд (без учёта эмбеддингов) — и нашла три степенных закона: по параметрам ($\alpha_N \approx 0.076$), по данным ($\alpha_D \approx 0.095$) и по вычислениям. Детали архитектуры (глубина или ширина, число голов) влияли на loss гораздо слабее, чем просто число параметров.

Главный практический вывод касался распределения бюджета. По их подгонке оптимальный размер модели растёт как $N_{opt} \propto C^{0.73}$ (значок $\propto$ читается «пропорционально»: равно $C^{0.73}$ с точностью до постоянного множителя), а данные — как $D \propto C^{0.27}$. Если вычислений стало в 10 раз больше, модель нужно увеличить в $10^{0.73} \approx 5.4$ раза, а данные — всего в $10^{0.27} \approx 1.9$ раза. Девиз: большие модели эффективнее используют данные, поэтому учите большую модель и останавливайтесь рано.

GPT-3 сделана в этом духе: 175B параметров и всего 300B токенов, меньше двух токенов на параметр.

Chinchilla 2022: «поровну»

Через два года DeepMind перепроверила выводы. Авторы обучили больше 400 моделей от 70M до 16B параметров на 5–500 млрд токенов и оценили оптимум тремя независимыми способами:

1. Огибающая кривых обучения. Для каждого бюджета $C$ смотрим, какая модель к этому моменту дала минимальный loss.
2. IsoFLOP-кривые. Фиксируем бюджет, перебираем размер модели (данные подстраиваются: $D = C / 6N$) и ищем минимум получившейся «параболы».
3. Параметрическая подгонка всей поверхности loss формулой $L(N, D)$.

Все три способа сошлись: $N_{opt} \propto C^{a}$ и $D_{opt} \propto C^{b}$ с $a \approx b \approx 0.5$. Удвоили бюджет — увеличьте и модель, и данные в $\sqrt{2} \approx 1.4$ раза. Отношение получилось около 20 токенов на параметр. Вычислительно-оптимальнаявычислительно-оптимальное обучениеEN compute-optimal trainingТакое деление бюджета между размером модели и числом токенов, при котором loss минимален; по Chinchilla — около 20 токенов на параметр. модель для бюджета $C$:

$$\begin{gathered} C = 6 N D = 6 \cdot N \cdot 20 N \;\Rightarrow\; N_{opt} = \sqrt{C / 120}, \\ D_{opt} = 20 \, N_{opt}. \end{gathered}$$

Пример: бюджет $C = 1.2 \cdot 10^{21}$ FLOPs даёт $N_{opt} = \sqrt{10^{19}} \approx 3.2$B параметров и $D_{opt} \approx 63$B токенов. Вот весь план «на салфетке» одной схемой:

flowchart LR
B["Бюджет: GPU × дни × MFU"] --> C["C, FLOPs"]
C --> N["N = √(C / 120)"]
C --> D["D = 20 · N"]
N --> L["Ожидаемый loss L(N, D)"]
D --> L
N --> I["Цена инференса ≈ 2N FLOPs на токен"]

Планирование обучения по правилу Chinchilla

Проверка боем: Chinchilla (70B, 1.4T токенов) против Gopher (280B, 300B токенов) при почти одинаковом бюджете. Модель в 4 раза меньше выиграла на большинстве тестов, например 67.5% против 60% на MMLU (вопросы с вариантами ответа по 57 предметам, урок 7.3.1), и при этом в 4 раза дешевле на инференсе.

Почему Kaplan ошибся

Чаще всего называют две причины. Первая — расписание learning rate. У Kaplan все модели учили с одним и тем же косинусным расписанием, а loss для меньшего числа токенов брали из промежуточных точек этих прогонов. Но в середине расписания learning rate ещё не снижен, и loss там выше, чем у модели, чьё расписание закончилось бы именно на этом числе токенов. Авторы Chinchilla показали, что такие завышенные промежуточные оценки исказили зависимость loss от данных и сдвинули вывод в пользу больших моделей. Вторая — масштаб: модели были маленькими, а параметры эмбеддингов не учитывались, что на малых размерах заметно искажает наклон (это показали более поздние разборы, например Pearce и Song, 2024). Вывод для практики: закон масштабирования верен ровно настолько, насколько аккуратны эксперименты под ним.

Формула, которую можно потрогать

Подход 3 дал параметрическую формулу:

$$L(N, D) = \underbrace{1.69}_{E} + \frac{406.4}{N^{0.34}} + \frac{410.7}{D^{0.28}}$$

Три слагаемых: неустранимый loss языка, штраф за маленькую модель и штраф за мало данных. Посчитаем IsoFLOP-срез при бюджете Chinchilla $C = 5.88 \cdot 10^{23}$ ($D = C / 6N$):

$N$	$D$	Токенов на параметр	$L(N, D)$
10B	9.8T	980	1.946
30B	3.3T	109	1.930
70B	1.4T	20	1.937
280B (Gopher)	350B	1.2	1.983

Две важные детали. У подгонки 3 оптимум сдвинут к меньшим моделям (30–40B), чем у подходов 1 и 2 (около 70B); в 2024 году исследователи Epoch AI (Besiroglu et al.) попытались воспроизвести эту подгонку по данным из графиков статьи и пришли к коэффициентам, которые лучше согласуются с «20 токенами». Но главное — дно очень плоское: 30B и 70B различаются на 0.3%. Это наблюдение и открыло дорогу следующему разделу.

Почему сейчас модели «перекармливают»

Посмотрите, на скольких токенах учат современные открытые модели:

Модель	Параметры	Токены	Токенов на параметр
Chinchilla (2022)	70B	1.4T	20
Llama 2 7B (2023)	7B	2T	≈290
Llama 3 8B (2024)	8B	15T	≈1900
Qwen3 (2025), вся линейка	0.6B–235B	≈36T	у 0.6B — десятки тысяч

Это сознательное перекармливание даннымиперекармливание данными, обучение сверх оптимумаEN overtrainingНе путать с переобучением (overfitting). Модель обучают на гораздо большем числе токенов, чем советует Chinchilla, чтобы она была меньше и дешевле на инференсе. (overtraining). Причин несколько.

1. Chinchilla оптимизирует только цену обучения. А модель потом годами работает на инференсеинференс, вывод моделиEN inferenceСм. «reasoning»: в китайском одно и то же слово., где каждый токен стоит около $2N$ FLOPs. Пусть за жизнь модель сгенерирует 10 трлн токенов. Для 70B это $2 \cdot 70 \cdot 10^9 \cdot 10^{13} = 1.4 \cdot 10^{24}$ FLOPs — больше, чем стоило её обучение ($5.9 \cdot 10^{23}$). Для 8B — $1.6 \cdot 10^{23}$, в 8.75 раза меньше.

2. Оптимум плоский. По формуле Chinchilla модель 8B на 15T токенах получает $L \approx 1.949$ против $1.937$ у Chinchilla 70B — хуже всего на 0.6%. Чтобы догнать её точно, 8B-модели нужно около 26T токенов: обучение обойдётся примерно в 2.1 раза дороже, зато каждый сгенерированный токен будет в 8.75 раза дешевле. Для популярной модели это выгодная сделка.

3. Обучение не насыщается. Meta писала, что её 8B и 70B продолжали улучшаться лог-линейно вплоть до 15T токенов, хотя «по Chinchilla» для 8B, по её же оценке, хватило бы около 200B (наше правило $20 \cdot 8$B даёт 160B — тот же порядок).

4. Железо. Модель на 0.6–8B помещается на одну видеокарту, ноутбук или телефон. Задержка ответа ниже, сервис проще.

Ограничение у этого подхода одно — данные. Качественного человеческого текста конечное количество, и разговоры о «стене данных»стена данныхEN data wallПредел роста за счёт новых человеческих текстов — качественных данных в интернете конечное количество. идут с 2022 года. Повторять данные можно: в экспериментах Muennighoff et al. (2023) до 4 эпох по одному и тому же тексту давали почти такой же результат, как свежие данные, а дальше польза быстро падала. Как выжимать из интернета больше качественных токенов и где брать синтетические, разберём в следующем уроке.

Правило 2026 года

«20 токенов на параметр» — это нижняя граница для серьёзной модели, а не цель. Если модель будут много использовать, выгоднее взять её меньше и учить дольше. Обратное (большая модель на малом числе токенов) почти всегда ошибка.

Эмерджентность и споры о ней

В 2022 году Wei et al. описали эмерджентные способностиэмерджентные способностиEN emergent abilities (китайский термин буквально значит «хлынувшие наружу способности»): способность почти отсутствует у малых моделей и резко появляется у больших. На графиках качество на арифметике, перестановке букв или многозадачных тестах держится на уровне случайного угадывания, а где-то между $10^{22}$ и $10^{24}$ FLOPs подскакивает. Это звучало как «количество переходит в качество» и подогревало ожидания: никто не знает, что появится на следующем масштабе.

В 2023 году Schaeffer, Miranda и Koyejo предложили простое объяснение: скачок создаёт метрика. Точное совпадениеточное совпадение (EM)EN exact matchМетрика «1, если нормализованный ответ совпал с эталоном, иначе 0». Всё решает нормализация и извлечение ответа. (exact match) — это всё или ничего. Пусть модель угадывает каждый токен ответа с вероятностью $p$, и $p$ растёт с масштабом плавно. Тогда ответ из 10 токенов верен с вероятностью $p^{10}$:

Точность на токен $p$	0.5	0.7	0.8	0.9	0.95	0.99
Точность ответа $p^{10}$	0.001	0.028	0.107	0.349	0.599	0.904

Пока $p$ растёт от 0.5 до 0.8, метрика почти не двигается. Затем за пару шагов масштаба взлетает. Если посчитать непрерывную метрику — вероятность правильного ответа, редакционное расстояние (сколько символов нужно исправить, чтобы получить правильный ответ) — рост оказывается плавным.

Спор на этом не закончился. Команда Zhipu AI и Университета Цинхуа (Du et al., 2024) посмотрела на эмерджентность «со стороны loss» (статья «Understanding Emergent Abilities of Language Models from the Loss Perspective»): качество на задачах лучше предсказывается loss предобучения, чем размером модели, а некоторые способности появляются, только когда loss опускается ниже порога, независимо от того, какой ценой этот loss получен.

Практические выводы:

• loss предсказуем, конкретные способности — гораздо хуже;
• в своих маленьких экспериментах смотрите на непрерывные метрики (лог-вероятность правильного ответа), а не только на точность;
• к заявлениям «на масштабе X внезапно появилось Y» относитесь с вопросом «а какой метрикой меряли?».

Практика

Соберите калькулятор, которым будете пользоваться весь курс: FLOPs, оптимум Chinchilla, GPU-часы, дни, деньги и предсказанный loss. Тесты сверяют ответы с цифрами этого урока.

Калькулятор обучения LLM6 тестов

import math

# Параметрическая подгонка Chinchilla (Hoffmann et al., 2022, подход 3):
# L(N, D) = E + A / N^alpha + B / D^beta
E, A, B, ALPHA, BETA = 1.69, 406.4, 410.7, 0.34, 0.28


def train_flops(n_params, n_tokens):
    """FLOPs на обучение модели с n_params параметрами на n_tokens токенах (правило 6·N·D)."""
    # TODO
    ...


def chinchilla_optimal(compute, tokens_per_param=20):
    """Вернуть (N, D): размер модели и число токенов при бюджете compute FLOPs,
    если на каждый параметр приходится tokens_per_param токенов."""
    # TODO
    ...


def gpu_hours(flops, peak_tflops, mfu):
    """Сколько GPU-часов займёт обучение.
    peak_tflops — пиковая производительность одной карты в TFLOPS (1 TFLOPS = 1e12 FLOP/с),
    mfu — доля пика, которую реально удаётся использовать (0..1)."""
    # TODO
    ...


def train_days(flops, n_gpus, peak_tflops, mfu):
    """Сколько суток займёт обучение на n_gpus картах."""
    # TODO
    ...


def train_cost(flops, peak_tflops, mfu, price_per_gpu_hour):
    """Стоимость обучения при аренде (цена одного GPU-часа в долларах)."""
    # TODO
    ...


def chinchilla_loss(n_params, n_tokens):
    """Предсказанный loss по формуле L(N, D) = E + A / N^ALPHA + B / D^BETA."""
    # TODO
    ...


def best_model_size(compute, candidates):
    """Из списка размеров candidates выбрать тот, что даёт минимальный chinchilla_loss
    при фиксированном бюджете compute (данные: D = compute / (6·N))."""
    # TODO
    ...


# Проверьте себя кнопкой «Запустить»:
c = train_flops(70e9, 1.4e12)
print(c)
print(chinchilla_optimal(c) if c else "сначала реализуйте train_flops")

ЗапуститьПроверитьПодсказкаСбросить

Когда тесты пройдут, посчитайте свой проект из модуля 5.6. Модель на 25M параметров по Chinchilla хочет $20 \cdot 25 \cdot 10^6 = 500$M токенов, это $6 \cdot 25 \cdot 10^6 \cdot 5 \cdot 10^8 = 7.5 \cdot 10^{16}$ FLOPs. Если видеокарта реально выдаёт 20 TFLOPS — около часа. Процессор, который выдаёт условные 0.2 TFLOPS, будет считать то же больше четырёх суток. Поэтому на CPU разумно брать модель меньше и токенов меньше.

🖥 На вашей машине (4×GPU)

Посчитайте бюджет своей лаборатории тем же способом, каким выше мы проверяли DeepSeek-V3.

1. Измерьте пик. Скрипт умножает две большие матрицы и делит число операций на время:

"""peak_tflops.py — сколько FLOPs в секунду устройство реально выдаёт на большом умножении матриц.

python peak_tflops.py cuda:0     (одна видеокарта, BF16)
python peak_tflops.py cpu        (процессор, FP32)
"""
import sys
import time

import torch

dev = sys.argv[1] if len(sys.argv) > 1 else "cpu"
gpu = dev.startswith("cuda")
# тензорные ядра — специальные блоки GPU для умножения матриц в BF16/FP16; на CPU их нет, считаем в FP32
dtype = torch.bfloat16 if gpu else torch.float32
N, reps = (8192, 50) if gpu else (4096, 5)
a = torch.randn(N, N, device=dev, dtype=dtype)
b = torch.randn(N, N, device=dev, dtype=dtype)


def sync():
    if gpu:
        torch.cuda.synchronize(dev)                  # GPU работает асинхронно: ждём, пока он досчитает


a @ b                                                # прогрев
sync()
t0 = time.perf_counter()
for _ in range(reps):
    a @ b
sync()
dt = (time.perf_counter() - t0) / reps
print(f"{dev}, {dtype}, N = {N}: {2 * N**3 / dt / 1e12:.2f} TFLOPS")   # 2·N³ FLOPs на умножение N×N на N×N

По паспорту (whitepaper NVIDIA по архитектуре Ada) у RTX 4080 около 97 TFLOPS в BF16 на тензорных ядрах, без учёта разреженности. На большом умножении вы, скорее всего, увидите меньше паспорта. Процессор в FP32 выдаст порядка единиц TFLOPS или меньше (наш небольшой тестовый сервер показал 0.45). Разница в десятки раз — главная причина, почему практика с этой ступени переезжает на видеокарты. Запишите оба числа в журнал.

2. Бюджет в FLOPs. Возьмём паспортные 97.5 TFLOPS на карту и MFU 30% (для маленьких моделей на GeForce это скорее оптимистично, проверьте в шаге 3). Модель по Chinchilla — $N_{opt} = \sqrt{C / 120}$ и $D_{opt} = 20 N_{opt}$:

Сколько учим	1 карта: $C$	1 карта: модель и токены	4 карты: $C$	4 карты: модель и токены
ночь, 8 ч	$8.4 \cdot 10^{17}$	84M на 1.7B	$3.4 \cdot 10^{18}$	168M на 3.4B
сутки	$2.5 \cdot 10^{18}$	145M на 2.9B	$1.0 \cdot 10^{19}$	290M на 5.8B
неделя	$1.8 \cdot 10^{19}$	384M на 7.7B	$7.1 \cdot 10^{19}$	768M на 15B

Для масштаба — чужие модели на тех же четырёх картах и при тех же допущениях: GPT-2 small (124M) по Chinchilla, то есть на 2.5B токенов, — около 4–5 часов; minimind-3 (64M) на 1.3B токенов — около часа; Qwen3-0.6B на 36T токенов — около 35 лет; DeepSeek-V3 — около 900 лет. Даже 768M из последней строки помещаются в память при обычном обучении с AdamW: 16 байт на параметр (веса, градиенты, мастер-копия и два момента Adam — разберём в уроке 5.4.1) — около 12 ГБ на карту плюс активации. Для моделей крупнее понадобится FSDP (урок 5.4.3).

3. Измерьте свой MFU. $\text{MFU} = 6 \cdot N \cdot \text{токенов в секунду} / (\text{число карт} \cdot \text{пик})$. Например, если модель на 25.8M параметров (конфигурация M из урока 5.6.2) обучается со скоростью 150 тыс. токенов в секунду на одной карте, это $6 \cdot 25.8 \cdot 10^6 \cdot 1.5 \cdot 10^5 \approx 23$ TFLOPS, то есть MFU около 24%. Это пример, а не замер: настоящую скорость печатает train.py из того урока. У маленьких моделей MFU обычно ниже, чем у больших: матрицы мелкие, и накладные расходы занимают большую долю времени.

4. Подставьте в калькулятор. Выберите GPU «RTX 4080 — ~97 TFLOPS», впишите свой замеренный MFU и число GPU — 4. Пресет «Ваша машина» уже настроен на эти значения.

Столбцы «4 карты» предполагают идеальное масштабирование. Ваши карты связаны через PCIe без NVLink, и часть времени уйдёт на обмен градиентами. Та же проблема заставила DeepSeek на урезанных H800 придумать DualPipe; насколько она заметна у вас, вы измерите в уроке 5.4.3. Настройка карт и проверка связи между ними — на странице «Ваша лаборатория (4×GPU)».

Китайский угол: законы масштабирования по-китайски

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

DeepSeek LLM (январь 2024, arXiv:2401.02954). Ещё до V2 и V3 DeepSeek опубликовала собственное исследование масштабирования, и в нём три идеи, которые полезно знать инженеру:

• вместо числа параметров $N$ авторы используют $M$ — FLOPs на токен без эмбеддингов, но с учётом внимания, и пишут бюджет как $C = M \cdot D$. Это точнее, чем $6N$, особенно для небольших моделей;
• законы масштабирования строятся и для гиперпараметров: оптимальный размер батча растёт с бюджетом, а оптимальный learning rate падает, оба — по степенному закону. Гиперпараметры большой модели подбирают по маленьким прогонам;
• оптимальное деление бюджета зависит от качества данных: чем чище данные, тем выгоднее вкладывать вычисления в размер модели. Этим авторы объясняют, почему у Kaplan и Chinchilla получились разные показатели степени: корпуса были разного качества.

MiniCPM (ModelBest, OpenBMB и Университет Цинхуа, 2024). Авторы маленьких моделей MiniCPM популяризовали расписание learning rate WSD (warmup — stable — decay), которое вы уже видели в уроке 4.6.3: короткий разогрев, длинное плато и короткий спад. Для законов масштабирования оно особенно удобно: из одного длинного прогона можно «ответвить» спад в любой момент и получить модели для разных $D$ ценой только короткой фазы спада, а не отдельного обучения с нуля для каждого $D$. Так гораздо дешевле строить кривые масштабирования. По их оценке, вычислительно-оптимальное число токенов на параметр получилось заметно больше чиншилловских 20.

DeepSeek-V3. Расчёт выше показывает, как работает экономия: модель хранит 671B параметров, но из-за MoE каждый токен стоит как 37B. Обучение в FP8 и расписание DualPipe, которое прячет обмен данными между картами за вычислениями, снижают цену обучения ещё сильнее, а MLA удешевляет инференс (модули 5.2–5.4).

Почитать по-китайски: глава 9 «Scaling Laws» в Datawhale diy-llm — китайская адаптация Stanford CS336 с заданием на подгонку законов масштабирования.

Проверь себя

Проверь себя6 вопросов·

1 Сколько FLOPs нужно, чтобы обучить плотную модель на 1B параметров на 20B токенах? Ответ дайте в единицах $10^{20}$.

2 Бюджет вычислений вырос в 4 раза. Как, по Chinchilla, изменить модель и данные?

Модель ×4, данные без измененийМодель ×2, данные ×2Модель ×2.75, данные ×1.45 (как у Kaplan)Модель без изменений, данные ×4

3 Сколько токенов нужно 7B-модели, чтобы обучиться вычислительно-оптимально по правилу Chinchilla? Ответ в миллиардах.

4 Какие причины заставляют обучать модели далеко за оптимумом Chinchilla?Можно выбрать несколько ответов

Каждый токен на инференсе стоит около $2N$ FLOPs, и маленькая модель окупается при массовом использованииВблизи оптимума loss меняется очень слабо, поэтому меньшая модель теряет немногоМаленькая модель помещается на одну карту или устройствоChinchilla неправильно считает FLOPs обучения

5 Как посчитать $N$ в формуле $C \approx 6ND$ для MoE-модели DeepSeek-V3 (671B всего, 37B активных)?

671B — все параметры37B — активные параметры на токен(671 + 37) / 2Формула к MoE неприменима

6 Точность на токен выросла с 0.8 до 0.9. Во сколько раз выросла точность ответа из 10 токенов по метрике exact match? Округлите до одного знака.

Проверить ответы

Итоги

• Loss падает по степенному закону от параметров, данных и вычислений: предсказуемо, но каждый процент дороже предыдущего.
• Обучение стоит $C \approx 6ND$ FLOPs; время и деньги получаются делением на пик GPU и MFU (обычно 35–50%).
• Chinchilla: при фиксированном бюджете модель и данные растут как $\sqrt{C}$, около 20 токенов на параметр. Kaplan переоценил выгоду от размера.
• Сегодня модели перекармливают данными (сотни и тысячи токенов на параметр): оптимум плоский, а инференс маленькой модели дешевле.
• «Эмерджентные» скачки часто создаёт разрывная метрика; loss предсказуем лучше, чем отдельные способности.

Дальше: откуда берутся триллионы токенов — Common Crawl, фильтрация, дедупликация и смеси данных: Данные для претрейна.