Transformers documentation
Mask2Former
Ce modèle a été publié dans HF papers le 2021-12-02 et ajouté à Hugging Face Transformers le 2023-01-16.
Mask2Former
Aperçu
Le modèle Mask2Former a été proposé dans Masked-attention Mask Transformer for Universal Image Segmentation par Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar. Mask2Former est un cadre unifié pour la segmentation panoptique, d’instances et sémantique, et présente des améliorations significatives en termes de performances et d’efficacité par rapport à MaskFormer.
L'abstract de l'article est le suivant :
La segmentation d’images regroupe des pixels selon des sémantiques différentes, par exemple l’appartenance à une catégorie ou à une instance. Chaque choix de sémantique définit une tâche. Bien que seules les sémantiques de chaque tâche diffèrent, les recherches actuelles se concentrent sur la conception d’architectures spécialisées pour chaque tâche. Nous présentons Masked-attention Mask Transformer (Mask2Former), une nouvelle architecture capable de traiter toute tâche de segmentation d’images (panoptique, d’instances ou sémantique). Ses composants clés incluent l’attention masquée, qui extrait des fonctionnalités localisées en contraignant l’attention croisée à l’intérieur des régions de masque prédites. En plus de réduire l’effort de recherche d’au moins trois fois, elle surpasse de loin les meilleures architectures spécialisées sur quatre jeux de données populaires. Plus remarquablement, Mask2Former établit un nouvel état de l’art pour la segmentation panoptique (57,8 PQ sur COCO), la segmentation d’instances (50,1 AP sur COCO) et la segmentation sémantique (57,7 mIoU sur ADE20K).
Mask2Former architecture. Taken from the original paper. Ce modèle a été contribué par Shivalika Singh et Alara Dirik. Le code d'origine peut être trouvé ici.
Conseils d'utilisation
- Mask2Former utilise les mêmes étapes de prétraitement et de post-traitement que MaskFormer. Utilisez Mask2FormerImageProcessor ou AutoImageProcessor pour préparer les images et les cibles facultatives pour le modèle.
- Pour obtenir la segmentation finale, selon la tâche, vous pouvez appeler post_process_semantic_segmentation() ou post_process_instance_segmentation() ou post_process_panoptic_segmentation(). Les trois tâches peuvent être résolues à l'aide de la sortie de Mask2FormerForUniversalSegmentation, la segmentation panoptique acceptant un argument facultatif
label_ids_to_fusepour fusionner les instances de l'objet cible (par exemple, le ciel).
Ressources
Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec Mask2Former.
- Des notebooks de démonstration concernant l'inférence et l'ajustement fin de Mask2Former sur des données personnalisées sont disponibles ici.
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.
Mask2FormerConfig
classe transformers.Mask2FormerConfig
< 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 = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefeature_size: int = 256mask_feature_size: int = 256hidden_dim: int = 256encoder_feedforward_dim: int = 1024activation_function: str = 'relu'encoder_layers: int = 6decoder_layers: int = 10num_attention_heads: int = 8dropout: float | int = 0.0dim_feedforward: int = 2048pre_norm: bool = Falseenforce_input_projection: bool = Falsecommon_stride: int = 4ignore_value: int = 255num_queries: int = 100no_object_weight: float = 0.1class_weight: float = 2.0mask_weight: float = 5.0dice_weight: float = 5.0train_num_points: int = 12544oversample_ratio: float = 3.0importance_sample_ratio: float = 0.75init_std: float = 0.02init_xavier_std: float = 1.0use_auxiliary_loss: bool = Truefeature_strides: list[int] | tuple[int, ...] = (4, 8, 16, 32)output_auxiliary_logits: bool | None = None )
Paramètres
- backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone. - feature_size (
int, facultatif, par défaut 256) — Les caractéristiques (canaux) des cartes de caractéristiques résultantes. - mask_feature_size (
int, facultatif, valeur par défaut 256) — La taille des caractéristiques des masques. Cette valeur est également utilisée pour spécifier la taille des caractéristiques du Feature Pyramid Network. - hidden_dim (
int, facultatif, par défaut256) — Dimension des représentations cachées. - encoder_feedforward_dim (
int, facultatif, valeur par défaut 1024) — Dimension du réseau feedforward de l'encodeur de deformable detr utilisé dans le cadre du décodeur de pixels. - activation_function (
str, facultatif, par défautrelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple,"gelu","relu","silu", etc. - encoder_layers (
int, facultatif, valeur par défaut6) — Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - decoder_layers (
int, facultatif, valeur par défaut10) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - num_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - dropout (
Union[float, int], facultatif, par défaut0.0) — Le taux appliqué à toutes les couches de dropout. - dim_feedforward (
int, facultatif, valeur par défaut 2048) — Dimension des caractéristiques dans le réseau feedforward du décodeur de transformer. - pre_norm (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser pre-LayerNorm ou non pour le décodeur du transformer. - enforce_input_projection (
bool, facultatif, valeur par défautFalse) — Indique s'il faut ajouter une convolution de projection d'entrée 1x1, même si les canaux d'entrée et la dimension cachée sont identiques dans le décodeur Transformer. - common_stride (
int, facultatif, valeur par défaut 4) — Paramètre utilisé pour déterminer le nombre de niveaux FPN utilisés dans le cadre du décodeur de pixels. - ignore_value (
int, facultatif, valeur par défaut 255) — Identifiant de catégorie à ignorer pendant l’entraînement. - num_queries (
int, facultatif, valeur par défaut 100) — Nombre de requêtes pour le décodeur. - no_object_weight (
float, facultatif, valeur par défaut0.1) — Poids de classification relatif de la classe sans objet dans la perte de détection d'objets. - class_weight (
float, facultatif, par défaut2.0) — Poids relatif de l'erreur de classification dans le coût d'appariement hongrois. - mask_weight (
float, facultatif, valeur par défaut5.0) — Poids relatif de la perte focale dans la perte de segmentation panoptique. - dice_weight (
float, facultatif, par défaut5.0) — Poids relatif de la perte dice dans la perte de segmentation panoptique. - train_num_points (
stroufunction, facultatif, valeur par défaut 12544) — Nombre de points utilisés pour l'échantillonnage lors du calcul de la perte. - oversample_ratio (
float, facultatif, valeur par défaut 3.0) — Paramètre de suréchantillonnage utilisé pour le calcul du nombre de points échantillonnés - importance_sample_ratio (
float, facultatif, valeur par défaut 0.75) — Ratio de points échantillonnés par échantillonnage d'importance. - init_std (
float, facultatif, valeur par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - init_xavier_std (
float, facultatif, valeur par défaut1.0) — Le facteur d'échelle utilisé pour l'initialisation de Xavier des poids de l'attention croisée. - use_auxiliary_loss (
bool, facultatif, valeur par défautTrue) — Indique s'il faut calculer la perte en utilisant les prédictions intermédiaires du décodeur du transformer. - feature_strides (
list[int], facultatif, par défaut[4, 8, 16, 32]) — Pas des caractéristiques correspondant aux caractéristiques générées par le réseau backbone. - output_auxiliary_logits (
bool, facultatif) — Indique si le modèle doit ou non retourner sesauxiliary_logits.
Ceci est la classe de configuration destinée à stocker la configuration d'un Mask2FormerModel. Elle est utilisée pour instancier un modèle Mask2Former 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/mask2former-swin-small-coco-instance
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.
Exemples :
>>> from transformers import Mask2FormerConfig, Mask2FormerModel
>>> # Initializing a Mask2Former facebook/mask2former-swin-small-coco-instance configuration
>>> configuration = Mask2FormerConfig()
>>> # Initializing a model (with random weights) from the facebook/mask2former-swin-small-coco-instance style configuration
>>> model = Mask2FormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSorties spécifiques à MaskFormer
classe transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput
< source >( encoder_last_hidden_state: typing.Optional[torch.Tensor] = Nonepixel_decoder_last_hidden_state: typing.Optional[torch.Tensor] = Nonetransformer_decoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor] | None = Nonepixel_decoder_hidden_states: tuple[torch.Tensor] | None = Nonetransformer_decoder_hidden_states: tuple[torch.Tensor] | None = Nonetransformer_decoder_intermediate_states: tuple[torch.Tensor] | None = Nonemasks_queries_logits: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = None )
Paramètres
- encoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width), facultatif) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle encodeur (backbone). Renvoyé lorsqueoutput_hidden_states=Trueest passé. - pixel_decoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width), facultatif) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle de décodeur de pixels. - transformer_decoder_last_hidden_state (
tuple(torch.Tensor)) — Sortie finale du décodeur transformer(batch_size, sequence_length, hidden_size). - encoder_hidden_states (
tuple(torch.Tensor), facultatif) — Tuplet detorch.Tensor(un pour la sortie des embeddings + 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 encodeur à la sortie de chaque étape. Renvoyé lorsqueoutput_hidden_states=Trueest passé. - pixel_decoder_hidden_states (
tuple(torch.Tensor), , facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme(batch_size, num_channels, height, width). États cachés (également appelés cartes de caractéristiques) du modèle de décodeur de pixels à la sortie de chaque étape. Renvoyé lorsqueoutput_hidden_states=Trueest passé. - transformer_decoder_hidden_states (
tuple(torch.Tensor), facultatif) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme(batch_size, sequence_length, hidden_size). États cachés (aussi appelés cartes de caractéristiques) du décodeur transformer à la sortie de chaque étape. Renvoyé lorsqueoutput_hidden_states=Trueest passé. - transformer_decoder_intermediate_states (
tuple(torch.Tensor)de forme(num_queries, 1, hidden_size)) — Activations intermédiaires du décodeur, c'est-à-dire la sortie de chaque couche du décodeur, chacune ayant passé par une layernorm. - masks_queries_logits (
tuple(torch.Tensor)de forme(batch_size, num_queries, height, width)) — Prédictions de masques de chaque couche du décodeur du transformer. - attentions (
tuple(tuple(torch.Tensor)), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé) — Tuplet detuple(torch.Tensor)(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids d'auto-attention du décodeur du transformer. - 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.
Classe pour les sorties de Mask2FormerModel. Cette classe renvoie tous les états cachés nécessaires pour calculer les logits.
classe transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneclass_queries_logits: typing.Optional[torch.Tensor] = Nonemasks_queries_logits: typing.Optional[torch.Tensor] = Noneauxiliary_logits: list[dict[str, torch.Tensor]] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Nonepixel_decoder_last_hidden_state: typing.Optional[torch.Tensor] = Nonetransformer_decoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor] | None = Nonepixel_decoder_hidden_states: tuple[torch.Tensor] | None = Nonetransformer_decoder_hidden_states: typing.Optional[torch.Tensor] = Noneattentions: tuple[torch.Tensor] | None = None )
Paramètres
- loss (
torch.Tensor, facultatif) — La perte calculée, renvoyée lorsque des étiquettes sont présentes. - class_queries_logits (
torch.Tensor, facultatif) — Un tenseur de forme(batch_size, num_queries, num_labels + 1)représentant les classes proposées pour chaque requête. Notez que le+ 1est nécessaire car nous intégrons la classe nulle. - masks_queries_logits (
torch.Tensor, facultatif) — Un tenseur de forme(batch_size, num_queries, height, width)représentant les masques proposés pour chaque requête. - auxiliary_logits (
list[Dict(str, torch.Tensor)], facultatif) — Liste des prédictions de classes et de masques issues de chaque couche du décodeur du transformer. - encoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width)) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle encodeur (backbone). - pixel_decoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width)) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle de décodeur de pixels. - transformer_decoder_last_hidden_state (
tuple(torch.Tensor)) — Sortie finale du décodeur transformer(batch_size, sequence_length, hidden_size). - encoder_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, num_channels, height, width). États cachés (également appelés feature maps) du modèle encodeur à la sortie de chaque étape. - pixel_decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme(batch_size, num_channels, height, width). États cachés (également appelés cartes de caractéristiques) du modèle de décodeur de pixels à la sortie de chaque étape. - transformer_decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuplet detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme(batch_size, sequence_length, hidden_size). États cachés (également appelés cartes de caractéristiques) du décodeur transformer à la sortie de chaque étape. - attentions (
tuple(tuple(torch.Tensor)), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftuple(torch.Tensor)(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length). Self and Cross Attentions weights from transformer decoder.
Classe pour les sorties de Mask2FormerForUniversalSegmentationOutput.
Cette sortie peut être transmise directement à post_process_semantic_segmentation() ou post_process_instance_segmentation() ou post_process_panoptic_segmentation() pour calculer les cartes de segmentation finales. Veuillez consulter [`~Mask2FormerImageProcessor] pour plus de détails sur l’utilisation.
Mask2FormerModel
classe transformers.Mask2FormerModel
< source >( config: Mask2FormerConfig )
Paramètres
- config (Mask2FormerConfig) — 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 Mask2Former 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: Tensorpixel_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Mask2FormerModelOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de Mask2FormerImageProcessor. Voir Mask2FormerImageProcessor.call() pour plus de détails (processor_classutilise Mask2FormerImageProcessor pour le traitement des images). - pixel_mask (
torch.Tensorde forme(batch_size, height, width), facultatif) — Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans[0, 1]:- 1 pour les pixels réels (c.-à-d. non masqués),
- 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).
- 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. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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
Mask2FormerModelOutput ou tuple(torch.Tensor)
Un Mask2FormerModelOutput 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 (Mask2FormerConfig) et des entrées.
La méthode forward de Mask2FormerModel surcharge la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
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.
encoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width), facultatif) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle encodeur (backbone). Renvoyé lorsqueoutput_hidden_states=Trueest passé.pixel_decoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width), facultatif) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle de décodeur de pixels.transformer_decoder_last_hidden_state (
tuple(torch.Tensor)) — Sortie finale du décodeur transformer(batch_size, sequence_length, hidden_size).encoder_hidden_states (
tuple(torch.Tensor), facultatif) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme(batch_size, num_channels, height, width). États cachés (aussi appelés feature maps) du modèle encodeur à la sortie de chaque étape. Renvoyé lorsqueoutput_hidden_states=Trueest passé.pixel_decoder_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, num_channels, height, width). États cachés (également appelés cartes de caractéristiques) du modèle de décodeur de pixels à la sortie de chaque étape. Renvoyé lorsqueoutput_hidden_states=Trueest passé.transformer_decoder_hidden_states (
tuple(torch.Tensor), facultatif) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme(batch_size, sequence_length, hidden_size). États cachés (aussi appelés cartes de caractéristiques) du décodeur transformer à la sortie de chaque étape. Renvoyé lorsqueoutput_hidden_states=Trueest passé.transformer_decoder_intermediate_states (
tuple(torch.Tensor)de forme(num_queries, 1, hidden_size)) — Activations intermédiaires du décodeur, c'est-à-dire la sortie de chaque couche du décodeur, chacune ayant passé par une layernorm.masks_queries_logits (
tuple(torch.Tensor)de forme(batch_size, num_queries, height, width)) Prédictions de masques de chaque couche du décodeur transformer. attentions (tuple(tuple(torch.Tensor)), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé) — Tuple detuple(torch.Tensor)(un pour chaque couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids d'auto-attention du décodeur transformer.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.
Mask2FormerForUniversalSegmentation
classe transformers.Mask2FormerForUniversalSegmentation
< source >( config: Mask2FormerConfig )
Paramètres
- config (Mask2FormerConfig) — 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 Mask2Former avec des têtes en haut pour la segmentation par instance/sémantique/panoptique.
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: Tensormask_labels: list[torch.Tensor] | None = Noneclass_labels: list[torch.Tensor] | None = Nonepixel_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_auxiliary_logits: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Mask2FormerForUniversalSegmentationOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de Mask2FormerImageProcessor. Voir Mask2FormerImageProcessor.call() pour plus de détails (processor_classutilise Mask2FormerImageProcessor pour le traitement des images). - mask_labels (
list[torch.Tensor], facultatif) — Liste d'étiquettes de masque de forme(num_labels, height, width)à fournir à un modèle - class_labels (
list[torch.LongTensor], facultatif) — liste des étiquettes de classes cibles de forme(num_labels, height, width)à fournir à un modèle. Elles identifient les étiquettes demask_labels, par exemple l'étiquette demask_labels[i][j]siclass_labels[i][j]. - pixel_mask (
torch.Tensorde forme(batch_size, height, width), facultatif) — Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans[0, 1]:- 1 pour les pixels réels (c.-à-d. non masqués),
- 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).
- 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. - output_auxiliary_logits (
bool, facultatif) — Indique s'il faut ou non afficher les logits auxiliaires. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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
Mask2FormerForUniversalSegmentationOutput ou tuple(torch.Tensor)
Un Mask2FormerForUniversalSegmentationOutput 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 (Mask2FormerConfig) et des entrées.
La méthode forward de Mask2FormerForUniversalSegmentation surcharge la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
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.Tensor, facultatif) — La perte calculée, renvoyée lorsque des étiquettes sont présentes. - class_queries_logits (
torch.Tensor, facultatif) — Un tenseur de forme(batch_size, num_queries, num_labels + 1)représentant les classes proposées pour chaque requête. Notez que le+ 1est nécessaire car nous intégrons la classe nulle. - masks_queries_logits (
torch.Tensor, facultatif) — Un tenseur de forme(batch_size, num_queries, height, width)représentant les masques proposés pour chaque requête. - auxiliary_logits (
list[Dict(str, torch.Tensor)], facultatif) — Liste des prédictions de classes et de masques issues de chaque couche du décodeur du transformer. - encoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width)) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle encodeur (backbone). - pixel_decoder_last_hidden_state (
torch.Tensorde forme(batch_size, num_channels, height, width)) — Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle de décodeur de pixels. - transformer_decoder_last_hidden_state (
tuple(torch.Tensor)) — Sortie finale du décodeur transformer(batch_size, sequence_length, hidden_size). - encoder_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, num_channels, height, width). États cachés (également appelés cartes de caractéristiques) du modèle encodeur à la sortie de chaque étape. - pixel_decoder_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, num_channels, height, width). États cachés (également appelés cartes de caractéristiques) du modèle de décodeur de pixels à la sortie de chaque étape. - transformer_decoder_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, sequence_length, hidden_size). États cachés (également appelés cartes de caractéristiques) du décodeur transformer à la sortie de chaque étape. - attentions (
tuple(tuple(torch.Tensor)), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detuple(torch.Tensor)(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids des attentions auto et croisées du décodeur du transformer.
Exemples :
Exemple de segmentation d'instances :
>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch
>>> # Load Mask2Former trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
... "facebook/mask2former-swin-small-coco-instance"
... )
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits
>>> # Perform post-processing to get instance segmentation map
>>> pred_instance_map = image_processor.post_process_instance_segmentation(
... outputs, target_sizes=[(image.height, image.width)]
... )[0]
>>> print(pred_instance_map.shape)
torch.Size([480, 640])Exemple de segmentation sémantique :
>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch
>>> # Load Mask2Former trained on ADE20k semantic segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-ade-semantic")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained("facebook/mask2former-swin-small-ade-semantic")
>>> url = (
... "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
... )
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits
>>> # Perform post-processing to get semantic segmentation map
>>> pred_semantic_map = image_processor.post_process_semantic_segmentation(
... outputs, target_sizes=[(image.height, image.width)]
... )[0]
>>> print(pred_semantic_map.shape)
torch.Size([512, 683])Exemple de segmentation panoptique :
>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch
>>> # Load Mask2Former trained on CityScapes panoptic segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-cityscapes-panoptic")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
... "facebook/mask2former-swin-small-cityscapes-panoptic"
... )
>>> url = "https://huggingface.co/static-proxy/cdn-media.huggingface.co/Inference-API/Sample-results-on-the-Cityscapes-dataset-The-above-images-show-how-our-method-can-handle.png"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits
>>> # Perform post-processing to get panoptic segmentation map
>>> pred_panoptic_map = image_processor.post_process_panoptic_segmentation(
... outputs, target_sizes=[(image.height, image.width)]
... )[0]["segmentation"]
>>> print(pred_panoptic_map.shape)
torch.Size([338, 676])Mask2FormerImageProcessor
classe transformers.Mask2FormerImageProcessor
< source >( **kwargs: *<class 'transformers.models.mask2former.image_processing_mask2former.Mask2FormerImageProcessorKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — 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' -- 800, 'longest_edge': 1333}) : Définit les dimensions maximales de l'entrée du modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautFalse) — 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) — Taille de l'image de sortie après application decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — 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 sido_normalizeest défini surTrue. - 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 sido_normalizeest défini surTrue. - 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 (
SizeDict, kwargs, facultatif) — La taille à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de toute image fournie pour le prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et à la largeur les plus grandes du lot. - 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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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. - ignore_index (
int, kwargs, facultatif) — Étiquette à attribuer aux pixels d'arrière-plan dans les cartes de segmentation. Si fourni, les pixels de la carte de segmentation désignés par 0 (arrière-plan) seront remplacés parignore_index. - do_reduce_labels (
bool, kwargs, facultatif, valeur par défautFalse) — Indique s'il faut décrémenter de 1 toutes les valeurs des étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par exemple ADE20k). L'étiquette d'arrière-plan sera remplacée parignore_index. - num_labels (
int, kwargs, facultatif) — Le nombre d'étiquettes dans la carte de segmentation. - size_divisor (
int, kwargs, facultatif, valeur par défaut32) — Certains backbones nécessitent des images divisibles par un certain nombre. S'il n'est pas fourni, la valeur par défaut est celle utilisée dans Swin Transformer.
Construit un processeur d’images Mask2FormerImageProcessor.
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']]segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneinstance_id_to_semantic_id: list[dict[int, int]] | dict[int, int] | None = None**kwargs: *<class 'transformers.models.mask2former.image_processing_mask2former.Mask2FormerImageProcessorKwargs'> ) → ~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éfinissezdo_rescale=False. - segmentation_maps (
ImageInput, facultatif) — Les cartes de segmentation. - instance_id_to_semantic_id (
Union[list[dict[int, int]], dict[int, int]], facultatif) — Une correspondance entre les identifiants d’instance et les identifiants sémantiques. - 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 decenter_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’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - 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 sido_rescaleest défini surTrue. - 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 sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - 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 (
SizeDict, kwargs, facultatif) — La taille à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de toute image fournie pour le prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et à la largeur les plus grandes du lot. - 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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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. - ignore_index (
int, kwargs, facultatif) — Étiquette à attribuer aux pixels d'arrière-plan dans les cartes de segmentation. Si fourni, les pixels de la carte de segmentation désignés par 0 (arrière-plan) seront remplacés parignore_index. - do_reduce_labels (
bool, kwargs, facultatif, valeur par défautFalse) — Indique s'il faut décrémenter de 1 toutes les valeurs des étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par exemple ADE20k). L'étiquette d'arrière-plan sera remplacée parignore_index. - num_labels (
int, kwargs, facultatif) — Le nombre d'étiquettes dans la carte de segmentation. - size_divisor (
int, kwargs, facultatif, valeur par défaut32) — Certains backbones nécessitent des images divisibles par un certain nombre. S'il n'est pas fourni, la valeur par défaut est celle utilisée dans Swin Transformer.
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.
post_process_semantic_segmentation
< source >( outputstarget_sizes: list[tuple[int, int]] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Paramètres
- outputs (Mask2FormerForUniversalSegmentation) — Sorties brutes du modèle.
- target_sizes (
list[tuple[int, int]], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si laissé à None, les prédictions ne seront pas redimensionnées. - return_segmentation_scores (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. SiTrue, chaque élément de la liste retournée est unSemanticSegmentationPostProcessorOutputavec les champssegmentation(IDs de classes, forme(height, width)) etsegmentation_scores(forme(num_classes, height, width)).
Retourne
list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]
Lorsque
return_segmentation_scores=False (par défaut), une liste de longueur batch_size où chaque élément est une
carte de segmentation de forme (height, width) avec des identifiants de classes. Lorsque return_segmentation_scores=True,
une liste de SemanticSegmentationPostProcessorOutput avec les champs segmentation (identifiants de classes, forme
(height, width)) et segmentation_scores (forme (num_classes, height, width)). Dans les deux cas,
(height, width) correspond à la taille cible (si target_sizes est spécifiée).
Convertit la sortie de Mask2FormerForUniversalSegmentation en cartes de segmentation sémantique. Prend uniquement en charge PyTorch.
post_process_instance_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8target_sizes: list[tuple[int, int]] | None = Nonereturn_coco_annotation: bool | None = Falsereturn_binary_maps: bool | None = False ) → List[Dict]
Paramètres
- outputs (Mask2FormerForUniversalSegmentation) — Sorties brutes du modèle.
- threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - target_sizes (
List[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (Tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si laissé à None, les prédictions ne seront pas redimensionnées. - return_coco_annotation (
bool, facultatif, par défautFalse) — Si défini surTrue, les cartes de segmentation sont renvoyées au format d'encodage par longueur de course (RLE) de COCO. - return_binary_maps (
bool, facultatif, par défautFalse) — Si défini surTrue, les cartes de segmentation sont renvoyées sous forme de tenseur concaténé de cartes de segmentation binaires (une par instance détectée).
Retourne
List[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — Un tenseur de forme
(height, width)où chaque pixel représente unsegment_id, ouList[List]encodage par longueur d'exécution (RLE) de la carte de segmentation si return_coco_annotation est défini surTrue, ou un tenseur de forme(num_instances, height, width)si return_binary_maps est défini surTrue. Défini surNonesi aucun masque n'est trouvé au-dessus dethreshold. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — Un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — Un entier représentant le
Convertit la sortie de Mask2FormerForUniversalSegmentationOutput en prédictions de segmentation d’instances.
Prend uniquement en charge PyTorch. Si les instances peuvent se chevaucher, définissez return_coco_annotation ou return_binary_maps
sur True pour obtenir le résultat de segmentation correct.
post_process_panoptic_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8label_ids_to_fuse: set[int] | None = Nonetarget_sizes: list[tuple[int, int]] | None = None ) → List[Dict]
Paramètres
- outputs (
Mask2FormerForUniversalSegmentationOutput) — Les sorties de Mask2FormerForUniversalSegmentation. - threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - label_ids_to_fuse (
Set[int], facultatif) — Les étiquettes de cet état verront toutes leurs instances fusionnées ensemble. Par exemple, on peut considérer qu’une image ne peut contenir qu’un seul ciel, mais plusieurs personnes ; l’identifiant de l’étiquette « sky » serait donc présent dans cet ensemble, mais pas celui de « person ». - target_sizes (
List[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (Tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction du lot. Si laissé à None, les prédictions ne seront pas redimensionnées.
Retourne
List[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — un tenseur de forme
(height, width)où chaque pixel représente unsegment_id, défini àNonesi aucun masque n'est trouvé au-dessus dethreshold. Sitarget_sizesest spécifié, la segmentation est redimensionnée à l'entrée correspondante detarget_sizes. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - was_fused — un booléen,
Truesilabel_idétait danslabel_ids_to_fuse,Falsesinon. Plusieurs instances de la même classe / étiquette ont été fusionnées et ont reçu un uniquesegment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — un entier représentant le
Convertit la sortie de Mask2FormerForUniversalSegmentationOutput en prédictions de segmentation panoptique d’images. Prend uniquement en charge PyTorch.
Mask2FormerImageProcessorPil
classe transformers.Mask2FormerImageProcessorPil
< source >( **kwargs: *<class 'transformers.models.mask2former.image_processing_pil_mask2former.Mask2FormerImageProcessorKwargs'> )
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']]segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneinstance_id_to_semantic_id: list[dict[int, int]] | dict[int, int] | None = None**kwargs: *<class 'transformers.models.mask2former.image_processing_pil_mask2former.Mask2FormerImageProcessorKwargs'> ) → ~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éfinissezdo_rescale=False. - segmentation_maps (
ImageInput, facultatif) — Les cartes de segmentation. - instance_id_to_semantic_id (
Union[list[dict[int, int]], dict[int, int]], facultatif) — Une correspondance entre les identifiants d’instance et les identifiants sémantiques. - 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 decenter_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’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - 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 sido_rescaleest défini surTrue. - 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 sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - 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 (
SizeDict, kwargs, facultatif) — La taille à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de toute image fournie pour le prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et à la largeur les plus grandes du lot. - 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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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. - ignore_index (
int, kwargs, facultatif) — Étiquette à attribuer aux pixels d'arrière-plan dans les cartes de segmentation. Si fourni, les pixels de la carte de segmentation désignés par 0 (arrière-plan) seront remplacés parignore_index. - do_reduce_labels (
bool, kwargs, facultatif, valeur par défautFalse) — Indique s'il faut décrémenter de 1 toutes les valeurs des étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par exemple ADE20k). L'étiquette d'arrière-plan sera remplacée parignore_index. - num_labels (
int, kwargs, facultatif) — Le nombre d'étiquettes dans la carte de segmentation. - size_divisor (
int, kwargs, facultatif, valeur par défaut32) — Certains backbones nécessitent des images divisibles par un certain nombre. S'il n'est pas fourni, la valeur par défaut est celle utilisée dans Swin Transformer.
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.
post_process_semantic_segmentation
< source >( outputstarget_sizes: list[tuple[int, int]] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Paramètres
- outputs (Mask2FormerForUniversalSegmentation) — Sorties brutes du modèle.
- target_sizes (
list[tuple[int, int]], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si laissé à None, les prédictions ne seront pas redimensionnées. - return_segmentation_scores (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. SiTrue, chaque élément de la liste retournée est unSemanticSegmentationPostProcessorOutputavec les champssegmentation(IDs de classes, forme(height, width)) etsegmentation_scores(forme(num_classes, height, width)).
Retourne
list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]
Lorsque
return_segmentation_scores=False (par défaut), une liste de longueur batch_size où chaque élément est une
carte de segmentation de forme (height, width) avec des identifiants de classes. Lorsque return_segmentation_scores=True,
une liste de SemanticSegmentationPostProcessorOutput avec les champs segmentation (identifiants de classes, forme
(height, width)) et segmentation_scores (forme (num_classes, height, width)). Dans les deux cas,
(height, width) correspond à la taille cible (si target_sizes est spécifiée).
Convertit la sortie de Mask2FormerForUniversalSegmentation en cartes de segmentation sémantique. Prend uniquement en charge PyTorch.
post_process_instance_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8target_sizes: list[tuple[int, int]] | None = Nonereturn_coco_annotation: bool | None = Falsereturn_binary_maps: bool | None = False ) → List[Dict]
Paramètres
- outputs (Mask2FormerForUniversalSegmentation) — Sorties brutes du modèle.
- threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - target_sizes (
List[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (Tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si laissé à None, les prédictions ne seront pas redimensionnées. - return_coco_annotation (
bool, facultatif, par défautFalse) — Si défini surTrue, les cartes de segmentation sont renvoyées au format d'encodage par longueur de course (RLE) de COCO. - return_binary_maps (
bool, facultatif, par défautFalse) — Si défini surTrue, les cartes de segmentation sont renvoyées sous forme de tenseur concaténé de cartes de segmentation binaires (une par instance détectée).
Retourne
List[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — Un tenseur de forme
(height, width)où chaque pixel représente unsegment_id, ouList[List]encodage par longueur d'exécution (RLE) de la carte de segmentation si return_coco_annotation est défini surTrue, ou un tenseur de forme(num_instances, height, width)si return_binary_maps est défini surTrue. Défini surNonesi aucun masque n'est trouvé au-dessus dethreshold. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — Un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — Un entier représentant le
Convertit la sortie de Mask2FormerForUniversalSegmentationOutput en prédictions de segmentation d’instances.
Prend uniquement en charge PyTorch. Si les instances peuvent se chevaucher, définissez return_coco_annotation ou return_binary_maps
sur True pour obtenir le résultat de segmentation correct.
post_process_panoptic_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8label_ids_to_fuse: set[int] | None = Nonetarget_sizes: list[tuple[int, int]] | None = None ) → List[Dict]
Paramètres
- outputs (
Mask2FormerForUniversalSegmentationOutput) — Les sorties de Mask2FormerForUniversalSegmentation. - threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - label_ids_to_fuse (
Set[int], facultatif) — Les étiquettes de cet état verront toutes leurs instances fusionnées ensemble. Par exemple, on peut considérer qu’une image ne peut contenir qu’un seul ciel, mais plusieurs personnes ; l’identifiant de l’étiquette « sky » serait donc présent dans cet ensemble, mais pas celui de « person ». - target_sizes (
List[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (Tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction du lot. Si laissé à None, les prédictions ne seront pas redimensionnées.
Retourne
List[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — un tenseur de forme
(height, width)où chaque pixel représente unsegment_id, défini àNonesi aucun masque n'est trouvé au-dessus dethreshold. Sitarget_sizesest spécifié, la segmentation est redimensionnée à l'entrée correspondante detarget_sizes. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - was_fused — un booléen,
Truesilabel_idétait danslabel_ids_to_fuse,Falsesinon. Plusieurs instances de la même classe / étiquette ont été fusionnées et ont reçu un uniquesegment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — un entier représentant le
Convertit la sortie de Mask2FormerForUniversalSegmentationOutput en prédictions de segmentation panoptique d’images. Prend uniquement en charge PyTorch.