Transformers documentation
Vision Transformer convolutif (CvT)
Ce modèle a été publié dans HF papers le 2021-03-29 et ajouté à Hugging Face Transformers le 2022-05-18.
Vision Transformer convolutif (CvT)
Convolutional Vision Transformer (CvT) est un modèle qui combine les atouts des réseaux de neurones convolutifs (CNN) et des Vision transformers pour les tâches de vision par ordinateur. Il introduit des couches convolutives dans l'architecture du vision transformer, lui permettant de capturer les motifs locaux dans les images tout en conservant le contexte global fourni par les mécanismes d'auto-attention.
Vous pouvez trouver tous les points de contrôle CvT sous l'organisation Microsoft.
Ce modèle a été contribué par anujunj.
Cliquez sur les modèles CvT dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer CvT à différentes tâches de vision par ordinateur.
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/cvt-13",
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/cvt-13")
model = AutoModelForImageClassification.from_pretrained(
"microsoft/cvt-13",
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}")Ressources
Reportez-vous à cette série de notebooks ViT pour des exemples d’inférence et de fine-tuning sur des jeux de données personnalisés. Remplacez ViTFeatureExtractor et ViTForImageClassification dans ces notebooks par AutoImageProcessor et CvtForImageClassification.
CvtConfig
classe transformers.CvtConfig
< 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 = Nonenum_channels: int = 3patch_sizes: list[int] | tuple[int, ...] = (7, 3, 3)patch_stride: list[int] | tuple[int, ...] = (4, 2, 2)patch_padding: list[int] | tuple[int, ...] = (2, 1, 1)embed_dim: list[int] | tuple[int, ...] = (64, 192, 384)num_heads: list[int] | tuple[int, ...] = (1, 3, 6)depth: list[int] | tuple[int, ...] = (1, 2, 10)mlp_ratio: list[float] | tuple[float, ...] = (4.0, 4.0, 4.0)attention_drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0)drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0)drop_path_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.1)qkv_bias: list[bool] | tuple[bool, ...] = (True, True, True)cls_token: list[bool] | tuple[bool, ...] = (False, False, True)qkv_projection_method: list[str] | tuple[str, ...] = ('dw_bn', 'dw_bn', 'dw_bn')kernel_qkv: list[int] | tuple[int, ...] = (3, 3, 3)padding_kv: list[int] | tuple[int, ...] = (1, 1, 1)stride_kv: list[int] | tuple[int, ...] = (2, 2, 2)padding_q: list[int] | tuple[int, ...] = (1, 1, 1)stride_q: list[int] | tuple[int, ...] = (1, 1, 1)initializer_range: float = 0.02layer_norm_eps: float = 1e-12 )
Paramètres
- num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - patch_sizes (
Union[list[int], tuple[int, ...]], facultatif, par défaut(7, 3, 3)) — Taille des patches à chaque étape du modèle. - patch_stride (
list[int], facultatif, par défaut[4, 2, 2]) — La taille du pas (stride) de l’incorporation de patch (patch embedding) de chaque encodeur. - patch_padding (
list[int], facultatif, par défaut[2, 1, 1]) — La taille du padding de l'embedding de patch de chaque encodeur. - embed_dim (
Union[list[int], tuple[int, ...]], facultatif, par défaut(64, 192, 384)) — Dimension des embeddings et des états cachés. - num_heads (
Union[list[int], tuple[int, ...]], facultatif, par défaut(1, 3, 6)) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - depth (
list[int], facultatif, par défaut[1, 2, 10]) — Le nombre de couches dans chaque bloc d'encodeur. - mlp_ratio (
Union[list[float], tuple[float, ...]], facultatif, valeur par défaut(4.0, 4.0, 4.0)) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding. - attention_drop_rate (
list[float], facultatif, valeur par défaut[0.0, 0.0, 0.0]) — Le taux de dropout appliqué aux probabilités d'attention. - drop_rate (
list[float], facultatif, par défaut[0.0, 0.0, 0.0]) — Le taux de dropout pour les probabilités des embeddings de patch. - drop_path_rate (
Union[list[float], tuple[float, ...]], facultatif, valeur par défaut(0.0, 0.0, 0.1)) — Taux de drop path pour la fusion des patches. - qkv_bias (
Union[list[bool], tuple[bool, ...]], facultatif, valeur par défaut(True, True, True)) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. - cls_token (
list[bool], facultatif, par défaut[False, False, True]) — Indique s'il faut ajouter un jeton de classification à la sortie de chacun des 3 derniers stades. - qkv_projection_method (
list[string], facultatif, par défaut [“dw_bn”, “dw_bn”, “dw_bn”]`) — Méthode de projection pour la requête, la clé et la valeur. Par défaut, il s’agit de convolutions depth-wise avec batch norm. Pour une projection linéaire, utilisez “avg”. - kernel_qkv (
list[int], facultatif, par défaut[3, 3, 3]) — Taille du noyau pour la requête, la clé et la valeur dans la couche d'attention - padding_kv (
list[int], facultatif, par défaut[1, 1, 1]) — Taille du padding pour les clés et les valeurs dans la couche d'attention - stride_kv (
list[int], facultatif, par défaut[2, 2, 2]) — Taille du pas pour les clés et les valeurs dans la couche d'attention - padding_q (
list[int], facultatif, par défaut[1, 1, 1]) — Taille du padding pour la requête dans la couche d'attention - stride_q (
list[int], facultatif, par défaut[1, 1, 1]) — Taille du pas pour la requête dans la couche d'attention - 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-12) — L'épsilon utilisé par les couches de normalisation de couche.
Ceci est la classe de configuration destinée à stocker la configuration d'un CvtModel. Elle est utilisée pour instancier un modèle Cvt 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 microsoft/cvt-13
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 CvtConfig, CvtModel
>>> # Initializing a Cvt msft/cvt style configuration
>>> configuration = CvtConfig()
>>> # Initializing a model (with random weights) from the msft/cvt style configuration
>>> model = CvtModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configCvtModel
classe transformers.CvtModel
< source >( config: CvtConfigadd_pooling_layer = True )
Paramètres
- config (CvtConfig) — 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 ajouter une couche de pooling
Le modèle Cvt 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] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithCLSToken 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 ConvNextImageProcessor. Voir ConvNextImageProcessor.call() pour plus de détails (processor_classutilise ConvNextImageProcessor pour le traitement des images). - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous 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
BaseModelOutputWithCLSToken ou tuple(torch.Tensor)
Un BaseModelOutputWithCLSToken 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 (CvtConfig) et des entrées.
La méthode forward de CvtModel 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.cls_token_value (
torch.Tensorde forme(batch_size, 1, hidden_size)) — Jeton de classification à la sortie de la dernière couche du modèle.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.
CvtForImageClassification
classe transformers.CvtForImageClassification
< source >( config: CvtConfig )
Paramètres
- config (CvtConfig) — 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.
Transformateur Cvt avec 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.
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.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ImageClassifierOutputWithNoAttention 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 ConvNextImageProcessor. Voir ConvNextImageProcessor.call() pour plus de détails (processor_classutilise ConvNextImageProcessor 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). - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous 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
ImageClassifierOutputWithNoAttention ou tuple(torch.Tensor)
Un ImageClassifierOutputWithNoAttention 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 (CvtConfig) et des entrées.
La méthode forward de CvtForImageClassification 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 é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, CvtForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtForImageClassification.from_pretrained("microsoft/cvt-13")
>>> 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])
...