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+

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.

---

Paso 1 — Alquila una GPU en Clore.ai

1. Ve a 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.

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.

---

Paso 2 — Dockerfile personalizado

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

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

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.

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.

---

Paso 3 — Conéctate vía SSH

Una vez que tu instancia esté en funcionamiento:

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:

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"

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.

Alternativa: Descargar solo pesos cuantizados fp8

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:

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

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

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.

---

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)

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.

---

Uso de la API de Python

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

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

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:

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]

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.

---

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:

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:

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

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.

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

• Mochi-1 en Hugging Face

• Blog de Genmo — Lanzamiento de Mochi-1

• Documentación de Diffusers Mochi

• Guía de prompts de Mochi (Comunidad)