Hugging Face's logo

Transformers documentation

EoMT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2025-03-24 et contribué à Hugging Face Transformers le 2025-06-27.

EoMT

Aperçu

Le modèle The Encoder-only Mask Transformer (EoMT) a été introduit dans le papier en vedette de CVPR 2025 Your ViT is Secretly an Image Segmentation Model par Tommie Kerssies, Niccolò Cavagnero, Alexander Hermans, Narges Norouzi, Giuseppe Averta, Bastian Leibe, Gijs Dubbelman et Daan de Geus. EoMT démontre que les Vision Transformers peuvent effectuer efficacement la segmentation d’images sans composants spécifiques à la tâche.

L'abstract de l'article est le suivant :

Les Vision Transformers (ViTs) ont démontré des performances et une évolutivité remarquables sur diverses tâches de vision par ordinateur. Pour appliquer des ViTs à une seule échelle à la segmentation d'images, les méthodes existantes adoptent un adaptateur convolutif pour générer des caractéristiques multi-échelles, un décodeur de pixels pour fusionner ces caractéristiques et un décodeur Transformer qui utilise les caractéristiques fusionnées pour effectuer des prédictions. Dans cet article, nous montrons que les biais inductifs introduits par ces composants spécifiques à la tâche peuvent au contraire être appris par le ViT lui-même, à condition de disposer de modèles suffisamment grands et d'un pré-entraînement étendu. Sur la base de ces constats, nous introduisons l'Encoder-only Mask Transformer (EoMT), qui réutilise l'architecture ViT standard pour effectuer la segmentation d'images. Grâce à des modèles de grande taille et à un pré-entraînement, EoMT obtient une précision de segmentation comparable à celle des modèles de pointe utilisant des composants spécifiques à la tâche. En même temps, EoMT est nettement plus rapide que ces méthodes en raison de la simplicité de son architecture, par exemple jusqu'à 4 fois plus rapide avec ViT-L. Sur une gamme de tailles de modèles, EoMT démontre un équilibre optimal entre la précision de segmentation et la vitesse de prédiction, suggérant que les ressources de calcul sont mieux utilisées pour mettre à l'échelle le ViT lui-même plutôt que pour ajouter de la complexité architecturale.

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

Informations sur l'architecture

Le modèle EoMT utilise un Vision Transformer pré-entraîné avec DINOv2, doté de register tokens, comme architecture de base. EoMT simplifie le pipeline de segmentation en s'appuyant uniquement sur l'encodeur, éliminant ainsi le besoin de décodeurs spécifiques à la tâche couramment utilisés dans les approches antérieures.

Sur le plan architectural, EoMT introduit un petit ensemble de requêtes apprises et un module de prédiction de masque léger. Ces requêtes sont injectées dans les derniers blocs de l'encodeur, permettant une attention conjointe entre les patches d'image et les requêtes d'objets. Lors de l'entraînement, une attention masquée est appliquée pour contraindre chaque requête à se concentrer sur sa région correspondante, imitant ainsi efficacement l'attention croisée. Cette contrainte est progressivement atténuée grâce à une stratégie d'annealing de masque, permettant une inférence efficace sans décodeur sans compromettre les performances de segmentation.

drawing

Le modèle prend en charge la segmentation sémantique, la segmentation d'instances et la segmentation panoptique grâce à une architecture unifiée et à un post-traitement spécifique à chaque tâche.

Exemples d'utilisation

Utilisez l’implémentation Hugging Face de EoMT pour l’inférence avec des modèles pré-entraînés.

Segmentation sémantique

Le modèle EoMT effectue la segmentation sémantique en utilisant une inférence par fenêtre glissante. L'image d'entrée est redimensionnée de sorte que le côté le plus court corresponde à la taille d'entrée cible, puis elle est découpée en recadrages superposés. Chaque recadrage est ensuite transmis au modèle. Après l'inférence, les logits prédits de chaque recadrage sont recollés et redimensionnés à la taille de l'image d'origine pour obtenir le masque de segmentation final.

Remarque :
Si vous souhaitez utiliser une taille cible personnalisée pour la segmentation sémantique, spécifiez-la dans le format suivant :
{"shortest_edge": 512}
Notez que longest_edge n'est pas fourni ici — c'est volontaire. Pour la segmentation sémantique, les images sont généralement redimensionnées de sorte que le plus petit côté soit supérieur ou égal à la taille cible, ce qui rend longest_edge inutile.

import matplotlib.pyplot as plt
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, EomtForUniversalSegmentation


model_id = "tue-mps/ade20k_semantic_eomt_large_512"
processor = AutoImageProcessor.from_pretrained(model_id)
model = EomtForUniversalSegmentation.from_pretrained(model_id, device_map="auto")

image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw)

inputs = processor(
    images=image,
    return_tensors="pt",
)

with torch.inference_mode():
    outputs = model(**inputs)

# Prepare the original image size in the format (height, width)
target_sizes = [(image.height, image.width)]

# Post-process the model outputs to get final segmentation prediction
preds = processor.post_process_semantic_segmentation(
    outputs,
    target_sizes=target_sizes,
)

# Visualize the segmentation mask
plt.imshow(preds[0])
plt.axis("off")
plt.title("Semantic Segmentation")
plt.show()

Segmentation d'instances

Le modèle EoMT effectue la segmentation d'instances en utilisant une inférence avec bourrage. L'image d'entrée est redimensionnée de sorte que le côté le plus long corresponde à la taille d'entrée cible, et le côté le plus court est bourré de zéros pour former un carré. Le masque résultant et les logits de classe sont combinés par un post-traitement (adapté de Mask2Former) pour produire une carte de segmentation d'instances unifiée, ainsi que des métadonnées de segment telles que l'identifiant du segment, les étiquettes de classe et les scores de confiance.

Remarque :
Pour utiliser une taille cible personnalisée, spécifiez la taille sous forme de dictionnaire au format suivant :
{"shortest_edge": 512, "longest_edge": 512}
Pour la segmentation d'instances et la segmentation panoptique, les images d'entrée seront redimensionnées et remplies pour atteindre cette taille cible.

import matplotlib.pyplot as plt
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, EomtForUniversalSegmentation


model_id = "tue-mps/coco_instance_eomt_large_640"
processor = AutoImageProcessor.from_pretrained(model_id)
model = EomtForUniversalSegmentation.from_pretrained(model_id, device_map="auto")

image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw)

inputs = processor(
    images=image,
    return_tensors="pt",
)

with torch.inference_mode():
    outputs = model(**inputs)

# Prepare the original image size in the format (height, width)
target_sizes = [(image.height, image.width)]

# Post-process the model outputs to get final segmentation prediction
preds = processor.post_process_instance_segmentation(
    outputs,
    target_sizes=target_sizes,
)

# Visualize the segmentation mask
plt.imshow(preds[0]["segmentation"])
plt.axis("off")
plt.title("Instance Segmentation")
plt.show()

Segmentation panoptique

Le modèle EoMT effectue une segmentation panoptique en utilisant la même stratégie d’inférence avec bourrage que pour la segmentation d’instances. Après le bourrage et la normalisation, le modèle prédit à la fois les classes de « thing » (instances) et de « stuff » (régions amorphes). Le masque et les logits de classes résultants sont combinés par un post-traitement (adapté de Mask2Former) pour produire une carte de segmentation panoptique unifiée, ainsi que des métadonnées de segments telles que l’identifiant du segment, les étiquettes de classes et les scores de confiance.

import matplotlib.pyplot as plt
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, EomtForUniversalSegmentation


model_id = "tue-mps/coco_panoptic_eomt_large_640"
processor = AutoImageProcessor.from_pretrained(model_id)
model = EomtForUniversalSegmentation.from_pretrained(model_id, device_map="auto")

image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw)

inputs = processor(
    images=image,
    return_tensors="pt",
)

with torch.inference_mode():
    outputs = model(**inputs)

# Prepare the original image size in the format (height, width)
target_sizes = [(image.height, image.width)]

# Post-process the model outputs to get final segmentation prediction
preds = processor.post_process_panoptic_segmentation(
    outputs,
    target_sizes=target_sizes,
)

# Visualize the panoptic segmentation mask
plt.imshow(preds[0]["segmentation"])
plt.axis("off")
plt.title("Panoptic Segmentation")
plt.show()

EomtImageProcessor

classe transformers.EomtImageProcessor

< >

( **kwargs: *<class 'transformers.models.eomt.image_processing_eomt.EomtImageProcessorKwargs'> )

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

Construit un processeur d’images EomtImageProcessor.

prétraiter

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]segmentation_maps: list[torch.Tensor] | None = Noneinstance_id_to_semantic_id: dict[int, int] | None = None**kwargs: *<class 'transformers.models.eomt.image_processing_eomt.EomtImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • segmentation_maps (ImageInput, facultatif) — Les cartes de segmentation à prétraiter pour les images correspondantes.
  • instance_id_to_semantic_id (list[dict[int, int]] ou dict[int, int], facultatif) — Une correspondance entre les identifiants d'instances d'objets et les identifiants de classes.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_split_image (bool, kwargs, facultatif, par défaut self.do_split_image) — Indique s'il faut diviser les images d'entrée en tuiles superposées pour la segmentation sémantique. Si défini sur True, les images d'entrée sont divisées en tuiles de taille size["shortest_edge"] avec un chevauchement entre les tuiles. Sinon, les images d'entrée sont remplies (padding) jusqu'à la taille cible.
  • ignore_index (int, kwargs, facultatif, valeur par défaut self.ignore_index) — Étiquette à attribuer aux pixels d'arrière-plan dans les cartes de segmentation. Si fournie, les pixels de la carte de segmentation désignés par 0 (arrière-plan) seront remplacés par ignore_index.

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

< >

( outputstarget_sizes: listsize: dict[str, int] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

Paramètres

  • outputs (EomtForUniversalSegmentation) — Sorties brutes du modèle.
  • target_sizes (list[tuple[int, int]]) — Une liste de tuples (tuple[int, int]) contenant la taille cible (hauteur, largeur) de chaque image du lot.
  • size (dict[str, int], facultatif) — La taille vers laquelle les masques intermédiaires sont interpolés. Par défaut, self.size.
  • return_segmentation_scores (bool, facultatif, 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 (IDs 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.

Convertit la sortie de EomtForUniversalSegmentation en cartes de segmentation sémantique.

post_process_instance_segmentation

< >

( outputstarget_sizes: listthreshold: float = 0.8size: dict[str, int] | None = None )

Post-traite les sorties du modèle en prédictions de segmentation d'instances.

post_process_panoptic_segmentation

< >

( outputstarget_sizes: listthreshold: float = 0.8mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8stuff_classes: list[int] | None = Nonesize: dict[str, int] | None = None )

Post-traite les sorties du modèle pour produire la prédiction finale de segmentation panoptique.

EomtImageProcessorPil

classe transformers.EomtImageProcessorPil

< >

( **kwargs: *<class 'transformers.models.eomt.image_processing_pil_eomt.EomtImageProcessorKwargs'> )

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

Construit un processeur d’images EomtImageProcessor.

prétraiter

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]segmentation_maps: list[torch.Tensor] | None = Noneinstance_id_to_semantic_id: dict[int, int] | None = None**kwargs: *<class 'transformers.models.eomt.image_processing_pil_eomt.EomtImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • segmentation_maps (ImageInput, facultatif) — Les cartes de segmentation à prétraiter pour les images correspondantes.
  • instance_id_to_semantic_id (list[dict[int, int]] ou dict[int, int], facultatif) — Une correspondance entre les identifiants d'instances d'objets et les identifiants de classes.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_split_image (bool, kwargs, facultatif, par défaut self.do_split_image) — Indique s'il faut diviser les images d'entrée en tuiles superposées pour la segmentation sémantique. Si défini sur True, les images d'entrée sont divisées en tuiles de taille size["shortest_edge"] avec un chevauchement entre les tuiles. Sinon, les images d'entrée sont remplies (padding) jusqu'à la taille cible.
  • ignore_index (int, kwargs, facultatif, valeur par défaut self.ignore_index) — Étiquette à attribuer aux pixels d'arrière-plan dans les cartes de segmentation. Si fournie, les pixels de la carte de segmentation désignés par 0 (arrière-plan) seront remplacés par ignore_index.

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

< >

( outputstarget_sizes: listsize: dict[str, int] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

Paramètres

  • outputs (EomtForUniversalSegmentation) — Sorties brutes du modèle.
  • target_sizes (list[tuple[int, int]]) — Une liste de tuples (tuple[int, int]) contenant la taille cible (hauteur, largeur) de chaque image du lot.
  • size (dict[str, int], facultatif) — La taille vers laquelle les masques intermédiaires sont interpolés. Par défaut, self.size.
  • return_segmentation_scores (bool, facultatif, 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 (IDs 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.

Convertit la sortie de EomtForUniversalSegmentation en cartes de segmentation sémantique.

post_process_instance_segmentation

< >

( outputstarget_sizes: listthreshold: float = 0.8size: dict[str, int] | None = None )

Post-traite les sorties du modèle en prédictions de segmentation d'instances.

post_process_panoptic_segmentation

< >

( outputstarget_sizes: listthreshold: float = 0.8mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8stuff_classes: list[int] | None = Nonesize: dict[str, int] | None = None )

Post-traite les sorties du modèle pour produire la prédiction finale de segmentation panoptique.

EomtConfig

classe transformers.EomtConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 16hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, int] = 640patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3mlp_ratio: int = 4layerscale_value: float = 1.0drop_path_rate: float | int = 0.0num_upscale_blocks: int = 2attention_dropout: float | int = 0.0use_swiglu_ffn: bool = Falsenum_blocks: int = 4no_object_weight: float = 0.1class_weight: float = 2.0mask_weight: float = 5.0dice_weight: float = 5.0train_num_points: int = 12544oversample_ratio: float = 3.0importance_sample_ratio: float = 0.75num_queries: int = 200num_register_tokens: int = 4 )

Paramètres

  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 24) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], facultatif, par défaut 0.0) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • image_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 640) — La taille (résolution) de chaque image.
  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 16) — La taille (résolution) de chaque patch.
  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • mlp_ratio (int, facultatif, par défaut 4) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.
  • layerscale_value (float, facultatif, valeur par défaut 1.0) — Valeur initiale du paramètre LayerScale.
  • drop_path_rate (Union[float, int], facultatif, par défaut 0.0) — Taux de drop path pour la fusion des patches.
  • num_upscale_blocks (int, facultatif, valeur par défaut 2) — Nombre de blocs de remonte en résolution utilisés dans le décodeur ou la tête de segmentation.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • use_swiglu_ffn (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser le réseau de neurones feedforward SwiGLU.
  • num_blocks (int, facultatif, valeur par défaut 4) — Nombre de blocs de caractéristiques ou de stades dans l'architecture.
  • no_object_weight (float, facultatif, valeur par défaut 0.1) — Poids de la perte pour la classe « no object » dans la segmentation panoptique/instance.
  • class_weight (float, facultatif, valeur par défaut 2.0) — Poids de la perte pour les cibles de classification.
  • mask_weight (float, facultatif, valeur par défaut 5.0) — Poids de la perte pour la prédiction du masque.
  • dice_weight (float, facultatif, par défaut 5.0) — Poids relatif de la perte dice dans la perte de segmentation panoptique.
  • train_num_points (int, facultatif, valeur par défaut 12544) — Nombre de points à échantillonner pour le calcul de la perte de masque pendant l’entraînement.
  • oversample_ratio (float, facultatif, valeur par défaut 3.0) — Ratio de suréchantillonnage utilisé dans l'échantillonnage de points pour l'entraînement du masque.
  • importance_sample_ratio (float, facultatif, valeur par défaut 0,75) — Ratio de points à échantillonner en fonction de l'importance pendant l'entraînement.
  • num_queries (int, facultatif, valeur par défaut 200) — Nombre de requêtes d'objets dans le Transformer.
  • num_register_tokens (int, facultatif, valeur par défaut : 4) — Nombre de jetons d'enregistrement apprenables ajoutés à l'entrée du transformeur.

Ceci est la classe de configuration destinée à stocker la configuration d'un EomtModel. Elle est utilisée pour instancier un modèle Eomt en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de tue-mps/coco_panoptic_eomt_large_640

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import EomtConfig, EomtForUniversalSegmentation

>>> # Initialize configuration
>>> config = EomtConfig()

>>> # Initialize model
>>> model = EomtForUniversalSegmentation(config)

>>> # Access config
>>> config = model.config

EomtForUniversalSegmentation

classe transformers.EomtForUniversalSegmentation

< >

( config: EomtConfig )

Paramètres

  • config (EomtConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle EoMT avec une tête en haut pour la segmentation instance/sémantique/panoptique.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( pixel_values: Tensormask_labels: list[torch.Tensor] | None = Noneclass_labels: list[torch.Tensor] | None = Nonepatch_offsets: list[torch.Tensor] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → EomtForUniversalSegmentationOutput or tuple(torch.FloatTensor)

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 de pixels peuvent être obtenues à l’aide de EomtImageProcessor. Voir EomtImageProcessor.call() pour plus de détails (processor_class utilise EomtImageProcessor pour le traitement des images).
  • mask_labels (list[torch.Tensor], facultatif) — liste d'étiquettes de masque de forme (num_labels, height, width) à fournir à un modèle
  • class_labels (list[torch.LongTensor], facultatif) — liste des étiquettes de classes cibles de forme (num_labels, height, width) à fournir à un modèle. Elles identifient les étiquettes de mask_labels, par exemple l'étiquette de mask_labels[i][j] si class_labels[i][j].
  • patch_offsets (list[torch.Tensor], facultatif) — liste de tuples indiquant l’index de l’image ainsi que les positions de début et de fin des patches pour la segmentation sémantique.

Retourne

EomtForUniversalSegmentationOutput ou tuple(torch.FloatTensor)

Un EomtForUniversalSegmentationOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (EomtConfig) et des entrées.

La méthode forward de EomtForUniversalSegmentation redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor, facultatif) — La perte calculée, renvoyée lorsque des étiquettes sont présentes.
  • class_queries_logits (torch.FloatTensor, 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.FloatTensor, facultatif) — Un tenseur de forme (batch_size, num_queries, height, width) représentant les masques proposés pour chaque requête.
  • last_hidden_state (torch.FloatTensor de forme (batch_size, num_channels, height, width)) — Derniers états cachés (carte de caractéristiques finale) de la dernière couche.
  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme (batch_size, sequence_length, hidden_size). États cachés de toutes les couches du modèle.
  • attentions (tuple(tuple(torch.FloatTensor)), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de tuple(torch.FloatTensor) (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length). Poids des attentions Self et Cross du décodeur du transformer.
  • patch_offsets (list[torch.Tensor], facultatif) — liste de tuples indiquant l’index de l’image ainsi que les positions de début et de fin des patches pour la segmentation sémantique.
Update on GitHub

←EfficientNet EoMT-DINOv3→