# Planificadores

Un programador indica al bucle de desruidoado cuánto ruido eliminar en cada paso. Los distintos programadores equilibran la velocidad con la calidad.

Esta guía muestra cómo cargar un programador y personalizar su programación de pasos de tiempo, su espaciado y sus sigmas.

## Elegir un programador

Comience desde el punto de control predeterminado. Cambie solo si necesita un equilibrio diferente entre velocidad y calidad.

- DPM++ 2M SDE Karras es una opción versátil y eficaz para muchos puntos de control de difusión latente.
- [TCDScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/tcd#diffusers.TCDScheduler) funciona bien con modelos destilados.
- Usa [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) o [FlowMatchHeunDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_heun_discrete#diffusers.FlowMatchHeunDiscreteScheduler) para modelos FlowMatch (Qwen-Image, Flux y similares).
- [EulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/euler#diffusers.EulerDiscreteScheduler) o [EulerAncestralDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/euler_ancestral#diffusers.EulerAncestralDiscreteScheduler) suelen funcionar bien para imágenes de estilo anime.
- [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler) con un UNet LCM o un LoRA para la generación en pocos pasos cuando el punto de control lo admite.

## Carga de programadores

> [!TIP]
> Los modelos de flow-matching como Qwen-Image y Flux incluyen [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) como valor predeterminado. Mantén ese scheduler a menos que estés experimentando de forma intencional. Sustitúyelo mediante [from_config()](/docs/diffusers/v0.43.0/es/api/configuration#diffusers.ConfigMixin.from_config) solo cuando el reemplazo sea compatible con el checkpoint.

Los Schedulers solo contienen configuración y no incluyen tensores de pesos. Acceda al atributo `.scheduler` de un pipeline para inspeccionar la configuración cargada.

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, device_map="cuda"  # or "mps", "xpu", "cpu"
)
pipeline.scheduler
```

Para cambiar los programadores en una pipeline cargada, use [from_config()](/docs/diffusers/v0.43.0/es/api/configuration#diffusers.ConfigMixin.from_config) con la configuración del programador existente para que `num_train_timesteps` y los campos relacionados permanezcan alineados. Para los puntos de control de FlowMatch (Qwen-Image, Flux y similares), mantenga [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler) a menos que esté experimentando intencionalmente con un reemplazo compatible.

```py
from diffusers import DPMSolverMultistepScheduler

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

También puedes cargar una configuración de programador desde el Hub con [from_pretrained()](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin.from_pretrained) y pasarla a [from_pretrained()](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) a través de `scheduler`.

```py
from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler

dpm = DPMSolverMultistepScheduler.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="scheduler"
)
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    scheduler=dpm,
    dtype=torch.float16,
    device_map="cuda",  # or "mps", "xpu", "cpu"
)
pipeline.scheduler
```

## Programas de pasos de tiempo

El timestep o la programación de ruido determina cómo se distribuye el ruido a lo largo del proceso de desruido. La programación puede ser lineal o más concentrada hacia el inicio o el final. Es una secuencia precalculada de niveles de ruido generada a partir de la configuración predeterminada del scheduler, pero se puede personalizar para utilizar otras programaciones.

```text
linear (even steps)                 AYS (denser where it matters)
noise                               noise
  ^                                   ^
  | *                                 | *
  |  *                                |   *
  |   *                               |    **
  |    *                              |     ***
  |     *                             |      **
  |      *                            |        *
  |       *                           |          *
  +-----------------> step            +-----------------> step
```

> [!TIP]
> Los `timesteps` personalizados solo funcionan si el `set_timesteps` de ese scheduler acepta el argumento (los pipelines comprueban la firma mediante `retrieve_timesteps` y lanzan `ValueError` en caso contrario). Consulta la página de API del scheduler o la firma de `set_timesteps` antes de pasarlos.

El ejemplo siguiente utiliza el programa [Align Your Steps (AYS)](https://research.nvidia.com/labs/toronto-ai/AlignYourSteps/), que puede generar una imagen de alta calidad en 10 pasos, acelerando significativamente la generación y reduciendo el tiempo de cómputo.

Importa el schedule y pásalo al argumento `timesteps` en el pipeline.

```py
import torch
from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
from diffusers.schedulers import AysSchedules

sampling_schedule = AysSchedules["StableDiffusionXLTimesteps"]
print(sampling_schedule)
# [999, 845, 730, 587, 443, 310, 193, 116, 53, 13]

pipeline = DiffusionPipeline.from_pretrained(
    "SG161222/RealVisXL_V4.0",
    dtype=torch.float16,
    device_map="cuda"  # or "mps", "xpu", "cpu"
)
pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
  pipeline.scheduler.config, algorithm_type="sde-dpmsolver++"
)

prompt = "A cinematic shot of a cute little rabbit wearing a jacket and doing a thumbs up"
image = pipeline(
    prompt=prompt,
    negative_prompt="",
    timesteps=sampling_schedule,
).images[0]
```

  
    
    Programa de pasos de tiempo AYS 10 pasos
  
  
    
    Programa de pasos de tiempo espaciados linealmente 10 pasos
  
  
    
    Programa de pasos de tiempo espaciados linealmente 25 pasos
  

Para el reescalado de v-prediction/zero-SNR en puntos de control antiguos, consulte [Puntos de control heredados](./legacy_checkpoints#rescaling-schedules).

## Espaciado de pasos de tiempo

La separación de pasos de tiempo se refiere a los pasos específicos *t* desde los que muestrear en la programación. Diffusers proporciona tres tipos de separación, como se muestra a continuación.

| estrategia de espaciado | cálculo del espaciado | pasos de tiempo de ejemplo |
|---|---|---|
| `leading` | pasos equidistantes | `[900, 800, 700, ..., 100, 0]` |
| `linspace` | incluye los pasos inicial y final y divide uniformemente los pasos intermedios restantes | `[1000, 888.89, 777.78, ..., 111.11, 0]` |
| `trailing` | incluye el último paso y divide uniformemente los pasos intermedios restantes comenzando desde el final | `[999, 899, 799, 699, 599, 499, 399, 299, 199, 99]` |

Pasa la estrategia de espaciado al argumento `timestep_spacing` en el programador.

> [!TIP]
> La estrategia `trailing` suele producir imágenes de mayor calidad y con más detalles en menos pasos, pero la diferencia de calidad no es tan evidente para valores de pasos más estándar.

```py
import torch
from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler

pipeline = DiffusionPipeline.from_pretrained(
    "SG161222/RealVisXL_V4.0",
    dtype=torch.float16,
    device_map="cuda"  # or "mps", "xpu", "cpu"
)
pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
  pipeline.scheduler.config, timestep_spacing="trailing"
)

prompt = "A cinematic shot of a cute little black cat sitting on a pumpkin at night"
image = pipeline(
    prompt=prompt,
    negative_prompt="",
    num_inference_steps=5,
).images[0]
image
```

  
    
    espaciado final tras 5 pasos
  
  
    
    espaciado inicial tras 5 pasos
  

## Sigmas

Sigmas es una medida de lo ruidoso que es una muestra en un paso determinado, según lo definido por la programación. Al usar `sigmas` personalizados, los `timesteps` se calculan a partir de estos valores en lugar de la configuración predeterminada del programador.

```text
step:   0    1    2    3    4
sigma:  σ0 > σ1 > σ2 > σ3 > σ4 ≈ 0
        high noise  --->  clean sample
```

> [!TIP]
> Los `sigmas` personalizados solo funcionan si el `set_timesteps` de ese programador acepta el argumento (los pipelines comprueban la firma mediante `retrieve_timesteps` y lanzan `ValueError` en caso contrario). Consulta la página de API del programador o la firma de `set_timesteps` antes de pasarlos.

Pasa los sigmas personalizados al argumento `sigmas` en el pipeline. El ejemplo de abajo usa los [sigmas](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_utils.py) de la programación AYS de 10 pasos.

```py
import torch
from diffusers import DiffusionPipeline, EulerDiscreteScheduler
from diffusers.schedulers import AysSchedules

pipeline = DiffusionPipeline.from_pretrained(
    "SG161222/RealVisXL_V4.0",
    dtype=torch.float16,
    device_map="cuda",  # or "mps", "xpu", "cpu"
)
pipeline.scheduler = EulerDiscreteScheduler.from_config(pipeline.scheduler.config)

sigmas = AysSchedules["StableDiffusionXLSigmas"]
prompt = "A cinematic shot of a cute little rabbit wearing a jacket and doing a thumbs up"
image = pipeline(
    prompt=prompt,
    negative_prompt="",
    sigmas=sigmas,
).images[0]
```

### Sigmas de Karras

[Karras sigmas](https://huggingface.co/papers/2206.00364) re-muestrea el plan de ruido para un muestreo más eficiente, agrupando los sigmas de forma más densa en la parte media de la secuencia, donde la reconstrucción de la estructura es crítica, mientras que utiliza menos sigmas al principio y al final, donde los cambios de ruido tienen menos impacto. Esto puede aumentar el nivel de detalle en una imagen generada.

```text
default σ:  *  *  *  *  *  *  *  *     even-ish
Karras σ:   *   * * * * *   *          denser mid, sparser ends
            |---structure---|
```

Establezca `use_karras_sigmas=True` en el programador para habilitarlo.

```py
import torch
from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler

pipeline = DiffusionPipeline.from_pretrained(
    "SG161222/RealVisXL_V4.0",
    dtype=torch.float16,
    device_map="cuda"  # or "mps", "xpu", "cpu"
)
pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
  pipeline.scheduler.config,
  algorithm_type="sde-dpmsolver++",
  use_karras_sigmas=True,
)

prompt = "A cinematic shot of a cute little rabbit wearing a jacket and doing a thumbs up"
image = pipeline(
    prompt=prompt,
    negative_prompt="",
    num_inference_steps=20,
).images[0]
```

  
    
    Karras sigmas habilitado
  
  
    
    Karras sigmas desactivado
  

Consulte el [resumen](../api/schedulers/overview) de la API del programador para obtener una lista de programadores que admiten sigmas de Karras. Solo debe usarse con modelos entrenados con sigmas de Karras.

## Próximos pasos

- Lea el artículo [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) para obtener más detalles sobre el reescalado del ruido para aplicar un SNR cero.