# 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を用いて、高密度に保存されたフレームレベルのメモリをエンコードします。動画セグメンテーションは高密度予測タスクであるため、クエリをグローバルレベルとパッチレベルのグループに分割することで、メモリの空間構造を保持することが不可欠であると判明しました。さらに、推論時のオーバーヘッドなしで性能をさらに向上させる蒸留パイプラインも提案します。その結果、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) で確認できます。

## 使用例

### Video Segmentation and Tracking

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`、*optional*、デフォルトは 2048) : 2-way transformer における MLP の次元数。

num_hidden_layers (`int`、*任意*、デフォルトは `2`) : Transformer デコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

attention_downsample_rate (`int`、*optional*、デフォルトは 2) : アテンション層のダウンサンプル率です。

num_multimask_outputs (`int`、*任意*、デフォルトは 3) : マルチマスク出力の数。

iou_head_depth (`int`、*optional*、デフォルトは 3) : IoU ヘッドの深さ。

iou_head_hidden_dim (`int`、*optional*、デフォルトは 256) : IoU ヘッドの隠れ次元です。

dynamic_multimask_via_stability (`bool`、*任意*、デフォルトは `True`) : stability を用いた動的マルチマスクを使用するかどうか。

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) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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`) : Layer Normalization 層で使用する epsilon です。

scale (`float`、*任意*、デフォルトは 1) : プロンプトエンコーダーのスケール係数です。

これは EdgeTamVideoModel の設定を保存するための設定クラスです。指定された引数に基づいて Edgetam Video モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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 オブジェクトまたは辞書。

prompt_encoder_config (Union[`dict`, `EdgeTamVideoPromptEncoderConfig`], *optional*) : [EdgeTamVideoPromptEncoderConfig](/docs/transformers/main/ja/model_doc/edgetam_video#transformers.EdgeTamVideoPromptEncoderConfig) を初期化するために使用される設定オプションの辞書。

mask_decoder_config (Union[`dict`, `EdgeTamVideoMaskDecoderConfig`], *optional*) : [EdgeTamMaskDecoderConfig](/docs/transformers/main/ja/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`) : 遮蔽に対する空間埋め込みを有効にするかどうか。

multimask_output_in_sam (`bool`、*任意*、デフォルトは `True`) : SAM ヘッドから複数のマスクを出力するかどうかを指定します。

multimask_min_pt_num (`int`、*任意*、デフォルトは 0) : マルチマスク出力をトリガーするための最小ポイント数。

multimask_max_pt_num (`int`、*optional*、デフォルトは 1) : マルチマスク出力をトリガーする最大ポイント数。

multimask_output_for_tracking (`bool`、*任意*、デフォルトは `True`) : トラッキングにマルチマスク出力を使用するかどうか。

max_object_pointers_in_encoder (`int`、*optional*、デフォルトは 16) : エンコーダー内のオブジェクトポインタの最大数。

max_cond_frame_num (`int`、*optional*、デフォルトは -1) : メモリアテンションで使用する条件付けフレームの最大数です。すべての条件付けフレームを使用するには -1 を設定してください。

enable_temporal_pos_encoding_for_object_pointers (`bool`、*任意*、デフォルトは`True`) : オブジェクトポインタに対して時間的位置エンコーディングを有効にするかどうか。

memory_attention_hidden_size (`int`、*optional*、デフォルトは 256) : メモリアテンションの隠れ状態の次元数。

memory_attention_num_layers (`int`、*optional*、デフォルトは 2) : メモリアテンションモジュールの層数。

memory_attention_num_attention_heads (`int`、*任意*、デフォルトは 1) : メモリアテンションにおける各アテンション層のアテンションヘッド数。

memory_attention_downsample_rate (`int`、*optional*、デフォルトは 1) : attention レイヤーのダウンサンプル率です。

memory_attention_mlp_hidden_size (`int`、*任意*、デフォルトは 2048) : メモリアテンションモジュールにおけるフィードフォワードネットワークの次元です。

memory_attention_mlp_hidden_act (`str`、*任意*、デフォルトは `"relu"`) : メモリアテンションモジュール内のフィードフォワードネットワークで使用する非線形活性化関数。

memory_attention_dropout (`float`、*任意*、デフォルトは 0.1) : メモリ注意機構の dropout 率です。

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 レートです。

rope_parameters (`dict`, *任意*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれており、より長い `max_position_embeddings` で RoPE を使用する場合にスケーリングに使用されるパラメータが任意で含まれます。

perceiver_resampler_num_latents (`int`、*任意*、デフォルトは 256) : perceiver resampler における 1 次元潜在トークンの数。

perceiver_resampler_num_latents_2d (`int`、*optional*、デフォルトは 256) : perceiver resampler における 2D 潜在トークンの数。

perceiver_resampler_hidden_size (`int`、*任意*、デフォルトは 64) : perceiver resampler の隠れ層サイズです。

perceiver_resampler_mlp_intermediate_size (`int`、*任意*、デフォルトは 256) : perceiver resampler におけるフィードフォワードネットワークの中間サイズです。

perceiver_resampler_num_attention_heads (`int`、*任意*、デフォルトは 1) : perceiver resampler のアテンションヘッド数。

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 のアテンション層における dropout rate です。

memory_encoder_hidden_size (`int`、*任意*、デフォルトは 256) : メモリエンコーダーの隠れ状態の次元数。

memory_encoder_output_channels (`int`、*optional*、デフォルトは 64) : メモリエンコーダーの出力チャネル数です。

mask_downsampler_embed_dim (`int`、*optional*、デフォルトは 256) : マスクダウンサンプラーの埋め込みの次元数。

memory_fuser_intermediate_dim (`int`、*任意*、デフォルトは 1024) : メモリフューザーのフィードフォワードネットワークの中間次元です。

mask_downsampler_kernel_size (`int`、*optional*、デフォルトは 3) : マスクダウンサンプラーのカーネルサイズです。

mask_downsampler_stride (`int`、*optional*、デフォルトは 2) : マスクダウンサンプラーのストライドです。

mask_downsampler_padding (`int`、*optional*、デフォルトは 1) : マスクダウンサンプラーのパディング。

mask_downsampler_total_stride (`int`、*任意*、デフォルトは 16) : マスクダウンサンプラーの総ストライド。

mask_downsampler_hidden_act (`str`、*任意*、デフォルトは `"gelu"`) : マスクダウンサンプラーで使用する非線形活性化関数。

memory_fuser_num_layers (`int`、*optional*、デフォルトは 2) : メモリフューザーのレイヤー数。

memory_fuser_embed_dim (`int`、*optional*、デフォルトは 256) : メモリフューザー埋め込みの次元数です。

memory_fuser_kernel_size (`int`、*optional*、デフォルトは 7) : メモリフューザーのカーネルサイズです。

memory_fuser_padding (`int`、*任意*、デフォルトは 3) : メモリフューザーの padding です。

memory_fuser_layer_scale_init_value (`float`、*任意*、デフォルト値は 1e-06) : メモリフュージョンにおけるレイヤースケールの初期値です。

memory_fuser_hidden_act (`str`、*任意*、デフォルトは`"gelu"`) : メモリフューザーで使用する非線形活性化関数。

これは EdgeTamVideoModel の設定を保存するための設定クラスです。指定された引数に基づいて Edgetam Video モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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.FloatTensor] = 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.FloatTensor`、*任意*) : 処理対象の動画。ストリーミング時には指定する必要はありません。

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`、*optional*、デフォルトは 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)

自動的なデバイス配置を備えたマスク入力を追加します。

#### 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)

自動的なデバイス配置で新しいフレームを追加します。

#### 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)

自動的なデバイス配置を備えたポイント入力を追加します。

#### 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)

必要に応じて新しいエントリを作成し、オブジェクト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/ja/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

特定のヘッドを上に載せずに、生のhidden-statesを出力する、素のEdgetam Video Modelです。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/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`, *optional*) : 推論を実行するフレームのインデックスです。新しいストリームされたフレームに対して推論を行う場合は、指定する必要はありません。

frame (`torch.Tensor`, *任意*) : 処理するフレーム。ストリーミングの場合に指定します。

reverse (`bool`、*任意*、デフォルトは`False`) : 逆方向に伝播するかどうか。

**戻り値:** `EdgeTamVideoSegmentationOutput` または `tuple(torch.FloatTensor)`

`EdgeTamVideoSegmentationOutput`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[EdgeTamVideoConfig](/docs/transformers/main/ja/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)）と入力に応じて、さまざまな要素で構成されます。

ストリーミングされた動画フレームを通じてオブジェクトを伝播させます。

- **object_ids** (`list[int]`、*任意*) -- 現在のフレームで追跡されているオブジェクトのIDのリスト。
- **pred_masks** (`torch.FloatTensor`、shape `(batch_size, num_masks, height, width)`) -- モデルの解像度で保存された予測マスク。
- **object_score_logits** (`torch.FloatTensor`、shape `(batch_size,)`、*任意*) -- オブジェクトが存在するかどうかを示す、オブジェクトスコアの logits。
- **frame_idx** (`int`, *任意*) -- 動画のフレームインデックス。

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

```python
get_image_features(pixel_values: FloatTensor, **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.FloatTensor`) : 形状が `(batch_size, num_channels, height, width)` の入力ピクセル値。

**戻り値:** `EdgeTamVideoVisionEncoderOutput` または `tuple(torch.FloatTensor)`

`EdgeTamVideoVisionEncoderOutput`、または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。設定（[EdgeTamVideoConfig](/docs/transformers/main/ja/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)）や入力に応じて、さまざまな要素で構成されます。

- **last_hidden_state** (`torch.FloatTensor`、形状 `(batch_size, height, width, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **fpn_hidden_states** (`tuple(torch.FloatTensor)`) -- 各特徴レベル（高解像度から低解像度へ）に対応する `torch.FloatTensor` のタプルで、形状は `(batch_size, hidden_size, height, width)` です。Feature Pyramid Network のネック部からの特徴マップです。
- **fpn_position_encoding** (`tuple(torch.FloatTensor)`) -- 各特徴レベル（高解像度から低解像度へ）に対応する `torch.FloatTensor` のタプルで、形状は `(batch_size, hidden_size, height, width)` です。`fpn_hidden_states` に対応する位置エンコーディングです。