дорожка · 22.10.2026 · спекулятивное декодирование

Как модель пишет несколько токенов за один шаг: спекулятивное декодирование

Обычная модель пишет ответ строго по одному токену, и каждый токен — это полный проход по всем её весам. Спекулятивное декодирование обходит это ограничение: маленькая быстрая модель набрасывает несколько токенов вперёд, а большая за один проход проверяет их все и оставляет только те, которые написала бы сама. Текст получается тем же самым, а проходов большой модели меньше. Разберём, почему проверка почти бесплатна, по какому правилу принимают черновик, откуда берётся ускорение и когда оно исчезает. Весь код на странице мы запускали, все выводы — из этих запусков; модели в примерах игрушечные, а цифры из статей подписаны источником.

Все дорожки — /put. Прошлая — внимание и кэш ключей.

1 Почему проверить пять токенов почти так же дёшево, как написать один

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

Вспомни третью ступень вчерашней дорожки про внимание и кэш. Ответ пишется по одному токену, и для каждого нового токена модель заново читает из памяти все свои веса — миллиарды чисел. Вычислений на один токен при этом мало: каждое прочитанное число умножается всего на одно число входа. Видеокарта умеет считать гораздо быстрее, чем подвозить данные, поэтому генерация упирается в пропускную способность памяти (memory bandwidth — сколько байт в секунду можно прочитать), а вычислительные блоки большую часть времени простаивают.

Отсюда главная идея. Если бы на вход шага пришёл не один токен, а пять, веса пришлось бы прочитать всё равно один раз, а умножений стало бы в пять раз больше — и этот прирост работы ложится на простаивающие блоки. Именно так устроен разбор запроса (prefill), когда модель одним проходом обрабатывает весь твой вопрос. Беда в том, что при генерации следующие токены ещё неизвестны: чтобы написать шестой, нужен пятый. Спекулятивное декодирование (speculative decoding) решает это так: кто-то дешёвый угадывает несколько следующих токенов, а большая модель одним проходом считает, что она сама поставила бы на каждом из этих мест. Где догадка совпала, токены принимаются, и за один проход большой модели в ответ попадает несколько токенов.

Название взято из процессоров: спекулятивное выполнение (speculative execution) — это когда процессор заранее выполняет команды, которые, возможно, понадобятся, а потом либо оставляет результат, либо выбрасывает. Для языковых моделей схему описали две группы почти одновременно: Leviathan, Kalman и Matias из Google Research в статье «Fast Inference from Transformers via Speculative Decoding» (2022, опубликована на ICML 2023) и Chen и соавторы из DeepMind в статье «Accelerating Large Language Model Decoding with Speculative Sampling» (2023). Первые пишут, что на модели T5-XXL получили ускорение в 2–3 раза при тех же выходах, вторые — в 2–2,5 раза на модели Chinchilla с 70 миллиардами параметров.

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

Подробный пример. Возьмём одну матрицу весов 8192 на 8192 — это 256 МиБ чисел, примерно как один крупный слой настоящей модели — и посмотрим, сколько стоит умножить её на 1, 2, 4 и больше векторов-токенов сразу. Это не модель целиком, а её самая тяжёлая операция. Запускали на обычном процессоре в один поток.

# Сколько стоит проверить k токенов за один проход по сравнению с одним токеном.
# Слой "большой модели" здесь - одна матрица весов 8192 x 8192 (256 МиБ в float32).
# На шаге генерации её приходится целиком прочитать из памяти - как и настоящие веса.
import os; os.environ["OPENBLAS_NUM_THREADS"] = "1"   # один поток процессора, чтобы замеры были ровнее
import time, numpy as np
rng = np.random.default_rng(0)
d = 8192
W = rng.standard_normal((d, d), dtype=np.float32)

def bench(k, repeats=30):
    x = rng.standard_normal((k, d), dtype=np.float32)
    x @ W                                   # прогрев
    t = time.perf_counter()
    for _ in range(repeats):
        x @ W
    return (time.perf_counter() - t) / repeats * 1000

times = {k: bench(k) for k in (1, 2, 4, 8, 16, 64, 256)}
for k, ms in times.items():
    print(f"токенов за проход {k:4d}: {ms:7.2f} мс   на один токен {ms/k:6.2f} мс   "
          f"относительно 2 токенов: {ms/times[2]:4.1f}")

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

токенов за проход    1:   10.03 мс   на один токен  10.03 мс   относительно 2 токенов:  0.4
токенов за проход    2:   27.11 мс   на один токен  13.55 мс   относительно 2 токенов:  1.0
токенов за проход    4:   27.85 мс   на один токен   6.96 мс   относительно 2 токенов:  1.0
токенов за проход    8:   28.98 мс   на один токен   3.62 мс   относительно 2 токенов:  1.1
токенов за проход   16:   32.97 мс   на один токен   2.06 мс   относительно 2 токенов:  1.2
токенов за проход   64:   60.80 мс   на один токен   0.95 мс   относительно 2 токенов:  2.2
токенов за проход  256:  174.13 мс   на один токен   0.68 мс   относительно 2 токенов:  6.4

Главное — строки от 2 до 16: обработать 16 токенов стоило всего на 20% дольше, чем 2, хотя работы в восемь раз больше. Время почти целиком уходит на чтение матрицы, а не на умножения. Дальше рост становится заметным: на 64 и 256 токенах вычисления наконец догоняют память. Честная оговорка про первую строку: один токен библиотека считает отдельной, более быстрой процедурой умножения матрицы на вектор, поэтому на нашем процессоре он в 2,7 раза дешевле двух. Значит, здесь проверка пяти токенов стоит примерно как три обычных шага, а не как один; на видеокартах соотношение другое, но мы его не мерили. Это ещё одна причина, по которой реальное ускорение всегда надо проверять на своём железе.

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

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

Спекулятивное декодирование (speculative decoding). способ писать несколько токенов за проход большой модели: дешёвый помощник угадывает продолжение, большая модель проверяет его целиком за раз.

Черновая модель (draft model). маленькая быстрая модель, которая предлагает несколько следующих токенов.

Целевая модель (target model). большая модель, чьи ответы мы хотим получить; она проверяет черновик и решает, что принять.

Проход модели (forward pass). одно вычисление модели от входа до выхода, при котором все её веса читаются из памяти.

Упор в память (memory-bound). состояние, когда скорость определяется чтением данных, а вычислительные блоки ждут.

Упор в вычисления (compute-bound). обратная ситуация: данные подвозятся быстрее, чем их успевают обработать, и лишняя работа стоит времени.

Спекулятивное выполнение (speculative execution). приём из процессоров: делать работу заранее, пока не известно, понадобится ли она, и выбрасывать лишнее.

2 Черновик и проверка: как получить тот же самый текст за меньшее число проходов

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

Жадный выбор (greedy decoding) — режим, при котором модель на каждом шаге берёт самый вероятный токен, без случайности; про него и про температуру была дорожка о выборе слова. Цикл спекулятивного декодирования в этом режиме такой. Шаг первый: черновая модель пишет k токенов обычным способом, по одному, — это быстро, потому что она маленькая. Шаг второй: большая модель получает текст вместе с этими k токенами и за один проход считает свой лучший токен для каждой из k+1 позиций — после исходного текста, после первого чернового токена, после второго и так далее. Это возможно благодаря причинной маске со второй ступени вчерашней дорожки: каждая позиция видит только то, что слева, поэтому все предсказания честные.

Шаг третий — сверка. Идём по черновику слева направо и сравниваем: если черновой токен совпал с тем, что поставила бы большая модель, принимаем его. На первом несовпадении останавливаемся, черновой токен выбрасываем, а вместо него ставим токен большой модели — он у нас уже посчитан. Если совпали все k, большая модель бесплатно даёт ещё один, k+1-й токен. Итог каждого прохода — от 1 до k+1 новых токенов, и каждый из них — ровно тот, который большая модель выбрала бы сама. Поэтому текст совпадает с обычной генерацией.

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

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

Подробный пример. Две игрушечные модели над словарём из 30 токенов. Большая выбирает следующий токен по таблице, зависящей от двух предыдущих. Черновая — та же таблица, испорченная случайным шумом, поэтому она часто, но не всегда выбирает то же самое. Генерируем 200 токенов обычным способом и спекулятивно с черновиком из 4 токенов и сравниваем.

# Жадное спекулятивное декодирование на игрушечных моделях.
# "Большая" модель: следующий токен = самый вероятный по таблице, зависящей от двух последних токенов.
# "Черновая" модель: та же таблица, но испорченная шумом - она часто, но не всегда угадывает.
import numpy as np
V = 30                                          # размер словаря
rng = np.random.default_rng(1)
big_table = rng.standard_normal((V, V, V))
draft_table = big_table + 0.25 * rng.standard_normal((V, V, V))

calls = {"big": 0, "draft": 0}
def big_next_all(seq, start):
    """Один проход большой модели: лучший следующий токен для каждой позиции от start до конца."""
    calls["big"] += 1
    return [int(np.argmax(big_table[seq[i-2], seq[i-1]])) for i in range(start, len(seq) + 1)]
def draft_next(seq):
    calls["draft"] += 1
    return int(np.argmax(draft_table[seq[-2], seq[-1]]))

def plain(prompt, n):
    seq = list(prompt)
    while len(seq) < len(prompt) + n:
        seq.append(big_next_all(seq, len(seq))[0])
    return seq

def speculative(prompt, n, k=4):
    seq, accepted = list(prompt), []
    while len(seq) < len(prompt) + n:
        draft = []
        for _ in range(k):                       # черновик пишет k токенов по одному
            draft.append(draft_next(seq + draft))
        best = big_next_all(seq + draft, len(seq))   # большая проверяет все k+1 позиций за ОДИН проход
        ok = 0
        while ok < k and draft[ok] == best[ok]:
            ok += 1
        accepted.append(ok)
        seq += draft[:ok] + [best[ok]]           # принятые токены + один токен от большой модели
    return seq[:len(prompt) + n], accepted

prompt, n = [3, 7], 200
calls.update(big=0, draft=0); a = plain(prompt, n); print("обычно:        проходов большой модели", calls["big"])
calls.update(big=0, draft=0); b, acc = speculative(prompt, n)
print("спекулятивно:  проходов большой модели", calls["big"], " черновых шагов", calls["draft"])
print("тексты совпадают:", a == b)
print("сколько черновых токенов принято за проход:", np.bincount(acc, minlength=5).tolist(), " (0,1,2,3,4)")
print("в среднем токенов за проход большой модели:", round(n / calls["big"], 2))

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

обычно:        проходов большой модели 200
спекулятивно:  проходов большой модели 86  черновых шагов 344
тексты совпадают: True
сколько черновых токенов принято за проход: [36, 24, 1, 12, 13]  (0,1,2,3,4)
в среднем токенов за проход большой модели: 2.33

Тексты совпали полностью, а проходов большой модели понадобилось 86 вместо 200 — в среднем 2,33 токена за проход. Цена — 344 шага черновой модели, и выигрыш по времени будет, только если черновой шаг намного дешевле большого; это посчитаем на четвёртой ступени. Распределение принятых токенов неровное: в 36 проходах черновик ошибся сразу, а в 13 угадал все четыре. Причина в том, что игрушечная модель без случайности быстро зацикливается на повторяющемся куске текста, и на одних местах цикла черновик стабильно прав, а на других стабильно ошибается. В настоящих текстах картина похожая: на шаблонных местах вроде скобок и повторяющихся имён черновик угадывает подряд, на смысловых развилках — нет.

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

  • Забывают откатить кэш ключей и значений после отказа. Выход тихо расходится с обычной генерацией, и это легко пропустить без прямого сравнения.
  • Берут черновую модель с другим словарём токенов. Черновик и большая модель должны резать текст одинаково, иначе токены нельзя сравнить один к одному.
  • Не проверяют совпадение выходов при температуре 0 после включения ускорения. Это самый дешёвый тест правильности, и он ловит большинство ошибок реализации.

Жадный выбор (greedy decoding). режим, при котором модель всегда берёт самый вероятный следующий токен.

Длина черновика (k, число спекулятивных токенов). сколько токенов черновая модель предлагает за один раз.

Принятый токен. черновой токен, совпавший с тем, что выбрала бы большая модель; он попадает в ответ.

Отказ (rejection). первое место, где черновик разошёлся с большой моделью; всё после него выбрасывается.

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

Откат кэша. удаление из кэша ключей и значений записей для отброшенных черновых токенов.

Общий словарь токенов. требование, чтобы черновая и большая модели одинаково резали текст на токены.

3 Правило принятия при случайном выборе: почему распределение не меняется

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

Обозначим: на очередном месте большая модель дала бы распределение p — доли вероятности для каждого токена, а черновая дала q. Черновик уже выбрал токен x по своим долям q. Правило такое: принимаем x с вероятностью min(1, p(x)/q(x)). Если большая модель любит этот токен не меньше черновой, то есть p(x) ≥ q(x), принимаем всегда. Если черновик переоценил токен, принимаем только в доле p(x)/q(x) случаев. Это схема выборки с отказом (rejection sampling) — давний приём из статистики, позволяющий получать выборку из одного распределения, имея генератор другого.

Если токен отвергнут, нельзя просто взять случайный токен из p: тогда те слова, которые черновик и так предлагает часто, выпадали бы слишком часто. Вместо этого берут выборку из запасного распределения (residual distribution): из каждой доли p вычитают долю q, отрицательные результаты заменяют нулём и всё делят на сумму, чтобы получились доли. Смысл простой: при отказе добираем ровно те слова, которые черновик недодал. Сложив оба пути — «принят» и «отказ, взят запасной», — получаем в точности p. Доказательство занимает несколько строк и приведено в обеих статьях; ниже проверим его опытом.

Полезное следствие: доля принятых черновых токенов на одном месте равна сумме по всем токенам минимумов min(p, q), то есть тому, насколько два распределения перекрываются. Чем ближе черновая модель к большой по вкусам, тем больше принимается. И это объясняет, почему повышение температуры обычно снижает ускорение: распределения становятся шире, и угадать в точности чужой выбор становится труднее. В статье Leviathan и соавторов это видно по их таблице для перевода: при температуре 0 ускорение у них выше, чем при температуре 1.

Граница: гарантия «распределение не меняется» относится к математике, а не к железу. Числа на видеокарте округляются, и проверка нескольких токенов за раз иногда даёт чуть иные дроби, чем по одному. В статье DeepMind это прямо оговорено как сохранение распределения «в пределах точности железа». На практике это может значить, что при температуре 0 изредка отличается один токен на развилке, где у двух вариантов почти равные доли. Отличие от выбора слова из дорожки про сэмплинг: там мы меняли распределение настройками, а здесь правило специально устроено так, чтобы распределение не менялось вовсе.

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

# Правило принятия черновика при выборе со случайностью (сэмплинге).
# p - распределение большой модели на следующем месте, q - распределение черновой.
import numpy as np
rng = np.random.default_rng(2)
words = ["кот", "пёс", "дом", "лес", "чай"]
p = np.array([0.50, 0.20, 0.15, 0.10, 0.05])   # большая модель
q = np.array([0.30, 0.40, 0.05, 0.05, 0.20])   # черновая модель ошибается в долях

residual = np.maximum(p - q, 0)
residual /= residual.sum()                      # запасное распределение на случай отказа

def one_step():
    x = rng.choice(5, p=q)                      # черновик предлагает слово
    if rng.random() < min(1.0, p[x] / q[x]):    # принять с вероятностью min(1, p/q)
        return x, True
    return rng.choice(5, p=residual), False     # отказ: берём слово из запасного распределения

N = 200_000
res = [one_step() for _ in range(N)]
counts = np.bincount([r[0] for r in res], minlength=5) / N
print("слово  большая p  черновик q  вышло у схемы")
for w, a, b, c in zip(words, p, q, counts):
    print(f"{w:5s}  {a:9.2f}  {b:10.2f}  {c:13.3f}")
print("доля принятых черновиков:", round(np.mean([r[1] for r in res]), 3),
      "  по формуле сумма min(p, q):", round(np.minimum(p, q).sum(), 3))
print("запасное распределение:", ", ".join(f"{w} {r:.3f}" for w, r in zip(words, residual)))

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

слово  большая p  черновик q  вышло у схемы
кот         0.50        0.30          0.499
пёс         0.20        0.40          0.200
дом         0.15        0.05          0.150
лес         0.10        0.05          0.100
чай         0.05        0.20          0.051
доля принятых черновиков: 0.651   по формуле сумма min(p, q): 0.65
запасное распределение: кот 0.571, пёс 0.000, дом 0.286, лес 0.143, чай 0.000

Черновик вчетверо переоценивает «чай» и вдвое — «пёс», а «кот» недооценивает. Но на выходе доли совпали с долями большой модели до третьего знака — расхождения на уровне случайного шума от конечного числа опытов. Черновик был принят в 65,1% случаев, ровно как предсказывает сумма минимумов. Запасное распределение показывает, как именно исправляются ошибки: при отказе «пёс» и «чай» не выпадают никогда, потому что черновик их и так перекормил, а больше всего достаётся «коту», которого он недодал.

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

  • При отказе берут токен из p вместо запасного распределения. Распределение ответов сдвигается к вкусам черновика, и это не видно без статистики на тысячах ответов.
  • Принимают черновик «если вероятность у большой модели выше порога». Это быстрее, но уже другой, приближённый метод, который меняет ответы.
  • Ждут от спекуляции одинакового ускорения при любой температуре. Чем она выше, тем меньше перекрытие распределений и тем меньше токенов принимается.

Распределение (p, q). набор долей вероятности для каждого токена словаря на очередном месте, в сумме дающих единицу.

Правило принятия. принять черновой токен с вероятностью min(1, p/q), где p и q — доли этого токена у большой и черновой модели.

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

Запасное распределение (residual distribution). разность p − q, где отрицательное заменено нулём и всё нормировано; из него берут токен после отказа.

Нормировка. деление всех долей на их сумму, чтобы в сумме получилась единица.

Доля принятия (acceptance rate). как часто черновой токен принимается; для одного места она равна сумме min(p, q).

Точное ускорение (lossless). ускорение, которое не меняет распределения ответов, в отличие от приближённых схем.

4 Сколько это ускоряет и когда выигрыш пропадает

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

Три числа такие. Первое — a, вероятность, что большая модель примет очередной черновой токен; с третьей ступени мы знаем, что это перекрытие распределений, и на практике его меряют на своих запросах. Второе — k, длина черновика. Третье — c, сколько стоит шаг черновика в долях от шага большой модели; если черновик в 20 раз быстрее, c = 0,05. Если считать, что каждый токен принимается независимо с вероятностью a, то за проход в среднем получается (1 − ak+1) / (1 − a) токенов — эта формула есть в статье Leviathan и соавторов. Время одного цикла — это один проход большой модели плюс k шагов черновика, то есть 1 + k·c в единицах большого шага. Ускорение равно отношению этих двух величин.

Из формулы видны два закона. Первый: длинный черновик полезен только при высокой доле принятия. Вероятность угадать подряд падает как степень a, поэтому при a = 0,5 даже бесконечный черновик в среднем даёт не больше двух токенов за проход, а платить за его длину приходится всегда. Второй: дорогой черновик съедает всё. Если черновая модель всего в 5 раз быстрее большой, k шагов черновика стоят почти столько же, сколько сам проход большой модели. Поэтому черновик обычно берут во много раз меньше большой модели той же семьи, с тем же словарём.

Где формула врёт. Она предполагает, что проверка k+1 токенов стоит как один шаг большой модели, а мы на первой ступени видели, что на нашем процессоре это не так. Она же предполагает, что токены угадываются независимо, а в реальном тексте удачи и неудачи идут сериями, как в примере второй ступени. И главное: всё это про один разговор. На сервере с большими пакетами, из пятой ступени вчерашней дорожки, видеокарта уже упирается в вычисления, лишние черновые токены отнимают место у чужих разговоров, и общая пропускная способность может упасть. Поэтому спекуляция больше всего помогает там, где важна задержка одного пользователя, — чат, автодополнение кода, — и меньше всего в пакетной обработке без спешки.

Подробный пример. Сначала проверим формулу моделированием, потом посчитаем таблицу ускорений для дешёвого (c = 0,05) и дорогого (c = 0,2) черновика.

# Сколько даёт спекулятивное декодирование в зависимости от трёх чисел:
# a - вероятность, что большая модель примет очередной черновой токен,
# k - сколько токенов пишет черновик за раз,
# c - сколько стоит один шаг черновика в долях от шага большой модели.
# Формула ожидаемого числа токенов за проход - из работы Leviathan и соавторов (2022);
# рядом - проверка простым моделированием.
import numpy as np
rng = np.random.default_rng(3)

def tokens_per_pass(a, k):
    return k + 1 if a == 1 else (1 - a ** (k + 1)) / (1 - a)

def simulate(a, k, passes=100_000):
    ok = rng.random((passes, k)) < a
    first_fail = np.where(ok.all(1), k, ok.argmin(1))   # сколько подряд принято
    return (first_fail + 1).mean()                       # + один токен от большой модели

def speedup(a, k, c):
    return tokens_per_pass(a, k) / (1 + k * c)          # токенов на единицу времени против 1 в обычном режиме

print("a     k  токенов/проход (формула | моделирование)")
for a in (0.5, 0.8):
    for k in (2, 4, 8):
        print(f"{a:.1f}  {k:2d}  {tokens_per_pass(a, k):5.2f} | {simulate(a, k):5.2f}")
print()
print("ускорение при цене черновика c = 0.05 и c = 0.2 (меньше 1 - стало медленнее)")
for a in (0.3, 0.5, 0.7, 0.9):
    row = "  ".join(f"k={k}: {speedup(a, k, 0.05):4.2f} / {speedup(a, k, 0.2):4.2f}" for k in (2, 4, 8))
    print(f"a={a:.1f}  {row}")

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

a     k  токенов/проход (формула | моделирование)
0.5   2   1.75 |  1.75
0.5   4   1.94 |  1.93
0.5   8   2.00 |  2.00
0.8   2   2.44 |  2.44
0.8   4   3.36 |  3.36
0.8   8   4.33 |  4.32

ускорение при цене черновика c = 0.05 и c = 0.2 (меньше 1 - стало медленнее)
a=0.3  k=2: 1.26 / 0.99  k=4: 1.19 / 0.79  k=8: 1.02 / 0.55
a=0.5  k=2: 1.59 / 1.25  k=4: 1.61 / 1.08  k=8: 1.43 / 0.77
a=0.7  k=2: 1.99 / 1.56  k=4: 2.31 / 1.54  k=8: 2.28 / 1.23
a=0.9  k=2: 2.46 / 1.94  k=4: 3.41 / 2.28  k=8: 4.38 / 2.36

Формула и моделирование совпали до сотых. При a = 0,5 удлинение черновика с 4 до 8 токенов почти ничего не добавляет: 1,94 против 2,00 токена за проход. Таблица ускорений показывает, где выигрыш пропадает. Слабый черновик (a = 0,3) с дорогим шагом (c = 0,2) замедляет работу при любой длине: 0,99, 0,79 и 0,55 — то есть до почти двукратного замедления при k = 8. При той же доле принятия и дешёвом черновике длинный черновик тоже вреден: при k = 8 выигрыш падает до 1,02. Хороший черновик (a = 0,9) и дешёвый шаг дают 4,38 раза при k = 8, но это идеальная картина без накладных расходов на проверку. Практический вывод: начинай с k около 3–5, измерь долю принятия на своих запросах и двигай k только после замера.

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

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

Доля принятия (a). вероятность, что очередной черновой токен будет принят; её меряют на своих запросах.

Цена шага черновика (c). время шага черновой модели в долях от прохода большой модели.

Токенов за проход. сколько токенов в среднем попадает в ответ за один проход большой модели.

Ускорение (speedup). во сколько раз быстрее пишется ответ по сравнению с обычной генерацией; меньше единицы — замедление.

Моделирование. проверка формулы многократной имитацией случайных событий на компьютере.

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

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

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

Самый простой вариант — поиск продолжения в самом тексте (n-gram lookup, его также называют prompt lookup decoding). Идея: когда модель правит код или цитирует документ, ответ во многом повторяет запрос. Берём последние n токенов уже написанного ответа, ищем такую же последовательность в запросе и предлагаем в качестве черновика k токенов, которые шли за ней там. Проверка и правило принятия — ровно те же, что на второй и третьей ступенях, поэтому ответ не меняется. Цена черновика почти нулевая, это поиск подстроки. Предел тоже очевиден: в свободном тексте, где ответ не похож на запрос, совпадения редки, и метод просто не предлагает черновиков. Такой режим есть, в частности, в сервере vLLM.

Второе семейство — дополнительные головы предсказания. Вместо отдельной модели к большой модели пристраивают несколько маленьких слоёв, которые по её же внутреннему состоянию угадывают не один, а два, три, четыре токена вперёд. Так устроена Medusa (Cai и соавторы, 2024), где каждая дополнительная голова отвечает за свою позицию вперёд. В EAGLE (Li и соавторы, 2024) черновик строится по скрытым векторам большой модели, а не по одним токенам, и это повышает долю принятия. Плюс таких схем — нет второй модели и второго словаря, минус — головы нужно обучить под конкретную большую модель, и они не переносятся на другую.

Третье — предсказание нескольких токенов (multi-token prediction) прямо при обучении большой модели. Модель с самого начала учат угадывать несколько следующих токенов, а не один; это исследовали, например, Gloeckle и соавторы из Meta в работе «Better & Faster Large Language Models via Multi-token Prediction» (2024). Те же дополнительные выходы потом можно использовать как встроенный черновик. Отличие от Medusa в том, что здесь это часть исходного обучения, а не надстройка над готовой моделью. Чем все эти варианты отличаются от квантования: они не трогают веса и при честном правиле принятия не меняют ответы, а квантование меняет числа модели и может менять качество.

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

Подробный пример. Задача «переименуй переменную s в total» — ответ почти целиком копирует запрос. Делим текст на грубые токены (слова, знаки, переносы строк), берём черновик поиском по последним двум токенам и считаем, сколько понадобится проходов большой модели. Саму большую модель здесь заменяет готовый правильный ответ: нас интересует только число проходов, а правильность проверяем сравнением.

# Черновик без черновой модели: поиск продолжения в самом запросе (n-gram lookup).
# Задача "переименуй переменную" - ответ почти целиком копирует запрос.
# Вместо большой модели - готовый правильный ответ: важно лишь, сколько проходов понадобится.
import re
prompt_code = """def total_price(items, discount):
    s = 0
    for item in items:
        s += item.price * item.count
    if discount:
        s = s * (1 - discount)
    return round(s, 2)"""
answer_code = prompt_code.replace(" s ", " total ").replace("(s,", "(total,").replace("    s =", "    total =").replace("s * (", "total * (")

tok = lambda t: re.findall(r"\w+|[^\w\s]|\n", t)        # грубые "токены": слова, знаки, переносы
prompt, answer = tok("Переименуй s в total:\n" + prompt_code), tok(answer_code)

def lookup_draft(context, n=2, k=6):
    """Ищем последние n токенов в запросе и предлагаем k токенов, которые шли за ними."""
    tail = context[-n:]
    for i in range(len(prompt) - n, -1, -1):
        if prompt[i:i + n] == tail:
            return prompt[i + n:i + n + k]
    return []

out, passes, accepted = [], 0, 0
while len(out) < len(answer):
    draft = lookup_draft(prompt + out)
    passes += 1                                          # один проход большой модели проверяет весь черновик
    ok = 0
    while ok < len(draft) and len(out) + ok < len(answer) and draft[ok] == answer[len(out) + ok]:
        ok += 1
    accepted += ok
    out += answer[len(out):len(out) + ok + 1]            # принятое + один токен от большой модели
print("токенов в ответе:", len(answer))
print("проходов большой модели:", passes, " принято из черновика:", accepted)
print("в среднем токенов за проход:", round(len(answer) / passes, 2))
print("ответ собран верно:", out == answer)

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

токенов в ответе: 51
проходов большой модели: 21  принято из черновика: 31
в среднем токенов за проход: 2.43
ответ собран верно: True

Вместо 51 прохода хватило 21 — в среднем 2,43 токена за проход, и черновик для этого не стоил ни одного вызова модели. Почему не больше: на каждом месте, где в ответе стоит новое имя total вместо s, поиск предлагает старое продолжение из запроса и получает отказ, а сразу после переименования последние два токена ответа обычно не встречаются в запросе вовсе, и черновика нет. Чем меньше правок относительно исходного текста, тем выше выигрыш; на свободном сочинении поиск почти не находил бы совпадений и давал бы около одного токена за проход.

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

  • Включают поиск в запросе для чата «обо всём». Ответ редко повторяет запрос, черновиков почти нет, и ускорения нет; этот метод для правки, пересказа и ответа по документам.
  • Берут готовые дополнительные головы от другой модели или другой версии. Они обучены на внутренние состояния конкретной модели и с другой работают плохо.
  • Не мерят долю принятия после переключения на новый вариант черновика. Без этого числа невозможно понять, какой из вариантов выгоднее на твоих задачах.

Поиск в запросе (n-gram lookup, prompt lookup decoding). черновик, взятый из того места запроса, где уже встречались последние написанные токены.

N-грамма (n-gram). последовательность из n идущих подряд токенов.

Дополнительная голова предсказания. маленький слой поверх большой модели, который угадывает токен на несколько позиций вперёд.

Medusa. схема с несколькими дополнительными головами, каждая из которых предсказывает свою позицию вперёд.

EAGLE. схема, где черновик строится по скрытым векторам большой модели, а не только по уже выбранным токенам.

Предсказание нескольких токенов (multi-token prediction). обучение модели угадывать сразу несколько следующих токенов, которое заодно даёт встроенный черновик.

Скрытое состояние (hidden state). внутренний вектор модели для токена на каком-то слое, из которого получается её предсказание.

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