SAM2 Vidéo

Suivez et segmentez des objets dans la vidéo 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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace le marketplace.

Location sur CLORE.AI

1. Visitez 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

• Article : Article SAM2

• Démo : Démo SAM2

• Poids du modèle : Checkpoints SAM2.1

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 :

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

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

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

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

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

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

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

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

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 :

# 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

# 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

# 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 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 - Détecter automatiquement les objets à segmenter

• Florence-2 - Compréhension vision-langage

• Depth Anything - Estimation de la profondeur