Séparation Demucs

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

Séparez la musique en stems (voix, batterie, basse, autres) avec Demucs.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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@<adresse-proxy>

Qu'est-ce que Demucs ?

Demucs par Meta AI peut :

Séparer les voix de la musique
Extraire la batterie, la basse et les autres instruments
Traiter tout format audio
Extraction de stems de haute qualité

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-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='Demucs Audio Separator'
)
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:

Aller à la Mes commandes page
Cliquez sur votre commande
Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_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 basique


# Séparer en 4 stems
demucs song.mp3

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

Options

demucs \
    --two-stems vocals \     # Seulement voix + instrumental
    -n htdemucs \            # Nom du modèle
    -d cuda \                # Utiliser le GPU
    -o ./output \            # Répertoire de sortie
    --mp3 \                  # Sortie au format MP3
    song.mp3

Traiter un dossier

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

API Python

Séparation basique

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]

# forme de sources : [4, channels, samples]

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

# Sauvegarder 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 + autres
    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

Meilleur

Moyen

htdemucs_ft

Best+

Lent

htdemucs_6s

Excellent

Moyen

mdx_extra

Excellent

Rapide

Modèle 6 stems

model = get_model('htdemucs_6s')

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

Modèle affiné

model = get_model('htdemucs_ft')

# Qualité supérieure 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"):
    # Sauvegarder le fichier téléversé
    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()

    # Sauvegarder 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 non vocaux
    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")

# Lancer : uvicorn server:app --host 0.0.0.0 --port 8000

Optimisation de la mémoire

Pour les longs fichiers audio

from demucs.apply import apply_model

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

Pour VRAM limitée


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

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

Cas d'utilisation

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

Utilisez une entrée sans perte (WAV, FLAC)
Fréquence d'échantillonnage plus élevée = 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 rumbles graves
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

~10s

chanson de 3 min

A100

~8s

album d'une heure

RTX 3090

~5 min

Dépannage

Mémoire insuffisante


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

Mauvaise séparation

Utilisez le modèle htdemucs_ft
Vérifiez la qualité de l'entrée
Évitez les MP3 fortement compressés

Artefacts

Augmenter le chevauchement
Utiliser un modèle de meilleure qualité
Vérifier la saturation (clipping) dans l'entrée

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 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 40GB

~$0.17

~$4.00

~$0.70

A100 80GB

~$0.25

~$6.00

~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)
Payer avec CLORE jetons
Comparer les prix entre différents fournisseurs

Prochaines étapes

RVC Voice Clone - Traiter les voix extraites
AudioCraft Music - Générer une nouvelle musique
Whisper Transcription - Transcrire les voix

PrécédentRVC Voice Clone SuivantAudioCraft Music

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce que Demucs ?

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagInstallation

hashtagUtilisation en ligne de commande

hashtagSéparation basique

hashtagOptions

hashtagTraiter un dossier

hashtagAPI Python

hashtagSéparation basique

hashtagObtenir uniquement les voix

hashtagObtenir l'instrumental (sans voix)

hashtagVariantes de modèle

hashtagModèle 6 stems

hashtagModèle affiné

hashtagTraitement par lots

hashtagServeur API

hashtagOptimisation de la mémoire

hashtagPour les longs fichiers audio

hashtagPour VRAM limitée

hashtagCas d'utilisation

hashtagPiste karaoké

hashtagPréparation de remix

hashtagExtraction d'acapella

hashtagConseils de qualité

hashtagPour de meilleurs résultats

hashtagPost-traitement

hashtagPerformances

hashtagDépannage

hashtagMémoire insuffisante

hashtagMauvaise séparation

hashtagArtefacts

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce que Demucs ?

Déploiement rapide

Accéder à votre service

Installation

Utilisation en ligne de commande

Séparation basique

Options

Traiter un dossier

API Python

Séparation basique

Obtenir uniquement les voix

Obtenir l'instrumental (sans voix)

Variantes de modèle

Modèle 6 stems

Modèle affiné

Traitement par lots

Serveur API

Optimisation de la mémoire

Pour les longs fichiers audio

Pour VRAM limitée

Cas d'utilisation

Piste karaoké

Préparation de remix

Extraction d'acapella

Conseils de qualité

Pour de meilleurs résultats

Post-traitement

Performances

Dépannage

Mémoire insuffisante

Mauvaise séparation

Artefacts

Estimation des coûts

Prochaines étapes