# Mask2Former ## Visão geral O modelo Mask2Former foi proposto em [Masked-attention Mask Transformer for Universal Image Segmentation](https://huggingface.co/papers/2112.01527) por Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov e Rohit Girdhar. O Mask2Former é um framework unificado para segmentação panótica, de instâncias e semântica, e apresenta melhorias significativas de desempenho e eficiência em relação ao [MaskFormer](maskformer). O resumo do artigo é o seguinte: *A segmentação de imagens agrupa pixels com semânticas diferentes, por exemplo, categoria ou instância. Cada escolha de semântica define uma tarefa. Embora apenas a semântica de cada tarefa difira, a pesquisa atual se concentra no design de arquiteturas especializadas para cada tarefa. Apresentamos o Masked-attention Mask Transformer (Mask2Former), uma nova arquitetura capaz de lidar com qualquer tarefa de segmentação de imagem (panótica, de instância ou semântica). Seus principais componentes incluem a atenção mascarada, que extrai recursos localizados ao restringir a atenção cruzada dentro das regiões de máscara previstas. Além de reduzir o esforço de pesquisa em pelo menos três vezes, ele supera as melhores arquiteturas especializadas por uma margem significativa em quatro conjuntos de dados populares. Mais notavelmente, o Mask2Former estabelece um novo estado da arte para a segmentação panótica (57,8 PQ no COCO), segmentação de instância (50,1 AP no COCO) e segmentação semântica (57,7 mIoU no ADE20K).* Arquitetura do Mask2Former. Retirada do artigo original. Este modelo foi contribuído por [Shivalika Singh](https://huggingface.co/shivi) e [Alara Dirik](https://huggingface.co/adirik). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/Mask2Former). ## Dicas de uso - O Mask2Former utiliza as mesmas etapas de pré-processamento e pós-processamento que o [MaskFormer](maskformer). Use [Mask2FormerImageProcessor](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor) ou [AutoImageProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoImageProcessor) para preparar as imagens e os alvos opcionais para o modelo. - Para obter a segmentação final, dependendo da tarefa, você pode chamar [post_process_semantic_segmentation()](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_instance_segmentation) ou [post_process_panoptic_segmentation()](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_panoptic_segmentation). As três tarefas podem ser resolvidas usando a saída de [Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation); a segmentação panóptica aceita um argumento opcional `label_ids_to_fuse` para fundir as instâncias do(s) objeto(s) alvo (por exemplo, céu). ## Recursos Uma lista de recursos oficiais do Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o Mask2Former. - Notebooks de demonstração sobre inferência + ajuste fino do Mask2Former em dados personalizados podem ser encontrados [aqui](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Mask2Former). Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão. O recurso deve, idealmente, demonstrar algo novo em vez de duplicar um recurso existente. ## Mask2FormerConfig[[transformers.Mask2FormerConfig]] #### transformers.Mask2FormerConfig[[transformers.Mask2FormerConfig]] ```python transformers.Mask2FormerConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, feature_size: int = 256, mask_feature_size: int = 256, hidden_dim: int = 256, encoder_feedforward_dim: int = 1024, activation_function: str = 'relu', encoder_layers: int = 6, decoder_layers: int = 10, num_attention_heads: int = 8, dropout: float | int = 0.0, dim_feedforward: int = 2048, pre_norm: bool = False, enforce_input_projection: bool = False, common_stride: int = 4, ignore_value: int = 255, num_queries: int = 100, 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, init_std: float = 0.02, init_xavier_std: float = 1.0, use_auxiliary_loss: bool = True, feature_strides: list[int] | tuple[int, ...] = (4, 8, 16, 32), output_auxiliary_logits: bool | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/configuration_mask2former.py#L28) **Parâmetros:** backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone. feature_size (`int`, *opcional*, padrão 256) : Os recursos (canais) dos mapas de recursos resultantes. mask_feature_size (`int`, *opcional*, padrão 256) : O tamanho das características das máscaras; esse valor também será usado para especificar o tamanho das características da Feature Pyramid Network. hidden_dim (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas. encoder_feedforward_dim (`int`, *opcional*, padrão 1024) : Dimensão da rede feedforward do encoder do deformable detr usado como parte do pixel decoder. activation_function (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. encoder_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. decoder_layers (`int`, *opcional*, padrão `10`) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout. dim_feedforward (`int`, *opcional*, padrão 2048) : Dimensão dos recursos na rede feedforward do decodificador do transformer. pre_norm (`bool`, *opcional*, padrão `False`) : Se deve usar pre-LayerNorm ou não no decodificador do transformer. enforce_input_projection (`bool`, *opcional*, padrão `False`) : Se deve adicionar uma convolução de projeção de entrada 1x1, mesmo que os canais de entrada e a dimensão oculta sejam idênticos no decodificador do Transformer. common_stride (`int`, *opcional*, padrão 4) : Parâmetro usado para determinar o número de níveis de FPN utilizados como parte do decodificador de pixels. ignore_value (`int`, *opcional*, padrão 255) : ID da categoria a ser ignorado durante o treinamento. num_queries (`int`, *opcional*, padrão 100) : Número de consultas para o decodificador. no_object_weight (`float`, *opcional*, padrão `0.1`) : Peso relativo de classificação da classe sem objeto na perda de detecção de objetos. class_weight (`float`, *opcional*, padrão `2.0`) : Peso relativo do erro de classificação no custo de correspondência húngara. mask_weight (`float`, *opcional*, padrão `5.0`) : Peso relativo da focal loss na perda de segmentação panótica. dice_weight (`float`, *opcional*, padrão `5.0`) : Peso relativo da perda dice na perda de segmentação panótica. train_num_points (`str` ou `function`, *opcional*, padrão 12544) : Número de pontos usados para amostragem durante o cálculo da perda. oversample_ratio (`float`, *opcional*, padrão 3.0) : Parâmetro de supersampling usado para calcular o número de pontos amostrados importance_sample_ratio (`float`, *opcional*, padrão 0.75) : Proporção de pontos amostrados por amostragem de importância. init_std (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. init_xavier_std (`float`, *opcional*, padrão `1.0`) : O fator de escala usado na inicialização Xavier dos pesos de atenção cruzada. use_auxiliary_loss (`bool`, *opcional*, padrão `True`) : Se deve calcular a perda usando as previsões intermediárias do decodificador do transformer. feature_strides (`list[int]`, *opcional*, padrão `[4, 8, 16, 32]`) : Passos de recursos correspondentes aos recursos gerados pela rede backbone. output_auxiliary_logits (`bool`, *opcional*) : Se o modelo deve ou não produzir seus `auxiliary_logits`. Esta é a classe de configuração para armazenar a configuração de um Mask2FormerModel. Ela é usada para instanciar um modelo Mask2Former 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 [facebook/mask2former-swin-small-coco-instance](https://huggingface.co/facebook/mask2former-swin-small-coco-instance) 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. Exemplos: ```python >>> from transformers import Mask2FormerConfig, Mask2FormerModel >>> # Initializing a Mask2Former facebook/mask2former-swin-small-coco-instance configuration >>> configuration = Mask2FormerConfig() >>> # Initializing a model (with random weights) from the facebook/mask2former-swin-small-coco-instance style configuration >>> model = Mask2FormerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Saídas específicas do MaskFormer[[transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput]] #### transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput[[transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput]] ```python transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput(encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, pixel_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, transformer_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, pixel_decoder_hidden_states: tuple[torch.Tensor] | None = None, transformer_decoder_hidden_states: tuple[torch.Tensor] | None = None, transformer_decoder_intermediate_states: tuple[torch.Tensor] | None = None, masks_queries_logits: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/modeling_mask2former.py#L143) **Parâmetros:** encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`, *opcional*) : Últimos estados ocultos (mapa de recursos final) do último estágio do modelo codificador (backbone). Retornado quando `output_hidden_states=True` é passado. pixel_decoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`, *opcional*) : Últimos estados ocultos (mapa de recursos final) do último estágio do modelo decodificador de pixels. transformer_decoder_last_hidden_state (`tuple(torch.Tensor)`) : Saída final do decodificador do transformer `(batch_size, sequence_length, hidden_size)`. encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*) : Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada estágio) com forma `(batch_size, num_channels, height, width)`. Estados ocultos (também chamados de mapas de características) do modelo codificador na saída de cada estágio. Retornado quando `output_hidden_states=True` é passado. pixel_decoder_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, num_channels, height, width)`. Hidden-states (também chamados de feature maps) do modelo pixel decoder na saída de cada estágio. Retornado quando `output_hidden_states=True` é passado. transformer_decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*) : 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 (também chamados de mapas de características) do decodificador do transformer na saída de cada estágio. Retornado quando `output_hidden_states=True` é passado. transformer_decoder_intermediate_states (`tuple(torch.Tensor)` de forma `(num_queries, 1, hidden_size)`) : Ativações intermediárias do decodificador, ou seja, a saída de cada camada do decodificador, cada uma delas passando por um layernorm. masks_queries_logits (`tuple(torch.Tensor)` de forma `(batch_size, num_queries, height, width)`) : Previsões de máscara de cada camada no decodificador do transformer. attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True` é passado) : Tupla de `tuple(torch.Tensor)` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de autoatenção do decodificador do transformer. attentions (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. Classe para as saídas de [Mask2FormerModel](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerModel). Esta classe retorna todos os estados ocultos necessários para calcular os logits. #### transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput[[transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput]] ```python transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, class_queries_logits: typing.Optional[torch.Tensor] = None, masks_queries_logits: typing.Optional[torch.Tensor] = None, auxiliary_logits: list[dict[str, torch.Tensor]] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, pixel_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, transformer_decoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, pixel_decoder_hidden_states: tuple[torch.Tensor] | None = None, transformer_decoder_hidden_states: typing.Optional[torch.Tensor] = None, attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/modeling_mask2former.py#L196) **Parâmetros:** 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 consulta. 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 query. auxiliary_logits (`list[Dict(str, torch.Tensor)]`, *opcional*) : Lista de previsões de classe e máscara de cada camada do decodificador do transformer. encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : Últimos estados ocultos (mapa de recursos final) do último estágio do modelo codificador (backbone). pixel_decoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : Últimos estados ocultos (mapa de recursos final) do último estágio do modelo decodificador de pixels. transformer_decoder_last_hidden_state (`tuple(torch.Tensor)`) : Saída final do decodificador do transformer `(batch_size, sequence_length, hidden_size)`. encoder_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, num_channels, height, width)`. Estados ocultos (também chamados de mapas de características) do modelo codificador na saída de cada estágio. pixel_decoder_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, num_channels, height, width)`. Estados ocultos (também chamados de mapas de características) do modelo decodificador de pixels na saída de cada estágio. transformer_decoder_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)`. Hidden-states (também chamados de feature maps) do decodificador do transformer na saída de cada estágio. 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. Classe para as saídas de `Mask2FormerForUniversalSegmentationOutput`. Esta saída pode ser passada diretamente para [post_process_semantic_segmentation()](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_instance_segmentation) ou [post_process_panoptic_segmentation()](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor.post_process_panoptic_segmentation) para calcular os mapas de segmentação finais. Consulte [`~Mask2FormerImageProcessor] para obter detalhes sobre o uso. ## Mask2FormerModel[[transformers.Mask2FormerModel]] #### transformers.Mask2FormerModel[[transformers.Mask2FormerModel]] ```python transformers.Mask2FormerModel(config: Mask2FormerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/modeling_mask2former.py#L2208) **Parâmetros:** config ([Mask2FormerConfig](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerConfig)) : 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 Mask2Former básico, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. 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.Mask2FormerModel.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/modeling_mask2former.py#L2218) **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 [Mask2FormerImageProcessor](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor). Consulte [Mask2FormerImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [Mask2FormerImageProcessor](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor) para processar imagens). pixel_mask (`torch.Tensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar a execução de atenção em valores de pixels de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para pixels reais (ou seja, **não mascarados**), - 0 para pixels de preenchimento (ou seja, **mascarados**). [O que são máscaras de atenção?](../glossary#attention-mask) output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [Mask2FormerModelOutput](/docs/transformers/main/pt/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput) ou `tuple(torch.Tensor)` Um [Mask2FormerModelOutput](/docs/transformers/main/pt/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput) 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 ([Mask2FormerConfig](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerConfig)) e das entradas. O método forward do [Mask2FormerModel](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerModel) 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. - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`, *opcional*) -- Últimos estados ocultos (mapa de recursos final) do último estágio do modelo codificador (backbone). Retornado quando `output_hidden_states=True` é passado. - **pixel_decoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`, *opcional*) -- Últimos estados ocultos (mapa de recursos final) do último estágio do modelo decodificador de pixels. - **transformer_decoder_last_hidden_state** (`tuple(torch.Tensor)`) -- Saída final do decodificador transformer `(batch_size, sequence_length, hidden_size)`. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada estágio) com forma `(batch_size, num_channels, height, width)`. Hidden-states (também chamados de feature maps) do modelo encoder na saída de cada estágio. Retornado quando `output_hidden_states=True` é passado. - **pixel_decoder_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, num_channels, height, width)`. Estados ocultos (também chamados de mapas de características) do modelo pixel decoder na saída de cada estágio. Retornado quando `output_hidden_states=True` é passado. - **transformer_decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- 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 (também chamados de mapas de características) do decodificador transformer na saída de cada estágio. Retornado quando `output_hidden_states=True` é passado. - **transformer_decoder_intermediate_states** (`tuple(torch.Tensor)` de forma `(num_queries, 1, hidden_size)`) -- Ativações intermediárias do decodificador, ou seja, a saída de cada camada do decodificador, cada uma delas passando por um layernorm. - **masks_queries_logits** (`tuple(torch.Tensor)` de forma `(batch_size, num_queries, height, width)`) Previsões de máscaras de cada camada no decodificador do transformer. attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True` é passado) -- Tupla de `tuple(torch.Tensor)` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de autoatenção do decodificador do transformer. - **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## Mask2FormerForUniversalSegmentation[[transformers.Mask2FormerForUniversalSegmentation]] #### transformers.Mask2FormerForUniversalSegmentation[[transformers.Mask2FormerForUniversalSegmentation]] ```python transformers.Mask2FormerForUniversalSegmentation(config: Mask2FormerConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/modeling_mask2former.py#L2284) **Parâmetros:** config ([Mask2FormerConfig](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerConfig)) : 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 Mask2Former com cabeças no topo para segmentação de instância/semântica/panótica. 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.Mask2FormerForUniversalSegmentation.forward]] ```python forward(pixel_values: Tensor, mask_labels: list[torch.Tensor] | None = None, class_labels: list[torch.Tensor] | None = None, pixel_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_auxiliary_logits: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/modeling_mask2former.py#L2337) **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 [Mask2FormerImageProcessor](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor). Consulte [Mask2FormerImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [Mask2FormerImageProcessor](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerImageProcessor) 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]`. pixel_mask (`torch.Tensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar a execução de atenção em valores de pixels de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para pixels reais (ou seja, **não mascarados**), - 0 para pixels de preenchimento (ou seja, **mascarados**). [O que são máscaras de atenção?](../glossary#attention-mask) output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. output_auxiliary_logits (`bool`, *opcional*) : Se deve ou não produzir logits auxiliares. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** [Mask2FormerForUniversalSegmentationOutput](/docs/transformers/main/pt/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput) ou `tuple(torch.Tensor)` Um [Mask2FormerForUniversalSegmentationOutput](/docs/transformers/main/pt/model_doc/mask2former#transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput) 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 ([Mask2FormerConfig](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerConfig)) e das entradas. O método forward de [Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation) 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. - **auxiliary_logits** (`list[Dict(str, torch.Tensor)]`, *opcional*) -- Lista de previsões de classe e máscara de cada camada do decodificador do transformer. - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Últimos estados ocultos (mapa de recursos final) do último estágio do modelo codificador (backbone). - **pixel_decoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Últimos estados ocultos (mapa de recursos final) do último estágio do modelo pixel decoder. - **transformer_decoder_last_hidden_state** (`tuple(torch.Tensor)`) -- Saída final do decodificador transformer `(batch_size, sequence_length, hidden_size)`. - **encoder_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, num_channels, height, width)`. Hidden-states (também chamados de feature maps) do modelo encoder na saída de cada estágio. - **pixel_decoder_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, num_channels, height, width)`. Hidden-states (também chamados de feature maps) do modelo pixel decoder na saída de cada estágio. - **transformer_decoder_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 etapa) com forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (também chamados de feature maps) do decodificador transformer na saída de cada etapa. - **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. Exemplos: Exemplo de segmentação de instâncias: ```python >>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> import torch >>> # Load Mask2Former trained on COCO instance segmentation dataset >>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance") >>> model = Mask2FormerForUniversalSegmentation.from_pretrained( ... "facebook/mask2former-swin-small-coco-instance" ... ) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = image_processor(image, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)` >>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)` >>> class_queries_logits = outputs.class_queries_logits >>> masks_queries_logits = outputs.masks_queries_logits >>> # Perform post-processing to get instance segmentation map >>> pred_instance_map = image_processor.post_process_instance_segmentation( ... outputs, target_sizes=[(image.height, image.width)] ... )[0] >>> print(pred_instance_map.shape) torch.Size([480, 640]) ``` Exemplo de segmentação semântica: ```python >>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> import torch >>> # Load Mask2Former trained on ADE20k semantic segmentation dataset >>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-ade-semantic") >>> model = Mask2FormerForUniversalSegmentation.from_pretrained("facebook/mask2former-swin-small-ade-semantic") >>> url = ( ... "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg" ... ) >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = image_processor(image, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)` >>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)` >>> class_queries_logits = outputs.class_queries_logits >>> masks_queries_logits = outputs.masks_queries_logits >>> # Perform post-processing to get semantic segmentation map >>> pred_semantic_map = image_processor.post_process_semantic_segmentation( ... outputs, target_sizes=[(image.height, image.width)] ... )[0] >>> print(pred_semantic_map.shape) torch.Size([512, 683]) ``` Exemplo de segmentação panóptica: ```python >>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> import torch >>> # Load Mask2Former trained on CityScapes panoptic segmentation dataset >>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-cityscapes-panoptic") >>> model = Mask2FormerForUniversalSegmentation.from_pretrained( ... "facebook/mask2former-swin-small-cityscapes-panoptic" ... ) >>> url = "https://cdn-media.huggingface.co/Inference-API/Sample-results-on-the-Cityscapes-dataset-The-above-images-show-how-our-method-can-handle.png" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = image_processor(image, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)` >>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)` >>> class_queries_logits = outputs.class_queries_logits >>> masks_queries_logits = outputs.masks_queries_logits >>> # Perform post-processing to get panoptic segmentation map >>> pred_panoptic_map = image_processor.post_process_panoptic_segmentation( ... outputs, target_sizes=[(image.height, image.width)] ... )[0]["segmentation"] >>> print(pred_panoptic_map.shape) torch.Size([338, 676]) ``` ## Mask2FormerImageProcessor[[transformers.Mask2FormerImageProcessor]] #### transformers.Mask2FormerImageProcessor[[transformers.Mask2FormerImageProcessor]] ```python transformers.Mask2FormerImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_mask2former.py#L263) **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' : 800, 'longest_edge': 1333}`): 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*) : 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 (`SizeDict`, *kwargs*, *opcional*) : O tamanho para o qual as imagens devem ser preenchidas (padding). 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. 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. ignore_index (`int`, *kwargs*, *opcional*) : Rótulo a ser atribuído aos pixels de fundo nos mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. do_reduce_labels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve ou não decrementar em 1 todos os valores de rótulo dos mapas de segmentação. Geralmente usado em conjuntos de dados em que 0 é usado para o plano de fundo e o próprio plano de fundo não está incluído em todas as classes de um conjunto de dados (por exemplo, ADE20k). O rótulo do plano de fundo será substituído por `ignore_index`. num_labels (`int`, *kwargs*, *opcional*) : O número de rótulos no mapa de segmentação. size_divisor (`int`, *kwargs*, *opcional*, padrão `32`) : Alguns backbones exigem que as imagens sejam divisíveis por um determinado número. Se não for informado, o valor padrão é o utilizado no Swin Transformer. Constrói um processador de imagem Mask2FormerImageProcessor. #### preprocess[[transformers.Mask2FormerImageProcessor.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: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, instance_id_to_semantic_id: list[dict[int, int]] | dict[int, int] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_mask2former.py#L386) **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. instance_id_to_semantic_id (`Union[list[dict[int, int]], dict[int, int]]`, *opcional*) : Um mapeamento de IDs de instância para IDs semânticos. 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 (`SizeDict`, *kwargs*, *opcional*) : O tamanho para o qual as imagens devem ser preenchidas (padding). 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. 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. ignore_index (`int`, *kwargs*, *opcional*) : Rótulo a ser atribuído aos pixels de fundo nos mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. do_reduce_labels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve ou não decrementar em 1 todos os valores de rótulo dos mapas de segmentação. Geralmente usado em conjuntos de dados em que 0 é usado para o plano de fundo e o próprio plano de fundo não está incluído em todas as classes de um conjunto de dados (por exemplo, ADE20k). O rótulo do plano de fundo será substituído por `ignore_index`. num_labels (`int`, *kwargs*, *opcional*) : O número de rótulos no mapa de segmentação. size_divisor (`int`, *kwargs*, *opcional*, padrão `32`) : Alguns backbones exigem que as imagens sejam divisíveis por um determinado número. Se não for informado, o valor padrão é o utilizado no Swin Transformer. **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.Mask2FormerImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_mask2former.py#L550) **Parâmetros:** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation)) : Saídas brutas do modelo. target_sizes (`list[tuple[int, int]]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão. Se deixado como None, as previsões não serão redimensionadas. 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 (se `target_sizes` for especificado). Converte a saída de [Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation) em mapas de segmentação semântica. Suporta apenas PyTorch. #### post_process_instance_segmentation[[transformers.Mask2FormerImageProcessor.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False, return_binary_maps: bool | None = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_mask2former.py#L627) **Parâmetros:** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation)) : Saídas brutas do modelo. threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. target_sizes (`List[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`Tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão. Se deixado como None, as previsões não serão redimensionadas. return_coco_annotation (`bool`, *opcional*, padrão `False`) : Se definido como `True`, os mapas de segmentação são retornados no formato de codificação por comprimento de execução (RLE) do COCO. return_binary_maps (`bool`, *opcional*, padrão `False`) : Se definido como `True`, os mapas de segmentação são retornados como um tensor concatenado de mapas de segmentação binários (um para cada instância detectada). **Retorna:** `List[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- Um tensor de forma `(height, width)` em que cada pixel representa um `segment_id`, ou uma codificação de comprimento de execução (RLE) `List[List]` do mapa de segmentação se return_coco_annotation estiver definido como `True`, ou um tensor de forma `(num_instances, height, width)` se return_binary_maps estiver definido como `True`. Definido como `None` se nenhuma máscara for encontrada acima do `threshold`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- Um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de `Mask2FormerForUniversalSegmentationOutput` em previsões de segmentação de instâncias. Suporta apenas PyTorch. Se as instâncias puderem se sobrepor, defina return_coco_annotation ou return_binary_maps como `True` para obter o resultado de segmentação correto. #### post_process_panoptic_segmentation[[transformers.Mask2FormerImageProcessor.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_mask2former.py#L748) **Parâmetros:** outputs (`Mask2FormerForUniversalSegmentationOutput`) : As saídas de [Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation). threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. label_ids_to_fuse (`Set[int]`, *opcional*) : Os rótulos neste estado terão todas as suas instâncias fundidas. Por exemplo, poderíamos dizer que pode haver apenas um céu em uma imagem, mas várias pessoas, então o ID do rótulo para céu estaria nesse conjunto, mas não o de pessoa. target_sizes (`List[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`Tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão no lote. Se deixado como None, as previsões não serão redimensionadas. **Retorna:** `List[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- um tensor de forma `(height, width)` em que cada pixel representa um `segment_id`, definido como `None` caso nenhuma máscara seja encontrada acima do `threshold`. Se `target_sizes` for especificado, a segmentation é redimensionada para a entrada correspondente de `target_sizes`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **was_fused** -- um booleano, `True` se `label_id` estava em `label_ids_to_fuse`, `False` caso contrário. Múltiplas instâncias da mesma classe / rótulo foram fundidas e atribuídas a um único `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de `Mask2FormerForUniversalSegmentationOutput` em previsões de segmentação panótica de imagem. Suporta apenas PyTorch. ## Mask2FormerImageProcessorPil[[transformers.Mask2FormerImageProcessorPil]] #### transformers.Mask2FormerImageProcessorPil[[transformers.Mask2FormerImageProcessorPil]] ```python transformers.Mask2FormerImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L274) #### preprocess[[transformers.Mask2FormerImageProcessorPil.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: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, instance_id_to_semantic_id: list[dict[int, int]] | dict[int, int] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L442) **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. instance_id_to_semantic_id (`Union[list[dict[int, int]], dict[int, int]]`, *opcional*) : Um mapeamento de IDs de instância para IDs semânticos. 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 (`SizeDict`, *kwargs*, *opcional*) : O tamanho para o qual as imagens devem ser preenchidas (padding). 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. 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. ignore_index (`int`, *kwargs*, *opcional*) : Rótulo a ser atribuído aos pixels de fundo nos mapas de segmentação. Se fornecido, os pixels do mapa de segmentação indicados com 0 (fundo) serão substituídos por `ignore_index`. do_reduce_labels (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve ou não decrementar em 1 todos os valores de rótulo dos mapas de segmentação. Geralmente usado em conjuntos de dados em que 0 é usado para o plano de fundo e o próprio plano de fundo não está incluído em todas as classes de um conjunto de dados (por exemplo, ADE20k). O rótulo do plano de fundo será substituído por `ignore_index`. num_labels (`int`, *kwargs*, *opcional*) : O número de rótulos no mapa de segmentação. size_divisor (`int`, *kwargs*, *opcional*, padrão `32`) : Alguns backbones exigem que as imagens sejam divisíveis por um determinado número. Se não for informado, o valor padrão é o utilizado no Swin Transformer. **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.Mask2FormerImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L587) **Parâmetros:** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation)) : Saídas brutas do modelo. target_sizes (`list[tuple[int, int]]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão. Se deixado como None, as previsões não serão redimensionadas. 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 (se `target_sizes` for especificado). Converte a saída de [Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation) em mapas de segmentação semântica. Suporta apenas PyTorch. #### post_process_instance_segmentation[[transformers.Mask2FormerImageProcessorPil.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False, return_binary_maps: bool | None = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L664) **Parâmetros:** outputs ([Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation)) : Saídas brutas do modelo. threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. target_sizes (`List[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`Tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão. Se deixado como None, as previsões não serão redimensionadas. return_coco_annotation (`bool`, *opcional*, padrão `False`) : Se definido como `True`, os mapas de segmentação são retornados no formato de codificação por comprimento de execução (RLE) do COCO. return_binary_maps (`bool`, *opcional*, padrão `False`) : Se definido como `True`, os mapas de segmentação são retornados como um tensor concatenado de mapas de segmentação binários (um para cada instância detectada). **Retorna:** `List[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- Um tensor de forma `(height, width)` em que cada pixel representa um `segment_id`, ou uma codificação de comprimento de execução (RLE) `List[List]` do mapa de segmentação se return_coco_annotation estiver definido como `True`, ou um tensor de forma `(num_instances, height, width)` se return_binary_maps estiver definido como `True`. Definido como `None` se nenhuma máscara for encontrada acima do `threshold`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- Um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de `Mask2FormerForUniversalSegmentationOutput` em previsões de segmentação de instâncias. Suporta apenas PyTorch. Se as instâncias puderem se sobrepor, defina return_coco_annotation ou return_binary_maps como `True` para obter o resultado de segmentação correto. #### post_process_panoptic_segmentation[[transformers.Mask2FormerImageProcessorPil.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mask2former/image_processing_pil_mask2former.py#L786) **Parâmetros:** outputs (`Mask2FormerForUniversalSegmentationOutput`) : As saídas de [Mask2FormerForUniversalSegmentation](/docs/transformers/main/pt/model_doc/mask2former#transformers.Mask2FormerForUniversalSegmentation). threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. label_ids_to_fuse (`Set[int]`, *opcional*) : Os rótulos neste estado terão todas as suas instâncias fundidas. Por exemplo, poderíamos dizer que pode haver apenas um céu em uma imagem, mas várias pessoas, então o ID do rótulo para céu estaria nesse conjunto, mas não o de pessoa. target_sizes (`List[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`Tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão no lote. Se deixado como None, as previsões não serão redimensionadas. **Retorna:** `List[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- um tensor de forma `(height, width)` em que cada pixel representa um `segment_id`, definido como `None` caso nenhuma máscara seja encontrada acima do `threshold`. Se `target_sizes` for especificado, a segmentation é redimensionada para a entrada correspondente de `target_sizes`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **was_fused** -- um booleano, `True` se `label_id` estava em `label_ids_to_fuse`, `False` caso contrário. Múltiplas instâncias da mesma classe / rótulo foram fundidas e atribuídas a um único `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de `Mask2FormerForUniversalSegmentationOutput` em previsões de segmentação panótica de imagem. Suporta apenas PyTorch.