Resumen

Transformers ofrece varias técnicas de optimización de inferencia para hacer que los modelos sean rápidos, asequibles y accesibles. Las opciones incluyen mecanismos de atención alternativos para reducir el tráfico de memoria, compilación de código para una ejecución más rápida y kernels optimizados para el rendimiento. Combine estas técnicas para obtener el máximo rendimiento.

Para la configuración del dispositivo y la configuración específica del hardware, consulte las guías de Hardware. Verifique qué técnicas se admiten en su hardware antes de aplicar las optimizaciones siguientes.

La memoria y la velocidad están estrechamente relacionadas, pero no son lo mismo. Reducir la huella de memoria hace que un modelo sea “más rápido” porque hay menos datos que mover. Las optimizaciones puras de velocidad no siempre reducen la memoria y a veces aumentan su uso. Elija la optimización adecuada según su caso de uso y su hardware.

Use la tabla siguiente para elegir una técnica de optimización.

Esta guía te ofrece una introducción rápida a las optimizaciones de Transformers.

Compilación

torch.compile reduce la sobrecarga de Python, fusiona operaciones y crea kernels ajustados a tus formas y hardware. La primera ejecución lo calienta y las ejecuciones posteriores utilizan la ruta compilada más rápida.

Pase una cache de tamaño fijo a generate() para activar torch.compile automáticamente.

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]

Evite llamar a torch.compile(model) fuera de generate() para evitar que el modelo se recompile en cada paso.

Backends de atención

Los backends de atención alternativos reducen el tráfico de memoria. Por ejemplo, FlashAttention divide los cálculos de atención en bloques y evita tensores intermedios grandes para reducir la huella de memoria.

Establezca attn_implementation en from_pretrained() para cargar un backend de atención optimizado.

from transformers import AutoModelForCausalLM

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

Kernels

Los kernels fusionan operaciones para aumentar el rendimiento y reducir el uso de memoria. La biblioteca Kernels carga kernels de cálculo optimizados desde el Hub de forma flexible y segura en cuanto a versiones.

El siguiente ejemplo carga un kernel optimizado de FlashAttention-2 sin instalar el paquete.

import torch
from transformers import AutoModelForCausalLM

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

Cuantización

Cuantización reduce el tamaño de cada parámetro, lo que disminuye la huella de memoria y aumenta la velocidad, ya que permite realizar más operaciones.

Pase una configuración de cuantización al argumento quantization_config en from_pretrained(). Cada backend de cuantización tiene una configuración diferente con argumentos distintos. El siguiente ejemplo cuantiza un modelo a 4 bits y configura el tipo de dato de la computación con el 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
)

Caché

Caching acelera la generación reutilizando las claves y valores anteriores en lugar de recalcularlos para cada token. Para compensar y reducir el coste de memoria de almacenar las claves y valores anteriores, Transformers admite descargar la caché a la CPU. Solo la capa actual permanece en la GPU.

Use el argumento cache_implementation en generate() para establecer una estrategia de caché.

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

Paralelismo

Parallelism distribuye un modelo entre varios dispositivos para que los modelos demasiado grandes para un solo dispositivo se ejecuten con rapidez. Este enfoque consume más memoria debido a la sobrecarga del particionamiento y a la comunicación necesaria para sincronizar los resultados.

El paralelismo de tensores divide una capa del modelo entre varios dispositivos. Establece el número de dispositivos con DistributedConfig(tp_size=N) y pásalo a from_pretrained() para activarlo.

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)

Loteo continuo

Continuous batching maximiza el rendimiento manteniendo la GPU ocupada mediante programación dinámica y prefill por fragmentos. Las aplicaciones de Serving lo utilizan para procesar múltiples solicitudes entrantes de forma concurrente.

Use generate_batch() para habilitar el lotes continuo.

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