OpenSora

Genera videos con OpenSora, la alternativa de código abierto a Sora

¡Hay alternativas más nuevas disponibles! FramePack genera video con solo 6 GB de VRAM, Wan2.1 ofrece una calidad superior, y LTX-2 añade generación nativa de audio.

Genera videos con OpenSora, la alternativa de código abierto a Sora, en las GPU de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

¿Por qué OpenSora?

• Código abierto - Licencia Apache 2.0 completa

• Inspirado en Sora - Arquitectura DiT como la de Sora de OpenAI

• Escalable - Múltiples tamaños y resoluciones de modelo

• Videos largos - Genera hasta 16 segundos

• Desarrollo activo - Actualizaciones y mejoras periódicas

Variantes del modelo

Modelo	Resolución	Duración	VRAM	Calidad
OpenSora 1.2	720p	16s	24GB	Excelente
OpenSora 1.1	480p	8s	16GB	Bueno
OpenSora 1.0	256p	4s	8GB	Básico
Open-Sora-Plan	512p	10s	20 GB	Excelente

Despliegue rápido en CLORE.AI

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

git clone https://github.com/hpcaitech/Open-Sora && \\
cd Open-Sora && \\
pip install -e . && \\
pip install gradio && \\
python scripts/inference.py \\
    --prompt "Un gato jugando con lana" \\
    --num-frames 51 \\
    --resolution 480p \\
    --save-dir ./outputs

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis pedidos:

1. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Requisitos de hardware

Versión del modelo	GPU mínima	Recomendado	Óptimo
OpenSora 1.0	RTX 3070 8GB	RTX 3090 24GB	RTX 4090
OpenSora 1.1	RTX 3090 16GB	RTX 4090 24GB	A100 40GB
OpenSora 1.2	RTX 4090 24GB	A100 40GB	A100 80GB

Instalación

Desde el código fuente

git clone https://github.com/hpcaitech/Open-Sora
cd Open-Sora

# Instalar dependencias
pip install -e .

# Descargar los pesos del modelo
python scripts/download_weights.py --version 1.2

Usando pip

pip install opensora

Uso básico

Línea de comandos

# Generación simple
python scripts/inference.py \\
    --prompt "Una hermosa puesta de sol sobre el océano, cinematográfica" \\
    --num-frames 51 \\
    --resolution 480p \\
    --save-dir ./outputs

# Alta calidad
python scripts/inference.py \\
    --prompt "Un majestuoso águila surcando las nubes" \\
    --num-frames 102 \\
    --resolution 720p \\
    --num-sampling-steps 100 \\
    --save-dir ./outputs

API de Python

import torch
from opensora.models import OpenSoraModel
from opensora.utils import export_to_video

# Cargar modelo
model = OpenSoraModel.from_pretrained("hpcaitech/OpenSora-v1.2")
model.to("cuda")

# Generar video
prompt = "Un cohete despegando hacia el espacio, iluminación dramática, cinematográfica"

video = model.generate(
    prompt=prompt,
    num_frames=51,
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.0
)

# Guardar
export_to_video(video, "rocket.mp4", fps=24)

Generación avanzada

Con prompts negativos

video = model.generate(
    prompt="Fotografía profesional de un tigre en libertad",
    negative_prompt="borroso, baja calidad, distorsionado, artefactos",
    num_frames=51,
    num_inference_steps=75,
    guidance_scale=7.5
)

Videos largos

# Genera 16 segundos a 24 fps
video = model.generate(
    prompt="Lapso de tiempo de flores floreciendo en un jardín",
    num_frames=384,  # 16 segundos a 24 fps
    height=480,
    width=854,
    num_inference_steps=100
)

export_to_video(video, "timelapse.mp4", fps=24)

Alta resolución

# Generación a 720p (requiere más VRAM)
video = model.generate(
    prompt="Vista aérea de una ciudad de noche con luces",
    num_frames=51,
    height=720,
    width=1280,
    num_inference_steps=75
)

Ejemplos de prompt

Cinemático

prompts = [
    "Toma cinematográfica de un samurái desenvainando su espada, iluminación dramática, 4K",
    "Toma panorámica épica de un castillo en un acantilado durante una tormenta",
    "Cámara lenta de gotas de agua cayendo en un estanque en calma,","
    "Toma de seguimiento por un callejón cyberpunk iluminado con neón de noche"
]

Naturaleza

prompts = [
    "Aurora boreal danzando sobre montañas nevadas, lapso de tiempo",
    "Toma macro de una mariposa saliendo del capullo",
    "Olas del océano rompiendo contra rocas volcánicas al atardecer",
    "Niebla desplazándose por un bosque antiguo al amanecer"
]

Abstracto

prompts = [
    "Gotas de pintura de colores cayendo al agua, cámara lenta",
    "Fractales evolucionando y transformándose, colores psicodélicos",
    "Metal líquido transformándose en diferentes formas"
]

Opciones de configuración

Preajustes de resolución

resolutions = {
    "256p": (256, 455),
    "360p": (360, 640),
    "480p": (480, 854),
    "720p": (720, 1280),
    "1080p": (1080, 1920)  # Se requiere mucha VRAM
}

Ajustes de calidad

# Vista previa rápida
config_fast = {
    "num_frames": 25,
    "num_inference_steps": 25,
    "guidance_scale": 5.0
}

# Equilibrado
config_balanced = {
    "num_frames": 51,
    "num_inference_steps": 50,
    "guidance_scale": 7.0
}

# Máxima calidad
config_quality = {
    "num_frames": 102,
    "num_inference_steps": 100,
    "guidance_scale": 7.5
}

Interfaz de Gradio

import gradio as gr
import torch
from opensora.models import OpenSoraModel
from opensora.utils import export_to_video
import tempfile

model = OpenSoraModel.from_pretrained("hpcaitech/OpenSora-v1.2")
model.to("cuda")

def generate_video(prompt, negative_prompt, frames, steps, guidance, resolution, seed):
    res_map = {"480p": (480, 854), "720p": (720, 1280)}
    height, width = res_map.get(resolution, (480, 854))

    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    video = model.generate(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        height=height,
        width=width,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(video, f.name, fps=24)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Textbox(label="Prompt", lines=2),
        gr.Textbox(label="Prompt negativo", value="borroso, baja calidad"),
        gr.Slider(25, 200, value=51, step=1, label="Fotogramas"),
        gr.Slider(20, 150, value=50, step=5, label="Pasos"),
        gr.Slider(3, 15, value=7, step=0.5, label="Guía"),
        gr.Dropdown(["480p", "720p"], value="480p", label="Resolución"),
        gr.Number(value=-1, label="Semilla")
    ],
    outputs=gr.Video(label="Video generado"),
    title="OpenSora - Texto a video",
    description="Genera videos usando OpenSora. Ejecutándose en CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Optimización de memoria

# Activar optimizaciones de memoria
model.enable_model_cpu_offload()
model.enable_vae_tiling()

# Para VRAM muy baja
model.enable_sequential_cpu_offload()

# Usar menor precisión
model = OpenSoraModel.from_pretrained(
    "hpcaitech/OpenSora-v1.2",
    torch_dtype=torch.float16
)

Generación por lotes

import os

prompts = [
    "Un fénix renaciendo de las llamas",
    "Lluvia cayendo sobre las calles de la ciudad por la noche",
    "Lapso de tiempo de flores floreciendo",
    "Luces del norte sobre montañas"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Generando {i+1}/{len(prompts)}: {prompt[:40]}...")

    video = model.generate(
        prompt=prompt,
        num_frames=51,
        num_inference_steps=50
    )

    export_to_video(video, f"{output_dir}/video_{i:03d}.mp4", fps=24)

    # Limpiar memoria entre generaciones
    torch.cuda.empty_cache()

Rendimiento

Resolución	Fotogramas	Pasos	GPU	Tiempo
480p	51	50	RTX 4090	~3 min
480p	51	50	A100 40GB	~2 min
720p	51	50	A100 40GB	~5 min
720p	102	100	A100 80GB	~15 min

Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

GPU	Tarifa por hora	~51 videos de 480p por hora
RTX 4090 24GB	~$0.10	~15-20
A100 40GB	~$0.17	~25-30
A100 80GB	~$0.25	~35 (puede hacer 720p)

Los precios varían. Consulta Marketplace de CLORE.AI las tarifas actuales.

Solución de problemas

Sin memoria

# Usar una resolución menor
python scripts/inference.py --resolution 360p --num-frames 25

# Habilitar descarga a CPU
python scripts/inference.py --cpu-offload

# Reduce el tamaño del lote
python scripts/inference.py --batch-size 1

Generación lenta

• Reduce num_inference_steps (30-50 suele ser suficiente)

• Usa una resolución más baja para las vistas previas

• Asegúrate de que la GPU se esté utilizando (comprueba nvidia-smi)

Calidad deficiente

• Aumenta los pasos a 75-100

• Usa prompts más descriptivos

• Añade prompts negativos para artefactos

• Prueba diferentes escalas de guía (5-10)

Artefactos de video

• Reduce la escala de guía

• Aumenta los pasos de inferencia

• Usa suavizado temporal

• Posprocesa con estabilización de video

OpenSora frente a otros

Función	OpenSora 1.2	Hunyuan	Wan2.1	SVD
Arquitectura	DiT	DiT	DiT	U-Net
Duración máxima	16s	5s	5s	4s
Resolución máxima	720p	720p	720p	576p
Calidad	Excelente	Excelente	Excelente	Bueno
Velocidad	Medio	Lento	Rápido	Rápido
Licencia	Apache 2.0	Abre	Apache 2.0	Abre

Usa OpenSora cuando:

• Necesitas generar videos más largos

• Quieres la licencia Apache 2.0 completa

• Te interesa una arquitectura similar a Sora

• Necesitas apoyo activo de la comunidad

Alternativa Open-Sora-Plan

Otra opción de código abierto:

git clone https://github.com/PKU-YuanGroup/Open-Sora-Plan
cd Open-Sora-Plan
pip install -e .

python scripts/inference.py \\
    --prompt "Tu prompt aquí" \\
    --output video.mp4

Siguientes pasos

• Hunyuan Video - T2V de alta calidad

• Video Wan2.1 - Generación rápida

• Stable Video Diffusion - Animación de imágenes

• Interpolación RIFE - Interpolación de fotogramas