# SAM3 Rastreador de Vídeo

    
        
        
    

## Visão geral

SAM3 (Segment Anything Model 3) foi introduzido em [SAM 3: Segment Anything with Concepts](https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/).

O Sam3TrackerVideo executa **Segmentação Visual Promptável (PVS)** em vídeos. O PVS utiliza prompts visuais interativos (pontos, caixas, máscaras) ou entradas de texto para rastrear uma **instância de objeto específica** por prompt ao longo dos quadros do vídeo.

Sam3TrackerVideo é uma versão atualizada do SAM2 Video que mantém a mesma API, ao mesmo tempo em que oferece desempenho e capacidades aprimorados.

O resumo do artigo é o seguinte:

*Apresentamos o Segment Anything Model (SAM) 3, um modelo unificado que detecta, segmenta e rastreia objetos em imagens e vídeos com base em prompts de conceito, que definimos como frases nominais curtas (por exemplo, "yellow school bus"), exemplares de imagem ou uma combinação de ambos. A Segmentação de Conceitos Promptável (PCS) recebe esses prompts e retorna máscaras de segmentação e identidades únicas para todas as instâncias de objetos correspondentes. Para avançar a PCS, construímos um motor de dados escalável que produz um conjunto de dados de alta qualidade com 4M rótulos de conceito únicos, incluindo negativos difíceis, em imagens e vídeos. Nosso modelo consiste em um detector de nível de imagem e um rastreador de vídeo baseado em memória que compartilham um único backbone. O reconhecimento e a localização são desacoplados por meio de uma presença head, o que aumenta a precisão da detecção. O SAM 3 dobra a precisão dos sistemas existentes tanto na PCS de imagem quanto na de vídeo, e melhora as capacidades anteriores do SAM em tarefas de segmentação visual. Tornamos o SAM 3 open source, juntamente com nosso novo benchmark Segment Anything with Concepts (SA-Co) para segmentação de conceitos promptável.*

Este modelo foi contribuído por [yonigozlan](https://huggingface.co/yonigozlan) e [ronghanghu](https://huggingface.co/ronghanghu).

## Exemplo de uso

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

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

```python
from transformers import Sam3TrackerVideoModel, Sam3TrackerVideoProcessor
import torch

model = Sam3TrackerVideoModel.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3TrackerVideoProcessor.from_pretrained("facebook/sam3")

# 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 (optional, you can also propagate the masks through the video directly)
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)
video_res_masks = processor.post_process_masks(
    [outputs.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
)[0]
print(f"Segmentation shape: {video_res_masks.shape}")
Segmentation shape: torch.Size([1, 1, 480, 854])

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

print(f"Tracked object through {len(video_segments)} frames")
Tracked object through 180 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 (optional, you can also propagate the masks through the video directly)
outputs = model(
    inference_session=inference_session,
    frame_idx=ann_frame_idx,
)

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

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

#### 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 sam3_tracker_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam3_tracker_video_output.frame_idx] = video_res_masks
```

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

Para aplicações em tempo real, o Sam3TrackerVideo 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
    sam3_tracker_video_output = model(inference_session=inference_session, frame=inputs.pixel_values[0])
...
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=inputs.original_sizes, binarize=False
    )[0]
    print(f"Frame {frame_idx}: mask shape {video_res_masks.shape}")
```

#### 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 sam3_tracker_video_output in model.propagate_in_video_iterator(inference_session):
    video_res_masks = processor.post_process_masks(
        [sam3_tracker_video_output.pred_masks], original_sizes=[[inference_session.video_height, inference_session.video_width]], binarize=False
    )[0]
    video_segments[sam3_tracker_video_output.frame_idx] = {
        obj_id: video_res_masks[i]
        for i, obj_id in enumerate(inference_session.obj_ids)
    }

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

## Sam3TrackerVideoConfig[[transformers.Sam3TrackerVideoConfig]]

#### transformers.Sam3TrackerVideoConfig[[transformers.Sam3TrackerVideoConfig]]

```python
transformers.Sam3TrackerVideoConfig(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, 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 = 4, enable_temporal_pos_encoding_for_object_pointers: bool = True, memory_attention_hidden_size: int = 256, memory_attention_num_layers: int = 4, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_feed_forward_hidden_size: int = 2048, memory_attention_feed_forward_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list | None = None, memory_attention_rope_dropout: float | int = 0.1, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, rope_parameters: dict | None = None, mask_downsampler_embed_dim: int = 256, mask_downsampler_kernel_size: int = 3, mask_downsampler_stride: int = 2, mask_downsampler_padding: int = 1, mask_downsampler_total_stride: int = 16, mask_downsampler_hidden_act: str = 'gelu', memory_fuser_num_layers: int = 2, memory_fuser_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, memory_fuser_kernel_size: int = 7, memory_fuser_padding: int = 3, memory_fuser_layer_scale_init_value: float = 1e-06, memory_fuser_hidden_act: str = 'gelu')
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/configuration_sam3_tracker_video.py#L99)

**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`, `Sam3TrackerVideoPromptEncoderConfig`], *opcional*) : Dicionário de opções de configuração usadas para inicializar [Sam3TrackerVideoPromptEncoderConfig](/docs/transformers/main/pt/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoPromptEncoderConfig).

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

initializer_range (`float`, *opcional*, padrão 0.02) : Desvio padrão para a inicialização dos parâmetros.

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

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 4) : Número máximo de quadros de condicionamento a serem usados na atenção de memória.

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 4) : 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_feed_forward_hidden_size (`int`, *opcional*, padrão 2048) : A dimensão da rede feedforward no módulo de atenção de memória.

memory_attention_feed_forward_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 (`list[int]`, *opcional*, padrão `[72, 72]`) : Os tamanhos dos recursos para a codificação posicional Rope.

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

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.

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.

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

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 da camada de incorporação no fuser de memória.

memory_fuser_intermediate_dim (`int`, *opcional*, padrão 1024) : A dimensão da camada intermediária no 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 Sam3TrackerVideoModel. Ela é usada para instanciar um modelo Sam3 Tracker 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 [facebook/sam3](https://huggingface.co/facebook/sam3)

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 (
...     Sam3VisionConfig,
...     Sam3TrackerVideoPromptEncoderConfig,
...     Sam3TrackerVideoMaskDecoderConfig,
...     Sam3TrackerVideoModel,
... )

>>> # Initializing a Sam3TrackerVideoConfig with `"facebook/sam3"` style configuration
>>> configuration = Sam3TrackerVideoConfig()

>>> # Initializing a Sam3TrackerVideoModel (with random weights) from the `"facebook/sam3"` style configuration
>>> model = Sam3TrackerVideoModel(configuration)

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

>>> # We can also initialize a Sam3TrackerVideoConfig from a Sam3TrackerVideoVisionConfig, Sam3TrackerVideoPromptEncoderConfig, and Sam3TrackerVideoMaskDecoderConfig

>>> # Initializing SAM3 tracker video vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam3TrackerVideoVisionConfig()
>>> prompt_encoder_config = Sam3TrackerVideoPromptEncoderConfig()
>>> mask_decoder_config = Sam3TrackerVideoMaskDecoderConfig()

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

## Sam3TrackerVideoMaskDecoderConfig[[transformers.Sam3TrackerVideoMaskDecoderConfig]]

#### transformers.Sam3TrackerVideoMaskDecoderConfig[[transformers.Sam3TrackerVideoMaskDecoderConfig]]

```python
transformers.Sam3TrackerVideoMaskDecoderConfig(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/sam3_tracker_video/configuration_sam3_tracker_video.py#L60)

**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 Sam3TrackerVideoModel. Ela é usada para instanciar um modelo Sam3 Tracker 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 [facebook/sam3](https://huggingface.co/facebook/sam3)

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.

## Sam3TrackerVideoPromptEncoderConfig[[transformers.Sam3TrackerVideoPromptEncoderConfig]]

#### transformers.Sam3TrackerVideoPromptEncoderConfig[[transformers.Sam3TrackerVideoPromptEncoderConfig]]

```python
transformers.Sam3TrackerVideoPromptEncoderConfig(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] = 1008, patch_size: int | list[int] | tuple[int, int] = 14, 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/sam3_tracker_video/configuration_sam3_tracker_video.py#L34)

**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 `1008`) : O tamanho (resolução) de cada imagem.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `14`) : 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 Sam3TrackerVideoModel. Ela é usada para instanciar um modelo Sam3 Tracker 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 [facebook/sam3](https://huggingface.co/facebook/sam3)

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.

## Sam3TrackerVideoProcessor[[transformers.Sam3TrackerVideoProcessor]]

#### transformers.Sam3TrackerVideoProcessor[[transformers.Sam3TrackerVideoProcessor]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L39)

**Parâmetros:**

image_processor (`Sam3ImageProcessor`) : O processador de imagem é uma entrada obrigatória.

video_processor (`video_processor_class`) : O processador de vídeo é uma entrada obrigatória.

target_size (`int`, *opcional*) : O tamanho alvo (em pixels) para normalizar pontos de entrada e caixas delimitadoras. Se não for fornecido, o padrão é a configuração de tamanho do processador de imagem. Todas as coordenadas de entrada (pontos e caixas) são normalizadas para esse tamanho antes de serem passadas ao modelo. Isso garante uma representação consistente das coordenadas, independentemente das dimensões originais da imagem.

point_pad_value (`int`, *opcional*, padrão -10) : O valor usado para preencher os pontos de entrada ao agrupar sequências de comprimentos diferentes. Esse valor é usado para marcar as posições preenchidas e é preservado durante a normalização de coordenadas.

Constrói um Sam3TrackerVideoProcessor que encapsula um processador de imagem e um processador de vídeo em um único processador.

[Sam3TrackerVideoProcessor](/docs/transformers/main/pt/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoProcessor) oferece todas as funcionalidades de [Sam3ImageProcessor](/docs/transformers/main/pt/model_doc/sam3#transformers.Sam3ImageProcessor) e `video_processor_class`. Consulte [~Sam3ImageProcessor](/docs/transformers/main/pt/model_doc/sam3#transformers.Sam3ImageProcessor) e `~video_processor_class` para mais informações.

#### __call__[[transformers.Sam3TrackerVideoProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, input_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = None, input_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, original_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

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

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

segmentation_maps (`ImageInput`, *opcional*) : Os mapas de segmentação a serem processados.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *opcional*) : Os pontos a serem adicionados ao frame.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *opcional*) : Os rótulos dos pontos.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opcional*) : As caixas delimitadoras a serem adicionadas ao quadro.

original_sizes (`list[list[float]]`, `torch.Tensor`, *opcional*) : Os tamanhos originais das imagens.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *opcional*) : Se definido, retornará tensors de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

**Retorna:** Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) com os seguintes campos

- `pixel_values` (`torch.Tensor`): A(s) imagem(ns) processada(s).
- `original_sizes` (`list[list[float]]`): Os tamanhos originais das imagens.
- `labels` (`torch.Tensor`): Os mapas de segmentação processados (se fornecidos).
- `input_points` (`torch.Tensor`): Os pontos processados.
- `input_labels` (`torch.Tensor`): Os rótulos processados.
- `input_boxes` (`torch.Tensor`): As caixas delimitadoras processadas.

#### post_process_masks[[transformers.Sam3TrackerVideoProcessor.post_process_masks]]

```python
post_process_masks(masks, original_sizes, mask_threshold = 0.0, binarize = True, max_hole_area = 0.0, max_sprinkle_area = 0.0, apply_non_overlapping_constraints = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L463)

**Parâmetros:**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : Máscaras em lote do mask_decoder no formato (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Os tamanhos originais de cada imagem antes de serem redimensionadas para o formato de entrada esperado pelo modelo, no formato (altura, largura).

mask_threshold (`float`, *opcional*, padrão 0.0) : Limiar para operações de binarização e pós-processamento.

binarize (`bool`, *opcional*, padrão `True`) : Se deve binarizar as máscaras.

max_hole_area (`float`, *opcional*, padrão 0.0) : A área máxima de um furo a ser preenchido.

max_sprinkle_area (`float`, *opcional*, padrão 0.0) : A área máxima de um sprinkle para preencher.

apply_non_overlapping_constraints (`bool`, *opcional*, padrão `False`) : Se deve aplicar restrições de não sobreposição às máscaras.

**Retorna:** (`torch.Tensor`)

Máscaras em lote no formato batch_size, num_channels, height, width), onde (height, width) é dado por original_size.

Remova o padding e redimensione as máscaras para o tamanho original da imagem.

#### init_video_session[[transformers.Sam3TrackerVideoProcessor.init_video_session]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L514)

**Parâmetros:**

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

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

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

processing_device (`str` ou `torch.device`, *opcional*) : O dispositivo a ser usado para o processamento de vídeo.

video_storage_device (`str` ou `torch.device`, *opcional*) : O dispositivo em que os quadros de vídeo processados serão armazenados.

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

dtype (`torch.dtype`, *opcional*, padrão `torch.float32`) : O dtype do torch a ser usado para toda a sessão.

Inicializa uma sessão de vídeo para inferência. Se um vídeo for fornecido (inferência assíncrona), o vídeo será processado e armazenado no `video_storage_device`.

#### add_inputs_to_inference_session[[transformers.Sam3TrackerVideoProcessor.add_inputs_to_inference_session]]

```python
add_inputs_to_inference_session(inference_session: Sam3TrackerVideoInferenceSession, frame_idx: int, obj_ids: list[int] | int, input_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = None, input_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, input_masks: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], NoneType] = None, original_size: tuple[int, int] | None = None, clear_old_inputs: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py#L567)

**Parâmetros:**

inference_session (`Sam3TrackerVideoInferenceSession`) : A sessão de inferência para o vídeo.

frame_idx (`int`) : O índice do quadro a ser processado.

obj_ids (`list[int]` ou `int`) : O(s) ID(s) do objeto a associar aos pontos ou à caixa. Estes podem ser quaisquer inteiros e podem ser reutilizados posteriormente para especificar um objeto.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *opcional*) : Os pontos a serem adicionados ao frame.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *opcional*) : Os rótulos dos pontos.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opcional*) : As caixas delimitadoras a serem adicionadas ao quadro.

input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]` ou `list[torch.Tensor]`, *opcional*) : A(s) máscara(s) a ser adicionada(s) ao quadro.

original_size (`tuple[int, int]`, *opcional*) : O tamanho original do vídeo. Forneça ao transmitir em streaming.

clear_old_inputs (`bool`, *opcional*, padrão `True`) : Se deve limpar as entradas antigas do objeto.

Processe novos pontos, caixas ou máscaras para um quadro de vídeo e adicione-os à sessão de inferência.

## Sam3TrackerVideoInferenceSession[[transformers.Sam3TrackerVideoInferenceSession]]

#### transformers.Sam3TrackerVideoInferenceSession[[transformers.Sam3TrackerVideoInferenceSession]]

```python
transformers.Sam3TrackerVideoInferenceSession(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/sam3_tracker_video/modeling_sam3_tracker_video.py#L109)

**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.Sam3TrackerVideoInferenceSession.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/sam3_tracker_video/modeling_sam3_tracker_video.py#L229)

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

#### add_new_frame[[transformers.Sam3TrackerVideoInferenceSession.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/sam3_tracker_video/modeling_sam3_tracker_video.py#L304)

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

#### add_point_inputs[[transformers.Sam3TrackerVideoInferenceSession.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/sam3_tracker_video/modeling_sam3_tracker_video.py#L215)

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

#### get_frame[[transformers.Sam3TrackerVideoInferenceSession.get_frame]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L320)

Obter quadro do vídeo.

#### get_obj_num[[transformers.Sam3TrackerVideoInferenceSession.get_obj_num]]

```python
get_obj_num()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L210)

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

#### get_output[[transformers.Sam3TrackerVideoInferenceSession.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/sam3_tracker_video/modeling_sam3_tracker_video.py#L277)

**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.Sam3TrackerVideoInferenceSession.obj_id_to_idx]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L184)

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

#### obj_idx_to_id[[transformers.Sam3TrackerVideoInferenceSession.obj_idx_to_id]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L206)

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

#### remove_mask_inputs[[transformers.Sam3TrackerVideoInferenceSession.remove_mask_inputs]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L235)

Remova as entradas de máscara.

#### remove_point_inputs[[transformers.Sam3TrackerVideoInferenceSession.remove_point_inputs]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L225)

Remova as entradas de ponto.

#### reset_inference_session[[transformers.Sam3TrackerVideoInferenceSession.reset_inference_session]]

```python
reset_inference_session()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L336)

Redefinir os dados de rastreamento e o cache.

#### reset_tracking_data[[transformers.Sam3TrackerVideoInferenceSession.reset_tracking_data]]

```python
reset_tracking_data()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L324)

Redefinir os dados de rastreamento, mas manter o cache.

#### store_output[[transformers.Sam3TrackerVideoInferenceSession.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/sam3_tracker_video/modeling_sam3_tracker_video.py#L240)

**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.

## Sam3TrackerVideoModel[[transformers.Sam3TrackerVideoModel]]

#### transformers.Sam3TrackerVideoModel[[transformers.Sam3TrackerVideoModel]]

```python
transformers.Sam3TrackerVideoModel(config: Sam3TrackerVideoConfig, remove_vision_encoder: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L1647)

**Parâmetros:**

config ([Sam3TrackerVideoConfig](/docs/transformers/main/pt/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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.

remove_vision_encoder (`bool`, *opcional*, padrão `False`) : Se deve remover o codificador de visão. Se True, o codificador de visão será definido como None.

O modelo de rastreamento de vídeo Sam3 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.Sam3TrackerVideoModel.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L1789)

**Parâmetros:**

inference_session (`~models.sam3_tracker_video.modeling_sam3_tracker_video.Sam3TrackerVideoInferenceSession`) : 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.

run_mem_encoder (`bool`, *opcional*, padrão `True`) : Se o codificador de memória deve ser executado nas máscaras previstas. O codificador de memória é processado em lote para todos os objetos, visando eficiência.

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

Um `Sam3TrackerVideoSegmentationOutput` 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 ([Sam3TrackerVideoConfig](/docs/transformers/main/pt/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) 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.

#### propagate_in_video_iterator[[transformers.Sam3TrackerVideoModel.propagate_in_video_iterator]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_tracker_video/modeling_sam3_tracker_video.py#L2812)

**Parâmetros:**

inference_session (`~models.sam3_tracker_video.modeling_sam3_tracker_video.Sam3TrackerVideoInferenceSession`) : O objeto de sessão de inferência de vídeo.

start_frame_idx (`int`, *opcional*) : O índice do quadro inicial para a propagação. Precisa ser fornecido se `forward` ainda não foi chamado em novas entradas. Se não for fornecido, o índice do quadro inicial será o quadro mais antigo com pontos de entrada.

max_frame_num_to_track (`int`, *opcional*) : O número máximo de quadros a serem rastreados.

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

show_progress_bar (`bool`, *opcional*, padrão `False`) : Se deve exibir uma barra de progresso durante a propagação.

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

Um `Sam3TrackerVideoSegmentationOutput` 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 ([Sam3TrackerVideoConfig](/docs/transformers/main/pt/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) e das entradas.

Propaga os objetos pelos quadros do vídeo. Usado ao inicializar uma sessão de inferência com um vídeo inteiro. Gera Sam3TrackerVideoSegmentationOutput para cada quadro.

- **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.Sam3TrackerVideoModel.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/sam3_tracker_video/modeling_sam3_tracker_video.py#L1914)

**Parâmetros:**

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

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

Um `Sam3TrackerVideoVisionEncoderOutput` 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 ([Sam3TrackerVideoConfig](/docs/transformers/main/pt/model_doc/sam3_tracker_video#transformers.Sam3TrackerVideoConfig)) 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`.