# UniPCMultistepScheduler

`UniPCMultistepScheduler` est un cadre sans entraînement conçu pour l’échantillonnage rapide des modèles de diffusion. Il a été introduit dans [UniPC: A Unified Predictor-Corrector Framework for Fast Sampling of Diffusion Models](https://huggingface.co/papers/2302.04867) par Wenliang Zhao, Lujia Bai, Yongming Rao, Jie Zhou, Jiwen Lu.

Il se compose d'un correcteur (UniC) et d'un prédicteur (UniP) qui partagent une forme analytique unifiée et prennent en charge des ordres arbitraires. UniPC est, par conception, indépendant du modèle, et prend en charge les DPM dans l'espace des pixels ou l'espace latent pour un échantillonnage non conditionné ou conditionné. Il peut également être appliqué aux modèles de prédiction du bruit et aux modèles de prédiction des données. Le correcteur UniC peut également être appliqué après n'importe quel solveur existant pour augmenter l'ordre de précision.

L'abstract de l'article est :

*Les modèles de diffusion probabilistes (DPM) ont démontré une capacité très prometteuse dans la synthèse d'images haute résolution. Cependant, l'échantillonnage à partir d'un DPM pré-entraîné est chronophage en raison des multiples évaluations du réseau de débruitage, ce qui rend de plus en plus important d'accélérer l'échantillonnage des DPM. Malgré les progrès récents dans la conception de sampleurs rapides, les méthodes existantes ne parviennent toujours pas à générer des images satisfaisantes dans de nombreuses applications où un nombre réduit d'étapes (par exemple, <10) est privilégié. Dans cet article, nous développons un correcteur unifié (UniC) qui peut être appliqué après n'importe quel sampleur DPM existant pour augmenter l'ordre de précision sans évaluations de modèle supplémentaires, et nous dérivons un prédicteur unifié (UniP) qui prend en charge un ordre arbitraire comme sous-produit. En combinant UniP et UniC, nous proposons un cadre de prédicteur-correcteur unifié appelé UniPC pour l'échantillonnage rapide des DPM, qui possède une forme analytique unifiée pour tout ordre et peut améliorer considérablement la qualité de l'échantillonnage par rapport aux méthodes précédentes, en particulier en un nombre extrêmement faible d'étapes. Nous évaluons nos méthodes à travers des expériences exhaustives incluant à la fois l'échantillonnage inconditionnel et conditionnel en utilisant des DPM en espace pixel et en espace latent. Notre UniPC peut atteindre un FID de 3,87 sur CIFAR10 (inconditionnel) et un FID de 7,51 sur ImageNet 256×256 (conditionnel) avec seulement 10 évaluations de fonction. Le code est disponible à [cette URL https](https://github.com/wl-zhao/UniPC).*

## Astuces

Il est recommandé de définir `solver_order` à 2 pour l'échantillonnage guidé, et `solver_order=3` pour l'échantillonnage non conditionnel.

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 `predict_x0=True` 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.

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

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

**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`, *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 UniPC, qui peut être n'importe quel entier positif. L'ordre d'exactitude effectif est `solver_order + 1` en raison de UniC. 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"`, *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`, 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 `predict_x0=True`.

predict_x0 (`bool`, par défaut `True`) : Indique s'il faut utiliser l'algorithme de mise à jour sur le x0 prédit.

solver_type (`"bh1"` ou `"bh2"`, par défaut `"bh2"`) : Type de solveur pour UniPC. Il est recommandé d'utiliser `bh1` pour l'échantillonnage non conditionnel lorsque steps < 10, et `bh2` dans le cas contraire.

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.

disable_corrector (`list`, par défaut `[]`) : Détermine à quelle étape désactiver le correcteur pour atténuer le désalignement entre `epsilon_theta(x_t, c)` et `epsilon_theta(x_t^c, c)`, qui peut influencer la convergence pour une échelle de guidage élevée. Le correcteur est généralement désactivé lors des premières étapes.

solver_p (`SchedulerMixin`, par défaut `None`) : Tout autre planificateur qui, s'il est spécifié, fait de l'algorithme `solver_p + UniC`.

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.

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`, valeur par défaut 0) : Un décalage ajouté aux étapes d'inférence, tel que requis par certaines familles de modèles.

final_sigmas_type (`"zero"` ou `"sigma_min"`, par défaut `"zero"`) : La valeur finale de `sigma` pour le calendrier de bruit pendant le processus d'échantillonnage. Si `"sigma_min"`, le sigma final est identique au dernier sigma du calendrier d'entraînement. Si `zero`, le sigma final est défini à 0.

rescale_betas_zero_snr (`bool`, par défaut `False`) : Indique s'il faut rééchelonner les bêtas pour obtenir un SNR terminal nul. Cela permet au modèle de générer des échantillons très clairs et très sombres, au lieu de se limiter à des échantillons de luminosité moyenne. Lié de manière lâche à [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).

`UniPCMultistepScheduler` est un cadre sans entraînement conçu pour l’échantillonnage rapide des modèles de diffusion.

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

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

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

**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.UniPCMultistepScheduler.convert_model_output]]

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

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

**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 UniPC a besoin.

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

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

**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_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)
```

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

**Paramètres :**

this_model_output (`torch.Tensor`) : Les sorties du modèle à `x_t`.

this_timestep (`int`) : L'étape temporelle actuelle `t`.

last_sample (`torch.Tensor`) : l'échantillon généré avant le dernier prédicteur `x_{t-1}`.

this_sample (`torch.Tensor`) : l'échantillon généré après le dernier prédicteur `x_{t}`.

order (`int`) : La valeur de `p` de UniC-p à cette étape. L'ordre d'efficacité effectif doit être `order + 1`.

**Retourne :** `torch.Tensor`

Le tenseur d'échantillon corrigé à l'étape temporelle actuelle.

Une étape pour la version 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)
```

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

**Paramètres :**

model_output (`torch.Tensor`) : La sortie directe du modèle de diffusion appris à l'étape temporelle actuelle.

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.

order (`int`) : L'ordre de UniP à cette étape de temps (correspond au *p* de UniPC-p).

**Retourne :** `torch.Tensor`

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

Une étape pour UniP (version B(h)). Sinon, `self.solver_p` est utilisé si spécifié.

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

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

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

**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.UniPCMultistepScheduler.set_begin_index]]

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

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

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

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

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

sigmas (`List[float]`, *facultatif*) : Valeurs personnalisées pour les sigmas à utiliser à chaque étape de diffusion. Si `None`, les sigmas sont calculés automatiquement.

mu (`float`, *facultatif*) : Paramètre mu facultatif pour le décalage dynamique lors de l'utilisation du type de décalage temporel exponentiel.

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

#### étape[[diffusers.UniPCMultistepScheduler.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/main/src/diffusers/schedulers/scheduling_unipc_multistep.py#L1153)

**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/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 multistep UniPC.

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

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

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

**Paramètres :**

t (`torch.Tensor`) : Un tenseur de pas de temps à étirer et à décaler.

**Retourne :** `torch.Tensor`

Un tenseur de pas de temps ajustés tel que la valeur finale soit égale à `self.config.shift_terminal`.

Étire et décale le calendrier des pas de temps pour s'assurer qu'il se termine à la valeur de configuration `shift_terminal` définie.

Référence : 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)
```

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

**Paramètres :**

mu (`float`) : Le paramètre mu pour le décalage temporel.

sigma (`float`) : Le paramètre sigma pour le décalage temporel.

t (`torch.Tensor`) : Les pas de temps d'entrée.

**Retourne :** `torch.Tensor`

Les pas de temps décalés dans le temps.

Appliquer un décalage temporel aux 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)
```

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