> 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 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 [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Pourquoi Stable Audio ?

* **Haute qualité** - Génération audio stéréo 44,1 kHz
* **Durée variable** - Générer jusqu'à 95 secondes
* **Polyvalent** - Musique, effets sonores, ambiances
* **Texte en 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 | Ouvrir     |
| Stable Audio 2.0  | 3 min | Excellent | 12Go | Commercial |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-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='Prompt'),
        gr.Slider(1, 47, value=10, label='Duration (sec)'),
        gr.Slider(10, 150, value=100, label='Steps'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Audio(label='Generated Audio'),
    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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

## Exigences matérielles

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

## Installation

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

## Utilisation de base

### Texte en 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 forestière paisible avec chants d'oiseaux et vent léger",
    "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 de prompts

### Genres musicaux

```python
prompts = {
    "electronic": "Titre EDM énergique avec basse profonde, arpèges de synthé et rythme entraînant, 130 BPM",
    "jazz": "Trio jazz piano doux avec contrebasse et batterie aux balais, tempo détendu",
    "rock": "Riff de guitare rock lourd avec distorsion, batterie et basse, puissant et énergique",
    "classical": "Pièce orchestrale avec cordes et bois, dramatique et cinématographique",
    "ambient": "Paysage sonore ambient atmosphérique avec nappes et textures subtiles, onirique",
    "hiphop": "Beat lo-fi hip hop avec craquement 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 gravier, allure de marche lente",
    "car": "Moteur de voiture sportive vrombissant et accélérant",
    "water": "Eau éclaboussant et gouttant dans une grotte",
    "wind": "Vent fort hurlant à travers les montagnes",
    "fire": "Feu de camp crépitant avec bois qui saute"
}
```

### Ambiance / Fond

```python
prompts = {
    "cafe": "Ambiance de café avec conversations calmes et machine à expresso",
    "ocean": "Vagues océaniques sur une plage de sable, mouettes au loin",
    "city": "Rue urbaine animée avec trafic, klaxons et piétons",
    "rain": "Pluie douce sur une fenêtre avec tonnerre occasionnel",
    "space": "Bourdonnement et bip d'un intérieur de vaisseau spatial de science-fiction"
}
```

## Options avancées

### Contrôler la génération

```python
output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # Plus de pas = meilleure qualité
    cfg_scale=7,            # Adhérence au prompt (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
}]

# Clip 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 ambient, textures évolutives",
    "seconds_start": 0,
    "seconds_total": 47
}]
```

## Génération par lot

```python
import os

prompts = [
    "Energetic drum and bass track",
    "Calm piano melody",
    "Sci-fi laser sound effects",
    "Rain on a tin roof"
]

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="Prompt", placeholder="Décrivez l'audio que vous voulez..."),
        gr.Slider(1, 47, value=15, step=1, label="Durée (secondes)"),
        gr.Slider(20, 200, value=100, step=10, label="Pas"),
        gr.Slider(1, 15, value=7, step=0.5, label="Échelle CFG"),
        gr.Number(value=-1, label="Graine (-1 pour aléatoire)")
    ],
    outputs=gr.Audio(label="Audio généré", type="filepath"),
    title="Stable Audio Open - Texte en audio",
    description="Générez de la musique et des effets sonores à partir de descriptions textuelles. Exécution sur CLORE.AI.",
    examples=[
        ["Upbeat electronic dance music with synths, 128 BPM", 20, 100, 7, 42],
        ["Thunderstorm with heavy rain", 15, 100, 7, 123],
        ["Peaceful piano melody, emotional", 30, 100, 7, 456]
    ]
)

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

## Performances

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

## Conseils de qualité

### Meilleure musique

```python
# Inclure le tempo et le style
prompt = "Musique rock énergique, guitare électrique, batterie, basse, 140 BPM, haute énergie"

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

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

### Meilleurs effets sonores

```python
# Soyez précis
prompt = "Unique coup de feu d'un fusil, extérieur, écho"

# Inclure l'environnement
prompt = "Pas sur un plancher en bois, intérieur, cadence lente, qui grince"

# Décrivez la texture
prompt = "Feu qui crépite, grand feu de joie, bois qui saute, étincelles"
```

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

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

*Les prix varient. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

## Dépannage

### Mémoire insuffisante

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

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

### Mauvaise qualité de sortie

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

### Pas de son / Silence

* Vérifiez que le prompt est suffisamment descriptif
* Évitez les descriptions très abstraites
* Essayez d'abord des prompts connus fonctionnels

### Artefacts audio

* Augmentez les pas
* Diminuez l'échelle CFG
* Réduisez la durée
* Vérifiez le throttling thermique du GPU

## Stable Audio vs Autres

| Fonction | Stable Audio | AudioCraft | Bark   |
| -------- | ------------ | ---------- | ------ |
| Musique  | Excellent    | Excellent  | Faible |
| SFX      | Excellent    | Bon        | Faible |
| Parole   | Non          | Non        | Oui    |
| Durée    | 47 s / 3 min | 30 s       | 15 s   |
| Qualité  | 44,1 kHz     | 32 kHz     | 24 kHz |
| Ouvrir   | 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 d'ambiance

## Prochaines étapes

* [AudioCraft](/guides/guides_v2-fr/audio-et-voix/audiocraft-music.md) - Génération de musique 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/stable-audio.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.