Разделение Demucs

Разделяйте музыку на вокал, ударные, бас и многое другое с помощью Demucs

Разделите музыку на стемы (вокал, ударные, бас, остальное) с помощью Demucs.

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

Аренда на CLORE.AI

1. Перейдите на маркетплейс CLORE.AI

2. Отфильтруйте по типу GPU, объёму VRAM и цене

3. Выберите On-Demand (фиксированная ставка) или Spot (цена ставки)

4. Настройте свой заказ:

   • Выберите Docker-образ

   • Установите порты (TCP для SSH, HTTP для веб-интерфейсов)

   • При необходимости добавьте переменные окружения

   • Введите команду запуска

5. Выберите способ оплаты: CLORE, BTC, или USDT/USDC

6. Создайте заказ и дождитесь развертывания

Получите доступ к своему серверу

• Найдите данные для подключения в Мои заказы

• Веб-интерфейсы: используйте URL HTTP-порта

• SSH: ssh -p <port> root@<proxy-address>

Что такое Demucs?

Demucs от Meta AI может:

• Разделять вокал и музыку

• Извлекать ударные, бас и другие инструменты

• Обрабатывать любой аудиоформат

• Извлечение стемов высокого качества

Быстрое развёртывание

Docker-образ:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Порты:

22/tcp
7860/http

Команда:

pip install demucs gradio && \
python -c "
import gradio as gr
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torch
import torchaudio
import tempfile
import os

model = get_model('htdemucs')
model.cuda()

def separate(audio_path, stem):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = {'drums': 0, 'bass': 1, 'other': 2, 'vocals': 3}
    output = sources[stems[stem]].cpu()

    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        torchaudio.save(f.name, output, sr)
        return f.name

demo = gr.Interface(
    fn=separate,
    inputs=[gr.Audio(type='filepath'), gr.Dropdown(['vocals', 'drums', 'bass', 'other'])],
    outputs=gr.Audio(),
    title='Аудиоразделитель Demucs'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"

Доступ к вашему сервису

После развертывания найдите свой http_pub URL в Мои заказы:

1. Перейдите на Мои заказы страницу

2. Нажмите на свой заказ

3. Найдите http_pub URL (например, abc123.clorecloud.net)

Используйте https://YOUR_HTTP_PUB_URL вместо localhost в примерах ниже.

Установка

pip install demucs

# или
pip install -e git+https://github.com/facebookresearch/demucs#egg=demucs

Использование в командной строке

Базовое разделение

# Разделить на 4 стема
demucs song.mp3

# Вывод: separated/htdemucs/song/{drums,bass,other,vocals}.wav

Параметры

demucs \
    --two-stems vocals \     # Только вокал + инструментал
    -n htdemucs \            # Имя модели
    -d cuda \                # Использовать GPU
    -o ./output \            # Каталог вывода
    --mp3 \                  # Вывод в формате MP3
    song.mp3

Обработка папки

demucs --two-stems vocals -d cuda ./songs/*.mp3

Python API

Базовое разделение

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

# Загрузить модель
model = get_model('htdemucs')
model.cuda()
model.eval()

# Загрузить аудио
wav, sr = torchaudio.load("song.mp3")
wav = wav.cuda()

# Разделить
with torch.no_grad():
    sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

# форма sources: [4, channels, samples]

# 0: ударные, 1: бас, 2: остальное, 3: вокал

# Сохранить стемы
stems = ['drums', 'bass', 'other', 'vocals']
for i, stem in enumerate(stems):
    torchaudio.save(f"{stem}.wav", sources[i].cpu(), sr)

Извлечь только вокал

def extract_vocals(audio_path):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    vocals = sources[3].cpu()  # Индекс 3 = вокал
    return vocals, sr

vocals, sr = extract_vocals("song.mp3")
torchaudio.save("vocals.wav", vocals, sr)

Извлечь инструментал (без вокала)

def extract_instrumental(audio_path):
    wav, sr = torchaudio.load(audio_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # Суммировать ударные + бас + остальное
    instrumental = sources[0] + sources[1] + sources[2]
    return instrumental.cpu(), sr

instrumental, sr = extract_instrumental("song.mp3")
torchaudio.save("instrumental.wav", instrumental, sr)

Варианты модели

Модель	Стемы	Качество	Скорость
htdemucs	4	Лучше всего	Средне
htdemucs_ft	4	Лучшее+	Медленно
htdemucs_6s	6	Отлично	Средне
mdx_extra	4	Отлично	Быстро

Модель с 6 стемами

model = get_model('htdemucs_6s')

# Стемы: ударные, бас, остальное, вокал, гитара, пианино

Дообученная модель

model = get_model('htdemucs_ft')

# Более высокое качество, но медленнее

Пакетная обработка

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

model = get_model('htdemucs')
model.cuda()
model.eval()

input_dir = "./songs"
output_dir = "./separated"

for filename in os.listdir(input_dir):
    if filename.endswith(('.mp3', '.wav', '.flac')):
        input_path = os.path.join(input_dir, filename)
        song_output_dir = os.path.join(output_dir, filename.rsplit('.', 1)[0])
        os.makedirs(song_output_dir, exist_ok=True)

        print(f"Обработка: {filename}")

        wav, sr = torchaudio.load(input_path)
        wav = wav.cuda()

        with torch.no_grad():
            sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

        stems = ['drums', 'bass', 'other', 'vocals']
        for i, stem in enumerate(stems):
            torchaudio.save(
                os.path.join(song_output_dir, f"{stem}.wav"),
                sources[i].cpu(),
                sr
            )

        print(f"Сохранено: {song_output_dir}")

API-сервер

from fastapi import FastAPI, UploadFile
from fastapi.responses import FileResponse
from demucs.pretrained import get_model
from demucs.apply import apply_model
import torchaudio
import torch
import tempfile
import os

app = FastAPI()

model = get_model('htdemucs')
model.cuda()
model.eval()

@app.post("/separate")
async def separate(file: UploadFile, stem: str = "vocals"):
    # Сохранить загруженный файл
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    # Загрузить и разделить
    wav, sr = torchaudio.load(tmp_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = {'drums': 0, 'bass': 1, 'other': 2, 'vocals': 3}
    output = sources[stems[stem]].cpu()

    # Сохранить результат
    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
        torchaudio.save(out.name, output, sr)
        return FileResponse(out.name, media_type="audio/wav")

@app.post("/instrumental")
async def get_instrumental(file: UploadFile):
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    wav, sr = torchaudio.load(tmp_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # Объединить невокальные стемы
    instrumental = sources[0] + sources[1] + sources[2]

    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
        torchaudio.save(out.name, instrumental.cpu(), sr)
        return FileResponse(out.name, media_type="audio/wav")

# Запуск: uvicorn server:app --host 0.0.0.0 --port 8000

Оптимизация памяти

Для длинного аудио

from demucs.apply import apply_model

# Использовать разбиение для длинного аудио
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,         # Разбить на чанки
    overlap=0.25,       # Перекрытие между чанками
    progress=True
)[0]

Для ограниченной VRAM

# Использовать CPU для некоторых операций
model.cpu()
wav = wav.cpu()

# Или использовать обработку сегментами
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,
    segment=10  # Сегменты по 10 секунд
)[0]

Сценарии использования

Караоке-трек

def create_karaoke(song_path):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    # Всё, кроме вокала
    karaoke = sources[0] + sources[1] + sources[2]
    return karaoke.cpu(), sr

Подготовка ремикса

def extract_all_stems(song_path, output_dir):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    stems = ['drums', 'bass', 'other', 'vocals']
    paths = {}

    for i, stem in enumerate(stems):
        path = os.path.join(output_dir, f"{stem}.wav")
        torchaudio.save(path, sources[i].cpu(), sr)
        paths[stem] = path

    return paths

Извлечение акапеллы

def extract_acapella(song_path):
    wav, sr = torchaudio.load(song_path)
    wav = wav.cuda()

    with torch.no_grad():
        sources = apply_model(model, wav.unsqueeze(0), split=True)[0]

    vocals = sources[3]
    return vocals.cpu(), sr

Советы по качеству

Для лучших результатов

• Используйте входные файлы без потерь (WAV, FLAC)

• Более высокая частота дискретизации = лучшее качество

• Используйте htdemucs_ft для критически важных задач

Постобработка

from pydub import AudioSegment
from pydub.effects import normalize, high_pass_filter

# Загрузить выделенный вокал
vocals = AudioSegment.from_wav("vocals.wav")

# Удалить низкочастотный гул
vocals = high_pass_filter(vocals, 80)

# Нормализовать
vocals = normalize(vocals)

vocals.export("vocals_clean.wav", format="wav")

Производительность

Длина аудио	GPU	Время
Песня 3 мин	RTX 3090	~15 с
Песня 3 мин	RTX 4090	~10 с
Песня 3 мин	A100	~8 с
Альбом 1 час	RTX 3090	~5 мин

Устранение неполадок

Недостаточно памяти

# Использовать более короткие сегменты
demucs --segment 10 song.mp3

Плохое разделение

• Используйте модель htdemucs_ft

• Проверьте качество входного файла

• Избегайте сильно сжатых MP3

Артефакты

• Увеличьте перекрытие

• Используйте модель более высокого качества

• Проверьте наличие клиппинга во входном файле

Оценка стоимости

Типичные цены на маркетплейсе CLORE.AI (по состоянию на 2024 год):

GPU	Почасовая ставка	Дневная ставка	4-часовая сессия
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40 ГБ	~$0.17	~$4.00	~$0.70
A100 80 ГБ	~$0.25	~$6.00	~$1.00

Цены зависят от провайдера и спроса. Проверьте маркетплейс CLORE.AI актуальные тарифы.

Сэкономьте деньги:

• Используйте Spot рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана ~13% скидки), остальные совпадают с ними

• Платите CLORE токенами

• Сравните цены у разных провайдеров

Дальнейшие шаги

• Клонирование голоса RVC - Обработать извлечённый вокал

• Музыка AudioCraft - Сгенерировать новую музыку

• Whisper Transcription - Распознать вокал