> 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/videogenerierung/mochi-1.md). # 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+ | {% 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 ausführen. Für volle Qualität verwenden Sie eine A100 mit 40 GB oder mehr. Multi-GPU-Setups werden unterstützt. {% endhint %} *** ## Schritt 1 — Miete eine GPU auf Clore.ai 1. Gehe zu [clore.ai](https://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**. {% hint style="info" %} Clore.ai listet A100-40-GB-Instanzen ab [Bare Metal](https://clore.ai/bare-metal). Für Mochi-1 in voller Qualität ist dies die kosteneffizienteste Wahl. {% endhint %} *** ## Schritt 2 — Benutzerdefiniertes Dockerfile Erstellen Sie Ihr eigenes Image oder verwenden Sie dieses `Dockerfile` um eine sofort nutzbare Mochi-1-Umgebung zu erstellen: ```dockerfile 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): ```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 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. {% endhint %} *** ## Schritt 3 — Per SSH verbinden Sobald Ihre Instanz läuft: ```bash ssh root@ -p ``` *** ## Schritt 4 — Mochi-1-Gewichte herunterladen Die Modellgewichte werden auf Hugging Face gehostet. Laden Sie sie über die `huggingface_hub` CLI herunter: ```bash 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" ``` {% hint style="info" %} 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. {% 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 — Gradio-Demo starten Mochi-1 wird mit einer Gradio-Weboberfläche für einfache Text-zu-Video-Generierung geliefert: ```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 den 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 bei Nichtgebrauch in den CPU-RAM, wodurch der maximale VRAM auf \~18–20 GB sinkt, allerdings bei etwa 2× langsamerer Generierung. {% endhint %} *** ## Schritt 6 — Zugriff auf die Web-UI Öffnen Sie Ihren Browser und navigieren Sie zu: ``` http://: ``` 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) | {% hint style="info" %} 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**. {% endhint %} *** ## Python-API-Nutzung Für die programmatische Generierung 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 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 ```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, 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: ```python 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] ``` {% hint style="info" %} 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. {% endhint %} *** ## 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: ```bash 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`: ```bash 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](https://clore.ai/bare-metal) | \~3–5 Min. | | A100 80GB | 80 GB | [Bare Metal](https://clore.ai/bare-metal) | \~2–3 Min. | | 2× A100 80GB | 160 GB | [Bare Metal](https://clore.ai/bare-metal) | \~60–90 Sek. | *** ## GPU-Empfehlungen für Clore.ai {% hint style="warning" %} **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](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst. {% endhint %} 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](https://clore.ai/bare-metal) | bf16 empfohlen | \~3–5 Min. | | A100 80GB | 80 GB | [Bare Metal](https://clore.ai/bare-metal) | volles bf16, schnell | \~2–3 Min. | | 2× A100 80GB | 160 GB | [Bare Metal](https://clore.ai/bare-metal) | Tensor-Parallelismus, am schnellsten | \~60–90 Sek. | {% hint style="warning" %} **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. {% endhint %} **Bestes Preis-Leistungs-Verhältnis für Qualität:** A100 40 GB bei [Bare Metal](https://clore.ai/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](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-Leitfaden (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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-de/videogenerierung/mochi-1.md?ask=&goal= ``` `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.