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

# SkyReels-V3

Générez des vidéos à 24 ips avec SkyReels-V3, le modèle vidéo open source de Kunlun basé sur Wan2.1, sur les GPU Clore.ai.

SkyReels-V3 est un modèle open source de génération de vidéos de Kunlun (SkyWork AI), construit sur l’architecture vidéo Wan2.1. Il génère des clips fluides à 24 ips, avec des capacités de texte vers vidéo (T2V) et d’image vers vidéo (I2V). Le modèle hérite de la forte cohérence du mouvement et de la consistance temporelle de Wan2.1, tout en ajoutant les raffinements d’entraînement de SkyWork pour améliorer la qualité visuelle et le respect des prompts.

Exécuter SkyReels-V3 sur [Clore.ai](https://clore.ai/) vous permet d’accéder aux 24 Go de VRAM dont il a besoin sans acheter de matériel — louez une RTX 4090 pour quelques dollars et commencez à générer.

## Caractéristiques clés

* **Sortie à 24 ips** — un taux d’image fluide, de qualité diffusion, prêt à l’emploi.
* **Texte vers vidéo** — générez des clips à partir de descriptions en langage naturel avec un excellent respect des prompts.
* **Image vers vidéo** — animez une image de référence avec un mouvement de caméra et un déplacement du sujet contrôlables.
* **Construit sur Wan2.1** — hérite de l’attention temporelle éprouvée et de la modélisation du mouvement de l’architecture Wan.
* **Multi-résolution** — prend en charge la génération en 480p et 720p selon le budget VRAM.
* **Poids ouverts** — disponible sous une licence ouverte pour la recherche et l’usage commercial.
* **Chinois + anglais** — prise en charge bilingue des prompts par l’encodeur de texte Wan2.1.

## Exigences

| Composant   | Minimum                        | Recommandé |
| ----------- | ------------------------------ | ---------- |
| VRAM GPU    | 16 Go (480p avec déchargement) | 24 Go      |
| RAM système | 32 Go                          | 64 Go      |
| Disque      | 25 Go                          | 50 Go      |
| Python      | 3.10+                          | 3.11       |
| CUDA        | 12.8+                          | 12.8+      |

**Recommandation de GPU Clore.ai :** Un **RTX 4090** (24 Go, 0,14–0,42 $/h) est le juste milieu — suffisamment de VRAM pour une génération en 720p en précision complète. Un **RTX 3090** (24 Go, 0,07–0,21 $/h) convient au 480p et offre le meilleur rapport prix/par-clip sur la place de marché.

## Démarrage rapide

```bash
# Installer les dépendances de base
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg]

# Vérifier le GPU
python -c "import torch; print(torch.cuda.get_device_name(0))"
```

## Exemples d'utilisation

### Texte vers vidéo

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

# SkyReels-V3 utilise l’architecture du pipeline Wan2.1
pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = (
    "Un samouraï marchant dans une forêt de bambous dans la brume du matin, "
    "la lumière du soleil filtrant à travers les hautes tiges, composition cinématographique, "
    "mouvement lent et délibéré"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="flou, basse qualité, filigrane, statique",
    num_frames=97,               # ~4 sec à 24 ips
    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("samurai_forest.mp4 enregistré")
```

### Image vers vidéo

```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 caméra avance lentement vers l’avant dans la scène, les nuages défilent au-dessus",
    image=image,
    negative_prompt="statique, saccades, flou",
    num_frames=97,
    num_inference_steps=30,
    guidance_scale=5.0,
).frames[0]

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

### Aperçu rapide en basse résolution

```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 pour une itération rapide
frames = pipe(
    prompt="Vagues de l’océan se brisant sur des rochers, embruns spectaculaires, coucher de soleil",
    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)
```

## Conseils pour les utilisateurs de Clore.ai

1. **Utilisez les classes du pipeline Wan** — SkyReels-V3 est architecturé sur Wan2.1, donc il utilise `WanPipeline` / `WanImageToVideoPipeline` de diffusers.
2. **Commencer en 480p** — itérez d’abord sur les prompts à plus basse résolution, puis générez les clips finaux en 720p une fois satisfait de la composition.
3. **Déchargement CPU** — `enable_model_cpu_offload()` est recommandé sur les cartes 24 Go pour une génération en 720p afin d’éviter un OOM.
4. **Stockage persistant** — définissez `HF_HOME=/workspace/hf_cache` sur un volume persistant Clore.ai ; le modèle pèse environ 15–20 Go.
5. **24 ips natifs** — ne changez pas le fps d’export ; l’attention temporelle du modèle a été entraînée pour une sortie à 24 ips.
6. **Prompts bilingues** — l’encodeur de texte Wan2.1 gère à la fois l’anglais et le chinois ; vous pouvez mélanger les langues si nécessaire.
7. **Échelle de guidance** — 4,0–6,0 fonctionne le mieux. Des valeurs plus élevées (>8) peuvent provoquer une sursaturation.
8. **tmux est obligatoire** — exécutez toujours la génération dans une `tmux` session sur Clore.ai pour survivre aux déconnexions SSH.

## Dépannage

| Problème                                    | Correctif                                                                                                                                        |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `OutOfMemoryError` en 720p                  | Activer `pipe.enable_model_cpu_offload()`; réduisez à 480p si l’erreur OOM persiste                                                              |
| Modèle introuvable sur HuggingFace          | Vérifiez le nom exact du dépôt sur [la page HF de SkyworkAI](https://huggingface.co/SkyworkAI) — il peut être répertorié sous un nom de variante |
| Mouvement saccadé ou scintillant            | Augmentez `num_inference_steps` à 40 ; réduisez `guidance_scale` à 4,0                                                                           |
| Génération lente                            | \~1–3 min par clip de 4 s sur RTX 4090 est normal pour le 720p ; le 480p est environ 2× plus rapide                                              |
| Dérive des couleurs / sursaturation         | Réduisez `guidance_scale` à 4,0–5,0                                                                                                              |
| `ImportError : imageio`                     | `pip install imageio[ffmpeg]`                                                                                                                    |
| Les poids sont retéléchargés au redémarrage | Montez un stockage persistant et définissez `HF_HOME` la variable d’environnement                                                                |


---

# 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-fr/generation-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.