Transformers documentation

LeViT

Transformers

Commencer

Transformers Installation Démarrage rapide

Classes de base

Modèles

Préprocesseurs

Inférence

API Pipeline

Générer l'API

Optimisation

Discuter avec des modèles

Mise en production

Entraînement

Commencer

Personnalisation

Ajustement fin efficace en termes de paramètres

Performance

Entraînement distribué

Matériel

Quantification

Intégrations à l'écosystème

Ressources

API

Classes principales

Modèles

Modèles de texte

Modèles de vision

Modèles audio

Modèles vidéo

Modèles multimodaux

Modèles d'apprentissage par renforcement

Modèles de séries temporelles

Aides internes

Référence

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

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

LeViT

Aperçu

Le modèle LeViT a été proposé dans LeViT: Introducing Convolutions to Vision Transformers par Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervé Jégou, Matthijs Douze. LeViT améliore les performances et l'efficacité du Vision Transformer (ViT) grâce à quelques différences architecturales, telles que des cartes d'activation aux résolutions décroissantes dans les Transformers et l'introduction d'un biais d'attention pour intégrer les informations positionnelles.

L'abstract de l'article est le suivant :

Nous concevons une famille d'architectures de classification d'images qui optimise le compromis entre précision et efficacité dans un régime de haute vitesse. Notre travail exploite les découvertes récentes dans les architectures basées sur l'attention, qui sont compétitives sur le matériel de traitement hautement parallèle. Nous réexaminons les principes issus de la vaste littérature sur les réseaux de neurones convolutifs pour les appliquer aux transformers, en particulier les cartes d'activation aux résolutions décroissantes. Nous introduisons également le biais d'attention, une nouvelle manière d'intégrer les informations positionnelles dans les transformers de vision. En conséquence, nous proposons LeVIT : un réseau de neurones hybride pour la classification d'images à inférence rapide. Nous considérons différentes mesures d'efficacité sur différentes plateformes matérielles, afin de refléter au mieux une large gamme de scénarios d'application. Nos expériences exhaustives valident empiriquement nos choix techniques et montrent qu'ils sont adaptés à la plupart des architectures. Dans l'ensemble, LeViT surpasse significativement les convnets et les transformers de vision existants en ce qui concerne le compromis vitesse/précision. Par exemple, à 80 % de précision top-1 sur ImageNet, LeViT est 5 fois plus rapide qu'EfficientNet sur CPU.

LeViT Architecture. Taken from the original paper.

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

Conseils d'utilisation

Par rapport à ViT, les modèles LeViT utilisent une tête de distillation supplémentaire pour apprendre efficacement d’un modèle enseignant (qui, dans l’article LeViT, est un modèle de type ResNet). La tête de distillation est apprise par rétropropagation sous la supervision d’un modèle de type ResNet. Ils s’inspirent également des réseaux de neurones convolutifs pour utiliser des cartes d’activation aux résolutions décroissantes afin d’augmenter l’efficacité.
Il existe deux façons d’affiner les modèles distillés : soit (1) de manière classique, en plaçant uniquement une tête de prédiction au-dessus de l’état caché final et sans utiliser la tête de distillation, soit (2) en plaçant à la fois une tête de prédiction et une tête de distillation au-dessus de l’état caché final. Dans ce cas, la tête de prédiction est entraînée à l’aide d’une entropie croisée classique entre la prédiction de la tête et l’étiquette de référence, tandis que la tête de prédiction de distillation est entraînée à l’aide d’une distillation dure (entropie croisée entre la prédiction de la tête de distillation et l’étiquette prédite par l’enseignant). Au moment de l’inférence, on prend la prédiction moyenne entre les deux têtes comme prédiction finale. (2) est également appelé « affinement avec distillation », car on s’appuie sur un enseignant qui a déjà été affiné sur le jeu de données en aval. En termes de modèles, (1) correspond à LevitForImageClassification et (2) correspond à LevitForImageClassificationWithTeacher.
Tous les points de contrôle publiés ont été pré-entraînés et affinés uniquement sur ImageNet-1k (également appelé ILSVRC 2012, un ensemble de 1,3 million d'images et de 1 000 classes). Aucune donnée externe n'a été utilisée. Cela contraste avec le modèle ViT original, qui utilisait des données externes comme le jeu de données JFT-300M/Imagenet-21k pour le pré-entraînement.
Les auteurs de LeViT ont publié 5 modèles LeViT entraînés, que vous pouvez directement intégrer dans LevitModel ou LevitForImageClassification. Des techniques telles que l'augmentation de données, l'optimisation et la régularisation ont été utilisées afin de simuler un entraînement sur un jeu de données beaucoup plus volumineux (tandis que seul ImageNet-1k était utilisé pour la pré-formation). Les 5 variantes disponibles sont (toutes entraînées sur des images de taille 224x224) : facebook/levit-128S, facebook/levit-128, facebook/levit-192, facebook/levit-256 et facebook/levit-384. Notez qu'il faut utiliser LevitImageProcessor afin de préparer les images pour le modèle.
LevitForImageClassificationWithTeacher prend actuellement en charge uniquement l'inférence, et non l'entraînement ou l'ajustement fin.
Vous pouvez consulter des notebooks de démonstration concernant l’inférence ainsi que l’ajustement fin sur des données personnalisées ici (il suffit de remplacer ViTImageProcessor par LevitImageProcessor et ViTForImageClassification par LevitForImageClassification ou LevitForImageClassificationWithTeacher).

Ressources

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

Image Classification

LevitForImageClassification est pris en charge par ce notebook.
Voir aussi : Guide de la tâche de classification d'images

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.

LevitConfig

classe transformers.LevitConfig

< 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] = 224num_channels: int = 3kernel_size: int = 3stride: int = 2padding: int = 1patch_size: int | list[int] | tuple[int, int] = 16hidden_sizes: list[int] | tuple[int, ...] = (128, 256, 384)num_attention_heads: list[int] | tuple[int, ...] = (4, 8, 12)depths: list[int] | tuple[int, ...] = (4, 4, 4)key_dim: list[int] | tuple[int, ...] = (16, 16, 16)drop_path_rate: int = 0mlp_ratio: list[int] | tuple[int, ...] = (2, 2, 2)attention_ratio: list[int] | tuple[int, ...] = (2, 2, 2)initializer_range: float = 0.02 )

Paramètres

image_size (Union[int, list[int], tuple[int, int]], facultatif, 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.
kernel_size (int, facultatif, par défaut 3) — La taille du noyau de convolution.
stride (int, facultatif, par défaut 2) — Taille du pas pour les couches de convolution initiales de l'intégration des patches.
padding (int, facultatif, valeur par défaut 1) — Taille du bourrage pour les couches de convolution initiales de l'intégration de patchs.
patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 16) — La taille (résolution) de chaque patch.
hidden_sizes (Union[list[int], tuple[int, ...]], facultatif, par défaut (128, 256, 384)) — Dimension (taille cachée) à chaque étape du modèle.
num_attention_heads (Union[list[int], tuple[int, ...]], facultatif, valeur par défaut (4, 8, 12)) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
depths (Union[list[int], tuple[int, ...]], facultatif, par défaut (4, 4, 4)) — Profondeur de chaque couche du Transformer.
key_dim (list[int], facultatif, par défaut [16, 16, 16]) — La taille de la clé dans chacun des blocs encodeur.
drop_path_rate (int, facultatif, valeur par défaut 0) — Taux de drop path pour la fusion des patches.
mlp_ratio (Union[list[int], tuple[int, ...]], facultatif, par défaut (2, 2, 2)) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.
attention_ratio (list[int], facultatif, par défaut [2, 2, 2]) — Ratio de la taille de la dimension de sortie par rapport à la dimension d'entrée des couches d'attention.
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.

Ceci est la classe de configuration destinée à stocker la configuration d'un LevitModel. Elle est utilisée pour instancier un modèle Levit 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 facebook/levit-128S

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 LevitConfig, LevitModel

>>> # Initializing a LeViT levit-128S style configuration
>>> configuration = LevitConfig()

>>> # Initializing a model (with random weights) from the levit-128S style configuration
>>> model = LevitModel(configuration)

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

LevitImageProcessor

classe transformers.LevitImageProcessor

< source >

( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

Paramètres

do_convert_rgb (bool, kwargs, facultatif, valeur par défaut None) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'shortest_edge' -- 224}) : Définit les dimensions maximales de l'entrée du modèle.
default_to_square (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 224, 'width': 224}) : Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

Construit un processeur d’images LevitImageProcessor.

prétraiter

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
image_like_kwargs (dict[str, Any], facultatif) — Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant que mot-clé ne fonctionne pas. Par exemple, preprocess(images, masks=masks) est l'option recommandée, mais elle peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas, preprocess(images, image_like_inputs={"masks": masks}) peut être utilisé à la place.
do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

Retourne

~image_processing_base.BatchFeature

data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

Prétraitez une image ou un lot d'images.

LevitImageProcessorPil

classe transformers.LevitImageProcessorPil

< source >

( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

Paramètres

do_convert_rgb (bool, kwargs, facultatif, valeur par défaut None) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'shortest_edge' -- 224}) : Définit les dimensions maximales de l'entrée du modèle.
default_to_square (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 224, 'width': 224}) : Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

Construit un processeur d’images LevitImageProcessor.

prétraiter

< source >

Paramètres

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
image_like_kwargs (dict[str, Any], facultatif) — Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant que mot-clé ne fonctionne pas. Par exemple, preprocess(images, masks=masks) est l'option recommandée, mais elle peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas, preprocess(images, image_like_inputs={"masks": masks}) peut être utilisé à la place.
do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

Retourne

~image_processing_base.BatchFeature

data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

Prétraitez une image ou un lot d'images.

LevitModel

classe transformers.LevitModel

< source >

( config: LevitConfig )

Paramètres

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

Le modèle Levit 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 ) → BaseModelOutputWithPoolingAndNoAttention 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 LevitImageProcessor. Voir LevitImageProcessor.call() pour plus de détails (processor_class utilise LevitImageProcessor 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.Tensor)

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

La méthode forward du modèle LevitModel 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.
pooler_output (torch.Tensor 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.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 :

LevitForImageClassification

classe transformers.LevitForImageClassification

< source >

( config: LevitConfig )

Paramètres

config (LevitConfig) — 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 Levit 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.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ImageClassifierOutputWithNoAttention 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 LevitImageProcessor. Voir LevitImageProcessor.call() pour plus de détails (processor_class utilise LevitImageProcessor 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 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

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

La méthode forward de LevitForImageClassification 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 (aussi appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

Exemple :

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/levit-128S")
>>> model = LevitForImageClassification.from_pretrained("facebook/levit-128S")

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

LevitForImageClassificationWithTeacher

classe transformers.LevitForImageClassificationWithTeacher

< source >

( config: LevitConfig )

Paramètres

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

LeViT Transformeur de modèle avec des têtes de classification d'images au sommet (une couche linéaire au sommet de l'état caché final et une couche linéaire au sommet de l'état caché final du jeton de distillation), par exemple pour ImageNet. .. warning:: Ce modèle prend en charge uniquement l'inférence. L'ajustement fin avec distillation (c'est-à-dire avec un enseignant) n'est pas encore pris en charge.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LevitForImageClassificationWithTeacherOutput 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 LevitImageProcessor. Voir LevitImageProcessor.call() pour plus de détails (processor_class utilise LevitImageProcessor 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

LevitForImageClassificationWithTeacherOutput ou tuple(torch.Tensor)

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

La méthode forward de LevitForImageClassificationWithTeacher 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.

logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de prédiction sous forme de moyenne des cls_logits et des distillation_logits.
cls_logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de prédiction de la tête de classification (c’est-à-dire la couche linéaire au-dessus de l’état caché final du jeton de classe).
distillation_logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de prédiction de la tête de distillation (c'est-à-dire la couche linéaire au-dessus de l'état caché final du jeton de distillation).
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.

Exemple :

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/levit-128S")
>>> model = LevitForImageClassificationWithTeacher.from_pretrained("facebook/levit-128S")

>>> 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

←ImageGPT LightGlue→