# Gemma4 ## 概要 Gemma 4 は、事前学習済みと指示チューニング済みのバリアントが用意されているマルチモーダルモデルで、E2B、E4B、31B、26B-A4B (MoE) のパラメータサイズが利用可能です。Gemma 4 モデルは、以下の機能を提供します。 - 推論: このファミリーのすべてのモデルは、設定可能な思考モードを備えた、高度な推論能力を持つ推論者として設計されています。 - 拡張マルチモーダル性: テキスト、可変のアスペクト比と解像度をサポートする画像（すべてのモデル）、動画、および音声（E2BおよびE4Bモデルでネイティブ対応）を処理します。 - コンテキストウィンドウの拡大: 小型モデルは128Kのコンテキストウィンドウを備えており、その他のモデルは256Kに対応しています。 - コーディングおよびエージェント機能の強化: 組み込みの関数呼び出しサポートにより、コーディングベンチマークで顕著な改善を実現し、高度な自律エージェントを駆動します。 - ネイティブなシステムプロンプトのサポート: Gemma 4では、システムロールの組み込みサポートが導入され、より構造化され、制御可能な対話が可能になりました。 [Gemma 4](https://huggingface.co/collections/google/gemma-4)リリースの下に、すべてのオリジナルの Gemma 4 チェックポイントを見つけることができます。 ### Gemma4 Vision モデル ビジョン機能において、以前の Gemma リリースとの主な違いは、**固定のトークン数**を使用して**異なるサイズの画像**を処理する新しい設計にあります。多くのモデルがすべての画像を固定の正方形（224×224 など）に圧縮するのに対し、Gemma 4 は画像の自然なアスペクト比を維持したまま、適切なサイズに調整します。以下のいくつかの制約を遵守する必要があります。 - 総ピクセル数はパッチ予算の範囲内に収まる必要があります - 高さも幅も、**48**（= パッチサイズ 16 × プーリングカーネル 3）で割り切れる必要があります。 > [!IMPORTANT] > Gemma 4 は、他の多くのビジョンモデルで使用されている標準的な ImageNet の平均/標準偏差による正規化を**適用しません**。モデル自体の patch embedding 層が最終的なスケーリングを内部で処理します（値を [-1, 1] の範囲にシフトします）。 画像プロセッサが生成できる「ソフトトークン」（ビジョントークンとも呼ばれる）の数は設定可能です。サポートされているオプションは以下に示されており、デフォルト値は1画像あたり**280ソフトトークン**です。 | ソフトトークン | パッチ(プーリング前) | おおよその画像領域 | |:-----------:|:------------------------:|:-------------------:| | 70 | 630 | 約161Kピクセル | | 140 | 1,260 | 約323Kピクセル | | **280** | **2,520** | **約645Kピクセル** | | 560 | 5,040 | 約130万ピクセル | | 1,120 | 10,080 | 約260万ピクセル | 画像内の各パッチの位置情報をエンコードするために、Gemma 4 は学習された 2D 位置埋め込みテーブルを使用します。位置テーブルは軸ごとに最大 10,240 個の位置を保持しており、これによりモデルは非常に大きな画像を処理できます。各位置は、パッチ埋め込みと同じ次元を持つ学習ベクトルです。Gemma 4 が使用する 2D RoPE は、アテンションヘッドの次元のうち半分を x 軸用に、残りの半分を y 軸用に独立して回転させます。これにより、モデルは「上」「下」「左」「右」のような空間的な関係を理解できます。 ### レイヤー別埋め込み（PLE） Gemma 4 は、入力部の単一の共有埋め込みにのみ依存するのではなく、各デコーダ層に補助的な残差シグナルを供給する Per-Layer Embeddings (PLE) システムを導入しています。 PLEは、2つのコンポーネントを合計し、`1/√2`でスケーリングしてから、各デコーダ層に渡すという構成です。 1. Token-identity（`get_per_layer_inputs`）: `embed_tokens_per_layer`（`√(hidden_size_per_layer_input)` を乗算する `Gemma4TextScaledWordEmbedding`）で `input_ids` を参照します。パッキングされた出力は、`[batch, seq, num_hidden_layers * hidden_size_per_layer_input]` から `[batch, seq, num_hidden_layers, hidden_size_per_layer_input]` にリサイズされます。 2. コンテキスト認識型（`project_per_layer_inputs`）: `inputs_embeds` を `per_layer_model_projection`（Linear レイヤー）で投影し、`1/√(hidden_size)` 倍でスケーリングし、`[batch, seq, num_layers, ple_dim]` にリサイズして、`per_layer_projection_norm`（RMSNorm）で正規化します。 両方のコンポーネントが利用可能な場合、最終的なレイヤーごとの入力は`(token_identity + context_aware) * (1/√2)`になります。`input_ids`が利用できないマルチモーダル入力の場合、コンテキスト認識プロジェクションのみが使用されます。 ## 使用例 以下の例では、[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-4-E2B-it", ) pipeline( images="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", text="<|image|>\n\nWhat is shown in this image?" ) ``` ```python from transformers import AutoModelForImageTextToText, AutoProcessor model = AutoModelForImageTextToText.from_pretrained( "google/gemma-4-E2B-it", device_map="auto", attn_implementation="sdpa" ) processor = AutoProcessor.from_pretrained( "google/gemma-4-E2B-it", padding_side="left" ) 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, ).to(model.device) input_len = inputs["input_ids"].shape[-1] output = model.generate(**inputs, max_new_tokens=50, cache_implementation="static") print(processor.decode(output[0][input_len:], skip_special_tokens=True)) ``` ### Function calling ```python from transformers import AutoModelForCausalLM, AutoProcessor WEATHER_TOOL = { "type": "function", "function": { "name": "get_n_day_weather_forecast", "description": "Get an N-day weather forecast", "parameters": { "type": "object", "properties": { "location": { "type": "string", "description": "The city and state, e.g. San Francisco, CA", }, "format": { "type": "string", "enum": ["celsius", "fahrenheit"], "description": "The temperature unit to use", }, "num_days": { "type": "integer", "description": "The number of days to forecast", }, }, "required": ["location", "format", "num_days"], }, }, } messages = [ { "role": "user", "content": "What's the weather like the next 3 days in San Francisco, CA (using F)?", }, ] model = AutoModelForCausalLM.from_pretrained( "google/gemma-4-E2B-it", device_map="auto", attn_implementation="sdpa" ) processor = AutoProcessor.from_pretrained( "google/gemma-4-E2B-it", padding_side="left" ) text = processor.apply_chat_template( messages, tools=[WEATHER_TOOL], tokenize=False, add_generation_prompt=True, ) inputs = processor(text=text, return_tensors="pt").to(model.device) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=200) print(processor.decode(outputs[0][input_len:], skip_special_tokens=False)) ``` ### Audio (E2BおよびE4Bのみ) ```python from transformers import AutoModelForMultimodalLM, AutoProcessor messages = [ { "role": "user", "content": [ {"type": "text", "text": "Please transcribe the following audio:"}, { "type": "audio", "url": "https://huggingface.co/datasets/eustlb/audio-samples/resolve/main/dude_where_is_my_car.wav", }, ], } ] model = AutoModelForMultimodalLM.from_pretrained( "google/gemma-4-E2B-it", device_map="auto", attn_implementation="sdpa" ) processor = AutoProcessor.from_pretrained( "google/gemma-4-E2B-it", padding_side="left" ) inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors="pt" ).to(model.device, dtype=model.dtype) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=200) print(processor.decode(outputs[0][input_len:], skip_special_tokens=False)) ``` ## Gemma4AudioConfig[[transformers.Gemma4AudioConfig]] #### transformers.Gemma4AudioConfig[[transformers.Gemma4AudioConfig]] ```python transformers.Gemma4AudioConfig(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, hidden_size: int = 1024, num_hidden_layers: int = 12, num_attention_heads: int = 8, hidden_act: str = 'silu', subsampling_conv_channels: list[int] | tuple[int, int] = (128, 32), conv_kernel_size: int = 5, residual_weight: float = 0.5, attention_chunk_size: int = 12, attention_context_left: int = 13, attention_context_right: int = 0, attention_logit_cap: float = 50.0, attention_invalid_logits_value: float = -1000000000.0, use_clipped_linears: bool = True, rms_norm_eps: float = 1e-06, gradient_clipping: float = 10000000000.0, output_proj_dims: int = 1536, initializer_range: float = 0.02) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/configuration_gemma4.py#L29) **パラメータ:** hidden_size (`int`、*任意*、デフォルトは`1024`) : 隠れ表現の次元数。 num_hidden_layers (`int`, *任意*, デフォルトは `12`) : Transformer デコーダーの隠れ層の数。 num_attention_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。 hidden_act (`str`、*任意*、デフォルトは`silu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。 subsampling_conv_channels (`list[int]`、デフォルトは`[128, 32]`) : Sub-sample Convolution Projection内の畳み込み層のチャネルサイズ。 conv_kernel_size (`int`、*任意*、デフォルトは`5`) : 畳み込みカーネルのサイズ。 residual_weight (`float`、デフォルトは`0.5`) : feedforward で残差と結合する前に hidden_states に適用されるスケーリング。 attention_chunk_size (`int`、デフォルトは`12`) : attention処理におけるサブシーケンスサイズです。 attention_context_left (`int`、デフォルトは`13`) : attention chunk の左方向のコンテキストサイズです。 attention_context_right (`int`、デフォルトは`0`) : attention chunk の右方向コンテキストサイズです。 attention_logit_cap (`float`、デフォルトは`50.0`) : 注意度重みに適用される上限値。 attention_invalid_logits_value (`float`、デフォルトは`1e-9`) : attentionにおける無効なlogitsに使用する値。 use_clipped_linears (`bool`、デフォルトは`True`) : true の場合、モデルのチェックポイントから境界値を取得して、Linear レイヤーにクリッピングを適用します。 rms_norm_eps (`float`、*任意*、デフォルトは`1e-06`) : rms 正規化レイヤーで使用する epsilon。 gradient_clipping (`float`、デフォルトは`1e10`) : 非常に大きな勾配値を安定化するために使用されるクリッピング値。 output_proj_dims (`int`、デフォルトは`1536`) : `hidden_size`からモデルの出力への最終的な線形変換の次元数。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 これはGemma4Modelの設定を保存するための設定クラスです。指定された引数に基づいてGemma4モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-4-e2b-it](https://huggingface.co/google/gemma-4-e2b-it)と類似した設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 ## Gemma4VisionConfig[[transformers.Gemma4VisionConfig]] #### transformers.Gemma4VisionConfig[[transformers.Gemma4VisionConfig]] ```python transformers.Gemma4VisionConfig(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, hidden_size: int = 768, intermediate_size: int = 3072, num_hidden_layers: int = 16, num_attention_heads: int = 12, num_key_value_heads: int = 12, head_dim: int = 64, hidden_activation: str = 'gelu_pytorch_tanh', rms_norm_eps: float = 1e-06, max_position_embeddings: int = 131072, attention_bias: bool | None = False, attention_dropout: float | None = 0.0, rope_parameters: dict | None = None, pooling_kernel_size: int = 3, patch_size: int = 16, position_embedding_size: int = 10240, use_clipped_linears: bool = False, standardize: bool = False, initializer_range: float = 0.02) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/configuration_gemma4.py#L271) **パラメータ:** hidden_size (`int`、*任意*、デフォルトは`768`) : 隠れ表現の次元数。 intermediate_size (`int`、*任意*、デフォルトは `3072`) : MLP 表現の次元数。 num_hidden_layers (`int`、*任意*、デフォルトは`16`) : Transformer デコーダーの隠れ層の数。 num_attention_heads (`int`、*任意*、デフォルトは `12`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。 num_key_value_heads (`int`、*任意*、デフォルトは`12`) : 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`、*任意*、デフォルトは`64`) : アテンションヘッドの次元数。None の場合、hidden_size // num_attention_heads がデフォルトとして使用されます。 hidden_activation (`str`、*任意*、デフォルトは `gelu_pytorch_tanh`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"` など。 rms_norm_eps (`float`、*任意*、デフォルトは`1e-06`) : rms 正規化レイヤーで使用する epsilon。 max_position_embeddings (`int`、*任意*、デフォルトは `131072`) : このモデルが使用される可能性のある最大シーケンス長です。 attention_bias (`bool`、*任意*、デフォルトは`False`) : セルフアテンションにおけるクエリ、キー、バリュー、出力の投影層でバイアスを使用するかどうか。 attention_dropout (`float`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率です。 rope_parameters (`dict`, *任意*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれており、より長い `max_position_embeddings` で RoPE を使用する場合にスケーリングに使用されるパラメータが任意で含まれます。 pooling_kernel_size (`int`, *任意*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 patch_size (`int`, *optional*, デフォルトは `16`) : 各パッチのサイズ（解像度）。 position_embedding_size (`int`、デフォルトは 10240) : ビジョンエンコーダーの位置埋め込みの最大数。パッチエンベッダーで使用される学習済み 2D 位置埋め込みテーブルのサイズを制御します。 use_clipped_linears (`bool`、デフォルトは`False`) : 重みクリップ付きの線形層を使用するかどうか。有効にすると、線形層の重みがフォワードパス中に固定範囲にクランプされ、数値的安定性が向上します。 standardize (`bool`、デフォルトは`False`) : true の場合、プーラーから返されるソフトトークンにバイアスとスケールを適用します。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 これはGemma4Modelの設定を保存するための設定クラスです。指定された引数に基づいてGemma4モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-4-e2b-it](https://huggingface.co/google/gemma-4-e2b-it)と類似した設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 ## Gemma4TextConfig[[transformers.Gemma4TextConfig]] #### transformers.Gemma4TextConfig[[transformers.Gemma4TextConfig]] ```python transformers.Gemma4TextConfig(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, 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 | None = None, use_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = None, vocab_size_per_layer_input: int = 262144, hidden_size_per_layer_input: int = 256, attention_k_eq_v: bool = False, num_kv_shared_layers: int = 0, enable_moe_block: bool = False, use_double_wide_mlp: bool = False, 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/gemma4/configuration_gemma4.py#L87) **パラメータ:** 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。 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`, *optional*) : 確率分布を計算する前に最終 logits に適用されるソフトキャップ値。logits は `tanh(logit / cap) * cap` によってスケーリングされます。 use_bidirectional_attention (`str`, *任意*) : 双方向アテンションの動作を制御します。`"vision"`に設定すると、ビジョントークンは双方向にアテンションを行い、テキストトークンは因果アテンションを使用します。`"all"`に設定すると、すべてのトークンが双方向アテンションを使用します。 vocab_size_per_layer_input (`int`、デフォルトは 262144) : 層別入力埋め込み (PLE) の語彙サイズです。層別残差ストリームを持つモデルで使用され、各デコーダー層でより小さい埋め込みが加算されます。 hidden_size_per_layer_input (`int`、デフォルト値は 256) : PLE システムにおける各層の隠れ次元です。すべての層が単一のテーブルにパックされるため、実際の埋め込み重みの形状は `[vocab_size_per_layer_input, num_hidden_layers * hidden_size_per_layer_input]` になります。PLE パイプライン全体の説明については、[Gemma4](https://huggingface.co/docs/transformers/main/en/model_doc/gemma4#per-layer-embeddings-ple) のドキュメントを参照してください。 attention_k_eq_v (`bool`、デフォルトは`False`) : キーとバリューが同じ投影重みを共有するかどうか。`True`の場合、キー投影の出力がバリュー投影として再利用されます。 num_kv_shared_layers (`int`、デフォルトは 0) : 同じ key-value 射影を共有する連続するデコーダー層の数。0 を指定すると共有を行いません（各層が独立した KV 射影を持ちます）。 enable_moe_block (`bool`、デフォルトは`False`) : デコーダー層でMixture-of-Experts (MoE) ブロックを有効にするかどうか。`True`の場合、対象となる層はスパースなMoEフィードフォワードネットワークを使用します。 use_double_wide_mlp (`bool`、デフォルトは`False`) : gate と up の投影を融合した、幅が2倍の MLP を使用するかどうか。 num_experts (`int`, *任意*) : MoE層におけるルーティング対象のエクスパートの数。 top_k_experts (`int`, *任意*) : MoE層でトークンごとにアクティブ化されるエキスパートの数。`enable_moe_block=True` の場合のみ使用されます。 moe_intermediate_size (`int`, *任意*) : MoE層における各エキスパートのフィードフォワードネットワークの中間（隠れ）サイズ。`enable_moe_block=True` の場合のみ使用されます。 これはGemma4Modelの設定を保存するための設定クラスです。指定された引数に基づいてGemma4モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-4-e2b-it](https://huggingface.co/google/gemma-4-e2b-it)と類似した設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 ## Gemma4Config[[transformers.Gemma4Config]] #### transformers.Gemma4Config[[transformers.Gemma4Config]] ```python transformers.Gemma4Config(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.gemma4.configuration_gemma4.Gemma4TextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.models.gemma4.configuration_gemma4.Gemma4VisionConfig | dict[str, typing.Any] | None = None, audio_config: transformers.models.gemma4.configuration_gemma4.Gemma4AudioConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, video_token_id: int | None = 258884, boa_token_id: int | None = 256000, eoa_token_index: int | None = 258883, audio_token_id: int | None = 258881, initializer_range: float | None = 0.02, tie_word_embeddings: bool = True) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/configuration_gemma4.py#L323) **パラメータ:** text_config (`Union[~models.gemma4.configuration_gemma4.Gemma4TextConfig, dict[str, Any]]`, *任意*) : テキストバックボーンの config オブジェクトまたは辞書。 vision_config (`Union[~models.gemma4.configuration_gemma4.Gemma4VisionConfig, dict[str, Any]]`, *任意*) : ビジョンバックボーンの config オブジェクトまたは辞書。 audio_config (`Union[~models.gemma4.configuration_gemma4.Gemma4AudioConfig, 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`) : 入力画像のプレースホルダーとして使用される画像トークンのインデックスです。 video_token_id (`int`、*任意*、デフォルトは`258884`) : 入力動画のプレースホルダーとして使用される動画トークンのインデックスです。 boa_token_id (`int`、*optional*、デフォルトは 256000) : 音声プロンプトをラップするための begin-of-audio トークンインデックスです。 eoa_token_index (`int`、*optional*、デフォルトは 258883) : 音声プロンプトをラップするための end-of-audio トークンインデックスです。 audio_token_id (`int`、*optional*、デフォルトは`258881`) : 入力音声のプレースホルダーとして使用されるオーディオトークンのインデックスです。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。 これはGemma4Modelの設定を保存するための設定クラスです。指定された引数に基づいてGemma4モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/gemma-4-e2b-it](https://huggingface.co/google/gemma-4-e2b-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 ( >>> Gemma4AudioConfig, >>> Gemma4Config, >>> Gemma4ForConditionalGeneration, >>> Gemma4TextConfig, >>> Gemma4VisionConfig, >>> ) >>> # Initializing a Gemma 4 Audio config. >>> audio_config = Gemma4AudioConfig() >>> # Initializing a Gemma 4 Text config. >>> text_config = Gemma4TextConfig() >>> # Initializing a Gemma 4 vision config. >>> vision_config = Gemma4VisionConfig() >>> # Initializing a Gemma 4 config similar to google/gemma-4-e2b-it >>> configuration = Gemma4Config(text_config, vision_config, audio_config) >>> # Initializing a model from the google/gemma-4-e2b-it configuration >>> model = Gemma4ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Gemma4AudioFeatureExtractor[[transformers.Gemma4AudioFeatureExtractor]] #### transformers.Gemma4AudioFeatureExtractor[[transformers.Gemma4AudioFeatureExtractor]] ```python transformers.Gemma4AudioFeatureExtractor(feature_size: int = 128, sampling_rate: int = 16000, padding_value: float = 0.0, return_attention_mask: bool = True, frame_length_ms: float = 20.0, hop_length_ms: float = 10.0, min_frequency: float = 0.0, max_frequency: float = 8000.0, preemphasis: float = 0.0, preemphasis_htk_flavor: bool = True, fft_overdrive: bool = False, dither: float = 0.0, input_scale_factor: float = 1.0, mel_floor: float = 0.001, 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/gemma4/feature_extraction_gemma4.py#L49) **パラメータ:** 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`、*任意*、デフォルトは 20.0) : フレームの長さ（ミリ秒）。 hop_length_ms (`float`、*optional*、デフォルト値は 10.0) : Mel 周波数係数を取得するために使用される STFT の、重複ウィンドウの長さ。 min_frequency (`float`、*任意*、デフォルトは 0.0) : Mel フィルターバンクの最小周波数 (Hz)。 max_frequency (`float`、*optional*、デフォルトは 8000.0) : Mel フィルターバンクの最大周波数 (Hz)。 preemphasis (`float`、*任意*、デフォルトは 0.0) : 事前強調係数です。 preemphasis_htk_flavor (`bool`、*任意*、デフォルトは`True`) : HTKスタイルの事前強調を使用するかどうか。 fft_overdrive (`bool`、*任意*、デフォルトは`False`) : 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`、*任意*、デフォルトは 0.001) : log(0) を回避するために、Mel スペクトログラムに設定する最小値。 per_bin_mean (`Optional[Sequence[float]]`, *任意*) : バインごとの正規化のための平均値。 per_bin_stddev (`Optional[Sequence[float]]`, *任意*) : バインごとの正規化に使用する標準偏差の値。 音声特徴抽出器 Universal Speech Models https://huggingface.co/papers/2303.01037。 #### __call__[[transformers.Gemma4AudioFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy = 'longest', max_length: int | None = 480000, truncation: bool = True, pad_to_multiple_of: int | None = 128, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = True, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/feature_extraction_gemma4.py#L226) **パラメータ:** raw_speech : MELスペクトログラムが作成されるオーディオ。 padding (`Union[bool, str, PaddingStrategy]`、*任意*、デフォルトは `"longest"`) : 長さが異なるオーディオのバッチに対して使用するパディング戦略です。 max_length (`int`, *optional*, デフォルトは 480000) : 指定された場合、許可される音声の最大長を定義します。`truncation=True` の場合、これより長い音声は切り詰められます。 truncation (`bool`、*任意*、デフォルトは `True`) : `max_length` を超えるオーディオを切り詰めるかどうか。 pad_to_multiple_of (`int`、*optional*、デフォルト値は 128) : パディングを行う場合、この値の倍数にパディングします。デフォルト値は、TPU での最適なサポートのために定義されています。 return_tensors (`Union[str, TensorType]`、*任意*、デフォルトは`None`) : 返すテンソルの型（例：NumPy、Torch など）。 return_attention_mask (`bool`、*任意*、デフォルトは `True`) : 生成された MEL スペクトログラムの attention mask を返すかどうかを指定します。 提供された生音声からMELスペクトログラムのバッチを作成します。 この実装は、ウィンドウ処理とプリエンファシスに異なるアルゴリズムを使用しており、組み込みの `transformers.audio_utils.spectrogram()` 関数とは _異なる_ 出力になります。特に事前学習済みモデルを使用する場合は、オーディオ特徴抽出器の選択時にこの点を慎重に検討してください。 ## Gemma4ImageProcessorPil[[transformers.Gemma4ImageProcessorPil]] #### transformers.Gemma4ImageProcessorPil[[transformers.Gemma4ImageProcessorPil]] ```python transformers.Gemma4ImageProcessorPil(**kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/image_processing_pil_gemma4.py#L137) **パラメータ:** do_convert_rgb (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *任意*, デフォルトは `True`) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *任意*、デフォルトは `True`) : size が整数の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*、デフォルトは `3`) : 画像をリサイズする場合に使用するリサンプリングフィルター。`PILImageResampling` の列挙型のいずれかになります。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。 do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `False`) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.0, 0.0, 0.0]`) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[1.0, 1.0, 1.0]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 patch_size (`int`, *kwargs*, *任意*) : 各画像パッチのピクセル数。 max_soft_tokens (`int`, *kwargs*, *任意*) : 1枚の画像あたりのソフト（ビジョン）トークンの最大数。{70, 140, 280, 560, 1120} のいずれかである必要があります。 pooling_kernel_size (`int`, *kwargs*, *optional*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 Gemma4の画像プロセッサを構築します。 #### preprocess[[transformers.Gemma4ImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/image_processing_pil_gemma4.py#L167) **パラメータ:** 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` を設定してください。 do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *optional*) : size が int の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 画像をリサイズする場合に使用するリサンプリングフィルタ。`PILImageResampling` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*) : `do_rescale` が `True` に設定されている場合、画像をリサイズするためのリスケール係数。 do_normalize (`bool`, *kwargs*, *optional*) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 patch_size (`int`, *kwargs*, *任意*) : 各画像パッチのピクセル数。 max_soft_tokens (`int`, *kwargs*, *任意*) : 1枚の画像あたりのソフト（ビジョン）トークンの最大数。{70, 140, 280, 560, 1120} のいずれかである必要があります。 pooling_kernel_size (`int`, *kwargs*, *optional*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 **戻り値:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- __call__ メソッドによって返されるリスト/配列/テンソルの辞書（'pixel_values' など）。 - **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。 ## Gemma4ImageProcessor[[transformers.Gemma4ImageProcessor]] #### transformers.Gemma4ImageProcessor[[transformers.Gemma4ImageProcessor]] ```python transformers.Gemma4ImageProcessor(**kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/image_processing_gemma4.py#L136) **パラメータ:** do_convert_rgb (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *任意*, デフォルトは `True`) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*、デフォルトは `None`) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *任意*、デフォルトは `True`) : size が整数の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*、デフォルトは `3`) : 画像をリサイズする場合に使用するリサンプリングフィルター。`PILImageResampling` の列挙型のいずれかになります。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。 do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `False`) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.0, 0.0, 0.0]`) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[1.0, 1.0, 1.0]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 patch_size (`int`, *kwargs*, *任意*) : 各画像パッチのピクセル数。 max_soft_tokens (`int`, *kwargs*, *任意*) : 1枚の画像あたりのソフト（ビジョン）トークンの最大数。{70, 140, 280, 560, 1120} のいずれかである必要があります。 pooling_kernel_size (`int`, *kwargs*, *optional*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 Gemma4の画像プロセッサを構築します。 #### preprocess[[transformers.Gemma4ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/image_processing_gemma4.py#L193) ## Gemma4VideoProcessor[[transformers.Gemma4VideoProcessor]] #### transformers.Gemma4VideoProcessor[[transformers.Gemma4VideoProcessor]] ```python transformers.Gemma4VideoProcessor(**kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/video_processing_gemma4.py#L155) **パラメータ:** do_convert_rgb (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *任意*, デフォルトは `True`) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*、デフォルトは `None`) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *任意*、デフォルトは `True`) : size が整数の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*、デフォルトは `3`) : 画像をリサイズする場合に使用するリサンプリングフィルター。`PILImageResampling` の列挙型のいずれかになります。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。 do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.0, 0.0, 0.0]`) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[1.0, 1.0, 1.0]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 do_sample_frames (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 処理前に動画からフレームをサンプリングするか、動画全体を処理するかどうかを指定します。 video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : 動画のメタデータ。総再生時間、fps、総フレーム数などの情報を含みます。動画からのフレームサンプリングやタイムスタンプの計算に使用されます。動画を処理する前に手動でデコードしようとしている場合を除き、メタデータは渡さないでください。 fps (`Annotated[int | float | None, None]`, *kwargs*) : `do_sample_frames=True` の場合、1 秒あたりにサンプリングするターゲットフレーム数。 num_frames (`Annotated[int | None, None]`, *kwargs*、デフォルトは `32`) : `do_sample_frames=True` の場合、サンプリングするフレームの最大数。 return_metadata (`bool`, *kwargs*, *任意*、デフォルトは `False`) : ビデオメタデータを返すかどうかを指定します。ビデオメタデータは、ビデオの長さ、fps、デコードバックエンドなどの情報を含むオブジェクトです。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 設定されている場合、特定のフレームワークのテンソルを返します。許可される値は以下の通りです。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。 patch_size (`int`, *kwargs*, *任意*) : 各画像パッチのピクセル数。 max_soft_tokens (`int`, *kwargs*, *任意*) : 1枚の動画フレームあたりのソフト（ビジョン）トークンの最大数。{70, 140, 280, 560, 1120} のいずれかである必要があります。 pooling_kernel_size (`int`, *kwargs*, *optional*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDict クラスを参照してください。 Gemma4VideoProcessorの動画プロセッサを構築します。 #### preprocess[[transformers.Gemma4VideoProcessor.preprocess]] ```python preprocess(videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]]], **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/video_processing_gemma4.py#L214) **パラメータ:** videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`) : 前処理対象の動画。ピクセル値が 0 から 255 の範囲にある、単一の動画またはバッチの動画を想定しています。ピクセル値が 0 から 1 の範囲にある動画を渡す場合は、`do_rescale=False` を設定してください。 do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *optional*) : size が int の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 画像をリサイズする場合に使用するリサンプリングフィルタ。`PILImageResampling` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*) : `do_rescale` が `True` に設定されている場合、画像をリサイズするためのリスケール係数。 do_normalize (`bool`, *kwargs*, *optional*) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 do_sample_frames (`bool`, *kwargs*, *optional*) : 処理前に動画からフレームをサンプリングするか、動画全体を処理するかを指定します。 video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : 動画のメタデータ。総再生時間、fps、総フレーム数などの情報を含みます。動画からのフレームサンプリングやタイムスタンプの計算に使用されます。動画を処理する前に手動でデコードしようとしている場合を除き、メタデータは渡さないでください。 fps (`Annotated[int | float | None, None]`, *kwargs*) : `do_sample_frames=True` の場合、1 秒あたりにサンプリングするターゲットフレーム数。 num_frames (`Annotated[int | None, None]`, *kwargs*) : `do_sample_frames=True` の場合、サンプリングするフレームの最大数。 return_metadata (`bool`, *kwargs*, *任意*) : ビデオメタデータを返すかどうかを指定します。ビデオメタデータは、ビデオの再生時間、fps、デコードバックエンドなどの情報を含むオブジェクトです。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 patch_size (`int`, *kwargs*, *任意*) : 各画像パッチのピクセル数。 max_soft_tokens (`int`, *kwargs*, *任意*) : 1枚の動画フレームあたりのソフト（ビジョン）トークンの最大数。{70, 140, 280, 560, 1120} のいずれかである必要があります。 pooling_kernel_size (`int`, *kwargs*, *optional*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 **戻り値:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- __call__ メソッドによって返されるリスト/配列/テンソルの辞書（'pixel_values' など）。 - **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。 ## Gemma4Processor[[transformers.Gemma4Processor]] #### transformers.Gemma4Processor[[transformers.Gemma4Processor]] ```python transformers.Gemma4Processor(feature_extractor, image_processor, tokenizer, video_processor, chat_template = None, image_seq_length: int = 280, audio_seq_length: int = 750, audio_ms_per_token: int = 40, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/processing_gemma4.py#L100) **パラメータ:** feature_extractor (*Gemma4AudioFeatureExtractor*) : 特徴抽出器は必須の入力です。 image_processor (*Gemma4ImageProcessor*) : 画像プロセッサは必須の入力です。 tokenizer (*tokenizer_class*) : トークナイザーは必須の入力です。 video_processor (*Gemma4VideoProcessor*) : 動画プロセッサは必須の入力です。 chat_template (*str*) : チャット内のメッセージのリストをトークン化可能な文字列に変換するための Jinja テンプレート。 image_seq_length (*int*、*optional*、デフォルトは 280) : プレースホルダーの展開に使用される、1 画像あたりのソフトトークン数。 audio_seq_length (*int*, *optional*, デフォルト値は 750) : 1 つの音声セグメントあたりの音声ソフトトークンの最大数です。動的な音声トークン数が計算される際の上限として機能します。 audio_ms_per_token (*int*、*optional*、デフォルトは 40) : 出力される 1 つの soft token に対応する音声のミリ秒数。`ceil(duration_ms / audio_ms_per_token)` として、音声プレースホルダー token の数を動的に計算するために使用されます。デフォルト値 40 は、10ms フレームに対する SSCP 畳み込みの 4 倍の時間削減に由来します。 feature extractor、image processor、tokenizer、video processorを単一のプロセッサーにラップするGemma4Processorを構築します。 [*Gemma4Processor*] は、[*Gemma4AudioFeatureExtractor*]、[*Gemma4ImageProcessor*]、[*tokenizer_class*]、および [*Gemma4VideoProcessor*] のすべての機能を提供します。詳細については、[*~Gemma4AudioFeatureExtractor*]、[*~Gemma4ImageProcessor*]、[*~tokenizer_class*]、および [*~Gemma4VideoProcessor*] を参照してください。 #### __call__[[transformers.Gemma4Processor.__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 = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L657) **パラメータ:** 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` を設定してください。 videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *任意*) : 前処理対象の動画。ピクセル値が 0 から 255 の範囲にある単一の動画またはバッチを想定しています。ピクセル値が 0 から 1 の範囲にある動画を渡す場合は、`do_rescale=False` を設定してください。 audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *任意*) : 準備対象のオーディオまたはオーディオのバッチです。各オーディオは 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 クラスを参照してください。 ## Gemma4PreTrainedModel[[transformers.Gemma4PreTrainedModel]] #### transformers.Gemma4PreTrainedModel[[transformers.Gemma4PreTrainedModel]] ```python transformers.Gemma4PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1443) **パラメータ:** 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.Gemma4PreTrainedModel.forward]] ```python forward(*args, **kwargs) ``` ドット区切りパス（例: `torch.float32`）に対するモック値: 属性アクセスのチェーン、呼び出しはパススルーデコレータとして動作し、`repr` はドット区切りパスを返し、ベースクラスとして使用するとプレーンな `type` ベースに置き換えられます（PEP 560 の `__mro_entries__`）。これにより、実際のサブクラスは通常のメタクラスを保持し、`inspect.signature` はモックのものではなく実際の `__init__` を読み取ります。 ## Gemma4AudioModel[[transformers.Gemma4AudioModel]] #### transformers.Gemma4AudioModel[[transformers.Gemma4AudioModel]] ```python transformers.Gemma4AudioModel(config: Gemma4AudioConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1885) [Universal Speech Model](https://huggingface.co/papers/2303.01037)アーキテクチャに基づく音声エンコーダー。 #### forward[[transformers.Gemma4AudioModel.forward]] ```python forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1942) **パラメータ:** input_features (`torch.Tensor`、shape `(batch_size, sequence_length, feature_dim)`) : 入力音声特徴に対応するテンソルです。音声特徴は [Gemma4AudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) を使用して取得できます。詳細は [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は音声の処理に [Gemma4AudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) を使用します）。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) **戻り値:** `tuple[torch.Tensor, torch.BoolTensor]` 音声特徴をソフトトークンにエンコードします。 ## Gemma4VisionModel[[transformers.Gemma4VisionModel]] #### transformers.Gemma4VisionModel[[transformers.Gemma4VisionModel]] ```python transformers.Gemma4VisionModel(config: Gemma4VisionConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1977) Gemma 4 Vision Encoder。 #### forward[[transformers.Gemma4VisionModel.forward]] ```python forward(pixel_values: FloatTensor, pixel_position_ids: LongTensor, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1998) **パラメータ:** pixel_values (`torch.FloatTensor` または `list[torch.FloatTensor]`) : エンコードする画像。単一の `[batch, channels, height, width]` テンソル（すべての画像が同じサイズ）または、`[1, channels, height, width]` テンソルのリスト（サイズが異なる場合）。 pixel_position_ids (`torch.LongTensor`、shape `(batch_size, max_patches, 2)`) : 画像内の (x, y) 座標としてのパッチ位置。パディングされたパッチは (-1, -1) で示されます。 **戻り値:** [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `tuple(torch.FloatTensor)` [Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config) や入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 パッチからソフトトークンへ、画像ピクセルをエンコードします。 - **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 ## Gemma4TextModel[[transformers.Gemma4TextModel]] #### transformers.Gemma4TextModel[[transformers.Gemma4TextModel]] ```python transformers.Gemma4TextModel(config: Gemma4TextConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1544) **パラメータ:** config ([Gemma4TextConfig](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4TextConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 言語モデリングヘッドを備えないベースのGemma 4言語モデル。 このモデルは [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.Gemma4TextModel.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, per_layer_inputs: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1601) **パラメータ:** 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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 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` として渡す必要があるでしょう。そうしないと、それらを再計算するためにメインの埋め込みを逆算する必要があり、コストが高くなります。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** `Gemma4TextModelOutputWithPast` または `tuple(torch.FloatTensor)` `Gemma4TextModelOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config)）や入力に応じて、さまざまな要素で構成されます。 [Gemma4TextModel](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4TextModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **shared_kv_states** (`KVSharingDict`、*任意*) -- レイヤー型の文字列を、(key_states, value_states) テンソルのタプルにマッピングする dict 形式のコンテナ。KV シェアリング時に、レイヤー間で共有 KV 状態を渡すために使用されます。 - **router_logits** (`tuple(torch.FloatTensor)`、*optional*、`output_router_logits=True` が渡された場合に返されます) -- 各 MoE レイヤーに対応する `torch.FloatTensor` のタプルで、形状は `(batch_size * sequence_length, num_experts)` です。 ## Gemma4ForCausalLM[[transformers.Gemma4ForCausalLM]] #### transformers.Gemma4ForCausalLM[[transformers.Gemma4ForCausalLM]] ```python transformers.Gemma4ForCausalLM(config: Gemma4TextConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1778) **パラメータ:** config ([Gemma4TextConfig](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4TextConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 言語モデリングヘッドを備えたベースのGemma 4言語モデル。 このモデルは [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.Gemma4ForCausalLM.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, per_layer_inputs: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L1795) **パラメータ:** 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 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。 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` として渡す必要があるでしょう。そうしないと、それらを再計算するためにメインの埋め込みを逆算する必要があり、コストが高くなります。 **戻り値:** `Gemma4CausalLMOutputWithPast` または `tuple(torch.FloatTensor)` `Gemma4CausalLMOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config)）や入力に応じて、さまざまな要素で構成されます。 [Gemma4ForCausalLM](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ForCausalLM) の 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 です。 - **shared_kv_states** (`KVSharingDict`、*任意*) -- レイヤー型の文字列を、(key_states, value_states) テンソルのタプルにマッピングする dict 形式のコンテナ。KV シェアリング時に、レイヤー間で共有 KV 状態を渡すために使用されます。 - **router_logits** (`tuple(torch.FloatTensor)`、*optional*、`output_router_logits=True` が渡された場合に返されます) -- 各 MoE レイヤーに対応する `torch.FloatTensor` のタプルで、形状は `(batch_size * sequence_length, num_experts)` です。 例: ```python >>> from transformers import AutoTokenizer, Gemma4ForCausalLM >>> model = Gemma4ForCausalLM.from_pretrained("google/gemma-4-E2B-it") >>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-4-E2B-it") >>> 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?" ``` ## Gemma4Model[[transformers.Gemma4Model]] #### transformers.Gemma4Model[[transformers.Gemma4Model]] ```python transformers.Gemma4Model(config: Gemma4Config) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L2153) **パラメータ:** config ([Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config)) : モデルのすべてのパラメータを含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 ベースの Gemma 4 モデルは、ビジョンバックボーン、オーディオバックボーン、および言語モデリングヘッドを備えない言語モデルで構成されています。 このモデルは [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.Gemma4Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = None, pixel_values_videos: 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, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, image_position_ids: typing.Optional[torch.LongTensor] = None, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: typing.Optional[torch.LongTensor] = None, per_layer_inputs: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L2248) **パラメータ:** 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)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [Gemma4ImageProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ImageProcessor) を使用して取得できます。詳細については [Gemma4ImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は画像の処理に [Gemma4ImageProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ImageProcessor) を使用します）。 pixel_values_videos (`torch.FloatTensor`、shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`、*optional*) : 入力動画に対応するテンソルです。動画のピクセル値は [Gemma4VideoProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4VideoProcessor) を使用して取得できます。詳細は [Gemma4VideoProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は動画の処理に [Gemma4VideoProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4VideoProcessor) を使用します）。 input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [Gemma4AudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) を使用して取得できます。詳細については [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は音声の処理に [Gemma4AudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) を使用します）。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) input_features_mask (`torch.FloatTensor`、shape `(num_images, seq_length)`) : 入力オーディオ用のアテンションマスク。 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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 image_position_ids (`torch.LongTensor`、shape `(batch_size, max_patches, 2)`、*optional*) : image processor からの 2D パッチ位置座標。パディングは `(-1, -1)` で示されます。位置埋め込みの計算のために vision encoder にそのまま渡されます。 video_position_ids (`torch.LongTensor`、shape `(total_num_frames, max_patches, 2)`、*optional*) : video processor からの 2D パッチ位置座標。パディングは `(-1, -1)` で示されます。位置埋め込みの計算のために vision encoder にそのまま渡されます。 num_frames_per_video (`torch.LongTensor`、shape `(num_videos,)`、*任意*) : 各動画に属するフレーム数。`pixel_values_videos` が渡される場合は必須です。すべての動画のフレームが単一の軸に沿って連結されるためです。 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)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。 **戻り値:** `Gemma4ModelOutputWithPast` または `tuple(torch.FloatTensor)` `Gemma4ModelOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config)）や入力に応じて、さまざまな要素で構成されます。 [Gemma4Model](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Model)の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)を参照してください。 逐次デコーディングを高速化するために使用できる（`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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **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 です。 - **shared_kv_states** (`KVSharingDict`、*任意*) -- レイヤー型の文字列を、(key_states, value_states) テンソルのタプルにマッピングする dict 形式のコンテナ。KV シェアリング時に、レイヤー間で共有 KV 状態を渡すために使用されます。 - **router_logits** (`tuple(torch.FloatTensor)`、*optional*、`output_router_logits=True` が渡された場合に返されます) -- 各 MoE レイヤーに対応する `torch.FloatTensor` のタプルで、形状は `(batch_size * sequence_length, num_experts)` です。 ## Gemma4ForConditionalGeneration[[transformers.Gemma4ForConditionalGeneration]] #### transformers.Gemma4ForConditionalGeneration[[transformers.Gemma4ForConditionalGeneration]] ```python transformers.Gemma4ForConditionalGeneration(config: Gemma4Config) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L2520) **パラメータ:** config ([Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config)) : モデルのすべてのパラメータを含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 ベースの Gemma 4 モデルは、ビジョンバックボーン、オーディオバックボーン、言語モデル、および言語モデリングヘッドで構成されています。 このモデルは [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.Gemma4ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = None, pixel_values_videos: 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, image_position_ids: typing.Optional[torch.LongTensor] = None, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: 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, 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: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4/modeling_gemma4.py#L2546) **パラメータ:** 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)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [Gemma4ImageProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ImageProcessor) を使用して取得できます。詳細については [Gemma4ImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は画像の処理に [Gemma4ImageProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ImageProcessor) を使用します）。 pixel_values_videos (`torch.FloatTensor`、shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`、*optional*) : 入力動画に対応するテンソルです。動画のピクセル値は [Gemma4VideoProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4VideoProcessor) を使用して取得できます。詳細は [Gemma4VideoProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は動画の処理に [Gemma4VideoProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4VideoProcessor) を使用します）。 input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [Gemma4AudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) を使用して取得できます。詳細については [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) を参照してください（[Gemma4Processor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Processor) は音声の処理に [Gemma4AudioFeatureExtractor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) を使用します）。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) input_features_mask (`torch.FloatTensor`、shape `(num_images, seq_length)`) : 入力オーディオ用のアテンションマスク。 position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids) image_position_ids (`torch.LongTensor`、shape `(batch_size, max_patches, 2)`、*optional*) : image processor からの 2D パッチ位置座標。パディングは `(-1, -1)` で示されます。位置埋め込みの計算のために vision encoder にそのまま渡されます。 video_position_ids (`torch.LongTensor`、shape `(total_num_frames, max_patches, 2)`、*optional*) : video processor からの 2D パッチ位置座標。パディングは `(-1, -1)` で示されます。位置埋め込みの計算のために vision encoder にそのまま渡されます。 num_frames_per_video (`torch.LongTensor`、shape `(num_videos,)`、*任意*) : 各動画に属するフレーム数。`pixel_values_videos` が渡される場合は必須です。すべての動画のフレームが単一の軸に沿って連結されるためです。 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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 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 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。 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)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。 **戻り値:** `Gemma4CausalLMOutputWithPast` または `tuple(torch.FloatTensor)` `Gemma4CausalLMOutputWithPast`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[Gemma4Config](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4Config)）や入力に応じて、さまざまな要素で構成されます。 [Gemma4ForConditionalGeneration](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ForConditionalGeneration)の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 です。 - **shared_kv_states** (`KVSharingDict`、*任意*) -- レイヤー型の文字列を、(key_states, value_states) テンソルのタプルにマッピングする dict 形式のコンテナ。KV シェアリング時に、レイヤー間で共有 KV 状態を渡すために使用されます。 - **router_logits** (`tuple(torch.FloatTensor)`、*optional*、`output_router_logits=True` が渡された場合に返されます) -- 各 MoE レイヤーに対応する `torch.FloatTensor` のタプルで、形状は `(batch_size * sequence_length, num_experts)` です。 例: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Gemma4ForConditionalGeneration >>> model = Gemma4ForConditionalGeneration.from_pretrained("google/gemma-4-e2b-it") >>> processor = AutoProcessor.from_pretrained("google/gemma-4-e2b-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] ```