> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/demucs-separation.md).

# Separación con Demucs

Separa música en voces, batería, bajo y más con Demucs

Separa la música en stems (voz, batería, bajo, otros) con Demucs.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es Demucs?

Demucs de Meta AI puede:

* Separar las voces de la música
* Extraer batería, bajo y otros instrumentos
* Procesar cualquier formato de audio
* Extracción de stems de alta calidad

## Despliegue rápido

**Imagen de Docker:**

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

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
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='Separador de audio Demucs'
)
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Instalación

```bash
pip install demucs

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

## Uso en línea de comandos

### Separación básica

```bash

# Separar en 4 stems
demucs song.mp3

# Salida: separated/htdemucs/song/{drums,bass,other,vocals}.wav
```

### Opciones

```bash
demucs \\
    --two-stems vocals \     # Solo voces + instrumental
    -n htdemucs \            # Nombre del modelo
    -d cuda \                # Usar GPU
    -o ./output \            # Directorio de salida
    --mp3 \                  # Salida como MP3
    song.mp3
```

### Procesar carpeta

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

## API de Python

### Separación básica

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

# Cargar modelo
model = get_model('htdemucs')
model.cuda()
model.eval()

# Cargar audio
wav, sr = torchaudio.load("song.mp3")
wav = wav.cuda()

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

# forma de sources: [4, canales, muestras]

# 0: batería, 1: bajo, 2: otros, 3: voces

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

### Obtener solo voces

```python
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()  # Índice 3 = voces
    return vocals, sr

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

### Obtener instrumental (sin voces)

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

    # Sumar batería + bajo + otros
    instrumental = sources[0] + sources[1] + sources[2]
    return instrumental.cpu(), sr

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

## Variantes del modelo

| Modelo       | Stems | Calidad   | Velocidad |
| ------------ | ----- | --------- | --------- |
| htdemucs     | 4     | Mejor     | Medio     |
| htdemucs\_ft | 4     | Best+     | Lento     |
| htdemucs\_6s | 6     | Excelente | Medio     |
| mdx\_extra   | 4     | Excelente | Rápido    |

### Modelo de 6 stems

```python
model = get_model('htdemucs_6s')

# Stems: batería, bajo, otros, voces, guitarra, piano
```

### Modelo ajustado

```python
model = get_model('htdemucs_ft')

# Mayor calidad pero más lento
```

## Procesamiento por lotes

```python
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"Procesando: {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"Guardado: {song_output_dir}")
```

## Servidor API

```python
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"):
    # Guardar archivo subido
    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name

    # Cargar y separar
    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()

    # Guardar salida
    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]

    # Combinar stems no vocales
    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")

# Ejecutar: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Optimización de memoria

### Para audio largo

```python
from demucs.apply import apply_model

# Usar división para audio largo
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,         # Dividir en fragmentos
    overlap=0.25,       # Solapamiento entre fragmentos
    progress=True
)[0]
```

### Para VRAM limitada

```python

# Usar CPU para algunas operaciones
model.cpu()
wav = wav.cpu()

# O usar procesamiento por segmentos
sources = apply_model(
    model,
    wav.unsqueeze(0),
    split=True,
    segment=10  # segmentos de 10 segundos
)[0]
```

## Casos de uso

### Pista de karaoke

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

    # Todo excepto las voces
    karaoke = sources[0] + sources[1] + sources[2]
    return karaoke.cpu(), sr
```

### Preparación de remix

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

### Extracción de a cappella

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

## Consejos de calidad

### Para mejores resultados

* Usa entrada sin pérdida (WAV, FLAC)
* Una frecuencia de muestreo más alta = mejor calidad
* Usa `htdemucs_ft` para trabajos críticos

### Posprocesamiento

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

# Cargar voz separada
vocals = AudioSegment.from_wav("vocals.wav")

# Eliminar retumbe de baja frecuencia
vocals = high_pass_filter(vocals, 80)

# Normalizar
vocals = normalize(vocals)

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

## Rendimiento

| Duración del audio | GPU      | Tiempo  |
| ------------------ | -------- | ------- |
| Canción de 3 min   | RTX 3090 | \~15s   |
| Canción de 3 min   | RTX 4090 | \~10 s  |
| Canción de 3 min   | A100     | \~8s    |
| Álbum de 1 hora    | RTX 3090 | \~5 min |

## Solución de problemas

### Sin memoria

```bash

# Usar segmentos más pequeños
demucs --segment 10 song.mp3
```

### Separación deficiente

* Usa el modelo htdemucs\_ft
* Comprueba la calidad de entrada
* Evita MP3 muy comprimidos

### Artefactos

* Aumenta el solapamiento
* Usa un modelo de mayor calidad
* Comprueba si hay clipping en la entrada

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| 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 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores

## Siguientes pasos

* [RVC Voice Clone](/guides/guides_v2-es/audio-y-voz/rvc-voice-clone.md) - Procesar las voces extraídas
* [Música AudioCraft](/guides/guides_v2-es/audio-y-voz/audiocraft-music.md) - Generar nueva música
* [Whisper Transcription](/guides/guides_v2-es/audio-y-voz/whisper-transcription.md) - Transcribir las voces


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/demucs-separation.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.