OpenSora

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

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

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

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

¿Por qué OpenSora?

• Código abierto - Licencia Apache 2.0 completa

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

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

• Videos largos - Genera hasta 16 segundos

• Desarrollo activo - Actualizaciones y mejoras regulares

Variantes de 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	20GB	Genial

Despliegue rápido en CLORE.AI

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-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 un ovillo de 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. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

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 la 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 volando entre 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 la naturaleza",
    negative_prompt="borroso, baja calidad, distorsionado, artefactos",
    num_frames=51,
    num_inference_steps=75,
    guidance_scale=7.5
)

Videos largos

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

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

Alta resolución

# Generación 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 prompts

Cinematográfico

prompts = [
    "Toma cinematográfica de un samurái desenvainando su espada, iluminación dramática, 4K",
    "Toma amplia é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 por neón durante la noche"
]

Naturaleza

prompts = [
    "Aurora boreal bailando sobre montañas nevadas, time-lapse",
    "Toma macro de una mariposa emergiendo del capullo",
    "Olas del océano chocando contra rocas volcánicas al atardecer",
    "Niebla rodando por un bosque antiguo al amanecer"
]

Abstracto

prompts = [
    "Gotas de pintura colorida cayendo en 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)  # 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 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="Negative Prompt", 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

# Habilitar 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 elevándose de las llamas",
    "Lluvia cayendo en las calles de la ciudad por la noche",
    "Time-lapse de flores floreciendo",
    "Luces del norte sobre las 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 hacerlo en 720p)

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

Solución de problemas

Memoria insuficiente

# Usar resolución más pequeña
python scripts/inference.py --resolution 360p --num-frames 25

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

# Reducir tamaño de lote
python scripts/inference.py --batch-size 1

Generación lenta

• Reducir num_inference_steps (30-50 a menudo es suficiente)

• Usar menor resolución para vistas previas

• Asegúrate de que la GPU esté siendo utilizada (revisa nvidia-smi)

Calidad pobre

• 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 en video

• Reducir la escala de guía

• Aumentar los pasos de inferencia

• Usar suavizado temporal

• Post-procesa con estabilización de video

OpenSora vs 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	Genial	Excelente	Excelente	Bueno
Velocidad	Medio	Lento	Rápido	Rápido
Licencia	Apache 2.0	Abrir	Apache 2.0	Abrir

Usa OpenSora cuando:

• Necesites generar videos más largos

• Quieras la licencia Apache 2.0 completa

• Intereses en una arquitectura similar a Sora

• Necesites soporte 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

Próximos pasos

• Hunyuan Video - T2V de alta calidad

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

• Stable Video Diffusion - Animación de imagen

• Interpolación RIFE - Interpolación de fotogramas