# TimmWrapper

## Aperçu

Classe d'aide permettant de charger des modèles timm pour les utiliser avec la bibliothèque transformers et ses autoclasses.

```python
from urllib.request import urlopen

import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForImageClassification

# Load image
image = Image.open(urlopen(
    'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
))

# Load model and image processor
checkpoint = "timm/resnet50.a1_in1k"
image_processor = AutoImageProcessor.from_pretrained(checkpoint)
model = AutoModelForImageClassification.from_pretrained(checkpoint).eval( device_map="auto")

# Preprocess image
inputs = image_processor(image)

# Forward pass
with torch.no_grad():
    logits = model(**inputs).logits

# Get top 5 predictions
top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
```

## Ressources

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

- [Collection de notebooks d'exemples](https://github.com/ariG23498/timm-wrapper-examples) 🌎

> [!TIP]
> Pour un aperçu plus détaillé, veuillez lire le [article de blog officiel](https://huggingface.co/blog/timm-transformers) sur l'intégration de timm.

## TimmWrapperConfig[[transformers.TimmWrapperConfig]]

#### transformers.TimmWrapperConfig[[transformers.TimmWrapperConfig]]

```python
transformers.TimmWrapperConfig(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, architecture: str = 'resnet50', initializer_range: float = 0.02, do_pooling: bool = True, model_args: dict[str, typing.Any] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/configuration_timm_wrapper.py#L31)

**Paramètres :**

architecture (`str`, *facultatif*, valeur par défaut `"resnet50"`) : L'architecture timm à charger.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

do_pooling (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un pooling sur last_hidden_state dans `TimmWrapperModel` ou non.

model_args (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires à passer à la fonction `timm.create_model`. Par exemple, `model_args={"depth": 3}` pour `timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k` afin de créer un modèle avec 3 blocs. La valeur par défaut est `None`.

Ceci est la classe de configuration destinée à stocker la configuration d'un TimmWrapperModel. Elle est utilisée pour instancier un modèle Timm Wrapper 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 [resnet50](https://huggingface.co/resnet50)

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 TimmWrapperModel

>>> # Initializing a timm model
>>> model = TimmWrapperModel.from_pretrained("timm/resnet18.a1_in1k")

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

## TimmWrapperImageProcessor[[transformers.TimmWrapperImageProcessor]]

#### transformers.TimmWrapperImageProcessor[[transformers.TimmWrapperImageProcessor]]

```python
transformers.TimmWrapperImageProcessor(pretrained_cfg: dict[str, typing.Any], architecture: str | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/image_processing_timm_wrapper.py#L38)

**Paramètres :**

pretrained_cfg (`dict[str, Any]`) : La configuration du modèle pré-entraîné utilisée pour résoudre les transformations d'évaluation et d'entraînement.

architecture (`Optional[str]`, *facultatif*) : Nom de l'architecture du modèle.

Classe enveloppe pour les modèles timm destinée à être utilisée dans transformers.

#### prétraiter[[transformers.TimmWrapperImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], return_tensors: str | transformers.utils.generic.TensorType | None = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/image_processing_timm_wrapper.py#L95)

**Paramètres :**

images (`ImageInput`) : Image à prétraiter. Attend une image unique ou un lot d'images

return_tensors (`str` ou `TensorType`, *facultatif*) : Le type de tenseurs à retourner.

Prétraitez une image ou un lot d'images.

## TimmWrapperModel[[transformers.TimmWrapperModel]]

#### transformers.TimmWrapperModel[[transformers.TimmWrapperModel]]

```python
transformers.TimmWrapperModel(config: TimmWrapperConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L163)

Classe enveloppe pour les modèles timm destinés à être utilisés dans transformers.

#### forward[[transformers.TimmWrapperModel.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | list[int] | None = None, return_dict: bool | None = None, do_pooling: bool | None = None, use_cache: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L177)

**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 [TimmWrapperImageProcessor](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor). Voir [TimmWrapperImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [TimmWrapperImageProcessor](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor) pour le traitement des images).

output_attentions (`bool`, *facultatif*) : Indique s'il faut retourner les tenseurs d'attention de toutes les couches d'attention. Non compatible avec les modèles enveloppés par timm.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Non compatible avec les modèles enveloppés par timm.

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.

do_pooling (`bool`, *facultatif*) : Indique s'il faut effectuer un pooling sur `TimmWrapperModel` pour `None` ou non. Si `None` est transmis, la valeur de `do_pooling` issue de la configuration est utilisée.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

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

Un `TimmWrapperModelOutput` 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 ([TimmWrapperConfig](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperConfig)) et les entrées.

La méthode forward de [TimmWrapperModel](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperModel) 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`) -- Le dernier état caché du modèle, en sortie avant l'application de la tête de classification.
- **pooler_output** (`torch.Tensor`, *facultatif*) -- La sortie agrégée dérivée de l'état caché final, le cas échéant.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé si `output_hidden_states=True` est défini ou si `config.output_hidden_states=True`) -- Un tuple contenant les états cachés intermédiaires du modèle à la sortie de chaque couche ou des couches spécifiées.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé si `output_attentions=True` est défini ou si `config.output_attentions=True`.) -- Un tuple contenant les poids d'attention intermédiaires du modèle à la sortie de chaque couche. Remarque : Actuellement, les modèles Timm ne prennent pas en charge la sortie des attentions.

Exemples :
```python
>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModel, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModel.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Get pooled output
>>> pooled_output = outputs.pooler_output

>>> # Get last hidden state
>>> last_hidden_state = outputs.last_hidden_state
```

## TimmWrapperForImageClassification[[transformers.TimmWrapperForImageClassification]]

#### transformers.TimmWrapperForImageClassification[[transformers.TimmWrapperForImageClassification]]

```python
transformers.TimmWrapperForImageClassification(config: TimmWrapperConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L280)

Classe enveloppe pour les modèles timm destinés à être utilisés dans transformers pour la classification d'images.

#### forward[[transformers.TimmWrapperForImageClassification.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/timm_wrapper/modeling_timm_wrapper.py#L303)

**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 [TimmWrapperImageProcessor](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor). Voir [TimmWrapperImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [TimmWrapperImageProcessor](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperImageProcessor) 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 régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

output_attentions (`bool`, *facultatif*) : Indique s'il faut retourner les tenseurs d'attention de toutes les couches d'attention. Non compatible avec les modèles enveloppés par timm.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Non compatible avec les modèles enveloppés par timm.

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. **kwargs : Arguments supplémentaires passés au forward du modèle `timm`.

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

Un [ImageClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) 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 ([TimmWrapperConfig](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperConfig)) et les entrées.

La méthode forward de [TimmWrapperForImageClassification](/docs/transformers/main/fr/model_doc/timm_wrapper#transformers.TimmWrapperForImageClassification) 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, sequence_length, hidden_size)`. États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, patch_size, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :
```python
>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModelForImageClassification, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModelForImageClassification.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # Get top 5 predictions
>>> top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)
```