# ResNet

## Ikhtisar

Model ResNet diusulkan dalam [Deep Residual Learning for Image Recognition](https://huggingface.co/papers/1512.03385) oleh Kaiming He, Xiangyu Zhang, Shaoqing Ren, dan Jian Sun. Implementasi kami mengikuti perubahan kecil yang dilakukan oleh [Nvidia](https://catalog.ngc.nvidia.com/orgs/nvidia/resources/resnet_50_v1_5_for_pytorch), di mana kami menerapkan `stride=2` untuk downsampling pada conv `3x3` bottleneck dan bukan pada `1x1` pertama. Hal ini umumnya dikenal sebagai "ResNet v1.5".

ResNet memperkenalkan koneksi residual, yang memungkinkan pelatihan jaringan dengan jumlah lapisan yang belum pernah terlihat sebelumnya (hingga 1000). ResNet memenangkan kompetisi ILSVRC & COCO 2015, sebuah tonggak penting dalam visi komputer mendalam.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Jaringan saraf yang lebih dalam lebih sulit dilatih. Kami menyajikan kerangka pembelajaran residual untuk memudahkan pelatihan jaringan yang jauh lebih dalam daripada yang digunakan sebelumnya. Kami secara eksplisit merumuskan ulang lapisan sebagai pembelajaran fungsi residual dengan referensi ke input lapisan, alih-alih mempelajari fungsi tanpa referensi. Kami menyediakan bukti empiris yang komprehensif yang menunjukkan bahwa jaringan residual ini lebih mudah dioptimalkan, dan dapat meningkatkan akurasi dari kedalaman yang meningkat secara signifikan. Pada dataset ImageNet, kami mengevaluasi jaringan residual dengan kedalaman hingga 152 lapisan---8x lebih dalam daripada jaringan VGG tetapi masih memiliki kompleksitas yang lebih rendah. Ensemble dari jaringan residual ini mencapai error 3,57% pada set pengujian ImageNet. Hasil ini memenangkan tempat ke-1 pada tugas klasifikasi ILSVRC 2015. Kami juga menyajikan analisis pada CIFAR-10 dengan 100 dan 1000 lapisan. Kedalaman representasi sangat penting untuk banyak tugas pengenalan visual. Hanya karena representasi yang sangat dalam dari kami, kami memperoleh peningkatan relatif 28% pada dataset deteksi objek COCO. Jaringan residual dalam adalah fondasi dari submission kami ke kompetisi ILSVRC & COCO 2015, di mana kami juga memenangkan tempat ke-1 pada tugas deteksi ImageNet, lokalisasi ImageNet, deteksi COCO, dan segmentasi COCO.*

Gambar di bawah ini mengilustrasikan arsitektur ResNet. Diambil dari [paper asli](https://huggingface.co/papers/1512.03385).

Model ini disumbangkan oleh [Francesco](https://huggingface.co/Francesco). Kode aslinya dapat ditemukan [di sini](https://github.com/KaimingHe/deep-residual-networks).

## Sumber daya

Daftar sumber resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan ResNet.

- [ResNetForImageClassification](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetForImageClassification) didukung oleh [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb) ini.
- Lihat juga: [Panduan tugas klasifikasi gambar](../tasks/image_classification)

Jika Anda tertarik untuk mengirimkan sumber daya agar disertakan di sini, silakan buka Pull Request dan kami akan meninjaunya! Sumber daya tersebut sebaiknya mendemonstrasikan sesuatu yang baru, bukan menduplikasi sumber daya yang sudah ada.

## 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/resnet/configuration_resnet.py#L27)

**Parameter:**

num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input.

embedding_size (`int`, *opsional*, defaultnya `64`) : Dimensi dari embeddings dan hidden states.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(256, 512, 1024, 2048)`) : Dimensi (hidden size) pada setiap tahap model.

depths (`Union[list[int], tuple[int, ...]]`, *opsional*, defaultnya `(3, 4, 6, 3)`) : Kedalaman setiap lapisan dalam Transformer.

layer_type (`str`, *opsional*, defaultnya `"bottleneck"`) : Lapisan yang akan digunakan, bisa berupa `"basic"` (dipakai untuk model yang lebih kecil, seperti resnet-18 atau resnet-34) atau `"bottleneck"` (dipakai untuk model yang lebih besar seperti resnet-50 ke atas).

hidden_act (`str`, *opsional*, defaultnya `relu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

downsample_in_first_stage (`bool`, *opsional*, defaultnya `False`) : Jika `True`, tahap pertama akan melakukan downsampling pada input menggunakan `stride` sebesar 2.

downsample_in_bottleneck (`bool`, *opsional*, defaultnya `False`) : Jika `True`, conv 1x1 pertama di ResNetBottleNeckLayer akan melakukan downsampling pada input menggunakan `stride` sebesar 2.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari ResNetModel. Kelas ini digunakan untuk membuat instans model Resnet sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [microsoft/resnet-50](https://huggingface.co/microsoft/resnet-50)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:
```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()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/resnet/configuration_resnet.py#L72)

Periksa bahwa `layer_types` didefinisikan dengan benar.

## ResNetModel[[transformers.ResNetModel]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/resnet/modeling_resnet.py#L291)

**Parameter:**

config ([ResNetConfig](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Resnet polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

```python
forward(pixel_values: Tensor, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/resnet/modeling_resnet.py#L301)

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [ConvNextImageProcessor](/docs/transformers/main/id/model_doc/convnext#transformers.ConvNextImageProcessor). Lihat [ConvNextImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [ConvNextImageProcessor](/docs/transformers/main/id/model_doc/convnext#transformers.ConvNextImageProcessor) untuk memproses gambar).

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** `BaseModelOutputWithPoolingAndNoAttention` atau `tuple(torch.FloatTensor)`

A `BaseModelOutputWithPoolingAndNoAttention` atau tuple dari `torch.FloatTensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([ResNetConfig](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetConfig)) dan input.

Metode forward dari [ResNetModel](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.FloatTensor` dengan bentuk `(batch_size, num_channels, height, width)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **pooler_output** (`torch.FloatTensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir setelah operasi pooling pada dimensi spasial.
- **hidden_states** (`tuple(torch.FloatTensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.FloatTensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, num_channels, height, width)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.

Contoh:

```python
```

## ResNetForImageClassification[[transformers.ResNetForImageClassification]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/resnet/modeling_resnet.py#L340)

**Parameter:**

config ([ResNetConfig](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model ResNet dengan kepala klasifikasi gambar di atasnya (lapisan linear di atas fitur yang dipooling), misalnya untuk ImageNet.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/resnet/modeling_resnet.py#L353)

**Parameter:**

pixel_values (`torch.FloatTensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [ConvNextImageProcessor](/docs/transformers/main/id/model_doc/convnext#transformers.ConvNextImageProcessor). Lihat [ConvNextImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [ConvNextImageProcessor](/docs/transformers/main/id/model_doc/convnext#transformers.ConvNextImageProcessor) untuk memproses gambar).

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [ImageClassifierOutputWithNoAttention](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) atau `tuple(torch.FloatTensor)`

A [ImageClassifierOutputWithNoAttention](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) atau tuple dari `torch.FloatTensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([ResNetConfig](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetConfig)) dan input.

Metode forward dari [ResNetForImageClassification](/docs/transformers/main/id/model_doc/resnet#transformers.ResNetForImageClassification) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.FloatTensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.FloatTensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
- **hidden_states** (`tuple(torch.FloatTensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.FloatTensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap tahap) dengan bentuk `(batch_size, num_channels, height, width)`. Hidden-states (juga disebut feature maps) dari model pada output dari setiap tahap.

Contoh:

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