Installer Demucs localement : Guide gratuit de séparation de stems par IA

Demucs est le modèle d'IA qui alimente aujourd'hui la plupart des outils professionnels de séparation de stems — y compris StemSplit. Ce guide couvre tout, de l'installation à l'architecture en passant par l'entraînement de modèles personnalisés, écrit pour les musiciens curieux comme pour les ingénieurs ML.

TL;DR : Demucs est un modèle Transformer hybride de Meta AI qui sépare l'audio en voix, batterie, basse et autres instruments. Installez avec pip install -U demucs, exécutez avec demucs votre_chanson.mp3, et obtenez des stems de qualité studio en quelques minutes. Pour de meilleurs résultats, utilisez le modèle htdemucs_ft avec accélération GPU.

---

Qu'est-ce que Demucs ?

Demucs (Deep Extractor for Music Sources) est un modèle d'IA open source développé par Meta AI Research pour la séparation de sources musicales. Il prend une piste audio mixée et produit des stems isolés — généralement voix, batterie, basse et "autre" (tout le reste).

Ce qui rend Demucs significatif :

• Qualité à la pointe : Atteint un SDR (Signal-to-Distortion Ratio) de 9,20 dB sur le benchmark MUSDB18-HQ — plus élevé que tout modèle précédent
• Traitement basé sur la forme d'onde : Travaille directement sur l'audio brut, pas seulement sur les spectrogrammes, préservant les informations de phase
• Open source : Licence MIT, gratuit pour usage commercial et personnel
• Éprouvé : Alimente la plupart des services professionnels de séparation de stems

La dernière version, Hybrid Transformer Demucs (HTDemucs), représente la quatrième itération majeure et combine le meilleur du traitement temporel et fréquentiel.

---

L'Évolution : v1 → v4

Comprendre l'évolution de Demucs aide à expliquer pourquoi il fonctionne si bien.

Demucs v1 (2019)

Le Demucs original a introduit une architecture U-Net opérant directement sur les formes d'onde — une rupture avec les méthodes utilisant uniquement les spectrogrammes. Innovations clés :

• Gated Linear Units (GLUs) pour l'activation
• LSTM bidirectionnel entre encodeur et décodeur
• Connexions de saut de l'encodeur au décodeur

Architecture : U-Net pur forme d'onde avec BiLSTM
SDR : ~6,3 dB sur MUSDB18
Innovation : Premier modèle compétitif utilisant uniquement les formes d'onde

Demucs v2 (2020)

Profondeur et entraînement améliorés :

• Encodeur/décodeur plus profond (6 couches → 7 couches)
• Meilleure initialisation des poids
• Améliorations de l'augmentation des données

SDR : ~6,8 dB sur MUSDB18
Innovation : A prouvé que les modèles de forme d'onde pouvaient rivaliser avec les méthodes de spectrogramme

Demucs v3 / Hybrid Demucs (2021)

La percée : combinaison du traitement spectrogramme et forme d'onde :

• Architecture U-Net double (une pour le domaine temporel, une pour le domaine fréquentiel)
• Représentations partagées entre les branches
• Fusion inter-domaines au goulot d'étranglement

SDR : ~7,5 dB sur MUSDB18
Innovation : Le meilleur des deux mondes — précision spectrogramme + phase forme d'onde

Demucs v4 / HTDemucs (2022-2023)

L'état de l'art actuel, ajoutant les Transformers :

• Couches Transformer dans l'encodeur et le décodeur
• Attention croisée entre les branches temporelles et spectrales
• Auto-attention pour les dépendances à longue portée

SDR : 9,20 dB sur MUSDB18-HQ
Innovation : Les Transformers capturent la structure musicale à longue portée

---

Plongée dans l'Architecture

Pour les praticiens ML : voici comment HTDemucs fonctionne réellement.

Structure de Haut Niveau

HTDemucs utilise une architecture à double chemin avec deux branches U-Net parallèles qui partagent des informations :

Branche Temporelle (Traitement de Forme d'Onde)

La branche temporelle traite les échantillons audio bruts :

1. Encodeur : Pile de convolutions 1D avec stride qui sous-échantillonnent progressivement l'audio
2. Goulot d'étranglement : BiLSTM + Auto-attention Transformer
3. Décodeur : Convolutions transposées qui suréchantillonnent à la résolution originale
4. Connexions de saut : Connexions style U-Net de l'encodeur au décodeur

# Structure simplifiée de couche d'encodeur
class TemporalEncoderLayer:
    def __init__(self, in_channels, out_channels, kernel_size=8, stride=4):
        self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride)
        self.norm = nn.GroupNorm(1, out_channels)
        self.glu = nn.GLU(dim=1)  # Gated Linear Unit
        
    def forward(self, x):
        x = self.conv(x)
        x = self.norm(x)
        x = self.glu(x)  # La sortie est out_channels // 2
        return x

Branche Spectrale (Traitement de Spectrogramme)

La branche spectrale traite la Transformée de Fourier à Court Terme (STFT) de l'audio :

1. Calcul STFT : Convertit la forme d'onde en spectrogramme complexe
2. Convolutions 2D : Traitent les représentations fréquence × temps
3. Couches Transformer : Auto-attention dans les dimensions fréquence et temps
4. STFT inverse : Reconversion en forme d'onde

Paramètres clés :

• Fenêtre STFT : 4096 échantillons
• Longueur de saut : 1024 échantillons
• Bins de fréquence : 2049 (pour audio 44,1kHz)

Fusion Inter-Domaines

La magie opère là où les branches communiquent :

# Attention croisée entre branches (simplifiée)
class CrossDomainAttention:
    def forward(self, temporal_features, spectral_features):
        # Le temporel attend le spectral
        temporal_out = self.temporal_cross_attn(
            query=temporal_features,
            key=spectral_features,
            value=spectral_features
        )
        
        # Le spectral attend le temporel
        spectral_out = self.spectral_cross_attn(
            query=spectral_features,
            key=temporal_features,
            value=temporal_features
        )
        
        return temporal_out, spectral_out

Pourquoi Cette Architecture Fonctionne

1. Préservation de la phase : La branche forme d'onde maintient les relations de phase exactes — crucial pour une séparation propre
2. Précision fréquentielle : La branche spectrale excelle dans la séparation d'instruments avec des profils de fréquence distincts
3. Dépendances à longue portée : Les Transformers modélisent la structure musicale (motifs couplet-refrain, motifs répétés)
4. Caractéristiques multi-échelles : U-Net capture à la fois les détails fins et le contexte global

---

Comparaison des Modèles Disponibles

Demucs propose plusieurs modèles pré-entraînés. Voici comment ils se comparent :

Détails des Modèles

htdemucs (par défaut)

• Le modèle Hybrid Transformer standard
• Bon compromis qualité/vitesse
• Entraîné sur le jeu de données interne Meta + MUSDB18-HQ

htdemucs_ft (affiné)

• Même architecture, affiné sur des données supplémentaires
• Qualité la plus élevée disponible
• Recommandé pour le travail de production final

htdemucs_6s (6-stems)

• Sépare en : voix, batterie, basse, guitare, piano, autre
• Utile quand vous avez besoin de la guitare ou du piano isolé
• Qualité légèrement inférieure par stem en raison de la tâche plus difficile

mdx / mdx_extra

• Modèles du concours MDX 2021
• Utilisent une approche d'ensemble "bag of models"
• Exigences VRAM plus faibles

---

Configuration Requise

Configuration Minimale

Estimations du Temps de Traitement

Pour une piste stéréo de 4 minutes à 44,1kHz :

Utilisation VRAM GPU

Les besoins en VRAM dépendent de la longueur audio et du modèle :

Si vous manquez de VRAM, utilisez le flag --segment pour traiter en plus petits morceaux.

---

Guide d'Installation

Option 1 : pip (Le Plus Simple)

Pour la plupart des utilisateurs qui veulent juste séparer des pistes :

# Créer un environnement virtuel (recommandé)
python3 -m venv demucs_env
source demucs_env/bin/activate  # Windows: demucs_env\Scripts\activate

# Installer Demucs
pip install -U demucs

# Vérifier l'installation
demucs --help

Vous devriez voir :

usage: demucs [-h] [-s SHIFTS] [--overlap OVERLAP] [-d DEVICE]
              [--two-stems STEM] [-n NAME] [-v] ...

positional arguments:
  tracks                Path to tracks

optional arguments:
  -h, --help            show this help message and exit
  ...

Option 2 : Conda (Recommandé pour GPU)

Pour l'accélération GPU et le développement ML :

# Cloner le dépôt
git clone https://github.com/facebookresearch/demucs
cd demucs

# Créer l'environnement (choisissez un)
conda env update -f environment-cuda.yml  # Pour GPU NVIDIA
conda env update -f environment-cpu.yml   # Pour CPU uniquement

# Activer l'environnement
conda activate demucs

# Installer en mode développement
pip install -e .

# Vérifier que le GPU est détecté
python -c "import torch; print(f'CUDA disponible: {torch.cuda.is_available()}')"

Sortie attendue avec GPU :

CUDA disponible: True

Option 3 : Docker (Isolation la Plus Propre)

Pour des environnements reproductibles :

# Dockerfile
FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime

RUN pip install -U demucs

WORKDIR /audio
ENTRYPOINT ["demucs"]

Construire et exécuter :

docker build -t demucs .
docker run --gpus all -v $(pwd):/audio demucs chanson.mp3

Notes Spécifiques aux Plateformes

macOS (Intel)

# Installer FFmpeg (requis)
brew install ffmpeg

# Installer SoundTouch (optionnel, pour l'augmentation de données)
brew install sound-touch

pip install -U demucs

macOS (Apple Silicon M1/M2/M3)

# FFmpeg
brew install ffmpeg

# Installer avec support MPS (Metal Performance Shaders)
pip install -U demucs

# Vérifier que MPS est disponible
python -c "import torch; print(f'MPS disponible: {torch.backends.mps.is_available()}')"

Utilisez le flag --device mps lors de l'exécution de Demucs.

Windows

# En utilisant Anaconda Prompt:
conda install -c conda-forge ffmpeg
pip install -U demucs soundfile

# Prévenir les problèmes de mémoire CUDA
set PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128

Linux (Ubuntu/Debian)

# Dépendances système
sudo apt-get update
sudo apt-get install ffmpeg libsndfile1

# Installer Demucs
pip install -U demucs

# Optionnel: Prévenir les problèmes de cache mémoire CUDA
export PYTORCH_NO_CUDA_MEMORY_CACHING=1

---

Utilisation de Base

Séparer une Piste

La commande la plus simple :

demucs chanson.mp3

Structure de sortie :

Cas d'Utilisation Courants

Extraire uniquement les voix (création karaoké) :

demucs --two-stems vocals chanson.mp3

Sortie : vocals.wav et no_vocals.wav (instrumental)

Extraire uniquement l'instrumental :

demucs --two-stems vocals chanson.mp3
# Puis utiliser le fichier no_vocals.wav

Traiter plusieurs fichiers :

demucs chanson1.mp3 chanson2.mp3 chanson3.mp3

Sortie en MP3 au lieu de WAV :

demucs --mp3 --mp3-bitrate 320 chanson.mp3

Utiliser le modèle de plus haute qualité :

demucs -n htdemucs_ft chanson.mp3

Spécifier le répertoire de sortie :

demucs -o ./mes_stems chanson.mp3

---

Options Avancées en Ligne de Commande

Voici chaque flag expliqué :

Sélection du Modèle

# Utiliser un modèle spécifique
demucs -n htdemucs_ft chanson.mp3     # Meilleure qualité
demucs -n htdemucs_6s chanson.mp3     # Sortie 6-stems
demucs -n mdx_q chanson.mp3           # Plus rapide/plus petit

Contrôle du Dispositif

# Forcer le traitement CPU
demucs -d cpu chanson.mp3

# Utiliser un GPU spécifique
demucs -d cuda:0 chanson.mp3          # Premier GPU
demucs -d cuda:1 chanson.mp3          # Deuxième GPU

# Apple Silicon
demucs -d mps chanson.mp3

Compromis Qualité vs Mémoire

# Longueur de segment (secondes) - plus bas = moins de VRAM, potentiellement moins bonne qualité
demucs --segment 10 chanson.mp3       # Pour très peu de VRAM
demucs --segment 40 chanson.mp3       # Par défaut pour la plupart des modèles

# Chevauchement entre segments (0-0,99)
demucs --overlap 0.25 chanson.mp3     # Par défaut

# Décalages - augmente la qualité de ~0,2 SDR, mais plus lent
demucs --shifts 2 chanson.mp3         # Traiter deux fois avec des décalages temporels
demucs --shifts 5 chanson.mp3         # Plus de décalages = meilleure qualité, plus lent

Format de Sortie

# Options WAV
demucs --int24 chanson.mp3            # Sortie WAV 24-bit
demucs --float32 chanson.mp3          # WAV float 32-bit

# Options MP3
demucs --mp3 chanson.mp3              # Bitrate par défaut
demucs --mp3 --mp3-bitrate 320 chanson.mp3  # Haute qualité
demucs --mp3 --mp3-preset 2 chanson.mp3     # Meilleur preset qualité
demucs --mp3 --mp3-preset 7 chanson.mp3     # Encodage le plus rapide

# Prévention du clipping
demucs --clip-mode rescale chanson.mp3      # Redimensionner pour éviter le clipping
demucs --clip-mode clamp chanson.mp3        # Limite dure (par défaut)
demucs --clip-mode none chanson.mp3         # Pas de protection

Traitement Parallèle

# Nombre de jobs parallèles (augmente l'utilisation mémoire)
demucs -j 4 chanson.mp3               # Utiliser 4 cœurs
demucs -j 8 chanson1.mp3 chanson2.mp3 # Traiter plusieurs fichiers en parallèle

Exemple Complet

Qualité maximale, accéléré GPU :

demucs \
  -n htdemucs_ft \
  -d cuda:0 \
  --shifts 2 \
  --overlap 0.25 \
  --float32 \
  --clip-mode rescale \
  -o ./output \
  chanson.mp3

---

Intégration API Python

Pour intégrer Demucs dans vos applications :

Utilisation Programmatique de Base

import demucs.separate

# En utilisant une liste d'arguments (comme CLI)
demucs.separate.main([
    "--mp3",
    "--two-stems", "vocals",
    "-n", "htdemucs",
    "chanson.mp3"
])

Utilisation de la Classe Separator

from demucs.api import Separator
import torch

# Initialiser le séparateur
separator = Separator(
    model="htdemucs_ft",
    segment=40,
    shifts=2,
    device="cuda" if torch.cuda.is_available() else "cpu",
    progress=True
)

# Charger et séparer
origin, separated = separator.separate_audio_file("chanson.mp3")

# `separated` est un dict avec des valeurs tensor:
# separated["vocals"] -> torch.Tensor
# separated["drums"] -> torch.Tensor
# separated["bass"] -> torch.Tensor
# separated["other"] -> torch.Tensor

# Sauvegarder les stems individuels
from demucs.api import save_audio

for stem_name, stem_tensor in separated.items():
    save_audio(
        stem_tensor,
        f"output/{stem_name}.wav",
        samplerate=separator.samplerate,
        clip="rescale"
    )

Accès Direct au Modèle

Pour les praticiens ML qui veulent plus de contrôle :

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

# Charger le modèle
model = pretrained.get_model("htdemucs_ft")
model.eval()

# Déplacer vers GPU si disponible
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Charger l'audio
waveform, sample_rate = torchaudio.load("chanson.mp3")

# S'assurer que c'est stéréo
if waveform.shape[0] == 1:
    waveform = waveform.repeat(2, 1)

# Ajouter dimension batch et déplacer vers le dispositif
mix = waveform.unsqueeze(0).to(device)

# Appliquer le modèle
with torch.no_grad():
    sources = apply_model(
        model,
        mix,
        shifts=2,
        split=True,
        overlap=0.25,
        progress=True,
        device=device
    )

# forme de sources: (batch, num_sources, channels, samples)
# sources[0, 0] = drums
# sources[0, 1] = bass
# sources[0, 2] = other
# sources[0, 3] = vocals

# Obtenir les noms des sources
source_names = model.sources  # ['drums', 'bass', 'other', 'vocals']

---

Quand le DIY a du Sens

Soyons honnêtes sur quand exécuter Demucs localement a du sens :

Comparaison des Coûts

DIY Demucs :

• Matériel : 0 € (existant) à 800+ € (mise à niveau GPU)
• Électricité : ~0,01-0,05 € par chanson
• Temps : Configuration (1-4 heures) + temps de traitement
• Maintenance : Mises à jour, dépannage

StemSplit :

• Pas de configuration
• Paiement à l'usage (les crédits n'expirent jamais)
• Aperçu gratuit avant engagement
• Toujours les derniers modèles

---

FAQ

Demucs est-il gratuit ?

Oui. Demucs est open source sous licence MIT, gratuit pour usage personnel et commercial. Les modèles sont également disponibles gratuitement.

Puis-je utiliser Demucs commercialement ?

Oui. La licence MIT permet l'usage commercial sans restrictions. Vous pouvez utiliser les stems séparés dans des sorties commerciales, construire des produits sur Demucs, etc.

Quelle est la différence entre Demucs et Spleeter ?

Demucs produit une qualité significativement supérieure mais nécessite plus de calcul.

Ai-je besoin d'un GPU ?

Non, mais ça aide significativement. Le traitement CPU fonctionne mais est 5-10x plus lent. Un GPU NVIDIA moderne avec 4Go+ de VRAM est recommandé pour des temps de traitement raisonnables.

Combien de temps prend le traitement ?

Dépend du matériel et du modèle :

• GPU (RTX 3080) : ~45 secondes pour une chanson de 4 minutes
• CPU (i7 moderne) : ~8-15 minutes pour une chanson de 4 minutes

Quels formats audio Demucs supporte-t-il ?

Entrée : MP3, WAV, FLAC, OGG, M4A, et tout ce que FFmpeg peut décoder. Sortie : WAV (par défaut), MP3 (avec le flag --mp3).

Pourquoi mes stems ont-ils des artefacts ?

Causes courantes :

1. Fichier source de basse qualité (utilisez 320kbps+ ou sans perte)
2. Master fortement compressé/limité
3. Utilisation d'un modèle plus léger (essayez htdemucs_ft)
4. Arrangement complexe et dense avec des fréquences qui se chevauchent

Demucs peut-il séparer plus de 4 stems ?

Oui. Utilisez htdemucs_6s pour une séparation en 6 stems :

• Voix
• Batterie
• Basse
• Guitare
• Piano
• Autre

Comment mettre à jour Demucs ?

pip install -U demucs

Où les modèles sont-ils téléchargés ?

Les modèles sont mis en cache dans :

• Linux/Mac : ~/.cache/torch/hub/checkpoints/
• Windows : C:\Users\<username>\.cache\torch\hub\checkpoints\

---

Conclusion

Demucs représente la pointe de la séparation de sources musicales alimentée par l'IA. Que vous soyez un producteur isolant des samples, un chercheur repoussant les limites du ML audio, ou simplement quelqu'un qui veut créer une piste karaoké — comprendre comment cette technologie fonctionne vous donne plus de contrôle sur vos résultats.

Pour la plupart des utilisateurs, le chemin le plus facile est d'utiliser un service qui gère l'infrastructure. Pour les utilisateurs avancés et les praticiens ML, exécuter Demucs localement offre un contrôle et une personnalisation maximaux.

---

Prêt à Essayer la Séparation de Stems ?

Vous avez vu comment la technologie fonctionne. Maintenant expérimentez-la.

Option 1 : L'exécuter vous-même — Suivez ce guide pour configurer Demucs localement.

Option 2 : Éviter la configuration — StemSplit exécute Demucs htdemucs_ft dans le cloud. Téléchargez votre chanson, prévisualisez 30 secondes gratuitement, et téléchargez des stems de qualité studio. Pas de Python requis.

Essayer StemSplit Gratuitement →

---

Lectures Complémentaires

• Dépôt GitHub Demucs
• Hybrid Transformers for Music Source Separation (Article)
• Jeu de Données Benchmark MUSDB18
• Music Demixing Challenge (MDX)