# EdgeTAMVideo

## Visão geral

O modelo EdgeTAM foi proposto em [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 é uma adaptação eficiente do SAM 2 que introduz uma arquitetura 2D Spatial Perceiver para otimizar os mecanismos de atenção de memória para segmentação de vídeo em tempo real em dispositivos móveis.

O resumo do artigo é o seguinte:

*Além do Segment Anything Model (SAM), o SAM 2 estende ainda mais sua capacidade de imagens para entradas de vídeo por meio de um mecanismo de banco de memória e obtém um desempenho notável em comparação com métodos anteriores, tornando-o um modelo de base para a tarefa de segmentação de vídeo. Neste artigo, nosso objetivo é tornar o SAM 2 muito mais eficiente, de modo que ele possa ser executado em dispositivos móveis mantendo um desempenho comparável. Apesar de vários trabalhos que otimizam o SAM para uma melhor eficiência, constatamos que eles não são suficientes para o SAM 2, pois todos se concentram na compressão do codificador de imagem, enquanto nosso benchmark mostra que os novos blocos de atenção de memória introduzidos também são o gargalo de latência. Dada essa observação, propomos o EdgeTAM, que utiliza um novo 2D Spatial Perceiver para reduzir o custo computacional. Em particular, o 2D Spatial Perceiver proposto codifica as memórias de nível de quadro armazenadas de forma densa com um Transformer leve que contém um conjunto fixo de consultas aprendíveis. Dado que a segmentação de vídeo é uma tarefa de predição densa, constatamos que preservar a estrutura espacial das memórias é essencial, de modo que as consultas são divididas em grupos de nível global e de nível de patch. Também propomos um pipeline de destilação que melhora ainda mais o desempenho sem sobrecarga de inferência. Como resultado, o EdgeTAM alcança 87,7, 70,0, 72,3 e 71,7 J&F em DAVIS 2017, MOSE, SA-V val e SA-V test, enquanto é executado a 16 FPS no iPhone 15 Pro Max.*

Este modelo foi contribuído por [yonigozlan](https://huggingface.co/yonigozlan). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/EdgeTAM).

## Exemplo de uso

### Segmentação e Rastreamento de Vídeo

A principal vantagem do EdgeTAM Video é a capacidade de rastrear objetos entre os quadros de um vídeo de forma eficiente em dispositivos móveis. Veja como usá-lo para segmentação de vídeo:

#### Rastreamento básico de vídeo

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

#### Rastreamento de Vídeo Multi-Objeto

Rastreie vários objetos simultaneamente entre os quadros de um vídeo:

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

#### Refinamento da segmentação de vídeo

Você pode adicionar cliques adicionais em qualquer quadro para refinar o rastreamento:

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

### Inferência de Vídeo em Streaming

Para aplicações em tempo real, o EdgeTAM Video suporta o processamento de quadros de vídeo à medida que chegam:

```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])
...
```

#### Processamento em Lote de Vídeos para Múltiplos Objetos

Rastreie vários objetos simultaneamente em um vídeo adicionando todos de uma vez:

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L57)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

mlp_dim (`int`, *opcional*, padrão 2048) : A dimensão do MLP no transformer bidirecional.

num_hidden_layers (`int`, *opcional*, padrão `2`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

attention_downsample_rate (`int`, *opcional*, padrão 2) : A taxa de downsampling para as camadas de atenção.

num_multimask_outputs (`int`, *opcional*, padrão 3) : O número de saídas multimask.

iou_head_depth (`int`, *opcional*, padrão 3) : A profundidade da cabeça de IoU.

iou_head_hidden_dim (`int`, *opcional*, padrão 256) : A dimensão oculta da cabeça de IoU.

dynamic_multimask_via_stability (`bool`, *opcional*, padrão `True`) : Se deve usar a multimáscara dinâmica via estabilidade.

dynamic_multimask_stability_delta (`float`, *opcional*, padrão 0.05) : O delta de estabilidade para a multimáscara dinâmica.

dynamic_multimask_stability_thresh (`float`, *opcional*, padrão 0.98) : O limiar de estabilidade para a multimáscara dinâmica.

Esta é a classe de configuração para armazenar a configuração de um EdgeTamVideoModel. Ela é usada para instanciar um modelo Edgetam Video de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L32)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `1024`) : O tamanho (resolução) de cada imagem.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch.

mask_input_channels (`int`, *opcional*, padrão 16) : O número de canais a serem enviados para o módulo `MaskDecoder`.

num_point_embeddings (`int`, *opcional*, padrão 4) : O número de embeddings de pontos a serem usados.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

scale (`float`, *opcional*, padrão 1) : O fator de escala para o codificador de prompt.

Esta é a classe de configuração para armazenar a configuração de um EdgeTamVideoModel. Ela é usada para instanciar um modelo Edgetam Video de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam_video/configuration_edgetam_video.py#L96)

**Parâmetros:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão.

prompt_encoder_config (Union[`dict`, `EdgeTamVideoPromptEncoderConfig`], *opcional*) : Dicionário de opções de configuração usadas para inicializar [EdgeTamVideoPromptEncoderConfig](/docs/transformers/main/pt/model_doc/edgetam_video#transformers.EdgeTamVideoPromptEncoderConfig).

mask_decoder_config (Union[`dict`, `EdgeTamVideoMaskDecoderConfig`], *opcional*) : Dicionário de opções de configuração usadas para inicializar [EdgeTamMaskDecoderConfig](/docs/transformers/main/pt/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig).

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

num_maskmem (`int`, *opcional*, padrão 7) : O número de slots de memória para a memória de máscara.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `1024`) : O tamanho (resolução) de cada imagem.

sigmoid_scale_for_mem_enc (`float`, *opcional*, padrão 20.0) : Fator de escala para a função sigmoid no codificador de memória.

sigmoid_bias_for_mem_enc (`float`, *opcional*, padrão -10.0) : Viés para a função sigmoid no codificador de memória.

enable_occlusion_spatial_embedding (`bool`, *opcional*, padrão `True`) : Se deve habilitar o incorporamento espacial para oclusões.

multimask_output_in_sam (`bool`, *opcional*, padrão `True`) : Se deve gerar múltiplas máscaras a partir da cabeça do SAM.

multimask_min_pt_num (`int`, *opcional*, padrão 0) : O número mínimo de pontos para acionar a saída multimask.

multimask_max_pt_num (`int`, *opcional*, padrão 1) : O número máximo de pontos para acionar a saída multimask.

multimask_output_for_tracking (`bool`, *opcional*, padrão `True`) : Se deve usar a saída multimask para rastreamento.

max_object_pointers_in_encoder (`int`, *opcional*, padrão 16) : O número máximo de ponteiros de objetos no codificador.

max_cond_frame_num (`int`, *opcional*, padrão -1) : Número máximo de frames de condicionamento a serem usados na atenção em memória. Defina como -1 para usar todos os frames de condicionamento.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *opcional*, padrão `True`) : Se deve habilitar a codificação posicional temporal para ponteiros de objeto.

memory_attention_hidden_size (`int`, *opcional*, padrão 256) : Dimensionalidade dos estados ocultos da atenção de memória.

memory_attention_num_layers (`int`, *opcional*, padrão 2) : O número de camadas no módulo de atenção de memória.

memory_attention_num_attention_heads (`int`, *opcional*, padrão 1) : Número de cabeças de atenção para cada camada de atenção na atenção de memória.

memory_attention_downsample_rate (`int`, *opcional*, padrão 1) : A taxa de downsampling para as camadas de atenção.

memory_attention_mlp_hidden_size (`int`, *opcional*, padrão 2048) : A dimensão da rede feedforward no módulo de atenção de memória.

memory_attention_mlp_hidden_act (`str`, *opcional*, padrão `"relu"`) : A função de ativação não linear na rede feedforward do módulo de atenção de memória.

memory_attention_dropout (`float`, *opcional*, padrão 0.1) : A taxa de dropout para o módulo de atenção de memória.

memory_attention_rope_feat_sizes (`Tuple[int, int]`, *opcional*, padrão `[64, 64]`) : Os tamanhos dos recursos para a codificação posicional Rope.

memory_attention_rope_k_sizes (`List[int]`, *opcional*, padrão `[16, 16]`) : Os tamanhos das dimensões das chaves para a codificação posicional RoPE na atenção de memória.

memory_attention_rope_dropout (`float`, *opcional*, padrão 0.1) : A taxa de dropout para a codificação posicional Rope.

rope_parameters (`dict`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

perceiver_resampler_num_latents (`int`, *opcional*, padrão 256) : O número de tokens latentes 1D no perceiver resampler.

perceiver_resampler_num_latents_2d (`int`, *opcional*, padrão 256) : O número de tokens latentes 2D no perceiver resampler.

perceiver_resampler_hidden_size (`int`, *opcional*, padrão 64) : O tamanho oculto do perceiver resampler.

perceiver_resampler_mlp_intermediate_size (`int`, *opcional*, padrão 256) : O tamanho intermediário da rede feedforward no perceiver resampler.

perceiver_resampler_num_attention_heads (`int`, *opcional*, padrão 1) : O número de cabeças de atenção no perceiver resampler.

perceiver_resampler_attention_head_dim (`int`, *opcional*, padrão 64) : A dimensão de cada cabeça de atenção no perceiver resampler.

perceiver_resampler_num_layers (`int`, *opcional*, padrão 2) : O número de camadas no perceiver resampler.

perceiver_resampler_hidden_dropout (`float`, *opcional*, padrão 0.0) : A taxa de dropout para as camadas ocultas no perceiver resampler.

perceiver_resampler_attention_dropout (`float`, *opcional*, padrão 0.0) : A taxa de dropout para as camadas de atenção no perceiver resampler.

memory_encoder_hidden_size (`int`, *opcional*, padrão 256) : Dimensionalidade dos estados ocultos do codificador de memória.

memory_encoder_output_channels (`int`, *opcional*, padrão 64) : O número de canais de saída para o codificador de memória.

mask_downsampler_embed_dim (`int`, *opcional*, padrão 256) : A dimensão do embedding do downsampler da máscara.

memory_fuser_intermediate_dim (`int`, *opcional*, padrão 1024) : A dimensão intermediária da rede feedforward do fuser de memória.

mask_downsampler_kernel_size (`int`, *opcional*, padrão 3) : O tamanho do kernel para o redutor de resolução da máscara.

mask_downsampler_stride (`int`, *opcional*, padrão 2) : O stride para o downsampler da máscara.

mask_downsampler_padding (`int`, *opcional*, padrão 1) : O padding para o downsampler da máscara.

mask_downsampler_total_stride (`int`, *opcional*, padrão 16) : O stride total para o downsampler da máscara.

mask_downsampler_hidden_act (`str`, *opcional*, padrão `"gelu"`) : A função de ativação não linear no redutor de máscara.

memory_fuser_num_layers (`int`, *opcional*, padrão 2) : O número de camadas no fuser de memória.

memory_fuser_embed_dim (`int`, *opcional*, padrão 256) : A dimensão do embedding do fuser de memória.

memory_fuser_kernel_size (`int`, *opcional*, padrão 7) : O tamanho do kernel para o fusor de memória.

memory_fuser_padding (`int`, *opcional*, padrão 3) : O padding para o fuser de memória.

memory_fuser_layer_scale_init_value (`float`, *opcional*, padrão 1e-06) : O valor inicial para a escala da camada no fuser de memória.

memory_fuser_hidden_act (`str`, *opcional*, padrão `"gelu"`) : A função de ativação não linear no fuser de memória.

Esta é a classe de configuração para armazenar a configuração de um EdgeTamVideoModel. Ela é usada para instanciar um modelo Edgetam Video de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

video (`torch.Tensor`, *opcional*) : O vídeo a ser processado. Não é necessário fornecer durante o streaming.

video_height (`int`, *opcional*) : A altura do vídeo.

video_width (`int`, *opcional*) : A largura do vídeo.

inference_device (`torch.device`, *opcional*, padrão `"cpu"`) : O dispositivo a ser usado para inferência.

inference_state_device (`torch.device`, *opcional*, padrão `"cpu"`) : O dispositivo em que o estado de inferência será armazenado.

video_storage_device (`torch.device`, *opcional*, padrão `"cpu"`) : O dispositivo em que o vídeo será armazenado.

dtype (`torch.dtype`, *opcional*, padrão `"float32"`) : O dtype a ser usado para o vídeo.

max_vision_features_cache_size (`int`, *opcional*, padrão 1) : O número máximo de recursos visuais a serem armazenados em cache.

Gerencia os parâmetros, o estado e o cache da sessão de inferência de vídeo.

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

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

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

Adicione entradas de máscara com posicionamento automático de dispositivo.

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

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

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

Adicione um novo frame com posicionamento automático de dispositivo.

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

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

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

Adicione entradas de ponto com posicionamento automático de dispositivo.

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

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

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

Obter quadro do vídeo.

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

```python
get_obj_num()
```

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

Obtenha o número total de ids de objetos únicos recebidos até o momento nesta sessão.

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

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

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

**Parâmetros:**

obj_idx (int) : O índice do objeto.

frame_idx (int) : O índice do quadro.

output_key (str) : A chave da saída.

is_conditioning_frame (bool) : Indica se a saída é para um quadro de condicionamento.

Obtenha a saída com gerenciamento inteligente de dispositivos.

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

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

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

Mapeia o ID do objeto para o índice, criando uma nova entrada, se necessário.

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

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

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

Mapeia o índice do objeto no lado do modelo para o id do objeto no lado do cliente.

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

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

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

Remova as entradas de máscara.

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

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

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

Remova as entradas de ponto.

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

```python
reset_inference_session()
```

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

Redefinir os dados de rastreamento e o cache.

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

```python
reset_tracking_data()
```

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

Redefinir os dados de rastreamento, mas manter o cache.

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

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

**Parâmetros:**

obj_idx (int) : O índice do objeto.

frame_idx (int) : O índice do quadro.

output_key (Optional[str]) : A chave da saída. Se for None, a saída é armazenada como um dicionário.

output_value (Optional[Union[torch.Tensor, dict]]) : O valor da saída.

is_conditioning_frame (bool) : Indica se a saída é para um quadro de condicionamento.

Armazene a saída com gerenciamento inteligente de dispositivos. Se output_key for None, a saída é armazenada como um dicionário.

## EdgeTamVideoModel[[transformers.EdgeTamVideoModel]]

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

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

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

**Parâmetros:**

config ([EdgeTamVideoConfig](/docs/transformers/main/pt/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Edgetam Video básico, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

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

**Parâmetros:**

inference_session (`~models.edgetam_video.modeling_edgetam_video.EdgeTamVideoInferenceSession`) : O objeto de sessão de inferência de vídeo.

frame_idx (`int`, *opcional*) : O índice do quadro em que a inferência será executada. Não é necessário fornecer ao inferir em um novo quadro transmitido.

frame (`torch.Tensor`, *opcional*) : O frame a ser processado. Forneça ao transmitir em streaming.

reverse (`bool`, *opcional*, padrão `False`) : Se deve propagar em sentido inverso.

**Retorna:** `EdgeTamVideoSegmentationOutput` ou `tuple(torch.Tensor)`

Um `EdgeTamVideoSegmentationOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EdgeTamVideoConfig](/docs/transformers/main/pt/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) e das entradas.

Propague os objetos por meio de um quadro de vídeo transmitido.

- **object_ids** (`list[int]`, *opcional*) -- Lista dos IDs de objetos rastreados no quadro atual.
- **pred_masks** (`torch.Tensor` de forma `(batch_size, num_masks, height, width)`) -- As máscaras previstas armazenadas na resolução do modelo.
- **object_score_logits** (`torch.Tensor` de forma `(batch_size,)`, *opcional*) -- Logits para as pontuações dos objetos, indicando se os objetos estão presentes.
- **frame_idx** (`int`, *opcional*) -- O índice do quadro do vídeo.

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

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

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

**Parâmetros:**

pixel_values (`torch.Tensor`) : Valores de pixels de entrada com forma `(batch_size, num_channels, height, width)`.

**Retorna:** `EdgeTamVideoVisionEncoderOutput` ou `tuple(torch.Tensor)`

Uma `EdgeTamVideoVisionEncoderOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EdgeTamVideoConfig](/docs/transformers/main/pt/model_doc/edgetam_video#transformers.EdgeTamVideoConfig)) e das entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, height, width, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- Tupla de `torch.Tensor` (um para cada nível de recurso, da resolução mais alta para a mais baixa) com forma `(batch_size, hidden_size, height, width)`. Mapas de recursos do pescoço da Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- Tupla de `torch.Tensor` (um para cada nível de recurso, da resolução mais alta para a mais baixa) com forma `(batch_size, hidden_size, height, width)`. Codificações posicionais correspondentes às `fpn_hidden_states`.