# EoMT ## Resumen El modelo [Encoder-only Mask Transformer](https://www.tue-mps.org/eomt) (EoMT) se presentó en el artículo destacado de CVPR 2025 *[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 y Daan de Geus. EoMT demuestra que los Vision Transformers pueden realizar segmentación de imágenes de manera eficiente sin componentes específicos de la tarea. El resumen del artículo es el siguiente: *Los Vision Transformers (ViTs) han demostrado un rendimiento y una escalabilidad notables en diversas tareas de visión por computadora. Para aplicar ViTs de una sola escala a la segmentación de imágenes, los métodos existentes adoptan un adaptador convolucional para generar características multiescala, un decodificador de píxeles para fusionar estas características y un decodificador Transformer que utiliza las características fusionadas para realizar predicciones. En este artículo, demostramos que los sesgos inductivos introducidos por estos componentes específicos de la tarea pueden aprenderse en su lugar por el propio ViT, siempre que se utilicen modelos suficientemente grandes y un preentrenamiento extenso. Basándonos en estos hallazgos, presentamos el Encoder-only Mask Transformer (EoMT), que reutiliza la arquitectura ViT estándar para realizar la segmentación de imágenes. Con modelos a gran escala y preentrenamiento, EoMT obtiene una precisión de segmentación similar a la de los modelos de última generación que utilizan componentes específicos de la tarea. Al mismo tiempo, EoMT es significativamente más rápido que estos métodos debido a su simplicidad arquitectónica, por ejemplo, hasta 4 veces más rápido con ViT-L. En una amplia gama de tamaños de modelo, EoMT demuestra un equilibrio óptimo entre la precisión de segmentación y la velocidad de predicción, lo que sugiere que los recursos de cómputo se destinan mejor a escalar el propio ViT en lugar de añadir complejidad arquitectónica.* Este modelo fue aportado por [Yaswanth Gali](https://huggingface.co/yaswanthgali). El código original se puede encontrar [aquí](https://github.com/tue-mps/eomt). ## Información de la arquitectura El modelo `EoMT` utiliza un Vision Transformer preentrenado con DINOv2 con **register tokens** como su backbone. EoMT simplifica el pipeline de segmentación al depender únicamente del codificador, eliminando la necesidad de decodificadores específicos de la tarea que se utilizan comúnmente en enfoques anteriores. Arquitectónicamente, EoMT introduce un pequeño conjunto de **consultas aprendidas** y un módulo ligero de **predicción de máscaras**. Estas consultas se inyectan en los bloques finales del codificador, lo que permite una **atención conjunta** entre los parches de imagen y las consultas de objetos. Durante el entrenamiento, se aplica una **atención enmascarada** para restringir cada consulta a que se centre en su región correspondiente, imitando de forma efectiva la atención cruzada. Esta restricción se elimina gradualmente mediante una **estrategia de recocido de máscaras**, lo que permite una **inferencia eficiente y sin decodificador** sin comprometer el rendimiento de la segmentación. drawing El modelo admite segmentación semántica, de instancias y panóptica mediante una arquitectura unificada y un posprocesado específico de cada tarea. ## Ejemplos de uso Utilice la implementación de EoMT de Hugging Face para la inferencia con modelos preentrenados. ### Segmentación semántica El modelo EoMT realiza segmentación semántica mediante inferencia con ventanas deslizantes. La imagen de entrada se redimensiona de modo que el lado más corto coincida con el tamaño de entrada objetivo, y luego se divide en recortes superpuestos. Cada recorte se pasa a través del modelo. Después de la inferencia, los logits predichos de cada recorte se vuelven a unir y se reescalan al tamaño original de la imagen para obtener la máscara de segmentación final. > **Nota:** Si deseas usar un tamaño de destino personalizado para **segmentación semántica**, especifícalo en el siguiente formato: `{"shortest_edge": 512}` Ten en cuenta que `longest_edge` no se proporciona aquí, y esto es intencional. En la segmentación semántica, las imágenes suelen **escalar de modo que el borde más corto sea mayor o igual al tamaño de destino**, por lo que longest_edge no es necesario. ```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() ``` ### Segmentación de instancias El modelo EoMT realiza segmentación de instancias mediante inferencia con relleno. La imagen de entrada se redimensiona para que el lado más largo coincida con el tamaño de entrada objetivo, y el lado más corto se rellena con ceros para formar un cuadrado. La máscara resultante y los logits de clase se combinan mediante un posprocesado (adaptado de Mask2Former) para producir un mapa unificado de segmentación de instancias, junto con metadatos de los segmentos como el id del segmento, las etiquetas de clase y las puntuaciones de confianza. > **Nota:** Para usar un tamaño de destino personalizado, especifique el tamaño como un diccionario en el siguiente formato: `{"shortest_edge": 512, "longest_edge": 512}` Tanto para la segmentación de instancias como para la segmentación panóptica, las imágenes de entrada se **escalarán y rellenarán** hasta este tamaño de destino. ```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() ``` ### Segmentación Panóptica El modelo EoMT realiza segmentación panóptica utilizando la misma estrategia de inferencia con relleno que en la segmentación de instancias. Después del relleno y la normalización, el modelo predice tanto las clases de thing (instancias) como las de stuff (regiones amorfas). La máscara y los logits de clase resultantes se combinan mediante un posprocesado (adaptado de Mask2Former) para producir un mapa de segmentación panóptica unificado, junto con metadatos de los segmentos como el id del segmento, las etiquetas de clase y las puntuaciones de confianza. ```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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L214) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'shortest_edge' : 640, 'longest_edge': 640}`): Describe las dimensiones máximas de entrada al modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando size es un int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. do_split_image (`bool`, *kwargs*, *opcional*, valor predeterminado `self.do_split_image`) : Indica si se deben dividir las imágenes de entrada en parches superpuestos para la segmentación semántica. Si se establece en `True`, las imágenes de entrada se dividirán en parches de tamaño `size["shortest_edge"]` con una superposición entre parches. En caso contrario, las imágenes de entrada se rellenarán hasta el tamaño objetivo. ignore_index (`int`, *kwargs*, *opcional*, valor predeterminado `self.ignore_index`) : Etiqueta que se asignará a los píxeles de fondo en los mapas de segmentación. Si se proporciona, los píxeles del mapa de segmentación marcados con 0 (fondo) se reemplazarán con `ignore_index`. Construye un procesador de imágenes EomtImageProcessor. #### preprocess[[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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L273) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. segmentation_maps (`ImageInput`, *opcional*) : Los mapas de segmentación que se preprocesarán para las imágenes correspondientes. instance_id_to_semantic_id (`list[dict[int, int]]` o `dict[int, int]`, *opcional*) : Un mapeo entre los ids de instancias de objetos y los ids de clases. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. do_split_image (`bool`, *kwargs*, *opcional*, valor predeterminado `self.do_split_image`) : Indica si se deben dividir las imágenes de entrada en parches superpuestos para la segmentación semántica. Si se establece en `True`, las imágenes de entrada se dividirán en parches de tamaño `size["shortest_edge"]` con una superposición entre parches. En caso contrario, las imágenes de entrada se rellenarán hasta el tamaño objetivo. ignore_index (`int`, *kwargs*, *opcional*, valor predeterminado `self.ignore_index`) : Etiqueta que se asignará a los píxeles de fondo en los mapas de segmentación. Si se proporciona, los píxeles del mapa de segmentación marcados con 0 (fondo) se reemplazarán con `ignore_index`. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. #### 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L502) **Parámetros:** outputs ([EomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : Salidas sin procesar del modelo. target_sizes (`list[tuple[int, int]]`) : Una lista de tuplas (`tuple[int, int]`) que contiene el tamaño objetivo (altura, ancho) de cada imagen del lote. size (`dict[str, int]`, *opcional*) : El tamaño al que se interpolan las máscaras intermedias. El valor predeterminado es `self.size`. return_segmentation_scores (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las puntuaciones de segmentación junto con el mapa de segmentación. Cuando `True`, cada elemento de la lista devuelta es un `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`). **Devuelve:** `list[torch.Tensor]` o `list[SemanticSegmentationPostProcessorOutput]` Cuando `return_segmentation_scores=False` (valor predeterminado), se devuelve una lista de longitud `batch_size` donde cada elemento es un mapa de segmentación de forma `(height, width)` con IDs de clase. Cuando `return_segmentation_scores=True`, se devuelve una lista de `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`). En ambos casos, `(height, width)` corresponde al tamaño objetivo. Convierte la salida de [EomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtForUniversalSegmentation) en mapas de segmentación semántica. #### 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L635) Procesa las salidas del modelo para convertirlas en predicciones de segmentación de instancias. #### 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L578) Procesa los resultados del modelo para obtener la predicción final de segmentación panóptica. ## EomtImageProcessorPil[[transformers.EomtImageProcessorPil]] #### transformers.EomtImageProcessorPil[[transformers.EomtImageProcessorPil]] ```python transformers.EomtImageProcessorPil(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L215) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'shortest_edge' : 640, 'longest_edge': 640}`): Describe las dimensiones máximas de entrada al modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando size es un int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. do_split_image (`bool`, *kwargs*, *opcional*, valor predeterminado `self.do_split_image`) : Indica si se deben dividir las imágenes de entrada en parches superpuestos para la segmentación semántica. Si se establece en `True`, las imágenes de entrada se dividirán en parches de tamaño `size["shortest_edge"]` con una superposición entre parches. En caso contrario, las imágenes de entrada se rellenarán hasta el tamaño objetivo. ignore_index (`int`, *kwargs*, *opcional*, valor predeterminado `self.ignore_index`) : Etiqueta que se asignará a los píxeles de fondo en los mapas de segmentación. Si se proporciona, los píxeles del mapa de segmentación marcados con 0 (fondo) se reemplazarán con `ignore_index`. Construye un procesador de imágenes EomtImageProcessor. #### preprocess[[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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L281) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. segmentation_maps (`ImageInput`, *opcional*) : Los mapas de segmentación que se preprocesarán para las imágenes correspondientes. instance_id_to_semantic_id (`list[dict[int, int]]` o `dict[int, int]`, *opcional*) : Un mapeo entre los ids de instancias de objetos y los ids de clases. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. do_split_image (`bool`, *kwargs*, *opcional*, valor predeterminado `self.do_split_image`) : Indica si se deben dividir las imágenes de entrada en parches superpuestos para la segmentación semántica. Si se establece en `True`, las imágenes de entrada se dividirán en parches de tamaño `size["shortest_edge"]` con una superposición entre parches. En caso contrario, las imágenes de entrada se rellenarán hasta el tamaño objetivo. ignore_index (`int`, *kwargs*, *opcional*, valor predeterminado `self.ignore_index`) : Etiqueta que se asignará a los píxeles de fondo en los mapas de segmentación. Si se proporciona, los píxeles del mapa de segmentación marcados con 0 (fondo) se reemplazarán con `ignore_index`. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. #### 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L495) **Parámetros:** outputs ([EomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : Salidas sin procesar del modelo. target_sizes (`list[tuple[int, int]]`) : Una lista de tuplas (`tuple[int, int]`) que contiene el tamaño objetivo (altura, ancho) de cada imagen del lote. size (`dict[str, int]`, *opcional*) : El tamaño al que se interpolan las máscaras intermedias. El valor predeterminado es `self.size`. return_segmentation_scores (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las puntuaciones de segmentación junto con el mapa de segmentación. Cuando `True`, cada elemento de la lista devuelta es un `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`). **Devuelve:** `list[torch.Tensor]` o `list[SemanticSegmentationPostProcessorOutput]` Cuando `return_segmentation_scores=False` (valor predeterminado), se devuelve una lista de longitud `batch_size` donde cada elemento es un mapa de segmentación de forma `(height, width)` con IDs de clase. Cuando `return_segmentation_scores=True`, se devuelve una lista de `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`). En ambos casos, `(height, width)` corresponde al tamaño objetivo. Convierte la salida de [EomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtForUniversalSegmentation) en mapas de segmentación semántica. #### 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L620) Procesa las salidas del modelo para convertirlas en predicciones de segmentación de instancias. #### 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L567) Procesa los resultados del modelo para obtener la predicción final de segmentación panóptica. ## 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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/configuration_eomt.py#L28) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas. num_hidden_layers (`int`, *opcional*, valor predeterminado `24`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La probabilidad de dropout para todas las capas completamente conectadas en los embeddings, el codificador y el pooler. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `640`) : El tamaño (resolución) de cada imagen. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche. num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada. mlp_ratio (`int`, *opcional*, valor predeterminado `4`) : Proporción entre la dimensión oculta del MLP y la dimensión de incrustación. layerscale_value (`float`, *opcional*, valor predeterminado 1.0) : Valor inicial para el parámetro LayerScale. drop_path_rate (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : Tasa de drop path para la fusión de parches. num_upscale_blocks (`int`, *opcional*, valor predeterminado 2) : Número de bloques de remuestreo ascendente utilizados en el decodificador o la cabeza de segmentación. attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención. use_swiglu_ffn (`bool`, *opcional*, por defecto `False`) : Si se debe usar la red neuronal de avance SwiGLU. num_blocks (`int`, *opcional*, valor predeterminado 4) : Número de bloques de características o etapas en la arquitectura. no_object_weight (`float`, *opcional*, valor predeterminado 0.1) : Peso de la pérdida para la clase 'no object' en la segmentación panoptica/instancia. class_weight (`float`, *opcional*, valor predeterminado 2.0) : Peso de la pérdida para los objetivos de clasificación. mask_weight (`float`, *opcional*, valor predeterminado 5.0) : Peso de la pérdida para la predicción de la máscara. dice_weight (`float`, *opcional*, valor predeterminado `5.0`) : Peso relativo de la pérdida dice en la pérdida de segmentación panóptica. train_num_points (`int`, *opcional*, valor predeterminado 12544) : Número de puntos a muestrear para el cálculo de la pérdida de máscara durante el entrenamiento. oversample_ratio (`float`, *opcional*, valor predeterminado 3.0) : Relación de sobremuestreo utilizada en el muestreo de puntos para el entrenamiento de máscaras. importance_sample_ratio (`float`, *opcional*, valor predeterminado 0.75) : Proporción de puntos a muestrear en función de la importancia durante el entrenamiento. num_queries (`int`, *opcional*, valor predeterminado 200) : Número de consultas de objetos en el Transformer. num_register_tokens (`int`, *opcional*, valor predeterminado: 4) : Número de tokens de registro aprendibles añadidos a la entrada del transformer. Esta es la clase de configuración para almacenar la configuración de un EomtModel. Se utiliza para instanciar un modelo Eomt según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [tue-mps/coco_panoptic_eomt_large_640](https://huggingface.co/tue-mps/coco_panoptic_eomt_large_640) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```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) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/modeling_eomt.py#L1016) **Parámetros:** config ([EomtConfig](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo EoMT con la cabeza en la parte superior para segmentación de instancias/semántica/panóptica. Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.). Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales. #### 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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/modeling_eomt.py#L1074) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [EomtImageProcessor](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtImageProcessor). Consulte [EomtImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [EomtImageProcessor](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtImageProcessor) para procesar las imágenes). mask_labels (`list[torch.Tensor]`, *opcional*) : lista de etiquetas de máscara de forma `(num_labels, height, width)` para alimentar a un modelo class_labels (`list[torch.LongTensor]`, *opcional*) : lista de etiquetas de clase objetivo de forma `(num_labels, height, width)` para alimentar a un modelo. Identifican las etiquetas de `mask_labels`, p. ej., la etiqueta de `mask_labels[i][j]` si `class_labels[i][j]`. patch_offsets (`list[torch.Tensor]`, *opcional*) : lista de tuplas que indican el índice de la imagen y las posiciones de inicio y fin de los parches para la segmentación semántica. **Devuelve:** `EomtForUniversalSegmentationOutput` o `tuple(torch.Tensor)` Un `EomtForUniversalSegmentationOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([EomtConfig](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtConfig)) y las entradas. El método forward de [EomtForUniversalSegmentation](/docs/transformers/v5.23.0/es/model_doc/eomt#transformers.EomtForUniversalSegmentation) sobrescribe el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **loss** (`torch.Tensor`, *opcional*) -- La pérdida calculada, devuelta cuando hay etiquetas presentes. - **class_queries_logits** (`torch.Tensor`, *opcional*) -- Un tensor de forma `(batch_size, num_queries, num_labels + 1)` que representa las clases propuestas para cada consulta. Tenga en cuenta que el `+ 1` es necesario porque incorporamos la clase nula. - **masks_queries_logits** (`torch.Tensor`, *opcional*) -- Un tensor de forma `(batch_size, num_queries, height, width)` que representa las máscaras propuestas para cada consulta. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Últimos estados ocultos (mapa de características final) de la última capa. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos de todas las capas del modelo. - **attentions** (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `tuple(torch.Tensor)` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de Self y Cross Attentions del decodificador del transformer. - **patch_offsets** (`list[torch.Tensor]`, *opcional*) -- lista de tuplas que indican el índice de la imagen y las posiciones de inicio y fin de los parches para la segmentación semántica.