# 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