Hugging Face's logo

Transformers documentation

Sapiens2

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 2026-04-23 et contribué à Hugging Face Transformers le 2026-06-03.

Sapiens2

SDPA FlashAttention

Aperçu

Le modèle Sapiens2 a été proposé dans Sapiens2 par Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su, Shunsuke Saito. Sapiens2 est une famille de vision transformers haute résolution pré-entraînés sur environ 1 milliard d’images humaines soigneusement sélectionnées, conçue pour des tâches de vision par ordinateur centrées sur l’humain, notamment l’estimation de pose, la segmentation des parties du corps, l’estimation des normales de surface et l’estimation de pointmaps.

Vous pouvez trouver tous les points de contrôle originaux de Sapiens2 dans la collection Sapiens2.

L'abstract de l'article est le suivant :

Nous présentons Sapiens2, une famille de transformers haute résolution pour la vision centrée sur l’humain, axée sur la généralisation, la polyvalence et des sorties haute fidélité. Nous pré-entraînons sur environ 1 milliard d’images humaines de haute qualité soigneusement sélectionnées, avec des annotations de tâches améliorées, et combinons la reconstruction d’images masquées avec des objectifs contrastifs auto-distillés pour apprendre à la fois des caractéristiques de bas niveau et sémantiques. Nos modèles passent de 0,4 à 5 milliards de paramètres et s’entraînent à une résolution native de 1K, avec des variantes hiérarchiques 4K pour un raisonnement spatial étendu. Sapiens2 apporte des améliorations substantielles par rapport à son prédécesseur : +4 mAP en estimation de pose, +24,3 mIoU en segmentation des parties du corps et une réduction de 45,6 % de l’erreur en estimation de normales, tout en s’étendant à de nouvelles tâches telles que l’estimation de pointmap et d’albédo. Le code est publiquement disponible.

Astuces :

  • Sapiens2 utilise des embeddings de position rotatifs (RoPE) et prend en charge des résolutions d’entrée arbitraires. Le processeur d’images par défaut redimensionne les images en 1024×768 (hauteur×largeur).
  • Le modèle utilise l'attention à requêtes groupées (GQA) pour les couches intermédiaires et l'attention multi-têtes complète pour les 8 premières et les 8 dernières couches.
  • Les jetons d’enregistrement (8 par défaut) réduisent les artefacts de norme élevée dans les jetons de patch, ce qui produit des cartes d’attention plus propres et de meilleures performances sur les tâches de prédiction dense.

Ce modèle a été contribué par guarin. Le code d'origine peut être trouvé ici.

Exemples d'utilisation

AutoModel
AutoBackbone
Estimation normale
Estimation de pointmap
Estimation de pose
Estimation de pose avec augmentation par retournement
Entraînement de l'estimation de pose
Segmentation sémantique
Matting

L’exemple ci-dessous montre comment obtenir le jeton CLS (représentation de l’image entière) avec Sapiens2Model.

import torch
from transformers import AutoImageProcessor, AutoModel
from transformers.image_utils import load_image

image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")

image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
model = AutoModel.from_pretrained("facebook/sapiens2-pretrain-0.4b", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)
with torch.inference_mode():
    outputs = model(**inputs)

# outputs.pooler_output is the CLS token (whole-image embedding)
cls_token = outputs.pooler_output
print("CLS token shape:", cls_token.shape)  # [1, 1024]

Sapiens2Config

classe transformers.Sapiens2Config

< >

( 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 = Nonepatch_size: int | list[int] | tuple[int, int] = 16hidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16hidden_act: str = 'silu'attention_dropout: float | int = 0.0initializer_range: float = 0.02rope_theta: float = 100.0image_size: int | list[int] | tuple[int, int] = 224num_channels: int = 3query_bias: bool = Truekey_bias: bool = Truevalue_bias: bool = Trueproj_bias: bool = Truemlp_bias: bool = Truelayerscale_value: float = 1.0drop_path_rate: float | int = 0.0use_gated_mlp: bool = Truenum_register_tokens: int = 8pos_embed_shift: float | None = Nonepos_embed_jitter: float | None = Nonepos_embed_rescale: float | None = 2.0_out_features: list[str] | None = None_out_indices: list[int] | None = Nonereshape_hidden_states: bool = Trueuse_mask_token: bool = Falserms_norm_eps: float = 1e-06normalize_backbone_outputs: bool = Trueuse_qk_norm: bool = Truenum_key_value_heads_per_layer: list[int] | None = Nonenum_key_value_attention_heads: int = 8num_first_full_attention_layers: int = 8num_last_full_attention_layers: int = 8semantic_loss_ignore_index: int = 255flip_pairs: list[list[int]] | None = Nonehead_config: transformers.models.sapiens2.configuration_sapiens2.Sapiens2HeadConfig | dict | None = None )

Paramètres

  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 16) — La taille (résolution) de chaque patch.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 4096) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 24) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • hidden_act (str, facultatif, par défaut silu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • 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.
  • rope_theta (float, facultatif, valeur par défaut 100.0) — La période de base des embeddings RoPE.
  • image_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 224) — La taille (résolution) de chaque image.
  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • query_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais à la projection de requête.
  • key_bias (bool, facultatif, par défaut False) — Indique s'il faut ajouter un biais à la projection des clés.
  • value_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais à la projection de valeur.
  • proj_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais à la projection de sortie.
  • mlp_bias (bool, facultatif, par défaut True) — Indique s'il faut utiliser un biais dans les couches up_proj, down_proj et gate_proj des couches MLP.
  • layerscale_value (float, facultatif, valeur par défaut 1.0) — Valeur initiale à utiliser pour l'échelle de couche.
  • drop_path_rate (Union[float, int], facultatif, par défaut 0.0) — Taux de drop path pour la fusion des patches.
  • use_gated_mlp (bool, facultatif, par défaut False) — Indique s'il faut utiliser le réseau de neurones feedforward SwiGLU.
  • num_register_tokens (int, facultatif, valeur par défaut 0) — Le nombre de jetons d'enregistrement.
  • pos_embed_shift (float, facultatif) — Quantité à appliquer pour décaler aléatoirement les coordonnées des embeddings de position dans l'intervalle [-shift, shift], uniquement en mode d'entraînement si la valeur n'est pas None.
  • pos_embed_jitter (float, facultatif) — Quantité à appliquer pour jitter aléatoirement les coordonnées des embeddings de position, avec une valeur log-uniforme dans [1/jitter, jitter], appliquée uniquement en mode d’entraînement si elle n’est pas None.
  • pos_embed_rescale (float, facultatif, valeur par défaut 2.0) — Quantité utilisée pour rééchelonner aléatoirement les coordonnées des embeddings de position selon une valeur log-uniforme dans [1/rescale, rescale], appliquée uniquement en mode d’entraînement si la valeur n’est pas None.
  • reshape_hidden_states (bool, facultatif, par défaut True) — Indique s'il faut redimensionner les états cachés vers les dimensions spatiales lorsqu'ils sont utilisés comme backbone.
  • use_mask_token (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser un jeton de masque dans les plongements (nécessaire pour la préformation par modélisation d'image masquée).
  • rms_norm_eps (float, facultatif, valeur par défaut : 1e-6) — Epsilon pour les couches de normalisation RMS.
  • normalize_backbone_outputs (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer RMSNorm aux sorties feature_maps et cls_tokens du backbone avant de les retourner depuis le passage avant. Ne s'applique que lorsque le modèle est utilisé comme backbone.
  • use_qk_norm (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer RMSNorm aux requêtes et aux clés avant RoPE dans les couches d'attention.
  • num_key_value_heads_per_layer (list[int], facultatif) — Nombre de têtes clé/valeur pour chaque couche de transformer. Définir la valeur d’une couche égale à num_attention_heads permet une attention multi-têtes complète ; une valeur plus petite permet une attention groupée par requête. Par défaut, la valeur est num_attention_heads pour les num_first_full_attention_layers premières couches et les num_last_full_attention_layers dernières couches, et num_key_value_attention_heads pour toutes les autres couches.
  • num_key_value_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes clé/valeur pour les couches utilisant l'attention à requêtes groupées lorsque num_key_value_heads_per_layer n'est pas défini. Ignoré lorsque num_key_value_heads_per_layer est défini.
  • num_first_full_attention_layers (int, facultatif, valeur par défaut : 8) — Nombre de couches de transformeur initiales qui utilisent l'attention multi-têtes complète. Utilisé uniquement lorsque num_key_value_heads_per_layer est None.
  • num_last_full_attention_layers (int, facultatif, valeur par défaut : 8) — Nombre de couches de transformer finales qui utilisent l'attention multi-têtes complète. Utilisé uniquement lorsque num_key_value_heads_per_layer est None.
  • semantic_loss_ignore_index (int, facultatif, valeur par défaut 255) — Index d'étiquette ignoré lors du calcul de la perte de segmentation.
  • flip_pairs (list[list[int]], facultatif) — Paires d'indices de points clés qui sont miroirées horizontalement (par ex., oreille gauche ↔ oreille droite). Chaque paire est une liste de deux éléments [left_index, right_index]. Utilisé pour l'augmentation par retournement horizontal au moment du test dans l'estimation de pose : passez ces paires à l'appel de forward secondaire afin que le modèle retourne les cartes de chaleur avant de les renvoyer.
  • head_config (Sapiens2HeadConfig, facultatif) — Configuration de la tête de décodage. Consultez Sapiens2HeadConfig pour les options disponibles.

Il s’agit de la classe de configuration destinée à stocker la configuration d’un Sapiens2Model. Elle est utilisée pour instancier un modèle Sapiens2 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 facebook/sapiens2-pretrain-0.4b

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.

Sapiens2HeadConfig

classe transformers.Sapiens2HeadConfig

< >

( 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 = Noneupsample_out_channels: list[int] | None = Noneupsample_kernel_sizes: list[int] | None = Noneupsample_kernel_size: int = 4use_pixel_shuffle: bool | None = Noneconv_out_channels: list[int] | None = Noneconv_kernel_sizes: list[int] | None = Noneconv_kernel_size: int = 1scale_conv_out_channels: list[int] | None = Nonescale_conv_kernel_sizes: list[int] | None = Nonescale_conv_kernel_size: int = 1scale_final_input_size: int | None = Nonescale_final_hidden_sizes: list[int] | None = None )

Paramètres

  • upsample_out_channels (list[int], facultatif) — Nombre de canaux de sortie pour chaque bloc de remontée en résolution. Le premier bloc reçoit hidden_size canaux en entrée ; les blocs suivants utilisent la sortie précédente.
  • upsample_kernel_sizes (list[int], facultatif) — Taille du noyau pour chaque bloc de suréchantillonnage. Rempli automatiquement avec [4, ...] lorsque upsample_out_channels est défini mais que celui-ci est None. Doit avoir la même longueur que upsample_out_channels.
  • upsample_kernel_size (int, par défaut 4) — Taille de noyau par défaut pour les blocs d'interpolation ascendante lorsque upsample_kernel_sizes n'est pas défini.
  • use_pixel_shuffle (bool, facultatif) — Indique si la tête de suréchantillonnage utilise le suréchantillonnage par pixel-shuffle plutôt que des convolutions transposées. Lorsque None (par défaut), la tête utilise des convolutions transposées.
  • conv_out_channels (list[int], facultatif) — Nombre de canaux de sortie pour les couches de convolution de raffinement qui suivent les blocs de suréchantillonnage.
  • conv_kernel_sizes (list[int], facultatif) — Taille du noyau pour chaque couche de convolution de raffinement. Rempli automatiquement avec [1, ...] lorsque conv_out_channels est défini mais que celui-ci est None. Doit avoir la même longueur que conv_out_channels.
  • conv_kernel_size (int, par défaut 1) — Taille de noyau par défaut pour les couches conv lorsque conv_kernel_sizes n'est pas défini.
  • scale_conv_out_channels (list[int], facultatif) — Nombre de canaux de sortie des couches de convolution de pas 2 utilisées pour prédire l'échelle de la distance focale. Lorsque None (par défaut), aucune branche d'échelle n'est construite.
  • scale_conv_kernel_sizes (list[int], facultatif) — Taille du noyau pour chaque couche de convolution d'échelle. Rempli automatiquement avec [1, ...] lorsque scale_conv_out_channels est défini mais que celui-ci est None. Doit avoir la même longueur que scale_conv_out_channels.
  • scale_conv_kernel_size (int, par défaut 1) — Taille de noyau par défaut pour les couches de convolution d'échelle lorsque scale_conv_kernel_sizes n'est pas défini.
  • scale_final_input_size (int, facultatif) — Taille des caractéristiques aplatie transmise au MLP d'échelle. Lorsque None (par défaut), elle est inférée automatiquement à partir de image_size et patch_size dans le Sapiens2Config parent.
  • scale_final_hidden_sizes (list[int], facultatif) — Tailles des couches cachées du MLP qui mappe les caractéristiques d'échelle aplatie vers la sortie scalaire d'échelle. Lorsque None (par défaut), aucune branche d'échelle n'est construite.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sapiens2Model. Elle est utilisée pour instancier un modèle Sapiens2 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 facebook/sapiens2-seg-0.4b

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.

Sapiens2ImageProcessor

classe transformers.Sapiens2ImageProcessor

< >

( **kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'> )

Paramètres

  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 1024, 'width': 768}) : Définit les dimensions d'entrée maximales du modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 224, 'width': 224}) : Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_reduce_labels (bool, kwargs, facultatif, par défaut self.do_reduce_labels) — Indique s'il faut réduire de 1 toutes les valeurs des étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes du jeu de données (par exemple ADE20k). L'étiquette de l'arrière-plan sera remplacée par 255.
  • keypoint_heatmap_downscale_factor (int, kwargs, facultatif, valeur par défaut : 4) — Facteur de réduction de la taille de la carte de chaleur cible par rapport à la taille d'entrée du modèle.
  • keypoint_heatmap_sigma (float, kwargs, facultatif, valeur par défaut : 6.0) — L'écart type (sigma) des distributions gaussiennes 2D utilisées pour générer les cartes de chaleur.

Construit un processeur d’image Sapiens2ImageProcessor.

prétraiter

< >

( 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] = Noneboxes: list[list[list[float]]] | None = Nonekeypoints: list[list[list[list[float]]]] | None = None**kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • segmentation_maps (ImageInput, facultatif) — Les cartes de segmentation à prétraiter.
  • boxes (list[list[list[float]]] ou np.ndarray, facultatif) — Liste ou tableau de boîtes englobantes pour chaque image. Chaque boîte doit être une liste de 4 flottants représentant les coordonnées de la boîte englobante au format COCO (top_left_x, top_left_y, width, height). Lorsqu’elles sont fournies, chaque recadrage de personne est transformé de manière affine à la taille d’entrée du modèle au lieu de redimensionner l’image entière.
  • keypoints (list[list[list[list[float]]]], optional) — List of keypoints for each person in each image. Expected format is COCO-style [x, y, visibility]. The x and y values are expected to be absolute image pixel coordinates. Format is [images -> persons -> keypoints -> [x, y, visibility]]. Used to generate ground-truth heatmaps and visibility weights for pose estimation fine-tuning.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_reduce_labels (bool, kwargs, facultatif, par défaut self.do_reduce_labels) — Indique s'il faut réduire de 1 toutes les valeurs des étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes du jeu de données (par exemple ADE20k). L'étiquette de l'arrière-plan sera remplacée par 255.
  • keypoint_heatmap_downscale_factor (int, kwargs, facultatif, valeur par défaut : 4) — Facteur de réduction de la taille de la carte de chaleur cible par rapport à la taille d'entrée du modèle.
  • keypoint_heatmap_sigma (float, kwargs, facultatif, valeur par défaut : 6.0) — L'écart type (sigma) des distributions gaussiennes 2D utilisées pour générer les cartes de chaleur.

Retourne

~image_processing_base.BatchFeature

  • data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

post_process_image_matting

< >

( outputstarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonebackgrounds: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None ) → list[dict] of length batch_size. Each dict has

Paramètres

  • outputs (Sapiens2ImageMattingOutput) — Sorties brutes du modèle.
  • target_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Requested final (height, width) for each prediction. Resized with bilinear interpolation. If unset, predictions are returned at the model output resolution.
  • backgrounds (ImageInput, facultatif) — Image(s) de fond à superposer. Peut être une image unique (appliquée à chaque élément du lot) ou une liste d'images, une par élément du lot. Accepte des images PIL, des tableaux numpy ou des tenseurs torch de n'importe quel dtype ; les types entiers (par ex. uint8) sont mis à l'échelle sur [0, 1] automatiquement. Lorsqu'il est fourni, chaque dictionnaire de résultat reçoit une clé "composite" contenant l'image composée en tant que tenseur uint8 dans [0, 255].

Retourne

list[dict] de longueur batch_size. Chaque dict contient

  • "alpha" (torch.Tensor de forme (1, height, width)) : valeurs alpha dans [0, 1].
  • "foreground" (torch.Tensor de forme (3, height, width)) : RGB pré-multiplié dans [0, 1].
  • "composite" (torch.Tensor de forme (3, height, width) ou None) : premier plan composité sur backgrounds sous forme de tenseur uint8 dans [0, 255] ; None lorsque backgrounds n’est pas fourni.

Convertit la sortie de Sapiens2ForImageMatting en masques alpha et cartes de premier plan.

post_process_normal_estimation

< >

( outputssource_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonedo_remove_padding: bool | None = None )

Paramètres

  • outputs (Sapiens2NormalEstimatorOutput) — Sorties brutes du modèle.
  • source_sizes (torch.Tensor or list[tuple[int, int]] de longueur batch_size, facultatif) — (height, width) d’origine de chaque image avant le prétraitement. Si cette valeur est fournie, le bourrelet ajouté lors du prétraitement est retiré et les prédictions sont redimensionnées pour retrouver la taille d’origine de l’image (sauf si target_sizes définit la taille finale).
  • target_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Requested final (height, width) for each prediction. When provided, used as the resize target instead of source_sizes. Resized with bilinear interpolation after L2 normalization.
  • do_remove_padding (bool, facultatif) — Indique s'il faut supprimer le bourrage de zéros ajouté lors de la prétraitement avant le redimensionnement. La valeur par défaut est True si source_sizes est fourni, False sinon.

Convertit la sortie de Sapiens2ForNormalEstimation en cartes de normales de surface normalisées en L2.

post_process_pointmap_estimation

< >

( outputssource_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonedo_remove_padding: bool | None = None )

Paramètres

  • outputs (Sapiens2PointmapEstimatorOutput) — Sorties brutes du modèle.
  • source_sizes (torch.Tensor or list[tuple[int, int]] de longueur batch_size, facultatif) — (height, width) d’origine de chaque image avant le prétraitement. Si cette valeur est fournie, le bourrelet ajouté lors du prétraitement est retiré et les prédictions sont redimensionnées pour retrouver la taille d’origine de l’image (sauf si target_sizes définit la taille finale).
  • target_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Requested final (height, width) for each prediction. Overrides source_sizes as the resize target.
  • do_remove_padding (bool, facultatif) — Indique s'il faut supprimer le bourrage de zéros ajouté lors de la prétraitement avant le redimensionnement. La valeur par défaut est True si source_sizes est fourni, False sinon.

Convertit la sortie de Sapiens2ForPointmapEstimation en tenseurs de pointmap dans l'espace image.

post_process_pose_estimation

< >

( outputsboxes: listoutputs_flipped = Nonekernel_size: int = 11threshold: float | None = Nonesource_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None ) → list[list[dict]]

Paramètres

  • outputs (Sapiens2PoseEstimatorOutput) — Sorties brutes du modèle. outputs.heatmaps doit avoir la forme (N_total, num_keypoints, heatmap_height, heatmap_width) où N_total = sum(len(b) for b in boxes).
  • boxes (list[list[list[float]]] ou np.ndarray) — Liste ou tableau de boîtes englobantes pour chaque image, en coordonnées de pixels absolues. Chaque boîte doit être une liste de 4 flottants représentant les coordonnées de la boîte englobante au format COCO (top_left_x, top_left_y, width, height). Doit correspondre à l'argument boxes transmis à preprocess.
  • outputs_flipped (Sapiens2PoseEstimatorOutput, facultatif) — Sorties obtenues en exécutant le modèle sur des entrées retournées horizontalement. Si fournies, les heatmaps sont moyennées avec outputs avant l’extraction des points clés afin d’améliorer la précision : avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2.
  • kernel_size (int, facultatif, valeur par défaut : 11) — Taille du noyau pour le flou gaussien utilisé dans le raffinement UDP Dark Pose.
  • threshold (float, facultatif) — Seuil de score. Les points clés dont le score est inférieur ou égal à cette valeur sont exclus des dictionnaires de résultats.
  • source_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Original (height, width) of each image in pixels. Required when target_sizes is provided, as the source coordinate space for scaling keypoints and bounding boxes.
  • target_sizes (torch.Tensor ou list[tuple[int, int]] de longueur batch_size, facultatif) — Espace de coordonnées de sortie (height, width) souhaité pour chaque image. Lorsqu’il est fourni avec source_sizes, les coordonnées des points clés et les boîtes englobantes sont mises à l’échelle de l’espace source vers l’espace cible.

Retourne

list[list[dict]]

La liste externe parcourt les images, la liste interne parcourt les personnes. Chaque dictionnaire contient :

  • keypoints (torch.Tensor de forme (num_keypoints, 2)) : coordonnées x/y absolues dans l’espace de l’image source, ou dans l’espace cible si target_sizes est fourni.
  • scores (torch.Tensor de forme (num_keypoints,)) : confiance par point clé.
  • labels (torch.LongTensor de forme (num_keypoints,)) : indices des points clés.
  • bbox (torch.Tensor de forme (4,)) : boîte englobante au format absolu (x_min, y_min, x_max, y_max), dans le même espace de coordonnées que keypoints.

Convertit la sortie de Sapiens2ForPoseEstimation en prédictions de points clés dans l'espace de l'image.

post_process_semantic_segmentation

< >

( outputstarget_sizes: list[tuple] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

Paramètres

  • outputs (Sapiens2ForSemanticSegmentation) — Sorties brutes du modèle.
  • target_sizes (list[Tuple] de longueur batch_size, facultatif) — Liste de tuples correspondant à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si non défini, les prédictions ne seront pas redimensionnées.
  • return_segmentation_scores (bool, facultatif, par défaut False) — Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. Si True, chaque élément de la liste retournée est un SemanticSegmentationPostProcessorOutput avec les champs segmentation (IDs de classes, forme (height, width)) et segmentation_scores (forme (num_classes, height, width)).

Retourne

list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]

Lorsque return_segmentation_scores=False (par défaut), une liste de longueur batch_size où chaque élément est une carte de segmentation de forme (height, width) avec des identifiants de classes. Lorsque return_segmentation_scores=True, une liste de SemanticSegmentationPostProcessorOutput avec les champs segmentation (identifiants de classes, forme (height, width)) et segmentation_scores (forme (num_classes, height, width)). Dans les deux cas, (height, width) correspond à la taille cible (si target_sizes est spécifiée).

Convertit la sortie de Sapiens2ForSemanticSegmentation en cartes de segmentation sémantique.

Sapiens2Model

classe transformers.Sapiens2Model

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le modèle Sapiens2 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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: Tensorbool_masked_pos: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).
  • bool_masked_pos (torch.BoolTensor de forme (batch_size, sequence_length), facultatif) — Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). Pertinent uniquement pour le pré-entraînement.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

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

La méthode forward de Sapiens2Model 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.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • 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, sequence_length, 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, sequence_length, 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.

Exemple :

>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-pretrain-0.4b")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> cls_token = outputs.pooler_output
>>> cls_token.shape
torch.Size([1, 1024])

Sapiens2Backbone

classe transformers.Sapiens2Backbone

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le backbone Sapiens2.

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: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2BackboneOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).

Retourne

Sapiens2BackboneOutput ou tuple(torch.Tensor)

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

La méthode forward de Sapiens2Backbone 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.

  • feature_maps (tuple(torch.Tensor) de forme (batch_size, num_channels, height, width)) — Cartes de caractéristiques des étapes.

  • 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 + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size) ou (batch_size, num_channels, height, width), selon le backbone.

    États cachés du modèle à la sortie de chaque étape, ainsi que les sorties des embeddings initiaux.

  • 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, sequence_length, sequence_length). Applicable uniquement si le backbone utilise l'attention.

    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.

  • cls_tokens (tuple(torch.Tensor), facultatif) — jeton CLS de chaque étape de fonction sélectionnée, chacun de forme (batch_size, hidden_size). Présent uniquement lorsque config.return_class_token=True.

Exemple :

>>> from transformers import AutoBackbone, AutoImageProcessor
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
>>> model = AutoBackbone.from_pretrained("facebook/sapiens2-pretrain-0.4b")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs, return_class_token=True)

>>> outputs.feature_maps[0].shape
torch.Size([1, 1024, 64, 48])
>>> outputs.cls_tokens[0].shape
torch.Size([1, 1024])

Sapiens2ForImageMatting

classe transformers.Sapiens2ForImageMatting

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le modèle Sapiens2 avec une tête de matting en haut (un décodeur basé sur PixelShuffle qui prédit un premier plan RGB pré-multiplié et une matité alpha).

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: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2ImageMattingOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).
  • labels (torch.Tensor de forme (batch_size, 4, height, width), facultatif) — Cibles de matting de référence pour le calcul de la perte.

Retourne

Sapiens2ImageMattingOutput ou tuple(torch.Tensor)

Un Sapiens2ImageMattingOutput 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 (Sapiens2Config) et des entrées.

La méthode forward de Sapiens2ForImageMatting 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.

  • alphas (torch.Tensor de forme (batch_size, 1, height, width)) — Valeurs alpha estimées.

  • 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 étape) de forme (batch_size, sequence_length, hidden_size). États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

  • 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, sequence_length, 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.

  • premiers plans (torch.Tensor de forme (batch_size, 3, height, width)) — Prédictions de premier plan RGB pré-multipliées dans [0, 1] (activées par sigmoïde).

Exemple :

>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-matting-1b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-matting-1b")

>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> outputs.alphas.shape
torch.Size([1, 1, 1024, 768])
>>> outputs.foregrounds.shape
torch.Size([1, 3, 1024, 768])

Sapiens2ForNormalEstimation

classe transformers.Sapiens2ForNormalEstimation

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le modèle Sapiens2 avec une tête d'estimation des normales au sommet (un décodeur basé sur PixelShuffle qui prédit les cartes de normales de surface).

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: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2NormalEstimatorOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).
  • labels (torch.Tensor de forme (batch_size, num_labels, height, width), facultatif) — Cartes de normales de surface de référence pour le calcul de la perte.

Retourne

Sapiens2NormalEstimatorOutput ou tuple(torch.Tensor)

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

La méthode forward de Sapiens2ForNormalEstimation 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 d'estimation normale.
  • normals (torch.Tensor de forme (batch_size, num_labels, height, width)) — Prédictions brutes de la carte des normales en sortie du modèle (non normalisées).
  • 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 + un pour la sortie de chaque étape) de forme (batch_size, sequence_length, hidden_size). États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.
  • 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, sequence_length, sequence_length). Poids des attentions après le softmax d'attention.

Exemple :

>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-normal-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-normal-0.4b")

>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> outputs.normals.shape
torch.Size([1, 3, 1024, 768])

Sapiens2ForPointmapEstimation

classe transformers.Sapiens2ForPointmapEstimation

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le modèle Sapiens2 avec une tête pointmap en haut (un décodeur basé sur PixelShuffle qui prédit les coordonnées 3D XYZ par pixel, ainsi qu'une branche d'échelle facultative pour la normalisation de la longueur focale).

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: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PointmapEstimatorOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).
  • labels (torch.Tensor de forme (batch_size, 3, height, width), facultatif) — Pointmap de référence pour le calcul de la perte.

Retourne

Sapiens2PointmapEstimatorOutput ou tuple(torch.Tensor)

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

La méthode forward de Sapiens2ForPointmapEstimation 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 d'estimation de Pointmap.
  • pointmaps (torch.Tensor de forme (batch_size, 3, height, width)) — Prédictions des coordonnées 3D XYZ par pixel dans l'espace caméra canonique.
  • scales (torch.Tensor de forme (batch_size, 1), facultatif) — Rapport entre la focale canonique et la focale réelle. None si aucune branche d'échelle n'est configurée.
  • 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 + un pour la sortie de chaque étape) de forme (batch_size, sequence_length, hidden_size). États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.
  • 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, sequence_length, sequence_length). Poids des attentions après le softmax d'attention.

Exemple :

>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pointmap-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-pointmap-0.4b")

>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> outputs.pointmaps.shape
torch.Size([1, 3, 1024, 768])

Sapiens2ForPoseEstimation

classe transformers.Sapiens2ForPoseEstimation

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le modèle Sapiens2 avec une tête d’estimation de pose au sommet (un ensemble de prédicteurs de cartes de chaleur au-dessus des états cachés en sortie).

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: Tensorflip_pairs: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonelabel_weights: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PoseEstimatorOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).
  • flip_pairs (torch.Tensor de forme (num_pairs, 2), facultatif) — Paires de points clés qui sont des miroirs l'un de l'autre (par exemple, oreille gauche — oreille droite), utilisés pour l'augmentation par retournement au moment du test. S'ils sont fournis, le modèle suppose que pixel_values contient des images retournées horizontalement et appelle flip_back sur les cartes de chaleur de sortie pour restaurer l'orientation d'origine.
  • labels (torch.Tensor de forme (batch_size, num_keypoints, height, width), facultatif) — Valeur de référence de la carte de chaleur pour le calcul de la perte.
  • label_weights (torch.Tensor de forme (batch_size, num_labels, 1, 1) ou (batch_size, num_labels, height, width), facultatif) — Poids de visibilité pour chaque point clé. Doit être diffusable à la forme de labels.

Retourne

Sapiens2PoseEstimatorOutput ou tuple(torch.Tensor)

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

La méthode forward de Sapiens2ForPoseEstimation 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 d'estimation de pose.

  • cartes de chaleur (torch.Tensor de forme (batch_size, num_keypoints, height, width)) — Cartes de chaleur telles que prédites par le modèle.

  • 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 étape) de forme (batch_size, sequence_length, hidden_size). États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

  • 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, sequence_length, 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.

Exemple :

>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pose-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-pose-0.4b")

>>> boxes = [[[270.8, 0.6, 294.1, 379.5]]]
>>> inputs = image_processor(image, boxes=boxes, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> outputs.heatmaps.shape
torch.Size([1, 308, 256, 192])

Sapiens2ForSemanticSegmentation

classe transformers.Sapiens2ForSemanticSegmentation

< >

( config: Sapiens2Config )

Paramètres

  • config (Sapiens2Config) — 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.

Le modèle Sapiens2 avec une tête de segmentation sémantique au sommet, 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: Tensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SemanticSegmenterOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de Sapiens2ImageProcessor. Consultez Sapiens2ImageProcessor.call() pour plus de détails (processor_class utilise Sapiens2ImageProcessor pour le traitement des images).
  • 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).

Retourne

SemanticSegmenterOutput ou tuple(torch.Tensor)

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

La méthode forward de Sapiens2ForSemanticSegmentation 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.

Exemple :

>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch

>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-seg-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-seg-0.4b")

>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> outputs.logits.shape
torch.Size([1, 29, 1024, 768])
Update on GitHub

←Sam3Tracker SegFormer→