Hugging Face's logo

Transformers documentation

EoMT

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

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 24 de marzo de 2025 y se contribuyó a Hugging Face Transformers el 27 de junio de 2025.

EoMT

Resumen

El modelo The Encoder-only Mask Transformer (EoMT) se presentó en el artículo destacado de CVPR 2025 Your ViT is Secretly an Image Segmentation Model, 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. El código original se puede encontrar aquí.

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. Para la segmentación semántica, las imágenes suelen escalar de modo que el borde más corto sea mayor o igual que el tamaño de destino, por lo que no es necesario especificar longest_edge.

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.

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.

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

clase transformers.EomtImageProcessor

< >

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

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 de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado False) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si 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 a 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) — 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 a 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 cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_split_image (bool, kwargs, opcional, valor predeterminado self.do_split_image) — 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 denotados con 0 (fondo) se reemplazarán con ignore_index.

Construye un procesador de imágenes EomtImageProcessor.

preprocesar

< >

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

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 instancia de objeto y los ids de clase.
  • 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 de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si 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) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enum 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 cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_split_image (bool, kwargs, opcional, valor predeterminado self.do_split_image) — 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 denotados 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

< >

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

Parámetros

  • outputs (EomtForUniversalSegmentation) — Salidas crudas 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 (por defecto), 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 en mapas de segmentación semántica.

post_process_instance_segmentation

< >

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

Procesa las salidas del modelo para convertirlas en predicciones de segmentación de instancias.

post_process_panoptic_segmentation

< >

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

Procesa los resultados del modelo para obtener la predicción final de segmentación panóptica.

EomtImageProcessorPil

clase transformers.EomtImageProcessorPil

< >

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

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 de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado False) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si 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 a 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) — 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 a 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 cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_split_image (bool, kwargs, opcional, valor predeterminado self.do_split_image) — 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 denotados con 0 (fondo) se reemplazarán con ignore_index.

Construye un procesador de imágenes EomtImageProcessor.

preprocesar

< >

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

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 instancia de objeto y los ids de clase.
  • 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 de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si 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) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enum 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 cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • do_split_image (bool, kwargs, opcional, valor predeterminado self.do_split_image) — 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 denotados 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

< >

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

Parámetros

  • outputs (EomtForUniversalSegmentation) — Salidas crudas 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 (por defecto), 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 en mapas de segmentación semántica.

post_process_instance_segmentation

< >

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

Procesa las salidas del modelo para convertirlas en predicciones de segmentación de instancias.

post_process_panoptic_segmentation

< >

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

Procesa los resultados del modelo para obtener la predicción final de segmentación panóptica.

EomtConfig

clase transformers.EomtConfig

< >

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

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 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 totalmente conectadas en las incrustaciones, el codificador y el pooler.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-06) — La epsilon utilizada por las capas de normalización de capa.
  • 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) — Relación entre la dimensión oculta del MLP y la dimensión de la 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, valor predeterminado False) — Si se debe usar la red neuronal feedforward 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 que se muestrean 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import EomtConfig, EomtForUniversalSegmentation

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

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

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

EomtForUniversalSegmentation

clase transformers.EomtForUniversalSegmentation

< >

( config: EomtConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

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

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 utilizando EomtImageProcessor. Consulte EomtImageProcessor.call() para más detalles (processor_class utiliza 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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.
Update on GitHub

←EfficientNet EoMT-DINOv3→