# SwiftFormer

## Aperçu

Le modèle SwiftFormer a été proposé dans [SwiftFormer: Efficient Additive Attention for Transformer-based Real-time Mobile Vision Applications](https://huggingface.co/papers/2303.15446) par Abdelrahman Shaker, Muhammad Maaz, Hanoona Rasheed, Salman Khan, Ming-Hsuan Yang, Fahad Shahbaz Khan.

L’article SwiftFormer présente un nouveau mécanisme d’attention additive efficace qui remplace efficacement les opérations de multiplication matricielle quadratique dans le calcul de l’auto-attention par des multiplications élément par élément linéaires. Une série de modèles nommés « SwiftFormer » est construite sur cette base, atteignant des performances de pointe en termes de précision et de vitesse d’inférence mobile. Même leur variante compacte atteint une précision top-1 de 78,5 % sur ImageNet1K avec une latence de seulement 0,8 ms sur iPhone 14, ce qui est plus précis et 2× plus rapide par rapport à MobileViT-v2.

L'abstract de l'article est le suivant :

*L'auto-attention est devenue le choix par défaut pour capturer le contexte global dans diverses applications de vision par ordinateur. Toutefois, sa complexité computationnelle quadratique par rapport à la résolution de l'image limite son utilisation dans les applications en temps réel, en particulier pour le déploiement sur des appareils mobiles aux ressources limitées. Bien que des approches hybrides aient été proposées pour combiner les avantages des convolutions et de l'auto-attention afin d'obtenir un meilleur compromis entre vitesse et précision, les opérations coûteuses de multiplication de matrices dans l'auto-attention restent un goulot d'étranglement. Dans ce travail, nous introduisons un nouveau mécanisme d'attention additive efficace qui remplace efficacement les opérations de multiplication de matrices quadratiques par des multiplications élément par élément linéaires. Notre conception montre que l'interaction clé-valeur peut être remplacée par une couche linéaire sans sacrifier la précision. Contrairement aux méthodes de l'état de l'art antérieures, notre formulation efficace de l'auto-attention permet son utilisation à tous les stades du réseau. En utilisant notre attention additive efficace proposée, nous construisons une série de modèles appelés « SwiftFormer » qui atteint des performances de l'état de l'art en termes de précision et de vitesse d'inférence mobile. Notre variante petite atteint une précision top-1 de 78,5 % sur ImageNet-1K avec une latence de seulement 0,8 ms sur iPhone 14, ce qui est plus précis et 2 fois plus rapide que MobileViT-v2.*

Ce modèle a été contribué par [shehan97](https://huggingface.co/shehan97). Le code d'origine est disponible [ici](https://github.com/Amshaker/SwiftFormer).

## SwiftFormerConfig[[transformers.SwiftFormerConfig]]

#### transformers.SwiftFormerConfig[[transformers.SwiftFormerConfig]]

```python
transformers.SwiftFormerConfig(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, image_size: int | list[int] | tuple[int, int] = 224, num_channels: int = 3, depths: list[int] | tuple[int, ...] = (3, 3, 6, 4), embed_dims: list[int] | tuple[int, ...] = (48, 56, 112, 220), mlp_ratio: int = 4, downsamples: list[bool] | tuple[bool, ...] = (True, True, True, True), hidden_act: str = 'gelu', down_patch_size: int | list[int] | tuple[int, int] = 3, down_stride: int = 2, down_pad: int = 1, drop_path_rate: float | int = 0.0, drop_mlp_rate: float | int = 0.0, drop_conv_encoder_rate: float | int = 0.0, use_layer_scale: bool = True, layer_scale_init_value: float = 1e-05, batch_norm_eps: float = 1e-05)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/swiftformer/configuration_swiftformer.py#L24)

**Paramètres :**

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `224`) : La taille (résolution) de chaque image.

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

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

embed_dims (`list[int]`, *facultatif*, par défaut `[48, 56, 112, 220]`) : La dimension des embeddings à chaque étape

mlp_ratio (`int`, *facultatif*, par défaut `4`) : Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.

downsamples (`list[bool]`, *facultatif*, par défaut `[True, True, True, True]`) : Indique s'il faut sous-échantillonner les entrées entre deux étapes.

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

down_patch_size (`int`, *facultatif*, valeur par défaut : 3) : La taille des patches dans les couches de sous-échantillonnage.

down_stride (`int`, *facultatif*, valeur par défaut : 2) : Le pas des noyaux de convolution dans les couches de sous-échantillonnage.

down_pad (`int`, *facultatif*, valeur par défaut : 1) : Rembourrage dans les couches de sous-échantillonnage.

drop_path_rate (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Taux de drop path pour la fusion des patches.

drop_mlp_rate (`float`, *facultatif*, valeur par défaut 0.0) : Taux de dropout pour le composant MLP de SwiftFormer.

drop_conv_encoder_rate (`float`, *facultatif*, valeur par défaut 0.0) : Taux de dropout pour le composant ConvEncoder de SwiftFormer.

use_layer_scale (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre à l'échelle les sorties des mélangeurs de jetons.

layer_scale_init_value (`float`, *facultatif*, valeur par défaut `1e-05`) : Échelle à utiliser dans les couches d'auto-attention. 0.1 pour les modèles de base, 1e-6 pour les grands modèles. Définir 0 pour désactiver l'échelle de couche.

batch_norm_eps (`float`, *facultatif*, par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation par lot.

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

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 SwiftFormerConfig, SwiftFormerModel

>>> # Initializing a SwiftFormer swiftformer-base-patch16-224 style configuration
>>> configuration = SwiftFormerConfig()

>>> # Initializing a model (with random weights) from the swiftformer-base-patch16-224 style configuration
>>> model = SwiftFormerModel(configuration)

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

## SwiftFormerModel[[transformers.SwiftFormerModel]]

#### transformers.SwiftFormerModel[[transformers.SwiftFormerModel]]

```python
transformers.SwiftFormerModel(config: SwiftFormerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/swiftformer/modeling_swiftformer.py#L405)

**Paramètres :**

config ([SwiftFormerConfig](/docs/transformers/v5.23.0/fr/model_doc/swiftformer#transformers.SwiftFormerConfig)) : 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 Swiftformer 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.SwiftFormerModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = 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/swiftformer/modeling_swiftformer.py#L416)

**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 [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor). Voir [ViTImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) 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 :** `BaseModelOutputWithNoAttention` ou `tuple(torch.Tensor)`

Un `BaseModelOutputWithNoAttention` 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 ([SwiftFormerConfig](/docs/transformers/v5.23.0/fr/model_doc/swiftformer#transformers.SwiftFormerConfig)) et les entrées.

La méthode forward de [SwiftFormerModel](/docs/transformers/v5.23.0/fr/model_doc/swiftformer#transformers.SwiftFormerModel) 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.
- **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
```

## SwiftFormerForImageClassification[[transformers.SwiftFormerForImageClassification]]

#### transformers.SwiftFormerForImageClassification[[transformers.SwiftFormerForImageClassification]]

```python
transformers.SwiftFormerForImageClassification(config: SwiftFormerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/swiftformer/modeling_swiftformer.py#L449)

**Paramètres :**

config ([SwiftFormerConfig](/docs/transformers/v5.23.0/fr/model_doc/swiftformer#transformers.SwiftFormerConfig)) : 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 Swiftformer avec une tête de classification d'images au sommet, 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.SwiftFormerForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/swiftformer/modeling_swiftformer.py#L466)

**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 [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor). Voir [ViTImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [ViTImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/vit#transformers.ViTImageProcessor) 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_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 ([SwiftFormerConfig](/docs/transformers/v5.23.0/fr/model_doc/swiftformer#transformers.SwiftFormerConfig)) et les entrées.

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("MBZUAI/swiftformer-xs")
>>> model = SwiftFormerForImageClassification.from_pretrained("MBZUAI/swiftformer-xs")

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

