Transformers 文档
Sapiens2
并获得增强的文档体验
开始使用
该模型于 2026 年 4 月 23 日在 HF 论文中发表，并于 2026 年 6 月 3 日贡献给 Hugging Face Transformers。
Sapiens2
概述
Sapiens2 模型由 Rawal Khirodkar、He Wen、Julieta Martinez、Yuan Dong、Zhaoen Su 和 Shunsuke Saito 在 Sapiens2 论文中提出。Sapiens2 是一系列高分辨率视觉 Transformer，在约 10 亿张精选的人体图像上进行预训练，专为以人为中心的计算机视觉任务而设计，包括姿态估计、身体部位分割、表面法线估计和点图估计。
您可以在 Sapiens2 收藏集中找到所有原始的 Sapiens2 检查点。
论文摘要如下：
我们推出了 Sapiens2，这是一系列用于以人为中心视觉的高分辨率 Transformer，专注于泛化能力、通用性和高保真输出。我们在约 10 亿张经过改进任务标注的精选高质量人体图像上进行预训练，并将掩码图像重建与自蒸馏对比目标相结合，以学习低级和语义特征。我们的模型参数规模从 0.4B 到 5B 不等，并在原始 1K 分辨率下进行训练，同时具有用于扩展空间推理的分层 4K 变体。Sapiens2 较其前身取得了实质性改进：姿态估计 mAP 提升 +4，身体部位分割 mIoU 提升 +24.3，法线估计误差降低 45.6%，同时扩展到了点图和反照率估计等新任务。代码已公开。
技巧
- Sapiens2 使用旋转位置嵌入 (RoPE) 并支持任意输入分辨率。默认的图像处理器将图像调整为 1024×768（高×宽）。
- 该模型在中间层使用分组查询注意力 (GQA)，在第一层和最后 8 层使用完整的全多头注意力。
- 寄存器 Token（默认 8 个）减少了 Patch Token 中的高范数伪影，从而生成更清晰的注意力图并在密集预测任务上表现更好。
使用示例
下面的示例展示了如何使用 Sapiens2Model 获取 CLS Token（全图嵌入）。
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
class transformers.Sapiens2Config
< source >( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 is_encoder_decoder: bool = False id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None patch_size: int | list[int] | tuple[int, int] = 16 hidden_size: int = 1024 intermediate_size: int = 4096 num_hidden_layers: int = 24 num_attention_heads: int = 16 hidden_act: str = 'silu' attention_dropout: float | int = 0.0 initializer_range: float = 0.02 rope_theta: float = 100.0 image_size: int | list[int] | tuple[int, int] = 224 num_channels: int = 3 query_bias: bool = True key_bias: bool = True value_bias: bool = True proj_bias: bool = True mlp_bias: bool = True layerscale_value: float = 1.0 drop_path_rate: float | int = 0.0 use_gated_mlp: bool = True num_register_tokens: int = 8 pos_embed_shift: float | None = None pos_embed_jitter: float | None = None pos_embed_rescale: float | None = 2.0 _out_features: list[str] | None = None _out_indices: list[int] | None = None reshape_hidden_states: bool = True use_mask_token: bool = False rms_norm_eps: float = 1e-06 normalize_backbone_outputs: bool = True use_qk_norm: bool = True num_key_value_heads_per_layer: list[int] | None = None num_key_value_attention_heads: int = 8 num_first_full_attention_layers: int = 8 num_last_full_attention_layers: int = 8 semantic_loss_ignore_index: int = 255 flip_pairs: list[list[int]] | None = None head_config: transformers.models.sapiens2.configuration_sapiens2.Sapiens2HeadConfig | dict | None = None )
参数
- patch_size (
Union[int, list[int], tuple[int, int]], 可选, 默认值为16) — 每个 Patch 的大小（分辨率）。 - hidden_size (
int, 可选, 默认值为1024) — 隐藏表示的维度。 - intermediate_size (
int, 可选, 默认值为4096) — MLP 表示的维度。 - num_hidden_layers (
int, 可选, 默认值为24) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int, 可选, 默认值为16) — Transformer 解码器中每个注意力层的注意力头数。 - hidden_act (
str, 可选, 默认值为silu) — 解码器中的非线性激活函数（函数或字符串）。例如："gelu","relu","silu"等。 - attention_dropout (
Union[float, int], 可选, 默认值为0.0) — 注意力概率的 Dropout 比率。 - initializer_range (
float, 可选, 默认值为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - rope_theta (
float, 可选, 默认值为 100.0) — RoPE 嵌入的基周期。 - image_size (
Union[int, list[int], tuple[int, int]], 可选, 默认值为224) — 每个图像的大小（分辨率）。 - num_channels (
int, 可选, 默认值为3) — 输入通道数。 - query_bias (
bool, 可选, 默认值为True) — 是否在查询投影中添加偏置。 - key_bias (
bool, 可选, 默认值为False) — 是否在键投影中添加偏置。 - value_bias (
bool, 可选, 默认值为True) — 是否在值投影中添加偏置。 - proj_bias (
bool, 可选, 默认值为True) — 是否在输出投影中添加偏置。 - mlp_bias (
bool, 可选, 默认为True) — 是否在 MLP 层中的 up_proj、down_proj 和 gate_proj 层使用偏置（bias）。 - layerscale_value (
float, 可选, 默认为 1.0) — 用于层缩放（layer scale）的初始值。 - drop_path_rate (
Union[float, int], 可选, 默认为0.0) — 用于 Patch 融合的丢弃路径（drop path）比例。 - use_gated_mlp (
bool, 可选, 默认为False) — 是否使用 SwiGLU 前馈神经网络。 - num_register_tokens (
int, 可选, 默认为 0) — 寄存器 token（register tokens）的数量。 - pos_embed_shift (
float, 可选) — 位置嵌入坐标在 [-shift, shift] 范围内的随机偏移量。如果不为None，则仅在训练模式下应用。 - pos_embed_jitter (
float, 可选) — 位置嵌入坐标在对数均匀分布 [1/jitter, jitter] 内的随机抖动量。如果不为None，则仅在训练模式下应用。 - pos_embed_rescale (
float, 可选, 默认为 2.0) — 位置嵌入坐标在对数均匀分布 [1/rescale, rescale] 内的随机缩放量。如果不为None，则仅在训练模式下应用。 - reshape_hidden_states (
bool, 可选, 默认为True) — 作为骨干网络（backbone）使用时，是否将隐藏状态重塑为空间维度。 - use_mask_token (
bool, 可选, 默认为False) — 是否在嵌入层中使用掩码 token（对于掩码图像建模预训练是必需的）。 - rms_norm_eps (
float, 可选, 默认为 1e-6) — RMS 归一化层的 epsilon 值。 - normalize_backbone_outputs (
bool, 可选, 默认为True) — 是否在从前向传播返回结果之前，对骨干网络输出的feature_maps和cls_tokens应用 RMSNorm。仅当模型用作骨干网络时适用。 - use_qk_norm (
bool, 可选, 默认为True) — 是否在注意力层中的 RoPE 之前对查询（queries）和键（keys）应用 RMSNorm。 - num_key_value_heads_per_layer (
list[int], 可选) — 每个 Transformer 层的键/值头数量。将某层的值设为等于num_attention_heads即实现完整的多头注意力；较小的值则实现分组查询注意力（grouped-query attention）。默认情况下，前num_first_full_attention_layers层和最后num_last_full_attention_layers层的值为num_attention_heads，其余所有层为num_key_valueattention_heads。 - num_key_value_attention_heads (
int, 可选, 默认为8) — 当未设置num_key_value_heads_per_layer时，使用分组查询注意力的层的键/值头数量。设置num_key_value_heads_per_layer时将忽略此参数。 - num_first_full_attention_layers (
int, 可选, 默认为 8) — 使用完整多头注意力的起始 Transformer 层数。仅在num_key_value_heads_per_layer为None时使用。 - num_last_full_attention_layers (
int, 可选, 默认为 8) — 使用完整多头注意力的末尾 Transformer 层数。仅在num_key_value_heads_per_layer为None时使用。 - semantic_loss_ignore_index (
int, 可选, 默认为 255) — 在计算分割损失时忽略的标签索引。 - flip_pairs (
list[list[int]], 可选) — 水平镜像对称的关键点索引对（例如，左耳 ↔ 右耳）。每对是一个包含两个元素的列表[left_index, right_index]。用于姿态估计中的测试时水平翻转增强：将这些对传给第二次前向传播调用，以便模型在返回结果前将热图翻转回来。 - head_config (
Sapiens2HeadConfig, 可选) — 解码头（decode head）的配置。有关可用选项，请参阅 Sapiens2HeadConfig。
这是用于存储 Sapiens2Model 配置的配置类。它根据指定的参数实例化 Sapiens2 模型，定义模型架构。使用默认值实例化配置将产生与 facebook/sapiens2-pretrain-0.4b 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。
Sapiens2HeadConfig
class transformers.Sapiens2HeadConfig
< 源码 >( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 is_encoder_decoder: bool = False id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None upsample_out_channels: list[int] | None = None upsample_kernel_sizes: list[int] | None = None upsample_kernel_size: int = 4 use_pixel_shuffle: bool | None = None conv_out_channels: list[int] | None = None conv_kernel_sizes: list[int] | None = None conv_kernel_size: int = 1 scale_conv_out_channels: list[int] | None = None scale_conv_kernel_sizes: list[int] | None = None scale_conv_kernel_size: int = 1 scale_final_input_size: int | None = None scale_final_hidden_sizes: list[int] | None = None )
参数
- upsample_out_channels (
list[int], 可选) — 每个上采样块的输出通道数。第一个块以hidden_size通道作为输入；后续块使用前一个块的输出。 - upsample_kernel_sizes (
list[int], optional) — 每个上采样块的卷积核大小。当设置了upsample_out_channels但此参数为None时，会自动填充为[4, ...]。必须与upsample_out_channels具有相同的长度。 - upsample_kernel_size (
int, 默认为 4) — 当未设置upsample_kernel_sizes时，上采样块的默认卷积核大小。 - use_pixel_shuffle (
bool, optional) — 上采样头是否使用像素洗牌（pixel-shuffle）上采样代替转置卷积。当为None（默认值）时，该头使用转置卷积。 - conv_out_channels (
list[int], optional) — 上采样块之后细化卷积层的输出通道数。 - conv_kernel_sizes (
list[int], optional) — 每个细化卷积层的卷积核大小。当设置了conv_out_channels但此参数为None时，会自动填充为[1, ...]。必须与conv_out_channels具有相同的长度。 - conv_kernel_size (
int, 默认为 1) — 当未设置conv_kernel_sizes时，卷积层的默认卷积核大小。 - scale_conv_out_channels (
list[int], optional) — 用于预测焦距比例的步长为 2 的卷积层的输出通道数。当为None（默认值）时，不会构建比例分支。 - scale_conv_kernel_sizes (
list[int], optional) — 每个比例卷积层的卷积核大小。当设置了scale_conv_out_channels但此参数为None时，会自动填充为[1, ...]。必须与scale_conv_out_channels具有相同的长度。 - scale_conv_kernel_size (
int, 默认为 1) — 当未设置scale_conv_kernel_sizes时，比例卷积层的默认卷积核大小。 - scale_final_input_size (
int, optional) — 传入比例 MLP 的扁平化特征大小。当为None（默认值）时，它会自动从父类 Sapiens2Config 中的image_size和patch_size推断得出。 - scale_final_hidden_sizes (
list[int], optional) — 用于将扁平化比例特征映射到标量比例输出的 MLP 的隐藏层大小。当为None（默认值）时，不会构建比例分支。
这是用于存储 Sapiens2Model 配置的配置类。它根据指定的参数实例化一个 Sapiens2 模型，从而定义模型架构。使用默认值实例化配置将产生与 facebook/sapiens2-seg-0.4b 相似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。
Sapiens2ImageProcessor
class transformers.Sapiens2ImageProcessor
< 源码 >( **kwargs: typing_extensions.Unpack[transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs] )
参数
- do_reduce_labels (
bool, kwargs, optional, 默认为self.do_reduce_labels) — 是否将分割图的所有标签值减 1。通常用于 0 被用作背景，且背景未包含在数据集的所有类别中的情况（例如 ADE20k）。背景标签将被替换为 255。 - **kwargs (ImagesKwargs, optional) — 附加的图像预处理选项。模型特定的 kwargs 列在上面；请参阅 TypedDict 类以获取支持参数的完整列表。
构建一个 Sapiens2ImageProcessor 图像处理器。
preprocess
< 源码 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None boxes: list[list[list[float]]] | None = None **kwargs: typing_extensions.Unpack[transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs] ) → ~image_processing_base.BatchFeature
参数
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 待预处理的图像。期望输入单个图像或一批图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。 - segmentation_maps (
ImageInput, optional) — 待预处理的分割图。 - boxes (
list[list[list[float]]]或np.ndarray, optional) — 每张图像的边界框列表或数组。每个框应为包含 4 个浮点数的列表，代表 COCO 格式的边界框坐标（左上角 x，左上角 y，宽度，高度）。提供此参数后，每个人物裁剪区域将进行仿射变换以匹配模型输入大小，而不是调整整个图像的大小。 - do_reduce_labels (
bool, kwargs, optional, 默认为self.do_reduce_labels) — 是否将分割图的所有标签值减 1。通常用于 0 被用作背景，且背景未包含在数据集的所有类别中的情况（例如 ADE20k）。背景标签将被替换为 255。 - return_tensors (
str或 TensorType, optional) — 如果设置为'pt'，则返回堆叠的张量，否则返回张量列表。 - **kwargs (ImagesKwargs, optional) — 附加的图像预处理选项。模型特定的 kwargs 列在上面；请参阅 TypedDict 类以获取支持参数的完整列表。
返回
~image_processing_base.BatchFeature
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。 - tensor_type (
Union[None, str, TensorType], optional) — 您可以在此处提供 tensor_type 以在初始化时将整数列表转换为 PyTorch/Numpy 张量。
post_process_image_matting
< 源码 >( outputs: Sapiens2ImageMattingOutput target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None backgrounds: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None ) → 长度为 batch_size 的 list[dict]。每个 dict 具有
参数
- outputs (
Sapiens2ImageMattingOutput) — 模型的原始输出。 - target_sizes (
torch.Tensor或长度为batch_size的list[tuple[int, int]]，optional) — 每个预测所要求的最终(height, width)。使用双线性插值调整大小。如果未设置，将以模型输出的分辨率返回预测。 - backgrounds (
ImageInput, optional) — 要合成在其上的背景图像。可以是单个图像（应用于批处理中的每一项）或图像列表（每批次项目一个）。接受 PIL 图像、numpy 数组或任何 dtype 的 torch 张量；整数类型（例如 uint8）会自动缩放到[0, 1]。提供背景后，每个结果字典中会增加一个"composite"键，其中包含作为 uint8 张量且在[0, 255]范围内的合成图像。
返回
长度为 batch_size 的 list[dict]。每个 dict 具有
"alpha"(形状为(1, height, width)的torch.Tensor)：范围在[0, 1]内的 alpha 值。"foreground"(形状为(3, height, width)的torch.Tensor)：范围在[0, 1]内的预乘 RGB 值。"composite"(torch.Tensor，形状为(3, height, width)或None)：作为 uint8 张量在[0, 255]范围内覆盖在backgrounds之上的前景合成图；当未提供backgrounds时为None。
将 Sapiens2ForImageMatting 的输出转换为 alpha 遮罩（alpha mattes）和前景图。
post_process_normal_estimation
< 源码 >( outputs: Sapiens2NormalEstimatorOutput source_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None do_remove_padding: bool | None = None )
参数
- outputs (
Sapiens2NormalEstimatorOutput) — 模型的原始输出。 - source_sizes (
torch.Tensor或 长度为batch_size的list[tuple[int, int]]，可选) — 预处理前每张图像的原始(height, width)。提供此参数时，会移除预处理过程中添加的填充，并将预测结果调整回原始图像大小（除非target_sizes覆盖了最终大小）。 - target_sizes (
torch.Tensor或 长度为batch_size的list[tuple[int, int]]，可选) — 每个预测所需的最终(height, width)。提供此参数时，将作为调整大小的目标而非使用source_sizes。在 L2 归一化后通过双线性插值进行调整。 - do_remove_padding (
bool，可选) — 是否在调整大小前裁剪掉预处理期间添加的零填充。当提供source_sizes时默认为True，否则默认为False。
将 Sapiens2ForNormalEstimation 的输出转换为 L2 归一化的表面法线图。
post_process_pointmap_estimation
< 源码 >( outputs: Sapiens2PointmapEstimatorOutput source_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None do_remove_padding: bool | None = None )
参数
- outputs (
Sapiens2PointmapEstimatorOutput) — 模型的原始输出。 - source_sizes (
torch.Tensor或 长度为batch_size的list[tuple[int, int]]，可选) — 预处理前每张图像的原始(height, width)。提供此参数时，会移除预处理过程中添加的填充，并将预测结果调整回原始图像大小（除非target_sizes覆盖了最终大小）。 - target_sizes (
torch.Tensor或 长度为batch_size的list[tuple[int, int]]，可选) — 每个预测所需的最终(height, width)。作为调整大小的目标，覆盖source_sizes。 - do_remove_padding (
bool，可选) — 是否在调整大小前裁剪掉预处理期间添加的零填充。当提供source_sizes时默认为True，否则默认为False。
将 Sapiens2ForPointmapEstimation 的输出转换为图像空间中的点图张量。
post_process_pose_estimation
< 源码 >( outputs: Sapiens2PoseEstimatorOutput boxes: list outputs_flipped: transformers.models.sapiens2.modeling_sapiens2.Sapiens2PoseEstimatorOutput | None = None kernel_size: int = 11 threshold: float | None = None source_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None ) → list[list[dict]]
参数
- outputs (
Sapiens2PoseEstimatorOutput) — 模型的原始输出。outputs.heatmaps的形状必须为(N_total, num_keypoints, heatmap_height, heatmap_width)，其中N_total = sum(len(b) for b in boxes)。 - boxes (
list[list[list[float]]]或np.ndarray) — 每张图像的边界框列表或数组，使用绝对像素坐标。每个框应为包含 4 个浮点数的列表，代表 COCO 格式的边界框坐标（左上角x，左上角y，宽度，高度）。必须与传递给preprocess的boxes参数相匹配。 - outputs_flipped (
Sapiens2PoseEstimatorOutput，可选) — 在水平翻转的输入上运行模型得到的输出。提供此参数时，在关键点提取前会先将热力图与outputs进行平均以提高精度：avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2。 - kernel_size (
int，可选，默认为 11) — 用于 UDP Dark Pose 细化的高斯模糊核大小。 - threshold (
float，可选) — 分数阈值。分数等于或低于此值的关键点将从结果字典中过滤掉。 - source_sizes (
torch.Tensor或 长度为batch_size的list[tuple[int, int]]，可选) — 每张图像的原始(height, width)（像素）。在提供target_sizes时是必需的，作为缩放关键点和边界框的原始坐标空间。 - target_sizes (
torch.Tensor或 长度为batch_size的list[tuple[int, int]]，可选) — 每张图像所需的输出(height, width)坐标空间。当与source_sizes一起提供时，关键点坐标和边界框将从源空间缩放到目标空间。
返回
list[list[dict]]
外层列表对应图像，内层列表对应人物。每个字典包含：
keypoints(torch.FloatTensor，形状为(num_keypoints, 2))：原始图像空间中的绝对 x/y 坐标；如果提供了target_sizes，则为目标空间中的坐标。scores(torch.FloatTensor，形状为(num_keypoints,))：每个关键点的置信度。labels(torch.LongTensor，形状为(num_keypoints,))：关键点索引。bbox(torch.FloatTensor，形状为(4,))：绝对坐标格式 (x_min, y_min, x_max, y_max) 的边界框，与keypoints处于相同的坐标空间。
将 Sapiens2ForPoseEstimation 的输出转换为图像空间中的关键点预测。
post_process_semantic_segmentation
< 源码 >( outputs target_sizes: list[tuple] | None = None ) → semantic_segmentation
参数
- outputs (Sapiens2ForSemanticSegmentation) — 模型的原始输出。
- target_sizes (长度为
batch_size的list[Tuple]，可选) — 对应每个预测所需的最终大小 (height, width) 的元组列表。如果未设置，预测结果将不会调整大小。
返回
语义分割
list[torch.Tensor] of length batch_size, where each item is a semantic segmentation map of shape (height, width) corresponding to the target_sizes entry (if target_sizes is specified). Each entry of each torch.Tensor correspond to a semantic class id.
将 Sapiens2ForSemanticSegmentation 的输出转换为语义分割图。
Sapiens2Model
class transformers.Sapiens2Model
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
原始的 Sapiens2 模型，输出原始隐藏状态，顶部没有任何特定任务的头部。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: Tensor bool_masked_pos: torch.Tensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)) — 输入图像对应的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 来处理图像）。 - bool_masked_pos (
torch.BoolTensor，形状为(batch_size, sequence_length)，可选) — 布尔遮罩位置。指示哪些块（patch）被遮罩（1），哪些没有（0）。仅与预训练相关。
返回
BaseModelOutputWithPooling or tuple(torch.FloatTensor)
一个 BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），根据配置（Sapiens2Config）和输入的不同，包含不同的元素。
Sapiens2Model 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。pooler_output (
torch.FloatTensor，形状为(batch_size, hidden_size)) — 序列第一个 token（分类 token）在进一步通过用于辅助预训练任务的层后的最后一个隐藏状态。例如，对于 BERT 系列模型，这会返回经过线性层和 tanh 激活函数处理后的分类 token。线性层的权重是通过预训练期间的下一句预测（分类）目标来训练的。hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> 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
class transformers.Sapiens2Backbone
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Sapiens2 主干网络。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: Tensor **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sapiens2BackboneOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)) — 输入图像对应的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 来处理图像）。
返回
Sapiens2BackboneOutput 或 tuple(torch.FloatTensor)
一个 Sapiens2BackboneOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），根据配置（Sapiens2Config）和输入的不同，包含不同的元素。
Sapiens2Backbone 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
feature_maps (
tuple(torch.FloatTensor)of shape(batch_size, num_channels, height, width)) — 阶段的特征图。hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor元组（一个用于嵌入输出 + 每个层输出一个）的形状为(batch_size, sequence_length, hidden_size)或(batch_size, num_channels, height, width)，具体取决于主干网络。模型在每个阶段输出的隐藏状态以及初始嵌入输出。
attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。仅当主干网络使用注意力时适用。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cls_tokens (
tuple(torch.FloatTensor)，可选) — 来自每个选定特征阶段的 CLS token，每个形状为(batch_size, hidden_size)。仅在config.return_class_token=True时存在。
示例
>>> 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
class transformers.Sapiens2ForImageMatting
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
顶部带有抠图（matting）头部的 Sapiens2 模型（一个基于 PixelShuffle 的解码器，用于预测预乘 RGB 前景和 alpha 遮罩）。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor labels: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sapiens2ImageMattingOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, image_size, image_size)) — 输入图像对应的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 来处理图像）。 - labels (
torch.FloatTensor，形状为(batch_size, 4, height, width)，可选) — 用于计算损失的真实值抠图目标。
返回
Sapiens2ImageMattingOutput 或 tuple(torch.FloatTensor)
一个 Sapiens2ImageMattingOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），根据配置（Sapiens2Config）和输入的不同，包含不同的元素。
Sapiens2ForImageMatting 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 损失值。alphas (
torch.FloatTensor，形状为(batch_size, 1, height, width)) — 估计的 alpha 值。hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。attentions (
tuple[torch.FloatTensor]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
foregrounds (
torch.FloatTensor，形状为(batch_size, 3, height, width)) — 预乘后的 RGB 前景预测，范围在[0, 1]（经 Sigmoid 激活）。
示例
>>> 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
class transformers.Sapiens2ForNormalEstimation
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
顶部带有法线估计头部的 Sapiens2 模型（一个基于 PixelShuffle 的解码器，用于预测表面法线图）。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor labels: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sapiens2NormalEstimatorOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, image_size, image_size)) — 输入图像对应的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 来处理图像）。 - labels (
torch.FloatTensor，形状为(batch_size, num_labels, height, width)，可选) — 用于计算损失的真实值表面法线图。
返回
Sapiens2NormalEstimatorOutput 或 tuple(torch.FloatTensor)
一个 Sapiens2NormalEstimatorOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），根据配置（Sapiens2Config）和输入的不同，包含不同的元素。
Sapiens2ForNormalEstimation 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 法线估计损失。 - normals (
torch.FloatTensor，形状为(batch_size, num_labels, height, width)) — 模型输出的原始法线图预测（未归一化）。 - hidden_states (
tuple(torch.FloatTensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（嵌入输出一个 + 每个阶段输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。 - attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重。
示例
>>> 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
class transformers.Sapiens2ForPointmapEstimation
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化模型不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Sapiens2 模型，顶部带有点图头（Pointmap head，一个基于 PixelShuffle 的解码器，用于预测每个像素的 3D XYZ 坐标，以及可选的用于焦距归一化的尺度分支）。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor labels: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sapiens2PointmapEstimatorOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)的torch.FloatTensor) — 对应于输入图像的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 进行图像处理）。 - labels (形状为
(batch_size, 3, height, width)的torch.FloatTensor，可选) — 用于计算损失的地面真值（Ground-truth）点图。
返回
Sapiens2PointmapEstimatorOutput 或 tuple(torch.FloatTensor)
Sapiens2PointmapEstimatorOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False 时），根据配置 (Sapiens2Config) 和输入包含各种元素。
Sapiens2ForPointmapEstimation 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
- loss (形状为
(1,)的torch.FloatTensor，可选，在提供labels时返回) — 点图估计损失。 - pointmaps (形状为
(batch_size, 3, height, width)的torch.FloatTensor) — 规范相机空间（canonical camera space）中的逐像素 3D XYZ 坐标预测。 - scales (形状为
(batch_size, 1)的torch.FloatTensor，可选) — 规范焦距与实际焦距之比。当未配置尺度分支时为None。 - hidden_states (
tuple(torch.FloatTensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（嵌入输出一个 + 每个阶段输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。 - attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重。
示例
>>> 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
class transformers.Sapiens2ForPoseEstimation
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化模型不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Sapiens2 模型，顶部带有姿态估计头（Pose estimation head，即在隐藏状态输出之上的热图预测器集合）。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor flip_pairs: torch.Tensor | None = None labels: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sapiens2PoseEstimatorOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)的torch.FloatTensor) — 对应于输入图像的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 进行图像处理）。 - flip_pairs (形状为
(num_pairs, 2)的torch.Tensor，可选) — 镜像对称的关键点对（例如左耳 — 右耳），用于测试时的水平翻转增强。提供此参数时，模型假定pixel_values包含水平翻转的图像，并对输出的热图调用flip_back以恢复原始方向。 - labels (形状为
(batch_size, num_keypoints, height, width)的torch.FloatTensor，可选) — 用于计算损失的热图地面真值。
返回
Sapiens2PoseEstimatorOutput 或 tuple(torch.FloatTensor)
Sapiens2PoseEstimatorOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False 时），根据配置 (Sapiens2Config) 和输入包含各种元素。
Sapiens2ForPoseEstimation 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (形状为
(1,)的torch.FloatTensor，可选，在提供labels时返回) — 姿态估计损失。heatmaps (形状为
(batch_size, num_keypoints, height, width)的torch.FloatTensor) — 模型预测的热图。hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> 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
class transformers.Sapiens2ForSemanticSegmentation
< 源码 >( config: Sapiens2Config )
参数
- config (Sapiens2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化模型不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Sapiens2 模型，顶部带有语义分割头（例如用于 ADE20K, CityScapes 等任务）。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( pixel_values: FloatTensor labels: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → SemanticSegmenterOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)的torch.FloatTensor) — 对应于输入图像的张量。像素值可以使用 Sapiens2ImageProcessor 获取。详细信息请参阅Sapiens2ImageProcessor.__call__()（processor_class使用 Sapiens2ImageProcessor 进行图像处理）。 - labels (形状为
(batch_size, height, width)的torch.LongTensor，可选) — 用于计算损失的地面真值语义分割图。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，将计算分类损失（交叉熵）。
返回
SemanticSegmenterOutput 或 tuple(torch.FloatTensor)
SemanticSegmenterOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False 时），根据配置 (Sapiens2Config) 和输入包含各种元素。
Sapiens2ForSemanticSegmentation 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits (形状为
(batch_size, config.num_labels, logits_height, logits_width)的torch.FloatTensor) — 每个像素的分类分数。返回的 logits 大小不一定与传入的
pixel_values相同。这是为了避免在用户需要将 logits 大小调整回原始图像大小时进行两次插值并损失质量。您应该始终检查 logits 形状并根据需要进行调整。hidden_states (
tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则包含一个嵌入层输出，加上每层的一个输出），形状为(batch_size, patch_size, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> 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])