Mochi-1-Video

Mochi-1 ist Genmos Open-Source-Videogenerierungsmodell mit 10 Milliarden Parametern, das Ausgaben in 848×480 bei 30 fps mit physikalisch realistischer Bewegung erzeugt. Es verwendet eine asymmetrische Diffusionstransformer-(AsymmDiT)-Architektur und gehört zu den hochwertigsten Open-Source-Videomodellen in Bezug auf Bewegungstreue. Setzen Sie es in Clore.ais GPU-Cloud ein, um Videos in professioneller Qualität zu einem Bruchteil der Kosten kommerzieller APIs zu erzeugen.

---

Was ist Mochi-1?

Mochi-1 ist ein Modell mit 10 Milliarden Parametern Videodiffusionsmodell, das darauf trainiert wurde, Videos mit folgenden Eigenschaften zu erzeugen:

• Flüssige, physikalisch plausible Bewegung

• Hohe zeitliche Konsistenz

• Starke Einhaltung der Vorgabe

• 848×480 Auflösung bei 30 fps

Es verwendet eine asymmetrische Diffusionstransformer -(AsymmDiT)-Architektur — unterschiedliche Encoder-Tiefen für Video und Text — die eine effiziente Inferenz im großen Maßstab ermöglicht. Die Gewichte werden unter der Genmo Open Source License veröffentlicht und sind für Forschungs- und kommerzielle Nutzung frei verfügbar.

Modell-Highlights:

• 10 Mrd. Parameter

• Natives 848×480-Ausgabeformat bei 30 fps

• Hohe Bewegungstreue (in Community-Benchmarks ganz 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	12.8+	12.8+

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 ausführen. Für volle Qualität verwenden Sie eine A100 mit 40 GB oder mehr. Multi-GPU-Setups werden unterstützt.

---

Schritt 1 — Miete eine GPU auf Clore.ai

1. Gehe zu clore.ai und melden Sie sich an.

2. Klicken Sie auf Marktplatz und filtern Sie nach:

   • VRAM: ≥ 24 GB (RTX 4090 minimum, A100 empfohlen)

   • Für Multi-GPU: nach GPU-Anzahl ≥ 2 filtern

3. Wählen Sie Ihren Server aus und klicken Sie auf Konfigurieren.

4. Docker-Image einstellen auf pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel (Basis-Image — wir installieren Mochi darin).

5. Offene Ports festlegen: 22 (SSH) und 7860 (Gradio-UI).

6. Klicken Sie auf Mieten.

Clore.ai listet A100-40-GB-Instanzen ab Bare Metal. Für Mochi-1 in voller Qualität ist dies die kosteneffizienteste Wahl.

---

Schritt 2 — Benutzerdefiniertes Dockerfile

Erstellen Sie Ihr eigenes Image oder verwenden Sie dieses Dockerfile um eine sofort nutzbare Mochi-1-Umgebung zu erstellen:

FROM pytorch/pytorch:2.11.0-cuda12.8-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/*

# SSH konfigurieren
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 environment ready. Run download script then launch demo." && \\
    tail -f /dev/null

Image erstellen und zu Docker Hub pushen

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

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.

Es gibt kein offizielles vorgefertigtes Docker-Image für Mochi-1 auf Docker Hub. Sie müssen es aus dem obigen Dockerfile erstellen. Alternativ können Sie pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel als Basis-Image direkt verwenden und die Einrichtungsschritte manuell per SSH ausführen.

---

Schritt 3 — Per SSH verbinden

Sobald Ihre Instanz läuft:

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 die huggingface_hub CLI herunter:

cd /workspace

# huggingface-cli installieren, 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"

Das vollständige bf16-Modell ist ungefähr 80 GB groß. Die fp8 quantisierte Version ist ~40 GB groß und läuft auf einer RTX 4090 (24 GB) mit CPU-Offload. Geben Sie --include "*fp8*" an, um nur die quantisierten Gewichte herunterzuladen.

Alternative: Nur fp8-quantisierte Gewichte herunterladen

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

---

Schritt 5 — Gradio-Demo starten

Mochi-1 wird mit einer Gradio-Weboberfläche für einfache Text-zu-Video-Generierung geliefert:

cd /workspace/mochi

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

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

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

Der --cpu_offload Flag verschiebt Modellschichten bei Nichtgebrauch in den CPU-RAM, wodurch der maximale VRAM auf ~18–20 GB sinkt, allerdings bei etwa 2× langsamerer Generierung.

---

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:

• Ein Texteingabe-Feld für Prompts

• Generierungseinstellungen (Schritte, Guidance-Scale, Seed)

• Video-Ausgabespieler

---

Schritt 7 — Erstellen Sie Ihr erstes Video

Beispiel-Prompts

Naturszene:

Ein majestätischer Wasserfall, der über moosbedeckte Felsen in einem üppigen Regenwald hinabstürzt, 
goldenes Sonnenlicht, das durch das Blätterdach fällt, langsame filmische Kameraschwenk

Actionszene:

Ein Gepard, der mit Höchstgeschwindigkeit über eine offene Savanne sprintet, 
Staub wirbelt hinter ihm auf, dramatische Totale, 4K-Wildlife-Dokumentation

Abstrakt/künstlerisch:

Farbige Farbe, die sich in Wasser in extremer Zeitlupe wirbelt, 
leuchtende blaue und orange Pigmente, die sich vermischen, Makroobjektiv, Studiobeleuchtung

Empfohlene Einstellungen

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

Die Generierungszeit variiert je nach GPU erheblich. Auf einer A100 mit 80 GB dauert ein 5-Sekunden-Video ungefähr 2–4 Minuten. Auf einer RTX 4090 mit CPU-Offload rechnen Sie mit 8–15 Minuten.

---

Python-API-Nutzung

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

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 generieren
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Ein Golden Retriever, der an einem sonnigen Strand apportiert, filmisch",
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
        generator=torch.Generator("cuda").manual_seed(42)
    ).frames[0]

# Export
export_to_video(frames, "output.mp4", fps=30)
print("Video saved to output.mp4")

Skript zur Batch-Generierung

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, der in Zeitlupe auf einer Blume landet, Makrofotografie",
    "Ozeanwellen, die bei Sonnenuntergang gegen felsige Klippen schlagen, Drohnenaufnahme",
    "Polarlichter, die über einem sternenklaren Himmel über einem zugefrorenen See tanzen",
]

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 Generierung mit mehreren GPUs:

import torch
from diffusers import MochiPipeline

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

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

Clore.ai bietet Multi-GPU-Server (2×, 4× RTX 4090 oder A100) an. Mit 2× A100 80 GB sinkt die Generierungszeit für einen 5-Sekunden-Clip auf unter 60 Sekunden.

---

Fehlerbehebung

CUDA Out of Memory

torch.cuda.OutOfMemoryError: CUDA out of memory

Lösungen:

1. Fügen Sie --cpu_offload zum gradio-Befehl

2. VAE-Slicing aktivieren: pipe.enable_vae_slicing()

3. Reduziere num_frames (versuchen Sie 24 statt 84)

4. Verwenden Sie fp8-quantisierte Gewichte statt bf16

Modell lädt langsam

Lösung: Stellen Sie sicher, dass sich die Gewichte auf einem schnellen NVMe-Laufwerk und nicht auf einer HDD befinden. Prüfen Sie die Speichergeschwindigkeit:

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

Video-Artefakte / temporales Flackern

Lösungen:

• Erhöhen Sie die Inferenzschritte (versuchen Sie 80–100)

• Passen Sie die Guidance-Scale an (der Bereich 3,5–5,0 ist meist am besten)

• Verwenden Sie einen bestimmten Seed für Reproduzierbarkeit und Iteration

Port 7860 nicht erreichbar

Prüfen Sie, ob der Port in Clore.ai korrekt geöffnet wurde und der Gradio-Server an 0.0.0.0:

ss -tlnp | grep 7860

---

Kostenschätzung

GPU	VRAM	Geschätzter Preis	Zeit für ein 5-Sekunden-Video
RTX 4090	24 GB	ca. 0,14–0,42 $/h	~10–15 Min.
A100 40GB	40 GB	Bare Metal	~3–5 Min.
A100 80GB	80 GB	Bare Metal	~2–3 Min.
2× A100 80GB	160 GB	Bare Metal	~60–90 Sek.

---

GPU-Empfehlungen für Clore.ai

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Mochi-1 ist sehr 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	ca. 0,14–0,42 $/h	nur fp8-quantisiert	~10–15 Min.
A100 40GB	40 GB	Bare Metal	bf16 empfohlen	~3–5 Min.
A100 80GB	80 GB	Bare Metal	volles bf16, schnell	~2–3 Min.
2× A100 80GB	160 GB	Bare Metal	Tensor-Parallelismus, am schnellsten	~60–90 Sek.

RTX 3090 (24 GB) wird nicht empfohlen — Mochi-1 im fp8-Modus benötigt mindestens 24 GB und lässt kaum Spielraum. Die RTX 4090 (24 GB) funktioniert im fp8-Modus, stößt bei längeren Sequenzen aber häufig an OOM-Grenzen. Beginnen Sie für verlässliche Ergebnisse mit einer A100 mit 40 GB.

Bestes Preis-Leistungs-Verhältnis für Qualität: A100 40 GB bei Bare Metal erzeugt einen 5-Sekunden-Clip in 3–5 Minuten. Das sind ca. 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

• Mochi-1 auf Hugging Face

• Genmo Blog — Mochi-1 Veröffentlichung

• Diffusers-Mochi-Dokumentation

• Mochi-Prompt-Leitfaden (Community)