# EmbeddingGemma2

## Tổng quan

EmbeddingGemma 2 là một mô hình nhúng đa phương thức từ Google, được xây dựng dựa trên kiến trúc [Gemma 4](./gemma4). Mô hình này mã hóa **văn bản, hình ảnh, âm thanh và video**—dù riêng lẻ hay kết hợp trong cùng một đầu vào—thành một không gian vector đặc 768 chiều chung, phục vụ cho việc truy xuất đa phương thức, tương đồng ngữ nghĩa, phân cụm và phân loại.

Các tính năng chính:

- **Không gian vector đa phương thức thống nhất.** Các tháp thị giác ([Gemma4VisionModel](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4VisionModel)) và âm thanh ([Gemma4AudioModel](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4AudioModel)) được chiếu vào bộ mã hóa văn bản hai chiều ([EmbeddingGemma2TextModel](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel)) kết hợp xen kẽ chú ý toàn phần và chú ý cửa sổ trượt với Per-Layer Embeddings (PLE). Bất kỳ phương thức đơn lẻ nào (`text`, `image`, `audio`, `video`) hoặc sự kết hợp của các phương thức (`image + text`, `text + audio`, `image + audio`, nhiều hình ảnh, văn bản và phương tiện xen kẽ) đều ánh xạ đến một embedding duy nhất có thể so sánh được.
- **Học biểu diễn Matryoshka (MRL).** [EmbeddingGemma2Model](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) xuất ra các biểu diễn token được chiếu xuống `embedding_dim` (`768`) thông qua một đầu tuyến tính. Các embedding có thể bị cắt ngắn xuống một tiền tố nhỏ hơn (`512`, `256` hoặc `128`) và được chuẩn hóa lại với mức suy giảm chất lượng tối thiểu.
- **Ngân sách hình ảnh & video có thể cấu hình.** [EmbeddingGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) cho phép bạn điều chỉnh ngân sách soft-token cho mỗi hình ảnh hoặc khung hình (`max_soft_tokens` trong `{70, 140, 280, 560, 1120}`) và tần suất lấy mẫu video (`fps=1`, `max_frames=32`, `overflow_strategy="uniform"`, `add_timestamps=False` theo mặc định).
- **Tải tháp chế độ chọn lọc.** Các tháp thị giác hoặc âm thanh không được sử dụng có thể bị vô hiệu hóa khi tải (`vision_config=None`, `audio_config=None`) để giảm dung lượng bộ nhớ cho các triển khai chỉ văn bản hoặc đơn chế độ.

Bạn có thể tìm thấy tất cả các checkpoint gốc của EmbeddingGemma trong bộ sưu tập [EmbeddingGemma](https://huggingface.co/collections/google/embeddinggemma). Các ví dụ bên dưới sử dụng định danh `google/embeddinggemma-2`.

## Ví dụ sử dụng

Một câu hoặc embedding đa phương thức được tạo ra qua hai bước: pool trung bình có nhận diện mask trên các token không bị đệm của `last_hidden_state`, sau đó chuẩn hóa L2 trong `float32`. [Sentence Transformers](https://sbert.net) (`>=6.1.0`) thực hiện tiền xử lý, định dạng prompt, pool trung bình và chuẩn hóa một cách tự động và là điểm vào được khuyến nghị. Khi dùng [AutoModel](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoModel), hãy sử dụng `processor.apply_chat_template` (hoặc `AutoTokenizer` cho văn bản thuần) và pool trực tiếp `last_hidden_state`.

### Truy xuất văn bản (`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)
```

### Lời nhắc cho tác vụ

Mô hình hỗ trợ các prompt tác vụ tùy chọn được thêm vào đầu đầu vào (và được đưa vào mean pooling), mặc dù prompt không bắt buộc và mô hình vẫn hoạt động tốt mà không có chúng. Vì cấu hình tối ưu phụ thuộc vào miền downstream và sự pha trộn của các modality, chúng tôi khuyến nghị đánh giá cả hai trường hợp có và không có prompt tác vụ trên tác vụ cụ thể của bạn. Sentence Transformers cung cấp danh mục bên dưới trong `config_sentence_transformers.json`, vì vậy hãy truyền `prompt_name` (hoặc sử dụng `encode_query` / `encode_document`, tương ứng với `query` và `document`); với [AutoModel](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoModel), hãy truyền prompt dưới dạng thông điệp `system` trong `apply_chat_template` (hoặc thêm nó vào đầu văn bản thuần túy).

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

### Matryoshka embeddings

Đầu embedding được huấn luyện bằng Matryoshka Representation Learning, do đó một embedding 768 chiều có thể được cắt thành một tiền tố ngắn hơn (`512`, `256` hoặc `128`) và chuẩn hóa lại. Điều này thu nhỏ chỉ mục và tăng tốc độ truy xuất trong khi vẫn giữ được chất lượng xếp hạng phần lớn. Hãy cắt ngắn truy vấn và tài liệu xuống cùng một *kích thước* chiều, và luôn chuẩn hóa sau khi cắt — trong Sentence Transformers, `truncate_dim` cắt phần đầu ra đã được chuẩn hóa, nên tiền tố sẽ không còn có độ dài đơn vị.

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

## Nhúng đa phương thức

Văn bản, hình ảnh, âm thanh và video được ánh xạ vào cùng một không gian vector 768 chiều, cho phép **truy xuất đa phương thức** (ví dụ: tìm kiếm hình ảnh, âm thanh hoặc video bằng truy vấn văn bản) cũng như **truy xuất đa phương thức kết hợp** (kết hợp nhiều phương thức thành một embedding truy vấn hoặc tài liệu duy nhất).

Trong Sentence Transformers, đầu vào đa phương thức được truyền dưới dạng các từ điển có khóa là `"text"`, `"image"`, `"audio"` và `"video"` (trong đó mỗi giá trị có thể là một mục duy nhất hoặc một danh sách các mục). Với [AutoModel](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoModel), hãy truyền các danh sách tin nhắn kiểu chat vào `processor.apply_chat_template(..., tokenize=True, return_dict=True, return_tensors="pt")`.

### 1. Các chế độ đơn & truy xuất liên chế độ

Mỗi phương thức (`text`, `image`, `audio`, `video`) có thể được nhúng riêng biệt và so sánh trực tiếp với bất kỳ phương thức nào khác thông qua độ tương tự cosine:

```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. Nhúng đa phương thức kết hợp (nhiều phương thức trong một đầu vào)

Nhiều phương thức khác nhau — hoặc nhiều mục của cùng một phương thức — có thể được kết hợp thành một **nhúng chung duy nhất**, bao gồm cả các tổ hợp hoàn toàn không phải văn bản như `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. Sắp xếp tự động so với các vị trí giữ chỗ thủ công

Khi không có token placeholder nào (`<|image|>`, `<|video|>`, `<|audio|>`) xuất hiện trong văn bản, các modalities sẽ được phát ra theo đúng thứ tự mà các mục của chúng xuất hiện trong từ điển hoặc `content` của tin nhắn chat (ngay sau bất kỳ prompt tác vụ `system` nào).

Để xen kẽ văn bản và phương tiện tại các vị trí cụ thể trong một câu, hãy viết `<|image|>`, `<|video|>` hoặc `<|audio|>` trực tiếp trong văn bản—khi đó, việc chèn placeholder tự động sẽ bị vô hiệu hóa cho đầu vào đó, và mỗi placeholder sẽ được mở rộng theo thứ tự với các mục phương tiện được cung cấp:

```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. Gom nhóm (batching) dị thể (hỗn hợp đa phương thức)

Một batch duy nhất có thể trộn lẫn văn bản thuần túy, phương tiện đơn phương thức và đầu vào đa phương thức trong một lần truyền tiến, tạo ra cùng một vector nhúng cho mỗi hàng như khi mã hóa từng mục riêng lẻ:

```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. Tắt các tháp phương thức không sử dụng (tối ưu hóa bộ nhớ)

Nếu tác vụ của bạn chỉ nhúng một tập con các phương thức (ví dụ: **chỉ văn bản** hoặc **văn bản + hình ảnh** không có âm thanh), bạn có thể bỏ qua việc khởi tạo và nạp các tháp thị giác hoặc âm thanh không được sử dụng bằng cách đặt `vision_config=None` và/hoặc `audio_config=None` trên cấu hình. Trọng số của tháp không được sử dụng trong checkpoint sẽ bị bỏ qua một cách sạch sẽ mà không có cảnh báo, giảm mô hình từ 744M xuống 439M tham số khi không có tháp âm thanh, hoặc xuống 271M khi không có cả hai tháp.

Truyền các tham số này qua `config_kwargs` (tham số này sẽ được chuyển đến `AutoConfig.from_pretrained`), không phải `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",
)
```

## Bộ xử lý

[EmbeddingGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) đóng gói tokenizer, image processor, audio feature extractor và video processor.

> [!TIP]
> Đối với đầu vào đa phương thức dạng lô, chúng tôi khuyến nghị truyền các từ điển theo từng mẫu thông qua **Sentence Transformers** (`model.encode([{"image": ..., "text": ...}, ...])`). Để có quyền kiểm soát tối đa về thứ tự chính xác và sự xen kẽ của các phương thức, hãy tự động bao gồm các vị trí giữ chỗ `<|image|>`, `<|video|>` và `<|audio|>` trong `text`.

### Kiểm soát ngân sách token hình ảnh (`max_soft_tokens`)

Ngân sách token mềm (`max_soft_tokens`, các giá trị được hỗ trợ `{70, 140, 280, 560, 1120}`) kiểm soát độ phân giải và số lượng token thị giác được tạo ra cho mỗi ảnh hoặc khung hình video (mặc định là `280` cho mỗi ảnh và `140` cho mỗi khung hình video). Các giá trị thấp hơn sẽ làm giảm độ dài chuỗi và độ trễ:

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

### Kiểm soát lấy mẫu khung hình video

Mặc định, [EmbeddingGemma2VideoProcessor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) lấy mẫu các khung hình với tốc độ 1 FPS (`fps=1`), giới hạn mỗi đoạn clip ở 32 khung hình (`max_frames=32`, `overflow_strategy="uniform"`) và bỏ qua mốc thời gian của khung hình trong prompt (`add_timestamps=False`). Mỗi tham số có thể được ghi đè cho từng lần gọi:

- `fps` (`int | float | None`): tần suất lấy mẫu mục tiêu tính bằng số khung hình mỗi giây. Yêu cầu `VideoMetadata` có `fps` và `duration` hợp lệ (được tự động điền khi giải mã từ tệp/URL video). Đối với mảng khung hình đã giải mã trước mà không có metadata, việc lấy mẫu FPS sẽ bị bỏ qua kèm theo cảnh báo và `max_frames` sẽ được áp dụng trực tiếp.
- `max_frames` (`int | None`): số lượng khung hình tối đa được giữ lại cho mỗi video.
- `overflow_strategy` (`"uniform" | "truncate" | None`): cách giảm số khung hình vượt quá `max_frames` (`"uniform"` lấy mẫu lại đều trên toàn bộ clip; `"truncate"` giữ lại `max_frames` khung hình đầu tiên).
- `add_timestamps` (`bool`): có nên thêm tiền tố khối soft-token của mỗi khung hình với mốc thời gian `mm:ss` của nó hay không. Khác với `fps`, tham số này không có phương án dự phòng: nếu đặt `add_timestamps=True` cho một video mà metadata không có `fps`, hệ thống sẽ gây lỗi, vì một tốc độ được suy đoán sẽ ghi các nhãn `mm:ss` sai vào 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",
)
```

### Gọi trực tiếp `processor(...)` không có chat template

Mặc dù `processor.apply_chat_template` là điểm vào chính cho các cuộc hội thoại đa phương thức, `processor(...)` cũng có thể được gọi trực tiếp. Khi `text` bị bỏ qua (`text=None`), các placeholder `<|image|>`, `<|video|>` và `<|audio|>` sẽ được tổng hợp tự động cho từng mẫu trong batch:

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

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

**Tham số:**

vocab_size (`int`, *tùy chọn*, mặc định là `262144`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

hidden_size (`int`, *tuỳ chọn*, mặc định là `512`) : Kích thước của các biểu diễn ẩn.

intermediate_size (`int`, *tuỳ chọn*, mặc định là `2048`) : Kích thước của các biểu diễn MLP.

num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `24`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là `4`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

num_key_value_heads (`int`, *optional*, mặc định là `2`) : Đây là số lượng key_value heads cần được sử dụng để triển khai Grouped Query Attention. Nếu `num_key_value_heads=num_attention_heads`, mô hình sẽ sử dụng Multi Head Attention (MHA), nếu `num_key_value_heads=1` mô hình sẽ sử dụng Multi Query Attention (MQA), ngược lại GQA sẽ được sử dụng. Khi chuyển đổi một checkpoint multi-head sang checkpoint GQA, mỗi nhóm key và value head nên được xây dựng bằng cách meanpooling tất cả các head gốc trong nhóm đó. Để biết thêm chi tiết, hãy xem [bài báo này](https://huggingface.co/papers/2305.13245). Nếu không được chỉ định, giá trị mặc định sẽ là `num_attention_heads`.

head_dim (`int`, *tùy chọn*, mặc định là `256`) : Kích thước chiều đầu chú ý. Nếu là None, giá trị mặc định sẽ là hidden_size // num_attention_heads

hidden_activation (`str`, *tùy chọn*, mặc định là `gelu_pytorch_tanh`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v.

max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `262144`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

rms_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa rms.

pad_token_id (`int`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

eos_token_id (`Union[int, list[int]]`, *tùy chọn*, mặc định là `1`) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng.

bos_token_id (`int`, *tuỳ chọn*, mặc định là `2`) : Id của token được dùng cho đầu luồng (beginning-of-stream) trong từ vựng.

rope_parameters (`dict`, *tùy chọn*) : Từ điển chứa các tham số cấu hình cho các embedding RoPE. Từ điển phải chứa một giá trị cho `rope_theta` và tùy chọn các tham số được sử dụng để mở rộng trong trường hợp bạn muốn sử dụng RoPE với `max_position_embeddings` dài hơn.

attention_bias (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng bias trong các lớp chiếu query, key, value và output trong quá trình tự chú ý hay không.

attention_dropout (`Union[int, float]`, *tùy chọn*, mặc định là `0.0`) : Tỷ lệ dropout cho các xác suất chú ý.

sliding_window (`int`, *optional*, mặc định là 512) : Bán kính bao gồm của cửa sổ trượt hai chiều: một lớp `sliding_attention` sẽ chú ý đến mọi vị trí có `abs(q_idx - kv_idx) <= sliding_window`. Đây là bán kính chứ không phải chiều rộng một phía như các mô hình Gemma nhân quả cấu hình, vì mặt nạ ở đây là đối xứng, nên giá trị mặc định bằng một nửa của cửa sổ rộng 1024 mà bản triển khai tham chiếu nêu ra.

layer_types (`list[str]`, *tùy chọn*) : Một danh sách ánh xạ rõ ràng từng chỉ số lớp với loại lớp của nó. Nếu không được cung cấp, danh sách này sẽ được tạo tự động dựa trên các giá trị cấu hình.

hidden_size_per_layer_input (`int`, *tuỳ chọn*, mặc định là 512) : Độ chiều của tín hiệu dư (residual) theo từng lớp (PLE). EmbeddingGemma 2 sử dụng PLE *chỉ chiếu (projection-only)*: tín hiệu được suy ra chỉ từ `inputs_embeds`, không có bảng tra cứu token bổ trợ.

embedding_dim (`int`, *tuỳ chọn*, mặc định là 768) : Độ chiều của vector nhúng câu do `embedding_projection` tạo ra.

Đây là lớp cấu hình để lưu trữ cấu hình của một EmbeddingGemma2Model. Nó được sử dụng để khởi tạo một mô hình Embedding Gemma2 theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

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

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

**Tham số:**

text_config (`EmbeddingGemma2TextConfig`, *tùy chọn*) : Cấu hình của bộ khung văn bản.

vision_config (`PreTrainedConfig` hoặc `dict`, *tùy chọn*) : Cấu hình của vision tower. Được tái sử dụng nguyên văn từ Gemma 4; bản thân tower được phân giải tại thời điểm chạy thông qua `AutoModel`.

audio_config (`PreTrainedConfig` hoặc `dict`, *tùy chọn*) : Cấu hình của audio tower. Được tái sử dụng nguyên văn từ Gemma 4; bản thân tower được phân giải tại thời điểm chạy thông qua `AutoModel`.

boi_token_id (`int`, *optional*, mặc định là 255999) : Chỉ số token bắt đầu hình ảnh để bao quanh prompt hình ảnh.

eoi_token_id (`int`, *optional*, mặc định là 258882) : Chỉ số token kết thúc hình ảnh để bao quanh prompt hình ảnh.

image_token_id (`int`, *tuỳ chọn*, mặc định là `258880`) : Chỉ số token hình ảnh được dùng làm ký tự thay thế cho các hình ảnh đầu vào.

video_token_id (`int`, *tuỳ chọn*, mặc định là `258884`) : Chỉ số token video được dùng làm ký tự thay thế cho các video đầu vào.

boa_token_id (`int`, *tuỳ chọn*, mặc định là 256000) : Chỉ số token bắt đầu âm thanh để bao quanh prompt âm thanh.

eoa_token_index (`int`, *optional*, mặc định là 258883) : Chỉ số token kết thúc âm thanh để bao quanh prompt âm thanh.

audio_token_id (`int`, *tuỳ chọn*, mặc định là `258881`) : Chỉ số token âm thanh được dùng làm ký tự thay thế cho âm thanh đầu vào.

initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số.

Đây là lớp cấu hình để lưu trữ cấu hình của một EmbeddingGemma2Model. Nó được sử dụng để khởi tạo một mô hình Embedding Gemma2 theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [google/embeddinggemma-2](https://huggingface.co/google/embeddinggemma-2)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

## EmbeddingGemma2VideoProcessor[[transformers.EmbeddingGemma2VideoProcessor]]

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

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

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

**Tham số:**

do_convert_rgb (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuyển đổi hình ảnh sang RGB hay không.

do_resize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có thay đổi kích thước ảnh hay không.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, mặc định là `None`) : Mô tả các kích thước đầu vào tối đa của mô hình.

default_to_square (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có nên mặc định sử dụng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, mặc định là `3`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các hằng số liệt kê (enum) của `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

do_rescale (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Xác định có nên điều chỉnh lại tỷ lệ ảnh hay không.

rescale_factor (`float`, *kwargs*, *optional*, mặc định là `0.00392156862745098`) : Hệ số để điều chỉnh lại kích thước ảnh nếu `do_rescale` được đặt thành `True`.

do_normalize (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `True`) : Có chuẩn hóa hình ảnh hay không.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[0.0, 0.0, 0.0]`) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, mặc định là `[1.0, 1.0, 1.0]`) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.

do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.

do_sample_frames (`bool`, *kwargs*, *optional*, mặc định là `True`) : Xác định xem có lấy mẫu các khung hình từ video trước khi xử lý hay xử lý toàn bộ video.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadata của video, chứa thông tin về tổng thời lượng, fps và tổng số khung hình. Dữ liệu này sẽ được sử dụng để lấy mẫu các khung hình từ video hoặc tính toán mốc thời gian. Không truyền bất kỳ metadata nào trừ khi bạn đang cố gắng giải mã video thủ công trước khi xử lý

fps (`Annotated[int | float | None, None]`, *kwargs*, mặc định là `1`) : Số khung hình mục tiêu cần lấy mẫu mỗi giây khi `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Số khung hình tối đa cần lấy mẫu khi `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *tuỳ chọn*, mặc định là `False`) : Có trả về metadata của video hay không. Video metadata là một đối tượng chứa thông tin về thời lượng video, fps, backend giải mã, v.v.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là: - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

patch_size (`int`, *kwargs*, *optional*) : Kích thước của mỗi ảnh patch tính bằng pixel.

max_soft_tokens (`int`, *kwargs*, *optional*) : Số lượng tối đa các token mềm (thị giác) trên mỗi khung hình video. Phải là một trong {70, 140, 280, 560, 1120}.

pooling_kernel_size (`int`, *kwargs*, *optional*) : Kích thước kernel pooling không gian được áp dụng sau khi patchification.

add_timestamps (`bool`, *kwargs*, *optional*) : Xác định có tiền tố cho mỗi khung hình trong phần mở rộng placeholder video với mốc thời gian `mm:ss` của nó hay không. Yêu cầu `VideoMetadata` có `fps` hợp lệ, vì không thể suy ra mốc thời gian từ các khung hình đã được giải mã.

max_frames (`int`, *kwargs*, *optional*) : Số khung tối đa cần lấy mẫu. Nếu được đặt, các chỉ số đã lấy mẫu sẽ được lấy mẫu lại một cách đồng đều để phù hợp với ngân sách.

overflow_strategy (`str`, *kwargs*, *optional*) : Chiến lược được sử dụng để cắt giảm tổng số khung hình được lấy mẫu xuống để phù hợp với ngân sách. Chỉ có thể được đặt thành "uniform" hoặc "truncate". Được áp dụng sau khi lấy mẫu dựa trên FPS, và độc lập khi lấy mẫu dựa trên FPS bị tắt hoặc không áp dụng được.

load_audio_from_video (`bool`, *kwargs*, *optional*) : Đã ngừng hỗ trợ, hãy dùng `OmniModalProcessingKwargs.load_audio_from_video` thay thế. Xác định có tải bản âm thanh của video đầu vào hay không.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/vi/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Các tùy chọn xử lý bổ sung cho từng phương thức (text, images, videos, audio). Các tham số cụ thể của model được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

Tạo một trình xử lý 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'>)
```

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

**Tham số:**

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 cần tiền xử lý. Kỳ vọng một video đơn hoặc một batch video có giá trị pixel từ 0 đến 255. Nếu truyền vào video có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *optional*) : Có chuyển đổi hình ảnh sang RGB hay không.

do_resize (`bool`, *kwargs*, *optional*) : Xác định có nên thay đổi kích thước ảnh hay không.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*): Mô tả các kích thước đầu vào tối đa của mô hình.

default_to_square (`bool`, *kwargs*, *tuỳ chọn*) : Có mặc định dùng ảnh vuông khi thay đổi kích thước hay không, nếu size là một số nguyên.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Bộ lọc resampling để sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các enum `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

do_rescale (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có nên điều chỉnh lại tỷ lệ hình ảnh hay không.

rescale_factor (`float`, *kwargs*, *optional*) : Hệ số để thay đổi tỷ lệ ảnh nếu `do_rescale` được đặt thành `True`.

do_normalize (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có chuẩn hóa hình ảnh hay không.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Giá trị trung bình của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Độ lệch chuẩn của ảnh để sử dụng cho việc chuẩn hóa. Chỉ có hiệu lực nếu `do_normalize` được đặt thành `True`.

do_center_crop (`bool`, *kwargs*, *optional*) : Có nên cắt ảnh theo kiểu căn giữa hay không.

do_pad (`bool`, *kwargs*, *optional*) : Xác định có chèn padding cho ảnh hay không. Padding được thực hiện đến kích thước lớn nhất trong batch hoặc đến một kích thước vuông cố định cho mỗi ảnh. Chiến lược padding cụ thể phụ thuộc vào model.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Kích thước của ảnh đầu ra sau khi áp dụng `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *tuỳ chọn*) : Chỉ hỗ trợ `ChannelDimension.FIRST`. Được thêm vào để tương thích với các bộ xử lý chậm.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Định dạng chiều kênh cho ảnh đầu vào. Nếu không được đặt, định dạng chiều kênh sẽ được suy ra từ ảnh đầu vào. Có thể là một trong các giá trị sau: - `"channels_first"` hoặc `ChannelDimension.FIRST`: ảnh ở định dạng (num_channels, height, width). - `"channels_last"` hoặc `ChannelDimension.LAST`: ảnh ở định dạng (height, width, num_channels). - `"none"` hoặc `ChannelDimension.NONE`: ảnh ở định dạng (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Thiết bị để xử lý các video. Nếu không được đặt, thiết bị sẽ được suy ra từ các video đầu vào.

do_sample_frames (`bool`, *kwargs*, *tuỳ chọn*) : Xác định xem có lấy mẫu các khung hình từ video trước khi xử lý hay xử lý toàn bộ video.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadata của video, chứa thông tin về tổng thời lượng, fps và tổng số khung hình. Dữ liệu này sẽ được sử dụng để lấy mẫu các khung hình từ video hoặc tính toán mốc thời gian. Không truyền bất kỳ metadata nào trừ khi bạn đang cố gắng giải mã video thủ công trước khi xử lý

fps (`Annotated[int | float | None, None]`, *kwargs*) : Số khung hình mục tiêu cần lấy mẫu mỗi giây khi `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Số khung hình tối đa cần lấy mẫu khi `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *tuỳ chọn*) : Xác định có trả về metadata của video hay không. Video metadata là một đối tượng chứa thông tin về thời lượng video, fps, backend giải mã, v.v.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Trả về các tensor đã xếp chồng nếu được đặt thành `'pt'`, ngược lại trả về một danh sách các tensor.

patch_size (`int`, *kwargs*, *optional*) : Kích thước của mỗi ảnh patch tính bằng pixel.

max_soft_tokens (`int`, *kwargs*, *optional*) : Số lượng tối đa các token mềm (thị giác) trên mỗi khung hình video. Phải là một trong {70, 140, 280, 560, 1120}.

pooling_kernel_size (`int`, *kwargs*, *optional*) : Kích thước kernel pooling không gian được áp dụng sau khi patchification.

add_timestamps (`bool`, *kwargs*, *optional*) : Xác định có tiền tố cho mỗi khung hình trong phần mở rộng placeholder video với mốc thời gian `mm:ss` của nó hay không. Yêu cầu `VideoMetadata` có `fps` hợp lệ, vì không thể suy ra mốc thời gian từ các khung hình đã được giải mã.

max_frames (`int`, *kwargs*, *optional*) : Số khung tối đa cần lấy mẫu. Nếu được đặt, các chỉ số đã lấy mẫu sẽ được lấy mẫu lại một cách đồng đều để phù hợp với ngân sách.

overflow_strategy (`str`, *kwargs*, *optional*) : Chiến lược được sử dụng để cắt giảm tổng số khung hình được lấy mẫu xuống để phù hợp với ngân sách. Chỉ có thể được đặt thành "uniform" hoặc "truncate". Được áp dụng sau khi lấy mẫu dựa trên FPS, và độc lập khi lấy mẫu dựa trên FPS bị tắt hoặc không áp dụng được.

load_audio_from_video (`bool`, *kwargs*, *optional*) : Đã ngừng hỗ trợ, hãy dùng `OmniModalProcessingKwargs.load_audio_from_video` thay thế. Xác định có tải bản âm thanh của video đầu vào hay không.

**Trả về:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Từ điển chứa các danh sách/mảng/tensor được trả về bởi phương thức __call__ ('pixel_values', v.v.).
- **tensor_type** (`Union[None, str, TensorType]`, *tùy chọn*) -- Bạn có thể cung cấp tensor_type tại đây để chuyển đổi các danh sách số nguyên trong Tensor PyTorch/Numpy khi khởi tạ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)
```

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

**Tham số:**

feature_extractor (*Gemma4AudioFeatureExtractor*) : Bộ trích xuất đặc trưng là một đầu vào bắt buộc.

image_processor (*Gemma4ImageProcessor*) : Bộ xử lý ảnh là một đầu vào bắt buộc.

tokenizer (*tokenizer_class*) : Tokenizer là đầu vào bắt buộc.

video_processor (*EmbeddingGemma2VideoProcessor*) : Bộ xử lý video là một đầu vào bắt buộc.

chat_template (*str*) : Một mẫu Jinja để chuyển đổi các danh sách tin nhắn trong một cuộc trò chuyện thành chuỗi có thể token hóa.

image_seq_length (*int*, *optional*, mặc định là 280) : Số lượng token mềm trên mỗi hình ảnh được sử dụng cho việc mở rộng placeholder.

audio_seq_length (*int*, *optional*, mặc định là 750) : Số lượng tối đa các token mềm âm thanh cho mỗi phân đoạn âm thanh. Đóng vai trò là giới hạn trên khi tính toán số lượng token âm thanh động.

audio_ms_per_token (*int*, *optional*, mặc định là 40) : Số mili giây âm thanh cho mỗi token mềm đầu ra. Được dùng để tính động số lượng token placeholder âm thanh dưới dạng `ceil(duration_ms / audio_ms_per_token)`. Giá trị mặc định 40 bắt nguồn từ việc giảm 4 lần về thời gian của phép tích chập SSCP trên các khung 10ms.

Tạo một EmbeddingGemma2Processor bao gồm một bộ trích xuất đặc trưng, một bộ xử lý ảnh, một bộ phân từ và một bộ xử lý video trong một bộ xử lý duy nhất.

[*EmbeddingGemma2Processor*] cung cấp đầy đủ các chức năng của [*Gemma4AudioFeatureExtractor*], [*Gemma4ImageProcessor*], [*tokenizer_class*] và [*EmbeddingGemma2VideoProcessor*]. Xem [*~Gemma4AudioFeatureExtractor*], [*~Gemma4ImageProcessor*], [*~tokenizer_class*] và [*~EmbeddingGemma2VideoProcessor*] để biết thêm thông tin.

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

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

**Tham số:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *tùy chọn*) : Ảnh cần tiền xử lý. Kỳ vọng một ảnh đơn hoặc một lô ảnh với giá trị pixel dao động từ 0 đến 255. Nếu truyền vào các ảnh có giá trị pixel nằm trong khoảng từ 0 đến 1, hãy đặt `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *tùy chọn*) : Chuỗi hoặc lô các chuỗi cần được mã hóa. Mỗi chuỗi có thể là một chuỗi ký tự hoặc một danh sách các chuỗi ký tự (chuỗi đã được tách token trước). Nếu bạn truyền vào đầu vào đã tách token trước, hãy đặt `is_split_into_words=True` để tránh nhầm lẫn với các đầu vào dạng lô.

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]]]`, *optional*) : Video cần tiền xử lý. Kỳ vọng một video đơn hoặc một batch video với giá trị pixel từ 0 đến 255. Nếu truyền vào video có giá trị pixel từ 0 đến 1, hãy đặt `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *optional*) : Âm thanh hoặc lô âm thanh cần được chuẩn bị. Mỗi âm thanh có thể là mảng NumPy hoặc tensor PyTorch. Trong trường hợp là mảng NumPy/tensor PyTorch, mỗi âm thanh nên có hình dạng (C, T), trong đó C là số kênh và T là độ dài mẫu của âm thanh.

audio_from_video_indices (`list[int]`, *optional*) : Một danh sách mô tả nguồn của mỗi khe âm thanh, trong đó - `None` -> âm thanh độc lập không liên kết với bất kỳ track video nào - `i`    -> âm thanh được trích xuất từ videos[i] Nếu `audio` có một mục cho mỗi khe, âm thanh của `videos[i]` sẽ được lấy từ đó thay vì được giải mã.

return_tensors (`str` hoặc [TensorType](/docs/transformers/v5.23.0/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

- ****kwargs** (`OmniModalProcessingKwargs`, *tuỳ chọn*) : Các tùy chọn xử lý bổ sung cho từng phương thức (văn bản, hình ảnh, video, âm thanh). Các tham số cụ thể của mô hình được liệt kê ở trên; xem lớp TypedDict để biết danh sách đầy đủ các đối số được hỗ trợ.

## EmbeddingGemma2PreTrainedModel[[transformers.EmbeddingGemma2PreTrainedModel]]

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

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

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

**Tham số:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/vi/main_classes/configuration#transformers.PreTrainedConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

Một giá trị giả lập cho một đường dẫn có dấu chấm (ví dụ: `torch.float32`): các chuỗi truy cập thuộc tính, các lời gọi hoạt động như các decorator pass-through, `repr` là đường dẫn có dấu chấm, và việc sử dụng nó như một lớp cơ sở sẽ thay thế bằng một lớp cơ sở `type` thông thường (PEP 560 `__mro_entries__`), do đó các lớp con thực sự vẫn giữ nguyên metaclass bình thường và `inspect.signature` sẽ đọc `__init__` thực của chúng thay vì của một mock.

## EmbeddingGemma2TextModel[[transformers.EmbeddingGemma2TextModel]]

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

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

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

**Tham số:**

config ([EmbeddingGemma2TextConfig](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Bộ khung văn bản EmbeddingGemma 2. Nó sở hữu `embedding_projection` để ánh xạ các trạng thái ẩn cuối cùng xuống `config.embedding_dim`, nhờ đó mô hình tổng hợp không cần ghi đè `forward`.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

**Trả về:** [BaseModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) và đầu vào.

Phương thức forward của [EmbeddingGemma2TextModel](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2TextModel) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

## EmbeddingGemma2Model[[transformers.EmbeddingGemma2Model]]

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

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

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

**Tham số:**

config ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình EmbeddingGemma 2: một bộ xương sống thị giác, một bộ xương thính giác và một bộ xương văn bản, trong đó các trạng thái ẩn cuối cùng của chúng được chiếu đến `config.text_config.embedding_dim`. Được thiết kế để được bọc bởi mean pooling và normalization của SentenceTransformers.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

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

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

**Tham số:**

input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids)

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`, *tùy chọn*) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [Gemma4ImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4ImageProcessor). Xem [Gemma4ImageProcessor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) sử dụng [Gemma4ImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4ImageProcessor) để xử lý ảnh).

pixel_values_videos (`torch.Tensor` có shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *optional*) : Các tensor tương ứng với video đầu vào. Giá trị pixel cho video có thể được lấy bằng cách sử dụng [EmbeddingGemma2VideoProcessor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor). Xem [EmbeddingGemma2VideoProcessor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) để biết chi tiết ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) sử dụng [EmbeddingGemma2VideoProcessor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2VideoProcessor) để xử lý video).

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng cách sử dụng [Gemma4AudioFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor). Xem [Gemma4AudioFeatureExtractor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor.__call__) để biết chi tiết ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) sử dụng [Gemma4AudioFeatureExtractor](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4AudioFeatureExtractor) để xử lý âm thanh).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

input_features_mask (`torch.Tensor` có hình dạng `(num_images, seq_length)`) : Mặt nạ chú ý (attention mask) cho âm thanh đầu vào.

position_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các embedding vị trí. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

image_position_ids (`torch.LongTensor` có shape `(batch_size, max_patches, 2)`, *tùy chọn*) : tọa độ vị trí patch 2D từ image processor, trong đó `(-1, -1)` chỉ padding. Được truyền qua vision encoder để tính toán positional embedding.

video_position_ids (`torch.LongTensor` có shape `(total_num_frames, max_patches, 2)`, *optional*) : tọa độ vị trí patch 2D từ video processor, trong đó `(-1, -1)` biểu thị padding. Được truyền qua vision encoder để tính toán positional embedding.

num_frames_per_video (`torch.LongTensor` có shape `(num_videos,)`, *tùy chọn*) : Số lượng khung hình thuộc về mỗi video. Bắt buộc khi `pixel_values_videos` được truyền vào, vì các khung hình của tất cả các video được nối (concatenate) dọc theo một trục duy nhất.

**Trả về:** `EmbeddingGemma2ModelOutput` hoặc `tuple(torch.Tensor)`

Một `EmbeddingGemma2ModelOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) và đầu vào.

Phương thức forward của [EmbeddingGemma2Model](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Model) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **image_hidden_states** (`torch.Tensor`, *tùy chọn*) -- Một `torch.Tensor` có kích thước `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states của mô hình do bộ mã hóa thị giác tạo ra và sau khi chiếu trạng thái ẩn cuối cùng.
- **audio_hidden_states** (`torch.Tensor`, *tuỳ chọn*) -- Một `torch.Tensor` có kích thước `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states của mô hình do bộ mã hóa âm thanh tạo ra và sau khi chiếu trạng thái ẩn cuối cùng.

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

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

**Tham số:**

pixel_values (`torch.Tensor` có shape `(batch_size, num_channels, image_size, image_size)`) : Các tensor tương ứng với các ảnh đầu vào. Giá trị pixel có thể được lấy bằng cách sử dụng [Gemma4ImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4ImageProcessor). Xem [Gemma4ImageProcessor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết ([EmbeddingGemma2Processor](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Processor) sử dụng [Gemma4ImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/gemma4#transformers.Gemma4ImageProcessor) để xử lý ảnh).

image_position_ids (`torch.LongTensor` có hình dạng `(batch_size, max_patches, 2)`, *tùy chọn*) : Vị trí của các patch dưới dạng tọa độ (x, y) trong ảnh. Các patch đệm được chỉ định bằng (-1, -1).

**Trả về:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) và đầu vào.

Chiếu trạng thái ẩn cuối cùng từ mô hình thị giác vào không gian của mô hình ngôn ngữ.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **pooler_output** (`torch.Tensor` có hình dạng `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý thêm thông qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

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

```python
get_video_features(pixel_values_videos: Tensor, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

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

**Tham số:**

pixel_values_videos (`torch.Tensor` có hình dạng `(total_num_frames, max_patches, patch_pixels)`) : Các khung hình của mọi video trong batch, được nối (concatenate) dọc theo trục khung hình thay vì xếp chồng lên một trục video riêng, để các video có độ dài khác nhau có thể được batch cùng nhau.

video_position_ids (`torch.LongTensor` có shape `(total_num_frames, max_patches, 2)`, *optional*) : tọa độ vị trí patch 2D từ video processor, trong đó `(-1, -1)` biểu thị padding. Được truyền qua vision encoder để tính toán positional embedding.

num_frames_per_video (`torch.LongTensor` có hình dạng `(num_videos,)`) : Số lượng khung hình thuộc về mỗi video, được sử dụng để tách chuỗi khung hình phẳng trở lại theo từng video.

**Trả về:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc `tuple(torch.Tensor)`

Một [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) và đầu vào.

Chiếu trạng thái ẩn cuối cùng từ bộ mã hóa thị giác vào không gian của mô hình ngôn ngữ.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **pooler_output** (`torch.Tensor` có hình dạng `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý thêm thông qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.

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

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

**Tham số:**

input_features (`torch.Tensor` có hình dạng `(num_images, seq_length, num_features)`) : Các tensor tương ứng với âm thanh đầu vào.

input_features_mask (`torch.Tensor` có hình dạng `(num_images, seq_length)`) : Mặt nạ chú ý (attention mask) cho âm thanh đầu vào.

**Trả về:** `EmbeddingGemma2AudioModelOutput` hoặc `tuple(torch.Tensor)`

Một `EmbeddingGemma2AudioModelOutput` hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([EmbeddingGemma2Config](/docs/transformers/v5.23.0/vi/model_doc/embedding_gemma2#transformers.EmbeddingGemma2Config)) và đầu vào.

Chiếu trạng thái ẩn cuối cùng từ bộ mã hóa âm thanh vào không gian của mô hình ngôn ngữ.

- **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình.
- **pooler_output** (`torch.Tensor` có hình dạng `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý thêm thông qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện.
- **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn.
- **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention.
- **attention_mask** (`torch.BoolTensor`, *tùy chọn*) -- Một torch.BoolTensor có hình dạng `(batch_size, num_frames)`. True cho các vị trí hợp lệ, False cho phần đệm.

