# ViTMSN

## Tổng quan

Mô hình ViTMSN được đề xuất trong [Masked Siamese Networks for Label-Efficient Learning](https://huggingface.co/papers/2204.07141) bởi Mahmoud Assran, Mathilde Caron, Ishan Misra, Piotr Bojanowski, Florian Bordes, Pascal Vincent, Armand Joulin, Michael Rabbat, Nicolas Ballas. Bài báo trình bày một kiến trúc nhúng chung (joint-embedding) để khớp các nguyên mẫu (prototypes) của các mảnh (patches) bị che với các nguyên mẫu của các mảnh không bị che. Với cấu hình này, phương pháp của họ cho thấy hiệu suất xuất sắc trong các chế độ ít mẫu (low-shot) và cực kỳ ít mẫu (extreme low-shot).

Tóm tắt từ bài báo như sau:

*Chúng tôi đề xuất Masked Siamese Networks (MSN), một khung học không giám sát để học biểu diễn ảnh. Phương pháp của chúng tôi khớp biểu diễn của một góc nhìn ảnh chứa các mảnh (patch) bị che ngẫu nhiên với biểu diễn của ảnh gốc không bị che. Chiến lược tiền huấn luyện không giám sát này đặc biệt có khả năng mở rộng khi áp dụng cho Vision Transformers vì chỉ các mảnh không bị che mới được xử lý bởi mạng. Kết quả là, MSN cải thiện khả năng mở rộng của các kiến trúc nhúng chung (joint-embedding), đồng thời tạo ra các biểu diễn ở mức ngữ nghĩa cao, đạt hiệu suất cạnh tranh trong phân loại ảnh ít mẫu (low-shot). Ví dụ, trên ImageNet-1K, với chỉ 5.000 ảnh được chú thích, mô hình MSN cơ bản của chúng tôi đạt độ chính xác top-1 là 72,4%, và với 1% nhãn của ImageNet-1K, chúng tôi đạt độ chính xác top-1 là 75,7%, thiết lập mức tiên tiến mới (state-of-the-art) cho học không giám sát trên bộ chuẩn này.*

 Kiến trúc MSN. Được trích từ bài báo gốc.

Mô hình này được đóng góp bởi [sayakpaul](https://huggingface.co/sayakpaul). Mã gốc có thể được tìm thấy [tại đây](https://github.com/facebookresearch/msn).

## Mẹo sử dụng

- MSN (masked siamese networks) là một phương pháp tiền huấn luyện tự giám sát cho Vision Transformers (ViTs). Tiền huấn
mục tiêu là khớp các nguyên mẫu được gán cho các góc nhìn không bị che của các hình ảnh với các nguyên mẫu của các góc nhìn bị che của cùng những hình ảnh đó.
- Các tác giả chỉ phát hành trọng số đã huấn luyện trước của phần thân (huấn luyện trước trên ImageNet-1k). Vì vậy, để sử dụng nó trên bộ dữ liệu phân loại ảnh của riêng bạn,
sử dụng lớp [ViTMSNForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNForImageClassification) được khởi tạo từ [ViTMSNModel](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNModel). Làm theo [notebook này](https://github.com/huggingface/notebooks/blob/main/examples/image_classification.ipynb) để xem hướng dẫn chi tiết về fine-tuning.
- MSN đặc biệt hữu ích trong các chế độ low-shot và extreme low-shot. Đáng chú ý, nó đạt độ chính xác top-1 là 75,7% chỉ với 1% của ImageNet-1K
các nhãn khi tinh chỉnh.

### Sử dụng Scaled Dot Product Attention (SDPA)

PyTorch bao gồm một toán tử scaled dot-product attention (SDPA) bản địa như một phần của `torch.nn.functional`. Hàm này bao gồm một số triển khai có thể được áp dụng tùy thuộc vào đầu vào và phần cứng đang sử dụng. Xem [tài liệu chính thức](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) hoặc trang [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) để biết thêm thông tin.

SDPA được sử dụng mặc định cho `torch>=2.1.1` khi có sẵn một bản triển khai, nhưng bạn cũng có thể đặt `attn_implementation="sdpa"` trong `from_pretrained()` để yêu cầu sử dụng SDPA một cách rõ ràng.

```python
from transformers import ViTMSNForImageClassification

model = ViTMSNForImageClassification.from_pretrained("facebook/vit-msn-base", attn_implementation="sdpa", device_map="auto")
...
```

Để đạt được tốc độ tăng tốc tốt nhất, chúng tôi khuyến nghị nạp mô hình ở độ chính xác nửa (ví dụ: `torch.float16` hoặc `torch.bfloat16`).

Trên một benchmark cục bộ (A100-40GB, PyTorch 2.3.0, hệ điều hành Ubuntu 22.04) với `float32` và mô hình `facebook/vit-msn-base`, chúng tôi đã quan sát thấy các mức tăng tốc sau trong quá trình suy luận.

|   Kích thước lô |   Thời gian suy luận trung bình (ms), chế độ eager |   Thời gian suy luận trung bình (ms), mô hình sdpa |   Tăng tốc, Sdpa / Eager (x) |
|--------------|-------------------------------------------|-------------------------------------------|------------------------------|
|            1 |                                         7 |                                         6 |                      1.17 |
|            2 |                                         8 |                                         6 |                      1.33 |
|            4 |                                         8 |                                         6 |                      1.33 |
|            8 |                                         8 |                                         6 |                      1.33 |

## Tài nguyên

Danh sách các tài nguyên chính thức của Hugging Face và cộng đồng (được đánh dấu bằng 🌎) để giúp bạn bắt đầu với ViT MSN.

- [ViTMSNForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNForImageClassification) được hỗ trợ bởi [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb) này.
- Xem thêm: [Hướng dẫn tác vụ phân loại hình ảnh](../tasks/image_classification)

Nếu bạn quan tâm đến việc gửi một tài nguyên để được đưa vào đây, hãy thoải mái mở một Pull Request và chúng tôi sẽ xem xét! Lý tưởng nhất là tài nguyên nên minh họa một điều gì đó mới thay vì sao chép một tài nguyên hiện có.

## ViTMSNConfig[[transformers.ViTMSNConfig]]

#### transformers.ViTMSNConfig[[transformers.ViTMSNConfig]]

```python
transformers.ViTMSNConfig(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True)
```

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

**Tham số:**

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

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

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

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

hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : 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.

hidden_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.0`) : Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler.

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

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

layer_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 lớp (layer normalization).

image_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `224`) : Kích thước (độ phân giải) của mỗi hình ảnh.

patch_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `16`) : Kích thước (độ phân giải) của mỗi patch.

num_channels (`int`, *tuỳ chọn*, mặc định là `3`) : Số lượng kênh đầu vào.

qkv_bias (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm bias vào queries, keys và values hay không.

Đây là lớp cấu hình để lưu trữ cấu hình của một ViTMSNModel. Nó được sử dụng để khởi tạo một mô hình Vit Msn 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 [facebook/vit_msn_base](https://huggingface.co/facebook/vit_msn_base)

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 ViTMSNModel, ViTMSNConfig

>>> # Initializing a ViT MSN vit-msn-base style configuration
>>> configuration = ViTConfig()

>>> # Initializing a model from the vit-msn-base style configuration
>>> model = ViTMSNModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## ViTMSNModel[[transformers.ViTMSNModel]]

#### transformers.ViTMSNModel[[transformers.ViTMSNModel]]

```python
transformers.ViTMSNModel(config: ViTMSNConfig, use_mask_token: bool = False)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vit_msn/modeling_vit_msn.py#L317)

**Tham số:**

config ([ViTMSNConfig](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNConfig)) : 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ố của mô hình.

use_mask_token (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng token mặt nạ cho việc mô hình hóa hình ảnh có mặt nạ hay không.

Mô hình Vit Msn cơ bản, 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.ViTMSNModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: 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/vit_msn/modeling_vit_msn.py#L331)

**Tham số:**

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 [ViTImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/vit#transformers.ViTImageProcessor). Xem [ViTImageProcessor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [ViTImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/vit#transformers.ViTImageProcessor) để xử lý ảnh).

bool_masked_pos (`torch.BoolTensor` có shape `(batch_size, num_patches)`, *tùy chọn*) : Các vị trí bị mask dạng Boolean. Chỉ ra những patch nào bị mask (1) và những patch nào không bị mask (0).

interpolate_pos_encoding (`bool`, *tùy chọn*) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không.

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)

**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 thành phần khác nhau tùy thuộc vào cấu hình ([ViTMSNConfig](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNConfig)) và đầu vào.

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

Ví dụ:

```python
>>> from transformers import AutoImageProcessor, ViTMSNModel
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/vit-msn-small")
>>> model = ViTMSNModel.from_pretrained("facebook/vit-msn-small")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
```

## ViTMSNForImageClassification[[transformers.ViTMSNForImageClassification]]

#### transformers.ViTMSNForImageClassification[[transformers.ViTMSNForImageClassification]]

```python
transformers.ViTMSNForImageClassification(config: ViTMSNConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vit_msn/modeling_vit_msn.py#L387)

**Tham số:**

config ([ViTMSNConfig](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNConfig)) : 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ố của mô hình.

Mô hình Vit Msn có đầu phân loại hình ảnh phía trên, ví dụ cho ImageNet.

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

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: 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/vit_msn/modeling_vit_msn.py#L395)

**Tham số:**

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 [ViTImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/vit#transformers.ViTImageProcessor). Xem [ViTImageProcessor.__call__()](/docs/transformers/v5.23.0/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [ViTImageProcessor](/docs/transformers/v5.23.0/vi/model_doc/vit#transformers.ViTImageProcessor) để xử lý ảnh).

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy hình ảnh.

interpolate_pos_encoding (`bool`, *tùy chọn*) : Có nội suy các mã hóa vị trí được huấn luyện trước hay không.

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)

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

Một [ImageClassifierOutput](/docs/transformers/v5.23.0/vi/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) 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 ([ViTMSNConfig](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNConfig)) và đầu vào.

Phương thức forward của [ViTMSNForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/vit_msn#transformers.ViTMSNForImageClassification) 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,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss phân loại (hoặc hồi quy nếu config.num_labels==1).
- **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax).
- **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 embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi giai đoạn) có hình dạng `(batch_size, sequence_length, hidden_size)`. Hidden-states (còn gọi là feature maps) của mô hình tại đầu ra của mỗi giai đoạ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, patch_size, 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
>>> from transformers import AutoImageProcessor, ViTMSNForImageClassification
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> torch.manual_seed(2)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/vit-msn-small")
>>> model = ViTMSNForImageClassification.from_pretrained("facebook/vit-msn-small")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tusker
```

