# VisionTextDualEncoder

## Tổng quan

[VisionTextDualEncoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderModel) có thể được sử dụng để khởi tạo một mô hình mã hóa kép thị giác-văn bản với bất kỳ mô hình tự mã hóa thị giác được huấn luyện trước nào làm bộ mã hóa thị giác (*ví dụ* [ViT](vit), [BEiT](beit), [DeiT](deit)) và bất kỳ mô hình tự mã hóa văn bản được huấn luyện trước nào làm bộ mã hóa văn bản (*ví dụ* [RoBERTa](roberta), [BERT](bert)). Hai lớp chiếu (projection) được thêm vào phía trên cả bộ mã hóa thị giác và bộ mã hóa văn bản để chiếu các vector nhúng đầu ra vào một không gian ẩn chung. Các lớp chiếu được khởi tạo ngẫu nhiên nên mô hình cần được tinh chỉnh (fine-tune) trên một tác vụ hạ nguồn. Mô hình này có thể được sử dụng để căn chỉnh các vector nhúng thị giác-văn bản bằng cách huấn luyện tương phản hình ảnh-văn bản kiểu CLIP, sau đó có thể được dùng cho các tác vụ thị giác zero-shot như phân loại hình ảnh hoặc truy xuất.

Trong [LiT: Zero-Shot Transfer with Locked-image Text Tuning](https://huggingface.co/papers/2111.07991), bài báo cho thấy việc tận dụng các mô hình ảnh và văn bản đã được huấn luyện trước (khóa/đóng băng) cho học tương phản mang lại cải thiện đáng kể trên các tác vụ thị giác zero-shot mới như phân loại ảnh hoặc truy xuất.

## VisionTextDualEncoderConfig[[transformers.VisionTextDualEncoderConfig]]

#### transformers.VisionTextDualEncoderConfig[[transformers.VisionTextDualEncoderConfig]]

```python
transformers.VisionTextDualEncoderConfig(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.configuration_utils.PreTrainedConfig | dict | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict | None = None, projection_dim: int = 512, logit_scale_init_value: int | float = 2.6592)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_text_dual_encoder/configuration_vision_text_dual_encoder.py#L25)

**Tham số:**

text_config (`Union[~configuration_utils.PreTrainedConfig, dict]`, *tùy chọn*) : Đối tượng config hoặc từ điển của text backbone.

vision_config (`Union[~configuration_utils.PreTrainedConfig, dict]`, *tùy chọn*) : Đối tượng config hoặc từ điển của vision backbone.

projection_dim (`int`, *optional*, mặc định là `512`) : Độ chiều của các lớp chiếu văn bản và thị giác.

logit_scale_init_value (`Union[int, float]`, *tùy chọn*, mặc định là `2.6592`) : Giá trị ban đầu của tham số *logit_scale*.

Đây là lớp cấu hình để lưu trữ cấu hình của một Model Vision Text Dual Encoder. Nó được sử dụng để khởi tạo một model Vision Text Dual Encoder theo các đối số được chỉ định, xác định kiến trúc của model. 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ủa [None](https://huggingface.co/None)

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.

Ví dụ:

```python
>>> from transformers import ViTConfig, BertConfig, VisionTextDualEncoderConfig, VisionTextDualEncoderModel

>>> # Initializing a BERT and ViT configuration
>>> config_vision = ViTConfig()
>>> config_text = BertConfig()

>>> config = VisionTextDualEncoderConfig(vision_config=config_vision, text_config=config_text, projection_dim=512)

>>> # Initializing a BERT and ViT model (with random weights)
>>> model = VisionTextDualEncoderModel(config=config)

>>> # Accessing the model configuration
>>> config_vision = model.config.vision_config
>>> config_text = model.config.text_config

>>> # Saving the model, including its configuration
>>> model.save_pretrained("vit-bert")

>>> # loading model and config from pretrained folder
>>> vision_text_config = VisionTextDualEncoderConfig.from_pretrained("vit-bert")
>>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert", config=vision_text_config)
```

#### from_vision_text_configs[[transformers.VisionTextDualEncoderConfig.from_vision_text_configs]]

```python
from_vision_text_configs(vision_config: PreTrainedConfig, text_config: PreTrainedConfig, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_text_dual_encoder/configuration_vision_text_dual_encoder.py#L64)

**Trả về:** [VisionTextDualEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)

Một đối tượng cấu hình

Tạo một [VisionTextDualEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig) (hoặc một lớp kế thừa) từ cấu hình mô hình văn bản và cấu hình mô hình thị giác.

## VisionTextDualEncoderProcessor[[transformers.VisionTextDualEncoderProcessor]]

#### transformers.VisionTextDualEncoderProcessor[[transformers.VisionTextDualEncoderProcessor]]

```python
transformers.VisionTextDualEncoderProcessor(image_processor = None, tokenizer = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_text_dual_encoder/processing_vision_text_dual_encoder.py#L24)

**Tham số:**

image_processor (`image_processor_class`) : 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.

Tạo một VisionTextDualEncoderProcessor, đóng gói một image processor và một tokenizer thành một processor duy nhất.

[VisionTextDualEncoderProcessor](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderProcessor) cung cấp đầy đủ các chức năng của `image_processor_class` và `tokenizer_class`. Xem `~image_processor_class` và `~tokenizer_class` để biết thêm thông tin.

#### __call__[[transformers.VisionTextDualEncoderProcessor.__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, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

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

**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.

return_mm_token_type_ids (`bool`, *kwargs*) : Có nên trả về các id loại token đa phương thức chỉ định vị trí của các token placeholder đa phương thức hay không.

return_text_replacement_offsets (`bool`, *kwargs*) : Có nên trả về các vị trí ký tự cho mỗi placeholder đa phương thức và phần thay thế của nó hay không.

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** ([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ợ.

## VisionTextDualEncoderModel[[transformers.VisionTextDualEncoderModel]]

#### transformers.VisionTextDualEncoderModel[[transformers.VisionTextDualEncoderModel]]

```python
transformers.VisionTextDualEncoderModel(config: transformers.models.vision_text_dual_encoder.configuration_vision_text_dual_encoder.VisionTextDualEncoderConfig | None = None, vision_model: transformers.modeling_utils.PreTrainedModel | None = None, text_model: transformers.modeling_utils.PreTrainedModel | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L45)

**Tham số:**

config ([VisionTextDualEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig), *tùy chọn*) : 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.

vision_model (`~modeling_utils.PreTrainedModel`, *tùy chọn*) : Mô hình thị giác cần sử dụng.

text_model (`~modeling_utils.PreTrainedModel`, *tùy chọn*) : Mô hình văn bản cần sử dụng.

Mô hình Vision Text Dual Encoder thô, xuất ra các hidden-states thô mà không có bất kỳ head cụ thể nào ở phía trên.

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.VisionTextDualEncoderModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, return_loss: bool | None = None, token_type_ids: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L171)

**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 `image_processor_class`. Xem `image_processor_class.__call__` để biết chi tiết ([VisionTextDualEncoderProcessor](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderProcessor) sử dụng `image_processor_class` để xử lý ảnh).

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)

return_loss (`bool`, *tùy chọn*) : Có trả về tổn thất tương phản hay không.

token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Các chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết.

output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết.

return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một `CLIPOutput` 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 thành phần khác nhau tùy thuộc vào cấu hình ([VisionTextDualEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)) và đầu vào.

Phương thức forward của [VisionTextDualEncoderModel](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderModel) 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.

- **loss** (`torch.Tensor` có shape `(1,)`, *tuỳ chọn*, được trả về khi `return_loss` là `True`) -- Mất tương phản cho độ tương đồng giữa ảnh và văn bản.
- **logits_per_image** (`torch.Tensor` có hình dạng `(image_batch_size, text_batch_size)`) -- Điểm tích vô hướng có tỷ lệ giữa `image_embeds` và `text_embeds`. Đây là các điểm tương đồng giữa ảnh và văn bản.
- **logits_per_text** (`torch.Tensor` có hình dạng `(text_batch_size, image_batch_size)`) -- Điểm tích vô hướng có trọng số giữa `text_embeds` và `image_embeds`. Đây là các điểm tương đồng giữa văn bản và hình ảnh.
- **text_embeds** (`torch.Tensor` có hình dạng `(batch_size, output_dim`) -- Các vector nhúng văn bản thu được bằng cách áp dụng lớp chiếu lên đầu ra đã gộp của [CLIPTextModel](/docs/transformers/v5.23.0/vi/model_doc/clip#transformers.CLIPTextModel).
- **image_embeds** (`torch.Tensor` có hình dạng `(batch_size, output_dim`) -- Các embedding hình ảnh thu được bằng cách áp dụng lớp chiếu lên đầu ra đã pool của [CLIPVisionModel](/docs/transformers/v5.23.0/vi/model_doc/clip#transformers.CLIPVisionModel).
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của [CLIPTextModel](/docs/transformers/v5.23.0/vi/model_doc/clip#transformers.CLIPTextModel).
- **vision_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *tùy chọn*) -- Đầu ra của [CLIPVisionModel](/docs/transformers/v5.23.0/vi/model_doc/clip#transformers.CLIPVisionModel).

Ví dụ:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import (
...     VisionTextDualEncoderModel,
...     VisionTextDualEncoderProcessor,
...     AutoImageProcessor,
...     AutoTokenizer,
... )

>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = VisionTextDualEncoderModel.from_vision_text_pretrained(
...     "google/vit-base-patch16-224", "google-bert/bert-base-uncased"
... )

>>> # contrastive training
>>> urls = [
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
...     "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> with httpx.stream("GET", urls[0]) as response:
...     image1 = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", urls[1]) as response:
...     image2 = Image.open(BytesIO(response.read()))

>>> images = [image1, image2]

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="pt", padding=True
... )
>>> outputs = model(
...     input_ids=inputs.input_ids,
...     attention_mask=inputs.attention_mask,
...     pixel_values=inputs.pixel_values,
...     return_loss=True,
... )
>>> loss, logits_per_image = outputs.loss, outputs.logits_per_image  # this is the image-text similarity score

>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert")

>>> # inference
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
```

#### get_text_features[[transformers.VisionTextDualEncoderModel.get_text_features]]

```python
get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, token_type_ids: 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/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L105)

**Tham số:**

input_ids (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong 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 thêm chi tiết. [Input IDs 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.Tensor` có shape `(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 position embeddings. Được chọn trong khoảng `[0, config.n_positions - 1]`.  [Position IDs là gì?](../glossary#position-ids)

token_type_ids (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số token phân đoạn để chỉ định phần đầu và phần thứ hai của các đầu vào. Các chỉ số được chọn trong `[0, 1]`:  - 0 tương ứng với token *câu A*, - 1 tương ứng với token *câu B*.  [Các ID loại token là gì?](../glossary#token-type-ids)

**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 ([VisionTextDualEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)) và đầu vào.

- **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.

Ví dụ:

```python
>>> import torch
>>> from transformers import VisionTextDualEncoderModel, AutoTokenizer

>>> model = VisionTextDualEncoderModel.from_pretrained("clip-italian/clip-italian")
>>> tokenizer = AutoTokenizer.from_pretrained("clip-italian/clip-italian")

>>> inputs = tokenizer(["una foto di un gatto", "una foto di un cane"], padding=True, return_tensors="pt")
>>> with torch.inference_mode():
...     text_features = model.get_text_features(**inputs)
```

#### get_image_features[[transformers.VisionTextDualEncoderModel.get_image_features]]

```python
get_image_features(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L142)

**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 `image_processor_class`. Xem `image_processor_class.__call__` để biết chi tiết ([VisionTextDualEncoderProcessor](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderProcessor) sử dụng `image_processor_class` để xử lý ảnh).

**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 ([VisionTextDualEncoderConfig](/docs/transformers/v5.23.0/vi/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)) và đầu vào.

- **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.

Ví dụ:

```python
>>> import torch
>>> from transformers import VisionTextDualEncoderModel, AutoImageProcessor
>>> from transformers.image_utils import load_image

>>> model = VisionTextDualEncoderModel.from_pretrained("clip-italian/clip-italian")
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> with torch.inference_mode():
...     image_features = model.get_image_features(**inputs)
```

