# 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/v0.43.0/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/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.PNDMScheduler.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_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/v0.43.0/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/v0.43.0/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/v0.43.0/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/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 le processus de diffusion à partir des sorties du modèle appris (le plus souvent le bruit prédit) et appelle [step_prk()](/docs/diffusers/v0.43.0/fr/api/schedulers/pndm#diffusers.PNDMScheduler.step_prk) ou [step_plms()](/docs/diffusers/v0.43.0/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/v0.43.0/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/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 à 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/v0.43.0/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/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 à 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/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.