# SAM2 Vidéo

    
        
        
    

## Aperçu

SAM2 (Segment Anything Model 2) a été proposé dans [Segment Anything in Images and Videos](https://ai.meta.com/research/publications/sam-2-segment-anything-in-images-and-videos/) par 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.

Le modèle peut être utilisé pour prédire les masques de segmentation de tout objet d'intérêt à partir d'une image ou d'une vidéo en entrée, ainsi que de points ou de boîtes englobantes en entrée.

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

L'abstract de l'article est le suivant :

*Nous présentons Segment Anything Model 2 (SAM 2), un modèle de fondation visant à résoudre le problème de la segmentation visuelle pilotée par des requêtes dans les images et les vidéos. Nous avons conçu un moteur de données qui améliore le modèle et les données grâce à l'interaction utilisateur, afin de collecter le plus grand jeu de données de segmentation vidéo à ce jour. Notre modèle repose sur une architecture transformer simple dotée d'une mémoire en flux pour le traitement vidéo en temps réel. SAM 2, entraîné sur nos données, offre de solides performances sur un large éventail de tâches. En segmentation vidéo, nous observons une précision supérieure, en utilisant 3 fois moins d'interactions que les approches antérieures. En segmentation d'image, notre modèle est plus précis et 6 fois plus rapide que Segment Anything Model (SAM). Nous pensons que nos données, notre modèle et nos analyses constitueront une étape importante pour la segmentation vidéo et les tâches de perception associées. Nous publions une version de notre modèle, le jeu de données et une démonstration interactive.*

Astuces :

- Prise en charge des lots et des vidéos : SAM2 prend nativement en charge le traitement par lots et la segmentation vidéo fluide, tandis que SAM d'origine est conçu pour les images statiques et des flux de travail plus simples, une image à la fois.
- Précision et généralisation : SAM2 présente une qualité de segmentation, une robustesse et une capacité de généralisation zéro-jeu à de nouveaux domaines améliorées par rapport au SAM original, en particulier avec des prompts mixtes.

Ce modèle a été contribué par [sangbumchoi](https://github.com/SangbumChoi) et [yonigozlan](https://huggingface.co/yonigozlan). Le code d'origine est disponible [ici](https://github.com/facebookresearch/sam2/tree/main).

## Exemple d'utilisation

### Segmentation et suivi vidéo

La force principale de SAM2 réside dans sa capacité à suivre des objets à travers les images d'une vidéo. Voici comment l'utiliser pour la segmentation vidéo :

#### Suivi vidéo de base

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

#### Suivi vidéo multi-objets

Suivre plusieurs objets simultanément à travers les images vidéo :

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

#### Affiner la segmentation vidéo

Vous pouvez ajouter des clics supplémentaires sur n'importe quel plan pour affiner le suivi :

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

### Inférence vidéo en streaming

Pour les applications en temps réel, SAM2 prend en charge le traitement des images vidéo à mesure qu’elles arrivent :

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

#### Traitement par lots de vidéos pour plusieurs objets

Suivre plusieurs objets simultanément dans une vidéo en les ajoutant tous d'un coup :

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

## Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec SAM.

- [Cahier de démonstration 🌎](https://colab.research.google.com/drive/1Z0NGLE7p8qnc9UpuI8KBETHd2xBbOEhv?usp=sharing) pour l'utilisation du modèle, contribué par [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')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/configuration_sam2_video.py#L96)

**Paramètres :**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel.

prompt_encoder_config (Union[`dict`, `Sam2PromptEncoderConfig`], *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser [Sam2PromptEncoderConfig](/docs/transformers/v5.23.0/fr/model_doc/sam2#transformers.Sam2PromptEncoderConfig).

mask_decoder_config (Union[`dict`, `Sam2MaskDecoderConfig`], *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser [Sam2MaskDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/sam2#transformers.Sam2MaskDecoderConfig).

initializer_range (`float`, *facultatif*, valeur par défaut 0.02) : Écart-type pour l'initialisation des paramètres.

num_maskmem (`int`, *facultatif*, valeur par défaut : 7) : Le nombre de slots mémoire pour la mémoire du masque.

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `1024`) : La taille (résolution) de chaque image.

sigmoid_scale_for_mem_enc (`float`, *facultatif*, valeur par défaut 20.0) : Facteur d'échelle de la fonction sigmoïde dans l'encodeur mémoire.

sigmoid_bias_for_mem_enc (`float`, *facultatif*, valeur par défaut -10.0) : Biais de la fonction sigmoïde dans l'encodeur mémoire.

enable_occlusion_spatial_embedding (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut activer l'intégration spatiale pour les occlusions.

multimask_output_in_sam (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut générer plusieurs masques à partir de la tête SAM.

multimask_min_pt_num (`int`, *facultatif*, valeur par défaut 0) : Nombre minimal de points pour déclencher la sortie multimask.

multimask_max_pt_num (`int`, *facultatif*, valeur par défaut : 1) : Nombre maximal de points pour déclencher la sortie multimask.

multimask_output_for_tracking (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser une sortie multimasque pour le suivi.

max_object_pointers_in_encoder (`int`, *facultatif*, valeur par défaut : 16) : Nombre maximal de pointeurs d'objets dans l'encodeur.

max_cond_frame_num (`int`, *facultatif*, valeur par défaut : -1) : Nombre maximal de frames de conditionnement à utiliser dans l'attention mémoire. Définir sur -1 pour utiliser toutes les frames de conditionnement.

enable_temporal_pos_encoding_for_object_pointers (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut activer le codage positionnel temporel pour les pointeurs d'objets.

memory_attention_hidden_size (`int`, *facultatif*, valeur par défaut 256) : Dimension des états cachés de l'attention mémoire.

memory_attention_num_layers (`int`, *facultatif*, valeur par défaut : 4) : Le nombre de couches dans le module d'attention mémoire.

memory_attention_num_attention_heads (`int`, *facultatif*, valeur par défaut : 1) : Nombre de têtes d'attention pour chaque couche d'attention dans l'attention mémoire.

memory_attention_downsample_rate (`int`, *facultatif*, valeur par défaut : 1) : Le taux de sous-échantillonnage pour les couches d'attention.

memory_attention_feed_forward_hidden_size (`int`, *facultatif*, valeur par défaut : 2048) : La dimension du réseau feedforward dans le module d'attention mémoire.

memory_attention_feed_forward_hidden_act (`str`, *facultatif*, valeur par défaut `"relu"`) : Fonction d'activation non linéaire du réseau feedforward dans le module d'attention mémoire.

memory_attention_dropout (`float`, *facultatif*, valeur par défaut 0.1) : Le taux de dropout pour le module d'attention mémoire.

memory_attention_rope_feat_sizes (`list[int]`, *facultatif*, par défaut `[64, 64]`) : Les tailles de caractéristiques pour l'encodage positionnel Rope.

memory_attention_rope_dropout (`float`, *facultatif*, valeur par défaut 0,1) : Le taux de dropout pour l'encodage positionnel Rope.

memory_encoder_hidden_size (`int`, *facultatif*, valeur par défaut 256) : Dimension des états cachés de l'encodeur mémoire.

memory_encoder_output_channels (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de canaux de sortie pour l'encodeur mémoire.

rope_parameters (`dict`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

mask_downsampler_embed_dim (`int`, *facultatif*, valeur par défaut 256) : La dimension de l'embedding du réducteur de masque.

mask_downsampler_kernel_size (`int`, *facultatif*, valeur par défaut : 3) : La taille du noyau pour le sous-échantillonneur de masque.

mask_downsampler_stride (`int`, *facultatif*, valeur par défaut : 2) : Le pas (stride) pour le sous-échantillonneur de masque.

mask_downsampler_padding (`int`, *facultatif*, valeur par défaut : 1) : Le padding pour le sous-échantillonneur de masque.

mask_downsampler_total_stride (`int`, *facultatif*, par défaut 16) : Le pas total pour le sous-échantillonneur de masque.

mask_downsampler_hidden_act (`str`, *facultatif*, valeur par défaut `"gelu"`) : Fonction d'activation non linéaire du sous-échantillonneur de masque.

memory_fuser_num_layers (`int`, *facultatif*, valeur par défaut : 2) : Le nombre de couches dans le fuser mémoire.

memory_fuser_embed_dim (`int`, *facultatif*, valeur par défaut 256) : La dimension de la couche d'incorporation dans le fuser mémoire.

memory_fuser_intermediate_dim (`int`, *facultatif*, valeur par défaut 1024) : La dimension de la couche intermédiaire dans le fuser mémoire.

memory_fuser_kernel_size (`int`, *facultatif*, par défaut 7) : La taille du noyau pour le fuser de mémoire.

memory_fuser_padding (`int`, *facultatif*, valeur par défaut : 3) : Le padding pour le fuser mémoire.

memory_fuser_layer_scale_init_value (`float`, *facultatif*, valeur par défaut 1e-06) : La valeur initiale de l'échelle de couche dans le fuser mémoire.

memory_fuser_hidden_act (`str`, *facultatif*, par défaut `"gelu"`) : La fonction d'activation non linéaire dans le fuser mémoire.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam2VideoModel. Elle est utilisée pour instancier un modèle Sam2 Video en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/sam2.1-hiera-tiny](https://huggingface.co/facebook/sam2.1-hiera-tiny)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

mlp_dim (`int`, *facultatif*, valeur par défaut 2048) : La dimension du MLP dans le transformeur bidirectionnel.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `2`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

attention_downsample_rate (`int`, *facultatif*, valeur par défaut : 2) : Le taux de sous-échantillonnage pour les couches d'attention.

num_multimask_outputs (`int`, *facultatif*, valeur par défaut : 3) : Le nombre de sorties multimask.

iou_head_depth (`int`, *facultatif*, valeur par défaut : 3) : La profondeur de la tête IoU.

iou_head_hidden_dim (`int`, *facultatif*, valeur par défaut 256) : La dimension cachée de la tête IoU.

dynamic_multimask_via_stability (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser le multimask dynamique via la stabilité.

dynamic_multimask_stability_delta (`float`, *facultatif*, valeur par défaut 0.05) : Le delta de stabilité pour le multimask dynamique.

dynamic_multimask_stability_thresh (`float`, *facultatif*, valeur par défaut 0.98) : Le seuil de stabilité pour le multimask dynamique.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam2VideoModel. Elle est utilisée pour instancier un modèle Sam2 Video en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `1024`) : La taille (résolution) de chaque image.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `16`) : La taille (résolution) de chaque patch.

mask_input_channels (`int`, *facultatif*, valeur par défaut 16) : Le nombre de canaux à transmettre au module `MaskDecoder`.

num_point_embeddings (`int`, *facultatif*, valeur par défaut : 4) : Le nombre d'embeddings de points à utiliser.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

scale (`float`, *facultatif*, valeur par défaut : 1) : Le facteur d'échelle pour l'encodeur de prompt.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam2VideoModel. Elle est utilisée pour instancier un modèle Sam2 Video en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/sam2_video.1-hiera-tiny](https://huggingface.co/facebook/sam2_video.1-hiera-tiny)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

image_processor (`Sam2ImageProcessor`) : le processeur d'images est une entrée obligatoire.

video_processor (`Sam2VideoVideoProcessor`) : le processeur vidéo est une entrée obligatoire.

target_size (`int`, *facultatif*) : La taille cible (en pixels) pour normaliser les points d'entrée et les boîtes englobantes. Si non fournie, la valeur par défaut est la configuration de taille du processeur d'images. Toutes les coordonnées d'entrée (points et boîtes) sont normalisées à cette taille avant d'être transmises au modèle. Cela garantit une représentation cohérente des coordonnées, indépendamment des dimensions d'origine de l'image.

point_pad_value (`int`, *facultatif*, valeur par défaut : -10) : La valeur utilisée pour rembourner les points d'entrée lors du groupement de séquences de longueurs différentes. Cette valeur sert à marquer les positions rembourrées et est conservée lors de la normalisation des coordonnées.

Construit un Sam2VideoProcessor qui encapsule un processeur d’images et un processeur de vidéos en un seul processeur.

[Sam2VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoProcessor) propose toutes les fonctionnalités de [Sam2ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam2#transformers.Sam2ImageProcessor) et de [Sam2VideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor). Consultez [~Sam2ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam2#transformers.Sam2ImageProcessor) et [~Sam2VideoVideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoVideoProcessor) pour plus d’informations.

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

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

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

segmentation_maps (`ImageInput`, *facultatif*) : Les cartes de segmentation à traiter.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *facultatif*) : Les points à ajouter au repère.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *facultatif*) : Les étiquettes des points.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *facultatif*) : Les boîtes englobantes à ajouter à l'image.

original_sizes (`list[list[float]]`, `torch.Tensor`, *facultatif*) : Les dimensions d'origine des images.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

**Retourne :** un [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) avec les champs suivants

- `pixel_values` (`torch.Tensor`) : l’image (ou les images) traitée(s).
- `original_sizes` (`list[list[float]]`) : Les dimensions d’origine des images.
- `labels` (`torch.Tensor`) : les cartes de segmentation traitées (si fournies).
- `input_points` (`torch.Tensor`) : Les points traités.
- `input_labels` (`torch.Tensor`) : Les étiquettes traitées.
- `input_boxes` (`torch.Tensor`) : Les boîtes englobantes traitées.

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

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

**Paramètres :**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : Masques par lot issus de mask_decoder, au format (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Les dimensions d'origine de chaque image avant son redimensionnement à la forme d'entrée attendue par le modèle, au format (hauteur, largeur).

mask_threshold (`float`, *facultatif*, valeur par défaut 0.0) : Seuil pour les opérations de binarisation et de post-traitement.

binarize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut binariser les masques.

max_hole_area (`float`, *facultatif*, valeur par défaut 0.0) : La surface maximale d'un trou à combler.

max_sprinkle_area (`float`, *facultatif*, valeur par défaut 0.0) : La surface maximale d'un point à remplir.

apply_non_overlapping_constraints (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut appliquer des contraintes de non-chevauchement aux masques.

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

Masques par lots au format batch_size, num_channels, height, width, où (height, width) est défini par original_size.

Supprimez le bourrage et redimensionnez les masques à la taille d'image d'origine.

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

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

**Paramètres :**

video (`VideoInput`, *facultatif*) : La vidéo à traiter. Aucun besoin de la fournir lors du streaming.

inference_device (`str` ou `torch.device`, *facultatif*, par défaut "cpu") : L'appareil à utiliser pour l'inférence.

inference_state_device (`str` ou `torch.device`, *facultatif*) : L'appareil sur lequel stocker l'état de déduction.

processing_device (`str` ou `torch.device`, *facultatif*) : L'appareil à utiliser pour le traitement vidéo.

video_storage_device (`str` ou `torch.device`, *facultatif*) : L'appareil sur lequel stocker les images vidéo traitées.

max_vision_features_cache_size (`int`, *facultatif*, valeur par défaut : 1) : Nombre maximal de fonctionnalités visuelles à mettre en cache.

dtype (`torch.dtype`, *facultatif*, par défaut `torch.float32`) : Le dtype torch à utiliser pour l'ensemble de la session.

Initialise une session vidéo pour l’inférence. Si une vidéo est fournie (inférence asynchrone), elle sera traitée et stockée sur le `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)
```

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

**Paramètres :**

inference_session (`Sam2VideoInferenceSession`) : la session d'inférence pour la vidéo.

frame_idx (`int`) : L'index de la frame à traiter.

obj_ids (`list[int]` ou `int`) : L'identifiant (ou les identifiants) d'objet à associer aux points ou à la boîte. Il peut s'agir de n'importe quels entiers, réutilisables plus tard pour désigner un objet.

input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *facultatif*) : Les points à ajouter au repère.

input_labels (`list[list[list[int]]]`, `torch.Tensor`, *facultatif*) : Les étiquettes des points.

input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *facultatif*) : Les boîtes englobantes à ajouter à l'image.

input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]` ou `list[torch.Tensor]`, *facultatif*) : Le(s) masque(s) à ajouter à la trame.

original_size (`tuple[int, int]`, *facultatif*) : La taille d'origine de la vidéo. À fournir lors du streaming.

clear_old_inputs (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut effacer les anciennes entrées de l'objet.

Traitez de nouveaux points, boîtes ou masques pour une image vidéo et ajoutez-les à la session d'inférence.

## Sam2VideoVideoProcessor[[transformers.Sam2VideoVideoProcessor]]

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

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

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

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 1024, 'width': 1024}`) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.485, 0.456, 0.406]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.229, 0.224, 0.225]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

do_sample_frames (`bool`, *kwargs*, *facultatif*) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d'images. Elles seront utilisées pour échantillonner des images à partir de la vidéo ou pour calculer des horodatages. Ne passez aucune métadonnée à moins de tenter de décoder manuellement la vidéo avant le traitement.

fps (`Annotated[int | float | None, None]`, *kwargs*) : Nombre de cibles à échantillonner par seconde lorsque `do_sample_frames=True`.

num_frames (`Annotated[int | None, None]`, *kwargs*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`.

return_metadata (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées de la vidéo sont un objet contenant des informations sur la durée de la vidéo, le nombre d'images par seconde, le backend de décodage, etc.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.VideosKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

Construit un processeur vidéo 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)
```

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

**Paramètres :**

masks (`Union[List[torch.Tensor], List[np.ndarray]]`) : Masques par lot issus de mask_decoder, au format (batch_size, num_channels, height, width).

original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : Les dimensions d'origine de chaque image avant son redimensionnement à la forme d'entrée attendue par le modèle, au format (hauteur, largeur).

reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`) : La taille de chaque image telle qu'elle est transmise au modèle, au format (hauteur, largeur). Utilisée pour supprimer le bourrage.

mask_threshold (`float`, *facultatif*, valeur par défaut 0.0) : Le seuil à utiliser pour binariser les masques.

binarize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut binariser les masques.

pad_size (`int`, *facultatif*, valeur par défaut `self.pad_size`) : La taille cible à laquelle les images ont été rembourdées avant d'être transmises au modèle. Si None, la taille cible est supposée être la `pad_size` du processeur.

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

Masques par lots au format batch_size, num_channels, height, width, où (height, width) est défini par original_size.

Supprimez le bourrage et redimensionnez les masques à la taille d'image d'origine.

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

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

**Paramètres :**

video (`torch.Tensor`, *facultatif*) : La vidéo à traiter. Inutile de la fournir lors d'un flux en continu.

video_height (`int`, *facultatif*) : La hauteur de la vidéo.

video_width (`int`, *facultatif*) : La largeur de la vidéo.

inference_device (`torch.device`, *facultatif*, par défaut `"cpu"`) : L'appareil à utiliser pour l'inférence.

inference_state_device (`torch.device`, *facultatif*, par défaut `"cpu"`) : L'appareil sur lequel stocker l'état de déduction.

video_storage_device (`torch.device`, *facultatif*, par défaut `"cpu"`) : L'appareil sur lequel stocker la vidéo.

dtype (`torch.dtype`, *facultatif*, par défaut `"float32"`) : Le dtype à utiliser pour la vidéo.

max_vision_features_cache_size (`int`, *facultatif*, valeur par défaut : 1) : Nombre maximal de fonctionnalités visuelles à mettre en cache.

Gère les paramètres, l'état et le cache des sessions d'inférence vidéo.

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

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

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

Ajoutez des entrées de masque avec un placement automatique sur l'appareil.

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

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

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

Ajouter un nouveau frame avec un placement automatique des appareils.

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

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

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

Ajoutez des entrées de points avec un placement automatique sur l'appareil.

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

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

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

Obtenir une image à partir d'une vidéo.

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

```python
get_obj_num()
```

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

Obtenir le nombre total d'identifiants d'objets uniques reçus jusqu'à présent dans cette session.

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

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

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

**Paramètres :**

obj_idx (int) : L'index de l'objet.

frame_idx (int) : L'index de la trame.

output_key (str) : La clé de la sortie.

is_conditioning_frame (bool) : Indique si la sortie correspond à une image de conditionnement.

Obtenez la sortie avec une gestion intelligente des appareils.

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

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

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

Associer l'ID d'objet à un index, en créant une nouvelle entrée si nécessaire.

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

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

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

Associer l'index d'objet côté modèle à l'identifiant d'objet côté client.

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

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

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

Supprimer les entrées de masque.

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

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

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

Supprimer les entrées de points.

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

```python
reset_inference_session()
```

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

Réinitialiser les données de suivi et le cache.

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

```python
reset_tracking_data()
```

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

Réinitialiser les données de suivi mais conserver le 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)
```

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

**Paramètres :**

obj_idx (int) : L'index de l'objet.

frame_idx (int) : L'index de la trame.

output_key (Optional[str]) : La clé de la sortie. Si None, la sortie est stockée sous forme de dictionnaire.

output_value (Optional[Union[torch.Tensor, dict]]) : La valeur de la sortie.

is_conditioning_frame (bool) : Indique si la sortie correspond à une image de conditionnement.

Stocke la sortie avec une gestion intelligente des appareils. Si output_key est None, la sortie est stockée sous forme de dictionnaire.

## Sam2VideoModel[[transformers.Sam2VideoModel]]

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

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

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

**Paramètres :**

config ([Sam2VideoConfig](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Sam2 Video brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : l'objet de session d'inférence vidéo.

frame_idx (`int`, *facultatif*) : L'index de la frame sur laquelle exécuter l'inférence. Pas besoin de le fournir lors de l'inférence sur une nouvelle frame diffusée en continu.

frame (`torch.Tensor`, *facultatif*) : La trame à traiter. À fournir lors du streaming.

reverse (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut propager en sens inverse.

run_mem_encoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut exécuter l'encodeur mémoire sur les masques prédits. L'encodeur mémoire est groupé par lot pour tous les objets afin d'optimiser l'efficacité.

**Retourne :** `Sam2VideoSegmentationOutput` ou `tuple(torch.Tensor)`

Un `Sam2VideoSegmentationOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sam2VideoConfig](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoConfig)) et les entrées.

Propagez les objets à travers une image vidéo diffusée en continu.

- **object_ids** (`list[int]`, *facultatif*) -- Liste des identifiants d'objets suivis dans l'image courante.
- **pred_masks** (`torch.Tensor` de forme `(batch_size, num_masks, height, width)`) -- Les masques prédits stockés à la résolution du modèle.
- **object_score_logits** (`torch.Tensor` de forme `(batch_size,)`, *facultatif*) -- Logits des scores d'objets, indiquant si des objets sont présents.
- **frame_idx** (`int`, *facultatif*) -- L'index de la frame de la vidéo.

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

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

**Paramètres :**

inference_session (`~models.sam2_video.modeling_sam2_video.Sam2VideoInferenceSession`) : l'objet de session d'inférence vidéo.

start_frame_idx (`int`, *facultatif*) : L'index de la frame de départ pour la propagation. Doit être fourni si `forward` n'a pas encore été appelé sur de nouvelles entrées. S'il n'est pas fourni, l'index de la frame de départ sera la frame la plus ancienne contenant des points d'entrée.

max_frame_num_to_track (`int`, *facultatif*) : Nombre maximal de frames à suivre.

reverse (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut propager en sens inverse.

show_progress_bar (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut afficher une barre de progression pendant la propagation.

**Retourne :** `Sam2VideoSegmentationOutput` ou `tuple(torch.Tensor)`

Un `Sam2VideoSegmentationOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sam2VideoConfig](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoConfig)) et les entrées.

Propage les objets à travers les images de la vidéo. Utilisé lors de l'initialisation d'une session d'inférence avec une vidéo entière. Produit un Sam2VideoSegmentationOutput pour chaque image.

- **object_ids** (`list[int]`, *facultatif*) -- Liste des identifiants d'objets suivis dans l'image courante.
- **pred_masks** (`torch.Tensor` de forme `(batch_size, num_masks, height, width)`) -- Les masques prédits stockés à la résolution du modèle.
- **object_score_logits** (`torch.Tensor` de forme `(batch_size,)`, *facultatif*) -- Logits des scores d'objets, indiquant si des objets sont présents.
- **frame_idx** (`int`, *facultatif*) -- L'index de la frame de la vidéo.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam2_video/modeling_sam2_video.py#L1901)

**Paramètres :**

pixel_values (`torch.Tensor`) : Valeurs de pixels d'entrée de forme `(batch_size, num_channels, height, width)`.

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

Un `Sam2VideoVisionEncoderOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sam2VideoConfig](/docs/transformers/v5.23.0/fr/model_doc/sam2_video#transformers.Sam2VideoConfig)) et les entrées.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, height, width, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- Tuple de `torch.Tensor` (un pour chaque niveau de caractéristique, de la résolution la plus haute à la plus basse) de forme `(batch_size, hidden_size, height, width)`. Cartes de caractéristiques issues du cou Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- Tuple de `torch.Tensor` (un pour chaque niveau de caractéristiques, de la résolution la plus haute à la plus basse) de forme `(batch_size, hidden_size, height, width)`. Encodages positionnels correspondant aux `fpn_hidden_states`.

