multithread for low latency

detector.py

@@ -4,6 +4,7 @@ import numpy as np
 import scipy.stats as stats
 import torch.nn.functional as F
 from transformers import AutoModelForAudioClassification, AutoFeatureExtractor, WhisperProcessor, WhisperForConditionalGeneration
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import base64
 import io
 import tempfile
@@ -154,7 +155,9 @@ class HybridEnsembleDetector:
         self.CV_HUMAN_THRESHOLD = 0.32
         self.INTENSITY_MIN_STD = 0.05
         self.INTENSITY_MAX_STD = 0.15
-        
+        # Analyze only middle N seconds for physics (reduces latency ~60% vs full 30s)
+        self.physics_analysis_duration = 8  # seconds; middle segment where voice is most stable
+
         print("✅ Hybrid Detector Ready\n")
 
     # ==========================================================
@@ -342,30 +345,36 @@ class HybridEnsembleDetector:
                 y = y[:max_samples]
                 duration = self.max_duration
                 was_truncated = True
+
+            # Use middle segment only for physics (faster; voice most stable in middle)
+            seg_dur = min(self.physics_analysis_duration, duration)
+            half = (duration - seg_dur) / 2.0
+            start_samp = int(half * sr)
+            end_samp = int((half + seg_dur) * sr)
+            y_physics = y[start_samp:end_samp]
+
+            print(f"   🔬 Running physics analysis on middle {seg_dur:.1f}s of {duration:.1f}s audio at {sr}Hz")
             
-            print(f"   🔬 Running physics analysis on {duration:.1f}s audio at {sr}Hz")
-            
-            # Robust pitch tracking using PYIN
+            # Fast pitch tracking using YIN (faster than PYIN, suitable for CPU/HF Spaces)
             try:
-                f0, voiced_flag, voiced_probs = librosa.pyin(
-                    y, 
+                f0 = librosa.yin(
+                    y_physics,
                     fmin=librosa.note_to_hz('C2'),  # ~65 Hz
                     fmax=librosa.note_to_hz('C7'),  # ~2093 Hz
                     sr=sr,
-                    frame_length=2048
+                    frame_length=2048,
                 )
-                valid_f0 = f0[~np.isnan(f0)]
+                valid_f0 = f0[~np.isnan(f0)] if f0 is not None else np.array([])
             except Exception as pitch_error:
                 print(f"   ⚠️  Pitch detection failed: {pitch_error}, using fallback method")
-                # Fallback: use simpler pitch detection
                 valid_f0 = np.array([])
             
             if len(valid_f0) < 10:  # Need at least 10 valid pitch points
                 print(f"   ⚠️  Insufficient pitch data ({len(valid_f0)} points), using alternative features")
-                # Fall back to non-pitch features
-                rms = librosa.feature.rms(y=y)[0]
-                centroid = librosa.feature.spectral_centroid(y=y, sr=sr)[0]
-                zcr = librosa.feature.zero_crossing_rate(y)[0]
+                # Fall back to non-pitch features (on segment)
+                rms = librosa.feature.rms(y=y_physics)[0]
+                centroid = librosa.feature.spectral_centroid(y=y_physics, sr=sr)[0]
+                zcr = librosa.feature.zero_crossing_rate(y_physics)[0]
                 
                 feats = {
                     'pitch_cv': 0.25,  # Neutral value
@@ -403,9 +412,9 @@ class HybridEnsembleDetector:
                 print(f"   🔬 Physics score (no pitch): {final_score:.3f}")
                 return round(final_score, 3), "Physics Analysis (Limited)", feats
 
-            # Full analysis with pitch
-            rms = librosa.feature.rms(y=y)[0]
-            centroid = librosa.feature.spectral_centroid(y=y, sr=sr)[0]
+            # Full analysis with pitch (on segment)
+            rms = librosa.feature.rms(y=y_physics)[0]
+            centroid = librosa.feature.spectral_centroid(y=y_physics, sr=sr)[0]
             
             mean_pitch = np.mean(valid_f0)
             std_pitch = np.std(valid_f0)
@@ -611,16 +620,29 @@ class HybridEnsembleDetector:
 
             print(f"🎵 Analyzing: {os.path.basename(audio_path)}")
 
-           
+            # 2 & 3. Run Physics and DL analysis in parallel (latency ≈ max of the two, not sum)
+            phys_score, phys_method, phys_feats = 0.0, "", {}
+            dl_score, dl_label = 0.0, ""
 
-            # 2. Run Physics Analysis
-            phys_score, phys_method, phys_feats = self.get_physics_score(audio_path)
-            # phys_score = 0
-            # phys_feats = {'pitch_cv': 1, 'intensity_std': 1}
-            
-            # 3. Run Deep Learning Analysis
-            dl_score, dl_label = self.get_dl_score(audio_path)
-            print(f"DL Score is:  ${dl_score}")
+            with ThreadPoolExecutor(max_workers=2) as executor:
+                future_phys = executor.submit(self.get_physics_score, audio_path)
+                future_dl = executor.submit(self.get_dl_score, audio_path)
+                for future in as_completed([future_phys, future_dl]):
+                    try:
+                        result = future.result()
+                        # Physics returns (score, method, feats); DL returns (score, label)
+                        if len(result) == 3:
+                            phys_score, phys_method, phys_feats = result
+                        else:
+                            dl_score, dl_label = result
+                            print(f"DL Score is:  ${dl_score}")
+                    except Exception as e:
+                        print(f"   ⚠️  Parallel task error: {e}")
+                        # Cannot know which failed; set both fallbacks if needed
+                        if future is future_phys:
+                            phys_score, phys_method, phys_feats = 0.0, f"Error: {e}", {'duration': 0, 'was_truncated': False}
+                        else:
+                            dl_score, dl_label = 0.0, f"DL Error: {e}"
 
             # 4. Calculate weighted ensemble score
             final_score = (