# PNDMScheduler

`PNDMScheduler`, ou méthodes numériques pseudo pour les modèles de diffusion, utilise des techniques d’intégration d’EDO plus avancées, telles que Runge-Kutta et la méthode linéaire à pas multiples. L’implémentation originale est disponible sur [crowsonkb/k-diffusion](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181).

## PNDMScheduler[[diffusers.PNDMScheduler]]

#### diffusers.PNDMScheduler[[diffusers.PNDMScheduler]]

```python
diffusers.PNDMScheduler(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, skip_prk_steps: bool = False, set_alpha_to_one: bool = False, prediction_type: typing.Literal['epsilon', 'v_prediction'] = 'epsilon', timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'leading', steps_offset: int = 0)
```

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

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

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

skip_prk_steps (`bool`, par défaut `False`) : Permet à l'ordonnanceur d'ignorer les étapes de Runge-Kutta définies dans l'article original comme étant nécessaires avant les étapes PLMS.

set_alpha_to_one (`bool`, par défaut `False`) : Chaque étape de diffusion utilise la valeur du produit des alphas à cette étape et à l'étape précédente. Pour l'étape finale, il n'y a pas d'alpha précédent. Lorsque cette option est `True`, le produit des alphas précédents est fixé à `1`, sinon il utilise la valeur de l'alpha à l'étape 0.

prediction_type (`"epsilon"` ou `"v_prediction"`, par défaut `"epsilon"`) : Type de prédiction de la fonction du planificateur ; peut être `epsilon` (prédit le bruit du processus de diffusion) ou `v_prediction` (voir la section 2.4 de l’article [Imagen Video](https://huggingface.co/papers/2210.02303)).

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.

`PNDMScheduler` utilise des méthodes numériques pseudo-numériques pour les modèles de diffusion, telles que Runge-Kutta et la méthode linéaire multi-étapes.

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

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

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

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

#### scale_model_input[[diffusers.PNDMScheduler.scale_model_input]]

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

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

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

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

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

**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.PNDMScheduler.step]]

```python
step(model_output: Tensor, timestep: int, sample: Tensor, return_dict: bool = True)
```

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

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

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 is `True`, [SchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) 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) et appelle [step_prk()](/docs/diffusers/main/fr/api/schedulers/pndm#diffusers.PNDMScheduler.step_prk) ou [step_plms()](/docs/diffusers/main/fr/api/schedulers/pndm#diffusers.PNDMScheduler.step_plms) en fonction de la variable interne `counter`.

#### step_plms[[diffusers.PNDMScheduler.step_plms]]

```python
step_plms(model_output: Tensor, timestep: int, sample: Tensor, return_dict: bool = True)
```

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

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

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 is `True`, [SchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) 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 l'échantillon à l'aide de la méthode multistep linéaire. Elle effectue plusieurs passes avant pour approximer la solution.

#### step_prk[[diffusers.PNDMScheduler.step_prk]]

```python
step_prk(model_output: Tensor, timestep: int, sample: Tensor, return_dict: bool = True)
```

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

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

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 is `True`, [SchedulerOutput](/docs/diffusers/main/fr/api/schedulers/ipndm#diffusers.schedulers.scheduling_utils.SchedulerOutput) 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 l'échantillon à l'aide de la méthode de Runge-Kutta. Elle effectue quatre passes avant pour approximer la solution de l'équation différentielle.

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