Tutorial Multi-Token Prediction: Cara Mempercepat LLM

Apa itu Multi-Token Prediction?

Sebagian besar LLM menghasilkan teks satu token per waktu. Model memprediksi token berikutnya, menambahkannya ke konteks, lalu mengulangi proses yang sama lagi. Ini andal, tetapi bisa lambat karena setiap token baru biasanya memerlukan langkah decoding lain.

Multi-Token Prediction mengubah ini dengan memungkinkan model untuk melihat ke depan dan mengusulkan beberapa token masa depan alih-alih hanya satu. Token yang diusulkan ini kemudian diperiksa oleh proses decoding utama. Jika prediksi benar, model dapat menerima beberapa token sekaligus. Jika ada token yang salah, model kembali ke jalur normal dari titik tersebut.

Dalam praktiknya, MTP bekerja seperti mekanisme drafting bawaan. Model menyusun beberapa token berikutnya yang mungkin, memverifikasinya, dan mempertahankan yang valid. Semakin banyak token draft yang diterima, semakin sedikit langkah decoding penuh yang dibutuhkan, yang dapat meningkatkan token per detik tanpa mengubah kualitas keluaran akhir.

Secara sederhana:

• Tanpa MTP: Hasilkan token 1 → hasilkan token 2 → hasilkan token 3
• Dengan MTP: Susun beberapa token → verifikasi → terima token yang valid bersama-sama

Inilah sebabnya MTP dapat membuat inferensi LLM lokal terasa jauh lebih cepat. Alih-alih memaksa model maju selangkah kecil setiap waktu, ini memungkinkan model melompat lebih jauh dengan aman kapan pun prediksi draft-nya benar. 

Dalam alat seperti llama.cpp dan implementasi bergaya vLLM-style, ini terkait erat dengan speculative decoding, di mana token draft diterima hanya ketika cocok dengan keluaran verifikator. 

1. Menyiapkan Mesin RunPod RTX 3090

Untuk panduan ini, saya menggunakan instance GPU RunPod dengan RTX 3090. Anda bisa memakai GPU lain yang mendukung CUDA, tetapi hasil benchmark dalam tutorial ini didasarkan pada setup RTX 3090.

Pertama, buat pod RunPod baru dan pilih GPU RTX 3090.

Sebelum men-deploy pod, edit pengaturan templat:

• Tingkatkan ukuran disk volume menjadi 100 GB

• Tambahkan port HTTP tambahan: 8910

• Tambahkan variabel lingkungan bernama HF_TOKEN dan atur nilainya ke access token Hugging Face Anda. 

Port HTTP ekstra akan memungkinkan Anda mengakses server dan web UI llama.cpp dari browser. Token Hugging Face membantu mengautentikasi permintaan unduhan dan dapat mempercepat pengunduhan model, terutama untuk file GGUF yang besar.

Setelah memperbarui templat, deploy pod. Setelah berjalan, tunggu hingga RunPod memberi Anda akses ke instance JupyterLab. Buka JupyterLab, lalu luncurkan terminal baru.

Di dalam terminal, instal paket sistem yang diperlukan:

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

2. Clone dan Beralih ke Branch MTP

Selanjutnya, masuk ke direktori workspace tempat kita akan memasang dan membangun llama.cpp:

cd /workspace

Clone repositori llama.cpp:

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

Perubahan MTP masih diuji melalui pull request khusus di llama.cpp, jadi kita fetch dan beralih ke branch tersebut untuk menggunakan implementasi MTP terbaru sebelum menjadi bagian dari build main standar.

Fetch branch MTP secara lokal:

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

Ini mengalihkan build llama.cpp lokal Anda ke versi yang mendukung MTP, yang akan kita gunakan untuk sisa panduan.

3. Membangun llama.cpp dengan Dukungan CUDA

Sekarang Anda sudah berada di branch yang mendukung MTP, bangun llama.cpp dengan dukungan CUDA. Ini memungkinkan model menggunakan GPU RTX 3090 alih-alih menjalankan inferensi di CPU.

Jalankan konfigurasi build CMake:

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

Lalu kompilasi dua target yang kita butuhkan untuk panduan ini:

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

Ini akan membangun:

• llama-cli untuk menjalankan uji cepat lewat command line

• llama-server untuk meluncurkan server yang kompatibel dengan OpenAI dengan akses melalui browser

Setelah build selesai, salin binary llama-server ke direktori utama llama.cpp:

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

Ini memudahkan menjalankan server dari root proyek pada langkah berikutnya.

4. Unduh Model Qwen3.6-27B-MTP

Berikutnya, unduh model Qwen3.6 27B MTP GGUF yang akan kita gunakan untuk pengujian. Ini adalah model yang akan kita jalankan terlebih dahulu tanpa MTP, lalu kembali dengan MTP diaktifkan untuk membandingkan perbedaan kecepatan.

Pertama, pasang alat unduh Hugging Face:

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

Kemudian aktifkan pengunduhan Hugging Face yang lebih cepat:

export HF_HUB_ENABLE_HF_TRANSFER=1

Ini membantu mempercepat pengunduhan model besar, terutama saat bekerja dengan file GGUF.

Sekarang buat direktori khusus untuk model:

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

Unduh 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

Jika Anda tertarik pada fine-tuning LLM, lihat tutorial saya tentang fine-tuning Qwen3.6 pada dataset tanya jawab medis.

5. Jalankan Qwen3.6-27B Tanpa MTP Diaktifkan

Sekarang kita sampai pada bagian utama panduan: menguji kecepatan model sebelum dan sesudah mengaktifkan MTP.

Pertama, kita akan menjalankan model tanpa MTP. Ini memberi kita baseline yang bersih sehingga kita dapat membandingkan perbedaan kecepatan nanti. Kita menggunakan model yang sama, GPU yang sama, ukuran konteks yang sama, dan pengaturan server yang sama. Satu-satunya perubahan utama pada langkah berikutnya adalah mengaktifkan MTP.

Kembali ke direktori llama.cpp:

cd /workspace/llama.cpp

Mulai server tanpa 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

Ini menjalankan server llama.cpp yang kompatibel dengan OpenAI pada port 8910.

Model mungkin memerlukan waktu singkat untuk dimuat karena server perlu memuat bobot model ke memori GPU. Setelah semuanya siap, terminal akan menampilkan bahwa server tersedia pada port 8910.

Karena kita mengekspos port ini saat menyiapkan templat RunPod, Anda tidak perlu mengonfigurasi apa pun lagi. Kembali ke dasbor RunPod Anda dan klik tautan yang terkait dengan port 8910. Ini akan membuka web UI llama.cpp di browser Anda, dengan model lokal yang sudah dimuat.

Dari sana, Anda dapat mulai menguji prompt langsung di browser, mirip seperti menggunakan antarmuka chat.

Dalam uji baseline saya, model menghasilkan respons sekitar 38,86 token/dtk tanpa MTP. Bahkan dengan prompt yang lebih kompleks, kecepatannya tetap di kisaran yang sama. 

Untuk model 27B yang berjalan di RTX 3090, ini sudah hasil yang dapat digunakan, terlebih mengingat GPU ini lebih lambat dan memiliki memori terbatas dibanding kartu data center yang lebih baru. 

6. Jalankan Qwen3.6-27B dengan MTP Diaktifkan

Sekarang kita akan menjalankan model yang sama lagi, tetapi kali ini dengan MTP diaktifkan.

Kembali ke terminal tempat server berjalan dan hentikan dengan:

CTRL + C

Hal penting di sini adalah kita tidak mengubah model, GPU, kuantisasi, atau sebagian besar pengaturan runtime. Kita hanya menambahkan dua flag terkait MTP:

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

Flag pertama memberi tahu llama.cpp untuk menggunakan speculative decoding gaya MTP. Flag kedua mengatur jumlah maksimum token draft menjadi 3. Artinya model dapat mencoba menyusun hingga tiga token masa depan sebelum verifikasi.

Sekarang mulai lagi server dengan MTP diaktifkan:

./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

Setelah server siap, segarkan halaman browser. Jika halaman tidak tersambung kembali secara otomatis, tutup lalu buka lagi tautan port 8910 dari dasbor RunPod Anda. 

Sekarang uji lagi model menggunakan jenis prompt yang sama.

Dengan MTP diaktifkan, kecepatannya meningkat secara nyata. Untuk prompt salam sederhana, model mencapai sekitar 65–67 token/dtk. Dibandingkan baseline sekitar 38,86 token/dtk, ini adalah peningkatan besar hanya dengan menambahkan dua flag command-line. 

Untuk prompt yang lebih kompleks, seperti meminta model membangun gim sederhana dalam Python, kecepatan sedikit lebih rendah tetapi masih jauh lebih cepat daripada baseline non-MTP. Dalam uji tersebut, model menghasilkan sekitar 56–61 token/dtk, yang tetap hasil kuat untuk model 27B di RTX 3090. 

Secara keseluruhan, mengaktifkan MTP meningkatkan Qwen3.6 27B dari sekitar 38 token/dtk menjadi 65 token/dtk pada setup RunPod RTX 3090. Itu memberikan percepatan 1,71x, atau sekitar 71% throughput lebih tinggi, tanpa mengubah perangkat keras atau beralih ke model yang lebih kecil. 

7. Rekomendasi: Optimisasi Kecepatan Lanjutan dengan TurboQuant

Benchmark dalam panduan ini menggunakan setup MTP asli llama.cpp, tanpa menambahkan TurboQuant, patch kustom, atau optimisasi tingkat runtime lainnya. Ini membuat pengujian tetap sederhana, dapat direproduksi, dan berfokus pada peningkatan kecepatan dari mengaktifkan MTP saja.

Untuk mendorong performa lebih jauh, optimisasi berikutnya yang perlu dijelajahi adalah MTP dan TurboQuant bersamaan. MTP meningkatkan throughput dengan memungkinkan model menerima beberapa token yang diprediksi, sementara TurboQuant membantu mengurangi tekanan memori KV-cache selama inferensi. 

Ini bisa sangat berguna untuk model yang lebih besar, prompt konteks panjang, dan GPU seperti RTX 3090, di mana bandwidth memori dan VRAM dapat menjadi faktor pembatas.

Inilah mengapa beberapa hasil komunitas r/LocalLLaMA melaporkan token/dtk yang lebih tinggi daripada panduan ini. Setup tersebut sering menggabungkan MTP dengan TurboQuant, build yang dipatch, pengaturan KV-cache berbeda, atau GPU yang lebih cepat. Karena tutorial ini berfokus pada benchmark MTP-bersih, TurboQuant sebaiknya diperlakukan sebagai eksperimen berikutnya yang direkomendasikan, bukan bagian dari setup saat ini.

Pemikiran Akhir 

Belakangan ini, saya mengikuti posting di komunitas Reddit LocalLLaMA, dan sungguh menakjubkan melihat sejauh apa inferensi LLM lokal telah berkembang. Banyak orang kini menjalankan model seperti Qwen3.6 27B sebagai agen pengodean lokal, bahkan pada GPU lama dengan VRAM terbatas. Beberapa juga menjalankan setup serupa di sistem Mac, dan hasilnya benar-benar mengesankan.

Setelah menguji MTP sendiri, saya paham mengapa banyak yang antusias. Dengan model dan setup RTX 3090 yang sama, mengaktifkan Multi-Token Prediction meningkatkan kecepatan generasi dari sekitar 38 token/dtk menjadi 65 token/dtk. Itu hampir 2x lebih cepat tanpa meng-upgrade GPU atau beralih ke model yang lebih kecil.

Panduan ini berfokus pada setup MTP yang sederhana dan dapat direproduksi menggunakan llama.cpp, tetapi ini terasa baru permulaan. Langkah berikutnya adalah bereksperimen dengan kuantisasi GGUF yang lebih baik, MTP, TurboQuant, dan pengaturan runtime yang lebih tertata untuk melihat seberapa jauh lagi kecepatan inferensi lokal bisa didorong.

Bagi saya, bagian paling menarik adalah maknanya bagi agen pengodean lokal. Anda bisa menjalankan model bertenaga di perangkat keras Anda sendiri, menurunkan biaya per kueri, menjaga kode Anda tetap privat, dan menggunakan asisten pengodean AI tanpa sepenuhnya bergantung pada API berbasis internet. LLM lokal menjadi lebih cepat, lebih praktis, dan jauh lebih berguna daripada sebelumnya.