SAM2 Video

Verfolge und segmentiere Objekte in Videos mit Metas SAM2 auf Clore.ai

Verfolge und segmentiere jedes Objekt per Video mit Metas SAM2.1 — der verbesserten Version von SAM2 mit erhöhter Video-Genauigkeit.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Alle Beispiele in diesem Leitfaden können auf GPU-Servern ausgeführt werden, die über CLORE.AI-Marktplatz Marktplatz gemietet werden.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist SAM2?

SAM2 (Segment Anything Model 2) von Meta AI ermöglicht:

• Echtzeit-Objektsegmentierung in Videos

• Klicke, um jedes Objekt zu verfolgen

• Konsistente Verfolgung trotz Verdeckungen

• Speichereffiziente Videoverarbeitung

Was ist neu in SAM2.1

SAM2.1 bringt im Vergleich zum ursprünglichen SAM2 erhebliche Verbesserungen:

• Verbesserte Video-Genauigkeit — Bessere Verfolgung bei Verdeckungen und schnellen Bewegungen

• Verbesserte Speicherkomponente — Konsistentere Langstreckenverfolgung

• Neue Checkpoints — sam2.1_hiera_* Serie mit besserer Leistung

• Offizielles pip-Paket — Installieren mit pip install sam-2 (kein manueller Build erforderlich)

• Schnellere Inferenz — Optimierte CUDA-Kerne

Ressourcen

• GitHub: facebookresearch/sam2

• Paper: SAM2-Paper

• Demo: SAM2-Demo

• Modellgewichte: SAM2.1-Checkpoints

Empfohlene Hardware

Komponente	Minimum	Empfohlen	Optimal
GPU	RTX 3060 12 GB	RTX 4080 16 GB	RTX 4090 24GB
VRAM	8 GB	16 GB	24 GB
CPU	4 Kerne	8 Kerne	16 Kerne
RAM	16 GB	32 GB	64 GB
Speicher	30 GB SSD	50 GB NVMe	100 GB NVMe
Internet	100 Mbit/s	500 Mbit/s	1 Gbit/s

Schnellbereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

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

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Installation

# Offizielles pip-Paket (empfohlen für SAM2.1)
pip install sam-2

# SAM2.1-Checkpoints herunterladen
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'),
]
"

# Oder das Download-Skript verwenden
mkdir -p checkpoints && cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt

Alternative: Aus dem Quellcode (für die Entwicklung)

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

# SAM2.1-Checkpoints herunterladen
cd checkpoints
bash download_ckpts.sh

Was du erstellen kannst

Videobearbeitung

• Objekte aus Videos entfernen

• Hintergründe nahtlos ersetzen

• Videomasken für Compositing erstellen

Sportanalyse

• Spieler durch Spiele verfolgen

• Bewegungsmuster analysieren

• Highlights erstellen

Medizinische Bildgebung

• Organe in CT-/MRT-Videos segmentieren

• Zellbewegungen in der Mikroskopie verfolgen

• Wachstum im Zeitverlauf messen

Überwachung & Sicherheit

• Objekte kameraübergreifend verfolgen

• Personen/Fahrzeuge zählen

• Anomalieerkennung

Kreative Projekte

• Rotoskopie für VFX

• Interaktive Video-Installationen

• AR/VR-Inhaltserstellung

Grundlegende Verwendung

Bildsegmentierung

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

# SAM2.1-Modell laden (verbesserte Genauigkeit gegenüber 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)

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

# Mit Punkt-Prompt segmentieren
point_coords = np.array([[500, 375]])  # x-, y-Koordinaten
point_labels = np.array([1])  # 1 = Vordergrund

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

# Beste Maske ermitteln
best_mask = masks[scores.argmax()]

Video-Objektverfolgung

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

# SAM2.1-Video-Predictor initialisieren (verbesserte Verfolgungsgenauigkeit)
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")

# Mit Video initialisieren
video_path = "./video_frames"  # Verzeichnis mit Frame-Bildern
inference_state = predictor.init_state(video_path=video_path)

# Punkt im ersten Frame hinzufügen
predictor.reset_state(inference_state)
frame_idx = 0
obj_id = 1  # Objekt-ID für die Verfolgung

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

# Objekt zur Verfolgung hinzufügen
_, 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
)

# Durch das Video propagieren
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)
    }

Multi-Objekt-Verfolgung

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)

# Mehrere Objekte verfolgen
objects_to_track = [
    {"id": 1, "point": [200, 150], "frame": 0},  # Person 1
    {"id": 2, "point": [400, 200], "frame": 0},  # Person 2
    {"id": 3, "point": [600, 300], "frame": 0},  # Ball
]

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

# Alle Objekte propagieren
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()

Box-Prompt-Segmentierung

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)

# Mit Begrenzungsrahmen segmentieren
box = np.array([100, 100, 400, 400])  # x1, y1, x2, y2

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

Gradio-Oberfläche

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()]

    # Overlay erstellen
    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="Eingabebild"),
        gr.Number(label="X-Koordinate"),
        gr.Number(label="Y-Koordinate")
    ],
    outputs=gr.Image(label="Segmentiertes Bild"),
    title="SAM2 - Alles segmentieren",
    description="Klicke auf Koordinaten, um Objekte zu segmentieren. Läuft auf CLORE.AI-GPU-Servern."
)

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

Masken als Video exportieren

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

# ... (Verfolgungscode von oben)

# In Video exportieren
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")

    # Masken-Overlay anwenden
    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()

Leistung

Aufgabe	Auflösung	GPU	Geschwindigkeit
Bildsegmentierung	1024x1024	RTX 3090	50ms
Bildsegmentierung	1024x1024	RTX 4090	30ms
Video (pro Frame)	720p	RTX 4090	45ms
Video (pro Frame)	1080p	A100	35 ms

Modellvarianten (SAM2.1)

SAM2.1 führt neue sam2.1_hiera_* Checkpoints mit verbesserter Video-Verfolgungsgenauigkeit ein:

Modell	Parameter	VRAM	Geschwindigkeit	Qualität	Checkpoint
sam2.1_hiera_tiny	38M	4 GB	Am schnellsten	Gut	sam2.1_hiera_tiny.pt
sam2.1_hiera_small	46M	5GB	Schnell	Besser	sam2.1_hiera_small.pt
sam2.1_hiera_base_plus	80M	8 GB	Mittel	Großartig	sam2.1_hiera_base_plus.pt
sam2.1_hiera_large	224M	12 GB	Langsamer	Am besten	sam2.1_hiera_large.pt

Hinweis: SAM2.1-Modelle übertreffen ihre SAM2-Pendants auf Videobenchmarks durchweg, insbesondere bei schnell bewegten Objekten und langen Verdeckungen.

Häufige Probleme & Lösungen

Speicher erschöpft

Problem: CUDA-Speicher bei langen Videos erschöpft

Lösungen:

# In Chunks verarbeiten
chunk_size = 100  # Frames pro Chunk

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # Chunk verarbeiten...
    torch.cuda.empty_cache()  # Speicher zwischen den Chunks leeren

Verfolgung verloren

Problem: Objektverfolgung schlägt mitten im Video fehl

Lösungen:

• Korrekturpunkte hinzufügen, wenn die Verfolgung driftet

• Verwende Box-Prompts für eine bessere anfängliche Segmentierung

• Wähle klarere Anfangsframes

# Korrekturpunkt hinzufügen
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)
)

Langsame Verarbeitung

Problem: Die Videoverarbeitung ist zu langsam

Lösungen:

• Verwende eine kleinere Modellvariante (tiny/small)

• Verringere die Videoauflösung

• Halbpräzision aktivieren (fp16)

• Auf A100-GPU verarbeiten

# Kleineres SAM2.1-Modell für mehr Geschwindigkeit verwenden
predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_t.yaml",
    "./checkpoints/sam2.1_hiera_tiny.pt",
    device="cuda"
)

Schlechte Maskenqualität

Problem: Segmentierungsränder sind grob

Lösungen:

• Verwende ein größeres Modell (large statt tiny)

• Füge mehr Punkt-Prompts hinzu

• Kombiniere Punkt- und Box-Prompts

Fehlerbehebung

Segmentierung ungenau

• Klicke präziser auf das Zielobjekt

• Füge mehrere positive/negative Punkte hinzu

• Verwende Box-Prompt für große Objekte

Video-Speicherfehler

• Verarbeite weniger Frames gleichzeitig

• Verringere die Videoauflösung

• Verwende den Streaming-Modus für lange Videos

Verfolgung verloren

• Füge mehr Prompts hinzu, wenn sich das Objekt verändert

• Verwende die Memory-Bank-Funktion

• Prüfe, ob das Objekt nicht verdeckt ist

Langsame Verarbeitung

• SAM2 ist rechenintensiv

• Verwende A100 für lange Videos

• Ziehe Frame-Skipping in Betracht

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• GroundingDINO - Objekte zur Segmentierung automatisch erkennen

• Florence-2 - Visuelles Sprachverständnis

• Depth Anything - Tiefenschätzung