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+

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.

---

Schritt 1 — Mieten Sie eine GPU auf Clore.ai

1. Gehe zu 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.

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.

---

Schritt 2 — Benutzerdefiniertes Dockerfile

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

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

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

---

Schritt 3 — Verbindung per SSH

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 das huggingface_hub CLI:

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"

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.

Alternative: Nur fp8-quantisierte Gewichte herunterladen

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:

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

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

---

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)

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.

---

Python-API-Verwendung

Für programmatische Erzeugung 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 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

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:

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]

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.

---

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:

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:

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

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.

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

• Mochi-1 auf Hugging Face

• Genmo Blog — Mochi-1 Veröffentlichung

• Diffusers Mochi Dokumentation

• Mochi Prompt Anleitung (Community)