# VQDiffusionScheduler

`VQDiffusionScheduler` convertit la sortie du modèle transformer en un échantillon pour l’image non bruitée à l’étape de diffusion précédente. Il a été introduit dans [Vector Quantized Diffusion Model for Text-to-Image Synthesis](https://huggingface.co/papers/2111.14822) par Shuyang Gu, Dong Chen, Jianmin Bao, Fang Wen, Bo Zhang, Dongdong Chen, Lu Yuan, Baining Guo.

L'abstract de l'article est :

*Nous présentons le modèle de diffusion quantifiée vectorielle (VQ-Diffusion) pour la génération d'images à partir de texte. Cette méthode repose sur un auto-encodeur variationnel quantifié vectoriellement (VQ-VAE) dont l'espace latent est modélisé par une variante conditionnelle du modèle probabiliste de diffusion de débruitage (DDPM) récemment développé. Nous constatons que cette méthode d'espace latent est bien adaptée aux tâches de génération d'images à partir de texte, car elle élimine non seulement le biais unidirectionnel des méthodes existantes, mais nous permet également d'intégrer une stratégie de diffusion par masquage et remplacement pour éviter l'accumulation d'erreurs, un problème grave des méthodes existantes. Nos expériences montrent que le VQ-Diffusion produit des résultats de génération d'images à partir de texte nettement supérieurs à ceux des modèles autorégressifs (AR) conventionnels ayant un nombre de paramètres similaire. Par rapport aux méthodes de génération d'images à partir de texte basées sur des GAN précédentes, notre VQ-Diffusion peut gérer des scènes plus complexes et améliorer considérablement la qualité des images synthétisées. Enfin, nous montrons que le calcul de génération d'images de notre méthode peut être rendu très efficace par reparamétrisation. Avec les méthodes AR traditionnelles, le temps de génération d'images à partir de texte augmente linéairement avec la résolution de l'image de sortie et est donc assez long, même pour des images de taille normale. Le VQ-Diffusion nous permet d'atteindre un meilleur compromis entre qualité et vitesse. Nos expériences indiquent que le modèle VQ-Diffusion avec reparamétrisation est quinze fois plus rapide que les méthodes AR traditionnelles tout en offrant une meilleure qualité d'image.*

## VQDiffusionScheduler[[diffusers.VQDiffusionScheduler]]

#### diffusers.VQDiffusionScheduler[[diffusers.VQDiffusionScheduler]]

```python
diffusers.VQDiffusionScheduler(num_vec_classes: int, num_train_timesteps: int = 100, alpha_cum_start: float = 0.99999, alpha_cum_end: float = 9e-06, gamma_cum_start: float = 9e-06, gamma_cum_end: float = 0.99999)
```

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

**Paramètres :**

num_vec_classes (`int`) : Le nombre de classes des embeddings vectoriels des pixels latents. Inclut la classe du pixel latent masqué.

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

alpha_cum_start (`float`, par défaut `0.99999`) : La valeur initiale d'alpha cumulée.

alpha_cum_end (`float`, par défaut `0.000009`) : La valeur finale de l'alpha cumulé.

gamma_cum_start (`float`, par défaut `0.000009`) : La valeur initiale du gamma cumulé.

gamma_cum_end (`float`, par défaut `0.99999`) : La valeur finale du gamma cumulé.

Un planificateur pour la diffusion à quantification vectorielle.

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.

#### apply_cumulative_transitions[[diffusers.VQDiffusionScheduler.apply_cumulative_transitions]]

```python
apply_cumulative_transitions(q: Tensor, t: typing.Union[int, torch.Tensor])
```

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

**Paramètres :**

q (`torch.Tensor` de forme `(batch size, num classes - 1, num latent pixels)`) : Les probabilités logarithmiques sur les classes des pixels latents non masqués.

t (`int` ou `torch.Tensor`) : L'étape temporelle qui détermine quelle matrice de transition cumulée est utilisée.

**Retourne :** `torch.Tensor` de forme `(batch size, num classes, num latent pixels)`

Les probabilités de log des transitions avec les probabilités de classes du masque ajoutées.

Appliquer la matrice de transition cumulée à un pas de temps aux probabilités logarithmiques des classes non masquées.

#### log_Q_t_transitioning_to_known_class[[diffusers.VQDiffusionScheduler.log_Q_t_transitioning_to_known_class]]

```python
log_Q_t_transitioning_to_known_class(t: typing.Union[int, torch.Tensor], x_t: LongTensor, log_onehot_x_t: Tensor, cumulative: bool)
```

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

**Paramètres :**

t (`int` ou `torch.Tensor`) : L'étape temporelle qui détermine quelle matrice de transition est utilisée.

x_t (`torch.LongTensor` de forme `(batch size, num latent pixels)`) : Les classes de chaque pixel latent au temps `t`.

log_onehot_x_t (`torch.Tensor` de forme `(batch size, num classes, num latent pixels)`) : Les vecteurs log one-hot de `x_t`.

cumulative (`bool`) : Si cumulative est `False`, la matrice de transition pour une étape unique `t-1`->`t` est utilisée. Si cumulative est `True`, la matrice de transition cumulative `0`->`t` est utilisée.

**Retourne :** `torch.Tensor`

Chaque _colonne_ de la matrice renvoyée est une _ligne_ de logarithmes de probabilités de la matrice de transition de probabilité complète. Le tenseur a la forme `(batch size, num classes - 1, num latent pixels)` lorsque `cumulative` est `True` et la forme `(batch size, num classes, num latent pixels)` sinon.

Lorsqu’ils sont cumulés, le tenseur possède une ligne de moins car le pixel latent initial ne peut pas être masqué.

Où :
- `q_n` est la distribution de probabilité du processus avant pour le pixel latent de rang `n`.
- C_0 est une classe d'incorporation de pixels latents
- C_k est la classe du pixel latent masqué

résultat non cumulatif (en omettant les logarithmes) :
```
q_0(x_t | x_{t-1} = C_0) ... q_n(x_t | x_{t-1} = C_0)
          .      .                     .
          .               .            .
          .                      .     .
q_0(x_t | x_{t-1} = C_k) ... q_n(x_t | x_{t-1} = C_k)
```

résultat cumulé (en omettant les logarithmes) :
```
q_0_cumulative(x_t | x_0 = C_0)    ...  q_n_cumulative(x_t | x_0 = C_0)
          .               .                          .
          .                        .                 .
          .                               .          .
q_0_cumulative(x_t | x_0 = C_{k-1}) ... q_n_cumulative(x_t | x_0 = C_{k-1})
```

Calcule les probabilités logarithmiques des lignes de la matrice de transition (cumulative ou non cumulative) pour chaque pixel latent dans `x_t`.

#### q_posterior[[diffusers.VQDiffusionScheduler.q_posterior]]

```python
q_posterior(log_p_x_0: Tensor, x_t: LongTensor, t: typing.Union[int, torch.Tensor])
```

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

**Paramètres :**

log_p_x_0 (`torch.Tensor` de forme `(batch size, num classes - 1, num latent pixels)`) : Les probabilités logarithmiques des classes prédites pour les pixels latents initiaux. N'inclut pas de prédiction pour la classe masquée, car l'image initiale non bruitée ne peut pas être masquée.

x_t (`torch.LongTensor` de forme `(batch size, num latent pixels)`) : Les classes de chaque pixel latent au temps `t`.

t (`int` ou `torch.Tensor`) : L'étape temporelle qui détermine quelle matrice de transition est utilisée.

**Retourne :** `torch.Tensor` de forme `(batch size, num classes, num latent pixels)`

Les probabilités logarithmiques des classes prédites de l'image à l'instant `t-1`.

Calcule les probabilités logarithmiques des classes prédites de l'image à l'instant `t-1` :

```
p(x_{t-1} | x_t) = sum( q(x_t | x_{t-1}) * q(x_{t-1} | x_0) * p(x_0) / q(x_t | x_0) )
```

#### set_timesteps[[diffusers.VQDiffusionScheduler.set_timesteps]]

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

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

**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 et les paramètres du processus de diffusion (alpha, beta, gamma) doivent être 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.VQDiffusionScheduler.step]]

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

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

**Paramètres :**

model_output (`torch.Tensor` de forme `(batch size, num classes - 1, num latent pixels)`) : Les probabilités logarithmiques des classes prédites pour les pixels latents initiaux. N'inclut pas de prédiction pour la classe masquée, car l'image initiale non bruitée ne peut pas être masquée.

timestep (`int` ou `torch.Tensor`) : L'étape temporelle qui détermine les matrices de transition utilisées.

sample (`torch.LongTensor` de forme `(batch size, num latent pixels)`) : Les classes de chaque pixel latent à l'étape temporelle actuelle.

generator (`torch.Generator`, *facultatif*) : Un générateur de nombres aléatoires pour le bruit appliqué à `p(x_{t-1} | x_t)` avant son échantillonnage.

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

**Retourne :** [VQDiffusionSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/vq_diffusion#diffusers.schedulers.scheduling_vq_diffusion.VQDiffusionSchedulerOutput) ou `tuple[torch.LongTensor]`

If return_dict is `True`, [VQDiffusionSchedulerOutput](/docs/diffusers/main/fr/api/schedulers/vq_diffusion#diffusers.schedulers.scheduling_vq_diffusion.VQDiffusionSchedulerOutput) 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 à l'aide de la distribution de transition inverse. Consultez [q_posterior()](/docs/diffusers/main/fr/api/schedulers/vq_diffusion#diffusers.VQDiffusionScheduler.q_posterior) pour plus de détails sur le calcul de la distribution.

## VQDiffusionSchedulerOutput[[diffusers.schedulers.scheduling_vq_diffusion.VQDiffusionSchedulerOutput]]

#### diffusers.schedulers.scheduling_vq_diffusion.VQDiffusionSchedulerOutput[[diffusers.schedulers.scheduling_vq_diffusion.VQDiffusionSchedulerOutput]]

```python
diffusers.schedulers.scheduling_vq_diffusion.VQDiffusionSchedulerOutput(prev_sample: LongTensor)
```

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

**Paramètres :**

prev_sample (`torch.LongTensor` de forme `(batch size, num latent pixels)`) : l'échantillon calculé à l'étape précédente. `prev_sample` doit être utilisé comme entrée du modèle suivante dans la boucle de débruitage.

Classe de sortie pour la fonction d'étape du planificateur.