# EmbeddingGemma2 ## Aperçu EmbeddingGemma 2 est un modèle d'embedding multimodal de Google, construit sur l'architecture [Gemma 4](./gemma4). Il encode le **texte, les images, l'audio et la vidéo** — individuellement ou combinés dans la même entrée — dans un espace vectoriel dense partagé de 768 dimensions, pour la récupération inter-modale, la similarité sémantique, le regroupement et la classification. Fonctionnalités principales : - **Espace vectoriel multimodal unifié.** Les tours de vision ([Gemma4VisionModel](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4VisionModel)) et d'audio ([Gemma4AudioModel](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4AudioModel)) projettent dans un encodeur de texte bidirectionnel ([EmbeddingGemma2TextModel](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel)) qui intercale une attention complète et une attention par fenêtre glissante avec des Per-Layer Embeddings (PLE). Toute modalité unique (`text`, `image`, `audio`, `video`) ou combinaison de modalités (`image + text`, `text + audio`, `image + audio`, plusieurs images, texte et médias intercalés) est mappée vers un unique embedding comparable. - **Apprentissage de représentations Matryoshka (MRL).** [EmbeddingGemma2Model](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) produit des représentations de jetons projetées sur `embedding_dim` (`768`) via une tête linéaire. Les plongements peuvent être tronqués à un préfixe plus petit (`512`, `256` ou `128`) et renormalisés avec une perte de qualité minimale. - **Budgets visuels et vidéo configurables.** [EmbeddingGemma2Processor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) permet d’ajuster le budget de jetons doux par image ou par image-vidéo (`max_soft_tokens` dans `{70, 140, 280, 560, 1120}`) et le taux d’échantillonnage vidéo (`fps=1`, `max_frames=32`, `overflow_strategy="uniform"`, `add_timestamps=False` par défaut). - **Chargement sélectif des tours de modalités.** Les tours de vision ou d’audio inutilisés peuvent être désactivés au chargement (`vision_config=None`, `audio_config=None`) afin de réduire l’empreinte mémoire pour les déploiements textuels uniquement ou à modalité unique. Vous pouvez trouver tous les points de contrôle originaux d'EmbeddingGemma dans la collection [EmbeddingGemma](https://huggingface.co/collections/google/embeddinggemma). Les exemples ci-dessous utilisent l'identifiant `google/embeddinggemma-2`. ## Exemples d'utilisation Un embedding de phrase ou multimodal est obtenu en deux étapes : un pooling moyen tenant compte des masques sur les jetons non rembourrés de `last_hidden_state`, suivi d'une normalisation L2 en `float32`. [Sentence Transformers](https://sbert.net) (`>=6.1.0`) effectue automatiquement la prétraitement, le formatage des prompts, le pooling moyen et la normalisation, et constitue le point d'entrée recommandé. Avec [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel), utilisez `processor.apply_chat_template` (ou `AutoTokenizer` pour du texte brut) et appliquez le pooling directement sur `last_hidden_state`. ### Récupération de texte (`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) ``` ### Prompts de tâche Le modèle prend en charge des prompts de tâche facultatifs préfixés à l'entrée (et inclus dans le pooling moyen), bien que les prompts ne soient pas obligatoires et que le modèle fonctionne également sans eux. Étant donné que la configuration optimale dépend du domaine en aval et du mélange de modalités, nous recommandons d'évaluer les deux approches, avec et sans prompts de tâche, sur votre tâche spécifique. Sentence Transformers fournit le catalogue ci-dessous dans `config_sentence_transformers.json`, il faut donc passer `prompt_name` (ou utiliser `encode_query` / `encode_document`, qui correspondent à `query` et `document`) ; avec [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel), passez le prompt en tant que message `system` dans `apply_chat_template` (ou préfixez-le au texte brut). ```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` | prompt | |---|---| | `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: ` | ### Embeddings Matryoshka La tête d’embedding est entraînée avec Matryoshka Representation Learning, de sorte qu’un embedding de 768 dimensions peut être tronqué à un préfixe plus court (`512`, `256` ou `128`) puis renormalisé. Cela réduit la taille de l’index et accélère la récupération tout en préservant largement la qualité du classement. Tronquez les requêtes et les documents à la *même* dimension, et normalisez toujours après la troncature — dans Sentence Transformers, `truncate_dim` tronque la sortie déjà normalisée, de sorte que le préfixe n’est plus de longueur unitaire. ```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) ``` ## Embeddings multimodaux Le texte, les images, l’audio et la vidéo sont projetés dans le même espace vectoriel de 768 dimensions, permettant la **récupération intermodale** (par exemple, rechercher des images, de l’audio ou des vidéos à l’aide d’une requête textuelle) ainsi que la **récupération multimodale composée** (combinaison de plusieurs modalités en un seul embedding de requête ou de document). Dans Sentence Transformers, les entrées multimodales sont transmises sous forme de dictionnaires indexés par `"text"`, `"image"`, `"audio"` et `"video"` (chaque valeur pouvant être un élément unique ou une liste d'éléments). Avec [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel), passez des listes de messages au format chat à `processor.apply_chat_template(..., tokenize=True, return_dict=True, return_tensors="pt")`. ### 1. Modalités uniques et récupération inter-modale Chaque modalité (`text`, `image`, `audio`, `video`) peut être intégrée indépendamment et comparée directement à toute autre modalité via la similarité cosinus : ```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. Incrustations multimodales composées (plusieurs modalités dans une seule entrée) Plusieurs modalités — ou plusieurs éléments de la même modalité — peuvent être combinés en un **unique embedding conjoint**, y compris des combinaisons purement non textuelles telles que `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. Ordre automatique vs. espaces réservés manuels Lorsqu’aucun jeton de substitution (`<|image|>`, `<|video|>`, `<|audio|>`) n’apparaît dans le texte, les modalités sont émises dans l’ordre exact de leurs entrées dans le dictionnaire ou le champ `content` du message de chat (immédiatement après tout prompt de tâche `system`). Pour intercaler du texte et des médias à des positions spécifiques au sein d’une phrase, écrivez `<|image|>`, `<|video|>` ou `<|audio|>` directement dans le texte : l’insertion automatique de placeholders est alors désactivée pour cette entrée, et chaque placeholder est développé dans l’ordre avec les éléments multimédias fournis : ```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. Lot de traitement hétérogène (modalités mixtes) Un seul lot peut mélanger du texte brut, des médias à une seule modalité et des entrées multimodales dans un seul passage avant, produisant le même vecteur d'incorporation par ligne que l'encodage de chaque élément individuellement : ```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. Désactivation des tours de modalités inutilisées (optimisation de la mémoire) Si votre charge de travail n’incorpore qu’un sous-ensemble des modalités (par exemple, **texte uniquement** ou **texte + images** sans audio), vous pouvez éviter d’instancier et de charger les tours de vision ou d’audio inutilisées en définissant `vision_config=None` et/ou `audio_config=None` dans la configuration. Les poids de la tour inutilisée présents dans le point de contrôle sont ignorés proprement, sans avertissement, réduisant le modèle de 744M à 439M paramètres sans la tour audio, ou à 271M sans aucune des deux tours. Passez-les via `config_kwargs` (qui atteint `AutoConfig.from_pretrained`), et non via `model_kwargs` : ```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", ) ``` ## Processeur [EmbeddingGemma2Processor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) regroupe le tokeniseur, le processeur d’images, l’extracteur de caractéristiques audio et le processeur vidéo. > [!TIP] > Pour les entrées multimodales par lots, nous recommandons de passer des dictionnaires par échantillon via **Sentence Transformers** (`model.encode([{"image": ..., "text": ...}, ...])`). Pour un contrôle maximal sur l’ordre exact des modalités et leur alternance, incluez manuellement les espaces réservés `<|image|>`, `<|video|>` et `<|audio|>` dans `text`. ### Contrôle du budget de jetons visuels (`max_soft_tokens`) Le budget de jetons doux (`max_soft_tokens`, valeurs prises en charge `{70, 140, 280, 560, 1120}`) contrôle la résolution et le nombre de jetons visuels produits par image ou par image vidéo (par défaut `280` par image et `140` par image vidéo). Des valeurs plus faibles réduisent la longueur de la séquence et la latence : ```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]) ``` ### Contrôles de l'échantillonnage des images vidéo Par défaut, [EmbeddingGemma2VideoProcessor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) échantillonne les images à 1 FPS (`fps=1`), limite chaque clip à 32 images (`max_frames=32`, `overflow_strategy="uniform"`) et omet les horodatages des images du prompt (`add_timestamps=False`). Chaque paramètre peut être remplacé pour chaque appel : - `fps` (`int | float | None`) : taux d'échantillonnage cible en images par seconde. Nécessite `VideoMetadata` avec des valeurs valides pour `fps` et `duration` (remplies automatiquement lors du décodage depuis un fichier vidéo ou une URL). Pour les tableaux de frames pré-décodées sans métadonnées, l'échantillonnage par FPS est ignoré avec un avertissement et `max_frames` est appliqué directement. - `max_frames` (`int | None`) : nombre maximal de frames conservées par vidéo. - `overflow_strategy` (`"uniform" | "truncate" | None`) : la manière dont les images excédentaires au-delà de `max_frames` sont réduites (`"uniform"` rééchantillonne uniformément sur l’ensemble du clip ; `"truncate"` conserve les `max_frames` premières images). - `add_timestamps` (`bool`) : indique s'il faut préfixer le bloc de jetons doux de chaque image par son horodatage `mm:ss`. Contrairement à `fps`, ce paramètre ne propose pas de valeur par défaut : `add_timestamps=True` sur une vidéo dont les métadonnées ne contiennent pas de `fps` provoque une erreur, car un taux estimé écrirait des libellés `mm:ss` incorrects dans le prompt. ```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", ) ``` ### Appels directs de `processor(...)` sans modèle de chat Bien que `processor.apply_chat_template` soit le point d’entrée principal pour les conversations multimodales, `processor(...)` peut également être appelé directement. Lorsque `text` est omis (`text=None`), les espaces réservés `<|image|>`, `<|video|>` et `<|audio|>` sont synthétisés automatiquement pour chaque échantillon du lot : ```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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/configuration_embedding_gemma2.py#L37) **Paramètres :** vocab_size (`int`, *facultatif*, valeur par défaut `262144`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, par défaut `512`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `4`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_key_value_heads (`int`, *facultatif*, valeur par défaut `2`) : C'est le nombre de têtes key_value à utiliser pour implémenter le Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera le Multi Head Attention (MHA) ; si `num_key_value_heads=1`, il utilisera le Multi Query Attention (MQA) ; sinon, le GQA est utilisé. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête key et value de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`. head_dim (`int`, *facultatif*, valeur par défaut `256`) : La dimension des têtes d'attention. Si None, elle prendra par défaut la valeur hidden_size // num_attention_heads hidden_activation (`str`, *facultatif*, par défaut `gelu_pytorch_tanh`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *facultatif*, valeur par défaut `262144`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. rms_norm_eps (`float`, *facultatif*, valeur par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation rms. pad_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `1`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur par défaut `2`) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire. rope_parameters (`dict`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs. attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention. attention_dropout (`Union[int, float]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. sliding_window (`int`, *facultatif*, valeur par défaut : 512) : Rayon inclusif de la fenêtre glissante bidirectionnelle : une couche `sliding_attention` porte son attention sur chaque position pour laquelle `abs(q_idx - kv_idx) <= sliding_window`. Il s'agit d'un rayon et non de la largeur unilatérale configurée par les modèles Gemma causaux, car le masque ici est symétrique ; la valeur par défaut est donc la moitié de la fenêtre de largeur 1024 indiquée par l'implémentation de référence. layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration. hidden_size_per_layer_input (`int`, *facultatif*, valeur par défaut : 512) : Dimensionnalité du signal résiduel par couche (PLE). EmbeddingGemma 2 utilise un PLE *projection-only* : le signal est dérivé uniquement de `inputs_embeds`, sans table de recherche de jetons auxiliaire. embedding_dim (`int`, *facultatif*, valeur par défaut 768) : Dimension de l'embedding de phrase produit par `embedding_projection`. Ceci est la classe de configuration destinée à stocker la configuration d'un EmbeddingGemma2Model. Elle est utilisée pour instancier un modèle Embedding Gemma2 en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## 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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/configuration_embedding_gemma2.py#L139) **Paramètres :** text_config (`EmbeddingGemma2TextConfig`, *facultatif*) : Configuration du backbone de texte. vision_config (`PreTrainedConfig` ou `dict`, *facultatif*) : Configuration de la tour de vision. Réutilisée telle quelle depuis Gemma 4 ; la tour elle-même est résolue à l'exécution via `AutoModel`. audio_config (`PreTrainedConfig` ou `dict`, *facultatif*) : Configuration de la tour audio. Réutilisée telle quelle depuis Gemma 4 ; la tour elle-même est résolue à l'exécution via `AutoModel`. boi_token_id (`int`, *facultatif*, valeur par défaut 255999) : L'index du jeton de début d'image à utiliser pour encadrer le prompt d'image. eoi_token_id (`int`, *facultatif*, valeur par défaut 258882) : L'index du jeton de fin d'image utilisé pour encadrer le prompt d'image. image_token_id (`int`, *facultatif*, valeur par défaut `258880`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée. video_token_id (`int`, *facultatif*, valeur par défaut `258884`) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée. boa_token_id (`int`, *facultatif*, valeur par défaut 256000) : L'index du jeton de début d'audio à utiliser pour encadrer le prompt audio. eoa_token_index (`int`, *facultatif*, valeur par défaut 258883) : L'index du jeton de fin d'audio à utiliser pour encadrer l'invite audio. audio_token_id (`int`, *facultatif*, valeur par défaut `258881`) : L'index du jeton audio utilisé comme espace réservé pour l'audio en entrée. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. Ceci est la classe de configuration destinée à stocker la configuration d'un EmbeddingGemma2Model. Elle est utilisée pour instancier un modèle Embedding Gemma2 en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]] #### transformers.EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]] ```python transformers.EmbeddingGemma2VideoProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L176) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `None`) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.0, 0.0, 0.0]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[1.0, 1.0, 1.0]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. do_sample_frames (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière. video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d'images. Elles seront utilisées pour échantillonner des images à partir de la vidéo ou pour calculer des horodatages. Ne passez aucune métadonnée à moins de tenter de décoder manuellement la vidéo avant le traitement. fps (`Annotated[int | float | None, None]`, *kwargs*, par défaut `1`) : Nombre de cibles d'images à échantillonner par seconde lorsque `do_sample_frames=True`. num_frames (`Annotated[int | None, None]`, *kwargs*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées de la vidéo sont un objet contenant des informations sur la durée de la vidéo, le nombre d'images par seconde, le backend de décodage, etc. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. patch_size (`int`, *kwargs*, *facultatif*) : Taille de chaque patch d'image en pixels. max_soft_tokens (`int`, *kwargs*, *facultatif*) : Nombre maximal de jetons doux (visuels) par image vidéo. Doit être l'un des éléments de {70, 140, 280, 560, 1120}. pooling_kernel_size (`int`, *kwargs*, *facultatif*) : Taille du noyau de pooling spatial appliquée après la patchification. add_timestamps (`bool`, *kwargs*, *facultatif*) : Indique s'il faut préfixer chaque image de l'expansion du placeholder vidéo avec son horodatage `mm:ss`. Nécessite `VideoMetadata` avec un `fps` valide, car les horodatages ne peuvent pas être déduits des images déjà décodées. max_frames (`int`, *kwargs*, *facultatif*) : Nombre maximal d'images à échantillonner. Si défini, les indices échantillonnés seront rééchantillonnés uniformément pour respecter ce budget. overflow_strategy (`str`, *kwargs*, *facultatif*) : La stratégie utilisée pour réduire le nombre total d'images échantillonnées afin de respecter le budget. Ne peut être définie que sur "uniform" ou "truncate". Appliquée après l'échantillonnage basé sur les FPS, et seule lorsque l'échantillonnage basé sur les FPS est désactivé ou non applicable. load_audio_from_video (`bool`, *kwargs*, *facultatif*) : Indique s'il faut charger la piste audio d'une vidéo d'entrée ou non. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge. Construit un processeur vidéo EmbeddingGemma2VideoProcessor. #### prétraiter[[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: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L240) **Paramètres :** 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]]]`) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels vont de 0 à 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. do_sample_frames (`bool`, *kwargs*, *facultatif*) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière. video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d'images. Elles seront utilisées pour échantillonner des images à partir de la vidéo ou pour calculer des horodatages. Ne passez aucune métadonnée à moins de tenter de décoder manuellement la vidéo avant le traitement. fps (`Annotated[int | float | None, None]`, *kwargs*) : Nombre de cibles à échantillonner par seconde lorsque `do_sample_frames=True`. num_frames (`Annotated[int | None, None]`, *kwargs*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *facultatif*) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées de la vidéo sont un objet contenant des informations sur la durée de la vidéo, le nombre d'images par seconde, le backend de décodage, etc. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. patch_size (`int`, *kwargs*, *facultatif*) : Taille de chaque patch d'image en pixels. max_soft_tokens (`int`, *kwargs*, *facultatif*) : Nombre maximal de jetons doux (visuels) par image vidéo. Doit être l'un des éléments de {70, 140, 280, 560, 1120}. pooling_kernel_size (`int`, *kwargs*, *facultatif*) : Taille du noyau de pooling spatial appliquée après la patchification. add_timestamps (`bool`, *kwargs*, *facultatif*) : Indique s'il faut préfixer chaque image de l'expansion du placeholder vidéo avec son horodatage `mm:ss`. Nécessite `VideoMetadata` avec un `fps` valide, car les horodatages ne peuvent pas être déduits des images déjà décodées. max_frames (`int`, *kwargs*, *facultatif*) : Nombre maximal d'images à échantillonner. Si défini, les indices échantillonnés seront rééchantillonnés uniformément pour respecter ce budget. overflow_strategy (`str`, *kwargs*, *facultatif*) : La stratégie utilisée pour réduire le nombre total d'images échantillonnées afin de respecter le budget. Ne peut être définie que sur "uniform" ou "truncate". Appliquée après l'échantillonnage basé sur les FPS, et seule lorsque l'échantillonnage basé sur les FPS est désactivé ou non applicable. load_audio_from_video (`bool`, *kwargs*, *facultatif*) : Indique s'il faut charger la piste audio d'une vidéo d'entrée ou non. **Retourne :** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.). - **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation. ## 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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/processing_embedding_gemma2.py#L106) **Paramètres :** feature_extractor (*Gemma4AudioFeatureExtractor*) : l'extracteur de caractéristiques est une entrée obligatoire. image_processor (*Gemma4ImageProcessor*) : le processeur d'images est une entrée obligatoire. tokenizer (*tokenizer_class*) : Le tokenizer est une entrée obligatoire. video_processor (*EmbeddingGemma2VideoProcessor*) : le processeur vidéo est une entrée obligatoire. chat_template (*str*) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable. image_seq_length (*int*, *optionnel*, valeur par défaut 280) : Nombre de jetons doux par image utilisés pour l'expansion des espaces réservés. audio_seq_length (*int*, *optionnel*, valeur par défaut : 750) : Nombre maximal de jetons audio doux par segment audio. Sert de limite supérieure lorsque les nombres de jetons audio dynamiques sont calculés. audio_ms_per_token (*int*, *facultatif*, valeur par défaut 40) : Nombre de millisecondes d'audio par jeton soft de sortie. Utilisé pour calculer dynamiquement le nombre de jetons de remplacement audio via `ceil(duration_ms / audio_ms_per_token)`. La valeur par défaut de 40 provient de la réduction temporelle de 4× de la convolution SSCP sur des trames de 10 ms. Construit un EmbeddingGemma2Processor qui encapsule un extracteur de caractéristiques, un processeur d’images, un tokeniseur et un processeur de vidéos en un seul processeur. [*EmbeddingGemma2Processor*] offre toutes les fonctionnalités de [*Gemma4AudioFeatureExtractor*], [*Gemma4ImageProcessor*], [*tokenizer_class*] et [*EmbeddingGemma2VideoProcessor*]. Consultez [*~Gemma4AudioFeatureExtractor*], [*~Gemma4ImageProcessor*], [*~tokenizer_class*] et [*~EmbeddingGemma2VideoProcessor*] pour plus d'informations. #### __appel__[[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: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2439) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot. 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]]]`, *facultatif*) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio. audio_from_video_indices (`list[int]`, *facultatif*) : Une liste qui décrit la source de chaque emplacement audio, où - `None` -> audio autonome non associé à aucune piste vidéo - `i` -> audio extrait de videos[i] return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge. ## EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]] #### transformers.EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]] ```python transformers.EmbeddingGemma2PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L442) **Paramètres :** config ([PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.EmbeddingGemma2PreTrainedModel.forward]] ```python forward(*args, **kwargs) ``` Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice. ## EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]] #### transformers.EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]] ```python transformers.EmbeddingGemma2TextModel(config: EmbeddingGemma2TextConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L477) **Paramètres :** config ([EmbeddingGemma2TextConfig](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le backbone de texte d'EmbeddingGemma 2. Il possède le `embedding_projection` qui projette les états cachés finaux vers `config.embedding_dim`, de sorte que le modèle composite n'a pas besoin de redéfinir `forward`. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### 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.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L510) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. **Retourne :** [BaseModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)` Un [BaseModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([EmbeddingGemma2Config](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) et les entrées. La méthode forward du modèle [EmbeddingGemma2TextModel](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]] #### transformers.EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]] ```python transformers.EmbeddingGemma2Model(config: EmbeddingGemma2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L633) **Paramètres :** config ([EmbeddingGemma2Config](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle EmbeddingGemma 2 : un backbone de vision, un backbone audio et un backbone de texte dont les états cachés finaux sont projetés vers `config.text_config.embedding_dim`. Conçu pour être encapsulé par le mean pooling et la normalisation de SentenceTransformers. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.EmbeddingGemma2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = 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.Tensor] = 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: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L739) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [Gemma4ImageProcessor](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4ImageProcessor). Voir [Gemma4ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([EmbeddingGemma2Processor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utilise [Gemma4ImageProcessor](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4ImageProcessor) pour le traitement des images). pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *facultatif*) : Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels des vidéos peuvent être obtenues à l’aide de [EmbeddingGemma2VideoProcessor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor). Voir [EmbeddingGemma2VideoProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) pour plus de détails ([EmbeddingGemma2Processor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utilise [EmbeddingGemma2VideoProcessor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) pour le traitement des vidéos). input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de [Gemma4AudioFeatureExtractor](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor). Voir [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) pour plus de détails ([EmbeddingGemma2Processor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utilise [Gemma4AudioFeatureExtractor](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) pour le traitement des audios). attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) input_features_mask (`torch.Tensor` de forme `(num_images, seq_length)`) : Le masque d'attention pour l'audio d'entrée. position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. image_position_ids (`torch.LongTensor` de forme `(batch_size, max_patches, 2)`, *facultatif*) : coordonnées de position des patches 2D issues du processeur d’images, où `(-1, -1)` indique le bourrage. Transmise à l’encodeur visuel pour le calcul des embeddings positionnels. video_position_ids (`torch.LongTensor` de forme `(total_num_frames, max_patches, 2)`, *facultatif*) : coordonnées de position des patches 2D issues du processeur vidéo, où `(-1, -1)` indique le bourrage. Transmise à l'encodeur visuel pour le calcul des embeddings positionnels. num_frames_per_video (`torch.LongTensor` de forme `(num_videos,)`, *facultatif*) : Nombre d'images appartenant à chaque vidéo. Obligatoire lorsque `pixel_values_videos` est transmis, car les images de toutes les vidéos sont concaténées le long d'un seul axe. **Retourne :** `EmbeddingGemma2ModelOutput` ou `tuple(torch.Tensor)` Un `EmbeddingGemma2ModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([EmbeddingGemma2Config](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) et les entrées. La méthode forward du modèle [EmbeddingGemma2Model](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **image_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states du modèle produit par l'encodeur visuel et après projection de l'état caché final. - **audio_hidden_states** (`torch.Tensor`, *facultatif*) -- Un `torch.Tensor` de taille `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states du modèle, générés par l'encodeur audio après projection de l'état caché final. #### get_image_features[[transformers.EmbeddingGemma2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, image_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L662) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [Gemma4ImageProcessor](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4ImageProcessor). Consultez [Gemma4ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([EmbeddingGemma2Processor](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utilise [Gemma4ImageProcessor](/docs/transformers/main/fr/model_doc/gemma4#transformers.Gemma4ImageProcessor) pour le traitement des images). image_position_ids (`torch.LongTensor` de forme `(batch_size, max_patches, 2)`, *facultatif*) : Les positions des patches en coordonnées (x, y) dans l'image. Les patches de bourrage sont indiqués par (-1, -1). **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([EmbeddingGemma2Config](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) et les entrées. Projette l'état caché final du modèle de vision dans l'espace du modèle de langage. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. #### get_video_features[[transformers.EmbeddingGemma2Model.get_video_features]] ```python get_video_features(pixel_values_videos: Tensor, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L880) **Paramètres :** pixel_values_videos (`torch.Tensor` de forme `(total_num_frames, max_patches, patch_pixels)`) : Les images de toutes les vidéos du lot, concaténées le long de l'axe des images plutôt que superposées sur un axe vidéo distinct, afin que des vidéos de longueurs différentes puissent être regroupées dans un même lot. video_position_ids (`torch.LongTensor` de forme `(total_num_frames, max_patches, 2)`, *facultatif*) : coordonnées de position des patches 2D issues du processeur vidéo, où `(-1, -1)` indique le bourrage. Transmise à l'encodeur visuel pour le calcul des embeddings positionnels. num_frames_per_video (`torch.LongTensor` de forme `(num_videos,)`) : Nombre d'images appartenant à chaque vidéo, utilisé pour diviser la séquence plate d'images par vidéo. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([EmbeddingGemma2Config](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) et les entrées. Projette l'état caché final du codeur visuel dans l'espace du modèle de langage. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. #### get_audio_features[[transformers.EmbeddingGemma2Model.get_audio_features]] ```python get_audio_features(input_features: Tensor, input_features_mask: Tensor, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L855) **Paramètres :** input_features (`torch.Tensor` de forme `(num_images, seq_length, num_features)`) : Les tenseurs correspondant à l'audio d'entrée. input_features_mask (`torch.Tensor` de forme `(num_images, seq_length)`) : Le masque d'attention pour l'audio d'entrée. **Retourne :** `EmbeddingGemma2AudioModelOutput` ou `tuple(torch.Tensor)` Un `EmbeddingGemma2AudioModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([EmbeddingGemma2Config](/docs/transformers/main/fr/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) et les entrées. Projette l'état caché final du codeur audio dans l'espace du modèle de langage. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **attention_mask** (`torch.BoolTensor`, *facultatif*) -- Un torch.BoolTensor de forme `(batch_size, num_frames)`. True pour les positions valides, False pour le padding.