AudioCraft Musik

Erzeuge Musik und Audio mit Metas AudioCraft auf Clore.ai

Erzeuge Musik und Audio mit Metas AudioCraft (MusicGen).

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

Mieten auf CLORE.AI

1. Besuchen Sie 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:

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

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

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:

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:

# 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

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

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

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

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

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

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

# 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

# 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

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

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

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

• RVC-Stimmenklon - Sprachkonversion

• Demucs-Trennung - Audio-Trennung