AudioCraft-Musik

Generiere Musik und Audio mit Metas AudioCraft auf Clore.ai

Musik und Audio mit Metas AudioCraft (MusicGen) generieren.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist AudioCraft?

AudioCraft umfasst:

• MusicGen - Text-zu-Musik-Generierung

• AudioGen - Generierung von Soundeffekten

• EnCodec - Audiokomprimierung

• MAGNeT - Schnellere Generierung

Modellgrößen

Modell	VRAM	Qualität	Geschwindigkeit
klein	4 GB	Gut	Schnell
mittel	8 GB	Großartig	Mittel
groß	16 GB	Am besten	Langsam
Melodie	8 GB	Großartig + Melodie	Mittel

Schnell bereitstellen

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

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='Eingabeaufforderung'), 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)
"

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.

Installation

pip install audiocraft
pip install scipy torchaudio

MusicGen: Text-zu-Musik

Grundlegende Generierung

from audiocraft.models import MusicGen
import torchaudio

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

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

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

Mehrere Eingaben

prompts = [
    "entspannender Piano-Jazz",
    "epische orchestrale Filmmusik",
    "akustischer Gitarren-Folksong",
    "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-Konditionierung

Verwenden Sie eine Melodie als Referenz:

from audiocraft.models import MusicGen
import torchaudio

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

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

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

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

Fortsetzung

Von bestehendem Audio fortsetzen:

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

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

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

AudioGen: Soundeffekte

from audiocraft.models import AudioGen

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

# Geräusche generieren
prompts = [
    "bellender Hund in der Ferne",
    "Regen an einem Fenster",
    "Autotor startet",
    "jubelnde Menge 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

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,          # Führung ohne Klassifikator
    two_step_cfg=False,    # Zweistufiges CFG
)

Parameterauswirkungen

Parameter	Niedriger Wert	Hoher Wert
temperature	Konservativ	Kreativ
top_k	Fokussierter	Mehr Vielfalt
cfg_coef	Lockere Interpretation	Streng am Prompt

Batch-Verarbeitung

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": "entspannter Lo-Fi-Hip-Hop-Beat"},
    {"name": "chorus", "prompt": "energetischer elektronischer Pop-Refrain"},
    {"name": "outro", "prompt": "sanftes Piano-Ausblenden"},
]

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

from audiocraft.models import MusicGen
import torch

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

# Streaming aktivieren
streamer = model.get_streaming_generator(
    "mitreißende Popmusik",
    max_gen_len=256  # Tokens
)

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

# Alles dekodieren
audio = model.decode(torch.cat(all_tokens, dim=-1))

Stereo-Generierung

from audiocraft.models import MusicGen

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

output = model.generate(["kinematische orchestrale Filmmusik"]))

# Ausgabeform: [Batch, 2, Samples] für Stereo

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

API-Server

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

Effektive Prompts

# Genre + Instrumente + Stimmung
"mitreißender Jazz mit Saxophon und Klavier, fröhlich und energiegeladen"

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

# Kinematisch
"epische orchestrale Trailer-Musik, zunehmende Spannung, dramatisch"

# Spezifische Elemente
"Muster des akustischen Gitarrenschlagens, Folksong, Lagerfeuer-Vibes"

Schlechte Prompts

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

# Songtexte
"Zum Geburtstag viel Glück..."  # Funktioniert nicht

# Künstlernamen
"wie Beatles"  # Versteht Künstler nicht

Nachbearbeitung

Clips kombinieren

from pydub import AudioSegment

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

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

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

Effekte hinzufügen

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

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

# Lautstärke normalisieren
audio = normalize(audio)

# Komprimierung hinzufügen
audio = compress_dynamic_range(audio)

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

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

Speicheroptimierung

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	30-Sekunden-Generierung
klein	RTX 3090	~10 s
mittel	RTX 3090	~25 s
groß	RTX 4090	~45s
Melodie	RTX 3090	~30s

Vergleich

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

Fehlerbehebung

Speicher erschöpft

• Verwenden Sie ein kleineres Modell (klein statt groß)

• Dauer reduzieren

• Cache leeren: torch.cuda.empty_cache()

Schlechte Qualität

• Spezifischere Prompts verwenden

• Versuchen Sie ein mittleres oder großes Modell

• Temperatur anpassen (0,8-1,2)

Wiederholte Ausgabe

• top_k erhöhen

• cfg_coef senken

• Verschiedene Prompts ausprobieren

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• Bark TTS - Spracherzeugung

• RVC-Sprachklon - Stimmumwandlung

• Demucs-Trennung - Audiotrennung