Руководство по Multi-Token Prediction: как ускорить LLM

Что такое Multi-Token Prediction?

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

Multi-Token Prediction меняет это, позволяя модели смотреть вперёд и предлагать несколько будущих токенов вместо одного. Эти предложенные токены затем проверяются основным процессом декодирования. Если предсказания верны, модель может принять сразу несколько токенов. Если один токен неверный, модель с этого места возвращается на обычный путь.

На практике MTP работает как встроенный механизм черновиков. Модель набрасывает несколько вероятных следующих токенов, проверяет их и сохраняет валидные. Чем больше черновых токенов принимается, тем меньше требуется полных шагов декодирования, что повышает количество токенов в секунду без изменения качества финального вывода.

Проще говоря:

• Без MTP: Сгенерировать токен 1 → сгенерировать токен 2 → сгенерировать токен 3
• С MTP: Набросать несколько токенов → проверить их → принять валидные токены вместе

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

В таких инструментах, как llama.cpp и реализации в стиле vLLM-типа это тесно связано со спекулятивным декодированием, где черновые токены принимаются только при совпадении с выводом верификатора. 

1. Настройте машину RunPod RTX 3090

Для этого гайда я использовал GPU-инстанс RunPod с RTX 3090. Можно использовать и другой GPU с поддержкой CUDA, но результаты бенчмарка в этом туториале основаны на конфигурации с RTX 3090.

Сначала создайте новый pod в RunPod и выберите GPU RTX 3090.

Перед развёртыванием pod отредактируйте параметры шаблона:

• Увеличьте размер диска тома до 100 ГБ

• Добавьте дополнительный HTTP-порт: 8910

• Добавьте переменную окружения HF_TOKEN и установите для неё значение вашего токена доступа Hugging Face. 

Дополнительный HTTP-порт позволит открыть сервер и веб‑интерфейс llama.cpp из браузера. Токен Hugging Face помогает аутентифицировать запрос и может ускорить загрузку модели, особенно крупных GGUF‑файлов.

После обновления шаблона разверните pod. Когда он запустится, дождитесь доступа к JupyterLab. Откройте JupyterLab и запустите новый терминал.

В терминале установите необходимые системные пакеты:

apt update
apt install -y git cmake build-essential curl wget python3-pip

2. Клонируйте репозиторий и переключитесь на ветку MTP

Далее перейдите в рабочую директорию, где мы установим и соберём llama.cpp:

cd /workspace

Клонируйте репозиторий llama.cpp:

git clone --depth 1 https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

Изменения для MTP всё ещё тестируются в отдельном pull request к llama.cpp, поэтому мы получим и переключимся на эту ветку, чтобы использовать актуальную реализацию MTP до того, как она войдёт в основную сборку.

Заберите ветку MTP локально:

git fetch origin pull/22673/head:mtp-pr
git checkout mtp-pr

Это переключает вашу локальную сборку llama.cpp на версию с поддержкой MTP, которую мы будем использовать далее.

3. Соберите llama.cpp с поддержкой CUDA

Теперь, находясь на ветке с поддержкой MTP, соберите llama.cpp с поддержкой CUDA. Это позволит модели использовать GPU RTX 3090 вместо запуска инференса на CPU.

Запустите конфигурацию сборки CMake:

cmake -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release

Затем скомпилируйте две цели, которые нам нужны в этом гайде:

cmake --build build --target llama-cli llama-server -j

Это соберёт:

• llama-cli для быстрых тестов в командной строке

• llama-server для запуска совместимого с OpenAI сервера с доступом из браузера

После завершения сборки скопируйте бинарный файл llama-server в корневую директорию llama.cpp:

cp ./build/bin/llama-server ./llama-server

Так будет удобнее запускать сервер из корня проекта на следующем шаге.

4. Скачайте модель Qwen3.6-27B-MTP

Теперь скачайте модель Qwen3.6 27B MTP в формате GGUF, с которой мы будем проводить тестирование. Сначала запустим её без MTP, а затем включим MTP для сравнения скорости.

Сначала установите инструменты загрузки Hugging Face:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Затем включите ускоренные загрузки Hugging Face:

export HF_HUB_ENABLE_HF_TRANSFER=1

Это помогает ускорить загрузку больших моделей, особенно в формате GGUF.

Создайте отдельную директорию для модели:

mkdir -p /workspace/models/qwen3.6-mtp

Скачайте модель Qwen3.6 27B MTP в формате GGUF:

hf download froggeric/Qwen3.6-27B-MTP-GGUF \
 Qwen3.6-27B-Q4_K_M-mtp.gguf \
 --local-dir /workspace/models/qwen3.6-mtp

Если вас интересует дообучение LLM, посмотрите мой туториал по дообучению Qwen3.6 на медицинском датасете вопросов и ответов.

5. Запустите Qwen3.6-27B без включённого MTP

Теперь мы подходим к основной части гайда: тестированию скорости модели до и после включения MTP.

Сначала запустим модель без MTP. Это даст чистую базовую линию для последующего сравнения. Мы используем ту же модель, тот же GPU, тот же размер контекста и те же настройки сервера. Единственным серьёзным изменением на следующем шаге будет включение MTP.

Вернитесь в директорию llama.cpp:

cd /workspace/llama.cpp

Запустите сервер без MTP:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-no-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

Это запустит совместимый с OpenAI сервер llama.cpp на порту 8910.

Загрузка модели может занять немного времени, так как серверу нужно поместить веса в память GPU. Когда всё будет готово, в терминале появится сообщение о доступности сервера на порту 8910.

Поскольку мы открыли этот порт на этапе настройки шаблона RunPod, ничего дополнительно конфигурировать не нужно. Вернитесь в панель RunPod и нажмите на ссылку, связанную с портом 8910. Откроется веб‑интерфейс llama.cpp в вашем браузере с уже загруженной локальной моделью.

Отсюда вы можете начинать тестировать подсказки прямо в браузере, как в обычном чат‑интерфейсе.

В моём базовом тесте модель генерировала ответы примерно со скоростью 38,86 токенов/с без MTP. Даже с более сложной подсказкой скорость оставалась в том же диапазоне. 

Для модели 27B на RTX 3090 это уже рабочий результат, особенно с учётом того, что этот GPU медленнее и имеет меньше памяти по сравнению с современными датацентровыми картами. 

6. Запустите Qwen3.6-27B с включённым MTP

Теперь запустим ту же модель снова, но на этот раз с включённым MTP.

Вернитесь в терминал, где запущен сервер, и остановите его сочетанием:

CTRL + C

Важно, что мы не меняем модель, GPU, квантизацию или большинство настроек рантайма. Мы лишь добавляем два флага, связанных с MTP:

--spec-type mtp
--spec-draft-n-max 3

Первый флаг указывает llama.cpp использовать спекулятивное декодирование в стиле MTP. Второй задаёт максимум черновых токенов равным 3. Это значит, что модель может пытаться набросать до трёх будущих токенов перед проверкой.

Теперь запустите сервер снова с включённым MTP:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--spec-type mtp \
--spec-draft-n-max 3 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

Когда сервер будет готов, обновите страницу в браузере. Если страница не переподключается автоматически, закройте её и снова откройте ссылку на порт 8910 из панели RunPod. 

Теперь протестируйте модель снова с тем же типом подсказок.

С включённым MTP скорость заметно выросла. Для простой приветственной подсказки модель достигала примерно 65–67 токенов/с. По сравнению с базовой скоростью около 38,86 токенов/с это значительное улучшение всего от двух флагов командной строки. 

Для более сложной подсказки, например просьбы собрать простую игру на Python, скорость была чуть ниже, но всё ещё намного выше, чем без MTP. В том тесте модель генерировала примерно 56–61 токенов/с, что остаётся сильным результатом для модели 27B на RTX 3090. 

В целом включение MTP улучшило Qwen3.6 27B с примерно 38 токенов/с до 65 токенов/с на стенде RunPod с RTX 3090. Это даёт ускорение в 1,71 раза, или около 71% больший пропускной поток, без смены «железа» или перехода на меньшую модель. 

7. Рекомендация: дополнительная оптимизация скорости с TurboQuant

Бенчмарк в этом гайде использует исходную настройку MTP в llama.cpp без добавления TurboQuant, кастомных патчей или других оптимизаций на уровне рантайма. Это делает тест простым, воспроизводимым и сосредоточенным на приросте скорости только от включения MTP.

Чтобы продвинуться дальше, следующая оптимизация — это совместное использование MTP и TurboQuant. MTP увеличивает пропускную способность за счёт принятия нескольких предсказанных токенов, а TurboQuant снижает давление на память KV‑кэша во время инференса. 

Это особенно полезно для крупных моделей, длинных контекстов и GPU вроде RTX 3090, где узким местом могут стать пропускная способность памяти и объём VRAM.

Поэтому некоторые результаты сообщества r/LocalLLaMA показывают более высокие токены/с, чем в этом гайде. Там часто комбинируют MTP с TurboQuant, патчёнными сборками, иными настройками KV‑кэша или более быстрыми GPU. Поскольку этот туториал фокусируется на чистом бенчмарке только с MTP, TurboQuant стоит рассматривать как рекомендуемый следующий эксперимент, а не часть текущей конфигурации.

Заключение 

В последнее время я следил за постами в сообществе LocalLLaMA на Reddit — поразительно, как далеко продвинулся локальный инференс LLM. Люди запускают модели вроде Qwen3.6 27B как локальных код‑агентов даже на старых GPU с ограниченной VRAM. Некоторые разворачивают похожие конфигурации и на Mac — результаты действительно впечатляют.

После собственного тестирования MTP я понимаю, откуда такой интерес. С той же моделью и тем же стендом на RTX 3090 включение Multi-Token Prediction ускорило генерацию с примерно 38 токенов/с до 65 токенов/с. Это почти двукратное ускорение без апгрейда GPU или перехода на меньшую модель.

В этом гайде мы сосредоточились на простой и воспроизводимой настройке MTP в llama.cpp, но ощущение такое, что это лишь начало. Следующий шаг — поэкспериментировать с лучшей квантизацией GGUF, MTP, TurboQuant и более тонкими настройками рантайма, чтобы посмотреть, насколько ещё можно ускорить локальный инференс.

Лично меня больше всего вдохновляют перспективы для локальных код‑агентов. Вы можете запускать мощные модели на своём «железе», снижать стоимость запроса, хранить исходники в приватности и пользоваться AI‑помощником по кодингу без полной зависимости от облачных API. Локальные LLM становятся быстрее, практичнее и заметно полезнее, чем ещё совсем недавно.