# DPMSolverMultistepInverse

`DPMSolverMultistepInverse` est le planificateur inversé issu de [DPM-Solver: A Fast ODE Solver for Diffusion Probabilistic Model Sampling in Around 10 Steps](https://huggingface.co/papers/2206.00927) et [DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models](https://huggingface.co/papers/2211.01095) de Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li et Jun Zhu.

L'implémentation est principalement basée sur la définition de l'inversion DDIM de [Null-text Inversion for Editing Real Images using Guided Diffusion Models](https://huggingface.co/papers/2211.09794) et sur l'implémentation du notebook de l'inversion latente `DiffEdit` de [Xiang-cd/DiffEdit-stable-diffusion](https://github.com/Xiang-cd/DiffEdit-stable-diffusion/blob/main/diffedit.ipynb).

## Astuces

Le seuillage dynamique issu de [Imagen](https://huggingface.co/papers/2205.11487) est pris en charge. Pour les modèles de diffusion en espace pixel, vous pouvez définir à la fois `algorithm_type="dpmsolver++"` et `thresholding=True` afin d’utiliser le seuillage dynamique. Cette méthode de seuillage n’est pas adaptée aux modèles de diffusion en espace latent, tels que Stable Diffusion.

## DPMSolverMultistepInverseScheduler[[diffusers.DPMSolverMultistepInverseScheduler]]

#### diffusers.DPMSolverMultistepInverseScheduler[[diffusers.DPMSolverMultistepInverseScheduler]]

```python
diffusers.DPMSolverMultistepInverseScheduler(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['dpmsolver', 'dpmsolver++', 'sde-dpmsolver', 'sde-dpmsolver++'] = 'dpmsolver++', solver_type: typing.Literal['midpoint', 'heun'] = 'midpoint', lower_order_final: bool = True, euler_at_final: bool = False, 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, lambda_min_clipped: float = -inf, variance_type: typing.Optional[typing.Literal['learned', 'learned_range']] = None, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', steps_offset: int = 0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.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 (`str`, 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`, *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 du DPMSolver, 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 (`str`, 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`) or `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper).

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` et `algorithm_type="dpmsolver++"`.

algorithm_type (`str`, par défaut `dpmsolver++`) : Type d'algorithme pour le solveur ; peut être `dpmsolver`, `dpmsolver++`, `sde-dpmsolver` ou `sde-dpmsolver++`. Le type `dpmsolver` implémente les algorithmes de l'article [DPMSolver](https://huggingface.co/papers/2206.00927), et le type `dpmsolver++` implémente les algorithmes de l'article [DPMSolver++](https://huggingface.co/papers/2211.01095). Il est recommandé d'utiliser `dpmsolver++` ou `sde-dpmsolver++` avec `solver_order=2` pour un échantillonnage guidé, comme dans Stable Diffusion.

solver_type (`str`, par défaut `midpoint`) : Type de solveur pour le solveur du second ordre ; peut être `midpoint` ou `heun`. Le type de solveur influence légèrement la qualité de l'échantillonnage, en particulier pour un petit nombre d'étapes. Il est recommandé d'utiliser les solveurs `midpoint`.

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. Cela peut stabiliser l'échantillonnage de DPMSolver pour moins de 15 étapes, en particulier pour 10 étapes ou moins.

euler_at_final (`bool`, par défaut `False`) : Indique s'il faut utiliser la méthode d'Euler à la dernière étape. Il s'agit d'un compromis entre la stabilité numérique et la richesse des détails. Cela peut stabiliser l'échantillonnage de la variante SDE de DPMSolver pour un petit nombre d'étapes d'inférence, mais peut parfois entraîner un flou.

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 facteur de décalage du flux. Valable uniquement lorsque `use_flow_sigmas=True`.

lambda_min_clipped (`float`, par défaut `-inf`) : Seuil de troncature pour la valeur minimale de `lambda(t)` afin d'assurer la stabilité numérique. C'est un paramètre crucial pour le plan de bruit cosinus (`squaredcos_cap_v2`).

variance_type (`str`, *facultatif*) : À définir sur "learned" ou "learned_range" pour les modèles de diffusion qui prédisent la variance. Si défini, la sortie du modèle contient la variance gaussienne prédite.

timestep_spacing (`str`, par défaut `"linspace"`) : La méthode de mise à l'échelle des timesteps. Consultez le 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`, valeur par défaut 0) : Un décalage ajouté aux étapes d'inférence, tel que requis par certaines familles de modèles.

`DPMSolverMultistepInverseScheduler` est le planificateur inverse de [DPMSolverMultistepScheduler](/docs/diffusers/main/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler).

Ce modèle hérite de [SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.SchedulerMixin) et [ConfigMixin](/docs/diffusers/main/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.DPMSolverMultistepInverseScheduler.add_noise]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L1118)

**Paramètres :**

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

noise (`torch.Tensor`) : Le tenseur de bruit.

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

**Retourne :** `torch.Tensor`

Les échantillons bruités.

Ajoutez du bruit aux `original_samples` propres à l'aide de la fonction équivalente du planificateur.

#### convert_model_output[[diffusers.DPMSolverMultistepInverseScheduler.convert_model_output]]

```python
convert_model_output(model_output: Tensor, *args, sample: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L600)

**Paramètres :**

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

sample (`torch.Tensor`, *facultatif*) : 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 DPMSolver/DPMSolver++ a besoin. DPM-Solver est conçu pour discrétiser une intégrale du modèle de prédiction du bruit, et DPM-Solver++ est conçu pour discrétiser une intégrale du modèle de prédiction des données.

> [!TIP] > L'algorithme et le type de modèle sont découplés. Vous pouvez utiliser DPMSolver ou DPMSolver++ pour les deux
bruit > prédiction et modèles de prédiction de données.

#### dpm_solver_first_order_update[[diffusers.DPMSolverMultistepInverseScheduler.dpm_solver_first_order_update]]

```python
dpm_solver_first_order_update(model_output: Tensor, *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L699)

**Paramètres :**

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

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

noise (`torch.Tensor`, *facultatif*) : Le tenseur de bruit.

**Retourne :** `torch.Tensor`

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

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

#### multistep_dpm_solver_second_order_update[[diffusers.DPMSolverMultistepInverseScheduler.multistep_dpm_solver_second_order_update]]

```python
multistep_dpm_solver_second_order_update(model_output_list: list[torch.Tensor], *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L774)

**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`, *facultatif*) : Une instance actuelle d'un échantillon créé par le processus de diffusion.

noise (`torch.Tensor`, *facultatif*) : Bruit aléatoire utilisé par les variantes de solveur stochastiques (`sde-*`). Requis lorsque `algorithm_type` est défini sur l'une d'entre elles, et inutilisé dans le cas contraire.

**Retourne :** `torch.Tensor`

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

Une étape pour le solveur DPMSolver multistep du second ordre.

#### multistep_dpm_solver_third_order_update[[diffusers.DPMSolverMultistepInverseScheduler.multistep_dpm_solver_third_order_update]]

```python
multistep_dpm_solver_third_order_update(model_output_list: list[torch.Tensor], *args, sample: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L901)

**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`, *facultatif*) : Une instance actuelle d'un échantillon créé par le processus de diffusion.

noise (`torch.Tensor`, *facultatif*) : Le tenseur de bruit.

**Retourne :** `torch.Tensor`

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

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

#### scale_model_input[[diffusers.DPMSolverMultistepInverseScheduler.scale_model_input]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L1103)

**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_timesteps[[diffusers.DPMSolverMultistepInverseScheduler.set_timesteps]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L283)

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

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

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py#L1017)

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

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

variance_noise (`torch.Tensor`) : Alternative à la génération de bruit avec `generator` en fournissant directement le bruit pour la variance elle-même. Utile pour des méthodes telles que `CycleDiffusion`.

return_dict (`bool`) : Indique s'il faut retourner un [SchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) ou un `tuple`.

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

If return_dict est `True`, [SchedulerOutput](/docs/diffusers/main/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 DPMSolver 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/main/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.