# ResNet

## Aperçu

Le modèle ResNet a été proposé dans [Deep Residual Learning for Image Recognition](https://huggingface.co/papers/1512.03385) par Kaiming He, Xiangyu Zhang, Shaoqing Ren et Jian Sun. Notre implémentation suit les petites modifications apportées par [Nvidia](https://catalog.ngc.nvidia.com/orgs/nvidia/resources/resnet_50_v1_5_for_pytorch) : nous appliquons `stride=2` pour le downsampling dans la convolution `3x3` du bottleneck, et non dans la première convolution `1x1`. C'est ce qu'on appelle généralement « ResNet v1.5 ».

ResNet a introduit les connexions résiduelles, qui permettent d’entraîner des réseaux avec un nombre de couches inédit (jusqu’à 1000). ResNet a remporté la compétition ILSVRC & COCO 2015, un jalon important dans la vision par ordinateur profonde.

L'abstract de l'article est le suivant :

*Les réseaux de neurones plus profonds sont plus difficiles à entraîner. Nous présentons un cadre d'apprentissage résiduel pour faciliter l'entraînement de réseaux nettement plus profonds que ceux utilisés précédemment. Nous reformulons explicitement les couches en tant qu'apprentissage de fonctions résiduelles par rapport aux entrées des couches, plutôt que d'apprendre des fonctions non référencées. Nous fournissons des preuves empiriques exhaustives montrant que ces réseaux résiduels sont plus faciles à optimiser et peuvent gagner en précision grâce à une profondeur considérablement accrue. Sur le jeu de données ImageNet, nous évaluons des réseaux résiduels d'une profondeur allant jusqu'à 152 couches, soit 8 fois plus profonds que les réseaux VGG, mais avec une complexité inférieure. Un ensemble de ces réseaux résiduels atteint un taux d'erreur de 3,57 % sur le jeu de test ImageNet. Ce résultat a remporté la 1re place à la tâche de classification ILSVRC 2015. Nous présentons également une analyse sur CIFAR-10 avec 100 et 1000 couches. La profondeur des représentations est d'une importance centrale pour de nombreuses tâches de reconnaissance visuelle. Uniquement grâce à nos représentations extrêmement profondes, nous obtenons une amélioration relative de 28 % sur le jeu de données de détection d'objets COCO. Les réseaux résiduels profonds sont les fondements de nos soumissions aux compétitions ILSVRC & COCO 2015, où nous avons également remporté les 1res places aux tâches de détection ImageNet, de localisation ImageNet, de détection COCO et de segmentation COCO.*

La figure ci-dessous illustre l'architecture de ResNet. Issue de l'[article original](https://huggingface.co/papers/1512.03385).

Ce modèle a été contribué par [Francesco](https://huggingface.co/Francesco). Le code d’origine est disponible [ici](https://github.com/KaimingHe/deep-residual-networks).

## Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec ResNet.

- [ResNetForImageClassification](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetForImageClassification) est pris en charge par ce [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- Voir aussi : [Guide de la tâche de classification d'images](../tasks/image_classification)

Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.

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

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

**Paramètres :**

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

embedding_size (`int`, *facultatif*, par défaut `64`) : Dimension des embeddings et des états cachés.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(256, 512, 1024, 2048)`) : Dimension (taille cachée) à chaque étape du modèle.

depths (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(3, 4, 6, 3)`) : Profondeur de chaque couche du Transformer.

layer_type (`str`, *facultatif*, par défaut `"bottleneck"`) : La couche à utiliser, qui peut être soit `"basic"` (utilisée pour les modèles plus petits, comme resnet-18 ou resnet-34), soit `"bottleneck"` (utilisée pour les modèles plus grands, comme resnet-50 et au-delà).

hidden_act (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

downsample_in_first_stage (`bool`, *facultatif*, valeur par défaut `False`) : Si `True`, la première étape effectue un sous-échantillonnage des entrées en utilisant un `stride` de 2.

downsample_in_bottleneck (`bool`, *facultatif*, valeur par défaut `False`) : Si `True`, la première convolution 1x1 de ResNetBottleNeckLayer effectue un sous-échantillonnage des entrées en utilisant un `stride` de 2.

Ceci est la classe de configuration destinée à stocker la configuration d'un ResNetModel. Elle est utilisée pour instancier un modèle Resnet en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/resnet-50](https://huggingface.co/microsoft/resnet-50)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

Vérifiez que `layer_types` est correctement défini.

## ResNetModel[[transformers.ResNetModel]]

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

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

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

**Paramètres :**

config ([ResNetConfig](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Resnet brut qui produit des états cachés bruts, sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [ConvNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/convnext#transformers.ConvNextImageProcessor). Voir [ConvNextImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ConvNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/convnext#transformers.ConvNextImageProcessor) pour le traitement des images).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** `BaseModelOutputWithPoolingAndNoAttention` ou `tuple(torch.Tensor)`

Un `BaseModelOutputWithPoolingAndNoAttention` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([ResNetConfig](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetConfig)) et des entrées.

La méthode forward de [ResNetModel](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_channels, height, width)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche après une opération de pooling sur les dimensions spatiales.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, num_channels, height, width)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

Exemple :

```python
```

## ResNetForImageClassification[[transformers.ResNetForImageClassification]]

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

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

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

**Paramètres :**

config ([ResNetConfig](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle ResNet avec une tête de classification d'images au sommet (une couche linéaire au-dessus des fonctionnalités agrégées), par exemple pour ImageNet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de [ConvNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/convnext#transformers.ConvNextImageProcessor). Voir [ConvNextImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ConvNextImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/convnext#transformers.ConvNextImageProcessor) pour le traitement des images).

labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [ImageClassifierOutputWithNoAttention](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) ou `tuple(torch.Tensor)`

Un [ImageClassifierOutputWithNoAttention](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([ResNetConfig](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetConfig)) et les entrées.

La méthode forward de [ResNetForImageClassification](/docs/transformers/v5.23.0/fr/model_doc/resnet#transformers.ResNetForImageClassification) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1).
- **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque étape) de forme `(batch_size, num_channels, height, width)`. États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

Exemple :

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

