# SkyReels-V3

SkyReels-V3 est un modèle de génération vidéo open-source 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 texte-vers-vidéo (T2V) et 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 l'adhérence aux prompts.

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

## Principales caractéristiques

* **Sortie 24 ips** — fréquence d'images fluide et de qualité broadcast prête à l'emploi.
* **Texte vers Vidéo** — générez des clips à partir de descriptions en langage naturel avec un fort respect du prompt.
* **Image vers Vidéo** — animez une image de référence avec un mouvement de caméra et un mouvement du sujet contrôlables.
* **Basé sur Wan2.1** — hérite de l'attention temporelle et de la modélisation du mouvement éprouvées 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 licence ouverte pour la recherche et un 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 offload) | 24 Go      |
| RAM système | 32 Go                     | 64 Go      |
| Disque      | 25 Go                     | 50 Go      |
| Python      | 3.10+                     | 3.11       |
| CUDA        | 12.1+                     | 12.4       |

**Recommandation GPU Clore.ai :** Un **RTX 4090** (24 Go, \~0,5–2 $/jour) est le bon compromis — assez de VRAM pour la génération 720p en précision complète. Un **RTX 3090** (24 Go, \~0,3–1 $/jour) convient pour le 480p et offre le meilleur rapport prix/clip sur la marketplace.

## Démarrage rapide

```bash
# Installer les dépendances principales
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
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 de 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 à travers une forêt de bambous dans la brume matinale, "
    "la lumière du soleil filtrant à travers les grandes 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("Saved samurai_forest.mp4")
```

### 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 dans la scène, des nuages dérivent au-dessus",
    image=image,
    negative_prompt="statique, tremblement, 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 des itérations rapides
frames = pipe(
    prompt="Vagues de l'océan s'écrasant sur les rochers, embruns dramatiques, 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 de pipeline Wan** — SkyReels-V3 est architecturally basé sur Wan2.1, donc il utilise `WanPipeline` / `WanImageToVideoPipeline` de diffusers.
2. **Commencez 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 la génération en 720p afin d'éviter les OOM.
4. **Stockage persistant** — définissez `HF_HOME=/workspace/hf_cache` sur un volume persistant Clore.ai ; le modèle pèse \~15–20 Go.
5. **24 ips natif** — ne changez pas les fps d'exportation ; 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 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                                  | Corriger                                                                                                                                 |
| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` en 720p                | Activez `pipe.enable_model_cpu_offload()`; réduisez à 480p si toujours OOM                                                               |
| Modèle introuvable sur HuggingFace        | Vérifiez le nom exact du dépôt sur [page HF de SkyworkAI](https://huggingface.co/SkyworkAI) — il peut être listé sous un nom de variante |
| Mouvement saccadé ou scintillement        | Augmentez `num_inference_steps` à 40 ; réduisez `guidance_scale` à 4.0                                                                   |
| Génération lente                          | \~1–3 min par clip de 4 secondes sur RTX 4090 est normal pour le 720p ; le 480p est environ 2× plus rapide                               |
| Décalage de couleur / sursaturation       | Plus bas `guidance_scale` à 4.0–5.0                                                                                                      |
| `ImportError : imageio`                   | `pip install imageio[ffmpeg]`                                                                                                            |
| Retéléchargement des poids au redémarrage | Montez un stockage persistant et définissez `HF_HOME` variable d'environnement                                                           |