Hugging Face 的 LOGO

Transformers 文档

SAM2

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

此模型于 2025 年 8 月 14 日贡献给 Hugging Face Transformers。

SAM2

SDPA FlashAttention

概述

SAM2 (Segment Anything Model 2) 由 Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár, Christoph Feichtenhofer 在 Segment Anything in Images and Videos 中提出。

该模型可用于根据输入图像或视频，以及输入的点或边界框，预测任何感兴趣对象的分割掩码。

example image

论文摘要如下：

我们提出了 Segment Anything Model 2 (SAM 2)，这是一个旨在解决图像和视频中可提示视觉分割任务的基础模型。我们构建了一个数据引擎，通过用户交互来改进模型和数据，从而收集了迄今为止最大的视频分割数据集。我们的模型采用了一种简单的 transformer 架构，并具有用于实时视频处理的流式内存。在我们的数据上训练的 SAM 2 在广泛的任务中表现出色。在视频分割方面，我们观察到与以往方法相比，其准确性更高，且交互次数减少了 3 倍。在图像分割方面，我们的模型比原始的 Segment Anything Model (SAM) 更准确，速度快 6 倍。我们相信我们的数据、模型和见解将成为视频分割及相关感知任务的一个重要里程碑。我们正在发布该模型的一个版本、数据集以及一个交互式演示。

技巧

  • 批处理与视频支持：SAM2 原生支持批处理和无缝视频分割，而原始 SAM 设计用于静态图像和更简单的逐图工作流。
  • 准确性与泛化能力：与原始 SAM 相比，SAM2 在分割质量、鲁棒性以及对新领域的零样本泛化能力方面表现更佳，特别是在混合提示的情况下。

此模型由 sangbumchoi 和 yonigozlan 贡献。原始代码可以在 这里 找到。

用法示例

通过流水线进行自动掩码生成

SAM2 可用于自动掩码生成，通过 mask-generation 流水线分割图像中的所有对象。

from transformers import pipeline


generator = pipeline("mask-generation", model="facebook/sam2.1-hiera-large", device=0)
image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
outputs = generator(image_url, points_per_batch=64)

len(outputs["masks"])  # Number of masks generated
39

基础图像分割

单点点击

您可以通过在要分割的对象上提供单个点击点来分割对象

from transformers import Sam2Processor, Sam2Model
import torch
from PIL import Image
import requests


model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", device_map="auto")
processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large")

image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
raw_image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

input_points = [[[[500, 375]]]]  # Single point click, 4 dimensions (image_dim, object_dim, point_per_object_dim, coordinates)
input_labels = [[[1]]]  # 1 for positive click, 0 for negative click, 3 dimensions (image_dim, object_dim, point_label)

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]

# The model outputs multiple mask predictions ranked by quality score
print(f"Generated {masks.shape[1]} masks with shape {masks.shape}")
Generated 3 masks with shape torch.Size(1, 3, 1500, 2250)

用于精细化的多点输入

您可以提供多个点来细化分割

# Add both positive and negative points to refine the mask
input_points = [[[[500, 375], [1125, 625]]]]  # Multiple points for refinement
input_labels = [[[1, 1]]]  # Both positive clicks

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]

边界框输入

SAM2 也支持将边界框作为分割输入。

# Define bounding box as [x_min, y_min, x_max, y_max]
input_boxes = [[[75, 275, 1725, 850]]]

inputs = processor(images=raw_image, input_boxes=input_boxes, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]

多对象分割

您可以同时分割多个对象

# Define points for two different objects
input_points = [[[[500, 375]], [[650, 750]]]]  # Points for two objects in same image
input_labels = [[[1], [1]]]  # Positive clicks for both objects

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

# Each object gets its own mask
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"Generated masks for {masks.shape[0]} objects")
Generated masks for 2 objects

批量推理

批量图像

同时处理多张图像以提高效率

from transformers import Sam2Processor, Sam2Model
import torch
from PIL import Image
import requests


model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", device_map="auto")
processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large")

# Load multiple images
image_urls = [
    "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/dog-sam.png"
]
raw_images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]

# Single point per image
input_points = [[[[500, 375]]], [[[770, 200]]]]  # One point for each image
input_labels = [[[1]], [[1]]]  # Positive clicks for both images

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

# Post-process masks for each image
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(all_masks)} images, each with {all_masks[0].shape[0]} objects")
Processed 2 images, each with 1 objects

每张图像的批量对象

使用批量推理分割每张图像中的多个对象

# Multiple objects per image - different numbers of objects per image
input_points = [
    [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects
    [[[770, 200]]]  # Dog image: 1 object
]
input_labels = [
    [[1], [1]],  # Truck image: positive clicks for both objects
    [[1]]  # Dog image: positive click for the object
]

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])

具有批量对象和多点输入的批量图像

处理复杂的批量场景，每个对象有多个点

# Add groceries image for more complex example
groceries_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/groceries.jpg"
groceries_image = Image.open(requests.get(groceries_url, stream=True).raw).convert("RGB")
raw_images = [raw_images[0], groceries_image]  # Use truck and groceries images

# Complex batching: multiple images, multiple objects, multiple points per object
input_points = [
    [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects with 1 point each
    [[[400, 300]], [[630, 300], [550, 300]]]  # Groceries image: obj1 has 1 point, obj2 has 2 points
]
input_labels = [
    [[1], [1]],  # Truck image: positive clicks
    [[1], [1, 1]]  # Groceries image: positive clicks for refinement
]

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])

批量边界框

处理具有边界框输入的批量图像

# Multiple bounding boxes per image (using truck and groceries images)
input_boxes = [
    [[75, 275, 1725, 850], [425, 600, 700, 875], [1375, 550, 1650, 800], [1240, 675, 1400, 750]],  # Truck image: 4 boxes
    [[450, 170, 520, 350], [350, 190, 450, 350], [500, 170, 580, 350], [580, 170, 640, 350]]  # Groceries image: 4 boxes
]

# Update images for this example
raw_images = [raw_images[0], groceries_image]  # truck and groceries

inputs = processor(images=raw_images, input_boxes=input_boxes, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(input_boxes)} images with {len(input_boxes[0])} and {len(input_boxes[1])} boxes respectively")
Processed 2 images with 4 and 4 boxes respectively

使用先前的掩码作为输入

SAM2 可以使用来自先前预测的掩码作为输入来精细化分割。

# Get initial segmentation
input_points = [[[[500, 375]]]]
input_labels = [[[1]]]
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

# Use the best mask as input for refinement
mask_input = outputs.pred_masks[:, :, torch.argmax(outputs.iou_scores.squeeze())]

# Add additional points with the mask input
new_input_points = [[[[500, 375], [450, 300]]]]
new_input_labels = [[[1, 1]]]
inputs = processor(
    input_points=new_input_points,
    input_labels=new_input_labels,
    original_sizes=inputs["original_sizes"],
    return_tensors="pt",
).to(model.device)

with torch.no_grad():
    refined_outputs = model(
        **inputs,
        input_masks=mask_input,
        image_embeddings=outputs.image_embeddings,
        multimask_output=False,
    )

Sam2Config

class transformers.Sam2Config

< >

( 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 vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None prompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None initializer_range: float = 0.02 )

参数

  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], 可选) — 视觉主干网络的配置对象或字典。
  • prompt_encoder_config (Union[dict, Sam2PromptEncoderConfig], 可选) — 用于初始化 Sam2PromptEncoderConfig 的配置选项字典。
  • mask_decoder_config (Union[dict, Sam2MaskDecoderConfig], 可选) — 用于初始化 Sam2MaskDecoderConfig 的配置选项字典。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 Sam2Model 配置的配置类。它用于根据指定的参数实例化一个 Sam2 模型，从而定义模型架构。使用默认值实例化配置将产生与 facebook/sam2.1-hiera-tiny 相似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。

示例

>>> from transformers import (
...     Sam2VisionConfig,
...     Sam2PromptEncoderConfig,
...     Sam2MaskDecoderConfig,
...     Sam2Model,
... )

>>> # Initializing a Sam2Config with `"facebook/sam2.1_hiera_tiny"` style configuration
>>> configuration = Sam2Config()

>>> # Initializing a Sam2Model (with random weights) from the `"facebook/sam2.1_hiera_tiny"` style configuration
>>> model = Sam2Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a Sam2Config from a Sam2VisionConfig, Sam2PromptEncoderConfig, and Sam2MaskDecoderConfig

>>> # Initializing SAM2 vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam2VisionConfig()
>>> prompt_encoder_config = Sam2PromptEncoderConfig()
>>> mask_decoder_config = Sam2MaskDecoderConfig()

>>> config = Sam2Config(vision_config, prompt_encoder_config, mask_decoder_config)

Sam2HieraDetConfig

class transformers.Sam2HieraDetConfig

< >

( 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 hidden_size: int = 96 num_attention_heads: int = 1 num_channels: int = 3 image_size: int | list[int] | None = None patch_kernel_size: int | list[int] | None = None patch_stride: int | list[int] | None = None patch_padding: int | list[int] | None = None query_stride: int | list[int] | None = None window_positional_embedding_background_size: list[int] | None = None num_query_pool_stages: int = 3 blocks_per_stage: list[int] | None = None embed_dim_per_stage: list[int] | None = None num_attention_heads_per_stage: list[int] | None = None window_size_per_stage: list[int] | None = None global_attention_blocks: list[int] | None = None mlp_ratio: float = 4.0 hidden_act: str = 'gelu' layer_norm_eps: float = 1e-06 initializer_range: float = 0.02 )

参数

  • hidden_size (int, 可选, 默认为 96) — 隐藏表示的维度。
  • num_attention_heads (int, 可选, 默认为 1) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_channels (int, 可选, 默认为 3) — 输入通道的数量。
  • image_size (Union[int, list[int]], 可选) — 每张图像的大小（分辨率）。
  • patch_kernel_size (list[int], 可选, 默认为 [7, 7]) — patch 的卷积核大小。
  • patch_stride (list[int], 可选, 默认为 [4, 4]) — patch 的步幅。
  • patch_padding (list[int], 可选, 默认为 [3, 3]) — 补丁（patch）的填充量。
  • query_stride (list[int], 可选, 默认为 [2, 2]) — 各阶段之间的下采样步长。
  • window_positional_embedding_background_size (list[int], 可选, 默认为 [7, 7]) — 未使用全局注意力时，各阶段的窗口大小。
  • num_query_pool_stages (int, 可选, 默认为 3) — 查询池（query pool）阶段的数量。
  • blocks_per_stage (list[int], 可选, 默认为 [1, 2, 7, 2]) — 每个阶段的区块（blocks）数量。
  • embed_dim_per_stage (list[int], 可选, 默认为 [96, 192, 384, 768]) — 每个阶段的嵌入维度。
  • num_attention_heads_per_stage (list[int], 可选, 默认为 [1, 2, 4, 8]) — 每个阶段的注意力头数。
  • window_size_per_stage (list[int], 可选, 默认为 [8, 4, 14, 7]) — 每个阶段的窗口大小。
  • global_attention_blocks (list[int], 可选, 默认为 [5, 7, 9]) — 使用全局注意力的区块索引。
  • mlp_ratio (float, 可选, 默认为 4.0) — MLP 隐藏层维度与嵌入维度的比率。
  • hidden_act (str, 可选, 默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如："gelu"、"relu"、"silu" 等。
  • layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon 值。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器（truncated_normal_initializer）的标准差。

这是用于存储 Sam2Model 配置的配置类。它用于根据指定的参数实例化一个 Sam2 模型，从而定义模型架构。使用默认值实例化配置将产生与 facebook/sam2.1-hiera-tiny 相似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。

Sam2VisionConfig

class transformers.Sam2VisionConfig

< >

( 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 backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None backbone_channel_list: list[int] | None = None backbone_feature_sizes: list | None = None fpn_hidden_size: int = 256 fpn_kernel_size: int = 1 fpn_stride: int = 1 fpn_padding: int = 0 fpn_top_down_levels: list[int] | None = None num_feature_levels: int = 3 hidden_act: str = 'gelu' layer_norm_eps: float = 1e-06 initializer_range: float = 0.02 )

参数

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], 可选) — 骨干网络（backbone）模型的配置。
  • backbone_channel_list (List[int], 可选, 默认为 [768, 384, 192, 96]) — 骨干网络的通道维度列表。
  • backbone_feature_sizes (List[List[int]], 可选, 默认为 [[256, 256], [128, 128], [64, 64]]) — 骨干网络输出特征图的空间大小。
  • fpn_hidden_size (int, 可选, 默认为 256) — FPN 的隐藏层维度。
  • fpn_kernel_size (int, 可选, 默认为 1) — Neck 中卷积层的卷积核大小。
  • fpn_stride (int, 可选, 默认为 1) — Neck 中卷积层的步长。
  • fpn_padding (int, 可选, 默认为 0) — Neck 中卷积层的填充量。
  • fpn_top_down_levels (List[int], 可选, 默认为 [2, 3]) — 自顶向下 FPN 连接的层级。
  • num_feature_levels (int, 可选, 默认为 3) — 使用的 FPN 特征层级数量。
  • hidden_act (str, 可选, 默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如："gelu"、"relu"、"silu" 等。
  • layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon 值。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器（truncated_normal_initializer）的标准差。

这是用于存储 Sam2Model 配置的配置类。它用于根据指定的参数实例化一个 Sam2 模型，从而定义模型架构。使用默认值实例化配置将产生与 facebook/sam2.1-hiera-tiny 相似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。

Sam2MaskDecoderConfig

class transformers.Sam2MaskDecoderConfig

< >

( 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 hidden_size: int = 256 hidden_act: str = 'gelu' mlp_dim: int = 2048 num_hidden_layers: int = 2 num_attention_heads: int = 8 attention_downsample_rate: int = 2 num_multimask_outputs: int = 3 iou_head_depth: int = 3 iou_head_hidden_dim: int = 256 dynamic_multimask_via_stability: bool = True dynamic_multimask_stability_delta: float = 0.05 dynamic_multimask_stability_thresh: float = 0.98 )

参数

  • hidden_size (int, optional, 默认为 256) — 隐藏层表示的维度。
  • hidden_act (str, optional, 默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如："gelu", "relu", "silu" 等。
  • mlp_dim (int, optional, 默认为 2048) — 双向 Transformer 中 MLP 的维度。
  • num_hidden_layers (int, optional, 默认为 2) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 8) — Transformer 解码器中每个注意力层的注意力头数量。
  • attention_downsample_rate (int, optional, 默认为 2) — 注意力层的下采样率。
  • num_multimask_outputs (int, optional, 默认为 3) — 多掩码输出的数量。
  • iou_head_depth (int, optional, 默认为 3) — IoU 头的深度。
  • iou_head_hidden_dim (int, optional, 默认为 256) — IoU 头的隐藏层维度。
  • dynamic_multimask_via_stability (bool, optional, 默认为 True) — 是否通过稳定性使用动态多掩码。
  • dynamic_multimask_stability_delta (float, optional, 默认为 0.05) — 动态多掩码的稳定性增量。
  • dynamic_multimask_stability_thresh (float, optional, 默认为 0.98) — 动态多掩码的稳定性阈值。

这是用于存储 Sam2Model 配置的配置类。它用于根据指定的参数实例化一个 Sam2 模型，从而定义模型架构。使用默认值实例化配置将产生与 facebook/sam2.1-hiera-tiny 相似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。

Sam2PromptEncoderConfig

class transformers.Sam2PromptEncoderConfig

< >

( 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 hidden_size: int = 256 image_size: int | list[int] | tuple[int, int] = 1024 patch_size: int | list[int] | tuple[int, int] = 16 mask_input_channels: int = 16 num_point_embeddings: int = 4 hidden_act: str = 'gelu' layer_norm_eps: float = 1e-06 scale: int = 1 )

参数

  • hidden_size (int, optional, 默认为 256) — 隐藏层表示的维度。
  • image_size (Union[int, list[int], tuple[int, int]], optional, 默认为 1024) — 每个图像的大小（分辨率）。
  • patch_size (Union[int, list[int], tuple[int, int]], optional, 默认为 16) — 每个分块（patch）的大小（分辨率）。
  • mask_input_channels (int, optional, 默认为 16) — 输入到 MaskDecoder 模块的通道数。
  • num_point_embeddings (int, optional, 默认为 4) — 要使用的点嵌入（point embeddings）数量。
  • hidden_act (str, optional, 默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如："gelu", "relu", "silu" 等。
  • layer_norm_eps (float, optional, 默认为 1e-06) — 层归一化层使用的 epsilon 值。
  • scale (float, optional, 默认为 1) — 提示编码器（prompt encoder）的缩放因子。

这是用于存储 Sam2Model 配置的配置类。它用于根据指定的参数实例化一个 Sam2 模型，从而定义模型架构。使用默认值实例化配置将产生与 facebook/sam2.1-hiera-tiny 相似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。

Sam2Processor

class transformers.Sam2Processor

< >

( image_processor target_size: int | None = None point_pad_value: int = -10 **kwargs )

参数

  • image_processor (Sam2ImageProcessor) — 图像处理器是必需的输入。
  • target_size (int, 可选) — 用于归一化输入点和边界框的目标尺寸（像素）。如果未提供，则默认为图像处理器的尺寸配置。所有输入坐标（点和框）在传递给模型之前都会被归一化为此尺寸。这确保了无论原始图像尺寸如何，坐标表示都保持一致。
  • point_pad_value (int, 可选, 默认为 -10) — 当对不同长度的序列进行批处理时，用于填充输入点的值。该值用于标记填充位置，并在坐标归一化期间保留。

构建一个 Sam2Processor，它将图像处理器包装成单个处理器。

Sam2Processor 提供了 Sam2ImageProcessor 的所有功能。更多信息请参阅 ~Sam2ImageProcessor。

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None 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 input_points: list[list[list[list[float]]]] | torch.Tensor | None = None input_labels: list[list[list[int]]] | torch.Tensor | None = None input_boxes: list[list[list[float]]] | torch.Tensor | None = None original_sizes: list[list[float]] | torch.Tensor | None = None return_tensors: str | transformers.utils.generic.TensorType | None = None **kwargs ) → 包含以下字段的 BatchEncoding

参数

  • 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, 可选) — 待处理的分割掩码。
  • input_points (list[list[list[list[float]]]], torch.Tensor, 可选) — 要添加到帧中的点。
  • input_labels (list[list[list[int]]], torch.Tensor, 可选) — 点的标签。
  • input_boxes (list[list[list[float]]], torch.Tensor, 可选) — 要添加到帧中的边界框。
  • original_sizes (list[list[float]], torch.Tensor, 可选) — 图像的原始尺寸。
  • return_tensors (Union[str, ~utils.generic.TensorType], 可选) — 如果设置，将返回特定框架的张量。可接受的值为：

    • 'pt': 返回 PyTorch torch.Tensor 对象。
    • 'np': 返回 NumPy np.ndarray 对象。

返回

具有以下字段的 BatchEncoding

  • pixel_values (torch.Tensor): 处理后的图像。
  • original_sizes (list[list[float]]): 图像的原始大小。
  • labels (torch.Tensor): 处理后的分割图（如果提供）。
  • input_points (torch.Tensor): 处理后的点。
  • input_labels (torch.Tensor): 处理后的标签。
  • input_boxes (torch.Tensor): 处理后的边界框。

post_process_masks

< >

( masks original_sizes mask_threshold = 0.0 binarize = True max_hole_area = 0.0 max_sprinkle_area = 0.0 apply_non_overlapping_constraints = False **kwargs ) → (torch.Tensor)

参数

  • masks (Union[List[torch.Tensor], List[np.ndarray]]) — 来自 mask_decoder 的批处理掩码，格式为 (batch_size, num_channels, height, width)。
  • original_sizes (Union[torch.Tensor, List[Tuple[int,int]]]) — 每张图像在调整大小到模型预期输入形状之前的原始尺寸，格式为 (height, width)。
  • mask_threshold (float, 可选, 默认为 0.0) — 二值化和后处理操作的阈值。
  • binarize (bool, 可选, 默认为 True) — 是否对掩码进行二值化。
  • max_hole_area (float, 可选, 默认为 0.0) — 要填充的孔洞的最大面积。
  • max_sprinkle_area (float, 可选, 默认为 0.0) — 要填充的离散点的最大面积。
  • apply_non_overlapping_constraints (bool, 可选, 默认为 False) — 是否对掩码应用非重叠约束。

返回

(torch.Tensor)

批量掩码，格式为 (batch_size, num_channels, height, width)，其中 (height, width) 由 original_size 给出。

去除填充并将掩码放大到原始图像大小。

Sam2ImageProcessor

class transformers.Sam2ImageProcessor

< >

( **kwargs: typing_extensions.Unpack[transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs] )

参数

  • mask_size (dict[str, *kwargs*, int], 可选) — 用于调整分割掩码尺寸的 {"height": int, "width": int} 大小。
  • **kwargs (ImagesKwargs, 可选) — 其他图像预处理选项。模型特定的 kwargs 列在上方；完整支持的参数列表请参阅 TypedDict 类。

构建一个 Sam2ImageProcessor 图像处理器。

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 **kwargs: typing_extensions.Unpack[transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs] ) → ~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, 可选) — 待预处理的分割掩码。
  • mask_size (dict[str, *kwargs*, int], 可选) — 用于调整分割掩码尺寸的 {"height": int, "width": int} 大小。
  • return_tensors (str 或 TensorType, 可选) — 如果设置为 'pt'，则返回堆叠后的张量，否则返回张量列表。
  • **kwargs (ImagesKwargs, 可选) — 额外的图像预处理选项。模型特定的 kwargs 在上方列出；完整支持的参数列表请参见 TypedDict 类。

返回

~image_processing_base.BatchFeature

  • data (dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。
  • tensor_type (Union[None, str, TensorType], optional) — 您可以在此处提供 tensor_type 以在初始化时将整数列表转换为 PyTorch/Numpy 张量。

Sam2HieraDetModel

class transformers.Sam2HieraDetModel

< >

( config: Sam2HieraDetConfig )

forward

< >

( pixel_values: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] )

Sam2VisionModel

class transformers.Sam2VisionModel

< >

( config: Sam2VisionConfig )

参数

  • config (Sam2VisionConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

Sam 的视觉模型，没有任何头部或顶部投影。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( pixel_values: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] )

Sam2Model

class transformers.Sam2Model

< >

( config: Sam2Config )

参数

  • config (Sam2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

Segment Anything Model 2 (SAM 2)，用于在给定输入图像、输入点、标签、框或掩码的情况下生成分割掩码。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( pixel_values: torch.FloatTensor | None = None input_points: torch.FloatTensor | None = None input_labels: torch.LongTensor | None = None input_boxes: torch.FloatTensor | None = None input_masks: torch.LongTensor | None = None image_embeddings: torch.FloatTensor | None = None multimask_output: bool = True attention_similarity: torch.FloatTensor | None = None target_embedding: torch.FloatTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sam2ImageSegmentationOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 Sam2ImageProcessor 获取。详情请参阅 Sam2ImageProcessor.__call__()（Sam2Processor 使用 Sam2ImageProcessor 处理图像）。
  • input_points (torch.FloatTensor，形状为 (batch_size, num_points, 2)) — 输入的二维空间点，供提示编码器（prompt encoder）用于编码提示。通常能产生更好的结果。点可以通过将嵌套列表传递给处理器来获取，处理器将创建维度为 4 的 torch 张量。第一个维度是图像批次大小，第二个维度是点批次大小（即我们希望模型为每个输入点预测多少个分割掩码），第三个维度是每个分割掩码的点数（可以为一个掩码传递多个点），最后一个维度是点的 x（垂直）和 y（水平）坐标。如果为每张图像或每个掩码传递的点数不同，处理器将创建坐标为 (0, 0) 的“填充（PAD）”点，并利用标签跳过这些点的嵌入计算。
  • input_labels (torch.LongTensor，形状为 (batch_size, point_batch_size, num_points)) — 点的输入标签，供提示编码器用于编码提示。根据官方实现，有 3 种标签类型

    • 1：该点包含目标对象
    • 0：该点不包含目标对象
    • -1：该点对应背景

    我们添加了以下标签：

    • -10：该点为填充点，因此应被提示编码器忽略

    填充标签应由处理器自动完成。

  • input_boxes (torch.FloatTensor，形状为 (batch_size, num_boxes, 4)) — 点的输入框，供提示编码器用于编码提示。通常能产生更好的生成掩码。框可以通过将嵌套列表传递给处理器来获取，处理器将生成一个 torch 张量，各维度分别对应图像批次大小、每张图像的框数以及框的左上角和右下角坐标。格式为 (x1, y1, x2, y2)：

    • x1：输入框左上角的 x 坐标
    • y1：输入框左上角的 y 坐标
    • x2：输入框右下角的 x 坐标
    • y2：输入框右下角的 y 坐标
  • input_masks (torch.FloatTensor，形状为 (batch_size, image_size, image_size)) — SAM 模型也接受分割掩码作为输入。该掩码将由提示编码器嵌入以生成对应的嵌入，随后馈送给掩码解码器。这些掩码需要由用户手动提供，并且形状必须为 (batch_size, image_size, image_size)。
  • image_embeddings (torch.FloatTensor，形状为 (batch_size, output_channels, window_size, window_size)) — 图像嵌入，供掩码解码器用于生成掩码和 IoU 分数。为了提高内存效率，用户可以首先使用 get_image_embeddings 方法获取图像嵌入，然后将其馈送给 forward 方法，而不是直接馈送 pixel_values。
  • multimask_output (bool，可选) — 在原始实现和论文中，模型始终为每张图像（或相关情况下的每个点/每个边界框）输出 3 个掩码。然而，通过指定 multimask_output=False，可以仅输出对应“最佳”掩码的单一掩码。
  • attention_similarity (torch.FloatTensor，可选) — 注意力相似度张量，用于在模型被用于 PerSAM 中引入的个性化设置时，为掩码解码器提供目标引导的注意力。
  • target_embedding (torch.FloatTensor，可选) — 目标概念的嵌入，用于在模型被用于 PerSAM 中引入的个性化设置时，为掩码解码器提供目标语义提示。

返回

Sam2ImageSegmentationOutput 或 tuple(torch.FloatTensor)

一个 Sam2ImageSegmentationOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (Sam2Config) 和输入包含各种元素。

Sam2Model 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

  • iou_scores (torch.FloatTensor of shape (batch_size, point_batch_size, num_masks)) — 预测掩码的 Intersection over Union (IoU) 分数。
  • pred_masks (torch.FloatTensor of shape (batch_size, point_batch_size, num_masks, height, width)) — 预测的低分辨率掩码。这是 low_res_masks 的别名。这些掩码需要经过处理器后处理才能达到原始图像大小。
  • object_score_logits (torch.FloatTensor of shape (batch_size, point_batch_size, 1)) — 对象分数的 logits，指示是否存在对象。
  • image_embeddings (tuple(torch.FloatTensor)) — FPN 中的特征，用于掩码解码器。这是一个 torch.FloatTensor 元组，每个张量的形状为 (batch_size, channels, height, width)。
  • vision_hidden_states (tuple(torch.FloatTensor), optional, 当 output_hidden_states=True 返回时) — torch.FloatTensor 元组（每个阶段的输出一个），形状为 (batch_size, height, width, hidden_size)。视觉模型在每个阶段输出的隐藏状态。
  • vision_attentions (tuple(torch.FloatTensor), optional, 当 output_attentions=True 返回时) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。视觉模型的注意力权重。
  • mask_decoder_attentions (tuple(torch.FloatTensor), optional, 当 output_attentions=True 返回时) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。掩码解码器的注意力权重。

示例

>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor

>>> model = AutoModel.from_pretrained("danelcsb/sam2.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/sam2.1_hiera_tiny")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     raw_image = Image.open(BytesIO(response.read())).convert("RGB")
>>> input_points = [[[400, 650]]]  # 2D location of a window on the car
>>> inputs = processor(images=raw_image, input_points=input_points, return_tensors="pt")

>>> # Get segmentation mask
>>> outputs = model(**inputs)

>>> # Postprocess masks
>>> masks = processor.post_process_masks(
...     outputs.pred_masks, inputs["original_sizes"]
... )

get_image_features

< >

( pixel_values: FloatTensor **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → Sam2VisionEncoderOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor) — 形状为 (batch_size, num_channels, height, width) 的输入像素值。

返回

Sam2VisionEncoderOutput 或 tuple(torch.FloatTensor)

一个 Sam2VisionEncoderOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (Sam2Config) 和输入包含各种元素。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, height, width, 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, height, width, 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
  • fpn_hidden_states (tuple(torch.FloatTensor)) — torch.FloatTensor 元组（每个特征级别一个，从高分辨率到低分辨率），形状为 (batch_size, hidden_size, height, width)。来自特征金字塔网络颈部的特征图。
  • fpn_position_encoding (tuple(torch.FloatTensor)) — torch.FloatTensor 元组（每个特征级别一个，从高分辨率到低分辨率），形状为 (batch_size, hidden_size, height, width)。与 fpn_hidden_states 对应的位置编码。

示例

在 GitHub 上更新

←RT-DETRv2 Sam3Tracker→
© . This site is unofficial and not affiliated with Hugging Face, Inc.