# CMStochasticIterativeScheduler

[Consistency Models](https://huggingface.co/papers/2303.01469), de Yang Song, Prafulla Dhariwal, Mark Chen e Ilya Sutskever, introdujo un programador de multietapas y de un solo paso (Algoritmo 1) capaz de generar buenas muestras en uno o un pequeño número de pasos.

El resumen del artículo es:

*Los modelos de difusión han avanzado significativamente en los campos de generación de imágenes, audio y vídeo, pero dependen de un proceso de muestreo iterativo que provoca una generación lenta. Para superar esta limitación, proponemos los modelos de consistencia, una nueva familia de modelos que generan muestras de alta calidad mapeando directamente el ruido a los datos. Por diseño, admiten una generación rápida en un solo paso, al tiempo que permiten el muestreo multipaso para intercambiar cómputo por calidad de muestra. También admiten la edición de datos sin ejemplos (zero-shot), como el relleno de imágenes (inpainting), la colorización y la superresolución, sin necesidad de entrenamiento explícito en estas tareas. Los modelos de consistencia se pueden entrenar ya sea destilando modelos de difusión preentrenados, o como modelos generativos independientes. A través de experimentos extensos, demostramos que superan a las técnicas de destilación existentes para modelos de difusión en el muestreo de uno y pocos pasos, logrando el nuevo estado del arte en FID de 3.55 en CIFAR-10 y 6.20 en ImageNet 64x64 para la generación en un solo paso. Cuando se entrenan de forma aislada, los modelos de consistencia se convierten en una nueva familia de modelos generativos que pueden superar a los modelos generativos existentes de un solo paso y no adversariales en benchmarks estándar como CIFAR-10, ImageNet 64x64 y LSUN 256x256.*

El código original se puede encontrar en [openai/consistency_models](https://github.com/openai/consistency_models).

## CMStochasticIterativeScheduler[[diffusers.CMStochasticIterativeScheduler]]

#### diffusers.CMStochasticIterativeScheduler[[diffusers.CMStochasticIterativeScheduler]]

```python
diffusers.CMStochasticIterativeScheduler(num_train_timesteps: int = 40, sigma_min: float = 0.002, sigma_max: float = 80.0, sigma_data: float = 0.5, s_noise: float = 1.0, rho: float = 7.0, clip_denoised: bool = True)
```

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

**Parámetros:**

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

sigma_min (`float`, por defecto 0.002) : Magnitud mínima de ruido en la programación de sigma. Por defecto, 0.002 según la implementación original.

sigma_max (`float`, por defecto 80.0) : Magnitud máxima de ruido en la programación de sigma. Por defecto es 80.0, según la implementación original.

sigma_data (`float`, por defecto 0.5) : La desviación estándar de la distribución de datos del [artículo](https://huggingface.co/papers/2206.00364) de EDM. Por defecto es 0.5, según la implementación original.

s_noise (`float`, por defecto 1.0) : La cantidad de ruido adicional para contrarrestar la pérdida de detalle durante el muestreo. Un rango razonable es [1.000, 1.011]. Por defecto es 1.0, según la implementación original.

rho (`float`, por defecto 7.0) : El parámetro para calcular el calendario de sigma de Karras a partir del [artículo](https://huggingface.co/papers/2206.00364) de EDM. Por defecto es 7.0, según la implementación original.

clip_denoised (`bool`, por defecto `True`) : Si se deben recortar las salidas desruidadas a `(-1, 1)`.

timesteps (`list` o `np.ndarray` o `torch.Tensor`, *opcional*) : Un programa de pasos de tiempo explícito que se puede especificar opcionalmente. Se espera que los pasos de tiempo estén en orden ascendente.

Muestreo multietapa y de un solo paso para modelos de consistencia.

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.CMStochasticIterativeScheduler.add_noise]]

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

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

**Parámetros:**

original_samples (`torch.Tensor`) : Las muestras originales a las que se les añadirá ruido.

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

timesteps (`torch.Tensor`) : Los pasos de tiempo en los que se añade ruido, determinando el nivel de ruido a partir de la programación.

**Devuelve:** `torch.Tensor`

Las muestras ruidosas con ruido añadido escalado según la programación de pasos de tiempo.

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

#### get_scalings[[diffusers.CMStochasticIterativeScheduler.get_scalings]]

```python
get_scalings(sigma: Tensor)
```

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

**Parámetros:**

sigma (`torch.Tensor`) : El valor actual de sigma en el plan de ruido.

**Devuelve:** `tuple[torch.Tensor, torch.Tensor]`

Una tupla que contiene `c_skip` (escalado para la muestra de entrada) y `c_out` (escalado para la salida del modelo).

Calcula los factores de escala para la salida del modelo de consistencia.

#### get_scalings_for_boundary_condition[[diffusers.CMStochasticIterativeScheduler.get_scalings_for_boundary_condition]]

```python
get_scalings_for_boundary_condition(sigma: Tensor)
```

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

**Parámetros:**

sigma (`torch.Tensor`) : La sigma actual en la programación de sigmas de Karras.

**Devuelve:** `tuple[torch.Tensor, torch.Tensor]`

Una tupla de dos elementos donde `c_skip` (que pondera la muestra actual) es el primer elemento y `c_out` (que pondera la salida del modelo de consistencia) es el segundo elemento.

Obtiene las escalas utilizadas en la parametrización del modelo de consistencia (del Apéndice C del [artículo](https://huggingface.co/papers/2303.01469)) para aplicar la condición de frontera.

> [!TIP] > `epsilon` en las ecuaciones de `c_skip` y `c_out` se establece en `sigma_min`.

#### index_for_timestep[[diffusers.CMStochasticIterativeScheduler.index_for_timestep]]

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

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

**Parámetros:**

timestep (`float` o `torch.Tensor`) : El valor de timestep a buscar en la programación.

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. Para el primer paso, devuelve el segundo índice si existen múltiples coincidencias para evitar omitir una sigma al comenzar a mitad de la programación (p. ej., para imagen a imagen).

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

#### scale_model_input[[diffusers.CMStochasticIterativeScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, timestep: typing.Union[float, torch.Tensor])
```

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

**Parámetros:**

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

timestep (`float` o `torch.Tensor`) : El paso temporal actual en la cadena de difusión.

**Devuelve:** `torch.Tensor`

Una muestra de entrada escalada.

Escala la entrada del modelo de consistencia por `(sigma**2 + sigma_data**2) ** 0.5`.

#### set_begin_index[[diffusers.CMStochasticIterativeScheduler.set_begin_index]]

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

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

**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.CMStochasticIterativeScheduler.set_timesteps]]

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

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

**Parámetros:**

num_inference_steps (`int`, *opcional*) : 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.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para admitir un espaciado arbitrario entre los pasos de tiempo. Si es `None`, se utiliza la estrategia de espaciado de pasos de tiempo por defecto, que es un espaciado igual entre los pasos de tiempo. Si se pasa `timesteps`, `num_inference_steps` debe ser `None`.

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

#### sigma_to_t[[diffusers.CMStochasticIterativeScheduler.sigma_to_t]]

```python
sigma_to_t(sigmas: float | numpy.ndarray)
```

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

**Parámetros:**

sigmas (`float` o `np.ndarray`) : Un sigma de Karras individual o un array de sigmas de Karras.

**Devuelve:** `np.ndarray`

Un array de pasos de tiempo de entrada escalado.

Obtiene los pasos de tiempo escalados a partir de las sigmas de Karras para la entrada del modelo de consistencia.

#### paso[[diffusers.CMStochasticIterativeScheduler.step]]

```python
step(model_output: Tensor, timestep: typing.Union[float, torch.Tensor], sample: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)
```

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

**Parámetros:**

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

timestep (`float` o `torch.Tensor`) : El paso temporal actual en la cadena de difusión.

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

generator (`torch.Generator`, *opcional*) : Un generador de números aleatorios.

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

**Devuelve:** [CMStochasticIterativeSchedulerOutput](/docs/diffusers/main/es/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) o `tuple`

If return_dict is `True`, [CMStochasticIterativeSchedulerOutput](/docs/diffusers/main/es/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) is returned, otherwise a tuple is returned where the first element is the sample tensor.

Predice la muestra del paso de tiempo anterior invirtiendo el SDE. Esta función propaga el proceso de difusión desde las salidas del modelo aprendido (con mayor frecuencia, el ruido predicho).

## CMStochasticIterativeSchedulerOutput[[diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput]]

#### diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput[[diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput]]

```python
diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput(prev_sample: Tensor)
```

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

**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 de salida para la función `step` del programador.