# FocalNet

## Tổng quan

Mô hình FocalNet được đề xuất trong [Focal Modulation Networks](https://huggingface.co/papers/2203.11926) bởi Jianwei Yang, Chunyuan Li, Xiyang Dai, Lu Yuan, Jianfeng Gao. FocalNets thay thế hoàn toàn self-attention (được sử dụng trong các mô hình như [ViT](vit) và [Swin](swin)) bằng cơ chế focal modulation để mô hình hóa tương tác giữa các token trong thị giác. Các tác giả khẳng định rằng FocalNets vượt trội hơn các mô hình dựa trên self-attention với chi phí tính toán tương tự trên các tác vụ phân loại ảnh, phát hiện đối tượng và phân đoạn.

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

*Chúng tôi đề xuất mạng điều biến tiêu điểm (gọi tắt là FocalNets), trong đó cơ chế tự chú ý (SA) được thay thế hoàn toàn bằng cơ chế điều biến tiêu điểm để mô hình hóa tương tác giữa các token trong thị giác. Điều biến tiêu điểm bao gồm ba thành phần: (i) ngữ cảnh hóa phân cấp, được triển khai bằng một chồng các lớp tích chập theo chiều sâu, để mã hóa ngữ cảnh thị giác từ phạm vi ngắn đến dài, (ii) tổng hợp có cổng để chọn lọc thu thập ngữ cảnh cho mỗi token truy vấn dựa trên nội dung của nó, và (iii) điều biến theo từng phần tử hoặc biến đổi affine để tiêm ngữ cảnh đã tổng hợp vào truy vấn. Các thí nghiệm rộng rãi cho thấy FocalNets vượt trội hơn so với các đối thủ SA tiên tiến nhất (ví dụ: Swin và Focal Transformers) với chi phí tính toán tương tự trên các tác vụ phân loại ảnh, phát hiện đối tượng và phân đoạn. Cụ thể, FocalNets với kích thước tiny và base đạt độ chính xác top-1 lần lượt là 82,3% và 83,9% trên ImageNet-1K. Sau khi được tiền huấn luyện trên ImageNet-22K ở độ phân giải 224, mô hình đạt độ chính xác top-1 là 86,5% và 87,3% khi được tinh chỉnh ở độ phân giải 224 và 384, tương ứng. Khi chuyển sang các tác vụ hạ nguồn, FocalNets thể hiện sự vượt trội rõ rệt. Đối với phát hiện đối tượng bằng Mask R-CNN, FocalNet base được huấn luyện với lịch trình 1\times vượt qua đối thủ Swin 2,1 điểm và đã vượt qua Swin được huấn luyện với lịch trình 3\times (49,0 so với 48,5). Đối với phân đoạn ngữ nghĩa bằng UPerNet, FocalNet base ở thang đo đơn vượt qua Swin 2,4 điểm và đánh bại Swin ở thang đo đa (50,5 so với 49,7). Sử dụng FocalNet lớn và Mask2former, chúng tôi đạt 58,5 mIoU cho phân đoạn ngữ nghĩa ADE20K và 57,9 PQ cho Phân đoạn Toàn cảnh COCO. Sử dụng FocalNet khổng lồ và DINO, chúng tôi đạt 64,3 và 64,4 mAP trên COCO minival và test-dev, tương ứng, thiết lập SoTA mới trên các mô hình dựa trên chú ý lớn hơn nhiều như Swinv2-G và BEIT-3.*

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

## FocalNetConfig[[transformers.FocalNetConfig]]

#### transformers.FocalNetConfig[[transformers.FocalNetConfig]]

```python
transformers.FocalNetConfig(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, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 4, num_channels: int = 3, embed_dim: int = 96, use_conv_embed: bool = False, hidden_sizes: list[int] | tuple[int, ...] = (192, 384, 768, 768), depths: list[int] | tuple[int, ...] = (2, 2, 6, 2), focal_levels: list[int] | tuple[int, ...] = (2, 2, 2, 2), focal_windows: list[int] | tuple[int, ...] = (3, 3, 3, 3), hidden_act: str = 'gelu', mlp_ratio: float = 4.0, hidden_dropout_prob: float | int = 0.0, drop_path_rate: float | int = 0.1, use_layerscale: bool = False, layerscale_value: float = 0.0001, use_post_layernorm: bool = False, use_post_layernorm_in_modulation: bool = False, normalize_modulator: bool = False, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, encoder_stride: int = 32, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/configuration_focalnet.py#L25)

**Tham số:**

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à `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à `96`) : Độ chiều của các embedding và trạng thái ẩn.

use_conv_embed (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng convolutional embedding hay không. Các tác giả lưu ý rằng việc sử dụng convolutional embedding thường cải thiện hiệu suất, nhưng tính năng này không được bật theo mặc định.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *tùy chọn*, mặc định là `(192, 384, 768, 768)`) : Kích thước ẩn (hidden size) ở mỗi giai đoạn của mô hình.

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

focal_levels (`list(int)`, *tùy chọn*, mặc định là `[2, 2, 2, 2]`) : Số lượng mức tiêu cự trong mỗi lớp của các giai đoạn tương ứng trong bộ mã hóa.

focal_windows (`list(int)`, *tùy chọn*, mặc định là `[3, 3, 3, 3]`) : Kích thước cửa sổ focal ở mỗi lớp của các giai đoạn tương ứng trong bộ mã hóa.

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.

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

hidden_dropout_prob (`float`, *optional*, mặc định là 0.0) : Xác suất dropout cho tất cả các lớp liên kết đầy đủ trong phần nhúng và bộ mã hóa.

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.

use_layerscale (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng layer scale trong encoder hay không.

layerscale_value (`float`, *tuỳ chọn*, mặc định là 0.0001) : Giá trị ban đầu của layer scale.

use_post_layernorm (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng chuẩn hóa sau lớp (post layer normalization) trong bộ mã hóa hay không.

use_post_layernorm_in_modulation (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng chuẩn hóa sau lớp (post layer normalization) trong lớp điều biến (modulation layer) hay không.

normalize_modulator (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chuẩn hóa bộ điều biến hay khô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ố.

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

encoder_stride (`int`, *tuỳ chọn*, mặc định là 32) : Hệ số để tăng độ phân giải không gian trong đầu giải mã (decoder head) cho việc mô hình hóa ảnh có mặt nạ (masked image modeling).

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

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/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/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

Ví dụ:

```python
>>> from transformers import FocalNetConfig, FocalNetModel

>>> # Initializing a FocalNet microsoft/focalnet-tiny style configuration
>>> configuration = FocalNetConfig()

>>> # Initializing a model (with random weights) from the microsoft/focalnet-tiny style configuration
>>> model = FocalNetModel(configuration)

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

## FocalNetModel[[transformers.FocalNetModel]]

#### transformers.FocalNetModel[[transformers.FocalNetModel]]

```python
transformers.FocalNetModel(config: FocalNetConfig, add_pooling_layer = True, use_mask_token = False)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L592)

**Tham số:**

config ([FocalNetConfig](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetConfig)) : 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/main/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

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 Focalnet cơ bản, xuất ra các hidden-states thô mà không có head cụ thể nào ở phía trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/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.FocalNetModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L617)

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

bool_masked_pos (`torch.BoolTensor` có hình dạng `(batch_size, num_patches)`) : Các vị trí bị che bằng Boolean. Chỉ ra những patch nào bị che (1) và những patch nào không bị che (0).

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/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một `FocalNetModelOutput` 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 ([FocalNetConfig](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetConfig)) và đầu vào.

Phương thức forward của [FocalNetModel](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetModel) 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]`, *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á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.
- **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
```

## FocalNetForMaskedImageModeling[[transformers.FocalNetForMaskedImageModeling]]

#### transformers.FocalNetForMaskedImageModeling[[transformers.FocalNetForMaskedImageModeling]]

```python
transformers.FocalNetForMaskedImageModeling(config: FocalNetConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L675)

**Tham số:**

config ([FocalNetConfig](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetConfig)) : 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/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình FocalNet với một bộ giải mã phía trên cho việc mô hình hóa hình ảnh có mặt nạ.

Điều này tuân theo cùng một cách triển khai như trong [SimMIM](https://huggingface.co/papers/2111.09886).

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/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.FocalNetForMaskedImageModeling.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L693)

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

bool_masked_pos (`torch.BoolTensor` có hình dạng `(batch_size, num_patches)`) : Các vị trí bị che bằng Boolean. Chỉ ra những patch nào bị che (1) và những patch nào không bị che (0).

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/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một `FocalNetMaskedImageModelingOutput` 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 ([FocalNetConfig](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetConfig)) và đầu vào.

Phương thức forward của [FocalNetForMaskedImageModeling](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetForMaskedImageModeling) 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 `bool_masked_pos` được cung cấp) -- Loss của Masked image modeling (MLM).
- **reconstruction** (`torch.Tensor` có hình dạng `(batch_size, num_channels, height, width)`) -- Giá trị pixel được tái tạo.
- **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á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.
- **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, FocalNetConfig, FocalNetForMaskedImageModeling
>>> 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("microsoft/focalnet-base-simmim-window6-192")
>>> config = FocalNetConfig()
>>> model = FocalNetForMaskedImageModeling(config)

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.logits
>>> list(reconstructed_pixel_values.shape)
[1, 3, 192, 192]
```

## FocalNetForImageClassification[[transformers.FocalNetForImageClassification]]

#### transformers.FocalNetForImageClassification[[transformers.FocalNetForImageClassification]]

```python
transformers.FocalNetForImageClassification(config: FocalNetConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L782)

**Tham số:**

config ([FocalNetConfig](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetConfig)) : 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/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình FocalNet 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 đầu ra đã được pool) ví dụ cho ImageNet.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/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.FocalNetForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L798)

**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 [BitImageProcessor](/docs/transformers/main/vi/model_doc/bit#transformers.BitImageProcessor). Xem [BitImageProcessor.__call__()](/docs/transformers/main/vi/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) để biết chi tiết (`processor_class` sử dụng [BitImageProcessor](/docs/transformers/main/vi/model_doc/bit#transformers.BitImageProcessor) để 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_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/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

Một `FocalNetImageClassifierOutput` 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 ([FocalNetConfig](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetConfig)) và đầu vào.

Phương thức forward của [FocalNetForImageClassification](/docs/transformers/main/vi/model_doc/focalnet#transformers.FocalNetForImageClassification) 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á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.
- **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, FocalNetForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny")
>>> model = FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny")

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