Updated language specific fix

detector.py

@@ -169,6 +169,14 @@ class HybridEnsembleDetector:
         # 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
 
+        # --- CHUNKING (MAX-POOLING) FOR LONG AUDIO ---
+        self.chunk_duration_sec = 5
+        self.max_chunks = 3  # If any chunk is AI, whole file is AI
+
+        # --- CLASSIFICATION THRESHOLD (language-specific) ---
+        self.default_ai_threshold = 0.55
+        self.tamil_ai_threshold = 0.45  # More aggressive for Tamil TTS
+
         print("✅ Hybrid Detector Ready\n")
 
     # ==========================================================
@@ -232,6 +240,26 @@ class HybridEnsembleDetector:
             was_truncated = True
         return y, sr, duration, was_truncated
 
+    def _chunk_audio(self, y, sr, duration):
+        """
+        Split audio into fixed-duration chunks for max-pooling.
+        Returns list of (y_chunk, sr, duration_chunk, was_truncated) for preloaded.
+        """
+        chunks = []
+        chunk_len = int(self.chunk_duration_sec * sr)
+        min_chunk_samples = int(1.0 * sr)  # skip chunks shorter than 1s
+        for i in range(self.max_chunks):
+            start = i * chunk_len
+            if start >= len(y):
+                break
+            end = min(start + chunk_len, len(y))
+            y_chunk = y[start:end]
+            if len(y_chunk) < min_chunk_samples:
+                break
+            dur_chunk = len(y_chunk) / sr
+            chunks.append((y_chunk.copy(), sr, dur_chunk, False))
+        return chunks
+
     # ==========================================================
     # HELPER: Base64 Decoding
     # ==========================================================
@@ -373,7 +401,12 @@ class HybridEnsembleDetector:
             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")
+            # VAD: trim silence so physics doesn't see "perfect stability" from empty segments
+            y_physics_trimmed, _ = librosa.effects.trim(y_physics, top_db=20)
+            if len(y_physics_trimmed) >= int(0.5 * sr):  # Keep at least 0.5s of audio
+                y_physics = y_physics_trimmed
+
+            print(f"   🔬 Running physics analysis on middle {seg_dur:.1f}s of {duration:.1f}s audio at {sr}Hz (VAD trimmed)")
             
             # Robust pitch tracking using pYIN (filters silence/noise; yin blindly estimates pitch there)
             try:
@@ -647,60 +680,72 @@ class HybridEnsembleDetector:
 
             print(f"🎵 Analyzing: {os.path.basename(audio_path)}")
 
-            # Load audio once and reuse for both branches (avoids duplicate I/O and decode)
-            preloaded = self._load_audio_once(audio_path)
+            # 1. Detect language for Tamil-specific threshold
+            language = self.detect_language(audio_path)
+            threshold = self.tamil_ai_threshold if language == "Tamil" else self.default_ai_threshold
+            if language == "Tamil":
+                print(f"   📐 Using Tamil-specific AI threshold: {threshold}")
 
-            # 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, ""
-
-            with ThreadPoolExecutor(max_workers=2) as executor:
-                future_phys = executor.submit(self.get_physics_score, audio_path, preloaded)
-                future_dl = executor.submit(self.get_dl_score, audio_path, preloaded)
-                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 = (
-                self.physics_weight * phys_score + 
-                self.dl_weight * dl_score
-            )
-            
-            # Round to 2 decimal places
-            final_score = round(final_score, 2)
-            # final_score = round(dl_score,2)
-            
-            # 5. Determine classification
-            classification = "AI_GENERATED" if final_score > 0.55 else "HUMAN"
-            
-            # 6. Generate explanation
+            # 2. Load audio once and split into chunks for max-pooling
+            preloaded = self._load_audio_once(audio_path)
+            y, sr, duration, was_truncated = preloaded
+            chunks = self._chunk_audio(y, sr, duration)
+            if not chunks:
+                chunks = [preloaded]  # Very short audio: single "chunk" = full audio
+
+            # 3. Run Physics and DL per chunk; take max score (if any chunk is AI → whole file AI)
+            best_score = -1.0
+            best_phys_score, best_phys_method, best_phys_feats = 0.0, "", {}
+            best_dl_score, best_dl_label = 0.0, ""
+
+            for idx, preloaded_chunk in enumerate(chunks):
+                phys_score, phys_method, phys_feats = 0.0, "", {}
+                dl_score, dl_label = 0.0, ""
+                with ThreadPoolExecutor(max_workers=2) as executor:
+                    future_phys = executor.submit(self.get_physics_score, None, preloaded_chunk)
+                    future_dl = executor.submit(self.get_dl_score, None, preloaded_chunk)
+                    for future in as_completed([future_phys, future_dl]):
+                        try:
+                            result = future.result()
+                            if len(result) == 3:
+                                phys_score, phys_method, phys_feats = result
+                            else:
+                                dl_score, dl_label = result
+                        except Exception as e:
+                            print(f"   ⚠️  Chunk {idx+1} task error: {e}")
+                            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}"
+
+                chunk_score = self.physics_weight * phys_score + self.dl_weight * dl_score
+                if chunk_score > best_score:
+                    best_score = chunk_score
+                    best_phys_score, best_phys_method, best_phys_feats = phys_score, phys_method, phys_feats
+                    best_dl_score, best_dl_label = dl_score, dl_label
+                print(f"   Chunk {idx+1}/{len(chunks)} score: {chunk_score:.3f} (phys={phys_score:.2f}, dl={dl_score:.2f})")
+
+            final_score = round(best_score, 2)
+            phys_score, phys_feats = best_phys_score, best_phys_feats
+            dl_score, dl_label = best_dl_score, best_dl_label
+
+            # 4. Classification with language-specific threshold
+            classification = "AI_GENERATED" if final_score > threshold else "HUMAN"
+
+            # 5. Generate explanation (using best chunk's scores/feats)
             explanation = self.generate_explanation(
-                final_score, 
-                dl_score, 
-                dl_label, 
+                final_score,
+                dl_score,
+                dl_label,
                 phys_score,
                 phys_feats
             )
 
-            # 7. Return API-compliant response (ensure all values are JSON serializable)
+            # 6. Return API-compliant response
             return {
                 "status": "success",
                 "classification": classification,
-                "confidenceScore": float(final_score),  # Convert to Python float
+                "confidenceScore": float(final_score),
                 "explanation": explanation,
                 "debug": {
                     "physics_score": float(phys_score),
@@ -710,8 +755,11 @@ class HybridEnsembleDetector:
                     "dl_weight": f"{self.dl_weight*100:.0f}%",
                     "audio_duration": float(phys_feats.get('duration', 0)),
                     "was_truncated": bool(phys_feats.get('was_truncated', False)),
-                    "physics_features": {k: float(v) if isinstance(v, (np.floating, np.integer)) else v 
-                                        for k, v in phys_feats.items() 
+                    "chunks_used": len(chunks),
+                    "ai_threshold_used": float(threshold),
+                    "language": language,
+                    "physics_features": {k: float(v) if isinstance(v, (np.floating, np.integer)) else v
+                                        for k, v in phys_feats.items()
                                         if k not in ['duration', 'was_truncated']}
                 }
             }