Stable Audio

Generieren Sie Musik und Soundeffekte mit Stable Audio auf Clore.ai

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

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

Warum Stable Audio?

• Hohe Qualität - 44,1 kHz Stereo-Audiodateien erstellen

• Variable Länge - Erzeuge bis zu 95 Sekunden

• Vielseitig - Musik, Soundeffekte, Ambient-Sounds

• 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 Sek.	Gut	8GB	Öffnen
Stable Audio 2.0	3 Min.	Ausgezeichnet	12GB	Kommerziell

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-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)
"

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Hardware-Anforderungen

Modell	Minimale GPU	Empfohlen
Stable Audio Open	RTX 3070 8GB	RTX 3090 24GB
Stable Audio 2.0	RTX 3090 12GB	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": "Beschwingte elektronische Tanzmusik mit eingängiger Synth-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 entferntem 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)

Ambient-Sounds

conditioning = [{
    "prompt": "Friedliche Waldatmosphäre mit singenden Vögeln 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": "Energetischer EDM-Track mit tiefem Bass, Synth-Arpeggios und treibendem Beat, 130 BPM",
    "jazz": "Santer Jazz-Piano-Trio mit Kontrabass und Besen-Schlagzeug, entspanntes Tempo",
    "rock": "Schwerer Rock-Gitarrenriff mit Verzerrung, Schlagzeug und Bass, kraftvoll und energiegeladen",
    "classical": "Orchesterstück mit Streichern und Holzbläsern, dramatisch und cinematisch",
    "ambient": "Atmosphärische Ambient-Klanglandschaft mit Pads und subtilen Texturen, verträumt",
    "hiphop": "Lo-fi Hip-Hop-Beat mit Vinyl-Knistern, mellow Klavier und chilligem Schlagzeug, 85 BPM"
}

Soundeffekte

prompts = {
    "explosion": "Massive Explosion mit Trümmern und Feuer, cinematisch",
    "footsteps": "Schritte auf Kies, langsames Gehtempo",
    "car": "Sportwagenmotor, der aufheult und beschleunigt",
    "water": "Wasser spritzt und tropft in einer Höhle",
    "wind": "Starker Wind, der durch Berge heult",
    "fire": "Knistern eines Lagerfeuers mit knackendem Holz"
}

Ambient/Hintergrund

prompts = {
    "cafe": "Café-Atmosphäre mit leisem Geplauder und Espressomaschine",
    "ocean": "Meereswellen an einem Sandstrand, Möwen in der Ferne",
    "city": "Belebte Stadtstraße mit Verkehr, Hupen und Fußgängern",
    "rain": "Sanfter Regen am Fenster mit gelegentlichem Donner",
    "space": "Sci-Fi-Raumschiff-Innenraummotorbrummen und Pieptöne"
}

Erweiterte Optionen

Generation steuern

output = generate_diffusion_cond(
    model,
    conditioning=conditioning,
    steps=150,              # Mehr Schritte = bessere Qualität
    cfg_scale=7,            # Prompt-Einhaltung (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": "Tür, die langsam knarrend aufgeht",
    "seconds_start": 0,
    "seconds_total": 5
}]

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

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

Batch-Generierung

import os

prompts = [
    "Energetischer 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 Web-Oberflä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 Audio, das du möchtest..."),
        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 Scale"),
        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=[
        ["Beschwingte elektronische Tanzmusik mit Synths, 128 BPM", 20, 100, 7, 42],
        ["Gewitter mit starkem Regen", 15, 100, 7, 123],
        ["Friedliche 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	~10s
30 Sek.	100	RTX 3090	~40s
30 Sek.	100	RTX 4090	~25s
47 Sek.	100	RTX 4090	~40s

Qualitätstipps

Bessere Musik

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

# Sei spezifisch bei Instrumenten
prompt = "Solo-Akustikgitarre Fingerpicking, Folk-Stil, warm und intim"

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

Bessere Soundeffekte

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

# Umgebung angeben
prompt = "Schritte auf Holzfußboden, innen, langsames Tempo, knarrend"

# Textur beschreiben
prompt = "Feuer knistern, großes Lagerfeuer, Holzknacken, Funken"

Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

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

Preise variieren. Prüfe CLORE.AI Marketplace auf aktuelle Preise.

Fehlerbehebung

Kein Speicher mehr

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

# Oder CPU-Offload aktivieren
model.enable_model_cpu_offload()

Schlechte Qualität der Ausgabe

• Erhöhe die Schritte (150–200)

• Passe den CFG-Scale an (versuche 5–10)

• Sei im Prompt spezifischer

• Probiere verschiedene Seeds

Kein Klang / Stille

• Prüfe, ob der Prompt ausreichend beschreibend ist

• Vermeide sehr abstrakte Beschreibungen

• Probiere zuerst bekannte funktionierende Prompts

Audio-Artefakte

• Erhöhe die Schritte

• Senk den CFG-Scale

• Reduziere die Dauer

• Prüfe auf GPU-Drosselung durch Hitze

Stable Audio vs. Andere

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

Verwende Stable Audio, wenn:

• Hochwertige Musikgenerierung

• Soundeffekte für Spiele/Video

• Hintergrundmusik

• Ambient-Klanglandschaften

Nächste Schritte

• AudioCraft - Metas Musikgenerierung

• Bark TTS - Sprachsynthese

• Demucs - Audio-Trennung

• Whisper - Transkription