# Sapiens2

    
        
        
    

## Resumen

El modelo Sapiens2 fue propuesto en [Sapiens2](https://huggingface.co/papers/2604.21681) por Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su y Shunsuke Saito. Sapiens2 es una familia de vision transformers de alta resolución preentrenados en aproximadamente 1 mil millones de imágenes humanas curadas, diseñados para tareas de visión por computadora centradas en humanos, que incluyen estimación de pose, segmentación de partes del cuerpo, estimación de normales de superficie y estimación de pointmaps.

Puedes encontrar todos los checkpoints originales de Sapiens2 en la colección [Sapiens2](https://huggingface.co/collections/facebook/sapiens2).

El resumen del artículo es el siguiente:

*Presentamos Sapiens2, una familia de transformers de alta resolución para visión centrada en humanos, enfocada en la generalización, la versatilidad y las salidas de alta fidelidad. Realizamos el preentrenamiento en aproximadamente 1 mil millones de imágenes humanas de alta calidad curadas, con anotaciones de tareas mejoradas, y combinamos la reconstrucción de imágenes enmascaradas con objetivos contrastivos autodestilados para aprender tanto características de bajo nivel como semánticas. Nuestros modelos escalan desde 0.4B hasta 5B parámetros y se entrenan a una resolución nativa de 1K, con variantes jerárquicas de 4K para el razonamiento espacial extendido. Sapiens2 logra mejoras sustanciales sobre su predecesor: +4 mAP en estimación de pose, +24.3 mIoU en segmentación de partes del cuerpo y una reducción del 45.6% en el error de estimación de normales, al tiempo que se extiende a nuevas tareas como la estimación de pointmap y albedo. El código está disponible públicamente.*

Consejos:

- Sapiens2 utiliza incrustaciones de posición rotacional (RoPE) y admite resoluciones de entrada arbitrarias. El procesador de imágenes predeterminado redimensiona las imágenes a 1024×768 (alto×ancho).
- El modelo usa Grouped Query Attention (GQA) para las capas intermedias y atención multi-cabeza completa para las primeras y últimas 8 capas.
- Los tokens de registro (8 por defecto) reducen los artefactos de alta norma en los tokens de parche, lo que produce mapas de atención más limpios y un mejor rendimiento en tareas de predicción densa.

Este modelo fue aportado por [guarin](https://huggingface.co/guarin). El código original se puede encontrar [aquí](https://github.com/facebookresearch/sapiens2).

## Ejemplos de uso

El siguiente ejemplo muestra cómo obtener el token CLS (incrustación de la imagen completa) con [Sapiens2Model](/docs/transformers/v5.23.0/es/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/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Backbone) expone los tokens de parche ya redimensionados a dimensiones espaciales y los tokens CLS directamente en el objeto de salida.

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

El siguiente ejemplo muestra cómo estimar normales de superficie con [Sapiens2ForNormalEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForNormalEstimation). Las normales de salida son crudas (sin normalizar); use `post_process_normal_estimation` para redimensionarlas y normalizarlas 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]
```

El siguiente ejemplo muestra cómo estimar coordenadas 3D por píxel con [Sapiens2ForPointmapEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPointmapEstimation). Utilice `post_process_pointmap_estimation` para eliminar el relleno de preprocesamiento, redimensionar al tamaño original de la imagen y aplicar la escala de longitud focal predicha.

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

El siguiente ejemplo muestra cómo ejecutar la estimación de pose con [Sapiens2ForPoseEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation). El modelo predice mapas de calor por punto clave; use `post_process_pose_estimation` para decodificarlos y obtener las coordenadas de los puntos clave en el espacio de la imagen. Requiere `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)
```

La aumentación por volteo horizontal (aumentación en el momento de la prueba) mejora la precisión de los puntos clave promediando las predicciones de la imagen original y la imagen espejada. Pasa `flip_pairs`, un tensor de pares `[left_keypoint, right_keypoint]`, a la segunda pasada hacia adelante. El modelo vuelve a voltear los mapas de calor a la orientación original antes de devolverlos, por lo que puedes promediar directamente ambas salidas.

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

El siguiente ejemplo muestra cómo calcular la pérdida supervisada de error cuadrático medio (MSE) enmascarado con [Sapiens2ForPoseEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation) pasando `labels` y `label_weights` opcionales. Esto es útil para el ajuste fino usando la API de `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())
```

El siguiente ejemplo muestra cómo realizar la segmentación de partes del cuerpo con [Sapiens2ForSemanticSegmentation](/docs/transformers/v5.23.0/es/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]
```

El ejemplo siguiente muestra cómo ejecutar el matting de imágenes con [Sapiens2ForImageMatting](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForImageMatting). Las salidas están activadas con sigmoid y ya están en `[0, 1]`; use `post_process_image_matting` para redimensionar y dividir en `alphas`, `foregrounds` y una imagen `composite` opcional. La imagen composite muestra el primer plano superpuesto sobre el fondo con la fórmula: `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)
```

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

**Parámetros:**

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas.

intermediate_size (`int`, *opcional*, valor predeterminado `4096`) : Dimensión de las representaciones MLP.

num_hidden_layers (`int`, *opcional*, valor predeterminado `24`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

rope_theta (`float`, *opcional*, valor predeterminado 100.0) : El período base de las incrustaciones RoPE.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `224`) : El tamaño (resolución) de cada imagen.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

query_bias (`bool`, *opcional*, valor predeterminado `True`) : Si se debe añadir un sesgo a la proyección de la consulta.

key_bias (`bool`, *opcional*, valor predeterminado `False`) : Si se debe añadir un sesgo a la proyección de la clave.

value_bias (`bool`, *opcional*, valor predeterminado `True`) : Si se debe añadir un sesgo a la proyección de valor.

proj_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un sesgo a la proyección de salida.

mlp_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar un sesgo en las capas up_proj, down_proj y gate_proj de las capas MLP.

layerscale_value (`float`, *opcional*, valor predeterminado 1.0) : Valor inicial para la escala de la capa.

drop_path_rate (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : Tasa de drop path para la fusión de parches.

use_gated_mlp (`bool`, *opcional*, por defecto `False`) : Si se debe usar la red neuronal de avance SwiGLU.

num_register_tokens (`int`, *opcional*, valor predeterminado 0) : El número de tokens de registro.

pos_embed_shift (`float`, *opcional*) : Cantidad para desplazar aleatoriamente las coordenadas de la incrustación de posición en [-shift, shift], aplicado solo en modo de entrenamiento si no es `None`.

pos_embed_jitter (`float`, *opcional*) : Cantidad para ajustar aleatoriamente las coordenadas de la incrustación de posición en un valor log-uniforme en [1/jitter, jitter], aplicado solo en modo de entrenamiento si no es `None`.

pos_embed_rescale (`float`, *opcional*, valor predeterminado 2.0) : Cantidad para reescalar aleatoriamente las coordenadas de la incrustación de posición en un valor log-uniforme en [1/rescale, rescale], aplicado solo en modo de entrenamiento si no es `None`.

reshape_hidden_states (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben redimensionar los estados ocultos a dimensiones espaciales cuando se utiliza como backbone.

use_mask_token (`bool`, *opcional*, valor predeterminado `False`) : Si se debe usar un token de máscara en las incrustaciones (necesario para el entrenamiento previo de modelado de imágenes enmascaradas).

rms_norm_eps (`float`, *opcional*, valor predeterminado 1e-6) : Epsilon para las capas de normalización RMS.

normalize_backbone_outputs (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar RMSNorm a las salidas `feature_maps` y `cls_tokens` del backbone antes de devolverlas desde la pasada hacia adelante. Solo se aplica cuando el modelo se utiliza como backbone.

use_qk_norm (`bool`, *opcional*, valor predeterminado `True`) : Si se aplica RMSNorm a las consultas y claves antes de RoPE en las capas de atención.

num_key_value_heads_per_layer (`list[int]`, *opcional*) : Número de cabezas de clave/valor para cada capa del transformador. Establecer el valor de una capa igual a `num_attention_heads` proporciona atención multi-cabeza completa; un valor menor proporciona atención de consulta agrupada. El valor predeterminado es `num_attention_heads` para las primeras `num_first_full_attention_layers` y las últimas `num_last_full_attention_layers` capas, y `num_key_value_attention_heads` para todas las demás capas.

num_key_value_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de clave/valor para las capas que utilizan atención de consulta agrupada cuando `num_key_value_heads_per_layer` no está establecido. Se ignora cuando `num_key_value_heads_per_layer` está establecido.

num_first_full_attention_layers (`int`, *opcional*, valor predeterminado 8) : Número de capas iniciales de transformer que utilizan atención multi-cabeza completa. Solo se utiliza cuando `num_key_value_heads_per_layer` es `None`.

num_last_full_attention_layers (`int`, *opcional*, valor predeterminado 8) : Número de capas finales de transformer que utilizan atención multi-cabeza completa. Solo se utiliza cuando `num_key_value_heads_per_layer` es `None`.

semantic_loss_ignore_index (`int`, *opcional*, valor predeterminado 255) : Índice de etiqueta que se ignora al calcular la pérdida de segmentación.

flip_pairs (`list[list[int]]`, *opcional*) : Pares de índices de puntos clave que se reflejan horizontalmente (p. ej., oreja izquierda ↔ oreja derecha). Cada par es una lista de dos elementos `[left_index, right_index]`. Se utiliza para la aumentación por volteo horizontal en tiempo de prueba en la estimación de pose: pase estos pares a la segunda llamada de forward para que el modelo vuelva a voltear los mapas de calor antes de devolverlos.

head_config (`Sapiens2HeadConfig`, *opcional*) : Configuración para la cabeza de decodificación. Consulte [Sapiens2HeadConfig](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2HeadConfig) para ver las opciones disponibles.

Esta es la clase de configuración para almacenar la configuración de un Sapiens2Model. Se utiliza para instanciar un modelo Sapiens2 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sapiens2-pretrain-0.4b](https://huggingface.co/facebook/sapiens2-pretrain-0.4b)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

**Parámetros:**

upsample_out_channels (`list[int]`, *opcional*) : Número de canales de salida para cada bloque de submuestreo ascendente. El primer bloque toma `hidden_size` canales como entrada; los bloques posteriores utilizan la salida anterior.

upsample_kernel_sizes (`list[int]`, *opcional*) : Tamaño del kernel para cada bloque de reescalado. Se rellena automáticamente con `[4, ...]` cuando `upsample_out_channels` está definido pero este es `None`. Debe tener la misma longitud que `upsample_out_channels`.

upsample_kernel_size (`int`, valor predeterminado 4) : Tamaño de kernel predeterminado para los bloques de upsample cuando `upsample_kernel_sizes` no está establecido.

use_pixel_shuffle (`bool`, *opcional*) : Indica si la cabeza de interpolación utiliza interpolación mediante pixel-shuffle en lugar de convoluciones transpuestas. Cuando `None` (valor predeterminado), la cabeza utiliza convoluciones transpuestas.

conv_out_channels (`list[int]`, *opcional*) : Número de canales de salida para las capas de convolución de refinamiento que siguen a los bloques de interpolación ascendente.

conv_kernel_sizes (`list[int]`, *opcional*) : Tamaño del kernel para cada capa de convolución de refinamiento. Se rellena automáticamente con `[1, ...]` cuando `conv_out_channels` está definido pero este es `None`. Debe tener la misma longitud que `conv_out_channels`.

conv_kernel_size (`int`, valor predeterminado 1) : Tamaño de kernel predeterminado para las capas conv cuando `conv_kernel_sizes` no está establecido.

scale_conv_out_channels (`list[int]`, *opcional*) : Número de canales de salida para las capas convolucionales con stride 2 utilizadas para predecir la escala de la distancia focal. Cuando es `None` (valor predeterminado), no se construye la rama de escala.

scale_conv_kernel_sizes (`list[int]`, *opcional*) : Tamaño del kernel para cada capa de convolución de escala. Se rellena automáticamente con `[1, ...]` cuando `scale_conv_out_channels` está definido pero este es `None`. Debe tener la misma longitud que `scale_conv_out_channels`.

scale_conv_kernel_size (`int`, valor predeterminado 1) : Tamaño de kernel predeterminado para las capas conv de escala cuando `scale_conv_kernel_sizes` no está establecido.

scale_final_input_size (`int`, *opcional*) : Tamaño de la característica aplanada que se pasa al MLP de escala. Cuando es `None` (valor predeterminado), se infiere automáticamente a partir de `image_size` y `patch_size` en el [Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config) padre.

scale_final_hidden_sizes (`list[int]`, *opcional*) : Tamaños de las capas ocultas del MLP que mapea las características de escala aplanadas a la salida escalar de escala. Cuando `None` (predeterminado), no se construye la rama de escala.

Esta es la clase de configuración para almacenar la configuración de un Sapiens2Model. Se utiliza para instanciar un modelo Sapiens2 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sapiens2-seg-0.4b](https://huggingface.co/facebook/sapiens2-seg-0.4b)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Sapiens2ImageProcessor[[transformers.Sapiens2ImageProcessor]]

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

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

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

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 1024, 'width': 768}`): Describe las dimensiones máximas de entrada para el modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 224, 'width': 224}`): Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

do_reduce_labels (`bool`, *kwargs*, *opcional*, valor predeterminado `self.do_reduce_labels`) : Indica si se deben reducir en 1 todos los valores de etiqueta de los mapas de segmentación. Se utiliza habitualmente en conjuntos de datos donde 0 se emplea para el fondo y el propio fondo no se incluye en todas las clases del conjunto de datos (p. ej. ADE20k). La etiqueta de fondo se reemplazará por 255.

keypoint_heatmap_downscale_factor (`int`, *kwargs*, *opcional*, valor predeterminado 4) : Factor de reducción de la escala del tamaño del mapa de calor objetivo en relación con el tamaño de entrada del modelo.

keypoint_heatmap_sigma (`float`, *kwargs*, *opcional*, valor predeterminado 6.0) : La desviación estándar (sigma) de las distribuciones gaussianas 2D utilizadas para generar los mapas de calor.

Construye un procesador de imágenes Sapiens2ImageProcessor.

#### preprocess[[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'>)
```

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

**Parámetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

segmentation_maps (`ImageInput`, *opcional*) : Los mapas de segmentación que se van a preprocesar.

boxes (`list[list[list[float]]]` o `np.ndarray`, *opcional*) : Lista o matriz de cajas delimitadoras para cada imagen. Cada caja debe ser una lista de 4 flotantes que representen las coordenadas de la caja delimitadora en formato COCO (top_left_x, top_left_y, width, height). Cuando se proporciona, cada recorte de persona se transforma de forma afín al tamaño de entrada del modelo en lugar de redimensionar la imagen completa.

keypoints (`list[list[list[list[float]]]]`, *opcional*) : Lista de puntos clave para cada persona en cada imagen. El formato esperado es de estilo COCO `[x, y, visibility]`. Se espera que los valores de `x` y `y` sean coordenadas absolutas de píxeles de la imagen. El formato es `[images -> persons -> keypoints -> [x, y, visibility]]`. Se utiliza para generar mapas de calor de referencia y pesos de visibilidad para el ajuste fino de la estimación de pose.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

do_reduce_labels (`bool`, *kwargs*, *opcional*, valor predeterminado `self.do_reduce_labels`) : Indica si se deben reducir en 1 todos los valores de etiqueta de los mapas de segmentación. Se utiliza habitualmente en conjuntos de datos donde 0 se emplea para el fondo y el propio fondo no se incluye en todas las clases del conjunto de datos (p. ej. ADE20k). La etiqueta de fondo se reemplazará por 255.

keypoint_heatmap_downscale_factor (`int`, *kwargs*, *opcional*, valor predeterminado 4) : Factor de reducción de la escala del tamaño del mapa de calor objetivo en relación con el tamaño de entrada del modelo.

keypoint_heatmap_sigma (`float`, *kwargs*, *opcional*, valor predeterminado 6.0) : La desviación estándar (sigma) de las distribuciones gaussianas 2D utilizadas para generar los mapas de calor.

**Devuelve:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

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

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

**Parámetros:**

outputs (`Sapiens2ImageMattingOutput`) : Salidas crudas del modelo.

target_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : `(height, width)` final solicitado para cada predicción. Se redimensiona con interpolación bilineal. Si no se establece, las predicciones se devuelven a la resolución de salida del modelo.

backgrounds (`ImageInput`, *opcional*) : Imagen(es) de fondo sobre la que compilar. Puede ser una sola imagen (aplicada a cada elemento del lote) o una lista de imágenes, una por elemento del lote. Acepta imágenes PIL, matrices numpy o tensores torch de cualquier dtype; los tipos enteros (p. ej. uint8) se escalan automáticamente a `[0, 1]`. Cuando se proporciona, cada diccionario de resultado obtiene una clave `"composite"` con la imagen compuesta como un tensor uint8 en `[0, 255]`.

**Devuelve:** `list[dict]` de longitud `batch_size`. Cada dict tiene

- `"alpha"` (`torch.Tensor` de forma `(1, height, width)`): valores de alpha en `[0, 1]`.
- `"foreground"` (`torch.Tensor` de forma `(3, height, width)`): RGB premultiplicado en `[0, 1]`.
- `"composite"` (`torch.Tensor` de forma `(3, height, width)` o `None`): primer plano compuesto sobre `backgrounds` como tensor uint8 en `[0, 255]`; `None` cuando no se proporciona `backgrounds`.

Convierte la salida de [Sapiens2ForImageMatting](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForImageMatting) en máscaras alfa y mapas de primer plano.

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

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

**Parámetros:**

outputs (`Sapiens2NormalEstimatorOutput`) : Salidas crudas del modelo.

source_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : `(height, width)` original de cada imagen antes del preprocesamiento. Cuando se proporciona, el relleno añadido durante el preprocesamiento se elimina y las predicciones se redimensionan al tamaño original de la imagen (a menos que `target_sizes` anule el tamaño final).

target_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : `(height, width)` final solicitado para cada predicción. Cuando se proporciona, se utiliza como objetivo de redimensionado en lugar de `source_sizes`. Se redimensiona con interpolación bilineal después de la normalización L2.

do_remove_padding (`bool`, *opcional*) : Indica si se debe recortar el relleno de ceros añadido durante el preprocesamiento antes de redimensionar. El valor predeterminado es `True` cuando se proporciona `source_sizes`, y `False` en caso contrario.

**Devuelve:**

`list[dict[str, torch.Tensor]]` de longitud `batch_size`. Cada dict tiene una clave `"normals"` que mapea a un tensor de forma `(3, height, width)` con vectores unitarios normalizados en L2 en `[-1, 1]` por canal (normales de superficie XYZ).

Convierte la salida de [Sapiens2ForNormalEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForNormalEstimation) en mapas de normales de superficie normalizados 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)
```

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

**Parámetros:**

outputs (`Sapiens2PointmapEstimatorOutput`) : Salidas crudas del modelo.

source_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : `(height, width)` original de cada imagen antes del preprocesamiento. Cuando se proporciona, el relleno añadido durante el preprocesamiento se elimina y las predicciones se redimensionan al tamaño original de la imagen (a menos que `target_sizes` anule el tamaño final).

target_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : `(height, width)` final solicitado para cada predicción. Anula `source_sizes` como destino de redimensionado.

do_remove_padding (`bool`, *opcional*) : Indica si se debe recortar el relleno de ceros añadido durante el preprocesamiento antes de redimensionar. El valor predeterminado es `True` cuando se proporciona `source_sizes`, y `False` en caso contrario.

**Devuelve:**

`list[dict[str, torch.Tensor]]` de longitud `batch_size`. Cada dict tiene una clave `"pointmap"` que apunta a un tensor de forma `(3, height, width)` con coordenadas 3D XYZ por píxel en el espacio de cámara canónico, opcionalmente dividido por `outputs.scales` para convertirlo a coordenadas métricas.

Convierte la salida de [Sapiens2ForPointmapEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPointmapEstimation) en tensores de pointmap en el espacio de imagen.

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

```python
post_process_pose_estimation(outputs, boxes: list[list[list[float]]], 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)
```

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

**Parámetros:**

outputs (`Sapiens2PoseEstimatorOutput`) : Salidas crudas del modelo. `outputs.heatmaps` debe tener la forma `(N_total, num_keypoints, heatmap_height, heatmap_width)`, donde `N_total = sum(len(b) for b in boxes)`.

boxes (`list[list[list[float]]]` o `np.ndarray`) : Lista o matriz de cajas delimitadoras para cada imagen en coordenadas de píxeles absolutas. Cada caja debe ser una lista de 4 flotantes que representen las coordenadas de la caja delimitadora en formato COCO (top_left_x, top_left_y, width, height). Debe coincidir con el argumento `boxes` pasado a `preprocess`.

outputs_flipped (`Sapiens2PoseEstimatorOutput`, *opcional*) : Salidas obtenidas al ejecutar el modelo con entradas horizontalmente invertidas. Cuando se proporcionan, los mapas de calor se promedian con `outputs` antes de la extracción de puntos clave para mejorar la precisión: `avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2`.

kernel_size (`int`, *opcional*, valor predeterminado 11) : Tamaño del kernel para el desenfoque gaussiano utilizado en el refinamiento de UDP Dark Pose.

threshold (`float`, *opcional*) : Umbral de puntuación. Los puntos clave con puntuaciones iguales o inferiores a este valor se filtran de los diccionarios de resultado.

source_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : `(height, width)` original de cada imagen en píxeles. Es obligatorio cuando se proporciona `target_sizes`, ya que actúa como el espacio de coordenadas de origen para escalar los puntos clave y las cajas delimitadoras.

target_sizes (`torch.Tensor` o `list[tuple[int, int]]` de longitud `batch_size`, *opcional*) : Espacio de coordenadas de salida `(height, width)` deseado para cada imagen. Cuando se proporciona junto con `source_sizes`, las coordenadas de puntos clave y los recuadros delimitadores se escalan del espacio de origen al de destino.

**Devuelve:** `list[list[dict]]`

La lista externa recorre las imágenes y la lista interna recorre las personas. Cada diccionario contiene:
- `keypoints` (`torch.Tensor` de forma `(num_keypoints, 2)`): coordenadas x/y absolutas en el espacio de la imagen de origen, o en el espacio de destino si se proporciona `target_sizes`.
- `scores` (`torch.Tensor` de forma `(num_keypoints,)`): confianza por punto clave.
- `labels` (`torch.LongTensor` de forma `(num_keypoints,)`): índices de puntos clave.
- `bbox` (`torch.Tensor` de forma `(4,)`): caja delimitadora en formato absoluto (x_min, y_min, x_max, y_max), en el mismo espacio de coordenadas que `keypoints`.

Convierte la salida de [Sapiens2ForPoseEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation) en predicciones de puntos clave en el espacio de la imagen.

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

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

**Parámetros:**

outputs ([Sapiens2ForSemanticSegmentation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForSemanticSegmentation)) : Salidas sin procesar del modelo.

target_sizes (`list[Tuple]` de longitud `batch_size`, *opcional*) : Lista de tuplas que corresponden al tamaño final solicitado (altura, ancho) de cada predicción. Si no se establece, las predicciones no se redimensionarán.

return_segmentation_scores (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las puntuaciones de segmentación junto con el mapa de segmentación. Cuando `True`, cada elemento de la lista devuelta es un `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`).

**Devuelve:** `list[torch.Tensor]` o `list[SemanticSegmentationPostProcessorOutput]`

Cuando `return_segmentation_scores=False` (valor predeterminado), se devuelve una lista de longitud `batch_size` en la que cada elemento es un mapa de segmentación de forma `(height, width)` con IDs de clase. Cuando `return_segmentation_scores=True`, se devuelve una lista de `SemanticSegmentationPostProcessorOutput` con los campos `segmentation` (IDs de clase, forma `(height, width)`) y `segmentation_scores` (forma `(num_classes, height, width)`). En ambos casos, `(height, width)` corresponde al tamaño objetivo (si se especifica `target_sizes`).

Convierte la salida de [Sapiens2ForSemanticSegmentation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForSemanticSegmentation) en mapas de segmentación semántica.

## Sapiens2Model[[transformers.Sapiens2Model]]

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

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sapiens2 sin procesar, que genera estados ocultos crudos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Posiciones enmascaradas booleanas. Indica qué parches están enmascarados (1) y cuáles no (0). Solo es relevante para el preentrenamiento.

**Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2Model](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Model) sobrescribe el método especial `__call__`.

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

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Ejemplo:

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El backbone Sapiens2.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

**Devuelve:** `Sapiens2BackboneOutput` o `tuple(torch.Tensor)`

Un `Sapiens2BackboneOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2Backbone](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Backbone) sobrescribe el método especial `__call__`.

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

- **feature_maps** (`tuple(torch.Tensor)` de forma `(batch_size, num_channels, height, width)`) -- Mapas de características de las etapas.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)` o `(batch_size, num_channels, height, width)`, dependiendo del backbone.

  Estados ocultos del modelo en la salida de cada etapa más las salidas de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Solo aplicable si el backbone utiliza atención.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cls_tokens** (`tuple(torch.Tensor)`, *opcional*) -- Token CLS de cada etapa de características seleccionada, cada uno con forma `(batch_size, hidden_size)`. Solo está presente cuando `config.return_class_token=True`.

Ejemplo:

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sapiens2 con una cabeza de matting en la parte superior (un decodificador basado en PixelShuffle que predice un primer plano RGB premultiplicado y una máscara alfa).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

labels (`torch.Tensor` de forma `(batch_size, 4, height, width)`, *opcional*) : Objetivos de matting de referencia para calcular la pérdida.

**Devuelve:** `Sapiens2ImageMattingOutput` o `tuple(torch.Tensor)`

Un `Sapiens2ImageMattingOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2ForImageMatting](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForImageMatting) reemplaza el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida.
- **alphas** (`torch.Tensor` de forma `(batch_size, 1, height, width)`) -- Valores de alfa estimados.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (también llamados feature maps) del modelo en la salida de cada etapa.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **primeros planos** (`torch.Tensor` de forma `(batch_size, 3, height, width)`) -- Predicciones de primer plano RGB premultiplicadas en `[0, 1]` (activadas con sigmoid).

Ejemplo:

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sapiens2 con una cabeza de estimación de normales en la parte superior (un decodificador basado en PixelShuffle que predice mapas de normales de superficie).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

labels (`torch.Tensor` de forma `(batch_size, num_labels, height, width)`, *opcional*) : Mapas de normales de superficie de referencia para calcular la pérdida.

**Devuelve:** `Sapiens2NormalEstimatorOutput` o `tuple(torch.Tensor)`

Un `Sapiens2NormalEstimatorOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2ForNormalEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForNormalEstimation) reemplaza el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, devuelta cuando se proporciona `labels`) -- Pérdida de estimación normal.
- **normals** (`torch.Tensor` de forma `(batch_size, num_labels, height, width)`) -- Predicciones de mapas normales sin procesar como salida del modelo (sin normalizar).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de los embeddings iniciales.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención.

Ejemplo:

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sapiens2 con una cabeza pointmap en la parte superior (un decodificador basado en PixelShuffle que predice coordenadas 3D XYZ por píxel, más una rama de escala opcional para la normalización de la longitud focal).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

labels (`torch.Tensor` de forma `(batch_size, 3, height, width)`, *opcional*) : Pointmap de referencia para calcular la pérdida.

**Devuelve:** `Sapiens2PointmapEstimatorOutput` o `tuple(torch.Tensor)`

Un `Sapiens2PointmapEstimatorOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2ForPointmapEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPointmapEstimation) reemplaza el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) -- Pérdida de estimación de Pointmap.
- **pointmaps** (`torch.Tensor` de forma `(batch_size, 3, height, width)`) -- Predicciones de coordenadas 3D XYZ por píxel en el espacio de cámara canónico.
- **scales** (`torch.Tensor` de forma `(batch_size, 1)`, *opcional*) -- Relación entre la distancia focal canónica y la distancia focal real. `None` cuando no se ha configurado una rama de escala.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de los embeddings iniciales.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención.

Ejemplo:

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sapiens2 con una cabeza de estimación de pose en la parte superior (un conjunto de predictores de mapas de calor sobre la salida de los estados ocultos).

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[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'>)
```

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

flip_pairs (`torch.Tensor` de forma `(num_pairs, 2)`, *opcional*) : Pares de puntos clave que son simétricos (por ejemplo, oreja izquierda -- oreja derecha), utilizados para la aumentación por volteo en el momento de la prueba. Cuando se proporciona, el modelo asume que `pixel_values` contiene imágenes volteadas horizontalmente y llama a `flip_back` en los mapas de calor de salida para restaurar la orientación original.

labels (`torch.Tensor` de forma `(batch_size, num_keypoints, height, width)`, *opcional*) : Ground truth del heatmap para calcular la pérdida.

label_weights (`torch.Tensor` de forma `(batch_size, num_labels, 1, 1)` o `(batch_size, num_labels, height, width)`, *opcional*) : Pesos de visibilidad para cada punto clave. Debe ser difusible a la forma de `labels`.

**Devuelve:** `Sapiens2PoseEstimatorOutput` o `tuple(torch.Tensor)`

Un `Sapiens2PoseEstimatorOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2ForPoseEstimation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForPoseEstimation) reemplaza el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, devuelta cuando se proporciona `labels`) -- Pérdida de estimación de pose.
- **mapas de calor** (`torch.Tensor` de forma `(batch_size, num_keypoints, height, width)`) -- Mapas de calor tal como los predice el modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (también llamados feature maps) del modelo en la salida de cada etapa.
- **attentions** (`tuple[torch.Tensor, ...]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Ejemplo:

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

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

**Parámetros:**

config ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sapiens2 con una cabeza de segmentación semántica en la parte superior, por ejemplo, para ADE20K, CityScapes.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor). Consulte [Sapiens2ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [Sapiens2ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ImageProcessor) para procesar las imágenes).

labels (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Mapas de segmentación semántica de referencia para calcular la pérdida. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels > 1`, se calcula una pérdida de clasificación (Cross-Entropy).

**Devuelve:** [SemanticSegmenterOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) o `tuple(torch.Tensor)`

Un [SemanticSegmenterOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sapiens2Config](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2Config)) y las entradas.

El método forward de [Sapiens2ForSemanticSegmentation](/docs/transformers/v5.23.0/es/model_doc/sapiens2#transformers.Sapiens2ForSemanticSegmentation) reemplaza el método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de clasificación (o de regresión si config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels, logits_height, logits_width)`) -- Puntuaciones de clasificación para cada píxel.

  

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

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

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, patch_size, sequence_length)`.

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

Ejemplo:

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

