# Visão geral

O Transformers oferece diversas técnicas de otimização de inferência para tornar os modelos rápidos, acessíveis e viáveis. As opções incluem mecanismos de atenção alternativos para reduzir o tráfego de memória, compilação de código para uma execução mais rápida e kernels otimizados para aumentar a taxa de transferência. Combine essas técnicas para obter o máximo desempenho.

Para configuração de dispositivo e ajustes específicos de hardware, consulte os guias de [Hardware](./hardware). Verifique quais técnicas são suportadas pelo seu hardware antes de aplicar as otimizações abaixo.

> [!NOTE]
> Memória e velocidade estão intimamente relacionadas, mas não são a mesma coisa. Reduzir a pegada de memória torna um modelo "mais rápido" porque há menos dados para mover. Otimizações puras de velocidade nem sempre reduzem a memória e, às vezes, aumentam o uso. Escolha a otimização adequada com base no seu caso de uso e hardware.

Use a tabela abaixo para escolher uma técnica de otimização.

| Técnica | Velocidade | Memória |
|---|:---:|:---:|
| [Compilação](#compilation) | ✅ | |
| [Backends de atenção](#attention-backends) | ✅ | ✅ |
| [Kernels](#kernels) | ✅ | ✅ |
| [Quantização](#quantization) | ✅ | ✅ |
| [Cache](#caching) | ✅ | ✅ |
| [Paralelismo](#parallelism) | ✅ | |
| [Loteamento contínuo](#continuous-batching) | ✅ | |

Este guia oferece uma introdução rápida às otimizações do Transformers.

## Compilação

[torch.compile](./perf_torch_compile) reduz a sobrecarga do Python, funde operações e cria kernels ajustados para as suas formas e o seu hardware. A primeira execução faz o aquecimento e as execuções subsequentes usam o caminho compilado mais rápido.

Passe um [cache de tamanho fixo](./kv_cache#fixed-size-cache) para [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) para acionar automaticamente o `torch.compile`.

```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]
> Evite chamar `torch.compile(model)` fora de [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) para evitar que o modelo seja recompilado a cada etapa.

## Backends de atenção

Backends alternativos de [atenção](./attention_interface) reduzem o tráfego de memória. Por exemplo, o FlashAttention aplica tiles às computações de atenção e evita tensores intermediários grandes para reduzir a pegada de memória.

Defina `attn_implementation` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar um backend de atenção otimizado.

```py
from transformers import AutoModelForCausalLM

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

## Kernels

Kernels fundem operações para aumentar a taxa de transferência e reduzir o uso de memória. A biblioteca [Kernels](https://huggingface.co/docs/kernels/en/index) carrega kernels de computação otimizados do [Hub](https://huggingface.co/kernels-community) de forma flexível e com segurança de versão.

O exemplo abaixo carrega um kernel otimizado do FlashAttention-2 sem instalar o pacote.

```py
import torch
from transformers import AutoModelForCausalLM

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

## Quantização

[Quantização](./quantization/overview) reduz o tamanho de cada parâmetro, o que diminui a pegada de memória e aumenta a velocidade, pois é possível executar mais operações.

Passe uma configuração de quantização para o argumento `quantization_config` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained). Cada backend de quantização possui uma configuração diferente com argumentos distintos. O exemplo abaixo quantiza um modelo para 4 bits e configura o dtype de computação com o 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
)
```

## Cache

[Caching](./kv_cache) acelera a geração reutilizando chaves e valores anteriores em vez de recalculá-los para cada token. Para compensar e reduzir o custo de memória de armazenar chaves e valores anteriores, o Transformers oferece suporte para descarregar o cache para a CPU. Apenas a camada atual permanece na GPU.

Use o argumento `cache_implementation` em [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) para definir uma estratégia de 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")
```

## Paralelismo

[Paralelismo](./perf_infer_gpu_multi) distribui um modelo entre dispositivos para que modelos grandes demais para um único dispositivo sejam executados com rapidez. Essa abordagem utiliza mais memória devido ao overhead de sharding e à comunicação necessária para sincronizar os resultados.

[Paralelismo de tensor](./perf_infer_gpu_multi) divide uma camada do modelo entre dispositivos. Defina o número de dispositivos com `DistributedConfig(tp_size=N)` e passe-o para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para ativá-lo.

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

## Loteamento contínuo

[Continuous batching](./continuous_batching) maximiza a taxa de transferência mantendo a GPU ocupada com agendamento dinâmico e pré-preenchimento em blocos. Aplicações de [Serving](./serve-cli/serving) o utilizam para processar múltiplas solicitações recebidas simultaneamente.

Use [generate_batch()](/docs/transformers/main/pt/main_classes/text_generation#transformers.ContinuousMixin.generate_batch) para habilitar o loteamento contínuo.

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