Transformers documentation

MobileViTV2

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2022-06-06 et a été ajouté à Hugging Face Transformers le 2023-06-02.

MobileViTV2

Aperçu

Le modèle MobileViTV2 a été proposé dans Separable Self-attention for Mobile Vision Transformers par Sachin Mehta et Mohammad Rastegari.

MobileViTV2 est la deuxième version de MobileViT, construite en remplaçant l'auto-attention multi-têtes de MobileViT par une auto-attention séparable.

L'abstract de l'article est le suivant :

Les transformeurs de vision mobiles (MobileViT) peuvent atteindre des performances de pointe sur plusieurs tâches de vision mobile, notamment la classification et la détection. Bien que ces modèles comptent moins de paramètres, leur latence est élevée par rapport aux modèles basés sur des réseaux de neurones convolutifs. Le principal goulot d'étranglement d'efficacité dans MobileViT est l'auto-attention multi-têtes (MHA) des transformeurs, qui nécessite une complexité temporelle de O(k2) par rapport au nombre de jetons (ou de patches) k. De plus, le MHA requiert des opérations coûteuses (par exemple, la multiplication de matrices par lot) pour calculer l'auto-attention, ce qui impacte la latence sur les appareils à ressources limitées. Cet article présente une méthode d'auto-attention séparable avec une complexité linéaire, c'est-à-dire O(k). Une caractéristique simple mais efficace de la méthode proposée est qu'elle utilise des opérations élément par élément pour calculer l'auto-attention, ce qui en fait un bon choix pour les appareils à ressources limitées. Le modèle amélioré, MobileViTV2, est de pointe sur plusieurs tâches de vision mobile, y compris la classification d'objets ImageNet et la détection d'objets MS-COCO. Avec environ trois millions de paramètres, MobileViTV2 atteint une précision top-1 de 75,6 % sur le jeu de données ImageNet, surpassant MobileViT d'environ 1 % tout en fonctionnant 3,2× plus vite sur un appareil mobile.

Ce modèle a été contribué par shehan97. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

  • MobileViTV2 ressemble davantage à un CNN qu'à un modèle Transformer. Il ne fonctionne pas sur des données séquentielles mais sur des lots d'images. Contrairement à ViT, il n'y a pas d'embeddings. Le modèle de base (backbone) produit une carte de caractéristiques (feature map).
  • On peut utiliser MobileViTImageProcessor pour préparer les images destinées au modèle. Notez que si vous effectuez votre propre prétraitement, les points de contrôle préentraînés s’attendent à ce que les images soient dans l’ordre de pixels BGR (et non RGB).
  • Les points de contrôle de classification d’images disponibles sont pré-entraînés sur ImageNet-1k (également appelé ILSVRC 2012, un ensemble de 1,3 million d’images et 1 000 classes).
  • Le modèle de segmentation utilise une tête DeepLabV3. Les points de contrôle de segmentation sémantique disponibles sont pré-entraînés sur PASCAL VOC.

MobileViTV2Config

classe transformers.MobileViTV2Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_channels: int = 3image_size: int | list[int] | tuple[int, int] = 256patch_size: int | list[int] | tuple[int, int] = 2expand_ratio: float = 2.0hidden_act: str = 'swish'conv_kernel_size: int = 3output_stride: int = 32classifier_dropout_prob: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05aspp_out_channels: int = 512atrous_rates: list[int] | tuple[int, ...] = (6, 12, 18)aspp_dropout_prob: float | int = 0.1semantic_loss_ignore_index: int = 255n_attn_blocks: list[int] | tuple[int, ...] = (2, 4, 3)base_attn_unit_dims: list[int] | tuple[int, ...] = (128, 192, 256)width_multiplier: float | int = 1.0ffn_multiplier: int = 2attn_dropout: float | int = 0.0ffn_dropout: float | int = 0.0 )

Paramètres

  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • image_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 256) — La taille (résolution) de chaque image.
  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 2) — La taille (résolution) de chaque patch.
  • expand_ratio (float, facultatif, par défaut 2.0) — Ratio d'expansion pour définir les dimensions de sortie de l'expansion
  • hidden_act (str, facultatif, par défaut swish) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • conv_kernel_size (int, facultatif, par défaut 3) — La taille du noyau de convolution.
  • output_stride (int, facultatif, par défaut 32) — Le ratio entre la résolution spatiale des cartes de caractéristiques d'entrée et de sortie.
  • classifier_dropout_prob (Union[float, int], facultatif, valeur par défaut 0.1) — Le taux de dropout pour le classifieur.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • aspp_out_channels (int, facultatif, par défaut 512) — Nombre de canaux de sortie utilisés dans la couche ASPP pour la segmentation sémantique.
  • atrous_rates (list[int], facultatif, par défaut [6, 12, 18]) — Facteurs de dilatation (atrous) utilisés dans la couche ASPP pour la segmentation sémantique.
  • aspp_dropout_prob (float, facultatif, valeur par défaut 0.1) — Taux de dropout de la couche ASPP pour la segmentation sémantique.
  • semantic_loss_ignore_index (int, facultatif, valeur par défaut 255) — L'index ignoré par la fonction de perte du modèle de segmentation sémantique.
  • n_attn_blocks (list[int], facultatif, par défaut [2, 4, 3]) — Le nombre de blocs d'attention dans chaque MobileViTV2Layer
  • base_attn_unit_dims (list[int], facultatif, par défaut [128, 192, 256]) — Le multiplicateur de base pour les dimensions des blocs d'attention dans chaque MobileViTV2Layer
  • width_multiplier (float, facultatif, valeur par défaut 1.0) — Le multiplicateur de largeur pour MobileViTV2.
  • ffn_multiplier (int, facultatif, valeur par défaut 2) — Le multiplicateur FFN pour MobileViTV2.
  • attn_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • ffn_dropout (float, facultatif, valeur par défaut 0.0) — Le dropout entre les couches FFN.

Ceci est la classe de configuration destinée à stocker la configuration d'un MobileViTV2Model. Elle est utilisée pour instancier un modèle Mobilevitv2 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de apple/mobilevitv2-1.0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import MobileViTV2Config, MobileViTV2Model

>>> # Initializing a mobilevitv2-small style configuration
>>> configuration = MobileViTV2Config()

>>> # Initializing a model from the mobilevitv2-small style configuration
>>> model = MobileViTV2Model(configuration)

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

MobileViTV2Model

classe transformers.MobileViTV2Model

< >

( config: MobileViTV2Configexpand_output: bool = True )

Paramètres

  • config (MobileViTV2Config) — 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() pour charger les poids du modèle.
  • expand_output (bool, facultatif, par défaut True) — Indique s'il faut étendre la sortie du modèle. Si True, le modèle sortira des fonctionnalités agrégées en plus des états cachés. Si False, seuls les états cachés seront renvoyés.

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

Ce modèle hérite de 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( pixel_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

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 MobileViTImageProcessor. Voir MobileViTImageProcessor.call() pour plus de détails (processor_class utilise MobileViTImageProcessor 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 sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

BaseModelOutputWithPoolingAndNoAttention ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPoolingAndNoAttention ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (MobileViTV2Config) et des entrées.

La méthode forward du modèle MobileViTV2Model surcharge 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.FloatTensor 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.FloatTensor 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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 :

MobileViTV2ForImageClassification

classe transformers.MobileViTV2ForImageClassification

< >

( config: MobileViTV2Config )

Paramètres

  • config (MobileViTV2Config) — 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() pour charger les poids du modèle.

Modèle MobileViTV2 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( pixel_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → ImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)

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 MobileViTImageProcessor. Voir MobileViTImageProcessor.call() pour plus de détails (processor_class utilise MobileViTImageProcessor 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 sous les tenseurs retournés pour plus de détails.
  • 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).
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

ImageClassifierOutputWithNoAttention ou tuple(torch.FloatTensor)

Un ImageClassifierOutputWithNoAttention ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (MobileViTV2Config) et des entrées.

La méthode forward de MobileViTV2ForImageClassification 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.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de classification (ou de régression si config.num_labels==1).
  • logits (torch.FloatTensor 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.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 (aussi appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

Exemple :

>>> from transformers import AutoImageProcessor, MobileViTV2ForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0")
>>> model = MobileViTV2ForImageClassification.from_pretrained("apple/mobilevitv2-1.0")

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

MobileViTV2ForSemanticSegmentation

classe transformers.MobileViTV2ForSemanticSegmentation

< >

( config: MobileViTV2Config )

Paramètres

  • config (MobileViTV2Config) — 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() pour charger les poids du modèle.

Modèle MobileViTV2 avec une tête de segmentation sémantique au sommet, par exemple pour Pascal VOC.

Ce modèle hérite de 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SemanticSegmenterOutput or tuple(torch.FloatTensor)

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 MobileViTImageProcessor. Voir MobileViTImageProcessor.call() pour plus de détails (processor_class utilise MobileViTImageProcessor pour le traitement des images).
  • labels (torch.LongTensor de forme (batch_size, height, width), facultatif) — Cartes de segmentation sémantique de référence pour le calcul de la perte. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels > 1, une perte de classification est calculée (Cross-Entropy).
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

SemanticSegmenterOutput ou tuple(torch.FloatTensor)

Un SemanticSegmenterOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (MobileViTV2Config) et des entrées.

La méthode forward de MobileViTV2ForSemanticSegmentation surcharge 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.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de classification (ou de régression si config.num_labels==1).

  • logits (torch.FloatTensor de forme (batch_size, config.num_labels, logits_height, logits_width)) — Scores de classification pour chaque pixel.

    Les logits retournés n'ont pas nécessairement la même taille que les pixel_values passés en entrée. Cela permet d'éviter de réaliser deux interpolations et de perdre en qualité lorsqu'un utilisateur doit redimensionner les logits à la taille de l'image d'origine en post-traitement. Vous devez toujours vérifier la forme de vos logits et les redimensionner si nécessaire.

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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, patch_size, hidden_size).

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

  • attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, patch_size, sequence_length).

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

Exemples :

>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch
>>> from PIL import Image
>>> from transformers import AutoImageProcessor, MobileViTV2ForSemanticSegmentation

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")
>>> model = MobileViTV2ForSemanticSegmentation.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")

>>> inputs = image_processor(images=image, return_tensors="pt")

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

>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits
Update on GitHub