# DDPMScheduler

[Denoising Diffusion Probabilistic Models](https://huggingface.co/papers/2006.11239) (DDPM) de Jonathan Ho, Ajay Jain et Pieter Abbeel propose un modèle de diffusion portant le même nom. Dans le contexte de la bibliothèque 🤗 Diffusers, DDPM désigne à la fois le planificateur de débruitage discret issu de l’article et le pipeline.

L'abstract de l'article est :

*Nous présentons des résultats de synthèse d’images de haute qualité à l’aide de modèles probabilistes de diffusion, une classe de modèles de variables latentes inspirée de considérations issues de la thermodynamique hors équilibre. Nos meilleurs résultats sont obtenus en entraînant sur une borne variationnelle pondérée, conçue selon une nouvelle connexion entre les modèles probabilistes de diffusion et l’ajustement du score de débruitage avec dynamique de Langevin. Nos modèles admettent naturellement un schéma de décompression progressive avec perte, qui peut être interprété comme une généralisation du décodage autorégressif. Sur le jeu de données non conditionnel CIFAR10, nous obtenons un score Inception de 9,46 et un score FID de pointe de 3,17. Sur LSUN 256x256, nous obtenons une qualité d’échantillons comparable à celle de ProgressiveGAN. Notre implémentation est disponible à [cette adresse](https://github.com/hojonathanho/diffusion).*

## DDPMScheduler[[diffusers.DDPMScheduler]]

#### diffusers.DDPMScheduler[[diffusers.DDPMScheduler]]

```python
diffusers.DDPMScheduler(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', 'sigmoid'] = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, variance_type: typing.Literal['fixed_small', 'fixed_small_log', 'fixed_large', 'fixed_large_log', 'learned', 'learned_range'] = 'fixed_small', clip_sample: bool = True, prediction_type: typing.Literal['epsilon', 'sample', 'v_prediction'] = 'epsilon', thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, clip_sample_range: float = 1.0, sample_max_value: float = 1.0, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'leading', steps_offset: int = 0, rescale_betas_zero_snr: bool = False)
```

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

**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"`, `"squaredcos_cap_v2"` ou `"sigmoid"`, 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.

trained_betas (`np.ndarray`, *facultatif*) : Un tableau de bêtas à passer directement au constructeur sans utiliser `beta_start` et `beta_end`.

variance_type (`"fixed_small"`, `"fixed_small_log"`, `"fixed_large"`, `"fixed_large_log"`, `"learned"` ou `"learned_range"`, par défaut `"fixed_small"`) : Applique un seuil à la variance lors de l'ajout de bruit à l'échantillon débruité.

clip_sample (`bool`, par défaut `True`) : Applique un seuil à l'échantillon prédit pour la stabilité numérique.

clip_sample_range (`float`, par défaut `1.0`) : L'amplitude maximale pour le rognage des échantillons. Valable uniquement lorsque `clip_sample=True`.

prediction_type (`"epsilon"`, `"sample"`, or `"v_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`) 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`.

timestep_spacing (`"linspace"`, `"leading"` ou `"trailing"`, par défaut `"leading"`) : 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.

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

`DDPMScheduler` explore les liens entre l’ajustement du score de débruitage et l’échantillonnage par dynamique de Langevin.

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

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

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

**Paramètres :**

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

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

timesteps (`torch.IntTensor`) : Les pas de temps indiquant le niveau de bruit pour chaque échantillon.

**Retourne :** `torch.Tensor`

Les échantillons bruités.

Ajoutez du bruit aux échantillons d'origine en fonction de l'amplitude du bruit à chaque pas de temps (il s'agit du processus de diffusion avant).

#### get_velocity[[diffusers.DDPMScheduler.get_velocity]]

```python
get_velocity(sample: Tensor, noise: Tensor, timesteps: IntTensor)
```

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

**Paramètres :**

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

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

timesteps (`torch.IntTensor`) : Les pas de temps pour le calcul de la vitesse.

**Retourne :** `torch.Tensor`

La vitesse calculée.

Calculer la prédiction de vitesse à partir de l'échantillon et du bruit selon la formule de vitesse.

#### previous_timestep[[diffusers.DDPMScheduler.previous_timestep]]

```python
previous_timestep(timestep: int)
```

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

**Paramètres :**

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

**Retourne :** `int` ou `torch.Tensor`

L'étape de temps précédente.

Calculer l'étape précédente dans la chaîne de diffusion.

#### scale_model_input[[diffusers.DDPMScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, timestep: int | None = None)
```

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

**Paramètres :**

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

timestep (`int`, *facultatif*) : L'étape temporelle actuelle dans la chaîne de diffusion.

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

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

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

**Paramètres :**

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

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 discrets utilisés pour la chaîne de diffusion (à exécuter avant l'inférence).

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

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

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

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

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [DDPMSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ddpm#diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput) ou un `tuple`.

**Retourne :** [DDPMSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ddpm#diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput) ou `tuple`

If return_dict is `True`, [DDPMSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ddpm#diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput) 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).

## DDPMSchedulerOutput[[diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput]]

#### diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput[[diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput]]

```python
diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput(prev_sample: Tensor, pred_original_sample: typing.Optional[torch.Tensor] = None)
```

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

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

pred_original_sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` pour les images) : l'échantillon débruité prédit `(x_{0})` basé sur la sortie du modèle à l'étape temporelle actuelle. `pred_original_sample` peut être utilisé pour prévisualiser la progression ou pour le guidage.

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