# SAM2 Video

    
        
        
    

## 개요

SAM2 (Segment Anything Model 2)는 Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár, Christoph Feichtenhofer가 [Segment Anything in Images and Videos](https://ai.meta.com/research/publications/sam-2-segment-anything-in-images-and-videos/)에서 제안했습니다.

모델은 입력 이미지 또는 비디오와 입력 점 또는 바운딩 박스를 제공하면 관심 대상인 모든 객체의 분할 마스크를 예측하는 데 사용할 수 있습니다.

![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는 이미지와 비디오에서 프롬프트 기반 시각 분할을 해결하기 위한 파운데이션 모델입니다. 사용자 상호작용을 통해 모델과 데이터를 개선하는 데이터 엔진을 구축하여, 지금까지 수집된 최대 규모의 비디오 분할 데이터셋을 확보했습니다. 본 모델은 실시간 비디오 처리를 위한 스트리밍 메모리를 갖춘 단순한 트랜스포머 아키텍처입니다. 해당 데이터로 학습된 SAM 2는 다양한 작업에서 강력한 성능을 제공합니다. 비디오 분할에서는 기존 접근법보다 3배 적은 상호작용으로 더 높은 정확도를 달성했습니다. 이미지 분할에서는 Segment Anything Model(SAM)보다 정확도가 높고 6배 빠릅니다. 본 데이터, 모델 및 인사이트가 비디오 분할 및 관련 인식 작업의 중요한 이정표가 될 것이라고 믿습니다. 모델 버전, 데이터셋 및 인터랙티브 데모를 공개합니다.*

팁:

- Batch & Video Support: SAM2는 배치 처리와 시ーム리스 비디오 분할을 네이티브로 지원하며, 원본 SAM은 정적 이미지와 한 번에 하나의 이미지를 처리하는 단순한 워크플로우를 위해 설계되었습니다.
- Accuracy & Generalization: SAM2는 원래 SAM과 비교하여, 특히 혼합 프롬프트를 사용할 때 분할 품질, 견고성, 새로운 도메인에 대한 제로샷 일반화 성능이 향상되었습니다.

이 모델은 [sangbumchoi](https://github.com/SangbumChoi)와 [yonigozlan](https://huggingface.co/yonigozlan)이 기여했습니다. 원본 코드는 [여기](https://github.com/facebookresearch/sam2/tree/main)에서 찾을 수 있습니다.

## 사용 예시

### 비디오 분할 및 추적

SAM2의 핵심 강점은 비디오 프레임에 걸쳐 객체를 추적하는 능력입니다. 비디오 분할에 이를 사용하는 방법은 다음과 같습니다:

#### 기본 비디오 추적

```python
from transformers import Sam2VideoModel, Sam2VideoProcessor
import torch

model = Sam2VideoModel.from_pretrained("facebook/sam2.1-hiera-tiny", device_map="auto")
processor = Sam2VideoProcessor.from_pretrained("facebook/sam2.1-hiera-tiny")

# Load video frames (example assumes you have a list of PIL Images)
# video_frames = [Image.open(f"frame_{i:05d}.jpg") for i in range(num_frames)]

# For this example, we'll use the video loading utility
from transformers.video_utils import load_video
video_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/bedroom.mp4"
video_frames, _ = load_video(video_url)

# Initialize video inference session
inference_session = processor.init_video_session(
    video=video_frames,
    inference_device=device,
)

# Add click on first frame to select object
ann_frame_idx = 0
ann_obj_id = 1
points = [[[[210, 350]]]]
labels = [[[1]]]

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=ann_obj_id,
    input_points=points,
    input_labels=labels,
)

# Segment the object on the first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)
video_res_masks = processor.post_process_masks(
    [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
)[0]
print(f"Segmentation shape: {video_res_masks.shape}")
Segmentation shape: torch.Size([1, 1, 480, 854])

# Propagate through the entire video
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = video_res_masks

print(f"Tracked object through {len(video_segments)} frames")
Tracked object through 180 frames
```

#### 다중 객체 비디오 추적

다중 객체를 비디오 프레임에 걸쳐 동시에 추적합니다:

```python
# Reset for new tracking session
inference_session.reset_inference_session()

# Add multiple objects on the first frame
ann_frame_idx = 0
obj_ids = [2, 3]
input_points = [[[[200, 300]], [[400, 150]]]]  # Points for two objects (batched)
input_labels = [[[1], [1]]]

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=obj_ids,
    input_points=input_points,
    input_labels=input_labels,
)

# Get masks for both objects on first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)

# Propagate both objects through video
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = {
        obj_id: video_res_masks[i]
        for i, obj_id in enumerate(inference_session.obj_ids)
    }

print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames")
Tracked 2 objects through 180 frames
```

#### 비디오 분할 개선

프레임에서 추가 클릭을 수행하여 추적을 정밀하게 조정할 수 있습니다:

```python
# Add refinement click on a later frame
refine_frame_idx = 50
ann_obj_id = 2  # Refining first object
points = [[[[220, 280]]]]  # Additional point
labels = [[[1]]]  # Positive click

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=refine_frame_idx,
    obj_ids=ann_obj_id,
    input_points=points,
    input_labels=labels,
)

# Re-propagate with the additional information
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = video_res_masks
```

### 스트리밍 비디오 추론

실시간 애플리케이션을 위해 SAM2는 비디오 프레임이 도착하는 대로 처리하는 것을 지원합니다:

```python
# Initialize session for streaming
inference_session = processor.init_video_session(
    inference_device=device,
)

# Process frames one by one
for frame_idx, frame in enumerate(video_frames[:10]):  # Process first 10 frames
    inputs = processor(images=frame, device=device, return_tensors="pt").to(model.device)
...
    if frame_idx == 0:
        # Add point input on first frame
        processor.add_inputs_to_inference_session(
            inference_session=inference_session,
            frame_idx=0,
            obj_ids=1,
            input_points=[[[[210, 350], [250, 220]]]],
            input_labels=[[[1, 1]]],
            original_size=inputs.original_sizes[0], # need to be provided when using streaming video inference
        )
...
    # Process current frame
    sam2_video_output = model(inference_session=inference_session, frame=inputs.pixel_values[0])
...
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=inputs.original_sizes, binarize=False
    )[0]
    print(f"Frame {frame_idx}: mask shape {video_res_masks.shape}")
```

#### 여러 개체를 위한 비디오 배치 처리

동시에 여러 개체를 추적하려면, 모든 개체를 한 번에 추가하여 비디오에서 동시에 추적할 수 있습니다:

```python
# Initialize video session
inference_session = processor.init_video_session(
    video=video_frames,
    inference_device=device,
)

# Add multiple objects on the first frame using batch processing
ann_frame_idx = 0
obj_ids = [2, 3]  # Track two different objects
input_points = [
    [[[200, 300], [230, 250], [275, 175]], [[400, 150]]]
]  # Object 2: 3 points (2 positive, 1 negative); Object 3: 1 point
input_labels = [
    [[1, 1, 0], [1]]
]  # Object 2: positive, positive, negative; Object 3: positive

processor.add_inputs_to_inference_session(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
    obj_ids=obj_ids,
    input_points=input_points,
    input_labels=input_labels,
)

# Get masks for all objects on the first frame
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)
video_res_masks = processor.post_process_masks(
    [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
)[0]
print(f"Generated masks for {video_res_masks.shape[0]} objects")
Generated masks for 2 objects

# Propagate all objects through the video
video_segments = {}
for sam2_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam2_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam2_video_output.frame_idx] = {
        obj_id: video_res_masks[i]
        for i, obj_id in enumerate(inference_session.obj_ids)
    }

print(f"Tracked {len(inference_session.obj_ids)} objects through {len(video_segments)} frames")
Tracked 2 objects through 180 frames
```

## 리소스

SAM을 시작하는 데 도움이 되는 공식 Hugging Face 및 커뮤니티(🌎로 표시) 리소스 목록입니다.

- [Sangbum Choi](https://github.com/SangbumChoi)님이 기여한 모델을 사용하는 [Demo notebook 🌎](https://colab.research.google.com/drive/1Z0NGLE7p8qnc9UpuI8KBETHd2xBbOEhv?usp=sharing).

## Sam2VideoConfig[[transformers.Sam2VideoConfig]]

#### transformers.Sam2VideoConfig[[transformers.Sam2VideoConfig]]

```python
transformers.Sam2VideoConfig(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, num_maskmem: int = 7, image_size: int | list[int] | tuple[int, int] = 1024, sigmoid_scale_for_mem_enc: float = 20.0, sigmoid_bias_for_mem_enc: float = -10.0, enable_occlusion_spatial_embedding: bool = True, multimask_output_in_sam: bool = True, multimask_min_pt_num: int = 0, multimask_max_pt_num: int = 1, multimask_output_for_tracking: bool = True, max_object_pointers_in_encoder: int = 16, max_cond_frame_num: int = -1, enable_temporal_pos_encoding_for_object_pointers: bool = True, memory_attention_hidden_size: int = 256, memory_attention_num_layers: int = 4, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_feed_forward_hidden_size: int = 2048, memory_attention_feed_forward_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list[int] | None = None, memory_attention_rope_dropout: float | int = 0.1, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, rope_parameters: dict | None = None, mask_downsampler_embed_dim: int = 256, mask_downsampler_kernel_size: int = 3, mask_downsampler_stride: int = 2, mask_downsampler_padding: int = 1, mask_downsampler_total_stride: int = 16, mask_downsampler_hidden_act: str = 'gelu', memory_fuser_num_layers: int = 2, memory_fuser_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, memory_fuser_kernel_size: int = 7, memory_fuser_padding: int = 3, memory_fuser_layer_scale_init_value: float = 1e-06, memory_fuser_hidden_act: str = 'gelu')
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/configuration_sam2_video.py#L96)

**매개변수:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *선택*) : 비전 백본의 config 객체 또는 사전 정의된 config 딕셔너리입니다.

prompt_encoder_config (Union[`dict`, `Sam2PromptEncoderConfig`], *선택*) : [Sam2PromptEncoderConfig](/docs/transformers/v5.23.0/ko/model_doc/sam2#transformers.Sam2PromptEncoderConfig)를 초기화하는 데 사용되는 구성 옵션의 사전.

mask_decoder_config (Union[`dict`, `Sam2MaskDecoderConfig`], *선택*) : [Sam2MaskDecoderConfig](/docs/transformers/v5.23.0/ko/model_doc/sam2#transformers.Sam2MaskDecoderConfig)를 초기화하는 데 사용되는 구성 옵션의 사전.

initializer_range (`float`, *선택 사항*, 기본값 0.02) : 매개변수 초기화에 사용되는 표준 편차.

num_maskmem (`int`, *선택 사항*, 기본값 7) : 마스크 메모리를 위한 메모리 슬롯의 수입니다.

image_size (`Union[int, list[int], tuple[int, int]]`, *선택 사항*, 기본값 `1024`) : 각 이미지의 크기(해상도).

sigmoid_scale_for_mem_enc (`float`, *선택 사항*, 기본값 20.0) : 메모리 인코더의 시그모이드 함수에 사용되는 스케일 팩터입니다.

sigmoid_bias_for_mem_enc (`float`, *선택 사항*, 기본값 -10.0) : 메모리 인코더의 시그모이드 함수에 사용되는 바이어스입니다.

enable_occlusion_spatial_embedding (`bool`, *선택 사항*, 기본값 `True`) : occlusion에 대한 spatial embedding을 활성화할지 여부.

multimask_output_in_sam (`bool`, *선택 사항*, 기본값 `True`) : SAM 헤드에서 여러 마스크를 출력할지 여부.

multimask_min_pt_num (`int`, *선택 사항*, 기본값 0) : 멀티마스크 출력을 트리거하기 위한 최소 포인트 수입니다.

multimask_max_pt_num (`int`, *선택 사항*, 기본값 1) : 멀티마스크 출력을 트리거할 최대 포인트 수입니다.

multimask_output_for_tracking (`bool`, *선택 사항*, 기본값 `True`) : 추적을 위해 멀티마스크 출력을 사용할지 여부.

max_object_pointers_in_encoder (`int`, *선택 사항*, 기본값 16) : 인코더의 최대 객체 포인터 수입니다.

max_cond_frame_num (`int`, *선택 사항*, 기본값 -1) : 메모리 어텐션에 사용할 조건 프레임의 최대 수입니다. 모든 조건 프레임을 사용하려면 -1로 설정하세요.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *선택 사항*, 기본값 `True`) : 객체 포인터에 대해 시간적 위치 인코딩을 활성화할지 여부입니다.

memory_attention_hidden_size (`int`, *선택 사항*, 기본값 256) : 메모리 어텐션 히든 상태의 차원입니다.

memory_attention_num_layers (`int`, *선택 사항*, 기본값 4) : 메모리 어텐션 모듈의 레이어 수입니다.

memory_attention_num_attention_heads (`int`, *선택 사항*, 기본값 1) : 메모리 어텐션의 각 어텐션 레이어당 어텐션 헤드 수입니다.

memory_attention_downsample_rate (`int`, *선택 사항*, 기본값 1) : attention 레이어의 다운샘플링 비율입니다.

memory_attention_feed_forward_hidden_size (`int`, *선택 사항*, 기본값 2048) : 메모리 어텐션 모듈의 피드포워드 네트워크 차원입니다.

memory_attention_feed_forward_hidden_act (`str`, *선택 사항*, 기본값 `"relu"`) : 메모리 어텐션 모듈의 피드포워드 네트워크에서 사용되는 비선형 활성화 함수입니다.

memory_attention_dropout (`float`, *선택 사항*, 기본값 0.1) : 메모리 어텐션 모듈의 드롭아웃 비율입니다.

memory_attention_rope_feat_sizes (`list[int]`, *선택 사항*, 기본값 `[64, 64]`) : Rope 위치 인코딩의 특징 크기입니다.

memory_attention_rope_dropout (`float`, *선택 사항*, 기본값 0.1) : Rope 위치 인코딩의 dropout rate입니다.

memory_encoder_hidden_size (`int`, *선택 사항*, 기본값 256) : 메모리 인코더의 숨겨진 상태(hidden states) 차원.

memory_encoder_output_channels (`int`, *선택 사항*, 기본값 64) : 메모리 인코더의 출력 채널 수입니다.

rope_parameters (`dict`, *선택*) : RoPE 임베딩의 구성 매개변수를 포함하는 사전입니다. 사전에는 `rope_theta` 값이 포함되어야 하며, 더 긴 `max_position_embeddings`로 RoPE를 사용하려는 경우 스케일링에 사용되는 매개변수를 선택적으로 포함할 수 있습니다.

mask_downsampler_embed_dim (`int`, *선택 사항*, 기본값 256) : 마스크 다운샘플러 임베딩의 차원입니다.

mask_downsampler_kernel_size (`int`, *선택 사항*, 기본값 3) : 마스크 다운샘플러의 커널 크기입니다.

mask_downsampler_stride (`int`, *선택 사항*, 기본값 2) : 마스크 다운샘플러의 스트라이드입니다.

mask_downsampler_padding (`int`, *선택 사항*, 기본값 1) : 마스크 다운샘플러의 패딩입니다.

mask_downsampler_total_stride (`int`, *선택 사항*, 기본값 16) : 마스크 다운샘플러의 총 스트라이드입니다.

mask_downsampler_hidden_act (`str`, *선택 사항*, 기본값 `"gelu"`) : 마스크 다운샘플러의 비선형 활성화 함수입니다.

memory_fuser_num_layers (`int`, *선택 사항*, 기본값 2) : 메모리 퓨저의 레이어 수입니다.

memory_fuser_embed_dim (`int`, *선택 사항*, 기본값 256) : memory fuser의 임베딩 레이어 차원입니다.

memory_fuser_intermediate_dim (`int`, *선택 사항*, 기본값 1024) : memory fuser의 중간 레이어 차원입니다.

memory_fuser_kernel_size (`int`, *선택 사항*, 기본값 7) : 메모리 퓨저에 사용되는 커널 크기입니다.

memory_fuser_padding (`int`, *선택 사항*, 기본값 3) : 메모리 푸저의 패딩입니다.

memory_fuser_layer_scale_init_value (`float`, *선택 사항*, 기본값 1e-06) : memory fuser의 layer scale 초기 값입니다.

memory_fuser_hidden_act (`str`, *선택 사항*, 기본값 `"gelu"`) : 메모리 퓨저의 비선형 활성화 함수.

이것은 Sam2VideoModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Sam2 Video 모델을 초기화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 초기화하면 [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/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)
```

## Sam2VideoMaskDecoderConfig[[transformers.Sam2VideoMaskDecoderConfig]]

#### transformers.Sam2VideoMaskDecoderConfig[[transformers.Sam2VideoMaskDecoderConfig]]

```python
transformers.Sam2VideoMaskDecoderConfig(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_video/configuration_sam2_video.py#L57)

**매개변수:**

hidden_size (`int`, *선택 사항*, 기본값 `256`) : 숨겨진 표현의 차원.

hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

mlp_dim (`int`, *선택 사항*, 기본값 2048) : 양방향 transformer의 MLP 차원입니다.

num_hidden_layers (`int`, *선택 사항*, 기본값 `2`) : Transformer 디코더의 숨겨진 레이어 수.

num_attention_heads (`int`, *선택 사항*, 기본값 `8`) : Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.

attention_downsample_rate (`int`, *선택 사항*, 기본값 2) : attention 레이어의 다운샘플링 비율입니다.

num_multimask_outputs (`int`, *선택 사항*, 기본값 3) : 멀티마스크 출력의 개수입니다.

iou_head_depth (`int`, *선택 사항*, 기본값 3) : IoU head의 깊이입니다.

iou_head_hidden_dim (`int`, *선택 사항*, 기본값 256) : IoU 헤드의 숨겨진 차원입니다.

dynamic_multimask_via_stability (`bool`, *선택 사항*, 기본값 `True`) : 안정성을 통한 동적 멀티마스크를 사용할지 여부.

dynamic_multimask_stability_delta (`float`, *선택 사항*, 기본값 0.05) : 동적 멀티마스크의 안정성 델타입니다.

dynamic_multimask_stability_thresh (`float`, *선택 사항*, 기본값 0.98) : 동적 멀티마스크의 안정성 임계값입니다.

이것은 Sam2VideoModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Sam2 Video 모델을 초기화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 초기화하면 [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

## Sam2VideoPromptEncoderConfig[[transformers.Sam2VideoPromptEncoderConfig]]

#### transformers.Sam2VideoPromptEncoderConfig[[transformers.Sam2VideoPromptEncoderConfig]]

```python
transformers.Sam2VideoPromptEncoderConfig(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_video/configuration_sam2_video.py#L32)

**매개변수:**

hidden_size (`int`, *선택 사항*, 기본값 `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`, *선택 사항*, 기본값 4) : 사용할 포인트 임베딩의 개수입니다.

hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-06`) : 레이어 정규화 레이어에서 사용되는 epsilon 값입니다.

scale (`float`, *선택 사항*, 기본값 1) : 프롬프트 인코더의 스케일 팩터입니다.

이것은 Sam2VideoModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Sam2 Video 모델을 초기화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 초기화하면 [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

## Sam2VideoProcessor[[transformers.Sam2VideoProcessor]]

#### transformers.Sam2VideoProcessor[[transformers.Sam2VideoProcessor]]

```python
transformers.Sam2VideoProcessor(image_processor, video_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_video/processing_sam2_video.py#L37)

**매개변수:**

image_processor (`Sam2ImageProcessor`) : 이미지 프로세서가 필수 입력입니다.

video_processor (`Sam2VideoVideoProcessor`) : 비디오 프로세서가 필수 입력입니다.

target_size (`int`, *선택 사항*) : 입력 점과 바운딩 박스를 정규화하기 위한 대상 크기(픽셀 단위). 제공되지 않으면 이미지 프로세서의 크기 설정을 기본값으로 사용합니다. 모든 입력 좌표(점과 박스)는 모델에 전달되기 전에 이 크기로 정규화됩니다. 이를 통해 원본 이미지 차원과 관계없이 일관된 좌표 표현을 보장합니다.

point_pad_value (`int`, *선택 사항*, 기본값 -10) : 길이가 다른 시퀀스를 배치할 때 입력 포인트를 패딩하는 데 사용되는 값. 이 값은 패딩된 위치를 표시하는 데 사용되며 좌표 정규화 과정에서도 유지됩니다.

이미지 프로세서와 비디오 프로세서를 단일 프로세서로 래핑하는 Sam2VideoProcessor를 생성합니다.

[Sam2VideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoProcessor)는 [Sam2ImageProcessor](/docs/transformers/v5.23.0/ko/model_doc/sam2#transformers.Sam2ImageProcessor)와 [Sam2VideoVideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor)의 모든 기능을 제공합니다. 자세한 내용은 [~Sam2ImageProcessor](/docs/transformers/v5.23.0/ko/model_doc/sam2#transformers.Sam2ImageProcessor)와 [~Sam2VideoVideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor)를 참고하세요.

#### __call__[[transformers.Sam2VideoProcessor.__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_video/processing_sam2_video.py#L55)

**매개변수:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *선택*) : 전처리할 이미지. 픽셀 값이 0에서 255 범위로 이루어진 단일 이미지 또는 배치 이미지를 기대합니다. 픽셀 값이 0에서 1 범위로 이루어진 이미지를 전달하는 경우 `do_rescale=False`로 설정하세요.

segmentation_maps (`ImageInput`, *선택 사항*) : 처리할 분할 맵입니다.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *선택 사항*) : 프레임에 추가할 점들.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *선택 사항*) : 포인트의 라벨입니다.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *선택 사항*) : 프레임에 추가할 바운딩 박스입니다.

original_sizes (`list[list[float]]`, `torch.Tensor`, *선택 사항*) : 이미지의 원래 크기입니다.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *선택*) : 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다: - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: NumPy `np.ndarray` 객체를 반환합니다.

**반환값:** 다음 필드를 가진 [BatchEncoding](/docs/transformers/v5.23.0/ko/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.Sam2VideoProcessor.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_video/processing_sam2_video.py#L461)

**매개변수:**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : (batch_size, num_channels, height, width) 형식의 mask_decoder에서 생성된 배치된 마스크.

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : 이미지가 모델의 예상 입력 형식으로 리사이즈되기 전의 원래 크기입니다. (height, width) 형식으로 제공됩니다.

mask_threshold (`float`, *선택 사항*, 기본값 0.0) : 이진화 및 후처리 작업에 사용되는 임계값.

binarize (`bool`, *선택 사항*, 기본값 `True`) : 마스크를 바이너리화할지 여부.

max_hole_area (`float`, *선택 사항*, 기본값 0.0) : 채울 구멍의 최대 면적.

max_sprinkle_area (`float`, *선택*, 기본값 0.0) : 채울 스프링클의 최대 면적입니다.

apply_non_overlapping_constraints (`bool`, *선택 사항*, 기본값 `False`) : 마스크에 겹치지 않는 제약 조건을 적용할지 여부.

**반환값:** (`torch.Tensor`)

batch_size, num_channels, height, width 형식의 배치된 마스크입니다. 여기서 (height, width)는 original_size로 주어집니다.

패딩을 제거하고 마스크를 원래 이미지 크기로 업스케일링합니다.

#### init_video_session[[transformers.Sam2VideoProcessor.init_video_session]]

```python
init_video_session(video: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, inference_device: typing.Union[str, ForwardRef('torch.device')] = 'cpu', inference_state_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, processing_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, video_storage_device: typing.Union[str, ForwardRef('torch.device'), NoneType] = None, max_vision_features_cache_size: int = 1, dtype: dtype = torch.float32)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L512)

**매개변수:**

video (`VideoInput`, *선택 사항*) : 처리할 비디오입니다. 스트리밍하는 경우 제공할 필요가 없습니다.

inference_device (`str` 또는 `torch.device`, *선택 사항*, 기본값 "cpu") : 추론에 사용할 장치입니다.

inference_state_device (`str` 또는 `torch.device`, *선택 사항*) : 추론 상태를 저장할 장치입니다.

processing_device (`str` 또는 `torch.device`, *선택 사항*) : 비디오 처리에 사용할 장치입니다.

video_storage_device (`str` 또는 `torch.device`, *선택 사항*) : 처리된 비디오 프레임을 저장할 장치입니다.

max_vision_features_cache_size (`int`, *선택 사항*, 기본값 1) : 캐시할 최대 비전 특징 수입니다.

dtype (`torch.dtype`, *선택 사항*, 기본값 `torch.float32`) : 전체 세션에 사용할 torch dtype입니다.

추론을 위한 비디오 세션을 초기화합니다. 비디오가 제공된 경우(비동기 추론), 비디오가 처리되어 `video_storage_device`에 저장됩니다.

#### add_inputs_to_inference_session[[transformers.Sam2VideoProcessor.add_inputs_to_inference_session]]

```python
add_inputs_to_inference_session(inference_session: Sam2VideoInferenceSession, frame_idx: int, obj_ids: list[int] | int, 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, input_masks: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], NoneType] = None, original_size: tuple[int, int] | None = None, clear_old_inputs: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/processing_sam2_video.py#L565)

**매개변수:**

inference_session (`Sam2VideoInferenceSession`) : 비디오를 위한 추론 세션입니다.

frame_idx (`int`) : 처리할 프레임의 인덱스.

obj_ids (`list[int]` 또는 `int`) : 점이나 박스와 연결할 객체 ID입니다. 이는 임의의 정수이며, 나중에 특정 객체를 지정할 때 재사용할 수 있습니다.

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`, *선택 사항*) : 프레임에 추가할 바운딩 박스입니다.

input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, 또는 `list[torch.Tensor]`, *선택 사항*) : 프레임에 추가할 마스크입니다.

original_size (`tuple[int, int]`, *선택 사항*) : 비디오의 원래 크기입니다. 스트리밍할 때 제공하세요.

clear_old_inputs (`bool`, *선택 사항*, 기본값 `True`) : 객체의 이전 입력을 지울지 여부.

새로운 점, 상자 또는 마스크를 비디오 프레임에 대해 처리하고 추론 세션에 추가합니다.

## Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

#### transformers.Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

```python
transformers.Sam2VideoVideoProcessor(**kwargs: *<class 'transformers.processing_utils.VideosKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/video_processing_sam2_video.py#L27)

**매개변수:**

do_convert_rgb (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 RGB로 변환할지 여부.

do_resize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 리사이즈할지 여부.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, 기본값 `{'height' : 1024, 'width': 1024}`): 모델에 입력되는 최대 차원을 설명합니다.

default_to_square (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : size가 int인 경우 리사이즈 시 정사각형 이미지로 설정할지 여부.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, 기본값 `2`) : 이미지를 리사이즈할 때 사용할 리샘플링 필터입니다. 이는 `PILImageResampling` enum 중 하나일 수 있습니다. `do_resize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_rescale (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 다시 스케일링할지 여부.

rescale_factor (`float`, *kwargs*, *선택 사항*, 기본값 `0.00392156862745098`) : `do_rescale`이 `True`로 설정된 경우 이미지를 재조정하는 데 사용되는 재조정 계수입니다.

do_normalize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 정규화할지 여부.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.485, 0.456, 0.406]`) : 정규화에 사용할 이미지 평균입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.229, 0.224, 0.225]`) : 정규화에 사용할 이미지 표준 편차입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_center_crop (`bool`, *kwargs*, *선택*) : 이미지를 중앙 크롭할지 여부.

do_pad (`bool`, *kwargs*, *선택*) : 이미지를 패딩할지 여부입니다. 패딩은 배치 내 가장 큰 크기로 수행하거나, 이미지마다 고정된 정사각형 크기로 수행합니다. 정확한 패딩 전략은 모델에 따라 달라집니다.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop`를 적용한 후의 출력 이미지 크기.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : `ChannelDimension.FIRST`만 지원됩니다. 느린 프로세서와의 호환성을 위해 추가되었습니다.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : 입력 이미지의 채널 차원 형식입니다. 설정하지 않으면 입력 이미지에서 채널 차원 형식을 추론합니다. 다음 중 하나일 수 있습니다: - `"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*) : 비디오를 처리할 장치입니다. 설정되지 않은 경우, 입력 비디오에서 장치를 추론합니다.

do_sample_frames (`bool`, *kwargs*, *선택*) : 처리 전에 비디오에서 프레임을 샘플링할지, 아니면 비디오 전체를 처리할지 여부.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : 총 길이, fps, 총 프레임 수에 대한 정보를 포함하는 비디오의 메타데이터입니다. 비디오에서 프레임을 샘플링하거나 타임스탬프를 계산하는 데 사용됩니다. 비디오를 수동으로 디코딩하여 처리하려는 경우를 제외하고는 메타데이터를 전달하지 마세요

fps (`Annotated[int | float | None, None]`, *kwargs*) : `do_sample_frames=True`일 때 초당 샘플링할 대상 프레임 수.

num_frames (`Annotated[int | None, None]`, *kwargs*) : `do_sample_frames=True`일 때 샘플링할 최대 프레임 수.

return_metadata (`bool`, *kwargs*, *선택 사항*, 기본값 `False`) : 비디오 메타데이터를 반환할지 여부입니다. 비디오 메타데이터는 비디오 길이, fps, 디코딩 백엔드 등에 대한 정보를 포함하는 객체입니다.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다: - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: NumPy `np.ndarray` 객체를 반환합니다.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/ko/main_classes/processors#transformers.VideosKwargs), *optional*) : 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

Sam2VideoVideoProcessor 비디오 프로세서를 생성합니다.

#### post_process_masks[[transformers.Sam2VideoVideoProcessor.post_process_masks]]

```python
post_process_masks(masks, original_sizes, reshaped_input_sizes, mask_threshold = 0.0, binarize = True, pad_size = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/video_processing_sam2_video.py#L58)

**매개변수:**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : (batch_size, num_channels, height, width) 형식의 mask_decoder에서 생성된 배치된 마스크.

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : 이미지가 모델의 예상 입력 형식으로 리사이즈되기 전의 원래 크기입니다. (height, width) 형식으로 제공됩니다.

reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : 모델에 입력될 각 이미지의 크기로, (height, width) 형식입니다. 패딩을 제거하는 데 사용됩니다.

mask_threshold (`float`, *선택 사항*, 기본값 0.0) : 마스크를 바이너리화할 때 사용할 임계값입니다.

binarize (`bool`, *선택 사항*, 기본값 `True`) : 마스크를 바이너리화할지 여부.

pad_size (`int`, *선택 사항*, 기본값 `self.pad_size`) : 모델에 전달되기 전에 이미지가 패딩된 대상 크기입니다. None인 경우, 대상 크기는 프로세서의 `pad_size`로 간주됩니다.

**반환값:** (`torch.Tensor`)

batch_size, num_channels, height, width 형식의 배치된 마스크입니다. 여기서 (height, width)는 original_size로 주어집니다.

패딩을 제거하고 마스크를 원래 이미지 크기로 업스케일링합니다.

## Sam2VideoInferenceSession[[transformers.Sam2VideoInferenceSession]]

#### transformers.Sam2VideoInferenceSession[[transformers.Sam2VideoInferenceSession]]

```python
transformers.Sam2VideoInferenceSession(video: typing.Optional[torch.Tensor] = None, video_height: int | None = None, video_width: int | None = None, inference_device: typing.Union[torch.device, str] = 'cpu', inference_state_device: typing.Union[torch.device, str] = 'cpu', video_storage_device: typing.Union[torch.device, str] = 'cpu', dtype: typing.Union[torch.dtype, str] = 'float32', max_vision_features_cache_size: int = 1)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L109)

**매개변수:**

video (`torch.Tensor`, *선택 사항*) : 처리할 비디오. 스트리밍 시에는 제공할 필요가 없습니다.

video_height (`int`, *선택 사항*) : 비디오의 높이.

video_width (`int`, *선택 사항*) : 비디오의 너비.

inference_device (`torch.device`, *선택 사항*, 기본값 `"cpu"`) : 추론에 사용할 장치입니다.

inference_state_device (`torch.device`, *선택 사항*, 기본값 `"cpu"`) : 추론 상태를 저장할 장치입니다.

video_storage_device (`torch.device`, *선택 사항*, 기본값 `"cpu"`) : 비디오를 저장할 장치입니다.

dtype (`torch.dtype`, *선택 사항*, 기본값 `"float32"`) : 비디오에 사용할 dtype입니다.

max_vision_features_cache_size (`int`, *선택 사항*, 기본값 1) : 캐시할 최대 비전 특징 수입니다.

비디오 추론 세션의 매개변수, 상태 및 캐시를 관리합니다.

#### add_mask_inputs[[transformers.Sam2VideoInferenceSession.add_mask_inputs]]

```python
add_mask_inputs(obj_idx: int, frame_idx: int, inputs: Tensor)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L229)

mask 입력을 자동 장치 배치와 함께 추가합니다.

#### add_new_frame[[transformers.Sam2VideoInferenceSession.add_new_frame]]

```python
add_new_frame(pixel_values: Tensor, frame_idx: int | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L304)

device 자동 배치로 새 프레임을 추가합니다.

#### add_point_inputs[[transformers.Sam2VideoInferenceSession.add_point_inputs]]

```python
add_point_inputs(obj_idx: int, frame_idx: int, inputs: dict)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L215)

point 입력을 자동 장치 배치와 함께 추가합니다.

#### get_frame[[transformers.Sam2VideoInferenceSession.get_frame]]

```python
get_frame(frame_idx: int)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L320)

비디오에서 프레임을 가져옵니다.

#### get_obj_num[[transformers.Sam2VideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L210)

이 세션에서 지금까지 수신된 고유한 객체 ID의 총 개수를 가져옵니다.

#### get_output[[transformers.Sam2VideoInferenceSession.get_output]]

```python
get_output(obj_idx: int, frame_idx: int, output_key: str, is_conditioning_frame: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L277)

**매개변수:**

obj_idx (int) : 객체의 인덱스.

frame_idx (int) : 프레임의 인덱스.

output_key (str) : 출력의 키.

is_conditioning_frame (bool) : 출력이 조건 프레임용인지 여부.

스마트한 장치 관리를 통해 출력을 가져옵니다.

#### obj_id_to_idx[[transformers.Sam2VideoInferenceSession.obj_id_to_idx]]

```python
obj_id_to_idx(obj_id: int)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L184)

필요한 경우 새 항목을 생성하여 object ID를 인덱스에 매핑합니다.

#### obj_idx_to_id[[transformers.Sam2VideoInferenceSession.obj_idx_to_id]]

```python
obj_idx_to_id(obj_idx: int)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L206)

모델 측 객체 인덱스를 클라이언트 측 객체 ID로 매핑합니다.

#### remove_mask_inputs[[transformers.Sam2VideoInferenceSession.remove_mask_inputs]]

```python
remove_mask_inputs(obj_idx: int, frame_idx: int)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L235)

마스크 입력을 제거합니다.

#### remove_point_inputs[[transformers.Sam2VideoInferenceSession.remove_point_inputs]]

```python
remove_point_inputs(obj_idx: int, frame_idx: int)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L225)

점 입력을 제거합니다.

#### reset_inference_session[[transformers.Sam2VideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L336)

추적 데이터와 캐시를 초기화합니다.

#### reset_tracking_data[[transformers.Sam2VideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L324)

트래킹 데이터는 초기화하되 캐시는 유지합니다.

#### store_output[[transformers.Sam2VideoInferenceSession.store_output]]

```python
store_output(obj_idx: int, frame_idx: int, output_key: str | None = None, output_value: typing.Union[torch.Tensor, dict, NoneType] = None, is_conditioning_frame: bool = True)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L240)

**매개변수:**

obj_idx (int) : 객체의 인덱스.

frame_idx (int) : 프레임의 인덱스.

output_key (Optional[str]) : 출력의 키입니다. None인 경우, 출력은 사전으로 저장됩니다.

output_value (Optional[Union[torch.Tensor, dict]]) : 출력 값.

is_conditioning_frame (bool) : 출력이 조건 프레임용인지 여부.

output_key가 None인 경우, 출력은 사전으로 저장됩니다.

## Sam2VideoModel[[transformers.Sam2VideoModel]]

#### transformers.Sam2VideoModel[[transformers.Sam2VideoModel]]

```python
transformers.Sam2VideoModel(config: Sam2VideoConfig)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L1643)

**매개변수:**

config ([Sam2VideoConfig](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

특정 헤드가 위에 없는 Sam2 Video Model의 원본 hidden-states를 출력하는 상태입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.Sam2VideoModel.forward]]

```python
forward(inference_session: Sam2VideoInferenceSession, frame_idx: int | None = None, frame: typing.Optional[torch.Tensor] = None, reverse: bool = False, run_mem_encoder: bool = True, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L1776)

**매개변수:**

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : 비디오 추론 세션 객체.

frame_idx (`int`, *선택 사항*) : 추론을 실행할 프레임의 인덱스입니다. 새로 스트리밍된 프레임에 대해 추론을 수행할 경우 제공하지 않아도 됩니다.

frame (`torch.Tensor`, *선택 사항*) : 처리할 프레임입니다. 스트리밍할 때 제공하세요.

reverse (`bool`, *선택 사항*, 기본값 `False`) : 역방향으로 전파할지 여부.

run_mem_encoder (`bool`, *선택 사항*, 기본값 `True`) : 예측된 마스크에 대해 메모리 인코더를 실행할지 여부입니다. 메모리 인코더는 효율성을 위해 모든 객체에 대해 배치됩니다.

**반환값:** `Sam2VideoSegmentationOutput` 또는 `tuple(torch.Tensor)`

`Sam2VideoSegmentationOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, 구성([Sam2VideoConfig](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoConfig)) 및 입력에 따라 다양한 요소를 포함합니다.

스트리밍된 비디오 프레임을 통해 객체를 전파합니다.

- **object_ids** (`list[int]`, *선택 사항*) -- 현재 프레임에서 추적 중인 객체 ID 목록.
- **pred_masks** (`torch.Tensor`, shape `(batch_size, num_masks, height, width)`) -- 모델의 해상도로 저장된 예측 마스크입니다.
- **object_score_logits** (`torch.Tensor`, shape `(batch_size,)`, *선택 사항*) -- 객체 점수에 대한 logits로, 객체가 존재하는지 여부를 나타냅니다.
- **frame_idx** (`int`, *선택 사항*) -- 비디오의 프레임 인덱스입니다.

#### propagate_in_video_iterator[[transformers.Sam2VideoModel.propagate_in_video_iterator]]

```python
propagate_in_video_iterator(inference_session: Sam2VideoInferenceSession, start_frame_idx: int | None = None, max_frame_num_to_track: int | None = None, reverse: bool = False, show_progress_bar: bool = False)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L2797)

**매개변수:**

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : 비디오 추론 세션 객체.

start_frame_idx (`int`, *선택 사항*) : 전파를 위한 시작 프레임 인덱스입니다. 새로운 입력에 대해 `forward`가 아직 호출되지 않은 경우 제공해야 합니다. 제공하지 않으면 입력 점이 있는 가장 초기 프레임이 시작 프레임 인덱스로 사용됩니다.

max_frame_num_to_track (`int`, *선택 사항*) : 추적할 최대 프레임 수입니다.

reverse (`bool`, *선택 사항*, 기본값 `False`) : 역방향으로 전파할지 여부.

show_progress_bar (`bool`, *선택 사항*, 기본값 `False`) : 전파 과정에서 진행 표시줄을 표시할지 여부.

**반환값:** `Sam2VideoSegmentationOutput` 또는 `tuple(torch.Tensor)`

`Sam2VideoSegmentationOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, 구성([Sam2VideoConfig](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoConfig)) 및 입력에 따라 다양한 요소를 포함합니다.

비디오 프레임에 걸쳐 객체를 전파합니다. 전체 비디오로 추론 세션을 초기화할 때 사용됩니다. 각 프레임에 대해 Sam2VideoSegmentationOutput을 반환합니다.

- **object_ids** (`list[int]`, *선택 사항*) -- 현재 프레임에서 추적 중인 객체 ID 목록.
- **pred_masks** (`torch.Tensor`, shape `(batch_size, num_masks, height, width)`) -- 모델의 해상도로 저장된 예측 마스크입니다.
- **object_score_logits** (`torch.Tensor`, shape `(batch_size,)`, *선택 사항*) -- 객체 점수에 대한 logits로, 객체가 존재하는지 여부를 나타냅니다.
- **frame_idx** (`int`, *선택 사항*) -- 비디오의 프레임 인덱스입니다.

#### get_image_features[[transformers.Sam2VideoModel.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_video/modeling_sam2_video.py#L1901)

**매개변수:**

pixel_values (`torch.Tensor`) : `(batch_size, num_channels, height, width)` 형식의 입력 픽셀 값.

**반환값:** `Sam2VideoVisionEncoderOutput` 또는 `tuple(torch.Tensor)`

`Sam2VideoVisionEncoderOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, 구성([Sam2VideoConfig](/docs/transformers/v5.23.0/ko/model_doc/sam2_video#transformers.Sam2VideoConfig))과 입력에 따라 다양한 요소를 포함합니다.

- **last_hidden_state** (shape가 `(batch_size, height, width, hidden_size)`인 `torch.Tensor`) -- 모델의 마지막 레이어 출력의 hidden-state 시퀀스.
- **pooler_output** (`torch.Tensor`, shape `(batch_size, hidden_size)`) -- 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 보조 사전학습 작업을 위해 사용되는 레이어들을 통해 추가 처리된 값입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전학습 단계에서 다음 문장 예측(분류) 목적 함수를 통해 학습됩니다.
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- shape이 `(batch_size, hidden_size, height, width)`인 `torch.Tensor`의 튜플(각 특징 레벨마다 하나씩, 고해상도에서 저해상도 순서로). Feature Pyramid Network neck에서 생성된 feature map입니다.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- shape이 `(batch_size, hidden_size, height, width)`인 `torch.Tensor`의 튜플(해상도가 높은 수준부터 낮은 수준까지 각 feature level에 하나씩). `fpn_hidden_states`에 해당하는 positional encodings입니다.