Musique AudioCraft

Générez de la musique et de l'audio avec AudioCraft de Meta sur Clore.ai

Générez de la musique et de l'audio avec AudioCraft de Meta (MusicGen).

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

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

Qu'est-ce qu'AudioCraft ?

AudioCraft comprend :

• MusicGen - Génération de texte en musique

• AudioGen - Génération d'effets sonores

• EnCodec - Compression audio

• MAGNeT - Génération plus rapide

Tailles des modèles

Modèle	VRAM	Qualité	Vitesse
petit	4 Go	Bon	Rapide
moyen	8 Go	Excellent	Moyen
grand	16 Go	Meilleur	Lent
mélodie	8 Go	Excellent + mélodie	Moyen

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

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='Invite'), gr.Slider(5, 30, value=10, label='Durée (s)')],
    outputs=gr.Audio(label='Musique générée'),
    title='MusicGen'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

pip install audiocraft
pip install scipy torchaudio

MusicGen : texte en musique

Génération de base

from audiocraft.models import MusicGen
import torchaudio

# Charger le modèle
model = MusicGen.get_pretrained('facebook/musicgen-medium')
model.set_generation_params(duration=15)  # secondes

# Générer
"musique de danse électronique entraînante avec des basses puissantes"
output = model.generate([prompt])

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

Plusieurs invites

prompts = [
    "jazz piano relaxant",
    "cinématographique orchestral épique",
    "chanson folk à la guitare acoustique",
    "heavy metal agressif"
]

outputs = model.generate(prompts)

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

Conditionnement par mélodie

Utilisez une mélodie comme référence :

from audiocraft.models import MusicGen
import torchaudio

# Charger le modèle de mélodie
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=15)

# Charger la mélodie de référence
melody, sr = torchaudio.load("reference.wav")
melody = melody.unsqueeze(0).cuda()

# Générer avec la mélodie
output = model.generate_with_chroma(
    ["version piano jazz"],
    melody,
    sr
)

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

Continuation

Continuer à partir de l'audio existant :

# Charger l'audio à continuer
audio, sr = torchaudio.load("start.wav")
audio = audio.unsqueeze(0).cuda()

# Continuer
output = model.generate_continuation(
    audio,
    prompt_sample_rate=sr,
    descriptions=["plus énergique avec des percussions"],
    progress=True
)

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

AudioGen : effets sonores

from audiocraft.models import AudioGen

# Charger le modèle
model = AudioGen.get_pretrained('facebook/audiogen-medium')
model.set_generation_params(duration=5)

# Générer des sons
prompts = [
    "aboiements d'un chien au loin",
    "pluie sur une fenêtre",
    "démarrage du moteur d'une voiture",
    "foule applaudissant à un concert"
]

outputs = model.generate(prompts)

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

Paramètres de génération

model.set_generation_params(
    duration=30,           # Durée en secondes
    top_k=250,             # Échantillonnage top-k
    top_p=0.0,             # Échantillonnage nucleus (0 = désactivé)
    temperature=1.0,       # Aléatoire
    cfg_coef=3.0,          # Guidage sans classificateur
    two_step_cfg=False,    # CFG en deux étapes
)

Effets des paramètres

Paramètre	Valeur faible	Valeur élevée
temperature	Conservateur	Créatif
top_k	Plus ciblé	Plus de variété
cfg_coef	Interprétation souple	Strictement fidèle à l'invite

Traitement par lots

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": "introduction ambient mystérieuse, montée lente"},
    {"name": "verse", "prompt": "rythme hip-hop lo-fi relax"},
    {"name": "chorus", "prompt": "refrain pop électronique énergique"},
    {"name": "outro", "prompt": "fondu final calme au piano"},
]

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"Généré : {item['name']}")

Génération en streaming

from audiocraft.models import MusicGen
import torch

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

# Activer le streaming
streamer = model.get_streaming_generator(
    "musique pop entraînante",
    max_gen_len=256  # jetons
)

all_tokens = []
for tokens in streamer:
    all_tokens.append(tokens)
    # Traiter le lot...

# Tout décoder
audio = model.decode(torch.cat(all_tokens, dim=-1))

Génération stéréo

from audiocraft.models import MusicGen

# Charger le modèle stéréo
model = MusicGen.get_pretrained('facebook/musicgen-stereo-medium')
model.set_generation_params(duration=15)

output = model.generate(["bande originale orchestrale cinématographique"])

# Forme de sortie : [batch, 2, samples] pour la stéréo

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

Serveur API

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

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000

Ingénierie des invites

Invites efficaces

# Genre + instruments + ambiance
"jazz entraînant avec saxophone et piano, joyeux et énergique"

# Référence de style
"rythme hip-hop lo-fi, musique d'étude relaxante, crépitement de vinyle"

# Cinématographique
"musique de bande-annonce orchestrale épique, tension croissante, dramatique"

# Éléments spécifiques
"motif de grattement de guitare acoustique, chanson folk, ambiance feu de camp"

Mauvais prompts

# Trop vague
"jolie musique"  # Pas assez spécifique

# Paroles de chanson
"Joyeux anniversaire à toi..."  # Ne fonctionnera pas

# Noms d'artistes
"comme les Beatles"  # Ne comprend pas les artistes

Post-traitement

Combiner les clips

from pydub import AudioSegment

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

# Fondu enchaîné
song = intro.append(verse, crossfade=1000)
song = song.append(chorus, crossfade=1000)

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

Ajouter des effets

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

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

# Normaliser le volume
audio = normalize(audio)

# Ajouter de la compression
audio = compress_dynamic_range(audio)

# Fondu entrant/sortant
audio = audio.fade_in(2000).fade_out(3000)

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

Optimisation de la mémoire

import torch
from audiocraft.models import MusicGen

# Utiliser un modèle plus petit
model = MusicGen.get_pretrained('facebook/musicgen-small')

# Activer le déchargement sur CPU
model.to('cpu')

# Générer sur le GPU, décharger immédiatement
with torch.cuda.amp.autocast():
    output = model.generate(["invite"])
    output = output.cpu()
    torch.cuda.empty_cache()

Performances

Modèle	GPU	Génération de 30 s
petit	RTX 3090	~10 s
moyen	RTX 3090	~25 s
grand	RTX 4090	~45 s
mélodie	RTX 3090	~30s

Comparaison

Fonctionnalité	MusicGen	Stable Audio	Riffusion
Qualité	Excellent	Excellent	Bon
Durée	30 s	90 s	Boucle
Entrée de mélodie	Oui	Non	Non
Open source	Oui	Non	Oui

Dépannage

Mémoire insuffisante

• Utilisez un modèle plus petit (small au lieu de large)

• Réduisez la durée

• Vider le cache : torch.cuda.empty_cache()

Qualité médiocre

• Utilisez des invites plus spécifiques

• Essayez un modèle medium ou large

• Ajustez la température (0,8-1,2)

Sortie répétitive

• Augmentez top_k

• Baissez cfg_coef

• Essayez d'autres invites

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Bark TTS - Génération vocale

• Clonage vocal RVC - Conversion vocale

• Séparation Demucs - Séparation audio