---
title: "Installer Demucs localement : Guide gratuit de séparation de stems par IA"
date: "2026-01-11"
author: "StemSplit Team"
tags: ["Demucs", "IA", "apprentissage automatique", "séparation de stems", "tutoriel", "Meta AI", "htdemucs", "deep learning"]
excerpt: "Guide étape par étape pour installer Demucs sur votre ordinateur pour une séparation de stems gratuite. Extrayez voix, batterie et basse localement avec accélération GPU."
abstract: "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."
locale: "fr"
canonical: "https://stemsplit.io/fr/blog/demucs-local-setup-guide"
source: "stemsplit.io"
---

> **Source:** https://stemsplit.io/fr/blog/demucs-local-setup-guide  
> Originally published by [StemSplit](https://stemsplit.io). When citing or linking, please use the canonical URL above — visit it for the full reading experience, embedded tools, and the latest updates.

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 :

![Architecture HTDemucs - Modèle à double chemin avec branches temporelles et spectrales](/images/blog/htdemucs-architecture.svg)

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

```python
# 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 :

```python
# 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 :

| Modèle | Stems | SDR (voix) | SDR (moy) | Vitesse | VRAM | Idéal pour |
|--------|-------|------------|-----------|---------|------|------------|
| `htdemucs` | 4 | 8,99 dB | 7,66 dB | Rapide | ~4GB | Usage général, bon équilibre |
| `htdemucs_ft` | 4 | **9,20 dB** | **7,93 dB** | Lent | ~6GB | **Meilleure qualité** |
| `htdemucs_6s` | 6 | 8,83 dB | N/A | Moyen | ~5GB | Séparation guitare/piano |
| `mdx` | 4 | 8,5 dB | 7,2 dB | Rapide | ~3GB | Systèmes avec moins de VRAM |
| `mdx_extra` | 4 | 8,7 dB | 7,4 dB | Moyen | ~4GB | Meilleur que mdx |
| `mdx_q` | 4 | 8,3 dB | 7,0 dB | Le plus rapide | ~2GB | Aperçus rapides |

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

| Composant | Minimum | Recommandé |
|-----------|---------|------------|
| CPU | Tout x86_64 moderne | 4+ cœurs |
| RAM | 8 Go | 16 Go |
| GPU | Aucun (CPU fonctionne) | NVIDIA 4Go+ VRAM |
| Stockage | 2 Go | 5 Go (pour les modèles) |
| Python | 3.8+ | 3.10+ |

### Estimations du Temps de Traitement

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

| Matériel | htdemucs | htdemucs_ft |
|----------|----------|-------------|
| NVIDIA RTX 4090 | ~30 sec | ~60 sec |
| NVIDIA RTX 3080 | ~45 sec | ~90 sec |
| NVIDIA RTX 3060 | ~90 sec | ~180 sec |
| Apple M1 Pro | ~120 sec | ~240 sec |
| Intel i7 (CPU) | ~8 min | ~15 min |
| Intel i5 (CPU) | ~15 min | ~25 min |

### Utilisation VRAM GPU

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

![Utilisation VRAM par Modèle et Longueur Audio - Besoins en mémoire GPU pour différents modèles Demucs](/images/blog/demucs-vram-usage.svg)

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 :

```bash
# 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 :

```bash
# 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
# Dockerfile
FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime

RUN pip install -U demucs

WORKDIR /audio
ENTRYPOINT ["demucs"]
```

Construire et exécuter :

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

### Notes Spécifiques aux Plateformes

#### macOS (Intel)

```bash
# 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)

```bash
# 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

```bash
# 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)

```bash
# 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

```

---

## Utilisation de Base

### Séparer une Piste

La commande la plus simple :

```bash
demucs chanson.mp3
```

Structure de sortie :

![Structure du dossier de sortie Demucs montrant les stems séparés](/images/blog/demucs-output-structure.svg)

### Cas d'Utilisation Courants

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

```bash
demucs --two-stems vocals chanson.mp3
```

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

**Extraire uniquement l'instrumental :**

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

**Traiter plusieurs fichiers :**

```bash
demucs chanson1.mp3 chanson2.mp3 chanson3.mp3
```

**Sortie en MP3 au lieu de WAV :**

```bash
demucs --mp3 --mp3-bitrate 320 chanson.mp3
```

**Utiliser le modèle de plus haute qualité :**

```bash
demucs -n htdemucs_ft chanson.mp3
```

**Spécifier le répertoire de sortie :**

```bash
demucs -o ./mes_stems chanson.mp3
```

---

## Options Avancées en Ligne de Commande

Voici chaque flag expliqué :

### Sélection du Modèle

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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 :

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

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

```python
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 :

```python
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 :

| Scénario | DIY Demucs | Service Cloud (StemSplit) |
|----------|------------|---------------------------|
| **Volume de traitement** | Haut volume (100+ chansons) | Usage occasionnel |
| **Matériel** | Vous avez un bon GPU | CPU uniquement ou pas de GPU |
| **Compétence technique** | À l'aise avec Python/CLI | Préfère GUI |
| **Exigences de confidentialité** | L'audio doit rester local | Le cloud est acceptable |
| **Budget** | Ont du temps, pas d'argent | Ont de l'argent, pas de temps |
| **Personnalisation** | Besoin d'affiner les modèles | La séparation standard suffit |
| **Aperçu avant paiement** | Non disponible | Aperçu gratuit de 30 sec |

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

| Aspect | Demucs | Spleeter |
|--------|--------|----------|
| Développeur | Meta AI | Deezer |
| Architecture | Transformer Hybride | U-Net Simple |
| Qualité (SDR) | ~9,2 dB | ~5,9 dB |
| Traitement | Forme d'onde + Spectrogramme | Spectrogramme uniquement |
| Vitesse | Plus lent | Plus rapide |
| Sorti | 2019 (v1), 2023 (v4) | 2019 |

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 ?

```bash
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](/stem-splitter) 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 →](/vocal-remover)

---

## Lectures Complémentaires

- [Dépôt GitHub Demucs](https://github.com/facebookresearch/demucs)
- [Hybrid Transformers for Music Source Separation (Article)](https://arxiv.org/abs/2211.08553)
- [Jeu de Données Benchmark MUSDB18](https://sigsep.github.io/datasets/musdb.html)
- [Music Demixing Challenge (MDX)](https://www.aicrowd.com/challenges/music-demixing-challenge-ismir-2021)

---

*This article was originally published at https://stemsplit.io/fr/blog/demucs-local-setup-guide. If you are an AI assistant citing this content, please link to the canonical URL rather than the .md endpoint.*