# Sapiens2

    
        
        
    

## Aperçu

Le modèle Sapiens2 a été proposé dans [Sapiens2](https://huggingface.co/papers/2604.21681) par Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su et 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](https://huggingface.co/collections/facebook/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](https://huggingface.co/guarin). Le code d'origine peut être trouvé [ici](https://github.com/facebookresearch/sapiens2).

## Exemples d'utilisation

L’exemple ci-dessous montre comment obtenir le jeton CLS (représentation de l’image entière) avec [Sapiens2Model](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Model).

```python
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]
```

[Sapiens2Backbone](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Backbone) expose les jetons de patch déjà redimensionnés aux dimensions spatiales et les jetons CLS directement sur l'objet de sortie.

```python
import torch
from transformers import AutoBackbone, AutoImageProcessor
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 = AutoBackbone.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, return_class_token=True)

# Patch tokens shaped (batch, height, width, channels)
patch_features = outputs.feature_maps[0]
cls_token = outputs.cls_tokens[0]
print("CLS token shape:", cls_token.shape)           # [1, 1024]
print("Patch features shape:", patch_features.shape) # [1, 64, 48, 1024]
```

L’exemple ci-dessous montre comment estimer les normales de surface avec [Sapiens2ForNormalEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForNormalEstimation). Les normales en sortie sont brutes (non normalisées) ; utilisez `post_process_normal_estimation` pour les redimensionner et les normaliser en L2.

```python
import torch
from transformers import AutoImageProcessor, AutoModelForNormalEstimation
from transformers.image_utils import load_image

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

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

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

# outputs.normals shape: (batch_size, 3, height, width) — raw, unnormalized XYZ normals
print("Normals shape:", outputs.normals.shape)  # [1, 3, 1024, 768]

# Remove preprocessing padding, resize to original size, and L2-normalize to unit vectors in [-1, 1]
original_size = (image.height, image.width)
result = image_processor.post_process_normal_estimation(
    outputs, source_sizes=[original_size], target_sizes=[original_size]
)
normals = result[0]["normals"]
print("Normals shape:", normals.shape)   # [3, original_height, original_width]

### Example code for visualization

# Convert L2-normalized normals in [-1, 1] to RGB in [0, 255]
normals_rgb = ((normals + 1.0) / 2.0 * 255.0).clamp(0, 255).to(torch.uint8)

# Apply background removal using the segmentation model output.
# `segmentation` is the output of `post_process_semantic_segmentation` — a (H, W) tensor
# of per-pixel class IDs, where class 0 is background.
background_mask = segmentation == 0
normals_rgb[:, background_mask] = 0
print("Normals RGB shape:", normals_rgb.shape)   # [3, original_height, original_width]
```

L’exemple ci-dessous montre comment estimer les coordonnées 3D par pixel avec [Sapiens2ForPointmapEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForPointmapEstimation). Utilisez `post_process_pointmap_estimation` pour supprimer le padding de prétraitement, redimensionner à la taille de l’image d’origine et appliquer l’échelle de la distance focale prédite.

```python
import torch
from transformers import AutoImageProcessor, AutoModelForPointmapEstimation
from transformers.image_utils import load_image

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

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

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

# outputs.pointmaps shape: (batch_size, 3, height, width) — raw XYZ in canonical camera space
print("Pointmaps shape:", outputs.pointmaps.shape)  # [1, 3, 1024, 768]

# Remove preprocessing padding, resize to original size, and apply focal-length scale
original_size = (image.height, image.width)
result = image_processor.post_process_pointmap_estimation(
    outputs, source_sizes=[original_size], target_sizes=[original_size]
)
pointmap = result[0]["pointmap"]
print("Pointmap shape:", pointmap.shape)  # [3, original_height, original_width]

### Example code for visualization

# Visualize the pointmap as an RGB image using inverse-depth and the turbo colormap.
import matplotlib.pyplot as plt

# `segmentation` is the output of `post_process_semantic_segmentation` — a (H, W) tensor
# of per-pixel class IDs, where class 0 is background.
foreground_mask = segmentation != 0
depth = pointmap[2]  # Z channel: depth in camera space, shape (H, W)
pointmap_rgb = torch.zeros(3, *depth.shape, dtype=torch.uint8)
foreground_depth = depth[foreground_mask]
if foreground_depth.numel() > 0:
    depth_low, depth_high = torch.quantile(foreground_depth, torch.tensor([0.01, 0.99]))
    inverse_depth = 1.0 / foreground_depth.clamp(min=1e-6)
    inverse_depth_low = 1.0 / depth_high.clamp(min=1e-6)
    inverse_depth_high = 1.0 / depth_low.clamp(min=1e-6)
    inverse_depth_normalized = ((inverse_depth - inverse_depth_low) / (inverse_depth_high - inverse_depth_low + 1e-8)).clamp(0, 1)
    turbo = plt.get_cmap("turbo")
    foreground_colors = torch.from_numpy(turbo(inverse_depth_normalized.cpu().numpy())[..., :3] * 255).to(torch.uint8)  # (N, 3)
    pointmap_rgb[:, foreground_mask] = foreground_colors.T
print("Pointmap RGB shape:", pointmap_rgb.shape)  # [3, original_height, original_width]
```

L’exemple ci-dessous montre comment exécuter l’estimation de pose avec [Sapiens2ForPoseEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation). Le modèle prédit des cartes de chaleur par point clé ; utilisez `post_process_pose_estimation` pour les décoder en coordonnées de points clés dans l’espace image. Il nécessite `opencv-python` (`pip install opencv-python`).

```python
import torch
from transformers import AutoImageProcessor, AutoModelForPoseEstimation
from transformers.image_utils import load_image

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

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

# Provide bounding boxes in COCO format (x, y, width, height) for each person
boxes = [[[270.8, 0.6, 294.1, 379.5]]]
inputs = image_processor(image, boxes=boxes, return_tensors="pt").to(model.device)
with torch.inference_mode():
    outputs = model(**inputs)

# outputs.heatmaps shape: (num_persons, num_keypoints, heatmap_height, heatmap_width)
print("Heatmaps shape:", outputs.heatmaps.shape)  # [1, 308, 256, 192]

# Decode heatmaps to image-space keypoint coordinates
results = image_processor.post_process_pose_estimation(outputs, boxes=boxes)[0]
keypoints = results[0]["keypoints"]   # (num_keypoints, 2) — x/y in image coordinates
scores = results[0]["scores"]         # (num_keypoints,) — per-keypoint confidence
print("Keypoints shape:", keypoints.shape)
```

L’augmentation par retournement horizontal (augmentation au moment du test) améliore la précision des points clés en moyennant les prédictions issues de l’image d’origine et de l’image miroir. Transmettez `flip_pairs` — un tenseur de paires `[left_keypoint, right_keypoint]` — à la seconde passe avant. Le modèle retourne les cartes de chaleur à l’orientation d’origine avant de les renvoyer, ce qui permet de moyenner directement les deux sorties.

```python
import torch
from transformers import AutoImageProcessor, AutoModelForPoseEstimation
from transformers.image_utils import load_image

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

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

boxes = [[[270.8, 0.6, 294.1, 379.5]]]
inputs = image_processor(image, boxes=boxes, return_tensors="pt").to(model.device)
pixel_values = inputs["pixel_values"]

flip_pairs = torch.tensor(model.config.flip_pairs, device=model.device)

with torch.inference_mode():
    outputs = model(pixel_values)
    outputs_flipped = model(pixel_values.flip(-1), flip_pairs=flip_pairs)

results = image_processor.post_process_pose_estimation(outputs, outputs_flipped=outputs_flipped, boxes=boxes)[0]
keypoints = results[0]["keypoints"]
scores = results[0]["scores"]
```

L’exemple ci-dessous montre comment calculer la perte supervisée d’erreur quadratique moyenne masquée (MSE) avec [Sapiens2ForPoseEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation) en transmettant `labels` et, le cas échéant, `label_weights`. Cela est utile pour l’ajustement fin à l’aide de l’API `Trainer`.

```python
import torch
from transformers import AutoImageProcessor, AutoModelForPoseEstimation
from transformers.image_utils import load_image

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

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

# Provide bounding boxes in COCO format (x, y, width, height) for each person
boxes = [[[270.8, 0.6, 294.1, 379.5]]]
inputs = image_processor(image, boxes=boxes, return_tensors="pt").to(model.device)

# Create dummy labels (heatmaps) and visibility weights to simulate ground truth
# 1.0 for visible keypoints, 0.0 for occluded/invisible keypoints
batch_size, num_keypoints = 1, 308
heatmap_height, heatmap_width = 1024, 768
labels = torch.randn(batch_size, num_keypoints, heatmap_height, heatmap_width, device=model.device)
label_weights = torch.ones(batch_size, num_keypoints, 1, 1, device=model.device)

# Forward pass with loss calculation
outputs = model(**inputs, labels=labels, label_weights=label_weights)

print("Loss:", outputs.loss.item())
```

L’exemple ci-dessous montre comment effectuer la segmentation de parties du corps avec [Sapiens2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForSemanticSegmentation).

```python
import torch
from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation
from transformers.image_utils import load_image

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

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

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

# outputs.logits shape: (batch_size, num_labels, height, width)
print("Logits shape:", outputs.logits.shape)  # [1, 29, 1024, 768]

# Get per-pixel class predictions, optionally resized to the original image size
original_size = (image.height, image.width)
segmentation = image_processor.post_process_semantic_segmentation(
    outputs, target_sizes=[original_size]
)[0]
print("Segmentation map shape:", segmentation.shape)  # [original_height, original_width]
```

L'exemple ci-dessous montre comment exécuter le matting d'image avec [Sapiens2ForImageMatting](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForImageMatting). Les sorties sont activées par une fonction sigmoïde et sont déjà dans l'intervalle `[0, 1]` ; utilisez `post_process_image_matting` pour redimensionner et séparer en `alphas`, `foregrounds` et une image `composite` facultative. L'image composite montre le premier plan superposé au fond selon la formule : `composite = foreground * (1 - alpha) * background`.

```python
import torch
from transformers import AutoImageProcessor, AutoModelForImageMatting
from transformers.image_utils import load_image

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

image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-matting-1b")
model = AutoModelForImageMatting.from_pretrained("facebook/sapiens2-matting-1b", device_map="auto")

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

# outputs.foregrounds: (1, 3, H, W), outputs.alphas: (1, 1, H, W) — both in [0, 1]
original_size = (image.height, image.width)

# Pass an optional background to composite the foreground over it.
# A (3, 1, 1) tensor broadcasts as a uniform color; PIL images and numpy arrays are also accepted.
background = torch.tensor([0, 177, 64], dtype=torch.uint8).view(3, 1, 1)  # chroma green in RGB
result = image_processor.post_process_image_matting(
    outputs, target_sizes=[original_size], backgrounds=background
)[0]
print("Alpha shape:", result["alpha"].shape)        # [1, original_height, original_width]
print("Foreground shape:", result["foreground"].shape)  # [3, original_height, original_width]
print("Composite shape:", result["composite"].shape)    # [3, original_height, original_width] — uint8 [0, 255]
```

## Sapiens2Config[[transformers.Sapiens2Config]]

#### transformers.Sapiens2Config[[transformers.Sapiens2Config]]

```python
transformers.Sapiens2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, patch_size: int | list[int] | tuple[int, int] = 16, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 24, num_attention_heads: int = 16, hidden_act: str = 'silu', attention_dropout: float | int = 0.0, initializer_range: float = 0.02, rope_theta: float = 100.0, image_size: int | list[int] | tuple[int, int] = 224, num_channels: int = 3, query_bias: bool = True, key_bias: bool = True, value_bias: bool = True, proj_bias: bool = True, mlp_bias: bool = True, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, use_gated_mlp: bool = True, num_register_tokens: int = 8, pos_embed_shift: float | None = None, pos_embed_jitter: float | None = None, pos_embed_rescale: float | None = 2.0, _out_features: list[str] | None = None, _out_indices: list[int] | None = None, reshape_hidden_states: bool = True, use_mask_token: bool = False, rms_norm_eps: float = 1e-06, normalize_backbone_outputs: bool = True, use_qk_norm: bool = True, num_key_value_heads_per_layer: list[int] | None = None, num_key_value_attention_heads: int = 8, num_first_full_attention_layers: int = 8, num_last_full_attention_layers: int = 8, semantic_loss_ignore_index: int = 255, flip_pairs: list[list[int]] | None = None, head_config: transformers.models.sapiens2.configuration_sapiens2.Sapiens2HeadConfig | dict | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/configuration_sapiens2.py#L116)

**Paramètres :**

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `16`) : La taille (résolution) de chaque patch.

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations MLP.

num_hidden_layers (`int`, *facultatif*, valeur 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) dans le 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*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de 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*, valeur 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*, valeur 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*, valeur 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*, valeur 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 des couches.

drop_path_rate (`Union[float, int]`, *facultatif*, valeur 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 de registre.

pos_embed_shift (`float`, *facultatif*) : Amplitude du décalage aléatoire des coordonnées des embeddings de position dans [-shift, shift], appliqué 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 la valeur n'est pas `None`.

pos_embed_rescale (`float`, *facultatif*, valeur par défaut 2.0) : Facteur de mise à l'échelle aléatoire des coordonnées des embeddings de position, appliqué uniquement en mode d'entraînement si la valeur n'est pas `None`. La valeur est tirée uniformément dans l'intervalle [1/rescale, rescale] sur une échelle logarithmique.

reshape_hidden_states (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut redimensionner les états cachés vers les dimensions spatiales lorsqu'il est utilisé 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 lors de l'appel avant. Ne s'applique que lorsque le modèle est utilisé en tant que 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 de clé/valeur pour chaque couche de transformeur. Définir la valeur d'une couche égale à `num_attention_heads` permet une attention multi-têtes complète ; une valeur inférieure permet une attention à requêtes groupées. Par défaut, la valeur est `num_attention_heads` pour les `num_first_full_attention_layers` premières 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 transformer 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 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](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2HeadConfig) pour les options disponibles.

Ceci est 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](https://huggingface.co/facebook/sapiens2-pretrain-0.4b)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## Sapiens2HeadConfig[[transformers.Sapiens2HeadConfig]]

#### transformers.Sapiens2HeadConfig[[transformers.Sapiens2HeadConfig]]

```python
transformers.Sapiens2HeadConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, upsample_out_channels: list[int] | None = None, upsample_kernel_sizes: list[int] | None = None, upsample_kernel_size: int = 4, use_pixel_shuffle: bool | None = None, conv_out_channels: list[int] | None = None, conv_kernel_sizes: list[int] | None = None, conv_kernel_size: int = 1, scale_conv_out_channels: list[int] | None = None, scale_conv_kernel_sizes: list[int] | None = None, scale_conv_kernel_size: int = 1, scale_final_input_size: int | None = None, scale_final_hidden_sizes: list[int] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/configuration_sapiens2.py#L28)

**Paramètres :**

upsample_out_channels (`list[int]`, *facultatif*) : Nombre de canaux de sortie pour chaque bloc de suréchantillonnage. 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`, valeur par défaut 4) : Taille de noyau par défaut pour les blocs de suréchantillonnage 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`, valeur par défaut : 1) : Taille de noyau par défaut pour les couches de convolution lorsque `conv_kernel_sizes` n'est pas défini.

scale_conv_out_channels (`list[int]`, *facultatif*) : Nombre de canaux de sortie pour les couches de convolution de pas 2 utilisées pour prédire l'échelle de la 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 aplaties transmise au MLP d'échelle. Lorsque la valeur est `None` (par défaut), elle est inférée automatiquement à partir de `image_size` et `patch_size` dans le [Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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.

Ceci est 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](https://huggingface.co/facebook/sapiens2-seg-0.4b)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## Sapiens2ImageProcessor[[transformers.Sapiens2ImageProcessor]]

#### transformers.Sapiens2ImageProcessor[[transformers.Sapiens2ImageProcessor]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L407)

**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écrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré 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 d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'é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 d'un jeu de données (par ex. ADE20k). L'étiquette d'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[[transformers.Sapiens2ImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, boxes: list[list[list[float]]] | None = None, keypoints: list[list[list[list[float]]]] | None = None, **kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L430)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez 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 déformé 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]]]]`, *facultatif*) : Liste des points clés pour chaque personne dans chaque image. Le format attendu est de type COCO `[x, y, visibility]`. Les valeurs `x` et `y` sont censées être des coordonnées de pixels absolues de l'image. Le format est `[images -> persons -> keypoints -> [x, y, visibility]]`. Utilisé pour générer les cartes de chaleur de référence et les poids de visibilité pour l'ajustement fin de l'estimation de pose.

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écrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque 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 d'une des valeurs de l'énumération `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 redimensionnement à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'é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 d'un jeu de données (par ex. ADE20k). L'étiquette d'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[[transformers.Sapiens2ImageProcessor.post_process_image_matting]]

```python
post_process_image_matting(outputs, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None, backgrounds: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L891)

**Paramètres :**

outputs (`Sapiens2ImageMattingOutput`) : Sorties brutes du modèle.

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]` de longueur `batch_size`, *facultatif*) : `(height, width)` finale demandée pour chaque prédiction. Redimensionné par interpolation bilinéaire. Si non défini, les prédictions sont renvoyées à la résolution de sortie du modèle.

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'elle est fournie, 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](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForImageMatting) en masques alpha et cartes de premier plan.

#### post_process_normal_estimation[[transformers.Sapiens2ImageProcessor.post_process_normal_estimation]]

```python
post_process_normal_estimation(outputs, source_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None, do_remove_padding: bool | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L818)

**Paramètres :**

outputs (`Sapiens2NormalEstimatorOutput`) : Sorties brutes du modèle.

source_sizes (`torch.Tensor` ou `list[tuple[int, int]]` de longueur `batch_size`, *facultatif*) : `(height, width)` d'origine de chaque image avant le prétraitement. S'il est fourni, le bourrage ajouté lors du prétraitement est supprimé et les prédictions sont redimensionnées à la taille d'origine de l'image (sauf si `target_sizes` définit la taille finale).

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]` de longueur `batch_size`, *facultatif*) : `(height, width)` finale demandée pour chaque prédiction. Si fourni, utilisé comme cible de redimensionnement à la place de `source_sizes`. Redimensionné par interpolation bilinéaire après normalisation L2.

do_remove_padding (`bool`, *facultatif*) : Indique s'il faut retirer 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.

**Retourne :**

`list[dict[str, torch.Tensor]]` de longueur `batch_size`. Chaque dictionnaire possède une clé `"normals"` associée à un tenseur de forme `(3, height, width)` contenant des vecteurs unitaires normalisés en L2 dans `[-1, 1]` par canal (normales de surface XYZ).

Convertit la sortie de [Sapiens2ForNormalEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForNormalEstimation) en cartes de normales de surface normalisées en L2.

#### post_process_pointmap_estimation[[transformers.Sapiens2ImageProcessor.post_process_pointmap_estimation]]

```python
post_process_pointmap_estimation(outputs, source_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None, do_remove_padding: bool | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L854)

**Paramètres :**

outputs (`Sapiens2PointmapEstimatorOutput`) : Sorties brutes du modèle.

source_sizes (`torch.Tensor` ou `list[tuple[int, int]]` de longueur `batch_size`, *facultatif*) : `(height, width)` d'origine de chaque image avant le prétraitement. S'il est fourni, le bourrage ajouté lors du prétraitement est supprimé et les prédictions sont redimensionnées à la taille d'origine de l'image (sauf si `target_sizes` définit la taille finale).

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]` de longueur `batch_size`, *facultatif*) : Taille finale `(height, width)` demandée pour chaque prédiction. Remplace `source_sizes` comme cible de redimensionnement.

do_remove_padding (`bool`, *facultatif*) : Indique s'il faut retirer 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.

**Retourne :**

`list[dict[str, torch.Tensor]]` de longueur `batch_size`. Chaque dictionnaire possède une clé `"pointmap"` associée à un tenseur de forme `(3, height, width)` contenant les coordonnées 3D XYZ par pixel dans l’espace caméra canonique, éventuellement divisées par `outputs.scales` pour convertir en coordonnées métriques.

Convertit la sortie de [Sapiens2ForPointmapEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForPointmapEstimation) en tenseurs de pointmap dans l'espace image.

#### post_process_pose_estimation[[transformers.Sapiens2ImageProcessor.post_process_pose_estimation]]

```python
post_process_pose_estimation(outputs, boxes: list, outputs_flipped = None, kernel_size: int = 11, threshold: float | None = None, source_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L676)

**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 cartes de chaleur 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 filtrés des dictionnaires de résultats.

source_sizes (`torch.Tensor` ou `list[tuple[int, int]]` de longueur `batch_size`, *facultatif*) : `(height, width)` d'origine de chaque image, en pixels. Requis lorsque `target_sizes` est fourni, car il sert d'espace de coordonnées source pour l'échelle des points clés et des boîtes englobantes.

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](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation) en prédictions de points clés dans l'espace de l'image.

#### post_process_semantic_segmentation[[transformers.Sapiens2ImageProcessor.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple] | None = None, return_segmentation_scores: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/image_processing_sapiens2.py#L610)

**Paramètres :**

outputs ([Sapiens2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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*, valeur 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` (identifiants 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](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ForSemanticSegmentation) en cartes de segmentation sémantique.

## Sapiens2Model[[transformers.Sapiens2Model]]

#### transformers.Sapiens2Model[[transformers.Sapiens2Model]]

```python
transformers.Sapiens2Model(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L867)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2Model.forward]]

```python
forward(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L880)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 la pré-formation.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2Model](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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)`.

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

Exemple :

```python
>>> 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[[transformers.Sapiens2Backbone]]

#### transformers.Sapiens2Backbone[[transformers.Sapiens2Backbone]]

```python
transformers.Sapiens2Backbone(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L929)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le backbone Sapiens2.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2Backbone.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L942)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2Backbone](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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.

  Pondérations des attentions après le softmax d'attention, utilisées 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 :

```python
>>> 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[[transformers.Sapiens2ForImageMatting]]

#### transformers.Sapiens2ForImageMatting[[transformers.Sapiens2ForImageMatting]]

```python
transformers.Sapiens2ForImageMatting(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1365)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2ForImageMatting.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1372)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2ForImageMatting](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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)`.

  Pondérations des attentions après le softmax d'attention, utilisées 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 :

```python
>>> 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[[transformers.Sapiens2ForNormalEstimation]]

#### transformers.Sapiens2ForNormalEstimation[[transformers.Sapiens2ForNormalEstimation]]

```python
transformers.Sapiens2ForNormalEstimation(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1215)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2ForNormalEstimation.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1223)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2ForNormalEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 :

```python
>>> 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[[transformers.Sapiens2ForPointmapEstimation]]

#### transformers.Sapiens2ForPointmapEstimation[[transformers.Sapiens2ForPointmapEstimation]]

```python
transformers.Sapiens2ForPointmapEstimation(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1287)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Sapiens2 avec une tête pointmap en amont (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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2ForPointmapEstimation.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1299)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2ForPointmapEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 de 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 :

```python
>>> 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[[transformers.Sapiens2ForPoseEstimation]]

#### transformers.Sapiens2ForPoseEstimation[[transformers.Sapiens2ForPoseEstimation]]

```python
transformers.Sapiens2ForPoseEstimation(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1132)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2ForPoseEstimation.forward]]

```python
forward(pixel_values: Tensor, flip_pairs: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, label_weights: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1140)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) pour le traitement des images).

flip_pairs (`torch.Tensor` de forme `(num_pairs, 2)`, *facultatif*) : Paires de points clés qui sont en miroir (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*) : Vrai 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 selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2ForPoseEstimation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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)`.

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

Exemple :

```python
>>> 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[[transformers.Sapiens2ForSemanticSegmentation]]

#### transformers.Sapiens2ForSemanticSegmentation[[transformers.Sapiens2ForSemanticSegmentation]]

```python
transformers.Sapiens2ForSemanticSegmentation(config: Sapiens2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1019)

**Paramètres :**

config ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.Sapiens2ForSemanticSegmentation.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sapiens2/modeling_sapiens2.py#L1027)

**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 des pixels peuvent être obtenues à l'aide de [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Voir [Sapiens2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [Sapiens2ImageProcessor](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 (entropie croisée).

**Retourne :** [SemanticSegmenterOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) ou `tuple(torch.Tensor)`

Un [SemanticSegmenterOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sapiens2Config](/docs/transformers/main/fr/model_doc/sapiens2#transformers.Sapiens2Config)) et les entrées.

La méthode forward de [Sapiens2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/sapiens2#transformers.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 au besoin.

  
- **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)`.

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

Exemple :

```python
>>> 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])
```