# DiscreteDDIMScheduler

Le `DiscreteDDIMScheduler` échantillonne chaque position du canevas à partir de la postérieure discrète exacte du processus de corruption uniforme (D3PM), conformément à [Structured Denoising Diffusion Models in Discrete State-Spaces](https://huggingface.co/papers/2107.03006). Il ne comporte aucun paramètre, et l'étape finale engage de manière déterministe les jetons prédits. Un mode prédicteur-correcteur facultatif ajoute les balayages de Gibbs leave-one-out de [Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation](https://huggingface.co/papers/2605.22765) via `corrector_steps`.

Ce planificateur est utilisé par [DiffusionGemmaPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipeline).

## DiscreteDDIMScheduler[[diffusers.DiscreteDDIMScheduler]]

#### diffusers.DiscreteDDIMScheduler[[diffusers.DiscreteDDIMScheduler]]

```python
diffusers.DiscreteDDIMScheduler(num_inference_steps: int = 32, corrector_steps: int = 0, corrector_k: int = 1, corrector_selection: str = 'lowest_log_margin', corrector_selection_tau: float = 1.0)
```

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

**Paramètres :**

num_inference_steps (`int`, par défaut 32) : Le nombre d'étapes de débruitage, définissant la grille de temps linéaire sur laquelle le posterior est évalué.

corrector_steps (`int`, par défaut 0) : Nombre de balayages correcteurs de Gibbs exécutés après chaque étape prédicteur. `0` correspond à l'échantillonnage ancestral DDIM standard.

corrector_k (`int`, par défaut 1) : Nombre de positions rééchantillonnées par balayage du correcteur.

corrector_selection (`str`, par défaut `"lowest_log_margin"`) : La méthode de sélection des positions rééchantillonnées : `"lowest_log_margin"`, `"lowest_maxprob"`, `"lowest_current_prob"` ou `"random"`.

corrector_selection_tau (`float`, par défaut 1.0) : Température de la sélection de positions Gumbel-top-k (plus la valeur est basse, plus la sélection est gloutonne).

Planificateur DDIM discret pour le processus de corruption uniforme, suivant « Structured Denoising Diffusion Models in Discrete State-Spaces » (D3PM, https://huggingface.co/papers/2107.03006).

Sur le calendrier linéaire, la probabilité de survie d’un jeton propre au temps `t` est `alpha(t) = 1 - t`. Une étape de débruitage du temps `t` à `s < t` échantillonne chaque position de bloc à partir de la postérieure exacte `q(x_s | x_t, x0)`, qui, pour le noyau uniforme, se décompose en trois chemins : sauter vers le jeton propre prédit `x0`, rester sur le jeton actuel, ou sauter vers un jeton aléatoire uniforme. Contrairement à la diffusion masquée, il n’y a pas de jeton de masque ; les positions non engagées portent des jetons aléatoires.

Un mode prédicteur-correcteur optionnel suit « Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation » via le débruiteur leave-one-out (LOO) (https://huggingface.co/papers/2605.22765). Lorsque `corrector_steps > 0`, le pipeline exécute ce nombre de balayages correcteurs de Gibbs après chaque étape de prédicteur (voir [step_correct()](/docs/diffusers/v0.43.0/fr/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler.step_correct)), en rééchantillonnant les positions les moins confiantes à partir de la conditionnelle à une coordonnée `Cat(alpha_s * x0_loo + (1 - alpha_s) / K)` tout en maintenant les autres fixes, ce qui laisse la marginale `p_s` invariante et améliore la génération sans coût d'entraînement.

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

```python
step(model_output: torch.Tensor, timestep: int | torch.Tensor, sample: torch.LongTensor, temperature: float = 0.0, generator: torch.Generator | None = None, return_dict: bool = True)
```

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

**Paramètres :**

model_output (`torch.Tensor` de forme `(batch_size, block_length, vocab_size)`) : Logits bruts du modèle pour le bloc actuel.

timestep (`int` ou `torch.Tensor`) : Index de l'étape actuelle dans le calendrier de débruitage, dans `[0, num_inference_steps - 1]`.

sample (`torch.LongTensor` de forme `(batch_size, block_length)`) : ID des jetons du bloc actuel `x_t`.

temperature (`float`) : Température d'échantillonnage appliquée aux logits lors du tirage de `x0`.

generator (`torch.Generator`, *facultatif*) : générateur de nombres aléatoires pour l'échantillonnage.

return_dict (`bool`) : Indique s'il faut retourner un [DiscreteDDIMSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMSchedulerOutput) ou un simple tuple.

Échantillonner le bloc suivant à partir de la postérieure `q(x_s | x_t, x0)` du processus de corruption uniforme.

Avec `a = alpha_t / alpha_s` (probabilité de survie de `s` à `t`) et `b = alpha_s`, la masse a posteriori de chaque trajet est

propre : `b * (1 - a) / K + a * b * 1[x_t = x0]`, stable : `a * (1 - b) / K`, bruit : `(1 - a) * (1 - b) / K`,

la dernière étape (`b = 1`) engage donc de manière déterministe les jetons propres prédits.

#### step_correct[[diffusers.DiscreteDDIMScheduler.step_correct]]

```python
step_correct(model_output: torch.Tensor, timestep: int | torch.Tensor, sample: torch.LongTensor, generator: torch.Generator | None = None, return_dict: bool = True)
```

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

**Paramètres :**

model_output (`torch.Tensor` de forme `(batch_size, block_length, vocab_size)`) : Logits bruts du modèle recalculés sur l'`sample` actuel (post-prédicteur).

timestep (`int` ou `torch.Tensor`) : l'indice de pas du prédicteur vient d'être terminé ; le correcteur s'exécute au point de grille suivant `s`.

sample (`torch.LongTensor` de forme `(batch_size, block_length)`) : ID des jetons du bloc actuel à affiner.

generator (`torch.Generator`, *facultatif*) : générateur de nombres aléatoires pour l'échantillonnage.

return_dict (`bool`) : Indique s'il faut retourner un [DiscreteDDIMSchedulerOutput](/docs/diffusers/v0.43.0/fr/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMSchedulerOutput) ou un simple tuple.

Effectuer un balayage d'un correcteur de Gibbs au temps post-prédicteur `s`, en suivant le prédicteur-correcteur leave-one-out de https://huggingface.co/papers/2605.22765.

Les logits du modèle (recalculés sur l'`sample` actuel) sont convertis en débruiteur LOO, la conditionnelle à une coordonnée `p_s(x^l | x^{-l}) = Cat(alpha_s * x0_loo + (1 - alpha_s) / K)` est formée, les positions du `corrector_k` le moins confiantes sont sélectionnées, et ces positions sont rééchantillonnées tandis que les autres sont maintenues fixes. Le balayage préserve `p_s`, il affine donc l'échantillon sans modifier sa marginale et n'exige aucune formation supplémentaire.

## DiscreteDDIMSchedulerOutput[[diffusers.DiscreteDDIMSchedulerOutput]]

#### diffusers.DiscreteDDIMSchedulerOutput[[diffusers.DiscreteDDIMSchedulerOutput]]

```python
diffusers.DiscreteDDIMSchedulerOutput(prev_sample: torch.LongTensor, sampled_tokens: torch.LongTensor, sampled_probs: torch.Tensor, pred_logits: torch.Tensor)
```

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

**Paramètres :**

prev_sample (`torch.LongTensor` de forme `(batch_size, block_length)`) : Jetons de bloc mis à jour après l'étape de débruitage actuelle.

sampled_tokens (`torch.LongTensor` de forme `(batch_size, block_length)`) : Identifiants de jetons échantillonnés à partir des logits du modèle, c'est-à-dire les jetons propres prédits `x0`.

sampled_probs (`torch.Tensor` de forme `(batch_size, block_length)`) : Probabilités des jetons échantillonnés.

pred_logits (`torch.Tensor` de forme `(batch_size, block_length, vocab_size)`) : Les logits du débruiteur, transmis pour l'auto-conditionnement de l'étape suivante.

Classe de sortie pour le planificateur DDIM discret.