# EmbeddingGemma2

## Visão geral

EmbeddingGemma 2 é um modelo de embedding multimodal da Google, construído sobre a arquitetura [Gemma 4](./gemma4). Ele codifica **texto, imagens, áudio e vídeo**—seja individualmente ou combinados na mesma entrada—em um espaço vetorial denso compartilhado de 768 dimensões, para recuperação entre modalidades, similaridade semântica, agrupamento e classificação.

Principais recursos:

- **Espaço vetorial multimodal unificado.** As torres de visão ([Gemma4VisionModel](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4VisionModel)) e de áudio ([Gemma4AudioModel](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4AudioModel)) projetam para um codificador de texto bidirecional ([EmbeddingGemma2TextModel](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel)) que intercala atenção completa e atenção em janela deslizante com Per-Layer Embeddings (PLE). Qualquer modalidade única (`text`, `image`, `audio`, `video`) ou combinação de modalidades (`image + text`, `text + audio`, `image + audio`, múltiplas imagens, texto e mídia intercalados) é mapeada para um único embedding comparável.
- **Aprendizado de Representação Matryoshka (MRL).** [EmbeddingGemma2Model](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) produz representações de tokens projetadas em `embedding_dim` (`768`) por meio de uma camada linear. Os embeddings podem ser truncados para um prefixo menor (`512`, `256` ou `128`) e renormalizados com perda mínima de qualidade.
- **Orçamentos visuais e de vídeo configuráveis.** O [EmbeddingGemma2Processor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) permite ajustar o orçamento de soft tokens por imagem ou quadro (`max_soft_tokens` em `{70, 140, 280, 560, 1120}`) e a taxa de amostragem de vídeo (`fps=1`, `max_frames=32`, `overflow_strategy="uniform"`, `add_timestamps=False` por padrão).
- **Carregamento seletivo de torres de modalidade.** Torres de visão ou áudio não utilizadas podem ser desativadas no momento do carregamento (`vision_config=None`, `audio_config=None`) para reduzir a pegada de memória em implantações apenas de texto ou de modalidade única.

Você pode encontrar todos os checkpoints originais do EmbeddingGemma na coleção [EmbeddingGemma](https://huggingface.co/collections/google/embeddinggemma). Os exemplos abaixo usam o identificador `google/embeddinggemma-2`.

## Exemplos de uso

Um embedding de frase ou multimodal é obtido em duas etapas: pooling médio com reconhecimento de máscara sobre os tokens não preenchidos de `last_hidden_state`, seguido pela normalização L2 em `float32`. O [Sentence Transformers](https://sbert.net) (`>=6.1.0`) executa o pré-processamento, o formatação de prompt, o pooling médio e a normalização automaticamente e é o ponto de entrada recomendado. Com o [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel), use `processor.apply_chat_template` (ou `AutoTokenizer` para texto simples) e aplique o pooling diretamente em `last_hidden_state`.

### Recuperação 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 tarefa

O modelo suporta prompts de tarefa opcionais adicionados ao início da entrada (e incluídos no mean pooling), embora os prompts não sejam obrigatórios e o modelo também funcione sem eles. Como a configuração ideal depende do domínio de destino e da mistura de modalidades, recomendamos avaliar tanto com quanto sem prompts de tarefa na sua tarefa específica. O Sentence Transformers fornece o catálogo abaixo em `config_sentence_transformers.json`, portanto, passe `prompt_name` (ou use `encode_query` / `encode_document`, que mapeiam para `query` e `document`); com [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel), passe o prompt como uma mensagem `system` em `apply_chat_template` (ou adicione-o ao início do texto simples).

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

A cabeça de incorporação é treinada com Matryoshka Representation Learning, de modo que uma incorporação de 768 dimensões pode ser reduzida a um prefixo mais curto (`512`, `256` ou `128`) e renormalizada. Isso reduz o tamanho do índice e acelera a recuperação, preservando em grande parte a qualidade do ranqueamento. Trunque consultas e documentos para a *mesma* dimensão e sempre normalize após o recorte — no Sentence Transformers, `truncate_dim` recorta a saída já normalizada, de modo que o prefixo não tem mais comprimento unitário.

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

Texto, imagens, áudio e vídeo são mapeados para o mesmo espaço vetorial de 768 dimensões, permitindo **recuperação entre modalidades** (por exemplo, buscar imagens, áudios ou vídeos com uma consulta de texto) e também **recuperação multimodal composta** (combinando múltiplas modalidades em um único embedding de consulta ou documento).

No Sentence Transformers, as entradas multimodais são passadas como dicionários com as chaves `"text"`, `"image"`, `"audio"` e `"video"` (em que cada valor pode ser um item único ou uma lista de itens). Com o [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel), passe listas de mensagens no estilo chat para `processor.apply_chat_template(..., tokenize=True, return_dict=True, return_tensors="pt")`.

### 1. Modalidades únicas & recuperação entre modalidades

Cada modalidade (`text`, `image`, `audio`, `video`) pode ser incorporada individualmente e comparada diretamente com qualquer outra modalidade por meio de similaridade de cosseno:

```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. Incorporações multimodais compostas (várias modalidades em uma única entrada)

Múltiplas modalidades — ou múltiplos itens da mesma modalidade — podem ser combinados em um **único embedding conjunto**, incluindo combinações puramente não textuais, 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. Ordenação automática vs. placeholders manuais

Quando nenhum token de marcador de posição (`<|image|>`, `<|video|>`, `<|audio|>`) aparece no texto, as modalidades são emitidas na ordem exata em que suas entradas aparecem no dicionário ou no `content` da mensagem de chat (imediatamente após qualquer prompt de tarefa `system`).

Para intercalar texto e mídia em posições específicas dentro de uma frase, escreva `<|image|>`, `<|video|>` ou `<|audio|>` diretamente no texto — a inserção automática de placeholders é desativada para essa entrada, e cada placeholder é expandido em ordem com os itens de mídia fornecidos:

```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. Lote heterogêneo (modalidade mista)

Um único lote pode misturar texto puro, mídia de uma única modalidade e entradas multimodais em uma única passagem de frente, produzindo o mesmo embedding por linha do que codificar cada item 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. Desativando torres de modalidade não utilizadas (otimização de memória)

Se sua carga de trabalho incorpora apenas um subconjunto de modalidades (por exemplo, **apenas texto** ou **texto + imagens** sem áudio), você pode pular a instanciação e o carregamento das torres de visão ou áudio não utilizadas, definindo `vision_config=None` e/ou `audio_config=None` na configuração. Os pesos da torre não utilizada no checkpoint são ignorados sem avisos, reduzindo o modelo de 744M para 439M de parâmetros sem a torre de áudio, ou para 271M sem nenhuma das torres.

Passe-os por meio de `config_kwargs` (que chega a `AutoConfig.from_pretrained`), e não por `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/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) agrupa o tokenizer, o processador de imagem, o extrator de recursos de áudio e o processador de vídeo.

> [!TIP]
> Para entradas multimodais em lote, recomendamos passar dicionários por amostra através do **Sentence Transformers** (`model.encode([{"image": ..., "text": ...}, ...])`). Para controle máximo sobre a ordem exata das modalidades e sua intercalação, inclua manualmente os placeholders `<|image|>`, `<|video|>` e `<|audio|>` em `text`.

### Controlando o orçamento de tokens visuais (`max_soft_tokens`)

O orçamento de soft tokens (`max_soft_tokens`, valores suportados `{70, 140, 280, 560, 1120}`) controla a resolução e o número de tokens visuais gerados por imagem ou por quadro de vídeo (padrão: `280` por imagem e `140` por quadro de vídeo). Valores menores reduzem o comprimento da sequência e a latência:

```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 amostragem de quadros de vídeo

Por padrão, [EmbeddingGemma2VideoProcessor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) amostra os quadros a 1 FPS (`fps=1`), limita cada clipe a 32 quadros (`max_frames=32`, `overflow_strategy="uniform"`) e omite os timestamps dos quadros do prompt (`add_timestamps=False`). Cada parâmetro pode ser sobrescrito por chamada:

- `fps` (`int | float | None`): taxa de amostragem alvo em quadros por segundo. Exige `VideoMetadata` com `fps` e `duration` válidos (preenchidos automaticamente ao decodificar de um arquivo/URL de vídeo). Para matrizes de quadros pré-decodificados sem metadados, a amostragem por FPS é ignorada com um aviso e `max_frames` é aplicado diretamente.
- `max_frames` (`int | None`): número máximo de quadros retidos por vídeo.
- `overflow_strategy` (`"uniform" | "truncate" | None`): como os quadros excedentes acima de `max_frames` são reduzidos (`"uniform"` reamostra uniformemente ao longo do clipe; `"truncate"` mantém os primeiros `max_frames` quadros).
- `add_timestamps` (`bool`): se deve prefixar o bloco de soft-tokens de cada quadro com seu timestamp `mm:ss`. Diferentemente de `fps`, este não possui fallback: `add_timestamps=True` em um vídeo cujo metadados não possuem `fps` gera uma exceção, pois uma taxa estimada escreveria rótulos `mm:ss` incorretos no 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",
)
```

### Chamadas diretas de `processor(...)` sem template de chat

Embora `processor.apply_chat_template` seja o ponto de entrada principal para conversas multimodais, `processor(...)` também pode ser chamado diretamente. Quando `text` é omitido (`text=None`), os placeholders `<|image|>`, `<|video|>` e `<|audio|>` são sintetizados automaticamente para cada amostra no 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)
```

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

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `262144`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `512`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `24`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `4`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

num_key_value_heads (`int`, *opcional*, padrão `2`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`.

head_dim (`int`, *opcional*, padrão `256`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

hidden_activation (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *opcional*, padrão `262144`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms.

pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `1`) : ID do token usado para o fim do fluxo no vocabulário.

bos_token_id (`int`, *opcional*, padrão `2`) : ID do token usado para o início do fluxo no vocabulário.

rope_parameters (`dict`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

attention_dropout (`Union[int, float]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

sliding_window (`int`, *opcional*, padrão 512) : Raio inclusivo da janela deslizante bidirecional: uma camada `sliding_attention` atende a todas as posições com `abs(q_idx - kv_idx) <= sliding_window`. Trata-se de um raio e não da largura unilateral configurada pelos modelos Gemma causais, pois a máscara aqui é simétrica, de modo que o valor padrão é a metade da janela de largura 1024 especificada pela implementação de referência.

layer_types (`list[str]`, *opcional*) : Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de config.

hidden_size_per_layer_input (`int`, *opcional*, padrão 512) : Dimensionalidade do sinal residual por camada (PLE). O EmbeddingGemma 2 usa PLE *apenas com projeção*: o sinal é derivado apenas de `inputs_embeds`, sem uma tabela de consulta de tokens auxiliares.

embedding_dim (`int`, *opcional*, padrão 768) : Dimensionalidade do embedding de frase produzido por `embedding_projection`.

Esta é a classe de configuração para armazenar a configuração de um EmbeddingGemma2Model. Ela é usada para instanciar um modelo Embedding Gemma2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

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

**Parâmetros:**

text_config (`EmbeddingGemma2TextConfig`, *opcional*) : Configuração do backbone de texto.

vision_config (`PreTrainedConfig` ou `dict`, *opcional*) : Configuração da torre de visão. Reutilizada literalmente do Gemma 4; a própria torre é resolvida em tempo de execução por meio de `AutoModel`.

audio_config (`PreTrainedConfig` ou `dict`, *opcional*) : Configuração da torre de áudio. Reutilizada literalmente do Gemma 4; a própria torre é resolvida em tempo de execução por meio de `AutoModel`.

boi_token_id (`int`, *opcional*, padrão 255999) : O índice do token de início de imagem para envolver o prompt da imagem.

eoi_token_id (`int`, *opcional*, padrão 258882) : O índice do token de fim de imagem para envolver o prompt da imagem.

image_token_id (`int`, *opcional*, padrão `258880`) : O índice do token de imagem usado como marcador para as imagens de entrada.

video_token_id (`int`, *opcional*, padrão `258884`) : O índice do token de vídeo usado como marcador de posição para os vídeos de entrada.

boa_token_id (`int`, *opcional*, padrão 256000) : O índice do token de início de áudio para envolver o prompt de áudio.

eoa_token_index (`int`, *opcional*, padrão 258883) : O índice do token de fim de áudio para envolver o prompt de áudio.

audio_token_id (`int`, *opcional*, padrão `258881`) : O índice do token de áudio usado como marcador para o áudio de entrada.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um EmbeddingGemma2Model. Ela é usada para instanciar um modelo Embedding Gemma2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L176)

**Parâmetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `None`) : Descreve as dimensões de entrada máximas para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.0, 0.0, 0.0]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[1.0, 1.0, 1.0]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento

fps (`Annotated[int | float | None, None]`, *kwargs*, padrão `1`) : Quadros-alvo a amostrar por segundo quando `do_sample_frames=True`.

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

return_metadata (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve ou não retornar metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Se definido, retornará tensors de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

patch_size (`int`, *kwargs*, *opcional*) : Tamanho de cada patch de imagem em pixels.

max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visão) por quadro de vídeo. Deve ser um dos valores {70, 140, 280, 560, 1120}.

pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamanho do kernel de pooling espacial aplicado após a patchification.

add_timestamps (`bool`, *kwargs*, *opcional*) : Se deve prefixar cada quadro na expansão do placeholder de vídeo com seu timestamp `mm:ss`. Requer `VideoMetadata` com um `fps` válido, pois os timestamps não podem ser inferidos a partir de quadros já decodificados.

max_frames (`int`, *kwargs*, *opcional*) : O número máximo de quadros a serem amostrados. Se definido, os índices amostrados serão reamostrados uniformemente para se adequar ao limite.

overflow_strategy (`str`, *kwargs*, *opcional*) : A estratégia usada para reduzir o número total de frames amostrados para caber no orçamento. Pode ser definida apenas como "uniform" ou "truncate". Aplicada após a amostragem baseada em FPS e, por si só, quando a amostragem baseada em FPS está desativada ou não se aplica.

load_audio_from_video (`bool`, *kwargs*, *opcional*) : Se deve carregar ou não a trilha de áudio de um vídeo de entrada.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Constrói um processador de vídeo 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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/video_processing_embedding_gemma2.py#L240)

**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]]]`) : Vídeo a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*) : Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento

fps (`Annotated[int | float | None, None]`, *kwargs*) : Quadros-alvo a amostrar por segundo quando `do_sample_frames=True`.

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

return_metadata (`bool`, *kwargs*, *opcional*) : Se deve ou não retornar os metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

patch_size (`int`, *kwargs*, *opcional*) : Tamanho de cada patch de imagem em pixels.

max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visão) por quadro de vídeo. Deve ser um dos valores {70, 140, 280, 560, 1120}.

pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamanho do kernel de pooling espacial aplicado após a patchification.

add_timestamps (`bool`, *kwargs*, *opcional*) : Se deve prefixar cada quadro na expansão do placeholder de vídeo com seu timestamp `mm:ss`. Requer `VideoMetadata` com um `fps` válido, pois os timestamps não podem ser inferidos a partir de quadros já decodificados.

max_frames (`int`, *kwargs*, *opcional*) : O número máximo de quadros a serem amostrados. Se definido, os índices amostrados serão reamostrados uniformemente para se adequar ao limite.

overflow_strategy (`str`, *kwargs*, *opcional*) : A estratégia usada para reduzir o número total de frames amostrados para caber no orçamento. Pode ser definida apenas como "uniform" ou "truncate". Aplicada após a amostragem baseada em FPS e, por si só, quando a amostragem baseada em FPS está desativada ou não se aplica.

load_audio_from_video (`bool`, *kwargs*, *opcional*) : Se deve carregar ou não a trilha de áudio de um vídeo de entrada.

**Retorna:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/embedding_gemma2/processing_embedding_gemma2.py#L106)

**Parâmetros:**

feature_extractor (*Gemma4AudioFeatureExtractor*) : O extrator de recursos é uma entrada obrigatória.

image_processor (*Gemma4ImageProcessor*) : O processador de imagens é uma entrada obrigatória.

tokenizer (*tokenizer_class*) : O tokenizer é uma entrada obrigatória.

video_processor (*EmbeddingGemma2VideoProcessor*) : O processador de vídeo é uma entrada obrigatória.

chat_template (*str*) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.

image_seq_length (*int*, *opcional*, padrão 280) : O número de tokens suaves por imagem usados para a expansão do placeholder.

audio_seq_length (*int*, *optional*, padrão 750) : O número máximo de soft tokens de áudio por segmento de áudio. Atua como um limite superior quando as contagens dinâmicas de tokens de áudio são calculadas.

audio_ms_per_token (*int*, *opcional*, padrão 40) : Milissegundos de áudio por token suave de saída. Usado para calcular dinamicamente o número de tokens de espaço reservado de áudio como `ceil(duration_ms / audio_ms_per_token)`. O padrão de 40 vem da redução de tempo 4× da convolução SSCP em quadros de 10 ms.

Constrói um EmbeddingGemma2Processor que encapsula um extrator de recursos, um processador de imagem, um tokenizador e um processador de vídeo em um único processador.

[*EmbeddingGemma2Processor*] oferece todas as funcionalidades de [*Gemma4AudioFeatureExtractor*], [*Gemma4ImageProcessor*], [*tokenizer_class*] e [*EmbeddingGemma2VideoProcessor*]. Consulte [*~Gemma4AudioFeatureExtractor*], [*~Gemma4ImageProcessor*], [*~tokenizer_class*] e [*~EmbeddingGemma2VideoProcessor*] para mais informações.

#### __call__[[transformers.EmbeddingGemma2Processor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, audio_from_video_indices: list[int] | None = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2496)

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em 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*) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.

audio_from_video_indices (`list[int]`, *opcional*) : Uma lista que descreve a origem de cada slot de áudio onde - `None` -> áudio independente associado a nenhum track de vídeo - `i`    -> áudio extraído de videos[i] Se `audio` tiver uma entrada por slot, o áudio de `videos[i]` é obtido a partir dele em vez de ser decodificado.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

## EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]]

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

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

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

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.

## EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]]

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

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

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

**Parâmetros:**

config ([EmbeddingGemma2TextConfig](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O backbone de texto do EmbeddingGemma 2. Ele possui o `embedding_projection`, que mapeia os estados ocultos finais para `config.embedding_dim`, de modo que o modelo composto não precisa de uma sobrescrita de `forward`.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([EmbeddingGemma2Config](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) e das entradas.

O método forward do [EmbeddingGemma2TextModel](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]]

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

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

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

**Parâmetros:**

config ([EmbeddingGemma2Config](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo EmbeddingGemma 2: um backbone de visão, um backbone de áudio e um backbone de texto cujos estados ocultos finais são projetados para `config.text_config.embedding_dim`. Destina-se a ser envolvido pelo mean pooling e pela normalização do SentenceTransformers.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Gemma4ImageProcessor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4ImageProcessor). Veja [Gemma4ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([EmbeddingGemma2Processor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) usa [Gemma4ImageProcessor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4ImageProcessor) para processar imagens).

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [EmbeddingGemma2VideoProcessor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor). Veja [EmbeddingGemma2VideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([EmbeddingGemma2Processor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) usa [EmbeddingGemma2VideoProcessor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) para processar vídeos).

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [Gemma4AudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor). Veja [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) para detalhes ([EmbeddingGemma2Processor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) usa [Gemma4AudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) para processar áudios).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : A máscara de atenção para o áudio de entrada.

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de imagem, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional.

video_position_ids (`torch.LongTensor` de forma `(total_num_frames, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de vídeo, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional.

num_frames_per_video (`torch.LongTensor` de forma `(num_videos,)`, *opcional*) : Número de quadros pertencentes a cada vídeo. Obrigatório sempre que `pixel_values_videos` for passado, pois os quadros de todos os vídeos são concatenados ao longo de um único eixo.

**Retorna:** `EmbeddingGemma2ModelOutput` ou `tuple(torch.Tensor)`

Um `EmbeddingGemma2ModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EmbeddingGemma2Config](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) e das entradas.

O método forward do [EmbeddingGemma2Model](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states do modelo produzido pelo codificador de áudio e após projetar o ú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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/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)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Gemma4ImageProcessor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4ImageProcessor). Veja [Gemma4ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([EmbeddingGemma2Processor](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) usa [Gemma4ImageProcessor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4ImageProcessor) para processar imagens).

image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : As posições dos patches como coordenadas (x, y) na imagem. Os patches de preenchimento são indicados por (-1, -1).

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EmbeddingGemma2Config](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) e das entradas.

Projeta o último estado oculto do modelo de visão para o espaço do modelo de linguagem.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

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

[Origem](https://github.com/huggingface/transformers/blob/main/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)`) : Os quadros de todos os vídeos no lote, concatenados ao longo do eixo de quadros em vez de empilhados em um eixo de vídeo separado, para que vídeos de diferentes comprimentos possam ser agrupados juntos.

video_position_ids (`torch.LongTensor` de forma `(total_num_frames, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de vídeo, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional.

num_frames_per_video (`torch.LongTensor` de forma `(num_videos,)`) : Número de quadros pertencentes a cada vídeo, usado para dividir a sequência plana de quadros novamente por vídeo.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EmbeddingGemma2Config](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) e das entradas.

Projeta o último estado oculto do codificador de visão para o espaço do modelo de linguagem.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

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

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

**Parâmetros:**

input_features (`torch.Tensor` de forma `(num_images, seq_length, num_features)`) : Os tensores correspondentes ao áudio de entrada.

input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : A máscara de atenção para o áudio de entrada.

**Retorna:** `EmbeddingGemma2AudioModelOutput` ou `tuple(torch.Tensor)`

Um `EmbeddingGemma2AudioModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EmbeddingGemma2Config](/docs/transformers/main/pt/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) e das entradas.

Projeta o último estado oculto do codificador de áudio para o espaço do modelo de linguagem.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **attention_mask** (`torch.BoolTensor`, *opcional*) -- Um torch.BoolTensor de forma `(batch_size, num_frames)`. True para posições válidas, False para padding.