Ikhtisar

Transformers menyediakan berbagai teknik optimasi inferensi untuk membuat model cepat, terjangkau, dan mudah diakses. Opsi yang tersedia mencakup mekanisme perhatian alternatif untuk mengurangi lalu lintas memori, kompilasi kode untuk eksekusi yang lebih cepat, dan kernel yang dioptimalkan untuk throughput. Kombinasikan teknik-teknik ini untuk performa maksimal.

Untuk pengaturan perangkat dan konfigurasi yang spesifik pada perangkat keras, lihat panduan Perangkat Keras. Periksa teknik mana yang didukung oleh perangkat keras Anda sebelum menerapkan optimasi di bawah ini.

Memori dan kecepatan saling berkaitan erat, tetapi tidak sama. Memperkecil jejak memori membuat model menjadi “lebih cepat” karena ada lebih sedikit data yang perlu dipindahkan. Optimasi kecepatan murni tidak selalu mengurangi memori, dan terkadang justru meningkatkan penggunaannya. Pilih optimasi yang sesuai berdasarkan kasus penggunaan dan perangkat keras Anda.

Gunakan tabel di bawah ini untuk memilih teknik optimasi.

Panduan ini memberikan Anda langkah awal cepat untuk optimasi Transformers.

Kompilasi

torch.compile mengurangi overhead Python, menggabungkan operasi, dan membuat kernel yang dioptimalkan untuk bentuk dan perangkat keras Anda. Eksekusi pertama berfungsi sebagai pemanasan, dan eksekusi berikutnya menggunakan jalur terkompilasi yang lebih cepat.

Lewatkan cache berukuran tetap ke generate() untuk memicu torch.compile secara otomatis.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.float16, device_map="auto")
input = tokenizer("The French Bread Law states", return_tensors="pt").to(model.device)

output = model.generate(**input, do_sample=False, max_new_tokens=20, cache_implementation="static")
tokenizer.batch_decode(output, skip_special_tokens=True)[0]

Hindari memanggil torch.compile(model) di luar generate() untuk mencegah model dikompilasi ulang setiap langkah.

Backend perhatian

Backend attention alternatif mengurangi lalu lintas memori. Misalnya, FlashAttention meng-tiling komputasi attention dan menghindari tensor perantara berukuran besar untuk mengurangi jejak memori.

Setel attn_implementation di from_pretrained() untuk memuat backend perhatian yang dioptimalkan.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", attn_implementation="flash_attention_2")

Kernels

Kernels menggabungkan operasi untuk meningkatkan throughput dan mengurangi penggunaan memori. Perpustakaan Kernels memuat kernel komputasi yang dioptimalkan dari Hub dengan cara yang fleksibel dan aman secara versi.

Contoh di bawah ini memuat kernel FlashAttention-2 yang dioptimalkan tanpa menginstal paketnya.

import torch
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", attn_implementation="kernels-community/flash-attn2"
)

Kuantisasi

Quantization memperkecil ukuran setiap parameter, sehingga mengurangi jejak memori dan meningkatkan kecepatan karena Anda dapat melakukan lebih banyak operasi.

Lewatkan konfigurasi kuantisasi ke argumen quantization_config di from_pretrained(). Setiap backend kuantisasi memiliki konfigurasi yang berbeda dengan argumen yang berbeda. Contoh di bawah ini mengkuantisasi model ke 4-bit dan mengatur dtype komputasi dengan backend bitsandbytes.

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16)

model = AutoModelForCausalLM.from_pretrained(
    "allenai/Olmo-3-7B-Think", quantization_config=bnb_config
)

Penyimpanan sementara

Caching mempercepat proses generation dengan memanfaatkan ulang past keys dan values alih-alih menghitung ulang untuk setiap token. Untuk mengimbangi dan mengurangi biaya memori akibat penyimpanan past keys dan values, Transformers mendukung offloading cache ke CPU. Hanya layer saat ini yang tetap berada di GPU.

Gunakan argumen cache_implementation di generate() untuk mengatur strategi cache.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", attn_implementation="kernels-community/flash-attn2"
)
inputs = tokenizer("The Le Décret Pain states that a baguette must,", return_tensors="pt")
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=50, cache_implementation="offloaded")

Paralelisme

Parallelism mendistribusikan model ke beberapa perangkat sehingga model yang terlalu besar untuk satu perangkat dapat berjalan cepat. Pendekatan ini menggunakan lebih banyak memori karena overhead sharding dan komunikasi untuk menyinkronkan hasil.

Tensor parallelism membagi lapisan model di antara beberapa perangkat. Atur jumlah perangkat dengan DistributedConfig(tp_size=N) dan teruskan ke from_pretrained() untuk mengaktifkannya.

from transformers import AutoModelForCausalLM, DistributedConfig

distributed_config = DistributedConfig(tp_size=4)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    distributed_config=distributed_config,
)
print(model._tp_plan)

Batching berkelanjutan

Continuous batching memaksimalkan throughput dengan menjaga GPU tetap sibuk melalui penjadwalan dinamis dan chunked prefill. Aplikasi Serving menggunakannya untuk memproses beberapa permintaan yang masuk secara bersamaan.

Gunakan generate_batch() untuk mengaktifkan continuous batching.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import ContinuousBatchingConfig, GenerationConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    attn_implementation="sdpa",
    device_map="auto",
    torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

prompts = [
    "The Le Décret Pain states that a baguette must",
    "Explain gravity in one sentence.",
    "Name the capital of France.",
]
inputs = [tokenizer.encode(p) for p in prompts]

generation_config = GenerationConfig(
    max_new_tokens=32,
    eos_token_id=tokenizer.eos_token_id,
    pad_token_id=tokenizer.pad_token_id,
    do_sample=False,
)
continuous_batching_config = ContinuousBatchingConfig(max_batch_tokens=512)

outputs = model.generate_batch(
    inputs=inputs,
    generation_config=generation_config,
    continuous_batching_config=continuous_batching_config,
)

for request_id, output in outputs.items():
    text = tokenizer.decode(output.generated_tokens, skip_special_tokens=True)
    print(f"[{request_id}] {text}")