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 funciona bien con modelos destilados.
Usa FlowMatchEulerDiscreteScheduler o FlowMatchHeunDiscreteScheduler para modelos FlowMatch (Qwen-Image, Flux y similares).
EulerDiscreteScheduler o EulerAncestralDiscreteScheduler suelen funcionar bien para imágenes de estilo anime.
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

Los modelos de flow-matching como Qwen-Image y Flux incluyen FlowMatchEulerDiscreteScheduler como valor predeterminado. Mantén ese scheduler a menos que estés experimentando de forma intencional. Sustitúyelo mediante 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.

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() 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 a menos que esté experimentando intencionalmente con un reemplazo compatible.

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() y pasarla a from_pretrained() a través de scheduler.

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.

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

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), 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.

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.

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.

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.

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.

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

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 de la programación AYS de 10 pasos.

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 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.

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

Establezca use_karras_sigmas=True en el programador para habilitarlo.

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 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 para obtener más detalles sobre el reescalado del ruido para aplicar un SNR cero.

Update on GitHub