Çoklu Token Tahmini Eğitimi: LLM’leri Nasıl Hızlandırırsınız

Çoklu Token Tahmini (MTP) Nedir?

Çoğu LLM, metni bir seferde bir token üreterek oluşturur. Model bir sonraki tokenı tahmin eder, bağlama ekler ve aynı işlemi tekrarlar. Bu güvenilirdir, ancak her yeni token genellikle başka bir çözümleme adımı gerektirdiğinden yavaş olabilir.

Çoklu Token Tahmini bunu, modelin yalnızca bir tane yerine birden fazla gelecekteki tokenı öngörmesine izin vererek değiştirir. Bu önerilen tokenlar daha sonra ana çözümleme süreci tarafından kontrol edilir. Tahminler doğruysa, model bir seferde birkaç tokenı kabul edebilir. Bir token yanlışsa model o noktadan itibaren normal yola geri döner.

Pratikte, MTP yerleşik bir taslak hazırlama mekanizması gibi çalışır. Model birkaç olası sonraki tokenı taslak olarak üretir, doğrular ve geçerli olanları tutar. Kabul edilen taslak token sayısı arttıkça gereken tam çözümleme adımları azalır; bu da nihai çıktı kalitesini değiştirmeden saniyedeki token sayısını artırabilir.

Basitçe söylemek gerekirse:

• MTP olmadan: Token 1 üret → token 2 üret → token 3 üret
• MTP ile: Birden fazla token taslağı hazırla → doğrula → geçerli tokenları birlikte kabul et

MTP’nin yerel LLM çıkarımını daha hızlı hissettirmesinin nedeni budur. Modeli her seferinde küçük adımlarla ilerlemeye zorlamak yerine, taslak tahminleri doğru olduğunda güvenle öne atlamasına izin verir. 

llama.cpp ve vLLM tarzı uygulamalarda bu, taslak tokenların yalnızca doğrulayıcının çıktısıyla eşleştiğinde kabul edildiği spekülatif çözümleme ile yakından ilişkilidir. 

1. RunPod RTX 3090 Makinesi Kurun

Bu kılavuz için RTX 3090’lı bir RunPod GPU örneği kullandım. Başka bir CUDA destekli GPU kullanabilirsiniz, ancak bu eğitimdeki kıyaslama sonuçları bir RTX 3090 kurulumuna dayanmaktadır.

Önce yeni bir RunPod pod’u oluşturun ve RTX 3090 GPU’sunu seçin.

Pod’u dağıtmadan önce şablon ayarlarını düzenleyin:

• Disk alanını 100 GB’a çıkarın

• Ek bir HTTP portu ekleyin: 8910

• HF_TOKEN adlı bir ortam değişkeni ekleyin ve değerini Hugging Face erişim jetonunuz olarak ayarlayın. 

Ek HTTP portu, llama.cpp sunucusuna ve web arayüzüne tarayıcınızdan erişmenizi sağlar. Hugging Face jetonu, indirme isteğini kimlik doğrulamaya yardımcı olur ve özellikle büyük GGUF dosyalarında model indirme hızını artırabilir.

Şablonu güncelledikten sonra pod’u dağıtın. Çalışmaya başladıktan sonra RunPod’un size JupyterLab erişimi vermesini bekleyin. JupyterLab’i açın ve yeni bir terminal başlatın.

Terminal içinde gerekli sistem paketlerini kurun:

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

2. MTP Dalını Klonlayın ve Ona Geçin

Sonraki adımda, llama.cpp’i kurup derleyeceğimiz çalışma alanı dizinine geçin:

cd /workspace

llama.cpp deposunu klonlayın:

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

MTP değişiklikleri hâlâ özel bir llama.cpp çekme isteği üzerinden test ediliyor; bu yüzden, standart ana derlemenin parçası olmadan önce en son MTP uygulamasını kullanmak için bu dalı yerelimize alıp ona geçeceğiz.

MTP dalını yerelde alın:

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

Bu işlem, yerel llama.cpp derlemenizi kılavuzun geri kalanında kullanacağımız MTP etkinleştirilmiş sürüme geçirir.

3. llama.cpp’i CUDA Desteğiyle Derleyin

Artık MTP etkin daldasınız; llama.cpp’i CUDA desteğiyle derleyin. Bu, modelin çıkarımı CPU yerine RTX 3090 GPU üzerinde çalıştırmasını sağlar.

CMake yapı yapılandırmasını çalıştırın:

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

Ardından bu kılavuz için gereken iki hedefi derleyin:

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

Bu derleme şunları üretir:

• Hızlı komut satırı testleri için llama-cli

• Tarayıcı erişimli, OpenAI uyumlu bir sunucu başlatmak için llama-server

Derleme tamamlandığında, llama-server ikili dosyasını ana llama.cpp dizinine kopyalayın:

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

Bu, sonraki adımlarda sunucuyu proje kökünden çalıştırmayı kolaylaştırır.

4. Qwen3.6-27B-MTP Modelini İndirin

Şimdi testlerde kullanacağımız Qwen3.6 27B MTP GGUF modelini indirin. Önce modeli MTP olmadan, ardından MTP etkinleştirilmiş şekilde çalıştırıp hız farkını karşılaştıracağız.

Önce Hugging Face indirme araçlarını kurun:

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

Ardından daha hızlı Hugging Face indirmelerini etkinleştirin:

export HF_HUB_ENABLE_HF_TRANSFER=1

Bu, özellikle GGUF dosyalarıyla çalışırken büyük model indirmelerini hızlandırmaya yardımcı olur.

Şimdi model için ayrılmış bir dizin oluşturun:

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

Qwen3.6 27B MTP GGUF modelini indirin:

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

LLM’lerin ince ayarıyla ilgileniyorsanız, Qwen3.6’yı tıbbi bir S&C veri kümesi üzerinde ince ayarlama konulu eğitimime göz atın.

5. Qwen3.6-27B’yi MTP Etkin Değilken Çalıştırın

Şimdi kılavuzun ana kısmındayız: MTP’yi etkinleştirmeden önce ve sonra model hızını test etmek.

Önce modeli MTP olmadan çalıştıracağız. Bu bize daha sonra hız farkını karşılaştırmak için temiz bir temel sağlar. Aynı modeli, aynı GPU’yu, aynı bağlam boyutunu ve aynı sunucu ayarlarını kullanıyoruz. Bir sonraki adımda yapılacak tek büyük değişiklik MTP’nin etkinleştirilmesi olacak.

llama.cpp dizinine geri dönün:

cd /workspace/llama.cpp

Sunucuyu MTP olmadan başlatın:

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

Bu, 8910 numaralı portta OpenAI uyumlu bir llama.cpp sunucusu başlatır.

Sunucu, model ağırlıklarını GPU belleğine yüklemesi gerektiğinden modelin yüklenmesi biraz zaman alabilir. Her şey hazır olduğunda terminal, sunucunun 8910 portunda kullanılabilir olduğunu gösterecektir.

RunPod şablonunu ayarlarken bu portu dışa açtığımız için başka bir şey yapılandırmanıza gerek yok. RunPod kontrol panelinize geri dönün ve 8910 portuyla ilişkili bağlantıya tıklayın. Bu, tarayıcınızda yerel model zaten yüklenmiş olarak llama.cpp web arayüzünü açacaktır.

Buradan, bir sohbet arayüzünü kullanmaya benzer şekilde doğrudan tarayıcıda istemleri test etmeye başlayabilirsiniz.

Benim temel testimde, model MTP olmadan yaklaşık saniyede 38,86 token üretti. Daha karmaşık bir istemde bile hız benzer aralıkta kaldı. 

Bir RTX 3090 üzerinde çalışan 27B’lik bir model için, GPU’nun daha yavaş ve daha yeni veri merkezi kartlarına kıyasla sınırlı belleğe sahip olduğu düşünüldüğünde, bu zaten kullanılabilir bir sonuçtur. 

6. Qwen3.6-27B’yi MTP Etkinken Çalıştırın

Şimdi aynı modeli MTP etkinleştirilmiş şekilde tekrar çalıştıracağız.

Sunucunun çalıştığı terminale geri dönün ve şununla durdurun:

CTRL + C

Burada önemli olan, modeli, GPU’yu, kuantizasyonu veya çalışma zamanı ayarlarının çoğunu değiştirmiyor olmamızdır. Yalnızca iki MTP ile ilgili bayrak ekliyoruz:

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

İlk bayrak, llama.cpp’e MTP tarzı spekülatif çözümleme kullanmasını söyler. İkinci bayrak, taslak token sayısının üst sınırını 3 olarak ayarlar. Bu, modelin doğrulamadan önce en fazla üç gelecekteki tokenı taslak olarak üretmeyi deneyebileceği anlamına gelir.

Şimdi sunucuyu MTP etkinleştirilmiş olarak yeniden başlatın:

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

Sunucu hazır olduğunda, tarayıcı sayfasını yenileyin. Sayfa otomatik olarak yeniden bağlanmazsa kapatın ve RunPod kontrol panelinizden 8910 portu bağlantısını tekrar açın. 

Şimdi aynı tür istemlerle modeli tekrar test edin.

MTP etkinleştirildiğinde hız gözle görülür şekilde arttı. Basit bir selamlama isteminde model yaklaşık 65–67 token/sn seviyesine ulaştı. Temel hız olan yaklaşık 38,86 token/sn ile karşılaştırıldığında bu, yalnızca iki komut satırı bayrağı ekleyerek elde edilen büyük bir iyileşme.

Modelden Python’da basit bir oyun yazmasını istemek gibi daha karmaşık bir istemde, hız biraz daha düşük olsa da MTP’siz temelin çok üzerindeydi. O testte model yaklaşık 56–61 token/sn üretti; bu da bir RTX 3090 üzerinde 27B bir model için güçlü bir sonuç. 

Genel olarak, MTP’nin etkinleştirilmesi, RunPod RTX 3090 kurulumunda Qwen3.6 27B’yi yaklaşık 38 token/sn’den 65 token/sn’ye çıkardı. Bu, 1,71 kat hız artışı ya da yaklaşık %71 daha yüksek verim sağlar; donanımı değiştirmeden veya daha küçük bir modele geçmeden. 

7. Öneri: TurboQuant ile Daha Fazla Hız Optimizasyonu

Bu kılavuzdaki kıyaslama, TurboQuant, özel yamalar veya diğer çalışma zamanı optimizasyonları eklenmeden, orijinal llama.cpp MTP kurulumunu kullanır. Bu, testi basit, tekrarlanabilir ve yalnızca MTP’yi etkinleştirmenin getirdiği hız kazancına odaklı tutar.

Performansı daha da artırmak için keşfedilecek bir sonraki optimizasyon MTP ve TurboQuant’ın birlikte kullanılmasıdır. MTP, modelin birden çok tahmin edilen tokenı kabul etmesine olanak tanıyarak verimi artırırken, TurboQuant çıkarım sırasında KV-cache bellek baskısını azaltmaya yardımcı olur. 

Bu, daha büyük modeller, uzun bağlamlı istemler ve bellek bant genişliği ile VRAM’in sınırlayıcı faktör olabildiği RTX 3090 gibi GPU’lar için özellikle faydalı olabilir.

Bu nedenle r/LocalLLaMA topluluğundaki bazı sonuçlar bu kılavuzdan daha yüksek token/sn bildirir. Bu kurulumlar sıklıkla MTP’yi TurboQuant, yamalı derlemeler, farklı KV-cache ayarları veya daha hızlı GPU’larla birleştirir. Bu eğitim temiz ve yalnızca MTP’ye odaklı bir kıyaslamayı hedeflediğinden, TurboQuant mevcut kurulumun parçası değil, önerilen bir sonraki deney olarak değerlendirilmelidir.

Son Düşünceler 

Son zamanlarda LocalLLaMA Reddit topluluğundaki paylaşımları takip ediyorum ve yerel LLM çıkarımının ne kadar ilerlediğini görmek etkileyici. İnsanlar artık Qwen3.6 27B gibi modelleri, VRAM’i sınırlı eski GPU’larda bile yerel kodlama ajanları olarak çalıştırıyor. Benzer kurulumları Mac sistemlerde çalıştıranlar da var ve sonuçlar gerçekten etkileyici.

MTP’yi kendim test ettikten sonra heyecanın nedenini anlıyorum. Aynı model ve aynı RTX 3090 kurulumu ile Çoklu Token Tahmini’ni etkinleştirmek, üretim hızını yaklaşık 38 token/sn’den 65 token/sn’ye çıkardı. Bu, GPU’yu yükseltmeden veya daha küçük bir modele geçmeden neredeyse 2 kat hız artışı demek.

Bu kılavuz, llama.cpp kullanarak basit ve tekrarlanabilir bir MTP kurulumuna odaklandı; ancak bu sadece bir başlangıç gibi duruyor. Bir sonraki adım, daha iyi GGUF kuantizasyonu, MTP, TurboQuant ve daha ayarlı çalışma zamanı ayarlarıyla deney yaparak yerel çıkarım hızının ne kadar ileri taşınabileceğini görmek.

Beni en çok heyecanlandıran şey, bunun yerel kodlama ajanları için ne anlama geldiği. Güçlü modelleri kendi donanımınızda çalıştırabilir, sorgu başına maliyeti azaltabilir, kodunuzu özel tutabilir ve tamamen internet tabanlı API’lere bağımlı olmadan bir yapay zekâ kodlama asistanı kullanabilirsiniz. Yerel LLM’ler kısa süre öncesine kıyasla daha hızlı, daha pratik ve çok daha kullanışlı hale geliyor.