# Mochi-1 Video

**🆕 — 10–15s संदर्भ ऑडियो से 8+ भाषाओं में ज़ीरो-शॉट वॉइस क्लोनिंग —** यह Genmo का ओपन-सोर्स 10-बिलियन पैरामीटर वीडियो जनरेशन मॉडल है जो भौतिक रूप से यथार्थवादी गति के साथ 848×480 @ 30fps आउटपुट उत्पन्न करता है। यह एक असममित डिफ्यूज़न ट्रांसफॉर्मर (AsymmDiT) आर्किटेक्चर का उपयोग करता है और गति सटीकता के मामले में उच्च-गुणवत्ता वाले ओपन-सोर्स वीडियो मॉडलों में शामिल है। व्यावसायिक API लागत के एक छोटे हिस्से में पेशेवर-ग्रेड वीडियो उत्पन्न करने के लिए इसे Clore.ai के GPU क्लाउड पर तैनात करें।

***

## Mochi-1 क्या है?

Mochi-1 एक **10-बिलियन पैरामीटर** वीडियो डिफ्यूज़न मॉडल है जिसे वीडियो निम्नलिखित गुणों के साथ उत्पन्न करने के लिए प्रशिक्षित किया गया है:

* मुलायम, भौतिक रूप से यथार्थवादी गति
* उच्च अस्थायी निरंतरता
* प्रॉम्प्ट के प्रति मजबूत अनुगमन
* 848×480 रिज़ॉल्यूशन पर 30 fps

यह उपयोग करता है **एक असममित डिफ्यूज़न ट्रांसफॉर्मर** (AsymmDiT) आर्किटेक्चर — वीडियो और टेक्स्ट के लिए अलग- अलग एन्कोडर गहराई — जो बड़े पैमाने पर कुशल इंफेरेंस सक्षम करता है। वज़न Genmo Open Source License के तहत जारी किए गए हैं, शोध और वाणिज्यिक उपयोग के लिए निःशुल्क।

**मॉडल मुख्य विशेषताएँ:**

* 10B पैरामीटर
* मूल 848×480 @ 30 fps आउटपुट
* उच्च-गति सटीकता (समुदाय बेंचमार्क में शीर्ष रैंकिंग)
* diffusers एकीकरण के साथ Hugging Face पर उपलब्ध
* सरल इंटरैक्शन के लिए Gradio डेमो UI

***

## पूर्व-आवश्यकताएँ

| आवश्यकता | न्यूनतम  | अनुशंसित    |
| -------- | -------- | ----------- |
| GPU VRAM | 24 GB    | 40–80 GB    |
| GPU      | RTX 4090 | A100 / H100 |
| RAM      | 32 GB    | 64 GB       |
| स्टोरेज  | 60 GB    | 100 GB      |
| CUDA     | 11.8+    | 12.1+       |

{% hint style="warning" %}
Mochi-1 एक बड़ा मॉडल है (≈40 GB fp8 में / ≈80 GB bf16 में)। क्वांटाइज़ेशन के साथ एक ही RTX 4090 (24 GB) इसे चला सकता है। पूर्ण गुणवत्ता के लिए A100 40 GB या उससे बड़ा उपयोग करें। मल्टी-GPU सेटअप समर्थित हैं।
{% endhint %}

***

## चरण 1 — Clore.ai पर एक GPU किराए पर लें

1. जाएँ [clore.ai](https://clore.ai) और साइन इन करें।
2. पर क्लिक करें **मार्केटप्लेस** और फ़िल्टर करें:
   * VRAM: **≥ 24 GB** (RTX 4090 न्यूनतम, A100 की सिफारिश)
   * मल्टी-GPU के लिए: GPU गिनती ≥ 2 से फ़िल्टर करें
3. अपने सर्वर का चयन करें और क्लिक करें **कॉन्फ़िगर**.
4. Docker इमेज सेट करें `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` (बेस इमेज — हम इसके भीतर Mochi इंस्टॉल करते हैं)।
5. खुले पोर्ट सेट करें: `22` (SSH) और `7860` (Gradio UI)।
6. पर क्लिक करें **किराए पर लें**.

{% hint style="info" %}
Clore.ai A100 40 GB इंस्टेंसों की सूची \~$0.60–$0.90/घंटा से शुरू करती है। Mochi-1 को पूर्ण गुणवत्ता पर चलाने के लिए यह सबसे लागत-कुशल विकल्प है।
{% endhint %}

***

## धップ 2 — कस्टम Dockerfile

अपनी खुद की इमेज बनाएं या इसको उपयोग करें `Dockerfile` ताकि एक रेडी-टू-यूज़ Mochi-1 परिवेश बनाया जा सके:

```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/*

# 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 रिपोजिटरी क्लोन करें
RUN git clone https://github.com/genmoai/mochi /workspace/mochi

# Python निर्भरताएँ इंस्टॉल करें
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 परिवेश तैयार है। डाउनलोड स्क्रिप्ट चलाने के बाद डेमो लॉन्च करें." && \
    tail -f /dev/null
```

### इमेज बनाएं और Docker Hub पर पुश करें

लोकल रूप से इमेज बनाएं और इसे अपने Docker Hub अकाउंट पर पुश करें (बदलें `YOUR_DOCKERHUB_USERNAME` अपने वास्तविक उपयोगकर्ता नाम से):

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

फिर उपयोग करें `YOUR_DOCKERHUB_USERNAME/mochi-1:latest` Clore.ai में अपने Docker इमेज के रूप में।

{% hint style="info" %}
Docker Hub पर Mochi-1 के लिए कोई आधिकारिक प्री-बिल्ट Docker इमेज नहीं है। आपको ऊपर दिए गए Dockerfile से बिल्ड करना होगा। वैकल्पिक रूप से, सीधे `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` को बेस इमेज के रूप में उपयोग करें और SSH के माध्यम से मैन्युअली सेटअप कमांड चलाएँ।
{% endhint %}

***

## स्टेप 3 — SSH के जरिए कनेक्ट करें

एक बार आपका इंस्टेंस चलने लगे:

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

***

## धप 4 — Mochi-1 वेट्स डाउनलोड करें

मॉडल वेट्स Hugging Face पर होस्ट किए गए हैं। उन्हें `huggingface_hub` CLI के माध्यम से डाउनलोड करें:

```bash
cd /workspace

# यदि huggingface-cli इंस्टॉल नहीं है तो इंस्टॉल करें
pip install -U huggingface_hub

# Mochi-1 वेट्स डाउनलोड करें (~40 GB bf16 के लिए)
huggingface-cli download genmo/mochi-1-preview \
    --local-dir /workspace/mochi-weights \
    --include "*.safetensors" "*.json" "*.txt"
```

{% hint style="info" %}
पूर्ण bf16 मॉडल लगभग 80 GB है। `fp8` क्वांटाइज़्ड संस्करण \~40 GB है और CPU ऑफलोडिंग के साथ RTX 4090 (24 GB) पर चलता है। निर्दिष्ट करें `--include "*fp8*"` केवल क्वांटाइज़्ड वेट्स ही डाउनलोड करने के लिए।
{% endhint %}

### वैकल्पिक: केवल fp8 क्वांटाइज़्ड वेट्स डाउनलोड करें

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

***

## धप 5 — Gradio डेमो लॉन्च करें

Mochi-1 में आसान टेक्स्ट-टू-वीडियो जनरेशन के लिए एक Gradio वेब UI शामिल है:

```bash
cd /workspace/mochi

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

**लो-VRAM मोड के लिए (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" %}
The `--cpu_offload` फ्लैग उपयोग में न होने पर मॉडेल लेयरों को CPU RAM में स्थानांतरित करता है, जिससे पीक VRAM लगभग 18–20 GB तक घट जाता है लेकिन जनरेशन लगभग 2× धीमा हो जाता है।
{% endhint %}

***

## धप 6 — वेब UI तक पहुँच

अपने ब्राउज़र को खोलें और नेविगेट करें:

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

आप Mochi-1 Gradio इंटरफ़ेस देखेंगे जिसमें:

* एक टेक्स्ट प्रॉम्प्ट इनपुट
* जनरेशन सेटिंग्स (स्टेप्स, गाइडेंस स्केल, सीड)
* वीडियो आउटपुट प्लेयर

***

## धप 7 — अपना पहला वीडियो जनरेट करें

### उदाहरण प्रॉम्प्ट्स

**प्रकृति दृश्य:**

```
एक विशाल झरना जो हरे-भरे जंगल में काई वाले चट्टानों से बह रहा है, 
कैनोपी के बीच से गुजरती सुनहरी घंटी की रोशनी, धीमा सिनेमाई पैन
```

**एक्शन सीन:**

```
एक चीता खुला सवाना पार करके पूरी गति से दौड़ रहा है, 
इसके पीछे धूल उठ रही है, नाटकीय वाइड शॉट, 4K वाइल्डलाइफ डाक्यूमेंट्री
```

**Abstract/कलात्मक:**

```
पानी में रंगीन पेंट चरम स्लो मोशन में घुम रहा है, 
जीवंत नीले और नारंगी रंग के पिगमेंट मिल रहे हैं, मैक्रो लेंस, स्टूडियो लाइटिंग
```

### अनुशंसित सेटिंग्स

| पैरामीटर      | मान                  |
| ------------- | -------------------- |
| स्टेप्स       | 64                   |
| गाइडेंस स्केल | 4.5                  |
| अवधि          | 5.1 सेकंड (डिफ़ॉल्ट) |
| रिज़ॉल्यूशन   | 848×480 (मूल)        |

{% hint style="info" %}
जनरेशन समय GPU के अनुसार काफी बदलता है। एक A100 80 GB पर, 5-सेकंड का वीडियो लगभग **2–4 मिनट**लेता है। RTX 4090 पर CPU ऑफलोड के साथ, अपेक्षा करें **8–15 मिनट**.
{% endhint %}

***

## Python API उपयोग

प्रोग्रामेटिक जनरेशन के लिए, diffusers पाइपलाइन का उपयोग करें:

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

# पाइपलाइन लोड करें
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# वीडियो जनरेट करें
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="एक सुनहरी रिट्रीवर धूप वाले समुद्र तट पर फेच खेल रहा है, सिनेमाई",
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
        generator=torch.Generator("cuda").manual_seed(42)
    ).frames[0]

# एक्सपोर्ट
export_to_video(frames, "output.mp4", fps=30)
print("वीडियो output.mp4 में सहेजा गया")
```

### बैच जनरेशन स्क्रिप्ट

```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 = [
    "एक तितली फूल पर स्लो मोशन में बैठती हुई, मैक्रो फोटोग्राफी",
    "सूर्यास्त पर चट्टानी चट्टानों से टकराती समुंद्री लहरें, ड्रोन शॉट",
    "एक जमी हुई झील के ऊपर तारों भरे आकाश में डांस करती उत्तरी रोशनी",
]

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"सहेजा गया: {output_path}")
```

***

## मल्टी-GPU इंफेरेंस

कई GPUs के साथ तेज़ जनरेशन के लिए:

```python
import torch
from diffusers import MochiPipeline

# ऑटोमैटिक मल्टी-GPU वितरण के लिए device_map का उपयोग करें
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16,
    device_map="balanced"
)

# कई GPUs के साथ cpu_offload की आवश्यकता नहीं
frames = pipe(
    prompt="आपका प्रॉम्प्ट यहाँ",
    num_frames=84,
    guidance_scale=4.5,
    num_inference_steps=64,
).frames[0]
```

{% hint style="info" %}
Clore.ai मल्टी-GPU सर्वर प्रदान करता है (2×, 4× RTX 4090 या A100)। 2× A100 80 GB के साथ, 5-सेकंड क्लिप के लिए जनरेशन समय 60 सेकंड से कम हो जाता है।
{% endhint %}

***

## समस्या निवारण

### CUDA मेमोरी खत्म (Out of Memory)

```
torch.cuda.OutOfMemoryError: CUDA आउट ऑफ मेमोरी
```

**समाधान:**

1. लॉन्च कमांड में जोड़ें `--cpu_offload` gradio कमांड में
2. VAE slicing सक्षम करें: `pipe.enable_vae_slicing()`
3. कम करें `num_frames` (84 के बजाय 24 आज़माएँ)
4. bf16 के बजाय fp8 क्वांटाइज़्ड वेट्स का उपयोग करें

### मॉडल लोडिंग धीमा है

**समाधान:** सुनिश्चित करें कि वेट्स तेज़ NVMe ड्राइव पर हैं, HDD पर नहीं। स्टोरेज स्पीड जांचें:

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

### वीडियो आर्टिफैक्ट्स / अस्थायी झिलमिलाहट

**समाधान:**

* इंफेरेंस स्टेप्स बढ़ाएँ (80–100 आज़माएँ)
* गाइडेंस स्केल समायोजित करें (आमतौर पर 3.5–5.0 रेंज सबसे अच्छा)
* पुनरुत्पादन और итरेशन के लिए एक विशिष्ट सीड का उपयोग करें

### पोर्ट 7860 पहुँच योग्य नहीं है

जांचें कि पोर्ट Clore.ai में सही तरीके से खोला गया है और Gradio सर्वर `0.0.0.0`:

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

***

## लागत अनुमान

| GPU          | VRAM   | अनुमानित मूल्य | 5s वीडियो समय |
| ------------ | ------ | -------------- | ------------- |
| RTX 4090     | 24 GB  | \~$0.35/घंटा   | \~10–15 मिनट  |
| A100 40GB    | 40 GB  | \~$0.70/घंटा   | \~3–5 मिनट    |
| A100 80GB    | 80 GB  | \~$1.20/घंटा   | \~2–3 मिनट    |
| 2× A100 80GB | 160 GB | \~$2.20/घंटा   | \~60–90 सेकंड |

***

## Clore.ai GPU सिफारिशें

Mochi-1 VRAM-भुखा है — 10B पैरामीटर मॉडल के लिए सावधानीपूर्वक GPU चयन आवश्यक है।

| GPU          | VRAM   | Clore.ai कीमत | मोड                    | 5s वीडियो जनरेशन समय |
| ------------ | ------ | ------------- | ---------------------- | -------------------- |
| RTX 4090     | 24 GB  | \~$0.70/घंटा  | केवल fp8 क्वांटाइज़्ड  | \~10–15 मिनट         |
| A100 40GB    | 40 GB  | \~$1.20/घंटा  | bf16 अनुशंसित          | \~3–5 मिनट           |
| A100 80GB    | 80 GB  | \~$2.00/घंटा  | पूर्ण bf16, तेज        | \~2–3 मिनट           |
| 2× A100 80GB | 160 GB | \~$4.00/घंटा  | टेनसर पैरेलल, सबसे तेज | \~60–90 सेकंड        |

{% hint style="warning" %}
**RTX 3090 (24GB) की सिफारिश नहीं की जाती** — Mochi-1 fp8 मोड में न्यूनतम 24GB की आवश्यकता होती है और लगभग कोई हेडरूम नहीं छोड़ता। RTX 4090 (24GB) fp8 में काम करता है लेकिन लंबी सीक्वेंस पर अक्सर OOM होता है। विश्वसनीय परिणामों के लिए A100 40GB से शुरू करें।
{% endhint %}

**गुणवत्ता के लिए सर्वोत्तम मूल्य:** A100 40GB \~$1.20/घंटा पर 5-सेकंड क्लिप को 3–5 मिनट में जनरेट करता है। यह प्रति वीडियो क्लिप लगभग $0.08–0.10 है — जो Runway ML ($0.25–0.50/क्लिप) या Pika Labs की सदस्यताओं की तुलना में काफी सस्ता है।

***

## उपयोगी संसाधन

* [Mochi-1 GitHub](https://github.com/genmoai/mochi)
* [Hugging Face पर Mochi-1](https://huggingface.co/genmo/mochi-1-preview)
* [Genmo ब्लॉग — Mochi-1 रिलीज़](https://www.genmo.ai/blog/mochi-1)
* [Diffusers Mochi दस्तावेज़](https://huggingface.co/docs/diffusers/api/pipelines/mochi)
* [Mochi प्रॉम्प्ट गाइड (समुदाय)](https://github.com/genmoai/mochi/blob/main/README.md)