---
title: "Demucs lokal installieren: Kostenlose KI-Stem-Separation Anleitung"
date: "2026-01-11"
author: "StemSplit Team"
tags: ["Demucs", "KI", "maschinelles Lernen", "Stem-Separation", "Tutorial", "Meta AI", "htdemucs", "Deep Learning"]
excerpt: "Schritt-für-Schritt-Anleitung zur Installation von Demucs auf Ihrem Computer für kostenlose Stem-Separation. Vocals, Drums und Bass lokal mit GPU-Beschleunigung extrahieren."
abstract: "Demucs ist das KI-Modell, das heute die meisten professionellen Stem-Separation-Tools antreibt — einschließlich StemSplit. Dieser Leitfaden behandelt alles von der Installation über die Architektur bis zum Training benutzerdefinierter Modelle, geschrieben für neugierige Musiker und ML-Ingenieure gleichermaßen."
locale: "de"
canonical: "https://stemsplit.io/de/blog/demucs-local-setup-guide"
source: "stemsplit.io"
---

> **Source:** https://stemsplit.io/de/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 ist das KI-Modell, das heute die meisten professionellen Stem-Separation-Tools antreibt — einschließlich StemSplit. Dieser Leitfaden behandelt alles von der Installation über die Architektur bis zum Training benutzerdefinierter Modelle, geschrieben für neugierige Musiker und ML-Ingenieure gleichermaßen.

**TL;DR**: Demucs ist ein Hybrid-Transformer-Modell von Meta AI, das Audio in Gesang, Schlagzeug, Bass und andere Instrumente trennt. Installation mit `pip install -U demucs`, Ausführung mit `demucs your_song.mp3`, und Sie erhalten in wenigen Minuten Stems in Studioqualität. Für beste Ergebnisse verwenden Sie das `htdemucs_ft`-Modell mit GPU-Beschleunigung.

---

## Was ist Demucs?

Demucs (Deep Extractor for Music Sources) ist ein Open-Source-KI-Modell, das von Meta AI Research für die Trennung von Musikquellen entwickelt wurde. Es nimmt eine gemischte Audiospur und gibt isolierte Stems aus — typischerweise Gesang, Schlagzeug, Bass und "Sonstiges" (alles andere).

Was Demucs bedeutsam macht:

- **Modernste Qualität**: Erreicht einen SDR (Signal-zu-Verzerrung-Verhältnis) von 9,20 dB auf dem MUSDB18-HQ-Benchmark — höher als jedes vorherige Modell
- **Wellenformbasierte Verarbeitung**: Arbeitet direkt mit rohem Audio, nicht nur mit Spektrogrammen, und bewahrt Phaseninformationen
- **Open Source**: MIT-lizenziert, kostenlos für kommerzielle und persönliche Nutzung
- **Praxiserprobt**: Treibt die meisten professionellen Stem-Separation-Dienste an

Die neueste Version, Hybrid Transformer Demucs (HTDemucs), repräsentiert die vierte große Iteration und kombiniert das Beste aus Zeit- und Frequenzbereichsverarbeitung.

---

## Die Entwicklung: v1 → v4

Das Verständnis der Entwicklung von Demucs hilft zu erklären, warum es so gut funktioniert.

### Demucs v1 (2019)

Das ursprüngliche Demucs führte eine U-Net-Architektur ein, die direkt auf Wellenformen arbeitet — eine Abkehr von reinen Spektrogramm-Methoden. Wichtige Innovationen:

- Gated Linear Units (GLUs) zur Aktivierung
- Bidirektionales LSTM zwischen Encoder und Decoder
- Skip-Verbindungen von Encoder- zu Decoder-Schichten

```
Architektur: Reines Wellenform-U-Net mit BiLSTM
SDR: ~6,3 dB auf MUSDB18
Innovation: Erstes konkurrenzfähiges reines Wellenform-Modell
```

### Demucs v2 (2020)

Verbesserte Tiefe und Training:

- Tieferer Encoder/Decoder (6 Schichten → 7 Schichten)
- Bessere Gewichtsinitialisierung
- Verbesserungen bei der Datenaugmentation

```
SDR: ~6,8 dB auf MUSDB18
Innovation: Bewies, dass Wellenform-Modelle mit Spektrogramm-Methoden konkurrieren können
```

### Demucs v3 / Hybrid Demucs (2021)

Der Durchbruch: Kombination von Spektrogramm- und Wellenformverarbeitung:

- Duale U-Net-Architektur (eine für Zeitbereich, eine für Frequenzbereich)
- Gemeinsame Repräsentationen zwischen den Zweigen
- Domänenübergreifende Fusion am Engpass

```
SDR: ~7,5 dB auf MUSDB18
Innovation: Das Beste aus beiden Welten — Spektrogramm-Präzision + Wellenform-Phase
```

### Demucs v4 / HTDemucs (2022-2023)

Der aktuelle Stand der Technik, mit Transformern:

- Transformer-Schichten sowohl im Encoder als auch im Decoder
- Cross-Attention zwischen zeitlichen und spektralen Zweigen
- Self-Attention für weitreichende Abhängigkeiten

```
SDR: 9,20 dB auf MUSDB18-HQ
Innovation: Transformer erfassen weitreichende musikalische Struktur
```

---

## Architektur-Tiefenanalyse

Für ML-Praktiker: So funktioniert HTDemucs tatsächlich.

### Übergeordnete Struktur

HTDemucs verwendet eine **Dual-Path-Architektur** mit zwei parallelen U-Net-Zweigen, die Informationen austauschen:

![HTDemucs Architektur - Dual-Path-Modell mit zeitlichen und spektralen Zweigen](/images/blog/htdemucs-architecture.svg)

### Zeitlicher Zweig (Wellenformverarbeitung)

Der zeitliche Zweig verarbeitet rohe Audio-Samples:

1. **Encoder**: Stapel von Strided-1D-Faltungen, die das Audio progressiv heruntersamplen
2. **Engpass**: BiLSTM + Transformer Self-Attention
3. **Decoder**: Transponierte Faltungen, die zurück zur ursprünglichen Auflösung hochsamplen
4. **Skip-Verbindungen**: U-Net-artige Verbindungen vom Encoder zum Decoder

```python
# Vereinfachte Encoder-Schicht-Struktur
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)  # Ausgabe ist out_channels // 2
        return x
```

### Spektraler Zweig (Spektrogrammverarbeitung)

Der spektrale Zweig verarbeitet die Kurzzeit-Fourier-Transformation (STFT) des Audios:

1. **STFT-Berechnung**: Wandelt Wellenform in komplexes Spektrogramm um
2. **2D-Faltungen**: Verarbeiten Frequenz × Zeit-Repräsentationen
3. **Transformer-Schichten**: Self-Attention in Frequenz- und Zeitdimensionen
4. **Inverse STFT**: Rückumwandlung in Wellenform

Schlüsselparameter:
- STFT-Fenster: 4096 Samples
- Hop-Länge: 1024 Samples
- Frequenz-Bins: 2049 (für 44,1kHz Audio)

### Domänenübergreifende Fusion

Die Magie geschieht dort, wo die Zweige kommunizieren:

```python
# Cross-Attention zwischen Zweigen (vereinfacht)
class CrossDomainAttention:
    def forward(self, temporal_features, spectral_features):
        # Zeitlich beachtet Spektral
        temporal_out = self.temporal_cross_attn(
            query=temporal_features,
            key=spectral_features,
            value=spectral_features
        )
        
        # Spektral beachtet Zeitlich
        spectral_out = self.spectral_cross_attn(
            query=spectral_features,
            key=temporal_features,
            value=temporal_features
        )
        
        return temporal_out, spectral_out
```

### Warum diese Architektur funktioniert

1. **Phasenerhaltung**: Der Wellenform-Zweig behält exakte Phasenbeziehungen bei — entscheidend für saubere Trennung
2. **Frequenzpräzision**: Der spektrale Zweig eignet sich hervorragend zur Trennung von Instrumenten mit unterschiedlichen Frequenzprofilen
3. **Weitreichende Abhängigkeiten**: Transformer modellieren musikalische Struktur (Strophe-Refrain-Muster, wiederkehrende Motive)
4. **Multi-Scale-Features**: U-Net erfasst sowohl feine Details als auch globalen Kontext

---

## Verfügbare Modelle im Vergleich

Demucs bietet mehrere vortrainierte Modelle. So vergleichen sie sich:

| Modell | Stems | SDR (Gesang) | SDR (Durchschnitt) | Geschwindigkeit | VRAM | Optimal für |
|--------|-------|--------------|-------------------|-----------------|------|-------------|
| `htdemucs` | 4 | 8,99 dB | 7,66 dB | Schnell | ~4GB | Allgemeine Nutzung, gute Balance |
| `htdemucs_ft` | 4 | **9,20 dB** | **7,93 dB** | Langsam | ~6GB | **Beste Qualität** |
| `htdemucs_6s` | 6 | 8,83 dB | N/A | Mittel | ~5GB | Gitarren/Klavier-Separation |
| `mdx` | 4 | 8,5 dB | 7,2 dB | Schnell | ~3GB | Systeme mit weniger VRAM |
| `mdx_extra` | 4 | 8,7 dB | 7,4 dB | Mittel | ~4GB | Besser als mdx |
| `mdx_q` | 4 | 8,3 dB | 7,0 dB | Am schnellsten | ~2GB | Schnelle Vorschauen |

### Modelldetails

**htdemucs (Standard)**
- Das Standard-Hybrid-Transformer-Modell
- Guter Qualität/Geschwindigkeit-Kompromiss
- Trainiert auf internem Meta-Datensatz + MUSDB18-HQ

**htdemucs_ft (feinabgestimmt)**
- Gleiche Architektur, feinabgestimmt auf zusätzlichen Daten
- Höchste verfügbare Qualität
- Empfohlen für finale Produktionsarbeit

**htdemucs_6s (6-Stem)**
- Trennt in: Gesang, Schlagzeug, Bass, Gitarre, Klavier, Sonstiges
- Nützlich, wenn Sie Gitarre oder Klavier isoliert benötigen
- Etwas niedrigere Qualität pro Stem aufgrund der schwierigeren Aufgabe

**mdx / mdx_extra**
- Modelle vom MDX 2021-Wettbewerb
- Verwenden "Bag of Models"-Ensemble-Ansatz
- Geringere VRAM-Anforderungen

---

## Systemanforderungen

### Mindestanforderungen

| Komponente | Minimum | Empfohlen |
|------------|---------|-----------|
| CPU | Jede moderne x86_64 | 4+ Kerne |
| RAM | 8 GB | 16 GB |
| GPU | Keine (CPU funktioniert) | NVIDIA 4GB+ VRAM |
| Speicher | 2 GB | 5 GB (für Modelle) |
| Python | 3.8+ | 3.10+ |

### Geschätzte Verarbeitungszeiten

Für eine 4-minütige Stereo-Spur bei 44,1kHz:

| Hardware | htdemucs | htdemucs_ft |
|----------|----------|-------------|
| NVIDIA RTX 4090 | ~30 Sek | ~60 Sek |
| NVIDIA RTX 3080 | ~45 Sek | ~90 Sek |
| NVIDIA RTX 3060 | ~90 Sek | ~180 Sek |
| Apple M1 Pro | ~120 Sek | ~240 Sek |
| Intel i7 (CPU) | ~8 Min | ~15 Min |
| Intel i5 (CPU) | ~15 Min | ~25 Min |

### GPU-VRAM-Nutzung

VRAM-Anforderungen hängen von der Audiolänge und dem Modell ab:

![VRAM-Nutzung nach Modell und Audiolänge - GPU-Speicheranforderungen für verschiedene Demucs-Modelle](/images/blog/demucs-vram-usage.svg)

Wenn Ihnen der VRAM ausgeht, verwenden Sie das `--segment`-Flag, um in kleineren Blöcken zu verarbeiten.

---

## Installationsanleitung

### Option 1: pip (Am einfachsten)

Für die meisten Benutzer, die einfach nur Spuren trennen möchten:

```bash
# Virtuelle Umgebung erstellen (empfohlen)
python3 -m venv demucs_env
source demucs_env/bin/activate  # Windows: demucs_env\Scripts\activate

# Demucs installieren
pip install -U demucs

# Installation überprüfen
demucs --help
```

Sie sollten sehen:

```
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 (Empfohlen für GPU)

Für GPU-Beschleunigung und ML-Entwicklung:

```bash
# Repository klonen
git clone https://github.com/facebookresearch/demucs
cd demucs

# Umgebung erstellen (wählen Sie eine)
conda env update -f environment-cuda.yml  # Für NVIDIA GPU
conda env update -f environment-cpu.yml   # Nur für CPU

# Umgebung aktivieren
conda activate demucs

# Im Entwicklungsmodus installieren
pip install -e .

# Überprüfen, ob GPU erkannt wird
python -c "import torch; print(f'CUDA verfügbar: {torch.cuda.is_available()}')"
```

Erwartete Ausgabe mit GPU:

```
CUDA verfügbar: True
```

### Option 3: Docker (Sauberste Isolation)

Für reproduzierbare Umgebungen:

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

RUN pip install -U demucs

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

Bauen und ausführen:

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

### Plattformspezifische Hinweise

#### macOS (Intel)

```bash
# FFmpeg installieren (erforderlich)
brew install ffmpeg

# SoundTouch installieren (optional, für Datenaugmentation)
brew install sound-touch

pip install -U demucs
```

#### macOS (Apple Silicon M1/M2/M3)

```bash
# FFmpeg
brew install ffmpeg

# Mit MPS-Unterstützung installieren (Metal Performance Shaders)
pip install -U demucs

# Überprüfen, ob MPS verfügbar ist
python -c "import torch; print(f'MPS verfügbar: {torch.backends.mps.is_available()}')"
```

Verwenden Sie das `--device mps`-Flag beim Ausführen von Demucs.

#### Windows

```bash
# Mit Anaconda Prompt:
conda install -c conda-forge ffmpeg
pip install -U demucs soundfile

# CUDA-Speicherprobleme verhindern
set PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128
```

#### Linux (Ubuntu/Debian)

```bash
# Systemabhängigkeiten
sudo apt-get update
sudo apt-get install ffmpeg libsndfile1

# Demucs installieren
pip install -U demucs

# Optional: CUDA-Speicher-Caching-Probleme verhindern

```

---

## Grundlegende Nutzung

### Eine Spur trennen

Der einfachste Befehl:

```bash
demucs song.mp3
```

Ausgabestruktur:

![Demucs-Ausgabeordnerstruktur mit getrennten Stems](/images/blog/demucs-output-structure.svg)

### Häufige Anwendungsfälle

**Nur Gesang extrahieren (Karaoke-Erstellung):**

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

Ausgabe: `vocals.wav` und `no_vocals.wav` (Instrumental)

**Nur Instrumental extrahieren:**

```bash
demucs --two-stems vocals song.mp3
# Dann die no_vocals.wav-Datei verwenden
```

**Mehrere Dateien verarbeiten:**

```bash
demucs song1.mp3 song2.mp3 song3.mp3
```

**Ausgabe als MP3 statt WAV:**

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

**Modell mit höchster Qualität verwenden:**

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

**Ausgabeverzeichnis angeben:**

```bash
demucs -o ./my_stems song.mp3
```

---

## Erweiterte Befehlszeilenoptionen

Hier ist jedes Flag erklärt:

### Modellauswahl

```bash
# Spezifisches Modell verwenden
demucs -n htdemucs_ft song.mp3     # Beste Qualität
demucs -n htdemucs_6s song.mp3     # 6-Stem-Ausgabe
demucs -n mdx_q song.mp3           # Am schnellsten/kleinsten
```

### Gerätesteuerung

```bash
# CPU-Verarbeitung erzwingen
demucs -d cpu song.mp3

# Spezifische GPU verwenden
demucs -d cuda:0 song.mp3          # Erste GPU
demucs -d cuda:1 song.mp3          # Zweite GPU

# Apple Silicon
demucs -d mps song.mp3
```

### Qualität vs. Speicher-Kompromisse

```bash
# Segmentlänge (Sekunden) - niedriger = weniger VRAM, potenziell schlechtere Qualität
demucs --segment 10 song.mp3       # Für sehr wenig VRAM
demucs --segment 40 song.mp3       # Standard für die meisten Modelle

# Überlappung zwischen Segmenten (0-0,99)
demucs --overlap 0.25 song.mp3     # Standard

# Shifts - erhöht Qualität um ~0,2 SDR, aber langsamer
demucs --shifts 2 song.mp3         # Zweimal mit Zeitverschiebungen verarbeiten
demucs --shifts 5 song.mp3         # Mehr Shifts = bessere Qualität, langsamer
```

### Ausgabeformat

```bash
# WAV-Optionen
demucs --int24 song.mp3            # 24-Bit WAV-Ausgabe
demucs --float32 song.mp3          # 32-Bit Float WAV

# MP3-Optionen
demucs --mp3 song.mp3              # Standard-Bitrate
demucs --mp3 --mp3-bitrate 320 song.mp3  # Hohe Qualität
demucs --mp3 --mp3-preset 2 song.mp3     # Bestes Qualitäts-Preset
demucs --mp3 --mp3-preset 7 song.mp3     # Schnellste Kodierung

# Clipping-Verhinderung
demucs --clip-mode rescale song.mp3      # Umskalieren zur Clipping-Verhinderung
demucs --clip-mode clamp song.mp3        # Harte Grenze (Standard)
demucs --clip-mode none song.mp3         # Kein Schutz
```

### Parallele Verarbeitung

```bash
# Anzahl der parallelen Jobs (erhöht Speicherverbrauch)
demucs -j 4 song.mp3               # 4 Kerne verwenden
demucs -j 8 song1.mp3 song2.mp3    # Mehrere Dateien parallel verarbeiten
```

### Vollständiges Beispiel

Maximale Qualität, GPU-beschleunigt:

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

---

## Python-API-Integration

Für die Integration von Demucs in Ihre Anwendungen:

### Grundlegende programmatische Nutzung

```python
import demucs.separate

# Mit Argumentliste (wie CLI)
demucs.separate.main([
    "--mp3",
    "--two-stems", "vocals",
    "-n", "htdemucs",
    "song.mp3"
])
```

### Verwendung der Separator-Klasse

```python
from demucs.api import Separator
import torch

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

# Laden und trennen
origin, separated = separator.separate_audio_file("song.mp3")

# `separated` ist ein Dict mit Tensor-Werten:
# separated["vocals"] -> torch.Tensor
# separated["drums"] -> torch.Tensor
# separated["bass"] -> torch.Tensor
# separated["other"] -> torch.Tensor

# Einzelne Stems speichern
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"
    )
```

### Direkter Modellzugriff

Für ML-Praktiker, die mehr Kontrolle wünschen:

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

# Modell laden
model = pretrained.get_model("htdemucs_ft")
model.eval()

# Auf GPU verschieben falls verfügbar
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Audio laden
waveform, sample_rate = torchaudio.load("song.mp3")

# Stereo sicherstellen
if waveform.shape[0] == 1:
    waveform = waveform.repeat(2, 1)

# Batch-Dimension hinzufügen und auf Gerät verschieben
mix = waveform.unsqueeze(0).to(device)

# Modell anwenden
with torch.no_grad():
    sources = apply_model(
        model,
        mix,
        shifts=2,
        split=True,
        overlap=0.25,
        progress=True,
        device=device
    )

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

# Quellnamen abrufen
source_names = model.sources  # ['drums', 'bass', 'other', 'vocals']
```

### Callback für Fortschrittsverfolgung

```python
from demucs.api import Separator

def progress_callback(info):
    """Wird während der Trennung mit Fortschrittsinformationen aufgerufen."""
    state = info.get("state", "")
    if state == "start":
        print(f"Verarbeite Segment bei Offset {info['segment_offset']}")
    elif state == "end":
        progress = info['segment_offset'] / info['audio_length'] * 100
        print(f"Fortschritt: {progress:.1f}%")

separator = Separator(
    model="htdemucs",
    callback=progress_callback
)

origin, separated = separator.separate_audio_file("song.mp3")
```

---

## Training benutzerdefinierter Modelle

Für Forscher und fortgeschrittene Benutzer, die auf benutzerdefinierten Daten trainieren möchten.

### Voraussetzungen

1. Das vollständige Repository klonen:

```bash
git clone https://github.com/facebookresearch/demucs
cd demucs
conda env update -f environment-cuda.yml
conda activate demucs
pip install -e .
```

2. [Dora](https://github.com/facebookresearch/dora) installieren (Metas Experiment-Manager):

```bash
pip install dora-search
```

### Datensatzvorbereitung

Demucs wird typischerweise auf [MUSDB18-HQ](https://zenodo.org/record/3338373) trainiert, der enthält:
- 150 vollständige Songs (100 Training, 50 Test)
- Separate Stems für jeden Song
- 44,1kHz Stereo-WAV-Dateien

Herunterladen und Pfad setzen:

```bash
# MUSDB18-HQ von Zenodo herunterladen
# Umgebungsvariable setzen

```

### Ein Modell trainieren

Grundlegender Trainingsbefehl:

```bash
# Mit Dora trainieren
dora run -d solver=htdemucs dset=musdb_hq

# Mit spezifischer Konfiguration
dora run -d solver=htdemucs dset=musdb_hq \
    model.depth=6 \
    model.channels=48 \
    optim.lr=3e-4 \
    optim.epochs=360
```

Trainingsparameter erklärt:

| Parameter | Beschreibung | Standard |
|-----------|--------------|----------|
| `model.depth` | Encoder/Decoder-Tiefe | 6 |
| `model.channels` | Basis-Kanalanzahl | 48 |
| `model.growth` | Kanal-Wachstumsfaktor | 2 |
| `optim.lr` | Lernrate | 3e-4 |
| `optim.epochs` | Trainings-Epochen | 360 |
| `optim.batch_size` | Batch-Größe | 4 |

### Feinabstimmung eines bestehenden Modells

Um auf benutzerdefinierten Daten feinabzustimmen:

1. Bereiten Sie Ihren Datensatz im MUSDB-Format vor
2. Führen Sie die Feinabstimmung aus:

```bash
dora run -d -f 81de367c continue_from=81de367c dset=your_dataset variant=finetune
```

### Evaluierung

Modell auf Testset evaluieren:

```bash
dora run -d solver=htdemucs dset=musdb_hq evaluate=true
```

Ausgabe enthält SDR (Signal-zu-Verzerrung-Verhältnis) pro Quelle:

```
Quelle      | SDR (dB)
------------|--------
vocals      | 8.99
drums       | 8.72
bass        | 7.84
other       | 5.09
------------|--------
Durchschnitt| 7.66
```

---

## Fehlerbehebung häufiger Probleme

### CUDA Out of Memory

**Fehler:**
```
RuntimeError: CUDA out of memory. Tried to allocate X MiB
```

**Lösungen:**

```bash
# Kleinere Segmente verwenden
demucs --segment 10 song.mp3

# Stattdessen CPU verwenden
demucs -d cpu song.mp3

# Ein leichteres Modell verwenden
demucs -n mdx_q song.mp3

# PyTorch-Speicherkonfiguration setzen (Windows)
set PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128

# Oder auf Linux/Mac

```

### Modell-Download-Probleme

**Fehler:**
```
HTTPError: 404 Client Error: Not Found
```

**Lösungen:**

```bash
# Cache leeren und erneut versuchen
rm -rf ~/.cache/torch/hub/checkpoints/
demucs song.mp3

# Manueller Download
# Modelle sind gespeichert unter: https://dl.fbaipublicfiles.com/demucs/
```

### FFmpeg nicht gefunden

**Fehler:**
```
FileNotFoundError: [Errno 2] No such file or directory: 'ffmpeg'
```

**Lösungen:**

```bash
# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt-get install ffmpeg

# Windows (über conda)
conda install -c conda-forge ffmpeg
```

### Modul nicht gefunden

**Fehler:**
```
ModuleNotFoundError: No module named 'demucs'
```

**Lösungen:**

```bash
# Sicherstellen, dass die virtuelle Umgebung aktiviert ist
source demucs_env/bin/activate  # oder conda activate demucs

# Neu installieren
pip install -U demucs
```

### Schlechte Trennungsqualität

**Symptome:** Artefakte, Übersprechen zwischen Stems, matschige Ausgabe

**Lösungen:**

1. Quelldateien höherer Qualität verwenden:
   - Verlustfrei (WAV, FLAC) > Hochbitrate MP3 (320kbps) > Niedrigbitrate MP3
   
2. Besseres Modell verwenden:
```bash
demucs -n htdemucs_ft song.mp3
```

3. Shifts erhöhen (auf Kosten der Geschwindigkeit):
```bash
demucs --shifts 5 song.mp3
```

4. Prüfen, ob die Quelle nicht bereits stark verarbeitet ist (starkes Limiting/Kompression beeinträchtigt die Trennung)

---

**Sie möchten keine Python-Umgebungen und GPU-Treiber troubleshooten?** [StemSplit](/stem-splitter) führt optimiertes Demucs in der Cloud aus — 30 Sekunden kostenlos vorhören, keine Einrichtung erforderlich.

---

## Wann DIY sinnvoll ist

Seien wir ehrlich darüber, wann das lokale Ausführen von Demucs sinnvoll ist:

| Szenario | DIY Demucs | Cloud-Service (StemSplit) |
|----------|------------|---------------------------|
| **Verarbeitungsvolumen** | Hohes Volumen (100+ Songs) | Gelegentliche Nutzung |
| **Hardware** | Sie haben eine gute GPU | Nur CPU oder keine GPU |
| **Technische Fähigkeiten** | Vertraut mit Python/CLI | Bevorzugt GUI |
| **Datenschutzanforderungen** | Audio muss lokal bleiben | Cloud ist akzeptabel |
| **Budget** | Haben Zeit, kein Geld | Haben Geld, keine Zeit |
| **Anpassung** | Müssen Modelle feinabstimmen | Standard-Trennung reicht |
| **Vorschau vor Zahlung** | Nicht verfügbar | 30 Sek. kostenlose Vorschau |

### Kostenvergleich

**DIY Demucs:**
- Hardware: 0 € (bestehend) bis 800+ € (GPU-Upgrade)
- Strom: ~0,01-0,05 € pro Song
- Zeit: Einrichtung (1-4 Stunden) + Verarbeitungszeit
- Wartung: Updates, Fehlerbehebung

**StemSplit:**
- Keine Einrichtung
- Bezahlung pro Nutzung (Guthaben verfällt nie)
- Kostenlose Vorschau vor Verpflichtung
- Immer die neuesten Modelle

### Die Realität

Wenn Sie:
- Stems professionell und regelmäßig verarbeiten
- ML-Erfahrung haben und anpassen möchten
- Tausende von Dateien verarbeiten müssen
- Datenschutzanforderungen für unveröffentlichte Musik haben

→ **Richten Sie Demucs lokal ein.**

Wenn Sie:
- Gelegentlich Stems benötigen
- Keine Python-Umgebungen verwalten möchten
- Die Qualität vor der Verpflichtung vorhören möchten
- Komfort über Kostenoptimierung stellen

→ **Nutzen Sie einen Service wie StemSplit.**

---

## FAQ

### Ist Demucs kostenlos?

Ja. Demucs ist Open Source unter der MIT-Lizenz, kostenlos für persönliche und kommerzielle Nutzung. Die Modelle sind ebenfalls frei verfügbar.

### Kann ich Demucs kommerziell nutzen?

Ja. Die MIT-Lizenz erlaubt kommerzielle Nutzung ohne Einschränkungen. Sie können getrennte Stems in kommerziellen Veröffentlichungen verwenden, Produkte auf Demucs aufbauen usw.

### Was ist der Unterschied zwischen Demucs und Spleeter?

| Aspekt | Demucs | Spleeter |
|--------|--------|----------|
| Entwickler | Meta AI | Deezer |
| Architektur | Hybrid Transformer | Einfaches U-Net |
| Qualität (SDR) | ~9,2 dB | ~5,9 dB |
| Verarbeitung | Wellenform + Spektrogramm | Nur Spektrogramm |
| Geschwindigkeit | Langsamer | Schneller |
| Veröffentlicht | 2019 (v1), 2023 (v4) | 2019 |

Demucs produziert deutlich höhere Qualität, benötigt aber mehr Rechenleistung.

### Brauche ich eine GPU?

Nein, aber sie hilft erheblich. CPU-Verarbeitung funktioniert, ist aber 5-10x langsamer. Eine moderne NVIDIA-GPU mit 4GB+ VRAM wird für angemessene Verarbeitungszeiten empfohlen.

### Wie lange dauert die Verarbeitung?

Abhängig von Hardware und Modell:
- GPU (RTX 3080): ~45 Sekunden für einen 4-Minuten-Song
- CPU (moderner i7): ~8-15 Minuten für einen 4-Minuten-Song

### Welche Audioformate unterstützt Demucs?

Eingabe: MP3, WAV, FLAC, OGG, M4A und alles, was FFmpeg dekodieren kann.
Ausgabe: WAV (Standard), MP3 (mit --mp3 Flag).

### Warum haben meine Stems Artefakte?

Häufige Ursachen:
1. Quelldatei mit niedriger Qualität (320kbps+ oder verlustfrei verwenden)
2. Stark komprimiertes/limitiertes Master
3. Verwendung eines leichteren Modells (htdemucs_ft versuchen)
4. Komplexes, dichtes Arrangement mit überlappenden Frequenzen

### Kann Demucs mehr als 4 Stems trennen?

Ja. Verwenden Sie `htdemucs_6s` für 6-Stem-Trennung:
- Gesang
- Schlagzeug
- Bass
- Gitarre
- Klavier
- Sonstiges

### Wie aktualisiere ich Demucs?

```bash
pip install -U demucs
```

### Wohin werden die Modelle heruntergeladen?

Modelle werden zwischengespeichert in:
- Linux/Mac: `~/.cache/torch/hub/checkpoints/`
- Windows: `C:\Users\<username>\.cache\torch\hub\checkpoints\`

---

## Fazit

Demucs repräsentiert die Spitze der KI-gestützten Musik-Quellentrennung. Ob Sie ein Produzent sind, der Samples isoliert, ein Forscher, der die Grenzen des Audio-ML erweitert, oder einfach jemand, der einen Karaoke-Track erstellen möchte — das Verständnis dieser Technologie gibt Ihnen mehr Kontrolle über Ihre Ergebnisse.

Für die meisten Benutzer ist der einfachste Weg die Nutzung eines Services, der die Infrastruktur verwaltet. Für Power-User und ML-Praktiker bietet das lokale Ausführen von Demucs maximale Kontrolle und Anpassungsmöglichkeiten.

---

## Bereit, Stem-Separation auszuprobieren?

Sie haben gesehen, wie die Technologie funktioniert. Jetzt erleben Sie sie.

**Option 1: Selbst ausführen** — Folgen Sie dieser Anleitung, um Demucs lokal einzurichten.

**Option 2: Setup überspringen** — [StemSplit](/stem-splitter) führt Demucs htdemucs_ft in der Cloud aus. Laden Sie Ihren Song hoch, hören Sie 30 Sekunden kostenlos vor und laden Sie Stems in Studioqualität herunter. Kein Python erforderlich.

[StemSplit kostenlos testen →](/vocal-remover)

---

## Weiterführende Lektüre

- [Demucs GitHub Repository](https://github.com/facebookresearch/demucs)
- [Hybrid Transformers for Music Source Separation (Paper)](https://arxiv.org/abs/2211.08553)
- [MUSDB18 Benchmark Dataset](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/de/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.*