> 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/opensora.md).

# OpenSora

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

{% hint style="info" %}
**¡Hay alternativas más nuevas disponibles!** [**FramePack**](/guides/guides_v2-es/generacion-de-video/framepack.md) genera video con solo 6 GB de VRAM, [**Wan2.1**](/guides/guides_v2-es/generacion-de-video/wan-video.md) ofrece una calidad superior, y [**LTX-2**](/guides/guides_v2-es/generacion-de-video/ltx-video-2.md) añade generación nativa de audio.
{% endhint %}

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

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

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

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

```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 surcando las 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 libertad",
    negative_prompt="borroso, baja calidad, distorsionado, artefactos",
    num_frames=51,
    num_inference_steps=75,
    guidance_scale=7.5
)
```

### Videos largos

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

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

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

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

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

```python
resolutions = {
    "256p": (256, 455),
    "360p": (360, 640),
    "480p": (480, 854),
    "720p": (720, 1280),
    "1080p": (1080, 1920)  # Se 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 de 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="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

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

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

## Solución de problemas

### Sin memoria

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

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

## Siguientes pasos

* [Hunyuan Video](/guides/guides_v2-es/generacion-de-video/hunyuan-video.md) - T2V de alta calidad
* [Video Wan2.1](/guides/guides_v2-es/generacion-de-video/wan-video.md) - Generación rápida
* [Stable Video Diffusion](/guides/guides_v2-es/generacion-de-video/stable-video-diffusion.md) - Animación de imágenes
* [Interpolación RIFE](/guides/guides_v2-es/procesamiento-de-video/rife-interpolation.md) - Interpolación de fotogramas


---

# 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/opensora.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.