# EmbeddingGemma2 ## 概要 EmbeddingGemma 2 は、Google によって [Gemma 4](./gemma4) アーキテクチャを基盤として構築されたマルチモーダル埋め込みモデルです。**テキスト、画像、音声、動画**を、それぞれ単独で、または同一の入力内で組み合わせて、クロスモーダル検索、意味的類似性、クラスタリング、分類のために、共有される 768 次元の稠密ベクトル空間にエンコードします。 主な機能: - **統合されたマルチモーダルベクトル空間。**ビジョン（[Gemma4VisionModel](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4VisionModel)）とオーディオ（[Gemma4AudioModel](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4AudioModel)）のタワーは、Per-Layer Embeddings（PLE）を用いてフルアテンションとスライディングウィンドウアテンションを交互に適用する双方向テキストエンコーダー（[EmbeddingGemma2TextModel](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel)）に射影されます。単一のモダリティ（`text`、`image`、`audio`、`video`）や、モダリティの組み合わせ（`image + text`、`text + audio`、`image + audio`、複数の画像、テキストとメディアの交互配置）は、いずれも単一の比較可能な埋め込みにマッピングされます。 - **マトリョーシカ表現学習 (MRL)。** [EmbeddingGemma2Model](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) は、線形ヘッドを通じて `embedding_dim` (`768`) に射影されたトークン表現を出力します。埋め込みは、より小さいプレフィックス (`512`、`256`、または `128`) に切り詰め、品質の低下を最小限に抑えながら再正規化できます。 - **設定可能なビジュアルおよびビデオの予算。** [EmbeddingGemma2Processor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) では、画像またはフレームごとのソフトトークン予算（`{70, 140, 280, 560, 1120}` 内の `max_soft_tokens`）と、ビデオのサンプリングレート（デフォルトでは `fps=1`、`max_frames=32`、`overflow_strategy="uniform"`、`add_timestamps=False`）を調整できます。 - **モダリティタワーの選択的読み込み。**テキストのみまたは単一モダリティのデプロイメントでは、メモリ使用量を削減するために、未使用のビジョンまたはオーディオタワーをロード時に無効化できます（`vision_config=None`、`audio_config=None`）。 すべての元のEmbeddingGemmaチェックポイントは、[EmbeddingGemma](https://huggingface.co/collections/google/embeddinggemma)コレクション内で確認できます。以下の例では、`google/embeddinggemma-2`識別子を使用しています。 ## 使用例 文またはマルチモーダル埋め込みは、2つのステップで取得されます。`last_hidden_state`のパディングされていないトークンに対してマスクを考慮した平均プーリングを行い、その後`float32`でL2正規化を実行します。[Sentence Transformers](https://sbert.net)（`>=6.1.0`）は、前処理、プロンプトの整形、平均プーリング、正規化を自動的に実行するため、推奨されるエントリポイントです。[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)を使用する場合は、`processor.apply_chat_template`（プレーンテキストの場合は`AutoTokenizer`）を使用し、`last_hidden_state`を直接プーリングします。 ### テキスト検索（`encode_query` / `encode_document`） ```bash pip install -U sentence-transformers ``` ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") queries = ["Which planet is known as the Red Planet?"] documents = [ "Venus is often called Earth's twin because of its similar size and proximity.", "Mars, known for its reddish appearance, is often referred to as the Red Planet.", ] # encode_query and encode_document apply the "query" and "document" task prompts query_embeddings = model.encode_query(queries) document_embeddings = model.encode_document(documents) print(query_embeddings.shape, document_embeddings.shape) # (1, 768) (2, 768) # (1, 2) matrix of cosine similarities print(model.similarity(query_embeddings, document_embeddings)) ``` ```python import torch import torch.nn.functional as F from transformers import AutoModel, AutoTokenizer model = AutoModel.from_pretrained("google/embeddinggemma-2", device_map="auto") tokenizer = AutoTokenizer.from_pretrained("google/embeddinggemma-2") # Prepend the task prompt directly to plain text inputs (see Task prompts below) sentences = [ "task: search result | query: Which planet is known as the Red Planet?", "title: none | text: Venus is often called Earth's twin because of its similar size and proximity.", "title: none | text: Mars, known for its reddish appearance, is often referred to as the Red Planet.", ] inputs = tokenizer(sentences, padding=True, return_tensors="pt").to(model.device) with torch.no_grad(): # (batch_size, sequence_length, config.text_config.embedding_dim) token_embeddings = model(**inputs).last_hidden_state # Mask-aware mean pooling over non-padded tokens, then L2 normalization in float32 mask = inputs["attention_mask"].unsqueeze(-1).to(token_embeddings.dtype) sentence_embeddings = (token_embeddings * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9) sentence_embeddings = F.normalize(sentence_embeddings.float(), p=2, dim=-1) query_embedding, document_embeddings = sentence_embeddings[:1], sentence_embeddings[1:] print(query_embedding @ document_embeddings.T) ``` ### タスクプロンプト モデルは、入力に前置される任意のタスクプロンプト（平均プーリングにも含まれる）をサポートしていますが、プロンプトは必須ではなく、プロンプトなしでも動作します。最適な設定は下流のドメインやモダリティの組み合わせによって異なるため、特定のタスクに対してプロンプトあり・なしの両方を評価することをお勧めします。Sentence Transformers は、以下のカタログを `config_sentence_transformers.json` に同梱しています。そのため、`prompt_name` を渡すか、`query` と `document` にそれぞれ対応する `encode_query` / `encode_document` を使用してください。[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel) を使用する場合は、プロンプトを `apply_chat_template` 内の `system` メッセージとして渡すか、プレーンテキストの先頭に前置してください。 ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") embeddings = model.encode("How to train a neural network", prompt_name="Classification") ``` | `prompt_name` | プロンプト | |---|---| | `query`, `Retrieval-query`, `Retrieval`, `Reranking`, `BitextMining`, `SearchQuery` | `task: search result \| query: ` | | `document`, `Document`, `Retrieval-document` | `title: none \| text: ` | | `Classification`, `MultilabelClassification` | `task: classification \| query: ` | | `Clustering` | `task: clustering \| query: ` | | `CodeRetrieval`, `InstructionRetrieval` | `task: code retrieval \| query: ` | | `FactChecking` | `task: fact checking \| query: ` | | `QuestionAnswering` | `task: question answering \| query: ` | | `STS`, `SentenceSimilarity`, `PairClassification`, `Summarization` | `task: sentence similarity \| query: ` | ### Matryoshka埋め込み Embedding head は Matryoshka Representation Learning で学習されるため、768 次元の embedding をより短いプレフィックス (`512`、`256`、または `128`) にスライスして再正規化できます。これによりインデックスが縮小し、検索が高速化され、ランキング品質は概ね維持されます。クエリとドキュメントは*同じ*次元に切り詰め、スライス後は必ず正規化してください。Sentence Transformers では `truncate_dim` はすでに正規化済みの出力をスライスするため、プレフィックスはもはや単位ベクトルではなくなります。 ```python import torch.nn.functional as F from sentence_transformers import SentenceTransformer # truncate_dim can also be set once at load time: SentenceTransformer(..., truncate_dim=256) model = SentenceTransformer("google/embeddinggemma-2") queries = ["Which planet is known as the Red Planet?"] documents = [ "Venus is often called Earth's twin because of its similar size and proximity.", "Mars, known for its reddish appearance, is often referred to as the Red Planet.", ] query_embeddings = model.encode_query(queries, truncate_dim=256, convert_to_tensor=True) document_embeddings = model.encode_document(documents, truncate_dim=256, convert_to_tensor=True) query_embeddings = F.normalize(query_embeddings.float(), p=2, dim=-1) document_embeddings = F.normalize(document_embeddings.float(), p=2, dim=-1) # (1, 256) and (2, 256): a 3x smaller index than the full 768 dimensions print(query_embeddings.shape, document_embeddings.shape) # the Mars document still ranks first print(model.similarity(query_embeddings, document_embeddings)) ``` ```python import torch import torch.nn.functional as F from transformers import AutoModel, AutoTokenizer model = AutoModel.from_pretrained("google/embeddinggemma-2", device_map="auto") tokenizer = AutoTokenizer.from_pretrained("google/embeddinggemma-2") sentences = [ "task: search result | query: Which planet is known as the Red Planet?", "title: none | text: Venus is often called Earth's twin because of its similar size and proximity.", "title: none | text: Mars, known for its reddish appearance, is often referred to as the Red Planet.", ] inputs = tokenizer(sentences, padding=True, return_tensors="pt").to(model.device) with torch.no_grad(): token_embeddings = model(**inputs).last_hidden_state mask = inputs["attention_mask"].unsqueeze(-1).to(token_embeddings.dtype) sentence_embeddings = (token_embeddings * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9) # Slice to the first 256 dimensions, then normalize sentence_embeddings = F.normalize(sentence_embeddings[:, :256].float(), p=2, dim=-1) print(sentence_embeddings.shape) # torch.Size([3, 256]) query_embedding, document_embeddings = sentence_embeddings[:1], sentence_embeddings[1:] # the Mars document still ranks first print(query_embedding @ document_embeddings.T) ``` ## マルチモーダル埋め込み テキスト、画像、音声、動画はすべて同じ768次元のベクトル空間にマッピングされるため、**クロスモーダル検索**（テキストクエリで画像、音声、動画を検索する）や、**複合マルチモーダル検索**（複数のモーダルを単一のクエリまたはドキュメントの埋め込みに統合する）が可能になります。 Sentence Transformersでは、マルチモーダル入力は`"text"`、`"image"`、`"audio"`、`"video"`をキーとする辞書として渡されます（各値は単一のアイテムまたはアイテムのリストであることができます）。[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)を使用する場合は、チャット形式のメッセージリストを`processor.apply_chat_template(..., tokenize=True, return_dict=True, return_tensors="pt")`に渡します。 ### 1. 単一モダリティおよびクロスモダリティ検索 各モダリティ(`text`、`image`、`audio`、`video`)は、それぞれ独立して埋め込みベクトル化でき、コサイン類似度によって他の任意のモダリティと直接比較できます。 ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" # Embed each modality on its own into the shared (768,) space candidates = model.encode( [ {"text": "A photo of a cat"}, {"image": IMAGE}, {"audio": "path/to/audio.wav"}, {"video": "path/to/video.mp4"}, ] ) print(candidates.shape) # (4, 768) # Cross-modal retrieval: rank text, image, audio, and video candidates against a text query query = model.encode_query(["A fluffy cat outdoors"]) print(model.similarity(query, candidates)) # tensor([[...]]) of shape (1, 4) ``` ```python import torch import torch.nn.functional as F from transformers import AutoModel, AutoProcessor model = AutoModel.from_pretrained("google/embeddinggemma-2", device_map="auto") processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" conversations = [ [{"role": "user", "content": [{"type": "text", "text": "A photo of a cat"}]}], [{"role": "user", "content": [{"type": "image", "url": IMAGE}]}], [{"role": "user", "content": [{"type": "audio", "url": "path/to/audio.wav"}]}], [{"role": "user", "content": [{"type": "video", "url": "path/to/video.mp4"}]}], ] inputs = processor.apply_chat_template( conversations, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) with torch.no_grad(): token_embeddings = model(**inputs).last_hidden_state mask = inputs["attention_mask"].unsqueeze(-1).to(token_embeddings.dtype) embeddings = (token_embeddings * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9) embeddings = F.normalize(embeddings.float(), p=2, dim=-1) print(embeddings.shape) # torch.Size([4, 768]) ``` ### 2. 複合マルチモーダル埋め込み（1つの入力に複数のモダリティを含む） 複数のモダリティ、または同一モダリティの複数のアイテムを、`image + audio`のような純粋にテキスト以外の組み合わせも含めて、**単一の結合埋め込み**に統合できます。 ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") IMAGE_1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" IMAGE_2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png" composed_embeddings = model.encode( [ # text + image {"text": "A photo of a cat", "image": IMAGE_1}, # text + audio {"text": "A song", "audio": "path/to/audio.wav"}, # image + audio (no text required) {"image": IMAGE_1, "audio": "path/to/audio.wav"}, # multiple images + audio + text in one embedding {"image": [IMAGE_1, IMAGE_2], "audio": "path/to/audio.wav", "text": "Compare both cats"}, ] ) print(composed_embeddings.shape) # (4, 768) ``` ```python import torch import torch.nn.functional as F from transformers import AutoModel, AutoProcessor model = AutoModel.from_pretrained("google/embeddinggemma-2", device_map="auto") processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" conversations = [ # text + image [ { "role": "user", "content": [ {"type": "text", "text": "A photo of a cat"}, {"type": "image", "url": IMAGE}, ], } ], # text + audio [ { "role": "user", "content": [ {"type": "text", "text": "A song"}, {"type": "audio", "url": "path/to/audio.wav"}, ], } ], # image + audio (no text required) [ { "role": "user", "content": [ {"type": "image", "url": IMAGE}, {"type": "audio", "url": "path/to/audio.wav"}, ], } ], ] inputs = processor.apply_chat_template( conversations, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) with torch.no_grad(): token_embeddings = model(**inputs).last_hidden_state mask = inputs["attention_mask"].unsqueeze(-1).to(token_embeddings.dtype) embeddings = (token_embeddings * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9) embeddings = F.normalize(embeddings.float(), p=2, dim=-1) print(embeddings.shape) # torch.Size([3, 768]) ``` ### 3. 自動順序付けと手動プレースホルダー プレースホルダートークン（`<|image|>`、`<|video|>`、`<|audio|>`）がテキストに存在しない場合、モダリティは辞書またはチャットメッセージの`content`にエントリが出現した正確な順序で出力されます（`system`タスクプロンプトの直後）。 文内の特定の位置にテキストとメディアを交互に配置するには、テキスト内に直接`<|image|>`、`<|video|>`、または`<|audio|>`を記述します。これにより、その入力に対するプレースホルダーの自動挿入は無効になり、各プレースホルダーは提供されたメディアアイテムの順に展開されます。 ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") IMAGE_1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" IMAGE_2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png" # 1. Automatic ordering: follows the dictionary's key order # -> [prompt] image_first = model.encode({"image": IMAGE_1, "text": "A photo of a cat"}, prompt_name="document") # -> [prompt] text_first = model.encode({"text": "A photo of a cat", "image": IMAGE_1}, prompt_name="document") # 2. Manual placeholders: interleave media at exact positions in the text # No extra placeholders are inserted; counts must match the passed media inputs. interleaved = model.encode( { "text": "A jacket similar to <|image|> or <|image|> featured in <|audio|>", "image": [IMAGE_1, IMAGE_2], "audio": "path/to/audio.wav", }, prompt_name="query", ) ``` ```python import torch import torch.nn.functional as F from transformers import AutoModel, AutoProcessor model = AutoModel.from_pretrained("google/embeddinggemma-2", device_map="auto") processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") IMAGE_1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" IMAGE_2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png" # 1. Automatic ordering: follows the content list order after any system prompt image_first_messages = [ {"role": "system", "content": "title: none | text: "}, { "role": "user", "content": [ {"type": "image", "url": IMAGE_1}, {"type": "text", "text": "A photo of a cat"}, ], }, ] # 2. Manual placeholders: interleave media at exact positions in the text interleaved_messages = [ {"role": "system", "content": "task: search result | query: "}, { "role": "user", "content": [ {"type": "image", "url": IMAGE_1}, {"type": "image", "url": IMAGE_2}, {"type": "audio", "url": "path/to/audio.wav"}, {"type": "text", "text": "A jacket similar to <|image|> or <|image|> featured in <|audio|>"}, ], }, ] inputs = processor.apply_chat_template( [image_first_messages, interleaved_messages], tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) with torch.no_grad(): token_embeddings = model(**inputs).last_hidden_state mask = inputs["attention_mask"].unsqueeze(-1).to(token_embeddings.dtype) embeddings = (token_embeddings * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9) embeddings = F.normalize(embeddings.float(), p=2, dim=-1) ``` ### 4. 異種（混合モダリティ）バッチ処理 1つのバッチでは、プレーンテキスト、単一モダリティのメディア、マルチモダリティの入力を1回のフォワードパスで混合でき、各行について個別にエンコードした場合と同一の埋め込みを生成します。 ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" embeddings = model.encode( [ "A photo of a cat", {"image": IMAGE}, {"text": "A photo of a cat", "image": IMAGE}, {"audio": "path/to/audio.wav"}, ], prompt_name="document", ) print(embeddings.shape) # (4, 768) ``` ```python import torch import torch.nn.functional as F from transformers import AutoModel, AutoProcessor model = AutoModel.from_pretrained("google/embeddinggemma-2", device_map="auto") processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" conversations = [ [ {"role": "system", "content": "title: none | text: "}, {"role": "user", "content": [{"type": "text", "text": "A photo of a cat"}]}, ], [ {"role": "system", "content": "title: none | text: "}, {"role": "user", "content": [{"type": "image", "url": IMAGE}]}, ], [ {"role": "system", "content": "title: none | text: "}, { "role": "user", "content": [ {"type": "text", "text": "A photo of a cat"}, {"type": "image", "url": IMAGE}, ], }, ], [ {"role": "system", "content": "title: none | text: "}, {"role": "user", "content": [{"type": "audio", "url": "path/to/audio.wav"}]}, ], ] inputs = processor.apply_chat_template( conversations, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) with torch.no_grad(): token_embeddings = model(**inputs).last_hidden_state mask = inputs["attention_mask"].unsqueeze(-1).to(token_embeddings.dtype) embeddings = (token_embeddings * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9) embeddings = F.normalize(embeddings.float(), p=2, dim=-1) print(embeddings.shape) # torch.Size([4, 768]) ``` ### 5. 未使用のモダリティタワーの無効化（メモリ最適化） ワークロードがモダリティのサブセットのみを埋め込む場合（例: **テキストのみ** または音声なしの **テキスト + 画像**）、設定で `vision_config=None` および/または `audio_config=None` を設定することで、未使用のビジョンまたはオーディオタワーのインスタンス化と読み込みをスキップできます。チェックポイント内の未使用タワーの重みは、警告なしにクリーンに無視され、オーディオタワーなしでモデルは 744M パラメータから 439M パラメータに、両方のタワーを除外すると 271M パラメータに削減されます。 これらは`model_kwargs`ではなく、`config_kwargs`（`AutoConfig.from_pretrained`に到達する）に渡してください: ```python from sentence_transformers import SentenceTransformer # Text-only deployment (skips both vision and audio towers) text_model = SentenceTransformer( "google/embeddinggemma-2", config_kwargs={"vision_config": None, "audio_config": None}, ) # Vision + text deployment (skips audio tower) vision_text_model = SentenceTransformer( "google/embeddinggemma-2", config_kwargs={"audio_config": None}, ) ``` ```python from transformers import AutoModel # Text-only deployment (skips both vision and audio towers) text_model = AutoModel.from_pretrained( "google/embeddinggemma-2", vision_config=None, audio_config=None, device_map="auto", ) # Vision + text deployment (skips audio tower) vision_text_model = AutoModel.from_pretrained( "google/embeddinggemma-2", audio_config=None, device_map="auto", ) ``` ## プロセッサ [EmbeddingGemma2Processor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) は、トークナイザー、画像プロセッサー、音声特徴抽出器、動画プロセッサーをまとめたものです。 > [!TIP] > バッチ処理されるマルチモーダル入力については、**Sentence Transformers** 経由でサンプルごとの辞書を渡すことを推奨します（`model.encode([{"image": ..., "text": ...}, ...])`）。モダリティの正確な順序やインターリーブを完全に制御したい場合は、`text` に `<|image|>`、`<|video|>`、`<|audio|>` のプレースホルダーを手動で含めてください。 ### ビジュアルトークン予算の制御(`max_soft_tokens`) ソフトトークン予算(`max_soft_tokens`、サポートされる値は`{70, 140, 280, 560, 1120}`)は、画像または動画フレームごとに生成される視覚トークンの解像度と数を制御します(デフォルトでは画像ごとに`280`、動画フレームごとに`140`)。値を下げると、シーケンス長とレイテンシが減少します: ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" image_embedding = model.encode( {"image": IMAGE}, processing_kwargs={"image": {"max_soft_tokens": 70}}, ) ``` ```python from transformers import AutoProcessor processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" inputs = processor(images=[IMAGE], max_soft_tokens=70, return_tensors="pt") print(inputs["input_ids"].shape, inputs["pixel_values"].shape) # torch.Size([1, 67]) torch.Size([1, 630, 768]) ``` ### Video frame sampling controls デフォルトでは、[EmbeddingGemma2VideoProcessor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) は 1 FPS (`fps=1`) でフレームをサンプリングし、各クリップのフレーム数を 32 フレームに制限 (`max_frames=32`、`overflow_strategy="uniform"`) し、プロンプトからフレームのタイムスタンプを省略 (`add_timestamps=False`) します。各パラメータは呼び出しごとに上書きできます。 - `fps` (`int | float | None`): 1 秒あたりのフレーム数で指定する、ターゲットのサンプリングレートです。有効な `fps` と `duration` を持つ `VideoMetadata` が必要です（動画ファイル/URL からデコードする場合は自動的に設定されます）。メタデータなしの事前デコード済みフレーム配列の場合、FPS サンプリングは警告を出力してスキップされ、`max_frames` が直接適用されます。 - `max_frames` (`int | None`): 1つの動画ごとに保持されるフレーム数の最大値。 - `overflow_strategy` (`"uniform" | "truncate" | None`): `max_frames` を超えるフレームを削減する方法（`"uniform"` はクリップ全体で均等にリサンプリングし、`"truncate"` は先頭の `max_frames` フレームを保持します）。 - `add_timestamps` (`bool`): 各フレームのソフトトークンブロックの先頭に`mm:ss`形式のタイムスタンプを付与するかどうかを指定します。`fps`とは異なり、フォールバックはありません。`fps`がメタデータに存在しない動画に対して`add_timestamps=True`を指定すると、推測したレートではプロンプトに誤った`mm:ss`ラベルが書き込まれてしまうため、例外が発生します。 ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("google/embeddinggemma-2") video_embedding = model.encode( {"video": "path/to/video.mp4"}, processing_kwargs={"video": {"add_timestamps": True, "fps": 2, "max_frames": 16, "overflow_strategy": "truncate"}}, ) ``` ```python from transformers import AutoProcessor processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") inputs = processor( videos=["path/to/video.mp4"], add_timestamps=True, fps=2, max_frames=16, overflow_strategy="truncate", return_tensors="pt", ) ``` ### チャットテンプレートなしで`processor(...)`を直接呼び出す `processor.apply_chat_template` はマルチモーダル会話の主なエントリポイントですが、`processor(...)` を直接呼び出すこともできます。`text` を省略した場合（`text=None`）、バッチ内の各サンプルに対して `<|image|>`、`<|video|>`、`<|audio|>` のプレースホルダーが自動的に生成されます。 ```python from transformers import AutoProcessor processor = AutoProcessor.from_pretrained("google/embeddinggemma-2") IMAGE = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" AUDIO = "path/to/audio.wav" # a path, a URL, or a 1-D float array sampled at 16 kHz # Text only inputs = processor(text=["task: search result | query: Which planet is the Red Planet?"], return_tensors="pt") # Media only (text=None): placeholders are synthesized per sample inputs = processor(images=[IMAGE], return_tensors="pt") inputs = processor(videos=["path/to/video.mp4"], return_tensors="pt") inputs = processor(audio=[AUDIO], return_tensors="pt") # Nested per-sample lists or combined modalities with text=None inputs = processor( images=[[IMAGE, IMAGE], [IMAGE]], audio=[[AUDIO], [AUDIO, AUDIO]], return_tensors="pt", ) # Manual placeholders in text for direct processor calls inputs = processor(text=["<|image|> a photo of a cat"], images=[[IMAGE]], return_tensors="pt") print(list(inputs.keys())) # ['input_ids', 'attention_mask', 'pixel_values', 'image_position_ids'] ``` ## EmbeddingGemma2TextConfig[[transformers.EmbeddingGemma2TextConfig]] #### transformers.EmbeddingGemma2TextConfig[[transformers.EmbeddingGemma2TextConfig]] ```python transformers.EmbeddingGemma2TextConfig(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 = 512, intermediate_size: int = 2048, num_hidden_layers: int = 24, num_attention_heads: int = 4, num_key_value_heads: int = 2, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 262144, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = 2, 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, hidden_size_per_layer_input: int = 512, embedding_dim: int = 768) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/configuration_embedding_gemma2.py#L37) **パラメータ:** vocab_size (`int`、*任意*、デフォルトは `262144`) : モデルの語彙サイズ。`input_ids` で表すことができるトークンの種類数を定義します。 hidden_size (`int`、*任意*、デフォルトは`512`) : 隠れ表現の次元数。 intermediate_size (`int`、*任意*、デフォルトは`2048`) : MLP 表現の次元数。 num_hidden_layers (`int`、*optional*、デフォルトは `24`) : Transformer デコーダーの隠れ層の数。 num_attention_heads (`int`、*任意*、デフォルトは `4`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。 num_key_value_heads (`int`、*任意*、デフォルトは `2`) : Grouped Query Attention を実装するために使用する key_value ヘッドの数です。`num_key_value_heads=num_attention_heads` の場合、モデルは Multi Head Attention (MHA) を使用し、`num_key_value_heads=1` の場合は Multi Query Attention (MQA) を使用し、それ以外の場合は GQA が使用されます。マルチヘッドのチェックポイントを GQA のチェックポイントに変換する際は、各グループの key ヘッドと value ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](https://huggingface.co/papers/2305.13245)を参照してください。指定されない場合、デフォルトで `num_attention_heads` が使用されます。 head_dim (`int`、*任意*、デフォルトは`256`) : アテンションヘッドの次元です。None の場合、hidden_size // num_attention_heads がデフォルトとして使用されます。 hidden_activation (`str`、*任意*、デフォルトは `gelu_pytorch_tanh`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"` など。 max_position_embeddings (`int`、*optional*、デフォルトは`262144`) : このモデルが使用される可能性のある最大シーケンス長です。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 rms_norm_eps (`float`、*任意*、デフォルトは`1e-06`) : rms 正規化レイヤーで使用する epsilon。 pad_token_id (`int`, *任意*, デフォルトは `0`) : 語彙内でパディングに使用されるトークン ID。 eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは `1`) : 語彙内でストリーム終了に使用されるトークン ID。 bos_token_id (`int`、*任意*、デフォルトは`2`) : 語彙内でストリームの開始に使用されるトークン ID。 rope_parameters (`dict`, *任意*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれており、より長い `max_position_embeddings` で RoPE を使用する場合にスケーリングに使用されるパラメータが任意で含まれます。 attention_bias (`bool`、*任意*、デフォルトは`False`) : セルフアテンションにおけるクエリ、キー、バリュー、出力の投影層でバイアスを使用するかどうか。 attention_dropout (`Union[int, float]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。 sliding_window (`int`、*optional*、デフォルトは 512) : 双方向スライディングウィンドウの半径（両端を含む）: `sliding_attention` レイヤーは、`abs(q_idx - kv_idx) <= sliding_window` を満たすすべての位置にアテンションを適用します。ここでのマスクは対称であるため、因果的な Gemma モデルが設定する片側の幅ではなく半径として定義されており、デフォルト値は参照実装で指定されている幅 1024 のウィンドウの半分です。 layer_types (`list[str]`、*任意*) : 各レイヤーのインデックスとそのレイヤータイプを明示的にマッピングするリストです。指定しない場合、config の値に基づいて自動的に生成されます。 hidden_size_per_layer_input (`int`、*任意*、デフォルト値は 512) : 層ごとの (PLE) 残差信号の次元数。EmbeddingGemma 2 は *projection-only* の PLE を使用します。この方式では、信号は `inputs_embeds` のみから導出され、補助的なトークンルックアップテーブルは使用されません。 embedding_dim (`int`、*任意*、デフォルトは 768) : `embedding_projection` によって生成される文埋め込みの次元数。 これは、EmbeddingGemma2Model の設定を保存するための設定クラスです。指定された引数に基づいて Embedding Gemma2 モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2) と同様の設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 ## EmbeddingGemma2Config[[transformers.EmbeddingGemma2Config]] #### transformers.EmbeddingGemma2Config[[transformers.EmbeddingGemma2Config]] ```python transformers.EmbeddingGemma2Config(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.embedding_gemma2.configuration_embedding_gemma2.EmbeddingGemma2TextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = None, audio_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, 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) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/configuration_embedding_gemma2.py#L139) **パラメータ:** text_config (`EmbeddingGemma2TextConfig`、*任意*) : テキストバックボーンの設定です。 vision_config (`PreTrainedConfig` または `dict`、*省略可*) : ビジョンタワーの設定です。Gemma 4 からそのまま再利用されます。タワー自体は実行時に `AutoModel` 経由で解決されます。 audio_config (`PreTrainedConfig` または `dict`、*省略可*) : オーディオタワーの設定です。Gemma 4 からそのまま再利用されます。タワー自体は実行時に `AutoModel` 経由で解決されます。 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の標準偏差です。 これは、EmbeddingGemma2Model の設定を保存するための設定クラスです。指定された引数に基づいて Embedding Gemma2 モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2) と同様の設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 ## EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]] #### transformers.EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]] ```python transformers.EmbeddingGemma2VideoProcessor(**kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L176) **パラメータ:** 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*、デフォルトは `1`) : `do_sample_frames=True` の場合、1 秒あたりサンプリングするターゲットフレーム数。 num_frames (`Annotated[int | None, None]`, *kwargs*) : `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*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 add_timestamps (`bool`, *kwargs*, *optional*) : ビデオプレースホルダーの展開において、各フレームの前に`mm:ss`形式のタイムスタンプを付与するかどうかを指定します。デコード済みのフレームからはタイムスタンプを推定できないため、有効な`fps`を持つ`VideoMetadata`が必要です。 max_frames (`int`, *kwargs*, *optional*) : サンプルするフレームの最大数。設定されている場合、サンプルされたインデックスは予算に収まるように均等に再サンプリングされます。 overflow_strategy (`str`, *kwargs*, *optional*) : サンプルフレームの総数を予算内に収めるために使用する戦略です。"uniform" または "truncate" のいずれかにのみ設定できます。FPS ベースのサンプリング後に適用され、FPS ベースのサンプリングがオフまたは適用されない場合は単独で適用されます。 load_audio_from_video (`bool`, *kwargs*, *任意*) : 入力動画のオーディオトラックを読み込むかどうか。 - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/ja/main_classes/processors#transformers.ProcessingKwargs), *optional*) : 各モダリティ（テキスト、画像、動画、音声）の追加処理オプション。モデル固有のパラメータは上記にリストされています。サポートされている引数の完全なリストについては、TypedDict クラスを参照してください。 EmbeddingGemma2VideoProcessor ビデオプロセッサを構築します。 #### preprocess[[transformers.EmbeddingGemma2VideoProcessor.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/embedding_gemma2/video_processing_embedding_gemma2.py#L240) **パラメータ:** 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*) : パッチ化後に適用される空間プーリングのカーネルサイズ。 add_timestamps (`bool`, *kwargs*, *optional*) : ビデオプレースホルダーの展開において、各フレームの前に`mm:ss`形式のタイムスタンプを付与するかどうかを指定します。デコード済みのフレームからはタイムスタンプを推定できないため、有効な`fps`を持つ`VideoMetadata`が必要です。 max_frames (`int`, *kwargs*, *optional*) : サンプルするフレームの最大数。設定されている場合、サンプルされたインデックスは予算に収まるように均等に再サンプリングされます。 overflow_strategy (`str`, *kwargs*, *optional*) : サンプルフレームの総数を予算内に収めるために使用する戦略です。"uniform" または "truncate" のいずれかにのみ設定できます。FPS ベースのサンプリング後に適用され、FPS ベースのサンプリングがオフまたは適用されない場合は単独で適用されます。 load_audio_from_video (`bool`, *kwargs*, *任意*) : 入力動画のオーディオトラックを読み込むかどうか。 **戻り値:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- __call__ メソッドによって返されるリスト/配列/テンソルの辞書（'pixel_values' など）。 - **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。 ## EmbeddingGemma2Processor[[transformers.EmbeddingGemma2Processor]] #### transformers.EmbeddingGemma2Processor[[transformers.EmbeddingGemma2Processor]] ```python transformers.EmbeddingGemma2Processor(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/embedding_gemma2/processing_embedding_gemma2.py#L106) **パラメータ:** feature_extractor (*Gemma4AudioFeatureExtractor*) : 特徴抽出器は必須の入力です。 image_processor (*Gemma4ImageProcessor*) : 画像プロセッサは必須の入力です。 tokenizer (*tokenizer_class*) : トークナイザーは必須の入力です。 video_processor (*EmbeddingGemma2VideoProcessor*) : video processor は必須の入力です。 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 倍の時間削減に由来します。 EmbeddingGemma2Processorを構築します。このクラスは、フィーチャーエクストラクター、画像プロセッサー、トークナイザー、およびビデオプロセッサーを単一のプロセッサーとしてラップします。 [*EmbeddingGemma2Processor*] は、[*Gemma4AudioFeatureExtractor*]、[*Gemma4ImageProcessor*]、[*tokenizer_class*]、および [*EmbeddingGemma2VideoProcessor*] のすべての機能を提供します。詳細については、[*~Gemma4AudioFeatureExtractor*]、[*~Gemma4ImageProcessor*]、[*~tokenizer_class*]、および [*~EmbeddingGemma2VideoProcessor*] を参照してください。 #### __call__[[transformers.EmbeddingGemma2Processor.__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, audio_from_video_indices: list[int] | None = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2443) **パラメータ:** 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 はオーディオのサンプル長を表します。 audio_from_video_indices (`list[int]`, *optional*) : 各オーディオスロットのソースを記述するリスト。- `None` -> どのビデオトラックにも関連付けられていない独立したオーディオ - `i` -> videos[i] から抽出されたオーディオ 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 クラスを参照してください。 ## EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]] #### transformers.EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]] ```python transformers.EmbeddingGemma2PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L442) **パラメータ:** 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.EmbeddingGemma2PreTrainedModel.forward]] ```python forward(*args, **kwargs) ``` ドット区切りパス（例: `torch.float32`）に対するモック値: 属性アクセスのチェーン、呼び出しはパススルーデコレータとして動作し、`repr` はドット区切りパスを返し、ベースクラスとして使用するとプレーンな `type` ベースに置き換えられます（PEP 560 の `__mro_entries__`）。これにより、実際のサブクラスは通常のメタクラスを保持し、`inspect.signature` はモックのものではなく実際の `__init__` を読み取ります。 ## EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]] #### transformers.EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]] ```python transformers.EmbeddingGemma2TextModel(config: EmbeddingGemma2TextConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L477) **パラメータ:** config ([EmbeddingGemma2TextConfig](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 EmbeddingGemma 2 のテキストバックボーンです。`embedding_projection` を保持しており、最終的な隠れ状態を `config.embedding_dim` にマッピングします。これにより、複合モデルでは `forward` のオーバーライドが不要になります。 このモデルは [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.EmbeddingGemma2TextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L510) **パラメータ:** 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) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 **戻り値:** [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `tuple(torch.FloatTensor)` [EmbeddingGemma2Config](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config) や入力に応じて、さまざまな要素で構成される [BaseModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [EmbeddingGemma2TextModel](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 ## EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]] #### transformers.EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]] ```python transformers.EmbeddingGemma2Model(config: EmbeddingGemma2Config) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L633) **パラメータ:** config ([EmbeddingGemma2Config](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 EmbeddingGemma 2 モデル: ビジョンバックボーン、オーディオバックボーン、テキストバックボーンから構成され、それぞれの最終的な隠れ状態が `config.text_config.embedding_dim` に射影されます。SentenceTransformers の平均プーリングと正規化によってラップされることを想定しています。 このモデルは [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.EmbeddingGemma2Model.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, inputs_embeds: typing.Optional[torch.FloatTensor] = 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, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L739) **パラメータ:** 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__) を参照してください（[EmbeddingGemma2Processor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) は画像の処理に [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*) : 入力動画に対応するテンソルです。動画のピクセル値は [EmbeddingGemma2VideoProcessor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) を使用して取得できます。詳細は [EmbeddingGemma2VideoProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) を参照してください（[EmbeddingGemma2Processor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) は動画の処理に [EmbeddingGemma2VideoProcessor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) を使用します）。 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__) を参照してください（[EmbeddingGemma2Processor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) は音声の処理に [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) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 image_position_ids (`torch.LongTensor`、shape `(batch_size, max_patches, 2)`、*optional*) : image processor からの 2D パッチ位置座標。パディングは `(-1, -1)` で示されます。位置埋め込みの計算のために vision encoder にそのまま渡されます。 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` が渡される場合は必須です。すべての動画のフレームが単一の軸に沿って連結されるためです。 **戻り値:** `EmbeddingGemma2ModelOutput` または `tuple(torch.FloatTensor)` `EmbeddingGemma2ModelOutput`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[EmbeddingGemma2Config](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)）や入力に応じて、さまざまな要素で構成されます。 [EmbeddingGemma2Model](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **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 です。 #### get_image_features[[transformers.EmbeddingGemma2Model.get_image_features]] ```python get_image_features(pixel_values: FloatTensor, image_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L662) **パラメータ:** 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__) を参照してください（[EmbeddingGemma2Processor](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) は画像の処理に [Gemma4ImageProcessor](/docs/transformers/main/ja/model_doc/gemma4#transformers.Gemma4ImageProcessor) を使用します）。 image_position_ids (`torch.LongTensor`、shape `(batch_size, max_patches, 2)`、*optional*) : 画像内の (x, y) 座標としてのパッチ位置。パディングされたパッチは (-1, -1) で示されます。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)` 設定（[EmbeddingGemma2Config](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)）や入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 ビジョンモデルの最後の隠れ状態を、言語モデルの空間に射影します。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 #### get_video_features[[transformers.EmbeddingGemma2Model.get_video_features]] ```python get_video_features(pixel_values_videos: FloatTensor, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L880) **パラメータ:** pixel_values_videos (`torch.FloatTensor`、shape `(total_num_frames, max_patches, patch_pixels)`) : バッチ内のすべての動画のフレームを、別々の動画軸にスタックするのではなく、フレーム軸に沿って連結したものです。これにより、長さの異なる動画をまとめてバッチ処理できます。 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`、形状 `(num_videos,)`) : 各動画に属するフレーム数。フラットなフレームシーケンスを動画ごとに分割するために使用されます。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)` 設定（[EmbeddingGemma2Config](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)）や入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling)、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 ビジョンエンコーダーの最後の隠れ状態を、言語モデルの空間に射影します。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 #### get_audio_features[[transformers.EmbeddingGemma2Model.get_audio_features]] ```python get_audio_features(input_features: Tensor, input_features_mask: Tensor, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L855) **パラメータ:** input_features (`torch.FloatTensor`、shape `(num_images, seq_length, num_features)`) : 入力オーディオに対応するテンソル。 input_features_mask (`torch.FloatTensor`、shape `(num_images, seq_length)`) : 入力オーディオ用のアテンションマスク。 **戻り値:** `EmbeddingGemma2AudioModelOutput` または `tuple(torch.FloatTensor)` `EmbeddingGemma2AudioModelOutput`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[EmbeddingGemma2Config](/docs/transformers/main/ja/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)）や入力に応じて、さまざまな要素で構成されます。 オーディオエンコーダーの最後の隠れ状態を、言語モデルの空間に射影します。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **attention_mask** (`torch.BoolTensor`、*任意*) -- 形状が`(batch_size, num_frames)`のtorch.BoolTensorです。有効な位置はTrue、パディングはFalseです。