> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-vision/sam2-video.md).

# SAM2 Vidéo

Suivez et segmentez n'importe quel objet dans une vidéo avec SAM2.1 de Meta — la version améliorée de SAM2 avec une précision vidéo renforcée.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace) le marketplace.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que SAM2 ?

SAM2 (Segment Anything Model 2) de Meta AI permet :

* Segmentation d'objets vidéo en temps réel
* Cliquez-pour-suivre n'importe quel objet
* Suivi cohérent à travers les occlusions
* Traitement vidéo économe en mémoire

## Quoi de neuf dans SAM2.1

SAM2.1 apporte des améliorations significatives par rapport à l'original SAM2 :

* **Précision vidéo améliorée** — Meilleur suivi à travers les occlusions et les mouvements rapides
* **Module de mémoire amélioré** — Suivi longue portée plus cohérent
* **Nouveaux checkpoints** — `série sam2.1_hiera_*` avec de meilleures performances
* **Package pip officiel** — Installer avec `pip install sam-2` (aucune compilation manuelle requise)
* **Inférence plus rapide** — Kernels CUDA optimisés

## Ressources

* **GitHub :** [facebookresearch/sam2](https://github.com/facebookresearch/sam2)
* **Article :** [Article SAM2](https://arxiv.org/abs/2408.00714)
* **Démo :** [Démo SAM2](https://sam2.metademolab.com/)
* **Poids du modèle :** [Checkpoints SAM2.1](https://github.com/facebookresearch/sam2#model-checkpoints)

## Matériel recommandé

| Composant | Minimum       | Recommandé    | Optimal       |
| --------- | ------------- | ------------- | ------------- |
| GPU       | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM      | 8 Go          | 16Go          | 24 Go         |
| CPU       | 4 cœurs       | 8 cœurs       | 16 cœurs      |
| RAM       | 16Go          | 32Go          | 64Go          |
| Stockage  | 30Go SSD      | 50Go NVMe     | 100Go NVMe    |
| Internet  | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

```bash
cd /workspace && \
pip install sam-2 && \
python -c "from sam2.build_sam import build_sam2; print('SAM2.1 ready!')"
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Installation

```bash
# Package pip officiel (recommandé pour SAM2.1)
pip install sam-2

# Télécharger les checkpoints SAM2.1
python -c "
from sam2.utils.misc import download_file_with_progress

checkpoints = [
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_tiny.pt', 'checkpoints/sam2.1_hiera_tiny.pt'),
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_small.pt', 'checkpoints/sam2.1_hiera_small.pt'),
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_base_plus.pt', 'checkpoints/sam2.1_hiera_base_plus.pt'),
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt', 'checkpoints/sam2.1_hiera_large.pt'),
]
"

# Ou utilisez le script de téléchargement
mkdir -p checkpoints && cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt
```

### Alternative : depuis la source (pour le développement)

```bash
git clone https://github.com/facebookresearch/sam2.git
cd sam2
pip install -e ".[demo]"

# Télécharger les checkpoints SAM2.1
cd checkpoints
bash download_ckpts.sh
```

## Ce que vous pouvez créer

### Montage vidéo

* Supprimer des objets des vidéos
* Remplacer les arrière-plans parfaitement
* Créer des masques vidéo pour le compositing

### Analyse sportive

* Suivre les joueurs pendant les matchs
* Analyser les schémas de mouvement
* Générer des résumés des meilleurs moments

### Imagerie médicale

* Segmenter des organes dans des vidéos CT/MRI
* Suivre le mouvement des cellules en microscopie
* Mesurer la croissance au fil du temps

### Surveillance et sécurité

* Suivre des objets à travers plusieurs caméras
* Compter les personnes/véhicules
* Détection d'anomalies

### Projets créatifs

* Rotoscopie pour les effets visuels (VFX)
* Installations vidéo interactives
* Création de contenu AR/VR

## Utilisation de base

### Segmentation d'images

```python
import torch
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor
from PIL import Image
import numpy as np

# Charger le modèle SAM2.1 (précision améliorée par rapport à SAM2)
checkpoint = "./checkpoints/sam2.1_hiera_large.pt"
model_cfg = "configs/sam2.1/sam2.1_hiera_l.yaml"

sam2 = build_sam2(model_cfg, checkpoint, device="cuda")
predictor = SAM2ImagePredictor(sam2)

# Charger l'image
image = np.array(Image.open("image.jpg"))
predictor.set_image(image)

# Segmenter avec une invite par point
point_coords = np.array([[500, 375]])  # coordonnées x, y
point_labels = np.array([1])  # 1 = premier plan

masks, scores, logits = predictor.predict(
    point_coords=point_coords,
    point_labels=point_labels,
    multimask_output=True
)

# Obtenir le meilleur masque
best_mask = masks[scores.argmax()]
```

### Suivi d'objets vidéo

```python
import torch
from sam2.build_sam import build_sam2_video_predictor
import numpy as np

# Initialiser le prédicteur vidéo SAM2.1 (précision de suivi améliorée)
checkpoint = "./checkpoints/sam2.1_hiera_large.pt"
model_cfg = "configs/sam2.1/sam2.1_hiera_l.yaml"

predictor = build_sam2_video_predictor(model_cfg, checkpoint, device="cuda")

# Initialiser avec la vidéo
video_path = "./video_frames"  # Dossier contenant les images des frames
inference_state = predictor.init_state(video_path=video_path)

# Ajouter un point sur la première frame
predictor.reset_state(inference_state)
frame_idx = 0
obj_id = 1  # ID de l'objet à suivre

points = np.array([[400, 300]], dtype=np.float32)
labels = np.array([1], dtype=np.int32)

# Ajouter un objet à suivre
_, out_obj_ids, out_mask_logits = predictor.add_new_points_or_box(
    inference_state=inference_state,
    frame_idx=frame_idx,
    obj_id=obj_id,
    points=points,
    labels=labels
)

# Propager à travers la vidéo
video_segments = {}
for out_frame_idx, out_obj_ids, out_mask_logits in predictor.propagate_in_video(inference_state):
    video_segments[out_frame_idx] = {
        obj_id: (out_mask_logits[i] > 0.0).cpu().numpy()
        for i, obj_id in enumerate(out_obj_ids)
    }
```

## Suivi multi-objets

```python
import torch
from sam2.build_sam import build_sam2_video_predictor
import numpy as np

predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)

video_path = "./video_frames"
inference_state = predictor.init_state(video_path=video_path)

# Suivre plusieurs objets
objects_to_track = [
    {"id": 1, "point": [200, 150], "frame": 0},  # Personne 1
    {"id": 2, "point": [400, 200], "frame": 0},  # Personne 2
    {"id": 3, "point": [600, 300], "frame": 0},  # Balle
]

for obj in objects_to_track:
    predictor.add_new_points_or_box(
        inference_state=inference_state,
        frame_idx=obj["frame"],
        obj_id=obj["id"],
        points=np.array([obj["point"]], dtype=np.float32),
        labels=np.array([1], dtype=np.int32)
    )

# Propager tous les objets
all_masks = {}
for frame_idx, obj_ids, mask_logits in predictor.propagate_in_video(inference_state):
    all_masks[frame_idx] = {}
    for i, obj_id in enumerate(obj_ids):
        all_masks[frame_idx][obj_id] = (mask_logits[i] > 0.0).cpu().numpy()
```

## Segmentation par invite de boîte

```python
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor
import numpy as np
from PIL import Image

sam2 = build_sam2(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)
predictor = SAM2ImagePredictor(sam2)

image = np.array(Image.open("image.jpg"))
predictor.set_image(image)

# Segmenter avec une boîte englobante
box = np.array([100, 100, 400, 400])  # x1, y1, x2, y2

masks, scores, _ = predictor.predict(
    box=box,
    multimask_output=False
)
```

## Interface Gradio

```python
import gradio as gr
import numpy as np
from PIL import Image
import torch
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor

sam2 = build_sam2(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)
predictor = SAM2ImagePredictor(sam2)

def segment_image(image, x, y):
    predictor.set_image(np.array(image))

    masks, scores, _ = predictor.predict(
        point_coords=np.array([[x, y]]),
        point_labels=np.array([1]),
        multimask_output=True
    )

    best_mask = masks[scores.argmax()]

    # Créer un overlay
    overlay = np.array(image).copy()
    overlay[best_mask] = overlay[best_mask] * 0.5 + np.array([255, 0, 0]) * 0.5

    return Image.fromarray(overlay.astype(np.uint8))

demo = gr.Interface(
    fn=segment_image,
    inputs=[
        gr.Image(type="pil", label="Image d'entrée"),
        gr.Number(label="Coordonnée X"),
        gr.Number(label="Coordonnée Y")
    ],
    outputs=gr.Image(label="Image segmentée"),
    title="SAM2 - Segment Anything",
    description="Cliquez sur des coordonnées pour segmenter des objets. Exécution sur les serveurs GPU CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Exporter les masques en vidéo

```python
import cv2
import numpy as np
from sam2.build_sam import build_sam2_video_predictor

predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)

# ... (code de suivi ci-dessus)

# Exporter en vidéo
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('output_masks.mp4', fourcc, 30.0, (width, height))

for frame_idx in sorted(video_segments.keys()):
    frame = cv2.imread(f"./video_frames/{frame_idx:05d}.jpg")

    # Appliquer l'overlay du masque
    for obj_id, mask in video_segments[frame_idx].items():
        color = [0, 255, 0] if obj_id == 1 else [0, 0, 255]
        frame[mask.squeeze()] = frame[mask.squeeze()] * 0.5 + np.array(color) * 0.5

    out.write(frame.astype(np.uint8))

out.release()
```

## Performances

| Tâche                | Résolution | GPU      | Vitesse |
| -------------------- | ---------- | -------- | ------- |
| Segmentation d'image | 1024x1024  | RTX 3090 | 50 ms   |
| Segmentation d'image | 1024x1024  | RTX 4090 | 30ms    |
| Vidéo (par frame)    | 720p       | RTX 4090 | 45ms    |
| Vidéo (par frame)    | 1080p      | A100     | 35ms    |

## Variantes de modèle (SAM2.1)

SAM2.1 introduit de nouveaux `série sam2.1_hiera_*` checkpoints avec une précision de suivi vidéo améliorée :

| Modèle                    | Paramètres | VRAM     | Vitesse        | Qualité      | Checkpoint                   |
| ------------------------- | ---------- | -------- | -------------- | ------------ | ---------------------------- |
| sam2.1\_hiera\_tiny       | 38M        | 4 Go     | Le plus rapide | Bon          | sam2.1\_hiera\_tiny.pt       |
| sam2.1\_hiera\_small      | 46M        | 5Go      | Rapide         | Meilleur     | sam2.1\_hiera\_small.pt      |
| sam2.1\_hiera\_base\_plus | 80M        | 8 Go     | Moyen          | Excellent    | sam2.1\_hiera\_base\_plus.pt |
| **sam2.1\_hiera\_large**  | **224M**   | **12Go** | **Plus lent**  | **Meilleur** | **sam2.1\_hiera\_large.pt**  |

> **Remarque :** Les modèles SAM2.1 surperforment systématiquement leurs homologues SAM2 sur les benchmarks vidéo, en particulier pour les objets se déplaçant rapidement et les longues occlusions.

## Problèmes courants et solutions

### Mémoire insuffisante

**Problème :** CUDA manque de mémoire sur les vidéos longues

**Solutions :**

```python

# Traiter par morceaux
chunk_size = 100  # frames par chunk

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # Traiter le chunk...
    torch.cuda.empty_cache()  # Libérer la mémoire entre les chunks
```

### Suivi perdu

**Problème :** Le suivi d'objet échoue en milieu de vidéo

**Solutions :**

* Ajouter des points de correction lorsque le suivi dérive
* Utiliser des invites par boîte pour une meilleure segmentation initiale
* Choisir des frames initiales plus claires

```python

# Ajouter un point de correction
predictor.add_new_points_or_box(
    inference_state=inference_state,
    frame_idx=lost_frame,
    obj_id=obj_id,
    points=np.array([[new_x, new_y]], dtype=np.float32),
    labels=np.array([1], dtype=np.int32)
)
```

### Traitement lent

**Problème :** Le traitement vidéo est trop lent

**Solutions :**

* Utiliser une variante de modèle plus petite (tiny/small)
* Réduire la résolution de la vidéo
* Activez la demi-précision (fp16)
* Traiter sur GPU A100

```python

# Utiliser un modèle SAM2.1 plus petit pour la rapidité
predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_t.yaml",
    "./checkpoints/sam2.1_hiera_tiny.pt",
    device="cuda"
)
```

### Mauvaise qualité des masques

**Problème :** Les bords de segmentation sont rugueux

**Solutions :**

* Utiliser un modèle plus grand (large au lieu de tiny)
* Ajouter plus d'invites par point
* Combiner invites par point et par boîte

## Dépannage

### Segmentation inexacte

* Cliquez plus précisément sur l'objet ciblé
* Ajouter plusieurs points positifs/négatifs
* Utiliser une invite par boîte pour les objets volumineux

### Erreur de mémoire vidéo

* Traiter moins de frames à la fois
* Réduire la résolution de la vidéo
* Utiliser le mode streaming pour les vidéos longues

### Suivi perdu

* Ajouter plus d'invites lorsque l'objet change
* Utiliser la fonctionnalité de banque de mémoire
* Vérifier que l'objet n'est pas occulté

### Traitement lent

* SAM2 est gourmand en calcul
* Utiliser A100 pour les vidéos longues
* Envisager de sauter des frames

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| RTX 3060  | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090  | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090  | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [GroundingDINO](/guides/guides_v2-fr/modeles-de-vision/groundingdino.md) - Détecter automatiquement les objets à segmenter
* [Florence-2](/guides/guides_v2-fr/modeles-de-vision/florence2.md) - Compréhension vision-langage
* [Depth Anything](/guides/guides_v2-fr/traitement-dimages/depth-anything.md) - Estimation de la profondeur


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-vision/sam2-video.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.