> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/stable-audio.md).

# 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](/guides/guides_v2-de/audio-and-sprache/audiocraft-music.md) - Metas Musikgenerierung
* [Bark TTS](/guides/guides_v2-de/audio-and-sprache/bark-tts.md) - Sprachsynthese
* [Demucs](/guides/guides_v2-de/audio-and-sprache/demucs-separation.md) - Audio-Trennung
* [Whisper](/guides/guides_v2-de/audio-and-sprache/whisper-transcription.md) - Transkription


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/stable-audio.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.