# LLaDA2

[LLaDA2](https://huggingface.co/collections/inclusionAI/llada21) est une famille de modèles de langage de diffusion discrète qui génèrent du texte par raffinement itératif par blocs. Plutôt que d’utiliser une génération auto-régressive token par token, LLaDA2 démarre avec une séquence entièrement masquée et démasque progressivement les tokens selon leur confiance au fil de plusieurs étapes de raffinement.

## Utilisation

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

Les callbacks s'exécutent après chaque étape de raffinement. Passez `callback_on_step_end_tensor_inputs` pour sélectionner les tenseurs inclus dans `callback_kwargs`. Dans l'implémentation actuelle, `block_x` (la fenêtre de séquence en cours de raffinement) et `transfer_index` (masque de commit de remplissage de masque) sont fournis ; renvoyez `{"block_x": ...}` depuis le callback pour remplacer la fenêtre.

```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"],
)
```

## Paramètres recommandés

Les modèles LLaDA2.1 prennent en charge deux modes :

| Mode | `threshold` | `editing_threshold` | `max_post_steps` |
|------|-------------|---------------------|------------------|
| Qualité | 0.7 | 0.5 | 16 |
| Vitesse | 0.5 | `None` | 16 |

Passez `editing_threshold=None`, `0.0` ou une valeur négative pour désactiver l'édition post-masque.

Pour les modèles LLaDA2.0, désactivez l'édition en passant `editing_threshold=None` ou `0.0`.

Pour tous les modèles : `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)
```

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

Pipeline pour la génération de texte par diffusion discrète de type LLaDA2 via raffinement itératif par blocs.

Ce pipeline maintient une séquence de modèle remplie de `mask_token_id` et l'affine par blocs. À chaque étape d'affinage, il échantillonne des jetons candidats pour le bloc actif et en valide un sous-ensemble en fonction de la confiance.

Le modèle est censé accepter un masque d'attention et `position_ids`, et renvoyer des logits de forme `[batch, seq, vocab_size]`.

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

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

**Paramètres :**

prompt (`str` ou `List[str]`, *facultatif*) : Texte du prompt. Lorsque `use_chat_template` est `True` (par défaut) et qu'un tokenizer avec un modèle de chat est disponible, le prompt est encapsulé dans un message de chat avant la tokenisation.

messages (`List[Dict[str, str]]`, *facultatif*) : Messages de chat à encoder (par ex. `[{"role": "user", "content": "Hello"}]`). Prend le pas sur `prompt` lorsqu'il est fourni. Nécessite un tokenizer avec `apply_chat_template`.

input_ids (`torch.LongTensor`, *facultatif*) : Identifiants d'entrée pré-tokenisés. Prend le pas sur `prompt` et `messages`.

attention_mask (`torch.LongTensor`, *facultatif*) : Masque par jeton (1 pour les jetons de prompt valides, 0 pour le bourrage) correspondant à la forme de `input_ids`. Utilisé uniquement lorsque `input_ids` est fourni. S'il est omis (et que `input_ids` est donné), toutes les positions sont considérées comme valides. Lors de la construction des entrées à partir de `prompt` / `messages`, le masque du tokeniseur est transmis automatiquement.

use_chat_template (`bool`, par défaut `True`) : Indique s'il faut envelopper le prompt dans un modèle de chat.

add_generation_prompt (`bool`, par défaut `True`) : Indique s'il faut ajouter le prompt de génération lors de l'utilisation de modèles de discussion.

gen_length (`int`) : Nombre de jetons à générer.

block_length (`int`, *facultatif*) : Taille de bloc pour le raffinement. Si non fourni, la valeur de `block_length` configurée dans le planificateur est utilisée.

num_inference_steps (`int`) : Nombre d'étapes de raffinement par bloc.

temperature (`float`) : Température d'échantillonnage.

top_p (`float`, *facultatif*) : Seuil d'échantillonnage par noyau.

top_k (`int`, *facultatif*) : Seuil d'échantillonnage Top-k.

sampling_method (`str`) : Méthode d'échantillonnage (`auto`, `greedy`, `multinomial`).

threshold (`float`) : Seuil de confiance pour valider les jetons.

editing_threshold (`float`, *facultatif*) : Seuil de confiance pour la modification des jetons déjà validés (hors masque). S'il est positif, une fois que tous les jetons masque d'un bloc sont résolus, le pipeline continue de raffiner : si le modèle prédit un jeton différent avec une confiance supérieure à ce seuil, le jeton existant est remplacé. Définissez la valeur sur `None`, `0.0` ou une valeur négative pour désactiver la modification. La valeur par défaut est `0.5`.

max_post_steps (`int`) : Nombre maximal d'itérations de raffinement supplémentaires après la résolution de tous les jetons de masque d'un bloc. Utilisé uniquement lorsque `editing_threshold` est activé. Valeur par défaut : `16`.

minimal_topk (`int`) : Nombre minimal de jetons à valider à chaque étape.

eos_early_stop (`bool`) : Indique s'il faut s'arrêter après l'engagement de l'EOS dans un bloc.

eos_token_id (`int`, *facultatif*) : ID du jeton EOS à utiliser pour l'arrêt anticipé.

mask_token_id (`int`, *facultatif*) : ID du jeton de masque à utiliser pour le modèle.

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

output_type (`str`, par défaut `"text"`) : Format de sortie. `"text"` décode les séquences en chaînes de caractères (nécessite un tokenizer). `"seq"` renvoie uniquement les séquences brutes d'identifiants de jetons.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [LLaDA2PipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) au lieu d'un tuple.

callback_on_step_end (`Callable` ou `PipelineCallback`, *facultatif*) : Callback exécuté après chaque étape de raffinement avec la signature `callback_on_step_end(self, step: int, timestep: int, callback_kwargs: Dict)`.

callback_on_step_end_tensor_inputs (`List[str]`, *facultatif*) : Clés de tenseurs à passer au rappel. Clés autorisées : `block_x`, `transfer_index`, `editing_transfer_index`, `sampled_tokens`, `sampled_probs`, `active_block`.

**Retourne :** [LLaDA2PipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) ou `tuple`

Si `return_dict` est `True`, [LLaDA2PipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) est retourné, sinon un `tuple` est retourné dont le premier élément est les identifiants de jetons générés (`torch.LongTensor`) et le deuxième élément est les textes décodés (`list[str]`), ou `None` lorsque `output_type` est `"seq"`.

Générer du texte avec une raffinement par blocs.

Exemples :
```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)
```

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