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 CLORE.AI Marketplace.

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 :

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

pip install stable-audio-tools torch torchaudio

Utilisation de base

Texte en 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 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

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

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

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

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

# 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

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

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

# 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

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

Dépannage

Mémoire insuffisante

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

• Bark TTS - Synthèse vocale

• Demucs - Séparation audio

• Whisper - Transcription