Stable Audio

Generiere Musik und Soundeffekte mit Stable Audio auf Clore.ai

Erzeuge Musik und Soundeffekte mit Stable Audio von Stability AI auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Warum Stable Audio?

• Hohe Qualität - 44,1-kHz-Stereo-Audioerzeugung

• Variable Länge - Erzeuge bis zu 95 Sekunden

• Vielseitig - Musik, Soundeffekte, Umgebungsgeräusche

• Text-zu-Audio - Beschreibe, was du hören möchtest

• Offene Gewichte - Stable Audio Open verfügbar

Modellvarianten

Modell	Dauer	Qualität	VRAM	Lizenz
Stable Audio Open	47 s	Gut	8 GB	Öffnen
Stable Audio 2.0	3 Min.	Hervorragend	12 GB	Kommerziell nutzbar

Schnellbereitstellung auf CLORE.AI

Docker-Image:

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

Ports:

22/tcp
7860/http

Befehl:

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='Dauer (Sek.)'),
        gr.Slider(10, 150, value=100, label='Schritte'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Audio(label='Generiertes Audio'),
    title='Stable Audio Open'
).launch(server_name='0.0.0.0', server_port=7860)
"

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Hardware-Anforderungen

Modell	Minimale GPU	Empfohlen
Stable Audio Open	RTX 3070 8GB	RTX 3090 24 GB
Stable Audio 2.0	RTX 3090 12 GB	RTX 4090 24GB

Installation

pip install stable-audio-tools torch torchaudio

Grundlegende Verwendung

Text zu Musik

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

# Modell laden
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"]

# Definiere, was du möchtest
conditioning = [{
    "prompt": "Mitreißende elektronische Tanzmusik mit eingängiger Synthesizer-Melodie, 128 BPM",
    "seconds_start": 0,
    "seconds_total": 30
}]

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

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

Soundeffekte

conditioning = [{
    "prompt": "Gewitter mit starkem Regen und fernem Donner",
    "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)

Umgebungsgeräusche

conditioning = [{
    "prompt": "Friedliche Waldatmosphäre mit Vogelgesang und sanftem Wind",
    "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)

Prompt-Beispiele

Musikgenres

prompts = {
    "electronic": "Energischer EDM-Track mit tiefem Bass, Synth-Arpeggios und treibendem Beat, 130 BPM",
    "jazz": "Smooth-Jazz-Klaviertrio mit Kontrabass und Besen-Drums, entspanntes Tempo",
    "rock": "Kraftvolles und energiegeladenes Rock-Gitarrenriff mit Verzerrung, Schlagzeug und Bass",
    "classical": "Orchesterstück mit Streichern und Holzbläsern, dramatisch und kinoreif",
    "ambient": "Atmosphärische Ambient-Klanglandschaft mit Flächen und subtilen Texturen, verträumt",
    "hiphop": "Lo-Fi-Hip-Hop-Beat mit Vinyl-Knistern, sanftem Klavier und entspannten Drums, 85 BPM"
}

Soundeffekte

prompts = {
    "explosion": "Massive Explosion mit Trümmern und Feuer, kinoreif",
    "footsteps": "Schritte auf Kies, langsames Gehtempo",
    "car": "Motor eines Sportwagens, aufheulend und beschleunigend",
    "water": "Wasser, das in einer Höhle spritzt und tropft",
    "wind": "Starker Wind, der durch die Berge heult",
    "fire": "Prasselndes Lagerfeuer mit knisterndem Holz"
}

Ambient/Hintergrund

prompts = {
    "cafe": "Atmosphäre eines Cafés mit leisen Gesprächen und Espressomaschine",
    "ocean": "Ozeanwellen an einem Sandstrand, Möwen in der Ferne",
    "city": "Belebte Innenstadtstraße mit Verkehr, Hupen und Fußgängern",
    "rain": "Sanfter Regen am Fenster mit gelegentlichem Donner",
    "space": "Summen und Pieptöne im Inneren eines Sci-Fi-Raumschiffs"
}

Erweiterte Optionen

Steuerung der Generierung

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # Mehr Schritte = bessere Qualität
    cfg_scale=7,            # Befolgung des Prompts (5-10)
    sample_size=sample_size,
    sample_rate=sample_rate,
    device="cuda",
    seed=42                 # Reproduzierbare Ergebnisse
)

Variable Länge

# Kurzer Soundeffekt (5 Sekunden)
conditioning = [{
    "prompt": "Eine Tür knarrt langsam auf",
    "seconds_start": 0,
    "seconds_total": 5
}]

# Mittlerer Clip (30 Sekunden)
conditioning = [{
    "prompt": "Mitreißende Rockmusik",
    "seconds_start": 0,
    "seconds_total": 30
}]

# Maximale Länge (47 Sekunden für Open)
conditioning = [{
    "prompt": "Ambient-Elektronikmusik, sich entwickelnde Texturen",
    "seconds_start": 0,
    "seconds_total": 47
}]

Batch-Generierung

import os

prompts = [
    "Energischer Drum-and-Bass-Track",
    "Ruhige Klaviermelodie",
    "Sci-Fi-Laser-Soundeffekte",
    "Regen auf einem Blechdach"
]

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"Generiert: {prompt[:30]}...")

    torch.cuda.empty_cache()

Gradio-Weboberfläche

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="Beschreibe das gewünschte Audio..."),
        gr.Slider(1, 47, value=15, step=1, label="Dauer (Sekunden)"),
        gr.Slider(20, 200, value=100, step=10, label="Schritte"),
        gr.Slider(1, 15, value=7, step=0.5, label="CFG-Skala"),
        gr.Number(value=-1, label="Seed (-1 für zufällig)")
    ],
    outputs=gr.Audio(label="Generiertes Audio", type="filepath"),
    title="Stable Audio Open - Text zu Audio",
    description="Erzeuge Musik und Soundeffekte aus Textbeschreibungen. Läuft auf CLORE.AI.",
    examples=[
        ["Mitreißende elektronische Tanzmusik mit Synths, 128 BPM", 20, 100, 7, 42],
        ["Gewitter mit starkem Regen", 15, 100, 7, 123],
        ["Ruhige Klaviermelodie, emotional", 30, 100, 7, 456]
    ]
)

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

Leistung

Dauer	Schritte	GPU	Zeit
10 Sek.	100	RTX 3090	~15s
10 Sek.	100	RTX 4090	~10 s
30 Sek.	100	RTX 3090	~40 s
30 Sek.	100	RTX 4090	~25 s
47 s	100	RTX 4090	~40 s

Qualitätstipps

Bessere Musik

# Tempo und Stil angeben
prompt = "Energiegeladene Rockmusik, E-Gitarre, Schlagzeug, Bass, 140 BPM, hohe Energie"

# Sei spezifisch bei den Instrumenten
prompt = "Fingerpicking auf einer akustischen Sologitarre, Folk-Stil, warm und intim"

# Beschreibe die Stimmung
prompt = "Melancholisches Klavierstück, Molltonart, langsames Tempo, emotional und traurig"

Bessere Soundeffekte

# Sei spezifisch
prompt = "Einzelschuss aus einem Gewehr, draußen, Echo"

# Gib die Umgebung an
prompt = "Schritte auf einem Holzboden, drinnen, langsames Tempo, Knarren"

# Beschreibe die Textur
prompt = "Feuerknistern, großes Lagerfeuer, knisterndes Holz, Funken"

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

GPU	Stundensatz	~30-Sek.-Clips/Stunde
RTX 3060 12 GB	~$0.03	~50
RTX 3090 24 GB	~$0.06	~90
RTX 4090 24GB	~$0.10	~140
A100 40GB	~$0.17	~200

Preise variieren. Prüfe CLORE.AI-Marktplatz für aktuelle Preise.

Fehlerbehebung

Speicher erschöpft

# Dauer reduzieren
conditioning = [{
    "prompt": prompt,
    "seconds_total": 15  # Statt 47
}]

# Oder CPU-Offload aktivieren
model.enable_model_cpu_offload()

Ausgabe von schlechter Qualität

• Schritte erhöhen (150-200)

• CFG-Skala anpassen (versuche 5-10)

• Im Prompt spezifischer sein

• Verschiedene Seeds ausprobieren

Kein Ton / Stille

• Prüfe, ob der Prompt ausreichend beschreibend ist

• Sehr abstrakte Beschreibungen vermeiden

• Versuche zuerst bewährte Prompts

Audio-Artefakte

• Schritte erhöhen

• CFG-Skala verringern

• Dauer reduzieren

• Auf thermisches Drosseln der GPU prüfen

Stable Audio im Vergleich zu anderen

Funktion	Stable Audio	AudioCraft	Bark
Musik	Hervorragend	Hervorragend	Schlecht
Soundeffekte	Großartig	Gut	Schlecht
Sprache	Nein	Nein	Ja
Dauer	47 s / 3 Min.	30 s	15 s
Qualität	44,1 kHz	32 kHz	24 kHz
Öffnen	Teilweise	Ja	Ja

Verwende Stable Audio, wenn:

• Hochwertige Musikgenerierung

• Soundeffekte für Spiele/Videos

• Hintergrundmusik

• Atmosphärische Klanglandschaften

Nächste Schritte

• AudioCraft - Metas Musikgenerierung

• Bark TTS - Sprachsynthese

• Demucs - Audiotrennung

• Whisper - Transkription