# DiffusionGemma

## 概要

DiffusionGemmaは、標準的な因果言語モデルの逐次処理によるボトルネックを軽減するように設計されています。推論速度に特化して最適化されたエンコーダー・デコーダーアーキテクチャを採用しています。

エンコーダーはプリフィルの役割で動作し、初期プロンプトを処理してKVキャッシュを生成します。その後、デコーダーは双方向アテンションを利用してトークンの入力ブロック（「キャンバス」）を処理し、クロスアテンションを介してキャッシュされたコンテキストにアクセスします。

推論時、DiffusionGemmaはマルチキャンバスサンプリングを活用します。トークンを1つずつ生成するのではなく、モデルは拡散サンプラーを使用してトークンの完全なブロックを反復的にノイズ除去します。キャンバスが完全にノイズ除去されると、エンコーダーによって処理されKVキャッシュに追加され、その後モデルは次のキャンバスを生成します。このブロック自己回帰アプローチにより、より高速なテキスト生成が可能になります。

モデルカードとチェックポイントは[こちら](https://huggingface.co/google/diffusiongemma-26B-A4B-it)で確認できます。モデルのビジュアルガイドは[こちら](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma)にあります。

## 使用例

テキスト拡散モデルであり独自の生成ループを持つものの、インターフェースの大部分は、[DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate) でテキストを生成できる他のモデルと共通しています。アプリで他の `transformers` モデルを使用している場合、このモデルに直接置き換えることができるはずです。

> [!NOTE]
> DiffusionGemma は [Transformers](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma) と [Diffusers](https://github.com/huggingface/diffusers/issues) の両方で利用可能ですが、主な利用先は Diffusers です。Diffusers にはスケジューリングのオプション、パイプラインユーティリティ、および新機能（追加のスケジューラー、停止条件、サンプリング戦略）がすべて揃っており、これらの新機能は Diffusers にのみ追加されます。使用例については DiffusionGemma を参照してください。異なるスケジューラーでの実験や機能の要望がある場合は、Diffusers に issue を作成してください。Transformers での実装にはバグ修正のみが反映され、新機能は追加されません。

### 一般的な注意点

- DiffusionGemma は `use_cache` を受け付けません。常に KV キャッシュを使用します。
- `top_k` などの一般的なフラグへのサポートはリリース時点では利用できませんが、テキスト拡散と互換性がある場合、今後随時追加される予定です。

### 基本的な例

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

### ストリーミング

テキストを生成できる他のモデルと同様に、ストリーマークラスを設定してテキストをストリーミングできます。他のモデルと異なり、DiffusionGemmaは最終テキストの前に中間ドラフトを生成します。`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)
```

### デノイジング出力の初期値を設定する

モデルは、256トークンのブロックを反復的に洗練するように学習されています。一部のアプリケーションでは、ランダムなトークンから始めるのではなく、デコーダーに開始点を与えることが有益になる場合があります。すべてのモデルインターフェースで利用可能な`decoder_input_ids`を使用して、開始キャンバスを設定できます。

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

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

**パラメータ:**

vocab_size (`int`、*任意*、デフォルトは `262144`) : モデルの語彙サイズ。`input_ids` で表すことができるトークンの種類数を定義します。

hidden_size (`int`、*任意*、デフォルトは`2304`) : 隠れ表現の次元数。

intermediate_size (`int`, *任意*, デフォルトは `9216`) : MLP 表現の次元数。

num_hidden_layers (`int`、*任意*、デフォルトは`30`) : Transformer デコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

num_key_value_heads (`int`, *optional*, デフォルトは `4`) : Grouped Query Attention を実装するために使用する key_value ヘッドの数です。`num_key_value_heads=num_attention_heads` の場合、モデルは Multi Head Attention (MHA) を使用し、`num_key_value_heads=1` の場合は Multi Query Attention (MQA) を使用し、それ以外の場合は GQA が使用されます。マルチヘッドのチェックポイントを GQA チェックポイントに変換する際は、各グループの key ヘッドと value ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](https://huggingface.co/papers/2305.13245)を参照してください。指定されない場合、デフォルトで `num_attention_heads` が使用されます。

head_dim (`int`、*任意*、デフォルトは`256`) : アテンションヘッドの次元です。None の場合、hidden_size // num_attention_heads がデフォルトとして使用されます。

hidden_activation (`str`、*任意*、デフォルトは `gelu_pytorch_tanh`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"` など。

max_position_embeddings (`int`、*任意*、デフォルトは `131072`) : このモデルが使用される可能性のある最大シーケンス長です。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

rms_norm_eps (`float`、*任意*、デフォルトは`1e-06`) : rms 正規化レイヤーで使用する epsilon。

pad_token_id (`int`, *任意*, デフォルトは `0`) : 語彙内でパディングに使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは `1`) : 語彙内でストリーム終了に使用されるトークン ID。

bos_token_id (`int`、*任意*、デフォルトは`2`) : 語彙内でストリームの開始に使用されるトークン ID。

tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。

rope_parameters (`dict`, *任意*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれており、より長い `max_position_embeddings` で RoPE を使用する場合にスケーリングに使用されるパラメータが任意で含まれます。

attention_bias (`bool`、*任意*、デフォルトは`False`) : セルフアテンションにおけるクエリ、キー、バリュー、出力の投影層でバイアスを使用するかどうか。

attention_dropout (`Union[int, float]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。

sliding_window (`int`、*任意*、デフォルトは`512`) : スライディングウィンドウアテンションのウィンドウサイズ。`None`の場合、スライディングウィンドウは適用されません。

layer_types (`list[str]`、*任意*) : 各レイヤーのインデックスとそのレイヤータイプを明示的にマッピングするリストです。指定しない場合、config の値に基づいて自動的に生成されます。

use_bidirectional_attention (`str`, *任意*) : 双方向アテンションの動作を制御します。`"vision"`に設定すると、ビジョントークンは双方向にアテンションを行い、テキストトークンは因果アテンションを使用します。`"all"`に設定すると、すべてのトークンが双方向アテンションを使用します。

num_experts (`int`, *任意*) : MoE層におけるルーティング対象のエクスパートの数。

top_k_experts (`int`, *任意*) : MoE層でトークンごとにアクティブ化されるエキスパートの数。

moe_intermediate_size (`int`, *任意*) : MoE層における各エキスパートのフィードフォワードネットワークの中間（隠れ）サイズ。

これは DiffusionGemmaModel の設定を保存するための設定クラスです。指定された引数に基づいて Diffusion Gemma モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

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

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

**パラメータ:**

text_config (`Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]]`, *任意*) : テキストバックボーンの config オブジェクトまたは辞書です。

vision_config (`Union[~configuration_utils.PreTrainedConfig, dict[str, Any]]`, *任意*) : ビジョンバックボーンの config オブジェクトまたは辞書。

boi_token_id (`int`、*optional*、デフォルトは 255999) : 画像プロンプトをラップするための begin-of-image トークンのインデックスです。

eoi_token_id (`int`、*optional*、デフォルト値は 258882) : 画像プロンプトをラップするための end-of-image トークンのインデックスです。

image_token_id (`int`、*任意*、デフォルトは`258880`) : 入力画像のプレースホルダーとして使用される画像トークンのインデックスです。

initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。

canvas_length (`int`、*optional*、デフォルト値は 256) : キャンバスのサイズ、言い換えればブロック拡散におけるブロック長です。空のキャンバスを初期化するために使用されます。

これは DiffusionGemmaModel の設定を保存するための設定クラスです。指定された引数に基づいて Diffusion Gemma モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

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

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

**パラメータ:**

sequences (`torch.LongTensor`、shape は `(batch_size, sequence_length)`) : `generate` メソッドに `input_ids` が提供された場合、プロンプトを含む生成されたシーケンス。

tokens_per_forward (`torch.LongTensor`、shape は (`batch_size`)) : この `generate` 呼び出しにおける、バッチ内の各メンバーの 1 回の forward あたりのトークン数。テキスト拡散モデルでは、二次的な評価指標としてよく使用されます。

past_key_values (`Cache`) : 生成に使用されるキャッシュです。マルチターンセッションにおいて、`generate` の後続の呼び出しに渡すことで、生成を高速化できます。

logits (`None`) : 未使用。後方互換性のためにインターフェースに保持されています。

scores (`None`) : 未使用。後方互換性のためにインターフェースに保持されています。

hidden_states (`None`) : 未使用。後方互換性のためにインターフェースに保持されています。

DiffusionGemmaの生成用の出力クラスです。

## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

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

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

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

DiffusionGemma の生成用の Mixin クラスです。モデルレベルのすべてのメソッドが含まれています。

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

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

**パラメータ:**

input_ids (*torch.LongTensor*、形状 *(batch_size, sequence_length)*、*任意*) : 生成のプロンプトとして使用されるシーケンス。

past_key_values ([Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache)、*optional*) : デコーダーの過去のキー値と過去のアテンションマスクを含む Cache オブジェクト。設定されている場合、`input_ids` および/または `pixel_values` は、キャッシュされていないデータに対応していなければなりません。

streamer (`BaseStreamer`、*任意*) : 生成されたシーケンスのストリーミングに使用される Streamer オブジェクトです。生成されたトークンは `streamer.put(token_ids)` を通して渡され、その後の処理はすべて streamer が担当します。streamer オブジェクトに `put_draft` メソッドがある場合、デノイジングステップからのトークンはそこに送信されます。

**上級ユーザー向けの追加引数:**

generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationConfig), *任意*) : 生成呼び出しのベースパラメータ化として使用される生成設定です。モデルのデフォルト値を上書きします。モデルのチェックポイントに`generation_config.json`ファイルがある場合、モデルのデフォルト値はそこから読み込まれます。それ以外の場合は、空の`DiffusionGemmaGenerationConfig`インスタンスになります。追加のショートカットとして、`generation_config`内の属性と一致する`**kwargs`は、それらの属性を上書きします。

logits_processor ([LogitsProcessorList](/docs/transformers/main/ja/internal/generation_utils#transformers.LogitsProcessorList)、*optional*) : 引数と生成設定から構築されるデフォルトの logits プロセッサを補完する、カスタムの logits プロセッサです。拡散 logits に適用されます。指定された場合、これらのプロセッサが最初に適用されます。この機能は上級ユーザー向けです。例えば、AR LLM でよく使用される logits プロセッサをここで渡すことができます。

stopping_criteria ([StoppingCriteriaList](/docs/transformers/main/ja/internal/generation_utils#transformers.StoppingCriteriaList)、*optional*) : 引数と生成設定から構築される、デフォルトのブロック自動回帰停止基準を補完するカスタム停止基準です。指定された場合、これらの基準が最初に適用されます。この機能は上級ユーザー向けです。例えば、AR LLMでよく使用される停止基準をここで渡すことができます。

kwargs (`dict[str, Any]`、*任意*) : `generation_config` のアドホックなパラメータ化、および/またはモデルの `forward` 関数に転送される追加のモデル固有の kwargs です。例えば、`decoder_input_ids` を設定して開始キャンバスを指定できます。

**戻り値:** `torch.LongTensor` または [DiffusionGemmaGenerationOutput](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput)

- `torch.LongTensor`: id 形式の生成テキスト。
- [DiffusionGemmaGenerationOutput](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput): 生成されたテキスト（`sequences`）およびその他の任意の出力を含む `ModelOutput` インスタンス。

拡散モデルを使用してテキストを生成します。

これは、キャンバス（トークンのブロック）の自己回帰的な生成を行う外側ループと、

各キャンバスで拡散処理を行うループです。アルゴリズムは概ね次のように動作します。
```
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
```

例:

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

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

**出力の長さを制御するパラメータ:**

max_new_tokens (`int`, *optional*) : プロンプトのトークン数を無視して生成するトークンの最大数。

max_length (`int`, *任意*) : 出力シーケンスの最大長。モデルが生成するトークン数を制御するには、`max_new_tokens`の使用を推奨します。

**Diffusion パラメータ:**

max_denoising_steps (`int`) : 実行するデノイジングステップの最大数。

sampler_config (`EntropyBoundSamplerConfig`) : サンプラーの設定です。テキスト拡散モデルにおけるサンプラーの動作については、[EntropyBoundSampler](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.EntropyBoundSampler)を参照してください。

t_min (`float`) : スケジュールの最終温度、つまり最後のノイズ除去ステップにおける温度です。詳細は [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) を参照してください。

t_max (`float`) : スケジュールの初期温度、つまり最初のノイズ除去ステップにおける温度です。詳細は [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) を参照してください。

stability_threshold (`int`) : 停止条件をトリガーするために、受け入れられたキャンバスが同一でなければならないステップ数。詳細は [StableAndConfidentStoppingCriteria](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) を参照してください。

confidence_threshold (`float`) : 温度スケーリング済み logits のエントロピーの平均が停止条件をトリガーするための閾値。詳細は [StableAndConfidentStoppingCriteria](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) を参照してください。

**キャッシュを制御するパラメータ:**

cache_implementation (`str`, *任意*) : `generate`内でインスタンス化されるキャッシュクラスの名称です。より高速なデコーディングのために使用されます。指定可能な値は以下の通りです:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/ja/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/ja/internal/generation_utils#transformers.QuantizedCache)  指定がない場合、モデルのデフォルトのキャッシュ（多くの場合は [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache)）が使用されます。詳細は [キャッシュのドキュメント](https://huggingface.co/docs/transformers/en/kv_cache) を参照してください。

cache_config (`dict`、*任意*、デフォルトは`None`) : キーバリューキャッシュクラスで使用する引数は、`cache_config`に渡すことができます。

**生成時に使用できる特殊トークン:**

bos_token_id (`int`, *任意*) : *シーケンス開始*トークンのID。

pad_token_id (`int`, *任意*) : *padding* トークンの ID。

eos_token_id (`Union[int, list[int]]`、*任意*) : *シーケンス終了*トークンのID。*シーケンス終了*トークンを複数設定するには、リストを使用できます。

[DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate)用にパラメータ設定をカスタマイズしたGenerationConfigクラス。

## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

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

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

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

**パラメータ:**

entropy_bound (`float`) : エントロピーの上限値です。この値が大きいほど、より多くのトークンが受け入れられます。適用方法の詳細については、[EntropyBoundSampler.accept_canvas()](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.EntropyBoundSampler.accept_canvas) の docstring を参照してください。

エントロピーバウンドサンプラー用の設定クラス。

## EntropyBoundSampler[[transformers.EntropyBoundSampler]]

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

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

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

**パラメータ:**

config (`EntropyBoundSamplerConfig`) : サンプラーの設定です。

canvas_length (`int`) : キャンバスの長さ。

vocab_size (`int`) : 語彙のサイズ。

max_denoising_steps (`int`) : デノイジングステップの最大数。(このサンプラーでは使用されません)

ランダムなトークンでキャンバスを初期化し、トークンレベルのエントロピーに基づいてトークンを受理し、受理されなかったトークンを再ノイズ化する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: FloatTensor, cur_step: int)
```

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

**パラメータ:**

current_canvas (`torch.LongTensor`) : 現在のキャンバス。

denoiser_canvas (`torch.LongTensor`) : デノイザーの予測からサンプリングされたキャンバス。

logits (`torch.FloatTensor`) : デノイザーからの logits。

cur_step (`int`) : 現在のステップ。

**戻り値:** `torch.LongTensor`

受け入れられたキャンバス。

エントロピーの境界に基づいて、デノイザーからトークンを受理します。より具体的には、サンプリングは、エントロピーが最も低いk個のトークンを受理することで進行し、

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

ここで、左辺はこれらのトークン間の結合相互情報量の上限であり、したがってサンプラーは、それらがほぼ独立であるように k 個のトークンを選択します。

https://arxiv.org/pdf/2505.24857 で初めて提案されました

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

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

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

`canvas_length` トークン分の新しいキャンバスを初期化し、語彙からランダムな値で初期化して返します。

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

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

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

**パラメータ:**

accepted_canvas (`torch.LongTensor`) : 受け入れられたキャンバス。

cur_step (`int`) : 現在のステップ（このサンプラーでは未使用）

**戻り値:** `torch.LongTensor`

再ノイズ化されたキャンバス。

受け入れられなかったすべてのトークンを再ノイズします。

## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

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

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

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

**パラメータ:**

stability_threshold (`int`) : 停止条件をトリガーするために、受け入れられたキャンバスが同一でなければならないステップ数。

confidence_threshold (`float`) : 温度スケーリング済み logits のエントロピーの平均が停止条件をトリガーするための閾値。

拡散プロセスが確信度を持ち安定した時点で停止する適応型停止戦略。より具体的には、以下の通りです：
- `stability_threshold` ステップにわたって受け入れられたキャンバスが同一である場合、拡散プロセスは安定しています。
- 処理済み logits のエントロピーの平均が `confidence_threshold` 未満の場合、拡散プロセスは確信度が高いと判断されます。

## LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

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

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

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

**パラメータ:**

t_min (`float`) : スケジュールの最終温度、つまり最後のノイズ除去ステップにおける温度。

t_max (`float`) : スケジュールの初期温度、つまり最初のノイズ除去ステップにおける温度です。

max_denoising_steps (`int`) : デノイジングステップの最大数。

Logits に線形温度スケジュールを適用する logits プロセッサです。`TemperatureLogitsWarper` と似ていますが、温度が現在のステップの関数である点が異なります。

ステップ n（全ステップ数 N のうち）において、温度 t は t = t_min + ((t_max - t_min) * (n/N)) で与えられます。

## DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

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

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

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

**パラメータ:**

config ([PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

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

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

ドット区切りパス（例: `torch.float32`）に対するモック値: 属性アクセスのチェーン、呼び出しはパススルーデコレータとして動作し、`repr` はドット区切りパスを返し、ベースクラスとして使用するとプレーンな `type` ベースに置き換えられます（PEP 560 の `__mro_entries__`）。これにより、実際のサブクラスは通常のメタクラスを保持し、`inspect.signature` はモックのものではなく実際の `__init__` を読み取ります。

## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

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

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

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

**パラメータ:**

config ([DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

特定のヘッドを付加せずに、生の隠れ状態を出力する、素の Diffusion Gemma Model。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### 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.FloatTensor] = 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'>)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : キャンバスのコンテキストとしてエンコードするプロンプトの、キャッシュされていないトークン ID。

attention_mask (`torch.Tensor`、形状 `(batch_size, sequence_length)` または `dict`、*任意*) : 入力トークンのマスク。

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, canvas_length)`、*任意*) : 精錬対象のキャンバスのトークン ID。

self_conditioning_logits (`torch.FloatTensor`、shape `(batch_size, canvas_length, vocab_size)`、*任意*) : 前回のデノイジングステップからの自己条件付けロジット。自己条件付け埋め込みの計算に使用されます。

self_conditioning_mask (`torch.BoolTensor`、shape `(batch_size,)`、*任意*) : `self_conditioning_logits` に対するサンプルごとのマスクです。`False` に設定されたサンプルには、そのサンプルに logits が渡されなかったかのように、ゼロ化された self-conditioning シグナルが適用されます。self-conditioning をある確率でサンプルごとに有効にするトレーニング時に有用です。

decoder_attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length+canvas_length)` または `dict`、*任意*) : デコーダの KV キャッシュ用のアテンションマスク。パディング済みまたは未設定のエンコーダ KV キャッシュエントリを指定するために使用されます。

decoder_position_ids (`torch.LongTensor`、shape `(batch_size, canvas_length)`、*optional*) : キャンバス内のトークンの位置IDです。

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *任意*) : キーがサポートされているモダリティ、値がそのモダリティのエンコード済み出力である辞書。各エンコード済み出力は、(`pooler_output`、*任意*: `last_hidden_states`、*任意*: `hidden_states`、*任意*: `attentions`) という形式のタプルで、`pooler_output` の形状は `(batch_size, sequence_length, hidden_size)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。

**戻り値:** `DiffusionGemmaModelOutputWithPast` または `tuple(torch.FloatTensor)`

`DiffusionGemmaModelOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)）や入力に応じて、さまざまな要素で構成されます。

[DiffusionGemmaModel](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **encoder_last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- エンコーダーの最終層の出力における隠れ状態のシーケンス。`input_ids` が提供された場合のみ設定されます。例えば、学習中にエンコーダーに対して自己回帰損失を計算する場合などです。

## DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

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

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

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

**パラメータ:**

config ([DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

ビジョンバックボーンと言語モデルから構成されるDiffusionGemmaエンコーダーモデルで、*言語モデリングヘッドは含まれていません*。Gemma4Modelと非常に似ていますが、音声や動画の入力をサポートせず、内部レイヤーでは常にMoEコードパスを前提としています。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = 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'>)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

pixel_values (`torch.FloatTensor`、shape `(batch_size, num_channels, image_size, image_size)`、*optional*) : 入力画像に対応するテンソルです。ピクセル値は `image_processor_class` を使用して取得できます。詳細は `image_processor_class.__call__` を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は画像の処理に `image_processor_class` を使用します）。

attention_mask (`Union[torch.Tensor, dict]`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対するアテンションの適用を回避するためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

mm_token_type_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各モダリティに一致する入力シーケンスのトークンインデックスです。例えば、テキスト (0)、画像 (1)、動画 (2) などです。マルチモーダルなトークンタイプIDは、[AutoProcessor](/docs/transformers/main/ja/model_doc/auto#transformers.AutoProcessor) を使用して取得できます。詳細は [ProcessorMixin.__call__()](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessorMixin.__call__) を参照してください。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

image_position_ids (`torch.LongTensor`、shape `(batch_size, max_patches, 2)`、*optional*) : image processor からの 2D パッチ位置座標。パディングは `(-1, -1)` で示されます。位置埋め込みの計算のために vision encoder にそのまま渡されます。

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *任意*) : キーがサポートされているモダリティ、値がそのモダリティのエンコード済み出力である辞書。各エンコード済み出力は、(`pooler_output`、*任意*: `last_hidden_states`、*任意*: `hidden_states`、*任意*: `attentions`) という形式のタプルで、`pooler_output` の形状は `(batch_size, sequence_length, hidden_size)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。

**戻り値:** [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `tuple(torch.FloatTensor)`

config（[DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)）や入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[DiffusionGemmaEncoderModel](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

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

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

[ソース](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.FloatTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`Union[torch.Tensor, dict]`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対するアテンションの適用を回避するためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

**戻り値:** [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `tuple(torch.FloatTensor)`

config（[DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)）や入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[DiffusionGemmaEncoderTextModel](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderTextModel) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

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

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

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

DiffusionGemma用のデコーダーモデル。

bidirectional self-attention と、エンコーダーの KV キャッシュへの cross-attention を用いて、キャンバスのトークンを処理します。デコーダーは KV キャッシュを読み取りますが、更新は行いません。これらの違いを除けば、`DiffusionGemmaEncoderTextModel` と類似しており、共通する重みはすべて共有しています。

#### 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.FloatTensor] = 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'>)
```

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

**パラメータ:**

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, canvas_length)`) : 精錬対象のキャンバスのトークン ID。

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

self_conditioning_logits (`torch.FloatTensor`、shape `(batch_size, canvas_length, vocab_size)`、*任意*) : 前回のデノイジングステップからの自己条件付けロジット。自己条件付け埋め込みの計算に使用されます。

self_conditioning_mask (`torch.BoolTensor`、shape `(batch_size,)`、*任意*) : `self_conditioning_logits` に対するサンプルごとのマスクです。`False` に設定されたサンプルには、そのサンプルに logits が渡されなかったかのように、ゼロ化された self-conditioning シグナルが適用されます。self-conditioning をある確率でサンプルごとに有効にするトレーニング時に有用です。

decoder_attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length+canvas_length)` または `dict`、*任意*) : デコーダの KV キャッシュ用のアテンションマスク。パディング済みまたは未設定のエンコーダ KV キャッシュエントリを指定するために使用されます。

decoder_position_ids (`torch.LongTensor`、shape `(batch_size, canvas_length)`、*optional*) : キャンバス内のトークンの位置IDです。

**戻り値:** [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `tuple(torch.FloatTensor)`

config（[DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)）や入力に応じて、さまざまな要素で構成される [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[DiffusionGemmaDecoderModel](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaDecoderModel) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

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

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

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

ブロック拡散用の DiffusionGemma モデルです。`DiffusionGemmaModel` を呼び出して、プロンプトの KV キャッシュを条件として、入力キャンバスの隠れ状態を取得します。その後、LM Head と自己条件付けブロックを使用して、その隠れ状態を logits に変換し、次のキャンバスのサンプリングと、次のブロック拡散ステップ用の自己条件付け埋め込みを生成します。

#### 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.FloatTensor] = 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'>)
```

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

**パラメータ:**

input_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : キャンバスのコンテキストとしてエンコードするプロンプトの、キャッシュされていないトークン ID。

attention_mask (`torch.LongTensor`、shape `(batch_size, sequence_length)` または `dict`、*任意*) : 入力トークンのマスク。

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, canvas_length)`、*任意*) : 精錬対象のキャンバスのトークン ID。

self_conditioning_logits (`torch.FloatTensor`、shape `(batch_size, canvas_length, vocab_size)`、*任意*) : 前回のデノイジングステップからの自己条件付けロジット。自己条件付け埋め込みの計算に使用されます。

self_conditioning_mask (`torch.BoolTensor`、shape `(batch_size,)`、*任意*) : `self_conditioning_logits` に対するサンプルごとのマスクです。`False` に設定されたサンプルには、そのサンプルに logits が渡されなかったかのように、ゼロ化された self-conditioning シグナルが適用されます。self-conditioning をある確率でサンプルごとに有効にするトレーニング時に有用です。

decoder_attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length+canvas_length)` または `dict`、*任意*) : デコーダの KV キャッシュ用のアテンションマスク。パディング済みまたは未設定のエンコーダ KV キャッシュエントリを指定するために使用されます。

decoder_position_ids (`torch.LongTensor`、shape `(batch_size, canvas_length)`、*optional*) : キャンバス内のトークンの位置IDです。

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *任意*) : キーがサポートされているモダリティ、値がそのモダリティのエンコード済み出力である辞書。各エンコード済み出力は、(`pooler_output`、*任意*: `last_hidden_states`、*任意*: `hidden_states`、*任意*: `attentions`) という形式のタプルで、`pooler_output` の形状は `(batch_size, sequence_length, hidden_size)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。

**戻り値:** `DiffusionGemmaBlockDiffusionOutputWithPast` または `tuple(torch.FloatTensor)`

`DiffusionGemmaBlockDiffusionOutputWithPast`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[DiffusionGemmaConfig](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)）や入力に応じて、さまざまな要素で構成されます。

[DiffusionGemmaForBlockDiffusion](/docs/transformers/main/ja/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*) -- 言語モデリングの損失。
- **logits** (`torch.FloatTensor`、shape `(batch_size, canvas_length, config.text_config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己注意ブロックのキーとバリュー）が含まれます。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **encoder_last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- エンコーダーの最終層の出力における隠れ状態のシーケンス。`input_ids` が提供された場合のみ設定されます。例えば、学習中にエンコーダーに対して自己回帰損失を計算する場合などです。

例:

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