> 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-de/computer-vision-modelle/sam2-video.md).

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

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](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-Marktplatz](https://clore.ai/marketplace) Marktplatz gemietet werden.
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI-Marktplatz](https://clore.ai/marketplace)
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](https://github.com/facebookresearch/sam2)
* **Paper:** [SAM2-Paper](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 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:**

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

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

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

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

# 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

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

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

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

# ... (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:**

```python

# 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

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

```python

# 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*](https://clore.ai/marketplace) *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](/guides/guides_v2-de/computer-vision-modelle/groundingdino.md) - Objekte zur Segmentierung automatisch erkennen
* [Florence-2](/guides/guides_v2-de/computer-vision-modelle/florence2.md) - Visuelles Sprachverständnis
* [Depth Anything](/guides/guides_v2-de/bildverarbeitung/depth-anything.md) - Tiefenschätzung


---

# 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-de/computer-vision-modelle/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.