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

Suivez et segmentez des objets dans des vidéos avec SAM2 de Meta sur Clore.ai

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 [la place de marché CLORE.AI](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 [la place de marché CLORE.AI](https://clore.ai/marketplace) la place de marché.
{% endhint %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À 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@<proxy-address>`

## Qu'est-ce que SAM2 ?

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

* Segmentation d'objets vidéo en temps réel
* Cliquer pour suivre n'importe quel objet
* Suivi cohérent malgré les occultations
* Traitement vidéo économe en mémoire

## Nouveautés de SAM2.1

SAM2.1 apporte des améliorations significatives par rapport au SAM2 original :

* **Précision vidéo améliorée** — Meilleur suivi malgré les occultations et les mouvements rapides
* **Module mémoire amélioré** — Suivi à longue portée plus cohérent
* **Nouveaux points de contrôle** — `sam2.1_hiera_*` série avec de meilleures performances
* **Package pip officiel** — Installation avec `pip install sam-2` (aucune compilation manuelle requise)
* **Inférence plus rapide** — Noyaux 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 :** [Points de contrôle SAM2.1](https://github.com/facebookresearch/sam2#model-checkpoints)

## Matériel recommandé

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

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.11.0-cuda12.8-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 prêt !')"
```

## Accéder à votre service

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

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_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 points de contrôle 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 les sources (pour le développement)

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

# Télécharger les points de contrôle SAM2.1
cd checkpoints
bash download_ckpts.sh
```

## Ce que vous pouvez créer

### Édition vidéo

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

### Analyse sportive

* Suivre les joueurs au fil des matchs
* Analyser les schémas de mouvement
* Générer des montages des temps forts

### Imagerie médicale

* Segmenter les organes dans les vidéos CT/IRM
* Suivre le mouvement cellulaire en microscopie
* Mesurer la croissance dans le temps

### Surveillance et sécurité

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

### Projets créatifs

* Rotoscopie pour les effets visuels
* 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 de 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 suiveur 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"  # Répertoire 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 l'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 dans 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 une superposition
    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. Fonctionne sur les serveurs GPU de CLORE.AI."
)

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

## Exporter les masques sous forme de 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 vers une 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 la superposition 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 | 50ms    |
| Segmentation d'image | 1024x1024  | RTX 4090 | 30 ms   |
| Vidéo (par image)    | 720p       | RTX 4090 | 45 ms   |
| Vidéo (par image)    | 1080p      | A100     | 35 ms   |

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

SAM2.1 introduit de nouveaux `sam2.1_hiera_*` points de contrôle avec une précision de suivi vidéo améliorée :

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

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

## Problèmes courants et solutions

### Mémoire insuffisante

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

**Solutions :**

```python

# Traiter par morceaux
chunk_size = 100  # images par lot

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

### Perte de suivi

**Problème :** Le suivi de l'objet échoue en cours de vidéo

**Solutions :**

* Ajoutez des points de correction lorsque le suivi dérive
* Utilisez des invites de boîte pour une meilleure segmentation initiale
* Choisissez des images 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 :**

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

```python

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

### Mauvaise qualité de masque

**Problème :** Les bords de la segmentation sont irréguliers

**Solutions :**

* Utilisez un modèle plus grand (large au lieu de tiny)
* Ajoutez davantage d'invites de points
* Combinez des invites de points et de boîte

## Dépannage

### Segmentation imprécise

* Cliquez plus précisément sur l'objet cible
* Ajoutez plusieurs points positifs/négatifs
* Utilisez une invite de boîte pour les grands objets

### Erreur de mémoire vidéo

* Traitez moins d'images à la fois
* Réduisez la résolution vidéo
* Utilisez le mode streaming pour les longues vidéos

### Perte de suivi

* Ajoutez davantage d'invites lorsque l'objet change
* Utilisez la fonctionnalité de banque mémoire
* Vérifiez que l'objet n'est pas occulté

### Traitement lent

* SAM2 est gourmand en calcul
* Utilisez un A100 pour les longues vidéos
* Envisagez de sauter des images

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs

## Étapes suivantes

* [GroundingDINO](/guides/guides_v2-fr/modeles-de-vision/groundingdino.md) - Détecte 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 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.