# SAM2 Video

    
        
        
    

## Resumen

SAM2 (Segment Anything Model 2) fue propuesto en [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.

El modelo se puede utilizar para predecir máscaras de segmentación de cualquier objeto de interés a partir de una imagen o video de entrada, y puntos o cajas delimitadoras de entrada.

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

El resumen del artículo es el siguiente:

*Presentamos Segment Anything Model 2 (SAM 2), un modelo de base orientado a resolver la segmentación visual con indicaciones en imágenes y videos. Construimos un motor de datos, que mejora el modelo y los datos mediante la interacción del usuario, para recopilar el mayor conjunto de datos de segmentación de video hasta la fecha. Nuestro modelo es una arquitectura de transformador simple con memoria de flujo para el procesamiento de video en tiempo real. SAM 2 entrenado con nuestros datos ofrece un rendimiento sólido en una amplia gama de tareas. En la segmentación de video, observamos una mayor precisión, utilizando 3 veces menos interacciones que los enfoques anteriores. En la segmentación de imágenes, nuestro modelo es más preciso y 6 veces más rápido que Segment Anything Model (SAM). Creemos que nuestros datos, modelo e insights servirán como un hito significativo para la segmentación de video y tareas de percepción relacionadas. Estamos publicando una versión de nuestro modelo, el conjunto de datos y una demo interactiva.*

Consejos:

- Soporte para lotes y vídeo: SAM2 admite de forma nativa el procesamiento por lotes y la segmentación de vídeo sin interrupciones, mientras que SAM original está diseñado para imágenes estáticas y flujos de trabajo más simples de una imagen a la vez.
- Precisión y generalización: SAM2 muestra una calidad de segmentación, robustez y generalización zero-shot a nuevos dominios mejoradas en comparación con el SAM original, especialmente con prompts mixtos.

Este modelo fue aportado por [sangbumchoi](https://github.com/SangbumChoi) y [yonigozlan](https://huggingface.co/yonigozlan). El código original se puede encontrar [aquí](https://github.com/facebookresearch/sam2/tree/main).

## Ejemplo de uso

### Segmentación y seguimiento de video

La principal fortaleza de SAM2 es su capacidad para seguir objetos a través de los fotogramas de un video. A continuación se explica cómo utilizarlo para la segmentación de video:

#### Seguimiento básico de video

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

#### Seguimiento de video de múltiples objetos

Rastrear múltiples objetos simultáneamente a través de los fotogramas de un video:

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

#### Refinar la segmentación de video

Puede hacer clics adicionales en cualquier fotograma para refinar el seguimiento:

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

### Inferencia de video en streaming

Para aplicaciones en tiempo real, SAM2 admite el procesamiento de fotogramas de video a medida que llegan:

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

#### Procesamiento por lotes de video para múltiples objetos

Rastrea varios objetos simultáneamente en un video añadiéndolos todos a la 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

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con SAM.

- [Cuaderno de demostración 🌎](https://colab.research.google.com/drive/1Z0NGLE7p8qnc9UpuI8KBETHd2xBbOEhv?usp=sharing) para usar el modelo, aportado 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')
```

[Fuente](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*) : El objeto de configuración o el diccionario del backbone de visión.

prompt_encoder_config (Union[`dict`, `Sam2PromptEncoderConfig`], *opcional*) : Diccionario de opciones de configuración utilizado para inicializar [Sam2PromptEncoderConfig](/docs/transformers/main/es/model_doc/sam2#transformers.Sam2PromptEncoderConfig).

mask_decoder_config (Union[`dict`, `Sam2MaskDecoderConfig`], *opcional*) : Diccionario de opciones de configuración utilizado para inicializar [Sam2MaskDecoderConfig](/docs/transformers/main/es/model_doc/sam2#transformers.Sam2MaskDecoderConfig).

initializer_range (`float`, *opcional*, valor predeterminado 0.02) : Desviación estándar para la inicialización de parámetros.

num_maskmem (`int`, *opcional*, valor predeterminado: 7) : El número de ranuras de memoria para la memoria de la máscara.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `1024`) : El tamaño (resolución) de cada imagen.

sigmoid_scale_for_mem_enc (`float`, *opcional*, valor predeterminado 20.0) : Factor de escala para la función sigmoide en el codificador de memoria.

sigmoid_bias_for_mem_enc (`float`, *opcional*, valor predeterminado -10.0) : Sesgo para la función sigmoide en el codificador de memoria.

enable_occlusion_spatial_embedding (`bool`, *opcional*, valor predeterminado `True`) : Si se habilita el incrustado espacial para las oclusiones.

multimask_output_in_sam (`bool`, *opcional*, valor predeterminado `True`) : Si se deben generar varias máscaras desde la cabeza de SAM.

multimask_min_pt_num (`int`, *opcional*, valor predeterminado 0) : El número mínimo de puntos para activar la salida multimask.

multimask_max_pt_num (`int`, *opcional*, valor predeterminado 1) : El número máximo de puntos para activar la salida multimask.

multimask_output_for_tracking (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar la salida multimask para el seguimiento.

max_object_pointers_in_encoder (`int`, *opcional*, valor predeterminado 16) : El número máximo de punteros de objetos en el codificador.

max_cond_frame_num (`int`, *opcional*, valor predeterminado: -1) : Número máximo de fotogramas de condicionamiento a utilizar en la atención en memoria. Establezca -1 para usar todos los fotogramas de condicionamiento.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *opcional*, valor predeterminado `True`) : Si se habilita la codificación posicional temporal para los punteros de objetos.

memory_attention_hidden_size (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de los estados ocultos de la atención de memoria.

memory_attention_num_layers (`int`, *opcional*, valor predeterminado 4) : El número de capas en el módulo de atención de memoria.

memory_attention_num_attention_heads (`int`, *opcional*, valor predeterminado: 1) : Número de cabezas de atención para cada capa de atención en la atención de memoria.

memory_attention_downsample_rate (`int`, *opcional*, valor predeterminado 1) : La tasa de submuestreo para las capas de atención.

memory_attention_feed_forward_hidden_size (`int`, *opcional*, valor predeterminado 2048) : La dimensión de la red feedforward en el módulo de atención de memoria.

memory_attention_feed_forward_hidden_act (`str`, *opcional*, valor predeterminado `"relu"`) : La función de activación no lineal en la red feedforward del módulo de atención de memoria.

memory_attention_dropout (`float`, *opcional*, valor predeterminado 0.1) : La tasa de dropout para el módulo de atención de memoria.

memory_attention_rope_feat_sizes (`list[int]`, *opcional*, valor predeterminado `[64, 64]`) : Los tamaños de las características para la codificación posicional Rope.

memory_attention_rope_dropout (`float`, *opcional*, valor predeterminado 0.1) : La tasa de dropout para la codificación posicional Rope.

memory_encoder_hidden_size (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de los estados ocultos del codificador de memoria.

memory_encoder_output_channels (`int`, *opcional*, valor predeterminado 64) : El número de canales de salida para el codificador de memoria.

rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos.

mask_downsampler_embed_dim (`int`, *opcional*, valor predeterminado 256) : La dimensión del embedding del reductor de la máscara.

mask_downsampler_kernel_size (`int`, *opcional*, valor predeterminado 3) : El tamaño del kernel para el reductor de la máscara.

mask_downsampler_stride (`int`, *opcional*, valor predeterminado 2) : El paso para el reductor de la máscara.

mask_downsampler_padding (`int`, *opcional*, valor predeterminado: 1) : El relleno para el reductor de la máscara.

mask_downsampler_total_stride (`int`, *opcional*, valor predeterminado 16) : El desplazamiento total para el reductor de la máscara.

mask_downsampler_hidden_act (`str`, *opcional*, valor predeterminado `"gelu"`) : La función de activación no lineal en el reductor de la máscara.

memory_fuser_num_layers (`int`, *opcional*, valor predeterminado: 2) : El número de capas en el fusionador de memoria.

memory_fuser_embed_dim (`int`, *opcional*, valor predeterminado 256) : La dimensión de la capa de incrustación en el fusionador de memoria.

memory_fuser_intermediate_dim (`int`, *opcional*, valor predeterminado 1024) : La dimensión de la capa intermedia en el fusionador de memoria.

memory_fuser_kernel_size (`int`, *opcional*, valor predeterminado: 7) : El tamaño del kernel para el fusionador de memoria.

memory_fuser_padding (`int`, *opcional*, valor predeterminado 3) : El relleno para el fusionador de memoria.

memory_fuser_layer_scale_init_value (`float`, *opcional*, valor predeterminado 1e-06) : El valor inicial para la escala de capa en el fusionador de memoria.

memory_fuser_hidden_act (`str`, *opcional*, valor predeterminado `"gelu"`) : La función de activación no lineal en el fusionador de memoria.

Esta es la clase de configuración para almacenar la configuración de un Sam2VideoModel. Se utiliza para instanciar un modelo Sam2 Video según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/configuration_sam2_video.py#L57)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

mlp_dim (`int`, *opcional*, valor predeterminado 2048) : La dimensión del MLP en el transformer bidireccional.

num_hidden_layers (`int`, *opcional*, valor predeterminado `2`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

attention_downsample_rate (`int`, *opcional*, valor predeterminado 2) : La tasa de submuestreo para las capas de atención.

num_multimask_outputs (`int`, *opcional*, valor predeterminado 3) : El número de salidas multimask.

iou_head_depth (`int`, *opcional*, valor predeterminado 3) : La profundidad de la cabeza de IoU.

iou_head_hidden_dim (`int`, *opcional*, valor predeterminado 256) : La dimensión oculta de la cabeza de IoU.

dynamic_multimask_via_stability (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar multimask dinámico mediante estabilidad.

dynamic_multimask_stability_delta (`float`, *opcional*, valor predeterminado 0.05) : El delta de estabilidad para la multimáscara dinámica.

dynamic_multimask_stability_thresh (`float`, *opcional*, valor predeterminado 0.98) : Umbral de estabilidad para la multimáscara dinámica.

Esta es la clase de configuración para almacenar la configuración de un Sam2VideoModel. Se utiliza para instanciar un modelo de Sam2 Video según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam2_video/configuration_sam2_video.py#L32)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `1024`) : El tamaño (resolución) de cada imagen.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

mask_input_channels (`int`, *opcional*, valor predeterminado 16) : El número de canales que se enviarán al módulo `MaskDecoder`.

num_point_embeddings (`int`, *opcional*, valor predeterminado: 4) : El número de embeddings de puntos que se utilizarán.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas.

scale (`float`, *opcional*, valor predeterminado 1) : El factor de escala para el codificador de prompts.

Esta es la clase de configuración para almacenar la configuración de un Sam2VideoModel. Se utiliza para instanciar un modelo de Sam2 Video según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

**Parámetros:**

image_processor (`Sam2ImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio.

video_processor (`Sam2VideoVideoProcessor`) : El procesador de video es una entrada obligatoria.

target_size (`int`, *opcional*) : El tamaño objetivo (en píxeles) para normalizar los puntos de entrada y los recuadros delimitadores. Si no se proporciona, se usa el tamaño configurado en el procesador de imágenes por defecto. Todas las coordenadas de entrada (puntos y recuadros) se normalizan a este tamaño antes de pasarse al modelo. Esto garantiza una representación de coordenadas coherente, independientemente de las dimensiones originales de la imagen.

point_pad_value (`int`, *opcional*, valor predeterminado: -10) : El valor utilizado para rellenar los puntos de entrada al agrupar secuencias de diferentes longitudes. Este valor se usa para marcar las posiciones rellenas y se conserva durante la normalización de coordenadas.

Construye un Sam2VideoProcessor que envuelve un procesador de imágenes y un procesador de video en un único procesador.

[Sam2VideoProcessor](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoProcessor) ofrece todas las funcionalidades de [Sam2ImageProcessor](/docs/transformers/main/es/model_doc/sam2#transformers.Sam2ImageProcessor) y [Sam2VideoVideoProcessor](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor). Consulte [~Sam2ImageProcessor](/docs/transformers/main/es/model_doc/sam2#transformers.Sam2ImageProcessor) y [~Sam2VideoVideoProcessor](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor) para obtener más información.

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

[Fuente](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*) : Imagen para preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

segmentation_maps (`ImageInput`, *opcional*) : Los mapas de segmentación a procesar.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *opcional*) : Los puntos que se añadirán al marco.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *opcional*) : Las etiquetas de los puntos.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opcional*) : Las cajas delimitadoras que se deben añadir al fotograma.

original_sizes (`list[list[float]]`, `torch.Tensor`, *opcional*) : Los tamaños originales de las imágenes.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

**Devuelve:** un [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) con los siguientes campos

- `pixel_values` (`torch.Tensor`): La(s) imagen(es) procesada(s).
- `original_sizes` (`list[list[float]]`): Los tamaños originales de las imágenes.
- `labels` (`torch.Tensor`): Los mapas de segmentación procesados (si se proporcionan).
- `input_points` (`torch.Tensor`): Los puntos procesados.
- `input_labels` (`torch.Tensor`): Las etiquetas procesadas.
- `input_boxes` (`torch.Tensor`): Las cajas delimitadoras procesadas.

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

[Fuente](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 por lotes procedentes de mask_decoder en formato (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Los tamaños originales de cada imagen antes de que se redimensionara a la forma de entrada esperada por el modelo, en formato (altura, ancho).

mask_threshold (`float`, *opcional*, valor predeterminado 0.0) : Umbral para las operaciones de binarización y posprocesamiento.

binarize (`bool`, *opcional*, valor predeterminado `True`) : Si se deben binarizar las máscaras.

max_hole_area (`float`, *opcional*, valor predeterminado 0.0) : El área máxima de un agujero que se rellenará.

max_sprinkle_area (`float`, *opcional*, valor predeterminado 0.0) : El área máxima de un sprinkle para rellenar.

apply_non_overlapping_constraints (`bool`, *opcional*, valor predeterminado `False`) : Si se aplican restricciones de no superposición a las máscaras.

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

Máscaras por lotes en el formato batch_size, num_channels, height, width, donde (height, width) está dado por original_size.

Eliminar el relleno y ampliar las máscaras al tamaño original de la imagen.

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

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

**Parámetros:**

video (`VideoInput`, *opcional*) : El video a procesar. No es necesario proporcionarlo durante la transmisión.

inference_device (`str` o `torch.device`, *opcional*, valor predeterminado "cpu") : El dispositivo que se usará para la inferencia.

inference_state_device (`str` o `torch.device`, *opcional*) : El dispositivo en el que se almacenará el estado de inferencia.

processing_device (`str` o `torch.device`, *opcional*) : El dispositivo que se usará para el procesamiento de video.

video_storage_device (`str` o `torch.device`, *opcional*) : El dispositivo en el que se almacenarán los fotogramas de vídeo procesados.

max_vision_features_cache_size (`int`, *opcional*, valor predeterminado: 1) : El número máximo de características visuales que se pueden almacenar en caché.

dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : El dtype de torch que se usará para toda la sesión.

Inicializa una sesión de video para inferencia. Si se proporciona un video (inferencia asíncrona), el video se procesará y se almacenará en `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)
```

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

**Parámetros:**

inference_session (`Sam2VideoInferenceSession`): la sesión de inferencia para el vídeo.

frame_idx (`int`) : El índice del fotograma a procesar.

obj_ids (`list[int]` o `int`) : El o los ID de objeto para asociar con los puntos o la caja. Pueden ser cualquier entero y reutilizarse más adelante para especificar un objeto.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *opcional*) : Los puntos que se añadirán al marco.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *opcional*) : Las etiquetas de los puntos.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opcional*) : Las cajas delimitadoras que se deben añadir al fotograma.

input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]` o `list[torch.Tensor]`, *opcional*) : La(s) máscara(s) que se añadirán al fotograma.

original_size (`tuple[int, int]`, *opcional*) : El tamaño original del video. Proporciónalo al transmitir en streaming.

clear_old_inputs (`bool`, *opcional*, valor predeterminado `True`) : Si se deben borrar las entradas antiguas del objeto.

Procesar nuevos puntos, cajas o máscaras para un fotograma de video y añadirlos a la sesión de inferencia.

## Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

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

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

[Fuente](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*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 1024, 'width': 1024}`): Describe las dimensiones máximas de entrada para el modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

do_sample_frames (`bool`, *kwargs*, *opcional*) : Indica si se deben muestrear fotogramas del vídeo antes de procesarlo o si se debe procesar el vídeo completo.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo

fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos objetivo a muestrear por segundo cuando `do_sample_frames=True`.

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

return_metadata (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica si se debe devolver o no la metadatos del video. Los metadatos del video son un objeto que contiene información sobre la duración del video, los fps, el backend de decodificación, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/main/es/main_classes/processors#transformers.VideosKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de video 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)
```

[Fuente](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 por lotes procedentes de mask_decoder en formato (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Los tamaños originales de cada imagen antes de que se redimensionara a la forma de entrada esperada por el modelo, en formato (altura, ancho).

reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : El tamaño de cada imagen tal como se introduce en el modelo, en formato (altura, ancho). Se utiliza para eliminar el relleno.

mask_threshold (`float`, *opcional*, valor predeterminado 0.0) : Umbral a utilizar para binarizar las máscaras.

binarize (`bool`, *opcional*, valor predeterminado `True`) : Si se deben binarizar las máscaras.

pad_size (`int`, *opcional*, valor predeterminado `self.pad_size`) : El tamaño objetivo al que se rellenaron las imágenes antes de pasarlas al modelo. Si es None, se asume que el tamaño objetivo es el `pad_size` del procesador.

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

Máscaras por lotes en el formato batch_size, num_channels, height, width, donde (height, width) está dado por original_size.

Eliminar el relleno y ampliar las máscaras al tamaño original de la imagen.

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

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

**Parámetros:**

video (`torch.Tensor`, *opcional*) : El video a procesar. No es necesario proporcionarlo al transmitir en streaming.

video_height (`int`, *opcional*) : La altura del video.

video_width (`int`, *opcional*) : El ancho del video.

inference_device (`torch.device`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo que se usará para la inferencia.

inference_state_device (`torch.device`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo en el que se almacenará el estado de inferencia.

video_storage_device (`torch.device`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo en el que se almacenará el video.

dtype (`torch.dtype`, *opcional*, valor predeterminado `"float32"`) : El dtype a utilizar para el vídeo.

max_vision_features_cache_size (`int`, *opcional*, valor predeterminado: 1) : El número máximo de características visuales que se pueden almacenar en caché.

Gestiona los parámetros, el estado y la caché de la sesión de inferencia de video.

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

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

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

Agregue entradas de máscara con colocación automática de dispositivos.

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

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

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

Agregue un nuevo marco con colocación automática de dispositivos.

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

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

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

Agregue entradas de puntos con colocación automática de dispositivos.

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

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

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

Obtener un fotograma del video.

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

```python
get_obj_num()
```

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

Obtenga el número total de ids de objetos únicos recibidos hasta ahora en esta sesión.

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

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

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

**Parámetros:**

obj_idx (int) : El índice del objeto.

frame_idx (int) : El índice del fotograma.

output_key (str) : La clave de la salida.

is_conditioning_frame (bool) : Indica si la salida corresponde a un fotograma de condicionamiento.

Obtén la salida con una gestión inteligente de dispositivos.

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

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

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

Mapea el ID del objeto a un índice, creando una nueva entrada si es necesario.

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

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

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

Mapea el índice de objeto del lado del modelo al id de objeto del lado del cliente.

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

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

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

Eliminar las entradas de máscara.

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

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

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

Eliminar las entradas de puntos.

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

```python
reset_inference_session()
```

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

Restablecer los datos de seguimiento y la caché.

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

```python
reset_tracking_data()
```

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

Restablecer los datos de seguimiento pero conservar la caché.

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

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

**Parámetros:**

obj_idx (int) : El índice del objeto.

frame_idx (int) : El índice del fotograma.

output_key (Optional[str]) : La clave de la salida. Si es None, la salida se almacena como un diccionario.

output_value (Optional[Union[torch.Tensor, dict]]) : El valor de la salida.

is_conditioning_frame (bool) : Indica si la salida corresponde a un fotograma de condicionamiento.

Almacena la salida con una gestión inteligente de dispositivos. Si output_key es None, la salida se almacena como un diccionario.

## Sam2VideoModel[[transformers.Sam2VideoModel]]

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

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

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

**Parámetros:**

config ([Sam2VideoConfig](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Sam2 Video básico que genera estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](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`) : El objeto de sesión de inferencia de video.

frame_idx (`int`, *opcional*) : El índice del fotograma en el que se ejecutará la inferencia. No es necesario proporcionarlo al realizar la inferencia en un nuevo fotograma transmitido.

frame (`torch.Tensor`, *opcional*) : El fotograma a procesar. Proporciónalo durante la transmisión en directo.

reverse (`bool`, *opcional*, valor predeterminado `False`) : Si se debe propagar en reversa.

run_mem_encoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe ejecutar el codificador de memoria en las máscaras predichas. El codificador de memoria se procesa por lotes para todos los objetos con fines de eficiencia.

**Devuelve:** `Sam2VideoSegmentationOutput` o `tuple(torch.Tensor)`

Un `Sam2VideoSegmentationOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sam2VideoConfig](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoConfig)) y las entradas.

Propagar los objetos a través de un fotograma de video transmitido.

- **object_ids** (`list[int]`, *opcional*) -- Lista de IDs de objetos que se están rastreando en el fotograma actual.
- **pred_masks** (`torch.Tensor` de forma `(batch_size, num_masks, height, width)`) -- Las máscaras predichas almacenadas en la resolución del modelo.
- **object_score_logits** (`torch.Tensor` de forma `(batch_size,)`, *opcional*) -- Logits para las puntuaciones de los objetos, que indican si están presentes.
- **frame_idx** (`int`, *opcional*) -- El índice del fotograma del video.

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

[Fuente](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`) : El objeto de sesión de inferencia de video.

start_frame_idx (`int`, *opcional*) : El índice de cuadro inicial para la propagación. Debe proporcionarse si `forward` aún no se ha llamado con nuevas entradas. Si no se proporciona, el índice de cuadro inicial será el cuadro más antiguo con puntos de entrada.

max_frame_num_to_track (`int`, *opcional*) : El número máximo de fotogramas a seguir.

reverse (`bool`, *opcional*, valor predeterminado `False`) : Si se debe propagar en reversa.

show_progress_bar (`bool`, *opcional*, valor predeterminado `False`) : Si se muestra una barra de progreso durante la propagación.

**Devuelve:** `Sam2VideoSegmentationOutput` o `tuple(torch.Tensor)`

Un `Sam2VideoSegmentationOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sam2VideoConfig](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoConfig)) y las entradas.

Propaga los objetos a través de los fotogramas del video. Se utiliza al inicializar una sesión de inferencia con un video completo. Genera Sam2VideoSegmentationOutput para cada fotograma.

- **object_ids** (`list[int]`, *opcional*) -- Lista de IDs de objetos que se están rastreando en el fotograma actual.
- **pred_masks** (`torch.Tensor` de forma `(batch_size, num_masks, height, width)`) -- Las máscaras predichas almacenadas en la resolución del modelo.
- **object_score_logits** (`torch.Tensor` de forma `(batch_size,)`, *opcional*) -- Logits para las puntuaciones de los objetos, que indican si están presentes.
- **frame_idx** (`int`, *opcional*) -- El índice del fotograma del video.

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

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

[Fuente](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 píxel de entrada con forma `(batch_size, num_channels, height, width)`.

**Devuelve:** `Sam2VideoVisionEncoderOutput` o `tuple(torch.Tensor)`

Un `Sam2VideoVisionEncoderOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sam2VideoConfig](/docs/transformers/main/es/model_doc/sam2_video#transformers.Sam2VideoConfig)) y las entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, height, width, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- Tupla de `torch.Tensor` (uno para cada nivel de características, de alta a baja resolución) de forma `(batch_size, hidden_size, height, width)`. Mapas de características del cuello de la Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- Tupla de `torch.Tensor` (una para cada nivel de características, de alta a baja resolución) de forma `(batch_size, hidden_size, height, width)`. Codificaciones posicionales correspondientes a `fpn_hidden_states`.