# LLaDA2

[LLaDA2](https://huggingface.co/collections/inclusionAI/llada21) adalah keluarga model bahasa difusi diskrit yang menghasilkan teks melalui penyempurnaan iteratif per blok. Alih-alih generasi token per token secara autoregresif, LLaDA2 dimulai dengan urutan yang sepenuhnya ter-mask dan secara progresif membuka mask token berdasarkan tingkat kepercayaan melalui beberapa langkah penyempurnaan.

## Penggunaan

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

## Callback

Callback dijalankan setelah setiap langkah penyempurnaan. Luluskan `callback_on_step_end_tensor_inputs` untuk memilih tensor mana yang disertakan dalam `callback_kwargs`. Dalam implementasi saat ini, `block_x` (jendela sekuens yang sedang disempurnakan) dan `transfer_index` (mask komitmen pengisian mask) disediakan; kembalikan `{"block_x": ...}` dari callback untuk mengganti jendela tersebut.

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

## Parameter yang direkomendasikan

Model LLaDA2.1 mendukung dua mode:

| Mode | `threshold` | `editing_threshold` | `max_post_steps` |
|------|-------------|---------------------|------------------|
| Kualitas | 0.7 | 0.5 | 16 |
| Kecepatan | 0.5 | `None` | 16 |

Lewati `editing_threshold=None`, `0.0`, atau nilai negatif untuk mematikan pengeditan pasca-masker.

Untuk model LLaDA2.0, nonaktifkan pengeditan dengan meneruskan `editing_threshold=None` atau `0.0`.

Untuk semua model: `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)
```

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

Pipeline untuk generasi teks difusi diskret bergaya LLaDA2 melalui penyempurnaan iteratif per blok.

Pipeline ini mempertahankan sekuens template yang diisi dengan `mask_token_id` dan menyempurnakannya dalam blok-blok. Pada setiap langkah penyempurnaan, pipeline ini mengambil sampel token kandidat untuk blok yang aktif dan mengunci sebagian kecil berdasarkan tingkat kepercayaan.

Model diharapkan menerima attention mask dan `position_ids`, serta mengembalikan logits dengan bentuk `[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)
```

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

**Parameter:**

prompt (`str` atau `List[str]`, *opsional*) : Teks prompt. Ketika `use_chat_template` adalah `True` (default) dan tokenizer dengan template chat tersedia, prompt dibungkus dalam pesan chat sebelum ditokenisasi.

messages (`List[Dict[str, str]]`, *opsional*) : Pesan chat untuk dienkod (mis. `[{"role": "user", "content": "Hello"}]`). Memiliki prioritas lebih tinggi daripada `prompt` jika diberikan. Memerlukan tokenizer dengan `apply_chat_template`.

input_ids (`torch.LongTensor`, *opsional*) : ID input yang sudah di-tokenisasi sebelumnya. Memiliki prioritas lebih tinggi daripada `prompt` dan `messages`.

attention_mask (`torch.LongTensor`, *opsional*) : Mask per token (1 untuk token prompt yang valid, 0 untuk padding) yang sesuai dengan bentuk `input_ids`. Hanya digunakan ketika `input_ids` diberikan. Ketika diabaikan (dan `input_ids` diberikan), semua posisi dianggap valid. Ketika menyusun input dari `prompt` / `messages`, mask dari tokenizer diteruskan secara otomatis.

use_chat_template (`bool`, defaultnya `True`) : Apakah prompt akan dibungkus dalam template chat.

add_generation_prompt (`bool`, defaultnya `True`) : Apakah akan menambahkan prompt generasi saat menggunakan template chat.

gen_length (`int`) : Jumlah token yang akan dihasilkan.

block_length (`int`, *opsional*) : Ukuran blok untuk penyempurnaan. Jika tidak disediakan, `block_length` yang dikonfigurasi pada scheduler akan digunakan.

num_inference_steps (`int`) : Jumlah langkah penyempurnaan per blok.

temperature (`float`) : Suhu sampling.

top_p (`float`, *opsional*) : Batasan pemotongan sampling nukleus.

top_k (`int`, *opsional*) : Batasan pemotongan sampling top-k.

sampling_method (`str`) : Metode sampling (`auto`, `greedy`, `multinomial`).

threshold (`float`) : Ambang kepercayaan untuk mengonfirmasi token.

editing_threshold (`float`, *opsional*) : Ambang kepercayaan untuk mengedit token yang sudah dikomit (non-mask). Jika bernilai positif, setelah semua token mask dalam blok terselesaikan, pipeline terus menyempurnakan: jika model memprediksi token yang berbeda dengan kepercayaan di atas ambang ini, token yang ada akan diganti. Atur ke `None`, `0.0`, atau nilai negatif untuk menonaktifkan pengeditan. Bawaan adalah `0.5`.

max_post_steps (`int`) : Jumlah maksimum iterasi penyempurnaan tambahan setelah semua token mask dalam blok terselesaikan. Hanya digunakan ketika `editing_threshold` diaktifkan. Nilai default adalah `16`.

minimal_topk (`int`) : Jumlah minimum token yang harus dikomit per langkah.

eos_early_stop (`bool`) : Apakah akan berhenti setelah meng-commit EOS dalam sebuah blok.

eos_token_id (`int`, *opsional*) : ID token EOS yang digunakan untuk penghentian dini.

mask_token_id (`int`, *opsional*) : ID token mask yang digunakan untuk template.

generator (`torch.Generator`, *opsional*) : RNG untuk sampling.

output_type (`str`, defaultnya `"text"`) : Format output. `"text"` mendekode urutan menjadi string (memerlukan tokenizer). `"seq"` hanya mengembalikan urutan ID token mentah.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [LLaDA2PipelineOutput](/docs/diffusers/main/id/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) alih-alih tuple.

callback_on_step_end (`Callable` atau `PipelineCallback`, *opsional*) : Callback yang dieksekusi setelah setiap langkah penyempurnaan dengan tanda tangan `callback_on_step_end(self, step: int, timestep: int, callback_kwargs: Dict)`.

callback_on_step_end_tensor_inputs (`List[str]`, *opsional*) : Kunci Tensor untuk diteruskan ke callback. Kunci yang diizinkan: `block_x`, `transfer_index`, `editing_transfer_index`, `sampled_tokens`, `sampled_probs`, `active_block`.

**Mengembalikan:** [LLaDA2PipelineOutput](/docs/diffusers/main/id/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) atau `tuple`

Jika `return_dict` adalah `True`, [LLaDA2PipelineOutput](/docs/diffusers/main/id/api/pipelines/llada2#diffusers.LLaDA2PipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah ID token yang dihasilkan (`torch.LongTensor`) dan elemen kedua adalah teks yang didekodekan (`list[str]`), atau `None` ketika `output_type` adalah `"seq"`.

Generate teks dengan penyempurnaan per blok.

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

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