# EoMT ## Visão geral O modelo [The Encoder-only Mask Transformer](https://www.tue-mps.org/eomt) (EoMT) foi introduzido no paper destaque da 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 e Daan de Geus. O EoMT demonstra que os Vision Transformers podem realizar segmentação de imagem de forma eficiente, sem componentes específicos para a tarefa. O resumo do artigo é o seguinte: *Os Vision Transformers (ViTs) demonstraram desempenho e escalabilidade notáveis em diversas tarefas de visão computacional. Para aplicar ViTs de escala única à segmentação de imagens, os métodos existentes adotam um adaptador convolucional para gerar recursos multiescala, um decodificador de pixels para fundir esses recursos e um decodificador Transformer que utiliza os recursos fundidos para fazer previsões. Neste artigo, mostramos que os vieses indutivos introduzidos por esses componentes específicos da tarefa podem, em vez disso, ser aprendidos pelo próprio ViT, desde que se utilizem modelos suficientemente grandes e pré-treinamento extensivo. Com base nessas descobertas, introduzimos o Encoder-only Mask Transformer (EoMT), que reaproveita a arquitetura simples do ViT para realizar segmentação de imagens. Com modelos de grande escala e pré-treinamento, o EoMT obtém uma precisão de segmentação semelhante à de modelos de estado da arte que utilizam componentes específicos da tarefa. Ao mesmo tempo, o EoMT é significativamente mais rápido que esses métodos devido à sua simplicidade arquitetural, por exemplo, até 4x mais rápido com ViT-L. Em uma ampla gama de tamanhos de modelo, o EoMT demonstra um equilíbrio ótimo entre a precisão de segmentação e a velocidade de previsão, sugerindo que os recursos computacionais são melhor gastos escalando o próprio ViT em vez de adicionar complexidade arquitetural.* Este modelo foi contribuído por [Yaswanth Gali](https://huggingface.co/yaswanthgali). O código original pode ser encontrado [aqui](https://github.com/tue-mps/eomt). ## Informações da Arquitetura O modelo `EoMT` utiliza um Vision Transformer pré-treinado com DINOv2, com **register tokens**, como sua base. O EoMT simplifica o pipeline de segmentação ao depender exclusivamente do codificador, eliminando a necessidade dos decodificadores específicos de tarefa comumente usados em abordagens anteriores. Arquiteturalmente, o EoMT introduz um pequeno conjunto de **queries aprendidas** e um módulo leve de **predição de máscara**. Essas queries são injetadas nos blocos finais do codificador, permitindo **atenção conjunta** entre patches de imagem e queries de objeto. Durante o treinamento, é aplicada **atenção mascarada** para restringir cada query a focar em sua região correspondente — imitando efetivamente a cross-attention. Essa restrição é gradualmente eliminada por meio de uma **estratégia de anelamento de máscara**, permitindo **inferência eficiente, sem decodificador**, sem comprometer o desempenho de segmentação. drawing O modelo suporta segmentação semântica, de instância e panóptica usando uma arquitetura unificada e pós-processamento específico para cada tarefa. ## Exemplos de uso Use a implementação do EoMT da Hugging Face para inferência com modelos pré-treinados. ### Segmentação Semântica O modelo EoMT executa segmentação semântica usando inferência com janela deslizante. A imagem de entrada é redimensionada de modo que o lado mais curto corresponda ao tamanho de entrada alvo, em seguida, ela é dividida em recortes sobrepostos. Cada recorte é então processado pelo modelo. Após a inferência, os logits previstos de cada recorte são reunidos novamente e redimensionados para o tamanho original da imagem, obtendo-se a máscara de segmentação final. > **Observação:** Se você deseja usar um tamanho de destino personalizado para **segmentação semântica**, especifique-o no seguinte formato: `{"shortest_edge": 512}` Observe que `longest_edge` não é fornecido aqui — isso é intencional. Para segmentação semântica, as imagens são tipicamente **escaladas de modo que a aresta mais curta seja maior ou igual ao tamanho de destino**, portanto, longest_edge não é necessário. ```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() ``` ### Segmentação de Instâncias O modelo EoMT executa segmentação de instâncias usando inferência com preenchimento. A imagem de entrada é redimensionada para que o lado mais longo corresponda ao tamanho de entrada alvo, e o lado mais curto é preenchido com zeros para formar um quadrado. A máscara resultante e os logits de classe são combinados por meio de pós-processamento (adaptado do Mask2Former) para produzir um mapa unificado de segmentação de instâncias, juntamente com metadados dos segmentos, como id do segmento, rótulos de classe e pontuações de confiança. > **Observação:** Para usar um tamanho de destino personalizado, especifique o tamanho como um dicionário no seguinte formato: `{"shortest_edge": 512, "longest_edge": 512}` Tanto para segmentação de instâncias quanto para segmentação panóptica, as imagens de entrada serão **redimensionadas e preenchidas** para esse tamanho 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() ``` ### Segmentação Panótica O modelo EoMT executa segmentação panótica usando a mesma estratégia de inferência com preenchimento (padding) que na segmentação de instâncias. Após o preenchimento e a normalização, o modelo prevê tanto as classes de objetos (instâncias) quanto as classes de regiões (regiões amorfas). A máscara resultante e os logits de classe são combinados por meio de pós-processamento (adaptado do Mask2Former) para produzir um mapa de segmentação panótica unificado, juntamente com metadados dos segmentos, como id do segmento, rótulos de classe e pontuações de confiança. ```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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L214) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'shortest_edge' : 640, 'longest_edge': 640}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.485, 0.456, 0.406]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.229, 0.224, 0.225]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. do_split_image (`bool`, *kwargs*, *opcional*, padrão `self.do_split_image`) : Se as imagens de entrada devem ser divididas em patches sobrepostos para segmentação semântica. Se definido como `True`, as imagens de entrada serão divididas em patches de tamanho `size["shortest_edge"]` com sobreposição entre os patches. Caso contrário, as imagens de entrada serão preenchidas até o tamanho alvo. ignore_index (`int`, *kwargs*, *opcional*, padrão é `self.ignore_index`) : Rótulo a ser atribuído aos pixels de fundo em mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. Constrói um processador de imagens 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/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]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. segmentation_maps (`ImageInput`, *opcional*) : Os mapas de segmentação a serem pré-processados para as imagens correspondentes. instance_id_to_semantic_id (`list[dict[int, int]]` ou `dict[int, int]`, *opcional*) : Um mapeamento entre ids de instâncias de objetos e ids de classes. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. do_split_image (`bool`, *kwargs*, *opcional*, padrão `self.do_split_image`) : Se as imagens de entrada devem ser divididas em patches sobrepostos para segmentação semântica. Se definido como `True`, as imagens de entrada serão divididas em patches de tamanho `size["shortest_edge"]` com sobreposição entre os patches. Caso contrário, as imagens de entrada serão preenchidas até o tamanho alvo. ignore_index (`int`, *kwargs*, *opcional*, padrão é `self.ignore_index`) : Rótulo a ser atribuído aos pixels de fundo em mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. #### post_process_semantic_segmentation[[transformers.EomtImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list, size: dict[str, int] | None = None, return_segmentation_scores: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L502) **Parâmetros:** outputs ([EomtForUniversalSegmentation](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : Saídas brutas do modelo. target_sizes (`list[tuple[int, int]]`) : Uma lista de tuplas (`tuple[int, int]`) contendo o tamanho alvo (altura, largura) de cada imagem no lote. size (`dict[str, int]`, *opcional*) : O tamanho para o qual as máscaras intermediárias são interpoladas. O padrão é `self.size`. return_segmentation_scores (`bool`, *opcional*, padrão `False`) : Se deve retornar as pontuações de segmentação junto com o mapa de segmentação. Quando `True`, cada elemento da lista retornada é um `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). **Retorna:** `list[torch.Tensor]` ou `list[SemanticSegmentationPostProcessorOutput]` Quando `return_segmentation_scores=False` (padrão), uma lista de comprimento `batch_size` em que cada item é um mapa de segmentação de forma `(height, width)` com IDs de classe. Quando `return_segmentation_scores=True`, uma lista de `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). Em ambos os casos, `(height, width)` corresponde ao tamanho alvo. Converte a saída de [EomtForUniversalSegmentation](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtForUniversalSegmentation) em mapas de segmentação semântica. #### post_process_instance_segmentation[[transformers.EomtImageProcessor.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, target_sizes: list, threshold: float = 0.8, size: dict[str, int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L635) Processa os resultados do modelo em previsões de segmentação de instâncias. #### post_process_panoptic_segmentation[[transformers.EomtImageProcessor.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, target_sizes: list, 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L578) Processa os resultados do modelo para gerar a previsão final de segmentação panótica. ## EomtImageProcessorPil[[transformers.EomtImageProcessorPil]] #### transformers.EomtImageProcessorPil[[transformers.EomtImageProcessorPil]] ```python transformers.EomtImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L215) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'shortest_edge' : 640, 'longest_edge': 640}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.485, 0.456, 0.406]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.229, 0.224, 0.225]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. do_split_image (`bool`, *kwargs*, *opcional*, padrão `self.do_split_image`) : Se as imagens de entrada devem ser divididas em patches sobrepostos para segmentação semântica. Se definido como `True`, as imagens de entrada serão divididas em patches de tamanho `size["shortest_edge"]` com sobreposição entre os patches. Caso contrário, as imagens de entrada serão preenchidas até o tamanho alvo. ignore_index (`int`, *kwargs*, *opcional*, padrão é `self.ignore_index`) : Rótulo a ser atribuído aos pixels de fundo em mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. Constrói um processador de imagens 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/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]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. segmentation_maps (`ImageInput`, *opcional*) : Os mapas de segmentação a serem pré-processados para as imagens correspondentes. instance_id_to_semantic_id (`list[dict[int, int]]` ou `dict[int, int]`, *opcional*) : Um mapeamento entre ids de instâncias de objetos e ids de classes. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. do_split_image (`bool`, *kwargs*, *opcional*, padrão `self.do_split_image`) : Se as imagens de entrada devem ser divididas em patches sobrepostos para segmentação semântica. Se definido como `True`, as imagens de entrada serão divididas em patches de tamanho `size["shortest_edge"]` com sobreposição entre os patches. Caso contrário, as imagens de entrada serão preenchidas até o tamanho alvo. ignore_index (`int`, *kwargs*, *opcional*, padrão é `self.ignore_index`) : Rótulo a ser atribuído aos pixels de fundo em mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. #### post_process_semantic_segmentation[[transformers.EomtImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list, size: dict[str, int] | None = None, return_segmentation_scores: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L495) **Parâmetros:** outputs ([EomtForUniversalSegmentation](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : Saídas brutas do modelo. target_sizes (`list[tuple[int, int]]`) : Uma lista de tuplas (`tuple[int, int]`) contendo o tamanho alvo (altura, largura) de cada imagem no lote. size (`dict[str, int]`, *opcional*) : O tamanho para o qual as máscaras intermediárias são interpoladas. O padrão é `self.size`. return_segmentation_scores (`bool`, *opcional*, padrão `False`) : Se deve retornar as pontuações de segmentação junto com o mapa de segmentação. Quando `True`, cada elemento da lista retornada é um `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). **Retorna:** `list[torch.Tensor]` ou `list[SemanticSegmentationPostProcessorOutput]` Quando `return_segmentation_scores=False` (padrão), uma lista de comprimento `batch_size` em que cada item é um mapa de segmentação de forma `(height, width)` com IDs de classe. Quando `return_segmentation_scores=True`, uma lista de `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). Em ambos os casos, `(height, width)` corresponde ao tamanho alvo. Converte a saída de [EomtForUniversalSegmentation](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtForUniversalSegmentation) em mapas de segmentação semântica. #### post_process_instance_segmentation[[transformers.EomtImageProcessorPil.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, target_sizes: list, threshold: float = 0.8, size: dict[str, int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L620) Processa os resultados do modelo em previsões de segmentação de instâncias. #### post_process_panoptic_segmentation[[transformers.EomtImageProcessorPil.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, target_sizes: list, 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L567) Processa os resultados do modelo para gerar a previsão final de segmentação panótica. ## 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/configuration_eomt.py#L28) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas. num_hidden_layers (`int`, *opcional*, padrão `24`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `640`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. mlp_ratio (`int`, *opcional*, padrão `4`) : Razão entre a dimensão oculta do MLP e a dimensão de incorporação. layerscale_value (`float`, *opcional*, padrão 1.0) : Valor inicial para o parâmetro LayerScale. drop_path_rate (`Union[float, int]`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches. num_upscale_blocks (`int`, *opcional*, padrão 2) : Número de blocos de amostragem ascendente usados no decodificador ou na cabeça de segmentação. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. use_swiglu_ffn (`bool`, *opcional*, padrão `False`) : Se deve usar a rede neural feedforward SwiGLU. num_blocks (`int`, *opcional*, padrão 4) : Número de blocos de recursos ou estágios na arquitetura. no_object_weight (`float`, *opcional*, padrão 0.1) : Peso da perda para a classe 'no object' em segmentação panotópica/por instância. class_weight (`float`, *opcional*, padrão 2.0) : Peso da perda para os alvos de classificação. mask_weight (`float`, *opcional*, padrão 5.0) : Peso da perda para a previsão da máscara. dice_weight (`float`, *opcional*, padrão `5.0`) : Peso relativo da perda dice na perda de segmentação panótica. train_num_points (`int`, *opcional*, padrão 12544) : Número de pontos a amostrar para o cálculo da perda de máscara durante o treinamento. oversample_ratio (`float`, *opcional*, padrão 3.0) : Razão de oversampling usada na amostragem de pontos para o treinamento de máscaras. importance_sample_ratio (`float`, *opcional*, padrão 0.75) : Proporção de pontos a amostrar com base na importância durante o treinamento. num_queries (`int`, *opcional*, padrão 200) : Número de consultas de objeto no Transformer. num_register_tokens (`int`, *opcional*, padrão 4) : Número de tokens de registro aprendíveis adicionados à entrada do transformer. Esta é a classe de configuração para armazenar a configuração de um EomtModel. Ela é usada para instanciar um modelo Eomt de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [tue-mps/coco_panoptic_eomt_large_640](https://huggingface.co/tue-mps/coco_panoptic_eomt_large_640) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/modeling_eomt.py#L1016) **Parâmetros:** config ([EomtConfig](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O Modelo EoMT com head no topo para segmentação de instância/semântica/panóptica. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/modeling_eomt.py#L1074) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [EomtImageProcessor](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtImageProcessor). Consulte [EomtImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [EomtImageProcessor](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtImageProcessor) para processar imagens). mask_labels (`list[torch.Tensor]`, *opcional*) : lista de rótulos de máscara com forma `(num_labels, height, width)` para ser fornecida a um modelo class_labels (`list[torch.LongTensor]`, *opcional*) : lista de rótulos de classes alvo com formato `(num_labels, height, width)` para ser fornecida a um modelo. Eles identificam os rótulos de `mask_labels`, por exemplo, o rótulo de `mask_labels[i][j]` se `class_labels[i][j]`. patch_offsets (`list[torch.Tensor]`, *opcional*) : lista de tuplas indicando o índice da imagem e as posições de início e fim dos patches para segmentação semântica. **Retorna:** `EomtForUniversalSegmentationOutput` ou `tuple(torch.Tensor)` Um `EomtForUniversalSegmentationOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EomtConfig](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtConfig)) e das entradas. O método forward de [EomtForUniversalSegmentation](/docs/transformers/main/pt/model_doc/eomt#transformers.EomtForUniversalSegmentation) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor`, *opcional*) -- A perda calculada, retornada quando os rótulos estão presentes. - **class_queries_logits** (`torch.Tensor`, *opcional*) -- Um tensor de forma `(batch_size, num_queries, num_labels + 1)` representando as classes propostas para cada query. Observe que o `+ 1` é necessário porque incorporamos a classe nula. - **masks_queries_logits** (`torch.Tensor`, *opcional*) -- Um tensor de forma `(batch_size, num_queries, height, width)` representando as máscaras propostas para cada consulta. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Últimos estados ocultos (mapa de recursos final) da última camada. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada estágio) com forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos de todas as camadas do modelo. - **attentions** (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `tuple(torch.Tensor)` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de Self e Cross Attentions do decodificador do transformer. - **patch_offsets** (`list[torch.Tensor]`, *opcional*) -- lista de tuplas indicando o índice da imagem e as posições de início e fim dos patches para segmentação semântica.