# LLaDA2

[LLaDA2](https://huggingface.co/collections/inclusionAI/llada21) es una familia de modelos de lenguaje de difusión discreta que generan texto mediante refinamiento iterativo por bloques. En lugar de la generación autoregresiva token a token, LLaDA2 comienza con una secuencia completamente enmascarada y desmascara progresivamente los tokens según su confianza a lo largo de múltiples pasos de refinamiento.

## Uso

```py
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

from diffusers import BlockRefinementScheduler, LLaDA2Pipeline

model_id = "inclusionAI/LLaDA2.1-mini"
model = AutoModelForCausalLM.from_pretrained(
    model_id, trust_remote_code=True, dtype=torch.bfloat16, device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
scheduler = BlockRefinementScheduler()

pipe = LLaDA2Pipeline(model=model, scheduler=scheduler, tokenizer=tokenizer)
output = pipe(
    prompt="Write a short poem about the ocean.",
    gen_length=256,
    block_length=32,
    num_inference_steps=32,
    threshold=0.7,
    editing_threshold=0.5,
    max_post_steps=16,
    temperature=0.0,
)
print(output.texts[0])
```

## Callbacks

Los callbacks se ejecutan después de cada paso de refinamiento. Pasa `callback_on_step_end_tensor_inputs` para seleccionar qué tensores se incluyen en `callback_kwargs`. En la implementación actual, se proporcionan `block_x` (la ventana de secuencia que se está refinando) y `transfer_index` (máscara de compromiso para rellenar máscaras); devuelve `{"block_x": ...}` desde el callback para reemplazar la ventana.

```py
def on_step_end(pipe, step, timestep, callback_kwargs):
    block_x = callback_kwargs["block_x"]
    # Inspect or modify `block_x` here.
    return {"block_x": block_x}

out = pipe(
    prompt="Write a short poem.",
    callback_on_step_end=on_step_end,
    callback_on_step_end_tensor_inputs=["block_x"],
)
```

## Parámetros recomendados

Los modelos LLaDA2.1 admiten dos modos:

| Modo | `threshold` | `editing_threshold` | `max_post_steps` |
|------|-------------|---------------------|------------------|
| Calidad | 0.7 | 0.5 | 16 |
| Velocidad | 0.5 | `None` | 16 |

Pasa `editing_threshold=None`, `0.0` o un valor negativo para desactivar la edición posterior a la máscara.

Para los modelos LLaDA2.0, desactive la edición pasando `editing_threshold=None` o `0.0`.

Para todos los modelos: `block_length=32`, `temperature=0.0`, `num_inference_steps=32`.

## LLaDA2Pipeline[[diffusers.LLaDA2Pipeline]]

#### diffusers.LLaDA2Pipeline[[diffusers.LLaDA2Pipeline]]

```python
diffusers.LLaDA2Pipeline(model: Any, scheduler: BlockRefinementScheduler, tokenizer: Any | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/llada2/pipeline_llada2.py#L59)

Pipeline para la generación de texto mediante difusión discreta de estilo LLaDA2, a través de refinamiento iterativo por bloques.

Este pipeline mantiene una secuencia de plantilla rellena con un `mask_token_id` y la refina en bloques. En cada paso de refinamiento, muestrea tokens candidatos para el bloque activo y confirma un subconjunto en función de la confianza.

Se espera que el modelo acepte una máscara de atención y `position_ids`, y que devuelva logits de forma `[batch, seq, vocab_size]`.

#### __call__[[diffusers.LLaDA2Pipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, messages: list[dict[str, str]] | None = None, input_ids: torch.LongTensor | None = None, attention_mask: torch.LongTensor | None = None, use_chat_template: bool = True, add_generation_prompt: bool = True, gen_length: int = 2048, block_length: int | None = None, num_inference_steps: int = 32, temperature: float = 0.0, top_p: float | None = None, top_k: int | None = None, sampling_method: str = 'multinomial', threshold: float = 0.7, editing_threshold: float | None = 0.5, max_post_steps: int = 16, minimal_topk: int = 1, eos_early_stop: bool = True, eos_token_id: int | None = None, mask_token_id: int | None = None, generator: torch.Generator | None = None, output_type: str = 'text', return_dict: bool = True, callback_on_step_end: Callable[[int, int, dict], None] | PipelineCallback | MultiPipelineCallbacks | None = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/llada2/pipeline_llada2.py#L242)

**Parámetros:**

prompt (`str` o `List[str]`, *opcional*) : Texto del prompt. Cuando `use_chat_template` es `True` (valor predeterminado) y hay disponible un tokenizador con una plantilla de chat, el prompt se envuelve en un mensaje de chat antes de la tokenización.

messages (`List[Dict[str, str]]`, *opcional*) : Mensajes de chat para codificar (p. ej. `[{"role": "user", "content": "Hello"}]`). Tiene prioridad sobre `prompt` cuando se proporciona. Requiere un tokenizer con `apply_chat_template`.

input_ids (`torch.LongTensor`, *opcional*) : IDs de entrada pretokenizados. Tiene prioridad sobre `prompt` y `messages`.

attention_mask (`torch.LongTensor`, *opcional*) : Máscara por token (1 para tokens de prompt válidos, 0 para relleno) que coincide con la forma de `input_ids`. Solo se utiliza cuando se proporciona `input_ids`. Si se omite (y se da `input_ids`), todas las posiciones se tratan como válidas. Al construir las entradas a partir de `prompt` / `messages`, la máscara del tokenizador se transmite automáticamente.

use_chat_template (`bool`, por defecto `True`) : Si se debe envolver el prompt en una plantilla de chat.

add_generation_prompt (`bool`, por defecto `True`) : Si se debe añadir el prompt de generación al usar plantillas de chat.

gen_length (`int`) : Número de tokens a generar.

block_length (`int`, *opcional*) : Tamaño de bloque para el refinamiento. Si no se proporciona, se utiliza el `block_length` configurado del programador.

num_inference_steps (`int`) : Número de pasos de refinamiento por bloque.

temperature (`float`) : Temperatura de muestreo.

top_p (`float`, *opcional*) : Corte de muestreo por núcleo.

top_k (`int`, *opcional*) : Corte de muestreo Top-k.

sampling_method (`str`) : Método de muestreo (`auto`, `greedy`, `multinomial`).

threshold (`float`) : Umbral de confianza para confirmar los tokens.

editing_threshold (`float`, *opcional*) : Umbral de confianza para editar tokens ya comprometidos (no máscara). Cuando es positivo, una vez que todos los tokens de máscara de un bloque se han resuelto, el pipeline continúa refinando: si el modelo predice un token diferente con una confianza superior a este umbral, el token existente se reemplaza. Establezca `None`, `0.0` o un valor negativo para deshabilitar la edición. El valor predeterminado es `0.5`.

max_post_steps (`int`) : Número máximo de iteraciones adicionales de refinamiento después de que todos los tokens de máscara de un bloque se hayan resuelto. Solo se utiliza cuando `editing_threshold` está habilitado. El valor predeterminado es `16`.

minimal_topk (`int`) : Número mínimo de tokens que se deben confirmar en cada paso.

eos_early_stop (`bool`) : Si se debe detener después de confirmar el EOS en un bloque.

eos_token_id (`int`, *opcional*) : ID del token EOS a utilizar para la detención anticipada.

mask_token_id (`int`, *opcional*) : ID del token de máscara a utilizar para la plantilla.

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

output_type (`str`, por defecto `"text"`) : Formato de salida. `"text"` decodifica las secuencias en cadenas de texto (requiere un tokenizador). `"seq"` devuelve únicamente las secuencias de ID de tokens crudos.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un [LLaDA2PipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) en lugar de una tupla.

callback_on_step_end (`Callable` o `PipelineCallback`, *opcional*) : Callback ejecutado después de cada paso de refinamiento con la firma `callback_on_step_end(self, step: int, timestep: int, callback_kwargs: Dict)`.

callback_on_step_end_tensor_inputs (`List[str]`, *opcional*) : Claves de tensor para pasar al callback. Claves permitidas: `block_x`, `transfer_index`, `editing_transfer_index`, `sampled_tokens`, `sampled_probs`, `active_block`.

**Devuelve:** [LLaDA2PipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [LLaDA2PipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento son los IDs de los tokens generados (`torch.LongTensor`) y el segundo elemento son los textos decodificados (`list[str]`), o `None` cuando `output_type` es `"seq"`.

Generar texto con refinamiento por bloques.

Ejemplos:
```python
>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> from diffusers import BlockRefinementScheduler, LLaDA2Pipeline

>>> model_id = "inclusionAI/LLaDA2.1-mini"
>>> model = AutoModelForCausalLM.from_pretrained(
...     model_id, trust_remote_code=True, dtype=torch.bfloat16, device_map="auto"
... )
>>> tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
>>> scheduler = BlockRefinementScheduler()

>>> pipe = LLaDA2Pipeline(model=model, scheduler=scheduler, tokenizer=tokenizer)
>>> output = pipe(prompt="What is the meaning of life?", gen_length=256)
>>> print(output.texts[0])
```

## LLaDA2PipelineOutput[[diffusers.LLaDA2PipelineOutput]]

#### diffusers.LLaDA2PipelineOutput[[diffusers.LLaDA2PipelineOutput]]

```python
diffusers.LLaDA2PipelineOutput(sequences: torch.LongTensor, texts: list[str] | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/llada2/pipeline_llada2.py#L54)