# OpenSora

{% hint style="info" %}
**¡Alternativas más nuevas disponibles!** [**FramePack**](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/framepack) genera video con solo 6GB de VRAM, [**Wan2.1**](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/wan-video) ofrece calidad superior, y [**LTX-2**](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/ltx-video-2) agrega generación de audio nativa.
{% endhint %}

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## ¿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:**

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

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

```bash
pip install opensora
```

## Uso básico

### Línea de comandos

```bash
# 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

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

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

```python
# 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

```python
# 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

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

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

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

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

### Ajustes de calidad

```python
# 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

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

```python
# 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

```python
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*](https://clore.ai/marketplace) *para las tarifas actuales.*

## Solución de problemas

### Memoria insuficiente

```bash
# 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:

```bash
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](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/hunyuan-video) - T2V de alta calidad
* [Wan2.1 Video](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/wan-video) - Generación rápida
* [Stable Video Diffusion](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/stable-video-diffusion) - Animación de imagen
* [Interpolación RIFE](https://docs.clore.ai/guides/guides_v2-es/procesamiento-de-video/rife-interpolation) - Interpolación de fotogramas