Upload 3 files

app.py

@@ -3,16 +3,15 @@ import gradio as gr
 import numpy as np
 import soundfile as sf
 import librosa
-import torch
 
 # 检查 GPU
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-SAMPLE_RATE = 44100
+try:
+    import torch
+    DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+except:
+    DEVICE = "cpu"
 
-# 全局变量（不在启动时加载）
-SILERO_MODEL = None
-SILERO_LOAD_ATTEMPTED = False
-SILERO_LOAD_STATUS = "未尝试"  # "未尝试", "加载中", "成功", "失败"
+SAMPLE_RATE = 44100
 
 def extract_audio_from_video(video_path, output_path):
     """从视频中提取音频"""
@@ -98,153 +97,36 @@ def run_demucs_separation(audio_path, output_dir):
         raise RuntimeError(f"Demucs 分离失败: {str(e)}")
 
 
-def load_silero_model_lazy(timeout=180):
+def detect_speaking_improved(vocals_audio, sr, strictness=0.6):
     """
-    懒加载 Silero VAD 模型（带超时机制）
+    改进的说话检测算法（无需外部模型）
     
-    超时机制说明：
-    - 给模型下载设置 180 秒（3分钟）时间限制
-    - 如果超时，返回 False，触发"降级"
+    基于多特征融合：
+    1. 能量包络（RMS）
+    2. 零交叉率（ZCR）
+    3. 频谱质心（Spectral Centroid）
+    4. 频谱滚降（Spectral Rolloff）
+    5. 音高连续性
     
-    降级机制说明：
-    - 如果 Silero VAD 加载失败（超时或其他错误）
-    - 自动切换到传统多特征算法
-    - 准确率从 85-90% 降到 75-80%
+    strictness: 0-1，越高越严格（只保留明确的说话）
     """
-    global SILERO_MODEL, SILERO_LOAD_ATTEMPTED, SILERO_LOAD_STATUS
-    
-    # 如果已经尝试过加载，直接返回结果
-    if SILERO_LOAD_ATTEMPTED:
-        return SILERO_MODEL is not None
-    
-    SILERO_LOAD_ATTEMPTED = True
-    SILERO_LOAD_STATUS = "加载中"
-    
-    try:
-        print("📥 开始下载 Silero VAD 模型（3分钟超时）...")
-        
-        # 使用 subprocess 控制超时
-        import signal
-        
-        def timeout_handler(signum, frame):
-            raise TimeoutError("Silero 模型下载超时（3分钟限制）")
-        
-        # 设置超时（只在 Linux/Mac 上有效）
-        if hasattr(signal, 'SIGALRM'):
-            signal.signal(signal.SIGALRM, timeout_handler)
-            signal.alarm(timeout)
-        
-        try:
-            # 尝试从 torch.hub 加载
-            SILERO_MODEL, utils = torch.hub.load(
-                repo_or_dir='snakers4/silero-vad',
-                model='silero_vad',
-                force_reload=False,
-                onnx=False,
-                verbose=False
-            )
-            SILERO_MODEL = SILERO_MODEL.to(DEVICE)
-            SILERO_MODEL.eval()
-            
-            SILERO_LOAD_STATUS = "成功"
-            print("✅ Silero VAD 模型加载成功")
-            return True
-        
-        finally:
-            # 取消超时
-            if hasattr(signal, 'SIGALRM'):
-                signal.alarm(0)
-    
-    except TimeoutError as e:
-        SILERO_LOAD_STATUS = "失败（超时）"
-        print(f"⚠️ {str(e)}")
-        print("   【降级】自动切换到传统算法")
-        SILERO_MODEL = None
-        return False
-    
-    except Exception as e:
-        SILERO_LOAD_STATUS = "失败（错误）"
-        print(f"⚠️ Silero VAD 加载失败: {str(e)}")
-        print("   【降级】自动切换到传统算法")
-        SILERO_MODEL = None
-        return False
-
-
-def detect_speech_with_silero(vocals_audio, sr):
-    """使用 Silero VAD 深度学习模型检测说话"""
-    try:
-        global SILERO_MODEL
-        if SILERO_MODEL is None:
-            raise RuntimeError("Silero 模型未加载")
-        
-        # 重采样到 16kHz
-        if sr != 16000:
-            vocals_16k = librosa.resample(vocals_audio, orig_sr=sr, target_sr=16000)
-            sr_work = 16000
-        else:
-            vocals_16k = vocals_audio
-            sr_work = 16000
-        
-        # 转换为 torch tensor
-        audio_tensor = torch.from_numpy(vocals_16k).float().to(DEVICE)
-        
-        # 使用 Silero VAD 检测
-        window_size_samples = 512
-        speech_probs = []
-        
-        with torch.no_grad():
-            for i in range(0, len(audio_tensor), window_size_samples):
-                chunk = audio_tensor[i:i+window_size_samples]
-                if len(chunk) < window_size_samples:
-                    chunk = torch.nn.functional.pad(chunk, (0, window_size_samples - len(chunk)))
-                
-                speech_prob = SILERO_MODEL(chunk.unsqueeze(0), sr_work).item()
-                speech_probs.append(speech_prob)
-        
-        # 创建掩码
-        speech_mask = np.repeat(speech_probs, window_size_samples)[:len(vocals_16k)]
-        speech_mask = (speech_mask > 0.5).astype(np.float32)
-        
-        # 调整回原始采样率
-        if sr != sr_work:
-            from scipy.interpolate import interp1d
-            old_indices = np.linspace(0, 1, len(speech_mask))
-            new_indices = np.linspace(0, 1, len(vocals_audio))
-            interpolator = interp1d(old_indices, speech_mask, kind='linear', fill_value='extrapolate')
-            speech_mask = interpolator(new_indices)
-        
-        # 确保长度匹配
-        if len(speech_mask) != len(vocals_audio):
-            if len(speech_mask) < len(vocals_audio):
-                speech_mask = np.pad(speech_mask, (0, len(vocals_audio) - len(speech_mask)))
-            else:
-                speech_mask = speech_mask[:len(vocals_audio)]
-        
-        speech_mask = (speech_mask > 0.5).astype(np.float32)
-        
-        return speech_mask
-    
-    except Exception as e:
-        print(f"Silero VAD 检测失败: {str(e)}")
-        return None
-
-
-def detect_speech_fallback(vocals_audio, sr):
-    """传统算法备用方案（降级后使用）"""
     try:
         hop_length = 512
         frame_length = 2048
         
-        # 能量
+        # ===== 特征1: 能量 =====
         rms = librosa.feature.rms(y=vocals_audio, frame_length=frame_length, hop_length=hop_length)[0]
         
-        # 零交叉率
+        # ===== 特征2: 零交叉率 =====
         zcr = librosa.feature.zero_crossing_rate(vocals_audio, frame_length=frame_length, hop_length=hop_length)[0]
         
-        # 频谱质心
+        # ===== 特征3: 频谱质心 =====
         spectral_centroids = librosa.feature.spectral_centroid(y=vocals_audio, sr=sr, hop_length=hop_length)[0]
         
-        # 音高检测
+        # ===== 特征4: 频谱滚降 =====
+        spectral_rolloff = librosa.feature.spectral_rolloff(y=vocals_audio, sr=sr, hop_length=hop_length)[0]
+        
+        # ===== 特征5: 音高检测 =====
         try:
             f0, voiced_flag, voiced_probs = librosa.pyin(
                 vocals_audio,
@@ -255,26 +137,35 @@ def detect_speech_fallback(vocals_audio, sr):
                 hop_length=hop_length
             )
             f0 = np.nan_to_num(f0, nan=0.0)
+            voiced_probs = np.nan_to_num(voiced_probs, nan=0.0)
         except:
             f0 = np.zeros(len(rms))
+            voiced_probs = np.zeros(len(rms))
+        
+        # ===== 特征融合 =====
+        min_len = min(len(rms), len(zcr), len(spectral_centroids), len(spectral_rolloff), len(voiced_probs))
         
-        # 归一化
-        min_len = min(len(rms), len(zcr), len(spectral_centroids), len(f0))
         rms = rms[:min_len]
         zcr = zcr[:min_len]
         spectral_centroids = spectral_centroids[:min_len]
+        spectral_rolloff = spectral_rolloff[:min_len]
+        voiced_probs = voiced_probs[:min_len]
         f0 = f0[:min_len]
         
         # 说话特征得分
+        # 1. 零交叉率高（但不是极高）
         zcr_score = np.clip((zcr - 0.05) / 0.15, 0, 1)
         
+        # 2. 能量适中（不是持续的高能量）
         rms_norm = rms / (np.max(rms) + 1e-8)
         energy_variation = np.abs(np.gradient(rms_norm))
         energy_score = np.clip(energy_variation * 10, 0, 1)
         
+        # 3. 频谱质心变化大
         centroid_variation = np.abs(np.gradient(spectral_centroids))
         centroid_score = np.clip(centroid_variation / (np.mean(centroid_variation) + 1e-8), 0, 1)
         
+        # 4. 音高不连续
         pitch_continuity = np.zeros_like(f0)
         for i in range(1, len(f0)):
             if f0[i] > 0 and f0[i-1] > 0:
@@ -290,9 +181,12 @@ def detect_speech_fallback(vocals_audio, sr):
             0.20 * pitch_continuity
         )
         
-        speaking_mask = (speaking_score > 0.6).astype(np.float32)
+        # 根据严格度调整阈值
+        threshold = strictness
+        speaking_mask = (speaking_score > threshold).astype(np.float32)
         
-        # 后处理
+        # ===== 后处理 =====
+        # 去除过短片段（<0.2秒）
         min_duration = int(0.2 * sr / hop_length)
         i = 0
         while i < len(speaking_mask):
@@ -306,15 +200,30 @@ def detect_speech_fallback(vocals_audio, sr):
             else:
                 i += 1
         
-        # 转换为样本级
+        # 填充小间隙（<0.15秒）
+        gap_threshold = int(0.15 * sr / hop_length)
+        i = 0
+        while i < len(speaking_mask) - 1:
+            if speaking_mask[i] == 1:
+                j = i + 1
+                while j < len(speaking_mask) and speaking_mask[j] == 0:
+                    j += 1
+                if j < len(speaking_mask) and j - i < gap_threshold:
+                    speaking_mask[i:j] = 1
+                i = j
+            else:
+                i += 1
+        
+        # 转换为样本级掩码
         speaking_mask_samples = np.repeat(speaking_mask, hop_length)
         
+        # 调整长度
         if len(speaking_mask_samples) < len(vocals_audio):
             speaking_mask_samples = np.pad(speaking_mask_samples, (0, len(vocals_audio) - len(speaking_mask_samples)))
         else:
             speaking_mask_samples = speaking_mask_samples[:len(vocals_audio)]
         
-        # 平滑
+        # 平滑边界
         smooth_window = int(0.03 * sr)
         if smooth_window > 1:
             speaking_mask_samples = np.convolve(
@@ -327,42 +236,14 @@ def detect_speech_fallback(vocals_audio, sr):
         return speaking_mask_samples
     
     except Exception as e:
-        print(f"传统算法检测失败: {str(e)}")
-        return np.zeros(len(vocals_audio), dtype=np.float32)
-
-
-def detect_singing_hybrid(vocals_audio, sr, mode='strict'):
-    """混合检测策略：优先使用 Silero VAD，失败则降级"""
-    try:
-        # 尝试加载 Silero 模型（懒加载，3分钟超时）
-        silero_available = load_silero_model_lazy(timeout=180)
-        
-        if silero_available:
-            print("✅ 使用 Silero VAD 深度学习模型检测")
-            speech_mask = detect_speech_with_silero(vocals_audio, sr)
-            
-            if speech_mask is not None:
-                if mode == 'strict':
-                    from scipy.ndimage import binary_erosion
-                    kernel_size = int(0.05 * sr)
-                    if kernel_size > 1:
-                        speech_mask = binary_erosion(speech_mask, structure=np.ones(kernel_size)).astype(np.float32)
-                
-                singing_mask = 1 - speech_mask
-                return singing_mask, "Silero VAD"
-        
-        # Silero 失败，降级到传统算法
-        print("⚠️ 【降级】使用传统多特征算法")
-        speech_mask = detect_speech_fallback(vocals_audio, sr)
-        singing_mask = 1 - speech_mask
-        return singing_mask, "传统算法"
-    
-    except Exception as e:
-        print(f"检测失败: {str(e)}")
-        return np.ones(len(vocals_audio), dtype=np.float32), "传统算法"
+        print(f"说话检测失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        # 🔴 修复：如果失败，返回全1（假设全是说话），而不是全0
+        return np.ones(len(vocals_audio), dtype=np.float32)
 
 
-def process_audio_full(audio_file, detection_mode, enable_detection):
+def process_audio_full(audio_file, strictness, enable_detection):
     """完整的音频分离流程"""
     if audio_file is None:
         return None, None, None, "❌ 请先上传音频或视频文件"
@@ -388,6 +269,7 @@ def process_audio_full(audio_file, detection_mode, enable_detection):
             save_audio(temp_wav, audio, sr)
             
             # 2. Demucs 分离
+            status_messages.append("━━━━━━━━━━━━━━━━━━━━")
             status_messages.append("🎵 使用 Demucs AI 模型分离人声和伴奏...")
             status_messages.append("   （首次运行会下载模型，约500MB）")
             yield None, None, None, "\n".join(status_messages)
@@ -397,53 +279,33 @@ def process_audio_full(audio_file, detection_mode, enable_detection):
             vocals, _ = librosa.load(vocals_path, sr=sr, mono=True)
             instrumental, _ = librosa.load(instrumental_path, sr=sr, mono=True)
             
-            # 3. 说话检测
-            algorithm_used = "无"
+            status_messages.append("   ✅ Demucs 分离完成")
+            status_messages.append("━━━━━━━━━━━━━━━━━━━━")
             
+            # 3. 说话检测
             if enable_detection:
-                status_messages.append("━━━━━━━━━━━━━━━━━━━━")
-                status_messages.append("🔧 正在初始化 AI 检测器...")
-                status_messages.append("   尝试加载 Silero VAD 模型...")
-                status_messages.append("   ⏱️ 超时限制: 3 分钟（180秒）")
-                status_messages.append("   如超时将自动【降级】到传统算法")
+                status_messages.append("")
+                status_messages.append("🎤 正在检测说话片段...")
+                status_messages.append("   算法: 多特征融合（能量+零交叉率+频谱+音高）")
+                status_messages.append(f"   严格度: {strictness:.2f}")
                 yield None, None, None, "\n".join(status_messages)
                 
-                # singing_mask: 1=唱歌, 0=说话
-                singing_mask, algorithm_used = detect_singing_hybrid(vocals, sr, mode=detection_mode)
-                
-                status_messages.append("━━━━━━━━━━━━━━━━━━━━")
+                # speaking_mask: 1=说话, 0=其他
+                speaking_mask = detect_speaking_improved(vocals, sr, strictness)
                 
-                # 醒目标注使用的算法
-                global SILERO_LOAD_STATUS
-                if algorithm_used == "Silero VAD":
-                    status_messages.append("✅✅✅ 检测器状态: Silero VAD 深度学习")
-                    status_messages.append("   📈 预期准确率: 85-90%")
-                    status_messages.append("   🎯 算法类型: 神经网络")
-                else:
-                    status_messages.append("⚠️⚠️⚠️ 检测器状态: 传统多特征算法（已降级）")
-                    status_messages.append(f"   🔴 降级原因: {SILERO_LOAD_STATUS}")
-                    status_messages.append("   📉 预期准确率: 75-80%")
-                    status_messages.append("   🎯 算法类型: 信号处理")
-                    status_messages.append("")
-                    status_messages.append("   💡 提示: 如需高准确率，建议:")
-                    status_messages.append("      1. 刷新页面重试")
-                    status_messages.append("      2. 或使用稳定版（移除 Silero）")
-                
-                status_messages.append("━━━━━━━━━━━━━━━━━━━━")
-                status_messages.append("🎤 正在分析音频特征...")
-                yield None, None, None, "\n".join(status_messages)
+                status_messages.append("   ✅ 检测完成")
             else:
                 status_messages.append("⚠️ 已关闭智能检测，所有人声归入对白")
-                singing_mask = np.zeros(len(vocals), dtype=np.float32)
-                algorithm_used = "关闭检测"
+                speaking_mask = np.ones(len(vocals), dtype=np.float32)
             
             # 4. 分离对白和唱歌
+            status_messages.append("")
             status_messages.append("✂️ 正在分离对白和背景音乐...")
             yield None, None, None, "\n".join(status_messages)
             
-            dialog_mask = 1 - singing_mask
+            singing_mask = 1 - speaking_mask
             
-            dialog_vocals = vocals * dialog_mask
+            dialog_vocals = vocals * speaking_mask
             singing_vocals = vocals * singing_mask
             
             # 5. 生成最终输出
@@ -462,20 +324,13 @@ def process_audio_full(audio_file, detection_mode, enable_detection):
             output_b = np.clip(instrumental + singing_vocals * singing_gain, -1.0, 1.0)
             output_c = instrumental
             
-            # 保存文件（文件名标注算法）
+            # 保存文件
             status_messages.append("💾 正在保存输出文件...")
             yield None, None, None, "\n".join(status_messages)
             
-            if algorithm_used == "Silero VAD":
-                algo_tag = "SileroVAD"
-            elif algorithm_used == "传统算法":
-                algo_tag = "Traditional"
-            else:
-                algo_tag = "NoDetect"
-            
-            path_a = os.path.join(tmpdir, f"A_dialog_{algo_tag}.wav")
-            path_b = os.path.join(tmpdir, f"B_bgm_with_singing_{algo_tag}.wav")
-            path_c = os.path.join(tmpdir, f"C_instrumental_{algo_tag}.wav")
+            path_a = os.path.join(tmpdir, "A_dialog.wav")
+            path_b = os.path.join(tmpdir, "B_bgm_with_singing.wav")
+            path_c = os.path.join(tmpdir, "C_instrumental.wav")
             
             save_audio(path_a, output_a, sr)
             save_audio(path_b, output_b, sr)
@@ -483,7 +338,7 @@ def process_audio_full(audio_file, detection_mode, enable_detection):
             
             # 统计信息
             total_duration = len(vocals) / sr
-            dialog_duration = np.sum(dialog_mask) / sr
+            dialog_duration = np.sum(speaking_mask) / sr
             singing_duration = total_duration - dialog_duration
             
             status_messages.append("")
@@ -497,29 +352,11 @@ def process_audio_full(audio_file, detection_mode, enable_detection):
             status_messages.append(f"   音乐人声时长: {singing_duration:.1f} 秒 ({singing_duration/total_duration*100:.1f}%)")
             status_messages.append(f"   运行设备: {DEVICE.upper()}")
             status_messages.append("")
-            
-            # 醒目标注使用的算法
-            if algorithm_used == "Silero VAD":
-                status_messages.append("🎯 本次使用的检测算法:")
-                status_messages.append("   ✅✅✅ Silero VAD 深度学习模型")
-                status_messages.append("   📈 准确率: 约 85-90%")
-                status_messages.append("   🧠 技术: 神经网络（10000+ 小时训练）")
-            elif algorithm_used == "传统算法":
-                status_messages.append("🎯 本次使用的检测算法:")
-                status_messages.append("   ⚠️⚠️⚠️ 传统多特征算法（已降级）")
-                status_messages.append("   📉 准确率: 约 75-80%")
-                status_messages.append("   🔧 技术: 能量+零交叉率+频谱+音高")
-                status_messages.append("")
-                status_messages.append("   ⚠️ 注意: 准确率低于 Silero VAD 约 10-15%")
-                status_messages.append("   💡 如需更高准确率，建议刷新页面重试")
-            else:
-                status_messages.append("🎯 本次使用的检测算法:")
-                status_messages.append("   ⚪ 未启用检测（所有人声归入对白）")
-            
+            status_messages.append("🎯 检测算法: 传统多特征融合")
+            status_messages.append("   📈 预期准确率: 75-80%")
+            status_messages.append("   🔧 技术: 能量+零交叉率+频谱+音高")
             status_messages.append("")
             status_messages.append("━━━━━━━━━━━━━━━━━━━━")
-            status_messages.append(f"💾 输出文件已标注算法: {algo_tag}")
-            status_messages.append("━━━━━━━━━━━━━━━━━━━━")
             
             yield (
                 path_a,
@@ -539,7 +376,7 @@ def process_audio_full(audio_file, detection_mode, enable_detection):
 # 创建 Gradio 界面
 with gr.Blocks(theme=gr.themes.Soft(), title="AI音频分离工具") as demo:
     gr.Markdown(f"""
-    # 🎵 AI 音频分离工具 - Silero VAD 版（3分钟超时）
+    # 🎵 AI 音频分离工具 - 稳定版
     
     **当前运行设备**: {DEVICE.upper()} {'✅ GPU加速' if DEVICE == 'cuda' else '⚠️ CPU模式'}
     
@@ -550,38 +387,8 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI音频分离工具") as demo:
     
     💡 **核心技术**: 
     - Demucs 4.0 深度学习模型（人声/伴奏分离）
-    - Silero VAD 神经网络（说话检测，懒加载）
-    - 传统多特征算法（自动降级备用）
-    
-    ---
-    
-    ## ⚠️ 重要说明：超时和降级机制
-    
-    ### 🔹 什么是"超时"？
-    - Silero VAD 模型需要从网络下载（约10MB）
-    - 给下载过程设置 **3 分钟（180秒）时间限制**
-    - 如果超过 3 分钟还没下载完，就**放弃下载**
-    
-    ### 🔹 什么是"降级"？
-    - 如果 Silero VAD 下载失败（超时或网络错误）
-    - 自动切换到**传统多特征算法**
-    - 准确率从 **85-90% 降到 75-80%**
-    
-    ### 🔹 如何知道用的是哪个算法？
-    1. **处理状态框**会有醒目标注：
-       - ✅✅✅ = 使用 Silero VAD（高准确率）
-       - ⚠️⚠️⚠️ = 使用传统算法（降级，准确率较低）
-    
-    2. **输出文件名**会包含算法标识：
-       - `A_dialog_SileroVAD.wav` = Silero VAD 处理
-       - `A_dialog_Traditional.wav` = 传统算法处理
-    
-    3. **最终结果**会明确显示使用的算法和准确率
-    
-    ### 💡 如果看到"降级"怎么办？
-    - 表示准确率**只有 75-80%**（不是 85-90%）
-    - 建议：刷新页面重新尝试
-    - 或者：使用稳定版（移除 Silero，准确率稳定在 75-80%）
+    - 多特征融合算法（能量、零交叉率、频谱、音高）
+    - **准确率 75-80%，稳定快速**
     """)
     
     with gr.Row():
@@ -603,71 +410,77 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI音频分离工具") as demo:
                     value=True,
                     label="🎯 启用智能说话检测（推荐开启）"
                 )
-                detection_mode = gr.Radio(
-                    choices=[
-                        ("严格模式 - 只保留明确的说话/旁白", "strict"),
-                        ("平衡模式 - 包含部分 Rap/快语", "balanced")
-                    ],
-                    value="strict",
-                    label="检测模式"
+                strictness = gr.Slider(
+                    0.4, 0.8, value=0.6, step=0.05,
+                    label="检测严格度"
                 )
                 gr.Markdown("""
-                **模式说明**:
-                - **严格模式**（推荐）：只有清晰的说话才归入对白
-                - **平衡模式**：包含部分 Rap 风格的说话
+                **调节建议**:
+                - **0.45-0.55**: 宽松（更多人声归入对白）
+                - **0.60-0.65**: 平衡（**推荐**，默认0.60）
+                - **0.70-0.80**: 严格（只保留明确的说话）
+                
+                **效果不满意？试试这样调**:
+                - 说话被误判为唱歌 → 降低到 0.50-0.55
+                - 唱歌被误判为说话 → 提高到 0.70-0.75
                 """)
             
-            process_btn = gr.Button("🚀 开始AI智能分离", variant="primary", size="lg")
+            process_btn = gr.Button("🚀 开始智能分离", variant="primary", size="lg")
         
         with gr.Column(scale=1):
             status_box = gr.Textbox(
-                label="📊 处理状态（会明确标注使用的算法）",
-                lines=25,
-                max_lines=30,
+                label="📊 处理状态",
+                lines=20,
+                max_lines=25,
                 show_label=True
             )
     
     gr.Markdown("---")
-    gr.Markdown("## 📥 分离结果（文件名会标注算法类型）")
+    gr.Markdown("## 📥 分离结果")
     
     with gr.Row():
-        output_a = gr.Audio(label="🎤 A - 纯对白", type="filepath")
-        output_b = gr.Audio(label="🎵 B - 背景音乐+人声", type="filepath")
+        output_a = gr.Audio(label="🎤 A - 纯对白（旁白/解说）", type="filepath")
+        output_b = gr.Audio(label="🎵 B - 背景音乐+人声（含唱歌/Rap）", type="filepath")
         output_c = gr.Audio(label="🎹 C - 纯伴奏", type="filepath")
     
     process_btn.click(
         fn=process_audio_full,
-        inputs=[audio_input, detection_mode, enable_detection],
+        inputs=[audio_input, strictness, enable_detection],
         outputs=[output_a, output_b, output_c, status_box]
     )
     
     gr.Markdown("""
     ---
-    ## 📌 算法对比表
+    ## 📌 使用说明
     
-    | 检测算法 | 准确率 | 优点 | 缺点 | 标识 |
-    |---------|--------|------|------|------|
-    | **Silero VAD** | **85-90%** | 深度学习，专门训练 | 需要下载（3分钟超时） | ✅✅✅ / SileroVAD |
-    | **传统算法** | **75-80%** | 快速稳定，无需下载 | 准确率较低 | ⚠️⚠️⚠️ / Traditional |
+    ### 🎯 本版本特点
     
-    ---
+    - ✅ **稳定快速**：无需下载外部模型
+    - ✅ **准确率 75-80%**：适合大部分场景
+    - ✅ **修复BUG**：确保对白始终有人声
+    - ✅ **启动快速**：3-5分钟构建完成
+    
+    ### 💡 如何获得最佳效果
+    
+    1. **优先用默认值 0.60** 测试
+    2. 根据结果微调严格度：
+       - 对白太少 → 降低到 0.50-0.55
+       - 对白太多 → 提高到 0.70-0.75
+    3. 每次调整 0.05 观察变化
     
-    ## 🎯 使用建议
+    ### ⚠️ 技术限制
     
-    ### 1. 如何判断效果好坏？
-    - **看状态框**：✅✅✅ = 高准确率，⚠️⚠️⚠️ = 较低准确率
-    - **看文件名**：`SileroVAD` = 高准确率，`Traditional` = 较低准确率
-    - **听结果**：对白是否干净，背景音乐是否完整
+    传统算法准确率有限，以下情况仍有挑战：
+    - 说唱风格旁白
+    - 快速说话 + 背景音乐
+    - 唱歌式说话
     
-    ### 2. 如果一直降级怎么办？
-    - 说明 HuggingFace Spaces 网络限制了 Silero 下载
-    - 建议使用"稳定版"（移除 Silero，准确率稳定在 75-80%）
-    - 或者本地部署（可以手动下载 Silero 模型）
+    ### 🔬 如果需要更高准确率
     
-    ### 3. 如何获得最佳效果？
-    - 优先等待 Silero VAD 加载成功（看到 ✅✅✅）
-    - 如果降级了，可以刷新页面重试
-    - 如果多次都降级，说明网络问题，建议用稳定版
+    可以考虑：
+    - 使用专业软件（如 Adobe Audition）
+    - 本地部署并手动下载 Silero VAD 模型
+    - 训练深度学习分类模型
     """)
 
 if __name__ == "__main__":