Mejora audio: Demucs 6 stems + filtro pasa-altos y normalización

app.py

@@ -9,51 +9,42 @@ from audio_pipeline import (
     reducir_ruido
 )
 
-def procesar_wav(input_wav_path):
+def procesar_wav(input_wav_path: str):
     # 1) Separar 6 stems con Demucs
     stems_dir = separar_audio_demucs_6stems(input_wav_path)
 
-    # 2) Limpiar cada stem
+    # 2) Limpiar cada stem (_cleaned.wav)
     limpiar_stems(stems_dir)
 
-    # 3) Recoger rutas a los 5 stems limpios + preparar base
-    stems = {}
-    for stem in ["vocals", "drums", "bass", "guitar", "piano", "other"]:
-        stems[stem] = os.path.join(stems_dir, f"{stem}_cleaned.wav")
+    # 3) Recoger rutas a los 6 stems limpios
+    labels = ["vocals", "drums", "bass", "guitar", "piano", "other"]
+    stems_paths = [os.path.join(stems_dir, f"{lbl}_cleaned.wav") for lbl in labels]
 
-    # 4) Generar base instrumental (sin vocals)
+    # 4) Generar base instrumental (mezcla sin vocals)
     combinar_stems_sin_vocales(stems_dir)
     base_raw = os.path.join(stems_dir, "base_instrumental.wav")
 
-    # 5) Reducir ruido en la base
-    base_clean = os.path.join(stems_dir, "base_instrumental_clean.wav")
-    reducir_ruido(base_raw, base_clean)
-
-    # 6) Devolver primero los 6 stems (incluye guitarra) y luego la base limpia
-    return (
-        stems["vocals"],
-        stems["drums"],
-        stems["bass"],
-        stems["guitar"],
-        stems["piano"],
-        stems["other"],
-        base_clean
-    )
+    # 5) Reducir ruido y normalizar la base
+    clean_base = os.path.join(stems_dir, "base_instrumental_clean.wav")
+    reducir_ruido(base_raw, clean_base)
+
+    # 6) Devolver stems + base limpia
+    return (*stems_paths, clean_base)
 
 demo = gr.Interface(
     fn=procesar_wav,
     inputs=gr.Audio(label="Sube un archivo .wav", type="filepath"),
     outputs=[
-        gr.Audio(label="Vocals (limpio)", type="filepath"),
-        gr.Audio(label="Drums (limpio)", type="filepath"),
-        gr.Audio(label="Bass (limpio)", type="filepath"),
-        gr.Audio(label="Guitar (limpio)", type="filepath"),
-        gr.Audio(label="Piano (limpio)", type="filepath"),
-        gr.Audio(label="Other (limpio)", type="filepath"),
+        gr.Audio(label="Vocals limpio", type="filepath"),
+        gr.Audio(label="Drums limpio", type="filepath"),
+        gr.Audio(label="Bass limpio", type="filepath"),
+        gr.Audio(label="Guitar limpio", type="filepath"),
+        gr.Audio(label="Piano limpio", type="filepath"),
+        gr.Audio(label="Other limpio", type="filepath"),
         gr.Audio(label="Base instrumental limpia", type="filepath"),
     ],
-    title="Stem Separation con Demucs (6 stems) + Base limpia",
-    description="Obtén vocals, drums, bass, guitar, piano, other y la base instrumental limpia."
+    title="Demucs 6-stems + Calidad Mejorada",
+    description="Sube tu WAV y obtén 6 stems limpios (incluye guitarra) más la base instrumental mejorada."
 )
 
 if __name__ == "__main__":

audio_pipeline.py

@@ -1,3 +1,5 @@
+# audio_pipeline.py
+
 import os
 import subprocess
 import sys
@@ -8,101 +10,38 @@ import librosa
 import numpy as np
 import soundfile as sf
 import noisereduce as nr
+from scipy.signal import butter, sosfilt
 
 # Suprime warnings de runtime (p.ej. invalid value encountered in divide)
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 
-# Directorio base donde guardaremos todos los stems
+# Carpeta raíz donde guardamos stems
 BASE_STEMS_DIR = "data/stems"
 
-def separar_audio_demucs_6stems(input_file, model="htdemucs_6s"):
+
+def highpass_filter(y: np.ndarray, sr: int, cutoff: float = 100.0, order: int = 4) -> np.ndarray:
     """
-    Separa 6 stems con Demucs (vocals, drums, bass, guitar, piano, other),
-    los guarda en data/stems/<model>/<track_folder>/ y devuelve la ruta de ese folder.
+    Aplica un filtro Butterworth de paso alto a la señal.
+    Recorta frecuencias por debajo de `cutoff` Hz para mayor claridad.
     """
-    out_root = os.path.join(BASE_STEMS_DIR, model)
-    os.makedirs(out_root, exist_ok=True)
-
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    cmd = [
-        sys.executable,
-        "-m", "demucs",
-        "-n", model,
-        "--out", out_root,
-        "--device", device,
-        input_file
-    ]
-    subprocess.run(cmd, check=True)
-
-    # Demucs crea un subdirectorio con el nombre de la pista dentro de out_root
-    # Encuentra el primer subdirectorio que contenga archivos .wav
-    for entry in os.listdir(out_root):
-        candidate = os.path.join(out_root, entry)
-        if os.path.isdir(candidate):
-            # Verifica que tenga stems
-            wavs = [f for f in os.listdir(candidate) if f.endswith('.wav')]
-            if wavs:
-                return candidate
-    raise FileNotFoundError(f"No se encontró el folder de stems en {out_root}")
-
-def limpiar_stems(stems_dir):
-    """Aplica reducción de ruido a cada stem (_cleaned.wav)."""
-    for archivo in os.listdir(stems_dir):
-        if archivo.endswith(".wav"):
-            ruta = os.path.join(stems_dir, archivo)
-            y, sr = librosa.load(ruta, sr=None)
-            reduced = nr.reduce_noise(y=y, sr=sr)
-            sf.write(ruta.replace(".wav", "_cleaned.wav"), reduced, sr)
-
-def combinar_stems_sin_vocales(stems_dir):
-    """Mezcla todos los stems limpios excepto vocals en base_instrumental.wav."""
-    wavs = [
-        f for f in os.listdir(stems_dir)
-        if f.endswith("_cleaned.wav") and "vocals" not in f.lower()
-    ]
-    if not wavs:
-        wavs = [
-            f for f in os.listdir(stems_dir)
-            if f.endswith(".wav") and "vocals" not in f.lower()
-        ]
-    signals = []
-    for w in wavs:
-        y, sr = librosa.load(os.path.join(stems_dir, w), sr=None)
-        signals.append(y)
-    if not signals:
-        raise RuntimeError("No se encontraron stems para combinar.")
-    maxlen = max(len(s) for s in signals)
-    mix = sum(np.pad(s, (0, maxlen - len(s))) for s in signals) / len(signals)
-    sf.write(os.path.join(stems_dir, "base_instrumental.wav"), mix, sr)
+    sos = butter(order, cutoff, btype="highpass", fs=sr, output="sos")
+    return sosfilt(sos, y)
 
-def reducir_ruido(input_file, output_file, noise_duration=0.5):
-    """Reduce ruido y guarda el resultado."""
-    y, sr = librosa.load(input_file, sr=None)
-    noise = y[:int(sr * noise_duration)]
-    with np.errstate(divide='ignore', invalid='ignore'):
-        reduced = nr.reduce_noise(y=y, sr=sr, y_noise=noise)
-    reduced = np.nan_to_num(reduced)
-    sf.write(output_file, reduced, sr)
-import os
-import subprocess
-import sys
-import torch
-import warnings
-import librosa
-import numpy as np
-import soundfile as sf
-import noisereduce as nr
 
-warnings.filterwarnings("ignore", category=RuntimeWarning)
+def normalize(y: np.ndarray) -> np.ndarray:
+    """
+    Normaliza la señal para que su pico absoluto sea 1.0,
+    manteniendo la relación de amplitudes.
+    """
+    peak = np.max(np.abs(y)) or 1.0
+    return y / peak
 
-BASE_STEMS_DIR = "data/stems"
 
-def separar_audio_demucs_6stems(input_file, model="htdemucs_6s"):
+def separar_audio_demucs_6stems(input_file: str, model: str = "htdemucs_6s") -> str:
     """
-    Separa 6 stems con Demucs (vocals, drums, bass, guitar, piano, other),
-    busca recursivamente la carpeta con .wav y la devuelve.
+    Usa Demucs para separar en 6 stems (vocals, drums, bass, guitar, piano, other).
+    Devuelve la ruta al directorio donde están los .wav resultantes.
     """
-    base = os.path.splitext(os.path.basename(input_file))[0]
     out_root = os.path.join(BASE_STEMS_DIR, model)
     os.makedirs(out_root, exist_ok=True)
 
@@ -116,26 +55,46 @@ def separar_audio_demucs_6stems(input_file, model="htdemucs_6s"):
     ]
     subprocess.run(cmd, check=True)
 
-    # Ahora buscamos recursivamente el primer directorio que contenga .wav
-    for root, dirs, files in os.walk(out_root):
+    # Busca recursivamente el primer folder con .wav
+    for root, _, files in os.walk(out_root):
         if any(f.endswith(".wav") for f in files):
             return root
 
-    # Si no aparece ninguno, error
     raise FileNotFoundError(f"No se encontró el folder de stems en {out_root}")
 
 
-def limpiar_stems(stems_dir):
-    """Aplica reducción de ruido a cada stem (_cleaned.wav)."""
+def limpiar_stems(stems_dir: str) -> None:
+    """
+    Para cada stem:
+      1) Reduce ruido
+      2) Filtro pasa-altos
+      3) Normaliza
+      4) Guarda como *_cleaned.wav
+    """
     for archivo in os.listdir(stems_dir):
         if archivo.endswith(".wav"):
-            ruta = os.path.join(stems_dir, archivo)
-            y, sr = librosa.load(ruta, sr=None)
-            reduced = nr.reduce_noise(y=y, sr=sr)
-            sf.write(ruta.replace(".wav", "_cleaned.wav"), reduced, sr)
+            ruta_in = os.path.join(stems_dir, archivo)
+            y, sr = librosa.load(ruta_in, sr=None)
+
+            # 1) reducción de ruido
+            y_denoised = nr.reduce_noise(y=y, sr=sr)
+
+            # 2) paso alto
+            y_hp = highpass_filter(y_denoised, sr, cutoff=100.0)
+
+            # 3) normalización
+            y_norm = normalize(y_hp)
 
-def combinar_stems_sin_vocales(stems_dir):
-    """Mezcla todos los stems limpios excepto vocals en base_instrumental.wav."""
+            # 4) guardar
+            ruta_out = ruta_in.replace(".wav", "_cleaned.wav")
+            sf.write(ruta_out, y_norm, sr)
+
+
+def combinar_stems_sin_vocales(stems_dir: str) -> None:
+    """
+    Mezcla todos los stems *_cleaned.wav excepto 'vocals'
+    en un único archivo 'base_instrumental.wav'.
+    """
     wavs = [
         f for f in os.listdir(stems_dir)
         if f.endswith("_cleaned.wav") and "vocals" not in f.lower()
@@ -145,21 +104,34 @@ def combinar_stems_sin_vocales(stems_dir):
             f for f in os.listdir(stems_dir)
             if f.endswith(".wav") and "vocals" not in f.lower()
         ]
+
     signals = []
+    sr = None
     for w in wavs:
         y, sr = librosa.load(os.path.join(stems_dir, w), sr=None)
         signals.append(y)
-    if not signals:
+
+    if not signals or sr is None:
         raise RuntimeError("No se encontraron stems para combinar.")
+
     maxlen = max(len(s) for s in signals)
     mix = sum(np.pad(s, (0, maxlen - len(s))) for s in signals) / len(signals)
     sf.write(os.path.join(stems_dir, "base_instrumental.wav"), mix, sr)
 
-def reducir_ruido(input_file, output_file, noise_duration=0.5):
-    """Reduce ruido y guarda el resultado."""
+
+def reducir_ruido(input_file: str, output_file: str, noise_duration: float = 0.5) -> None:
+    """
+    Procesa un WAV completo:
+      1) Reduce ruido usando los primeros `noise_duration` s
+      2) Aplica filtro pasa-altos
+      3) Normaliza
+      4) Guarda en output_file
+    """
     y, sr = librosa.load(input_file, sr=None)
     noise = y[:int(sr * noise_duration)]
-    with np.errstate(divide='ignore', invalid='ignore'):
-        reduced = nr.reduce_noise(y=y, sr=sr, y_noise=noise)
-    reduced = np.nan_to_num(reduced)
-    sf.write(output_file, reduced, sr)
+    y_denoised = nr.reduce_noise(y=y, sr=sr, y_noise=noise)
+
+    y_hp = highpass_filter(y_denoised, sr, cutoff=100.0)
+    y_norm = normalize(y_hp)
+
+    sf.write(output_file, y_norm, sr)