Genel Bakış

Transformers, modellerin hızlı, uygun fiyatlı ve erişilebilir olmasını sağlamak için birden çok çıkarım optimizasyon tekniği sunar. Seçenekler arasında, azaltılmış bellek trafiği için alternatif dikkat mekanizmaları, daha hızlı çalıştırma için kod derlemesi ve verimlilik için optimize edilmiş çekirdekler yer alır. Maksimum performans için bu teknikleri bir arada kullanın.

Cihaz kurulumu ve donanıma özgü yapılandırma için Donanım kılavuzlarına bakın. Aşağıdaki optimizasyonları uygulamadan önce, donanımınızda hangi tekniklerin desteklendiğini kontrol edin.

Bellek ve hız birbirine yakından bağlıdır ancak aynı şey değildir. Bellek kullanımınızı küçültmek, etrafında taşınacak daha az veri olduğu için modeli “daha hızlı” hale getirir. Saf hız optimizasyonları her zaman bellek kullanımını azaltmaz, bazen kullanımı artırabilir. Uygun optimizasyonu kullanım senaryonuza ve donanımınıza göre seçin.

Bir optimizasyon tekniği seçmek için aşağıdaki tabloyu kullanın.

Bu kılavuz, Transformers optimizasyonlarına hızlı bir başlangıç yapmanızı sağlar.

Derleme

torch.compile, Python iş yükünü azaltır, işlemleri birleştirir ve şekillerinize ve donanımınıza göre ayarlanmış çekirdekler oluşturur. İlk çalıştırma sistemi ısıtır ve sonraki çalıştırmalar daha hızlı derlenmiş yolu kullanır.

torch.compile'in otomatik olarak tetiklenmesini sağlamak için generate() fonksiyonuna sabit boyutlu bir önbellek iletin.

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]

Modelin her adımda yeniden derlenmesini önlemek için torch.compile(model) çağrısını generate() dışında yapmaktan kaçının.

Dikkat arka uçları

Alternatif dikkat arka uçları bellek trafiğini azaltır. Örneğin, FlashAttention, dikkat hesaplamalarını karolar (tile) ve büyük ara tensörlerden kaçınarak bellek ayak izini küçültür.

Optimize edilmiş bir dikkat arka ucunu yüklemek için from_pretrained() içinde attn_implementation değerini ayarlayın.

from transformers import AutoModelForCausalLM

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

Çekirdekler

Kernels, işlemleri birleştirerek verimliliği artırır ve bellek kullanımını azaltır. Kernels kütüphanesi, optimize edilmiş hesaplama çekirdeklerini Hub üzerinden esnek ve sürüm güvenli bir şekilde yükler.

Aşağıdaki örnek, paketi kurmadan optimize edilmiş bir FlashAttention-2 çekirdeği yükler.

import torch
from transformers import AutoModelForCausalLM

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

Kantizasyon

Kantizasyon, her parametrenin boyutunu küçülterek bellek kullanımını azaltır ve daha fazla işlem yapılabilmesi sayesinde hızı artırır.

from_pretrained() içindeki quantization_config argümanına bir kuantizasyon yapılandırması geçirin. Her kuantizasyon arka ucunun, farklı argümanlara sahip farklı bir yapılandırması vardır. Aşağıdaki örnek, bir modeli 4-bite kuantize eder ve bitsandbytes arka ucunu kullanarak hesaplama veri türünü yapılandırır.

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
)

Önbelleğe Alma

Caching, her token için yeniden hesaplamak yerine geçmiş anahtar ve değerleri yeniden kullanarak üretimi hızlandırır. Geçmiş anahtar ve değerleri saklamanın bellek maliyetini dengelemek ve azaltmak için Transformers, önbelleği CPU'ya taşımayı destekler. GPU'da yalnızca geçerli katman kalır.

generate() içinde cache_implementation argümanını kullanarak bir önbellek stratejisi belirleyin.

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")

Paralellik

Parallelism, tek bir cihazda çalıştırılması çok büyük olan modellerin hızlı çalışabilmesi için modeli cihazlar arasında dağıtır. Bu yaklaşım, parçalama (sharding) maliyeti ve sonuçları senkronize etmek için yapılan iletişim nedeniyle daha fazla bellek kullanır.

Tensor paralelliği, bir model katmanını cihazlar arasında böler. Cihaz sayısını DistributedConfig(tp_size=N) ile belirleyin ve etkinleştirmek için from_pretrained() fonksiyonuna iletin.

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)

Sürekli toplu işleme

Continuous batching, dinamik zamanlama ve parçalı prefill ile GPU'yu meşgul tutarak verimliliği en üst düzeye çıkarır. Serving uygulamaları, birden çok gelen isteği eşzamanlı olarak işlemek için bunu kullanır.

Sürekli toplu işleme (continuous batching) etkinleştirmek için generate_batch() kullanın.

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