дорожка · 28.10.2026 · законы масштабирования

Сколько параметров и сколько данных: законы масштабирования

Прежде чем потратить миллионы долларов на обучение, лаборатория отвечает на вопрос: при этом бюджете вычислений модель какого размера брать и на скольких токенах её учить. Ответ дают законы масштабирования (scaling laws): измеренные на маленьких запусках зависимости потери от числа параметров, объёма данных и вычислений, которые потом продлевают на большие. Разберём, как выглядит такой закон и как его подгоняют, как считают бюджет обучения, что показала работа Chinchilla, почему современные небольшие модели учат намного дольше «оптимума» и где эти законы перестают предсказывать то, что тебе важно. Опираемся на дорожку о функции потерь и о цене и скорости. Все примеры — расчёты на numpy; код на странице мы запускали, выводы взяты из этих запусков, а где число — наше предположение, так и сказано.

Все дорожки — /put. Прошлая — дистилляция знаний.

1 Степенной закон: как потеря падает с размером и почему нужен «пол»

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

Как это устроено. Каплан и соавторы (OpenAI, 2020, «Scaling Laws for Neural Language Models») обучили много моделей разного размера и измерили потерю на отложенном тексте — среднюю «удивлённость» модели следующим токеном, ту самую перекрёстную энтропию из дорожки о потерях. Оказалось, что если ничто другое не ограничивает, потеря падает как степень от числа параметров N: L ≈ A / Nα. Такую зависимость называют степенным законом (power law): увеличение N в 10 раз уменьшает потерю на одну и ту же долю, сколько бы параметров ни было. В логарифмических осях это прямая с наклоном −α. Похожие законы они нашли для объёма данных D (числа токенов обучения) и для вычислений C.

Шаги построения такие: выбирают одну архитектуру и один набор данных; обучают серию моделей от маленьких к средним; для каждой берут потерю в конце обучения; рисуют точки в логарифмах и подгоняют кривую; затем продлевают её на размер, который собираются обучать. Важно, что каждая точка — это отдельный законченный запуск. Этим закон масштабирования отличается от кривой обучения (learning curve), где по оси X идут шаги одного запуска.

Главное ограничение — у потери есть пол. Даже бесконечная модель не угадает следующий токен в живом тексте наверняка, потому что сам текст содержит случайность: имена, числа, выбор слов. Эту неустранимую часть обозначают E, и полная форма закона — L = E + A / Nα. Чистая прямая в логарифмах годится, пока потеря далеко от пола; ближе к нему кривая выпрямляется в горизонталь, и прогноз без E начинает врать в сторону излишнего оптимизма.

Подробный пример. Сделаем «истинный» закон L = 1,8 + 12 / N0,3, «измерим» его на шести маленьких моделях от миллиона до 300 миллионов параметров с шумом в 1% и подгоним двумя способами: прямой в логарифмах без пола и той же формой с полом E, который перебираем. Потом продлим оба прогноза на модели в 1, 10 и 100 миллиардов параметров:

import numpy as np
rng = np.random.default_rng(0)
# Игрушечный «закон»: потеря = 1.8 + 12 / N**0.3, плюс шум измерения ±1%
N = np.array([1e6, 3e6, 1e7, 3e7, 1e8, 3e8])          # параметры маленьких пробных моделей
L = (1.8 + 12 / N**0.3) * (1 + 0.01 * rng.standard_normal(N.size))
# Подгонка 1: прямая в логарифмах, без постоянной части (без «пола»)
k, b = np.polyfit(np.log(N), np.log(L), 1)
# Подгонка 2: с полом E — перебираем E и для каждого подгоняем прямую к log(L - E)
best = None
for E in np.arange(0.0, 2.2, 0.01):
    if (L - E).min() <= 0: break
    kk, bb = np.polyfit(np.log(N), np.log(L - E), 1)
    err = np.sum((E + np.exp(bb) * N**kk - L) ** 2)
    if best is None or err < best[0]: best = (err, E, kk, bb)
_, E, kk, bb = best
print(f"подгонка без пола: наклон {k:.3f}; с полом: E={E:.2f}, наклон {kk:.3f}")
for n in [1e9, 1e10, 1e11]:
    true = 1.8 + 12 / n**0.3
    print(f"N={n:.0e}: истина {true:.3f} | без пола {np.exp(b)*n**k:.3f} | с полом {E+np.exp(bb)*n**kk:.3f}")

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

подгонка без пола: наклон -0.014; с полом: E=1.80, наклон -0.298
N=1e+09: истина 1.824 | без пола 1.791 | с полом 1.824
N=1e+10: истина 1.812 | без пола 1.733 | с полом 1.812
N=1e+11: истина 1.806 | без пола 1.677 | с полом 1.806

Подгонка с полом нашла E = 1,80 и наклон −0,298, почти точно истинные 1,8 и −0,3, и её прогноз совпал с истиной на всех трёх размерах. Подгонка без пола получила наклон −0,014: она пытается описать горизонтальный участок прямой линией. На 100 миллиардах параметров она обещает потерю 1,677, хотя истинная 1,806 и ниже 1,8 не опустится никогда. В реальных отчётах разница бывает меньше, но направление ошибки то же: забытый пол делает большие модели в прогнозе лучше, чем они получатся.

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

  • Продлевают прямую на три-четыре порядка дальше последней измеренной точки и считают прогноз фактом. Чем дальше продление, тем сильнее влияет шум в наклоне.
  • Сравнивают потери моделей с разными токенизаторами или на разных проверочных текстах. Потеря на токен зависит от того, как текст порезан на токены, и такие числа несопоставимы.
  • Читают закон как «больше параметров — всегда лучше». Он верен, только если данных и обучения хватает; иначе упирается в другой ограничитель.

Закон масштабирования (scaling law). измеренная зависимость потери модели от её размера, объёма данных или вычислений.

Степенной закон (power law). зависимость вида A / Nα, которая в логарифмических осях выглядит прямой линией.

Показатель степени α. наклон этой прямой: насколько быстро падает потеря при росте N.

Неустранимая потеря E. пол, ниже которого потеря не опустится, потому что сам текст содержит случайность.

Отложенный текст. текст, на котором модель не училась и по которому честно меряют потерю.

Кривая обучения (learning curve). потеря одного запуска по шагам обучения; не путать с законом масштабирования по многим запускам.

Экстраполяция. продление подогнанной кривой за пределы измеренных точек.

2 Бюджет обучения: формула 6·N·D и перевод в часы ускорителей

Зачем это в работе. Любое решение о размере модели упирается в бюджет вычислений: сколько ускорителей и на сколько дней у тебя есть. Формула 6·N·D позволяет за минуту прикинуть, во что обойдётся обучение модели нужного размера, проверить чужие заявления вроде «обучили за неделю на тысяче GPU» и сравнить две схемы обучения по одной валюте — числу операций.

Как это устроено. Пусть у модели N параметров, и она учится на D токенах. На прямом проходе (forward pass, вычисление ответа) каждый параметр на каждом токене участвует примерно в одном умножении и одном сложении — это 2 операции, итого 2·N·D. Обратный проход (backward pass, вычисление того, как поправить веса) требует примерно вдвое больше: нужно посчитать градиенты и по входам слоя, и по весам. Вместе выходит около 6·N·D операций с плавающей точкой (FLOP). Эту оценку используют и Каплан и соавторы, и авторы Chinchilla.

Чтобы перевести операции во время, делят на реальную скорость ускорителя. Паспортный пик почти никогда не достигается: часть времени уходит на передачу данных между чипами, ожидание памяти, контрольные точки. Долю пика, которую обучение реально использует на полезные вычисления модели, называют загрузкой по операциям модели (model FLOPs utilization, MFU). Её надо мерить на своём запуске; в примере ниже мы её не меряли, а предположили.

Ограничения формулы. Она не учитывает слагаемое от механизма внимания, которое растёт с длиной контекста: при длинных окнах реальная стоимость выше. Она считает только финальный запуск, а не десятки пробных, перезапуски после сбоев и подбор гиперпараметров. И она про обучение: при работе модели (инференсе) на один токен уходит около 2·N операций, без обратного прохода, — это пригодится на четвёртой ступени.

Подробный пример. Считаем бюджет четырёх вариантов и переводим его в часы ускорителя H100. Пик плотных вычислений BF16 у H100 SXM — 989 триллионов операций в секунду по паспорту NVIDIA; загрузку 40% мы взяли как предположение, а не как измерение:

# Бюджет обучения: C ≈ 6·N·D операций (прямой проход 2ND + обратный ~4ND)
def train_flops(N, D): return 6 * N * D
GPU_PEAK = 989e12   # пик плотного BF16 у H100 SXM по паспорту NVIDIA, операций/с
for name, N, D in [("1B на 20B токенов", 1e9, 20e9),
                   ("7B на 140B токенов", 7e9, 140e9),
                   ("7B на 2T токенов", 7e9, 2e12),
                   ("70B на 1.4T токенов", 70e9, 1.4e12)]:
    C = train_flops(N, D)
    for mfu in (0.4,):   # предположение: используем 40% пика
        gpu_hours = C / (GPU_PEAK * mfu) / 3600
        print(f"{name:22s} C={C:.1e}  ≈{gpu_hours:,.0f} GPU-часов при загрузке {mfu:.0%}")

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

1B на 20B токенов      C=1.2e+20  ≈84 GPU-часов при загрузке 40%
7B на 140B токенов     C=5.9e+21  ≈4,129 GPU-часов при загрузке 40%
7B на 2T токенов       C=8.4e+22  ≈58,982 GPU-часов при загрузке 40%
70B на 1.4T токенов    C=5.9e+23  ≈412,875 GPU-часов при загрузке 40%

Модель в 1 миллиард параметров на 20 миллиардах токенов при наших предположениях укладывается примерно в 84 часа одного ускорителя, то есть в сутки на четырёх. Модель в 7 миллиардов на 2 триллионах токенов — около 59 тысяч часов: это порядка месяца на 80 ускорителях. Вариант 70 миллиардов на 1,4 триллиона — тот самый бюджет Chinchilla из следующей ступени — уже около 413 тысяч часов. Заметь: увеличить и модель, и данные в 10 раз значит увеличить бюджет в 100 раз. Если загрузка у тебя окажется не 40%, а 25%, часы вырастут в 1,6 раза, поэтому MFU — первое, что стоит измерить перед расчётом денег.

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

  • Делят операции на паспортный пик ускорителя и получают срок в два-три раза меньше реального.
  • Берут пик «с разреженностью» из маркетинговой таблицы. Для H100 он вдвое выше плотного и к обычному обучению не относится.
  • Считают стоимость проекта только по финальному запуску, забывая пробные запуски и перезапуски.

FLOP. одна операция с плавающей точкой — умножение или сложение двух чисел.

Формула 6·N·D. оценка числа операций на обучение: по 2 на прямом проходе и около 4 на обратном на каждый параметр и токен.

Прямой проход (forward pass). вычисление ответа модели на вход.

Обратный проход (backward pass). вычисление градиентов, то есть того, как поправить веса.

Загрузка по операциям модели (MFU). доля паспортного пика ускорителя, которая реально идёт на вычисления модели.

BF16. 16-битный формат чисел, в котором обычно ведут вычисления при обучении больших моделей.

GPU-час. один час работы одного ускорителя; валюта, в которой считают аренду.

3 Chinchilla: как делить бюджет между размером модели и данными

Зачем это в работе. При фиксированном бюджете можно взять модель побольше и учить её меньше или поменьше и учить дольше. Ошибка в этом выборе стоит столько же, сколько обучение вдвое меньшей модели, поэтому правило деления бюджета — одно из самых практичных знаний о больших моделях. Когда говорят «модель обучена по Chinchilla» или «переобучена относительно Chinchilla», имеют в виду именно это деление.

Как это устроено. Каплан и соавторы в 2020 году пришли к выводу, что с ростом бюджета выгоднее в основном растить модель, а данные — медленнее. Под этот рецепт попадали модели того времени: GPT-3 при 175 миллиардах параметров училась примерно на 300 миллиардах токенов. Хоффманн и соавторы (DeepMind, 2022, «Training Compute-Optimal Large Language Models») обучили более 400 моделей от 70 миллионов до более чем 16 миллиардов параметров на 5–500 миллиардах токенов и тремя разными способами нашли другое: при оптимальном делении размер модели и число токенов надо растить примерно одинаково, оба пропорционально корню из бюджета.

Отсюда правило на пальцах — около 20 токенов обучения на параметр. Проверка была прямой: модель Chinchilla в 70 миллиардов параметров на 1,4 триллиона токенов при том же бюджете, что у их же Gopher в 280 миллиардов параметров на 300 миллиардах токенов, оказалась лучше Gopher на большинстве проверок. Такое деление называют вычислительно-оптимальным (compute-optimal): оно даёт наименьшую потерю за данный бюджет обучения.

Почему результаты разошлись. Позже Пирс и Сонг (2024) показали, что большая часть расхождения объясняется тем, что Каплан считал параметры без слоёв встраивания (embedding) и работал на малых масштабах; сами авторы Chinchilla указывали ещё на график скорости обучения, не подогнанный под длину запуска. Третий способ Chinchilla — подгонка формулы L(N, D) = E + A/Nα + B/Dβ — тоже оспорен: Бесироглу и соавторы (Epoch AI, 2024) попытались воспроизвести её по данным статьи и пришли к выводу, что опубликованные константы плохо согласуются с двумя другими способами.

Подробный пример. Возьмём опубликованные в статье Chinchilla константы третьего способа и для каждого бюджета переберём размер модели, а число токенов получим из бюджета по формуле 6·N·D. Затем сравним при бюджете Chinchilla два варианта: 70 миллиардов параметров и 280 миллиардов:

import numpy as np
# Параметрическая подгонка из статьи Chinchilla (Hoffmann и др., 2022, подход 3)
E, A, B, a, b = 1.69, 406.4, 410.7, 0.34, 0.28
def loss(N, D): return E + A / N**a + B / D**b
for C in [1e21, 1e22, 1e23, 1e24]:
    N = np.logspace(7, 13, 4000); D = C / (6 * N)
    i = np.argmin(loss(N, D))
    print(f"C={C:.0e}: лучшее N={N[i]:.2e}, D={D[i]:.2e}, токенов на параметр {D[i]/N[i]:.0f}, потеря {loss(N[i],D[i]):.3f}")
C = 6 * 70e9 * 1.4e12
print(f"тот же бюджет {C:.2e}: 70B/1.4T потеря {loss(70e9,1.4e12):.3f}; 280B/{C/6/280e9/1e12:.2f}T потеря {loss(280e9, C/6/280e9):.3f}")

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

C=1e+21: лучшее N=1.82e+09, D=9.14e+10, токенов на параметр 50, потеря 2.329
C=1e+22: лучшее N=5.16e+09, D=3.23e+11, токенов на параметр 63, потеря 2.139
C=1e+23: лучшее N=1.46e+10, D=1.14e+12, токенов на параметр 78, потеря 2.005
C=1e+24: лучшее N=4.13e+10, D=4.04e+12, токенов на параметр 98, потеря 1.911
тот же бюджет 5.88e+23: 70B/1.4T потеря 1.937; 280B/0.35T потеря 1.983

Сравнение двух моделей подтверждает главный вывод: при одном бюджете 70 миллиардов на 1,4 триллиона токенов дают потерю 1,937, а 280 миллиардов на 0,35 триллиона — 1,983, то есть большая, но недоученная модель хуже. А вот число токенов на параметр по этой формуле выходит не 20, а от 50 до 98 и растёт с бюджетом. Это и есть то несогласие с двумя другими способами, о котором писали воспроизводившие: формулу из статьи нельзя механически подставлять как источник «правильного» отношения. Практический вывод — относиться к 20 токенам на параметр как к ориентиру порядка, а не как к константе.

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

  • Считают Chinchilla-оптимальность признаком лучшей модели для использования. Она оптимальна только по стоимости обучения, о работе модели — следующая ступень.
  • Переносят число 20 на другие данные, токенизатор или архитектуру без проверки. Константы законов зависят от всего этого.
  • Сравнивают модели по числу параметров и не смотрят, на скольких токенах их учили.

Chinchilla. модель DeepMind 2022 года и одноимённая работа о том, как делить бюджет между размером и данными.

Вычислительно-оптимальное обучение (compute-optimal). деление бюджета, которое даёт наименьшую потерю за данное число операций обучения.

Токенов на параметр. отношение D к N; около 20 у Chinchilla-оптимальных моделей.

Gopher. модель DeepMind в 280 миллиардов параметров, с которой сравнивали Chinchilla при равном бюджете.

Слои встраивания (embedding). таблица, превращающая номер токена в вектор; у малых моделей это заметная доля параметров.

График скорости обучения (learning rate schedule). правило, по которому шаг обучения меняется от начала к концу запуска.

Воспроизведение. повторная проверка результата другой группой по данным или методу оригинальной работы.

4 Учить дольше оптимума: когда выгодна маленькая модель на огромных данных

Зачем это в работе. Большинство популярных небольших моделей обучены намного дольше Chinchilla-оптимума. Meta, например, сообщила, что Llama 3 8B (2024) училась на более чем 15 триллионах токенов — порядка 1900 токенов на параметр вместо 20. Если ты выбираешь модель для своего продукта, это объясняет, почему маленькая модель, «переученная» на огромных данных, часто выгоднее большой: за неё ты платишь на каждом запросе меньше.

Как это устроено. Chinchilla минимизирует только стоимость обучения. Но после обучения модель работает: на каждый обработанный токен уходит около 2·N операций. Если модель будет обслуживать триллионы токенов, стоимость работы перекрывает стоимость обучения, и выгоднее заплатить больше на обучении, чтобы получить меньшую модель того же качества. Эту поправку формально разобрали Сардана и Франкл (2023, «Beyond Chinchilla-Optimal»): оптимальный размер зависит от ожидаемого объёма работы, и при большом спросе модель надо брать меньше и учить дольше.

По шагам: фиксируешь целевое качество; для каждого размера N находишь, сколько токенов D нужно, чтобы до него дойти; считаешь полную стоимость 6·N·D + 2·N·(токены в работе); выбираешь минимум. Чем меньше модель, тем больше нужно данных, причём быстро растущее количество: качество маленькой модели упирается в её размер, и последние доли потери даются всё дороже.

Ограничение — данные. Уникального качественного текста конечное количество. Мюннигофф и соавторы (2023, «Scaling Data-Constrained Language Models») измерили, что повтор тех же данных до примерно четырёх эпох (полных проходов) почти не хуже свежих данных, а дальше ценность каждого повтора быстро падает. Поэтому длинное обучение маленьких моделей опирается на фильтрацию, синтетические данные и дистилляцию.

Подробный пример. Берём формулу Chinchilla из прошлой ступени и бюджет 1022 операций; оптимальная по обучению модель — около 5,16 миллиарда параметров. Фиксируем её потерю как цель и считаем, сколько данных нужно меньшим моделям до того же качества и какой выходит полная стоимость без работы и при 10 триллионах обработанных токенов (это число — наше предположение о спросе):

import numpy as np
E, A, B, a, b = 1.69, 406.4, 410.7, 0.34, 0.28
def loss(N, D): return E + A / N**a + B / D**b
def tokens_for(N, target):         # сколько токенов обучения нужно модели N до потери target
    lo, hi = 1e9, 1e17
    for _ in range(200):
        mid = (lo * hi) ** 0.5
        lo, hi = (mid, hi) if loss(N, mid) > target else (lo, mid)
    return hi
C = 1e22
Ns = np.logspace(8, 12, 4000); i = np.argmin(loss(Ns, C / (6 * Ns)))
N0 = Ns[i]; target = loss(N0, C / (6 * N0))
print(f"оптимум для C=1e22: N={N0/1e9:.2f}B, потеря {target:.3f}")
for served in (0, 1e13):           # сколько токенов модель обработает за жизнь (предположение)
    print(f"--- токенов в работе: {served:.0e}")
    for N in [N0, 4e9, 3e9, 2e9, 1.5e9]:
        D = tokens_for(N, target)
        train, serve = 6 * N * D, 2 * N * served
        print(f"N={N/1e9:.2f}B: D={D/1e12:.2f}T ({D/N:.0f} на параметр), обучение {train:.2e}, работа {serve:.2e}, всего {train+serve:.2e}")

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

оптимум для C=1e22: N=5.16B, потеря 2.139
--- токенов в работе: 0e+00
N=5.16B: D=0.32T (63 на параметр), обучение 1.00e+22, работа 0.00e+00, всего 1.00e+22
N=4.00B: D=0.43T (106 на параметр), обучение 1.02e+22, работа 0.00e+00, всего 1.02e+22
N=3.00B: D=0.62T (207 на параметр), обучение 1.12e+22, работа 0.00e+00, всего 1.12e+22
N=2.00B: D=1.24T (618 на параметр), обучение 1.48e+22, работа 0.00e+00, всего 1.48e+22
N=1.50B: D=2.40T (1603 на параметр), обучение 2.16e+22, работа 0.00e+00, всего 2.16e+22
--- токенов в работе: 1e+13
N=5.16B: D=0.32T (63 на параметр), обучение 1.00e+22, работа 1.03e+23, всего 1.13e+23
N=4.00B: D=0.43T (106 на параметр), обучение 1.02e+22, работа 8.00e+22, всего 9.02e+22
N=3.00B: D=0.62T (207 на параметр), обучение 1.12e+22, работа 6.00e+22, всего 7.12e+22
N=2.00B: D=1.24T (618 на параметр), обучение 1.48e+22, работа 4.00e+22, всего 5.48e+22
N=1.50B: D=2.40T (1603 на параметр), обучение 2.16e+22, работа 3.00e+22, всего 5.16e+22

Без работы оптимум — исходные 5,16 миллиарда: модель в 1,5 миллиарда до той же потери нужно учить на 2,4 триллиона токенов, и обучение обходится в 2,2 раза дороже. Но если модель обработает 10 триллионов токенов, картина переворачивается: у 5,16 миллиарда работа стоит 1,03·1023 операций, у 1,5 миллиарда — 3·1022, и полная стоимость падает с 1,13·1023 до 5,16·1022, более чем вдвое. Обрати внимание на цену: 1603 токена на параметр — это 2,4 триллиона токенов, и где-то здесь упираешься в запас уникальных данных. Константы формулы оспорены, поэтому смотри на направление вывода, а не на точные числа.

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

  • Называют модель на 1900 токенов на параметр «неэффективно обученной». Она неэффективна по обучению и эффективна по работе, это сознательный выбор.
  • Считают, что маленькая модель при достаточном обучении догонит большую. Она упирается в свой размер: последние доли потери даются всё дороже, а ниже предела своего размера не опускаются.
  • Гонят данные десятки эпох, чтобы набрать токены. После нескольких повторов модель начинает запоминать, а не учиться.

Переобучение относительно Chinchilla (overtraining). обучение на гораздо большем числе токенов, чем вычислительно-оптимальное; не путать с переобучением как подгонкой под обучающие данные.

Стоимость работы. около 2·N операций на каждый обработанный токен после обучения.

Полная стоимость. сумма стоимости обучения и всей будущей работы модели.

Эпоха. один полный проход по обучающим данным.

Ограничение по данным (data-constrained). режим, когда уникальных данных меньше, чем хотелось бы для выбранного размера.

Llama 3 8B. открытая модель Meta 2024 года в 8 миллиардов параметров, обученная на более чем 15 триллионах токенов.

Целевое качество. потеря или результат на проверке, которого модель должна достичь; от неё считают нужные данные.

5 Где законы масштабирования ломаются: потеря не равна умениям

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

Как это устроено. Первое — внезапные умения. Вэй и соавторы (2022) описали «эмерджентные способности» (emergent abilities): на некоторых задачах качество близко к нулю у малых моделей и резко растёт после определённого размера. Шеффер, Миранда и Коеджо (2023, «Are Emergent Abilities of Large Language Models a Mirage?») показали, что значительная часть таких скачков объясняется метрикой: если засчитывается только полностью правильный ответ, плавное улучшение каждого токена выглядит как обрыв. С плавной метрикой те же модели улучшаются ровно.

Второе — перенос с маленьких запусков. Закон подгоняют на маленьких моделях, но при росте модели нужно менять скорость обучения и другие гиперпараметры (настройки обучения, которые не учатся сами). Если их не переносить правильно, большой запуск ложится выше прогноза, и это ошибка настройки, а не «конец закона». Для этого есть схемы параметризации вроде μP (Ян и соавторы, 2022), при которых подобранные на маленькой модели настройки работают и на большой.

Третье — закон привязан к данным и архитектуре. Константы меняются, если поменять смесь данных, их качество, токенизатор, перейти к смеси экспертов. Четвёртое — есть другие оси масштабирования, кроме обучения: вычисления при ответе. Снелл и соавторы (2024) показали, что дополнительное время на рассуждение при ответе может заменить часть размера модели на трудных задачах; об этом — дорожка о рассуждении.

Подробный пример. Пусть точность одного токена растёт с размером модели плавно (кривая придумана для примера, не измерена), а задача засчитывается, только если все 30 токенов ответа верны. Смотрим обе метрики рядом:

import numpy as np
# Пусть точность одного токена растёт плавно с размером модели,
# а задача засчитывается, только если все 30 токенов ответа верны
sizes = np.logspace(8, 12, 9)
p_tok = 1 - 0.5 * (sizes / 1e8) ** -0.25      # плавная кривая (выдумана для примера)
for n, p in zip(sizes, p_tok):
    print(f"N={n:.0e}: точность токена {p:.3f} | верный ответ целиком {p**30:.3f}")

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

N=1e+08: точность токена 0.500 | верный ответ целиком 0.000
N=3e+08: точность токена 0.625 | верный ответ целиком 0.000
N=1e+09: точность токена 0.719 | верный ответ целиком 0.000
N=3e+09: точность токена 0.789 | верный ответ целиком 0.001
N=1e+10: точность токена 0.842 | верный ответ целиком 0.006
N=3e+10: точность токена 0.881 | верный ответ целиком 0.023
N=1e+11: точность токена 0.911 | верный ответ целиком 0.061
N=3e+11: точность токена 0.933 | верный ответ целиком 0.126
N=1e+12: точность токена 0.950 | верный ответ целиком 0.215

Точность токена растёт ровно: 0,50, 0,72, 0,84, 0,91, 0,95 при каждом росте размера в 10 раз. А доля полностью верных ответов до 3 миллиардов параметров нулевая (0,000–0,001), потом начинает подниматься и к триллиону доходит до 0,215. На графике с линейной осью точности это выглядит как «умение появилось» около 10–30 миллиардов, хотя модель улучшалась всё время. Повторить можно на своей задаче: посчитай рядом с точной метрикой плавную — долю верных токенов или вероятность правильного ответа — и посмотри, есть ли скачок в ней.

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

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

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

Точная метрика (exact match). засчитывает ответ, только если он полностью совпал с правильным.

Плавная метрика. оценка, которая учитывает частичную правильность, например долю верных токенов.

Гиперпараметры. настройки обучения, которые выбирает человек: скорость обучения, размер пакета, длина разгона.

μP (maximal update parametrization). способ задать масштабы весов и шагов так, чтобы настройки с маленькой модели переносились на большую.

Вычисления при ответе (test-time compute). дополнительные вычисления во время ответа модели, например длинное рассуждение или несколько попыток.

Смесь данных. пропорции источников в обучении: веб, код, книги, математика; меняет константы закона.

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