Tổng quan

Transformers cung cấp nhiều kỹ thuật tối ưu hóa suy luận để giúp các mô hình nhanh, tiết kiệm và dễ tiếp cận hơn. Các tùy chọn bao gồm các cơ chế chú ý thay thế để giảm lưu lượng bộ nhớ, biên dịch mã để thực thi nhanh hơn và các kernel được tối ưu hóa để tăng thông lượng. Kết hợp các kỹ thuật này để đạt hiệu suất tối đa.

Để cài đặt thiết bị và cấu hình cụ thể cho phần cứng, hãy xem các hướng dẫn Phần cứng. Kiểm tra các kỹ thuật nào được hỗ trợ trên phần cứng của bạn trước khi áp dụng các tối ưu hóa bên dưới.

Bộ nhớ và tốc độ có mối liên hệ chặt chẽ nhưng không giống nhau. Việc thu nhỏ dấu chân bộ nhớ giúp mô hình “nhanh hơn” vì có ít dữ liệu hơn cần di chuyển. Các tối ưu hóa thuần túy về tốc độ không phải lúc nào cũng giảm bộ nhớ và đôi khi còn làm tăng mức sử dụng. Hãy chọn phương pháp tối ưu hóa phù hợp dựa trên trường hợp sử dụng và phần cứng của bạn.

Sử dụng bảng dưới đây để chọn một kỹ thuật tối ưu hóa.

Hướng dẫn này giúp bạn bắt đầu nhanh với các tối ưu hóa của Transformers.

Biên dịch

torch.compile giảm overhead của Python, hợp nhất các thao tác và tạo ra các kernel được tối ưu cho hình dạng và phần cứng của bạn. Chạy lần đầu tiên sẽ làm nóng hệ thống và các lần chạy sau đó sẽ sử dụng đường dẫn đã biên dịch nhanh hơn.

Truyền một cache có kích thước cố định vào generate() để kích hoạt torch.compile một cách tự động.

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]

Tránh gọi torch.compile(model) bên ngoài generate() để ngăn mô hình biên dịch lại ở mỗi bước.

Các backend chú ý

Các backend attention thay thế giúp giảm lưu lượng bộ nhớ. Ví dụ, FlashAttention chia nhỏ các phép tính attention thành các khối (tiles) và tránh tạo ra các tensor trung gian lớn nhằm giảm dung lượng bộ nhớ sử dụng.

Đặt attn_implementation trong from_pretrained() để tải một backend attention được tối ưu hóa.

from transformers import AutoModelForCausalLM

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

Kernels

Kernels hợp nhất các thao tác để tăng thông lượng và giảm mức sử dụng bộ nhớ. Thư viện Kernels nạp các kernel tính toán đã được tối ưu từ Hub theo cách linh hoạt và an toàn về phiên bản.

Ví dụ dưới đây tải một kernel FlashAttention-2 đã được tối ưu hóa mà không cần cài đặt gói.

import torch
from transformers import AutoModelForCausalLM

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

Lượng tử hóa

Lượng tử hóa thu nhỏ kích thước của mọi tham số, từ đó giảm lượng bộ nhớ sử dụng và tăng tốc độ vì bạn có thể thực hiện nhiều phép toán hơn.

Truyền cấu hình lượng tử hóa vào tham số quantization_config trong from_pretrained(). Mỗi backend lượng tử hóa có một cấu hình khác nhau với các tham số khác nhau. Ví dụ bên dưới lượng tử hóa một mô hình xuống 4-bit và cấu hình kiểu dữ liệu tính toán bằng 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
)

Bộ nhớ đệm

Caching tăng tốc độ sinh bằng cách tái sử dụng các key và value trong quá khứ thay vì tính lại chúng cho từng token. Để bù đắp và giảm chi phí bộ nhớ khi lưu trữ các key và value trong quá khứ, Transformers hỗ trợ chuyển cache sang CPU. Chỉ có lớp hiện tại được giữ trên GPU.

Sử dụng đối số cache_implementation trong generate() để thiết lập chiến lược 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")

Song song

Parallelism phân phối một mô hình trên nhiều thiết bị để các mô hình quá lớn so với một thiết bị duy nhất vẫn chạy nhanh. Cách tiếp cận này sử dụng nhiều bộ nhớ hơn do chi phí phân mảnh (sharding) và giao tiếp để đồng bộ hóa kết quả.

Song song tensor chia một lớp mô hình trên các thiết bị. Đặt số lượng thiết bị bằng DistributedConfig(tp_size=N) và truyền nó vào from_pretrained() để bật tính năng này.

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)

Lô liên tục

Continuous batching tối đa hóa thông lượng bằng cách giữ cho GPU hoạt động liên tục nhờ lịch động và chunked prefill. Các ứng dụng Serving sử dụng nó để xử lý đồng thời nhiều yêu cầu đến.

Sử dụng generate_batch() để bật 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}")