> 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/video-generierung/mochi-1.md).

# Mochi-1 Video

**Mochi-1** ist Genmos Open-Source-Videoerzeugungsmodell mit 10 Milliarden Parametern, das Ausgaben mit 848×480 @ 30 fps und physikalisch realistischem Bewegungsverlauf erzeugt. Es verwendet eine asymmetrische Diffusions-Transformer-Architektur (AsymmDiT) und gehört zu den qualitativ hochwertigsten Open-Source-Videomodellen hinsichtlich Bewegungsgenauigkeit. Setzen Sie es auf Clore.ais GPU-Cloud ein, um professionelle Videos zu einem Bruchteil der Kosten kommerzieller APIs zu erzeugen.

***

## Was ist Mochi-1?

Mochi-1 ist ein **10-Milliarden-Parameter** Video-Diffusionsmodell, das darauf trainiert wurde, Videos mit:

* Sanfter, physikalisch plausibler Bewegung
* Hoher zeitlicher Konsistenz
* Starker Prompt-Treue
* 848×480 Auflösung bei 30 fps

Es verwendet einen **asymmetrischen Diffusions-Transformer** (AsymmDiT)-Architektur — unterschiedliche Encoder-Tiefen für Video und Text — die effiziente Inferenz in großem Maßstab ermöglicht. Die Gewichte wurden unter der Genmo Open Source License veröffentlicht und sind kostenlos für Forschung und kommerzielle Nutzung.

**Modell-Highlights:**

* 10B Parameter
* Native Ausgabe 848×480 @ 30 fps
* Hohe Bewegungsgenauigkeit (in Community-Benchmarks oben platziert)
* Verfügbar auf Hugging Face mit Diffusers-Integration
* Gradio-Demo-UI für einfache Interaktion

***

## Voraussetzungen

| Anforderung | Minimum  | Empfohlen   |
| ----------- | -------- | ----------- |
| GPU-VRAM    | 24 GB    | 40–80 GB    |
| GPU         | RTX 4090 | A100 / H100 |
| RAM         | 32 GB    | 64 GB       |
| Speicher    | 60 GB    | 100 GB      |
| CUDA        | 11.8+    | 12.1+       |

{% hint style="warning" %}
Mochi-1 ist ein großes Modell (≈40 GB in fp8 / ≈80 GB in bf16). Eine einzelne RTX 4090 (24 GB) kann es mit Quantisierung betreiben. Für volle Qualität verwenden Sie eine A100 40 GB oder größer. Multi-GPU-Konfigurationen werden unterstützt.
{% endhint %}

***

## Schritt 1 — Mieten Sie eine GPU auf Clore.ai

1. Gehe zu [clore.ai](https://clore.ai) und melden Sie sich an.
2. Klicken Sie **Marktplatz** und filtern:
   * VRAM: **≥ 24 GB** (RTX 4090 Minimum, A100 empfohlen)
   * Für Multi-GPU: nach GPU-Anzahl ≥ 2 filtern
3. Wählen Sie Ihren Server und klicken Sie **Konfigurieren**.
4. Setzen Sie das Docker-Image auf `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` (Basis-Image — wir installieren Mochi darin).
5. Offene Ports festlegen: `22` (SSH) und `7860` (Gradio-UI).
6. Klicken Sie **Mieten**.

{% hint style="info" %}
Clore.ai listet A100-40-GB-Instanzen ab etwa \~$0.60–$0.90/Stunde. Für Mochi-1 in voller Qualität ist dies die kosteneffizienteste Wahl.
{% endhint %}

***

## Schritt 2 — Benutzerdefiniertes Dockerfile

Bauen Sie Ihr eigenes Image oder verwenden Sie dieses `Dockerfile` um eine einsatzbereite Mochi-1-Umgebung zu erstellen:

```dockerfile
FROM pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    git wget curl ffmpeg \
    libgl1 libglib2.0-0 \
    openssh-server \
    && rm -rf /var/lib/apt/lists/*

# Konfiguriere SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
    sed -i 's/UsePAM yes/UsePAM no/' /etc/ssh/sshd_config

WORKDIR /workspace

# Mochi-1-Repository klonen
RUN git clone https://github.com/genmoai/mochi /workspace/mochi

# Python-Abhängigkeiten installieren
RUN cd /workspace/mochi && \
    pip install --upgrade pip && \
    pip install -e . && \
    pip install gradio huggingface_hub

EXPOSE 22 7860

CMD service ssh start && \
    echo "Mochi-1-Umgebung bereit. Führen Sie das Download-Skript aus und starten Sie dann die Demo." && \
    tail -f /dev/null
```

### Build und Push zu Docker Hub

Bauen Sie das Image lokal und pushen Sie es in Ihr eigenes Docker-Hub-Konto (ersetzen Sie `YOUR_DOCKERHUB_USERNAME` durch deinen tatsächlichen Benutzernamen):

```bash
docker build -t YOUR_DOCKERHUB_USERNAME/mochi-1:latest .
docker push YOUR_DOCKERHUB_USERNAME/mochi-1:latest
```

Verwenden Sie dann `YOUR_DOCKERHUB_USERNAME/mochi-1:latest` als Ihr Docker-Image in Clore.ai.

{% hint style="info" %}
Es gibt kein offizielles vorgefertigtes Docker-Image für Mochi-1 auf Docker Hub. Sie müssen es aus dem obigen Dockerfile bauen. Alternativ verwenden Sie `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` als Basis-Image direkt und führen die Setup-Befehle manuell per SSH aus.
{% endhint %}

***

## Schritt 3 — Verbindung per SSH

Sobald Ihre Instanz läuft:

```bash
ssh root@<clore-host> -p <assigned-ssh-port>
```

***

## Schritt 4 — Mochi-1-Gewichte herunterladen

Die Modellgewichte werden auf Hugging Face gehostet. Laden Sie sie über das `huggingface_hub` CLI:

```bash
cd /workspace

# Installieren Sie huggingface-cli, falls nicht vorhanden
pip install -U huggingface_hub

# Mochi-1-Gewichte herunterladen (~40 GB für bf16)
huggingface-cli download genmo/mochi-1-preview \
    --local-dir /workspace/mochi-weights \
    --include "*.safetensors" "*.json" "*.txt"
```

{% hint style="info" %}
Das vollständige bf16-Modell ist ungefähr 80 GB groß. Die `fp8` quantisierte Version ist \~40 GB und läuft auf RTX 4090 (24 GB) mit CPU-Offloading. Geben Sie `--include "*fp8*"` an, um nur quantisierte Gewichte herunterzuladen.
{% endhint %}

### Alternative: Nur fp8-quantisierte Gewichte herunterladen

```bash
huggingface-cli download genmo/mochi-1-preview \
    --local-dir /workspace/mochi-weights \
    --include "*fp8*" "*.json" "*.txt"
```

***

## Schritt 5 — Starten der Gradio-Demo

Mochi-1 wird mit einer Gradio-Web-UI für einfache Text-zu-Video-Generierung ausgeliefert:

```bash
cd /workspace/mochi

python demos/gradio_ui.py \
    --model_dir /workspace/mochi-weights \
    --share False \
    --host 0.0.0.0 \
    --port 7860
```

**Für Low-VRAM-Modus (RTX 4090, 24 GB):**

```bash
python demos/gradio_ui.py \
    --model_dir /workspace/mochi-weights \
    --cpu_offload \
    --share False \
    --host 0.0.0.0 \
    --port 7860
```

{% hint style="info" %}
Der `--cpu_offload` Flag verschiebt Modellschichten auf den CPU-RAM, wenn sie nicht verwendet werden, und reduziert die Spitzen-VRAM auf \~18–20 GB zum Preis einer etwa 2× langsameren Erzeugung.
{% endhint %}

***

## Schritt 6 — Zugriff auf die Web-UI

Öffnen Sie Ihren Browser und navigieren Sie zu:

```
http://<clore-host>:<public-port-7860>
```

Sie sehen die Mochi-1-Gradio-Oberfläche mit:

* Eingabefeld für Text-Prompt
* Generierungseinstellungen (Schritte, Guidance-Scale, Seed)
* Video-Ausgabespieler

***

## Schritt 7 — Generieren Sie Ihr erstes Video

### Beispiel-Prompts

**Naturszene:**

```
Ein majestätischer Wasserfall, der über moosbedeckte Felsen in einem üppigen Regenwald herabstürzt, 
Goldene Stunde Sonnenlicht, das durch das Blätterdach filtert, langsame filmische Schwenkbewegung
```

**Action-Szene:**

```
Ein Gepard sprintet mit voller Geschwindigkeit über eine offene Savanne, 
Staub, der hinter ihm aufwirbelt, dramatische Totale, 4K-Wildtierdokumentation
```

**Abstrakt/künstlerisch:**

```
Bunte Farbe, die sich in Wasser in extremer Zeitlupe wirbelt, 
leuchtend blaue und orange Pigmente mischen sich, Makro-Objektiv, Studio-Beleuchtung
```

### Empfohlene Einstellungen

| Parameter      | Wert                    |
| -------------- | ----------------------- |
| Schritte       | 64                      |
| Guidance Scale | 4.5                     |
| Dauer          | 5,1 Sekunden (Standard) |
| Auflösung      | 848×480 (nativ)         |

{% hint style="info" %}
Die Generierungszeit variiert stark je nach GPU. Auf einer A100 80 GB benötigt ein 5-Sekunden-Video ungefähr **2–4 Minuten**. Auf einer RTX 4090 mit CPU-Offload rechnen Sie mit **8–15 Minuten**.
{% endhint %}

***

## Python-API-Verwendung

Für programmatische Erzeugung verwenden Sie die Diffusers-Pipeline:

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video

# Pipeline laden
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# Video erzeugen
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Ein Golden Retriever spielt Apport am sonnigen Strand, filmisch",
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
        generator=torch.Generator("cuda").manual_seed(42)
    ).frames[0]

# Exportieren
export_to_video(frames, "output.mp4", fps=30)
print("Video gespeichert in output.mp4")
```

### Batch-Generierungsskript

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
import os

pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

prompts = [
    "Ein Schmetterling landet in Zeitlupe auf einer Blume, Makrofotografie",
    "Ozeanwellen schlagen bei Sonnenuntergang gegen felsige Klippen, Drohnenaufnahme",
    "Nordlichter tanzen über einem sternenklaren Himmel über einem zugefrorenen See",
]

os.makedirs("/workspace/outputs", exist_ok=True)

for i, prompt in enumerate(prompts):
    frames = pipe(
        prompt=prompt,
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
    ).frames[0]
    
    output_path = f"/workspace/outputs/video_{i:03d}.mp4"
    export_to_video(frames, output_path, fps=30)
    print(f"Gespeichert: {output_path}")
```

***

## Multi-GPU-Inferenz

Für schnellere Erzeugung mit mehreren GPUs:

```python
import torch
from diffusers import MochiPipeline

# Verwenden Sie device_map für automatische Multi-GPU-Verteilung
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16,
    device_map="balanced"
)

# Kein cpu_offload mit mehreren GPUs erforderlich
frames = pipe(
    prompt="Ihr Prompt hier",
    num_frames=84,
    guidance_scale=4.5,
    num_inference_steps=64,
).frames[0]
```

{% hint style="info" %}
Clore.ai bietet Multi-GPU-Server (2×, 4× RTX 4090 oder A100). Mit 2× A100 80 GB sinkt die Generierungszeit für einen 5-Sekunden-Clip auf unter 60 Sekunden.
{% endhint %}

***

## Fehlerbehebung

### CUDA Out of Memory

```
torch.cuda.OutOfMemoryError: CUDA out of memory
```

**Lösungen:**

1. Fügen Sie `--cpu_offload` an den Gradio-Befehl
2. VAE-Slicing aktivieren: `pipe.enable_vae_slicing()`
3. Reduzieren Sie `num_frames` (versuchen Sie 24 statt 84)
4. Verwenden Sie fp8-quantisierte Gewichte statt bf16

### Langsames Laden des Modells

**Lösung:** Stellen Sie sicher, dass die Gewichte auf einer schnellen NVMe-Festplatte liegen, nicht auf einer HDD. Überprüfen Sie die Speicherleistung:

```bash
dd if=/dev/zero of=/workspace/test bs=1M count=1000 conv=fdatasync
```

### Videoartefakte / zeitliches Flackern

**Lösungen:**

* Erhöhen Sie die Inferenzschritte (versuchen Sie 80–100)
* Passen Sie die Guidance-Scale an (Bereich 3.5–5.0 ist in der Regel am besten)
* Verwenden Sie einen spezifischen Seed für Reproduzierbarkeit und Iteration

### Port 7860 nicht zugänglich

Überprüfen Sie, dass der Port in Clore.ai korrekt geöffnet wurde und der Gradio-Server an `0.0.0.0`:

```bash
ss -tlnp | grep 7860
```

***

## Kostenabschätzung

| GPU          | VRAM   | Geschätzter Preis | 5s Videolänge |
| ------------ | ------ | ----------------- | ------------- |
| RTX 4090     | 24 GB  | \~$0.35/Stunde    | \~10–15 min   |
| A100 40GB    | 40 GB  | \~$0.70/Stunde    | \~3–5 min     |
| A100 80GB    | 80 GB  | \~$1.20/Stunde    | \~2–3 min     |
| 2× A100 80GB | 160 GB | \~$2.20/hr        | \~60–90 sec   |

***

## Clore.ai GPU-Empfehlungen

Mochi-1 ist VRAM-hungrig — das 10B-Parameter-Modell erfordert eine sorgfältige GPU-Auswahl.

| GPU          | VRAM   | Clore.ai-Preis | Modus                           | 5s Video-Generierungszeit |
| ------------ | ------ | -------------- | ------------------------------- | ------------------------- |
| RTX 4090     | 24 GB  | \~$0.70/Stunde | nur fp8-quantisiert             | \~10–15 min               |
| A100 40GB    | 40 GB  | \~$1.20/Stunde | bf16 empfohlen                  | \~3–5 min                 |
| A100 80GB    | 80 GB  | \~$2.00/Stunde | volles bf16, schnell            | \~2–3 min                 |
| 2× A100 80GB | 160 GB | \~$4.00/hr     | Tensor-Parallel, am schnellsten | \~60–90 sec               |

{% hint style="warning" %}
**RTX 3090 (24GB) wird nicht empfohlen** — Mochi-1 im fp8-Modus benötigt mindestens 24 GB und lässt kaum Spielraum. Die RTX 4090 (24GB) funktioniert in fp8, läuft aber bei längeren Sequenzen häufig in OOM. Beginnen Sie mit einer A100 40GB für zuverlässige Ergebnisse.
{% endhint %}

**Bestes Preis-Leistungs-Verhältnis für Qualität:** A100 40GB für etwa \~$1.20/Stunde erzeugt einen 5-Sekunden-Clip in 3–5 Minuten. Das sind etwa \~$0.08–0.10 pro Videoclip — deutlich günstiger als Runway ML ($0.25–0.50/Clip) oder Pika Labs-Abonnements.

***

## Nützliche Ressourcen

* [Mochi-1 GitHub](https://github.com/genmoai/mochi)
* [Mochi-1 auf Hugging Face](https://huggingface.co/genmo/mochi-1-preview)
* [Genmo Blog — Mochi-1 Veröffentlichung](https://www.genmo.ai/blog/mochi-1)
* [Diffusers Mochi Dokumentation](https://huggingface.co/docs/diffusers/api/pipelines/mochi)
* [Mochi Prompt Anleitung (Community)](https://github.com/genmoai/mochi/blob/main/README.md)


---

# 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/video-generierung/mochi-1.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.