# UniPCMultistepScheduler

`UniPCMultistepScheduler` es un marco de trabajo sin entrenamiento diseñado para la muestreo rápido de modelos de difusión. Fue introducido en [UniPC: A Unified Predictor-Corrector Framework for Fast Sampling of Diffusion Models](https://huggingface.co/papers/2302.04867) por Wenliang Zhao, Lujia Bai, Yongming Rao, Jie Zhou, Jiwen Lu.

Está compuesto por un corrector (UniC) y un predictor (UniP) que comparten una forma analítica unificada y admiten órdenes arbitrarios. UniPC es agnóstico al modelo por diseño, y admite DPMs en espacio de píxeles/espacio latente para muestreo incondicional/condicional. También puede aplicarse a modelos de predicción de ruido y de predicción de datos. El corrector UniC también puede aplicarse después de cualquier solver comercial para aumentar el orden de precisión.

El resumen del artículo es:

*Los modelos de difusión probabilística (DPM) han demostrado una capacidad muy prometedora en la síntesis de imágenes de alta resolución. Sin embargo, muestrear desde un DPM preentrenado es un proceso que consume mucho tiempo debido a las múltiples evaluaciones de la red de eliminación de ruido, lo que hace cada vez más importante acelerar el muestreo de los DPM. A pesar de los avances recientes en el diseño de muestreadores rápidos, los métodos existentes aún no pueden generar imágenes satisfactorias en muchas aplicaciones donde se prefieren menos pasos (p. ej., <10). En este artículo, desarrollamos un corrector unificado (UniC) que puede aplicarse después de cualquier muestreador DPM existente para aumentar el orden de precisión sin evaluaciones adicionales del modelo, y derivamos un predictor unificado (UniP) que soporta un orden arbitrario como subproducto. Combinando UniP y UniC, proponemos un marco de predictor-corrector unificado llamado UniPC para el muestreo rápido de DPM, que tiene una forma analítica unificada para cualquier orden y puede mejorar significativamente la calidad del muestreo en comparación con los métodos anteriores, especialmente en un número extremadamente bajo de pasos. Evaluamos nuestros métodos a través de experimentos extensos que incluyen tanto muestreo incondicional como condicional utilizando DPM en el espacio de píxeles y en el espacio latente. Nuestro UniPC puede lograr un FID de 3.87 en CIFAR10 (incondicional) y un FID de 7.51 en ImageNet 256×256 (condicional) con solo 10 evaluaciones de función. El código está disponible en [esta URL de https](https://github.com/wl-zhao/UniPC).*

## Consejos

Se recomienda establecer `solver_order` en 2 para la muestreo con guía, y `solver_order=3` para el muestreo incondicional.

El umbral dinámico de [Imagen](https://huggingface.co/papers/2205.11487) es compatible, y para los modelos de difusión en el espacio de píxeles, puede establecer tanto `predict_x0=True` como `thresholding=True` para usar el umbral dinámico. Este método de umbral no es adecuado para los modelos de difusión en el espacio latente, como Stable Diffusion.

## UniPCMultistepScheduler[[diffusers.UniPCMultistepScheduler]]

#### diffusers.UniPCMultistepScheduler[[diffusers.UniPCMultistepScheduler]]

```python
diffusers.UniPCMultistepScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: str = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, solver_order: int = 2, prediction_type: typing.Literal['epsilon', 'sample', 'v_prediction', 'flow_prediction'] = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, sample_max_value: float = 1.0, predict_x0: bool = True, solver_type: typing.Literal['bh1', 'bh2'] = 'bh2', lower_order_final: bool = True, disable_corrector: list[int] = [], solver_p: SchedulerMixin = None, use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, use_flow_sigmas: bool = False, flow_shift: float = 1.0, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', steps_offset: int = 0, final_sigmas_type: typing.Literal['zero', 'sigma_min'] = 'zero', rescale_betas_zero_snr: bool = False, use_dynamic_shifting: bool = False, time_shift_type: typing.Literal['exponential'] = 'exponential', sigma_min: float | None = None, sigma_max: bool | None = None, shift_terminal: bool | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L123)

**Parámetros:**

num_train_timesteps (`int`, por defecto 1000) : El número de pasos de difusión para entrenar el modelo.

beta_start (`float`, por defecto 0.0001) : El valor inicial de `beta` para la inferencia.

beta_end (`float`, por defecto 0.02) : El valor final de `beta`.

beta_schedule (`"linear"`, `"scaled_linear"` o `"squaredcos_cap_v2"`, por defecto `"linear"`) : El programa de betas, una función que mapea un rango de betas a una secuencia de betas para dar pasos al modelo. Elija entre `linear`, `scaled_linear` o `squaredcos_cap_v2`.

trained_betas (`np.ndarray`, *opcional*) : Pasa un array de betas directamente al constructor para omitir `beta_start` y `beta_end`.

solver_order (`int`, por defecto `2`) : El orden de UniPC, que puede ser cualquier entero positivo. El orden efectivo de precisión es `solver_order + 1` debido a UniC. Se recomienda usar `solver_order=2` para muestreo guiado y `solver_order=3` para muestreo incondicional.

prediction_type (`"epsilon"`, `"sample"`, `"v_prediction"`, or `"flow_prediction"`, defaults to `"epsilon"`, *optional*) : Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`), `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper), or `flow_prediction`.

thresholding (`bool`, por defecto `False`) : Si se debe utilizar el método de "umbral dinámico". No es adecuado para modelos de difusión en el espacio latente, como Stable Diffusion.

dynamic_thresholding_ratio (`float`, por defecto 0.995) : La proporción para el método de umbral dinámico. Solo es válido cuando `thresholding=True`.

sample_max_value (`float`, por defecto 1.0) : El valor de umbral para el umbral dinámico. Solo es válido cuando `thresholding=True` y `predict_x0=True`.

predict_x0 (`bool`, por defecto `True`) : Si se debe usar el algoritmo de actualización en el x0 predicho.

solver_type (`"bh1"` o `"bh2"`, por defecto `"bh2"`) : Tipo de solver para UniPC. Se recomienda usar `bh1` para muestreo incondicional cuando steps < 10, y `bh2` en caso contrario.

lower_order_final (`bool`, por defecto `True`) : Si se deben usar solvers de orden inferior en los pasos finales. Solo es válido para < 15 pasos de inferencia. Esto puede estabilizar el muestreo de DPMSolver para pasos < 15, especialmente para pasos <= 10.

disable_corrector (`list`, por defecto `[]`) : Decide en qué paso desactivar el corrector para mitigar el desalineamiento entre `epsilon_theta(x_t, c)` y `epsilon_theta(x_t^c, c)`, que puede influir en la convergencia para una escala de guía grande. El corrector suele desactivarse durante los primeros pasos.

solver_p (`SchedulerMixin`, valor predeterminado `None`) : Cualquier otro programador que, si se especifica, hace que el algoritmo sea `solver_p + UniC`.

use_karras_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas de Karras para los tamaños de paso en el plan de ruido durante el proceso de muestreo. Si es `True`, los sigmas se determinan según una secuencia de niveles de ruido {σi}.

use_exponential_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas exponenciales para los tamaños de paso en el plan de ruido durante el proceso de muestreo.

use_beta_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas beta para los tamaños de paso en el plan de ruido durante el proceso de muestreo. Consulte [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) para obtener más información.

use_flow_sigmas (`bool`, *opcional*, valor predeterminado `False`) : Si se deben usar sigmas de flujo para los tamaños de paso en el plan de ruido durante el proceso de muestreo.

timestep_spacing (`"linspace"`, `"leading"` o `"trailing"`, por defecto `"linspace"`) : La forma en que se deben escalar los timesteps. Consulte la Tabla 2 de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) para obtener más información.

steps_offset (`int`, valor predeterminado 0) : Un desplazamiento que se suma a los pasos de inferencia, tal como lo requieren algunas familias de modelos.

final_sigmas_type (`"zero"` o `"sigma_min"`, por defecto `"zero"`) : El valor final de `sigma` para el plan de ruido durante el proceso de muestreo. Si es `"sigma_min"`, el sigma final es el mismo que el último sigma del plan de entrenamiento. Si es `zero`, el sigma final se establece en 0.

rescale_betas_zero_snr (`bool`, por defecto `False`) : Si se deben reescalar los betas para tener un SNR terminal cero. Esto permite al modelo generar muestras muy brillantes y oscuras en lugar de limitarlo a muestras con un brillo medio. Relacionado de forma laxa con [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).

`UniPCMultistepScheduler` es un marco de trabajo sin entrenamiento diseñado para la muestreo rápido de modelos de difusión.

Este modelo hereda de [SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin) y [ConfigMixin](/docs/diffusers/main/es/api/configuration#diffusers.ConfigMixin). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los programadores, como la carga y el guardado.

#### add_noise[[diffusers.UniPCMultistepScheduler.add_noise]]

```python
add_noise(original_samples: Tensor, noise: Tensor, timesteps: IntTensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1250)

**Parámetros:**

original_samples (`torch.Tensor`) : Las muestras originales sin ruido.

noise (`torch.Tensor`) : El ruido que se añadirá a las muestras.

timesteps (`torch.IntTensor`) : Los pasos de tiempo en los que se debe añadir ruido a las muestras.

**Devuelve:** `torch.Tensor`

Las muestras ruidosas.

Añade ruido a las muestras originales según el programa de ruido en los pasos de tiempo especificados.

#### convert_model_output[[diffusers.UniPCMultistepScheduler.convert_model_output]]

```python
convert_model_output(model_output: Tensor, *args, sample: Tensor = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L760)

**Parámetros:**

model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido.

timestep (`int`) : El paso de tiempo discreto actual en la cadena de difusión.

sample (`torch.Tensor`) : Una instancia actual de una muestra creada por el proceso de difusión.

**Devuelve:** `torch.Tensor`

La salida del modelo convertido.

Convierta la salida del modelo al tipo correspondiente que necesita el algoritmo UniPC.

#### index_for_timestep[[diffusers.UniPCMultistepScheduler.index_for_timestep]]

```python
index_for_timestep(timestep: typing.Union[int, torch.Tensor], schedule_timesteps: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1100)

**Parámetros:**

timestep (`int` o `torch.Tensor`) : El paso de tiempo para el que se debe encontrar el índice.

schedule_timesteps (`torch.Tensor`, *opcional*) : El calendario de pasos de tiempo en el que buscar. Si es `None`, usa `self.timesteps`.

**Devuelve:** `int`

El índice del paso de tiempo en la programación.

Encuentra el índice para un paso de tiempo dado en la programación.

#### multistep_uni_c_bh_update[[diffusers.UniPCMultistepScheduler.multistep_uni_c_bh_update]]

```python
multistep_uni_c_bh_update(this_model_output: Tensor, *args, last_sample: Tensor = None, this_sample: Tensor = None, order: int = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L962)

**Parámetros:**

this_model_output (`torch.Tensor`) : Las salidas del modelo en `x_t`.

this_timestep (`int`) : El paso temporal actual `t`.

last_sample (`torch.Tensor`) : La muestra generada antes del último predictor `x_{t-1}`.

this_sample (`torch.Tensor`) : La muestra generada después del último predictor `x_{t}`.

order (`int`) : El `p` de UniC-p en este paso. El orden efectivo de precisión debe ser `order + 1`.

**Devuelve:** `torch.Tensor`

El tensor de muestra corregido en el paso de tiempo actual.

Un paso para la versión UniC (B(h)).

#### multistep_uni_p_bh_update[[diffusers.UniPCMultistepScheduler.multistep_uni_p_bh_update]]

```python
multistep_uni_p_bh_update(model_output: Tensor, *args, sample: Tensor = None, order: int = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L833)

**Parámetros:**

model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido en el paso de tiempo actual.

prev_timestep (`int`) : El paso de tiempo discreto anterior en la cadena de difusión.

sample (`torch.Tensor`) : Una instancia actual de una muestra creada por el proceso de difusión.

order (`int`) : El orden de UniP en este paso de tiempo (corresponde a la *p* en UniPC-p).

**Devuelve:** `torch.Tensor`

El tensor de muestra en el paso de tiempo anterior.

Un paso para UniP (versión B(h)). Alternativamente, se utiliza `self.solver_p` si se especifica.

#### scale_model_input[[diffusers.UniPCMultistepScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, *args, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1234)

**Parámetros:**

sample (`torch.Tensor`) : La muestra de entrada.

**Devuelve:** `torch.Tensor`

Una muestra de entrada escalada.

Garantiza la interoperabilidad con los programadores que necesitan escalar la entrada del modelo de desruido en función del paso temporal actual.

#### set_begin_index[[diffusers.UniPCMultistepScheduler.set_begin_index]]

```python
set_begin_index(begin_index: int = 0)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L308)

**Parámetros:**

begin_index (`int`, por defecto `0`) : El índice inicial del programador.

Establece el índice inicial para el programador. Esta función debe ejecutarse desde la tubería antes de la inferencia.

#### set_timesteps[[diffusers.UniPCMultistepScheduler.set_timesteps]]

```python
set_timesteps(num_inference_steps: int | None = None, device: typing.Union[str, torch.device] = None, sigmas: list[float] | None = None, mu: bool | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L318)

**Parámetros:**

num_inference_steps (`int`) : El número de pasos de difusión utilizados al generar muestras con un modelo preentrenado.

device (`str` o `torch.device`, *opcional*) : El dispositivo al que deben moverse los pasos de tiempo. Si es `None`, los pasos de tiempo no se mueven.

sigmas (`List[float]`, *opcional*) : Valores personalizados para sigmas que se usarán en cada paso de difusión. Si es `None`, los sigmas se calculan automáticamente.

mu (`float`, *opcional*) : Parámetro mu opcional para el desplazamiento dinámico al usar el tipo de desplazamiento temporal exponencial.

Establece los pasos discretos utilizados para la cadena de difusión (para ejecutarse antes de la inferencia).

#### paso[[diffusers.UniPCMultistepScheduler.step]]

```python
step(model_output: Tensor, timestep: typing.Union[int, torch.Tensor], sample: Tensor, return_dict: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1153)

**Parámetros:**

model_output (`torch.Tensor`) : La salida directa del modelo de difusión aprendido.

timestep (`int` o `torch.Tensor`) : El paso de tiempo discreto actual en la cadena de difusión.

sample (`torch.Tensor`) : Una instancia actual de una muestra creada por el proceso de difusión.

return_dict (`bool`, por defecto `True`) : Si se devuelve un [SchedulerOutput](/docs/diffusers/main/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) o un `tuple`.

**Devuelve:** [SchedulerOutput](/docs/diffusers/main/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) o `tuple`

If return_dict es `True`, se devuelve [SchedulerOutput](/docs/diffusers/main/es/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput); en caso contrario, se devuelve una tupla cuyo primer elemento es el tensor de muestras.

Predice la muestra del paso de tiempo anterior invirtiendo la EDE. Esta función propaga la muestra con el UniPC de múltiples pasos.

#### stretch_shift_to_terminal[[diffusers.UniPCMultistepScheduler.stretch_shift_to_terminal]]

```python
stretch_shift_to_terminal(t: Tensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L506)

**Parámetros:**

t (`torch.Tensor`) : Un tensor de pasos de tiempo que se estirará y desplazará.

**Devuelve:** `torch.Tensor`

Un tensor de pasos de tiempo ajustados de modo que el valor final sea igual a `self.config.shift_terminal`.

Estira y desplaza la programación de pasos de tiempo para garantizar que termine en el valor de configuración `shift_terminal` configurado.

Referencia: https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51

#### time_shift[[diffusers.UniPCMultistepScheduler.time_shift]]

```python
time_shift(mu: float, sigma: float, t: Tensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L484)

**Parámetros:**

mu (`float`) : El parámetro mu para el desplazamiento en el tiempo.

sigma (`float`) : El parámetro sigma para el desplazamiento temporal.

t (`torch.Tensor`) : Los pasos de tiempo de entrada.

**Devuelve:** `torch.Tensor`

Los pasos de tiempo desplazados.

Aplicar el desplazamiento temporal a los sigmas.

## SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]]

#### diffusers.schedulers.scheduling_utils.SchedulerOutput[[diffusers.schedulers.scheduling_utils.SchedulerOutput]]

```python
diffusers.schedulers.scheduling_utils.SchedulerOutput(prev_sample: Tensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_utils.py#L66)

**Parámetros:**

prev_sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` para imágenes) : Muestra `(x_{t-1})` calculada del paso de tiempo anterior. `prev_sample` debe usarse como entrada del modelo en la siguiente iteración del bucle de desruido.

Clase base para la salida de la función `step` de un programador.