Dekoding terbimbing

Decoding terbantu mempercepat generasi teks dengan memungkinkan helper mengusulkan token kandidat sebelum model utama mengonfirmasinya. Model utama memverifikasi token kandidat dalam satu forward pass. Helper cepat dan murah, serta dapat menggantikan puluhan forward pass yang lebih mahal oleh model utama.

Panduan ini membahas metode decoding terbantu dalam Transformers.

Dekoding spekulatif

Speculative decoding menggunakan model asisten yang lebih kecil untuk menyusun kandidat token. Model utama memeriksa token-token ini dalam satu kali proses. Token yang tervalidasi masuk ke output akhir, sedangkan token yang ditolak memicu sampling standar. Proses generasi menjadi lebih cepat karena model utama menjalankan lebih sedikit forward pass yang mahal.

Metode ini bekerja paling baik ketika model asisten jauh lebih kecil daripada model utama dan menggunakan tokenizer yang sama. Dekoding spekulatif mendukung pencarian serakah dan pengambilan sampel, tetapi tidak mendukung input yang di-batch.

Lewatkan assistant_model ke generate(). Atur do_sample=True untuk melakukan resampling jika validasi token gagal.

greedy search

sampling

Prompt lookup decoding

Prompt lookup decoding tidak memerlukan model asisten. Metode ini menemukan n-gram yang tumpang tindih dalam prompt untuk mengusulkan token kandidat. Jika tidak ada kecocokan, sistem kembali ke decoding autoregresif normal. Pendekatan ini cocok untuk tugas yang berbasis input seperti ringkasan dan terjemahan karena token kandidat sering kali mencerminkan pola lokal dalam teks sumber.

Lewatkan prompt_lookup_num_tokens ke generate(). Ini mengatur berapa banyak token yang dicoba untuk disalin oleh algoritma dari bagian awal prompt ketika mendeteksi pola berulang.

greedy decoding

sampling

Self-speculative decoding

Self-speculative decoding menggunakan lapisan-lapisan antara model sebagai asisten untuk mengusulkan token kandidat. Jika usulan tersebut cocok, model keluar lebih awal dan lapisan-lapisan yang tersisa memverifikasi atau memperbaiki token tersebut.

Karena semuanya adalah satu model, bobot dan cache dibagikan, yang meningkatkan kecepatan tanpa overhead memori tambahan. Teknik ini hanya berfungsi untuk model yang dilatih untuk mendukung logit keluaran awal dari lapisan perantara.

Lewatkan assistant_early_exit ke generate() untuk mengatur lapisan keluar.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("facebook/layerskip-llama3.2-1B")
model = AutoModelForCausalLM.from_pretrained("facebook/layerskip-llama3.2-1B", dtype="auto")
inputs = tokenizer("Hugging Face is an open-source company", return_tensors="pt")

outputs = model.generate(**inputs, assistant_early_exit=4, do_sample=False, max_new_tokens=20)
tokenizer.batch_decode(outputs, skip_special_tokens=True)

Lapisan prediksi multi-token (MTP)

Lapisan prediksi multi-token (MTP) menyusun token kandidat dengan lapisan prediksi tambahan yang berasal dari checkpoint model utama itu sendiri. Lapisan MTP menggunakan kembali embeddings dan output head dari model utama. Setiap lapisan MTP menyusun satu token, sehingga jumlah kandidat per langkah sesuai dengan jumlah lapisan MTP pada checkpoint. Model utama memverifikasi draf dalam satu forward pass.

MTP hanya berfungsi dengan checkpoint yang dilatih dengan lapisan MTP, seperti DeepSeek-V3 dan GLM-4.5. Checkpoint ini membawa bobot MTP dan mengatur num_mtp_layers di konfigurasinya, yang tercantum sebagai num_nextn_predict_layers di config.json.

Lewati use_mtp=True ke generate(), yang akan memicu error jika model tidak memiliki lapisan MTP. Seperti speculative decoding, MTP mendukung greedy search dan sampling tetapi tidak mendukung input batched.

Di sini, MTP merujuk pada lapisan prediksi yang disertakan dalam checkpoint target, seperti pada DeepSeek-V3 dan GLM-4.5. Gemma 4 menggunakan checkpoint asisten terpisah untuk decoding MTP. Sampaikan sebagai assistant_model (lihat Drafter prediksi multi-token).

Pipeline text-generation dan generate() keduanya menerima use_mtp=True.

from transformers import pipeline

pipe = pipeline(
    "text-generation",
    model="zai-org/GLM-4.5-Air",
    device_map="auto",
)

outputs = pipe(
    "Hugging Face is an open-source company",
    use_mtp=True,
    do_sample=False,
    max_new_tokens=50,
    add_special_tokens=True,
    return_full_text=True,
)

[output["generated_text"] for output in outputs]

Sebagai alternatif, Anda dapat melakukan inferensi sebagai berikut.

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("zai-org/GLM-4.5-Air")
model = AutoModelForCausalLM.from_pretrained("zai-org/GLM-4.5-Air", device_map="auto")
inputs = tokenizer("Hugging Face is an open-source company", return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, use_mtp=True, do_sample=False, max_new_tokens=50)
tokenizer.batch_decode(outputs, skip_special_tokens=True)

Drafter prediksi multi-token

MTP drafter adalah model asisten ringan yang dimuat dari checkpoint terpisah. Model ini mengusulkan token kandidat untuk diverifikasi oleh model target. Drafter menggunakan input embeddings dari model target dan memperhatikan KV cache-nya. Proses dimulai dari hidden states model target, kemudian mendraft token secara autoregresif. Untuk setiap token berikutnya, drafter memasukkan kembali hidden state yang diproyeksikannya ke dalam drafter. Model target memverifikasi token yang telah didraft dalam satu forward pass, seperti pada speculative decoding.

Berbeda dengan lapisan MTP, yang merupakan bagian dari checkpoint target dan berbagi output head-nya, drafter MTP adalah model asisten yang terpisah. Ia menggunakan input embeddings dan KV cache dari target untuk mengusulkan token.

from transformers import AutoProcessor, AutoModelForCausalLM

processor = AutoProcessor.from_pretrained("google/gemma-4-E4B-it")
target_model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-4-E4B-it",
    dtype="auto",
    device_map="auto",

)

assistant_model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-4-E4B-it-assistant",
    dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Write a short joke about saving RAM."},
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    enable_thinking=False
).to(target_model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = target_model.generate(
    **inputs,
    assistant_model=assistant_model,
    max_new_tokens=256,
)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)

processor.parse_response(response)

Dekoding terbantu universal

Universal assisted decoding (UAD) memungkinkan speculative decoding bahkan ketika model utama dan model asisten memiliki tokenizer yang berbeda. Fitur ini memungkinkan Anda memasangkan model asisten kecil apa pun dengan model utama. Token kandidat di-encode ulang dan algoritma menghitung longest common subsequence agar kelanjutan tetap selaras.

Lewatkan tokenizer, assistant_tokenizer, dan assistant_model ke generate() untuk mengaktifkan UAD.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

assistant_tokenizer = AutoTokenizer.from_pretrained("double7/vicuna-68m")
tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b")
model = AutoModelForCausalLM.from_pretrained("google/gemma-2-9b", dtype="auto")
assistant_model = AutoModelForCausalLM.from_pretrained("double7/vicuna-68m", dtype="auto")
inputs = tokenizer("Hugging Face is an open-source company", return_tensors="pt")

outputs = model.generate(**inputs, assistant_model=assistant_model, tokenizer=tokenizer, assistant_tokenizer=assistant_tokenizer)
tokenizer.batch_decode(outputs, skip_special_tokens=True)
'Hugging Face is an open-source company that is dedicated to creating a better world through technology.'

Verifikasi ensemble statis

Standard speculative decoding adalah lossless — menjamin bahwa distribusi output persis sama dengan model target. Static ensemble verification melonggarkan hal ini dengan memverifikasi terhadap campuran distribusi target dan draft, sehingga meningkatkan tingkat penerimaan (inferensi lebih cepat) dengan mengorbankan distribusi output menjadi campuran, bukan distribusi target yang persis. Nilai awal yang direkomendasikan adalah 0.7.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM-1.7B")
model = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM-1.7B", dtype="auto")
assistant_model = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM-135M", dtype="auto")
inputs = tokenizer("Hugging Face is an open-source company", return_tensors="pt")

outputs = model.generate(**inputs, assistant_model=assistant_model, assistant_ensemble_weight=0.7, do_sample=True)
tokenizer.batch_decode(outputs, skip_special_tokens=True)

Hal ini memerlukan kandidat logits dari model asisten dan tidak didukung dengan prompt lookup decoding.

Sumber daya

Baca artikel blog Assisted Generation: a new direction toward low-latency text generation untuk konteks lebih lanjut tentang latensi generasi teks dan assisted generation.

Update on GitHub