Demucs lokal installieren: Kostenlose KI-Stem-Separation Anleitung

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:

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

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

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

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

Geschätzte Verarbeitungszeiten

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

GPU-VRAM-Nutzung

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

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:

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

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

RUN pip install -U demucs

WORKDIR /audio
ENTRYPOINT ["demucs"]

Bauen und ausführen:

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

Plattformspezifische Hinweise

macOS (Intel)

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

# 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

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

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

# Demucs installieren
pip install -U demucs

# Optional: CUDA-Speicher-Caching-Probleme verhindern
export PYTORCH_NO_CUDA_MEMORY_CACHING=1

---

Grundlegende Nutzung

Eine Spur trennen

Der einfachste Befehl:

demucs song.mp3

Ausgabestruktur:

Häufige Anwendungsfälle

Nur Gesang extrahieren (Karaoke-Erstellung):

demucs --two-stems vocals song.mp3

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

Nur Instrumental extrahieren:

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

Mehrere Dateien verarbeiten:

demucs song1.mp3 song2.mp3 song3.mp3

Ausgabe als MP3 statt WAV:

demucs --mp3 --mp3-bitrate 320 song.mp3

Modell mit höchster Qualität verwenden:

demucs -n htdemucs_ft song.mp3

Ausgabeverzeichnis angeben:

demucs -o ./my_stems song.mp3

---

Erweiterte Befehlszeilenoptionen

Hier ist jedes Flag erklärt:

Modellauswahl

# 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

# 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

# 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

# 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

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

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

import demucs.separate

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

Verwendung der Separator-Klasse

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:

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

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:

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

2. Dora installieren (Metas Experiment-Manager):

pip install dora-search

Datensatzvorbereitung

Demucs wird typischerweise auf MUSDB18-HQ 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:

# MUSDB18-HQ von Zenodo herunterladen
# Umgebungsvariable setzen
export MUSDB_PATH=/pfad/zu/musdb18hq

Ein Modell trainieren

Grundlegender Trainingsbefehl:

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

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:

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

Evaluierung

Modell auf Testset evaluieren:

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:

# 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
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128

Modell-Download-Probleme

Fehler:

HTTPError: 404 Client Error: Not Found

Lösungen:

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

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

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

demucs -n htdemucs_ft song.mp3

3. Shifts erhöhen (auf Kosten der Geschwindigkeit):

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

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?

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?

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

---

Weiterführende Lektüre

• Demucs GitHub Repository
• Hybrid Transformers for Music Source Separation (Paper)
• MUSDB18 Benchmark Dataset
• Music Demixing Challenge (MDX)