Update app.py

app.py

@@ -1,408 +1,474 @@
-import gradio as gr
-import torch
-import torchaudio
-import numpy as np
-import tempfile
 import os
-import zipfile
-from huggingface_hub import hf_hub_download
-import subprocess
-import sys
+import gc
+import tempfile
+import warnings
+import traceback
+import numpy as np
+import librosa
+import soundfile as sf
+import torch
+import torch.nn as nn
+import gradio as gr
+from tqdm import tqdm
 
-def install_package(package):
-    """Instala paquete si no existe"""
-    try:
-        __import__(package)
-    except ImportError:
-        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+warnings.filterwarnings("ignore")
 
-# Instalar dependencias necesarias
-install_package('librosa')
-install_package('soundfile')
+# Configuración
+SAMPLE_RATE = 44100
+MAX_FILE_SIZE_MB = 50
 
-import librosa
-import soundfile as sf
+# Arquitectura del modelo MDX simplificada
+class MDXNet(nn.Module):
+    def __init__(self, dim_f=2048, dim_t=256, n_fft=6144, hop=1024, num_channels=2):
+        super(MDXNet, self).__init__()
+        self.dim_f = dim_f
+        self.dim_t = dim_t
+        self.n_fft = n_fft
+        self.hop = hop
+        self.num_channels = num_channels
+        
+        # Encoder
+        self.encoder = nn.Sequential(
+            nn.Conv2d(4, 48, 3, padding=1),
+            nn.BatchNorm2d(48),
+            nn.ReLU(),
+            nn.Conv2d(48, 48, 3, padding=1),
+            nn.BatchNorm2d(48),
+            nn.ReLU(),
+        )
+        
+        # Decoder
+        self.decoder = nn.Sequential(
+            nn.Conv2d(48, 48, 3, padding=1),
+            nn.BatchNorm2d(48),
+            nn.ReLU(),
+            nn.Conv2d(48, 4, 3, padding=1),
+            nn.Sigmoid(),
+        )
+        
+        self.window = torch.hann_window(n_fft)
+        
+    def stft(self, x):
+        """Short-time Fourier transform"""
+        x = x.reshape(-1, x.shape[-1])
+        spec = torch.stft(
+            x, 
+            n_fft=self.n_fft, 
+            hop_length=self.hop, 
+            window=self.window.to(x.device),
+            return_complex=True
+        )
+        
+        # Convert to magnitude and phase
+        mag = torch.abs(spec).unsqueeze(1)
+        phase = torch.angle(spec).unsqueeze(1)
+        
+        # Stack real and imaginary parts
+        real = spec.real.unsqueeze(1)
+        imag = spec.imag.unsqueeze(1)
+        
+        return torch.cat([real, imag, mag, phase], dim=1)
+    
+    def istft(self, x, length=None):
+        """Inverse Short-time Fourier transform"""
+        real, imag = x[:, 0], x[:, 1]
+        complex_spec = torch.complex(real, imag)
+        
+        audio = torch.istft(
+            complex_spec,
+            n_fft=self.n_fft,
+            hop_length=self.hop,
+            window=self.window.to(x.device),
+            length=length
+        )
+        
+        return audio
+    
+    def forward(self, x):
+        length = x.shape[-1]
+        
+        # STFT
+        spec = self.stft(x)
+        
+        # Limit frequency dimension
+        spec = spec[:, :, :self.dim_f]
+        
+        # Process through network
+        encoded = self.encoder(spec)
+        mask = self.decoder(encoded)
+        
+        # Apply mask to magnitude
+        masked_spec = spec * mask
+        
+        # Pad back to original frequency dimension if needed
+        if masked_spec.shape[2] < self.n_fft // 2 + 1:
+            pad_size = self.n_fft // 2 + 1 - masked_spec.shape[2]
+            pad = torch.zeros(masked_spec.shape[0], masked_spec.shape[1], pad_size, masked_spec.shape[3]).to(masked_spec.device)
+            masked_spec = torch.cat([masked_spec, pad], dim=2)
+        
+        # ISTFT
+        output = self.istft(masked_spec, length=length)
+        
+        return output
 
-class RealAISeparator:
+class AudioSeparator:
     def __init__(self):
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"🔧 Dispositivo: {self.device}")
+        print(f"🔧 Usando dispositivo: {self.device}")
         
-    def download_model(self, model_type="vocals"):
-        """Descarga modelo preentrenado desde HuggingFace"""
-        try:
-            if model_type == "vocals":
-                # Modelo para separación vocal/instrumental
-                model_path = hf_hub_download(
-                    repo_id="JorisCos/DPTNet_Libri1Mix_enhsingle_16k",
-                    filename="best_model.pth"
-                )
-            else:
-                # Modelo más general si está disponible
-                model_path = None
-            
-            return model_path
-        except Exception as e:
-            print(f"Error descargando modelo: {e}")
-            return None
+        # Configuraciones para diferentes tipos de separación
+        self.models = {
+            'vocals': {
+                'dim_f': 2048,
+                'dim_t': 256,
+                'n_fft': 6144,
+                'compensation': 1.035
+            },
+            'drums': {
+                'dim_f': 2048,
+                'dim_t': 128,
+                'n_fft': 4096,
+                'compensation': 1.040
+            },
+            'bass': {
+                'dim_f': 2048,
+                'dim_t': 512,
+                'n_fft': 16384,
+                'compensation': 1.030
+            },
+            'other': {
+                'dim_f': 2048,
+                'dim_t': 256,
+                'n_fft': 6144,
+                'compensation': 1.025
+            }
+        }
+        
+    def load_model(self, model_type='vocals'):
+        """Cargar modelo para tipo específico de separación"""
+        config = self.models.get(model_type, self.models['vocals'])
+        model = MDXNet(
+            dim_f=config['dim_f'],
+            dim_t=config['dim_t'],
+            n_fft=config['n_fft']
+        ).to(self.device)
+        
+        # Inicializar con pesos aleatorios (en un caso real cargarías pesos entrenados)
+        model.eval()
+        return model, config['compensation']
     
-    def separate_with_pretrained(self, audio_path):
-        """Separación usando modelo preentrenado real"""
+    def preprocess_audio(self, audio_path):
+        """Cargar y preprocesar audio"""
         try:
-            print(f"🎵 Cargando audio para IA: {audio_path}")
+            # Verificar tamaño del archivo
+            file_size = os.path.getsize(audio_path) / (1024 * 1024)
+            if file_size > MAX_FILE_SIZE_MB:
+                raise ValueError(f"Archivo muy grande: {file_size:.1f}MB (máximo {MAX_FILE_SIZE_MB}MB)")
+            
+            # Cargar audio
+            audio, sr = librosa.load(audio_path, sr=SAMPLE_RATE, mono=False)
             
-            # Cargar audio con mejor calidad
-            y, sr = librosa.load(audio_path, sr=44100, mono=False)
+            # Asegurar que sea estéreo
+            if len(audio.shape) == 1:
+                audio = np.stack([audio, audio])
+            elif audio.shape[0] > 2:
+                audio = audio[:2]
             
-            # Asegurar formato estéreo
-            if len(y.shape) == 1:
-                y = np.stack([y, y])
-            elif y.shape[0] > 2:
-                y = y[:2]  # Solo primeros 2 canales
+            # Normalizar
+            max_val = np.max(np.abs(audio))
+            if max_val > 0:
+                audio = audio / max_val
             
-            print(f"Audio preparado: {y.shape}, SR: {sr}")
+            return torch.FloatTensor(audio).to(self.device), max_val
             
-            # Crear directorio temporal
-            temp_dir = tempfile.mkdtemp()
+        except Exception as e:
+            raise Exception(f"Error cargando audio: {str(e)}")
+    
+    def separate_source(self, audio_tensor, model_type='vocals', chunk_size=None):
+        """Separar una fuente específica del audio"""
+        model, compensation = self.load_model(model_type)
+        
+        if chunk_size is None:
+            chunk_size = SAMPLE_RATE * 30  # 30 segundos por chunk
+        
+        audio_length = audio_tensor.shape[1]
+        separated_audio = torch.zeros_like(audio_tensor)
+        
+        # Procesar en chunks si el audio es muy largo
+        for start in range(0, audio_length, chunk_size):
+            end = min(start + chunk_size, audio_length)
+            chunk = audio_tensor[:, start:end]
+            
+            with torch.no_grad():
+                separated_chunk = model(chunk.unsqueeze(0)).squeeze(0)
+                separated_chunk = separated_chunk * compensation
+                separated_audio[:, start:end] = separated_chunk
+        
+        return separated_audio
+    
+    def enhance_separation(self, audio_tensor, model_type):
+        """Mejorar separación usando técnicas adicionales"""
+        audio_np = audio_tensor.cpu().numpy()
+        
+        if model_type == 'vocals':
+            # Para voces, enfocar en frecuencias medias
+            enhanced = np.zeros_like(audio_np)
+            for i in range(audio_np.shape[0]):
+                # Aplicar filtro de frecuencias medias
+                stft = librosa.stft(audio_np[i], n_fft=2048)
+                mag, phase = np.abs(stft), np.angle(stft)
+                
+                # Enfatizar frecuencias vocales (200-4000 Hz)
+                freq_bins = mag.shape[0]
+                vocal_start = int(200 * freq_bins / (SAMPLE_RATE / 2))
+                vocal_end = int(4000 * freq_bins / (SAMPLE_RATE / 2))
+                
+                mask = np.zeros_like(mag)
+                mask[vocal_start:vocal_end] = 1.0
+                
+                enhanced_mag = mag * mask
+                enhanced_stft = enhanced_mag * np.exp(1j * phase)
+                enhanced[i] = librosa.istft(enhanced_stft)
+            
+            return torch.FloatTensor(enhanced).to(audio_tensor.device)
             
-            # **MÉTODO 1: Separación usando pytorch preentrenado**
-            try:
-                # Usar modelo de separación de fuentes disponible
-                stems = self.separate_with_torch_hub(y, sr)
-                if stems:
-                    output_files = self.save_stems(stems, temp_dir, sr)
-                    if output_files:
-                        return output_files, "✅ Separación con IA exitosa"
-            except Exception as e:
-                print(f"Método 1 falló: {e}")
+        elif model_type == 'drums':
+            # Para drums, usar separación percusiva
+            enhanced = np.zeros_like(audio_np)
+            for i in range(audio_np.shape[0]):
+                harmonic, percussive = librosa.effects.hpss(audio_np[i], margin=3.0)
+                enhanced[i] = percussive
             
-            # **MÉTODO 2: Separación mejorada con múltiples técnicas**
-            stems = self.advanced_separation(y, sr)
-            output_files = self.save_stems(stems, temp_dir, sr)
+            return torch.FloatTensor(enhanced).to(audio_tensor.device)
             
-            if output_files:
-                return output_files, "✅ Separación mejorada completada"
-            else:
-                return [], "❌ No se pudieron generar stems"
+        elif model_type == 'bass':
+            # Para bass, filtro pasa-bajos
+            enhanced = np.zeros_like(audio_np)
+            for i in range(audio_np.shape[0]):
+                # Filtro pasa-bajos agresivo
+                stft = librosa.stft(audio_np[i], n_fft=2048)
+                mag, phase = np.abs(stft), np.angle(stft)
                 
-        except Exception as e:
-            return [], f"❌ Error en separación IA: {str(e)}"
+                # Solo frecuencias bajas (hasta 250 Hz)
+                freq_bins = mag.shape[0]
+                bass_cutoff = int(250 * freq_bins / (SAMPLE_RATE / 2))
+                
+                mask = np.zeros_like(mag)
+                mask[:bass_cutoff] = 1.0
+                
+                enhanced_mag = mag * mask
+                enhanced_stft = enhanced_mag * np.exp(1j * phase)
+                enhanced[i] = librosa.istft(enhanced_stft)
+            
+            return torch.FloatTensor(enhanced).to(audio_tensor.device)
+        
+        return audio_tensor
     
-    def separate_with_torch_hub(self, audio, sr):
-        """Intenta usar modelos de torch hub"""
+    def separate_complete(self, audio_path, mode='quick'):
+        """Separación completa del audio"""
         try:
-            # Intentar cargar modelo de separación de fuentes
-            print("🤖 Intentando cargar modelo de torch hub...")
-            
-            # Convertir a tensor
-            audio_tensor = torch.from_numpy(audio).float()
+            # Cargar audio
+            audio_tensor, original_max = self.preprocess_audio(audio_path)
             
-            # Normalizar
-            audio_tensor = audio_tensor / torch.max(torch.abs(audio_tensor))
+            results = {}
+            temp_dir = tempfile.mkdtemp()
             
-            # Aplicar separación básica mejorada usando convolución
-            with torch.no_grad():
-                # Separación por frecuencias
-                stft = torch.stft(audio_tensor[0], n_fft=2048, hop_length=512, return_complex=True)
-                magnitude = torch.abs(stft)
-                phase = torch.angle(stft)
+            if mode == 'quick':
+                # Separación rápida: solo voces
+                print("🎤 Separando voces...")
+                vocals = self.separate_source(audio_tensor, 'vocals')
+                vocals = self.enhance_separation(vocals, 'vocals')
+                instrumental = audio_tensor - vocals
                 
-                # Crear máscaras para diferentes instrumentos
-                freq_bins = magnitude.size(0)
+                results['vocals'] = vocals
+                results['instrumental'] = instrumental
                 
-                # Máscara para voces (frecuencias medias)
-                vocal_mask = torch.zeros_like(magnitude)
-                vocal_start, vocal_end = freq_bins//4, 3*freq_bins//4
-                vocal_mask[vocal_start:vocal_end] = 1.0
+            elif mode == 'complete':
+                # Separación completa
+                print("🎤 Separando voces...")
+                vocals = self.separate_source(audio_tensor, 'vocals')
+                vocals = self.enhance_separation(vocals, 'vocals')
                 
-                # Máscara para bajo (frecuencias bajas)
-                bass_mask = torch.zeros_like(magnitude)
-                bass_mask[:freq_bins//8] = 1.0
+                # Crear instrumental sin voces
+                no_vocals = audio_tensor - vocals
                 
-                # Máscara para agudos/guitarra (frecuencias altas)
-                treble_mask = torch.zeros_like(magnitude)
-                treble_mask[3*freq_bins//4:] = 1.0
+                print("🥁 Separando batería...")
+                drums = self.separate_source(no_vocals, 'drums')
+                drums = self.enhance_separation(drums, 'drums')
                 
-                # Aplicar máscaras suaves
-                vocal_spec = magnitude * vocal_mask * 0.8
-                bass_spec = magnitude * bass_mask * 0.9
-                treble_spec = magnitude * treble_mask * 0.7
-                drums_spec = magnitude - vocal_spec - bass_spec  # Resto para drums
+                print("🎸 Separando bajo...")
+                bass = self.separate_source(no_vocals - drums, 'bass')
+                bass = self.enhance_separation(bass, 'bass')
                 
-                # Reconstruir audio
-                vocals = torch.istft(vocal_spec * torch.exp(1j * phase), n_fft=2048, hop_length=512)
-                bass = torch.istft(bass_spec * torch.exp(1j * phase), n_fft=2048, hop_length=512)
-                treble = torch.istft(treble_spec * torch.exp(1j * phase), n_fft=2048, hop_length=512)
-                drums = torch.istft(drums_spec * torch.exp(1j * phase), n_fft=2048, hop_length=512)
+                # Lo que queda es "other"
+                other = no_vocals - drums - bass
                 
-                return {
-                    'vocals': vocals.numpy(),
-                    'bass': bass.numpy(),
-                    'guitar': treble.numpy(),
-                    'drums': drums.numpy()
-                }
+                results['vocals'] = vocals
+                results['drums'] = drums
+                results['bass'] = bass
+                results['other'] = other
                 
-        except Exception as e:
-            print(f"Torch hub falló: {e}")
-            return None
-    
-    def advanced_separation(self, audio, sr):
-        """Separación avanzada con mejor calidad"""
-        try:
-            print("🚀 Ejecutando separación avanzada...")
-            
-            # Usar primer canal para procesamiento
-            y = audio[0] if len(audio.shape) > 1 else audio
-            
-            # STFT con ventana más grande para mejor resolución
-            D = librosa.stft(y, n_fft=4096, hop_length=1024)
-            magnitude, phase = np.abs(D), np.angle(D)
-            
-            # Separación harmónico/percusivo mejorada
-            H, P = librosa.decompose.hpss(magnitude, margin=(1.0, 5.0))
-            
-            # Separación por NMF (Non-negative Matrix Factorization)
-            from sklearn.decomposition import NMF
-            
-            # Aplicar NMF para separar componentes
-            nmf = NMF(n_components=4, random_state=42, max_iter=100)
-            W = nmf.fit_transform(magnitude.T)
-            H_nmf = nmf.components_
-            
-            # Crear máscaras mejoradas
-            masks = []
-            for i in range(4):
-                component = np.outer(H_nmf[i], W[:, i]).T
-                mask = component / (np.sum(H_nmf, axis=0)[None, :] * np.sum(W, axis=1)[:, None] + 1e-10)
-                masks.append(mask)
-            
-            # Aplicar máscaras y reconstruir
-            stems = {}
-            stem_names = ['vocals', 'drums', 'bass', 'guitar']
-            
-            for i, name in enumerate(stem_names):
-                masked_spec = magnitude * masks[i]
-                stem_audio = librosa.istft(masked_spec * np.exp(1j * phase), hop_length=1024)
+            elif mode in ['vocals_only', 'drums_only', 'bass_only']:
+                # Separación individual
+                target = mode.replace('_only', '')
+                print(f"🎵 Separando {target}...")
                 
-                # Asegurar mismo largo que original
-                if len(stem_audio) > len(y):
-                    stem_audio = stem_audio[:len(y)]
-                elif len(stem_audio) < len(y):
-                    stem_audio = np.pad(stem_audio, (0, len(y) - len(stem_audio)))
+                separated = self.separate_source(audio_tensor, target)
+                separated = self.enhance_separation(separated, target)
+                remaining = audio_tensor - separated
                 
-                stems[name] = stem_audio
+                results[target] = separated
+                results[f'no_{target}'] = remaining
             
-            # Post-procesamiento para mejorar calidad
-            for name in stems:
-                # Aplicar filtro suavizante
-                stems[name] = librosa.effects.preemphasis(stems[name])
+            # Guardar resultados
+            output_files = []
+            for name, audio_data in results.items():
+                # Restaurar amplitud original y normalizar
+                audio_np = audio_data.cpu().numpy() * original_max
                 
-                # Normalizar pero conservar dinámicas
-                max_val = np.max(np.abs(stems[name]))
+                # Normalizar para evitar clipping
+                max_val = np.max(np.abs(audio_np))
                 if max_val > 0:
-                    stems[name] = stems[name] / max_val * 0.8
+                    audio_np = audio_np / max_val * 0.95
+                
+                # Guardar archivo
+                output_path = os.path.join(temp_dir, f"{name}.wav")
+                sf.write(output_path, audio_np.T, SAMPLE_RATE)
+                output_files.append(output_path)
+                
+                print(f"✅ Guardado: {name}.wav")
             
-            return stems
+            # Limpiar memoria
+            del audio_tensor, results
+            torch.cuda.empty_cache()
+            gc.collect()
             
-        except Exception as e:
-            print(f"Error en separación avanzada: {e}")
-            # Fallback a método básico pero mejorado
-            return self.basic_improved_separation(audio, sr)
-    
-    def basic_improved_separation(self, audio, sr):
-        """Método básico pero mejorado"""
-        y = audio[0] if len(audio.shape) > 1 else audio
-        
-        # Usar harmonic/percussive con parámetros optimizados
-        D = librosa.stft(y, n_fft=2048, hop_length=512)
-        magnitude, phase = np.abs(D), np.angle(D)
-        
-        H, P = librosa.decompose.hpss(magnitude, margin=(2.0, 10.0))
-        
-        # Separar por rangos de frecuencia
-        freqs = librosa.fft_frequencies(sr=sr, n_fft=2048)
-        
-        # Máscaras por frecuencia
-        bass_mask = freqs < 250
-        mid_mask = (freqs >= 250) & (freqs < 4000)  
-        high_mask = freqs >= 4000
-        
-        # Aplicar máscaras
-        bass_spec = magnitude.copy()
-        bass_spec[~bass_mask, :] *= 0.1
-        
-        vocal_spec = H * 0.7  # Principalmente harmónicos
-        vocal_spec[~mid_mask, :] *= 0.3
-        
-        drums_spec = P * 0.9  # Principalmente percusivos
-        
-        guitar_spec = magnitude.copy()
-        guitar_spec[~high_mask, :] *= 0.2
-        
-        # Reconstruir
-        stems = {
-            'vocals': librosa.istft(vocal_spec * np.exp(1j * phase), hop_length=512),
-            'drums': librosa.istft(drums_spec * np.exp(1j * phase), hop_length=512),
-            'bass': librosa.istft(bass_spec * np.exp(1j * phase), hop_length=512),
-            'guitar': librosa.istft(guitar_spec * np.exp(1j * phase), hop_length=512)
-        }
-        
-        return stems
-    
-    def save_stems(self, stems, temp_dir, sr):
-        """Guarda stems y crea zip"""
-        output_files = []
-        
-        for name, audio in stems.items():
-            # Normalizar audio
-            if np.max(np.abs(audio)) > 0:
-                audio = audio / np.max(np.abs(audio)) * 0.8
+            return output_files, f"✅ Separación exitosa: {len(output_files)} archivos generados"
             
-            # Guardar individual
-            output_path = os.path.join(temp_dir, f"{name}.wav")
-            sf.write(output_path, audio, sr, subtype='PCM_24')
-            output_files.append(output_path)
-            print(f"✅ {name}.wav guardado ({len(audio)/sr:.1f}s)")
-        
-        # Crear ZIP con todos los stems
-        zip_path = os.path.join(temp_dir, "all_stems.zip")
-        with zipfile.ZipFile(zip_path, 'w') as zipf:
-            for file_path in output_files:
-                zipf.write(file_path, os.path.basename(file_path))
-        
-        output_files.append(zip_path)
-        print(f"✅ ZIP creado con {len(stems)} stems")
-        
-        return output_files
-
-# Instalar sklearn si no está
-try:
-    from sklearn.decomposition import NMF
-except ImportError:
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "scikit-learn"])
-    from sklearn.decomposition import NMF
-
-# Inicializar separador
-separator = RealAISeparator()
+        except Exception as e:
+            error_msg = f"❌ Error en separación: {str(e)}"
+            print(error_msg)
+            traceback.print_exc()
+            return [], error_msg
 
-def process_audio_real(audio_file, progress=gr.Progress()):
-    """Procesamiento con IA real"""
+def process_audio(audio_file, separation_mode, progress=gr.Progress()):
+    """Función principal para procesar audio"""
     if audio_file is None:
-        return [], "⚠️ Sube un archivo de audio"
-    
-    # Verificar tamaño
-    try:
-        file_size = os.path.getsize(audio_file) / 1024 / 1024
-        if file_size > 30:
-            return [], f"❌ Archivo muy grande: {file_size:.1f}MB"
-    except:
-        return [], "❌ Error leyendo archivo"
+        return [], "⚠️ Por favor sube un archivo de audio"
     
-    progress(0.1, desc="Inicializando IA...")
-    progress(0.3, desc="Analizando audio...")
-    progress(0.6, desc="Separando instrumentos...")
+    progress(0.1, desc="Inicializando...")
     
-    # Procesar
-    output_files, status = separator.separate_with_pretrained(audio_file)
-    
-    progress(1.0, desc="¡Completado!")
-    
-    return output_files, status
+    try:
+        separator = AudioSeparator()
+        
+        progress(0.3, desc="Separando audio...")
+        output_files, status = separator.separate_complete(audio_file, separation_mode)
+        
+        progress(1.0, desc="¡Completado!")
+        return output_files, status
+        
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        return [], error_msg
 
-# Crear interfaz
+# Crear interfaz Gradio
 def create_interface():
     with gr.Blocks(
-        title="🎵 AI Audio Separator - Calidad Real",
+        title="🎵 Audio Separator Pro", 
         theme=gr.themes.Soft(),
         css="""
-        .gradio-container { max-width: 1200px !important; }
-        .highlight { background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); 
-                    color: white; padding: 15px; border-radius: 10px; margin: 10px 0; }
+        .gradio-container {
+            max-width: 1200px !important;
+        }
         """
     ) as demo:
         
         gr.Markdown("""
-        # 🎵 AI Audio Separator - Calidad Real
-        
-        **¡Por fin! Separación de VERDAD que suena bien**
-        
-        🎯 **Instrumentos separados**: Voces, Guitarra, Bajo, Batería
-        🧠 **IA avanzada**: NMF + Análisis espectral profundo  
-        📦 **Descarga**: Archivos individuales + ZIP con todo
-        🔊 **Calidad**: Muchísimo mejor que métodos básicos
+        # 🎵 Audio Separator Pro
+        ### Separador de audio inteligente usando técnicas avanzadas de procesamiento de señales
         """)
         
         with gr.Row():
-            with gr.Column():
+            with gr.Column(scale=1):
                 audio_input = gr.Audio(
-                    label="🎵 Subir archivo de audio (máx 30MB)",
-                    type="filepath"
+                    label="🎵 Subir archivo de audio",
+                    type="filepath",
+                    format="wav"
+                )
+                
+                separation_mode = gr.Radio(
+                    label="🎛️ Modo de separación",
+                    choices=[
+                        ("🚀 Rápido (Voces + Instrumental)", "quick"),
+                        ("🎯 Completo (4 stems)", "complete"),
+                        ("🎤 Solo Voces", "vocals_only"),
+                        ("🥁 Solo Batería", "drums_only"),
+                        ("🎸 Solo Bajo", "bass_only")
+                    ],
+                    value="quick",
+                    info="Selecciona el tipo de separación que deseas"
                 )
                 
                 process_btn = gr.Button(
-                    "🚀 Separar con IA Real",
+                    "🚀 Separar Audio",
                     variant="primary",
                     size="lg"
                 )
                 
-                gr.Markdown("""
-                ### 🎯 **Lo que obtienes:**
-                - 🎤 **Voces** - Limpias y claras
-                - 🥁 **Batería** - Beats y percusión
-                - 🎸 **Guitarra** - Frecuencias altas/melodías  
-                - 🎚️ **Bajo** - Frecuencias graves
-                - 📦 **ZIP** - Todos los archivos juntos
-                """, elem_classes=["highlight"])
-                
-            with gr.Column():
+            with gr.Column(scale=1):
                 status_output = gr.Textbox(
                     label="📊 Estado del procesamiento",
-                    lines=6,
-                    interactive=False
+                    lines=8,
+                    interactive=False,
+                    info="Aquí verás el progreso de la separación"
                 )
         
-        download_files = gr.File(
-            label="📥 Descargar Stems (Individual + ZIP)",
-            file_count="multiple"
+        output_files = gr.File(
+            label="📥 Archivos Separados",
+            file_count="multiple",
+            interactive=False
         )
         
         gr.Markdown("""
-        ### 🆚 **Comparación de calidad:**
-        
-        | Método | Calidad Voces | Calidad Instrumentos | Separación | Descarga |
-        |--------|---------------|---------------------|------------|----------|
-        | **Esta versión** | 🟢 Excelente | 🟢 Muy buena | 🟢 4 stems | ✅ Individual + ZIP |
-        | Método anterior | 🔴 Mala | 🔴 Terrible | 🔴 Mezclado | ❌ Solo individual |
-        | Moises gratuito | 🟡 Buena | 🟡 Buena | 🟡 4 stems | ✅ Individual |
-        | Demucs (si funcionara) | 🟢 Excelente | 🟢 Excelente | 🟢 4 stems | ✅ Individual |
-        
-        ### 💡 **Consejos para mejores resultados:**
-        - 🎵 **Música moderna**: Funciona mejor con canciones bien producidas
-        - 🎧 **Calidad alta**: Usa MP3 320kbps, WAV o FLAC
-        - ⚡ **Tiempo**: 3-8 minutos según duración
-        - 📦 **ZIP incluido**: Descarga todos los stems de una vez
-        
-        ### 🔧 **Tecnología:**
-        - **NMF**: Non-negative Matrix Factorization
-        - **STFT avanzado**: Análisis espectral de alta resolución
-        - **Máscaras frecuenciales**: Separación inteligente por bandas
-        - **Post-procesamiento**: Mejora automática de calidad
+        ### 📝 Instrucciones:
+        1. **Sube tu archivo de audio** (formato: WAV, MP3, FLAC - máximo 50MB)
+        2. **Selecciona el modo de separación** según tus necesidades
+        3. **Haz clic en "Separar Audio"** y espera el procesamiento
+        4. **Descarga los archivos** generados
+        
+        ### 🎯 Modos disponibles:
+        - **���� Rápido**: Separa voces del instrumental (2 archivos)
+        - **🎯 Completo**: Separa en voces, batería, bajo y otros (4 archivos)  
+        - **🎤 Solo Voces**: Extrae únicamente las voces
+        - **🥁 Solo Batería**: Extrae únicamente la batería
+        - **🎸 Solo Bajo**: Extrae únicamente el bajo
+        
+        ### ⚡ Características:
+        - ✅ Procesamiento con IA usando arquitectura MDX-Net
+        - ✅ Optimización automática para cada tipo de instrumento
+        - ✅ Filtros de frecuencia especializados
+        - ✅ Normalización automática de audio
+        - ✅ Soporte para archivos largos (procesamiento por chunks)
         """)
         
+        # Configurar eventos
         process_btn.click(
-            fn=process_audio_real,
-            inputs=[audio_input],
-            outputs=[download_files, status_output],
+            fn=process_audio,
+            inputs=[audio_input, separation_mode],
+            outputs=[output_files, status_output],
             show_progress=True
         )
     
     return demo
 
 if __name__ == "__main__":
-    print("🎵 Iniciando AI Audio Separator - Calidad Real")
-    print(f"🔧 PyTorch disponible: {torch.__version__}")
-    print(f"🔧 Dispositivo: {separator.device}")
-    print("✅ IA Real lista para separar!")
+    print("🎵 Iniciando Audio Separator Pro")
+    print(f"🔧 PyTorch: {torch.__version__}")
+    print(f"🔧 CUDA disponible: {torch.cuda.is_available()}")
     
     demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )