Hugging Face's logo

Transformers documentation

UPerNet

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

and get access to the augmented documentation experience

to get started

Este modelo foi publicado no HF papers em 2018-07-26 e contribuído para o Hugging Face Transformers em 2023-01-16.

UPerNet

Visão geral

O modelo UPerNet foi proposto em Unified Perceptual Parsing for Scene Understanding por Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang e Jian Sun. O UPerNet é um framework geral para segmentar eficazmente uma ampla variedade de conceitos a partir de imagens, aproveitando qualquer backbone de visão, como ConvNeXt ou Swin.

O resumo do artigo é o seguinte:

Os seres humanos reconhecem o mundo visual em múltiplos níveis: categorizamos cenas e detectamos objetos nelas com facilidade, ao mesmo tempo em que identificamos as texturas e superfícies dos objetos, bem como suas diferentes partes constitutivas. Neste artigo, estudamos uma nova tarefa chamada Unified Perceptual Parsing, que exige que os sistemas de visão computacional reconheçam o máximo possível de conceitos visuais a partir de uma imagem dada. Desenvolvemos um framework multitarefa chamado UPerNet e uma estratégia de treinamento para aprender a partir de anotações de imagem heterogêneas. Avaliamos nosso framework em Unified Perceptual Parsing e demonstramos que ele é capaz de segmentar eficazmente uma ampla gama de conceitos a partir de imagens. As redes treinadas são, em seguida, aplicadas para descobrir conhecimento visual em cenas naturais.

drawing UPerNet framework. Taken from the original paper.

Este modelo foi contribuído por nielsr. O código original é baseado no mmsegmentation do OpenMMLab aqui.

Exemplos de uso

UPerNet é um framework geral para segmentação semântica. Ele pode ser usado com qualquer backbone de visão, da seguinte forma:

from transformers import SwinConfig, UperNetConfig, UperNetForSemanticSegmentation


backbone_config = SwinConfig(out_features=["stage1", "stage2", "stage3", "stage4"])

config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)

Para usar outro backbone de visão, como ConvNeXt, basta instanciar o modelo com o backbone apropriado:

from transformers import ConvNextConfig, UperNetConfig, UperNetForSemanticSegmentation


backbone_config = ConvNextConfig(out_features=["stage1", "stage2", "stage3", "stage4"])

config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)

Observe que isso inicializará aleatoriamente todos os pesos do modelo.

Recursos

Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o UPerNet.

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.

UperNetConfig

classe transformers.UperNetConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonehidden_size: int = 512initializer_range: float = 0.02pool_scales: list[int] | tuple[int, ...] = (1, 2, 3, 6)use_auxiliary_head: bool = Trueauxiliary_loss_weight: float = 0.4auxiliary_in_channels: int | None = Noneauxiliary_channels: int = 256auxiliary_num_convs: int = 1auxiliary_concat_input: bool = Falseloss_ignore_index: int = 255 )

Parâmetros

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — A configuração do modelo backbone.
  • hidden_size (int, opcional, padrão 512) — Dimensão das representações ocultas.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • pool_scales (tuple[int], opcional, padrão [1, 2, 3, 6]) — Escala de pooling usada no Pooling Pyramid Module aplicado ao último mapa de características.
  • use_auxiliary_head (bool, opcional, padrão True) — Se deve usar uma cabeça auxiliar durante o treinamento.
  • auxiliary_loss_weight (float, opcional, padrão 0.4) — Peso da perda de entropia cruzada da cabeça auxiliar.
  • auxiliary_in_channels (int, opcional, padrão 256) — Número de canais de entrada na cabeça auxiliar.
  • auxiliary_channels (int, opcional, padrão 256) — Número de canais a serem usados na cabeça auxiliar.
  • auxiliary_num_convs (int, opcional, padrão 1) — Número de camadas convolucionais a serem usadas na cabeça auxiliar.
  • auxiliary_concat_input (bool, opcional, padrão False) — Se deve concatenar a saída da cabeça auxiliar com a entrada antes da camada de classificação.
  • loss_ignore_index (int, opcional, padrão 255) — O índice que é ignorado pela função de perda.

Esta é a classe de configuração para armazenar a configuração de um UpernetModel. Ela é usada para instanciar um modelo Upernet 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 openmmlab/upernet-convnext-tiny

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplos:

>>> from transformers import UperNetConfig, UperNetForSemanticSegmentation

>>> # Initializing a configuration
>>> configuration = UperNetConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = UperNetForSemanticSegmentation(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

UperNetForSemanticSegmentation

classe transformers.UperNetForSemanticSegmentation

< >

( config: UperNetConfig )

Parâmetros

  • config (UperNetConfig) — 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() para carregar os pesos do modelo.

Framework UperNet que aproveita qualquer backbone de visão, por exemplo, para ADE20k, CityScapes.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None**kwargs ) → SemanticSegmenterOutput or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Os tensors correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando SegformerImageProcessor. Consulte SegformerImageProcessor.call() para mais detalhes (processor_class usa SegformerImageProcessor para processar imagens).
  • 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.
  • output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de segmentação semântica de verdade para o cálculo da perda. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels > 1, uma perda de classificação é calculada (Cross-Entropy).
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

SemanticSegmenterOutput ou tuple(torch.Tensor)

Um SemanticSegmenterOutput 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 (UperNetConfig) e das entradas.

O método forward de UperNetForSemanticSegmentation 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 de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação (ou regressão se config.num_labels==1).

  • logits (torch.Tensor de forma (batch_size, config.num_labels, logits_height, logits_width)) — Pontuações de classificação para cada pixel.

    Os logits retornados não necessariamente têm o mesmo tamanho que os pixel_values passados como entradas. Isso é para evitar fazer duas interpolações e perder alguma qualidade quando um usuário precisa redimensionar os logits para o tamanho da imagem original como pós-processamento. Você deve sempre verificar a forma dos seus logits e redimensioná-los conforme necessário.

  • 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, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, patch_size, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • 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 forma (batch_size, num_heads, patch_size, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

>>> from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download

>>> image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny")
>>> model = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny")

>>> filepath = hf_hub_download(
...     repo_id="hf-internal-testing/fixtures_ade20k", filename="ADE_val_00000001.jpg", repo_type="dataset"
... )
>>> image = Image.open(filepath).convert("RGB")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> logits = outputs.logits  # shape (batch_size, num_labels, height, width)
>>> list(logits.shape)
[1, 150, 512, 512]
Update on GitHub

←Timm Wrapper UVDoc→