# 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](./hardware). Periksa teknik mana yang didukung oleh perangkat keras Anda sebelum menerapkan optimasi di bawah ini.

> [!AgentPrompt]
> Bantu pengguna memilih optimasi untuk beban kerja inferensi Transformers mereka. Pertama, identifikasi apakah masalah muncul pada memori atau kecepatan saat memuat model, memproses input panjang, menghasilkan urutan yang lebih panjang, atau melayani permintaan konkuren. Gunakan panduan yang sesuai di bawah ini dan periksa dukungan untuk model serta perangkat keras pengguna sebelum merekomendasikan perubahan.
>
> 1. Minta model dan revisi, versi pustaka, GPU dan VRAM yang tersedia, RAM CPU, panjang input, batas generasi, ukuran batch, dan jumlah permintaan konkuren. Ajukan pertanyaan lanjutan jika detail yang hilang dapat mengubah rekomendasi, dan nyatakan asumsi Anda. 2. Gunakan titik di mana masalah terjadi untuk memilih apa yang harus diselidiki. Periksa bobot model dan pengaturan pemuatan untuk memori saat pemuatan, cache KV seiring pertumbuhan urutan yang dihasilkan, alokasi perhatian untuk input panjang, serta status per-permintaan dan penjadwalan untuk permintaan konkuren. Perlakukan kuantisasi bobot dan kuantisasi cache-KV sebagai pengaturan yang terpisah. 3. Rekomendasikan satu perubahan pada satu waktu. Periksa kompatibilitas model dan perangkat keras, lalu ukur memori GPU puncak, latensi atau throughput, dan kualitas output pada beban kerja representatif yang sama. Jelaskan setiap pengurangan panjang input, panjang generasi, atau konkurensi sebagai kompromi beban kerja. 4. Laporkan konfigurasi yang diusulkan, dokumentasi yang mendukungnya, kompromi yang diharapkan, pertanyaan kompatibilitas yang belum terpecahkan, dan prosedur validasi. Pisahkan pengukuran dari estimasi. Jika Anda tidak dapat menjalankan beban kerja, nyatakan bahwa kecocokan dan kinerja tetap belum diverifikasi.

> [!NOTE]
> Memori dan kecepatan sangat berkaitan 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 penggunaan. Pilih optimasi yang sesuai berdasarkan kasus penggunaan dan perangkat keras Anda.

Gunakan tabel di bawah ini untuk memilih teknik optimasi.

| Teknik | Kecepatan | Memori |
|---|:---:|:---:|
| [Kompilasi](#compilation) | ✅ | |
| [Backend perhatian](#attention-backends) | ✅ | ✅ |
| [Kernels](#kernels) | ✅ | ✅ |
| [Kuantisasi](#quantization) | ✅ | ✅ |
| [Penyimpanan sementara](#caching) | ✅ | ✅ |
| [Paralelisme](#parallelism) | ✅ | |
| [Continuous batching](#continuous-batching) | ✅ | |

Panduan ini memberikan Anda langkah awal cepat untuk optimasi Transformers.

## Kompilasi

[torch.compile](./perf_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](./kv_cache#fixed-size-cache) ke [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate) untuk memicu `torch.compile` secara otomatis.

```py
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]
```

> [!WARNING]
> Hindari memanggil `torch.compile(model)` di luar [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate) untuk mencegah model dikompilasi ulang setiap langkah.

## Backend perhatian

[Backend attention](./attention_interface) 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()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat backend perhatian yang dioptimalkan.

```py
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](https://huggingface.co/docs/kernels/en/index) memuat kernel komputasi yang dioptimalkan dari [Hub](https://huggingface.co/kernels-community) dengan cara yang fleksibel dan aman secara versi.

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

```py
import torch
from transformers import AutoModelForCausalLM

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

## Kuantisasi

[Quantization](./quantization/overview) 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()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.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](./quantization/bitsandbytes).

```py
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](./kv_cache) mempercepat generasi dengan memanfaatkan ulang kunci dan nilai sebelumnya alih-alih menghitung ulang untuk setiap token. Untuk mengimbangi dan mengurangi biaya memori dari penyimpanan kunci dan nilai sebelumnya, Transformers mendukung offloading cache ke CPU. Hanya lapisan saat ini yang tetap berada di GPU.

Gunakan argumen `cache_implementation` di [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate) untuk mengatur strategi cache.

```py
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](./perf_infer_gpu_multi) 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](./perf_infer_gpu_multi) membagi lapisan model di antara beberapa perangkat. Atur jumlah perangkat dengan `DistributedConfig(tp_size=N)` dan teruskan ke [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk mengaktifkannya.

```py
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](./continuous_batching) memaksimalkan throughput dengan menjaga GPU tetap sibuk melalui penjadwalan dinamis dan chunked prefill. Aplikasi [Serving](./serve-cli/serving) menggunakannya untuk memproses beberapa permintaan yang masuk secara bersamaan.

Gunakan [generate_batch()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.ContinuousMixin.generate_batch) untuk mengaktifkan continuous batching.

```py
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}")
```

