# Biến đổi chú ý lân cận giãn

## Tổng quan

DiNAT được đề xuất trong [Dilated Neighborhood Attention Transformer](https://huggingface.co/papers/2209.15001) bởi Ali Hassani và Humphrey Shi.

Nó mở rộng [NAT](https://huggingface.co/papers/2204.07143) bằng cách thêm mẫu Dilated Neighborhood Attention để nắm bắt ngữ cảnh toàn cục, và cho thấy cải thiện hiệu suất đáng kể so với nó.

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

*Transformers đang nhanh chóng trở thành một trong những kiến trúc học sâu được ứng dụng rộng rãi nhất trên nhiều phương thức, lĩnh vực và tác vụ. Trong thị giác, bên cạnh các nỗ lực liên tục dành cho các transformer thuần túy, các transformer phân cấp cũng đã thu hút sự chú ý đáng kể nhờ hiệu suất và khả năng tích hợp dễ dàng vào các khung làm việc hiện có. Các mô hình này thường sử dụng các cơ chế chú ý cục bộ, chẳng hạn như Neighborhood Attention (NA) dạng cửa sổ trượt hoặc Shifted Window Self Attention của Swin Transformer. Mặc dù hiệu quả trong việc giảm độ phức tạp bậc hai của self attention, chú ý cục bộ làm suy yếu hai thuộc tính mong muốn nhất của self attention: mô hình hóa sự phụ thuộc tầm xa và trường nhận cảm toàn cục. Trong bài báo này, chúng tôi giới thiệu Dilated Neighborhood Attention (DiNA), một phần mở rộng tự nhiên, linh hoạt và hiệu quả của NA, có khả năng nắm bắt ngữ cảnh toàn cục hơn và mở rộng trường nhận cảm theo cấp số nhân mà không phát sinh chi phí bổ sung. Chú ý cục bộ của NA và chú ý toàn cục thưa của DiNA bổ trợ cho nhau, do đó chúng tôi giới thiệu Dilated Neighborhood Attention Transformer (DiNAT), một transformer thị giác phân cấp mới được xây dựng dựa trên cả hai. Các biến thể DiNAT đạt được cải thiện đáng kể so với các baseline mạnh như NAT, Swin và ConvNeXt. Mô hình lớn của chúng tôi nhanh hơn và vượt qua phiên bản Swin tương ứng 1,5% box AP trong phát hiện đối tượng COCO, 1,3% mask AP trong phân đoạn instance COCO và 1,1% mIoU trong phân đoạn ngữ nghĩa ADE20K. Khi kết hợp với các khung làm việc mới, biến thể lớn của chúng tôi là mô hình phân đoạn panoptic tiên tiến nhất mới trên COCO (58,2 PQ) và ADE20K (48,5 PQ), cũng như mô hình phân đoạn instance trên Cityscapes (44,5 AP) và ADE20K (35,4 AP) (không dùng thêm dữ liệu). Nó cũng ngang bằng với các mô hình phân đoạn ngữ nghĩa chuyên biệt tiên tiến nhất trên ADE20K (58,2 mIoU) và xếp thứ hai trên Cityscapes (84,5 mIoU) (không dùng thêm dữ liệu).*

<img
src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/dilated-neighborhood-attention-pattern.jpg"
alt="drawing" width="600"/>

 Neighborhood Attention với các giá trị dilation khác nhau. Được trích từ bài báo gốc.

Mô hình này được đóng góp bởi [Ali Hassani](https://huggingface.co/alihassanijr). Mã gốc có thể được tìm thấy [tại đây](https://github.com/SHI-Labs/Neighborhood-Attention-Transformer).

## Mẹo sử dụng

DiNAT có thể được sử dụng như một *backbone*. Khi `output_hidden_states = True`, nó sẽ xuất ra cả `hidden_states` và `reshaped_hidden_states`. `reshaped_hidden_states` có hình dạng `(batch, num_channels, height, width)` thay vì `(batch_size, height, width, num_channels)`.

Ghi chú:

- DiNAT phụ thuộc vào việc triển khai Neighborhood Attention và Dilated Neighborhood Attention của [NATTEN](https://github.com/SHI-Labs/NATTEN/).
Bạn có thể cài đặt bằng các wheel đã được xây dựng sẵn cho Linux bằng cách tham khảo [shi-labs.com/natten](https://shi-labs.com/natten), hoặc tự build trên hệ thống của bạn bằng cách chạy `pip install natten`. Lưu ý rằng cách sau có thể mất nhiều thời gian để biên dịch. NATTEN hiện chưa hỗ trợ các thiết bị Windows.
- Hiện tại chỉ hỗ trợ kích thước patch là 4.

## 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 DiNAT.

- [DinatForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatForImageClassification) đượ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ó.

## DinatConfig[[transformers.DinatConfig]]

#### transformers.DinatConfig[[transformers.DinatConfig]]

```python
transformers.DinatConfig(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, patch_size: int | list[int] | tuple[int, int] = 4, num_channels: int = 3, embed_dim: int = 64, depths: list[int] | tuple[int, ...] = (3, 4, 6, 5), num_heads: list[int] | tuple[int, ...] = (2, 4, 8, 16), kernel_size: int = 7, dilations: list | tuple | None = None, mlp_ratio: float = 3.0, qkv_bias: bool = True, hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, drop_path_rate: float | int = 0.1, hidden_act: str = 'gelu', initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, layer_scale_init_value: float = 0.0, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

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

**Tham số:**

patch_size (`Union[int, list[int], tuple[int, int]]`, *tùy chọn*, mặc định là `4`) : 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.

embed_dim (`int`, *tuỳ chọn*, mặc định là `64`) : Độ chiều của các embedding và trạng thái ẩn.

depths (`Union[list[int], tuple[int, ...]]`, *tùy chọn*, mặc định là `(3, 4, 6, 5)`) : Độ sâu của từng lớp trong Transformer.

num_heads (`Union[list[int], tuple[int, ...]]`, *tùy chọn*, mặc định là `(2, 4, 8, 16)`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

kernel_size (`int`, *tuỳ chọn*, mặc định là `7`) : Kích thước của nhân tích chập.

dilations (`list[list[int]]`, *tùy chọn*, mặc định là `[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]`) : Giá trị giãn nở (dilation) của mỗi lớp NA trong bộ mã hóa Transformer.

mlp_ratio (`float`, *tuỳ chọn*, mặc định là `3.0`) : Tỷ lệ giữa chiều ẩn của MLP và chiều nhúng.

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.

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ú ý.

drop_path_rate (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ drop path cho việc hợp nhất patch.

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.

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-05`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

layer_scale_init_value (`float`, *optional*, mặc định là `0.0`) : Hệ số tỷ lệ sử dụng trong các lớp self-attention. 0.1 cho base, 1e-6 cho large. Đặt 0 để vô hiệu hóa layer scale.

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

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 DinatConfig, DinatModel

>>> # Initializing a Dinat shi-labs/dinat-mini-in1k-224 style configuration
>>> configuration = DinatConfig()

>>> # Initializing a model (with random weights) from the shi-labs/dinat-mini-in1k-224 style configuration
>>> model = DinatModel(configuration)

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

## DinatModel[[transformers.DinatModel]]

#### transformers.DinatModel[[transformers.DinatModel]]

```python
transformers.DinatModel(config: DinatConfig, add_pooling_layer = True)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dinat/modeling_dinat.py#L541)

**Tham số:**

config ([DinatConfig](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatConfig)) : 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.

add_pooling_layer (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm một lớp pooling hay không

Mô hình Dinat cơ bản, xuất ra các hidden-state 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.DinatModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = 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/dinat/modeling_dinat.py#L567)

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

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ề:** `DinatModelOutput` hoặc `tuple(torch.Tensor)`

Một `DinatModelOutput` 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 ([DinatConfig](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatConfig)) và đầu vào.

Phương thức forward của [DinatModel](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatModel) 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)`, *tùy chọn*) -- 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)`, *tùy chọn*, được trả về khi truyền `add_pooling_layer=True`) -- Average pooling của hidden-state ở lớp cuối.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *tùy 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ác `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 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, ...]`, *tùy 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.
- **reshaped_hidden_states** (`tuple(torch.Tensor)`, *tùy 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 + một cho đầu ra của mỗi giai đoạn) có hình dạng `(batch_size, hidden_size, height, width)`.

  Trạng thái ẩn (hidden-states) của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của lớp nhúng (embedding) ban đầu, được định dạng lại (reshape) để bao gồm các chiều không gian.

Ví dụ:

```python
```

## DinatForImageClassification[[transformers.DinatForImageClassification]]

#### transformers.DinatForImageClassification[[transformers.DinatForImageClassification]]

```python
transformers.DinatForImageClassification(config: DinatConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/dinat/modeling_dinat.py#L622)

**Tham số:**

config ([DinatConfig](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatConfig)) : 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.

Model transformer Dinat với đầu phân loại hình ảnh phía trên (một lớp tuyến tính phía trên trạng thái ẩn cuối cùng của token [CLS]) 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.DinatForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: 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/dinat/modeling_dinat.py#L639)

**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. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy).

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ề:** `DinatImageClassifierOutput` hoặc `tuple(torch.Tensor)`

Một `DinatImageClassifierOutput` 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 ([DinatConfig](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatConfig)) và đầu vào.

Phương thức forward của [DinatForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/dinat#transformers.DinatForImageClassification) 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, ...]`, *tùy 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ác `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 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, ...]`, *tùy 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.
- **reshaped_hidden_states** (`tuple(torch.Tensor)`, *tùy 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 + một cho đầu ra của mỗi giai đoạn) có hình dạng `(batch_size, hidden_size, height, width)`.

  Trạng thái ẩn (hidden-states) của mô hình tại đầu ra của mỗi lớp cùng với đầu ra của lớp nhúng (embedding) ban đầu, được định dạng lại (reshape) để bao gồm các chiều không gian.

Ví dụ:

```python
>>> from transformers import AutoImageProcessor, DinatForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("shi-labs/dinat-mini-in1k-224")
>>> model = DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224")

>>> inputs = image_processor(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])
...
```