Transformers documentation
Swin Transformer
Ce modèle a été publié dans les papiers HF le 25/03/2021 et a été ajouté à Hugging Face Transformers le 21/01/2022.
Swin Transformer
Swin Transformer est un vision transformer hiérarchique. Les images sont traitées sous forme de patches et une auto-attention par fenêtres est utilisée pour capturer les informations locales. Ces fenêtres sont décalées sur l'image pour permettre des connexions inter-fenêtres, capturant ainsi les informations globales de manière plus efficace. Cette approche hiérarchique avec fenêtres décalées permet au Swin Transformer de traiter efficacement les images à différentes échelles et d'atteindre une complexité computationnelle linéaire par rapport à la taille de l'image, ce qui en fait un backbone polyvalent pour diverses tâches de vision telles que la classification d'images et la détection d'objets.
Vous pouvez trouver tous les points de contrôle officiels de Swin Transformer sous l’organisation Microsoft.
Cliquez sur les modèles Swin Transformer dans la barre latérale droite pour plus d'exemples sur la manière d'appliquer Swin Transformer à différentes tâches d'image.
L'exemple ci-dessous montre comment classifier une image avec Pipeline ou la classe AutoModel.
from transformers import pipeline
pipeline = pipeline(
task="image-classification",
model="microsoft/swin-tiny-patch4-window7-224",
device=0
)
pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")import requests
import torch
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForImageClassification
image_processor = AutoImageProcessor.from_pretrained(
"microsoft/swin-tiny-patch4-window7-224",
use_fast=True,
)
model = AutoModelForImageClassification.from_pretrained(
"microsoft/swin-tiny-patch4-window7-224",
device_map="auto"
)
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = image_processor(image, return_tensors="pt").to(model.device)
with torch.no_grad():
logits = model(**inputs).logits
predicted_class_id = logits.argmax(dim=-1).item()
class_labels = model.config.id2label
predicted_class_label = class_labels[predicted_class_id]
print(f"The predicted class label is: {predicted_class_label}")Notes
- Swin peut effectuer un bourrage des entrées pour toute hauteur et largeur d'entrée divisibles par
32. - Swin peut être utilisé comme backbone. Lorsque
output_hidden_states = True, il renvoie à la foishidden_statesetreshaped_hidden_states. Lesreshaped_hidden_statesont une forme de(batch, num_channels, height, width)plutôt que(batch_size, sequence_length, num_channels).
SwinConfig
classe transformers.SwinConfig
< source >( 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 = Noneimage_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 4num_channels: int = 3embed_dim: int = 96depths: list[int] | tuple[int, ...] = (2, 2, 6, 2)num_heads: list[int] | tuple[int, ...] = (3, 6, 12, 24)window_size: int = 7mlp_ratio: float | int = 4.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'use_absolute_embeddings: bool = Falseinitializer_range: float = 0.02layer_norm_eps: float = 1e-05encoder_stride: int = 32_out_features: list[str] | None = None_out_indices: list[int] | None = None )
Paramètres
- image_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut224) — La taille (résolution) de chaque image. - patch_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut4) — La taille (résolution) de chaque patch. - num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - embed_dim (
int, facultatif, par défaut96) — Dimension des embeddings et des états cachés. - depths (
list(int), facultatif, par défaut[2, 2, 6, 2]) — Profondeur de chaque couche dans l'encodeur Transformer. - num_heads (
list(int), facultatif, par défaut[3, 6, 12, 24]) — Nombre de têtes d'attention dans chaque couche de l'encodeur Transformer. - window_size (
int, facultatif, par défaut 7) — Taille des fenêtres. - mlp_ratio (
Union[float, int], facultatif, par défaut4.0) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding. - qkv_bias (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. - hidden_dropout_prob (
Union[float, int], facultatif, par défaut0.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éfaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - drop_path_rate (
Union[float, int], facultatif, par défaut0.1) — Taux de drop path pour la fusion des patches. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - use_absolute_embeddings (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser des embeddings de position absolue. - initializer_range (
float, facultatif, par défaut0.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éfaut1e-05) — L'épsilon utilisé par les couches de normalisation de couche. - encoder_stride (
int, facultatif, valeur par défaut 32) — Facteur d'augmentation de la résolution spatiale dans la tête du décodeur pour le masquage d'images.
Ceci est la classe de configuration destinée à stocker la configuration d'un SwinModel. Elle est utilisée pour instancier un modèle Swin 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 microsoft/swin-tiny-patch4-window7-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 SwinConfig, SwinModel
>>> # Initializing a Swin microsoft/swin-tiny-patch4-window7-224 style configuration
>>> configuration = SwinConfig()
>>> # Initializing a model (with random weights) from the microsoft/swin-tiny-patch4-window7-224 style configuration
>>> model = SwinModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSwinModel
classe transformers.SwinModel
< source >( config: SwinConfigadd_pooling_layer = Trueuse_mask_token = False )
Paramètres
- config (SwinConfig) — 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éfautTrue) — Indique s'il faut appliquer une couche de pooling. - use_mask_token (
bool, facultatif, valeur par défautFalse) — Indique s'il faut créer et appliquer des jetons de masque dans la couche d'incorporation.
Le modèle Swin 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
< source >( pixel_values: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.BoolTensor] = Noneinterpolate_pos_encoding: bool = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SwinModelOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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_classutilise ViTImageProcessor pour le traitement des images). - bool_masked_pos (
torch.BoolTensorde forme(batch_size, num_patches), facultatif) — Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). - interpolate_pos_encoding (
bool, facultatif, par défautFalse) — Indique s'il faut interpoler les encodages de position pré-entraînés.
Retourne
SwinModelOutput ou tuple(torch.Tensor)
Un SwinModelOutput 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 (SwinConfig) et des entrées.
La méthode forward de SwinModel 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
Moduleplutô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.Tensorde 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.Tensorde forme(batch_size, hidden_size), facultatif, renvoyé lorsqueadd_pooling_layer=Trueest passé) — Pooling moyen de l'état caché de la dernière couche.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
SwinForMaskedImageModeling
classe transformers.SwinForMaskedImageModeling
< source >( config: SwinConfig )
Paramètres
- config (SwinConfig) — 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 Swin avec un décodeur en tête pour la modélisation d'images masquées, tel que proposé dans SimMIM.
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
< source >( pixel_values: typing.Optional[torch.Tensor] = Nonebool_masked_pos: typing.Optional[torch.BoolTensor] = Noneinterpolate_pos_encoding: bool = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SwinMaskedImageModelingOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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_classutilise ViTImageProcessor pour le traitement des images). - bool_masked_pos (
torch.BoolTensorde forme(batch_size, num_patches)) — Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). - interpolate_pos_encoding (
bool, facultatif, par défautFalse) — Indique s'il faut interpoler les encodages de position pré-entraînés.
Retourne
SwinMaskedImageModelingOutput ou tuple(torch.Tensor)
Un SwinMaskedImageModelingOutput 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 (SwinConfig) et des entrées.
La méthode forward de SwinForMaskedImageModeling 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquebool_masked_posest fourni) — Perte de modélisation d'images masquées (MLM).reconstruction (
torch.Tensorde forme(batch_size, num_channels, height, width)) — Valeurs de pixels reconstruites.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
Exemples :
>>> from transformers import AutoImageProcessor, SwinForMaskedImageModeling
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> 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("microsoft/swin-base-simmim-window6-192")
>>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")
>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()
>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 192, 192]SwinForImageClassification
classe transformers.SwinForImageClassification
< source >( config: SwinConfig )
Paramètres
- config (SwinConfig) — 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 Swin doté d'une tête de classification d'images au sommet (une couche linéaire au-dessus de l'état caché final du jeton [CLS]), par exemple pour ImageNet.
Notez qu’il est possible d’affiner Swin sur des images de résolution supérieure à celles utilisées pour son entraînement, en définissant
interpolate_pos_encodingsurTruedans le forward du modèle. Cela permet d’interpoler les embeddings de position pré-entraînés à la résolution supérieure.
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
< source >( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneinterpolate_pos_encoding: bool = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SwinImageClassifierOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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_classutilise ViTImageProcessor pour le traitement des images). - labels (
torch.LongTensorde 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]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - interpolate_pos_encoding (
bool, facultatif, par défautFalse) — Indique s'il faut interpoler les encodages de position pré-entraînés.
Retourne
SwinImageClassifierOutput ou tuple(torch.Tensor)
Un SwinImageClassifierOutput 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 (SwinConfig) et des entrées.
La méthode forward de SwinForImageClassification 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, SwinForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-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])
...