Instalar Demucs Localmente: Guía de Configuración Gratuita para Separación de Stems con IA

Demucs es el modelo de IA que impulsa la mayoría de las herramientas profesionales de separación de stems hoy en día — incluyendo StemSplit. Esta guía cubre todo desde la instalación hasta la arquitectura y el entrenamiento de modelos personalizados, escrita tanto para músicos curiosos como para ingenieros de ML.

TL;DR: Demucs es un modelo híbrido transformer de Meta AI que separa audio en voces, batería, bajo y otros instrumentos. Instala con pip install -U demucs, ejecuta con demucs tu_cancion.mp3, y obtén stems de calidad de estudio en minutos. Para mejores resultados, usa el modelo htdemucs_ft con aceleración GPU.

---

¿Qué Es Demucs?

Demucs (Deep Extractor for Music Sources) es un modelo de IA de código abierto desarrollado por Meta AI Research para separación de fuentes musicales. Toma una pista de audio mezclada y produce stems aislados — típicamente voces, batería, bajo y "otros" (todo lo demás).

Lo que hace significativo a Demucs:

• Calidad de vanguardia: Logra un SDR (Signal-to-Distortion Ratio) de 9.20 dB en el benchmark MUSDB18-HQ — más alto que cualquier modelo anterior
• Procesamiento basado en forma de onda: Funciona directamente en audio crudo, no solo espectrogramas, preservando información de fase
• Código abierto: Licencia MIT, gratuito para uso comercial y personal
• Probado en batalla: Impulsa la mayoría de los servicios profesionales de separación de stems

La última versión, Hybrid Transformer Demucs (HTDemucs), representa la cuarta iteración principal y combina lo mejor del procesamiento en dominio temporal y frecuencial.

---

La Evolución: v1 → v4

Entender la evolución de Demucs ayuda a explicar por qué funciona tan bien.

Demucs v1 (2019)

El Demucs original introdujo una arquitectura U-Net operando directamente en formas de onda — una desviación de los métodos solo espectrograma. Innovaciones clave:

• Unidades Lineales con Compuerta (GLUs) para activación
• LSTM bidireccional entre codificador y decodificador
• Conexiones de salto desde capas de codificador a decodificador

Arquitectura: U-Net de forma de onda pura con BiLSTM
SDR: ~6.3 dB en MUSDB18
Innovación: Primer modelo competitivo solo forma de onda

Demucs v2 (2020)

Mejoró la profundidad y el entrenamiento:

• Codificador/decodificador más profundo (6 capas → 7 capas)
• Mejor inicialización de pesos
• Mejoras en aumento de datos

SDR: ~6.8 dB en MUSDB18
Innovación: Probó que los modelos de forma de onda podían competir con métodos espectrograma

Demucs v3 / Hybrid Demucs (2021)

El avance: combinando procesamiento espectrograma y forma de onda:

• Arquitectura U-Net dual (una para dominio temporal, una para dominio frecuencial)
• Representaciones compartidas entre ramas
• Fusión entre dominios en el cuello de botella

SDR: ~7.5 dB en MUSDB18
Innovación: Lo mejor de ambos mundos — precisión espectrograma + fase forma de onda

Demucs v4 / HTDemucs (2022-2023)

El estado del arte actual, agregando Transformers:

• Capas Transformer tanto en codificador como decodificador
• Atención cruzada entre ramas temporal y espectral
• Auto-atención para dependencias de largo alcance

SDR: 9.20 dB en MUSDB18-HQ
Innovación: Los Transformers capturan estructura musical de largo alcance

---

Inmersión Profunda en Arquitectura

Para practicantes de ML: así es como HTDemucs realmente funciona.

Estructura de Alto Nivel

HTDemucs usa una arquitectura de doble ruta con dos ramas U-Net paralelas que comparten información:

Rama Temporal (Procesamiento de Forma de Onda)

La rama temporal procesa muestras de audio crudo:

1. Codificador: Pila de convoluciones 1D con stride que progresivamente reducen la resolución del audio
2. Cuello de Botella: BiLSTM + Auto-atención Transformer
3. Decodificador: Convoluciones transpuestas que aumentan la resolución de vuelta a la original
4. Conexiones de salto: Conexiones estilo U-Net desde codificador a decodificador

# Estructura simplificada de capa de codificador
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)  # Unidad Lineal con Compuerta
        
    def forward(self, x):
        x = self.conv(x)
        x = self.norm(x)
        x = self.glu(x)  # Salida es out_channels // 2
        return x

Rama Espectral (Procesamiento de Espectrograma)

La rama espectral procesa la Transformada de Fourier de Corto Tiempo (STFT) del audio:

1. Cálculo STFT: Convierte forma de onda a espectrograma complejo
2. Convoluciones 2D: Procesan representaciones frecuencia × tiempo
3. Capas Transformer: Auto-atención en dimensiones frecuencia y tiempo
4. STFT inversa: Convierte de vuelta a forma de onda

Parámetros clave:

• Ventana STFT: 4096 muestras
• Longitud de salto: 1024 muestras
• Bins de frecuencia: 2049 (para audio 44.1kHz)

Fusión Entre Dominios

La magia ocurre donde las ramas se comunican:

# Atención cruzada entre ramas (simplificado)
class CrossDomainAttention:
    def forward(self, temporal_features, spectral_features):
        # Temporal atiende a espectral
        temporal_out = self.temporal_cross_attn(
            query=temporal_features,
            key=spectral_features,
            value=spectral_features
        )
        
        # Espectral atiende a temporal
        spectral_out = self.spectral_cross_attn(
            query=spectral_features,
            key=temporal_features,
            value=temporal_features
        )
        
        return temporal_out, spectral_out

Por Qué Esta Arquitectura Funciona

1. Preservación de fase: La rama forma de onda mantiene relaciones de fase exactas — crítico para separación limpia
2. Precisión frecuencial: La rama espectral sobresale en separar instrumentos con perfiles de frecuencia distintos
3. Dependencias de largo alcance: Los Transformers modelan estructura musical (patrones verso-coro, motivos repetidos)
4. Características multi-escala: U-Net captura tanto detalle fino como contexto global

---

Modelos Disponibles Comparados

Demucs ofrece varios modelos preentrenados. Así es como se comparan:

Detalles del Modelo

htdemucs (predeterminado)

• El modelo Hybrid Transformer estándar
• Buen equilibrio calidad/velocidad
• Entrenado en dataset interno Meta + MUSDB18-HQ

htdemucs_ft (fine-tuned)

• Misma arquitectura, fine-tuned en datos adicionales
• Más alta calidad disponible
• Recomendado para trabajo de producción final

htdemucs_6s (6-stem)

• Separa en: voces, batería, bajo, guitarra, piano, otros
• Útil cuando necesitas guitarra o piano aislados
• Calidad ligeramente menor por-stem debido a tarea más difícil

mdx / mdx_extra

• Modelos de la competencia MDX 2021
• Usan enfoque conjunto "bolsa de modelos"
• Requisitos de VRAM más bajos

---

Requisitos del Sistema

Requisitos Mínimos

Estimaciones de Tiempo de Procesamiento

Para una pista estéreo de 4 minutos a 44.1kHz:

Uso de VRAM GPU

Los requisitos de VRAM dependen de la longitud del audio y el modelo:

Si te quedas sin VRAM, usa la bandera --segment para procesar en fragmentos más pequeños.

---

Guía de Instalación

¿Qué método de instalación es adecuado para ti?

Opción 1: pip (Más Simple)

Para la mayoría de usuarios que solo quieren separar pistas:

# Crea un entorno virtual (recomendado)
python3 -m venv demucs_env
source demucs_env/bin/activate  # Windows: demucs_env\Scripts\activate

# Instala Demucs
pip install -U demucs

# Verifica instalación
demucs --help

Deberías ver:

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

Opción 2: Conda (Recomendado para GPU)

Para aceleración GPU y desarrollo ML:

# Clona el repositorio
git clone https://github.com/facebookresearch/demucs
cd demucs

# Crea entorno (elige uno)
conda env update -f environment-cuda.yml  # Para GPU NVIDIA
conda env update -f environment-cpu.yml   # Solo CPU

# Activa entorno
conda activate demucs

# Instala en modo desarrollo
pip install -e .

# Verifica que GPU sea detectada (PyTorch: https://pytorch.org/)
python -c "import torch; print(f'CUDA disponible: {torch.cuda.is_available()}')"

Salida esperada con GPU:

CUDA disponible: True

Opción 3: Docker (Aislamiento Más Limpio)

Para entornos reproducibles:

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

RUN pip install -U demucs

WORKDIR /audio
ENTRYPOINT ["demucs"]

Construye y ejecuta:

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

Notas Específicas de Plataforma

macOS (Intel)

# Instala FFmpeg (requerido)
# Descarga desde: https://ffmpeg.org/download.html
brew install ffmpeg

# Instala SoundTouch (opcional, para aumento de datos)
brew install sound-touch

pip install -U demucs

macOS (Apple Silicon M1/M2/M3)

# FFmpeg (requerido para procesamiento de audio)
# Sitio oficial: https://ffmpeg.org/
brew install ffmpeg

# Instala con soporte MPS (Metal Performance Shaders)
pip install -U demucs

# Verifica que MPS esté disponible
python -c "import torch; print(f'MPS disponible: {torch.backends.mps.is_available()}')"

Usa la bandera --device mps al ejecutar Demucs.

Windows

# Usando Anaconda Prompt:
conda install -c conda-forge ffmpeg
pip install -U demucs soundfile

# Previene problemas de memoria CUDA
set PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128

Linux (Ubuntu/Debian)

# Dependencias del sistema
# FFmpeg: https://ffmpeg.org/
sudo apt-get update
sudo apt-get install ffmpeg libsndfile1

# Instala Demucs
pip install -U demucs

# Opcional: Previene problemas de caché de memoria CUDA
export PYTORCH_NO_CUDA_MEMORY_CACHING=1

---

Uso Básico

Separar una Pista

El comando más simple:

demucs cancion.mp3

Estructura de salida:

Casos de Uso Comunes

Extraer solo voces (creación de karaoke):

demucs --two-stems vocals cancion.mp3

Salida: vocals.wav y no_vocals.wav (instrumental)

Extraer solo instrumental:

demucs --two-stems vocals cancion.mp3
# Luego usa el archivo no_vocals.wav

Procesar múltiples archivos:

demucs cancion1.mp3 cancion2.mp3 cancion3.mp3

Salida como MP3 en lugar de WAV:

demucs --mp3 --mp3-bitrate 320 cancion.mp3

Usar modelo de más alta calidad:

demucs -n htdemucs_ft cancion.mp3

Especificar directorio de salida:

demucs -o ./mis_stems cancion.mp3

---

Opciones Avanzadas de Línea de Comandos

Aquí está cada bandera explicada:

Selección de Modelo

# Usar modelo específico
demucs -n htdemucs_ft cancion.mp3     # Mejor calidad
demucs -n htdemucs_6s cancion.mp3     # Salida 6-stem
demucs -n mdx_q cancion.mp3           # Más rápida/pequeña

Control de Dispositivo

# Forzar procesamiento CPU
demucs -d cpu cancion.mp3

# Usar GPU específica
demucs -d cuda:0 cancion.mp3          # Primera GPU
demucs -d cuda:1 cancion.mp3          # Segunda GPU

# Apple Silicon
demucs -d mps cancion.mp3

Compromisos Calidad vs Memoria

# Longitud de segmento (segundos) - menor = menos VRAM, potencialmente peor calidad
demucs --segment 10 cancion.mp3       # Para VRAM muy baja
demucs --segment 40 cancion.mp3       # Predeterminado para la mayoría de modelos

# Solapamiento entre segmentos (0-0.99)
demucs --overlap 0.25 cancion.mp3     # Predeterminado

# Shifts - aumenta calidad en ~0.2 SDR, pero más lento
demucs --shifts 2 cancion.mp3         # Procesa dos veces con desplazamientos temporales
demucs --shifts 5 cancion.mp3         # Más shifts = mejor calidad, más lento

Formato de Salida

# Opciones WAV
demucs --int24 cancion.mp3            # Salida WAV 24-bit
demucs --float32 cancion.mp3          # WAV 32-bit float

# Opciones MP3
demucs --mp3 cancion.mp3              # Bitrate predeterminado
demucs --mp3 --mp3-bitrate 320 cancion.mp3  # Alta calidad
demucs --mp3 --mp3-preset 2 cancion.mp3     # Preset mejor calidad
demucs --mp3 --mp3-preset 7 cancion.mp3     # Codificación más rápida

# Prevención de recorte
demucs --clip-mode rescale cancion.mp3      # Reescala para prevenir recorte
demucs --clip-mode clamp cancion.mp3        # Límite duro (predeterminado)
demucs --clip-mode none cancion.mp3         # Sin protección

Procesamiento Paralelo

# Número de trabajos paralelos (aumenta uso de memoria)
demucs -j 4 cancion.mp3               # Usa 4 núcleos
demucs -j 8 cancion1.mp3 cancion2.mp3    # Procesa múltiples archivos en paralelo

Ejemplo Completo

Máxima calidad, acelerado por GPU:

demucs \
  -n htdemucs_ft \
  -d cuda:0 \
  --shifts 2 \
  --overlap 0.25 \
  --float32 \
  --clip-mode rescale \
  -o ./salida \
  cancion.mp3

---

Integración API Python

Para integrar Demucs en tus aplicaciones:

Uso Programático Básico

import demucs.separate

# Usando lista de argumentos (como CLI)
demucs.separate.main([
    "--mp3",
    "--two-stems", "vocals",
    "-n", "htdemucs",
    "cancion.mp3"
])

Usando la Clase Separator

from demucs.api import Separator
import torch

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

# Carga y separa
origin, separated = separator.separate_audio_file("cancion.mp3")

# `separated` es un dict con valores tensor:
# separated["vocals"] -> torch.Tensor
# separated["drums"] -> torch.Tensor
# separated["bass"] -> torch.Tensor
# separated["other"] -> torch.Tensor

# Guarda stems individuales
from demucs.api import save_audio

for stem_name, stem_tensor in separated.items():
    save_audio(
        stem_tensor,
        f"salida/{stem_name}.wav",
        samplerate=separator.samplerate,
        clip="rescale"
    )

Acceso Directo al Modelo

Para practicantes de ML que quieren más control (requiere PyTorch):

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

# Carga modelo
model = pretrained.get_model("htdemucs_ft")
model.eval()

# Mueve a GPU si está disponible
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Carga audio
waveform, sample_rate = torchaudio.load("cancion.mp3")

# Asegura estéreo
if waveform.shape[0] == 1:
    waveform = waveform.repeat(2, 1)

# Agrega dimensión de batch y mueve a dispositivo
mix = waveform.unsqueeze(0).to(device)

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

# Obtiene nombres de fuentes
source_names = model.sources  # ['drums', 'bass', 'other', 'vocals']

Callback para Seguimiento de Progreso

from demucs.api import Separator

def progress_callback(info):
    """Llamado durante separación con información de progreso."""
    state = info.get("state", "")
    if state == "start":
        print(f"Procesando segmento en offset {info['segment_offset']}")
    elif state == "end":
        progress = info['segment_offset'] / info['audio_length'] * 100
        print(f"Progreso: {progress:.1f}%")

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

origin, separated = separator.separate_audio_file("cancion.mp3")

---

Entrenar Modelos Personalizados

Para investigadores y usuarios avanzados que quieren entrenar en datos personalizados.

Prerrequisitos

1. Clona el repositorio completo:

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

2. Instala Dora (gestor de experimentos de Meta):

pip install dora-search

Preparación del Dataset

Demucs típicamente se entrena en MUSDB18-HQ, que contiene:

• 150 canciones completas (100 entrenamiento, 50 prueba)
• Stems separados para cada canción
• Archivos WAV estéreo 44.1kHz

Descarga y establece ruta:

# Descarga MUSDB18-HQ desde Zenodo
# Establece variable de entorno
export MUSDB_PATH=/ruta/a/musdb18hq

Entrenar un Modelo

Comando de entrenamiento básico:

# Entrena usando Dora
dora run -d solver=htdemucs dset=musdb_hq

# Con configuración específica
dora run -d solver=htdemucs dset=musdb_hq \
    model.depth=6 \
    model.channels=48 \
    optim.lr=3e-4 \
    optim.epochs=360

Parámetros de entrenamiento explicados:

Fine-Tuning de un Modelo Existente

Para fine-tuning en datos personalizados:

1. Prepara tu dataset en formato MUSDB
2. Ejecuta fine-tuning:

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

Evaluación

Evalúa modelo en conjunto de prueba:

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

Salida incluye SDR (Signal-to-Distortion Ratio) por fuente:

Fuente      | SDR (dB)
------------|--------
vocals      | 8.99
drums       | 8.72
bass        | 7.84
other       | 5.09
------------|--------
promedio    | 7.66

---

Solución de Problemas Comunes

CUDA Sin Memoria

Error:

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

Soluciones:

# Usa segmentos más pequeños
demucs --segment 10 cancion.mp3

# Usa CPU en su lugar
demucs -d cpu cancion.mp3

# Usa un modelo más ligero
demucs -n mdx_q cancion.mp3

# Establece configuración de memoria PyTorch (Windows)
set PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128

# O en Linux/Mac
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128

Problemas de Descarga de Modelo

Error:

HTTPError: 404 Client Error: Not Found

Soluciones:

# Limpia caché y reintenta
rm -rf ~/.cache/torch/hub/checkpoints/
demucs cancion.mp3

# Descarga manual
# Los modelos se almacenan en: https://dl.fbaipublicfiles.com/demucs/

FFmpeg No Encontrado

Error:

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

Soluciones:

FFmpeg es requerido para conversión de formato de audio. Descarga desde el sitio oficial de FFmpeg o instala vía:

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt-get install ffmpeg

# Windows (vía conda)
conda install -c conda-forge ffmpeg

Módulo No Encontrado

Error:

ModuleNotFoundError: No module named 'demucs'

Soluciones:

# Asegura que entorno virtual esté activado
source demucs_env/bin/activate  # o conda activate demucs

# Reinstala
pip install -U demucs

Calidad de Separación Pobre

Síntomas: Artefactos, sangrado entre stems, salida turbia

Soluciones:

1. Usa archivos fuente de mayor calidad:

   • Sin pérdidas (WAV, FLAC) > MP3 alta tasa de bits (320kbps) > MP3 baja tasa de bits

2. Usa mejor modelo:

demucs -n htdemucs_ft cancion.mp3

3. Aumenta shifts (a costo de velocidad):

demucs --shifts 5 cancion.mp3

4. Verifica que fuente no esté ya muy procesada (limitación/compresión pesada daña separación)

---

¿No quieres solucionar entornos Python y controladores GPU? StemSplit ejecuta Demucs optimizado en la nube — vista previa 30 segundos gratis, sin configuración requerida.

---

Cuándo DIY Tiene Sentido

Seamos honestos sobre cuándo ejecutar Demucs localmente tiene sentido:

Comparación de Costos

DIY Demucs:

• Hardware: $0 (existente) a $800+ (actualización GPU)
• Electricidad: ~$0.01-0.05 por canción
• Tiempo: Configuración (1-4 horas) + tiempo de procesamiento
• Mantenimiento: Actualizaciones, solución de problemas

StemSplit:

• Sin configuración
• Paga por uso (créditos nunca expiran)
• Vista previa gratis antes de comprometerte
• Siempre usando últimos modelos

La Conversación Real

Si tú:

• Procesas stems profesionalmente y regularmente
• Tienes experiencia ML y quieres personalizar
• Necesitas procesar miles de archivos
• Tienes requisitos de privacidad para música no lanzada

→ Configura Demucs localmente.

Si tú:

• Necesitas stems ocasionalmente
• No quieres gestionar entornos Python
• Quieres vista previa de calidad antes de comprometerte
• Valoras conveniencia sobre optimización de costo

→ Usa un servicio como StemSplit.

---

Preguntas Frecuentes

¿Demucs es gratis?

Sí. Demucs es código abierto bajo licencia MIT, gratuito para uso personal y comercial. Los modelos también están disponibles gratuitamente.

¿Puedo usar Demucs comercialmente?

Sí. La licencia MIT permite uso comercial sin restricciones. Puedes usar stems separados en lanzamientos comerciales, construir productos sobre Demucs, etc.

¿Cuál es la diferencia entre Demucs y Spleeter?

Demucs produce calidad significativamente mayor pero requiere más cómputo.

¿Necesito una GPU?

No, pero ayuda significativamente. El procesamiento CPU funciona pero es 5-10x más lento. Se recomienda una GPU NVIDIA moderna con 4GB+ VRAM para tiempos de procesamiento razonables.

¿Cuánto tiempo toma el procesamiento?

Depende del hardware y modelo:

• GPU (RTX 3080): ~45 segundos para canción de 4 minutos
• CPU (i7 moderno): ~8-15 minutos para canción de 4 minutos

¿Qué formatos de audio soporta Demucs?

Entrada: MP3, WAV, FLAC, OGG, M4A, y cualquier cosa que FFmpeg pueda decodificar. Salida: WAV (predeterminado), MP3 (con bandera --mp3).

¿Por qué mis stems tienen artefactos?

Causas comunes:

1. Archivo fuente de baja calidad (usa 320kbps+ o sin pérdidas)
2. Master muy comprimido/limitado
3. Usando modelo más ligero (prueba htdemucs_ft)
4. Arreglo complejo y denso con frecuencias superpuestas

¿Demucs puede separar más de 4 stems?

Sí. Usa htdemucs_6s para separación 6-stem:

• Voces
• Batería
• Bajo
• Guitarra
• Piano
• Otros

¿Cómo actualizo Demucs?

pip install -U demucs

¿Dónde se descargan los modelos?

Los modelos se almacenan en caché en:

• Linux/Mac: ~/.cache/torch/hub/checkpoints/
• Windows: C:\Users\<usuario>\.cache\torch\hub\checkpoints\

---

Conclusión

Demucs representa la vanguardia de la separación de fuentes musicales impulsada por IA. Ya seas un productor aislando muestras, un investigador empujando los límites del ML de audio, o simplemente alguien que quiere crear una pista de karaoke, entender cómo funciona esta tecnología te da más control sobre tus resultados.

Para la mayoría de usuarios, el camino más fácil es usar un servicio que maneja la infraestructura. Para usuarios avanzados y practicantes de ML, ejecutar Demucs localmente ofrece máximo control y personalización.

---

¿Listo para Probar Separación de Stems?

Has visto cómo funciona la tecnología. Ahora experimenta.

Opción 1: Ejecútalo tú mismo — Sigue esta guía para configurar Demucs localmente.

Opción 2: Omite la configuración — StemSplit ejecuta Demucs htdemucs_ft en la nube. Sube tu canción, vista previa 30 segundos gratis, y descarga stems de calidad de estudio. Sin Python requerido.

Prueba StemSplit Gratis →

---

Lectura Adicional

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