# SAM3

    
        
        
    

## Обзор

SAM3 (Segment Anything Model 3) был представлен в [SAM 3: Segment Anything with Concepts](https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/).

SAM3 выполняет **сегментацию концептов по запросу (PCS)** на изображениях. PCS принимает в качестве входных данных текст и/или примеры изображений (например, «жёлтый школьный автобус») и предсказывает маски инстансов и семантические маски для **каждого объекта**, соответствующего концепту.

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

*Мы представляем Segment Anything Model (SAM) 3 — унифицированную модель, которая обнаруживает, сегментирует и отслеживает объекты на изображениях и в видео на основе концептуальных промптов, которые мы определяем как короткие именные фразы (например, «жёлтый школьный автобус»), образцы-примеры или комбинацию обоих. Promptable Concept Segmentation (PCS) принимает такие промпты и возвращает маски сегментации и уникальные идентификаторы для всех соответствующих экземпляров объектов. Для развития PCS мы создали масштабируемый движок данных, который формирует высококачественный датасет с 4 млн уникальных концептуальных меток, включая сложные негативные примеры, на изображениях и в видео. Наша модель состоит из детектора на уровне изображения и видео-трекера на основе памяти, которые используют общий бэкбон. Распознавание и локализация разделены с помощью presence head, что повышает точность обнаружения. SAM 3 удваивает точность существующих систем как в PCS для изображений, так и для видео, а также улучшает возможности предыдущих версий SAM в задачах визуальной сегментации. Мы открыли исходный код SAM 3 вместе с нашим новым бенчмарком Segment Anything with Concepts (SA-Co) для promptable concept segmentation.*

Эта модель была предоставлена [yonigozlan](https://huggingface.co/yonigozlan) и [ronghanghu](https://huggingface.co/ronghanghu).

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

### Промпты только с текстом

```python
import requests
import torch
from PIL import Image

from transformers import Sam3Model, Sam3Processor

model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3")

# Load image
image_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

# Segment using text prompt
inputs = processor(images=image, text="ear", return_tensors="pt").to(model.device)

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

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]

print(f"Found {len(results['masks'])} objects")
# Results contain:
# - masks: Binary masks resized to original image size
# - boxes: Bounding boxes in absolute pixel coordinates (xyxy format)
# - scores: Confidence scores
```

### Одиночный промпт ограничивающего прямоугольника

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

```python
# Box in xyxy format: [x1, y1, x2, y2] in pixel coordinates
# Example: laptop region
box_xyxy = [100, 150, 500, 450]
input_boxes = [[box_xyxy]]  # [batch, num_boxes, 4]
input_boxes_labels = [[1]]  # 1 = positive box

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

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

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]
```

### Несколько box-промптов (положительные и отрицательные)

Используйте несколько рамок с положительными и отрицательными метками, чтобы уточнить концепцию:

```python
# Load kitchen image
kitchen_url = "http://images.cocodataset.org/val2017/000000136466.jpg"
kitchen_image = Image.open(requests.get(kitchen_url, stream=True).raw).convert("RGB")

# Define two positive boxes (e.g., dial and button on oven)
# Boxes are in xyxy format [x1, y1, x2, y2] in pixel coordinates
box1_xyxy = [59, 144, 76, 163]  # Dial box
box2_xyxy = [87, 148, 104, 159]  # Button box
input_boxes = [[box1_xyxy, box2_xyxy]]
input_boxes_labels = [[1, 1]]  # Both positive

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

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

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]
```

### Составные промпты (текст + отрицательное поле)

Используйте текстовые промпты вместе с негативными визуальными промптами для уточнения концепции:

```python
# Segment "handle" but exclude the oven handle using a negative box
text = "handle"
# Negative box covering oven handle area (xyxy): [40, 183, 318, 204]
oven_handle_box = [40, 183, 318, 204]
input_boxes = [[oven_handle_box]]

inputs = processor(
    images=kitchen_image,
    text=text,
    input_boxes=input_boxes,
    input_boxes_labels=[[0]],  # 0 = negative (exclude this region)
    return_tensors="pt"
).to(model.device)

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

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]
# This will segment pot handles but exclude the oven handle
```

### Пакетный вывод с текстовыми запросами

Эффективная обработка нескольких изображений с различными текстовыми подсказками:

```python
cat_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
kitchen_url = "http://images.cocodataset.org/val2017/000000136466.jpg"
images = [
    Image.open(requests.get(cat_url, stream=True).raw).convert("RGB"),
    Image.open(requests.get(kitchen_url, stream=True).raw).convert("RGB")
]

# Different text prompt for each image
text_prompts = ["ear", "dial"]

inputs = processor(images=images, text=text_prompts, return_tensors="pt").to(model.device)

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

# Post-process results for both images
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)

print(f"Image 1: {len(results[0]['masks'])} objects found")
print(f"Image 2: {len(results[1]['masks'])} objects found")
```

### Пакетные смешанные промпты

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

```python
# Image 1: text prompt "laptop"
# Image 2: visual prompt (dial box)
box2_xyxy = [59, 144, 76, 163]

inputs = processor(
    images=images,
    text=["laptop", None],  # Only first image has text
    input_boxes=[None, [box2_xyxy]],  # Only second image has box
    input_boxes_labels=[None, [1]],  # Positive box for second image
    return_tensors="pt"
).to(model.device)

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

# Post-process results for both images
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)
# Both images processed in single forward pass
```

### Результат семантической сегментации

SAM3 также обеспечивает семантическую сегментацию наряду с масками экземпляров:

```python
inputs = processor(images=image, text="ear", return_tensors="pt").to(model.device)

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

# Instance segmentation masks
instance_masks = torch.sigmoid(outputs.pred_masks)  # [batch, num_queries, H, W]

# Semantic segmentation (single channel)
semantic_seg = outputs.semantic_seg  # [batch, 1, H, W]

print(f"Instance masks: {instance_masks.shape}")
print(f"Semantic segmentation: {semantic_seg.shape}")
```

### Эффективный вывод для нескольких подсказок на одном изображении

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

```python
from transformers import Sam3Processor, Sam3Model
import torch
from PIL import Image
import requests

model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3")

# Load image
image_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

# Pre-process image and compute vision embeddings once
img_inputs = processor(images=image, return_tensors="pt").to(model.device)
with torch.no_grad():
    vision_embeds = model.get_vision_features(pixel_values=img_inputs.pixel_values)

# Run multiple text prompts efficiently
text_prompts = ["ear", "eye", "nose"]
all_results = []

for prompt in text_prompts:
    text_inputs = processor(text=prompt, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(vision_embeds=vision_embeds, **text_inputs)
...
    results = processor.post_process_instance_segmentation(
        outputs,
        threshold=0.5,
        mask_threshold=0.5,
        target_sizes=img_inputs.get("original_sizes").tolist()
    )[0]
    all_results.append({"prompt": prompt, "results": results})

for item in all_results:
    print(f"Prompt '{item['prompt']}': {len(item['results']['masks'])} objects found")
```

### Эффективный вывод по одному промпту для нескольких изображений

При обработке одного и того же текстового запроса для нескольких изображений предварительно вычислите текстовые эмбеддинги, чтобы избежать избыточных вычислений:

```python
from transformers import Sam3Processor, Sam3Model
import torch
from PIL import Image
import requests

model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3")

# Pre-compute text embeddings once
text_prompt = "ear"
text_inputs = processor(text=text_prompt, return_tensors="pt").to(model.device)
with torch.no_grad():
    text_embeds = model.get_text_features(**text_inputs)

# Load multiple images
image_urls = [
    "http://images.cocodataset.org/val2017/000000077595.jpg",
    "http://images.cocodataset.org/val2017/000000039769.jpg",
]
images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]

# Run inference on each image reusing text embeddings
# Note: attention_mask must be passed along with text_embeds for proper masking
all_results = []

for image in images:
    img_inputs = processor(images=image, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(
            pixel_values=img_inputs.pixel_values,
            text_embeds=text_embeds,
            attention_mask=text_inputs.attention_mask,
        )
...
    results = processor.post_process_instance_segmentation(
        outputs,
        threshold=0.5,
        mask_threshold=0.5,
        target_sizes=img_inputs.get("original_sizes").tolist()
    )[0]
    all_results.append(results)

for i, results in enumerate(all_results):
    print(f"Image {i+1}: {len(results['masks'])} '{text_prompt}' objects found")
```

### Вывод с настраиваемым разрешением

⚠️ **Примечание о производительности**: Использование нестандартных разрешений может снизить точность. Модель предназначена для работы с разрешением 1008px.

Для более быстрого вывода или меньшего потребления памяти:

```python
config = Sam3Config.from_pretrained("facebook/sam3")
config.image_size = 560
model = Sam3Model.from_pretrained("facebook/sam3", config=config, device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3", size={"height": 560, "width": 560})
```

### Соглашения о метках в промптах

SAM3 использует следующие соглашения по разметке:

**Для точек и прямоугольников:**

- `1`: Позитивный промпт (включить этот регион/объект)
- `0`: Отрицательный промпт (исключить этот регион/объект)
- `-10`: значение для выравнивания пакетных входных данных

**Форматы координат:**

- **Поля ввода**: `[x1, y1, x2, y2]` (формат xyxy) в пиксельных координатах
- **Коробки вывода** (сырые): `[x1, y1, x2, y2]` (формат xyxy), нормализованные к [0, 1]
- **Коробки вывода** (после обработки): `[x1, y1, x2, y2]` (формат xyxy) в абсолютных пиксельных координатах

## Sam3Config[[transformers.Sam3Config]]

#### transformers.Sam3Config[[transformers.Sam3Config]]

```python
transformers.Sam3Config(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, geometry_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, detr_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, detr_decoder_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/main/src/transformers/models/sam3/configuration_sam3.py#L197)

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

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

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

geometry_encoder_config (`dict` или `Sam3GeometryEncoderConfig`, *необязательный*) : Конфигурация для геометрического энкодера.

detr_encoder_config (`dict` или `Sam3DETREncoderConfig`, *необязательный*) : Конфигурация для кодировщика DETR.

detr_decoder_config (`dict` или `Sam3DETRDecoderConfig`, *необязательный*) : Конфигурация декодера DETR.

mask_decoder_config (`dict` или `Sam3MaskDecoderConfig`, *необязательный*) : Конфигурация декодера масок.

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

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

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

Пример:
```python
>>> from transformers import Sam3Config, Sam3Model

>>> # Initializing a SAM3 configuration
>>> configuration = Sam3Config()

>>> # Initializing a model from the configuration
>>> model = Sam3Model(configuration)

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

## Sam3ViTConfig[[transformers.Sam3ViTConfig]]

#### transformers.Sam3ViTConfig[[transformers.Sam3ViTConfig]]

```python
transformers.Sam3ViTConfig(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 = 1024, intermediate_size: int = 4736, num_hidden_layers: int = 32, num_attention_heads: int = 16, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 1008, patch_size: int | list[int] | tuple[int, int] = 14, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, window_size: int = 24, global_attn_indexes: list[int] | None = None, layer_scale_init_value: float | None = None, pretrain_image_size: int | list[int] | tuple[int, int] = 336, hidden_dropout: float | int = 0.0, initializer_range: float = 0.02, rope_parameters: dict | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L25)

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

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

intermediate_size (`int`, *необязательный*, по умолчанию `4736`) : Размерность представлений MLP.

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

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

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

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

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

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

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

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания.

window_size (`int`, *optional*, по умолчанию 24) : Размер окна для оконного внимания.

global_attn_indexes (`list[int]`, *необязательный*, по умолчанию `[7, 15, 23, 31]`) : Индексы слоев с глобальным вниманием.

layer_scale_init_value (`float`, *optional*) : Масштаб, используемый в слоях само-внимания. 0.1 для базовых моделей, 1e-6 для крупных. Установите 0, чтобы отключить масштабирование слоя.

pretrain_image_size (`int`, *optional*, по умолчанию 336) : Размер изображения предобученной модели для инициализации позиционного эмбеддинга.

hidden_dropout (`float`, *необязательный*, по умолчанию 0.0) : Вероятность dropout для скрытых состояний.

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

rope_parameters (`dict`, *необязательный*) : Словарь, содержащий параметры конфигурации для вложений RoPE. Словарь должен содержать значение для `rope_theta` и, при необходимости, параметры, используемые для масштабирования, если вы хотите использовать RoPE с более длинными `max_position_embeddings`.

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

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

## Sam3VisionConfig[[transformers.Sam3VisionConfig]]

#### transformers.Sam3VisionConfig[[transformers.Sam3VisionConfig]]

```python
transformers.Sam3VisionConfig(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, fpn_hidden_size: int = 256, backbone_feature_sizes: list | None = None, scale_factors: list[float] | None = None, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, initializer_range: float = 0.02)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L68)

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

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

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

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

scale_factors (`list[float]`, *необязательный*, по умолчанию `[4.0, 2.0, 1.0, 0.5]`) : Коэффициенты масштабирования для многомасштабных признаков FPN. Список коэффициентов масштабирования для каждого уровня FPN.

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

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

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

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

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

## Sam3GeometryEncoderConfig[[transformers.Sam3GeometryEncoderConfig]]

#### transformers.Sam3GeometryEncoderConfig[[transformers.Sam3GeometryEncoderConfig]]

```python
transformers.Sam3GeometryEncoderConfig(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, num_layers: int = 3, num_attention_heads: int = 8, intermediate_size: int = 2048, dropout: float | int = 0.1, hidden_act: str = 'relu', hidden_dropout: float | int = 0.0, layer_norm_eps: float = 1e-06, roi_size: int = 7, initializer_range: float = 0.02)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L112)

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

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

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

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

intermediate_size (`int`, *необязательный*, по умолчанию `2048`) : Размерность представлений MLP.

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

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

hidden_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пулере.

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

roi_size (`int`, *optional*, по умолчанию 7) : размер ROI для операций box pooling.

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

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

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

## Sam3DETREncoderConfig[[transformers.Sam3DETREncoderConfig]]

#### transformers.Sam3DETREncoderConfig[[transformers.Sam3DETREncoderConfig]]

```python
transformers.Sam3DETREncoderConfig(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, num_layers: int = 6, num_attention_heads: int = 8, intermediate_size: int = 2048, dropout: float | int = 0.1, hidden_act: str = 'relu', hidden_dropout: float | int = 0.0, layer_norm_eps: float = 1e-06, initializer_range: float = 0.02)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L134)

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

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

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

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

intermediate_size (`int`, *необязательный*, по умолчанию `2048`) : Размерность представлений MLP.

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

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

hidden_dropout (`float`, *необязательный*, по умолчанию 0.0) : Вероятность dropout для скрытых состояний.

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

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

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

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

## Sam3DETRDecoderConfig[[transformers.Sam3DETRDecoderConfig]]

#### transformers.Sam3DETRDecoderConfig[[transformers.Sam3DETRDecoderConfig]]

```python
transformers.Sam3DETRDecoderConfig(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, num_layers: int = 6, num_queries: int = 200, num_attention_heads: int = 8, intermediate_size: int = 2048, dropout: float | int = 0.1, hidden_act: str = 'relu', hidden_dropout: float | int = 0.0, layer_norm_eps: float = 1e-06, initializer_range: float = 0.02)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L156)

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

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

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

num_queries (`int`, *optional*, по умолчанию 200) : Количество запросов объектов.

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

intermediate_size (`int`, *необязательный*, по умолчанию `2048`) : Размерность представлений MLP.

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

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

hidden_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пулере.

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

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

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

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

## Sam3MaskDecoderConfig[[transformers.Sam3MaskDecoderConfig]]

#### transformers.Sam3MaskDecoderConfig[[transformers.Sam3MaskDecoderConfig]]

```python
transformers.Sam3MaskDecoderConfig(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, num_upsampling_stages: int = 3, layer_norm_eps: float = 1e-06, dropout: float | int = 0.0, num_attention_heads: int = 8, initializer_range: float = 0.02)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L179)

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

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

num_upsampling_stages (`int`, *optional*, по умолчанию 3) : Количество стадий апсемплинга в пиксельном декодере (FPN).

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

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент для всех слоёв dropout.

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

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

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

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

## Sam3Processor[[transformers.Sam3Processor]]

#### transformers.Sam3Processor[[transformers.Sam3Processor]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/processing_sam3.py#L87)

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

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

tokenizer (`CLIPTokenizer`) : Токенизатор является обязательным входным параметром.

target_size (`int`, *optional*) : Целевой размер (target_size, target_size), к которому будет изменён размер изображения.

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

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

[Sam3Processor](/docs/transformers/main/ru/model_doc/sam3#transformers.Sam3Processor) предоставляет все возможности [Sam3ImageProcessor](/docs/transformers/main/ru/model_doc/sam3#transformers.Sam3ImageProcessor) и [CLIPTokenizer](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPTokenizer). Подробнее см. в [~Sam3ImageProcessor](/docs/transformers/main/ru/model_doc/sam3#transformers.Sam3ImageProcessor) и [~CLIPTokenizer](/docs/transformers/main/ru/model_doc/clip#transformers.CLIPTokenizer).

#### __call__[[transformers.Sam3Processor.__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, text: str | list[str] | list[list[str]] | None = 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_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, input_boxes_labels: typing.Union[list[list[list[int]]], 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/main/src/transformers/models/sam3/processing_sam3.py#L101)

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

images (`ImageInput`, *необязательный*) : Изображение(я) для обработки.

text (`str`, `list[str]`, `list[list[str]]`, *необязательный*) : Текст для обработки.

segmentation_maps (`ImageInput`, *необязательный*) : карты сегментации для обработки.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *необязательный*) : Границы обрабатываемых объектов.

input_boxes_labels (`list[list[int]]`, `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/main/ru/main_classes/tokenizer#transformers.BatchEncoding) со следующими полями

- `pixel_values` (`torch.Tensor`): Обработанное изображение или изображения.
- `original_sizes` (`list[list[float]]`): исходные размеры изображений.
- `labels` (`torch.Tensor`): Обработанные карты сегментации (если предоставлены).
- `input_boxes_labels` (`torch.Tensor`): Обработанные метки для ограничивающих прямоугольников.
- `input_boxes` (`torch.Tensor`): Обработанные ограничивающие рамки.

## Sam3ImageProcessor[[transformers.Sam3ImageProcessor]]

#### transformers.Sam3ImageProcessor[[transformers.Sam3ImageProcessor]]

```python
transformers.Sam3ImageProcessor(**kwargs: *<class 'transformers.models.sam3.image_processing_sam3.Sam3ImageProcessorKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/image_processing_sam3.py#L400)

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

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' : 1008, 'width': 1008}`): Описывает максимальные размеры входных данных для модели.

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.5, 0.5, 0.5]`) : Средние значения изображения для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.5, 0.5, 0.5]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `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}`, к которому следует изменить размер карт сегментации.

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

#### preprocess[[transformers.Sam3ImageProcessor.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.sam3.image_processing_sam3.Sam3ImageProcessorKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/image_processing_sam3.py#L420)

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

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.

## Sam3ViTModel[[transformers.Sam3ViTModel]]

#### transformers.Sam3ViTModel[[transformers.Sam3ViTModel]]

```python
transformers.Sam3ViTModel(config: Sam3ViTConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L828)

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

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

Модель Sam3 без дополнительных слоёв, выводящая необработанные скрытые состояния.

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

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

#### forward[[transformers.Sam3ViTModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L851)

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

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

**Возвращает:** [BaseModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([Sam3Config](/docs/transformers/main/ru/model_doc/sam3#transformers.Sam3Config)) и входных данных.

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

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## Sam3VisionModel[[transformers.Sam3VisionModel]]

#### transformers.Sam3VisionModel[[transformers.Sam3VisionModel]]

```python
transformers.Sam3VisionModel(config: Sam3VisionConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L1088)

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

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

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

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

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

#### forward[[transformers.Sam3VisionModel.forward]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L1103)

## Sam3Model[[transformers.Sam3Model]]

#### transformers.Sam3Model[[transformers.Sam3Model]]

```python
transformers.Sam3Model(config: Sam3Config)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L2187)

#### forward[[transformers.Sam3Model.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, vision_embeds: transformers.models.sam3.modeling_sam3.Sam3VisionEncoderOutput | None = None, input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, text_embeds: typing.Optional[torch.Tensor] = None, input_boxes: typing.Optional[torch.Tensor] = None, input_boxes_labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L2300)

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

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

vision_embeds (`Sam3VisionEncoderOutput`, *необязательный*) : Предварительно вычисленные визуальные эмбеддинги. Можно использовать для простого повторного применения визуальных эмбеддингов. Если передано, `pixel_values` не должно передаваться. Взаимоисключается с `pixel_values`.

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

text_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Предварительно вычисленные текстовые эмбеддинги. Можно использовать для простого повторного применения текстовых эмбеддингов. Если передано, `input_ids` не следует передавать. Взаимоисключается с `input_ids`.

input_boxes (`torch.Tensor` формы `(batch_size, num_boxes, 4)`, *необязательный*) : Нормализованные координаты границ в диапазоне [0, 1], в формате (cx, cy, w, h).

input_boxes_labels (`torch.LongTensor` формы `(batch_size, num_boxes)`, *необязательный*) : Метки для ящиков: 1 (положительный), 0 (отрицательный).

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

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

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

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

- **pred_masks** (`torch.Tensor` формы `(batch_size, num_queries, height, width)`) -- Предсказанные маски сегментации для каждого запроса.
- **pred_boxes** (`torch.Tensor` формы `(batch_size, num_queries, 4)`) -- Предсказанные ограничивающие рамки в формате (x1, y1, x2, y2).
- **pred_logits** (`torch.Tensor` формы `(batch_size, num_queries)`, *необязательный*) -- Оценки уверенности классификации для каждого запроса, вычисленные по скалярному произведению признаков запросов декодера и текстовых признаков.
- **presence_logits** (`torch.Tensor` формы `(batch_size, 1)`, *необязательный*) -- Presence logits из presence-токена декодера DETR (только последний слой). Они указывают на наличие объектов в сцене. Можно использовать для вычисления финальных оценок, умножив на pred_logits: `final_scores = pred_logits.sigmoid() * presence_logits.sigmoid()`.
- **semantic_seg** (`torch.Tensor` формы `(batch_size, 1, height, width)`, *необязательный*) -- Выход семантической сегментации.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *необязательный*) -- Кортеж скрытых состояний из всех слоёв декодера DETR. Каждая тензор имеет форму `(batch_size, num_queries, hidden_size)`.
- **decoder_reference_boxes** (`torch.Tensor` формы `(num_layers, batch_size, num_queries, 4)`, *необязательный*) -- Справочные рамки из всех слоёв декодера DETR.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *необязательный*) -- Кортеж скрытых состояний из всех слоев кодировщика DETR.
- **vision_hidden_states** (`tuple[torch.Tensor]`, *необязательный*) -- Кортеж скрытых состояний из всех слоев визуального кодировщика (ViT).
- **vision_attentions** (`tuple[torch.Tensor]`, *optional*) -- Веса внимания из слоев визуального кодировщика (ViT).
- **detr_encoder_attentions** (`tuple[torch.Tensor]`, *optional*) -- Веса внимания из слоев кодировщика DETR.
- **detr_decoder_attentions** (`tuple[torch.Tensor]`, *optional*) -- Веса внимания из декодерных слоёв DETR (само-внимание и кросс-внимание).
- **mask_decoder_attentions** (`tuple[torch.Tensor]`, *необязательный*) -- Веса внимания из слоев декодера маски.

Пример:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor

>>> model = AutoModel.from_pretrained("facebook/sam3")
>>> processor = AutoProcessor.from_pretrained("facebook/sam3")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")
>>> text = "car"
>>> inputs = processor(images=image, text=text, return_tensors="pt")

>>> # Get segmentation output
>>> outputs = model(**inputs)
>>> pred_masks = outputs.pred_masks
>>> pred_boxes = outputs.pred_boxes
```

#### get_text_features[[transformers.Sam3Model.get_text_features]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L2227)

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

**Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)`

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, 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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import Sam3Model, Sam3Processor
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> model = Sam3Model.from_pretrained("facebook/sam3")
>>> processor = Sam3Processor.from_pretrained("facebook/sam3")

>>> # Pre-compute text embeddings
>>> text_inputs = processor(text="cat", return_tensors="pt")
>>> text_embeds = model.get_text_features(**text_inputs).pooler_output

>>> # Reuse text embeddings for multiple images
>>> url = "http://images.cocodataset.org/val2017/000000077595.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> img_inputs = processor(images=image, return_tensors="pt")
>>> outputs = model(pixel_values=img_inputs.pixel_values, text_embeds=text_embeds)
```