# DiffusionGemma

## Ikhtisar

DiffusionGemma dirancang untuk mengurangi hambatan berurutan pada model bahasa kausal standar. Model ini menggunakan arsitektur encoder-decoder yang dioptimalkan secara khusus untuk kecepatan inferensi.

Encoder beroperasi dalam kapasitas prefill, memproses prompt awal dan menghasilkan KV cache. Decoder kemudian memanfaatkan bidirectional attention untuk memproses blok input (sebuah 'canvas') token, mengakses konteks yang di-cache melalui cross-attention.

Selama inferensi, DiffusionGemma memanfaatkan multi-canvas sampling. Alih-alih menghasilkan satu token pada satu waktu, model secara iteratif melakukan denoising pada blok token penuh menggunakan diffusion sampler. Setelah sebuah canvas sepenuhnya didenoise, canvas tersebut diproses oleh encoder dan ditambahkan ke KV cache, setelahnya model menghasilkan canvas berikutnya. Pendekatan block-autoregressive ini memfasilitasi generasi teks pada kecepatan yang lebih tinggi.

Anda dapat menemukan kartu model dan checkpoint [di sini](https://huggingface.co/google/diffusiongemma-26B-A4B-it). Anda dapat menemukan panduan visual untuk model [di sini](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma).

## Contoh penggunaan

Meskipun merupakan model difusi teks dan memiliki loop generasi khusus, sebagian besar antarmuka dibagikan dengan model lain yang dapat menghasilkan teks menggunakan [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate). Jika Anda menggunakan model `transformers` lain di aplikasi Anda, Anda seharusnya dapat langsung menggantinya dengan model ini.

> [!NOTE]
> DiffusionGemma tersedia di Transformers dan Diffusers, tetapi Diffusers adalah tempat utamanya. Diffusers memiliki set lengkap opsi penjadwalan, utilitas pipeline, dan fitur baru (penjadwal tambahan, kriteria penghentian, strategi sampling) hanya ditambahkan di sana. Lihat [DiffusionGemma](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma) untuk contoh penggunaan, dan buka [issue](https://github.com/huggingface/diffusers/issues) di Diffusers untuk bereksperimen dengan penjadwal yang berbeda atau meminta fitur. Implementasi di Transformers hanya menerima perbaikan bug tetapi tidak ada fitur baru.

### Hal-hal yang perlu diperhatikan

- DiffusionGemma tidak menerima `use_cache`. Ia selalu menggunakan KV cache;
- Dukungan untuk flag umum seperti `top_k` tidak akan tersedia pada hari rilis, tetapi akan ditambahkan seiring waktu jika kompatibel dengan difusi teks.

### Contoh dasar

```python
from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor

model = DiffusionGemmaForBlockDiffusion.from_pretrained(
    "google/diffusiongemma-26B-A4B-it", device_map="auto",
)
processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

messages = [
    {
        "role": "user", "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "What is shown in this image?"},
        ]
    },
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    # Add the following to enable thinking
    # enable_thinking=True,
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

# Set `cache_implementation="static"` in `generate` to trigger `torch.compile`.
# Compilation is much faster, after warming up!
output = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(output.sequences[0][input_len:], skip_special_tokens=True))
```

### Streaming

Seperti model lain yang dapat menghasilkan teks, Anda dapat mengatur kelas streamer untuk mengalirkan teks. Berbeda dengan model lain, DiffusionGemma menghasilkan draf perantara sebelum teks final. Anda dapat memvisualisasikannya dengan `TextDiffusionStreamer`

```python
from transformers import TextDiffusionStreamer

# (... copy from the example above, up to the `generate` call)
streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
model.generate(**inputs, max_new_tokens=256, streamer=streamer)
```

### Mengatur keluaran denoising awal

Model dilatih untuk menyempurnakan blok 256 token secara iteratif. Pada beberapa aplikasi, mungkin lebih menguntungkan untuk memberikan titik awal bagi decoder, alih-alih memulai dari token acak. Anda dapat menggunakan `decoder_input_ids`, yang tersedia di semua antarmuka model, untuk mengatur kanvas awal.

```py
initial_estimate = ... # a tensor with shape (bsz, 256)
model.generate(**inputs, max_new_tokens=256, decoder_input_ids=initial_estimate)
```

## DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]]

#### transformers.DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]]

```python
transformers.DiffusionGemmaTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 262144, hidden_size: int = 2304, intermediate_size: int = 9216, num_hidden_layers: int = 30, num_attention_heads: int = 8, num_key_value_heads: int = 4, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = 2, tie_word_embeddings: bool = True, rope_parameters: dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, sliding_window: int = 512, layer_types: list[str] | None = None, use_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = None, num_experts: int | None = None, top_k_experts: int | None = None, moe_intermediate_size: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L35)

**Parameter:**

vocab_size (`int`, *opsional*, defaultnya `262144`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `2304`) : Dimensi dari representasi tersembunyi.

intermediate_size (`int`, *opsional*, defaultnya `9216`) : Dimensi dari representasi MLP.

num_hidden_layers (`int`, *opsional*, defaultnya `30`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

num_key_value_heads (`int`, *opsional*, defaultnya `4`) : Ini adalah jumlah key_value heads yang harus digunakan untuk mengimplementasikan Grouped Query Attention. Jika `num_key_value_heads=num_attention_heads`, model akan menggunakan Multi Head Attention (MHA), jika `num_key_value_heads=1` model akan menggunakan Multi Query Attention (MQA), selain itu GQA yang digunakan. Saat mengonversi checkpoint multi-head menjadi checkpoint GQA, setiap group key dan value head harus dibangun dengan meanpooling semua head asli di dalam grup tersebut. Untuk detail lebih lanjut, lihat [paper ini](https://huggingface.co/papers/2305.13245). Jika tidak ditentukan, akan default ke `num_attention_heads`.

head_dim (`int`, *opsional*, defaultnya `256`) : Dimensi kepala perhatian. Jika None, nilainya akan menjadi hidden_size // num_attention_heads

hidden_activation (`str`, *opsional*, defaultnya `gelu_pytorch_tanh`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

max_position_embeddings (`int`, *opsional*, defaultnya `131072`) : Panjang maksimum urutan yang mungkin akan digunakan dengan model ini.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

rms_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi rms.

pad_token_id (`int`, *opsional*, defaultnya `0`) : ID token yang digunakan untuk padding dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `1`) : Token id yang digunakan untuk end-of-stream dalam kosakata.

bos_token_id (`int`, *opsional*, defaultnya `2`) : Token id yang digunakan untuk awal-stream dalam kosakata.

tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model.

rope_parameters (`dict`, *opsional*) : Kamus yang berisi parameter konfigurasi untuk embedding RoPE. Kamus ini harus berisi nilai untuk `rope_theta` dan secara opsional parameter yang digunakan untuk penskalaan jika Anda ingin menggunakan RoPE dengan `max_position_embeddings` yang lebih panjang.

attention_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention.

attention_dropout (`Union[int, float]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

sliding_window (`int`, *opsional*, defaultnya `512`) : Ukuran jendela untuk sliding window attention. Jika `None`, sliding window tidak diterapkan.

layer_types (`list[str]`, *opsional*) : Daftar yang secara eksplisit memetakan setiap indeks lapisan dengan tipe lapisannya. Jika tidak disediakan, daftar ini akan dibuat secara otomatis berdasarkan nilai konfigurasi.

use_bidirectional_attention (`str`, *opsional*) : Mengontrol perilaku perhatian bidireksional. Ketika diatur ke `"vision"`, token visual memperhatikan secara bidireksional sementara token teks menggunakan perhatian kausal. Ketika diatur ke `"all"`, semua token menggunakan perhatian bidireksional.

num_experts (`int`, *opsional*) : Jumlah pakar yang dirutekan di lapisan MoE.

top_k_experts (`int`, *opsional*) : Jumlah pakar yang diaktifkan per token di lapisan MoE.

moe_intermediate_size (`int`, *opsional*) : Ukuran (tersembunyi) antara dari jaringan feed-forward masing-masing ahli di lapisan MoE.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DiffusionGemmaModel. Kelas ini digunakan untuk membuat instans model Diffusion Gemma sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]]

#### transformers.DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]]

```python
transformers.DiffusionGemmaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: transformers.models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, initializer_range: float | None = 0.02, tie_word_embeddings: bool = True, canvas_length: int | None = 256)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L163)

**Parameter:**

text_config (`Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]]`, *opsional*) : Objek config atau dictionary dari text backbone.

vision_config (`Union[~configuration_utils.PreTrainedConfig, dict[str, Any]]`, *opsional*) : Objek config atau dictionary dari vision backbone.

boi_token_id (`int`, *opsional*, defaultnya 255999) : Indeks token awal gambar untuk membungkus prompt gambar.

eoi_token_id (`int`, *opsional*, defaultnya 258882) : Indeks token akhir gambar untuk membungkus prompt gambar.

image_token_id (`int`, *opsional*, defaultnya `258880`) : Indeks token gambar yang digunakan sebagai placeholder untuk gambar input.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model.

canvas_length (`int`, *opsional*, defaultnya 256) : Ukuran kanvas atau, dengan kata lain, panjang blok dalam block diffusion. Digunakan untuk menginisialisasi kanvas kosong.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DiffusionGemmaModel. Kelas ini digunakan untuk membuat instans model Diffusion Gemma sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

```python
>>> from transformers import (
>>>     DiffusionGemmaConfig,
>>>     DiffusionGemmaModel,
>>>     DiffusionGemmaTextConfig,
>>>     Gemma4VisionConfig,
>>> )

>>> # Initializing a DiffusionGemma Text config.
>>> text_config = DiffusionGemmaTextConfig()

>>> # Initializing a Gemma 4 vision config (DiffusionGemma uses Gemma 4's vision block).
>>> vision_config = Gemma4VisionConfig()

>>> # Initializing a DiffusionGemma text config
>>> configuration = DiffusionGemmaConfig(text_config, vision_config)

>>> # Initializing a model from the configuration
>>> model = DiffusionGemmaModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]]

#### transformers.DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]]

```python
transformers.DiffusionGemmaGenerationOutput(sequences: LongTensor, tokens_per_forward: int | None = None, past_key_values: transformers.cache_utils.Cache | None = None, logits: None = None, scores: None = None, hidden_states: None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L247)

**Parameter:**

sequences (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Urutan yang dihasilkan, termasuk prompt jika `input_ids` diberikan ke metode `generate`.

tokens_per_forward (`torch.LongTensor` dengan bentuk (`batch_size`)) : Jumlah token per forward dalam panggilan `generate` ini, untuk setiap anggota dalam batch. Ini sering digunakan sebagai metrik evaluasi sekunder untuk model difusi teks.

past_key_values (`Cache`) : `Cache` yang digunakan untuk generasi. Hal ini dapat diteruskan ke pemanggilan `generate` berikutnya untuk mempercepat proses generasi, terutama pada sesi multi-turn.

logits (`None`) : Tidak digunakan. Dipertahankan di antarmuka untuk kompatibilitas mundur.

scores (`None`) : Tidak digunakan. Dipertahankan di antarmuka untuk kompatibilitas mundur.

hidden_states (`None`) : Tidak digunakan. Dipertahankan di antarmuka untuk kompatibilitas mundur.

Kelas output untuk generasi DiffusionGemma.

## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

#### transformers.DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

```python
transformers.DiffusionGemmaGenerationMixin()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L543)

Kelas Mixin untuk generasi DiffusionGemma. Mengandung semua metode tingkat model.

#### generate[[transformers.DiffusionGemmaGenerationMixin.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, streamer: transformers.generation.streamers.BaseStreamer | None = None, generation_config: transformers.models.diffusion_gemma.generation_diffusion_gemma.DiffusionGemmaGenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L548)

**Parameter:**

input_ids (*torch.LongTensor* dengan bentuk *(batch_size, sequence_length)*, *opsional*) : Urutan yang digunakan sebagai prompt untuk generasi.

past_key_values ([Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache), *opsional*) : Objek Cache yang berisi nilai kunci masa lalu dan mask perhatian masa lalu untuk decoder. Jika diset, `input_ids` dan/atau `pixel_values` harus hanya sesuai dengan data yang tidak di-cache.

streamer (`BaseStreamer`, *opsional*) : Objek Streamer yang akan digunakan untuk streaming urutan yang dihasilkan. Token yang dihasilkan diteruskan melalui `streamer.put(token_ids)` dan streamer bertanggung jawab untuk pemrosesan lebih lanjut. Jika objek streamer memiliki metode `put_draft`, token dari langkah-langkah denoising akan dikirim ke sana.

**Argumen tambahan untuk pengguna lanjutan:**

generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationConfig), *opsional*) : Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi, menggantikan nilai bawaan model. Jika checkpoint model memiliki file `generation_config.json`, nilai bawaan model akan dimuat dari sana. Jika tidak, akan menjadi instance `DiffusionGemmaGenerationConfig` yang kosong. Sebagai pintasan tambahan, `**kwargs` yang cocok dengan atribut dalam `generation_config` akan menggantikan atribut tersebut.

logits_processor ([LogitsProcessorList](/docs/transformers/main/id/internal/generation_utils#transformers.LogitsProcessorList), *opsional*) : Prosesor logits kustom yang melengkapi prosesor logits bawaan yang dibangun dari argumen dan konfigurasi generasi, untuk diterapkan pada logits difusi. Jika disediakan, prosesor-prosesor ini akan menjadi yang pertama diterapkan. Fitur ini ditujukan untuk pengguna tingkat lanjut. Anda, misalnya, dapat melewatkan di sini prosesor logits yang umum digunakan dengan LLM AR.

stopping_criteria ([StoppingCriteriaList](/docs/transformers/main/id/internal/generation_utils#transformers.StoppingCriteriaList), *optional*) : Kriteria penghentian kustom yang melengkapi kriteria penghentian autoregresif blok bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika disediakan, kriteria ini akan diterapkan terlebih dahulu. Fitur ini ditujukan untuk pengguna tingkat lanjut. Anda, misalnya, dapat meneruskan di sini kriteria penghentian yang umum digunakan dengan LLM AR.

kwargs (`dict[str, Any]`, *opsional*) : Parametrisasi ad hoc untuk `generation_config` dan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsi `forward` dari model. Sebagai contoh, Anda dapat mengatur kanvas awal dengan `decoder_input_ids`.

**Mengembalikan:** `torch.LongTensor` atau [DiffusionGemmaGenerationOutput](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput)

- `torch.LongTensor`: teks yang dihasilkan dalam bentuk id.
- [DiffusionGemmaGenerationOutput](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput): sebuah instance `ModelOutput` yang berisi teks yang dihasilkan (`sequences`), serta output opsional lainnya.

Membuat teks menggunakan model difusi.

Ia berisi loop luar yang melakukan generasi autoregresif dari kanvas (blok token), dan loop

loop yang melakukan difusi pada setiap kanvas. Algoritma ini bekerja kurang lebih sebagai berikut:
```
1. Autoregressive canvas generation loop:
    a. Encode all previous tokens using the encoder, to get the KV cache.
    b. Prepare data for the new denoising loop
    c. For each denoising (diffusion) step:
        i.   Run the decoder, taking the current canvas, the encoder KV cache, and the self-conditioning logits
             (if available) as inputs.
        ii.  Select new canvas tokens from the output logits.
        iii. Apply the sampler acceptance and renoising logic.
        iv.  Update the diffusion stopping criteria.
        v.   Use the output logits as self-conditioning logits for the next step.
    d. Append the new denoised canvas to the sequence of generated tokens.
    e. Check if any autoregressive stopping criteria are met, and break the outer loop if all sequences have
       met them. Replaces generated tokens in finished sequences by pad.
    f. Prepare tensors for the next block
```

Contoh:

```python
>>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(
...     "google/diffusiongemma-26B-A4B-it", device_map="auto",
>>> )

>>> chat = [{"role": "user", "content": "Why is the sky blue?"},]
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")
>>> input_ids = processor.apply_chat_template(chat, tokenize=True, return_tensors="pt")

>>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
>>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer)
```

## DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]]

#### transformers.DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]]

```python
transformers.DiffusionGemmaGenerationConfig(**kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L55)

**Parameter yang mengontrol panjang output:**

max_new_tokens (`int`, *opsional*) : Jumlah maksimum token yang akan dihasilkan, mengabaikan jumlah token dalam prompt.

max_length (`int`, *opsional*) : Panjang maksimum dari urutan output. `max_new_tokens` direkomendasikan untuk mengontrol berapa banyak token yang dihasilkan model.

**Parameter difusi:**

max_denoising_steps (`int`) : Jumlah maksimum langkah denoising yang akan dilakukan.

sampler_config (`EntropyBoundSamplerConfig`) : Konfigurasi untuk sampler. Lihat [EntropyBoundSampler](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.EntropyBoundSampler) untuk mempelajari cara kerja sampler dalam model difusi teks.

t_min (`float`) : Suhu akhir dalam jadwal, yaitu pada langkah denoising terakhir. Lihat [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) untuk detail lebih lanjut.

t_max (`float`) : Suhu awal dalam jadwal, yaitu pada langkah denoising pertama. Lihat [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) untuk detail lebih lanjut.

stability_threshold (`int`) : Jumlah langkah di mana kanvas yang diterima harus sama untuk memicu kriteria penghentian. Lihat [StableAndConfidentStoppingCriteria](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) untuk detail lebih lanjut.

confidence_threshold (`float`) : Ambang batas untuk rata-rata entropi dari logits yang diskalakan suhu untuk memicu kriteria penghentian. Lihat [StableAndConfidentStoppingCriteria](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) untuk detail lebih lanjut.

**Parameter yang mengontrol cache:**

cache_implementation (`str`, *opsional*) : Nama kelas cache yang akan diinstansiasi di `generate`, untuk decoding yang lebih cepat. Nilai yang mungkin adalah:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/id/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/id/internal/generation_utils#transformers.QuantizedCache)  Jika tidak ada yang ditentukan, kami akan menggunakan cache default untuk model (yang sering kali adalah [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache)). Lihat [dokumentasi cache](https://huggingface.co/docs/transformers/en/kv_cache) kami untuk informasi lebih lanjut.

cache_config (`dict`, *opsional*, default ke `None`) : Argumen yang digunakan dalam kelas cache key-value dapat diteruskan ke `cache_config`.

**Token khusus yang dapat digunakan saat generasi:**

bos_token_id (`int`, *opsional*) : id dari token *awal-sekuens*.

pad_token_id (`int`, *opsional*) : id dari token *padding*.

eos_token_id (`Union[int, list[int]]`, *opsional*) : id dari token *end-of-sequence*. Secara opsional, gunakan daftar untuk mengatur beberapa token *end-of-sequence*.

Kelas GenerationConfig dengan parameterisasi yang dikustomisasi untuk [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate).

## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

#### transformers.EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

```python
transformers.EntropyBoundSamplerConfig(entropy_bound: float)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L320)

**Parameter:**

entropy_bound (`float`) : Batas entropi. Semakin tinggi nilai ini, semakin banyak token yang akan diterima. Lihat docstring dari [EntropyBoundSampler.accept_canvas()](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.EntropyBoundSampler.accept_canvas) untuk detail lebih lanjut tentang cara penerapannya.

Kelas konfigurasi untuk sampler batas entropi.

## EntropyBoundSampler[[transformers.EntropyBoundSampler]]

#### transformers.EntropyBoundSampler[[transformers.EntropyBoundSampler]]

```python
transformers.EntropyBoundSampler(config: EntropyBoundSamplerConfig, canvas_length: int, vocab_size: int, max_denoising_steps: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L343)

**Parameter:**

config (`EntropyBoundSamplerConfig`) : Konfigurasi dari sampler.

canvas_length (`int`) : Panjang kanvas.

vocab_size (`int`) : Ukuran dari kosakata.

max_denoising_steps (`int`) : Jumlah maksimum langkah denoising. (Tidak digunakan dalam sampler ini)

Kelas Sampler yang menginisialisasi kanvas dengan token acak, menerima token berdasarkan entropi tingkat token, dan melakukan renoising pada token yang tidak diterima.

Berikut adalah sketsa kasar tentang cara kerja loop sampler:
```
          +-----------------------+
          | Canvas initialization |
          | x_T ∈ U(V)            |
          +-----------+-----------+
                      |
                      v
           +----------+---------+       +---------------------+
+--------->| Current canvas x_t |------>| Denoiser canvas x_D |
|          +----------+---------+       +----------+----------+
|                      \                          /
|                       \                        /
|                        \   Acceptance logic   /
|                         v                    v
|                       +-------------------------+
| Stop if max           | Accepted canvas x_{t-1} |
| denosing steps        +------------+------------+      +-------------------+
| reached or                          \                  | New canvas ∈ U(V) |
| adaptive stopping                    \                 +---------+---------+
| triggers                              \    Renoising logic      /
|                                        v                       v
|                                       +-------------------------+
+---------------------------------------| Next canvas x_{t-1}     |
                                        +-------------------------+
```

#### accept_canvas[[transformers.EntropyBoundSampler.accept_canvas]]

```python
accept_canvas(current_canvas: LongTensor, denoiser_canvas: LongTensor, logits: Tensor, cur_step: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L406)

**Parameter:**

current_canvas (`torch.LongTensor`) : Kanvas saat ini.

denoiser_canvas (`torch.LongTensor`) : Kanvas yang diambil dari prediksi denoiser.

logits (`torch.Tensor`) : Logit dari denoiser.

cur_step (`int`) : Langkah saat ini.

**Mengembalikan:** `torch.LongTensor`

Kanvas yang diterima.

Menerima token dari denoiser berdasarkan batas entropi. Secara lebih konkret, proses sampling dilakukan dengan menerima k token dengan entropi terendah, sehingga

sum_i^k entropy_i - max(entropy_1, ..., entropy_k) <= entropy_bound,

di mana ruas kiri adalah batas atas dari informasi bersama (joint mutual information) antar token-token ini, sehingga sampler memilih k token yang kira-kira independen.

Awalnya diusulkan dalam https://arxiv.org/pdf/2505.24857

#### initialize_canvas[[transformers.EntropyBoundSampler.initialize_canvas]]

```python
initialize_canvas(batch_size: int, device: device)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L394)

Membuat dan mengembalikan kanvas baru dengan `canvas_length` token berisi nilai acak dari kosakata.

#### renoise_canvas[[transformers.EntropyBoundSampler.renoise_canvas]]

```python
renoise_canvas(accepted_canvas: LongTensor, cur_step: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L450)

**Parameter:**

accepted_canvas (`torch.LongTensor`) : Kanvas yang diterima.

cur_step (`int`) : Langkah saat ini. (Tidak digunakan dalam sampler ini)

**Mengembalikan:** `torch.LongTensor`

Kanvas yang dinoise ulang.

Menolak semua token yang tidak diterima.

## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

#### transformers.StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

```python
transformers.StableAndConfidentStoppingCriteria(stability_threshold: int, confidence_threshold: float)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L484)

**Parameter:**

stability_threshold (`int`) : Jumlah langkah di mana kanvas yang diterima harus sama untuk memicu kriteria penghentian.

confidence_threshold (`float`) : Ambang batas untuk rata-rata entropi dari logits yang diskalakan suhu untuk memicu kriteria penghentian.

Strategi penghentian adaptif yang menghentikan proses difusi ketika proses tersebut sudah yakin dan stabil. Secara lebih spesifik:
- Proses difusi stabil ketika kanvas yang diterima sama di sepanjang `stability_threshold` langkah.
- Proses difusi dianggap yakin ketika rata-rata entropi dari logits yang diproses berada di bawah `confidence_threshold`.

## LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

#### transformers.LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

```python
transformers.LinearTemperatureScheduleLogitsProcessor(t_min: float, t_max: float, max_denoising_steps: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L276)

**Parameter:**

t_min (`float`) : Suhu akhir dalam jadwal, yaitu pada langkah denoising terakhir.

t_max (`float`) : Suhu awal dalam jadwal, yaitu pada langkah denoising pertama.

max_denoising_steps (`int`) : Jumlah maksimum langkah denoising.

Logits processor yang menerapkan jadwal suhu linear ke logits. Ini mirip dengan `TemperatureLogitsWarper`, kecuali bahwa suhu adalah fungsi dari langkah saat ini.

Pada langkah n dari N, suhu t diberikan oleh t = t_min + ((t_max - t_min) * (n/N)).

## DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

#### transformers.DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

```python
transformers.DiffusionGemmaPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L817)

**Parameter:**

config ([PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.DiffusionGemmaPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Nilai mock untuk jalur bertitik (misalnya `torch.float32`): rantai akses atribut, panggilan berperilaku sebagai dekorator pass-through, `repr` adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar `type` polos (PEP 560 `__mro_entries__`), sehingga subclass asli tetap mempertahankan metaclass normal dan `inspect.signature` membaca `__init__` asli mereka, bukan milik mock.

## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

#### transformers.DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

```python
transformers.DiffusionGemmaModel(config: DiffusionGemmaConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1452)

**Parameter:**

config ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Diffusion Gemma polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.DiffusionGemmaModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1494)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : ID token yang tidak di-cache untuk prompt yang akan dikodekan sebagai konteks untuk kanvas.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)` atau `dict`, *opsional*) : Mask untuk token input.

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor` dengan bentuk `(batch_size, canvas_length)`, *opsional*) : ID token untuk kanvas yang akan disempurnakan.

self_conditioning_logits (`torch.Tensor` dengan bentuk `(batch_size, canvas_length, vocab_size)`, *opsional*) : Logit self-conditioning dari langkah denoising sebelumnya, digunakan untuk menghitung embedding self-conditioning.

self_conditioning_mask (`torch.BoolTensor` dengan bentuk `(batch_size,)`, *opsional*) : Mask per-contoh untuk `self_conditioning_logits`: contoh yang diset ke `False` akan menerima sinyal self-conditioning yang dinolkan, seolah-olah tidak ada logits yang diberikan untuk mereka. Berguna untuk pelatihan, di mana self-conditioning diaktifkan per contoh dengan probabilitas tertentu.

decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length+canvas_length)` atau `dict`, *opsional*) : Attention mask untuk KV cache decoder. Digunakan untuk menentukan entri KV cache encoder yang di-padded/tidak terisi.

decoder_position_ids (`torch.LongTensor` dengan bentuk `(batch_size, canvas_length)`, *opsional*) : ID posisi untuk token di kanvas.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opsional*) : Dict di mana kuncinya adalah modalitas yang didukung dan nilainya adalah output terenkod untuk modalitas tersebut. Setiap output terenkod adalah tuple yang terdiri dari (`pooler_output`, *opsional*: `last_hidden_states`, *opsional*: `hidden_states`, *opsional*: `attentions`) `pooler_output` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah rangkaian fitur multimodal dari encoder yang digabungkan ke dalam embedding teks.

**Mengembalikan:** `DiffusionGemmaModelOutputWithPast` atau `tuple(torch.Tensor)`

A `DiffusionGemmaModelOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) dan input.

Metode forward dari [DiffusionGemmaModel](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden state pada keluaran lapisan terakhir encoder. Hanya diset ketika `input_ids` diberikan, misalnya untuk menghitung loss autoregresif pada encoder selama pelatihan.

## DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

#### transformers.DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

```python
transformers.DiffusionGemmaEncoderModel(config: DiffusionGemmaConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L995)

**Parameter:**

config ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model encoder DiffusionGemma yang terdiri dari tulang punggung visual dan model bahasa, *tanpa* kepala pemodelan bahasa. Model ini sangat mirip dengan Gemma4Model, kecuali bahwa model ini tidak mendukung input audio atau video, dan selalu mengasumsikan jalur kode MoE di lapisan internal.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.DiffusionGemmaEncoderModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, image_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1060)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan `image_processor_class`. Lihat `image_processor_class.__call__` untuk detailnya ([Gemma4Processor](/docs/transformers/main/id/model_doc/gemma4#transformers.Gemma4Processor) menggunakan `image_processor_class` untuk memproses gambar).

attention_mask (`Union[torch.Tensor, dict]` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak dimask**, - 0 untuk token yang **dimask**.  [Apa itu attention mask?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

mm_token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token urutan masukan yang sesuai dengan setiap modalitas. Misalnya teks (0), gambar (1), video (2). ID jenis token multimodal dapat diperoleh menggunakan [AutoProcessor](/docs/transformers/main/id/model_doc/auto#transformers.AutoProcessor). Lihat [ProcessorMixin.__call__()](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin.__call__) untuk detailnya.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

image_position_ids (`torch.LongTensor` dengan bentuk `(batch_size, max_patches, 2)`, *opsional*) : koordinat posisi patch 2D dari image processor, dengan `(-1, -1)` menunjukkan padding. Diteruskan ke vision encoder untuk perhitungan positional embedding.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opsional*) : Dict di mana kuncinya adalah modalitas yang didukung dan nilainya adalah output terenkod untuk modalitas tersebut. Setiap output terenkod adalah tuple yang terdiri dari (`pooler_output`, *opsional*: `last_hidden_states`, *opsional*: `hidden_states`, *opsional*: `attentions`) `pooler_output` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah rangkaian fitur multimodal dari encoder yang digabungkan ke dalam embedding teks.

**Mengembalikan:** [BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) dan input.

Metode forward dari [DiffusionGemmaEncoderModel](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

#### transformers.DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

```python
transformers.DiffusionGemmaEncoderTextModel(config: DiffusionGemmaTextConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L881)

#### forward[[transformers.DiffusionGemmaEncoderTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L909)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

attention_mask (`Union[torch.Tensor, dict]` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak dimask**, - 0 untuk token yang **dimask**.  [Apa itu attention mask?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

**Mengembalikan:** [BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) dan input.

Metode forward dari [DiffusionGemmaEncoderTextModel](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderTextModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

#### transformers.DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

```python
transformers.DiffusionGemmaDecoderModel(config: DiffusionGemmaConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1175)

Model decoder untuk DiffusionGemma.

Memproses token canvas dengan self-attention bidireksional dan cross-attention ke KV cache encoder. Dekoder membaca tetapi tidak memperbarui KV cache. Selain perbedaan tersebut, model ini mirip dengan `DiffusionGemmaEncoderTextModel`, dan keduanya berbagi semua bobot yang mereka miliki bersama.

#### forward[[transformers.DiffusionGemmaDecoderModel.forward]]

```python
forward(decoder_input_ids: LongTensor, past_key_values: transformers.cache_utils.Cache | None = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1217)

**Parameter:**

decoder_input_ids (`torch.LongTensor` dengan bentuk `(batch_size, canvas_length)`) : ID token untuk kanvas yang akan disempurnakan.

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

self_conditioning_logits (`torch.Tensor` dengan bentuk `(batch_size, canvas_length, vocab_size)`, *opsional*) : Logit self-conditioning dari langkah denoising sebelumnya, digunakan untuk menghitung embedding self-conditioning.

self_conditioning_mask (`torch.BoolTensor` dengan bentuk `(batch_size,)`, *opsional*) : Mask per-contoh untuk `self_conditioning_logits`: contoh yang diset ke `False` akan menerima sinyal self-conditioning yang dinolkan, seolah-olah tidak ada logits yang diberikan untuk mereka. Berguna untuk pelatihan, di mana self-conditioning diaktifkan per contoh dengan probabilitas tertentu.

decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length+canvas_length)` atau `dict`, *opsional*) : Attention mask untuk KV cache decoder. Digunakan untuk menentukan entri KV cache encoder yang di-padded/tidak terisi.

decoder_position_ids (`torch.LongTensor` dengan bentuk `(batch_size, canvas_length)`, *opsional*) : ID posisi untuk token di kanvas.

**Mengembalikan:** [BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) dan input.

Metode forward dari [DiffusionGemmaDecoderModel](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaDecoderModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

#### transformers.DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

```python
transformers.DiffusionGemmaForBlockDiffusion(config: DiffusionGemmaConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1579)

Model DiffusionGemma untuk block diffusion. Model ini memanggil `DiffusionGemmaModel` untuk memperoleh hidden states dari input canvas, dengan kondisi berupa prompt KV cache. Menggunakan LM Head dan self-conditioning blocks, model ini mengonversi hidden states tersebut menjadi logits untuk mensampel canvas berikutnya, serta self-conditioning embeddings untuk langkah block diffusion berikutnya.

#### forward[[transformers.DiffusionGemmaForBlockDiffusion.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1601)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : ID token yang tidak di-cache untuk prompt yang akan dikodekan sebagai konteks untuk kanvas.

attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)` atau `dict`, *opsional*) : Mask untuk token input.

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor` dengan bentuk `(batch_size, canvas_length)`, *opsional*) : ID token untuk kanvas yang akan disempurnakan.

self_conditioning_logits (`torch.Tensor` dengan bentuk `(batch_size, canvas_length, vocab_size)`, *opsional*) : Logit self-conditioning dari langkah denoising sebelumnya, digunakan untuk menghitung embedding self-conditioning.

self_conditioning_mask (`torch.BoolTensor` dengan bentuk `(batch_size,)`, *opsional*) : Mask per-contoh untuk `self_conditioning_logits`: contoh yang diset ke `False` akan menerima sinyal self-conditioning yang dinolkan, seolah-olah tidak ada logits yang diberikan untuk mereka. Berguna untuk pelatihan, di mana self-conditioning diaktifkan per contoh dengan probabilitas tertentu.

decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length+canvas_length)` atau `dict`, *opsional*) : Attention mask untuk KV cache decoder. Digunakan untuk menentukan entri KV cache encoder yang di-padded/tidak terisi.

decoder_position_ids (`torch.LongTensor` dengan bentuk `(batch_size, canvas_length)`, *opsional*) : ID posisi untuk token di kanvas.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opsional*) : Dict di mana kuncinya adalah modalitas yang didukung dan nilainya adalah output terenkod untuk modalitas tersebut. Setiap output terenkod adalah tuple yang terdiri dari (`pooler_output`, *opsional*: `last_hidden_states`, *opsional*: `hidden_states`, *opsional*: `attentions`) `pooler_output` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah rangkaian fitur multimodal dari encoder yang digabungkan ke dalam embedding teks.

**Mengembalikan:** `DiffusionGemmaBlockDiffusionOutputWithPast` atau `tuple(torch.Tensor)`

`DiffusionGemmaBlockDiffusionOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DiffusionGemmaConfig](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) dan input.

Metode forward dari [DiffusionGemmaForBlockDiffusion](/docs/transformers/main/id/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*) -- Loss pemodelan bahasa.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, canvas_length, config.text_config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden state pada keluaran lapisan terakhir encoder. Hanya diset ketika `input_ids` diberikan, misalnya untuk menghitung loss autoregresif pada encoder selama pelatihan.

Contoh:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained("google/diffusiongemma-26B-A4B-it")
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```