# EdgeTAMVideo

## 개요

EdgeTAM 모델은 [EdgeTAM: On-Device Track Anything Model](https://huggingface.co/papers/2501.07256) (Chong Zhou, Chenchen Zhu, Yunyang Xiong, Saksham Suri, Fanyi Xiao, Lemeng Wu, Raghuraman Krishnamoorthi, Bo Dai, Chen Change Loy, Vikas Chandra, Bilge Soran)에서 제안되었습니다.

EdgeTAM은 모바일 기기에서 실시간 비디오 분할을 위해 메모리 주의 메커니즘을 최적화하는 2D Spatial Perceiver 아키텍처를 도입한 SAM 2의 효율적인 적응 모델입니다.

해당 논문의 초록은 다음과 같습니다:

*Segment Anything Model(SAM)을 기반으로 SAM 2는 메모리 뱅크 메커니즘을 통해 이미지에서 비디오 입력으로 기능을 확장하여 기존 방법 대비 뛰어난 성능을 달성함으로써 비디오 분할 작업의 기반 모델이 되었습니다. 본 논문에서는 SAM 2의 효율성을 크게 높여 모바일 기기에서도 실행 가능하면서도 유사한 성능을 유지할 수 있도록 하는 것을 목표로 합니다. SAM의 효율성을 최적화한 여러 연구가 있지만, SAM 2에는 충분하지 않다고 판단됩니다. 이는 기존 연구들이 모두 이미지 인코더 압축에 초점을 맞추고 있기 때문이며, 우리의 벤치마크는 새로 도입된 메모리 어텐션 블록이 또한 지연 시간의 병목 현상임을 보여줍니다. 이러한 관찰을 바탕으로, 우리는 새로운 2D Spatial Perceiver를 활용하여 계산 비용을 줄이는 EdgeTAM을 제안합니다. 특히, 제안된 2D Spatial Perceiver는 고정된 학습 가능한 쿼리 집합을 포함하는 경량 Transformer를 사용하여 밀도 있게 저장된 프레임 수준의 메모리를 인코딩합니다. 비디오 분할이 밀집 예측(dense prediction) 작업이므로, 메모리의 공간 구조를 보존하는 것이 필수적이라고 판단하여 쿼리를 글로벌 레벨과 패치 레벨 그룹으로 나누었습니다. 또한, 추론 오버헤드 없이 성능을 추가로 향상시키는 증류(distillation) 파이프라인을 제안합니다. 그 결과, EdgeTAM은 DAVIS 2017, MOSE, SA-V val, SA-V test에서 각각 87.7, 70.0, 72.3, 71.7의 J&F를 달성하는 동시에 iPhone 15 Pro Max에서 16 FPS로 실행됩니다.*

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

## 사용 예시

### 비디오 분할 및 추적

EdgeTAM Video의 핵심 강점은 모바일 기기에서 비디오 프레임 간 객체를 효율적으로 추적할 수 있다는 점입니다. 비디오 분할에 사용하는 방법은 다음과 같습니다:

#### 기본 비디오 추적

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

model = EdgeTamVideoModel.from_pretrained("yonigozlan/edgetam-video-1", device_map="auto")
processor = Sam2VideoProcessor.from_pretrained("yonigozlan/edgetam-video-1")

# 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, 540, 960])

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

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

실시간 애플리케이션을 위해, EdgeTAM Video는 프레임이 도착하는 대로 처리할 수 있습니다:

```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}")

Frame 0: mask shape torch.Size([1, 1, 540, 960])
...
```

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

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

```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 200 frames
```

## EdgeTamVideoMaskDecoderConfig[[transformers.EdgeTamVideoMaskDecoderConfig]]

#### transformers.EdgeTamVideoMaskDecoderConfig[[transformers.EdgeTamVideoMaskDecoderConfig]]

```python
transformers.EdgeTamVideoMaskDecoderConfig(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/main/src/transformers/models/edgetam_video/configuration_edgetam_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) : 동적 멀티마스크의 안정성 임계값입니다.

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

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

## EdgeTamVideoPromptEncoderConfig[[transformers.EdgeTamVideoPromptEncoderConfig]]

#### transformers.EdgeTamVideoPromptEncoderConfig[[transformers.EdgeTamVideoPromptEncoderConfig]]

```python
transformers.EdgeTamVideoPromptEncoderConfig(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/main/src/transformers/models/edgetam_video/configuration_edgetam_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) : 프롬프트 인코더의 스케일 팩터입니다.

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

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

## EdgeTamVideoConfig[[transformers.EdgeTamVideoConfig]]

#### transformers.EdgeTamVideoConfig[[transformers.EdgeTamVideoConfig]]

```python
transformers.EdgeTamVideoConfig(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 = 2, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_mlp_hidden_size: int = 2048, memory_attention_mlp_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list | None = None, memory_attention_rope_k_sizes: list | None = None, memory_attention_rope_dropout: float | int = 0.1, rope_parameters: dict | None = None, perceiver_resampler_num_latents: int = 256, perceiver_resampler_num_latents_2d: int = 256, perceiver_resampler_hidden_size: int = 64, perceiver_resampler_mlp_intermediate_size: int = 256, perceiver_resampler_num_attention_heads: int = 1, perceiver_resampler_attention_head_dim: int = 64, perceiver_resampler_num_layers: int = 2, perceiver_resampler_hidden_dropout: float | int = 0.0, perceiver_resampler_attention_dropout: float | int = 0.0, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, mask_downsampler_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, 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_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/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L96)

**매개변수:**

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

prompt_encoder_config (Union[`dict`, `EdgeTamVideoPromptEncoderConfig`], *선택*) : [EdgeTamVideoPromptEncoderConfig](/docs/transformers/main/ko/model_doc/edgetam_video#transformers.EdgeTamVideoPromptEncoderConfig)를 초기화하는 데 사용되는 구성 옵션의 사전입니다.

mask_decoder_config (Union[`dict`, `EdgeTamVideoMaskDecoderConfig`], *optional*) : [EdgeTamMaskDecoderConfig](/docs/transformers/main/ko/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig)를 초기화하는 데 사용되는 구성 옵션의 사전.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

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`, *선택 사항*, 기본값 2) : 메모리 어텐션 모듈의 레이어 수입니다.

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

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

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

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

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

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

memory_attention_rope_k_sizes (`List[int]`, *선택 사항*, 기본값 `[16, 16]`) : 메모리 어텐션에서 RoPE 위치 인코딩에 사용되는 주요 특징 크기입니다.

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

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

perceiver_resampler_num_latents (`int`, *선택 사항*, 기본값 256) : perceiver resampler의 1D latent 토큰 수입니다.

perceiver_resampler_num_latents_2d (`int`, *선택 사항*, 기본값 256) : perceiver resampler의 2D latent 토큰 수입니다.

perceiver_resampler_hidden_size (`int`, *선택 사항*, 기본값 64) : perceiver resampler의 hidden size입니다.

perceiver_resampler_mlp_intermediate_size (`int`, *선택 사항*, 기본값 256) : perceiver resampler의 feedforward 네트워크 중간 크기입니다.

perceiver_resampler_num_attention_heads (`int`, *선택 사항*, 기본값 1) : Perceiver resampler의 attention head 수입니다.

perceiver_resampler_attention_head_dim (`int`, *선택 사항*, 기본값 64) : perceiver resampler의 각 attention head 차원입니다.

perceiver_resampler_num_layers (`int`, *선택 사항*, 기본값 2) : perceiver resampler의 레이어 수입니다.

perceiver_resampler_hidden_dropout (`float`, *선택 사항*, 기본값 0.0) : perceiver resampler의 숨겨진 레이어에 적용되는 dropout rate입니다.

perceiver_resampler_attention_dropout (`float`, *선택 사항*, 기본값 0.0) : perceiver resampler의 attention 레이어에 적용되는 dropout rate입니다.

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

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

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

memory_fuser_intermediate_dim (`int`, *선택 사항*, 기본값 1024) : 메모리 퓨저 피드포워드 네트워크의 중간 차원입니다.

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_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"`) : 메모리 퓨저에서 사용되는 비선형 활성화 함수입니다.

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

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

예:

```python
>>> from transformers import (
...     EdgeTamVisionConfig,
...     EdgeTamVideoPromptEncoderConfig,
...     EdgeTamVideoMaskDecoderConfig,
...     EdgeTamVideoModel,
...     EdgeTamVideoConfig,
... )

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

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

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

>>> # We can also initialize a EdgeTamConfig from a EdgeTamVisionConfig, EdgeTamPromptEncoderConfig, and EdgeTamMaskDecoderConfig

>>> # Initializing EDGETAM vision encoder, memory attention, and memory encoder configurations
>>> vision_config = EdgeTamVisionConfig()
>>> prompt_encoder_config = EdgeTamVideoPromptEncoderConfig()
>>> mask_decoder_config = EdgeTamVideoMaskDecoderConfig()

>>> config = EdgeTamVideoConfig(vision_config, prompt_encoder_config, mask_decoder_config)
```

## EdgeTamVideoInferenceSession[[transformers.EdgeTamVideoInferenceSession]]

#### transformers.EdgeTamVideoInferenceSession[[transformers.EdgeTamVideoInferenceSession]]

```python
transformers.EdgeTamVideoInferenceSession(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/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L942)

**매개변수:**

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.EdgeTamVideoInferenceSession.add_mask_inputs]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1062)

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

#### add_new_frame[[transformers.EdgeTamVideoInferenceSession.add_new_frame]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1137)

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

#### add_point_inputs[[transformers.EdgeTamVideoInferenceSession.add_point_inputs]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1048)

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

#### get_frame[[transformers.EdgeTamVideoInferenceSession.get_frame]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1153)

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

#### get_obj_num[[transformers.EdgeTamVideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1043)

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

#### get_output[[transformers.EdgeTamVideoInferenceSession.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/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1110)

**매개변수:**

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

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

output_key (str) : 출력의 키.

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

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

#### obj_id_to_idx[[transformers.EdgeTamVideoInferenceSession.obj_id_to_idx]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1017)

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

#### obj_idx_to_id[[transformers.EdgeTamVideoInferenceSession.obj_idx_to_id]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1039)

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

#### remove_mask_inputs[[transformers.EdgeTamVideoInferenceSession.remove_mask_inputs]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1068)

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

#### remove_point_inputs[[transformers.EdgeTamVideoInferenceSession.remove_point_inputs]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1058)

점 입력을 제거합니다.

#### reset_inference_session[[transformers.EdgeTamVideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1169)

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

#### reset_tracking_data[[transformers.EdgeTamVideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1157)

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

#### store_output[[transformers.EdgeTamVideoInferenceSession.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/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L1073)

**매개변수:**

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인 경우, 출력은 사전으로 저장됩니다.

## EdgeTamVideoModel[[transformers.EdgeTamVideoModel]]

#### transformers.EdgeTamVideoModel[[transformers.EdgeTamVideoModel]]

```python
transformers.EdgeTamVideoModel(config: EdgeTamVideoConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2062)

**매개변수:**

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

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

이 모델은 [PreTrainedModel](/docs/transformers/main/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.EdgeTamVideoModel.forward]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2196)

**매개변수:**

inference_session (`~models.edgetam_video.modeling_edgetam_video.EdgeTamVideoInferenceSession`) : 비디오 추론 세션 객체.

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

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

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

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

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

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

- **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.EdgeTamVideoModel.get_image_features]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/modeling_edgetam_video.py#L2295)

**매개변수:**

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

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

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

- **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입니다.