> 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-stimme/stable-audio.md).

# 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## Fehlerbehebung

### Speicher erschöpft

```python
# 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](/guides/guides_v2-de/audio-and-stimme/audiocraft-music.md) - Metas Musikgenerierung
* [Bark TTS](/guides/guides_v2-de/audio-and-stimme/bark-tts.md) - Sprachsynthese
* [Demucs](/guides/guides_v2-de/audio-and-stimme/demucs-separation.md) - Audiotrennung
* [Whisper](/guides/guides_v2-de/audio-and-stimme/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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.