# SAM2 Vídeo

    
        
        
    

## Visão geral

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

O modelo pode ser usado para prever máscaras de segmentação de qualquer objeto de interesse, dado uma imagem ou vídeo de entrada, e pontos ou caixas delimitadoras de entrada.

![example image](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam2_header.gif)

O resumo do artigo é o seguinte:

*Apresentamos o Segment Anything Model 2 (SAM 2), um modelo de base para resolver a segmentação visual acionável por prompt em imagens e vídeos. Construímos um mecanismo de dados, que melhora o modelo e os dados por meio da interação do usuário, para coletar o maior conjunto de dados de segmentação de vídeo até o momento. Nosso modelo é uma arquitetura de transformer simples com memória em streaming para processamento de vídeo em tempo real. O SAM 2 treinado com nossos dados oferece desempenho robusto em uma ampla variedade de tarefas. Na segmentação de vídeo, observamos maior precisão, usando 3x menos interações do que as abordagens anteriores. Na segmentação de imagem, nosso modelo é mais preciso e 6x mais rápido que o Segment Anything Model (SAM). Acreditamos que nossos dados, modelo e insights servirão como um marco significativo para a segmentação de vídeo e tarefas de percepção relacionadas. Estamos lançando uma versão do nosso modelo, o conjunto de dados e uma demonstração interativa.*

Dicas:

- Suporte a lotes e vídeos: o SAM2 oferece suporte nativo ao processamento em lote e à segmentação de vídeo sem interrupções, enquanto o SAM original foi projetado para imagens estáticas e fluxos de trabalho mais simples, com uma imagem por vez.
- Precisão e Generalização: o SAM2 apresenta melhor qualidade de segmentação, robustez e generalização zero-shot para novos domínios em comparação com o SAM original, especialmente com prompts mistos.

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

## Exemplo de uso

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

O principal ponto forte do SAM2 é sua capacidade de rastrear objetos entre os quadros de um vídeo. Veja como usá-lo para segmentação de vídeo:

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

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

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

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

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

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

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

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

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

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

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

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

#### 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 180 frames
```

## Recursos

Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o SAM.

- [Nota de demonstração 🌎](https://colab.research.google.com/drive/1Z0NGLE7p8qnc9UpuI8KBETHd2xBbOEhv?usp=sharing) para usar o modelo, contribuída por [Sangbum Choi](https://github.com/SangbumChoi).

## Sam2VideoConfig[[transformers.Sam2VideoConfig]]

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

```python
transformers.Sam2VideoConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, prompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02, num_maskmem: int = 7, image_size: int | list[int] | tuple[int, int] = 1024, sigmoid_scale_for_mem_enc: float = 20.0, sigmoid_bias_for_mem_enc: float = -10.0, enable_occlusion_spatial_embedding: bool = True, multimask_output_in_sam: bool = True, multimask_min_pt_num: int = 0, multimask_max_pt_num: int = 1, multimask_output_for_tracking: bool = True, max_object_pointers_in_encoder: int = 16, max_cond_frame_num: int = -1, enable_temporal_pos_encoding_for_object_pointers: bool = True, memory_attention_hidden_size: int = 256, memory_attention_num_layers: int = 4, memory_attention_num_attention_heads: int = 1, memory_attention_downsample_rate: int = 1, memory_attention_feed_forward_hidden_size: int = 2048, memory_attention_feed_forward_hidden_act: str = 'relu', memory_attention_dropout: float | int = 0.1, memory_attention_rope_feat_sizes: list[int] | None = None, memory_attention_rope_dropout: float | int = 0.1, memory_encoder_hidden_size: int = 256, memory_encoder_output_channels: int = 64, rope_parameters: dict | None = None, mask_downsampler_embed_dim: int = 256, mask_downsampler_kernel_size: int = 3, mask_downsampler_stride: int = 2, mask_downsampler_padding: int = 1, mask_downsampler_total_stride: int = 16, mask_downsampler_hidden_act: str = 'gelu', memory_fuser_num_layers: int = 2, memory_fuser_embed_dim: int = 256, memory_fuser_intermediate_dim: int = 1024, memory_fuser_kernel_size: int = 7, memory_fuser_padding: int = 3, memory_fuser_layer_scale_init_value: float = 1e-06, memory_fuser_hidden_act: str = 'gelu')
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/configuration_sam2_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`, `Sam2PromptEncoderConfig`], *opcional*) : Dicionário de opções de configuração usadas para inicializar [Sam2PromptEncoderConfig](/docs/transformers/main/pt/model_doc/sam2#transformers.Sam2PromptEncoderConfig).

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

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.

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 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 `[64, 64]`) : 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 Sam2VideoModel. Ela é usada para instanciar um modelo Sam2 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/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

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 (
...     Sam2VisionConfig,
...     Sam2PromptEncoderConfig,
...     Sam2MaskDecoderConfig,
...     Sam2Model,
... )

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

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

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

>>> # We can also initialize a Sam2Config from a Sam2VisionConfig, Sam2PromptEncoderConfig, and Sam2MaskDecoderConfig

>>> # Initializing SAM2 vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam2VisionConfig()
>>> prompt_encoder_config = Sam2PromptEncoderConfig()
>>> mask_decoder_config = Sam2MaskDecoderConfig()

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

## Sam2VideoMaskDecoderConfig[[transformers.Sam2VideoMaskDecoderConfig]]

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

```python
transformers.Sam2VideoMaskDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, hidden_act: str = 'gelu', mlp_dim: int = 2048, num_hidden_layers: int = 2, num_attention_heads: int = 8, attention_downsample_rate: int = 2, num_multimask_outputs: int = 3, iou_head_depth: int = 3, iou_head_hidden_dim: int = 256, dynamic_multimask_via_stability: bool = True, dynamic_multimask_stability_delta: float = 0.05, dynamic_multimask_stability_thresh: float = 0.98)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/configuration_sam2_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 Sam2VideoModel. Ela é usada para instanciar um modelo Sam2 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/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

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.

## Sam2VideoPromptEncoderConfig[[transformers.Sam2VideoPromptEncoderConfig]]

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

```python
transformers.Sam2VideoPromptEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, mask_input_channels: int = 16, num_point_embeddings: int = 4, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, scale: int = 1)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/configuration_sam2_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 Sam2VideoModel. Ela é usada para instanciar um modelo Sam2 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/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

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.

## Sam2VideoProcessor[[transformers.Sam2VideoProcessor]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/processing_sam2_video.py#L37)

**Parâmetros:**

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

video_processor (`Sam2VideoVideoProcessor`) : 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 Sam2VideoProcessor que encapsula um processador de imagem e um processador de vídeo em um único processador.

[Sam2VideoProcessor](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoProcessor) oferece todas as funcionalidades de [Sam2ImageProcessor](/docs/transformers/main/pt/model_doc/sam2#transformers.Sam2ImageProcessor) e [Sam2VideoVideoProcessor](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor). Consulte [~Sam2ImageProcessor](/docs/transformers/main/pt/model_doc/sam2#transformers.Sam2ImageProcessor) e [~Sam2VideoVideoProcessor](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor) para mais informações.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/processing_sam2_video.py#L55)

**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.Sam2VideoProcessor.post_process_masks]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/processing_sam2_video.py#L461)

**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.Sam2VideoProcessor.init_video_session]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/processing_sam2_video.py#L512)

**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.Sam2VideoProcessor.add_inputs_to_inference_session]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/processing_sam2_video.py#L565)

**Parâmetros:**

inference_session (`Sam2VideoInferenceSession`) : 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.

## Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/video_processing_sam2_video.py#L27)

**Parâmetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 1024, 'width': 1024}`): Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.485, 0.456, 0.406]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.229, 0.224, 0.225]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*) : Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento

fps (`Annotated[int | float | None, None]`, *kwargs*) : Quadros-alvo a amostrar por segundo quando `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Número máximo de quadros a amostrar quando `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve ou não retornar metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 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.

- ****kwargs** ([VideosKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.VideosKwargs), *opcional*) : Opções adicionais de processamento para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Constrói um processador de vídeo Sam2VideoVideoProcessor.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/video_processing_sam2_video.py#L58)

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

reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : O tamanho de cada imagem conforme é fornecida ao modelo, no formato (altura, largura). Usado para remover o preenchimento.

mask_threshold (`float`, *opcional*, padrão 0.0) : O limiar a ser usado para binarizar as máscaras.

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

pad_size (`int`, *opcional*, padrão `self.pad_size`) : O tamanho de destino para o qual as imagens foram preenchidas antes de serem passadas ao modelo. Se for None, o tamanho de destino é assumido como o `pad_size` do processador.

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

## Sam2VideoInferenceSession[[transformers.Sam2VideoInferenceSession]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/modeling_sam2_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.Sam2VideoInferenceSession.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/sam2_video/modeling_sam2_video.py#L229)

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

#### add_new_frame[[transformers.Sam2VideoInferenceSession.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/sam2_video/modeling_sam2_video.py#L304)

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

#### add_point_inputs[[transformers.Sam2VideoInferenceSession.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/sam2_video/modeling_sam2_video.py#L215)

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

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

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

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

Obter quadro do vídeo.

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

```python
get_obj_num()
```

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

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

#### get_output[[transformers.Sam2VideoInferenceSession.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/sam2_video/modeling_sam2_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.Sam2VideoInferenceSession.obj_id_to_idx]]

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

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

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

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/modeling_sam2_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.Sam2VideoInferenceSession.remove_mask_inputs]]

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

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

Remova as entradas de máscara.

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

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

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

Remova as entradas de ponto.

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

```python
reset_inference_session()
```

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

Redefinir os dados de rastreamento e o cache.

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

```python
reset_tracking_data()
```

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

Redefinir os dados de rastreamento, mas manter o cache.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/modeling_sam2_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.

## Sam2VideoModel[[transformers.Sam2VideoModel]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/modeling_sam2_video.py#L1643)

**Parâmetros:**

config ([Sam2VideoConfig](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoConfig)) : 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.

O modelo de vídeo Sam2 puro, que produz estados ocultos brutos sem nenhum head 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.Sam2VideoModel.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/modeling_sam2_video.py#L1776)

**Parâmetros:**

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : 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:** `Sam2VideoSegmentationOutput` ou `tuple(torch.Tensor)`

Um `Sam2VideoSegmentationOutput` 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 ([Sam2VideoConfig](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoConfig)) 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.Sam2VideoModel.propagate_in_video_iterator]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/modeling_sam2_video.py#L2797)

**Parâmetros:**

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : 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:** `Sam2VideoSegmentationOutput` ou `tuple(torch.Tensor)`

Um `Sam2VideoSegmentationOutput` 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 ([Sam2VideoConfig](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoConfig)) 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 Sam2VideoSegmentationOutput 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.Sam2VideoModel.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/sam2_video/modeling_sam2_video.py#L1901)

**Parâmetros:**

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

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

Um `Sam2VideoVisionEncoderOutput` 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 ([Sam2VideoConfig](/docs/transformers/main/pt/model_doc/sam2_video#transformers.Sam2VideoConfig)) 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`.