# ScoreSdeVeScheduler

`ScoreSdeVeScheduler` est un planificateur d'équation différentielle stochastique (SDE) à variance croissante. Il a été introduit dans l'article [Score-Based Generative Modeling through Stochastic Differential Equations](https://huggingface.co/papers/2011.13456) de Yang Song, Jascha Sohl-Dickstein, Diederik P. Kingma, Abhishek Kumar, Stefano Ermon, Ben Poole.

L'abstract de l'article est :

*Créer du bruit à partir de données est facile ; créer des données à partir de bruit est la modélisation générative. Nous présentons une équation différentielle stochastique (SDE) qui transforme en douceur une distribution de données complexe en une distribution a priori connue en injectant lentement du bruit, ainsi qu’une SDE en temps inverse correspondante qui transforme la distribution a priori en distribution de données en retirant lentement le bruit. Crucialement, la SDE en temps inverse ne dépend que du champ de gradient dépendant du temps (\aka, score) de la distribution de données perturbée. En tirant parti des avancées en modélisation générative basée sur le score, nous pouvons estimer précisément ces scores avec des réseaux de neurones et utiliser des solveurs numériques de SDE pour générer des échantillons. Nous montrons que ce cadre englobe les approches précédentes en modélisation générative basée sur le score et en modélisation probabiliste par diffusion, permettant de nouvelles procédures d’échantillonnage et de nouvelles capacités de modélisation. En particulier, nous introduisons un cadre prédicteur-correcteur pour corriger les erreurs dans l’évolution de la SDE en temps inverse discrétisée. Nous dérivons également une ODE neuronale équivalente qui échantillonne à partir de la même distribution que la SDE, mais qui permet en outre le calcul exact de la vraisemblance et une efficacité d’échantillonnage améliorée. De plus, nous proposons une nouvelle manière de résoudre des problèmes inverses avec des modèles basés sur le score, comme le montrent des expériences sur la génération conditionnée par classe, l’image inpainting et la colorisation. Combiné à plusieurs améliorations architecturales, nous atteignons des performances record pour la génération d’images non conditionnée sur CIFAR-10 avec un score Inception de 9,89 et un FID de 2,20, une vraisemblance compétitive de 2,99 bits/dim, et démontrons pour la première fois la génération fidèle d’images de 1024 x 1024 à partir d’un modèle génératif basé sur le score.*

## ScoreSdeVeScheduler[[diffusers.ScoreSdeVeScheduler]]

#### diffusers.ScoreSdeVeScheduler[[diffusers.ScoreSdeVeScheduler]]

```python
diffusers.ScoreSdeVeScheduler(num_train_timesteps: int = 2000, snr: float = 0.15, sigma_min: float = 0.01, sigma_max: float = 1348.0, sampling_eps: float = 1e-05, correct_steps: int = 1)
```

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

**Paramètres :**

num_train_timesteps (`int`, par défaut 2000) : Le nombre d'étapes de diffusion pour entraîner le modèle.

snr (`float`, par défaut 0.15) : Un coefficient pondérant l'étape allant de l'échantillon `model_output` (provenant du réseau) vers le bruit aléatoire.

sigma_min (`float`, par défaut 0.01) : L'échelle de bruit initiale pour la séquence de sigma dans la procédure d'échantillonnage. Le sigma minimal doit refléter la distribution des données.

sigma_max (`float`, valeur par défaut 1348.0) : La valeur maximale utilisée pour la plage des pas de temps continus transmis au modèle.

sampling_eps (`float`, par défaut 1e-5) : La valeur finale de l'échantillonnage, où les timesteps diminuent progressivement de 1 à epsilon.

correct_steps (`int`, par défaut 1) : Le nombre d'étapes de correction effectuées sur un échantillon produit.

`ScoreSdeVeScheduler` est un planificateur d'équation différentielle stochastique (SDE) à variance croissante.

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.ScoreSdeVeScheduler.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_sde_ve.py#L300)

**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. Il s'agit du processus de diffusion avant.

#### get_adjacent_sigma[[diffusers.ScoreSdeVeScheduler.get_adjacent_sigma]]

```python
get_adjacent_sigma(timesteps: Tensor, t: Tensor)
```

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

**Paramètres :**

timesteps (`torch.Tensor`) : Le tenseur des indices discrets de pas de temps.

t (`torch.Tensor`) : Le tenseur des valeurs continues de pas de temps.

**Retourne :** `torch.Tensor`

Les valeurs sigma pour l'index de pas de temps adjacent (précédent).

Retourne la valeur de sigma correspondant à l'index de la précédente étape temporelle. Si l'étape temporelle est nulle (aucune étape précédente), retourne zéro.

#### scale_model_input[[diffusers.ScoreSdeVeScheduler.scale_model_input]]

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

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

**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_sigmas[[diffusers.ScoreSdeVeScheduler.set_sigmas]]

```python
set_sigmas(num_inference_steps: int, sigma_min: float | None = None, sigma_max: float | None = None, sampling_eps: float | None = None)
```

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

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

sigma_min (`float`, *facultatif*) : La valeur initiale de l'échelle du bruit (remplace la valeur donnée lors de l'instantiation du planificateur).

sigma_max (`float`, *facultatif*) : La valeur finale de l'échelle de bruit (remplace la valeur donnée lors de l'instantiation du planificateur).

sampling_eps (`float`, *facultatif*) : La valeur finale du timestep (remplace la valeur donnée lors de l'instantiation du scheduler).

Définit les échelles de bruit utilisées pour la chaîne de diffusion (à exécuter avant l'inférence). Les sigmas contrôlent le poids des composantes `drift` et `diffusion` de la mise à jour de l'échantillon.

#### set_timesteps[[diffusers.ScoreSdeVeScheduler.set_timesteps]]

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

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

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

sampling_eps (`float`, *facultatif*) : La valeur finale du timestep (remplace la valeur donnée lors de l'instantiation du scheduler).

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

#### step_correct[[diffusers.ScoreSdeVeScheduler.step_correct]]

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

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

**Paramètres :**

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

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`, *facultatif*, 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.

Corrigez l'échantillon prédit sur la base de `model_output` du réseau. Cette opération est souvent exécutée de manière répétée après avoir effectué la prédiction pour l'étape temporelle précédente.

#### step_pred[[diffusers.ScoreSdeVeScheduler.step_pred]]

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

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

**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`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [SdeVeOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/score_sde_ve#diffusers.schedulers.scheduling_sde_ve.SdeVeOutput) ou un `tuple`.

**Retourne :** [SdeVeOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/score_sde_ve#diffusers.schedulers.scheduling_sde_ve.SdeVeOutput) ou `tuple`

If return_dict is `True`, [SdeVeOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/score_sde_ve#diffusers.schedulers.scheduling_sde_ve.SdeVeOutput) 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).

## SdeVeOutput[[diffusers.schedulers.scheduling_sde_ve.SdeVeOutput]]

#### diffusers.schedulers.scheduling_sde_ve.SdeVeOutput[[diffusers.schedulers.scheduling_sde_ve.SdeVeOutput]]

```python
diffusers.schedulers.scheduling_sde_ve.SdeVeOutput(prev_sample: Tensor, prev_sample_mean: Tensor)
```

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

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

prev_sample_mean (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` pour les images) : Moyenne de `prev_sample` sur les pas de temps précédents.

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