Hugging Face's logo

Transformers documentation

Sapiens2

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 23 de abril de 2026 y se contribuyó a Hugging Face Transformers el 3 de junio de 2026.

Sapiens2

SDPA FlashAttention

Resumen

El modelo Sapiens2 fue propuesto en Sapiens2 por Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su, Shunsuke Saito. Sapiens2 es una familia de vision transformers de alta resolución preentrenados en ~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.

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. El código original se puede encontrar aquí.

Ejemplos de uso

AutoModel
AutoBackbone
Estimación normal
Estimación de Pointmap
Estimación de la pose
Estimación de pose con aumento de datos por volteo
Entrenamiento de estimación de pose
Segmentación semántica
Matting

El siguiente ejemplo muestra cómo obtener el token CLS (incrustación de la imagen completa) con Sapiens2Model.

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

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

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

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

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

Sapiens2Config

clase transformers.Sapiens2Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonepatch_size: int | list[int] | tuple[int, int] = 16hidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16hidden_act: str = 'silu'attention_dropout: float | int = 0.0initializer_range: float = 0.02rope_theta: float = 100.0image_size: int | list[int] | tuple[int, int] = 224num_channels: int = 3query_bias: bool = Truekey_bias: bool = Truevalue_bias: bool = Trueproj_bias: bool = Truemlp_bias: bool = Truelayerscale_value: float = 1.0drop_path_rate: float | int = 0.0use_gated_mlp: bool = Truenum_register_tokens: int = 8pos_embed_shift: float | None = Nonepos_embed_jitter: float | None = Nonepos_embed_rescale: float | None = 2.0_out_features: list[str] | None = None_out_indices: list[int] | None = Nonereshape_hidden_states: bool = Trueuse_mask_token: bool = Falserms_norm_eps: float = 1e-06normalize_backbone_outputs: bool = Trueuse_qk_norm: bool = Truenum_key_value_heads_per_layer: list[int] | None = Nonenum_key_value_attention_heads: int = 8num_first_full_attention_layers: int = 8num_last_full_attention_layers: int = 8semantic_loss_ignore_index: int = 255flip_pairs: list[list[int]] | None = Nonehead_config: transformers.models.sapiens2.configuration_sapiens2.Sapiens2HeadConfig | dict | None = None )

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 del 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 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 del 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) — Si se debe añadir un sesgo a la proyección de salida.
  • mlp_bias (bool, opcional, valor predeterminado True) — 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 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, valor predeterminado False) — Si se debe utilizar la red neuronal feedforward 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) — Si se deben redimensionar los estados ocultos a dimensiones espaciales cuando se usa 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) — Si se aplica 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 de transformer. 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 de transformer iniciales 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 ignorado 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 el momento de la 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 para 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

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

Sapiens2HeadConfig

clase transformers.Sapiens2HeadConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneupsample_out_channels: list[int] | None = Noneupsample_kernel_sizes: list[int] | None = Noneupsample_kernel_size: int = 4use_pixel_shuffle: bool | None = Noneconv_out_channels: list[int] | None = Noneconv_kernel_sizes: list[int] | None = Noneconv_kernel_size: int = 1scale_conv_out_channels: list[int] | None = Nonescale_conv_kernel_sizes: list[int] | None = Nonescale_conv_kernel_size: int = 1scale_final_input_size: int | None = Nonescale_final_hidden_sizes: list[int] | None = None )

Parámetros

  • upsample_out_channels (list[int], opcional) — Número de canales de salida para cada bloque de upsample. 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 upsample. 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, por defecto 4) — Tamaño de kernel predeterminado para los bloques de upsample cuando upsample_kernel_sizes no está establecido.
  • use_pixel_shuffle (bool, opcional) — Si la cabeza de remuestreo utiliza el remuestreo por pixel-shuffle en lugar de convoluciones transpuestas. Cuando None (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, por defecto 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 de convolución de escala cuando scale_conv_kernel_sizes no está establecido.
  • scale_final_input_size (int, opcional) — Tamaño de las características aplanadas 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 la configuración principal Sapiens2Config.
  • 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 es None (predeterminado), no se construye ninguna 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

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

Sapiens2ImageProcessor

clase transformers.Sapiens2ImageProcessor

< >

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

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 de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado True) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • 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 a 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) — 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 a 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 cualquier tamaño de imagen proporcionado 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) — 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse 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 está incluido 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 escala para el 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.

preprocesar

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneboxes: list[list[list[float]]] | None = Nonekeypoints: list[list[list[list[float]]]] | None = None**kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

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 representan 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 deforma 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 de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • 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 a utilizar si se redimensiona la imagen. Puede ser uno de los enum 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 cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse 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 está incluido 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 escala para el 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

< >

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

Parámetros

  • outputs (Sapiens2ImageMattingOutput) — Salidas sin procesar 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, arrays de numpy o tensores de 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 en máscaras alfa y mapas de primer plano.

post_process_normal_estimation

< >

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

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) — Si se debe recortar el relleno de ceros añadido durante la preprocesamiento antes de redimensionar. Por defecto es True cuando se proporciona source_sizes, False en caso contrario.

Convierte la salida de Sapiens2ForNormalEstimation en mapas de normales de superficie normalizados en L2.

post_process_pointmap_estimation

< >

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

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 a source_sizes como destino de redimensionado.
  • do_remove_padding (bool, opcional) — Si se debe recortar el relleno de ceros añadido durante la preprocesamiento antes de redimensionar. Por defecto es True cuando se proporciona source_sizes, False en caso contrario.

Convierte la salida de Sapiens2ForPointmapEstimation en tensores de pointmap en el espacio de imagen.

post_process_pose_estimation

< >

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

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. Si se proporciona, 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. 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 deseado (height, width) 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, 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 en predicciones de puntos clave en el espacio de la imagen.

post_process_semantic_segmentation

< >

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

Parámetros

  • outputs (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 (por defecto), se devuelve una lista de longitud batch_size donde 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 en mapas de segmentación semántica.

Sapiens2Model

clase transformers.Sapiens2Model

< >

( config: Sapiens2Config )

Parámetros

  • config (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() 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

( pixel_values: Tensorbool_masked_pos: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

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 utilizando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para más detalles (processor_class utiliza 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 o tuple(torch.Tensor)

Un 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, 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:

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

clase transformers.Sapiens2Backbone

< >

( config: Sapiens2Config )

Parámetros

  • config (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() para cargar los pesos del modelo.

El backbone Sapiens2.

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

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

forward

< >

( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2BackboneOutput or tuple(torch.Tensor)

Parámetros

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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, 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 capa) de forma (batch_size, sequence_length, hidden_size) o (batch_size, num_channels, height, width), según el 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 usa 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:

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

clase transformers.Sapiens2ForImageMatting

< >

( config: Sapiens2Config )

Parámetros

  • config (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() 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2ImageMattingOutput or tuple(torch.Tensor)

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 utilizando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para más detalles (processor_class utiliza Sapiens2ImageProcessor para procesar las imágenes).
  • labels (torch.Tensor de forma (batch_size, 4, height, width), opcional) — Objetivos de matting correctos 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) y las entradas.

El método forward de 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida.

  • 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 las incrustaciones, si el modelo tiene una capa de incrustación, + una para la salida de cada etapa) de forma (batch_size, sequence_length, hidden_size). Estados ocultos (también llamados mapas de características) 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:

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

clase transformers.Sapiens2ForNormalEstimation

< >

( config: Sapiens2Config )

Parámetros

  • config (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() 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2NormalEstimatorOutput or tuple(torch.Tensor)

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 utilizando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para más detalles (processor_class utiliza 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, tal como las genera el 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 (uno por capa) de forma (batch_size, num_heads, sequence_length, sequence_length). Pesos de atención después del softmax de atención.

Ejemplo:

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

clase transformers.Sapiens2ForPointmapEstimation

< >

( config: Sapiens2Config )

Parámetros

  • config (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() 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PointmapEstimatorOutput or tuple(torch.Tensor)

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 utilizando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para más detalles (processor_class utiliza 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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 (uno por capa) de forma (batch_size, num_heads, sequence_length, sequence_length). Pesos de atención después del softmax de atención.

Ejemplo:

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

clase transformers.Sapiens2ForPoseEstimation

< >

( config: Sapiens2Config )

Parámetros

  • config (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() 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

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

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 utilizando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para más detalles (processor_class utiliza 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 tiempo de 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) — Verdadero de la etiqueta del mapa de calor 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) y las entradas.

El método forward de 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de estimación de pose.

  • mapas de calor (torch.Tensor de forma (batch_size, num_keypoints, height, width)) — Mapas de calor predichos por 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 las incrustaciones, si el modelo tiene una capa de incrustación, + una para la salida de cada etapa) de forma (batch_size, sequence_length, hidden_size). Estados ocultos (también llamados mapas de características) 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:

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

clase transformers.Sapiens2ForSemanticSegmentation

< >

( config: Sapiens2Config )

Parámetros

  • config (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() 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. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

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

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SemanticSegmenterOutput or tuple(torch.Tensor)

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 utilizando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para más detalles (processor_class utiliza 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 o tuple(torch.Tensor)

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

El método forward de 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

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

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

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

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

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

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

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

Ejemplo:

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

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

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

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

←Sam3Tracker SegFormer→