# Stable Audio

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

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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:**

```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='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

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

## Grundlegende Verwendung

### Text zu Musik

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
# 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

```python
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

```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="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

```python
# 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

```python
# 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*](https://clore.ai/marketplace) *auf aktuelle Preise.*

## Fehlerbehebung

### Kein Speicher mehr

```python
# 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](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/audiocraft-music) - Metas Musikgenerierung
* [Bark TTS](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/bark-tts) - Sprachsynthese
* [Demucs](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/demucs-separation) - Audio-Trennung
* [Whisper](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/whisper-transcription) - Transkription