# Resumen

La inferencia de difusión es computacionalmente costosa y a menudo se ejecuta un [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline) más de una vez antes de obtener un resultado satisfactorio. Esta página ofrece una visión general de las principales técnicas de optimización de Diffusers, qué hacen y cuándo usarlas.

## Ruta de inicio

Cuando el modelo cabe en una GPU, comience con esta carga de línea base. Establezca `dtype` y coloque el pipeline en un acelerador. Recurra al offload de CPU del modelo solo cuando la memoria sea limitada. También puede acelerar la inferencia con menos pasos o un programador más rápido.

Cuando omites `dtype`, Diffusers carga los componentes en `float32`. Pasa `dtype=torch.bfloat16` (o `torch.float16` si bfloat16 no es compatible) y luego coloca el pipeline en un acelerador con `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]
```

Si el pipeline no cabe o la memoria es limitada, llama a [enable_model_cpu_offload()](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) en lugar de mantener todo en la GPU. Coloca el modelo activo en la GPU y mantiene los demás componentes en la CPU.

Omitelo cuando el modelo quepa. El descargado es más lento cuando no lo necesitas.

Para más opciones de descarga, consulte [Reducir el uso de memoria](./memory#offloading).

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

Menor latencia con menos `num_inference_steps` o un programador más rápido, como [DPMSolverMultistepScheduler](/docs/diffusers/main/es/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler). Eso suele acelerar la generación, pero puede reducir la calidad de la imagen en comparación con un programador más lento y de mayor calidad. Consulte [Técnicas de optimización](#optimization-techniques) a continuación para conocer más técnicas de velocidad.

```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 optimización

Cuando la ruta inicial no es suficiente, utiliza estas técnicas. Si la inferencia es demasiado lenta, comienza con `torch.compile`, el almacenamiento en caché o los backends de atención. Si te quedas sin memoria, comienza con el offloading o la cuantización.

Inferencia más rápida:

- [torch.compile](./fp16#torchcompile) — Compila el UNet, el transformer o el VAE en kernels optimizados.
- [Compilación regional](./fp16#regional-compilation) — Compila bloques repetidos para reducir la latencia de arranque en frío de `torch.compile` y reutilizar los artefactos compilados.
- [Caché](./cache) — Reutiliza los intermedios entre los pasos de desruido cuando buscas más velocidad y puedes gastar memoria.
- [Backends de atención](./attention_backends) — Cambia las implementaciones de atención de Diffusers a través de una API unificada cuando la atención sea el cuello de botella.
- [Kernels](./fp16#kernels) — Carga kernels de cómputo optimizados de Hub (atención y operaciones CUDA personalizadas como RMSNorm o RoPE) cuando necesites aceleraciones específicas del hardware más allá de PyTorch estándar.

Menos memoria:

- [Offloading](./memory#offloading) — Mover modelos o capas inactivos a la CPU mediante offloading de CPU, de modelo o de grupo.
- [Cuantización](../quantization/overview) — Carga pesos más pequeños para reducir la memoria (algunos backends también aceleran la inferencia). [GGUF](../quantization/gguf) es un punto de partida común.
- [Segmentación de VAE](./memory#vae-slicing) y [mosaico de VAE](./memory#vae-tiling): decodifica lotes grandes o imágenes de alta resolución por partes para reducir la memoria pico.

Ambos:

- [Cuantizar, compilar y descargar](./speed-memory-optims) — Combina la cuantización, `torch.compile` y la descarga cuando una sola técnica no es suficiente.