# Video Mochi-1

**Mochi-1** es el modelo de generación de video de código abierto de Genmo con 10 mil millones de parámetros que produce salida a 848×480 @ 30fps con movimiento físicamente realista. Utiliza una arquitectura de transformador de difusión asimétrica (AsymmDiT) y se encuentra entre los modelos de video de código abierto de mayor calidad en fidelidad de movimiento. Desplégalo en la nube GPU de Clore.ai para generar videos de calidad profesional a una fracción del costo de las API comerciales.

***

## ¿Qué es Mochi-1?

Mochi-1 es un **modelo de 10 mil millones de parámetros** modelo de difusión de video entrenado para producir videos con:

* Movimiento suave y físicamente plausible
* Alta consistencia temporal
* Fuerte adherencia al prompt
* Resolución 848×480 a 30 fps

Utiliza un **transformador de difusión asimétrico** (arquitectura AsymmDiT) — diferentes profundidades de codificador para video y texto — que permite inferencia eficiente a escala. Los pesos se publican bajo la Licencia de Código Abierto de Genmo, libres para uso de investigación y comercial.

**Aspectos destacados del modelo:**

* 10B de parámetros
* Salida nativa 848×480 @ 30 fps
* Alta fidelidad de movimiento (clasificado entre los mejores en benchmarks comunitarios)
* Disponible en Hugging Face con integración en diffusers
* Interfaz demo en Gradio para interacción fácil

***

## Prerrequisitos

| Requisito      | Mínimo   | Recomendado |
| -------------- | -------- | ----------- |
| VRAM GPU       | 24 GB    | 40–80 GB    |
| GPU            | RTX 4090 | A100 / H100 |
| RAM            | 32 GB    | 64 GB       |
| Almacenamiento | 60 GB    | 100 GB      |
| CUDA           | 11.8+    | 12.1+       |

{% hint style="warning" %}
Mochi-1 es un modelo grande (≈40 GB en fp8 / ≈80 GB en bf16). Una sola RTX 4090 (24 GB) puede ejecutarlo con cuantización. Para calidad completa, use una A100 de 40 GB o mayor. Se soportan configuraciones multi-GPU.
{% endhint %}

***

## Paso 1 — Alquila una GPU en Clore.ai

1. Ve a [clore.ai](https://clore.ai) e inicie sesión.
2. Haz clic **Marketplace** y filtre:
   * VRAM: **≥ 24 GB** (mínimo RTX 4090, A100 recomendado)
   * Para multi-GPU: filtrar por cantidad de GPU ≥ 2
3. Seleccione su servidor y haga clic **Configurar**.
4. Establezca la imagen de Docker en `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` (imagen base — instalamos Mochi dentro).
5. Establecer puertos abiertos: `22` (SSH) y `7860` (UI de Gradio).
6. Haz clic **Alquilar**.

{% hint style="info" %}
Clore.ai lista instancias A100 40 GB desde aproximadamente $0.60–$0.90/h. Para Mochi-1 a calidad completa, esta es la opción más rentable.
{% endhint %}

***

## Paso 2 — Dockerfile personalizado

Construya su propia imagen o use este `Dockerfile` para crear un entorno Mochi-1 listo para usar:

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

# Configurar 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

# Clonar el repositorio Mochi-1
RUN git clone https://github.com/genmoai/mochi /workspace/mochi

# Instalar dependencias de 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 "Entorno Mochi-1 listo. Ejecute el script de descarga y luego inicie la demo." && \
    tail -f /dev/null
```

### Construir y publicar en Docker Hub

Construya la imagen localmente y púlsela en su propia cuenta de Docker Hub (reemplace `YOUR_DOCKERHUB_USERNAME` con tu nombre de usuario real):

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

Luego use `YOUR_DOCKERHUB_USERNAME/mochi-1:latest` como su imagen Docker en Clore.ai.

{% hint style="info" %}
No existe una imagen Docker previamente construida oficial para Mochi-1 en Docker Hub. Necesita construirla desde el Dockerfile anterior. Alternativamente, use `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` como la imagen base directamente y ejecute los comandos de configuración manualmente vía SSH.
{% endhint %}

***

## Paso 3 — Conéctate vía SSH

Una vez que tu instancia esté en funcionamiento:

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

***

## Paso 4 — Descargar los pesos de Mochi-1

Los pesos del modelo están alojados en Hugging Face. Descárguelos vía el `huggingface_hub` CLI:

```bash
cd /workspace

# Instalar huggingface-cli si no está presente
pip install -U huggingface_hub

# Descargar pesos de Mochi-1 (~40 GB para bf16)
huggingface-cli download genmo/mochi-1-preview \
    --local-dir /workspace/mochi-weights \
    --include "*.safetensors" "*.json" "*.txt"
```

{% hint style="info" %}
El modelo bf16 completo es aproximadamente 80 GB. La `fp8` versión cuantizada es \~40 GB y se ejecuta en RTX 4090 (24 GB) con offloading a CPU. Especifique `--include "*fp8*"` para descargar solo los pesos cuantizados.
{% endhint %}

### Alternativa: Descargar solo pesos cuantizados fp8

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

***

## Paso 5 — Iniciar la demo de Gradio

Mochi-1 incluye una interfaz web Gradio para generación de texto a video fácil:

```bash
cd /workspace/mochi

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

**Para modo de baja 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" %}
El `--cpu_offload` la bandera mueve capas del modelo a la RAM de la CPU cuando no están en uso, reduciendo el pico de VRAM a \~18–20 GB a costa de una generación \~2× más lenta.
{% endhint %}

***

## Paso 6 — Acceder a la interfaz web

Abra su navegador y navegue a:

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

Verá la interfaz Gradio de Mochi-1 con:

* Un campo de entrada para prompt de texto
* Configuraciones de generación (steps, guidance scale, seed)
* Reproductor de salida de video

***

## Paso 7 — Genere su primer video

### Prompts de ejemplo

**Escena natural:**

```
Una majestuosa cascada cayendo sobre rocas cubiertas de musgo en una selva exuberante, 
luz dorada de la hora dorada filtrándose a través del dosel, paneo cinematográfico lento
```

**Escena de acción:**

```
Un guepardo corriendo a toda velocidad por una sabana abierta, 
polvo levantándose detrás de él, plano general dramático, documental de vida salvaje en 4K
```

**Abstracto/artístico:**

```
Pintura colorida girando en agua en cámara súper lenta, 
pigmentos azul y naranja vívidos mezclándose, lente macro, iluminación de estudio
```

### Configuraciones recomendadas

| Parámetro      | Valor                      |
| -------------- | -------------------------- |
| Pasos          | 64                         |
| Escala de guía | 4.5                        |
| Duración       | 5.1 segundos (por defecto) |
| Resolución     | 848×480 (nativa)           |

{% hint style="info" %}
El tiempo de generación varía significativamente según la GPU. En una A100 80 GB, un video de 5 segundos toma aproximadamente **2–4 minutos**. En RTX 4090 con offload a CPU, espere **8–15 minutos**.
{% endhint %}

***

## Uso de la API de Python

Para generación programática, use la pipeline de diffusers:

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

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

# Generar video
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Un golden retriever jugando a buscar en una playa soleada, cinematográfico",
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
        generator=torch.Generator("cuda").manual_seed(42)
    ).frames[0]

# Exportar
export_to_video(frames, "output.mp4", fps=30)
print("Video guardado en output.mp4")
```

### Script de generación por lotes

```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 = [
    "Una mariposa posándose en una flor en cámara lenta, fotografía macro",
    "Olas del océano estrellándose contra acantilados rocosos al atardecer, plano con dron",
    "Auroras boreales bailando sobre un cielo estrellado sobre un lago congelado",
]

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"Guardado: {output_path}")
```

***

## Inferencia multi-GPU

Para generación más rápida con múltiples GPUs:

```python
import torch
from diffusers import MochiPipeline

# Use device_map para distribución automática multi-GPU
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16,
    device_map="balanced"
)

# No es necesario cpu_offload con múltiples GPUs
frames = pipe(
    prompt="Su prompt aquí",
    num_frames=84,
    guidance_scale=4.5,
    num_inference_steps=64,
).frames[0]
```

{% hint style="info" %}
Clore.ai ofrece servidores multi-GPU (2×, 4× RTX 4090 o A100). Con 2× A100 80 GB, el tiempo de generación baja a menos de 60 segundos para un clip de 5 segundos.
{% endhint %}

***

## Solución de problemas

### CUDA Fuera de memoria

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

**Soluciones:**

1. Añade `--cpu_offload` al comando gradio
2. Habilitar VAE slicing: `pipe.enable_vae_slicing()`
3. Reducir `num_frames` (pruebe 24 en lugar de 84)
4. Use pesos cuantizados fp8 en lugar de bf16

### Carga del modelo lenta

**Solución:** Asegúrese de que los pesos estén en una unidad NVMe rápida, no en HDD. Compruebe la velocidad de almacenamiento:

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

### Artefactos de video / Parpadeo temporal

**Soluciones:**

* Aumente los pasos de inferencia (pruebe 80–100)
* Ajuste la escala de guía (el rango 3.5–5.0 suele ser el mejor)
* Use una semilla específica para reproducibilidad e iteración

### Puerto 7860 no accesible

Verifique que el puerto se abrió correctamente en Clore.ai y que el servidor Gradio está enlazando a `0.0.0.0`:

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

***

## Estimación de Costos

| GPU          | VRAM   | Precio estimado | Tiempo de video de 5s |
| ------------ | ------ | --------------- | --------------------- |
| RTX 4090     | 24 GB  | \~$0.35/hr      | \~10–15 min           |
| A100 40GB    | 40 GB  | \~$0.70/h       | \~3–5 min             |
| A100 80GB    | 80 GB  | \~$1.20/h       | \~2–3 min             |
| 2× A100 80GB | 160 GB | \~$2.20/hr      | \~60–90 seg           |

***

## Recomendaciones de GPU en Clore.ai

Mochi-1 exige mucha VRAM — el modelo de 10B de parámetros requiere una selección cuidadosa de GPU.

| GPU          | VRAM   | Precio en Clore.ai | Modo                                    | Tiempo de generación de video de 5s |
| ------------ | ------ | ------------------ | --------------------------------------- | ----------------------------------- |
| RTX 4090     | 24 GB  | \~$0.70/h          | solo cuantizado fp8                     | \~10–15 min                         |
| A100 40GB    | 40 GB  | \~$1.20/h          | bf16 recomendado                        | \~3–5 min                           |
| A100 80GB    | 80 GB  | \~$2.00/h          | bf16 completo, rápido                   | \~2–3 min                           |
| 2× A100 80GB | 160 GB | \~$4.00/hr         | paralelismo por tensores, el más rápido | \~60–90 seg                         |

{% hint style="warning" %}
**RTX 3090 (24GB) no es recomendable** — Mochi-1 en modo fp8 necesita 24GB como mínimo y deja casi sin margen. La RTX 4090 (24GB) funciona en fp8 pero con frecuencia da OOM en secuencias más largas. Empiece con A100 40GB para resultados fiables.
{% endhint %}

**Mejor valor por calidad:** A100 40GB a \~$1.20/hr genera un clip de 5 segundos en 3–5 minutos. Eso es \~$0.08–0.10 por clip de video — significativamente más barato que Runway ML ($0.25–0.50/clip) o suscripciones de Pika Labs.

***

## Recursos Útiles

* [Mochi-1 en GitHub](https://github.com/genmoai/mochi)
* [Mochi-1 en Hugging Face](https://huggingface.co/genmo/mochi-1-preview)
* [Blog de Genmo — Lanzamiento de Mochi-1](https://www.genmo.ai/blog/mochi-1)
* [Documentación de Diffusers Mochi](https://huggingface.co/docs/diffusers/api/pipelines/mochi)
* [Guía de prompts de Mochi (Comunidad)](https://github.com/genmoai/mochi/blob/main/README.md)


---

# Agent Instructions: 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-es/generacion-de-video/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.