# SAM2 Video

Verfolge und segmentiere beliebige Objekte in Videos mit Metas SAM2.1 — der verbesserten Version von SAM2 mit gesteigerter Video-Genauigkeit.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Alle Beispiele in diesem Leitfaden können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace) Marktplatz ausgeführt werden.
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen Sie [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Umgebungsvariablen bei Bedarf hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden Sie in **Meine Bestellungen**
* Webschnittstellen: Verwenden Sie 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
* Klicken, um beliebiges Objekt zu verfolgen
* Konsistentes Tracking trotz Verdeckungen
* Speichereffiziente Videoverarbeitung

## Was ist neu in SAM2.1

SAM2.1 bringt bedeutende Verbesserungen gegenüber dem ursprünglichen SAM2:

* **Verbesserte Video-Genauigkeit** — Besseres Tracking bei Verdeckungen und schneller Bewegung
* **Verbessertes Speichermodul** — Konsistenteres Tracking über lange Zeiträume
* **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](https://github.com/facebookresearch/sam2)
* **Paper:** [SAM2-Papier](https://arxiv.org/abs/2408.00714)
* **Demo:** [SAM2-Demo](https://sam2.metademolab.com/)
* **Modellgewichte:** [SAM2.1-Checkpoints](https://github.com/facebookresearch/sam2#model-checkpoints)

## Empfohlene Hardware

| Komponente | Minimum       | Empfohlen     | Optimal       |
| ---------- | ------------- | ------------- | ------------- |
| GPU        | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM       | 8GB           | 16GB          | 24GB          |
| CPU        | 4 Kerne       | 8 Kerne       | 16 Kerne      |
| RAM        | 16GB          | 32GB          | 64GB          |
| Speicher   | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Internet   | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

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

**Befehl:**

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

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

## Installation

```bash
# 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 benutze das Download-Skript
mkdir -p checkpoints && cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt
```

### Alternative: Vom Quellcode (für Entwicklung)

```bash
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 Sie erstellen können

### Video-Bearbeitung

* Objekte aus Videos entfernen
* Hintergründe nahtlos ersetzen
* Video-Masken für Compositing erstellen

### Sportanalyse

* Spieler durch Spiele verfolgen
* Bewegungsmuster analysieren
* Highlight-Zusammenstellungen erzeugen

### Medizinische Bildgebung

* Organe in CT-/MRI-Videos segmentieren
* Zellbewegung in der Mikroskopie verfolgen
* Wachstum über die Zeit messen

### Überwachung & Sicherheit

* Objekte über Kameras hinweg verfolgen
* Personen/Fahrzeuge zählen
* Anomalieerkennung

### Kreative Projekte

* Rotoscoping für VFX
* Interaktive Videoinstallationen
* AR/VR-Inhalte erstellen

## Grundlegende Verwendung

### Bildsegmentierung

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

# Lade SAM2.1-Modell (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)

# Segmentieren mit Punkt-Prompt
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 erhalten
best_mask = masks[scores.argmax()]
```

### Video-Objekt-Tracking

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

# Initialisiere SAM2.1 Video-Predictor (verbesserte Tracking-Genauigkeit)
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 das Tracking

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

# Objekt zum Verfolgen 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 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-Tracking

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

# 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

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

# 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

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

    # 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 - Segment Anything",
    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

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

# ... (Tracking-Code von oben)

# Exportieren als Video
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     | 35ms            |

## Modellvarianten (SAM2.1)

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

| Modell                    | Parameter | VRAM     | Geschwindigkeit | Qualität      | Checkpoint                   |
| ------------------------- | --------- | -------- | --------------- | ------------- | ---------------------------- |
| sam2.1\_hiera\_tiny       | 38M       | 4GB      | 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       | 8GB      | Mittel          | Großartig     | sam2.1\_hiera\_base\_plus.pt |
| **sam2.1\_hiera\_large**  | **224M**  | **12GB** | **Langsamer**   | **Am besten** | **sam2.1\_hiera\_large.pt**  |

> **Hinweis:** SAM2.1-Modelle übertreffen ihre SAM2-Pendants durchgängig in Video-Benchmarks, insbesondere bei schnell bewegten Objekten und langen Verdeckungen.

## Häufige Probleme & Lösungen

### Kein Speicher mehr

**Problem:** CUDA: Nicht genug Speicher bei langen Videos

**Lösungen:**

```python

# In Abschnitten verarbeiten
chunk_size = 100  # Frames pro Abschnitt

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # Abschnitt verarbeiten...
    torch.cuda.empty_cache()  # Speicher zwischen Abschnitten freigeben
```

### Tracking verloren

**Problem:** Objektverfolgung schlägt mitten im Video fehl

**Lösungen:**

* Korrekturpunkte hinzufügen, wenn das Tracking driftet
* Box-Prompts für bessere Anfangssegmentierung verwenden
* Klarere Anfangsframes wählen

```python

# 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:** Videoverarbeitung ist zu langsam

**Lösungen:**

* Kleinere Modellvariante verwenden (tiny/small)
* Videoauflösung reduzieren
* Aktiviere Halbfeld-Präzision (fp16)
* Auf A100 GPU verarbeiten

```python

# Kleinere SAM2.1-Modellvariante für 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 rau

**Lösungen:**

* Größeres Modell verwenden (large statt tiny)
* Mehr Punkt-Prompts hinzufügen
* Punkt- und Box-Prompts kombinieren

## Fehlerbehebung

### Unpräzise Segmentierung

* Genauer auf das Zielobjekt klicken
* Mehrere positive/negative Punkte hinzufügen
* Box-Prompt für große Objekte verwenden

### Video-Speicherfehler

* Weniger Frames gleichzeitig verarbeiten
* Videoauflösung reduzieren
* Streaming-Modus für lange Videos verwenden

### Tracking verloren

* Mehr Prompts hinzufügen, wenn sich das Objekt verändert
* Die Memory-Bank-Funktion verwenden
* Überprüfen, dass das Objekt nicht verdeckt ist

### Langsame Verarbeitung

* SAM2 ist rechenintensiv
* Für lange Videos A100 verwenden
* Frame-Skipping in Betracht ziehen

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (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           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen

## Nächste Schritte

* [GroundingDINO](https://docs.clore.ai/guides/guides_v2-de/vision-modelle/groundingdino) - Objekte automatisch zum Segmentieren erkennen
* [Florence-2](https://docs.clore.ai/guides/guides_v2-de/vision-modelle/florence2) - Vision-Sprach-Verständnis
* [Depth Anything](https://docs.clore.ai/guides/guides_v2-de/bildverarbeitung/depth-anything) - Tiefenschätzung