> 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-es/generacion-de-video/mochi-1.md).

# Video Mochi-1

**Mochi-1** es el modelo de generación de video de código abierto de 10 mil millones de parámetros de Genmo, que produce salida de 848×480 a 30 fps con movimiento físicamente realista. Utiliza una arquitectura de transformador de difusión asimétrica (AsymmDiT) y se sitúa 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 **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 de 848×480 a 30 fps

Utiliza una **arquitectura de transformador de difusión asimétrica** (AsymmDiT), con distintas profundidades de codificador para video y texto, lo que permite una inferencia eficiente a escala. Los pesos se publican bajo la Licencia de Código Abierto de Genmo, gratuita para uso de investigación y comercial.

**Aspectos destacados del modelo:**

* 10B de parámetros
* Salida nativa de 848×480 a 30 fps
* Alta fidelidad de movimiento (clasificado en los primeros puestos de los benchmarks de la comunidad)
* Disponible en Hugging Face con integración con diffusers
* Interfaz demo de Gradio para una interacción sencilla

***

## Requisitos previos

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

{% 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 obtener la máxima calidad, usa una A100 de 40 GB o superior. Se admiten configuraciones con varias GPU.
{% endhint %}

***

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

1. Ve a [clore.ai](https://clore.ai) y entra.
2. Haz clic en **Marketplace** y filtra:
   * VRAM: **≥ 24 GB** (RTX 4090 mínimo, A100 recomendada)
   * Para varias GPU: filtra por cantidad de GPU ≥ 2
3. Selecciona tu servidor y haz clic en **Configurar**.
4. Establece la imagen de Docker en `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel` (imagen base; instalamos Mochi dentro).
5. Establece los puertos abiertos: `22` (SSH) y `7860` (interfaz Gradio).
6. Haz clic en **Alquilar**.

{% hint style="info" %}
Clore.ai muestra instancias A100 de 40 GB desde [bare metal](https://clore.ai/bare-metal). Para Mochi-1 con calidad máxima, esta es la opción más rentable.
{% endhint %}

***

## Paso 2 — Dockerfile personalizado

Compila tu propia imagen o usa este `Dockerfile` para crear un entorno Mochi-1 listo para usar:

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

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

### Compilar y enviar a Docker Hub

Compila la imagen localmente y súbela a tu propia cuenta de Docker Hub (reemplaza `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 usa `YOUR_DOCKERHUB_USERNAME/mochi-1:latest` como tu imagen Docker en Clore.ai.

{% hint style="info" %}
No existe una imagen Docker oficial preconstruida para Mochi-1 en Docker Hub. Debes compilarla a partir del Dockerfile anterior. Como alternativa, usa `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel` como imagen base directamente y ejecuta los comandos de configuración manualmente por SSH.
{% endhint %}

***

## Paso 3 — Conéctate por SSH

Una vez que tu instancia esté en ejecución:

```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árgalos mediante la `huggingface_hub` CLI:

```bash
cd /workspace

# Instala 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 de aproximadamente 80 GB. La `fp8` cuantizada pesa \~40 GB y se ejecuta en una RTX 4090 (24 GB) con descarga a CPU. Especifica `--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 de Gradio para facilitar la generación de texto a video:

```bash
cd /workspace/mochi

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

**Para el modo de poca 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 las capas del modelo a la RAM de la CPU cuando no se usan, reduciendo la VRAM máxima a \~18–20 GB a costa de una generación \~2× más lenta.
{% endhint %}

***

## Paso 6 — Acceder a la interfaz web

Abre tu navegador y navega a:

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

Verás la interfaz Gradio de Mochi-1 con:

* Un campo de entrada de prompt de texto
* Configuración de generación (pasos, escala de guía, semilla)
* Reproductor de salida de video

***

## Paso 7 — Genera tu primer video

### Prompts de ejemplo

**Escena de naturaleza:**

```
Una majestuosa cascada cayendo sobre rocas cubiertas de musgo en una exuberante selva tropical, 
luz 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, 
levantando polvo a su paso, toma general dramática, documental de vida salvaje en 4K
```

**Abstracto/artístico:**

```
Pintura colorida arremolinándose en agua en cámara súper lenta, 
mezcla de pigmentos azul y naranja intensos, lente macro, iluminación de estudio
```

### Ajustes recomendados

| Parámetro      | Valor                         |
| -------------- | ----------------------------- |
| Pasos          | 64                            |
| Escala de guía | 4.5                           |
| Duración       | 5,1 segundos (predeterminado) |
| Resolución     | 848×480 (nativa)              |

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

***

## Uso de la API de Python

Para generación programática, usa la canalización de diffusers:

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

# Cargar 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="A golden retriever playing fetch on a sunny beach, cinematic",
        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 = [
    "A butterfly landing on a flower in slow motion, macro photography",
    "Ocean waves crashing against rocky cliffs at sunset, drone shot",
    "Northern lights dancing across a starry sky over a frozen lake",
]

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 una generación más rápida con varias GPU:

```python
import torch
from diffusers import MochiPipeline

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

# No necesitas cpu_offload con varias GPU
frames = pipe(
    prompt="Your prompt here",
    num_frames=84,
    guidance_scale=4.5,
    num_inference_steps=64,
).frames[0]
```

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

***

## Solución de problemas

### Memoria insuficiente en CUDA

```
torch.cuda.OutOfMemoryError: memoria CUDA insuficiente
```

**Soluciones:**

1. Añade `--cpu_offload` al comando de Gradio
2. Activa la segmentación VAE: `pipe.enable_vae_slicing()`
3. Reduce `num_frames` (prueba 24 en lugar de 84)
4. Usa pesos cuantizados fp8 en lugar de bf16

### Carga del modelo lenta

**Solución:** Asegúrate de que los pesos estén en un disco NVMe rápido, no en un HDD. Comprueba la velocidad de almacenamiento:

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

### Artefactos de video / parpadeo temporal

**Soluciones:**

* Aumenta los pasos de inferencia (prueba 80–100)
* Ajusta la escala de guía (el rango 3,5–5,0 suele ser el mejor)
* Usa una semilla específica para reproducibilidad e iteración

### El puerto 7860 no es accesible

Comprueba que el puerto se haya abierto correctamente en Clore.ai y que el servidor de Gradio esté vinculándose a `0.0.0.0`:

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

***

## Estimación de costos

| GPU              | VRAM   | Precio est.                               | tiempo de video de 5 s |
| ---------------- | ------ | ----------------------------------------- | ---------------------- |
| RTX 4090         | 24 GB  | $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 de 80 GB | 160 GB | [bare metal](https://clore.ai/bare-metal) | \~60–90 s              |

***

## Recomendaciones de GPU para Clore.ai

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

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

| GPU              | VRAM   | Precio de Clore.ai                        | Modo                                   | Tiempo de generación de video de 5 s |
| ---------------- | ------ | ----------------------------------------- | -------------------------------------- | ------------------------------------ |
| RTX 4090         | 24 GB  | $0.14–0.42/h                              | solo fp8 cuantizado                    | \~10–15 min                          |
| A100 40GB        | 40 GB  | [bare metal](https://clore.ai/bare-metal) | se recomienda bf16                     | \~3–5 min                            |
| A100 80GB        | 80 GB  | [bare metal](https://clore.ai/bare-metal) | bf16 completo, rápido                  | \~2–3 min                            |
| 2× A100 de 80 GB | 160 GB | [bare metal](https://clore.ai/bare-metal) | paralelismo de tensores, el más rápido | \~60–90 s                            |

{% hint style="warning" %}
**No se recomienda la RTX 3090 (24GB)** — Mochi-1 en modo fp8 necesita un mínimo de 24 GB y deja casi ningún margen. La RTX 4090 (24 GB) funciona en fp8, pero se queda sin memoria con frecuencia en secuencias más largas. Empieza con una A100 de 40 GB para obtener resultados fiables.
{% endhint %}

**Mejor relación calidad-precio:** A100 40GB a [bare metal](https://clore.ai/bare-metal) genera un clip de 5 segundos en 3–5 minutos. Eso es \~$0,08–0,10 por clip de video, considerablemente más barato que Runway ML ($0,25–0,50/clip) o las suscripciones de Pika Labs.

***

## Recursos útiles

* [GitHub de Mochi-1](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 Mochi en Diffusers](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
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-es/generacion-de-video/mochi-1.md?ask=<question>&goal=<endgoal>
```

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