# EmbeddingGemma2

## Resumen

EmbeddingGemma 2 es un modelo de incrustación multimodal de Google basado en la arquitectura [Gemma 4](./gemma4). Codifica **texto, imágenes, audio y video**, ya sea de forma individual o combinados en la misma entrada, en un espacio vectorial denso compartido de 768 dimensiones para recuperación entre modalidades, similitud semántica, agrupamiento y clasificación.

Características principales:

- **Un espacio vectorial multimodal unificado.** Las torres de visión ([Gemma4VisionModel](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4VisionModel)) y de audio ([Gemma4AudioModel](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4AudioModel)) proyectan en un codificador de texto bidireccional ([EmbeddingGemma2TextModel](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel)) que intercala atención completa y atención con ventana deslizante mediante Per-Layer Embeddings (PLE). Cualquier modalidad individual (`text`, `image`, `audio`, `video`) o combinación de modalidades (`image + text`, `text + audio`, `image + audio`, varias imágenes, texto y medios intercalados) se mapea a un único embedding comparable.
- **Aprendizaje de representaciones Matryoshka (MRL).** [EmbeddingGemma2Model](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) genera representaciones de tokens proyectadas a `embedding_dim` (`768`) mediante una capa lineal. Las representaciones pueden truncarse a un prefijo más pequeño (`512`, `256` o `128`) y renormalizarse con una pérdida mínima de calidad.
- **Presupuestos visuales y de video configurables.** [EmbeddingGemma2Processor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) permite ajustar el presupuesto de soft tokens por imagen o fotograma (`max_soft_tokens` en `{70, 140, 280, 560, 1120}`) y la tasa de muestreo de video (`fps=1`, `max_frames=32`, `overflow_strategy="uniform"`, `add_timestamps=False` por defecto).
- **Carga selectiva de torres de modalidad.** Las torres de visión o audio que no se utilicen pueden desactivarse en el momento de la carga (`vision_config=None`, `audio_config=None`) para reducir la huella de memoria en despliegues de solo texto o de una sola modalidad.

Puedes encontrar todos los puntos de control originales de EmbeddingGemma en la colección [EmbeddingGemma](https://huggingface.co/collections/google/embeddinggemma). Los ejemplos a continuación utilizan el identificador `google/embeddinggemma-2`.

## Ejemplos de uso

Una representación de una oración o multimodal se obtiene en dos pasos: un pooling medio consciente de las máscaras sobre los tokens no rellenos de `last_hidden_state`, seguido de una normalización L2 en `float32`. [Sentence Transformers](https://sbert.net) (`>=6.1.0`) realiza el preprocesamiento, el formato de los prompts, el pooling medio y la normalización de forma automática y es el punto de entrada recomendado. Con [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel), use `processor.apply_chat_template` (o `AutoTokenizer` para texto plano) y aplique el pooling directamente a `last_hidden_state`.

### Recuperación de texto (`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 tareas

El modelo admite prompts de tarea opcionales que se antepone a la entrada (e incluidos en el pooling medio), aunque los prompts no son obligatorios y el modelo también funciona sin ellos. Dado que la configuración óptima depende del dominio de destino y de la mezcla de modalidades, recomendamos evaluar tanto con como sin prompts de tarea en su tarea específica. Sentence Transformers incluye el catálogo siguiente en `config_sentence_transformers.json`, por lo que debe pasar `prompt_name` (o usar `encode_query` / `encode_document`, que se mapean a `query` y `document`); con [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel), pase el prompt como un mensaje `system` en `apply_chat_template` (o antepóngalo al texto plano).

```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 cabeza de incrustación se entrena con Matryoshka Representation Learning, por lo que una incrustación de 768 dimensiones se puede recortar a un prefijo más corto (`512`, `256` o `128`) y renormalizar. Esto reduce el índice y acelera la recuperación, preservando en gran medida la calidad del ordenamiento. Trunca las consultas y los documentos a la *misma* dimensión y normaliza siempre después de recortar: en Sentence Transformers, `truncate_dim` recorta la salida ya normalizada, por lo que el prefijo ya no tiene longitud unitaria.

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

## Incrustaciones multimodales

El texto, las imágenes, el audio y el vídeo se mapean en el mismo espacio vectorial de 768 dimensiones, lo que permite la **recuperación entre modalidades** (por ejemplo, buscar imágenes, audio o vídeos con una consulta de texto) y la **recuperación multimodal compuesta** (combinar varias modalidades en una única consulta o representación de documento).

En Sentence Transformers, las entradas multimodales se pasan como diccionarios con las claves `"text"`, `"image"`, `"audio"` y `"video"` (donde cada valor puede ser un elemento único o una lista de elementos). Con [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel), pase listas de mensajes de estilo chat a `processor.apply_chat_template(..., tokenize=True, return_dict=True, return_tensors="pt")`.

### 1. Modalidades individuales y recuperación entre modalidades

Cada modalidad (`text`, `image`, `audio`, `video`) puede incrustarse de forma independiente y compararse directamente con cualquier otra modalidad mediante similitud coseno:

```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. Incrustaciones multimodales compuestas (varias modalidades en una sola entrada)

Se pueden combinar múltiples modalidades, o múltiples elementos de la misma modalidad, en un **único embedding conjunto**, incluidas combinaciones puramente no textuales como `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. Orden automático frente a marcadores de posición manuales

Cuando no aparecen tokens de marcador de posición (`<|image|>`, `<|video|>`, `<|audio|>`) en el texto, las modalidades se emiten en el orden exacto en que aparecen sus entradas en el diccionario o en el `content` del mensaje de chat (inmediatamente después de cualquier `system` prompt de tarea).

Para intercalar texto y medios en posiciones específicas dentro de una oración, escriba `<|image|>`, `<|video|>` o `<|audio|>` directamente en el texto: la inserción automática de marcadores se deshabilita para esa entrada y cada marcador se expande en orden con los elementos de medios proporcionados:

```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
#    -> <bos> [prompt] <image_tokens> <text_tokens> <eos>
image_first = model.encode({"image": IMAGE_1, "text": "A photo of a cat"}, prompt_name="document")

#    -> <bos> [prompt] <text_tokens> <image_tokens> <eos>
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. Loteo heterogéneo (de modalidades mixtas)

Un solo lote puede combinar texto plano, medios de una sola modalidad y entradas multimodales en una sola pasada hacia adelante, produciendo la misma representación por fila que codificar cada elemento individualmente:

```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. Desactivar torres de modalidades no utilizadas (optimización de memoria)

Si su carga de trabajo solo incrusta un subconjunto de modalidades (por ejemplo, **solo texto** o **texto + imágenes** sin audio), puede omitir la instanciación y la carga de las torres de visión o audio no utilizadas estableciendo `vision_config=None` y/o `audio_config=None` en la configuración. Los pesos de la torre no utilizada en el punto de control se ignoran limpiamente sin advertencias, reduciendo el modelo de 744M a 439M de parámetros sin la torre de audio, o a 271M sin ninguna de las dos torres.

Pásalos a través de `config_kwargs` (que llega a `AutoConfig.from_pretrained`), no a `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",
)
```

## Processor

[EmbeddingGemma2Processor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) agrupa el tokenizador, el procesador de imágenes, el extractor de características de audio y el procesador de video.

> [!TIP]
> Para entradas multimodales por lotes, recomendamos pasar diccionarios por muestra a través de **Sentence Transformers** (`model.encode([{"image": ..., "text": ...}, ...])`). Para un control máximo sobre el orden exacto de las modalidades y su intercalado, incluya manualmente los marcadores de posición `<|image|>`, `<|video|>` y `<|audio|>` en `text`.

### Control del presupuesto de tokens visuales (`max_soft_tokens`)

El presupuesto de tokens suaves (`max_soft_tokens`, valores admitidos `{70, 140, 280, 560, 1120}`) controla la resolución y el número de tokens visuales generados por imagen o por fotograma de vídeo (con un valor predeterminado de `280` por imagen y `140` por fotograma de vídeo). Los valores más bajos reducen la longitud de la secuencia y la latencia:

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

### Controles de muestreo de fotogramas de video

Por defecto, [EmbeddingGemma2VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) muestrea fotogramas a 1 FPS (`fps=1`), limita cada clip a 32 fotogramas (`max_frames=32`, `overflow_strategy="uniform"`) y omite las marcas de tiempo de los fotogramas del prompt (`add_timestamps=False`). Cada parámetro se puede sobrescribir en cada llamada:

- `fps` (`int | float | None`): tasa de muestreo objetivo en fotogramas por segundo. Requiere `VideoMetadata` con `fps` y `duration` válidos (se rellenan automáticamente al decodificar desde un archivo de video/URL). Para matrices de fotogramas predecodificados sin metadatos, el muestreo por FPS se omite con una advertencia y se aplica `max_frames` directamente.
- `max_frames` (`int | None`): número máximo de fotogramas conservados por video.
- `overflow_strategy` (`"uniform" | "truncate" | None`): cómo se reducen los fotogramas excedentes por encima de `max_frames` (`"uniform"` realiza una re-muestreo uniforme en todo el clip; `"truncate"` conserva los primeros `max_frames` fotogramas).
- `add_timestamps` (`bool`): si se debe prefijar el bloque de soft-tokens de cada fotograma con su marca de tiempo `mm:ss`. A diferencia de `fps`, esta opción no tiene valor predeterminado: si se establece `add_timestamps=True` en un video cuyo metadatos no incluye `fps`, se generará un error, ya que una tasa estimada escribiría etiquetas `mm:ss` incorrectas en el 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",
)
```

### Llamadas directas a `processor(...)` sin plantilla de chat

Aunque `processor.apply_chat_template` es el punto de entrada principal para conversaciones multimodales, también se puede llamar directamente a `processor(...)`. Cuando se omite `text` (`text=None`), los marcadores de posición `<|image|>`, `<|video|>` y `<|audio|>` se sintetizan automáticamente para cada muestra del lote:

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/configuration_embedding_gemma2.py#L37)

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `262144`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

hidden_size (`int`, *opcional*, valor predeterminado `512`) : Dimensión de las representaciones ocultas.

intermediate_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones MLP.

num_hidden_layers (`int`, *opcional*, valor predeterminado `24`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `4`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

num_key_value_heads (`int`, *opcional*, valor predeterminado `2`) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulte [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

head_dim (`int`, *opcional*, valor predeterminado `256`) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads

hidden_activation (`str`, *opcional*, valor predeterminado `gelu_pytorch_tanh`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *opcional*, valor predeterminado `262144`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización rms.

pad_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el relleno en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `1`) : Id del token utilizado para el fin de la secuencia en el vocabulario.

bos_token_id (`int`, *opcional*, valor predeterminado `2`) : Identificador de token utilizado para el inicio de la secuencia en el vocabulario.

rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos.

attention_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

attention_dropout (`Union[int, float]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

sliding_window (`int`, *opcional*, valor predeterminado 512) : Radio inclusivo de la ventana deslizante bidireccional: una capa `sliding_attention` atiende a todas las posiciones con `abs(q_idx - kv_idx) <= sliding_window`. Es un radio y no el ancho unilateral que configuran los modelos Gemma causales, porque la máscara aquí es simétrica, por lo que el valor predeterminado es la mitad de la ventana de ancho 1024 que indica la implementación de referencia.

layer_types (`list[str]`, *opcional*) : Una lista que mapea explícitamente cada índice de capa con su tipo de capa. Si no se proporciona, se generará automáticamente en función de los valores de la configuración.

hidden_size_per_layer_input (`int`, *opcional*, valor predeterminado: 512) : Dimensionalidad de la señal residual por capa (PLE). EmbeddingGemma 2 utiliza PLE de *solo proyección*: la señal se deriva únicamente de `inputs_embeds`, sin una tabla de búsqueda de tokens auxiliares.

embedding_dim (`int`, *opcional*, valor predeterminado 768) : Dimensionalidad del embedding de oración producido por `embedding_projection`.

Esta es la clase de configuración para almacenar la configuración de un EmbeddingGemma2Model. Se utiliza para instanciar un modelo Embedding Gemma2 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/configuration_embedding_gemma2.py#L139)

**Parámetros:**

text_config (`EmbeddingGemma2TextConfig`, *opcional*) : Configuración del backbone de texto.

vision_config (`PreTrainedConfig` o `dict`, *opcional*) : Configuración de la torre de visión. Se reutiliza textualmente de Gemma 4; la propia torre se resuelve en tiempo de ejecución a través de `AutoModel`.

audio_config (`PreTrainedConfig` o `dict`, *opcional*) : Configuración de la torre de audio. Se reutiliza textualmente de Gemma 4; la propia torre se resuelve en tiempo de ejecución a través de `AutoModel`.

boi_token_id (`int`, *opcional*, valor predeterminado 255999) : El índice del token de inicio de imagen para envolver el prompt de imagen.

eoi_token_id (`int`, *opcional*, valor predeterminado 258882) : El índice del token de fin de imagen para envolver el prompt de imagen.

image_token_id (`int`, *opcional*, valor predeterminado `258880`) : El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada.

video_token_id (`int`, *opcional*, valor predeterminado `258884`) : El índice de token de video utilizado como marcador de posición para los videos de entrada.

boa_token_id (`int`, *opcional*, valor predeterminado 256000) : El índice del token de inicio de audio para envolver el prompt de audio.

eoa_token_index (`int`, *opcional*, valor predeterminado 258883) : El índice del token de fin de audio para envolver el prompt de audio.

audio_token_id (`int`, *opcional*, valor predeterminado `258881`) : El índice de token de audio utilizado como marcador de posición para el audio de entrada.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

Esta es la clase de configuración para almacenar la configuración de un EmbeddingGemma2Model. Se utiliza para instanciar un modelo Embedding Gemma2 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]]

#### transformers.EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]]

```python
transformers.EmbeddingGemma2VideoProcessor(**kwargs: *<class 'transformers.models.embedding_gemma2.video_processing_embedding_gemma2.EmbeddingGemma2VideoProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L177)

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `None`) : Describe las dimensiones de entrada máximas del modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `3`) : Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.0, 0.0, 0.0]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` se establece en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[1.0, 1.0, 1.0]`) : Desviación estándar de la imagen que se usará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se deben muestrear fotogramas del video antes de procesarlo o si se debe procesar el video completo.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo

fps (`Annotated[int | float | None, None]`, *kwargs*, por defecto `1`) : Marcos objetivo a muestrear por segundo cuando `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Número máximo de fotogramas a muestrear cuando `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe devolver o no la metadatos del video. Los metadatos del video son un objeto que contiene información sobre la duración del video, los fps, el backend de decodificación, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

patch_size (`int`, *kwargs*, *opcional*) : Tamaño de cada parche de imagen en píxeles.

max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visión) por fotograma de vídeo. Debe ser uno de {70, 140, 280, 560, 1120}.

pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamaño del kernel de pooling espacial aplicado después de la segmentación en parches.

add_timestamps (`bool`, *kwargs*, *opcional*) : Indica si se debe añadir un prefijo con la marca de tiempo `mm:ss` a cada fotograma en la expansión del marcador de posición de video. Requiere `VideoMetadata` con un `fps` válido, ya que las marcas de tiempo no se pueden inferir a partir de fotogramas ya decodificados.

max_frames (`int`, *kwargs*, *opcional*) : El número máximo de fotogramas a muestrear. Si se establece, los índices muestreados se volverán a muestrear de forma uniforme para ajustarse al presupuesto.

overflow_strategy (`str`, *kwargs*, *opcional*) : La estrategia utilizada para reducir el número total de fotogramas muestreados para que quepa en el presupuesto. Solo se puede establecer en "uniform" o "truncate". Se aplica después del muestreo basado en FPS, y por sí solo cuando el muestreo basado en FPS está desactivado o no es aplicable.

load_audio_from_video (`bool`, *kwargs*, *opcional*) : Obsoleto, use `OmniModalProcessingKwargs.load_audio_from_video` en su lugar. Indica si se debe cargar la pista de audio de un video de entrada o no.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de video 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: *<class 'transformers.models.embedding_gemma2.video_processing_embedding_gemma2.EmbeddingGemma2VideoProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L241)

**Parámetros:**

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]]]`) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*) : Indica si se deben muestrear fotogramas del vídeo antes de procesarlo o si se debe procesar el vídeo completo.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo

fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos objetivo a muestrear por segundo cuando `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Número máximo de fotogramas a muestrear cuando `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *opcional*) : Indica si se debe devolver o no los metadatos del vídeo. Los metadatos del vídeo son un objeto que contiene información sobre la duración del vídeo, los fps, el backend de decodificación, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

patch_size (`int`, *kwargs*, *opcional*) : Tamaño de cada parche de imagen en píxeles.

max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visión) por fotograma de vídeo. Debe ser uno de {70, 140, 280, 560, 1120}.

pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamaño del kernel de pooling espacial aplicado después de la segmentación en parches.

add_timestamps (`bool`, *kwargs*, *opcional*) : Indica si se debe añadir un prefijo con la marca de tiempo `mm:ss` a cada fotograma en la expansión del marcador de posición de video. Requiere `VideoMetadata` con un `fps` válido, ya que las marcas de tiempo no se pueden inferir a partir de fotogramas ya decodificados.

max_frames (`int`, *kwargs*, *opcional*) : El número máximo de fotogramas a muestrear. Si se establece, los índices muestreados se volverán a muestrear de forma uniforme para ajustarse al presupuesto.

overflow_strategy (`str`, *kwargs*, *opcional*) : La estrategia utilizada para reducir el número total de fotogramas muestreados para que quepa en el presupuesto. Solo se puede establecer en "uniform" o "truncate". Se aplica después del muestreo basado en FPS, y por sí solo cuando el muestreo basado en FPS está desactivado o no es aplicable.

load_audio_from_video (`bool`, *kwargs*, *opcional*) : Obsoleto, use `OmniModalProcessingKwargs.load_audio_from_video` en su lugar. Indica si se debe cargar la pista de audio de un video de entrada o no.

**Devuelve:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/processing_embedding_gemma2.py#L98)

**Parámetros:**

feature_extractor (*Gemma4AudioFeatureExtractor*) : El extractor de características es una entrada obligatoria.

image_processor (*Gemma4ImageProcessor*) : El procesador de imágenes es una entrada obligatoria.

tokenizer (*tokenizer_class*): El tokenizador es una entrada obligatoria.

video_processor (*EmbeddingGemma2VideoProcessor*) : El procesador de video es una entrada obligatoria.

chat_template (*str*) : Una plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

image_seq_length (*int*, *optional*, por defecto 280) : El número de tokens suaves por imagen utilizados para la expansión del marcador de posición.

audio_seq_length (*int*, *optional*, valor predeterminado: 750) : Número máximo de tokens suaves de audio por segmento de audio. Actúa como un límite superior cuando se calculan las cantidades dinámicas de tokens de audio.

audio_ms_per_token (*int*, *optional*, valor predeterminado 40) : Milisegundos de audio por token suave de salida. Se utiliza para calcular dinámicamente el número de tokens de marcador de posición de audio como `ceil(duration_ms / audio_ms_per_token)`. El valor predeterminado de 40 proviene de la reducción temporal 4× de la convolución SSCP en marcos de 10 ms.

Construye un EmbeddingGemma2Processor que encapsula un extractor de características, un procesador de imágenes, un tokenizador y un procesador de video en un único procesador.

[*EmbeddingGemma2Processor*] ofrece todas las funcionalidades de [*Gemma4AudioFeatureExtractor*], [*Gemma4ImageProcessor*], [*tokenizer_class*] y [*EmbeddingGemma2VideoProcessor*]. Consulte [*~Gemma4AudioFeatureExtractor*], [*~Gemma4ImageProcessor*], [*~tokenizer_class*] y [*~EmbeddingGemma2VideoProcessor*] para obtener más información.

#### __llamada__[[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: *<class 'transformers.processing_utils.OmniModalProcessingKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/processing_utils.py#L2575)

**Parámetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagen para preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

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]]]`, *opcional*) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestreo del audio.

audio_from_video_indices (`list[int]`, *opcional*) : Una lista que describe la fuente de cada ranura de audio donde - `None` -> audio independiente asociado a ninguna pista de video - `i`    -> audio extraído de videos[i] Si `audio` tiene una entrada por ranura, el audio de `videos[i]` se toma de ella en lugar de ser decodificado.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** (`OmniModalProcessingKwargs`, *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

## EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]]

#### transformers.EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L442)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.EmbeddingGemma2PreTrainedModel.forward]]

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

Un valor simulado para una ruta con puntos (p. ej., `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulacro.

## EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]]

#### transformers.EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]]

```python
transformers.EmbeddingGemma2TextModel(config: EmbeddingGemma2TextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L477)

**Parámetros:**

config ([EmbeddingGemma2TextConfig](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El backbone de texto de EmbeddingGemma 2. Posee el `embedding_projection` que mapea los estados ocultos finales a `config.embedding_dim`, de modo que el modelo compuesto no necesita una sobrescritura de `forward`.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L510)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

**Devuelve:** [BaseModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o `tuple(torch.Tensor)`

Un [BaseModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) y las entradas.

El método forward de [EmbeddingGemma2TextModel](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]]

#### transformers.EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]]

```python
transformers.EmbeddingGemma2Model(config: EmbeddingGemma2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L633)

**Parámetros:**

config ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo EmbeddingGemma 2: un backbone de visión, un backbone de audio y un backbone de texto cuyos estados ocultos finales se proyectan a `config.text_config.embedding_dim`. Está diseñado para ser envuelto por el mean pooling y la normalización de SentenceTransformers.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L739)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando [Gemma4ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4ImageProcessor). Consulte [Gemma4ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utiliza [Gemma4ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4ImageProcessor) para procesar las imágenes).

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Los tensores correspondientes al video de entrada. Los valores de píxel de los videos se pueden obtener usando [EmbeddingGemma2VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor). Consulte [EmbeddingGemma2VideoProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para más detalles ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) usa [EmbeddingGemma2VideoProcessor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) para procesar videos).

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando [Gemma4AudioFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor). Consulte [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) para obtener más detalles ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utiliza [Gemma4AudioFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) para procesar audios).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : La máscara de atención para la entrada de audio.

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : coordenadas de posición de parches 2D del procesador de imágenes, donde `(-1, -1)` indica relleno. Se transmite al codificador de visión para el cálculo de la incrustación posicional.

video_position_ids (`torch.LongTensor` de forma `(total_num_frames, max_patches, 2)`, *opcional*) : coordenadas de posición de parches 2D del procesador de video, donde `(-1, -1)` indica relleno. Se transmite al codificador de visión para el cálculo de la incrustación posicional.

num_frames_per_video (`torch.LongTensor` de forma `(num_videos,)`, *opcional*) : Número de fotogramas que pertenecen a cada vídeo. Es obligatorio siempre que se pase `pixel_values_videos`, ya que los fotogramas de todos los vídeos se concatenan a lo largo de un único eje.

**Devuelve:** `EmbeddingGemma2ModelOutput` o `tuple(torch.Tensor)`

Un `EmbeddingGemma2ModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) y las entradas.

El método forward de [EmbeddingGemma2Model](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Un `torch.Tensor` de tamaño `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states del modelo generado por el codificador de visión y después de proyectar el último estado oculto.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Un `torch.Tensor` de tamaño `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states del modelo producido por el codificador de audio y después de proyectar el último estado oculto.

#### get_image_features[[transformers.EmbeddingGemma2Model.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L662)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando [Gemma4ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4ImageProcessor). Consulte [Gemma4ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) utiliza [Gemma4ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/gemma4#transformers.Gemma4ImageProcessor) para procesar imágenes).

image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : Las posiciones de los parches como coordenadas (x, y) en la imagen. Los parches de relleno se indican mediante (-1, -1).

**Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) y las entradas.

Proyecta el último estado oculto del modelo de visión al espacio del modelo de lenguaje.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

#### 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L880)

**Parámetros:**

pixel_values_videos (`torch.Tensor` de forma `(total_num_frames, max_patches, patch_pixels)`) : Los fotogramas de cada vídeo del lote, concatenados a lo largo del eje de fotogramas en lugar de apilados en un eje de vídeo separado, de modo que los vídeos de diferentes longitudes puedan agruparse en el mismo lote.

video_position_ids (`torch.LongTensor` de forma `(total_num_frames, max_patches, 2)`, *opcional*) : coordenadas de posición de parches 2D del procesador de video, donde `(-1, -1)` indica relleno. Se transmite al codificador de visión para el cálculo de la incrustación posicional.

num_frames_per_video (`torch.LongTensor` de forma `(num_videos,)`) : Número de fotogramas que pertenecen a cada vídeo, utilizado para dividir la secuencia plana de fotogramas de nuevo por vídeo.

**Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) y las entradas.

Proyecta el último estado oculto del codificador de visión al espacio del modelo de lenguaje.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

#### get_audio_features[[transformers.EmbeddingGemma2Model.get_audio_features]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/embedding_gemma2/modeling_embedding_gemma2.py#L855)

**Parámetros:**

input_features (`torch.Tensor` de forma `(num_images, seq_length, num_features)`) : Los tensores correspondientes al audio de entrada.

input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : La máscara de atención para la entrada de audio.

**Devuelve:** `EmbeddingGemma2AudioModelOutput` o `tuple(torch.Tensor)`

Un `EmbeddingGemma2AudioModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/es/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) y las entradas.

Proyecta el último estado oculto del codificador de audio al espacio del modelo de lenguaje.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **attention_mask** (`torch.BoolTensor`, *opcional*) -- Un torch.BoolTensor de forma `(batch_size, num_frames)`. True para posiciones válidas, False para relleno.

