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 foi publicado em HF papers em 2026-04-23 e contribuído para Hugging Face Transformers em 2026-06-03.

Sapiens2

SDPA FlashAttention

Visão geral

O modelo Sapiens2 foi proposto em Sapiens2 por Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su, Shunsuke Saito. O Sapiens2 é uma família de vision transformers de alta resolução pré-treinados em cerca de 1 bilhão de imagens humanas curadas, projetado para tarefas de visão computacional centradas em humanos, incluindo estimativa de pose, segmentação de partes do corpo, estimativa de normais de superfície e estimativa de pointmap.

Você pode encontrar todos os checkpoints originais do Sapiens2 na coleção Sapiens2.

O resumo do artigo é o seguinte:

Apresentamos o Sapiens2, uma família de transformers de alta resolução para visão centrada em humanos, com foco em generalização, versatilidade e saídas de alta fidelidade. Fazemos o pré-treinamento em cerca de 1 bilhão de imagens humanas de alta qualidade e curadas, com anotações de tarefas aprimoradas, e combinamos a reconstrução de imagens mascaradas com objetivos contrastivos autodestilados para aprender tanto recursos de baixo nível quanto recursos semânticos. Nossos modelos variam de 0,4B a 5B parâmetros e são treinados na resolução nativa de 1K, com variantes hierárquicas de 4K para raciocínio espacial estendido. O Sapiens2 alcança melhorias substanciais em relação ao seu antecessor: +4 mAP na estimativa de pose, +24,3 mIoU na segmentação de partes do corpo e redução de 45,6% no erro na estimativa de normais, além de se estender a novas tarefas, como a estimativa de pointmap e albedo. O código está publicamente disponível.

Dicas:

  • Sapiens2 usa Rotary Position Embeddings (RoPE) e suporta resoluções de entrada arbitrárias. O processador de imagem padrão redimensiona as imagens para 1024×768 (altura×largura).
  • O modelo usa Grouped Query Attention (GQA) para as camadas intermediárias e atenção multi-head completa para as primeiras e últimas 8 camadas.
  • Os tokens de registro (8 por padrão) reduzem artefatos de norma elevada nos tokens de patch, resultando em mapas de atenção mais limpos e melhor desempenho em tarefas de predição densa.

Este modelo foi contribuído por guarin. O código original pode ser encontrado aqui.

Exemplos de uso

AutoModel
AutoBackbone
Estimação normal
Estimação de pointmap
Estimação de pose
Estimação de pose com aumento de dados por espelhamento
Treinamento de estimativa de pose
Segmentação semântica
Matting

O exemplo abaixo mostra como obter o token CLS (embedding da imagem inteira) com Sapiens2Model.

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

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

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

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

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

Sapiens2Config

classe transformers.Sapiens2Config

< >

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

Parâmetros

  • patch_size (Union[int, list[int], tuple[int, int]], opcional, padrão 16) — O tamanho (resolução) de cada patch.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • rope_theta (float, opcional, padrão 100.0) — O período base dos embeddings RoPE.
  • image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 224) — O tamanho (resolução) de cada imagem.
  • num_channels (int, opcional, padrão 3) — O número de canais de entrada.
  • query_bias (bool, opcional, padrão True) — Indica se deve ser adicionado um viés à projeção da query.
  • key_bias (bool, opcional, padrão False) — Indica se deve ser adicionado um viés à projeção da chave.
  • value_bias (bool, opcional, padrão True) — Indica se deve ser adicionado um viés à projeção de valor.
  • proj_bias (bool, opcional, padrão True) — Indica se deve ser adicionado um viés à projeção de saída.
  • mlp_bias (bool, opcional, padrão True) — Se deve usar um viés nas camadas up_proj, down_proj e gate_proj das camadas MLP.
  • layerscale_value (float, opcional, padrão 1.0) — Valor inicial a ser usado para a escala da camada.
  • drop_path_rate (Union[float, int], opcional, padrão 0.0) — Taxa de drop path para a fusão de patches.
  • use_gated_mlp (bool, opcional, padrão False) — Se deve usar a rede neural feedforward SwiGLU.
  • num_register_tokens (int, opcional, padrão 0) — O número de tokens de registro.
  • pos_embed_shift (float, opcional) — Quantidade para deslocar aleatoriamente as coordenadas do embedding de posição em [-shift, shift], aplicada apenas no modo de treinamento, se não for None.
  • pos_embed_jitter (float, opcional) — Quantidade para jitter aleatório das coordenadas do embedding de posição em valor log-uniforme em [1/jitter, jitter], aplicado apenas no modo de treinamento se não for None.
  • pos_embed_rescale (float, opcional, padrão 2.0) — Quantidade para reescalar aleatoriamente as coordenadas do embedding de posição em um valor log-uniforme em [1/rescale, rescale], aplicado apenas no modo de treinamento, se não for None.
  • reshape_hidden_states (bool, opcional, padrão True) — Se deve redimensionar os estados ocultos para dimensões espaciais quando usado como backbone.
  • use_mask_token (bool, opcional, padrão False) — Se deve usar um token de máscara nos embeddings (necessário para o pré-treinamento de modelagem de imagem mascarada).
  • rms_norm_eps (float, opcional, padrão 1e-6) — Epsilon para as camadas de normalização RMS.
  • normalize_backbone_outputs (bool, opcional, padrão True) — Indica se deve ser aplicado RMSNorm às saídas feature_maps e cls_tokens do backbone antes de retorná-las da passagem de forward. Aplica-se apenas quando o modelo é usado como backbone.
  • use_qk_norm (bool, opcional, padrão True) — Se deve aplicar RMSNorm às queries e chaves antes do RoPE nas camadas de atenção.
  • num_key_value_heads_per_layer (list[int], opcional) — Número de cabeças de chave/valor para cada camada do transformer. Definir o valor de uma camada igual a num_attention_heads resulta em atenção multi-cabeça completa; um valor menor resulta em atenção grouped-query. O padrão é num_attention_heads para as primeiras num_first_full_attention_layers e as últimas num_last_full_attention_layers camadas e num_key_value_attention_heads para todas as demais camadas.
  • num_key_value_attention_heads (int, opcional, padrão 8) — Número de cabeças de chave/valor para camadas que usam grouped-query attention quando num_key_value_heads_per_layer não está definido. Ignorado quando num_key_value_heads_per_layer está definido.
  • num_first_full_attention_layers (int, opcional, padrão 8) — Número de camadas iniciais do transformer que usam atenção multi-cabeça completa. Usado apenas quando num_key_value_heads_per_layer é None.
  • num_last_full_attention_layers (int, opcional, padrão 8) — Número de camadas finais do transformer que usam atenção multi-cabeça completa. Usado apenas quando num_key_value_heads_per_layer é None.
  • semantic_loss_ignore_index (int, opcional, padrão 255) — Índice de rótulo ignorado ao calcular a perda de segmentação.
  • flip_pairs (list[list[int]], opcional) — Pares de índices de pontos-chave que são espelhados horizontalmente (por exemplo, orelha esquerda ↔ orelha direita). Cada par é uma lista de dois elementos [left_index, right_index]. Usado para aumento de dados por espelhamento horizontal no momento do teste em estimativa de pose: passe esses pares para a segunda chamada de forward para que o modelo reverta os heatmaps antes de retorná-los.
  • head_config (Sapiens2HeadConfig, opcional) — Configuração para o cabeçalho de decodificação. Consulte Sapiens2HeadConfig para as opções disponíveis.

Esta é a classe de configuração para armazenar a configuração de um Sapiens2Model. Ela é usada para instanciar um modelo Sapiens2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do facebook/sapiens2-pretrain-0.4b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Sapiens2HeadConfig

classe transformers.Sapiens2HeadConfig

< >

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

Parâmetros

  • upsample_out_channels (list[int], opcional) — Quantidade de canais de saída para cada bloco de upsample. O primeiro bloco recebe hidden_size canais como entrada; os blocos subsequentes utilizam a saída anterior.
  • upsample_kernel_sizes (list[int], opcional) — Tamanho do kernel para cada bloco de upsample. Preenchido automaticamente com [4, ...] quando upsample_out_channels está definido, mas este é None. Deve ter o mesmo comprimento que upsample_out_channels.
  • upsample_kernel_size (int, padrão 4) — Tamanho padrão do kernel para blocos de upsample quando upsample_kernel_sizes não está definido.
  • use_pixel_shuffle (bool, opcional) — Se a cabeça de upsample usa upsample por pixel-shuffle em vez de convoluções transpostas. Quando None (padrão), a cabeça usa convoluções transpostas.
  • conv_out_channels (list[int], opcional) — Quantidades de canais de saída para as camadas de convolução de refinamento que seguem os blocos de upsample.
  • conv_kernel_sizes (list[int], opcional) — Tamanho do kernel para cada camada de convolução de refinamento. Preenchido automaticamente com [1, ...] quando conv_out_channels está definido, mas este é None. Deve ter o mesmo comprimento que conv_out_channels.
  • conv_kernel_size (int, padrão 1) — Tamanho padrão do kernel para camadas conv quando conv_kernel_sizes não está definido.
  • scale_conv_out_channels (list[int], opcional) — Quantidade de canais de saída para as camadas conv com stride 2 usadas para prever a escala de distância focal. Quando None (padrão), nenhum ramo de escala é construído.
  • scale_conv_kernel_sizes (list[int], opcional) — Tamanho do kernel para cada camada de convolução de escala. Preenchido automaticamente com [1, ...] quando scale_conv_out_channels está definido, mas este é None. Deve ter o mesmo comprimento que scale_conv_out_channels.
  • scale_conv_kernel_size (int, padrão 1) — Tamanho de kernel padrão para as camadas de convolução de escala quando scale_conv_kernel_sizes não está definido.
  • scale_final_input_size (int, opcional) — Tamanho aplanado dos recursos passado para o MLP de escala. Quando None (padrão), é inferido automaticamente a partir de image_size e patch_size no Sapiens2Config pai.
  • scale_final_hidden_sizes (list[int], opcional) — Tamanhos das camadas ocultas do MLP que mapeia os recursos de escala achatados para a saída escalar de escala. Quando None (padrão), nenhum ramo de escala é construído.

Esta é a classe de configuração para armazenar a configuração de um Sapiens2Model. Ela é usada para instanciar um modelo Sapiens2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do facebook/sapiens2-seg-0.4b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Sapiens2ImageProcessor

classe transformers.Sapiens2ImageProcessor

< >

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

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 1024, 'width': 768}): Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional, padrão True) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 224, 'width': 224}): Tamanho da imagem de saída após aplicar center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 2) — Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.485, 0.456, 0.406]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.229, 0.224, 0.225]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional, padrão False) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional, padrão False) — Se deve recortar a imagem pelo centro.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • do_reduce_labels (bool, kwargs, opcional, padrão self.do_reduce_labels) — Indica se todos os valores de rótulo dos mapas de segmentação devem ser reduzidos em 1. Geralmente usado em conjuntos de dados em que 0 é usado para o plano de fundo e o próprio plano de fundo não está incluído em todas as classes do conjunto de dados (por exemplo, ADE20k). O rótulo do plano de fundo será substituído por 255.
  • keypoint_heatmap_downscale_factor (int, kwargs, opcional, padrão 4) — Fator de redução da escala do tamanho do mapa de calor em relação ao tamanho de entrada do modelo.
  • keypoint_heatmap_sigma (float, kwargs, opcional, padrão 6.0) — O desvio padrão (sigma) das distribuições gaussianas 2D usadas para gerar os heatmaps.

Constrói um processador de imagem Sapiens2ImageProcessor.

pré-processamento

< >

( 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]]) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • segmentation_maps (ImageInput, opcional) — Os mapas de segmentação a serem pré-processados.
  • boxes (list[list[list[float]]] ou np.ndarray, opcional) — Lista ou matriz de caixas delimitadoras para cada imagem. Cada caixa deve ser uma lista de 4 floats representando as coordenadas da caixa delimitadora no formato COCO (top_left_x, top_left_y, width, height). Quando fornecida, cada recorte de pessoa é deformado afimetricamente para o tamanho de entrada do modelo, em vez de redimensionar a imagem completa.
  • keypoints (list[list[list[list[float]]]], opcional) — Lista de pontos-chave para cada pessoa em cada imagem. O formato esperado é no estilo COCO [x, y, visibility]. Os valores de x e y devem ser coordenadas absolutas de pixels da imagem. O formato é [images -> persons -> keypoints -> [x, y, visibility]]. Usado para gerar mapas de calor de referência e pesos de visibilidade para o ajuste fino de estimativa de pose.
  • do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • do_reduce_labels (bool, kwargs, opcional, padrão self.do_reduce_labels) — Indica se todos os valores de rótulo dos mapas de segmentação devem ser reduzidos em 1. Geralmente usado em conjuntos de dados em que 0 é usado para o plano de fundo e o próprio plano de fundo não está incluído em todas as classes do conjunto de dados (por exemplo, ADE20k). O rótulo do plano de fundo será substituído por 255.
  • keypoint_heatmap_downscale_factor (int, kwargs, opcional, padrão 4) — Fator de redução da escala do tamanho do mapa de calor em relação ao tamanho de entrada do modelo.
  • keypoint_heatmap_sigma (float, kwargs, opcional, padrão 6.0) — O desvio padrão (sigma) das distribuições gaussianas 2D usadas para gerar os heatmaps.

Retorna

~image_processing_base.BatchFeature

  • data (dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

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) — Saídas brutas do modelo.
  • target_sizes (torch.Tensor ou list[tuple[int, int]] de comprimento batch_size, opcional) — Resolução final (height, width) solicitada para cada previsão. Redimensionada com interpolação bilinear. Se não definido, as previsões são retornadas na resolução de saída do modelo.
  • backgrounds (ImageInput, opcional) — Imagem(ns) de fundo para compor por cima. Pode ser uma única imagem (aplicada a cada item do lote) ou uma lista de imagens, uma para cada item do lote. Aceita imagens PIL, arrays numpy ou tensores torch de qualquer dtype; tipos inteiros (por exemplo, uint8) são escalados automaticamente para [0, 1]. Quando fornecido, cada dicionário de resultado ganha uma chave "composite" com a imagem composta como um tensor uint8 em [0, 255].

Retorna

list[dict] de comprimento batch_size. Cada dict tem

  • "alpha" (torch.Tensor de forma (1, height, width)): valores de alpha em [0, 1].
  • "foreground" (torch.Tensor de forma (3, height, width)): RGB pré-multiplicado em [0, 1].
  • "composite" (torch.Tensor de forma (3, height, width) ou None): primeiro plano composto sobre backgrounds como um tensor uint8 em [0, 255]; None quando backgrounds não é fornecido.

Converte a saída de Sapiens2ForImageMatting em máscaras alfa e mapas de primeiro 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) — Saídas brutas do modelo.
  • source_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Original (height, width) of each image before preprocessing. When provided, the padding added during preprocessing is removed and predictions are resized back to the original image size (unless target_sizes overrides the final size).
  • target_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Requested final (height, width) for each prediction. When provided, used as the resize target instead of source_sizes. Resized with bilinear interpolation after L2 normalization.
  • do_remove_padding (bool, opcional) — Indica se o preenchimento com zeros adicionado durante o pré-processamento deve ser removido antes do redimensionamento. O valor padrão é True quando source_sizes é fornecido, e False caso contrário.

Converte a saída de Sapiens2ForNormalEstimation em mapas de normais de superfície normalizados em 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) — Saídas brutas do modelo.
  • source_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Original (height, width) of each image before preprocessing. When provided, the padding added during preprocessing is removed and predictions are resized back to the original image size (unless target_sizes overrides the final size).
  • target_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Requested final (height, width) for each prediction. Overrides source_sizes as the resize target.
  • do_remove_padding (bool, opcional) — Indica se o preenchimento com zeros adicionado durante o pré-processamento deve ser removido antes do redimensionamento. O valor padrão é True quando source_sizes é fornecido, e False caso contrário.

Converte a saída de Sapiens2ForPointmapEstimation em tensores de pointmap no espaço da imagem.

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) — Saídas brutas do modelo. outputs.heatmaps deve ter a forma (N_total, num_keypoints, heatmap_height, heatmap_width), onde N_total = sum(len(b) for b in boxes).
  • boxes (list[list[list[float]]] ou np.ndarray) — Lista ou matriz de caixas delimitadoras para cada imagem em coordenadas de pixels absolutas. Cada caixa deve ser uma lista de 4 floats representando as coordenadas da caixa delimitadora no formato COCO (top_left_x, top_left_y, width, height). Deve corresponder ao argumento boxes passado para preprocess.
  • outputs_flipped (Sapiens2PoseEstimatorOutput, opcional) — Saídas obtidas ao executar o modelo em entradas horizontalmente invertidas. Quando fornecidas, os heatmaps são média com outputs antes da extração dos keypoints para melhorar a precisão: avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2.
  • kernel_size (int, opcional, padrão 11) — Tamanho do kernel para o desfoque gaussiano usado no refinamento UDP Dark Pose.
  • threshold (float, opcional) — Limiar de pontuação. Pontos-chave com pontuações iguais ou inferiores a esse valor são filtrados dos dicionários de resultado.
  • source_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Original (height, width) of each image in pixels. Required when target_sizes is provided, as the source coordinate space for scaling keypoints and bounding boxes.
  • target_sizes (torch.Tensor or list[tuple[int, int]] of length batch_size, optional) — Desired output (height, width) coordinate space for each image. When provided alongside source_sizes, keypoint coordinates and bounding boxes are scaled from source to target space.

Retorna

list[list[dict]]

A lista externa percorre as imagens e a lista interna percorre as pessoas. Cada dicionário contém:

  • keypoints (torch.FloatTensor de forma (num_keypoints, 2)): coordenadas x/y absolutas no espaço da imagem de origem, ou no espaço de destino se target_sizes for fornecida.
  • scores (torch.FloatTensor de forma (num_keypoints,)): confiança por ponto-chave.
  • labels (torch.LongTensor de forma (num_keypoints,)): índices dos pontos-chave.
  • bbox (torch.FloatTensor de forma (4,)): caixa delimitadora em formato absoluto (x_min, y_min, x_max, y_max), no mesmo espaço de coordenadas de keypoints.

Converte a saída de Sapiens2ForPoseEstimation em previsões de pontos-chave no espaço da imagem.

post_process_semantic_segmentation

< >

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

Parâmetros

  • outputs (Sapiens2ForSemanticSegmentation) — Saídas brutas do modelo.
  • target_sizes (list[Tuple] de comprimento batch_size, opcional) — Lista de tuplas correspondentes ao tamanho final solicitado (altura, largura) de cada previsão. Se não definido, as previsões não serão redimensionadas.
  • return_segmentation_scores (bool, opcional, padrão False) — Indica se as pontuações de segmentação devem ser retornadas junto com o mapa de segmentação. Quando True, cada elemento da lista retornada é um SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma (height, width)) e segmentation_scores (forma (num_classes, height, width)).

Retorna

list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]

Quando return_segmentation_scores=False (padrão), uma lista de comprimento batch_size em que cada item é um mapa de segmentação de forma (height, width) com IDs de classe. Quando return_segmentation_scores=True, uma lista de SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma (height, width)) e segmentation_scores (forma (num_classes, height, width)). Em ambos os casos, (height, width) corresponde ao tamanho alvo (se target_sizes for especificado).

Converte a saída de Sapiens2ForSemanticSegmentation em mapas de segmentação semântica.

Sapiens2Model

classe transformers.Sapiens2Model

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Sapiens2 puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para mais detalhes (processor_class usa Sapiens2ImageProcessor para processar as imagens).
  • bool_masked_pos (torch.BoolTensor de forma (batch_size, sequence_length), opcional) — Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0). Relevante apenas para pré-treinamento.

Retorna

BaseModelOutputWithPooling ou tuple(torch.FloatTensor)

Um BaseModelOutputWithPooling ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward do Sapiens2Model sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • pooler_output (torch.FloatTensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com formato (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

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

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

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

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

Sapiens2Backbone

classe transformers.Sapiens2Backbone

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O backbone Sapiens2.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

Retorna

Sapiens2BackboneOutput ou tuple(torch.FloatTensor)

Uma Sapiens2BackboneOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward de Sapiens2Backbone substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • feature_maps (tuple(torch.FloatTensor) de forma (batch_size, num_channels, height, width)) — Mapas de características dos estágios.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (uma para a saída dos embeddings + uma para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size) ou (batch_size, num_channels, height, width), dependendo do backbone.

    Estados ocultos do modelo na saída de cada estágio, além das saídas do embedding inicial.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length). Aplicável apenas se o backbone usar atenção.

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • cls_tokens (tuple(torch.FloatTensor), opcional) — token CLS de cada estágio de recurso selecionado, cada um com forma (batch_size, hidden_size). Presente apenas quando config.return_class_token=True.

Exemplo:

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

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

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

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

Sapiens2ForImageMatting

classe transformers.Sapiens2ForImageMatting

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Sapiens2 com uma cabeça de matting no topo (um decodificador baseado em PixelShuffle que prevê um primeiro plano RGB pré-multiplicado e uma máscara alfa).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para mais detalhes (processor_class usa Sapiens2ImageProcessor para processar as imagens).
  • labels (torch.FloatTensor de forma (batch_size, 4, height, width), opcional) — Alvos de matting reais para o cálculo da perda.

Retorna

Sapiens2ImageMattingOutput ou tuple(torch.FloatTensor)

Um Sapiens2ImageMattingOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward de Sapiens2ForImageMatting substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda.

  • alphas (torch.FloatTensor de forma (batch_size, 1, height, width)) — Valores de alpha estimados.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.

  • attentions (tuple[torch.FloatTensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • foregrounds (torch.FloatTensor de forma (batch_size, 3, height, width)) — Previsões de primeiro plano RGB pré-multiplicadas em [0, 1] (ativadas por sigmoid).

Exemplo:

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

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

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

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

Sapiens2ForNormalEstimation

classe transformers.Sapiens2ForNormalEstimation

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Sapiens2 com uma cabeça de estimativa de normais no topo (um decodificador baseado em PixelShuffle que prevê mapas de normais de superfície).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para mais detalhes (processor_class usa Sapiens2ImageProcessor para processar as imagens).
  • labels (torch.FloatTensor de forma (batch_size, num_labels, height, width), opcional) — Mapas de normais de superfície de referência para o cálculo da perda.

Retorna

Sapiens2NormalEstimatorOutput ou tuple(torch.FloatTensor)

Uma Sapiens2NormalEstimatorOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward de Sapiens2ForNormalEstimation substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de estimativa normal.
  • normals (torch.FloatTensor de forma (batch_size, num_labels, height, width)) — Previsões brutas do mapa de normais produzidas pelo modelo (não normalizadas).
  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (uma para a saída dos embeddings + uma para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas dos embeddings iniciais.
  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma por camada) com a forma (batch_size, num_heads, sequence_length, sequence_length). Pesos das atenções após o softmax de atenção.

Exemplo:

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

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

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

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

Sapiens2ForPointmapEstimation

classe transformers.Sapiens2ForPointmapEstimation

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Sapiens2 com uma cabeça de pointmap no topo (um decodificador baseado em PixelShuffle que prevê coordenadas 3D XYZ por pixel, além de um ramo opcional de escala para normalização da distância focal).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para mais detalhes (processor_class usa Sapiens2ImageProcessor para processar as imagens).
  • labels (torch.FloatTensor de forma (batch_size, 3, height, width), opcional) — Pointmap de referência (ground-truth) para o cálculo da perda.

Retorna

Sapiens2PointmapEstimatorOutput ou tuple(torch.FloatTensor)

Uma Sapiens2PointmapEstimatorOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward de Sapiens2ForPointmapEstimation substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de estimativa de Pointmap.
  • pointmaps (torch.FloatTensor de forma (batch_size, 3, height, width)) — Previsões de coordenadas 3D XYZ por pixel no espaço de câmera canônico.
  • scales (torch.FloatTensor de forma (batch_size, 1), opcional) — Razão entre a distância focal canônica e a distância focal real. None quando nenhum ramo de escala está configurado.
  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (uma para a saída dos embeddings + uma para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas dos embeddings iniciais.
  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma por camada) com a forma (batch_size, num_heads, sequence_length, sequence_length). Pesos das atenções após o softmax de atenção.

Exemplo:

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

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

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

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

Sapiens2ForPoseEstimation

classe transformers.Sapiens2ForPoseEstimation

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Sapiens2 com uma cabeça de estimativa de pose no topo (um conjunto de preditores de mapa de calor sobre a saída dos estados ocultos).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para mais detalhes (processor_class usa Sapiens2ImageProcessor para processar as imagens).
  • flip_pairs (torch.Tensor de forma (num_pairs, 2), opcional) — Pares de pontos-chave que são espelhados (por exemplo, orelha esquerda — orelha direita), usados para aumentação por espelhamento no momento do teste. Quando fornecido, o modelo assume que pixel_values contém imagens espelhadas horizontalmente e chama flip_back nos mapas de calor de saída para restaurar a orientação original.
  • labels (torch.FloatTensor de forma (batch_size, num_keypoints, height, width), opcional) — Ground truth do heatmap para o cálculo da perda.
  • label_weights (torch.FloatTensor de forma (batch_size, num_labels, 1, 1) ou (batch_size, num_labels, height, width), opcional) — Pesos de visibilidade para cada ponto-chave. Deve ser broadcastável para a forma de labels.

Retorna

Sapiens2PoseEstimatorOutput ou tuple(torch.FloatTensor)

Uma Sapiens2PoseEstimatorOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward de Sapiens2ForPoseEstimation substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de estimativa de pose.

  • heatmaps (torch.FloatTensor de forma (batch_size, num_keypoints, height, width)) — Heatmaps previstos pelo modelo.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.

  • attentions (tuple[torch.FloatTensor, ...], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com formato (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

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

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

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

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

Sapiens2ForSemanticSegmentation

classe transformers.Sapiens2ForSemanticSegmentation

< >

( config: Sapiens2Config )

Parâmetros

  • config (Sapiens2Config) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Sapiens2 com uma cabeça de segmentação semântica no topo, por exemplo, para ADE20K, CityScapes.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

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

Parâmetros

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Sapiens2ImageProcessor. Consulte Sapiens2ImageProcessor.call() para mais detalhes (processor_class usa Sapiens2ImageProcessor para processar as imagens).
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de segmentação semântica de verdade para o cálculo da perda. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels > 1, uma perda de classificação é calculada (Cross-Entropy).

Retorna

SemanticSegmenterOutput ou tuple(torch.FloatTensor)

Um SemanticSegmenterOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (Sapiens2Config) e das entradas.

O método forward de Sapiens2ForSemanticSegmentation substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.FloatTensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação (ou de regressão se config.num_labels==1).

  • logits (torch.FloatTensor de forma (batch_size, config.num_labels, logits_height, logits_width)) — Pontuações de classificação para cada pixel.

    Os logits retornados não necessariamente têm o mesmo tamanho que os pixel_values passados como entradas. Isso é para evitar fazer duas interpolações e perder alguma qualidade quando um usuário precisa redimensionar os logits para o tamanho da imagem original como pós-processamento. Você deve sempre verificar a forma dos seus logits e redimensioná-los conforme necessário.

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) com formato (batch_size, patch_size, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com forma (batch_size, num_heads, patch_size, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

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