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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI la place de marché.

Louer sur CLORE.AI

Visitez la place de marché CLORE.AI
Filtrez par type de GPU, VRAM et prix
Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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
Article : Article SAM2
Démo : Démo SAM2
Poids du modèle : Points de contrôle SAM2.1

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 :

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:

Accédez à Mes commandes la page
Cliquez sur votre commande
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

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

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

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

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

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

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 :


# 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


# 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


# 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 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 - Détecte automatiquement les objets à segmenter
Florence-2 - Compréhension vision-langage
Depth Anything - Estimation de profondeur

PrécédentFlorence-2

SuivantGroundingDINO

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?