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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

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 :

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

pip install stable-audio-tools torch torchaudio

Utilisation de base

Texte vers musique

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

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

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

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

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

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

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

# 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

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

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

# 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

# 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 les tarifs actuels.

Dépannage

Mémoire insuffisante

# 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 - Génération musicale de Meta

• Bark TTS - Synthèse vocale

• Demucs - Séparation audio

• Whisper - Transcription