# MaskFormer Il s'agit d'un modèle récemment introduit, de sorte que l'API n'a pas encore été testée de manière exhaustive. Il est possible que des bugs ou de légères modifications cassantes subsistent et devront être corrigés à l'avenir. Si vous remarquez un comportement inattendu, veuillez ouvrir un [Github Issue](https://github.com/huggingface/transformers/issues/new?assignees=&labels=&template=bug-report.md&title). ## Aperçu Le modèle MaskFormer a été proposé dans [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://huggingface.co/papers/2107.06278) par Bowen Cheng, Alexander G. Schwing et Alexander Kirillov. MaskFormer aborde la segmentation sémantique avec un paradigme de classification de masques plutôt qu’une classification pixel par pixel classique. L'abstract de l'article est le suivant : *Les approches modernes formulent généralement la segmentation sémantique comme une tâche de classification par pixel, tandis que la segmentation au niveau des instances est traitée par une classification de masques alternative. Notre insight clé : la classification de masques est suffisamment générale pour résoudre à la fois les tâches de segmentation sémantique et au niveau des instances de manière unifiée, en utilisant exactement le même modèle, la même fonction de perte et la même procédure d’entraînement. Suivant cette observation, nous proposons MaskFormer, un modèle simple de classification de masques qui prédit un ensemble de masques binaires, chacun associé à une prédiction unique d’étiquette de classe globale. Dans l’ensemble, la méthode basée sur la classification de masques que nous proposons simplifie le paysage des approches efficaces pour les tâches de segmentation sémantique et panoptique et montre d’excellents résultats empiriques. En particulier, nous observons que MaskFormer surpasse les lignes de base de classification par pixel lorsque le nombre de classes est élevé. Notre méthode basée sur la classification de masques surpasse à la fois les modèles sémantiques (55,6 mIoU sur ADE20K) et de segmentation panoptique (52,7 PQ sur COCO) actuellement à l’état de l’art.* La figure ci-dessous illustre l'architecture de MaskFormer. Issue de l'[article original](https://huggingface.co/papers/2107.06278). Ce modèle a été contribué par [francesco](https://huggingface.co/francesco). Le code d'origine peut être trouvé [ici](https://github.com/facebookresearch/MaskFormer). ## Conseils d'utilisation - Le décodeur Transformer de MaskFormer est identique à celui de [DETR](detr). Lors de l’entraînement, les auteurs de DETR ont constaté qu’il était utile d’utiliser des pertes auxiliaires dans le décodeur, en particulier pour aider le modèle à produire le bon nombre d’objets de chaque classe. Si vous définissez le paramètre `use_auxiliary_loss` de [MaskFormerConfig](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerConfig) sur `True`, des réseaux de neurones feedforward de prédiction et des pertes hongroises sont ajoutés après chaque couche du décodeur (les FFN partageant leurs paramètres). - Si vous souhaitez entraîner le modèle dans un environnement distribué sur plusieurs nœuds, il faut mettre à jour la fonction `get_num_masks` dans la classe `MaskFormerLoss` du fichier `modeling_maskformer.py`. Lors de l’entraînement sur plusieurs nœuds, cette valeur doit être définie comme le nombre moyen de masques cibles sur l’ensemble des nœuds, comme on peut le voir dans l’implémentation d’origine [ici](https://github.com/facebookresearch/MaskFormer/blob/da3e60d85fdeedcb31476b5edd7d328826ce56cc/mask_former/modeling/criterion.py#L169). - On peut utiliser [MaskFormerImageProcessor](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor) pour préparer les images et les cibles optionnelles pour le modèle. - Pour obtenir la segmentation finale, selon la tâche, vous pouvez appeler [post_process_semantic_segmentation()](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor.post_process_semantic_segmentation) ou [post_process_panoptic_segmentation()](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor.post_process_panoptic_segmentation). Les deux tâches peuvent être résolues à l'aide de la sortie de [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation) ; la segmentation panoptique accepte un argument facultatif `label_ids_to_fuse` pour fusionner les instances de l'objet cible (par exemple, le ciel). ## Ressources - Tous les notebooks illustrant l'inférence ainsi que l'ajustement fin sur des données personnalisées avec MaskFormer sont disponibles [ici](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/MaskFormer). ## Sorties spécifiques à MaskFormer[[transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput]] #### transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput[[transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput]] ```python transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput(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, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/modeling_maskformer.py#L136) **Paramètres :** 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 (FPN). transformer_decoder_last_hidden_state (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle décodeur du transformer. 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. 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` contenant `encoder_hidden_states`, `pixel_decoder_hidden_states` et `decoder_hidden_states` hidden_states (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d’embedding initiales facultatives. 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 [MaskFormerModel](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerModel). Cette classe renvoie tous les états cachés nécessaires pour calculer les logits. #### transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput[[transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput]] ```python transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, class_queries_logits: typing.Optional[torch.Tensor] = None, masks_queries_logits: typing.Optional[torch.Tensor] = None, auxiliary_logits: typing.Optional[torch.Tensor] = 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: tuple[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/modeling_maskformer.py#L182) **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 (`Dict[str, torch.Tensor]`, *facultatif*, renvoyé lorsque `output_auxiliary_logits=True`) : Dictionnaire contenant les prédictions auxiliaires pour chaque couche du décodeur lorsque les pertes auxiliaires sont activées. 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 (FPN). transformer_decoder_last_hidden_state (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle décodeur du transformer. 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 du décodeur du transformer à la sortie de chaque étape. 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` contenant `encoder_hidden_states`, `pixel_decoder_hidden_states` et `decoder_hidden_states`. hidden_states (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d’embedding initiales facultatives. 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 [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation). Cette sortie peut être transmise directement à [post_process_semantic_segmentation()](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor.post_process_instance_segmentation) ou [post_process_panoptic_segmentation()](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor.post_process_panoptic_segmentation) selon la tâche. Veuillez consulter [`~MaskFormerImageProcessor] pour plus de détails sur l'utilisation. ## MaskFormerDetrConfig[[transformers.MaskFormerDetrConfig]] #### transformers.MaskFormerDetrConfig[[transformers.MaskFormerDetrConfig]] ```python transformers.MaskFormerDetrConfig(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, 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, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_channels: int = 3, num_queries: int = 100, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', dilation: bool = False, class_cost: int = 1, bbox_cost: int = 5, giou_cost: int = 2, mask_loss_coefficient: int = 1, dice_loss_coefficient: int = 1, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, eos_coefficient: float = 0.1) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/configuration_maskformer.py#L32) **Paramètres :** is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non. backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : La configuration du modèle de base. num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée. num_queries (`int`, *facultatif*, valeur par défaut 100) : Nombre de requêtes d'objets, c'est-à-dire de fentes de détection. Il s'agit du nombre maximal d'objets que [ConditionalDetrModel](/docs/transformers/main/fr/model_doc/conditional_detr#transformers.ConditionalDetrModel) peut détecter dans une image unique. Pour COCO, nous recommandons 100 requêtes. 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. encoder_ffn_dim (`int`, *facultatif*, valeur par défaut `2048`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur. encoder_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer. decoder_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini. decoder_ffn_dim (`int`, *facultatif*, valeur par défaut `2048`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur. decoder_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. encoder_layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Probabilité de LayerDrop pour l'encodeur. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails. decoder_layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Probabilité de LayerDrop pour le décodeur. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails. 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. d_model (`int`, *facultatif*, par défaut `256`) : Taille des couches d'encodeur et de la couche pooler. dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée. 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. auxiliary_loss (`bool`, *facultatif*, par défaut `False`) : Indique si les pertes de décodage auxiliaires (pertes à chaque couche du décodeur) doivent être utilisées. position_embedding_type (`str`, *facultatif*, par défaut `"sine"`) : Type d'embeddings de position à utiliser sur les caractéristiques de l'image. Soit `"sine"` ou `"learned"`. dilation (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut remplacer le pas (stride) par la dilatation dans le dernier bloc convolutif (DC5). Pris en charge uniquement lorsque `use_timm_backbone` = `True`. class_cost (`int`, *facultatif*, valeur par défaut `1`) : Poids relatif de l'erreur de classification dans le coût d'appariement hongrois. bbox_cost (`int`, *facultatif*, valeur par défaut `5`) : Poids relatif de l'erreur de boîte englobante L1 dans le coût d'appariement hongrois. giou_cost (`int`, *facultatif*, valeur par défaut `2`) : Poids relatif de la perte d'IoU généralisée dans le coût d'appariement hongrois. mask_loss_coefficient (`int`, *facultatif*, valeur par défaut `1`) : Poids relatif de la focal loss dans la perte de segmentation panoptique. dice_loss_coefficient (`int`, *facultatif*, valeur par défaut `1`) : Poids relatif de la perte dice dans la perte de segmentation panoptique. bbox_loss_coefficient (`int`, *facultatif*, valeur par défaut `5`) : Poids relatif de la perte de boîte englobante L1 dans la perte de segmentation panoptique. giou_loss_coefficient (`int`, *facultatif*, valeur par défaut `2`) : Poids relatif de la perte IoU généralisée dans la perte de segmentation panoptique. eos_coefficient (`float`, *facultatif*, valeur par défaut `0.1`) : Poids de classification relatif de la classe « no-object » dans la fonction de perte de détection d'objets. Il s’agit de la classe de configuration destinée à stocker la configuration d’un MaskFormerModel. Elle est utilisée pour instancier un modèle Maskformer 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/maskformer-swin-base-ade](https://huggingface.co/facebook/maskformer-swin-base-ade) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemples : ```python >>> from transformers import MaskFormerDetrConfig, MaskFormerDetrModel >>> # Initializing a MASK_FORMER_DETR facebook/mask_former_detr-resnet-50 style configuration >>> configuration = MaskFormerDetrConfig() >>> # Initializing a model (with random weights) from the facebook/mask_former_detr-resnet-50 style configuration >>> model = MaskFormerDetrModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MaskFormerConfig[[transformers.MaskFormerConfig]] #### transformers.MaskFormerConfig[[transformers.MaskFormerConfig]] ```python transformers.MaskFormerConfig(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, fpn_feature_size: int = 256, mask_feature_size: int = 256, no_object_weight: float = 0.1, use_auxiliary_loss: bool = False, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, init_std: float = 0.02, init_xavier_std: float = 1.0, dice_weight: float = 1.0, cross_entropy_weight: float = 1.0, mask_weight: float = 20.0, output_auxiliary_logits: bool | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/configuration_maskformer.py#L126) **Paramètres :** fpn_feature_size (`int`, *facultatif*, valeur par défaut 256) : La taille des caractéristiques du Feature Pyramid Network. 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. 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. use_auxiliary_loss (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut calculer la perte à l'aide des prédictions intermédiaires issues du décodeur du transformer. backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : La configuration du modèle de base. decoder_config (`Dict`, *facultatif*) : La configuration transmise au modèle de décodeur de transformeur. Si elle n'est pas définie, la configuration de base de `detr-resnet-50` sera utilisée. 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. dice_weight (`float`, *facultatif*, valeur par défaut `1.0`) : Poids relatif de la perte dice dans la perte de segmentation panoptique. cross_entropy_weight (`float`, *facultatif*, par défaut 1.0) : Le poids pour la perte d'entropie croisée. mask_weight (`float`, *facultatif*, valeur par défaut `20.0`) : Poids relatif de la focal loss dans la perte de segmentation panoptique. output_auxiliary_logits (`bool`, *facultatif*) : Indique si le modèle doit produire ses `auxiliary_logits` ou non. **Levée :** ``ValueError`` - ``ValueError`` -- Levée si le type de modèle de backbone sélectionné n'est pas dans `["swin"]` ou si le type de modèle de décodeur sélectionné n'est pas dans `["detr"]` Il s’agit de la classe de configuration destinée à stocker la configuration d’un MaskFormerModel. Elle est utilisée pour instancier un modèle Maskformer 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/maskformer-swin-base-ade](https://huggingface.co/facebook/maskformer-swin-base-ade) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/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/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemples : ```python >>> from transformers import MaskFormerConfig, MaskFormerModel >>> # Initializing a MaskFormer facebook/maskformer-swin-base-ade configuration >>> configuration = MaskFormerConfig() >>> # Initializing a model (with random weights) from the facebook/maskformer-swin-base-ade style configuration >>> model = MaskFormerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MaskFormerImageProcessor[[transformers.MaskFormerImageProcessor]] #### transformers.MaskFormerImageProcessor[[transformers.MaskFormerImageProcessor]] ```python transformers.MaskFormerImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/image_processing_maskformer.py#L257) **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 MaskFormerImageProcessor. #### prétraiter[[transformers.MaskFormerImageProcessor.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/main/src/transformers/models/maskformer/image_processing_maskformer.py#L380) **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.MaskFormerImageProcessor.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/main/src/transformers/models/maskformer/image_processing_maskformer.py#L546) **Paramètres :** outputs ([MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation)) : 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 [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation) en cartes de segmentation sémantique. Prend uniquement en charge PyTorch. #### post_process_instance_segmentation[[transformers.MaskFormerImageProcessor.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/main/src/transformers/models/maskformer/image_processing_maskformer.py#L616) **Paramètres :** outputs ([MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation)) : 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 encodage par longueur d'exécution (RLE) de type `list[List]` 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 `MaskFormerForInstanceSegmentationOutput` 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.MaskFormerImageProcessor.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/main/src/transformers/models/maskformer/image_processing_maskformer.py#L733) **Paramètres :** outputs (`MaskFormerForInstanceSegmentationOutput`) : Les sorties de [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation). 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 `MaskFormerForInstanceSegmentationOutput` en prédictions de segmentation panoptique d’image. Prend uniquement en charge PyTorch. ## MaskFormerImageProcessorPil[[transformers.MaskFormerImageProcessorPil]] #### transformers.MaskFormerImageProcessorPil[[transformers.MaskFormerImageProcessorPil]] ```python transformers.MaskFormerImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/image_processing_pil_maskformer.py#L270) **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 MaskFormerImageProcessor. #### prétraiter[[transformers.MaskFormerImageProcessorPil.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/main/src/transformers/models/maskformer/image_processing_pil_maskformer.py#L438) **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.MaskFormerImageProcessorPil.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/main/src/transformers/models/maskformer/image_processing_pil_maskformer.py#L583) **Paramètres :** outputs ([MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation)) : 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 [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation) en cartes de segmentation sémantique. Prend uniquement en charge PyTorch. #### post_process_instance_segmentation[[transformers.MaskFormerImageProcessorPil.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/main/src/transformers/models/maskformer/image_processing_pil_maskformer.py#L653) **Paramètres :** outputs ([MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation)) : 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 encodage par longueur d'exécution (RLE) de type `list[List]` 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 `MaskFormerForInstanceSegmentationOutput` 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.MaskFormerImageProcessorPil.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/main/src/transformers/models/maskformer/image_processing_pil_maskformer.py#L771) **Paramètres :** outputs (`MaskFormerForInstanceSegmentationOutput`) : Les sorties de [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation). 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 `MaskFormerForInstanceSegmentationOutput` en prédictions de segmentation panoptique d’image. Prend uniquement en charge PyTorch. ## MaskFormerModel[[transformers.MaskFormerModel]] #### transformers.MaskFormerModel[[transformers.MaskFormerModel]] ```python transformers.MaskFormerModel(config: MaskFormerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/modeling_maskformer.py#L1748) **Paramètres :** config ([MaskFormerConfig](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerConfig)) : 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/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Maskformer 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/main/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.MaskFormerModel.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/main/src/transformers/models/maskformer/modeling_maskformer.py#L1758) **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 [MaskFormerImageProcessor](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor). Voir [MaskFormerImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [MaskFormerImageProcessor](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor) 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/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [MaskFormerModelOutput](/docs/transformers/main/fr/model_doc/maskformer#transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput) ou `tuple(torch.Tensor)` Un [MaskFormerModelOutput](/docs/transformers/main/fr/model_doc/maskformer#transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput) 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 ([MaskFormerConfig](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerConfig)) et les entrées. La méthode forward du [MaskFormerModel](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerModel) 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)`) -- 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 (FPN). - **transformer_decoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle de décodeur transformer. - **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. 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` contenant `encoder_hidden_states`, `pixel_decoder_hidden_states` et `decoder_hidden_states` - **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **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. Exemples : ```python >>> from transformers import AutoImageProcessor, MaskFormerModel >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> # load MaskFormer fine-tuned on ADE20k semantic segmentation >>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade") >>> model = MaskFormerModel.from_pretrained("facebook/maskformer-swin-base-ade") >>> 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") >>> # forward pass >>> outputs = model(**inputs) >>> # the decoder of MaskFormer outputs hidden states of shape (batch_size, num_queries, hidden_size) >>> transformer_decoder_last_hidden_state = outputs.transformer_decoder_last_hidden_state >>> list(transformer_decoder_last_hidden_state.shape) [1, 100, 256] ``` ## MaskFormerForInstanceSegmentation[[transformers.MaskFormerForInstanceSegmentation]] #### transformers.MaskFormerForInstanceSegmentation[[transformers.MaskFormerForInstanceSegmentation]] ```python transformers.MaskFormerForInstanceSegmentation(config: MaskFormerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/maskformer/modeling_maskformer.py#L1847) #### forward[[transformers.MaskFormerForInstanceSegmentation.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_auxiliary_logits: bool | None = 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/main/src/transformers/models/maskformer/modeling_maskformer.py#L1929) **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 [MaskFormerImageProcessor](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor). Voir [MaskFormerImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [MaskFormerImageProcessor](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerImageProcessor) 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_auxiliary_logits (`bool`, *facultatif*) : Indique s'il faut ou non afficher les logits auxiliaires. 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/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [MaskFormerForInstanceSegmentationOutput](/docs/transformers/main/fr/model_doc/maskformer#transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput) ou `tuple(torch.Tensor)` Un [MaskFormerForInstanceSegmentationOutput](/docs/transformers/main/fr/model_doc/maskformer#transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput) 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 ([MaskFormerConfig](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerConfig)) et les entrées. La méthode forward de [MaskFormerForInstanceSegmentation](/docs/transformers/main/fr/model_doc/maskformer#transformers.MaskFormerForInstanceSegmentation) 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** (`Dict[str, torch.Tensor]`, *facultatif*, renvoyé lorsque `output_auxiliary_logits=True`) -- Dictionnaire contenant les prédictions auxiliaires pour chaque couche du décodeur lorsque les pertes auxiliaires sont activées. - **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 (FPN). - **transformer_decoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Derniers états cachés (carte de caractéristiques finale) de la dernière étape du modèle de décodeur transformer. - **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 du décodeur transformer à la sortie de chaque étape. 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` contenant `encoder_hidden_states`, `pixel_decoder_hidden_states` et `decoder_hidden_states`. - **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **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. Exemples : Exemple de segmentation sémantique : ```python >>> from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> # load MaskFormer fine-tuned on ADE20k semantic segmentation >>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade") >>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-ade") >>> 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(images=image, return_tensors="pt") >>> 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 >>> # you can pass them to image_processor for postprocessing >>> predicted_semantic_map = image_processor.post_process_semantic_segmentation( ... outputs, target_sizes=[(image.height, image.width)] ... )[0] >>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs) >>> list(predicted_semantic_map.shape) [512, 683] ``` Exemple de segmentation panoptique : ```python >>> from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> # load MaskFormer fine-tuned on COCO panoptic segmentation >>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-coco") >>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-coco") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = image_processor(images=image, return_tensors="pt") >>> 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 >>> # you can pass them to image_processor for postprocessing >>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(image.height, image.width)])[0] >>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs) >>> predicted_panoptic_map = result["segmentation"] >>> list(predicted_panoptic_map.shape) [480, 640] ```