# HeunDiscreteScheduler

Le planificateur Heun (Algorithme 1) provient de l'article [Elucidating the Design Space of Diffusion-Based Generative Models](https://huggingface.co/papers/2206.00364) de Karras et al. Le planificateur est porté depuis la bibliothèque [k-diffusion](https://github.com/crowsonkb/k-diffusion) et a été créé par [Katherine Crowson](https://github.com/crowsonkb/).

## HeunDiscreteScheduler[[diffusers.HeunDiscreteScheduler]]

#### diffusers.HeunDiscreteScheduler[[diffusers.HeunDiscreteScheduler]]

```python
diffusers.HeunDiscreteScheduler(num_train_timesteps: int = 1000, beta_start: float = 0.00085, beta_end: float = 0.012, beta_schedule: str = 'linear', trained_betas: numpy.ndarray | list[float] | None = None, prediction_type: str = 'epsilon', use_karras_sigmas: bool = False, use_exponential_sigmas: bool = False, use_beta_sigmas: bool = False, clip_sample: bool = False, clip_sample_range: float = 1.0, timestep_spacing: typing.Literal['linspace', 'leading', 'trailing'] = 'linspace', steps_offset: int = 0)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L103)

**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 `"exp"`, par défaut `"linear"`) : le plan de beta, une correspondance entre une plage de beta et une séquence de beta pour faire avancer le modèle. Choisissez parmi `linear`, `scaled_linear`, `squaredcos_cap_v2` ou `exp`.

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

prediction_type (`"epsilon"`, `"sample"`, or `"v_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`) or `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper).

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

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.

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.

Planificateur avec des étapes de Heun pour les plans bêta discrets.

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L662)

**Paramètres :**

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

noise (`torch.Tensor`) : Le tenseur de bruit à ajouter aux échantillons d'origine.

timesteps (`torch.Tensor`) : Les pas de temps auxquels ajouter du bruit, déterminant le niveau de bruit à partir de l'ordonnancement.

**Retourne :** `torch.Tensor`

Les échantillons bruités avec un bruit ajouté mis à l'échelle selon le calendrier des pas de temps.

Ajouter du bruit aux échantillons d'origine selon le calendrier de bruit aux pas de temps spécifiés.

#### index_for_timestep[[diffusers.HeunDiscreteScheduler.index_for_timestep]]

```python
index_for_timestep(timestep: typing.Union[float, torch.Tensor], schedule_timesteps: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L198)

**Paramètres :**

timestep (`float` ou `torch.Tensor`) : La valeur de timestep à rechercher dans le planning.

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 planning. Pour la toute première étape, renvoie le deuxième indice si plusieurs correspondances existent, afin d'éviter de sauter un sigma lors d'un démarrage en cours de planning (par exemple, pour l'image-vers-image).

Trouver l'index d'une étape de temps donnée dans le calendrier des étapes de temps.

#### scale_model_input[[diffusers.HeunDiscreteScheduler.scale_model_input]]

```python
scale_model_input(sample: Tensor, timestep: typing.Union[float, torch.Tensor])
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L261)

**Paramètres :**

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

timestep (`float` ou `torch.Tensor`) : 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_begin_index[[diffusers.HeunDiscreteScheduler.set_begin_index]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L251)

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

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L287)

**Paramètres :**

num_inference_steps (`int`, *facultatif*, valeur par défaut `None`) : 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`, `torch.device`, *facultatif*, par défaut `None`) : L'appareil vers lequel les timesteps doivent être déplacés. Si `None`, les timesteps ne sont pas déplacés.

num_train_timesteps (`int`, *facultatif*, valeur par défaut `None`) : Le nombre d'étapes de diffusion utilisées lors de l'entraînement du modèle. Si `None`, l'attribut par défaut `num_train_timesteps` est utilisé.

timesteps (`list[int]`, *facultatif*) : Étapes personnalisées utilisées pour prendre en charge un espacement arbitraire entre les étapes. Si `None`, les étapes seront générées en fonction de l'attribut `timestep_spacing`. Si `timesteps` est transmis, `num_inference_steps` doit être `None`, et l'attribut `timestep_spacing` sera ignoré.

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

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

```python
step(model_output: typing.Union[torch.Tensor, numpy.ndarray], timestep: typing.Union[float, torch.Tensor], sample: typing.Union[torch.Tensor, numpy.ndarray], return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/schedulers/scheduling_heun_discrete.py#L558)

**Paramètres :**

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

timestep (`float`) : 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`) : Indique s'il faut retourner un `HeunDiscreteSchedulerOutput` ou un tuple.

**Retourne :** `HeunDiscreteSchedulerOutput` ou `tuple`

Si `True` est fourni, `HeunDiscreteSchedulerOutput` est renvoyé, sinon un tuple est renvoyé 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).

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