# Visão geral

A inferência de difusão é computacionalmente cara e você frequentemente executa um [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline) mais de uma vez antes de gostar do resultado. Esta página fornece uma visão geral das principais técnicas de otimização do Diffusers, o que elas fazem e quando usá-las.

## Caminho inicial

Quando o modelo cabe em uma GPU, comece com este carregamento de linha de base. Defina `dtype` e coloque o pipeline em um acelerador. Recorra ao offload de modelo para CPU apenas quando a memória estiver apertada. Você também pode acelerar a inferência com menos etapas ou um agendador mais rápido.

Quando você omite `dtype`, o Diffusers carrega os componentes em `float32`. Passe `dtype=torch.bfloat16` (ou `torch.float16` se bfloat16 não for suportado) e, em seguida, coloque o pipeline em um acelerador com `pipeline.to("cuda")`.

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.bfloat16,
)
pipeline.to("cuda")  # or "mps", "xpu"

prompt = """
cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California
highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain
"""
pipeline(prompt).images[0]
```

Se o pipeline não couber, ou se a memória estiver limitada, chame [enable_model_cpu_offload()](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) em vez de manter tudo na GPU. Ele coloca o modelo ativo na GPU e mantém os outros componentes na CPU.

Pule-o quando o modelo couber. O offloading é mais lento quando você não precisa dele.

Para mais opções de offloading, consulte [Reduzir o uso de memória](./memory#offloading).

```py
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.bfloat16,
)
pipeline.enable_model_cpu_offload()
```

Menor latência com menos `num_inference_steps` ou um scheduler mais rápido, como [DPMSolverMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler). Isso geralmente acelera a geração, mas pode reduzir a qualidade da imagem em comparação com um scheduler mais lento e de maior qualidade. Consulte [Técnicas de otimização](#optimization-techniques) abaixo para mais técnicas de velocidade.

```py
import time
from diffusers import DPMSolverMultistepScheduler

pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)

start_time = time.perf_counter()
image = pipeline(prompt, num_inference_steps=25).images[0]
end_time = time.perf_counter()

print(f"Image generation took {end_time - start_time:.3f} seconds")
```

## Técnicas de otimização

Quando o caminho inicial não for suficiente, use estas técnicas. Se a inferência estiver lenta demais, comece com `torch.compile`, cache ou backends de atenção. Se estiver sem memória, comece com offloading ou quantização.

Inferência mais rápida:

- [torch.compile](./fp16#torchcompile) — Compila o UNet, o transformer ou o VAE em kernels otimizados.
- [Compilação regional](./fp16#regional-compilation) — Compile blocos repetidos para reduzir a latência de inicialização a frio do `torch.compile` e reutilizar artefatos compilados.
- [Cache](./cache) — Reutilize intermediários entre as etapas de remoção de ruído quando você deseja mais velocidade e pode gastar memória.
- [Backends de atenção](./attention_backends) — Troque as implementações de atenção do Diffusers por meio de uma API unificada quando a atenção for o gargalo.
- [Kernels](./fp16#kernels) — Carrega kernels de computação otimizados do Hub (atenção e operações CUDA personalizadas, como RMSNorm ou RoPE) quando você precisa de acelerações específicas de hardware além do PyTorch padrão.

Menos memória:

- [Offloading](./memory#offloading) — Mova modelos ou camadas inativos para a CPU com offloading de CPU, modelo ou grupo.
- [Quantização](../quantization/overview) — Carrega pesos menores para reduzir a memória (alguns backends também aceleram a inferência). [GGUF](../quantization/gguf) é um ponto de partida comum.
- [VAE slicing](./memory#vae-slicing) e [VAE tiling](./memory#vae-tiling) — Decodifique grandes lotes ou imagens de alta resolução em partes para reduzir a memória de pico.

Ambos:

- [Quantize, compile, and offload](./speed-memory-optims) — Combine quantização, `torch.compile` e offloading quando uma técnica não for suficiente.