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

app.py

@@ -42,7 +42,8 @@ except ImportError:
 
 # PANNs imports
 try:
-    import panns_inference
+    # MODIFIED: Import labels as well for correct probability calculation
+    from panns_inference import AudioTagging, labels
     PANNS_AVAILABLE = True
     print("✅ PANNs available")
 except ImportError:
@@ -232,8 +233,6 @@ class OptimizedPANNs:
     def load_model(self):
         try:
             if PANNS_AVAILABLE:
-                # Use panns_inference for easier model loading
-                from panns_inference import AudioTagging
                 self.model = AudioTagging(checkpoint_path=None, device=self.device)
                 print(f"✅ {self.model_name} loaded successfully")
             else:
@@ -247,7 +246,6 @@ class OptimizedPANNs:
         start_time = time.time()
         
         if self.model is None or len(audio) == 0:
-            # Fallback using basic energy detection
             if len(audio) > 0:
                 energy = np.sum(audio ** 2)
                 threshold = 0.01
@@ -262,24 +260,16 @@ class OptimizedPANNs:
             if len(audio.shape) > 1:
                 audio = audio.mean(axis=1)
             
-            # Resample to 32kHz if needed
-            if LIBROSA_AVAILABLE and len(audio) > 0:
-                audio = librosa.resample(audio, orig_sr=16000, target_sr=self.sample_rate)
+            # MODIFIED: Removed resampling and 10-second padding.
+            # This function now expects the full audio clip at the correct sample rate (32kHz).
             
-            # Ensure minimum length for PANNs (10 seconds)
-            required_length = self.sample_rate * 10
-            if len(audio) < required_length:
-                audio = np.pad(audio, (0, required_length - len(audio)), 'constant')
-            elif len(audio) > required_length:
-                audio = audio[:required_length]
+            # MODIFIED: Use clipwise_output for probabilities, not embeddings.
+            clip_probs, _ = self.model.inference(audio[None, :])  # Add batch dimension
             
-            # Run inference
-            _, embeddings = self.model.inference(audio[None, :])  # Add batch dimension
-            
-            # Use speech class probability (assuming class index for speech/voice)
-            # PANNs outputs 527 classes, we'll look for speech-related classes
-            speech_classes = [0, 1, 2, 3, 4, 5]  # Typical speech-related indices
-            speech_prob = np.mean([embeddings[0][i] for i in speech_classes if i < len(embeddings[0])])
+            # MODIFIED: Use imported `labels` to find indices of speech-related classes for a robust average.
+            speech_tags = ['Speech', 'Conversation', 'Narration', 'Male speech', 'Female speech', 'Child speech']
+            speech_indices = [labels.index(tag) for tag in speech_tags if tag in labels]
+            speech_prob = clip_probs[0][speech_indices].mean().item()
             
             probability = float(np.clip(speech_prob, 0, 1))
             is_speech = probability > 0.5
@@ -288,7 +278,6 @@ class OptimizedPANNs:
             
         except Exception as e:
             print(f"Error in {self.model_name}: {e}")
-            # Fallback
             if len(audio) > 0:
                 energy = np.sum(audio ** 2)
                 threshold = 0.01
@@ -311,7 +300,6 @@ class OptimizedAST:
     def load_model(self):
         try:
             if AST_AVAILABLE:
-                # Load pretrained AST model from Hugging Face
                 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)
@@ -329,7 +317,6 @@ class OptimizedAST:
         start_time = time.time()
         
         if self.model is None or len(audio) == 0:
-            # Fallback using spectral features
             if len(audio) > 0:
                 if LIBROSA_AVAILABLE:
                     spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=audio, sr=self.sample_rate))
@@ -348,26 +335,19 @@ class OptimizedAST:
             if len(audio.shape) > 1:
                 audio = audio.mean(axis=1)
             
-            # Ensure minimum length (AST expects longer sequences)
-            min_length = self.sample_rate * 2  # 2 seconds minimum
+            min_length = self.sample_rate * 2
             if len(audio) < min_length:
                 audio = np.pad(audio, (0, min_length - len(audio)), 'constant')
             
-            # Process with feature extractor
             inputs = self.feature_extractor(audio, sampling_rate=self.sample_rate, return_tensors="pt")
-            
-            # Move to device
             inputs = {k: v.to(self.device) for k, v in inputs.items()}
             
-            # Run inference
             with torch.no_grad():
                 outputs = self.model(**inputs)
                 logits = outputs.logits
                 probs = torch.sigmoid(logits)
             
-            # Extract speech-related probabilities
-            # AudioSet classes: look for speech, voice, etc.
-            speech_indices = [0, 1, 2, 3, 4, 5]  # First few classes often speech-related
+            speech_indices = [0, 1, 2, 3, 4, 5]
             speech_probs = probs[0][speech_indices]
             speech_prob = torch.mean(speech_probs).item()
             
@@ -378,7 +358,6 @@ class OptimizedAST:
             
         except Exception as e:
             print(f"Error in {self.model_name}: {e}")
-            # Fallback
             if len(audio) > 0:
                 energy = np.sum(audio ** 2)
                 threshold = 0.01
@@ -397,18 +376,16 @@ class AudioProcessor:
         self.chunk_duration = 4.0
         self.chunk_size = int(sample_rate * self.chunk_duration)
         
-        # Ultra high-resolution spectrogram parameters
-        self.n_fft = 8192  # Ultra high frequency resolution
-        self.hop_length = 128  # Ultra high time resolution
+        # MODIFIED: Changed FFT parameters for higher temporal resolution.
+        self.n_fft = 2048          # Was 8192. (128 ms window @ 16kHz)
+        self.hop_length = 256      # Was 128. (16 ms hop @ 16kHz for a good balance)
         self.n_mels = 128
         self.fmin = 20
         self.fmax = 8000
         
-        # Real-time processing parameters
-        self.window_size = 0.032  # 32ms windows like WebRTC
-        self.hop_size = 0.008     # 8ms hop for ultra-smooth processing
+        self.window_size = 0.032
+        self.hop_size = 0.008
         
-        # Delay correction parameters
         self.delay_compensation = 0.0
         self.correlation_threshold = 0.7
         
@@ -439,22 +416,20 @@ class AudioProcessor:
             return np.array([])
     
     def compute_high_res_spectrogram(self, audio_data):
-        """Compute high-resolution spectrogram matching GitHub demo quality"""
         try:
             if LIBROSA_AVAILABLE and len(audio_data) > 0:
-                # High-resolution STFT
+                # MODIFIED: Added center=False to prevent time shift and improve onset/offset alignment.
                 stft = librosa.stft(
                     audio_data,
                     n_fft=self.n_fft,
                     hop_length=self.hop_length,
                     win_length=self.n_fft,
-                    window='hann'
+                    window='hann',
+                    center=False
                 )
                 
-                # Convert to power spectrogram
                 power_spec = np.abs(stft) ** 2
                 
-                # Apply mel filterbank
                 mel_basis = librosa.filters.mel(
                     sr=self.sample_rate,
                     n_fft=self.n_fft,
@@ -466,12 +441,10 @@ class AudioProcessor:
                 mel_spec = np.dot(mel_basis, power_spec)
                 mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)
                 
-                # Create high-resolution time axis
                 time_frames = np.arange(mel_spec_db.shape[1]) * self.hop_length / self.sample_rate
                 
                 return mel_spec_db, time_frames
             else:
-                # High-resolution fallback using scipy
                 from scipy import signal
                 f, t, Sxx = signal.spectrogram(
                     audio_data, 
@@ -481,10 +454,8 @@ class AudioProcessor:
                     window='hann'
                 )
                 
-                # Create mel-like spectrogram with better resolution
                 mel_spec_db = np.zeros((self.n_mels, Sxx.shape[1]))
                 
-                # Logarithmic frequency spacing for mel-like scale
                 mel_freqs = np.logspace(
                     np.log10(self.fmin), 
                     np.log10(min(self.fmax, self.sample_rate/2)), 
@@ -504,43 +475,35 @@ class AudioProcessor:
                 
         except Exception as e:
             print(f"Spectrogram computation error: {e}")
-            # Return empty spectrogram
-            dummy_spec = np.zeros((self.n_mels, 200))  # Higher resolution
+            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]:
-        """Advanced onset/offset detection with delay compensation"""
         onsets_offsets = []
         
-        if len(vad_results) < 3:  # Need at least 3 points for trend analysis
+        if len(vad_results) < 3:
             return onsets_offsets
         
-        # Group by model
         models = {}
         for result in vad_results:
             if result.model_name not in models:
                 models[result.model_name] = []
             models[result.model_name].append(result)
         
-        # Advanced detection for each model
         for model_name, results in models.items():
             if len(results) < 3:
                 continue
             
-            # Sort by timestamp
             results.sort(key=lambda x: x.timestamp)
             
-            # Extract probability time series
             timestamps = np.array([r.timestamp for r in results])
             probabilities = np.array([r.probability for r in results])
             
-            # Apply smoothing to reduce noise
             if len(probabilities) > 5:
                 window_size = min(5, len(probabilities) // 3)
                 probabilities = np.convolve(probabilities, np.ones(window_size)/window_size, mode='same')
             
-            # Detect crossings with hysteresis
             upper_thresh = threshold + 0.1
             lower_thresh = threshold - 0.1
             
@@ -552,13 +515,10 @@ class AudioProcessor:
                 curr_prob = probabilities[i]
                 curr_time = timestamps[i]
                 
-                # Onset detection: crossing upper threshold from below
                 if not in_speech_segment and prev_prob <= upper_thresh and curr_prob > upper_thresh:
                     in_speech_segment = True
-                    # Apply delay compensation
                     current_onset_time = curr_time - self.delay_compensation
                     
-                # Offset detection: crossing lower threshold from above
                 elif in_speech_segment and prev_prob >= lower_thresh and curr_prob < lower_thresh:
                     in_speech_segment = False
                     if current_onset_time >= 0:
@@ -574,7 +534,6 @@ class AudioProcessor:
                         ))
                         current_onset_time = -1
             
-            # Handle ongoing speech at the end
             if in_speech_segment and current_onset_time >= 0:
                 onsets_offsets.append(OnsetOffset(
                     onset_time=max(0, current_onset_time),
@@ -586,12 +545,10 @@ class AudioProcessor:
         return onsets_offsets
     
     def estimate_delay_compensation(self, audio_data, vad_results):
-        """Estimate delay compensation using cross-correlation"""
         try:
             if len(audio_data) == 0 or len(vad_results) == 0:
                 return 0.0
             
-            # Create energy-based reference signal
             window_size = int(self.sample_rate * self.window_size)
             hop_size = int(self.sample_rate * self.hop_size)
             
@@ -605,28 +562,23 @@ class AudioProcessor:
             if len(energy_signal) == 0:
                 return 0.0
             
-            # Normalize energy signal
             energy_signal = (energy_signal - np.mean(energy_signal)) / (np.std(energy_signal) + 1e-8)
             
-            # Create VAD probability signal
             vad_times = np.array([r.timestamp for r in vad_results])
             vad_probs = np.array([r.probability for r in vad_results])
             
-            # Interpolate VAD probabilities to match energy signal timing
             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)
             
-            # Cross-correlation to find delay
             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
                 
-                # Only apply compensation if correlation is strong enough
                 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)  # Limit to ±100ms
+                    self.delay_compensation = np.clip(delay_seconds, -0.1, 0.1)
                 
             return self.delay_compensation
             
@@ -639,19 +591,14 @@ class AudioProcessor:
 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):
-    """Create complete GitHub-style visualization with separated models per panel"""
     
     if not PLOTLY_AVAILABLE:
         return None
     
     try:
-        # Compute ultra high-resolution spectrogram
         mel_spec_db, time_frames = processor.compute_high_res_spectrogram(audio_data)
-        
-        # Create frequency axis
         freq_axis = np.linspace(processor.fmin, processor.fmax, processor.n_mels)
         
-        # Create the main figure with proper layout
         fig = make_subplots(
             rows=2, cols=1,
             subplot_titles=(f"Model A: {model_a}", f"Model B: {model_b}"),
@@ -659,10 +606,8 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
             shared_xaxes=True
         )
         
-        # Use SAME colorscale for both panels
         colorscale = 'Viridis'
         
-        # Panel A - Top spectrogram (Model A)
         fig.add_trace(
             go.Heatmap(
                 z=mel_spec_db,
@@ -676,13 +621,12 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
             row=1, col=1
         )
         
-        # Panel B - Bottom spectrogram (Model B) - SAME colorscale
         fig.add_trace(
             go.Heatmap(
                 z=mel_spec_db,
                 x=time_frames,
                 y=freq_axis,
-                colorscale=colorscale,  # Same as Panel A
+                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}'
@@ -690,9 +634,7 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
             row=2, col=1
         )
         
-        # Add threshold line (horizontal) on both spectrograms
         if len(time_frames) > 0:
-            # Map threshold to frequency domain for visualization
             threshold_freq = processor.fmin + (threshold * (processor.fmax - processor.fmin))
             
             fig.add_hline(
@@ -708,19 +650,17 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
                 row=2, col=1
             )
         
-        # Separate VAD results by model
         model_a_data = {'times': [], 'probs': []}
         model_b_data = {'times': [], 'probs': []}
         
         for result in vad_results:
-            if result.model_name == model_a:
+            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 == model_b:
+            elif result.model_name.startswith(model_b):
                 model_b_data['times'].append(result.timestamp)
                 model_b_data['probs'].append(result.probability)
         
-        # Add probability curve ONLY for Model A in Panel A
         if len(model_a_data['times']) > 1:
             prob_freqs_a = [processor.fmin + (p * (processor.fmax - processor.fmin)) for p in model_a_data['probs']]
             
@@ -738,7 +678,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
                 row=1, col=1
             )
         
-        # Add probability curve ONLY for Model B in Panel B
         if len(model_b_data['times']) > 1:
             prob_freqs_b = [processor.fmin + (p * (processor.fmax - processor.fmin)) for p in model_b_data['probs']]
             
@@ -756,11 +695,9 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
                 row=2, col=1
             )
         
-        # Separate onset/offset markers by model
-        model_a_events = [e for e in onsets_offsets if e.model_name == model_a]
-        model_b_events = [e for e in onsets_offsets if e.model_name == model_b]
+        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)]
         
-        # Add onset and offset markers for Model A (Panel A only)
         for event in model_a_events:
             if event.onset_time >= 0 and event.onset_time <= time_frames[-1]:
                 fig.add_vline(
@@ -780,7 +717,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
                     row=1, col=1
                 )
         
-        # Add onset and offset markers for Model B (Panel B only)
         for event in model_b_events:
             if event.onset_time >= 0 and event.onset_time <= time_frames[-1]:
                 fig.add_vline(
@@ -800,7 +736,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
                     row=2, col=1
                 )
         
-        # Update layout to match GitHub demo
         fig.update_layout(
             height=500,
             title_text="Real-Time Speech Visualizer",
@@ -818,7 +753,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
             paper_bgcolor='white'
         )
         
-        # Update axes to match original
         fig.update_xaxes(
             title_text="Time (seconds)", 
             row=2, col=1,
@@ -843,7 +777,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
             griddash='dot'
         )
         
-        # Add delay compensation info if available
         if hasattr(processor, 'delay_compensation') and processor.delay_compensation != 0:
             fig.add_annotation(
                 text=f"Delay Compensation: {processor.delay_compensation*1000:.1f}ms",
@@ -855,7 +788,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
                 borderwidth=1
             )
         
-        # Add resolution info
         resolution_text = f"Resolution: {processor.n_fft}-point FFT, {processor.hop_length}-sample hop"
         fig.add_annotation(
             text=resolution_text,
@@ -871,7 +803,6 @@ def create_realtime_plot(audio_data: np.ndarray, vad_results: List[VADResult],
         
     except Exception as e:
         print(f"Visualization error: {e}")
-        # Return simple fallback
         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)}")
@@ -896,50 +827,71 @@ class VADDemo:
         print(f"📊 Available models: {list(self.models.keys())}")
     
     def process_audio_with_events(self, audio, model_a, model_b, threshold):
-        """Process audio with complete GitHub demo functionality"""
-        
         if audio is None:
             return None, "🔇 No audio detected", "Ready to process audio..."
         
         try:
-            # Process audio
             processed_audio = self.processor.process_audio(audio)
             
             if len(processed_audio) == 0:
                 return None, "🎵 Processing audio...", "No audio data processed"
-            
-            # Real-time chunk processing with higher resolution
+
+            # MODIFIED: Efficiently pre-compute results for heavy models (PANNs, AST) once per clip.
+            panns_prob = None
+            ast_prob = None
+            selected_models = [model_a, model_b] if model_a != model_b else [model_a]
+
+            # Pre-compute for PANNs if selected
+            if 'PANNs' in selected_models:
+                model_instance = self.models['PANNs']
+                if LIBROSA_AVAILABLE:
+                    # Resample audio to 32kHz for PANNs
+                    audio_32k = librosa.resample(processed_audio, orig_sr=self.processor.sample_rate, target_sr=model_instance.sample_rate)
+                    vad_result = model_instance.predict(audio_32k, 0.0)
+                    panns_prob = vad_result.probability
+                else:
+                    panns_prob = 0.0  # Fallback if librosa isn't available for resampling
+
+            # Pre-compute for AST if selected
+            if 'AST' in selected_models:
+                model_instance = self.models['AST']
+                vad_result = model_instance.predict(processed_audio, 0.0)
+                ast_prob = vad_result.probability
+
+            # MODIFIED: Process in chunks and use pre-computed results for heavy models.
             window_samples = int(self.processor.sample_rate * self.processor.window_size)
             hop_samples = int(self.processor.sample_rate * self.processor.hop_size)
-            
             vad_results = []
-            selected_models = [model_a, model_b] if model_a != model_b else [model_a]
-            
-            # Process with sliding windows for smooth analysis
+
             for i in range(0, len(processed_audio) - window_samples, hop_samples):
-                chunk = processed_audio[i:i + window_samples]
                 timestamp = i / self.processor.sample_rate
                 
                 for model_name in selected_models:
-                    if model_name in self.models:
-                        result = self.models[model_name].predict(chunk, timestamp)
-                        # Apply threshold
-                        result.is_speech = result.probability > threshold
+                    result = None
+                    if model_name == 'PANNs' and panns_prob is not None:
+                        # Use pre-computed result, creating a new VADResult for the current timestamp
+                        result = VADResult(panns_prob, panns_prob > threshold, 'PANNs', 0.0, timestamp)
+                    elif model_name == 'AST' and ast_prob is not None:
+                        # Use pre-computed result for AST
+                        result = VADResult(ast_prob, ast_prob > threshold, 'AST', 0.0, timestamp)
+                    elif model_name not in ['PANNs', 'AST']:
+                        # Process lightweight models on the fly for each chunk
+                        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)
-            
-            # Estimate and apply delay compensation
+
             delay_compensation = self.processor.estimate_delay_compensation(processed_audio, vad_results)
-            
-            # Advanced onset/offset detection with delay compensation
             onsets_offsets = self.processor.detect_onset_offset_advanced(vad_results, threshold)
             
-            # Create complete GitHub-style visualization
             fig = create_realtime_plot(
                 processed_audio, vad_results, onsets_offsets, 
                 self.processor, model_a, model_b, threshold
             )
             
-            # Create enhanced status message
             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
             
@@ -950,7 +902,6 @@ class VADDemo:
             else:
                 status_msg = f"🔇 No speech detected{delay_info}"
             
-            # Create comprehensive analysis
             details_lines = [
                 f"📊 **Advanced VAD Analysis** (Threshold: {threshold:.2f})",
                 f"📏 **Audio Duration**: {len(processed_audio)/self.processor.sample_rate:.2f} seconds",
@@ -960,15 +911,15 @@ class VADDemo:
                 ""
             ]
             
-            # Enhanced model summaries
             model_summaries = {}
             for result in vad_results:
-                if result.model_name not in model_summaries:
-                    model_summaries[result.model_name] = {
+                name = result.model_name.split(' ')[0] # Group fallbacks with main model
+                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
+                        'avg_time': 0, 'max_prob': 0, 'min_prob': 1, 'full_name': result.model_name
                     }
-                summary = model_summaries[result.model_name]
+                summary = model_summaries[name]
                 summary['probs'].append(result.probability)
                 summary['total_chunks'] += 1
                 summary['avg_time'] += result.processing_time
@@ -978,25 +929,24 @@ class VADDemo:
                     summary['speech_chunks'] += 1
             
             for model_name, summary in model_summaries.items():
-                avg_prob = np.mean(summary['probs'])
-                std_prob = np.std(summary['probs'])
-                speech_ratio = summary['speech_chunks'] / summary['total_chunks']
-                avg_time = (summary['avg_time'] / summary['total_chunks']) * 1000
+                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} **{model_name}**:",
+                    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})",
                     ""
                 ])
             
-            # Advanced onset/offset analysis
             if onsets_offsets:
                 details_lines.append("🎯 **Speech Events (with Delay Compensation)**:")
                 total_speech_duration = 0
-                for i, event in enumerate(onsets_offsets[:10]):  # Show first 10 events
+                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
@@ -1026,7 +976,9 @@ class VADDemo:
             
         except Exception as e:
             print(f"Processing error: {e}")
-            return None, f"❌ Error: {str(e)}", f"Error details: {str(e)}"
+            import traceback
+            traceback.print_exc()
+            return None, f"❌ Error: {str(e)}", f"Error details: {traceback.format_exc()}"
 
 # Initialize demo
 print("🎤 Initializing VAD Demo...")
@@ -1047,7 +999,7 @@ def create_interface():
         ✨ **Ultra-High Resolution Features**: 
         - 🟢 **Green markers**: Speech onset detection with delay compensation
         - 🔴 **Red markers**: Speech offset detection  
-        - 📊 **Ultra-HD spectrograms**: 8192-point FFT, 128-sample hop (4x resolution)
+        - 📊 **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
@@ -1105,7 +1057,7 @@ def create_interface():
                 - **🔵 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**: 8192-point FFT, same Viridis colorscale
+                - **Ultra-HD spectrograms**: 2048-point FFT, same Viridis colorscale
                 """)
                 
             with gr.Column():
@@ -1154,7 +1106,7 @@ def create_interface():
         **🎯 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**: 8192-point FFT with 128-sample hop (ultra-smooth)
+        - **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
         
@@ -1168,7 +1120,7 @@ def create_interface():
         - **Precision**: 94.2% on CHiME-Home dataset
         - **Recall**: 91.8% with optimized thresholds  
         - **Latency**: <50ms processing time (Real-Time Factor: 0.05)
-        - **Resolution**: 8ms time resolution, 128 mel bins (ultra-high definition)
+        - **Resolution**: 16ms time resolution, 128 mel bins (ultra-high definition)
         
         **Citation:** *Speech Removal Framework for Privacy-Preserving Audio Recordings*, WASPAA 2025