# AudioCraft Musik

Erzeuge Musik und Audio mit Metas AudioCraft (MusicGen).

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

## Mieten auf CLORE.AI

1. Besuchen Sie [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Umgebungsvariablen bei Bedarf hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden Sie in **Meine Bestellungen**
* Webschnittstellen: Verwenden Sie die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist AudioCraft?

AudioCraft umfasst:

* **MusicGen** - Text-zu-Musik-Generierung
* **AudioGen** - Erzeugung von Soundeffekten
* **EnCodec** - Audiokompression
* **MAGNeT** - Schnellere Generierung

## Modellgrößen

| Modell  | VRAM | Qualität            | Geschwindigkeit |
| ------- | ---- | ------------------- | --------------- |
| small   | 4GB  | Gut                 | Schnell         |
| medium  | 8GB  | Großartig           | Mittel          |
| groß    | 16GB | Am besten           | Langsam         |
| Melodie | 8GB  | Großartig + Melodie | Mittel          |

## Schnelle Bereitstellung

**Docker-Image:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Ports:**

```
22/tcp
7860/http
```

**Befehl:**

```bash
pip install audiocraft gradio scipy && \
python -c "
import gradio as gr
from audiocraft.models import MusicGen
import scipy.io.wavfile as wav
import tempfile

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=10)

def generate(prompt, duration):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])
    audio = output[0].cpu().numpy().T
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, 32000, audio)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[gr.Textbox(label='Prompt'), gr.Slider(5, 30, value=10, label='Dauer (s)')],
    outputs=gr.Audio(label='Generierte Musik'),
    title='MusicGen'
)
demo.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.

## Installation

```bash
pip install audiocraft
pip install scipy torchaudio
```

## MusicGen: Text-zu-Musik

### Grundlegende Generierung

```python
from audiocraft.models import MusicGen
import torchaudio

# Modell laden
model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)  # Sekunden

# Generieren
prompt = "beschwingte elektronische Tanzmusik mit starkem Bass"
output = model.generate([prompt])

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

### Mehrere Prompts

```python
prompts = [
    "entspannender Klavierjazz",
    "epische orchestrale Filmmusik",
    "akustische Gitarre Folk-Song",
    "aggressiver Heavy Metal"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"music_{i}.wav", output.cpu(), sample_rate=32000)
```

### Melodie-Bedingung

Verwende eine Melodie als Referenz:

```python
from audiocraft.models import MusicGen
import torchaudio

# Lade Melodie-Modell
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=15)

# Lade Referenzmelodie
melody, sr = torchaudio.load("reference.wav")
melody = melody.unsqueeze(0).cuda()

# Generiere mit Melodie
output = model.generate_with_chroma(
    ["Jazz-Klavier-Version"],
    melody,
    sr
)

torchaudio.save("jazz_version.wav", output[0].cpu(), sample_rate=32000)
```

### Fortsetzung

Fortsetzen von bestehendem Audio:

```python

# Lade Audio zum Fortsetzen
audio, sr = torchaudio.load("start.wav")
audio = audio.unsqueeze(0).cuda()

# Fortsetzen
output = model.generate_continuation(
    audio,
    prompt_sample_rate=sr,
    descriptions=["mehr energie mit Schlagzeug"],
    progress=True
)

torchaudio.save("continued.wav", output[0].cpu(), sample_rate=32000)
```

## AudioGen: Soundeffekte

```python
from audiocraft.models import AudioGen

# Modell laden
model = AudioGen.get_pretrained('facebook/audiogen-medium')
model.set_generation_params(duration=5)

# Erzeuge Sounds
prompts = [
    "Hund bellt in der Ferne",
    "Regen auf einem Fenster",
    "Auto startet",
    "Menschenmenge jubelt bei einem Konzert"
]

outputs = model.generate(prompts)

for i, output in enumerate(outputs):
    torchaudio.save(f"sound_{i}.wav", output.cpu(), sample_rate=16000)
```

## Generierungsparameter

```python
model.set_generation_params(
    duration=30,           # Länge in Sekunden
    top_k=250,             # Top-k Sampling
    top_p=0.0,             # Nucleus-Sampling (0 = deaktiviert)
    temperature=1.0,       # Zufälligkeit
    cfg_coef=3.0,          # Classifier-free Guidance
    two_step_cfg=False,    # Zwei-Schritt CFG
)
```

### Auswirkung der Parameter

| Parameter   | Niedriger Wert       | Hoher Wert         |
| ----------- | -------------------- | ------------------ |
| temperature | Konservativ          | Kreativ            |
| top\_k      | Fokussierter         | Mehr Vielfalt      |
| cfg\_coef   | Freie Interpretation | Strikt nach Prompt |

## Batch-Verarbeitung

```python
from audiocraft.models import MusicGen
import torchaudio
import os

model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)

prompts = [
    {"name": "intro", "prompt": "mysteriöses Ambient-Intro, langsamer Aufbau"},
    {"name": "verse", "prompt": "chiller Lo-Fi Hip-Hop-Beat"},
    {"name": "chorus", "prompt": "energetischer elektronischer Pop-Chorus"},
    {"name": "outro", "prompt": "ruhiges Klavier-Ausfaden"},
]

output_dir = "./music_parts"
os.makedirs(output_dir, exist_ok=True)

for item in prompts:
    output = model.generate([item["prompt"]])
    torchaudio.save(
        os.path.join(output_dir, f"{item['name']}.wav"),
        output[0].cpu(),
        sample_rate=32000
    )
    print(f"Generiert: {item['name']}")
```

## Streaming-Generierung

```python
from audiocraft.models import MusicGen
import torch

model = MusicGen.get_pretrained('facebook/musicgen-small')

# Streaming aktivieren
streamer = model.get_streaming_generator(
    "beschwingte Popmusik",
    max_gen_len=256  # Token
)

all_tokens = []
for tokens in streamer:
    all_tokens.append(tokens)
    # Abschnitt verarbeiten...

# Alle decodieren
audio = model.decode(torch.cat(all_tokens, dim=-1))
```

## Stereo-Generierung

```python
from audiocraft.models import MusicGen

# Lade Stereo-Modell
model = MusicGen.get_pretrained('facebook/musicgen-stereo-medium')
model.set_generation_params(duration=15)

output = model.generate(["cinematische Orchesterpartitur"])

# Ausgabeform: [batch, 2, samples] für Stereo

torchaudio.save("stereo_music.wav", output[0].cpu(), sample_rate=32000)
```

## API-Server

```python
from fastapi import FastAPI
from fastapi.responses import FileResponse
from audiocraft.models import MusicGen
import torchaudio
import tempfile

app = FastAPI()
model = MusicGen.get_pretrained('facebook/musicgen-medium')

@app.post("/generate")
async def generate_music(prompt: str, duration: int = 10):
    model.set_generation_params(duration=duration)
    output = model.generate([prompt])

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

@app.post("/generate_with_melody")
async def generate_with_melody(prompt: str, melody_path: str, duration: int = 15):
    melody, sr = torchaudio.load(melody_path)

    model_melody = MusicGen.get_pretrained('facebook/musicgen-melody')
    model_melody.set_generation_params(duration=duration)

    output = model_melody.generate_with_chroma([prompt], melody.unsqueeze(0).cuda(), sr)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        torchaudio.save(f.name, output[0].cpu(), sample_rate=32000)
        return FileResponse(f.name, media_type="audio/wav")

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Prompt-Engineering

### Wirksame Prompts

```python

# Genre + Instrumente + Stimmung
"beschwingter Jazz mit Saxophon und Klavier, fröhlich und energetisch"

# Stilreferenz
"Lo-Fi Hip-Hop-Beat, entspannte Lernmusik, Vinyl-Knistern"

# Filmisch
"epische orchestrale Trailer-Musik, steigende Spannung, dramatisch"

# Spezifische Elemente
"Akustische Gitarrenanschlagmuster, Folksong, Lagerfeuer-Atmosphäre"
```

### Schlechte Prompts

```python

# Zu vage
"schöne Musik"  # Nicht spezifisch genug

# Songtexte
"Happy Birthday to you..."  # Funktioniert nicht

# Künstlernamen
"wie Beatles"  # Versteht keine Künstler
```

## Nachbearbeitung

### Clips kombinieren

```python
from pydub import AudioSegment

intro = AudioSegment.from_wav("intro.wav")
verse = AudioSegment.from_wav("verse.wav")
chorus = AudioSegment.from_wav("chorus.wav")

# Crossfade
song = intro.append(verse, crossfade=1000)
song = song.append(chorus, crossfade=1000)

song.export("full_song.mp3", format="mp3")
```

### Effekte hinzufügen

```python
from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range

audio = AudioSegment.from_wav("generated.wav")

# Lautstärke normalisieren
audio = normalize(audio)

# Kompression hinzufügen
audio = compress_dynamic_range(audio)

# Ein-/Ausblenden
audio = audio.fade_in(2000).fade_out(3000)

audio.export("processed.wav", format="wav")
```

## Speicheroptimierung

```python
import torch
from audiocraft.models import MusicGen

# Kleineres Modell verwenden
model = MusicGen.get_pretrained('facebook/musicgen-small')

# CPU-Offload aktivieren
model.to('cpu')

# Auf GPU generieren, sofort auslagern
with torch.cuda.amp.autocast():
    output = model.generate(["prompt"])
    output = output.cpu()
    torch.cuda.empty_cache()
```

## Leistung

| Modell  | GPU      | 30s Generierung |
| ------- | -------- | --------------- |
| small   | RTX 3090 | \~10s           |
| medium  | RTX 3090 | \~25s           |
| groß    | RTX 4090 | \~45s           |
| Melodie | RTX 3090 | \~30s           |

## Vergleich

| Funktion        | MusicGen  | Stable Audio | Riffusion |
| --------------- | --------- | ------------ | --------- |
| Qualität        | Großartig | Großartig    | Gut       |
| Länge           | 30s       | 90s          | Schleife  |
| Melodie-Eingabe | Ja        | Nein         | Nein      |
| Open Source     | Ja        | Nein         | Ja        |

## Fehlerbehebung

### Kein Speicher mehr

* Verwende kleineres Modell (small statt large)
* Reduziere die Dauer
* Cache leeren: `torch.cuda.empty_cache()`

### Schlechte Qualität

* Verwende spezifischere Prompts
* Versuche ein medium- oder large-Modell
* Passe die Temperatur an (0.8-1.2)

### Wiederholende Ausgabe

* Erhöhe top\_k
* Senke cfg\_coef
* Probiere andere Prompts

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| RTX 3060  | \~$0.03     | \~$0.70   | \~$0.12           |
| RTX 3090  | \~$0.06     | \~$1.50   | \~$0.25           |
| RTX 4090  | \~$0.10     | \~$2.30   | \~$0.40           |
| A100 40GB | \~$0.17     | \~$4.00   | \~$0.70           |
| A100 80GB | \~$0.25     | \~$6.00   | \~$1.00           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen

## Nächste Schritte

* [Bark TTS](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/bark-tts) - Sprachsynthese
* [RVC-Stimmenklon](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/rvc-voice-clone) - Sprachkonversion
* [Demucs-Trennung](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/demucs-separation) - Audio-Trennung


---

# Agent Instructions: 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-stimme/audiocraft-music.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.