Séparation Demucs

Séparez la musique en voix, batterie, basse et plus encore avec Demucs

Séparer la musique en stems (voix, batterie, basse, autre) avec Demucs.

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 que Demucs ?

Demucs de Meta AI peut :

• Séparer les voix de la musique

• Extraire la batterie, la basse et les autres instruments

• Traiter n’importe quel format audio

• Extraction de stems de haute qualité

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

pip install demucs gradio && \
python -c "
import gradio as gr
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torch
import torchaudio
import tempfile
import os

model = get_model('htdemucs')
model.cuda()

def separate(audio_path, stem):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = {'drums': 0, 'bass': 1, 'other': 2, 'vocals': 3}
    output = sources[stems[stem]].cpu()

    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        torchaudio.save(f.name, output, sr)
        return f.name

demo = gr.Interface(
    fn=separate,
    inputs=[gr.Audio(type='filepath'), gr.Dropdown(['vocals', 'drums', 'bass', 'other'])],
    outputs=gr.Audio(),
    title='Séparateur audio Demucs'
)
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 demucs

# ou
pip install -e git+https://github.com/facebookresearch/demucs#egg=demucs

Utilisation en ligne de commande

Séparation de base

# Séparer en 4 stems
demucs song.mp3

# Sortie : separated/htdemucs/song/{drums,bass,other,vocals}.wav

Options

demucs \
    --two-stems vocals \     # Uniquement voix + instrumental
    -n htdemucs \            # Nom du modèle
    -d cuda \                # Utiliser le GPU
    -o ./output \            # Dossier de sortie
    --mp3 \                  # Sortie en MP3
    song.mp3

Traiter un dossier

demucs --two-stems vocals -d cuda ./songs/*.mp3

API Python

Séparation de base

from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch

# Charger le modèle
model = get_model('htdemucs')
model.cuda()
model.eval()

# Charger l’audio
wav, sr = torchaudio.load("song.mp3")
wav = wav.cuda()

# Séparer
with torch.no_grad():
    sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

# sources shape: [4, channels, samples]

# 0: batterie, 1: basse, 2: autre, 3: voix

# Enregistrer les stems
stems = ['drums', 'bass', 'other', 'vocals']
for i, stem in enumerate(stems):
    torchaudio.save(f"{stem}.wav", sources[i].cpu(), sr)

Obtenir uniquement les voix

def extract_vocals(audio_path):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    vocals = sources[3].cpu()  # Index 3 = voix
    return vocals, sr

vocals, sr = extract_vocals("song.mp3")
torchaudio.save("vocals.wav", vocals, sr)

Obtenir l’instrumental (sans voix)

def extract_instrumental(audio_path):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # Additionner batterie + basse + autre
    instrumental = sources[0] + sources[1] + sources[2]
    return instrumental.cpu(), sr

instrumental, sr = extract_instrumental("song.mp3")
torchaudio.save("instrumental.wav", instrumental, sr)

Variantes de modèle

Modèle	Stems	Qualité	Vitesse
htdemucs	4	Meilleur	Moyen
htdemucs_ft	4	Best+	Lent
htdemucs_6s	6	Excellent	Moyen
mdx_extra	4	Excellent	Rapide

Modèle à 6 stems

model = get_model('htdemucs_6s')

# Stems : batterie, basse, autre, voix, guitare, piano

Modèle affiné

model = get_model('htdemucs_ft')

# Meilleure qualité, mais plus lent

Traitement par lots

import os
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch

model = get_model('htdemucs')
model.cuda()
model.eval()

input_dir = "./songs"
output_dir = "./separated"

for filename in os.listdir(input_dir):
    if filename.endswith(('.mp3', '.wav', '.flac')):
        input_path = os.path.join(input_dir, filename)
        song_output_dir = os.path.join(output_dir, filename.rsplit('.', 1)[0])
        os.makedirs(song_output_dir, exist_ok=True)

        print(f"Traitement : {filename}")

        wav, sr = torchaudio.load(input_path)
        wav = wav.cuda()

        with torch.no_grad():
            sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

        stems = ['drums', 'bass', 'other', 'vocals']
        for i, stem in enumerate(stems):
            torchaudio.save(
                os.path.join(song_output_dir, f"{stem}.wav"),
                sources[i].cpu(),
                sr
            )

        print(f"Enregistré : {song_output_dir}")

Serveur API

from fastapi import FastAPI, UploadFile
from fastapi.responses import FileResponse
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch
import tempfile
import os

app = FastAPI()

model = get_model('htdemucs')
model.cuda()
model.eval()

@app.post("/separate")
async def separate(file: UploadFile, stem: str = "vocals"):
    # Enregistrer le fichier téléchargé
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    # Charger et séparer
    wav, sr = torchaudio.load(tmp_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = {'drums': 0, 'bass': 1, 'other': 2, 'vocals': 3}
    output = sources[stems[stem]].cpu()

    # Enregistrer la sortie
    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
        torchaudio.save(out.name, output, sr)
        return FileResponse(out.name, media_type="audio/wav")

@app.post("/instrumental")
async def get_instrumental(file: UploadFile):
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    wav, sr = torchaudio.load(tmp_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # Combiner les stems sans voix
    instrumental = sources[0] + sources[1] + sources[2]

    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
        torchaudio.save(out.name, instrumental.cpu(), sr)
        return FileResponse(out.name, media_type="audio/wav")

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

Optimisation de la mémoire

Pour les longs audios

from demucs.apply import apply_model

# Utiliser le découpage pour les longs audios
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,         # Découper en segments
    overlap=0.25,       # Chevauchement entre les segments
    progress=True
)[0]

Pour une VRAM limitée

# Utiliser le CPU pour certaines opérations
model.cpu()
wav = wav.cpu()

# Ou utiliser le traitement par segments
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,
    segment=10  # segments de 10 secondes
)[0]

Cas d’usage

Piste de karaoké

def create_karaoke(song_path):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # Tout sauf les voix
    karaoke = sources[0] + sources[1] + sources[2]
    return karaoke.cpu(), sr

Préparation d’un remix

def extract_all_stems(song_path, output_dir):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = ['drums', 'bass', 'other', 'vocals']
    paths = {}

    for i, stem in enumerate(stems):
        path = os.path.join(output_dir, f"{stem}.wav")
        torchaudio.save(path, sources[i].cpu(), sr)
        paths[stem] = path

    return paths

Extraction d’acapella

def extract_acapella(song_path):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    vocals = sources[3]
    return vocals.cpu(), sr

Conseils de qualité

Pour de meilleurs résultats

• Utiliser une entrée sans perte (WAV, FLAC)

• Un taux d’échantillonnage plus élevé = meilleure qualité

• Utilisez htdemucs_ft pour les travaux critiques

Post-traitement

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

# Charger la voix séparée
vocals = AudioSegment.from_wav("vocals.wav")

# Supprimer les basses fréquences parasites
vocals = high_pass_filter(vocals, 80)

# Normaliser
vocals = normalize(vocals)

vocals.export("vocals_clean.wav", format="wav")

Performances

Durée audio	GPU	Temps
chanson de 3 min	RTX 3090	~15s
chanson de 3 min	RTX 4090	~10 s
chanson de 3 min	A100	~8 s
album d’1 heure	RTX 3090	~5 min

Dépannage

Mémoire insuffisante

# Utiliser des segments plus petits
demucs --segment 10 song.mp3

Séparation médiocre

• Utiliser le modèle htdemucs_ft

• Vérifier la qualité de l’entrée

• Éviter les MP3 fortement compressés

Artefacts

• Augmenter le chevauchement

• Utiliser un modèle de meilleure qualité

• Vérifier la présence d’écrêtage dans l’entrée

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

• Clonage vocal RVC - Traiter les voix extraites

• Musique AudioCraft - Générer de la nouvelle musique

• Whisper Transcription - Transcrire les voix