Samouczek Multi-Token Prediction: jak przyspieszyć LLM-y

Czym jest Multi-Token Prediction?

Większość LLM-ów generuje tekst po jednym tokenie. Model przewiduje kolejny token, dodaje go do kontekstu i powtarza ten sam proces. To niezawodne, ale bywa wolne, ponieważ każdy nowy token zwykle wymaga kolejnego kroku dekodowania.

Multi-Token Prediction zmienia to, pozwalając modelowi wybiegać w przód i proponować kilka przyszłych tokenów zamiast tylko jednego. Te propozycje są następnie weryfikowane przez główny proces dekodowania. Jeśli przewidywania są poprawne, model może przyjąć kilka tokenów naraz. Jeśli któryś token jest błędny, model wraca od tego miejsca do normalnej ścieżki.

W praktyce MTP działa jak wbudowany mechanizm szkicowania. Model szkicuje kilka prawdopodobnych kolejnych tokenów, weryfikuje je i zachowuje prawidłowe. Im więcej szkicowanych tokenów zostanie zaakceptowanych, tym mniej pełnych kroków dekodowania jest potrzebnych, co może zwiększyć liczbę tokenów na sekundę bez zmiany jakości wyniku.

W prostych słowach:

• Bez MTP: Generuj token 1 → generuj token 2 → generuj token 3
• Z MTP: Szkicuj wiele tokenów → zweryfikuj je → zaakceptuj poprawne łącznie

Dlatego MTP może znacząco przyspieszyć lokalną inferencję LLM. Zamiast zmuszać model do poruszania się małymi krokami, umożliwia bezpieczne przeskakiwanie naprzód, kiedy jego szkicowe przewidywania są trafne. 

W narzędziach takich jak llama.cpp i implementacjach w stylu vLLM-style jest to ściśle powiązane ze spekulatywnym dekodowaniem, gdzie szkicowe tokeny są akceptowane tylko wtedy, gdy pokrywają się z wynikiem weryfikatora. 

1. Skonfiguruj maszynę RunPod RTX 3090

Do tego przewodnika użyłem instancji GPU RunPod z RTX 3090. Można użyć innego GPU z obsługą CUDA, ale wyniki benchmarku w tym poradniku opierają się na konfiguracji z RTX 3090.

Najpierw utwórz nowy pod RunPod i wybierz GPU RTX 3090.

Przed wdrożeniem poda edytuj ustawienia szablonu:

• Zwiększ rozmiar dysku wolumenu do 100 GB

• Dodaj dodatkowy port HTTP: 8910

• Dodaj zmienną środowiskową HF_TOKEN i ustaw jej wartość na swój token dostępu Hugging Face. 

Dodatkowy port HTTP pozwoli uzyskać dostęp do serwera i interfejsu webowego llama.cpp z poziomu przeglądarki. Token Hugging Face pomaga uwierzytelnić pobieranie i może przyspieszyć transfer modeli, zwłaszcza dużych plików GGUF.

Po zaktualizowaniu szablonu wdroż pod. Gdy będzie uruchomiony, poczekaj, aż RunPod udostępni dostęp do instancji JupyterLab. Otwórz JupyterLab, a następnie uruchom nowy terminal.

W terminalu zainstaluj wymagane pakiety systemowe:

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

2. Sklonuj repozytorium i przełącz się na gałąź MTP

Następnie przejdź do katalogu workspace, w którym zainstalujemy i zbudujemy llama.cpp:

cd /workspace

Sklonuj repozytorium llama.cpp:

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

Zmiany MTP są nadal testowane w dedykowanym pull requeście do llama.cpp, więc pobierzemy i przełączymy się na tę gałąź, aby skorzystać z najnowszej implementacji MTP, zanim trafi do standardowego wydania.

Pobierz gałąź MTP lokalnie:

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

To przełącza lokalną kompilację llama.cpp na wersję z włączonym MTP, której użyjemy w dalszej części przewodnika.

3. Zbuduj llama.cpp z obsługą CUDA

Teraz, będąc na gałęzi z włączonym MTP, zbuduj llama.cpp z obsługą CUDA. Dzięki temu model wykorzysta GPU RTX 3090 zamiast uruchamiać inferencję na CPU.

Uruchom konfigurację kompilacji CMake:

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

Następnie skompiluj dwa cele potrzebne w tym przewodniku:

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

To buduje:

• llama-cli do szybkich testów w wierszu poleceń

• llama-server do uruchamiania serwera kompatybilnego z OpenAI z dostępem przez przeglądarkę

Po zakończeniu kompilacji skopiuj plik wykonywalny llama-server do głównego katalogu llama.cpp:

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

Ułatwi to uruchamianie serwera z katalogu głównego projektu w kolejnych krokach.

4. Pobierz model Qwen3.6-27B-MTP

Następnie pobierz model Qwen3.6 27B MTP w formacie GGUF, którego użyjemy do testów. Uruchomimy go najpierw bez MTP, a potem ponownie z włączonym MTP, aby porównać różnicę w szybkości.

Najpierw zainstaluj narzędzia do pobierania z Hugging Face:

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

Następnie włącz szybsze pobieranie z Hugging Face:

export HF_HUB_ENABLE_HF_TRANSFER=1

To pomaga przyspieszyć pobieranie dużych modeli, zwłaszcza plików GGUF.

Utwórz teraz dedykowany katalog na model:

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

Pobierz model 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

Jeśli interesuje Pana/Panią dostrajanie LLM-ów, proszę zajrzeć do mojego poradnika o dostrajaniu Qwen3.6 na medycznym zbiorze Q&A.

5. Uruchom Qwen3.6-27B bez włączonego MTP

Przechodzimy do głównej części przewodnika: testowania szybkości modelu przed i po włączeniu MTP.

Najpierw uruchomimy model bez MTP. Daje to czysty punkt odniesienia, aby później porównać różnicę w szybkości. Używamy tego samego modelu, tego samego GPU, tej samej długości kontekstu i tych samych ustawień serwera. Jedyną istotną zmianą w kolejnym kroku będzie włączenie MTP.

Wróć do katalogu llama.cpp:

cd /workspace/llama.cpp

Uruchom serwer bez 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

To uruchamia serwer llama.cpp kompatybilny z OpenAI na porcie 8910.

Model może ładować się chwilę, ponieważ serwer musi wczytać wagi do pamięci GPU. Gdy wszystko będzie gotowe, terminal pokaże, że serwer jest dostępny na porcie 8910.

Ponieważ odsłoniliśmy ten port podczas konfiguracji szablonu RunPod, nie trzeba nic więcej ustawiać. Proszę wrócić do pulpitu RunPod i kliknąć link powiązany z portem 8910. Otworzy się interfejs webowy llama.cpp w przeglądarce, z już załadowanym lokalnym modelem.

Stąd można zacząć testować prompty bezpośrednio w przeglądarce, podobnie jak w interfejsie czatu.

W moim teście bazowym model generował odpowiedzi z prędkością około 38,86 tokenów/s bez MTP. Nawet przy bardziej złożonym promptcie prędkość pozostawała w podobnym zakresie. 

Jak na model 27B działający na RTX 3090, to już wynik używalny, zwłaszcza że to GPU jest wolniejsze i ma mniej pamięci niż nowsze karty centrów danych. 

6. Uruchom Qwen3.6-27B z włączonym MTP

Teraz uruchomimy ten sam model ponownie, ale tym razem z włączonym MTP.

Wróć do terminala, w którym działa serwer, i zatrzymaj go skrótem:

CTRL + C

Kluczowe jest to, że nie zmieniamy modelu, GPU, kwantyzacji ani większości ustawień wykonania. Dodajemy tylko dwie flagi związane z MTP:

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

Pierwsza flaga mówi llama.cpp, aby użyła spekulatywnego dekodowania w stylu MTP. Druga ustawia maksymalną liczbę szkicowanych tokenów na 3. Oznacza to, że model może próbować naszkicować do trzech przyszłych tokenów przed weryfikacją.

Teraz uruchom serwer ponownie z włączonym 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

Gdy serwer będzie gotowy, odśwież stronę w przeglądarce. Jeśli strona nie połączy się ponownie automatycznie, proszę ją zamknąć i ponownie otworzyć link do portu 8910 z pulpitu RunPod. 

Przetestuj teraz model ponownie, używając tego samego typu promptów.

Po włączeniu MTP prędkość wyraźnie wzrosła. Dla prostego promptu powitalnego model osiągnął około 65–67 tokenów/s. W porównaniu z bazową prędkością około 38,86 tokenów/s to duża poprawa dzięki dodaniu zaledwie dwóch flag wiersza poleceń. 

Przy bardziej złożonym promptcie, np. prośbie o zbudowanie prostej gry w Pythonie, prędkość była nieco niższa, ale wciąż znacznie wyższa niż bez MTP. W tym teście model generował około 56–61 tokenów/s, co nadal jest bardzo dobrym wynikiem dla modelu 27B na RTX 3090. 

Łącznie włączenie MTP poprawiło Qwen3.6 27B z około 38 tokenów/s do 65 tokenów/s na konfiguracji RunPod z RTX 3090. Daje to 1,71× przyspieszenie, czyli około 71% wyższą przepustowość, bez zmiany sprzętu i bez przechodzenia na mniejszy model. 

7. Rekomendacja: dalsza optymalizacja szybkości z TurboQuant

Benchmark w tym poradniku korzysta z oryginalnej konfiguracji MTP w llama.cpp, bez dodawania TurboQuant, niestandardowych łatek czy innych optymalizacji na poziomie wykonania. Dzięki temu test jest prosty, powtarzalny i skupia się na zysku z samego włączenia MTP.

Aby pójść dalej z wydajnością, kolejną optymalizacją do zbadania jest połączenie MTP i TurboQuant. MTP zwiększa przepustowość, pozwalając modelowi akceptować wiele przewidzianych tokenów, a TurboQuant pomaga zmniejszyć presję na pamięć podręczną KV podczas inferencji. 

Może to być szczególnie przydatne dla większych modeli, długich kontekstów oraz GPU takich jak RTX 3090, gdzie przepustowość pamięci i VRAM mogą być czynnikami ograniczającymi.

Dlatego w społeczności r/LocalLLaMA pojawiają się wyniki z wyższą liczbą tokenów/s niż w tym przewodniku. Te konfiguracje często łączą MTP z TurboQuant, łatkami, innymi ustawieniami pamięci KV-cache lub szybszymi GPU. Ponieważ ten samouczek skupia się na czystym benchmarku tylko z MTP, TurboQuant należy traktować jako zalecany kolejny eksperyment, a nie część bieżącej konfiguracji.

Na zakończenie 

Ostatnio śledzę wpisy w społeczności LocalLLaMA na Reddicie i niesamowite jest, jak daleko zaszła lokalna inferencja LLM. Ludzie uruchamiają dziś modele takie jak Qwen3.6 27B jako lokalnych agentów do kodowania, nawet na starszych GPU z ograniczonym VRAM. Niektórzy uruchamiają podobne konfiguracje na Macach i wyniki są naprawdę imponujące.

Po własnych testach MTP rozumiem, skąd ten entuzjazm. Przy tym samym modelu i tej samej konfiguracji RTX 3090 włączenie Multi-Token Prediction poprawiło szybkość generowania z około 38 tokenów/s do 65 tokenów/s. To niemal 2× szybciej bez wymiany GPU czy przechodzenia na mniejszy model.

Ten przewodnik skupił się na prostej i powtarzalnej konfiguracji MTP w llama.cpp, ale to dopiero początek. Kolejny krok to eksperymenty z lepszą kwantyzacją GGUF, MTP, TurboQuant i bardziej dostrojonymi ustawieniami wykonania, aby sprawdzić, jak bardzo można jeszcze przyspieszyć lokalną inferencję.

Najbardziej ekscytująca jest dla mnie wizja lokalnych agentów do kodowania. Można uruchamiać mocne modele na własnym sprzęcie, obniżać koszt na zapytanie, zachować prywatność kodu i korzystać z asystenta AI bez pełnej zależności od internetowych API. Lokalne LLM-y stają się szybsze, bardziej praktyczne i znacznie użyteczniejsze niż jeszcze niedawno.