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.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 26-07-2018 y se contribuyó a Hugging Face Transformers el 16-01-2023.

UPerNet

Resumen

El modelo UPerNet fue propuesto en Unified Perceptual Parsing for Scene Understanding por Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, Jian Sun. UPerNet es un marco general para segmentar de manera efectiva una amplia gama de conceptos a partir de imágenes, aprovechando cualquier backbone de visión como ConvNeXt o Swin.

El resumen del artículo es el siguiente:

Los humanos reconocen el mundo visual en múltiples niveles: categorizamos escenas y detectamos objetos en ellas sin esfuerzo, al tiempo que identificamos las texturas y superficies de los objetos junto con sus diferentes partes composicionales. En este artículo, estudiamos una nueva tarea llamada Unified Perceptual Parsing, que requiere que los sistemas de visión por computadora reconozcan la mayor cantidad posible de conceptos visuales a partir de una imagen dada. Se desarrolló un marco multitarea llamado UPerNet y una estrategia de entrenamiento para aprender de anotaciones de imagen heterogéneas. Evaluamos nuestro marco en Unified Perceptual Parsing y demostramos que es capaz de segmentar de manera efectiva una amplia gama de conceptos a partir de imágenes. Las redes entrenadas se aplican además para descubrir conocimiento visual en escenas naturales.

drawing UPerNet framework. Taken from the original paper.

Este modelo fue aportado por nielsr. El código original se basa en mmsegmentation de OpenMMLab aquí.

Ejemplos de uso

UPerNet es un marco general para la segmentación semántica. Puede utilizarse con cualquier backbone de visión, de la siguiente manera:

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 otro backbone de visión, como ConvNeXt, simplemente instancie el modelo con el backbone adecuado:

from transformers import ConvNextConfig, UperNetConfig, UperNetForSemanticSegmentation


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

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

Tenga en cuenta que esto inicializará aleatoriamente todos los pesos del modelo.

Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con UPerNet.

Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente.

UperNetConfig

clase 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) — La configuración del modelo backbone.
  • hidden_size (int, opcional, valor predeterminado 512) — Dimensión de las representaciones ocultas.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • pool_scales (tuple[int], opcional, valor predeterminado [1, 2, 3, 6]) — Escala de agrupación utilizada en el módulo de pirámide de agrupación aplicado al último mapa de características.
  • use_auxiliary_head (bool, opcional, valor predeterminado True) — Si se debe utilizar una cabeza auxiliar durante el entrenamiento.
  • auxiliary_loss_weight (float, opcional, valor predeterminado 0.4) — Peso de la pérdida de entropía cruzada de la cabeza auxiliar.
  • auxiliary_in_channels (int, opcional, valor predeterminado 256) — Número de canales de entrada en la cabeza auxiliar.
  • auxiliary_channels (int, opcional, valor predeterminado 256) — Número de canales a utilizar en la cabeza auxiliar.
  • auxiliary_num_convs (int, opcional, valor predeterminado 1) — Número de capas convolucionales a utilizar en la cabeza auxiliar.
  • auxiliary_concat_input (bool, opcional, valor predeterminado False) — Si se debe concatenar la salida de la cabeza auxiliar con la entrada antes de la capa de clasificación.
  • loss_ignore_index (int, opcional, valor predeterminado 255) — El índice que se ignora en la función de pérdida.

Esta es la clase de configuración para almacenar la configuración de un UpernetModel. Se utiliza para instanciar un modelo Upernet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de openmmlab/upernet-convnext-tiny

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

Ejemplos:

>>> 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

clase transformers.UperNetForSemanticSegmentation

< >

( config: UperNetConfig )

Parámetros

  • config (UperNetConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Framework UperNet que aprovecha cualquier backbone de visión, por ejemplo, para ADE20k, CityScapes.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( pixel_values: 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) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando SegformerImageProcessor. Consulte SegformerImageProcessor.call() para más detalles (processor_class utiliza SegformerImageProcessor para procesar las imágenes).
  • output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
  • output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de segmentación semántica de referencia para calcular la pérdida. Los índices deben estar en [0, ..., config.num_labels - 1]. Si config.num_labels > 1, se calcula una pérdida de clasificación (Cross-Entropy).
  • return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

SemanticSegmenterOutput o tuple(torch.Tensor)

Un SemanticSegmenterOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (UperNetConfig) y las entradas.

El método forward de UperNetForSemanticSegmentation sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación (o de regresión si config.num_labels==1).

  • logits (torch.Tensor de forma (batch_size, config.num_labels, logits_height, logits_width)) — Puntuaciones de clasificación para cada píxel.

    Los logits devueltos no tienen necesariamente el mismo tamaño que los pixel_values pasados como entradas. Esto se hace para evitar realizar dos interpolaciones y perder algo de calidad cuando un usuario necesita redimensionar los logits al tamaño de la imagen original como procesamiento posterior. Debe comprobar siempre la forma de sus logits y redimensionarlos según sea necesario.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, patch_size, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, patch_size, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

>>> 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→