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

# 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](/guides/guides_v2-de/vision-modelle/groundingdino.md) - Objekte automatisch zum Segmentieren erkennen
* [Florence-2](/guides/guides_v2-de/vision-modelle/florence2.md) - Vision-Sprach-Verstä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:

```
GET https://docs.clore.ai/guides/guides_v2-de/vision-modelle/sam2-video.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.