# Mask2Former ## Aperçu Le modèle Mask2Former a été proposé dans [Masked-attention Mask Transformer for Universal Image Segmentation](https://huggingface.co/papers/2112.01527) 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](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, par instance 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 par instance (50,1 AP sur COCO) et la segmentation sémantique (57,7 mIoU sur ADE20K).* Architecture de Mask2Former. Issue de l’article original. Ce modèle a été contribué par [Shivalika Singh](https://huggingface.co/shivi) et [Alara Dirik](https://huggingface.co/adirik). Le code d'origine peut être trouvé [ici](https://github.com/facebookresearch/Mask2Former). ## Conseils d'utilisation - Mask2Former utilise les mêmes étapes de prétraitement et de post-traitement que [MaskFormer](maskformer). Utilisez [Mask2FormerImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor) ou [AutoImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.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()](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_instance_segmentation) ou [post_process_panoptic_segmentation()](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_panoptic_segmentation). Les trois tâches peuvent être résolues à l'aide de la sortie de [Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation), la segmentation panoptique acceptant un argument facultatif `label_ids_to_fuse` pour 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](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Mask2Former). 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[[transformers.Mask2FormerConfig]] #### transformers.Mask2FormerConfig[[transformers.Mask2FormerConfig]] ```python transformers.Mask2FormerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, feature_size: int = 256, mask_feature_size: int = 256, hidden_dim: int = 256, encoder_feedforward_dim: int = 1024, activation_function: str = 'relu', encoder_layers: int = 6, decoder_layers: int = 10, num_attention_heads: int = 8, dropout: float | int = 0.0, dim_feedforward: int = 2048, pre_norm: bool = False, enforce_input_projection: bool = False, common_stride: int = 4, ignore_value: int = 255, num_queries: int = 100, no_object_weight: float = 0.1, class_weight: float = 2.0, mask_weight: float = 5.0, dice_weight: float = 5.0, train_num_points: int = 12544, oversample_ratio: float = 3.0, importance_sample_ratio: float = 0.75, init_std: float = 0.02, init_xavier_std: float = 1.0, use_auxiliary_loss: bool = True, feature_strides: list[int] | tuple[int, ...] = (4, 8, 16, 32), output_auxiliary_logits: bool | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/configuration_mask2former.py#L28) **Paramètres :** backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : La configuration du modèle de base. feature_size (`int`, *facultatif*, valeur 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éfaut `256`) : Dimension des représentations cachées. encoder_feedforward_dim (`int`, *facultatif*, valeur par défaut 1024) : Dimension du réseau feedforward de l'encodeur deformable detr utilisé dans le cadre du décodeur de pixels. activation_function (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. encoder_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini. decoder_layers (`int`, *facultatif*, valeur par défaut `10`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini. num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le ratio pour 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 transformer. pre_norm (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser pre-LayerNorm ou non pour le décodeur du transformer. enforce_input_projection (`bool`, *facultatif*, valeur par défaut `False`) : 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 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éfaut `0.1`) : Poids de classification relatif de la classe sans objet dans la fonction de perte de détection d'objets. class_weight (`float`, *facultatif*, valeur par défaut `2.0`) : Poids relatif de l'erreur de classification dans le coût d'appariement hongrois. mask_weight (`float`, *facultatif*, valeur par défaut `5.0`) : Poids relatif de la focal loss dans la perte de segmentation panoptique. dice_weight (`float`, *facultatif*, valeur par défaut `5.0`) : Poids relatif de la perte dice dans la perte de segmentation panoptique. train_num_points (`str` ou `function`, *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) : Proportion de points échantillonnés par échantillonnage d'importance. init_std (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. init_xavier_std (`float`, *facultatif*, par défaut `1.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éfaut `True`) : Indique s'il faut calculer la perte à l'aide des prédictions intermédiaires issues 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 produire ses `auxiliary_logits` ou non. 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, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/mask2former-swin-small-coco-instance](https://huggingface.co/facebook/mask2former-swin-small-coco-instance) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemples : ```python >>> 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.config ``` ## Sorties spécifiques à MaskFormer[[transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput]] #### transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput[[transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput]] ```python transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput(encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, pixel_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, transformer_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, pixel_decoder_hidden_states: tuple[torch.Tensor] | None = None, transformer_decoder_hidden_states: tuple[torch.Tensor] | None = None, transformer_decoder_intermediate_states: tuple[torch.Tensor] | None = None, masks_queries_logits: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/modeling_mask2former.py#L143) **Paramètres :** encoder_last_hidden_state (`torch.Tensor` de 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é lorsque `output_hidden_states=True` est passé. pixel_decoder_last_hidden_state (`torch.Tensor` de 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 du transformer `(batch_size, sequence_length, hidden_size)`. encoder_hidden_states (`tuple(torch.Tensor)`, *facultatif*) : Tuple de `torch.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. Renvoyé lorsque `output_hidden_states=True` est passé. pixel_decoder_hidden_states (`tuple(torch.Tensor)`, , *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, num_channels, height, width)`. États cachés (également appelés feature maps) du modèle de décodeur de pixels à la sortie de chaque étape. Renvoyé lorsque `output_hidden_states=True` est passé. transformer_decoder_hidden_states (`tuple(torch.Tensor)`, *facultatif*) : Tuple de `torch.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 du transformer à la sortie de chaque étape. Renvoyé lorsque `output_hidden_states=True` est 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 normalisation de couche. masks_queries_logits (`tuple(torch.Tensor)` de forme `(batch_size, num_queries, height, width)`) : Prédiction des masques de chaque couche du décodeur du transformer. attentions (`tuple(tuple(torch.Tensor))`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé) : Tuple de `tuple(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é lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Classe pour les sorties de [Mask2FormerModel](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerModel). Cette classe renvoie tous les états cachés nécessaires pour calculer les logits. #### transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput[[transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput]] ```python transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, class_queries_logits: typing.Optional[torch.Tensor] = None, masks_queries_logits: typing.Optional[torch.Tensor] = None, auxiliary_logits: list[dict[str, torch.Tensor]] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, pixel_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, transformer_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, pixel_decoder_hidden_states: tuple[torch.Tensor] | None = None, transformer_decoder_hidden_states: typing.Optional[torch.Tensor] = None, attentions: tuple[torch.Tensor] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/modeling_mask2former.py#L196) **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 `+ 1` est 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.Tensor` de 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.Tensor` de 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 du transformer `(batch_size, sequence_length, hidden_size)`. encoder_hidden_states (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `tuple(torch.Tensor)` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Poids des attentions Self et Cross du décodeur du transformer. Classe pour les sorties de `Mask2FormerForUniversalSegmentationOutput`. Cette sortie peut être transmise directement à [post_process_semantic_segmentation()](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_instance_segmentation) ou [post_process_panoptic_segmentation()](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_panoptic_segmentation) pour calculer les cartes de segmentation finales. Veuillez consulter [`~Mask2FormerImageProcessor] pour plus de détails sur l'utilisation. ## Mask2FormerModel[[transformers.Mask2FormerModel]] #### transformers.Mask2FormerModel[[transformers.Mask2FormerModel]] ```python transformers.Mask2FormerModel(config: Mask2FormerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/modeling_mask2former.py#L2224) **Paramètres :** config ([Mask2FormerConfig](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Mask2FormerModel.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/modeling_mask2former.py#L2234) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [Mask2FormerImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor). Voir [Mask2FormerImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Mask2FormerImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor) pour le traitement des images). pixel_mask (`torch.Tensor` de 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 de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans 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. Voir `attentions` sous les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [Mask2FormerModelOutput](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput) ou `tuple(torch.Tensor)` Un [Mask2FormerModelOutput](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Mask2FormerConfig](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerConfig)) et les entrées. La méthode forward de [Mask2FormerModel](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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 `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. - **encoder_last_hidden_state** (`torch.Tensor` de 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é lorsque `output_hidden_states=True` est passé. - **pixel_decoder_last_hidden_state** (`torch.Tensor` de 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 de `torch.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é lorsque `output_hidden_states=True` est passé. - **pixel_decoder_hidden_states** (`tuple(torch.Tensor)`, , *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_hidden_states=True` est passé. - **transformer_decoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- Tuple de `torch.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. Renvoyé lorsque `output_hidden_states=True` est 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 normalisation de couche (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é lorsque `output_attentions=True` est passé) -- Tuple de `tuple(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é lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## Mask2FormerForUniversalSegmentation[[transformers.Mask2FormerForUniversalSegmentation]] #### transformers.Mask2FormerForUniversalSegmentation[[transformers.Mask2FormerForUniversalSegmentation]] ```python transformers.Mask2FormerForUniversalSegmentation(config: Mask2FormerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/modeling_mask2former.py#L2300) **Paramètres :** config ([Mask2FormerConfig](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Mask2FormerForUniversalSegmentation.forward]] ```python forward(pixel_values: Tensor, mask_labels: list[torch.Tensor] | None = None, class_labels: list[torch.Tensor] | None = None, pixel_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_auxiliary_logits: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/modeling_mask2former.py#L2353) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [Mask2FormerImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerImageProcessor). Voir [Mask2FormerImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Mask2FormerImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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 d'étiquettes de classes cibles de forme `(num_labels, height, width)` à fournir à un modèle. Elles identifient les étiquettes de `mask_labels`, par exemple l'étiquette de `mask_labels[i][j]` si `class_labels[i][j]`. pixel_mask (`torch.Tensor` de 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 de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans 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. Voir `attentions` sous les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [Mask2FormerForUniversalSegmentationOutput](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput) ou `tuple(torch.Tensor)` Un [Mask2FormerForUniversalSegmentationOutput](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Mask2FormerConfig](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerConfig)) et les entrées. La méthode forward de [Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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 `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`, *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 `+ 1` est 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.Tensor` de 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.Tensor` de 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, 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é lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `tuple(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 : ```python >>> 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 : ```python >>> 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 : ```python >>> 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://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[[transformers.Mask2FormerImageProcessor]] #### transformers.Mask2FormerImageProcessor[[transformers.Mask2FormerImageProcessor]] ```python transformers.Mask2FormerImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_mask2former.py#L263) **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é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' : 800, 'longest_edge': 1333}`) : Décrit les dimensions d'entrée maximales pour le modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un 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*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`SizeDict`, *kwargs*, *facultatif*) : La taille à laquelle rembourder les images. Doit être supérieure à la taille de toute image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourdées à la hauteur et à la largeur maximales 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*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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 notés 0 (arrière-plan) seront remplacés par `ignore_index`. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut décrémenter de 1 toutes les valeurs d'étiquette 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 ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par `ignore_index`. num_labels (`int`, *kwargs*, *facultatif*) : Le nombre d'étiquettes dans la carte de segmentation. size_divisor (`int`, *kwargs*, *facultatif*, valeur par défaut `32`) : certains backbones nécessitent des images divisibles par un certain nombre. Si aucune valeur n'est fournie, la valeur utilisée dans Swin Transformer est appliquée par défaut. Construit un processeur d’images Mask2FormerImageProcessor. #### prétraiter[[transformers.Mask2FormerImageProcessor.preprocess]] ```python preprocess(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] = None, instance_id_to_semantic_id: list[dict[int, int]] | dict[int, int] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_mask2former.py#L386) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. segmentation_maps (`ImageInput`, *facultatif*) : Les cartes de segmentation. instance_id_to_semantic_id (`Union[list[dict[int, int]], dict[int, int]]`, *facultatif*) : Un mappage des identifiants d'instances vers 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque 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 d'une des valeurs de l'énumération `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 redimensionnement à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`SizeDict`, *kwargs*, *facultatif*) : La taille à laquelle rembourder les images. Doit être supérieure à la taille de toute image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourdées à la hauteur et à la largeur maximales 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*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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 notés 0 (arrière-plan) seront remplacés par `ignore_index`. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut décrémenter de 1 toutes les valeurs d'étiquette 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 ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par `ignore_index`. num_labels (`int`, *kwargs*, *facultatif*) : Le nombre d'étiquettes dans la carte de segmentation. size_divisor (`int`, *kwargs*, *facultatif*, valeur par défaut `32`) : certains backbones nécessitent des images divisibles par un certain nombre. Si aucune valeur n'est fournie, la valeur utilisée dans Swin Transformer est appliquée par défaut. **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[[transformers.Mask2FormerImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_mask2former.py#L550) **Paramètres :** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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*, valeur par défaut `False`) : Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. Si `True`, chaque élément de la liste retournée est un `SemanticSegmentationPostProcessorOutput` avec les champs `segmentation` (identifiants de classes, forme `(height, width)`) et `segmentation_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](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation) en cartes de segmentation sémantique. Prend uniquement en charge PyTorch. #### post_process_instance_segmentation[[transformers.Mask2FormerImageProcessor.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False, return_binary_maps: bool | None = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_mask2former.py#L627) **Paramètres :** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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*, valeur par défaut `False`) : Si défini sur `True`, les cartes de segmentation sont renvoyées au format d'encodage par longueur d'exécution (RLE) de COCO. return_binary_maps (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, 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 un `segment_id`, ou un `List[List]` d'encodage par longueur d'exécution (RLE) de la carte de segmentation si return_coco_annotation est défini sur `True`, ou un tenseur de forme `(num_instances, height, width)` si return_binary_maps est défini sur `True`. Défini sur `None` si aucun masque n'est trouvé au-dessus du `threshold`. - **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 / de l'étiquette correspondant à `segment_id`. - **score** -- Score de prédiction du segment portant l'`segment_id`. 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[[transformers.Mask2FormerImageProcessor.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_mask2former.py#L748) **Paramètres :** outputs (`Mask2FormerForUniversalSegmentationOutput`) : Les sorties de [Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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 affirmer 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 un `segment_id`, défini à `None` si aucun masque n'est trouvé au-dessus du `threshold`. Si `target_sizes` est spécifié, la segmentation est redimensionnée à l'entrée correspondante de `target_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 / de l'étiquette correspondant à `segment_id`. - **was_fused** -- un booléen, `True` si `label_id` était présent dans `label_ids_to_fuse`, `False` sinon. Plusieurs instances de la même classe / étiquette ont été fusionnées et se sont vu attribuer un unique `segment_id`. - **score** -- Score de prédiction du segment portant l'`segment_id`. Convertit la sortie de `Mask2FormerForUniversalSegmentationOutput` en prédictions de segmentation panoptique d’images. Prend uniquement en charge PyTorch. ## Mask2FormerImageProcessorPil[[transformers.Mask2FormerImageProcessorPil]] #### transformers.Mask2FormerImageProcessorPil[[transformers.Mask2FormerImageProcessorPil]] ```python transformers.Mask2FormerImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L274) #### prétraiter[[transformers.Mask2FormerImageProcessorPil.preprocess]] ```python preprocess(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] = None, instance_id_to_semantic_id: list[dict[int, int]] | dict[int, int] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L442) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. segmentation_maps (`ImageInput`, *facultatif*) : Les cartes de segmentation. instance_id_to_semantic_id (`Union[list[dict[int, int]], dict[int, int]]`, *facultatif*) : Un mappage des identifiants d'instances vers 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque 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 d'une des valeurs de l'énumération `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 redimensionnement à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`SizeDict`, *kwargs*, *facultatif*) : La taille à laquelle rembourder les images. Doit être supérieure à la taille de toute image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourdées à la hauteur et à la largeur maximales 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*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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 notés 0 (arrière-plan) seront remplacés par `ignore_index`. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut décrémenter de 1 toutes les valeurs d'étiquette 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 ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par `ignore_index`. num_labels (`int`, *kwargs*, *facultatif*) : Le nombre d'étiquettes dans la carte de segmentation. size_divisor (`int`, *kwargs*, *facultatif*, valeur par défaut `32`) : certains backbones nécessitent des images divisibles par un certain nombre. Si aucune valeur n'est fournie, la valeur utilisée dans Swin Transformer est appliquée par défaut. **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[[transformers.Mask2FormerImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L587) **Paramètres :** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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*, valeur par défaut `False`) : Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. Si `True`, chaque élément de la liste retournée est un `SemanticSegmentationPostProcessorOutput` avec les champs `segmentation` (identifiants de classes, forme `(height, width)`) et `segmentation_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](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation) en cartes de segmentation sémantique. Prend uniquement en charge PyTorch. #### post_process_instance_segmentation[[transformers.Mask2FormerImageProcessorPil.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False, return_binary_maps: bool | None = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L664) **Paramètres :** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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*, valeur par défaut `False`) : Si défini sur `True`, les cartes de segmentation sont renvoyées au format d'encodage par longueur d'exécution (RLE) de COCO. return_binary_maps (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, 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 un `segment_id`, ou un `List[List]` d'encodage par longueur d'exécution (RLE) de la carte de segmentation si return_coco_annotation est défini sur `True`, ou un tenseur de forme `(num_instances, height, width)` si return_binary_maps est défini sur `True`. Défini sur `None` si aucun masque n'est trouvé au-dessus du `threshold`. - **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 / de l'étiquette correspondant à `segment_id`. - **score** -- Score de prédiction du segment portant l'`segment_id`. 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[[transformers.Mask2FormerImageProcessorPil.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L786) **Paramètres :** outputs (`Mask2FormerForUniversalSegmentationOutput`) : Les sorties de [Mask2FormerForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/mask2former#transformers.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 affirmer 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 un `segment_id`, défini à `None` si aucun masque n'est trouvé au-dessus du `threshold`. Si `target_sizes` est spécifié, la segmentation est redimensionnée à l'entrée correspondante de `target_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 / de l'étiquette correspondant à `segment_id`. - **was_fused** -- un booléen, `True` si `label_id` était présent dans `label_ids_to_fuse`, `False` sinon. Plusieurs instances de la même classe / étiquette ont été fusionnées et se sont vu attribuer un unique `segment_id`. - **score** -- Score de prédiction du segment portant l'`segment_id`. Convertit la sortie de `Mask2FormerForUniversalSegmentationOutput` en prédictions de segmentation panoptique d’images. Prend uniquement en charge PyTorch.