# ResNet

## Tổng quan

Mô hình ResNet được đề xuất trong [Deep Residual Learning for Image Recognition](https://huggingface.co/papers/1512.03385) bởi Kaiming He, Xiangyu Zhang, Shaoqing Ren và Jian Sun. Bản triển khai của chúng tôi tuân theo những thay đổi nhỏ do [Nvidia](https://catalog.ngc.nvidia.com/orgs/nvidia/resources/resnet_50_v1_5_for_pytorch) thực hiện, chúng tôi áp dụng `stride=2` cho việc giảm mẫu trong conv `3x3` của bottleneck thay vì trong `1x1` đầu tiên. Điều này thường được biết đến với tên gọi "ResNet v1.5".

ResNet đã giới thiệu các kết nối dư, cho phép huấn luyện các mạng với số lượng lớp chưa từng thấy (lên đến 1000). ResNet đã giành chiến thắng trong cuộc thi ILSVRC & COCO năm 2015, một cột mốc quan trọng trong thị giác máy tính sâu.

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

*Mạng nơ-ron sâu hơn khó huấn luyện hơn. Chúng tôi trình bày một khung học tập dư thừa (residual learning) để giảm bớt việc huấn luyện các mạng sâu hơn đáng kể so với những mạng được sử dụng trước đây. Chúng tôi tái định dạng rõ ràng các lớp để học các hàm dư thừa với tham chiếu đến đầu vào của lớp, thay vì học các hàm không có tham chiếu. Chúng tôi cung cấp bằng chứng thực nghiệm toàn diện cho thấy các mạng dư thừa này dễ tối ưu hơn và có thể đạt được độ chính xác cao hơn từ độ sâu tăng lên đáng kể. Trên bộ dữ liệu ImageNet, chúng tôi đánh giá các mạng dư thừa với độ sâu lên đến 152 lớp---sâu gấp 8 lần so với mạng VGG nhưng vẫn có độ phức tạp thấp hơn. Một tập hợp (ensemble) các mạng dư thừa này đạt được lỗi 3,57% trên bộ kiểm tra ImageNet. Kết quả này đã giành giải nhất trong nhiệm vụ phân loại ILSVRC 2015. Chúng tôi cũng trình bày phân tích trên CIFAR-10 với 100 và 1000 lớp. Độ sâu của các biểu diễn có tầm quan trọng trung tâm đối với nhiều nhiệm vụ nhận dạng thị giác. Hoàn toàn nhờ vào các biểu diễn cực kỳ sâu của chúng tôi, chúng tôi đạt được cải thiện tương đối 28% trên bộ dữ liệu phát hiện đối tượng COCO. Các mạng dư thừa sâu là nền tảng cho các bài nộp của chúng tôi trong các cuộc thi ILSVRC & COCO 2015, nơi chúng tôi cũng giành giải nhất trong các nhiệm vụ phát hiện ImageNet, định vị ImageNet, phát hiện COCO và phân đoạn COCO.*

Hình dưới đây minh họa kiến trúc của ResNet. Trích từ [bài báo gốc](https://huggingface.co/papers/1512.03385).

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

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

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

## ResNetConfig[[transformers.ResNetConfig]]

#### transformers.ResNetConfig[[transformers.ResNetConfig]]

```python
transformers.ResNetConfig(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, num_channels: int = 3, embedding_size: int = 64, hidden_sizes: list[int] | tuple[int, ...] | None = (256, 512, 1024, 2048), depths: list[int] | tuple[int, ...] | None = (3, 4, 6, 3), layer_type: str = 'bottleneck', hidden_act: str = 'relu', downsample_in_first_stage: bool = False, downsample_in_bottleneck: bool = False)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/resnet/configuration_resnet.py#L27)

**Tham số:**

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

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

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *tùy chọn*, mặc định là `(256, 512, 1024, 2048)`) : 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à `(3, 4, 6, 3)`) : Độ sâu của từng lớp trong Transformer.

layer_type (`str`, *tùy chọn*, mặc định là `"bottleneck"`) : Lớp cần sử dụng, có thể là `"basic"` (dùng cho các mô hình nhỏ hơn, như resnet-18 hoặc resnet-34) hoặc `"bottleneck"` (dùng cho các mô hình lớn hơn như resnet-50 trở lên).

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

downsample_in_first_stage (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, giai đoạn đầu tiên sẽ giảm mẫu các đầu vào bằng cách sử dụng `stride` là 2.

downsample_in_bottleneck (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, conv 1x1 đầu tiên trong ResNetBottleNeckLayer sẽ giảm mẫu đầu vào bằng cách sử dụng `stride` là 2.

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

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 ResNetConfig, ResNetModel

>>> # Initializing a ResNet resnet-50 style configuration
>>> configuration = ResNetConfig()

>>> # Initializing a model (with random weights) from the resnet-50 style configuration
>>> model = ResNetModel(configuration)

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

#### validate_layer_type[[transformers.ResNetConfig.validate_layer_type]]

```python
validate_layer_type()
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/resnet/configuration_resnet.py#L72)

Kiểm tra xem `layer_types` có được định nghĩa chính xác hay không.

## ResNetModel[[transformers.ResNetModel]]

#### transformers.ResNetModel[[transformers.ResNetModel]]

```python
transformers.ResNetModel(config: ResNetConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/resnet/modeling_resnet.py#L291)

**Tham số:**

config ([ResNetConfig](/docs/transformers/v5.23.0/vi/model_doc/resnet#transformers.ResNetConfig)) : 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 Resnet 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.ResNetModel.forward]]

```python
forward(pixel_values: Tensor, 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/resnet/modeling_resnet.py#L301)

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

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

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

Phương thức forward của [ResNetModel](/docs/transformers/v5.23.0/vi/model_doc/resnet#transformers.ResNetModel) 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, num_channels, height, width)`) -- Chuỗi các trạng thái ẩn 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 sau khi thực hiện phép pooling trên các chiều không gian.
- **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 lớp) có hình dạng `(batch_size, num_channels, height, width)`.

  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.

Ví dụ:

```python
```

## ResNetForImageClassification[[transformers.ResNetForImageClassification]]

#### transformers.ResNetForImageClassification[[transformers.ResNetForImageClassification]]

```python
transformers.ResNetForImageClassification(config: ResNetConfig)
```

[Nguồn](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/resnet/modeling_resnet.py#L340)

**Tham số:**

config ([ResNetConfig](/docs/transformers/v5.23.0/vi/model_doc/resnet#transformers.ResNetConfig)) : 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 ResNet với một đầu phân loại hình ảnh phía trên (một lớp tuyến tính phía trên các đặc trưng đã được pool), 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.ResNetForImageClassification.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/v5.23.0/src/transformers/models/resnet/modeling_resnet.py#L353)

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

labels (`torch.LongTensor` có shape `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán loss phân loại/hồi quy ảnh. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels > 1`, loss 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/v5.23.0/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không.

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

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

Phương thức forward của [ResNetForImageClassification](/docs/transformers/v5.23.0/vi/model_doc/resnet#transformers.ResNetForImageClassification) 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`) -- 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, num_channels, height, width)`. 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.

Ví dụ:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/resnet-50")
>>> model = ResNetForImageClassification.from_pretrained("microsoft/resnet-50")

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