Transformers documentation

Transformeur d'attention de voisinage dilaté

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
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-09-29 et ajouté à Hugging Face Transformers le 2022-11-18.

Transformeur d'attention de voisinage dilaté

Aperçu

DiNAT a été proposé dans Dilated Neighborhood Attention Transformer par Ali Hassani et Humphrey Shi.

Il étend NAT en ajoutant un motif d'attention de voisinage dilaté pour capturer le contexte global, et montre des améliorations de performances significatives par rapport à celui-ci.

L'abstract de l'article est le suivant :

Les Transformers deviennent rapidement l'une des architectures d'apprentissage profond les plus largement appliquées à travers les modalités, les domaines et les tâches. En vision, au-delà des efforts en cours sur les Transformers « plain », les Transformers hiérarchiques ont également suscité un intérêt considérable, grâce à leurs performances et à leur intégration aisée dans les cadres existants. Ces modèles emploient typiquement des mécanismes d'attention localisés, tels que l'attention de voisinage glissante (sliding-window Neighborhood Attention, NA) ou l'auto-attention à fenêtre décalée (Shifted Window Self Attention) du Swin Transformer. Bien qu'efficaces pour réduire la complexité quadratique de l'auto-attention, l'attention locale affaiblit deux des propriétés les plus souhaitables de l'auto-attention : la modélisation des dépendances à longue portée et le champ récepteur global. Dans cet article, nous introduisons la Dilated Neighborhood Attention (DiNA), une extension naturelle, flexible et efficace de la NA, capable de capturer un contexte plus global et d'élargir exponentiellement les champs récepteurs sans coût supplémentaire. L'attention locale de la NA et l'attention globale creuse (sparse) de la DiNA se complètent mutuellement ; nous introduisons donc le Dilated Neighborhood Attention Transformer (DiNAT), un nouveau Transformer hiérarchique pour la vision construit sur les deux. Les variantes de DiNAT offrent des améliorations significatives par rapport à des références fortes telles que NAT, Swin et ConvNeXt. Notre grand modèle est plus rapide et devance son équivalent Swin de 1,5 % de box AP en détection d'objets COCO, de 1,3 % de mask AP en segmentation d'instances COCO et de 1,1 % de mIoU en segmentation sémantique ADE20K. Associé à de nouveaux cadres, notre grande variante est le nouveau modèle d'état de l'art en segmentation panoptique sur COCO (58,2 PQ) et ADE20K (48,5 PQ), ainsi qu'en segmentation d'instances sur Cityscapes (44,5 AP) et ADE20K (35,4 AP) (sans données supplémentaires). Il égale également les modèles spécialisés d'état de l'art en segmentation sémantique sur ADE20K (58,2 mIoU) et se classe deuxième sur Cityscapes (84,5 mIoU) (sans données supplémentaires).

drawing Neighborhood Attention with different dilation values. Taken from the original paper.

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

Conseils d'utilisation

DiNAT peut être utilisé comme backbone. Lorsque output_hidden_states = True, il renvoie à la fois hidden_states et reshaped_hidden_states. Les reshaped_hidden_states ont une forme de (batch, num_channels, height, width) plutôt que (batch_size, height, width, num_channels).

Remarques :

  • DiNAT dépend de l’implémentation de Neighborhood Attention et Dilated Neighborhood Attention par NATTEN. Vous pouvez l’installer à l’aide de roues préconstruites pour Linux en consultant shi-labs.com/natten, ou en le compilant sur votre système en exécutant pip install natten. Notez que cette dernière option prendra probablement du temps à compiler. NATTEN ne prend pas encore en charge les appareils Windows.
  • La taille de patch 4 est actuellement la seule prise en charge.

Ressources

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

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.

DinatConfig

classe transformers.DinatConfig

< >

( 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 = Nonepatch_size: int | list[int] | tuple[int, int] = 4num_channels: int = 3embed_dim: int = 64depths: list[int] | tuple[int, ...] = (3, 4, 6, 5)num_heads: list[int] | tuple[int, ...] = (2, 4, 8, 16)kernel_size: int = 7dilations: list | tuple | None = Nonemlp_ratio: float = 3.0qkv_bias: bool = Truehidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0drop_path_rate: float | int = 0.1hidden_act: str = 'gelu'initializer_range: float = 0.02layer_norm_eps: float = 1e-05layer_scale_init_value: float = 0.0_out_features: list[str] | None = None_out_indices: list[int] | None = None )

Paramètres

  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 4) — La taille (résolution) de chaque patch.
  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • embed_dim (int, facultatif, par défaut 64) — Dimension des embeddings et des états cachés.
  • depths (Union[list[int], tuple[int, ...]], facultatif, par défaut (3, 4, 6, 5)) — Profondeur de chaque couche du Transformer.
  • num_heads (Union[list[int], tuple[int, ...]], facultatif, par défaut (2, 4, 8, 16)) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • kernel_size (int, facultatif, par défaut 7) — La taille du noyau de convolution.
  • dilations (list[list[int]], facultatif, par défaut [[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]) — Valeur de dilatation de chaque couche NA de l'encodeur Transformer.
  • mlp_ratio (float, facultatif, par défaut 3.0) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.
  • qkv_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.
  • hidden_dropout_prob (Union[float, int], facultatif, par défaut 0.0) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.
  • attention_probs_dropout_prob (Union[float, int], facultatif, par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • drop_path_rate (Union[float, int], facultatif, par défaut 0.1) — Taux de drop path pour la fusion des patches.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • 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.
  • layer_scale_init_value (float, facultatif, par défaut 0.0) — É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.

Ceci est la classe de configuration permettant de stocker la configuration d'un DinatModel. Elle est utilisée pour instancier un modèle Dinat 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 shi-labs/dinat-mini-in1k-224

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 DinatConfig, DinatModel

>>> # Initializing a Dinat shi-labs/dinat-mini-in1k-224 style configuration
>>> configuration = DinatConfig()

>>> # Initializing a model (with random weights) from the shi-labs/dinat-mini-in1k-224 style configuration
>>> model = DinatModel(configuration)

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

DinatModel

classe transformers.DinatModel

< >

( config: DinatConfigadd_pooling_layer = True )

Paramètres

  • config (DinatConfig) — 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.
  • add_pooling_layer (bool, facultatif, par défaut True) — Indique s'il faut ajouter une couche de pooling

Le modèle Dinat 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_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DinatModelOutput or tuple(torch.Tensor)

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. Voir ViTImageProcessor.call() pour plus de détails (processor_class utilise ViTImageProcessor pour le traitement des images).
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • 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

DinatModelOutput ou tuple(torch.Tensor)

Un DinatModelOutput 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 (DinatConfig) et des entrées.

La méthode forward du DinatModel 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, sequence_length, hidden_size), facultatif) — 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), facultatif, renvoyé lorsque add_pooling_layer=True est passé) — Pooling moyen de l'état caché de la dernière couche.

  • 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, sequence_length, hidden_size).

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

  • 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, sequence_length, 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.

  • reshaped_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 + un pour la sortie de chaque étape) de forme (batch_size, hidden_size, height, width).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux, redimensionnés pour inclure les dimensions spatiales.

Exemple :

DinatForImageClassification

classe transformers.DinatForImageClassification

< >

( config: DinatConfig )

Paramètres

  • config (DinatConfig) — 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.

Transformeur de modèle Dinat avec une tête de classification d'images au sommet (une couche linéaire au sommet de l'état caché final du jeton [CLS]), 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] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DinatImageClassifierOutput or tuple(torch.Tensor)

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. Voir ViTImageProcessor.call() pour plus de détails (processor_class utilise 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_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • 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

DinatImageClassifierOutput ou tuple(torch.Tensor)

Un DinatImageClassifierOutput 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 (DinatConfig) et des entrées.

La méthode forward de DinatForImageClassification 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 couche) de forme (batch_size, sequence_length, hidden_size).

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

  • 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, sequence_length, 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.

  • reshaped_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 + un pour la sortie de chaque étape) de forme (batch_size, hidden_size, height, width).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux, redimensionnés pour inclure les dimensions spatiales.

Exemple :

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("shi-labs/dinat-mini-in1k-224")
>>> model = DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224")

>>> 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])
...
Update on GitHub