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

Ce modèle a été publié dans HF papers le 26/07/2018 et ajouté à Hugging Face Transformers le 16/01/2023.

UPerNet

Aperçu

Le modèle UPerNet a été proposé dans Unified Perceptual Parsing for Scene Understanding par Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, Jian Sun. UPerNet est un cadre général permettant de segmenter efficacement une large gamme de concepts à partir d’images, en s’appuyant sur n’importe quel backbone visuel tel que ConvNeXt ou Swin.

L'abstract de l'article est le suivant :

Les humains reconnaissent le monde visuel à plusieurs niveaux : nous catégorisons sans effort les scènes et détectons les objets qui s’y trouvent, tout en identifiant les textures et les surfaces de ces objets ainsi que leurs différentes parties compositionnelles. Dans cet article, nous étudions une nouvelle tâche appelée Unified Perceptual Parsing, qui exige des systèmes de vision par ordinateur de reconnaître le plus grand nombre de concepts visuels possible à partir d’une image donnée. Un cadre multitâche appelé UPerNet et une stratégie d’entraînement sont développés pour apprendre à partir d’annotations d’images hétérogènes. Nous évaluons notre cadre sur Unified Perceptual Parsing et montrons qu’il est capable de segmenter efficacement une large gamme de concepts à partir d’images. Les réseaux entraînés sont ensuite appliqués pour découvrir des connaissances visuelles dans des scènes naturelles.

drawing UPerNet framework. Taken from the original paper.

Ce modèle a été contribué par nielsr. Le code d’origine est basé sur mmsegmentation d’OpenMMLab, ici.

Exemples d'utilisation

UPerNet est un cadre général pour la segmentation sémantique. Il peut être utilisé avec n'importe quel backbone de vision, comme suit :

from transformers import SwinConfig, UperNetConfig, UperNetForSemanticSegmentation


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

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

Pour utiliser un autre backbone de vision, comme ConvNeXt, il suffit d’instancier le modèle avec le backbone approprié :

from transformers import ConvNextConfig, UperNetConfig, UperNetForSemanticSegmentation


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

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

Notez que cela initialisera aléatoirement tous les poids du modèle.

Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec UPerNet.

Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.

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 )

Paramètres

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone.
  • hidden_size (int, facultatif, par défaut 512) — Dimension des représentations cachées.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • pool_scales (tuple[int], facultatif, par défaut [1, 2, 3, 6]) — Échelles de pooling utilisées dans le Pooling Pyramid Module appliqué à la dernière carte de caractéristiques.
  • use_auxiliary_head (bool, facultatif, valeur par défaut True) — Indique s'il faut utiliser une tête auxiliaire pendant l'entraînement.
  • auxiliary_loss_weight (float, facultatif, valeur par défaut 0.4) — Poids de la perte d'entropie croisée de la tête auxiliaire.
  • auxiliary_in_channels (int, facultatif, valeur par défaut 256) — Nombre de canaux d'entrée dans la tête auxiliaire.
  • auxiliary_channels (int, facultatif, valeur par défaut 256) — Nombre de canaux à utiliser dans la tête auxiliaire.
  • auxiliary_num_convs (int, facultatif, valeur par défaut 1) — Nombre de couches de convolution à utiliser dans la tête auxiliaire.
  • auxiliary_concat_input (bool, facultatif, valeur par défaut False) — Indique s'il faut concaténer la sortie de la tête auxiliaire avec l'entrée avant la couche de classification.
  • loss_ignore_index (int, facultatif, valeur par défaut : 255) — L'index ignoré par la fonction de perte.

Il s'agit de la classe de configuration permettant de stocker la configuration d'un UpernetModel. Elle est utilisée pour instancier un modèle Upernet en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de openmmlab/upernet-convnext-tiny

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemples :

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

Paramètres

  • config (UperNetConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Cadre UperNet exploitant n’importe quel backbone de vision, par exemple pour ADE20k, CityScapes.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

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)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de SegformerImageProcessor. Voir SegformerImageProcessor.call() pour plus de détails (processor_class utilise SegformerImageProcessor pour le traitement des images).
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • labels (torch.LongTensor de forme (batch_size, height, width), facultatif) — Cartes de segmentation sémantique de référence pour le calcul de la perte. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels > 1, une perte de classification est calculée (Cross-Entropy).
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

SemanticSegmenterOutput ou tuple(torch.Tensor)

Un SemanticSegmenterOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (UperNetConfig) et des entrées.

La méthode forward de UperNetForSemanticSegmentation redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de classification (ou de régression si config.num_labels==1).

  • logits (torch.Tensor de forme (batch_size, config.num_labels, logits_height, logits_width)) — Scores de classification pour chaque pixel.

    Les logits retournés n'ont pas nécessairement la même taille que les pixel_values passés en entrée. Cela permet d'éviter de réaliser deux interpolations et de perdre en qualité lorsqu'un utilisateur doit redimensionner les logits à la taille de l'image d'origine en post-traitement. Vous devez toujours vérifier la forme de vos logits et les redimensionner si nécessaire.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, patch_size, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, patch_size, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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