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

# OpenSora

Générez des vidéos avec OpenSora, l'alternative open source à Sora

{% hint style="info" %}
**Des alternatives plus récentes disponibles !** [**FramePack**](/guides/guides_v2-fr/generation-video/framepack.md) génère des vidéos avec seulement 6 Go de VRAM, [**Wan2.1**](/guides/guides_v2-fr/generation-video/wan-video.md) offre une qualité supérieure, et [**LTX-2**](/guides/guides_v2-fr/generation-video/ltx-video-2.md) ajoute la génération audio native.
{% endhint %}

Générez des vidéos avec OpenSora, l’alternative open source à Sora, sur les GPU CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Pourquoi OpenSora ?

* **Code source ouvert** - Licence Apache 2.0 complète
* **Inspiré de Sora** - Architecture DiT comme celle de Sora d’OpenAI
* **Évolutif** - Plusieurs tailles de modèles et résolutions
* **Vidéos longues** - Génère jusqu’à 16 secondes
* **Développement actif** - Mises à jour et améliorations régulières

## Variantes de modèle

| Modèle         | Résolution | Durée | VRAM  | Qualité    |
| -------------- | ---------- | ----- | ----- | ---------- |
| OpenSora 1.2   | 720p       | 16 s  | 24GB  | Excellente |
| OpenSora 1.1   | 480p       | 8 s   | 16 Go | Bon        |
| OpenSora 1.0   | 256p       | 4 s   | 8 Go  | Basique    |
| Open-Sora-Plan | 512p       | 10 s  | 20 Go | Excellent  |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

```bash
git clone https://github.com/hpcaitech/Open-Sora && \
cd Open-Sora && \
pip install -e . && \\
pip install gradio && \
python scripts/inference.py \
    --prompt "Un chat jouant avec de la laine" \
    --num-frames 51 \
    --resolution 480p \
    --save-dir ./outputs
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Configuration matérielle requise

| Version du modèle | GPU minimum    | Recommandé     | Optimal    |
| ----------------- | -------------- | -------------- | ---------- |
| OpenSora 1.0      | RTX 3070 8 Go  | RTX 3090 24 Go | RTX 4090   |
| OpenSora 1.1      | RTX 3090 16 Go | RTX 4090 24 Go | A100 40 Go |
| OpenSora 1.2      | RTX 4090 24 Go | A100 40 Go     | A100 80 Go |

## Installation

### Depuis les sources

```bash
git clone https://github.com/hpcaitech/Open-Sora
cd Open-Sora

# Installer les dépendances
pip install -e .

# Télécharger les poids du modèle
python scripts/download_weights.py --version 1.2
```

### Avec pip

```bash
pip install opensora
```

## Utilisation de base

### Ligne de commande

```bash
# Génération simple
python scripts/inference.py \
    --prompt "Un magnifique coucher de soleil sur l’océan, cinématographique" \
    --num-frames 51 \
    --resolution 480p \
    --save-dir ./outputs

# Haute qualité
python scripts/inference.py \
    --prompt "Un aigle majestueux planant à travers les nuages" \
    --num-frames 102 \
    --resolution 720p \
    --num-sampling-steps 100 \
    --save-dir ./outputs
```

### API Python

```python
import torch
from opensora.models import OpenSoraModel
from opensora.utils import export_to_video

# Charger le modèle
model = OpenSoraModel.from_pretrained("hpcaitech/OpenSora-v1.2")
model.to("cuda")

# Générer la vidéo
prompt = "Une fusée décollant dans l’espace, éclairage dramatique, cinématographique"

video = model.generate(
    prompt=prompt,
    num_frames=51,
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.0
)

# Enregistrer
export_to_video(video, "rocket.mp4", fps=24)
```

## Génération avancée

### Avec prompts négatifs

```python
video = model.generate(
    prompt="Photographie professionnelle d’un tigre dans la nature",
    negative_prompt="flou, basse qualité, déformé, artefacts",
    num_frames=51,
    num_inference_steps=75,
    guidance_scale=7.5
)
```

### Vidéos longues

```python
# Générer 16 secondes à 24 i/s
video = model.generate(
    prompt="Accéléré de fleurs qui s’épanouissent dans un jardin",
    num_frames=384,  # 16 secondes à 24 i/s
    height=480,
    width=854,
    num_inference_steps=100
)

export_to_video(video, "timelapse.mp4", fps=24)
```

### Haute résolution

```python
# Génération en 720p (nécessite plus de VRAM)
video = model.generate(
    prompt="Vue aérienne d’une ville la nuit avec des lumières",
    num_frames=51,
    height=720,
    width=1280,
    num_inference_steps=75
)
```

## Exemples d'invites

### Cinématographique

```python
prompts = [
    "Plan cinématographique d’un samouraï dégainant son épée, éclairage dramatique, 4K",
    "Plan large épique d’un château sur une falaise pendant une tempête",
    "Ralenti de gouttes d’eau tombant dans un étang immobile",
    "Plan de suivi à travers une ruelle cyberpunk éclairée au néon la nuit"
]
```

### Nature

```python
prompts = [
    "Aurore boréale dansant au-dessus de montagnes enneigées, accéléré",
    "Plan macro d’un papillon sortant de son cocon",
    "Vagues de l’océan s’écrasant sur des rochers volcaniques au coucher du soleil",
    "Brouillard roulant à travers une forêt ancienne à l’aube"
]
```

### Abstrait

```python
prompts = [
    "Gouttes de peinture colorées tombant dans l’eau, ralenti",
    "Fractales évoluant et se transformant, couleurs psychédéliques",
    "Métal liquide se transformant en différentes formes"
]
```

## Options de configuration

### Préréglages de résolution

```python
resolutions = {
    "256p": (256, 455),
    "360p": (360, 640),
    "480p": (480, 854),
    "720p": (720, 1280),
    "1080p": (1080, 1920)  # Grande quantité de VRAM requise
}
```

### Paramètres de qualité

```python
# Aperçu rapide
config_fast = {
    "num_frames": 25,
    "num_inference_steps": 25,
    "guidance_scale": 5.0
}

# Équilibré
config_balanced = {
    "num_frames": 51,
    "num_inference_steps": 50,
    "guidance_scale": 7.0
}

# Qualité maximale
config_quality = {
    "num_frames": 102,
    "num_inference_steps": 100,
    "guidance_scale": 7.5
}
```

## Interface 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="Invite", lines=2),
        gr.Textbox(label="Invite négative", value="flou, basse qualité"),
        gr.Slider(25, 200, value=51, step=1, label="Images"),
        gr.Slider(20, 150, value=50, step=5, label="Étapes"),
        gr.Slider(3, 15, value=7, step=0.5, label="Guidage"),
        gr.Dropdown(["480p", "720p"], value="480p", label="Résolution"),
        gr.Number(value=-1, label="Graine")
    ],
    outputs=gr.Video(label="Vidéo générée"),
    title="OpenSora - Texte vers vidéo",
    description="Générez des vidéos avec OpenSora. Fonctionne sur CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Optimisation de la mémoire

```python
# Activer les optimisations mémoire
model.enable_model_cpu_offload()
model.enable_vae_tiling()

# Pour une très faible VRAM
model.enable_sequential_cpu_offload()

# Utiliser une précision plus faible
model = OpenSoraModel.from_pretrained(
    "hpcaitech/OpenSora-v1.2",
    torch_dtype=torch.float16
)
```

## Génération par lots

```python
import os

prompts = [
    "Un phénix renaissant de ses flammes",
    "Pluie tombant sur les rues de la ville la nuit",
    "Accéléré de fleurs en train d’éclore",
    "Aurores boréales au-dessus des montagnes"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Génération de {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)

    # Vider la mémoire entre les générations
    torch.cuda.empty_cache()
```

## Performances

| Résolution | Images | Étapes | GPU        | Temps    |
| ---------- | ------ | ------ | ---------- | -------- |
| 480p       | 51     | 50     | RTX 4090   | \~3 min  |
| 480p       | 51     | 50     | A100 40 Go | \~2 min  |
| 720p       | 51     | 50     | A100 40 Go | \~5 min  |
| 720p       | 102    | 100    | A100 80 Go | \~15 min |

## Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

| GPU            | Tarif horaire | \~51 vidéos 480p images/s heure |
| -------------- | ------------- | ------------------------------- |
| RTX 4090 24 Go | \~$0.10       | \~15-20                         |
| A100 40 Go     | \~$0.17       | \~25-30                         |
| A100 80 Go     | \~$0.25       | \~35 (peut faire du 720p)       |

*Les prix varient. Vérifiez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

## Dépannage

### Mémoire insuffisante

```bash
# Utiliser une résolution plus petite
python scripts/inference.py --resolution 360p --num-frames 25

# Activer le déchargement sur CPU
python scripts/inference.py --cpu-offload

# Réduire la taille du lot
python scripts/inference.py --batch-size 1
```

### Génération lente

* Réduisez `num_inference_steps` (30-50 suffisent souvent)
* Utiliser une résolution plus basse pour les aperçus
* S’assurer que le GPU est utilisé (vérifier `nvidia-smi`)

### Qualité médiocre

* Augmenter les étapes à 75-100
* Utiliser des prompts plus descriptifs
* Ajouter des prompts négatifs pour les artefacts
* Essayer différentes échelles de guidage (5-10)

### Artefacts vidéo

* Réduire l’échelle de guidage
* Augmenter les étapes d’inférence
* Utiliser un lissage temporel
* Post-traitez avec une stabilisation vidéo

## OpenSora vs autres

| Fonctionnalité      | OpenSora 1.2 | Hunyuan    | Wan2.1     | SVD    |
| ------------------- | ------------ | ---------- | ---------- | ------ |
| Architecture        | DiT          | DiT        | DiT        | U-Net  |
| Durée maximale      | 16 s         | 5 s        | 5 s        | 4 s    |
| Résolution maximale | 720p         | 720p       | 720p       | 576p   |
| Qualité             | Excellent    | Excellente | Excellente | Bon    |
| Vitesse             | Moyen        | Lent       | Rapide     | Rapide |
| Licence             | Apache 2.0   | Ouvrez     | Apache 2.0 | Ouvrez |

**Utilisez OpenSora lorsque :**

* Besoin d’une génération vidéo plus longue
* Vous voulez une licence Apache 2.0 complète
* Vous êtes intéressé par une architecture de type Sora
* Besoin d’un support actif de la communauté

## Alternative Open-Sora-Plan

Une autre option open source :

```bash
git clone https://github.com/PKU-YuanGroup/Open-Sora-Plan
cd Open-Sora-Plan
pip install -e .

python scripts/inference.py \
    --prompt "Votre prompt ici" \
    --output video.mp4
```

## Étapes suivantes

* [Hunyuan Video](/guides/guides_v2-fr/generation-video/hunyuan-video.md) - T2V de haute qualité
* [Vidéo Wan2.1](/guides/guides_v2-fr/generation-video/wan-video.md) - Génération rapide
* [Stable Video Diffusion](/guides/guides_v2-fr/generation-video/stable-video-diffusion.md) - Animation d'images
* [Interpolation RIFE](/guides/guides_v2-fr/traitement-video/rife-interpolation.md) - Interpolation d'images


---

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