# SAM2

    
        
        
    

## Обзор

SAM2 (Segment Anything Model 2) был предложен в статье [Segment Anything in Images and Videos](https://ai.meta.com/research/publications/sam-2-segment-anything-in-images-and-videos/) 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.

Модель может использоваться для предсказания масок сегментации любого объекта интереса по входному изображению или видео, а также входным точкам или ограничивающим рамкам.

![example image](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam2_header.gif)

Аннотация из статьи следующая:

*Мы представляем Segment Anything Model 2 (SAM 2) — фундаментальную модель для решения задачи интерактивной визуальной сегментации на изображениях и в видео. Мы создали движок данных, который совершенствует модель и данные за счёт взаимодействия с пользователем, и с его помощью собрали крупнейший на сегодняшний день датасет для сегментации видео. Наша модель построена на простой архитектуре трансформера с потоковой памятью для обработки видео в реальном времени. SAM 2, обученный на наших данных, демонстрирует высокую производительность на широком спектре задач. В задаче сегментации видео мы наблюдаем более высокую точность при использовании в 3 раза меньше взаимодействий, чем в предыдущих подходах. В задаче сегментации изображений наша модель точнее и в 6 раз быстрее, чем Segment Anything Model (SAM). Мы считаем, что наши данные, модель и полученные результаты станут значимой вехой для сегментации видео и связанных с ней задач восприятия. Мы публикуем версию нашей модели, датасет и интерактивную демонстрацию.*

Советы:

- Поддержка пакетной обработки и видео: SAM2 изначально поддерживает пакетную обработку и бесшовную сегментацию видео, тогда как исходная SAM разработана для статичных изображений и более простых сценариев работы с одним изображением за раз.
- Точность и обобщение: SAM2 демонстрирует улучшенное качество сегментации, устойчивость и способность к обобщению в режиме zero-shot на новые домены по сравнению с исходной моделью SAM, особенно при использовании смешанных промптов.

Эта модель была добавлена [sangbumchoi](https://github.com/SangbumChoi) и [yonigozlan](https://huggingface.co/yonigozlan). Исходный код можно найти [здесь](https://github.com/facebookresearch/sam2/tree/main).

## Пример использования

### Автоматическая генерация масок с помощью Pipeline

SAM2 можно использовать для автоматической генерации масок, чтобы сегментировать все объекты на изображении с помощью конвейера `mask-generation`:

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

### Базовая сегментация изображений

#### Одиночный щелчок

Вы можете сегментировать объекты, выполнив один клик по объекту, который нужно сегментировать:

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

#### Несколько точек для уточнения

Вы можете указать несколько точек для уточнения сегментации:

```python
# 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 также поддерживает входные данные в виде ограничивающих прямоугольников для сегментации:

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

#### Сегментация нескольких объектов

Вы можете сегментировать несколько объектов одновременно:

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

### Пакетный вывод

#### Пакетные изображения

Обрабатывайте несколько изображений одновременно для повышения эффективности:

```python
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/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/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
```

#### Пакетные объекты на изображение

Сегментируйте несколько объектов на каждом изображении с помощью пакетного вывода:

```python
# 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"])
```

#### Пакетные изображения с пакетными объектами и несколькими точками

Обработка сложных сценариев батчей с несколькими точками на объект:

```python
# 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"])
```

#### Пакетные ограничивающие рамки

Обработка нескольких изображений с входными данными в виде ограничивающих прямоугольников:

```python
# 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 может использовать маски из предыдущих предсказаний в качестве входных данных для уточнения сегментации:

```python
# 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[[transformers.Sam2Config]]

#### transformers.Sam2Config[[transformers.Sam2Config]]

```python
transformers.Sam2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L220)

**Параметры:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Объект конфигурации или словарь для визуального бэкбона.

prompt_encoder_config (Union[`dict`, `Sam2PromptEncoderConfig`], *optional*) : Словарь параметров конфигурации, используемых для инициализации [Sam2PromptEncoderConfig](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2PromptEncoderConfig).

mask_decoder_config (Union[`dict`, `Sam2MaskDecoderConfig`], *optional*) : Словарь параметров конфигурации, используемых для инициализации [Sam2MaskDecoderConfig](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2MaskDecoderConfig).

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

Это класс конфигурации для хранения настроек модели Sam2Model. Он используется для создания модели Sam2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

```python
>>> 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[[transformers.Sam2HieraDetConfig]]

#### transformers.Sam2HieraDetConfig[[transformers.Sam2HieraDetConfig]]

```python
transformers.Sam2HieraDetConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L25)

**Параметры:**

hidden_size (`int`, *optional*, по умолчанию `96`) : Размерность скрытых представлений.

num_attention_heads (`int`, *необязательный*, по умолчанию `1`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

num_channels (`int`, *необязательный*, по умолчанию `3`) : Количество входных каналов.

image_size (`Union[int, list[int]]`, *необязательный*) : Размер (разрешение) каждого изображения.

patch_kernel_size (`list[int]`, *optional*, по умолчанию `[7, 7]`) : Размер ядра патча.

patch_stride (`list[int]`, *необязательный*, по умолчанию `[4, 4]`) : Шаг (stride) патча.

patch_padding (`list[int]`, *необязательный*, по умолчанию `[3, 3]`) : Отступ (padding) патча.

query_stride (`list[int]`, *optional*, по умолчанию `[2, 2]`) : Шаг downsampling между стадиями.

window_positional_embedding_background_size (`list[int]`, *необязательный*, по умолчанию `[7, 7]`) : Размер окна на каждом этапе при отсутствии глобального внимания.

num_query_pool_stages (`int`, *необязательный*, по умолчанию 3) : Количество этапов пула запросов.

blocks_per_stage (`list[int]`, *необязательный*, по умолчанию `[1, 2, 7, 2]`) : Количество блоков на каждом этапе.

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](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## Sam2VisionConfig[[transformers.Sam2VisionConfig]]

#### transformers.Sam2VisionConfig[[transformers.Sam2VisionConfig]]

```python
transformers.Sam2VisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L103)

**Параметры:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *необязательный*) : Конфигурация базовой модели.

backbone_channel_list (`List[int]`, *необязательный*, по умолчанию `[768, 384, 192, 96]`) : Список размерностей каналов для базовой сети.

backbone_feature_sizes (`List[List[int]]`, *необязательный*, по умолчанию `[[256, 256], [128, 128], [64, 64]]`) : Пространственные размеры карт признаков, получаемых от backbone.

fpn_hidden_size (`int`, *optional*, по умолчанию 256) : Скрытое измерение FPN.

fpn_kernel_size (`int`, *optional*, по умолчанию 1) : Размер ядра для свёрток в neck.

fpn_stride (`int`, *optional*, по умолчанию 1) : Шаг для свёрток в neck.

fpn_padding (`int`, *optional*, по умолчанию 0) : Отступ для свёрток в neck.

fpn_top_down_levels (`List[int]`, *необязательный*, по умолчанию `[2, 3]`) : Уровни для сверху-вниз соединений FPN.

num_feature_levels (`int`, *optional*, по умолчанию 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](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## Sam2MaskDecoderConfig[[transformers.Sam2MaskDecoderConfig]]

#### transformers.Sam2MaskDecoderConfig[[transformers.Sam2MaskDecoderConfig]]

```python
transformers.Sam2MaskDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L181)

**Параметры:**

hidden_size (`int`, *optional*, по умолчанию `256`) : Размерность скрытых представлений.

hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

mlp_dim (`int`, *optional*, по умолчанию 2048) : Размерность MLP в двухстороннем трансформере.

num_hidden_layers (`int`, *необязательный*, по умолчанию `2`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `8`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

attention_downsample_rate (`int`, *optional*, по умолчанию 2) : Коэффициент downsampling для слоев внимания.

num_multimask_outputs (`int`, *необязательный*, по умолчанию 3) : Количество выходов multimask.

iou_head_depth (`int`, *optional*, по умолчанию 3) : Глубина IoU-головы.

iou_head_hidden_dim (`int`, *optional*, по умолчанию 256) : Скрытое измерение головы IoU.

dynamic_multimask_via_stability (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли динамическую мультимаску через стабильность.

dynamic_multimask_stability_delta (`float`, *необязательный*, по умолчанию 0.05) : Дельта стабильности для динамической мультимаски.

dynamic_multimask_stability_thresh (`float`, *optional*, по умолчанию 0.98) : Порог стабильности для динамической мультимаски.

Это класс конфигурации для хранения настроек модели Sam2Model. Он используется для создания модели Sam2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## Sam2PromptEncoderConfig[[transformers.Sam2PromptEncoderConfig]]

#### transformers.Sam2PromptEncoderConfig[[transformers.Sam2PromptEncoderConfig]]

```python
transformers.Sam2PromptEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/configuration_sam2.py#L156)

**Параметры:**

hidden_size (`int`, *optional*, по умолчанию `256`) : Размерность скрытых представлений.

image_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `1024`) : Размер (разрешение) каждого изображения.

patch_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `16`) : Размер (разрешение) каждого патча.

mask_input_channels (`int`, *необязательный*, по умолчанию 16) : Количество каналов, передаваемых в модуль `MaskDecoder`.

num_point_embeddings (`int`, *optional*, по умолчанию 4) : Количество используемых встраиваний точек.

hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-06`) : Значение epsilon, используемое слоями нормализации.

scale (`float`, *необязательный*, по умолчанию 1) : Коэффициент масштабирования для кодировщика промпта.

Это класс конфигурации для хранения настроек модели Sam2Model. Он используется для создания модели Sam2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## Sam2Processor[[transformers.Sam2Processor]]

#### transformers.Sam2Processor[[transformers.Sam2Processor]]

```python
transformers.Sam2Processor(image_processor, target_size: int | None = None, point_pad_value: int = -10, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/processing_sam2.py#L37)

**Параметры:**

image_processor (`Sam2ImageProcessor`) : процессор изображений является обязательным входным параметром.

target_size (`int`, *optional*) : Целевой размер (в пикселях) для нормализации входных точек и ограничивающих прямоугольников. Если не указан, по умолчанию используется конфигурация размера процессора изображений. Все входные координаты (точки и прямоугольники) нормализуются до этого размера перед передачей в модель. Это обеспечивает согласованное представление координат независимо от исходных размеров изображения.

point_pad_value (`int`, *optional*, по умолчанию -10) : Значение, используемое для дополнения входных точек при пакетной обработке последовательностей разной длины. Это значение используется для пометки дополненных позиций и сохраняется при нормализации координат.

Создаёт Sam2Processor, который объединяет процессор изображений в единый процессор.

[Sam2Processor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2Processor) предоставляет все возможности [Sam2ImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2ImageProcessor). Подробнее см. в [~Sam2ImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2ImageProcessor).

#### __call__[[transformers.Sam2Processor.__call__]]

```python
__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: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = None, input_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, original_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/processing_sam2.py#L53)

**Параметры:**

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'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

**Возвращает:** [BatchEncoding](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.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[[transformers.Sam2Processor.post_process_masks]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/processing_sam2.py#L459)

**Параметры:**

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]]]`) : исходные размеры каждого изображения до его изменения до ожидаемой входной формы модели, в формате (высота, ширина).

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.

Удалите заполнение (padding) и масштабируйте маски до исходного размера изображения.

## Sam2ImageProcessor[[transformers.Sam2ImageProcessor]]

#### transformers.Sam2ImageProcessor[[transformers.Sam2ImageProcessor]]

```python
transformers.Sam2ImageProcessor(**kwargs: *<class 'transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/image_processing_sam2.py#L369)

**Параметры:**

do_convert_rgb (`bool`, *kwargs*, *необязательный*, по умолчанию `True`) : Преобразовать ли изображение в RGB.

do_resize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли изменять размер изображения.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'height' : 1024, 'width': 1024}`): Описывает максимальные размеры входных данных для модели.

default_to_square (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Использовать ли квадратное изображение по умолчанию при изменении размера, если size является int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, по умолчанию `2`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только если `do_resize` установлено в `True`.

do_rescale (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *kwargs*, *optional*, по умолчанию `0.00392156862745098`) : Коэффициент масштабирования для изменения масштаба изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.485, 0.456, 0.406]`) : Средние значения изображения, используемые для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.229, 0.224, 0.225]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_pad (`bool`, *kwargs*, *optional*, по умолчанию `None`) : Нужно ли добавлять отступы к изображению. Отступы добавляются либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Точная стратегия добавления отступов зависит от модели.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `None`) : Размер в формате `{"height": int, "width" int}`, до которого следует дополнить изображения. Должен быть больше любого размера изображения, переданного для предобработки. Если `pad_size` не указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только при `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Возвращает стопку тензоров, если установлено значение `'pt'`, иначе возвращает список тензоров.

disable_grouping (`bool`, *kwargs*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора.

mask_size (`dict[str, *kwargs*, int]`, *необязательный*) : Размер `{"height": int, "width": int}`, к которому следует изменить размер карт сегментации.

Создаёт процессор изображений Sam2ImageProcessor.

#### preprocess[[transformers.Sam2ImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/image_processing_sam2.py#L389)

**Параметры:**

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`, *необязательный*) : карты сегментации для предварительной обработки.

do_convert_rgb (`bool`, *kwargs*, *необязательный*) : Преобразовать ли изображение в RGB.

do_resize (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли изменить размер изображения.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Описывает максимальные размеры входных данных для модели.

default_to_square (`bool`, *kwargs*, *необязательный*) : Указывает, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задан как int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только при установке `do_resize` в `True`.

do_rescale (`bool`, *kwargs*, *необязательный*) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *kwargs*, *optional*) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *необязательный*) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Среднее значение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер в формате `{"height": int, "width" int}`, до которого следует дополнить изображения. Должен быть больше любого размера изображения, переданного для предобработки. Если `pad_size` не указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только при `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Возвращает стопку тензоров, если установлено значение `'pt'`, иначе возвращает список тензоров.

disable_grouping (`bool`, *kwargs*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора.

mask_size (`dict[str, *kwargs*, int]`, *необязательный*) : Размер `{"height": int, "width": int}`, к которому следует изменить размер карт сегментации.

**Возвращает:** `~image_processing_base.BatchFeature`

- **data** (`dict`) — Словарь списков/массивов/тензоров, возвращаемый методом __call__ ('pixel_values' и т. д.).
- **tensor_type** (`Union[None, str, TensorType]`, *необязательный*) -- Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.

## Sam2HieraDetModel[[transformers.Sam2HieraDetModel]]

#### transformers.Sam2HieraDetModel[[transformers.Sam2HieraDetModel]]

```python
transformers.Sam2HieraDetModel(config: Sam2HieraDetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L603)

#### forward[[transformers.Sam2HieraDetModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L646)

## Sam2VisionModel[[transformers.Sam2VisionModel]]

#### transformers.Sam2VisionModel[[transformers.Sam2VisionModel]]

```python
transformers.Sam2VisionModel(config: Sam2VisionConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L677)

**Параметры:**

config ([Sam2VisionConfig](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2VisionConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель зрения от Sam без какой-либо головы или проекции сверху.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.Sam2VisionModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L699)

## Sam2Model[[transformers.Sam2Model]]

#### transformers.Sam2Model[[transformers.Sam2Model]]

```python
transformers.Sam2Model(config: Sam2Config)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L1314)

**Параметры:**

config ([Sam2Config](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2Config)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Segment Anything Model 2 (SAM 2) для генерации сегментационных масок по входному изображению и входным точкам и меткам, рамкам или маскам.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.Sam2Model.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, input_points: typing.Optional[torch.Tensor] = None, input_labels: typing.Optional[torch.LongTensor] = None, input_boxes: typing.Optional[torch.Tensor] = None, input_masks: typing.Optional[torch.LongTensor] = None, image_embeddings: typing.Optional[torch.Tensor] = None, multimask_output: bool = True, attention_similarity: typing.Optional[torch.Tensor] = None, target_embedding: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L1413)

**Параметры:**

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [Sam2ImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2ImageProcessor). Подробности см. в [Sam2ImageProcessor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) ([Sam2Processor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2Processor) использует [Sam2ImageProcessor](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2ImageProcessor) для обработки изображений).

input_points (`torch.Tensor` формы `(batch_size, num_points, 2)`) : Входные 2D пространственные точки, которые используются кодировщиком промпта для кодирования промпта. Как правило, это даёт значительно лучшие результаты. Точки можно получить, передав в процессор список списков списков, который создаст соответствующие тензоры `torch` размерности 4. Первая размерность — размер батча изображений, вторая — размер батча точек (то есть сколько сегментационных масок модель должна предсказать на каждую входную точку), третья — количество точек на сегментационную маску (можно передать несколько точек для одной маски), а последняя — координаты x (вертикальная) и y (горизонтальная) точки. Если для каждого изображения или для каждой маски передано разное количество точек, процессор создаст точки «PAD», соответствующие координате (0, 0), и вычисление эмбеддинга для этих точек будет пропущено с помощью меток.

input_labels (`torch.LongTensor` формы `(batch_size, point_batch_size, num_points)`) : Входные метки для точек, используются кодировщиком промпта для кодирования промпта. Согласно официальному реализованию, существует 3 типа меток  - `1`: точка содержит объект интереса - `0`: точка не содержит объект интереса - `-1`: точка соответствует фону  Мы добавили метку:  - `-10`: точка является заполнителем (padding), поэтому должна игнорироваться кодировщиком промпта  Метки заполнения должны назначаться автоматически процессором.

input_boxes (`torch.Tensor` формы `(batch_size, num_boxes, 4)`) : Входные рамки для точек, используются кодировщиком подсказок для кодирования подсказки. Как правило, это приводит к значительно более качественным сгенерированным маскам. Рамки можно получить, передав в процессор список списков списков, который сгенерирует тензор `torch`, где каждое измерение соответствует соответственно размеру батча изображений, количеству рамок на изображение и координатам верхней левой и нижней правой точек рамки. В порядке (`x1`, `y1`, `x2`, `y2`):  - `x1`: координата x верхней левой точки входной рамки - `y1`: координата y верхней левой точки входной рамки - `x2`: координата x нижней правой точки входной рамки - `y2`: координата y нижней правой точки входной рамки

input_masks (`torch.Tensor` формы `(batch_size, image_size, image_size)`) : Модель SAM также принимает в качестве входных данных маски сегментации. Маска будет встроена с помощью кодировщика подсказок для генерации соответствующего встраивания, которое затем будет передано декодеру масок. Эти маски необходимо вручную передавать пользователем, и они должны иметь форму (`batch_size`, `image_size`, `image_size`).

image_embeddings (`torch.Tensor` формы `(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.Tensor`, *необязательный*) : тензор сходства внимания, который передается декодеру маски для целевого управления вниманием в случае, если модель используется для персонализации, как описано в [PerSAM](https://huggingface.co/papers/2305.03048).

target_embedding (`torch.Tensor`, *необязательный*) : Вложение целевого концепта, которое передается декодеру маски для семантического промптинга цели, если модель используется для персонализации, как описано в [PerSAM](https://huggingface.co/papers/2305.03048).

**Возвращает:** `Sam2ImageSegmentationOutput` или `tuple(torch.Tensor)`

Объект `Sam2ImageSegmentationOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Sam2Config](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2Config)) и входных данных.

Метод forward класса [Sam2Model](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2Model) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **iou_scores** (`torch.Tensor` формы `(batch_size, point_batch_size, num_masks)`) -- Оценки пересечения по объединению (IoU) для предсказанных масок.
- **pred_masks** (`torch.Tensor` формы `(batch_size, point_batch_size, num_masks, height, width)`) -- Предсказанные маски низкого разрешения. Это псевдоним для `low_res_masks`. Эти маски необходимо обработать с помощью процессора, чтобы привести их к исходному размеру изображения.
- **object_score_logits** (`torch.Tensor` формы `(batch_size, point_batch_size, 1)`) -- Логиты для оценки объекта, указывающие на наличие объекта.
- **image_embeddings** (`tuple(torch.Tensor)`) -- Признаки из FPN, используемые декодером масок. Это кортеж `torch.Tensor`, где каждый тензор имеет форму `(batch_size, channels, height, width)`.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_hidden_states=True`) -- Кортеж `torch.Tensor` (по одному на выход каждого этапа) формы `(batch_size, height, width, hidden_size)`. Скрытые состояния модели зрения на выходе каждого этапа.
- **vision_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания модели зрения.
- **mask_decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания декодера маски.

Пример:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils 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[[transformers.Sam2Model.get_image_features]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2/modeling_sam2.py#L1589)

**Параметры:**

pixel_values (`torch.Tensor`) : Входные значения пикселей формы `(batch_size, num_channels, height, width)`.

**Возвращает:** `Sam2VisionEncoderOutput` или `tuple(torch.Tensor)`

Объект `Sam2VisionEncoderOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Sam2Config](/docs/transformers/v5.23.0/ru/model_doc/sam2#transformers.Sam2Config)) и входных данных.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, height, width, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) — Кортеж `torch.Tensor` (по одному для каждого уровня признаков, от высокого разрешения к низкому) формы `(batch_size, hidden_size, height, width)`. Карты признаков из шейки Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) — Кортеж `torch.Tensor` (по одному для каждого уровня признаков, от высокого разрешения к низкому) формы `(batch_size, hidden_size, height, width)`. Позиционные кодировки, соответствующие `fpn_hidden_states`.

Пример:

```python
```

