# DEISMultistepScheduler

Le Diffusion Exponential Integrator Sampler (DEIS) est proposé dans [Fast Sampling of Diffusion Models with Exponential Integrator](https://huggingface.co/papers/2204.13902) par Qinsheng Zhang et Yongxin Chen. `DEISMultistepScheduler` est un solveur rapide d'ordre élevé pour les équations différentielles ordinaires (EDO) des modèles de diffusion.

Cette implémentation modifie la formule d’ajustement polynomial dans l’espace log-rho plutôt que dans l’espace linéaire `t` original du papier DEIS. Cette modification bénéficie de coefficients sous forme fermée pour la mise à jour exponentielle multi-étapes, au lieu de s’appuyer sur un solveur numérique.

L'abstract de l'article est :

*Ces dernières années ont été marquées par le grand succès des modèles de diffusion~(DMs) dans la génération d'échantillons haute fidélité pour les tâches de modélisation générative. Une limitation majeure des DMs est leur procédure d'échantillonnage notoirement lente, qui nécessite normalement des centaines à des milliers d'étapes de discrétisation temporelle du processus de diffusion appris pour atteindre la précision souhaitée. Notre objectif est de développer une méthode d'échantillonnage rapide pour les DMs, avec un nombre d'étapes beaucoup plus réduit, tout en conservant une haute qualité d'échantillonnage. À cette fin, nous analysons systématiquement la procédure d'échantillonnage dans les DMs et identifions les facteurs clés qui affectent la qualité des échantillons, parmi lesquels la méthode de discrétisation est la plus cruciale. En examinant attentivement le processus de diffusion appris, nous proposons le Diffusion Exponential Integrator Sampler~(DEIS). Il est basé sur l'Exponential Integrator conçu pour discrétiser les équations différentielles ordinaires (ODEs) et exploite une structure semi-linéaire du processus de diffusion appris pour réduire l'erreur de discrétisation. La méthode proposée peut être appliquée à n'importe quel DM et peut générer des échantillons haute fidélité en aussi peu que 10 étapes. Dans nos expériences, il faut environ 3 minutes sur un GPU A6000 pour générer 50k images à partir de CIFAR10. De plus, en utilisant directement des DMs pré-entraînés, nous atteignons des performances d'échantillonnage de l'état de l'art lorsque le nombre d'évaluations de la fonction de score~(NFE) est limité, par exemple, 4.17 FID avec 10 NFEs, 3.37 FID, et 9.74 IS avec seulement 15 NFEs sur CIFAR10. Le code est disponible à [cette URL https](https://github.com/qsh-zh/deis).*

## Astuces

Il est recommandé de définir `solver_order` sur 2 ou 3, tandis que `solver_order=1` est équivalent à [DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler).

Le seuillage dynamique issu de [Imagen](https://huggingface.co/papers/2205.11487) est pris en charge, et pour les modèles de diffusion en espace pixel, vous pouvez définir `thresholding=True` pour utiliser le seuillage dynamique.

## DEISMultistepScheduler[[diffusers.DEISMultistepScheduler]]

#### diffusers.DEISMultistepScheduler[[diffusers.DEISMultistepScheduler]]

```python
diffusers.DEISMultistepScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.0001, beta_end: float = 0.02, beta_schedule: typing.Literal['linear', 'scaled_linear', 'squaredcos_cap_v2'] = '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, algorithm_type: typing.Literal['deis'] = 'deis', solver_type: typing.Literal['logrho'] = 'logrho', lower_order_final: bool = True, 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, use_dynamic_shifting: bool = False, time_shift_type: typing.Literal['exponential'] = 'exponential')
```

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

**Paramètres :**

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

beta_start (`float`, par défaut `0.0001`) : valeur initiale de `beta` pour l'inférence.

beta_end (`float`, par défaut `0.02`) : La valeur finale de `beta`.

beta_schedule (`"linear"`, `"scaled_linear"` ou `"squaredcos_cap_v2"`, par défaut `"linear"`) : le planning des bêtas, une correspondance entre une plage de bêtas et une séquence de bêtas pour faire avancer le modèle. Choisissez parmi `linear`, `scaled_linear` ou `squaredcos_cap_v2`.

trained_betas (`np.ndarray` ou `list[float]`, *facultatif*) : Passez un tableau de bêtas directement au constructeur pour contourner `beta_start` et `beta_end`.

solver_order (`int`, par défaut `2`) : L'ordre DEIS, qui peut être `1` ou `2` ou `3`. Il est recommandé d'utiliser `solver_order=2` pour l'échantillonnage guidé et `solver_order=3` pour l'échantillonnage non conditionnel.

prediction_type (`"epsilon"`, `"sample"`, `"v_prediction"`, or `"flow_prediction"`, defaults to `"epsilon"`) : 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`, par défaut `False`) : Indique s'il faut utiliser la méthode de « seuillage dynamique ». Cette méthode n'est pas adaptée aux modèles de diffusion en espace latent, tels que Stable Diffusion.

dynamic_thresholding_ratio (`float`, par défaut `0.995`) : Le ratio pour la méthode de seuillage dynamique. Valable uniquement lorsque `thresholding=True`.

sample_max_value (`float`, par défaut `1.0`) : La valeur de seuil pour le seuillage dynamique. Valable uniquement lorsque `thresholding=True`.

algorithm_type (`"deis"`, par défaut `"deis"`) : Le type d'algorithme pour le solveur.

solver_type (`"logrho"`, par défaut `"logrho"`) : Type de solveur pour DEIS.

lower_order_final (`bool`, par défaut `True`) : Indique s'il faut utiliser des solveurs d'ordre inférieur aux étapes finales. Valable uniquement pour moins de 15 étapes d'inférence.

use_karras_sigmas (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser les sigmas de Karras pour les tailles de pas dans le calendrier de bruit pendant le processus d'échantillonnage. Si `True`, les sigmas sont déterminés selon une séquence de niveaux de bruit {σi}.

use_exponential_sigmas (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser des sigmas exponentiels pour les tailles de pas dans le calendrier de bruit pendant le processus d'échantillonnage.

use_beta_sigmas (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser des sigmas bêta pour les tailles de pas dans le calendrier de bruit pendant le processus d'échantillonnage. Consultez [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) pour plus d'informations.

use_flow_sigmas (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser les sigmas de flux pour les tailles de pas dans le calendrier de bruit pendant le processus d'échantillonnage.

flow_shift (`float`, *facultatif*, valeur par défaut `1.0`) : Le paramètre de décalage de flux pour les modèles basés sur le flux.

timestep_spacing (`"linspace"`, `"leading"` ou `"trailing"`, par défaut `"linspace"`) : La manière dont les timesteps doivent être mis à l'échelle. Reportez-vous au tableau 2 de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) pour plus d'informations.

steps_offset (`int`, par défaut `0`) : Un décalage ajouté aux étapes d'inférence, tel que requis par certaines familles de modèles.

use_dynamic_shifting (`bool`, par défaut `False`) : Indique s'il faut utiliser un décalage dynamique pour le calendrier de bruit.

time_shift_type (`"exponential"`, par défaut `"exponential"`) : Le type de décalage temporel à appliquer.

`DEISMultistepScheduler` est un solveur d’ordre élevé rapide pour les équations différentielles ordinaires (EDO) de diffusion.

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

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

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

**Paramètres :**

original_samples (`torch.Tensor`) : Les échantillons d'origine sans bruit.

noise (`torch.Tensor`) : Le bruit à ajouter aux échantillons.

timesteps (`torch.IntTensor`) : Les pas de temps auxquels ajouter du bruit aux échantillons.

**Retourne :** `torch.Tensor`

Les échantillons bruités.

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

#### convert_model_output[[diffusers.DEISMultistepScheduler.convert_model_output]]

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

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

**Paramètres :**

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

timestep (`int`) : L'étape discrète actuelle dans la chaîne de diffusion.

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

**Retourne :** `torch.Tensor`

La sortie du modèle converti.

Convertir la sortie du modèle vers le type correspondant dont l'algorithme DEIS a besoin.

#### deis_first_order_update[[diffusers.DEISMultistepScheduler.deis_first_order_update]]

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

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

**Paramètres :**

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

timestep (`int`) : L'étape discrète actuelle dans la chaîne de diffusion.

prev_timestep (`int`) : L'étape discrète précédente dans la chaîne de diffusion.

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

**Retourne :** `torch.Tensor`

Le tenseur d'échantillon à l'étape temporelle précédente.

Une étape pour le DEIS du premier ordre (équivalent à DDIM).

#### index_for_timestep[[diffusers.DEISMultistepScheduler.index_for_timestep]]

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

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

**Paramètres :**

timestep (`int` ou `torch.Tensor`) : Le pas de temps pour lequel trouver l'index.

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

Trouver l'index pour une étape de temps donnée dans le calendrier.

#### multistep_deis_second_order_update[[diffusers.DEISMultistepScheduler.multistep_deis_second_order_update]]

```python
multistep_deis_second_order_update(model_output_list: list[torch.Tensor], *args, sample: Tensor = None, **kwargs)
```

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

**Paramètres :**

model_output_list (`list[torch.Tensor]`) : Les sorties directes du modèle de diffusion appris aux pas de temps actuels et ultérieurs.

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

**Retourne :** `torch.Tensor`

Le tenseur d'échantillon à l'étape temporelle précédente.

Une étape pour la méthode DEIS multistep du second ordre.

#### multistep_deis_third_order_update[[diffusers.DEISMultistepScheduler.multistep_deis_third_order_update]]

```python
multistep_deis_third_order_update(model_output_list: list[torch.Tensor], *args, sample: Tensor = None, **kwargs)
```

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

**Paramètres :**

model_output_list (`list[torch.Tensor]`) : Les sorties directes du modèle de diffusion appris aux pas de temps actuels et ultérieurs.

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

**Retourne :** `torch.Tensor`

Le tenseur d'échantillon à l'étape temporelle précédente.

Une étape pour le DEIS multistep du troisième ordre.

#### scale_model_input[[diffusers.DEISMultistepScheduler.scale_model_input]]

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

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

**Paramètres :**

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

**Retourne :** `torch.Tensor`

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

Assure l'interchangeabilité avec les planificateurs qui doivent mettre à l'échelle l'entrée du modèle de débruitage en fonction de l'étape temporelle actuelle.

#### set_begin_index[[diffusers.DEISMultistepScheduler.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_deis_multistep.py#L262)

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

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

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

**Paramètres :**

num_inference_steps (`int`) : Le nombre d'étapes de diffusion utilisées 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.

mu (`float`, *facultatif*) : Le paramètre mu pour le décalage dynamique. Utilisé uniquement lorsque `use_dynamic_shifting=True` et `time_shift_type="exponential"`.

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

#### étape[[diffusers.DEISMultistepScheduler.step]]

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

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

**Paramètres :**

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

timestep (`int` ou `torch.Tensor`) : L'étape discrète actuelle dans la chaîne de diffusion.

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

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

**Retourne :** [SchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) ou `tuple`

If return_dict est `True`, [SchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) est retourné, sinon un tuple est retourné dont le premier élément est le tenseur d'échantillon.

Prédit l'échantillon de l'étape temporelle précédente en inversant l'EDS. Cette fonction propage l'échantillon avec le DEIS multi-étapes.

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

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

**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 base pour la sortie de la fonction `step` d'un planificateur.