> 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/audio-et-voix/stable-audio.md).

# Stable Audio

Générez de la musique et des effets sonores avec Stable Audio sur Clore.ai

Générez de la musique et des effets sonores avec Stable Audio de Stability AI 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 Stable Audio ?

* **Haute qualité** - Génération audio stéréo en 44,1 kHz
* **Durée variable** - Générez jusqu'à 95 secondes
* **Polyvalent** - Musique, effets sonores, sons d'ambiance
* **Texte vers audio** - Décrivez ce que vous voulez entendre
* **Poids ouverts** - Stable Audio Open disponible

## Variantes de modèle

| Modèle            | Durée | Qualité   | VRAM  | Licence    |
| ----------------- | ----- | --------- | ----- | ---------- |
| Stable Audio Open | 47 s  | Bon       | 8 Go  | Ouvrez     |
| Stable Audio 2.0  | 3 min | Excellent | 12 Go | Commercial |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

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

**Ports :**

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

**Commande :**

```bash
pip install stable-audio-tools gradio && \\
python -c "
import gradio as gr
import torch
from stable_audio_tools import get_pretrained_model
from stable_audio_tools.inference.generation import generate_diffusion_cond
import soundfile as sf
import tempfile

model, model_config = get_pretrained_model('stabilityai/stable-audio-open-1.0')
model = model.to('cuda')

def generate(prompt, duration, steps, seed):
    conditioning = [{
        'prompt': prompt,
        'seconds_start': 0,
        'seconds_total': duration
    }]

    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None

    output = generate_diffusion_cond(
        model,
        conditioning=conditioning,
        steps=steps,
        cfg_scale=7,
        sample_size=model_config['sample_size'],
        sample_rate=model_config['sample_rate'],
        device='cuda',
        seed=seed if seed > 0 else None
    )

    audio = output[0].T.cpu().numpy()

    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        sf.write(f.name, audio, model_config['sample_rate'])
        return f.name

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Instruction'),
        gr.Slider(1, 47, value=10, label='Durée (s)'),
        gr.Slider(10, 150, value=100, label='Étapes'),
        gr.Number(value=-1, label='Graine')
    ],
    outputs=gr.Audio(label='Audio généré'),
    title='Stable Audio Open'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

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

| Modèle            | GPU minimum   | Recommandé     |
| ----------------- | ------------- | -------------- |
| Stable Audio Open | RTX 3070 8 Go | RTX 3090 24 Go |
| Stable Audio 2.0  | RTX 3090 12GB | RTX 4090 24 Go |

## Installation

```bash
pip install stable-audio-tools torch torchaudio
```

## Utilisation de base

### Texte vers musique

```python
import torch
import torchaudio
from stable_audio_tools import get_pretrained_model
from stable_audio_tools.inference.generation import generate_diffusion_cond

# Charger le modèle
model, model_config = get_pretrained_model("stabilityai/stable-audio-open-1.0")
model = model.to("cuda")

sample_rate = model_config["sample_rate"]
sample_size = model_config["sample_size"]

# Définissez ce que vous voulez
conditioning = [{
    "prompt": "Musique dance électronique entraînante avec une mélodie de synthé accrocheuse, 128 BPM",
    "seconds_start": 0,
    "seconds_total": 30
}]

# Générer
output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=100,
    cfg_scale=7,
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda"
)

# Enregistrer
audio = output[0].T
torchaudio.save("music.wav", audio.cpu(), sample_rate)
```

### Effets sonores

```python
conditioning = [{
    "prompt": "Orage avec forte pluie et tonnerre lointain",
    "seconds_start": 0,
    "seconds_total": 20
}]

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=100,
    cfg_scale=7,
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda"
)

torchaudio.save("thunderstorm.wav", output[0].T.cpu(), sample_rate)
```

### Sons d'ambiance

```python
conditioning = [{
    "prompt": "Ambiance paisible de forêt avec des oiseaux qui chantent et une brise légère",
    "seconds_start": 0,
    "seconds_total": 45
}]

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=100,
    cfg_scale=7,
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda"
)

torchaudio.save("forest.wav", output[0].T.cpu(), sample_rate)
```

## Exemples d'instructions

### Genres musicaux

```python
prompts = {
    "electronic": "Titre EDM énergique avec des basses profondes, des arpèges de synthé et un rythme entraînant, 130 BPM",
    "jazz": "Trio de piano jazz doux avec contrebasse et batterie aux balais, tempo détendu",
    "rock": "Riff de guitare rock puissant avec distorsion, batterie et basse, puissant et énergique",
    "classical": "Pièce orchestrale avec cordes et bois, dramatique et cinématographique",
    "ambient": "Paysage sonore ambiant atmosphérique avec nappes et textures subtiles, onirique",
    "hiphop": "Beat hip-hop lo-fi avec crépitements de vinyle, piano doux et batterie chill, 85 BPM"
}
```

### Effets sonores

```python
prompts = {
    "explosion": "Explosion massive avec débris et feu, cinématographique",
    "footsteps": "Pas sur du gravier, rythme de marche lent",
    "car": "Moteur de voiture de sport qui monte dans les tours et accélère",
    "water": "Eau qui éclabousse et goutte dans une grotte",
    "wind": "Fort vent hurlant à travers les montagnes",
    "fire": "Feu de camp crépitant avec des bûches qui claquent"
}
```

### Ambiant / arrière-plan

```python
prompts = {
    "cafe": "Ambiance de café avec conversations discrètes et machine à expresso",
    "ocean": "Vagues de l'océan sur une plage de sable, mouettes au loin",
    "city": "Rue animée de ville avec circulation, klaxons et piétons",
    "rain": "Pluie légère sur une fenêtre avec tonnerre occasionnel",
    "space": "Bourdonnement et bips à l'intérieur d'un vaisseau spatial de science-fiction"
}
```

## Options avancées

### Contrôle de la génération

```python
output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # Plus d'étapes = meilleure qualité
    cfg_scale=7,            # Respect de l'instruction (5-10)
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda",
    seed=42                 # Résultats reproductibles
)
```

### Durée variable

```python
# Effet sonore court (5 secondes)
conditioning = [{
    "prompt": "Porte qui grince en s'ouvrant lentement",
    "seconds_start": 0,
    "seconds_total": 5
}]

# Extrait moyen (30 secondes)
conditioning = [{
    "prompt": "Musique rock entraînante",
    "seconds_start": 0,
    "seconds_total": 30
}]

# Longueur maximale (47 secondes pour Open)
conditioning = [{
    "prompt": "Musique électronique ambiante, textures évolutives",
    "seconds_start": 0,
    "seconds_total": 47
}]
```

## Génération par lots

```python
import os

prompts = [
    "Morceau drum and bass énergique",
    "Mélodie de piano calme",
    "Effets sonores laser de science-fiction",
    "Pluie sur un toit en tôle"
]

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

for i, prompt in enumerate(prompts):
    conditioning = [{
        "prompt": prompt,
        "seconds_start": 0,
        "seconds_total": 15
    }]

    output = generate_diffusion_cond(
        model,
        conditioning=conditioning,
        steps=100,
        cfg_scale=7,
        sample_size=sample_size,
        sample_rate=sample_rate,
        device="cuda"
    )

    torchaudio.save(f"{output_dir}/audio_{i}.wav", output[0].T.cpu(), sample_rate)
    print(f"Généré : {prompt[:30]}...")

    torch.cuda.empty_cache()
```

## Interface Web Gradio

```python
import gradio as gr
import torch
import torchaudio
from stable_audio_tools import get_pretrained_model
from stable_audio_tools.inference.generation import generate_diffusion_cond
import tempfile

model, model_config = get_pretrained_model("stabilityai/stable-audio-open-1.0")
model = model.to("cuda")

sample_rate = model_config["sample_rate"]
sample_size = model_config["sample_size"]

def generate_audio(prompt, duration, steps, cfg_scale, seed):
    conditioning = [{
        "prompt": prompt,
        "seconds_start": 0,
        "seconds_total": duration
    }]

    generator_seed = seed if seed > 0 else None

    output = generate_diffusion_cond(
        model,
        conditioning=conditioning,
        steps=steps,
        cfg_scale=cfg_scale,
        sample_size=sample_size,
        sample_rate=sample_rate,
        device="cuda",
        seed=generator_seed
    )

    audio = output[0].T.cpu()

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, audio, sample_rate)
        return f.name

demo = gr.Interface(
    fn=generate_audio,
    inputs=[
        gr.Textbox(label="Instruction", placeholder="Décrivez l'audio que vous souhaitez..."),
        gr.Slider(1, 47, value=15, step=1, label="Durée (secondes)"),
        gr.Slider(20, 200, value=100, step=10, label="Étapes"),
        gr.Slider(1, 15, value=7, step=0.5, label="Échelle CFG"),
        gr.Number(value=-1, label="Seed (-1 pour aléatoire)")
    ],
    outputs=gr.Audio(label="Audio généré", type="filepath"),
    title="Stable Audio Open - texte vers audio",
    description="Générez de la musique et des effets sonores à partir de descriptions textuelles. Fonctionne sur CLORE.AI.",
    examples=[
        ["Musique dance électronique entraînante avec des synthés, 128 BPM", 20, 100, 7, 42],
        ["Orage avec forte pluie", 15, 100, 7, 123],
        ["Mélodie de piano paisible, émotive", 30, 100, 7, 456]
    ]
)

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

## Performances

| Durée | Étapes | GPU      | Temps  |
| ----- | ------ | -------- | ------ |
| 10 s  | 100    | RTX 3090 | \~15 s |
| 10 s  | 100    | RTX 4090 | \~10 s |
| 30 s  | 100    | RTX 3090 | \~40 s |
| 30 s  | 100    | RTX 4090 | \~25 s |
| 47 s  | 100    | RTX 4090 | \~40 s |

## Conseils de qualité

### Meilleure musique

```python
# Incluez le tempo et le style
prompt = "Musique rock énergique, guitare électrique, batterie, basse, 140 BPM, très énergique"

# Soyez précis sur les instruments
prompt = "Guitare acoustique solo en fingerpicking, style folk, chaleureuse et intime"

# Décrivez l'ambiance
prompt = "Pièce de piano mélancolique, tonalité mineure, tempo lent, émotive et triste"
```

### Meilleurs effets sonores

```python
# Soyez précis
prompt = "Coup de feu unique d'un fusil, en extérieur, avec écho"

# Incluez l'environnement
prompt = "Pas sur un plancher en bois, en intérieur, rythme lent, grincement"

# Décrivez la texture
prompt = "Feu crépitant, grand brasier, bois qui éclate, étincelles"
```

## Estimation des coûts

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

| GPU            | Tarif horaire | \~30 s de clips/heure |
| -------------- | ------------- | --------------------- |
| RTX 3060 12 Go | \~$0.03       | \~50                  |
| RTX 3090 24 Go | \~$0.06       | \~90                  |
| RTX 4090 24 Go | \~$0.10       | \~140                 |
| A100 40 Go     | \~$0.17       | \~200                 |

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

## Dépannage

### Mémoire insuffisante

```python
# Réduisez la durée
conditioning = [{
    "prompt": prompt,
    "seconds_total": 15  # Au lieu de 47
}]

# Ou activez le déchargement CPU
model.enable_model_cpu_offload()
```

### Résultat de mauvaise qualité

* Augmentez les étapes (150-200)
* Ajustez l'échelle CFG (essayez 5-10)
* Soyez plus précis dans l'instruction
* Essayez différentes graines

### Pas de son / silence

* Vérifiez que l'instruction est suffisamment descriptive
* Évitez les descriptions trop abstraites
* Essayez d'abord des instructions connues pour fonctionner

### Artefacts audio

* Augmentez les étapes
* Réduisez l'échelle CFG
* Réduisez la durée
* Vérifiez l'étranglement thermique du GPU

## Stable Audio vs les autres

| Fonctionnalité | Stable Audio | AudioCraft | Bark    |
| -------------- | ------------ | ---------- | ------- |
| Musique        | Excellent    | Excellent  | Mauvais |
| Effets sonores | Excellent    | Bon        | Mauvais |
| Parole         | Non          | Non        | Oui     |
| Durée          | 47 s / 3 min | 30 s       | 15 s    |
| Qualité        | 44.1kHz      | 32kHz      | 24kHz   |
| Ouvrez         | Partiel      | Oui        | Oui     |

**Utilisez Stable Audio lorsque :**

* Génération de musique de haute qualité
* Effets sonores pour jeux/vidéo
* Musique de fond
* Paysages sonores ambiants

## Étapes suivantes

* [AudioCraft](/guides/guides_v2-fr/audio-et-voix/audiocraft-music.md) - Génération musicale de Meta
* [Bark TTS](/guides/guides_v2-fr/audio-et-voix/bark-tts.md) - Synthèse vocale
* [Demucs](/guides/guides_v2-fr/audio-et-voix/demucs-separation.md) - Séparation audio
* [Whisper](/guides/guides_v2-fr/audio-et-voix/whisper-transcription.md) - Transcription


---

# 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/audio-et-voix/stable-audio.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.