---
title: "Instalar Demucs Localmente: Guía de Configuración Gratuita para Separación de Stems con IA"
date: "2026-01-11"
lastUpdated: "2026-01-29"
author: "StemSplit Team"
tags: ["Demucs", "IA", "aprendizaje automático", "separación de stems", "tutorial", "Meta AI", "htdemucs", "aprendizaje profundo"]
excerpt: "Guía paso a paso para instalar Demucs en tu computadora para separación gratuita de stems. Extrae voces, batería y bajo localmente con aceleración GPU. Sin necesidad de nube."
abstract: "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."
locale: "es"
canonical: "https://stemsplit.io/es/blog/demucs-local-setup-guide"
source: "stemsplit.io"
---

> **Source:** https://stemsplit.io/es/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 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](https://ai.meta.com/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)](https://en.wikipedia.org/wiki/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](https://opensource.org/licenses/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.

![Línea de Tiempo de Evolución de Demucs - De v1 a v4 mostrando mejoras SDR](/images/blog/demucs-evolution-timeline.svg)

### Demucs v1 (2019)

El Demucs original introdujo una [arquitectura U-Net](https://en.wikipedia.org/wiki/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:

![Arquitectura HTDemucs - Modelo de doble ruta con ramas temporal y espectral](/images/blog/htdemucs-architecture.svg)

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

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

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

![Comparación de Modelos Demucs - Calidad vs Velocidad vs VRAM](/images/blog/demucs-models-comparison.svg)

| Modelo | Stems | SDR (voces) | SDR (prom) | Velocidad | VRAM | Mejor Para |
|--------|-------|-------------|------------|----------|------|------------|
| `htdemucs` | 4 | 8.99 dB | 7.66 dB | Rápida | ~4GB | Uso general, buen equilibrio |
| `htdemucs_ft` | 4 | **9.20 dB** | **7.93 dB** | Lenta | ~6GB | **Mejor calidad** |
| `htdemucs_6s` | 6 | 8.83 dB | N/A | Media | ~5GB | Separación guitarra/piano |
| `mdx` | 4 | 8.5 dB | 7.2 dB | Rápida | ~3GB | Sistemas con VRAM baja |
| `mdx_extra` | 4 | 8.7 dB | 7.4 dB | Media | ~4GB | Mejor que mdx |
| `mdx_q` | 4 | 8.3 dB | 7.0 dB | Más rápida | ~2GB | Vistas previas rápidas |

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

| Componente | Mínimo | Recomendado |
|------------|--------|-------------|
| CPU | Cualquier x86_64 moderno | 4+ núcleos |
| RAM | 8 GB | 16 GB |
| GPU | Ninguna (CPU funciona) | NVIDIA 4GB+ VRAM |
| Almacenamiento | 2 GB | 5 GB (para modelos) |
| Python | 3.8+ | 3.10+ |

### Estimaciones de Tiempo de Procesamiento

![Tiempo de Procesamiento de Demucs por Hardware - Comparación de rendimiento en diferentes sistemas](/images/blog/demucs-processing-times.svg)

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

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

### Uso de VRAM GPU

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

![Uso de VRAM por Modelo y Longitud de Audio - Requisitos de memoria GPU para diferentes modelos Demucs](/images/blog/demucs-vram-usage.svg)

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?**

![Árbol de Decisión de Método de Instalación - Elige la mejor configuración para tus necesidades](/images/blog/demucs-installation-flowchart.svg)

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

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

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

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

RUN pip install -U demucs

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

Construye y ejecuta:

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

### Notas Específicas de Plataforma

#### macOS (Intel)

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

```bash
# 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

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

```bash
# 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

```

---

## Uso Básico

### Separar una Pista

El comando más simple:

```bash
demucs cancion.mp3
```

Estructura de salida:

![Estructura de carpeta de salida Demucs mostrando stems separados](/images/blog/demucs-output-structure.svg)

### Casos de Uso Comunes

**Extraer solo voces (creación de karaoke):**

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

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

**Extraer solo instrumental:**

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

**Procesar múltiples archivos:**

```bash
demucs cancion1.mp3 cancion2.mp3 cancion3.mp3
```

**Salida como MP3 en lugar de WAV:**

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

**Usar modelo de más alta calidad:**

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

**Especificar directorio de salida:**

```bash
demucs -o ./mis_stems cancion.mp3
```

---

## Opciones Avanzadas de Línea de Comandos

Aquí está cada bandera explicada:

![Referencia Rápida de Línea de Comandos Demucs - Todas las banderas y opciones explicadas](/images/blog/demucs-cli-cheatsheet.svg)

### Selección de Modelo

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

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

```bash
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

```python
import demucs.separate

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

### Usando la Clase Separator

```python
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](https://pytorch.org/)):

```python
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

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

```bash
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](https://github.com/facebookresearch/dora) (gestor de experimentos de Meta):

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

### Preparación del Dataset

Demucs típicamente se entrena en [MUSDB18-HQ](https://zenodo.org/record/3338373), 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:

```bash
# Descarga MUSDB18-HQ desde Zenodo
# Establece variable de entorno

```

### Entrenar un Modelo

Comando de entrenamiento básico:

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

| Parámetro | Descripción | Predeterminado |
|-----------|-------------|----------------|
| `model.depth` | Profundidad codificador/decodificador | 6 |
| `model.channels` | Recuento de canales base | 48 |
| `model.growth` | Factor de crecimiento de canales | 2 |
| `optim.lr` | Tasa de aprendizaje | 3e-4 |
| `optim.epochs` | Épocas de entrenamiento | 360 |
| `optim.batch_size` | Tamaño de batch | 4 |

### Fine-Tuning de un Modelo Existente

Para fine-tuning en datos personalizados:

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

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

### Evaluación

Evalúa modelo en conjunto de prueba:

```bash
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
```

---

![Guía de Solución de Problemas Demucs - Soluciones rápidas a problemas comunes](/images/blog/demucs-troubleshooting.svg)

## Solución de Problemas Comunes

### CUDA Sin Memoria

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

**Soluciones:**

```bash
# 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

```

### Problemas de Descarga de Modelo

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

**Soluciones:**

```bash
# 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](https://ffmpeg.org/download.html) o instala vía:

```bash
# 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:**

```bash
# 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:
```bash
demucs -n htdemucs_ft cancion.mp3
```

3. Aumenta shifts (a costo de velocidad):
```bash
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](/stem-splitter) 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 DIY vs Servicio en Nube - Haz la elección correcta para tu flujo de trabajo](/images/blog/demucs-diy-vs-cloud.svg)

| Escenario | DIY Demucs | Servicio en Nube (StemSplit) |
|-----------|------------|------------------------------|
| **Volumen de procesamiento** | Alto volumen (100+ canciones) | Uso ocasional |
| **Hardware** | Tienes una buena GPU | Solo CPU o sin GPU |
| **Habilidad técnica** | Cómodo con Python/CLI | Prefieres GUI |
| **Requisitos de privacidad** | Necesitas mantener audio local | Nube es aceptable |
| **Presupuesto** | Tienes tiempo, no dinero | Tienes dinero, no tiempo |
| **Personalización** | Necesitas fine-tune modelos | Separación estándar está bien |
| **Vista previa antes de pagar** | No disponible | Vista previa gratis 30 seg |

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

| Aspecto | Demucs | Spleeter |
|---------|--------|----------|
| Desarrollador | Meta AI | Deezer |
| Arquitectura | Hybrid Transformer | U-Net Simple |
| Calidad (SDR) | ~9.2 dB | ~5.9 dB |
| Procesamiento | Forma de onda + Espectrograma | Solo espectrograma |
| Velocidad | Más lento | Más rápido |
| Lanzado | 2019 (v1), 2023 (v4) | 2019 |

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?

```bash
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](/stem-splitter) 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 →](/vocal-remover)

---

## Lectura Adicional

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