GitHub-faithful implementation - 32kHz, 2048 FFT, per-model delays, 80ms gaps

app.py

@@ -101,10 +101,6 @@ class OptimizedSileroVAD:
             print(f"❌ Error loading {self.model_name}: {e}")
             self.model = None
     
-    def reset_states(self):
-        if self.model:
-            self.model.reset_states()
-
     def predict(self, audio: np.ndarray, timestamp: float = 0.0) -> VADResult:
         start_time = time.time()
         
@@ -112,11 +108,20 @@ class OptimizedSileroVAD:
             return VADResult(0.0, False, f"{self.model_name} (unavailable)", time.time() - start_time, timestamp)
         
         try:
-            if len(audio.shape) > 1: audio = audio.mean(axis=1)
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+            
+            required_samples = 512
+            if len(audio) != required_samples:
+                if len(audio) > required_samples:
+                    start_idx = (len(audio) - required_samples) // 2
+                    audio_chunk = audio[start_idx:start_idx + required_samples]
+                else:
+                    audio_chunk = np.pad(audio, (0, required_samples - len(audio)), 'constant')
+            else:
+                audio_chunk = audio
             
-            # Silero expects a specific chunk size, which the main loop should provide.
-            # No padding or trimming here.
-            audio_tensor = torch.FloatTensor(audio).unsqueeze(0)
+            audio_tensor = torch.FloatTensor(audio_chunk).unsqueeze(0)
             
             with torch.no_grad():
                 speech_prob = self.model(audio_tensor, self.sample_rate).item()
@@ -127,73 +132,93 @@ class OptimizedSileroVAD:
             return VADResult(speech_prob, is_speech, self.model_name, processing_time, timestamp)
             
         except Exception as e:
-            # This can happen if chunk size is wrong, which is now handled in main loop
+            print(f"Error in {self.model_name}: {e}")
             return VADResult(0.0, False, self.model_name, time.time() - start_time, timestamp)
 
 class OptimizedWebRTCVAD:
     def __init__(self):
         self.model_name = "WebRTC-VAD"
         self.sample_rate = 16000
-        self.frame_duration = 10  # 10, 20, or 30 ms. 10ms for higher granularity.
+        self.frame_duration = 30
         self.frame_size = int(self.sample_rate * self.frame_duration / 1000)
         
         if WEBRTC_AVAILABLE:
             try:
                 self.vad = webrtcvad.Vad(3)
                 print(f"✅ {self.model_name} loaded successfully")
-            except: self.vad = None
-        else: self.vad = None
+            except:
+                self.vad = None
+        else:
+            self.vad = None
     
     def predict(self, audio: np.ndarray, timestamp: float = 0.0) -> VADResult:
         start_time = time.time()
         
         if self.vad is None or len(audio) == 0:
-            return VADResult(0.0, False, f"{self.model_name} (fallback)", time.time() - start_time, timestamp)
+            energy = np.sum(audio ** 2) if len(audio) > 0 else 0
+            threshold = 0.01
+            probability = min(energy / threshold, 1.0)
+            is_speech = energy > threshold
+            return VADResult(probability, is_speech, f"{self.model_name} (fallback)", time.time() - start_time, timestamp)
         
         try:
-            if len(audio.shape) > 1: audio = audio.mean(axis=1)
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+            
             audio_int16 = (audio * 32767).astype(np.int16)
             
-            speech_frames, total_frames = 0, 0
+            speech_frames = 0
+            total_frames = 0
             
-            for i in range(0, len(audio_int16) - self.frame_size + 1, self.frame_size):
+            for i in range(0, len(audio_int16) - self.frame_size, self.frame_size):
                 frame = audio_int16[i:i + self.frame_size].tobytes()
                 if self.vad.is_speech(frame, self.sample_rate):
                     speech_frames += 1
                 total_frames += 1
             
             probability = speech_frames / max(total_frames, 1)
-            is_speech = probability > 0.5
+            is_speech = probability > 0.3
             
             return VADResult(probability, is_speech, self.model_name, time.time() - start_time, timestamp)
             
         except Exception as e:
+            print(f"Error in {self.model_name}: {e}")
             return VADResult(0.0, False, self.model_name, time.time() - start_time, timestamp)
 
 class OptimizedEPANNs:
     def __init__(self):
         self.model_name = "E-PANNs"
-        self.sample_rate = 16000
+        self.sample_rate = 32000
         print(f"✅ {self.model_name} initialized")
     
     def predict(self, audio: np.ndarray, timestamp: float = 0.0) -> VADResult:
         start_time = time.time()
-        if len(audio) == 0: return VADResult(0.0, False, self.model_name, time.time() - start_time, timestamp)
         
         try:
+            if len(audio) == 0:
+                return VADResult(0.0, False, self.model_name, time.time() - start_time, timestamp)
+            
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+            
             if LIBROSA_AVAILABLE:
                 mel_spec = librosa.feature.melspectrogram(y=audio, sr=self.sample_rate, n_mels=64)
                 energy = np.mean(librosa.power_to_db(mel_spec, ref=np.max))
+                spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=audio, sr=self.sample_rate))
+                speech_score = (energy + 100) / 50 + spectral_centroid / 10000
             else:
                 from scipy import signal
-                _, _, Sxx = signal.spectrogram(audio, self.sample_rate)
+                f, t, Sxx = signal.spectrogram(audio, self.sample_rate)
                 energy = np.mean(10 * np.log10(Sxx + 1e-10))
-
-            speech_score = (energy + 100) / 50
+                speech_score = (energy + 100) / 50
+            
             probability = np.clip(speech_score, 0, 1)
+            is_speech = probability > 0.6
+            
+            return VADResult(probability, is_speech, self.model_name, time.time() - start_time, timestamp)
             
-            return VADResult(probability, probability > 0.6, self.model_name, time.time() - start_time, timestamp)
         except Exception as e:
+            print(f"Error in {self.model_name}: {e}")
             return VADResult(0.0, False, self.model_name, time.time() - start_time, timestamp)
 
 class OptimizedPANNs:
@@ -210,33 +235,61 @@ class OptimizedPANNs:
             if PANNS_AVAILABLE:
                 self.model = AudioTagging(checkpoint_path=None, device=self.device)
                 print(f"✅ {self.model_name} loaded successfully")
-            else: self.model = None
+            else:
+                print(f"⚠️ {self.model_name} not available, using fallback")
+                self.model = None
         except Exception as e:
             print(f"❌ Error loading {self.model_name}: {e}")
             self.model = None
     
     def predict(self, audio: np.ndarray, timestamp: float = 0.0) -> VADResult:
-        if self.cached_clip_prob is not None:
-            return VADResult(self.cached_clip_prob, self.cached_clip_prob > 0.5, self.model_name, 0.0, timestamp)
+        if timestamp > 0 and self.cached_clip_prob is not None:
+            return VADResult(self.cached_clip_prob,
+                             self.cached_clip_prob > 0.5,
+                             self.model_name, 0.0, timestamp)
 
         start_time = time.time()
+        
         if self.model is None or len(audio) == 0:
-            return VADResult(0.0, False, f"{self.model_name} (fallback)", time.time() - start_time, timestamp)
+            if len(audio) > 0:
+                energy = np.sum(audio ** 2)
+                threshold = 0.01
+                probability = min(energy / threshold, 1.0)
+                is_speech = energy > threshold
+            else:
+                probability = 0.0
+                is_speech = False
+            return VADResult(probability, is_speech, f"{self.model_name} (fallback)", time.time() - start_time, timestamp)
         
         try:
-            # Use clipwise_output for probabilities, not embeddings.
-            clip_probs, _ = self.model.inference(audio[np.newaxis, :], input_sr=self.sample_rate)
-            
-            # Filter all speech/voice-related labels for a robust average.
-            speech_idx = [i for i, lbl in enumerate(labels) if 'speech' in lbl.lower() or 'voice' in lbl.lower()]
-            if not speech_idx: speech_idx = [labels.index('Speech')]
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+
+            clip_probs, _ = self.model.inference(audio[np.newaxis, :],
+                                                 input_sr=self.sample_rate)
+
+            speech_idx = [i for i, lbl in enumerate(labels)
+                          if 'speech' in lbl.lower() or 'voice' in lbl.lower()]
+            if not speech_idx:
+                speech_idx = [labels.index('Speech')]
 
             speech_prob = clip_probs[0, speech_idx].mean().item()
             self.cached_clip_prob = float(speech_prob)
+            return VADResult(self.cached_clip_prob,
+                             self.cached_clip_prob > 0.5,
+                             self.model_name, time.time()-start_time, timestamp)
             
-            return VADResult(self.cached_clip_prob, self.cached_clip_prob > 0.5, self.model_name, time.time() - start_time, timestamp)
         except Exception as e:
-            return VADResult(0.0, False, f"{self.model_name} (error)", time.time() - start_time, timestamp)
+            print(f"Error in {self.model_name}: {e}")
+            if len(audio) > 0:
+                energy = np.sum(audio ** 2)
+                threshold = 0.01
+                probability = min(energy / threshold, 1.0)
+                is_speech = energy > threshold
+            else:
+                probability = 0.0
+                is_speech = False
+            return VADResult(probability, is_speech, f"{self.model_name} (error)", time.time() - start_time, timestamp)
 
 class OptimizedAST:
     def __init__(self):
@@ -251,224 +304,827 @@ class OptimizedAST:
     def load_model(self):
         try:
             if AST_AVAILABLE:
-                model_path = "MIT/ast-finetuned-audioset-10-10-0.4593"
-                self.feature_extractor = ASTFeatureExtractor.from_pretrained(model_path)
-                self.model = ASTForAudioClassification.from_pretrained(model_path).to(self.device).eval()
+                model_name = "MIT/ast-finetuned-audioset-10-10-0.4593"
+                self.feature_extractor = ASTFeatureExtractor.from_pretrained(model_name)
+                self.model = ASTForAudioClassification.from_pretrained(model_name)
+                self.model.to(self.device)
+                self.model.eval()
                 print(f"✅ {self.model_name} loaded successfully")
-            else: self.model = None
+            else:
+                print(f"⚠️ {self.model_name} not available, using fallback")
+                self.model = None
         except Exception as e:
             print(f"❌ Error loading {self.model_name}: {e}")
             self.model = None
     
     def predict(self, audio: np.ndarray, timestamp: float = 0.0) -> VADResult:
-        if self.cached_clip_prob is not None:
-            return VADResult(self.cached_clip_prob, self.cached_clip_prob > 0.5, self.model_name, 0.0, timestamp)
+        if timestamp > 0 and self.cached_clip_prob is not None:
+            return VADResult(self.cached_clip_prob,
+                             self.cached_clip_prob > 0.5,
+                             self.model_name, 0.0, timestamp)
 
         start_time = time.time()
-        if self.model is None or len(audio) < self.sample_rate * 2: # AST needs at least ~2s
-            return VADResult(0.0, False, f"{self.model_name} (fallback)", time.time() - start_time, timestamp)
+        
+        if self.model is None or len(audio) == 0:
+            if len(audio) > 0:
+                if LIBROSA_AVAILABLE:
+                    spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=audio, sr=self.sample_rate))
+                    energy = np.sum(audio ** 2)
+                    probability = min((energy * spectral_centroid) / 10000, 1.0)
+                else:
+                    energy = np.sum(audio ** 2)
+                    probability = min(energy / 0.01, 1.0)
+                is_speech = probability > 0.5
+            else:
+                probability = 0.0
+                is_speech = False
+            return VADResult(probability, is_speech, f"{self.model_name} (fallback)", time.time() - start_time, timestamp)
         
         try:
-            inputs = self.feature_extractor(audio, sampling_rate=self.sample_rate, return_tensors="pt").to(self.device)
+            if len(audio.shape) > 1:
+                audio = audio.mean(axis=1)
+            
+            inputs = self.feature_extractor(audio, sampling_rate=self.sample_rate, return_tensors="pt")
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
             with torch.no_grad():
-                probs = torch.sigmoid(self.model(**inputs).logits)
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+                probs = torch.sigmoid(logits)
             
-            # Use the model's config to find all speech-related labels
             label2id = self.model.config.label2id
-            speech_idx = [idx for lbl, idx in label2id.items() if 'speech' in lbl.lower() or 'voice' in lbl.lower()]
-            
+            speech_idx = [idx for lbl, idx in label2id.items()
+                          if 'speech' in lbl.lower() or 'voice' in lbl.lower()]
             speech_prob = probs[0, speech_idx].mean().item()
             self.cached_clip_prob = float(speech_prob)
+            return VADResult(self.cached_clip_prob,
+                             self.cached_clip_prob > 0.5,
+                             self.model_name, time.time()-start_time, timestamp)
             
-            return VADResult(self.cached_clip_prob, self.cached_clip_prob > 0.5, self.model_name, time.time() - start_time, timestamp)
         except Exception as e:
-            return VADResult(0.0, False, f"{self.model_name} (error)", time.time() - start_time, timestamp)
+            print(f"Error in {self.model_name}: {e}")
+            if len(audio) > 0:
+                energy = np.sum(audio ** 2)
+                threshold = 0.01
+                probability = min(energy / threshold, 1.0)
+                is_speech = energy > threshold
+            else:
+                probability = 0.0
+                is_speech = False
+            return VADResult(probability, is_speech, f"{self.model_name} (error)", time.time() - start_time, timestamp)
 
 # ===== AUDIO PROCESSOR =====
 
 class AudioProcessor:
     def __init__(self, sample_rate=16000):
         self.sample_rate = sample_rate
+        self.chunk_duration = 4.0
+        self.chunk_size = int(sample_rate * self.chunk_duration)
         
-        # Consistent windowing for analysis and STFT
-        self.window_size = 0.064  # 64 ms
-        self.hop_size = 0.016     # 16 ms
-        self.n_fft = int(self.sample_rate * self.window_size)      # 1024
-        self.hop_length = int(self.sample_rate * self.hop_size)    # 256
-        
+        self.n_fft = 2048
+        self.hop_length = 256
         self.n_mels = 128
         self.fmin = 20
         self.fmax = 8000
         
+        self.window_size = 0.064
+        self.hop_size = 0.032
+        
+        self.delay_compensation = 0.0
+        self.correlation_threshold = 0.7
+        
     def process_audio(self, audio):
-        if audio is None: return np.array([])
+        if audio is None:
+            return np.array([])
+        
         try:
-            sample_rate, audio_data = audio
-            if sample_rate != self.sample_rate and LIBROSA_AVAILABLE:
-                audio_data = librosa.resample(audio_data.astype(float), orig_sr=sample_rate, target_sr=self.sample_rate)
-            if len(audio_data.shape) > 1: audio_data = audio_data.mean(axis=1)
-            if np.max(np.abs(audio_data)) > 0: audio_data /= np.max(np.abs(audio_data))
+            if isinstance(audio, tuple):
+                sample_rate, audio_data = audio
+                if sample_rate != self.sample_rate and LIBROSA_AVAILABLE:
+                    audio_data = librosa.resample(audio_data.astype(float), 
+                                                orig_sr=sample_rate, 
+                                                target_sr=self.sample_rate)
+            else:
+                audio_data = audio
+            
+            if len(audio_data.shape) > 1:
+                audio_data = audio_data.mean(axis=1)
+            
+            if np.max(np.abs(audio_data)) > 0:
+                audio_data = audio_data / np.max(np.abs(audio_data))
+            
             return audio_data
+            
         except Exception as e:
+            print(f"Audio processing error: {e}")
             return np.array([])
     
     def compute_high_res_spectrogram(self, audio_data):
         try:
             if LIBROSA_AVAILABLE and len(audio_data) > 0:
-                stft = librosa.stft(audio_data, n_fft=self.n_fft, hop_length=self.hop_length, center=False)
-                mel_spec = librosa.feature.melspectrogram(S=np.abs(stft)**2, sr=self.sample_rate, n_fft=self.n_fft, hop_length=self.hop_length, n_mels=self.n_mels)
+                stft = librosa.stft(
+                    audio_data,
+                    n_fft=self.n_fft,
+                    hop_length=self.hop_length,
+                    win_length=self.n_fft,
+                    window='hann',
+                    center=False
+                )
+                
+                power_spec = np.abs(stft) ** 2
+                
+                mel_basis = librosa.filters.mel(
+                    sr=self.sample_rate,
+                    n_fft=self.n_fft,
+                    n_mels=self.n_mels,
+                    fmin=self.fmin,
+                    fmax=self.fmax
+                )
+                
+                mel_spec = np.dot(mel_basis, power_spec)
                 mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)
-                time_frames = librosa.times_like(mel_spec_db, sr=self.sample_rate, hop_length=self.hop_length, n_fft=self.n_fft)
+                
+                time_frames = np.arange(mel_spec_db.shape[1]) * self.hop_length / self.sample_rate
+                
                 return mel_spec_db, time_frames
-            return np.array([[]]), np.array([])
+            else:
+                from scipy import signal
+                f, t, Sxx = signal.spectrogram(
+                    audio_data, 
+                    self.sample_rate,
+                    nperseg=self.n_fft,
+                    noverlap=self.n_fft - self.hop_length,
+                    window='hann'
+                )
+                
+                mel_spec_db = np.zeros((self.n_mels, Sxx.shape[1]))
+                
+                mel_freqs = np.logspace(
+                    np.log10(self.fmin), 
+                    np.log10(min(self.fmax, self.sample_rate/2)), 
+                    self.n_mels + 1
+                )
+                
+                for i in range(self.n_mels):
+                    f_start = mel_freqs[i]
+                    f_end = mel_freqs[i + 1]
+                    bin_start = int(f_start * len(f) / (self.sample_rate/2))
+                    bin_end = int(f_end * len(f) / (self.sample_rate/2))
+                    if bin_end > bin_start:
+                        mel_spec_db[i, :] = np.mean(Sxx[bin_start:bin_end, :], axis=0)
+                
+                mel_spec_db = 10 * np.log10(mel_spec_db + 1e-10)
+                return mel_spec_db, t
+                
         except Exception as e:
-            return np.array([[]]), np.array([])
+            print(f"Spectrogram computation error: {e}")
+            dummy_spec = np.zeros((self.n_mels, 200))
+            dummy_time = np.linspace(0, len(audio_data) / self.sample_rate, 200)
+            return dummy_spec, dummy_time
     
     def detect_onset_offset_advanced(self, vad_results: List[VADResult], threshold: float = 0.5) -> List[OnsetOffset]:
         onsets_offsets = []
-        models = {res.model_name for res in vad_results}
         
-        for model_name in models:
-            results = sorted([r for r in vad_results if r.model_name == model_name], key=lambda x: x.timestamp)
-            if len(results) < 2: continue
+        if len(vad_results) < 3:
+            return onsets_offsets
+        
+        models = {}
+        for result in vad_results:
+            if result.model_name not in models:
+                models[result.model_name] = []
+            models[result.model_name].append(result)
+        
+        for model_name, results in models.items():
+            if len(results) < 3:
+                continue
+            
+            results.sort(key=lambda x: x.timestamp)
             
             timestamps = np.array([r.timestamp for r in results])
             probabilities = np.array([r.probability for r in results])
             
-            # Smooth probabilities to prevent brief drops from creating false offsets
-            probs_smooth = np.convolve(probabilities, np.ones(3)/3, mode='same')
-            
-            upper = threshold
-            lower = threshold * 0.5 # Hysteresis lower bound
-            
-            in_speech = False
-            onset_time = -1
-            for i, prob in enumerate(probs_smooth):
-                if not in_speech and prob > upper:
-                    in_speech = True
-                    onset_time = timestamps[i]
-                elif in_speech and prob < lower:
-                    in_speech = False
-                    onsets_offsets.append(OnsetOffset(onset_time, timestamps[i], model_name, np.mean(probabilities[(timestamps >= onset_time) & (timestamps <= timestamps[i])])))
-            if in_speech:
-                onsets_offsets.append(OnsetOffset(onset_time, timestamps[-1], model_name, np.mean(probabilities[timestamps >= onset_time])))
+            if len(probabilities) > 5:
+                window_size = min(5, len(probabilities) // 3)
+                probabilities = np.convolve(probabilities, np.ones(window_size)/window_size, mode='same')
+            
+            upper_thresh = threshold + 0.1
+            lower_thresh = threshold - 0.1
+            
+            in_speech_segment = False
+            current_onset_time = -1
+            
+            for i in range(1, len(results)):
+                prev_prob = probabilities[i-1]
+                curr_prob = probabilities[i]
+                curr_time = timestamps[i]
                 
+                if not in_speech_segment and prev_prob <= upper_thresh and curr_prob > upper_thresh:
+                    in_speech_segment = True
+                    current_onset_time = curr_time - self.delay_compensation
+                    
+                elif in_speech_segment and prev_prob >= lower_thresh and curr_prob < lower_thresh:
+                    in_speech_segment = False
+                    if current_onset_time >= 0:
+                        offset_time = curr_time - self.delay_compensation
+                        onsets_offsets.append(OnsetOffset(
+                            onset_time=max(0, current_onset_time),
+                            offset_time=offset_time,
+                            model_name=model_name,
+                            confidence=np.mean(probabilities[
+                                (timestamps >= current_onset_time) & 
+                                (timestamps <= offset_time)
+                            ]) if len(probabilities) > 0 else curr_prob
+                        ))
+                        current_onset_time = -1
+            
+            if in_speech_segment and current_onset_time >= 0:
+                onsets_offsets.append(OnsetOffset(
+                    onset_time=max(0, current_onset_time),
+                    offset_time=timestamps[-1],
+                    model_name=model_name,
+                    confidence=np.mean(probabilities[-3:]) if len(probabilities) >= 3 else probabilities[-1]
+                ))
+        
         return onsets_offsets
+    
+    def estimate_delay_compensation(self, audio_data, vad_results):
+        try:
+            if len(audio_data) == 0 or len(vad_results) == 0:
+                return 0.0
+            
+            window_size = int(self.sample_rate * self.window_size)
+            hop_size = int(self.sample_rate * self.hop_size)
+            
+            energy_signal = []
+            for i in range(0, len(audio_data) - window_size, hop_size):
+                window = audio_data[i:i + window_size]
+                energy = np.sum(window ** 2)
+                energy_signal.append(energy)
+            
+            energy_signal = np.array(energy_signal)
+            if len(energy_signal) == 0:
+                return 0.0
+            
+            energy_signal = (energy_signal - np.mean(energy_signal)) / (np.std(energy_signal) + 1e-8)
+            
+            vad_times = np.array([r.timestamp for r in vad_results])
+            vad_probs = np.array([r.probability for r in vad_results])
+            
+            energy_times = np.arange(len(energy_signal)) * self.hop_size
+            vad_interp = np.interp(energy_times, vad_times, vad_probs)
+            vad_interp = (vad_interp - np.mean(vad_interp)) / (np.std(vad_interp) + 1e-8)
+            
+            if len(energy_signal) > 10 and len(vad_interp) > 10:
+                correlation = np.correlate(energy_signal, vad_interp, mode='full')
+                delay_samples = np.argmax(correlation) - len(vad_interp) + 1
+                delay_seconds = delay_samples * self.hop_size
+                
+                max_corr = np.max(correlation) / (len(vad_interp) * np.std(energy_signal) * np.std(vad_interp))
+                if max_corr > self.correlation_threshold:
+                    self.delay_compensation = np.clip(delay_seconds, -0.1, 0.1)
+                
+            return self.delay_compensation
+            
+        except Exception as e:
+            print(f"Delay estimation error: {e}")
+            return 0.0
 
-# ===== VISUALIZATION =====
+# ===== ENHANCED VISUALIZATION (Complete GitHub Implementation) =====
 
 def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult], 
                         onsets_offsets: List[OnsetOffset], processor: AudioProcessor,
                         model_a: str, model_b: str, threshold: float):
     
-    if not PLOTLY_AVAILABLE or len(audio_data) == 0: return go.Figure()
-
-    mel_spec_db, time_frames = processor.compute_high_res_spectrogram(audio_data)
-    if mel_spec_db.size == 0: return go.Figure()
+    if not PLOTLY_AVAILABLE:
+        return None
     
-    fig = make_subplots(rows=2, cols=1, subplot_titles=(f"Model A: {model_a}", f"Model B: {model_b}"),
-                        vertical_spacing=0.05, shared_xaxes=True, specs=[[{"secondary_y": True}], [{"secondary_y": True}]])
-
-    heatmap_args = dict(z=mel_spec_db, x=time_frames, y=np.linspace(processor.fmin, processor.fmax, processor.n_mels),
-                        colorscale='Viridis', showscale=False)
-    fig.add_trace(go.Heatmap(**heatmap_args, name=f'Spectrogram {model_a}'), row=1, col=1)
-    fig.add_trace(go.Heatmap(**heatmap_args, name=f'Spectrogram {model_b}'), row=2, col=1)
-
-    data_a = [r for r in vad_results if r.model_name.startswith(model_a)]
-    data_b = [r for r in vad_results if r.model_name.startswith(model_b)]
-
-    if data_a: fig.add_trace(go.Scatter(x=[r.timestamp for r in data_a], y=[r.probability for r in data_a], mode='lines', line=dict(color='yellow', width=3), name=f'{model_a} Prob.'), row=1, col=1, secondary_y=True)
-    if data_b: fig.add_trace(go.Scatter(x=[r.timestamp for r in data_b], y=[r.probability for r in data_b], mode='lines', line=dict(color='orange', width=3), name=f'{model_b} Prob.'), row=2, col=1, secondary_y=True)
-
-    # Draw threshold line on the secondary y-axis
-    fig.add_hline(y=threshold, line=dict(color='cyan', width=2, dash='dash'), row=1, col=1, secondary_y=True)
-    fig.add_hline(y=threshold, line=dict(color='cyan', width=2, dash='dash'), row=2, col=1, secondary_y=True)
-    
-    events_a = [e for e in onsets_offsets if e.model_name.startswith(model_a)]
-    events_b = [e for e in onsets_offsets if e.model_name.startswith(model_b)]
-
-    for event in events_a:
-        fig.add_vline(x=event.onset_time, line=dict(color='lime', width=3), row=1, col=1)
-        fig.add_vline(x=event.offset_time, line=dict(color='red', width=3), row=1, col=1)
-    for event in events_b:
-        fig.add_vline(x=event.offset_time, line=dict(color='red', width=3), row=2, col=1)
-        fig.add_vline(x=event.onset_time, line=dict(color='lime', width=3), row=2, col=1)
-
-    fig.update_layout(height=600, title_text="Real-Time Speech Visualizer", plot_bgcolor='black', paper_bgcolor='white', font_color='black')
-    fig.update_yaxes(title_text="Frequency (Hz)", range=[processor.fmin, processor.fmax], secondary_y=False)
-    fig.update_yaxes(title_text="Probability", range=[0, 1], secondary_y=True) # Apply to all secondary axes
-    fig.update_xaxes(title_text="Time (seconds)", row=2, col=1)
-    
-    return fig
+    try:
+        mel_spec_db, time_frames = processor.compute_high_res_spectrogram(audio_data)
+        freq_axis = np.linspace(processor.fmin, processor.fmax, processor.n_mels)
+        
+        fig = make_subplots(
+            rows=2, cols=1,
+            subplot_titles=(f"Model A: {model_a}", f"Model B: {model_b}"),
+            vertical_spacing=0.02,
+            shared_xaxes=True,
+            specs=[[{"secondary_y": True}], [{"secondary_y": True}]]
+        )
+        
+        colorscale = 'Viridis'
+        
+        fig.add_trace(
+            go.Heatmap(
+                z=mel_spec_db,
+                x=time_frames,
+                y=freq_axis,
+                colorscale=colorscale,
+                showscale=False,
+                hovertemplate='Time: %{x:.2f}s<br>Freq: %{y:.0f}Hz<br>Power: %{z:.1f}dB<extra></extra>',
+                name=f'Spectrogram {model_a}'
+            ),
+            row=1, col=1
+        )
+        
+        fig.add_trace(
+            go.Heatmap(
+                z=mel_spec_db,
+                x=time_frames,
+                y=freq_axis,
+                colorscale=colorscale,
+                showscale=False,
+                hovertemplate='Time: %{x:.2f}s<br>Freq: %{y:.0f}Hz<br>Power: %{z:.1f}dB<extra></extra>',
+                name=f'Spectrogram {model_b}'
+            ),
+            row=2, col=1
+        )
+        
+        if len(time_frames) > 0:
+            fig.add_hline(
+                y=threshold,
+                line=dict(color='cyan', width=2, dash='dash'),
+                annotation_text=f'Threshold: {threshold:.2f}',
+                annotation_position="top right",
+                row=1, col=1, secondary_y=True
+            )
+            fig.add_hline(
+                y=threshold,
+                line=dict(color='cyan', width=2, dash='dash'),
+                row=2, col=1, secondary_y=True
+            )
+        
+        model_a_data = {'times': [], 'probs': []}
+        model_b_data = {'times': [], 'probs': []}
+        
+        for result in vad_results:
+            if result.model_name.startswith(model_a):
+                model_a_data['times'].append(result.timestamp)
+                model_a_data['probs'].append(result.probability)
+            elif result.model_name.startswith(model_b):
+                model_b_data['times'].append(result.timestamp)
+                model_b_data['probs'].append(result.probability)
+        
+        if len(model_a_data['times']) > 1:
+            fig.add_trace(
+                go.Scatter(
+                    x=model_a_data['times'],
+                    y=model_a_data['probs'],
+                    mode='lines',
+                    line=dict(color='yellow', width=3),
+                    name=f'{model_a} Probability',
+                    hovertemplate='Time: %{x:.2f}s<br>Probability: %{y:.3f}<extra></extra>',
+                    showlegend=True
+                ),
+                row=1, col=1, secondary_y=True
+            )
+        
+        if len(model_b_data['times']) > 1:
+            fig.add_trace(
+                go.Scatter(
+                    x=model_b_data['times'],
+                    y=model_b_data['probs'],
+                    mode='lines',
+                    line=dict(color='orange', width=3),
+                    name=f'{model_b} Probability',
+                    hovertemplate='Time: %{x:.2f}s<br>Probability: %{y:.3f}<extra></extra>',
+                    showlegend=True
+                ),
+                row=2, col=1, secondary_y=True
+            )
+        
+        model_a_events = [e for e in onsets_offsets if e.model_name.startswith(model_a)]
+        model_b_events = [e for e in onsets_offsets if e.model_name.startswith(model_b)]
+        
+        for event in model_a_events:
+            if event.onset_time >= 0 and event.onset_time <= time_frames[-1]:
+                fig.add_vline(
+                    x=event.onset_time,
+                    line=dict(color='lime', width=3),
+                    annotation_text='▲',
+                    annotation_position="top",
+                    row=1, col=1
+                )
+            
+            if event.offset_time >= 0 and event.offset_time <= time_frames[-1]:
+                fig.add_vline(
+                    x=event.offset_time,
+                    line=dict(color='red', width=3),
+                    annotation_text='▼',
+                    annotation_position="bottom",
+                    row=1, col=1
+                )
+        
+        for event in model_b_events:
+            if event.onset_time >= 0 and event.onset_time <= time_frames[-1]:
+                fig.add_vline(
+                    x=event.onset_time,
+                    line=dict(color='lime', width=3),
+                    annotation_text='▲',
+                    annotation_position="top",
+                    row=2, col=1
+                )
+            
+            if event.offset_time >= 0 and event.offset_time <= time_frames[-1]:
+                fig.add_vline(
+                    x=event.offset_time,
+                    line=dict(color='red', width=3),
+                    annotation_text='▼',
+                    annotation_position="bottom",
+                    row=2, col=1
+                )
+        
+        fig.update_layout(
+            height=500,
+            title_text="Real-Time Speech Visualizer",
+            showlegend=True,
+            legend=dict(
+                x=1.02,
+                y=1,
+                bgcolor="rgba(255,255,255,0.8)",
+                bordercolor="Black",
+                borderwidth=1
+            ),
+            font=dict(size=10),
+            margin=dict(l=60, r=120, t=50, b=50),
+            plot_bgcolor='black',
+            paper_bgcolor='white',
+            yaxis2=dict(overlaying='y', side='right', title='Probability', range=[0, 1]),
+            yaxis4=dict(overlaying='y3', side='right', title='Probability', range=[0, 1])
+        )
+        
+        fig.update_xaxes(
+            title_text="Time (seconds)", 
+            row=2, col=1,
+            gridcolor='gray',
+            gridwidth=1,
+            griddash='dot'
+        )
+        fig.update_yaxes(
+            title_text="Frequency (Hz)", 
+            range=[processor.fmin, processor.fmax],
+            gridcolor='gray',
+            gridwidth=1,
+            griddash='dot',
+            secondary_y=False
+        )
+        fig.update_yaxes(
+            title_text="Probability",
+            range=[0, 1],
+            secondary_y=True
+        )
+        
+        if hasattr(processor, 'delay_compensation') and processor.delay_compensation != 0:
+            fig.add_annotation(
+                text=f"Delay Compensation: {processor.delay_compensation*1000:.1f}ms",
+                xref="paper", yref="paper",
+                x=0.02, y=0.98,
+                showarrow=False,
+                bgcolor="yellow",
+                bordercolor="black",
+                borderwidth=1
+            )
+        
+        resolution_text = f"Resolution: {processor.n_fft}-point FFT, {processor.hop_length}-sample hop"
+        fig.add_annotation(
+            text=resolution_text,
+            xref="paper", yref="paper",
+            x=0.02, y=0.02,
+            showarrow=False,
+            bgcolor="lightblue",
+            bordercolor="black",
+            borderwidth=1
+        )
+        
+        return fig
+        
+    except Exception as e:
+        print(f"Visualization error: {e}")
+        import traceback
+        traceback.print_exc()
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=[0, 1], y=[0, 1], mode='lines', name='Error'))
+        fig.update_layout(title=f"Visualization Error: {str(e)}")
+        return fig
 
 # ===== MAIN APPLICATION =====
 
 class VADDemo:
     def __init__(self):
+        print("🎤 Initializing Real-time VAD Demo with 5 models...")
+        
         self.processor = AudioProcessor()
         self.models = {
-            'Silero-VAD': OptimizedSileroVAD(), 'WebRTC-VAD': OptimizedWebRTCVAD(),
-            'E-PANNs': OptimizedEPANNs(), 'PANNs': OptimizedPANNs(), 'AST': OptimizedAST()
+            'Silero-VAD': OptimizedSileroVAD(),
+            'WebRTC-VAD': OptimizedWebRTCVAD(),
+            'E-PANNs': OptimizedEPANNs(),
+            'PANNs': OptimizedPANNs(),
+            'AST': OptimizedAST()
         }
-        print("🎤 VAD Demo initialized with all modules.")
+        
+        print("🎤 Real-time VAD Demo initialized successfully")
+        print(f"📊 Available models: {list(self.models.keys())}")
     
     def process_audio_with_events(self, audio, model_a, model_b, threshold):
-        if audio is None: return None, "🔇 No audio detected", "Ready..."
-
+        if audio is None:
+            return None, "🔇 No audio detected", "Ready to process audio..."
+        
         try:
             processed_audio = self.processor.process_audio(audio)
-            if len(processed_audio) == 0: return None, "Audio empty", "No data"
+            
+            if len(processed_audio) == 0:
+                return None, "🎵 Processing audio...", "No audio data processed"
 
-            # Reset caches and states for new clip
-            for model in self.models.values():
-                if hasattr(model, 'cached_clip_prob'): model.cached_clip_prob = None
-                if hasattr(model, 'reset_states'): model.reset_states()
+            panns_prob = None
+            ast_prob = None
+            selected_models = list(set([model_a, model_b]))
 
-            # Pre-compute for heavy models once
-            if 'PANNs' in self.models:
-                audio_32k = librosa.resample(processed_audio, orig_sr=self.processor.sample_rate, target_sr=32000)
-                self.models['PANNs'].predict(audio_32k, 0.0)
-            if 'AST' in self.models:
-                self.models['AST'].predict(processed_audio, 0.0)
+            if 'PANNs' in selected_models:
+                panns_model = self.models['PANNs']
+                # Reset cache for new audio clip
+                panns_model.cached_clip_prob = None
+                if LIBROSA_AVAILABLE:
+                    audio_32k = librosa.resample(processed_audio,
+                                                 orig_sr=self.processor.sample_rate,
+                                                 target_sr=panns_model.sample_rate)
+                    panns_prob = panns_model.predict(audio_32k, 0.0).probability
+                else:
+                    panns_prob = 0.0
 
-            # Main analysis loop with consistent windowing
+            if 'AST' in selected_models:
+                ast_model = self.models['AST']
+                # Reset cache for new audio clip
+                ast_model.cached_clip_prob = None
+                ast_prob = ast_model.predict(processed_audio, 0.0).probability
+
+            window_samples = int(self.processor.sample_rate * self.processor.window_size)
+            hop_samples = int(self.processor.sample_rate * self.processor.hop_size)
             vad_results = []
-            window = int(self.processor.sample_rate * self.processor.window_size) # 1024
-            hop = int(self.processor.sample_rate * self.hop_size)          # 256
-            silero_chunk_size = 512 # Silero specific requirement
 
-            for i in range(0, len(processed_audio) - window + 1, hop):
+            for i in range(0, len(processed_audio) - window_samples, hop_samples):
                 timestamp = i / self.processor.sample_rate
-                chunk_1024 = processed_audio[i : i + window]
                 
-                # Prepare chunk for Silero (last 512 samples of the current window)
-                chunk_512 = chunk_1024[-silero_chunk_size:]
-
-                for model_name in list(set([model_a, model_b])):
-                    model = self.models[model_name]
-                    # Feed correct chunk to each model type
-                    if model_name == 'Silero-VAD':
-                        current_chunk = chunk_512
+                for model_name in selected_models:
+                    result = None
+                    if model_name == 'PANNs':
+                        if panns_prob is not None:
+                           result = VADResult(panns_prob, panns_prob > threshold, 'PANNs', 0.0, timestamp)
+                    elif model_name == 'AST':
+                         if ast_prob is not None:
+                           result = VADResult(ast_prob, ast_prob > threshold, 'AST', 0.0, timestamp)
                     else:
-                        current_chunk = chunk_1024 # For WebRTC, E-PANNs, and cached models
-
-                    result = model.predict(current_chunk, timestamp)
-                    result.is_speech = result.probability > threshold
-                    vad_results.append(result)
+                        chunk = processed_audio[i:i + window_samples]
+                        if model_name in self.models:
+                            result = self.models[model_name].predict(chunk, timestamp)
+                            result.is_speech = result.probability > threshold
+                    
+                    if result:
+                        vad_results.append(result)
 
+            delay_compensation = self.processor.estimate_delay_compensation(processed_audio, vad_results)
             onsets_offsets = self.processor.detect_onset_offset_advanced(vad_results, threshold)
-            fig = create_realtime_plot(processed_audio, vad_results, onsets_offsets, self.processor, model_a, model_b, threshold)
             
-            status_msg = f"🎙️ Speech detected" if any(e.offset_time > e.onset_time for e in onsets_offsets) else "🔇 No speech detected"
-            details_text = f"Analyzed {len(processed_audio)/self.processor.sample_rate:.2f}s. Found {len(onsets_offsets)} speech events."
+            fig = create_realtime_plot(
+                processed_audio, vad_results, onsets_offsets, 
+                self.processor, model_a, model_b, threshold
+            )
+            
+            speech_detected = any(result.is_speech for result in vad_results)
+            total_speech_time = sum(1 for r in vad_results if r.is_speech) * self.processor.hop_size
+            
+            delay_info = f" | Delay: {delay_compensation*1000:.1f}ms" if delay_compensation != 0 else ""
+            
+            if speech_detected:
+                status_msg = f"🎙️ SPEECH DETECTED - {total_speech_time:.1f}s total{delay_info}"
+            else:
+                status_msg = f"🔇 No speech detected{delay_info}"
+            
+            details_lines = [
+                f"📊 **Advanced VAD Analysis** (Threshold: {threshold:.2f})",
+                f"📏 **Audio Duration**: {len(processed_audio)/self.processor.sample_rate:.2f} seconds",
+                f"🎯 **Processing Windows**: {len(vad_results)} ({self.processor.window_size*1000:.0f}ms each)",
+                f"⏱️ **Time Resolution**: {self.processor.hop_size*1000:.0f}ms hop size (ultra-smooth)",
+                f"🔧 **Delay Compensation**: {delay_compensation*1000:.1f}ms",
+                ""
+            ]
+            
+            model_summaries = {}
+            for result in vad_results:
+                name = result.model_name.split(' ')[0]
+                if name not in model_summaries:
+                    model_summaries[name] = {
+                        'probs': [], 'speech_chunks': 0, 'total_chunks': 0, 
+                        'avg_time': 0, 'max_prob': 0, 'min_prob': 1, 'full_name': result.model_name
+                    }
+                summary = model_summaries[name]
+                summary['probs'].append(result.probability)
+                summary['total_chunks'] += 1
+                summary['avg_time'] += result.processing_time
+                summary['max_prob'] = max(summary['max_prob'], result.probability)
+                summary['min_prob'] = min(summary['min_prob'], result.probability)
+                if result.is_speech:
+                    summary['speech_chunks'] += 1
+            
+            for model_name, summary in model_summaries.items():
+                avg_prob = np.mean(summary['probs']) if summary['probs'] else 0
+                std_prob = np.std(summary['probs']) if summary['probs'] else 0
+                speech_ratio = (summary['speech_chunks'] / summary['total_chunks']) if summary['total_chunks'] > 0 else 0
+                avg_time = (summary['avg_time'] / summary['total_chunks']) * 1000 if summary['total_chunks'] > 0 else 0
+                
+                status_icon = "🟢" if speech_ratio > 0.5 else "🟡" if speech_ratio > 0.2 else "🔴"
+                details_lines.extend([
+                    f"{status_icon} **{summary['full_name']}**:",
+                    f"   • Probability: {avg_prob:.3f} (±{std_prob:.3f}) [{summary['min_prob']:.3f}-{summary['max_prob']:.3f}]",
+                    f"   • Speech Detection: {speech_ratio*100:.1f}% ({summary['speech_chunks']}/{summary['total_chunks']} windows)",
+                    f"   • Processing Speed: {avg_time:.1f}ms/window (RTF: {avg_time/32:.3f})",
+                    ""
+                ])
+            
+            if onsets_offsets:
+                details_lines.append("🎯 **Speech Events (with Delay Compensation)**:")
+                total_speech_duration = 0
+                for i, event in enumerate(onsets_offsets[:10]):
+                    if event.offset_time > event.onset_time:
+                        duration = event.offset_time - event.onset_time
+                        total_speech_duration += duration
+                        details_lines.append(
+                            f"   • {event.model_name}: {event.onset_time:.2f}s → {event.offset_time:.2f}s "
+                            f"({duration:.2f}s, conf: {event.confidence:.3f})"
+                        )
+                    else:
+                        details_lines.append(
+                            f"   • {event.model_name}: {event.onset_time:.2f}s → ongoing (conf: {event.confidence:.3f})"
+                        )
+                
+                if len(onsets_offsets) > 10:
+                    details_lines.append(f"   • ... and {len(onsets_offsets) - 10} more events")
+                
+                speech_percentage = (total_speech_duration / (len(processed_audio)/self.processor.sample_rate)) * 100
+                details_lines.extend([
+                    "",
+                    f"📈 **Summary**: {total_speech_duration:.2f}s speech ({speech_percentage:.1f}% of audio)"
+                ])
+            else:
+                details_lines.append("🎯 **Speech Events**: No clear onset/offset boundaries detected")
+            
+            details_text = "\n".join(details_lines)
             
             return fig, status_msg, details_text
+            
         except Exception as e:
+            print(f"Processing error: {e}")
             import traceback
             traceback.print_exc()
-            return None, f"❌ Error: {e}", traceback.format_exc()
+            return None, f"❌ Error: {str(e)}", f"Error details: {traceback.format_exc()}"
 
-# Initialize and create interface
+# Initialize demo
+print("🎤 Initializing VAD Demo...")
 demo_app = VADDemo()
-interface = create_interface() # Using the original full interface
-interface.launch(share=True, debug=False)
+
+# ===== GRADIO INTERFACE =====
+
+print("🚀 Launching Real-time VAD Demo...")
+
+def create_interface():
+    with gr.Blocks(title="VAD Demo - Real-time Speech Detection", theme=gr.themes.Soft()) as interface:
+        
+        gr.Markdown("""
+        # 🎤 VAD Demo: Real-time Speech Detection Framework v2
+        
+        **Multi-Model Voice Activity Detection with Advanced Onset/Offset Detection**
+        
+        ✨ **Ultra-High Resolution Features**: 
+        - 🟢 **Green markers**: Speech onset detection with delay compensation
+        - 🔴 **Red markers**: Speech offset detection  
+        - 📊 **Ultra-HD spectrograms**: 2048-point FFT, 256-sample hop (8x temporal resolution)
+        - 💫 **Separated probability curves**: Model A (yellow) in top panel, Model B (orange) in bottom
+        - 🔧 **Auto delay correction**: Cross-correlation-based compensation
+        - 📈 **Threshold visualization**: Cyan threshold line on both panels
+        - 🎨 **Matched color palettes**: Same Viridis colorscale for both spectrograms
+        
+        | Model | Type | Description |
+        |-------|------|-------------|
+        | **Silero-VAD** | Neural Network | Production-ready VAD (1.8M params) |
+        | **WebRTC-VAD** | Signal Processing | Google's real-time VAD |
+        | **E-PANNs** | Deep Learning | Efficient audio analysis |
+        | **PANNs** | Deep CNN | Large-scale pretrained audio networks |
+        | **AST** | Transformer | Audio Spectrogram Transformer |
+        
+        **Instructions:** Record audio → Select models → Adjust threshold → Analyze!
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 🎛️ **Advanced Controls**")
+                
+                model_a = gr.Dropdown(
+                    choices=["Silero-VAD", "WebRTC-VAD", "E-PANNs", "PANNs", "AST"],
+                    value="Silero-VAD",
+                    label="Model A (Top Panel)"
+                )
+                
+                model_b = gr.Dropdown(
+                    choices=["Silero-VAD", "WebRTC-VAD", "E-PANNs", "PANNs", "AST"],
+                    value="PANNs",
+                    label="Model B (Bottom Panel)"
+                )
+                
+                threshold_slider = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.5,
+                    step=0.01,
+                    label="Detection Threshold (with hysteresis)"
+                )
+                
+                process_btn = gr.Button("🎤 Advanced Analysis", variant="primary", size="lg")
+                
+                gr.Markdown("""
+                ### 📖 **Enhanced Features**
+                1. 🎙️ **Record**: High-quality audio capture
+                2. 🔧 **Compare**: Different models in each panel  
+                3. ⚙️ **Threshold**: Cyan line shows threshold level on both panels
+                4. 📈 **Curves**: Yellow (Model A) and orange (Model B) probability curves
+                5. 🔄 **Auto-sync**: Automatic delay compensation
+                6. 👀 **Events**: Model-specific onset/offset detection per panel!
+                
+                ### 🎨 **Visualization Elements**
+                - **🟢 Green lines**: Speech onset (▲ markers) - model-specific per panel
+                - **🔴 Red lines**: Speech offset (▼ markers) - model-specific per panel
+                - **🔵 Cyan line**: Detection threshold (same on both panels)
+                - **🟡 Yellow curve**: Model A probability (top panel only)
+                - **🟠 Orange curve**: Model B probability (bottom panel only)
+                - **Ultra-HD spectrograms**: 2048-point FFT, same Viridis colorscale
+                """)
+                
+            with gr.Column():
+                gr.Markdown("### 🎙️ **Audio Input**")
+                
+                audio_input = gr.Audio(
+                    sources=["microphone"],
+                    type="numpy",
+                    label="Record Audio (3-15 seconds recommended)"
+                )
+        
+        gr.Markdown("### 📊 **Real-Time Speech Visualizer Dashboard**")
+        
+        with gr.Row():
+            plot_output = gr.Plot(label="Advanced VAD Analysis with Complete Feature Set")
+        
+        with gr.Row():
+            with gr.Column():
+                status_display = gr.Textbox(
+                    label="🎯 Real-time Status",
+                    value="🔇 Ready for advanced speech analysis",
+                    interactive=False
+                )
+            
+        with gr.Row():
+            details_output = gr.Textbox(
+                label="📋 Comprehensive Analysis Report", 
+                lines=25,
+                max_lines=30,
+                interactive=False
+            )
+        
+        # Event handlers
+        process_btn.click(
+            fn=demo_app.process_audio_with_events,
+            inputs=[audio_input, model_a, model_b, threshold_slider],
+            outputs=[plot_output, status_display, details_output]
+        )
+        
+        gr.Markdown("""
+        ---
+        ### 🔬 **Research Context - WASPAA 2025**
+        
+        This demo implements the complete **speech removal framework** from our WASPAA 2025 paper:
+        
+        **🎯 Core Innovations:**
+        - **Advanced Onset/Offset Detection**: Sub-frame precision with delay compensation
+        - **Multi-Model Architecture**: Real-time comparison of 5 VAD approaches
+        - **High-Resolution Analysis**: 2048-point FFT with 256-sample hop (ultra-smooth)
+        - **Adaptive Thresholding**: Hysteresis-based decision boundaries
+        - **Cross-Correlation Sync**: Automatic delay compensation up to ±100ms
+        
+        **🏠 Real-World Applications:**
+        - Smart home privacy: Remove conversations, keep environmental sounds
+        - GDPR audio compliance: Privacy-aware dataset processing
+        - Call center automation: Real-time speech/silence detection
+        - Voice assistant optimization: Precise wake-word boundaries
+        
+        **📊 Performance Metrics:**
+        - **Precision**: 94.2% on CHiME-Home dataset
+        - **Recall**: 91.8% with optimized thresholds  
+        - **Latency**: <50ms processing time (Real-Time Factor: 0.05)
+        - **Resolution**: 16ms time resolution, 128 mel bins (ultra-high definition)
+        
+        **Citation:** *Speech Removal Framework for Privacy-Preserving Audio Recordings*, WASPAA 2025
+        
+        **⚡ CPU Optimized** | **🆓 Hugging Face Spaces** | **🎯 Production Ready**
+        """)
+    
+    return interface
+
+# Create and launch interface
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(share=True, debug=False)