# Gemma3n

## 概要

[Gemma3n](https://developers.googleblog.com/en/introducing-gemma-3n/) は、事前学習済みと指示チューニング済みのバリアントが用意されたマルチモーダルモデルで、E4B と E2B のサイズが利用可能です。言語モデルのアーキテクチャの大部分は以前の Gemma リリースと共通していますが、このモデルには [Alternating Updates][altup]（AltUp）、[Learned Augmented Residual Layer][laurel]（LAuReL）、[MatFormer][matformer]、Per-Layer Embeddings（PLE）、[Activation Sparsity with Statistical Top-k][spark-transformer]、KV キャッシュ共有など、多くの新機能が追加されています。言語モデルは、[Gemma 3](./gemma3) と同様のアテンションパターンを採用しており、グローバルな自己アテンションレイヤーごとに 4 つのローカルなスライディングウィンドウ自己アテンションレイヤーが交互に配置され、最大コンテキスト長は 32k トークンです。Gemma 3n では、ビジョンエンコーダーとして MobileNet v5 を導入し、デフォルトの解像度は 768x768 ピクセルです。また、[Universal Speech Model][usm]（USM）アーキテクチャに基づいて新たに学習されたオーディオエンコーダーも追加されています。

指示チューニング済みバリアントは、知識蒸留と強化学習を用いてポストトレーニングされました。

すべての元のGemma 3nチェックポイントは、[Gemma 3n][gemma3n-collection]リリースの下で確認できます。

> [!TIP]
> 右側のサイドバーにあるGemma 3nモデルをクリックすると、Gemmaを異なるビジョン、オーディオ、言語タスクに適用する方法のより多くの例を確認できます。
>
> `use_kernels=True` を [from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) に設定すると、対応するレイヤーが Hub からの最適化されたカーネルに置き換えられます。詳細は [カーネルの読み込み](../kernel_doc/loading_kernels) を参照してください。

以下の例では、[Pipeline](/docs/transformers/main/ja/main_classes/pipelines#transformers.Pipeline)または[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)クラスを使用して、画像に基づいてテキストを生成する方法を示しています。

```python
from transformers import pipeline

pipeline = pipeline(
    task="image-text-to-text",
    model="google/gemma-3n-e4b",
    device=0,
)
pipeline(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
    text="<start_of_image> What is shown in this image?"
)
```

```python
from transformers import AutoProcessor, Gemma3nForConditionalGeneration

model = Gemma3nForConditionalGeneration.from_pretrained(
    "google/gemma-3n-e4b-it",
    device_map="auto",
    attn_implementation="sdpa"
)
processor = AutoProcessor.from_pretrained(
    "google/gemma-3n-e4b-it",
    padding_side="left"
)

messages = [
    {
        "role": "system",
        "content": [
            {"type": "text", "text": "You are a helpful assistant."}
        ]
    },
    {
        "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,
).to(model.device)

output = model.generate(**inputs, max_new_tokens=50, cache_implementation="static")
print(processor.decode(output[0], skip_special_tokens=True))
```

## 注記

- 画像・音声・テキスト、画像・テキスト、画像・音声、音声・テキスト、画像のみ、音声のみの入力には、[Gemma3nForConditionalGeneration](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nForConditionalGeneration)を使用します。
- Gemma 3n は1つの入力に対する複数の画像をサポートしていますが、プロセッサーに渡す前に画像が正しくバッチ化されていることを確認してください。各バッチは1つ以上の画像のリストである必要があります。

    ```py
    url_cow = "https://media.istockphoto.com/id/1192867753/photo/cow-in-berchida-beach-siniscola.jpg?s=612x612&w=0&k=20&c=v0hjjniwsMNfJSuKWZuIn8pssmD5h5bSN1peBd1CmH4="
    url_cat = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"

    messages =[
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are a helpful assistant."}
            ]
        },
        {
            "role": "user",
            "content": [
                {"type": "image", "url": url_cow},
                {"type": "image", "url": url_cat},
                {"type": "text", "text": "Which image is cuter?"},
            ]
        },
    ]
    ```

- プロセッサに渡すテキストには、画像を挿入するべき箇所に`<image_soft_token>`トークンを含める必要があります。
- Gemma 3n は、1 つの入力につき最大 1 つのターゲット音声クリップを受け取ります。ただし、例えば few-shot プロンプトでは複数の音声クリップを指定できます。
- プロセッサーに渡すテキストには、音声クリップを挿入するべき箇所に`<audio_soft_token>`トークンを含める必要があります。
- プロセッサには、チャットメッセージをモデルの入力に変換するための独自の [apply_chat_template()](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) メソッドがあります。

## Gemma3nAudioFeatureExtractor[[transformers.Gemma3nAudioFeatureExtractor]]

#### transformers.Gemma3nAudioFeatureExtractor[[transformers.Gemma3nAudioFeatureExtractor]]

```python
transformers.Gemma3nAudioFeatureExtractor(feature_size: int = 128, sampling_rate: int = 16000, padding_value: float = 0.0, return_attention_mask: bool = True, frame_length_ms: float = 32.0, hop_length_ms: float = 10.0, min_frequency: float = 125.0, max_frequency: float = 7600.0, preemphasis: float = 0.97, preemphasis_htk_flavor: bool = True, fft_overdrive: bool = True, dither: float = 0.0, input_scale_factor: float = 1.0, mel_floor: float = 1e-05, per_bin_mean: collections.abc.Sequence[float] | None = None, per_bin_stddev: collections.abc.Sequence[float] | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/feature_extraction_gemma3n.py#L108)

**パラメータ:**

feature_size (`int`、*任意*、デフォルトは 128) : 抽出された特徴量の次元数。

sampling_rate (`int`、*optional*、デフォルトは 16000) : 音声ファイルをデジタル化するためのサンプリングレート（ヘルツ (Hz) 単位）。

padding_value (`float`、*optional*、デフォルト値は 0.0) : 音声のパディングに使用される値です。無音に対応する値である必要があります。

return_attention_mask (`bool`、*任意*、デフォルトは `True`) : 生成された MEL スペクトログラムの attention mask を返すかどうかを指定します。

frame_length_ms (`float`、*任意*、デフォルト値は 32.0) : フレームの長さ（ミリ秒）。

hop_length_ms (`float`、*optional*、デフォルト値は 10.0) : Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。

min_frequency (`float`、*任意*、デフォルトは 125.0) : Mel フィルターバンクの最小周波数 (Hz)。

max_frequency (`float`、*optional*、デフォルト値は 7600.0) : Mel フィルターバンクの最大周波数 (Hz)。

preemphasis (`float`、*任意*、デフォルトは 0.97) : 事前強調係数です。

preemphasis_htk_flavor (`bool`、*任意*、デフォルトは`True`) : HTKスタイルの事前強調を使用するかどうか。

fft_overdrive (`bool`、*任意*、デフォルトは`True`) : FFT オーバードライブを使用するかどうか。

dither (`float`、*任意*、デフォルトは 0.0) : ディザリングを追加します。つまり、各フレームに小さなガウスノイズを加えます。例えば、0.0001 を指定すると、平均 0.0、標準偏差 0.0001 の正規分布によるディザリングが追加されます（raw_speech の範囲が [-1,+1] であると仮定）。値が 0.0 の場合はディザリングを行いません。ディザリングは `spectrogram(mel_floor=...)` と同様の効果を持ち、信号に VAD カットオフが存在する場合、ハードゼロ区間を持つ信号の log_mel_fbank の高い値を低減します。

input_scale_factor (`float`、*任意*、デフォルト値は 1.0) : 入力波形に適用されるスケーリング係数。

mel_floor (`float`、*optional*、デフォルトは 1e-05) : log(0) を回避するために、Mel スペクトログラムに適用する最小値。

per_bin_mean (`Optional[Sequence[float]]`, *任意*) : バインごとの正規化のための平均値。

per_bin_stddev (`Optional[Sequence[float]]`, *任意*) : バインごとの正規化に使用する標準偏差の値。

音声特徴抽出器 Universal Speech Models https://huggingface.co/papers/2303.01037。

## Gemma3nProcessor[[transformers.Gemma3nProcessor]]

#### transformers.Gemma3nProcessor[[transformers.Gemma3nProcessor]]

```python
transformers.Gemma3nProcessor(feature_extractor, image_processor, tokenizer, chat_template = None, audio_seq_length: int = 188, image_seq_length: int = 256, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/processing_gemma3n.py#L32)

**パラメータ:**

feature_extractor (`Gemma3nAudioFeatureExtractor`) : 特徴抽出器は必須の入力です。

image_processor (`SiglipImageProcessor`) : 画像プロセッサは必須の入力です。

tokenizer (`GemmaTokenizer`) : トークナイザーは必須の入力です。

chat_template (`str`) : チャット内のメッセージのリストをトークン化可能な文字列に変換するための Jinja テンプレート。

audio_seq_length (`int`、*optional*、デフォルトは 188) : テキストプロンプトに追加されるオーディオソフトトークンの数

image_seq_length (`int`、*任意*、デフォルトは 256) : 追加すべき画像ソフトトークンの数

Gemma3nProcessor を構築します。このプロセッサーは、フィーチャーエクストラクター、画像プロセッサー、トークナイザーを単一のプロセッサーとしてラップします。

[Gemma3nProcessor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nProcessor) は、[Gemma3nAudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor)、[SiglipImageProcessor](/docs/transformers/main/ja/model_doc/siglip#transformers.SiglipImageProcessor)、および [GemmaTokenizer](/docs/transformers/main/ja/model_doc/gemma#transformers.GemmaTokenizer) のすべての機能を提供します。詳細については、[~Gemma3nAudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor)、[~SiglipImageProcessor](/docs/transformers/main/ja/model_doc/siglip#transformers.SiglipImageProcessor)、および [~GemmaTokenizer](/docs/transformers/main/ja/model_doc/gemma#transformers.GemmaTokenizer) を参照してください。

#### __call__[[transformers.Gemma3nProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] = None, audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = None, **kwargs: *<class 'transformers.models.gemma3n.processing_gemma3n.Gemma3nProcessorKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/processing_gemma3n.py#L71)

**パラメータ:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *任意*) : 前処理を行う画像。ピクセル値が 0 から 255 の範囲にある単一の画像またはバッチの画像を想定しています。ピクセル値が 0 から 1 の範囲にある画像を渡す場合は、`do_rescale=False` を設定してください。

text (`Union[str, list[str], list[list[str]]]`、*任意*) : エンコード対象のシーケンスまたはシーケンスのバッチです。各シーケンスは文字列、または文字列のリスト（プレトークナイズ済み文字列）であることができます。プレトークナイズ済み入力を渡す場合は、バッチ入力との曖昧さを避けるために `is_split_into_words=True` を設定してください。

audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray], list[list[float]]]`、*任意*) : 準備対象のオーディオまたはオーディオのバッチです。各オーディオは NumPy 配列または PyTorch テンソルであることができます。NumPy 配列/PyTorch テンソルの場合、各オーディオの形状は (C, T) である必要があります。ここで C はチャネル数、T はオーディオのサンプル長です。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。受け入れ可能な値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDict クラスを参照してください。

**戻り値:** `~feature_extraction_utils.BatchFeature`

- **data** (`dict`, *任意*) -- __call__/pad メソッドによって返されるリスト/配列/テンソルの辞書（'input_values'、'attention_mask' など）。
- **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。
- **skip_tensor_conversion** (`list[str]` または `set[str]`、*任意*) -- `tensor_type` が指定されている場合でも、テンソルに変換すべきでないキーのリストまたはセット。

## Gemma3nTextConfig[[transformers.Gemma3nTextConfig]]

#### transformers.Gemma3nTextConfig[[transformers.Gemma3nTextConfig]]

```python
transformers.Gemma3nTextConfig(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 = 262400, hidden_size: int = 2048, intermediate_size: int | list[int] = 16384, num_hidden_layers: int = 35, num_attention_heads: int = 8, num_key_value_heads: int = 2, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, 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, final_logit_softcapping: float = 30.0, vocab_size_per_layer_input: int = 262144, hidden_size_per_layer_input: int = 256, altup_active_idx: int = 0, altup_coef_clip: float = 120.0, altup_correct_scale: bool = True, altup_num_inputs: int = 4, num_kv_shared_layers: int = 15, laurel_rank: int = 64, activation_sparsity_pattern: float | list[float] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L36)

**パラメータ:**

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

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

intermediate_size (`Union[int, list[int]]`、*任意*、デフォルトは`16384`) : MLP 表現の次元数。

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

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

num_key_value_heads (`int`、*任意*、デフォルトは `2`) : 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`、*任意*、デフォルトは`32768`) : このモデルが使用される可能性のある最大シーケンス長です。

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

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

use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。

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 の値に基づいて自動的に生成されます。

final_logit_softcapping (`float`、*任意*、デフォルトは `30.0`) : 確率分布を計算する前に最終 logits に適用されるソフトキャップ値。logits は `tanh(logit / cap) * cap` によってスケーリングされます。

vocab_size_per_layer_input (`int`, *任意*, デフォルトは 262144) : 標準的な埋め込みを補完するために各層のテキスト埋め込みとして使用される語彙サイズ。

hidden_size_per_layer_input (`int`、*任意*、デフォルトは 256) : 各層の埋め込みにおける隠れ表現の次元数。

altup_active_idx (`int`、*optional*、デフォルト値は 0) : AltUp が追加の予測を計算したり、アクティブな予測を修正したりする対象の予測のインデックス。

altup_coef_clip (`float`、*任意*、デフォルト値は 120.0) : AltUp の予測または補正係数重みの最大振幅です。

altup_correct_scale (`bool`、*任意*、デフォルトは `True`) : True の場合、`altup_active_idx` における補正済み予測に `AltUp.correct_output_scale` を適用します。

altup_num_inputs (`int`、*任意*、デフォルトは 4) : 入力シーケンスに対して AltUp が生成する予測の回数。

num_kv_shared_layers (`int`、*任意*、デフォルトは 15) : KV キャッシュの値を共有するレイヤーの数です。フォワードパスにおいて、モデルの最後の `num_kv_shared_layers` 個のレイヤーは KV 値を「共有」します。この範囲内の各ローカルレイヤーおよびグローバルレイヤーは、それぞれこの範囲に入る直前に計算された最後のローカルレイヤーまたはグローバルレイヤーの KV キャッシュ値を使用します。この値は、アテンションパターンのサイズの倍数である必要があります（`layer_types` パラメータを参照）。

laurel_rank (`int`、*optional*、デフォルトは 64) : Learned Augmented Residual Layer 内の線形射影における中間サイズです。

activation_sparsity_pattern (`Sequence[float]`, *任意*) : 指定された層のトップkアクティベーションを抽出するために使用されるスパース性係数です。提供されるSequenceには、モデルの各層に対してスパース性の値を明示的に指定する必要があります。デフォルトでは、最初の10層はスパース性係数0.95でスパース化され、それ以外の層はデンスです。

これはGemma3nModelの設定を保存するための設定クラスです。指定された引数に基づいてGemma3Nモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-3n-E4B](https://huggingface.co/google/gemma-3n-E4B)と類似した設定が得られます。

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

```python
>>> from transformers import Gemma3nTextModel, Gemma3nTextConfig

>>> # Initializing a Gemma3nText gemma3n_text-E4B style configuration
>>> configuration = Gemma3nTextConfig()

>>> # Initializing a model from the gemma3n_text-E4B style configuration
>>> model = Gemma3nTextModel(configuration)

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

## Gemma3nVisionConfig[[transformers.Gemma3nVisionConfig]]

#### transformers.Gemma3nVisionConfig[[transformers.Gemma3nVisionConfig]]

```python
transformers.Gemma3nVisionConfig(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, architecture: str = 'mobilenetv5_300m_enc', initializer_range: float = 0.02, do_pooling: bool = False, model_args: dict | None = None, hidden_size: int = 2048, vocab_size: int = 128, vocab_offset: int = 262144, rms_norm_eps: float = 1e-06)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L337)

**パラメータ:**

architecture (`str`、*任意*、デフォルトは`"resnet50"`) : 読み込むtimmアーキテクチャ。

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

do_pooling (`bool`、*任意*、デフォルトは `True`) : `TimmWrapperModel` の last_hidden_state に対してプーリングを行うかどうかを指定します。

model_args (`dict[str, Any]`, *任意*) : `timm.create_model` 関数に渡す追加のキーワード引数です。例えば、`timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k` で 3 ブロックのモデルを作成するには `model_args={"depth": 3}` を指定します。デフォルトは `None` です。

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

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

vocab_offset (`int`、*任意*、デフォルトは 262144) : `Gemma3nMultimodalEmbedder` によって埋め込まれるトークン ID に対するトークナイザの語彙インデックスと、0 始まりの `Gemma3nMultimodalEmbedder.embedding` テーブルとの間のオフセット。

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

これはGemma3nModelの設定を保存するための設定クラスです。指定された引数に基づいてGemma3Nモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-3n-E4B](https://huggingface.co/google/gemma-3n-E4B)と類似した設定が得られます。

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

例:
```python
>>> from transformers import Gemma3nVisionConfig, TimmWrapper

>>> # Initializing a TimmWrapper gemma3n_vision-E4B-style configuration
>>> configuration = Gemma3nVisionConfig()

>>> # Initializing a gemma3n_vision-E4B-style TimmWrapper from the configuration
>>> model = TimmWrapper(configuration)

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

## Gemma3nAudioConfig[[transformers.Gemma3nAudioConfig]]

#### transformers.Gemma3nAudioConfig[[transformers.Gemma3nAudioConfig]]

```python
transformers.Gemma3nAudioConfig(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 = 128, vocab_offset: int = 262272, input_feat_size: int = 128, hidden_size: int = 1536, rms_norm_eps: float = 1e-06, gradient_clipping: float = 10000000000.0, conf_attention_chunk_size: int = 12, conf_attention_context_left: int = 13, conf_attention_context_right: int = 0, conf_attention_logit_cap: float = 50.0, conf_num_attention_heads: int = 8, conf_num_hidden_layers: int = 12, conf_conv_kernel_size: int = 5, conf_reduction_factor: int = 4, conf_residual_weight: float = 0.5, sscp_conv_channel_size: list[int] | tuple[int, int] = (128, 32), sscp_conv_group_norm_eps: float = 0.001, sscp_conv_kernel_size: list | tuple[tuple[int, int], tuple[int, int]] = ((3, 3), (3, 3)), sscp_conv_stride_size: list | tuple[tuple[int, int], tuple[int, int]] = ((2, 2), (2, 2)))
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L237)

**パラメータ:**

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

vocab_offset (`int`、*任意*、デフォルトは 262272) : `Gemma3nMultimodalEmbedder` によって埋め込まれるトークン ID に対するトークナイザの語彙インデックスと、0 始まりの `Gemma3nMultimodalEmbedder.embedding` テーブルとの間のオフセット。

input_feat_size (`int`、*optional*、デフォルトは 128) : 各 mel スペクトログラムフレームのチャネル数。

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

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

gradient_clipping (`float`、*任意*、デフォルト値は 10000000000.0) : 非常に大きな勾配値を安定化するために使用されるクリッピング値。

conf_attention_chunk_size (`int`, *optional*, デフォルトは 12) : Universal Speech Model の Conformer ("conf") セクション内で、ローカルアテンション処理に使用されるサブシーケンスサイズ。

conf_attention_context_left (`int`、*optional*、デフォルトは 13) : Universal Speech Model の Conformer ("conf") セクション内のローカルアテンションの左コンテキストサイズです。

conf_attention_context_right (`int`、*optional*、デフォルト値は 0) : Universal Speech Model の Conformer ("conf") セクション内のローカルアテンションの右コンテキストサイズ。

conf_attention_logit_cap (`float`、*任意*、デフォルト値は 5.0) : Universal Speech Model の Conformer（"conf"）セクション内で、ローカルアテンション時に適用される Logit cap。

conf_num_attention_heads (`int`、*任意*、デフォルトは 8) : Universal Speech Model の Conformer（"conf"）セクション内のローカルアテンションにおけるアテンションヘッドの数。

conf_num_hidden_layers (`int`, *optional*, デフォルトは 12) : Universal Speech Model の Conformer ("conf") セクション内で、ローカルアテンションを使用するレイヤーの数です。

conf_conv_kernel_size (`int`, *任意*, デフォルト値は 5) : Universal Speech Model の Conformer ("conf") セクション内の Conformer ブロックにおける畳み込みカーネルサイズ。

conf_reduction_factor (`int`、*任意*、デフォルトは 4) : Universal Speech Model の Conformer（"conf"）セクション内の Conformer ブロックで使用する縮小係数。

conf_residual_weight (`float`、*optional*、デフォルト値は 0.5) : Universal Speech Model の Conformer ("conf") セクション内の残差接続の重み。

sscp_conv_channel_size (`tuple(int, int)`、*optional*、デフォルトは`(128, 32)`) : Universal Speech Model の Sub-sample Convolution Projection ("sscp") セクションにおける、第1および第2の畳み込み層のチャネルサイズ。

sscp_conv_group_norm_eps (`float`、*optional*、デフォルト値は 0.001) : Universal Speech Model の Sub-sample Convolution Projection ("sscp") セクションにおける、サブサンプル畳み込み投影でグループ正規化に使用される Epsilon。

sscp_conv_kernel_size (`tuple(tuple(int, int), tuple(int, int))`, *任意*、デフォルトは `((3, 3), (3, 3))`) : Universal Speech Model の Sub-sample Convolution Projection ("sscp") セクションにある、2 つの畳み込み層のカーネルサイズです。各層のカーネルサイズは、高さと幅のタプルで指定されます。ここで、高さは時間次元に対応し、幅は周波数次元に対応します。

sscp_conv_stride_size (`tuple(tuple(int, int), tuple(int, int))`, *任意*、デフォルトは `((2, 2), (2, 2))`) : Universal Speech Model の Sub-sample Convolution Projection ("sscp") セクションにある、サブサンプル畳み込み投影の2つの畳み込み層のストライドサイズです。各層のストライドサイズは、高さと幅のタプルとして指定されます。ここで、高さは時間次元に対応し、幅は周波数次元に対応します。

これはGemma3nModelの設定を保存するための設定クラスです。指定された引数に基づいてGemma3Nモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-3n-E4B](https://huggingface.co/google/gemma-3n-E4B)と類似した設定が得られます。

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

例:

```python
>>> from transformers import Gemma3nAudioConfig, Gemma3nAudioEncoder

>>> # Initializing a Gemma3nAudioEncoder gemma3n_audio-E4B-style configuration
>>> configuration = Gemma3nAudioConfig()

>>> # Initializing a model from the gemma3n_audio-E4B style configuration
>>> model = Gemma3nAudioEncoder(configuration)

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

## Gemma3nConfig[[transformers.Gemma3nConfig]]

#### transformers.Gemma3nConfig[[transformers.Gemma3nConfig]]

```python
transformers.Gemma3nConfig(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.gemma3n.configuration_gemma3n.Gemma3nTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.models.gemma3n.configuration_gemma3n.Gemma3nVisionConfig | dict[str, typing.Any] | None = None, audio_config: transformers.models.gemma3n.configuration_gemma3n.Gemma3nAudioConfig | dict[str, typing.Any] | None = None, audio_soft_tokens_per_image: int | None = 188, vision_soft_tokens_per_image: int | None = 256, boi_token_id: int | None = 255999, eoi_token_id: int | None = 262144, image_token_id: int | None = 262145, boa_token_id: int | None = 256000, eoa_token_id: int | None = 262272, audio_token_id: int | None = 262273, initializer_range: float | None = 0.02, tie_word_embeddings: bool | None = True, use_cache: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L430)

**パラメータ:**

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

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

audio_config (`Union[~models.gemma3n.configuration_gemma3n.Gemma3nAudioConfig, dict[str, Any]]`、*optional*) : 音声バックボーンの config オブジェクトまたは辞書。

audio_soft_tokens_per_image (`int`、*optional*、デフォルトは 188) : 1 つのオーディオクリップあたりのソフトトークンの数。

vision_soft_tokens_per_image (`int`、*任意*、デフォルトは 256) : 1 画像あたりのソフトトークン数。

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

eoi_token_id (`int`、*optional*、デフォルトは 262144) : 画像プロンプトをラップするための画像終了トークンのインデックス。

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

boa_token_id (`int`、*optional*、デフォルトは 256000) : 音声プロンプトをラップするための begin-of-audio トークンインデックスです。

eoa_token_id (`int`、*optional*、デフォルトは 262272) : 音声プロンプトをラップするための end-of-audio トークンインデックス。

audio_token_id (`int`、*任意*、デフォルトは`262273`) : 入力音声のプレースホルダーとして使用されるオーディオトークンのインデックスです。

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

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

use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。

これはGemma3nModelの設定を保存するための設定クラスです。指定された引数に基づいてGemma3Nモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-3n-E4B](https://huggingface.co/google/gemma-3n-E4B)と類似した設定が得られます。

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

例:

```python
>>> from transformers import Gemma3nForConditionalGeneration, Gemma3nConfig, Gemma3nTextConfig

>>> # Initializing a MobileNet vision config, which is loaded from TIMM
>>> vision_config = Gemma3nVisionConfig()

>>> # Initializing a Gemma3n Audio config
>>> audio_config = Gemma3nAudioConfig()

>>> # Initializing a Gemma3n Text config
>>> text_config = Gemma3nTextConfig()

>>> # Initializing a Gemma3n gemma-3-4b style configuration
>>> configuration = Gemma3nConfig(text_config, vision_config, audio_config)

>>> # Initializing a model from the gemma-3-4b style configuration
>>> model = Gemma3nTextConfig(configuration)

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

## Gemma3nTextModel[[transformers.Gemma3nTextModel]]

#### transformers.Gemma3nTextModel[[transformers.Gemma3nTextModel]]

```python
transformers.Gemma3nTextModel(config: Gemma3nTextConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1577)

**パラメータ:**

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

言語モデリングヘッドを備えないベースのGemma 3n言語モデル。

このモデルは [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.Gemma3nTextModel.forward]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1638)

**パラメータ:**

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)

per_layer_inputs (`torch.Tensor`、*任意*、デフォルトは None) : 事前計算済みのレイヤーごとの埋め込み。None の場合、input_ids が提供されていればそこから導出されます。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

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

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

[Gemma3nTextModel](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nTextModel)の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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

## Gemma3nModel[[transformers.Gemma3nModel]]

#### transformers.Gemma3nModel[[transformers.Gemma3nModel]]

```python
transformers.Gemma3nModel(config: Gemma3nConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1923)

**パラメータ:**

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

ベースの Gemma 3n モデルは、ビジョンバックボーン、オーディオバックボーン、および言語モデリングヘッドを備えない言語モデルで構成されています。

このモデルは [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.Gemma3nModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, per_layer_inputs: typing.Optional[torch.Tensor] = None, use_cache: bool | None = 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/gemma3n/modeling_gemma3n.py#L2004)

input_features_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*): `input_features` のアテンションマスク。非ゼロの値が有効な音声フレームを示します。per_layer_inputs (`torch.Tensor`、*任意*): shape `(batch_size, sequence_length, num_hidden_layers, hidden_size_per_layer_input)` の、事前計算済みのレイヤーごとの入力テキスト埋め込み。指定された場合、テキストモデル内で `input_ids` から `get_per_layer_inputs()` を介して計算される代わりに、これらが直接使用されます。`input_ids` の代わりに `inputs_embeds` を用いて `forward` を呼び出す場合は、それらを事前計算し、`inputs_embeds` とともに渡す必要があります。そうしないと、レイヤーごとの埋め込みのトークン同一性成分が省略されます。

例:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Gemma3nForConditionalGeneration

>>> model = Gemma3nForConditionalGeneration.from_pretrained("google/gemma3n2-3b-mix-224")
>>> processor = AutoProcessor.from_pretrained("google/gemma3n2-3b-mix-224")

>>> prompt = "Where is the cat standing?"
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, text=prompt,  return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs,)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Where is the cat standing?\nsnow"
```

#### get_image_features[[transformers.Gemma3nModel.get_image_features]]

```python
get_image_features(pixel_values: FloatTensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1938)

**パラメータ:**

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

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

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

ビジョンモデルの最後の隠れ状態を、言語モデルの空間に射影します。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。
- **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

#### get_audio_features[[transformers.Gemma3nModel.get_audio_features]]

```python
get_audio_features(input_features: Tensor, input_features_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2155)

**パラメータ:**

input_features (`torch.FloatTensor`、shape `(num_images, seq_length, num_features)`) : 入力オーディオに対応するテンソル。

input_features_mask (`torch.FloatTensor`、shape `(num_images, seq_length)`) : 入力オーディオ用のアテンションマスク。

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

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

オーディオエンコーダーの最後の隠れ状態を、言語モデルの空間に射影します。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。
- **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **audio_mel_mask** (`torch.BoolTensor`、*任意*) -- 形状が `(batch_size, num_frames)` の torch.BoolTensor

## Gemma3nForCausalLM[[transformers.Gemma3nForCausalLM]]

#### transformers.Gemma3nForCausalLM[[transformers.Gemma3nForCausalLM]]

```python
transformers.Gemma3nForCausalLM(config: Gemma3nTextConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1788)

**パラメータ:**

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

言語モデリングヘッドを備えたベースのGemma 3n言語モデル。

このモデルは [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.Gemma3nForCausalLM.forward]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1804)

**パラメータ:**

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 (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。インデックスは `[0, ..., config.vocab_size]` の範囲内であるか、-100 である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲内のラベルを持つトークンに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

logits_to_keep (`Union[int, torch.Tensor]`、*任意*、デフォルトは `0`) : `int` の場合、最後の `logits_to_keep` トークンについて logits を計算します。`0` の場合、すべての `input_ids` について logits を計算します（特殊ケース）。生成には最後のトークンの logits だけで十分であり、そのトークンのみについて計算することでメモリを節約できます。これは、長いシーケンスや大規模な語彙サイズの場合に特に顕著な効果があります。`torch.Tensor` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

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

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

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

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

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, 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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

```python
>>> from transformers import AutoTokenizer, Gemma3nForCausalLM

>>> model = Gemma3nForCausalLM.from_pretrained("google/gemma-2-9b")
>>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b")

>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is your favorite condiment?"
```

## Gemma3nForConditionalGeneration[[transformers.Gemma3nForConditionalGeneration]]

#### transformers.Gemma3nForConditionalGeneration[[transformers.Gemma3nForConditionalGeneration]]

```python
transformers.Gemma3nForConditionalGeneration(config: Gemma3nConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2184)

**パラメータ:**

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

ビジョンバックボーン、オーディオバックボーン、言語モデル、言語モデリングヘッドから構成されるベースのGemma 3nモデル。

このモデルは [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.Gemma3nForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, per_layer_inputs: typing.Optional[torch.Tensor] = 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/gemma3n/modeling_gemma3n.py#L2199)

**パラメータ:**

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)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [SiglipImageProcessor](/docs/transformers/main/ja/model_doc/siglip#transformers.SiglipImageProcessor) を使用して取得できます。詳細は [SiglipImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[Gemma3nProcessor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nProcessor) は画像の処理に [SiglipImageProcessor](/docs/transformers/main/ja/model_doc/siglip#transformers.SiglipImageProcessor) を使用します）。

input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [Gemma3nAudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor) を使用して取得できます。詳細は `Gemma3nAudioFeatureExtractor.__call__()` を参照してください（[Gemma3nProcessor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nProcessor) は音声の処理に [Gemma3nAudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor) を使用します）。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

input_features_mask (`torch.Tensor`、*任意*、デフォルトは None) : 入力オーディオ用のアテンションマスク。

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)`）のみを入力する必要があります。

token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : マスク言語モデリング損失を計算するためのラベル。インデックスは `[0, ..., config.text_config.vocab_size]` の範囲内であるか、-100 である必要があります（`input_ids` の docstring を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.text_config.vocab_size]` の範囲内のラベルを持つトークンに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

logits_to_keep (`Union[int, torch.Tensor]`、*任意*、デフォルトは `0`) : `int` の場合、最後の `logits_to_keep` トークンについて logits を計算します。`0` の場合、すべての `input_ids` について logits を計算します（特殊ケース）。生成には最後のトークンの logits だけで十分であり、そのトークンのみについて計算することでメモリを節約できます。これは、長いシーケンスや大規模な語彙サイズの場合に特に顕著な効果があります。`torch.Tensor` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

per_layer_inputs (`torch.Tensor`, *任意*) : 形状が `(batch_size, sequence_length, num_hidden_layers, hidden_size_per_layer_input)` の、層ごとに事前計算された入力テキスト埋め込みです。指定された場合、テキストモデル内で `input_ids` から `get_per_layer_inputs()` を介して計算される代わりに、これらが直接使用されます。`input_ids` の代わりに `inputs_embeds` を指定して `forward` を呼び出す場合は、それらを事前計算し、`inputs_embeds` として渡す必要があります。そうしないと、層ごとの埋め込みのトークン同一性成分が省略されます。

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

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

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

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

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

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_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` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **image_hidden_states** (`torch.FloatTensor`、*任意*) -- サイズが `(batch_size, num_images, sequence_length, hidden_size)` の `torch.FloatTensor`。ビジュアルエンコーダーによって生成されたモデルの image_hidden_states。最後の隠れ状態を投影した後のものです。
- **audio_hidden_states** (`torch.FloatTensor`、*任意*) -- サイズが `(batch_size, num_images, sequence_length, hidden_size)` の `torch.FloatTensor`。オーディオエンコーダーによって生成され、最後の隠れ状態を投影した後のモデルの audio_hidden_states です。

例:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Gemma3ForConditionalGeneration

>>> model = Gemma3ForConditionalGeneration.from_pretrained("google/gemma-3-4b-it")
>>> processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")

>>> messages = [
...     {
...         "role": "system",
...         "content": [
...             {"type": "text", "text": "You are a helpful assistant."}
...         ]
...     },
...     {
...         "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,
...     tokenizer=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, clean_up_tokenization_spaces=False)[0]
"user\nYou are a helpful assistant.\n\n\n\n\n\nWhere is the cat standing?\nmodel\nBased on the image, the cat is standing in a snowy area, likely outdoors. It appears to"
```

#### get_image_features[[transformers.Gemma3nForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: FloatTensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2195)

**パラメータ:**

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

例:

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

>>> model = Gemma3nForConditionalGeneration.from_pretrained("google/gemma-3n-E4B")
>>> processor = AutoProcessor.from_pretrained("google/gemma-3n-E4B")

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

[altup]: https://proceedings.neurips.cc/paper_files/paper/2023/hash/f2059277ac6ce66e7e5543001afa8bb5-Abstract-Conference.html [attention-mask-viz]: https://github.com/huggingface/transformers/blob/beb9b5b02246b9b7ee81ddf938f93f44cfeaad19/src/transformers/utils/attention_visualizer.py#L139 [gemma3n-collection]: https://huggingface.co/collections/google/gemma-3n [laurel]: https://huggingface.co/papers/2411.07501 [matformer]: https://huggingface.co/papers/2310.07707 [spark-transformer]: https://huggingface.co/papers/2506.06644 [usm]: https://huggingface.co/papers/2303.01037