# RegNet

## Aperçu

Le modèle RegNet a été proposé dans [Designing Network Design Spaces](https://huggingface.co/papers/2003.13678) par Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollár.

Les auteurs conçoivent des espaces de recherche pour effectuer la recherche d'architecture neuronale (NAS). Ils commencent d'abord par un espace de recherche de haute dimension et réduisent itérativement cet espace en appliquant empiriquement des contraintes basées sur les modèles les plus performants échantillonnés par l'espace de recherche actuel.

L'abstract de l'article est le suivant :

*Dans ce travail, nous présentons un nouveau paradigme de conception de réseaux. Notre objectif est de contribuer à faire progresser la compréhension de la conception de réseaux et de découvrir des principes de conception qui se généralisent à travers différents contextes. Plutôt que de nous concentrer sur la conception d’instances individuelles de réseaux, nous concevons des espaces de conception de réseaux qui paramètrent des populations de réseaux. Le processus global est analogue à la conception manuelle classique de réseaux, mais élevé au niveau de l’espace de conception. En utilisant notre méthodologie, nous explorons l’aspect structurel de la conception de réseaux et aboutissons à un espace de conception de faible dimension composé de réseaux simples et régulaires que nous appelons RegNet. L’idée centrale de la paramétrisation RegNet est étonnamment simple : les largeurs et les profondeurs des bons réseaux peuvent être expliquées par une fonction linéaire quantifiée. Nous analysons l’espace de conception RegNet et aboutissons à des résultats intéressants qui ne correspondent pas à la pratique actuelle de la conception de réseaux. L’espace de conception RegNet fournit des réseaux simples et rapides qui fonctionnent bien dans une large gamme de régimes de flops. Dans des conditions d’entraînement et des flops comparables, les modèles RegNet surpassent les modèles EfficientNet populaires tout en étant jusqu’à 5 fois plus rapides sur GPU.*

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

Le modèle de 10 milliards de paramètres issu de [Self-supervised Pretraining of Visual Features in the Wild](https://huggingface.co/papers/2103.01988), entraîné sur un milliard d’images Instagram, est disponible sur le [hub](https://huggingface.co/facebook/regnet-y-10b-seer)

## Ressources

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

- [RegNetForImageClassification](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetForImageClassification) 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.

## RegNetConfig[[transformers.RegNetConfig]]

#### transformers.RegNetConfig[[transformers.RegNetConfig]]

```python
transformers.RegNetConfig(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 = 32, hidden_sizes: list[int] | tuple[int, ...] = (128, 192, 512, 1088), depths: list[int] | tuple[int, ...] = (2, 6, 12, 2), groups_width: int = 64, layer_type: str = 'y', hidden_act: str = 'relu', downsample_in_first_stage: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/configuration_regnet.py#L24)

**Paramètres :**

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

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

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(128, 192, 512, 1088)`) : Dimensionnalité (taille cachée) à chaque étape du modèle.

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

groups_width (`int`, *facultatif*, valeur par défaut : 64) : Largeur du groupe pour chaque étape.

layer_type (`str`, *optional*, defaults to `"y"`) : The layer to use, it can be either `"x" or `"y"`. An `x` layer is a ResNet's BottleNeck layer with `reduction` fixed to `1`. While a `y` layer is a `x` but with squeeze and excitation. Please refer to the paper for a detailed explanation of how these layers were constructed.

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un RegNetModel. Elle est utilisée pour instancier un modèle Regnet 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 [facebook/regnet-y-040](https://huggingface.co/facebook/regnet-y-040)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :
```python
>>> from transformers import RegNetConfig, RegNetModel

>>> # Initializing a RegNet regnet-y-40 style configuration
>>> configuration = RegNetConfig()
>>> # Initializing a model from the regnet-y-40 style configuration
>>> model = RegNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

## RegNetModel[[transformers.RegNetModel]]

#### transformers.RegNetModel[[transformers.RegNetModel]]

```python
transformers.RegNetModel(config: RegNetConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/modeling_regnet.py#L282)

**Paramètres :**

config ([RegNetConfig](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Regnet 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/main/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.RegNetModel.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/main/src/transformers/models/regnet/modeling_regnet.py#L292)

**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/main/fr/model_doc/convnext#transformers.ConvNextImageProcessor). Voir [ConvNextImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ConvNextImageProcessor](/docs/transformers/main/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/main/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 ([RegNetConfig](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetConfig)) et des entrées.

La méthode forward de [RegNetModel](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetModel) 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
```

## RegNetForImageClassification[[transformers.RegNetForImageClassification]]

#### transformers.RegNetForImageClassification[[transformers.RegNetForImageClassification]]

```python
transformers.RegNetForImageClassification(config: RegNetConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/modeling_regnet.py#L332)

**Paramètres :**

config ([RegNetConfig](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle RegNet 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/main/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.RegNetForImageClassification.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/main/src/transformers/models/regnet/modeling_regnet.py#L345)

**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/main/fr/model_doc/convnext#transformers.ConvNextImageProcessor). Voir [ConvNextImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ConvNextImageProcessor](/docs/transformers/main/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/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un [ImageClassifierOutputWithNoAttention](/docs/transformers/main/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 ([RegNetConfig](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetConfig)) et les entrées.

La méthode forward de [RegNetForImageClassification](/docs/transformers/main/fr/model_doc/regnet#transformers.RegNetForImageClassification) 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, RegNetForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = RegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

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