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

# SkyReels-V3

Genera video a 24 fps con SkyReels-V3, el modelo abierto de video basado en Wan2.1 de Kunlun, en GPUs de Clore.ai.

SkyReels-V3 es un modelo de generación de video de código abierto de Kunlun (SkyWork AI) construido sobre la arquitectura de video Wan2.1. Genera clips fluidos de 24 fps con capacidades tanto de texto a video (T2V) como de imagen a video (I2V). El modelo hereda la fuerte coherencia de movimiento y consistencia temporal de Wan2.1, al tiempo que añade los refinamientos de entrenamiento de SkyWork para mejorar la calidad visual y el cumplimiento de los prompts.

Ejecutar SkyReels-V3 en [Clore.ai](https://clore.ai/) te permite acceder a los 24 GB de VRAM que necesita sin comprar hardware — alquila una RTX 4090 por unos pocos dólares y empieza a generar.

## Características clave

* **Salida a 24 fps** — una tasa de fotogramas fluida y de calidad de emisión desde el primer momento.
* **Texto a video** — genera clips a partir de descripciones en lenguaje natural con un gran seguimiento del prompt.
* **Imagen a video** — anima una imagen de referencia con movimiento de cámara y movimiento del sujeto controlables.
* **Basado en Wan2.1** — hereda la probada atención temporal y el modelado de movimiento de la arquitectura Wan.
* **Multirresolución** — admite generación en 480p y 720p según el presupuesto de VRAM.
* **Pesos abiertos** — disponible bajo una licencia abierta para investigación y uso comercial.
* **Chino + inglés** — soporte bilingüe de prompts desde el codificador de texto Wan2.1.

## Requisitos

| Componente      | Mínimo                    | Recomendado |
| --------------- | ------------------------- | ----------- |
| VRAM de GPU     | 16 GB (480p con descarga) | 24 GB       |
| RAM del sistema | 32 GB                     | 64 GB       |
| Disco           | 25 GB                     | 50 GB       |
| Python          | 3.10+                     | 3.11        |
| CUDA            | 12.8+                     | 12.8+       |

**Recomendación de GPU de Clore.ai:** Un **RTX 4090** (24 GB, $0.14–0.42/h) es el punto óptimo — suficiente VRAM para generación a 720p con precisión completa. Un **RTX 3090** (24 GB, $0.07–0.21/h) funciona para 480p y ofrece la mejor relación precio por clip en el mercado.

## Inicio rápido

```bash
# Instala las dependencias principales
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg]

# Verificar GPU
python -c "import torch; print(torch.cuda.get_device_name(0))"
```

## Ejemplos de uso

### Texto a video

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

# SkyReels-V3 usa la arquitectura de canalización de Wan2.1
pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = (
    "Un samurái caminando por un bosque de bambú en la niebla de la mañana, "
    "la luz del sol filtrándose entre los altos tallos, composición cinematográfica, "
    "movimiento lento y deliberado"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="borroso, baja calidad, marca de agua, estático",
    num_frames=97,               # ~4 s a 24 fps
    width=1280,
    height=720,
    num_inference_steps=30,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]

export_to_video(video_frames, "samurai_forest.mp4", fps=24)
print("Guardado samurai_forest.mp4")
```

### Imagen a video

```python
import torch
from PIL import Image
from diffusers import WanImageToVideoPipeline
from diffusers.utils import export_to_video

pipe = WanImageToVideoPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-I2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

image = Image.open("landscape.png").resize((1280, 720))

video_frames = pipe(
    prompt="La cámara avanza lentamente hacia la escena, las nubes se desplazan por encima",
    image=image,
    negative_prompt="estático, temblor, borroso",
    num_frames=97,
    num_inference_steps=30,
    guidance_scale=5.0,
).frames[0]

export_to_video(video_frames, "landscape_anim.mp4", fps=24)
```

### Vista previa rápida de menor resolución

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V", torch_dtype=torch.bfloat16
).to("cuda")

# 480p para iteración rápida
frames = pipe(
    prompt="Olas del océano rompiendo contra las rocas, spray dramático, atardecer",
    num_frames=49,
    width=854,
    height=480,
    num_inference_steps=20,
    guidance_scale=5.0,
).frames[0]

export_to_video(frames, "waves_preview.mp4", fps=24)
```

## Consejos para usuarios de Clore.ai

1. **Usa las clases de la canalización Wan** — SkyReels-V3 está basado arquitectónicamente en Wan2.1, por lo que usa `WanPipeline` / `WanImageToVideoPipeline` de diffusers.
2. **Empieza en 480p** — itera sobre los prompts primero a menor resolución y luego genera los clips finales en 720p una vez que estés satisfecho con la composición.
3. **Descarga a CPU** — `enable_model_cpu_offload()` se recomienda en tarjetas de 24 GB para generación a 720p para evitar OOM.
4. **Almacenamiento persistente** — establece `HF_HOME=/workspace/hf_cache` en un volumen persistente de Clore.ai; el modelo pesa \~15–20 GB.
5. **24 fps nativo** — no cambies los fps de exportación; la atención temporal del modelo fue entrenada para salida a 24 fps.
6. **Prompts bilingües** — el codificador de texto Wan2.1 maneja tanto inglés como chino; puedes mezclar idiomas si es necesario.
7. **Escala de guía** — 4.0–6.0 funciona mejor. Los valores más altos (>8) pueden causar sobresaturación.
8. **tmux es obligatorio** — ejecuta siempre la generación en una `tmux` sesión en Clore.ai para sobrevivir a desconexiones SSH.

## Solución de problemas

| Problema                                      | Solución                                                                                                                                                 |
| --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` a 720p                     | Habilita `pipe.enable_model_cpu_offload()`; reduce a 480p si aún se agota la memoria                                                                     |
| Modelo no encontrado en HuggingFace           | Comprueba el nombre exacto del repositorio en [la página HF de SkyworkAI](https://huggingface.co/SkyworkAI) — puede que aparezca bajo un nombre variante |
| Movimiento entrecortado o parpadeante         | Aumenta `num_inference_steps` a 40; reduce `guidance_scale` a 4.0                                                                                        |
| Generación lenta                              | \~1–3 min por clip de 4 s en una RTX 4090 es normal para 720p; 480p es aproximadamente 2× más rápido                                                     |
| Desplazamiento de color / sobresaturación     | Reduce `guidance_scale` a 4.0–5.0                                                                                                                        |
| `ImportError: imageio`                        | `pip install imageio[ffmpeg]`                                                                                                                            |
| Los pesos se vuelven a descargar al reiniciar | Monta almacenamiento persistente y establece `HF_HOME` la variable de entorno                                                                            |


---

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