# EoMT

## Aperçu

Le modèle [The Encoder-only Mask Transformer](https://www.tue-mps.org/eomt) (EoMT) a été introduit dans le CVPR 2025 Highlight Paper *[Your ViT is Secretly an Image Segmentation Model](https://huggingface.co/papers/2503.19108)* de 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](https://huggingface.co/yaswanthgali). Le code d'origine peut être trouvé [ici](https://github.com/tue-mps/eomt).

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

  <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/eomt_architecture.png"
       alt="drawing" width="500"/>

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.

```python
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 comme pour la segmentation panoptique, les images d'entrée seront **redimensionnées et remplies** pour atteindre cette taille cible.

```python
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.

```python
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[[transformers.EomtImageProcessor]]

#### transformers.EomtImageProcessor[[transformers.EomtImageProcessor]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L214)

**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é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*, valeur par défaut `False`) : 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 (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 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.

do_split_image (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_split_image`) : Indique s'il faut diviser les images d'entrée en tuiles chevauchantes pour la segmentation sémantique. Si la valeur est `True`, les images d'entrée sont découpé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 marqués avec 0 (arrière-plan) seront remplacés par `ignore_index`.

Construit un processeur d’images EomtImageProcessor.

#### prétraiter[[transformers.EomtImageProcessor.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: list[torch.Tensor] | None = None, instance_id_to_semantic_id: dict[int, int] | None = None, **kwargs: *<class 'transformers.models.eomt.image_processing_eomt.EomtImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L273)

**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 à prétraiter pour les images correspondantes.

instance_id_to_semantic_id (`list[dict[int, int]]` ou `dict[int, int]`, *facultatif*) : Un mappage 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é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 (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 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.

do_split_image (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_split_image`) : Indique s'il faut diviser les images d'entrée en tuiles chevauchantes pour la segmentation sémantique. Si la valeur est `True`, les images d'entrée sont découpé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 marqués avec 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[[transformers.EomtImageProcessor.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]], size: dict[str, int] | None = None, return_segmentation_scores: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L502)

**Paramètres :**

outputs ([EomtForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.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*, 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.

Convertit la sortie de [EomtForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.EomtForUniversalSegmentation) en cartes de segmentation sémantique.

#### post_process_instance_segmentation[[transformers.EomtImageProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, size: dict[str, int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L635)

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

#### post_process_panoptic_segmentation[[transformers.EomtImageProcessor.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, stuff_classes: list[int] | None = None, size: dict[str, int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L578)

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

## EomtImageProcessorPil[[transformers.EomtImageProcessorPil]]

#### transformers.EomtImageProcessorPil[[transformers.EomtImageProcessorPil]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L215)

**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é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*, valeur par défaut `False`) : 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 (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 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.

do_split_image (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_split_image`) : Indique s'il faut diviser les images d'entrée en tuiles chevauchantes pour la segmentation sémantique. Si la valeur est `True`, les images d'entrée sont découpé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 marqués avec 0 (arrière-plan) seront remplacés par `ignore_index`.

Construit un processeur d’images EomtImageProcessor.

#### prétraiter[[transformers.EomtImageProcessorPil.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: list[torch.Tensor] | None = None, instance_id_to_semantic_id: dict[int, int] | None = None, **kwargs: *<class 'transformers.models.eomt.image_processing_pil_eomt.EomtImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L281)

**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 à prétraiter pour les images correspondantes.

instance_id_to_semantic_id (`list[dict[int, int]]` ou `dict[int, int]`, *facultatif*) : Un mappage 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é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 (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 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.

do_split_image (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_split_image`) : Indique s'il faut diviser les images d'entrée en tuiles chevauchantes pour la segmentation sémantique. Si la valeur est `True`, les images d'entrée sont découpé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 marqués avec 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[[transformers.EomtImageProcessorPil.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]], size: dict[str, int] | None = None, return_segmentation_scores: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L495)

**Paramètres :**

outputs ([EomtForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.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*, 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.

Convertit la sortie de [EomtForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.EomtForUniversalSegmentation) en cartes de segmentation sémantique.

#### post_process_instance_segmentation[[transformers.EomtImageProcessorPil.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, size: dict[str, int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L620)

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

#### post_process_panoptic_segmentation[[transformers.EomtImageProcessorPil.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, stuff_classes: list[int] | None = None, size: dict[str, int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L567)

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

## EomtConfig[[transformers.EomtConfig]]

#### transformers.EomtConfig[[transformers.EomtConfig]]

```python
transformers.EomtConfig(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, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 640, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, mlp_ratio: int = 4, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, num_upscale_blocks: int = 2, attention_dropout: float | int = 0.0, use_swiglu_ffn: bool = False, num_blocks: int = 4, no_object_weight: float = 0.1, class_weight: float = 2.0, mask_weight: float = 5.0, dice_weight: float = 5.0, train_num_points: int = 12544, oversample_ratio: float = 3.0, importance_sample_ratio: float = 0.75, num_queries: int = 200, num_register_tokens: int = 4)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/configuration_eomt.py#L28)

**Paramètres :**

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, valeur 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) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur 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*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `640`) : La taille (résolution) de chaque image.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur 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*, valeur 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 suréchantillonnage 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*, 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*, valeur 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) : Taux de suréchantillonnage utilisé lors de 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 leur 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, 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 [tue-mps/coco_panoptic_eomt_large_640](https://huggingface.co/tue-mps/coco_panoptic_eomt_large_640)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import EomtConfig, EomtForUniversalSegmentation

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

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

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

## EomtForUniversalSegmentation[[transformers.EomtForUniversalSegmentation]]

#### transformers.EomtForUniversalSegmentation[[transformers.EomtForUniversalSegmentation]]

```python
transformers.EomtForUniversalSegmentation(config: EomtConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/modeling_eomt.py#L1016)

**Paramètres :**

config ([EomtConfig](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.EomtForUniversalSegmentation.forward]]

```python
forward(pixel_values: Tensor, mask_labels: list[torch.Tensor] | None = None, class_labels: list[torch.Tensor] | None = None, patch_offsets: list[torch.Tensor] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/modeling_eomt.py#L1074)

**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 [EomtImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.EomtImageProcessor). Voir [EomtImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [EomtImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.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 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]`.

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

Un `EomtForUniversalSegmentationOutput` 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 ([EomtConfig](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.EomtConfig)) et les entrées.

La méthode forward de [EomtForUniversalSegmentation](/docs/transformers/v5.23.0/fr/model_doc/eomt#transformers.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.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.
- **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 couche.
- **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 de toutes les couches du modèle.
- **attentions** (`tuple(tuple(torch.Tensor))`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `tuple(torch.Tensor)` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Poids des attentions auto et croisées du décodeur du transformer.
- **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.

