Demucs: 10K+ Stars 的音乐源分离工具 — 2026年对比 UVR、Spleeter

# Python 3.8+ 必需
python --version

# 必须安装 FFmpeg
ffmpeg -version

# (可选) NVIDIA GPU + CUDA 11.8+ 用于加速
nvidia-smi

# 创建虚拟环境
python -m venv demucs-env
source demucs-env/bin/activate  # Linux/macOS
# demucs-env\Scripts\activate   # Windows

# 安装 Demucs
pip install -U demucs

# 验证安装
demucs --help

# 克隆仓库
git clone https://github.com/adefossez/demucs.git
cd demucs

# 从官方配置创建环境
conda env update -f environment-cuda.yml
conda activate demucs

# 开发模式安装
pip install -e .

# 验证 GPU 是否被检测到
python -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}')"

# Dockerfile
FROM pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

RUN pip install -U demucs

WORKDIR /audio
ENTRYPOINT ["demucs"]

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

version: '3.8'

services:
  demucs:
    build: .
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    volumes:
      - ./input:/audio/input:ro
      - ./output:/audio/output
    command: ["-n", "htdemucs_ft", "--mp3", "-o", "/audio/output", "/audio/input"]

# 使用默认模型的基础 4 音轨分离
demucs song.mp3

# 输出到 ./separated/htdemucs/song/
# 包含：drums.wav、bass.wav、other.wav、vocals.wav

# 使用微调模型获得更好质量
demucs -n htdemucs_ft song.mp3

# 只分离人声和伴奏
demucs --two-stems=vocals song.mp3

# 输出为 MP3（文件更小）
demucs --mp3 --mp3-bitrate 320 song.mp3

# 列出已下载的模型
ls ~/.cache/torch/hub/checkpoints/

# 预期输出包含：
# htdemucs-*.th, htdemucs_ft-*.th

# 检查将使用哪个模型
demucs -n htdemucs_ft --help | grep "name"

# 使用短音频文件快速测试
ffmpeg -f lavfi -i "sine=frequency=1000:duration=5" test_tone.wav
demucs -n htdemucs test_tone.wav

import subprocess
import os

def preprocess_for_rvc(input_song, output_dir):
    """为 RVC 声音转换提取干净的人声。"""
    os.makedirs(output_dir, exist_ok=True)

    # 步骤 1：使用 Demucs 分离
    subprocess.run([
        'demucs', '-n', 'htdemucs_ft',
        '--two-stems=vocals',
        '-o', output_dir,
        input_song
    ], check=True)

    # 步骤 2：返回隔离人声的路径
    base = os.path.splitext(os.path.basename(input_song))[0]
    vocals_path = os.path.join(
        output_dir, 'htdemucs_ft', base, 'vocals.wav'
    )
    return vocals_path

# 使用
vocals = preprocess_for_rvc('input.mp3', './separated')
# 将人声输入 RVC 进行声音转换

from demucs.api import Separator
import torchaudio

separator = Separator(model="htdemucs", device="cuda")

# 分离并提取人声
origin, separated = separator.separate_audio_file("reference.mp3")
vocals = separated["vocals"]

# 保存为 24kHz 供 GPT-SoVITS 使用
torchaudio.save("clean_reference.wav", vocals, 24000)

import gradio as gr
from demucs.api import Separator

separator = Separator(model="htdemucs_ft")

def separate(audio_file, stem):
    origin, separated = separator.separate_audio_file(audio_file)
    output_path = f"{stem}.wav"
    separator.save_audio(separated[stem], output_path, samplerate=44100)
    return output_path

demo = gr.Interface(
    fn=separate,
    inputs=[
        gr.Audio(type="filepath", label="上传歌曲"),
        gr.Dropdown(
            choices=["vocals", "drums", "bass", "other"],
            value="vocals",
            label="音轨"
        )
    ],
    outputs=gr.Audio(label="分离后的音轨"),
    title="Demucs 源分离",
    description="使用 Meta 的 Demucs 模型分离音乐音轨"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

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

# 加载模型
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = get_model("htdemucs_ft")
model.to(device)
model.eval()

# 加载音频
wav, sr = torchaudio.load("input.mp3")

# 确保立体声
if wav.shape[0] == 1:
    wav = wav.repeat(2, 1)

# 添加批次维度
mix = wav.unsqueeze(0).to(device)

# 使用优化设置进行分离
with torch.no_grad():
    sources = apply_model(
        model,
        mix,
        shifts=1,       # Shift trick：值越高质量越好，速度越慢
        split=True,     # 分块处理（长音频必需）
        overlap=0.25,   # 块之间的重叠
        segment=10,     # 段长度（秒）
        progress=True,
        device=device
    )[0]

# sources 形状：(num_sources, channels, samples)
source_names = model.sources  # ['drums', 'bass', 'other', 'vocals']

# 保存各音轨
for i, name in enumerate(source_names):
    torchaudio.save(f"{name}.wav", sources[i].cpu(), sr)

from pathlib import Path
import subprocess
import json

def batch_separate(input_dir, output_dir, model="htdemucs"):
    """处理目录中的所有音频文件。"""
    input_dir = Path(input_dir)
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    audio_exts = {'.mp3', '.wav', '.flac', '.ogg', '.m4a'}
    files = [f for f in input_dir.iterdir() if f.suffix in audio_exts]

    # 在单次 Demucs 调用中处理所有文件
    subprocess.run([
        'demucs', '-n', model,
        '-o', str(output_dir),
        '--mp3',
        '--mp3-bitrate', '320',
        *[str(f) for f in files]
    ], check=True)

    # 生成元数据清单
    manifest = {}
    for f in files:
        base = f.stem
        stem_dir = output_dir / model / base
        manifest[base] = {
            'drums': str(stem_dir / 'drums.mp3'),
            'bass': str(stem_dir / 'bass.mp3'),
            'other': str(stem_dir / 'other.mp3'),
            'vocals': str(stem_dir / 'vocals.mp3'),
        }

    with open(output_dir / 'manifest.json', 'w') as fp:
        json.dump(manifest, fp, indent=2)

    return manifest

# 使用
batch_separate('./raw_songs/', './stems/', model='htdemucs_ft')

# 强制 CPU 卸载大文件
import os
os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'

# 使用更小的分段
sources = apply_model(
    model,
    mix,
    split=True,
    segment=7,      # 从默认 ~10s 减少到 7s
    overlap=0.1,    # 减少重叠
    device=device
)[0]

import logging
import time

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('demucs')

def separate_with_metrics(input_path, output_dir):
    start = time.time()

    separator = Separator(model="htdemucs_ft", device="cuda")
    origin, separated = separator.separate_audio_file(input_path)

    duration = time.time() - start
    logger.info(f"分离 {input_path} 耗时 {duration:.1f} 秒")

    # 记录各音轨电平
    for name, audio in separated.items():
        rms = torch.sqrt(torch.mean(audio ** 2)).item()
        logger.info(f"  {name}: RMS={rms:.4f}")

    return separated