# DiscreteDDIMScheduler

El `DiscreteDDIMScheduler` muestrea cada posición del lienzo a partir de la posterior discreta exacta del proceso de corrupción uniforme (D3PM), siguiendo [Structured Denoising Diffusion Models in Discrete State-Spaces](https://huggingface.co/papers/2107.03006). No tiene parámetros y el paso final compromete de forma determinista los tokens predichos. Un modo opcional de predictor-corrección añade las barridas de Gibbs leave-one-out de [Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation](https://huggingface.co/papers/2605.22765) a través de `corrector_steps`.

Este programador es utilizado por [DiffusionGemmaPipeline](/docs/diffusers/main/es/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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_discrete_ddim.py#L49)

**Parámetros:**

num_inference_steps (`int`, por defecto 32) : El número de pasos de desruido, que define la cuadrícula de tiempo lineal sobre la que se evalúa la posterior.

corrector_steps (`int`, valor predeterminado 0) : Número de barridos correctores de Gibbs ejecutados después de cada paso del predictor. `0` recupera el muestreo ancestral DDIM simple.

corrector_k (`int`, por defecto 1) : Número de posiciones muestreadas de nuevo por barrido del corrector.

corrector_selection (`str`, por defecto `"lowest_log_margin"`) : Cómo se eligen las posiciones re-muestreadas: `"lowest_log_margin"`, `"lowest_maxprob"`, `"lowest_current_prob"` o `"random"`.

corrector_selection_tau (`float`, por defecto 1.0) : Temperatura de la selección de posiciones Gumbel-top-k (cuanto más baja, más codiciosa).

Programador DDIM discreto para el proceso de corrupción uniforme, siguiendo "Structured Denoising Diffusion Models in Discrete State-Spaces" (D3PM, https://huggingface.co/papers/2107.03006).

En la programación lineal, la probabilidad de supervivencia de un token limpio en el tiempo `t` es `alpha(t) = 1 - t`. Un paso de desruido desde el tiempo `t` hasta `s < t` muestrea cada posición de bloque de la posterior exacta `q(x_s | x_t, x0)`, que para el kernel uniforme se descompone en tres rutas: saltar al token limpio predicho `x0`, permanecer en el token actual o saltar a un token aleatorio uniforme. A diferencia de la difusión enmascarada, no hay un token de máscara; las posiciones no comprometidas contienen tokens aleatorios.

Un modo opcional de predictor-corregidor sigue "Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation" mediante el denoiser leave-one-out (LOO) (https://huggingface.co/papers/2605.22765). Cuando `corrector_steps > 0`, el pipeline ejecuta ese número de barridos correctores de Gibbs después de cada paso de predictor (ver [step_correct()](/docs/diffusers/main/es/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler.step_correct)), muestreando de nuevo las posiciones de menor confianza desde la condicional de una coordenada `Cat(alpha_s * x0_loo + (1 - alpha_s) / K)` mientras mantiene el resto fijo, lo que deja la marginal `p_s` invariante y mejora la generación sin coste de entrenamiento.

#### paso[[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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_discrete_ddim.py#L145)

**Parámetros:**

model_output (`torch.Tensor` de forma `(batch_size, block_length, vocab_size)`) : Logits crudos del modelo para el bloque actual.

timestep (`int` o `torch.Tensor`) : Índice del paso actual dentro del programa de desruido, en `[0, num_inference_steps - 1]`.

sample (`torch.LongTensor` de forma `(batch_size, block_length)`) : IDs de tokens del bloque actual `x_t`.

temperature (`float`) : Temperatura de muestreo aplicada a los logits al extraer `x0`.

generator (`torch.Generator`, *opcional*) : Generador de números aleatorios para el muestreo.

return_dict (`bool`) : Si se debe devolver un [DiscreteDDIMSchedulerOutput](/docs/diffusers/main/es/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMSchedulerOutput) o una tupla simple.

Muestree el siguiente bloque de la posterior `q(x_s | x_t, x0)` del proceso de corrupción uniforme.

Con `a = alpha_t / alpha_s` (probabilidad de supervivencia de `s` a `t`) y `b = alpha_s`, la masa posterior de cada ruta es

limpio: `b * (1 - a) / K + a * b * 1[x_t = x0]`, mantener: `a * (1 - b) / K`, ruido: `(1 - a) * (1 - b) / K`,

por lo que el último paso (`b = 1`) confirma de forma determinista los tokens limpios predichos.

#### 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_discrete_ddim.py#L248)

**Parámetros:**

model_output (`torch.Tensor` de forma `(batch_size, block_length, vocab_size)`) : Logits crudos del modelo recalculados en la `sample` actual (post-predictor).

timestep (`int` o `torch.Tensor`) : El índice del paso del predictor que acaba de completarse; el corrector se ejecuta en el siguiente punto de la cuadrícula `s`.

sample (`torch.LongTensor` de forma `(batch_size, block_length)`) : IDs de tokens del bloque actual para refinar.

generator (`torch.Generator`, *opcional*) : Generador de números aleatorios para el muestreo.

return_dict (`bool`) : Si se debe devolver un [DiscreteDDIMSchedulerOutput](/docs/diffusers/main/es/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMSchedulerOutput) o una tupla simple.

Ejecuta un barrido de corrector de Gibbs en el tiempo posterior al predictor `s`, siguiendo el predictor-corrector leave-one-out de https://huggingface.co/papers/2605.22765.

Los logits del modelo (recalculados en la `sample` actual) se convierten en el desruidador LOO, se forma la condicional de una coordenada `p_s(x^l | x^{-l}) = Cat(alpha_s * x0_loo + (1 - alpha_s) / K)`, se seleccionan las posiciones de `corrector_k` con menor confianza y se muestrea de nuevo en esas posiciones mientras el resto se mantiene fijo. El barrido preserva `p_s`, por lo que refina la muestra sin alterar su marginal y no requiere entrenamiento adicional.

## 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_discrete_ddim.py#L28)

**Parámetros:**

prev_sample (`torch.LongTensor` de forma `(batch_size, block_length)`) : Tokens de bloque actualizados tras el paso de desruido actual.

sampled_tokens (`torch.LongTensor` de forma `(batch_size, block_length)`) : IDs de tokens muestreados de los logits del modelo, es decir, los tokens limpios predichos `x0`.

sampled_probs (`torch.Tensor` de forma `(batch_size, block_length)`) : Probabilidades de los tokens muestreados.

pred_logits (`torch.Tensor` de forma `(batch_size, block_length, vocab_size)`) : Los logits del denoiser, transmitidos para la autocondición del siguiente paso.

Clase de salida para el programador DDIM discreto.