# CMStochasticIterativeScheduler

[Consistency Models](https://huggingface.co/papers/2303.01469) de Yang Song, Prafulla Dhariwal, Mark Chen et Ilya Sutskever ont introduit un planificateur multistep et onestep (Algorithme 1) capable de générer de bons échantillons en une seule étape ou en un petit nombre d’étapes.

L'abstract de l'article est :

*Les modèles de diffusion ont considérablement fait progresser les domaines de la génération d’images, d’audio et de vidéo, mais ils reposent sur un processus d’échantillonnage itératif qui entraîne une génération lente. Pour surmonter cette limitation, nous proposons les modèles de cohérence, une nouvelle famille de modèles qui génèrent des échantillons de haute qualité en cartographiant directement le bruit vers les données. Ils prennent en charge la génération rapide en une étape par conception, tout en permettant un échantillonnage multi-étapes pour échanger le calcul contre la qualité des échantillons. Ils prennent également en charge l’édition de données en zéro tirage, comme l’interpolation d’images, la colorisation et la super-résolution, sans nécessiter d’entraînement explicite sur ces tâches. Les modèles de cohérence peuvent être entraînés soit en distillant des modèles de diffusion pré-entraînés, soit comme des modèles génératifs autonomes. À travers des expériences exhaustives, nous démontrons qu’ils surpassent les techniques de distillation existantes pour les modèles de diffusion en échantillonnage en une ou quelques étapes, atteignant le nouvel état de l’art avec un FID de 3,55 sur CIFAR-10 et 6,20 sur ImageNet 64x64 pour la génération en une étape. Lorsqu’ils sont entraînés de manière isolée, les modèles de cohérence deviennent une nouvelle famille de modèles génératifs qui peuvent surpasser les modèles génératifs existants en une étape et non adversariaux sur des benchmarks standard tels que CIFAR-10, ImageNet 64x64 et LSUN 256x256.*

Le code source original peut être trouvé sur [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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L43)

**Paramètres :**

num_train_timesteps (`int`, par défaut 40) : Le nombre d'étapes de diffusion pour entraîner le modèle.

sigma_min (`float`, par défaut 0.002) : Amplitude minimale du bruit dans le planificateur sigma. La valeur par défaut est 0.002, conformément à l'implémentation originale.

sigma_max (`float`, valeur par défaut 80.0) : Amplitude maximale du bruit dans le planificateur sigma. La valeur par défaut est 80.0, conformément à l'implémentation originale.

sigma_data (`float`, par défaut 0.5) : L'écart-type de la distribution des données du [paper](https://huggingface.co/papers/2206.00364) EDM. La valeur par défaut est de 0.5, conformément à l'implémentation originale.

s_noise (`float`, par défaut 1.0) : La quantité de bruit supplémentaire pour compenser la perte de détails lors de l'échantillonnage. Une plage raisonnable est [1.000, 1.011]. La valeur par défaut est 1.0, conformément à l'implémentation d'origine.

rho (`float`, par défaut 7.0) : Le paramètre pour le calcul de l'ordonnancement des sigmas de Karras à partir de l'[article](https://huggingface.co/papers/2206.00364) EDM. La valeur par défaut est 7.0, conformément à l'implémentation originale.

clip_denoised (`bool`, par défaut `True`) : Indique s'il faut limiter les sorties débruitées à `(-1, 1)`.

timesteps (`list` ou `np.ndarray` ou `torch.Tensor`, *facultatif*) : Un calendrier explicite de pas de temps qui peut être spécifié en option. Les pas de temps sont attendus dans un ordre croissant.

Échantillonnage multistep et onestep pour les modèles de cohérence.

Ce modèle hérite de [SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin) et [ConfigMixin](/docs/diffusers/v0.43.0/fr/api/configuration#diffusers.ConfigMixin). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les planificateurs, telles que le chargement et l'enregistrement.

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L461)

**Paramètres :**

original_samples (`torch.Tensor`) : Les échantillons d'origine auxquels du bruit sera ajouté.

noise (`torch.Tensor`) : Le tenseur de bruit à ajouter aux échantillons d'origine.

timesteps (`torch.Tensor`) : Les pas de temps auxquels ajouter du bruit, déterminant le niveau de bruit à partir de l'ordonnancement.

**Retourne :** `torch.Tensor`

Les échantillons bruités avec un bruit ajouté mis à l'échelle selon le calendrier des pas de temps.

Ajouter du bruit aux échantillons d'origine selon le calendrier de bruit aux pas de temps spécifiés.

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L276)

**Paramètres :**

sigma (`torch.Tensor`) : La valeur sigma actuelle dans le calendrier de bruit.

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

Un tuple contenant `c_skip` (mise à l'échelle de l'échantillon d'entrée) et `c_out` (mise à l'échelle de la sortie du modèle).

Calcule les facteurs d'échelle pour la sortie du modèle de cohérence.

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L294)

**Paramètres :**

sigma (`torch.Tensor`) : La valeur sigma actuelle dans le calendrier sigma de Karras.

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

Un tuple à deux éléments où `c_skip` (qui pondère l'échantillon actuel) est le premier élément et `c_out` (qui pondère la sortie du modèle de cohérence) est le second élément.

Récupère les échelles utilisées dans la paramétrisation du modèle de cohérence (de l'annexe C de l'[article](https://huggingface.co/papers/2303.01469)) pour imposer la condition aux limites.

> [!TIP] > `epsilon` dans les équations de `c_skip` et `c_out` est défini comme `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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L318)

**Paramètres :**

timestep (`float` ou `torch.Tensor`) : La valeur de timestep à rechercher dans le planning.

schedule_timesteps (`torch.Tensor`, *facultatif*) : Le calendrier des pas de temps à explorer. Si `None`, utilise `self.timesteps`.

**Retourne :** `int`

L'indice de la pas de temps dans le planning. Pour la toute première étape, renvoie le deuxième indice si plusieurs correspondances existent, afin d'éviter de sauter un sigma lors d'un démarrage en cours de planning (par exemple, pour l'image-vers-image).

Trouver l'index d'une étape de temps donnée dans le calendrier des étapes de temps.

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L136)

**Paramètres :**

sample (`torch.Tensor`) : L'échantillon d'entrée.

timestep (`float` ou `torch.Tensor`) : L'étape temporelle actuelle dans la chaîne de diffusion.

**Retourne :** `torch.Tensor`

Un échantillon d'entrée mis à l'échelle.

Échelle de l'entrée du modèle de cohérence par `(sigma**2 + sigma_data**2) ** 0.5`.

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L126)

**Paramètres :**

begin_index (`int`, par défaut `0`) : L'index de début pour le planificateur.

Définit l'index de début pour le planificateur. Cette fonction doit être exécutée depuis le pipeline avant l'inférence.

#### 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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L180)

**Paramètres :**

num_inference_steps (`int`, *facultatif*) : Le nombre d'étapes de diffusion utilisé lors de la génération d'échantillons avec un modèle pré-entraîné.

device (`str` ou `torch.device`, *facultatif*) : L'appareil vers lequel les timesteps doivent être déplacés. Si `None`, les timesteps ne sont pas déplacés.

timesteps (`list[int]`, *facultatif*) : Étapes personnalisées utilisées pour prendre en charge un espacement arbitraire entre les étapes. Si `None`, la stratégie d’espacement par défaut, à savoir un espacement égal entre les étapes, est utilisée. Si `timesteps` est transmis, `num_inference_steps` doit être `None`.

Définit les pas de temps utilisés pour la chaîne de diffusion (à exécuter avant l'inférence).

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L161)

**Paramètres :**

sigmas (`float` ou `np.ndarray`) : Un sigma de Karras unique ou un tableau de sigmas de Karras.

**Retourne :** `np.ndarray`

Un tableau de pas de temps d'entrée mis à l'échelle.

Récupère les pas de temps mis à l'échelle à partir des sigmas de Karras pour l'entrée du modèle de cohérence.

#### étape[[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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L364)

**Paramètres :**

model_output (`torch.Tensor`) : La sortie directe du modèle de diffusion appris.

timestep (`float` ou `torch.Tensor`) : L'étape temporelle actuelle dans la chaîne de diffusion.

sample (`torch.Tensor`) : Une instance actuelle d'un échantillon créé par le processus de diffusion.

generator (`torch.Generator`, *facultatif*) : Un générateur de nombres aléatoires.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [CMStochasticIterativeSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) ou un `tuple`.

**Retourne :** [CMStochasticIterativeSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/cm_stochastic_iterative#diffusers.schedulers.scheduling_consistency_models.CMStochasticIterativeSchedulerOutput) ou `tuple`

If return_dict is `True`, [CMStochasticIterativeSchedulerOutput](/docs/diffusers/v0.43.0/fr/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.

Prédit l'échantillon de l'étape temporelle précédente en inversant l'EDS. Cette fonction propage le processus de diffusion à partir des sorties du modèle appris (le plus souvent le bruit prédit).

## 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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_consistency_models.py#L30)

**Paramètres :**

prev_sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` pour les images) : Échantillon calculé `(x_{t-1})` de l'étape temporelle précédente. `prev_sample` doit être utilisé comme entrée du modèle suivante dans la boucle de débruitage.

Classe de sortie de la fonction `step` du planificateur.