Deploy optimized VoiceGuard with Abhishtagatya model

Dockerfile

@@ -23,6 +23,11 @@ COPY . .
 # Expose port (documentary only, but good practice)
 EXPOSE 8000
 
-# Run the application using shell form to expand PORT variable
-# Railway (and others) often inject a generic PORT variable
-CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]
+# Create user with UID 1000 (required for HF Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -4,6 +4,7 @@ emoji: 🛡️
 colorFrom: blue
 colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
 license: mit
 ---

app.py

@@ -1,183 +0,0 @@
-"""VoiceGuard - AI Voice Detection App for HuggingFace Spaces."""
-
-import gradio as gr
-import numpy as np
-import torch
-import librosa
-from transformers import pipeline
-import warnings
-import tempfile
-import os
-
-warnings.filterwarnings("ignore")
-
-# Model Configuration
-MODEL_NAME = "abhishtagatya/hubert-base-960h-itw-deepfake"
-
-# Global classifier (loaded once)
-classifier = None
-
-def load_model():
-    """Load the deepfake detection model."""
-    global classifier
-    if classifier is None:
-        print("🔄 Loading model...")
-        device = 0 if torch.cuda.is_available() else -1
-        classifier = pipeline(
-            "audio-classification",
-            model=MODEL_NAME,
-            device=device
-        )
-        print(f"✅ Model loaded on {'GPU' if device == 0 else 'CPU'}")
-    return classifier
-
-def detect_deepfake(audio_input):
-    """
-    Detect if audio is AI-generated or human.
-    
-    Args:
-        audio_input: Tuple of (sample_rate, audio_array) from Gradio
-        
-    Returns:
-        Dictionary with detection results
-    """
-    if audio_input is None:
-        return "❌ Please upload or record an audio file."
-    
-    try:
-        # Load model
-        model = load_model()
-        
-        # Handle Gradio audio input
-        sample_rate, audio_data = audio_input
-        
-        # Convert to float32 and normalize
-        if audio_data.dtype == np.int16:
-            audio_data = audio_data.astype(np.float32) / 32768.0
-        elif audio_data.dtype == np.int32:
-            audio_data = audio_data.astype(np.float32) / 2147483648.0
-        
-        # Convert stereo to mono
-        if len(audio_data.shape) > 1:
-            audio_data = np.mean(audio_data, axis=1)
-        
-        # Resample to 16kHz if needed
-        if sample_rate != 16000:
-            audio_data = librosa.resample(audio_data, orig_sr=sample_rate, target_sr=16000)
-        
-        # Save to temp file for pipeline
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-            import soundfile as sf
-            sf.write(f.name, audio_data, 16000)
-            temp_path = f.name
-        
-        # Run detection
-        results = model(temp_path)
-        
-        # Clean up
-        os.unlink(temp_path)
-        
-        # Parse results
-        scores = {r["label"]: r["score"] for r in results}
-        best = max(results, key=lambda x: x["score"])
-        label = best["label"].lower()
-        confidence = best["score"]
-        
-        # Determine classification with 98% threshold
-        if "spoof" in label or "fake" in label:
-            if confidence >= 0.98:
-                classification = "🤖 AI-GENERATED"
-                emoji = "🚨"
-            else:
-                classification = "👤 LIKELY HUMAN"
-                emoji = "✅"
-        else:
-            classification = "👤 HUMAN"
-            emoji = "✅"
-        
-        # Format output
-        result = f"""
-## {emoji} Detection Result
-
-### Classification: {classification}
-### Confidence: {confidence*100:.2f}%
-
----
-
-### Raw Scores:
-"""
-        for label, score in scores.items():
-            bar = "█" * int(score * 20) + "░" * (20 - int(score * 20))
-            result += f"- **{label}**: {bar} {score*100:.1f}%\n"
-        
-        result += f"""
----
-
-### Model Used:
-`{MODEL_NAME}`
-
-### Device:
-{'🖥️ GPU (CUDA)' if torch.cuda.is_available() else '💻 CPU'}
-"""
-        
-        return result
-        
-    except Exception as e:
-        return f"❌ Error processing audio: {str(e)}"
-
-# Create Gradio Interface
-with gr.Blocks(title="VoiceGuard - AI Voice Detection", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🛡️ VoiceGuard - AI Voice Detection
-    
-    Detect whether an audio sample is **AI-generated (deepfake)** or **genuine human speech**.
-    
-    ### Supported Languages
-    🇮🇳 Tamil | English | Hindi | Malayalam | Telugu
-    
-    ---
-    """)
-    
-    with gr.Row():
-        with gr.Column():
-            audio_input = gr.Audio(
-                label="Upload or Record Audio",
-                sources=["upload", "microphone"],
-                type="numpy"
-            )
-            
-            detect_btn = gr.Button("🔍 Analyze Voice", variant="primary", size="lg")
-            
-            gr.Markdown("""
-            ### Tips:
-            - Upload MP3, WAV, or other audio formats
-            - Record directly using your microphone
-            - Minimum 1 second of audio recommended
-            """)
-        
-        with gr.Column():
-            output = gr.Markdown(label="Detection Result")
-    
-    detect_btn.click(
-        fn=detect_deepfake,
-        inputs=[audio_input],
-        outputs=[output]
-    )
-    
-    gr.Markdown("""
-    ---
-    
-    ### About
-    
-    VoiceGuard uses the **HuBERT** model fine-tuned for deepfake audio detection.
-    
-    **Model**: `abhishtagatya/hubert-base-960h-itw-deepfake`
-    
-    **India AI Impact Summit Buildathon 2026**
-    """)
-
-# Launch
-if __name__ == "__main__":
-    # Pre-load model
-    load_model()
-    demo.launch()

app/api/routes.py

@@ -20,14 +20,8 @@ from app.core.audio_processor import (
     audio_processor,
     AudioProcessingError,
     InvalidBase64Error,
-    InvalidAudioFormatError,
-    AudioTooShortError,
-    AudioTooLongError
 )
 from app.core.detector import detector
-from app.core.hybrid_detector import hybrid_detector
-from app.core.signal_analyzer import signal_analyzer
-from app.core.explainer import explainer
 from app.config import settings
 
 
@@ -56,9 +50,7 @@ def validate_api_key(x_api_key: Optional[str] = Header(None, alias="x-api-key"))
 
 # ============== LOGIC HELPER ==============
 
-from app.core.hybrid_detector import hybrid_detector
 
-# ... (Previous imports kept if needed, but detector/signal_analyzer/explainer are now inside hybrid)
 
 async def _process_detection_logic(
     audio_bytes: bytes, 
@@ -72,9 +64,9 @@ async def _process_detection_logic(
     waveform, duration = audio_processor.process_bytes(audio_bytes)
     print(f"✅ Audio processed: {duration:.2f}s duration")
     
-    # Step 2: Run Hybrid Detection (ML + Signal Analysis)
-    print("🔍 Running hybrid deepfake detection...")
-    result = hybrid_detector.detect(waveform, language=language)
+    # Step 2: Run Detection (HuBERT Model)
+    print("🔍 Running deepfake detection...")
+    result = detector.detect(waveform, language=language)
     
     # Calculate processing time
     processing_time_ms = int((time.time() - start_time) * 1000)

app/config.py

@@ -10,24 +10,19 @@ class Settings(BaseSettings):
     
     # Server
     HOST: str = "0.0.0.0"
-    PORT: int = 8000
+    PORT: int = 7860
     DEBUG: bool = True
     
     # API Key Authentication (required by hackathon)
     API_KEY: str = "sk_voiceguard_2026_secret"
-    
-    # Model
-    MODEL_NAME: str = "MelodyMachine/Deepfake-audio-detection-V2"
-    MODEL_CACHE_DIR: str = "./model_cache"
+
     
     # Audio Processing
     TARGET_SAMPLE_RATE: int = 16000
     MIN_DURATION: float = 1.0  # seconds
     MAX_DURATION: float = 60.0  # seconds
     MAX_FILE_SIZE: int = 10 * 1024 * 1024  # 10 MB
-    
-    # Heatmap
-    HEATMAP_DIR: str = "./static/heatmaps"
+
     
     class Config:
         env_file = ".env"

app/core/audio_processor.py

@@ -161,7 +161,7 @@ class AudioProcessor:
             mono=True
         )
         # 1. Trim Silence (Focus on speech, remove digital zeros)
-        waveform, _ = librosa.effects.trim(waveform, top_db=20)
+        waveform, _ = librosa.effects.trim(waveform, top_db=30)
         
         # 2. Normalize Volume (Consistent amplitude)
         waveform = librosa.util.normalize(waveform)

app/core/detector.py

@@ -34,6 +34,7 @@ class DetectionResult:
     confidence: float    # 0.0 - 1.0
     raw_scores: Dict[str, float]  # All label scores
     model_used: str  # Which model was used
+    explanation: str # Reason for the decision
 
 
 class DeepfakeDetector:
@@ -122,13 +123,28 @@ class DeepfakeDetector:
         # Determine initial classification from label
         label_lower = label.lower()
         
+        # Robust Label Matching
+        is_ai = False
+        
+        # 1. Direct label matching
         if "fake" in label_lower or "spoof" in label_lower or "synthetic" in label_lower or "deepfake" in label_lower:
+            is_ai = True
+        elif "label_0" in label_lower: # Common deepfake dataset convention: 0=Fake, 1=Real (or vice versa, but usually 0 is negative/fake class in some contexts, but in ASVspoof 0 is often spoof. Wait, let's be safe. Usually spoof=1, bona-fide=0? Actually typically: 0=spoof, 1=bonafide for some, but often 'LABEL_0' is just the first class. 
+        # CAUTION: Without knowing the exact map, we rely on the specific model 'abhishtagatya'. 
+        # The docstring says "Labels: bona-fide (human) / spoof (AI)". 
+        # If it returns LABEL_*, we are in trouble. 
+        # Let's assume the docstring is correct and only handle the text labels robustly for now. 
+        # If model returns LABEL_0, we should log a warning.
+            pass
+            
+        if is_ai:
             initial_classification = "AI_GENERATED"
-        elif "real" in label_lower or "bona-fide" in label_lower or "bonafide" in label_lower or "human" in label_lower or "genuine" in label_lower:
-            initial_classification = "HUMAN"
         else:
-            print(f"   ⚠️ Unknown label: {label}, defaulting to HUMAN")
             initial_classification = "HUMAN"
+            
+        # Double check if label is unknown and not 'real'/'human'
+        if not is_ai and not any(x in label_lower for x in ["real", "bona", "human", "genuine"]):
+             print(f"   ⚠️ Unknown label: {label}, defaulting to HUMAN")
         
         # Use the model's classification directly
         classification = initial_classification
@@ -139,11 +155,18 @@ class DeepfakeDetector:
         else:
              print(f"   ✅ High confidence detection: {classification} ({confidence:.2%})")
         
+        # Generate simple explanation
+        if classification == "AI_GENERATED":
+            explanation = f"Model detected synthetic patterns with {confidence:.0%} confidence."
+        else:
+            explanation = f"Voice signatures match natural human speech ({confidence:.0%} confidence)."
+
         return DetectionResult(
             classification=classification,
             confidence=confidence,
             raw_scores=raw_scores,
-            model_used=MODEL_CONFIG["name"]
+            model_used=MODEL_CONFIG["name"],
+            explanation=explanation
         )
     
     @property

app/core/elevenlabs_detector.py

@@ -1,270 +0,0 @@
-"""ElevenLabs-Specific Deepfake Detection Module.
-
-This module is specifically tuned to detect AI voices generated by:
-- ElevenLabs (premium models)
-- Similar neural vocoder-based TTS systems
-- Modern AI voice cloning tools
-
-Key detection signals for ElevenLabs-style voices:
-1. Neural vocoder artifacts (subtle but detectable)
-2. Unnaturally consistent prosody
-3. Missing breath sounds or unnatural breath patterns
-4. Spectral smoothness in high frequencies
-5. Lack of micro-variations in pitch (shimmer/jitter)
-"""
-
-import numpy as np
-from typing import Dict, Tuple, List
-from dataclasses import dataclass
-import librosa
-
-
-@dataclass
-class ElevenLabsDetectionResult:
-    """Result from ElevenLabs-specific detection."""
-    classification: str  # "AI_GENERATED" or "HUMAN"
-    confidence: float
-    signals: Dict[str, Dict]
-    explanation: str
-
-
-class ElevenLabsDetector:
-    """
-    Specialized detector for ElevenLabs and similar modern AI voices.
-    
-    Uses aggressive thresholds tuned for neural vocoder-based synthesis.
-    """
-    
-    def __init__(self, sr: int = 16000):
-        self.sr = sr
-        
-        # Thresholds tuned for ElevenLabs detection
-        # These are based on known characteristics of neural vocoder voices
-        self.thresholds = {
-            # Pitch analysis - ElevenLabs has very stable pitch
-            "pitch_std_low": 25,      # Human typically > 30
-            "jitter_low": 3.0,        # Human typically > 5
-            
-            # Spectral analysis - ElevenLabs has smooth spectra
-            "spectral_flatness_high": 0.15,   # Human typically < 0.1
-            "mfcc_delta_std_low": 2.0,        # Human typically > 3
-            
-            # Energy dynamics - ElevenLabs has consistent energy
-            "rms_cv_low": 0.4,        # Coefficient of variation, human > 0.5
-            
-            # High-frequency content - Neural vocoders attenuate HF
-            "hf_energy_low": 0.05,    # Human typically > 0.08
-        }
-    
-    def detect(self, waveform: np.ndarray, language: str = "english") -> ElevenLabsDetectionResult:
-        """
-        Detect if audio is generated by ElevenLabs or similar AI.
-        
-        Args:
-            waveform: Audio samples (16kHz mono)
-            language: Language for logging
-            
-        Returns:
-            ElevenLabsDetectionResult with classification
-        """
-        print(f"🔬 Running ElevenLabs-specific detection for: {language}")
-        
-        signals = {}
-        ai_indicators = 0
-        human_indicators = 0
-        reasons = []
-        
-        # ============ 1. PITCH ANALYSIS ============
-        print("   🎵 Analyzing pitch stability...")
-        try:
-            f0, voiced, _ = librosa.pyin(
-                waveform, 
-                fmin=50, 
-                fmax=500, 
-                sr=self.sr,
-                frame_length=2048
-            )
-            
-            f0_voiced = f0[~np.isnan(f0)]
-            
-            if len(f0_voiced) > 20:
-                pitch_std = np.std(f0_voiced)
-                pitch_diff = np.diff(f0_voiced)
-                jitter = np.mean(np.abs(pitch_diff))
-                
-                signals["pitch"] = {
-                    "std": float(pitch_std),
-                    "jitter": float(jitter),
-                    "is_ai": pitch_std < self.thresholds["pitch_std_low"] or jitter < self.thresholds["jitter_low"]
-                }
-                
-                if pitch_std < self.thresholds["pitch_std_low"]:
-                    ai_indicators += 2  # Strong signal
-                    reasons.append(f"unnaturally stable pitch (std={pitch_std:.1f})")
-                else:
-                    human_indicators += 1
-                
-                if jitter < self.thresholds["jitter_low"]:
-                    ai_indicators += 2  # Strong signal
-                    reasons.append(f"missing pitch micro-variations (jitter={jitter:.2f})")
-                else:
-                    human_indicators += 1
-                    
-                print(f"      Pitch std: {pitch_std:.2f} (threshold: {self.thresholds['pitch_std_low']})")
-                print(f"      Jitter: {jitter:.2f} (threshold: {self.thresholds['jitter_low']})")
-            else:
-                signals["pitch"] = {"error": "insufficient voiced segments"}
-                
-        except Exception as e:
-            signals["pitch"] = {"error": str(e)}
-            print(f"      ⚠️ Pitch analysis error: {e}")
-        
-        # ============ 2. SPECTRAL SMOOTHNESS ============
-        print("   📊 Analyzing spectral characteristics...")
-        try:
-            # MFCC delta (rate of change) - AI voices have smoother changes
-            mfccs = librosa.feature.mfcc(y=waveform, sr=self.sr, n_mfcc=13)
-            mfcc_delta = librosa.feature.delta(mfccs)
-            mfcc_delta_std = np.std(mfcc_delta)
-            
-            # Spectral flatness
-            flatness = librosa.feature.spectral_flatness(y=waveform)[0]
-            flatness_mean = np.mean(flatness)
-            
-            signals["spectral"] = {
-                "mfcc_delta_std": float(mfcc_delta_std),
-                "flatness_mean": float(flatness_mean),
-                "is_ai": mfcc_delta_std < self.thresholds["mfcc_delta_std_low"]
-            }
-            
-            if mfcc_delta_std < self.thresholds["mfcc_delta_std_low"]:
-                ai_indicators += 2
-                reasons.append(f"overly smooth spectral transitions (delta_std={mfcc_delta_std:.2f})")
-            else:
-                human_indicators += 1
-                
-            print(f"      MFCC delta std: {mfcc_delta_std:.2f} (threshold: {self.thresholds['mfcc_delta_std_low']})")
-            print(f"      Spectral flatness: {flatness_mean:.4f}")
-            
-        except Exception as e:
-            signals["spectral"] = {"error": str(e)}
-            print(f"      ⚠️ Spectral analysis error: {e}")
-        
-        # ============ 3. ENERGY DYNAMICS ============
-        print("   📈 Analyzing energy dynamics...")
-        try:
-            rms = librosa.feature.rms(y=waveform)[0]
-            rms_mean = np.mean(rms)
-            rms_std = np.std(rms)
-            rms_cv = rms_std / (rms_mean + 1e-10)  # Coefficient of variation
-            
-            signals["energy"] = {
-                "rms_cv": float(rms_cv),
-                "is_ai": rms_cv < self.thresholds["rms_cv_low"]
-            }
-            
-            if rms_cv < self.thresholds["rms_cv_low"]:
-                ai_indicators += 1
-                reasons.append(f"unnaturally consistent energy (CV={rms_cv:.2f})")
-            else:
-                human_indicators += 1
-                
-            print(f"      RMS CV: {rms_cv:.2f} (threshold: {self.thresholds['rms_cv_low']})")
-            
-        except Exception as e:
-            signals["energy"] = {"error": str(e)}
-            print(f"      ⚠️ Energy analysis error: {e}")
-        
-        # ============ 4. HIGH-FREQUENCY CONTENT ============
-        print("   🔊 Analyzing high-frequency content...")
-        try:
-            stft = np.abs(librosa.stft(waveform))
-            freq_bins = stft.shape[0]
-            
-            # Neural vocoders often attenuate high frequencies
-            hf_energy = np.mean(stft[int(freq_bins * 0.7):, :])
-            total_energy = np.mean(stft) + 1e-10
-            hf_ratio = hf_energy / total_energy
-            
-            signals["hf_content"] = {
-                "hf_ratio": float(hf_ratio),
-                "is_ai": hf_ratio < self.thresholds["hf_energy_low"]
-            }
-            
-            if hf_ratio < self.thresholds["hf_energy_low"]:
-                ai_indicators += 1
-                reasons.append(f"reduced high-frequency content (ratio={hf_ratio:.3f})")
-            else:
-                human_indicators += 1
-                
-            print(f"      HF ratio: {hf_ratio:.4f} (threshold: {self.thresholds['hf_energy_low']})")
-            
-        except Exception as e:
-            signals["hf_content"] = {"error": str(e)}
-            print(f"      ⚠️ HF analysis error: {e}")
-        
-        # ============ 5. BREATH DETECTION ============
-        print("   💨 Analyzing breath patterns...")
-        try:
-            # Look for characteristic breath sounds (fricative noise)
-            # Breath sounds have high ZCR and low energy
-            zcr = librosa.feature.zero_crossing_rate(waveform)[0]
-            rms = librosa.feature.rms(y=waveform)[0]
-            
-            # Potential breath frames: high ZCR, low RMS
-            zcr_threshold = np.percentile(zcr, 80)
-            rms_threshold = np.percentile(rms, 30)
-            
-            potential_breaths = (zcr > zcr_threshold) & (rms < rms_threshold)
-            breath_ratio = np.sum(potential_breaths) / len(potential_breaths)
-            
-            signals["breath"] = {
-                "breath_ratio": float(breath_ratio),
-                "is_ai": breath_ratio < 0.02  # Very few breath-like segments
-            }
-            
-            if breath_ratio < 0.02:
-                ai_indicators += 1
-                reasons.append("missing natural breath patterns")
-            else:
-                human_indicators += 1
-                
-            print(f"      Breath ratio: {breath_ratio:.4f}")
-            
-        except Exception as e:
-            signals["breath"] = {"error": str(e)}
-            print(f"      ⚠️ Breath analysis error: {e}")
-        
-        # ============ FINAL DECISION ============
-        total_signals = ai_indicators + human_indicators
-        if total_signals > 0:
-            ai_confidence = ai_indicators / total_signals
-        else:
-            ai_confidence = 0.5
-        
-        # Decision threshold - bias toward detection (better to flag AI than miss it)
-        is_ai = ai_indicators >= 3 or ai_confidence >= 0.5
-        
-        if is_ai:
-            classification = "AI_GENERATED"
-            confidence = min(0.6 + (ai_indicators * 0.1), 0.95)
-            explanation = f"AI voice detected: {'; '.join(reasons)}" if reasons else "Multiple AI indicators detected"
-        else:
-            classification = "HUMAN"
-            confidence = min(0.6 + (human_indicators * 0.1), 0.95)
-            explanation = "Human voice patterns confirmed"
-        
-        print(f"   ✅ Result: {classification} ({confidence:.2%})")
-        print(f"   📊 AI indicators: {ai_indicators}, Human indicators: {human_indicators}")
-        print(f"   📝 {explanation}")
-        
-        return ElevenLabsDetectionResult(
-            classification=classification,
-            confidence=confidence,
-            signals=signals,
-            explanation=explanation
-        )
-
-
-# Singleton instance
-elevenlabs_detector = ElevenLabsDetector()

app/core/explainer.py

@@ -1,204 +0,0 @@
-"""Explanation Generator Module.
-
-Generates human-readable explanations for detection results.
-"""
-
-from typing import List, Dict
-from dataclasses import dataclass
-
-from app.core.signal_analyzer import SignalScores
-
-
-@dataclass
-class Artifact:
-    """Detected artifact in audio."""
-    timestamp: float
-    type: str
-    severity: str  # "high", "medium", "low"
-    
-    def to_dict(self) -> Dict:
-        return {
-            "timestamp": self.timestamp,
-            "type": self.type,
-            "severity": self.severity
-        }
-
-
-class ExplanationGenerator:
-    """Generates explanations for detection results."""
-    
-    # Thresholds for scoring
-    HIGH_THRESHOLD = 0.8
-    MEDIUM_THRESHOLD = 0.6
-    
-    # Explanation templates
-    SIGNAL_EXPLANATIONS = {
-        "prosody": {
-            "high": "Unnatural rhythm patterns detected - timing is too consistent",
-            "medium": "Some rhythm irregularities noted",
-            "low": "Natural speech rhythm detected"
-        },
-        "breath": {
-            "high": "Missing natural breath sounds throughout the audio",
-            "medium": "Reduced breath patterns compared to natural speech",
-            "low": "Normal breathing patterns present"
-        },
-        "spectral": {
-            "high": "Vocoder artifacts detected in frequency spectrum",
-            "medium": "Some spectral irregularities detected",
-            "low": "Natural spectral characteristics"
-        },
-        "formant": {
-            "high": "Unnatural vocal formant transitions",
-            "medium": "Some formant anomalies detected",
-            "low": "Natural vocal transitions"
-        },
-        "silence": {
-            "high": "Artificially perfect silence patterns",
-            "medium": "Some silence irregularities",
-            "low": "Natural pause patterns"
-        }
-    }
-    
-    LANGUAGE_INSIGHTS = {
-        "tamil": "Tamil vowel length patterns analyzed",
-        "hindi": "Hindi aspiration patterns checked",
-        "telugu": "Telugu word-ending patterns verified",
-        "malayalam": "Malayalam consonant patterns analyzed",
-        "english": "English prosody patterns checked"
-    }
-    
-    def _get_severity(self, score: float) -> str:
-        """Convert score to severity level."""
-        if score >= self.HIGH_THRESHOLD:
-            return "high"
-        elif score >= self.MEDIUM_THRESHOLD:
-            return "medium"
-        return "low"
-    
-    def generate_artifacts(
-        self, 
-        scores: SignalScores, 
-        duration: float
-    ) -> List[Artifact]:
-        """Generate artifact list with timestamps.
-        
-        Args:
-            scores: Signal analysis scores
-            duration: Audio duration in seconds
-            
-        Returns:
-            List of detected artifacts with timestamps
-        """
-        artifacts = []
-        
-        # Generate pseudo-timestamps based on scores
-        # In a real implementation, you'd detect actual positions
-        
-        if scores.spectral_score >= self.MEDIUM_THRESHOLD:
-            # Vocoder artifacts typically appear early
-            artifacts.append(Artifact(
-                timestamp=round(duration * 0.1, 2),
-                type="vocoder_artifact",
-                severity=self._get_severity(scores.spectral_score)
-            ))
-        
-        if scores.breath_score >= self.MEDIUM_THRESHOLD:
-            # Missing breath around middle
-            artifacts.append(Artifact(
-                timestamp=round(duration * 0.4, 2),
-                type="missing_breath",
-                severity=self._get_severity(scores.breath_score)
-            ))
-        
-        if scores.formant_score >= self.MEDIUM_THRESHOLD:
-            # Formant issues later in audio
-            artifacts.append(Artifact(
-                timestamp=round(duration * 0.7, 2),
-                type="unnatural_formant",
-                severity=self._get_severity(scores.formant_score)
-            ))
-        
-        if scores.prosody_score >= self.HIGH_THRESHOLD:
-            artifacts.append(Artifact(
-                timestamp=round(duration * 0.2, 2),
-                type="rhythm_anomaly",
-                severity=self._get_severity(scores.prosody_score)
-            ))
-        
-        if scores.silence_score >= self.HIGH_THRESHOLD:
-            artifacts.append(Artifact(
-                timestamp=round(duration * 0.5, 2),
-                type="artificial_silence",
-                severity=self._get_severity(scores.silence_score)
-            ))
-        
-        # Sort by timestamp
-        artifacts.sort(key=lambda x: x.timestamp)
-        
-        return artifacts
-    
-    def generate_explanation(
-        self,
-        classification: str,
-        confidence: float,
-        scores: SignalScores,
-        language: str,
-        artifacts: List[Artifact]
-    ) -> str:
-        """Generate human-readable explanation.
-        
-        Args:
-            classification: "AI_GENERATED" or "HUMAN"
-            confidence: Detection confidence
-            scores: Signal analysis scores
-            language: Detected language
-            artifacts: List of detected artifacts
-            
-        Returns:
-            Human-readable explanation string
-        """
-        parts = []
-        
-        if classification == "AI_GENERATED":
-            # Start with main finding
-            parts.append(f"This audio shows signs of AI generation with {confidence:.0%} confidence.")
-            
-            # Add specific findings based on scores
-            high_signals = []
-            
-            if scores.spectral_score >= self.HIGH_THRESHOLD:
-                high_signals.append("vocoder patterns")
-            if scores.breath_score >= self.HIGH_THRESHOLD:
-                high_signals.append("missing breath sounds")
-            if scores.prosody_score >= self.HIGH_THRESHOLD:
-                high_signals.append("unnatural rhythm")
-            if scores.formant_score >= self.HIGH_THRESHOLD:
-                high_signals.append("artificial vocal transitions")
-            if scores.silence_score >= self.HIGH_THRESHOLD:
-                high_signals.append("too-perfect pauses")
-            
-            if high_signals:
-                parts.append(f"Key indicators: {', '.join(high_signals)}.")
-            
-            # Add artifact timestamps
-            if artifacts:
-                timestamps = [f"{a.timestamp}s ({a.type.replace('_', ' ')})" 
-                             for a in artifacts[:3]]
-                parts.append(f"Artifacts detected at: {', '.join(timestamps)}.")
-        
-        else:  # HUMAN
-            parts.append(f"This audio appears to be genuine human speech with {confidence:.0%} confidence.")
-            
-            # Mention what was checked
-            parts.append("Natural breath patterns, varied prosody, and authentic vocal characteristics detected.")
-        
-        # Add language insight
-        if language in self.LANGUAGE_INSIGHTS:
-            parts.append(self.LANGUAGE_INSIGHTS[language])
-        
-        return " ".join(parts)
-
-
-# Create singleton instance
-explainer = ExplanationGenerator()

app/core/hybrid_detector.py

@@ -1,504 +0,0 @@
-"""Hybrid Deepfake Detection Module.
-
-Combines multiple detection signals for robust AI voice detection:
-1. Spectral Analysis - Unusual frequency patterns in AI voices
-2. Pitch Consistency - AI voices often have unnatural pitch stability
-3. Pause Pattern Analysis - AI voices have different timing patterns
-4. Formant Analysis - Synthetic voices have unusual formant transitions
-5. Model-based Detection - ML model as one voting signal
-"""
-
-import numpy as np
-from typing import Dict, Tuple, Optional
-from dataclasses import dataclass
-import librosa
-import scipy.stats as stats
-from scipy.signal import find_peaks
-
-
-@dataclass
-class DetectionSignal:
-    """A single detection signal result."""
-    name: str
-    is_ai: bool
-    confidence: float
-    reason: str
-
-
-@dataclass
-class HybridResult:
-    """Combined result from all detection signals."""
-    classification: str  # "AI_GENERATED" or "HUMAN"
-    confidence: float
-    signals: list[DetectionSignal]
-    explanation: str
-
-
-class SpectralAnalyzer:
-    """Analyzes spectral characteristics typical of AI-generated audio."""
-    
-    def __init__(self, sr: int = 16000):
-        self.sr = sr
-    
-    def analyze(self, waveform: np.ndarray) -> DetectionSignal:
-        """
-        Analyze spectral features for AI detection.
-        
-        AI voices often have:
-        - Unnaturally smooth spectral envelopes
-        - Missing or reduced high-frequency content
-        - Periodic spectral artifacts from neural vocoders
-        """
-        # Extract MFCCs
-        mfccs = librosa.feature.mfcc(y=waveform, sr=self.sr, n_mfcc=20)
-        
-        # 1. MFCC variance analysis - AI voices often have lower variance
-        mfcc_var = np.var(mfccs, axis=1).mean()
-        
-        # 2. Spectral flatness - AI voices can have unusual flatness patterns  
-        spectral_flatness = librosa.feature.spectral_flatness(y=waveform)[0]
-        flatness_mean = np.mean(spectral_flatness)
-        flatness_std = np.std(spectral_flatness)
-        
-        # 3. Spectral contrast - AI voices may have reduced contrast
-        spectral_contrast = librosa.feature.spectral_contrast(y=waveform, sr=self.sr)
-        contrast_var = np.var(spectral_contrast)
-        
-        # 4. High-frequency energy ratio
-        stft = np.abs(librosa.stft(waveform))
-        freq_bins = stft.shape[0]
-        high_freq_energy = np.mean(stft[int(freq_bins * 0.7):, :])
-        low_freq_energy = np.mean(stft[:int(freq_bins * 0.3), :]) + 1e-10
-        hf_ratio = high_freq_energy / low_freq_energy
-        
-        # AI detection heuristics based on spectral features
-        ai_score = 0.0
-        reasons = []
-        
-        # Low MFCC variance suggests synthetic audio
-        if mfcc_var < 15:
-            ai_score += 0.25
-            reasons.append("unusually consistent spectral patterns")
-        
-        # Very low or very high flatness can indicate synthesis
-        if flatness_mean < 0.01 or flatness_mean > 0.3:
-            ai_score += 0.2
-            reasons.append("abnormal spectral flatness")
-        
-        # Low flatness variance (too consistent)
-        if flatness_std < 0.02:
-            ai_score += 0.25
-            reasons.append("overly uniform spectral texture")
-        
-        # Low high-frequency content (vocoder artifact)
-        if hf_ratio < 0.1:
-            ai_score += 0.3
-            reasons.append("reduced high-frequency content")
-        
-        is_ai = ai_score >= 0.4
-        confidence = min(ai_score + 0.3, 0.95) if is_ai else max(0.7 - ai_score, 0.5)
-        
-        return DetectionSignal(
-            name="Spectral Analysis",
-            is_ai=is_ai,
-            confidence=confidence,
-            reason=", ".join(reasons) if reasons else "natural spectral characteristics"
-        )
-
-
-class PitchAnalyzer:
-    """Analyzes pitch patterns for AI detection."""
-    
-    def __init__(self, sr: int = 16000):
-        self.sr = sr
-    
-    def analyze(self, waveform: np.ndarray) -> DetectionSignal:
-        """
-        Analyze pitch characteristics.
-        
-        AI voices often have:
-        - Unnaturally consistent pitch (low variance)
-        - Robotic pitch transitions
-        - Missing micro-variations in F0
-        """
-        # Extract fundamental frequency (F0)
-        f0, voiced_flag, _ = librosa.pyin(
-            waveform, 
-            fmin=librosa.note_to_hz('C2'),
-            fmax=librosa.note_to_hz('C7'),
-            sr=self.sr
-        )
-        
-        # Filter out unvoiced segments
-        f0_voiced = f0[voiced_flag > 0.5] if len(f0[voiced_flag > 0.5]) > 10 else f0[~np.isnan(f0)]
-        
-        if len(f0_voiced) < 10:
-            return DetectionSignal(
-                name="Pitch Analysis",
-                is_ai=False,
-                confidence=0.5,
-                reason="insufficient voiced segments for analysis"
-            )
-        
-        # 1. Pitch variance - AI often has unnaturally low variance
-        pitch_var = np.var(f0_voiced)
-        pitch_std = np.std(f0_voiced)
-        
-        # 2. Pitch micro-variations (jitter) - human voices have natural jitter
-        pitch_diff = np.diff(f0_voiced)
-        jitter = np.mean(np.abs(pitch_diff))
-        
-        # 3. Pitch contour smoothness
-        # Calculate second derivative for contour analysis
-        if len(f0_voiced) > 20:
-            pitch_acceleration = np.diff(pitch_diff)
-            smoothness = 1.0 / (np.var(pitch_acceleration) + 1e-6)
-        else:
-            smoothness = 0
-        
-        ai_score = 0.0
-        reasons = []
-        
-        # Very low pitch variance (robotic)
-        if pitch_std < 10:
-            ai_score += 0.35
-            reasons.append("unnaturally stable pitch")
-        
-        # Very low jitter (too perfect)
-        if jitter < 2:
-            ai_score += 0.3
-            reasons.append("missing natural pitch micro-variations")
-        
-        # Too smooth contour (lacks natural fluctuation)
-        if smoothness > 100:
-            ai_score += 0.25
-            reasons.append("overly smooth pitch transitions")
-        
-        is_ai = ai_score >= 0.4
-        confidence = min(ai_score + 0.3, 0.95) if is_ai else max(0.7 - ai_score, 0.5)
-        
-        return DetectionSignal(
-            name="Pitch Analysis",
-            is_ai=is_ai,
-            confidence=confidence,
-            reason=", ".join(reasons) if reasons else "natural pitch characteristics"
-        )
-
-
-class PausePatternAnalyzer:
-    """Analyzes pause and timing patterns for AI detection."""
-    
-    def __init__(self, sr: int = 16000):
-        self.sr = sr
-    
-    def analyze(self, waveform: np.ndarray) -> DetectionSignal:
-        """
-        Analyze pause patterns.
-        
-        AI voices often have:
-        - More consistent pause durations
-        - Less natural speech rhythm
-        - Different silence-to-speech ratios
-        """
-        # Calculate RMS energy
-        frame_length = int(0.025 * self.sr)  # 25ms frames
-        hop_length = int(0.010 * self.sr)    # 10ms hop
-        
-        rms = librosa.feature.rms(y=waveform, frame_length=frame_length, hop_length=hop_length)[0]
-        
-        # Dynamic threshold for speech/silence
-        threshold = np.mean(rms) * 0.3
-        
-        # Find speech/silence segments
-        is_speech = rms > threshold
-        
-        # Find segment boundaries
-        changes = np.diff(is_speech.astype(int))
-        speech_starts = np.where(changes == 1)[0]
-        speech_ends = np.where(changes == -1)[0]
-        
-        if len(speech_starts) < 3 or len(speech_ends) < 3:
-            return DetectionSignal(
-                name="Pause Pattern",
-                is_ai=False,
-                confidence=0.5,
-                reason="insufficient speech segments for analysis"
-            )
-        
-        # Calculate pause durations (in frames)
-        pause_durations = []
-        for i in range(min(len(speech_ends), len(speech_starts) - 1)):
-            if speech_starts[i + 1] > speech_ends[i]:
-                pause_durations.append(speech_starts[i + 1] - speech_ends[i])
-        
-        if len(pause_durations) < 2:
-            return DetectionSignal(
-                name="Pause Pattern",
-                is_ai=False,
-                confidence=0.5,
-                reason="not enough pauses to analyze"
-            )
-        
-        # AI detection based on pause patterns
-        pause_durations = np.array(pause_durations)
-        pause_var = np.var(pause_durations)
-        pause_cv = np.std(pause_durations) / (np.mean(pause_durations) + 1e-6)  # Coefficient of variation
-        
-        # Speech segment durations
-        speech_durations = []
-        for i in range(min(len(speech_starts), len(speech_ends))):
-            if speech_ends[i] > speech_starts[i]:
-                speech_durations.append(speech_ends[i] - speech_starts[i])
-        
-        if len(speech_durations) > 1:
-            speech_cv = np.std(speech_durations) / (np.mean(speech_durations) + 1e-6)
-        else:
-            speech_cv = 0.5
-        
-        ai_score = 0.0
-        reasons = []
-        
-        # Very consistent pause lengths (artificial)
-        if pause_cv < 0.3:
-            ai_score += 0.35
-            reasons.append("unnaturally consistent pause durations")
-        
-        # Very consistent speech lengths
-        if speech_cv < 0.25:
-            ai_score += 0.3
-            reasons.append("robotic speech segment rhythm")
-        
-        # Very low pause variance
-        if pause_var < 10:
-            ai_score += 0.25
-            reasons.append("mechanical timing patterns")
-        
-        is_ai = ai_score >= 0.4
-        confidence = min(ai_score + 0.3, 0.95) if is_ai else max(0.7 - ai_score, 0.5)
-        
-        return DetectionSignal(
-            name="Pause Pattern",
-            is_ai=is_ai,
-            confidence=confidence,
-            reason=", ".join(reasons) if reasons else "natural speech rhythm"
-        )
-
-
-class FormantAnalyzer:
-    """Analyzes formant characteristics for AI detection."""
-    
-    def __init__(self, sr: int = 16000):
-        self.sr = sr
-    
-    def analyze(self, waveform: np.ndarray) -> DetectionSignal:
-        """
-        Analyze formant patterns.
-        
-        AI voices may have:
-        - Unnatural formant transitions
-        - Missing formant dynamics
-        - Unusual F1-F2 relationships
-        """
-        try:
-            # Use spectral peaks as proxy for formants
-            n_fft = 2048
-            hop_length = 512
-            
-            stft = np.abs(librosa.stft(waveform, n_fft=n_fft, hop_length=hop_length))
-            
-            # Get spectral centroids over time as formant proxy
-            spectral_centroid = librosa.feature.spectral_centroid(y=waveform, sr=self.sr)[0]
-            spectral_bandwidth = librosa.feature.spectral_bandwidth(y=waveform, sr=self.sr)[0]
-            
-            # Formant transition smoothness (real voices have more variation)
-            centroid_var = np.var(spectral_centroid)
-            centroid_diff = np.diff(spectral_centroid)
-            transition_smoothness = 1.0 / (np.var(centroid_diff) + 1e-6)
-            
-            # Bandwidth dynamics
-            bandwidth_var = np.var(spectral_bandwidth)
-            
-            ai_score = 0.0
-            reasons = []
-            
-            # Very smooth formant transitions (synthetic)
-            if transition_smoothness > 500:
-                ai_score += 0.3
-                reasons.append("overly smooth formant transitions")
-            
-            # Low centroid variance (limited vocal tract modeling)
-            if centroid_var < 50000:
-                ai_score += 0.25
-                reasons.append("limited formant variation")
-            
-            # Low bandwidth dynamics
-            if bandwidth_var < 10000:
-                ai_score += 0.25
-                reasons.append("static spectral bandwidth")
-            
-            is_ai = ai_score >= 0.4
-            confidence = min(ai_score + 0.3, 0.95) if is_ai else max(0.7 - ai_score, 0.5)
-            
-            return DetectionSignal(
-                name="Formant Analysis",
-                is_ai=is_ai,
-                confidence=confidence,
-                reason=", ".join(reasons) if reasons else "natural formant dynamics"
-            )
-            
-        except Exception as e:
-            return DetectionSignal(
-                name="Formant Analysis",
-                is_ai=False,
-                confidence=0.5,
-                reason=f"analysis error: {str(e)}"
-            )
-
-
-# ... (Keep Analyzer classes: Spectral, Pitch, Pause, Formant as they are useful for explanation)
-
-# ... (Keep Analyzer classes: Spectral, Pitch, Pause, Formant as they are useful for explanation)
-
-class HybridDetector:
-    """
-    State-of-the-Art Ensemble Detector (Indian Accent Optimized).
-    
-    Combines:
-    1. Gustking (XLS-R 300M) - Multilingual (Best for Indian Accents)
-    2. MelodyMachine (WavLM Deepfake-v2) - High Fidelity
-    
-    Logic: Uses Cross-Model Agreement. If models disagree, we trust the 'Real' prediction 
-    more (Assumes Innocence) to avoid False Positives on non-standard accents.
-    """
-    
-    def __init__(self, sr: int = 16000):
-        self.sr = sr
-        self.spectral_analyzer = SpectralAnalyzer(sr)
-        self.pitch_analyzer = PitchAnalyzer(sr)
-        self.pause_analyzer = PausePatternAnalyzer(sr)
-        self.formant_analyzer = FormantAnalyzer(sr)
-        
-        # Model pipelines (lazy loaded)
-        self._pipe1 = None  # Gustking (XLS-R)
-        self._pipe2 = None  # MelodyMachine
-        self._models_loaded = False
-        
-    def _load_models(self):
-        """
-        Load models on demand:
-        1. Primary: DavidCombei/wavLM-base-Deepfake_V2 (70%)
-        2. Secondary: MelodyMachine/Deepfake-audio-detection-v2 (30%)
-        """
-        if self._pipe1: return # Already loaded
-        
-        from transformers import pipeline
-        print("🧠 Loading 2-Model Ensemble...")
-        try:
-             # Model 1: WavLM (Primary - Best Accuracy)
-            self._pipe1 = pipeline("audio-classification", model="DavidCombei/wavLM-base-Deepfake_V2")
-            
-            # Model 2: MelodyMachine (Secondary - Artifacts)
-            self._pipe2 = pipeline("audio-classification", model="MelodyMachine/Deepfake-audio-detection-v2")
-            
-            print("✅ 2 Models loaded successfully")
-        except Exception as e:
-            print(f"❌ Failed to load models: {e}")
-
-    def _get_ai_probability(self, pipeline, waveform, model_name) -> float:
-        try:
-            results = pipeline(waveform, sampling_rate=self.sr)
-            
-            score_ai = 0.0
-
-            for res in results:
-                lbl = str(res["label"]).lower()
-                
-                # CRITICAL FIX: Label Mapping for WavLM/MelodyMachine
-                # Research shows: 
-                # - LABEL_0 = FAKE (AI)
-                # - LABEL_1 = REAL (Human)
-                # - "fake" / "spoof" = FAKE
-                # - "real" = REAL
-                
-                is_fake_label = False
-                
-                # 1. Explicit String Labels
-                if "fake" in lbl or "spoof" in lbl or "synthetic" in lbl:
-                    is_fake_label = True
-                
-                # 2. Numbered Labels (DavidCombei/Melody Convention)
-                # If model returns LABEL_0, it means FAKE
-                elif "label_0" in lbl: 
-                    is_fake_label = True
-                
-                # 3. Handle LABEL_1 (It is REAL, so ignore it)
-                elif "label_1" in lbl or "real" in lbl:
-                    is_fake_label = False
-                    
-                if is_fake_label:
-                    score_ai += res["score"]
-            
-            return score_ai
-            
-        except Exception as e:
-            print(f"   ⚠️ Error in {model_name}: {e}")
-            return 0.5
-
-    def detect(self, waveform: np.ndarray, language: str = "english") -> HybridResult:
-        """
-        Run Simplified High-Accuracy Ensemble (2 Models).
-        """
-        self._load_models()
-        print(f"🔬 Running 2-Model Ensemble for: {language}")
-
-        # 1. Run Models
-        # Primary: WavLM (DavidCombei) - 70% Weight
-        # Best performance for accents and general deepfake detection
-        p_ai_1 = self._get_ai_probability(self._pipe1, waveform, "WavLM")
-        
-        # Secondary: MelodyMachine - 30% Weight
-        # Good at detecting artifacts/noise
-        p_ai_2 = self._get_ai_probability(self._pipe2, waveform, "MelodyMachine")
-
-        print(f"   🤖 WavLM Score (70%): {p_ai_1:.2%}")
-        print(f"   🤖 Melody Score (30%): {p_ai_2:.2%}")
-
-        # --- SIMPLE WEIGHTED VOTING ---
-        # Weights: WavLM=0.7, Melody=0.3
-        # We trust WavLM more as it is a newer, better architecture than HuBERT
-        weighted_score = (p_ai_1 * 0.70) + (p_ai_2 * 0.30)
-        
-        # --- SIMPLE THRESHOLD ---
-        is_ai = weighted_score > 0.50
-        confidence = weighted_score if is_ai else (1.0 - weighted_score)
-        classification = "AI_GENERATED" if is_ai else "HUMAN"
-
-        # 2. Explanations
-        explanation_parts = []
-        if is_ai:
-             explanation_parts.append(f"AI Patterns Detected ({weighted_score:.0%})")
-        else:
-             explanation_parts.append(f"Natural Voice Confirmed ({confidence:.0%})")
-
-        # Add signal context
-        signals = []
-        signals.append(self.pitch_analyzer.analyze(waveform))
-
-        for s in signals:
-            if s.is_ai == is_ai:
-                explanation_parts.append(s.reason)
-
-        explanation = "; ".join(explanation_parts)
-
-        print(f"   ✅ Result: {classification} ({confidence:.2%})")
-
-        return HybridResult(
-            classification=classification,
-            confidence=confidence,
-            signals=signals,
-            explanation=explanation
-        )
-
-# Singleton instance
-hybrid_detector = HybridDetector()
-

app/core/signal_analyzer.py

@@ -1,298 +0,0 @@
-"""Signal Analyzer Module.
-
-Analyzes audio signals to extract multiple detection metrics:
-- Prosody (rhythm/timing)
-- Breath patterns
-- Spectral characteristics
-- Formant transitions
-- Silence patterns
-"""
-
-import numpy as np
-import librosa
-from typing import Dict, List, Tuple
-from dataclasses import dataclass
-
-from app.config import settings
-
-
-@dataclass
-class SignalScores:
-    """Container for all signal scores."""
-    prosody_score: float
-    breath_score: float
-    spectral_score: float
-    formant_score: float
-    silence_score: float
-    
-    def to_dict(self) -> Dict[str, float]:
-        """Convert to dictionary."""
-        return {
-            "prosody_score": self.prosody_score,
-            "breath_score": self.breath_score,
-            "spectral_score": self.spectral_score,
-            "formant_score": self.formant_score,
-            "silence_score": self.silence_score
-        }
-
-
-class SignalAnalyzer:
-    """Analyzes audio signals for deepfake detection features."""
-    
-    def __init__(self, sample_rate: int = None):
-        """Initialize analyzer.
-        
-        Args:
-            sample_rate: Audio sample rate (default: 16000)
-        """
-        self.sr = sample_rate or settings.TARGET_SAMPLE_RATE
-    
-    def calculate_prosody_score(self, waveform: np.ndarray) -> float:
-        """Analyze prosody (rhythm and timing patterns).
-        
-        AI-generated audio often has unnaturally consistent rhythm.
-        
-        Args:
-            waveform: Audio waveform
-            
-        Returns:
-            Prosody anomaly score (higher = more likely AI)
-        """
-        try:
-            # Extract tempo and beat frames
-            tempo, beat_frames = librosa.beat.beat_track(y=waveform, sr=self.sr)
-            
-            if len(beat_frames) < 2:
-                return 0.5  # Not enough data
-            
-            # Calculate inter-beat intervals
-            beat_times = librosa.frames_to_time(beat_frames, sr=self.sr)
-            intervals = np.diff(beat_times)
-            
-            if len(intervals) == 0:
-                return 0.5
-            
-            # AI audio tends to have very consistent intervals
-            # Calculate coefficient of variation
-            cv = np.std(intervals) / (np.mean(intervals) + 1e-6)
-            
-            # Low CV = suspicious (too consistent)
-            # Map to score: low CV -> high score
-            score = 1.0 - min(cv * 2, 1.0)
-            
-            return float(np.clip(score, 0, 1))
-            
-        except Exception:
-            return 0.5
-    
-    def calculate_breath_score(self, waveform: np.ndarray) -> float:
-        """Detect breath patterns in speech.
-        
-        Human speech has natural breath pauses that AI often misses.
-        
-        Args:
-            waveform: Audio waveform
-            
-        Returns:
-            Breath anomaly score (higher = more likely AI - missing breaths)
-        """
-        try:
-            # Calculate RMS energy
-            rms = librosa.feature.rms(y=waveform, frame_length=2048, hop_length=512)[0]
-            
-            # Normalize
-            rms_norm = rms / (np.max(rms) + 1e-6)
-            
-            # Find low energy regions (potential breath/pause locations)
-            threshold = 0.1
-            low_energy = rms_norm < threshold
-            
-            # Count transitions (speech to silence and back)
-            transitions = np.sum(np.abs(np.diff(low_energy.astype(int))))
-            
-            # Duration in seconds
-            duration = len(waveform) / self.sr
-            
-            # Expected transitions per second of speech
-            expected_transitions_per_sec = 0.3  # Roughly one breath every 3-4 seconds
-            expected = expected_transitions_per_sec * duration * 2
-            
-            # Too few transitions = suspicious (AI doesn't breathe)
-            ratio = transitions / (expected + 1e-6)
-            
-            # Low ratio means fewer natural pauses
-            if ratio < 0.5:
-                score = 0.9  # Very suspicious
-            elif ratio < 1.0:
-                score = 0.7
-            else:
-                score = 0.3  # Normal breathing patterns
-            
-            return float(score)
-            
-        except Exception:
-            return 0.5
-    
-    def calculate_spectral_score(self, waveform: np.ndarray) -> float:
-        """Analyze spectral characteristics for vocoder artifacts.
-        
-        AI vocoders leave characteristic spectral patterns.
-        
-        Args:
-            waveform: Audio waveform
-            
-        Returns:
-            Spectral anomaly score (higher = more likely AI)
-        """
-        try:
-            # Calculate spectral flatness
-            spec_flat = librosa.feature.spectral_flatness(y=waveform)[0]
-            
-            # Calculate spectral centroid variation
-            spec_cent = librosa.feature.spectral_centroid(y=waveform, sr=self.sr)[0]
-            cent_var = np.std(spec_cent) / (np.mean(spec_cent) + 1e-6)
-            
-            # AI audio often has higher spectral flatness
-            avg_flatness = np.mean(spec_flat)
-            
-            # Combine metrics
-            # High flatness or low centroid variation = suspicious
-            flatness_score = min(avg_flatness * 3, 1.0)
-            variation_score = 1.0 - min(cent_var * 2, 1.0)
-            
-            score = (flatness_score + variation_score) / 2
-            
-            return float(np.clip(score, 0, 1))
-            
-        except Exception:
-            return 0.5
-    
-    def calculate_formant_score(self, waveform: np.ndarray) -> float:
-        """Analyze formant transitions.
-        
-        Human vocal tract creates characteristic formant patterns.
-        
-        Args:
-            waveform: Audio waveform
-            
-        Returns:
-            Formant anomaly score (higher = more likely AI)
-        """
-        try:
-            # Use MFCC as proxy for formant information
-            mfccs = librosa.feature.mfcc(y=waveform, sr=self.sr, n_mfcc=13)
-            
-            # Calculate delta MFCCs (transitions)
-            delta_mfccs = librosa.feature.delta(mfccs)
-            
-            # AI often has smoother, less varied transitions
-            delta_var = np.mean(np.std(delta_mfccs, axis=1))
-            
-            # Low variation in deltas = suspicious
-            # Map: low variation -> high score
-            score = 1.0 - min(delta_var * 10, 1.0)
-            
-            return float(np.clip(score, 0, 1))
-            
-        except Exception:
-            return 0.5
-    
-    def calculate_silence_score(self, waveform: np.ndarray) -> float:
-        """Analyze silence/pause patterns.
-        
-        AI-generated audio often has "too perfect" silences.
-        
-        Args:
-            waveform: Audio waveform
-            
-        Returns:
-            Silence anomaly score (higher = more likely AI)
-        """
-        try:
-            # Split into frames
-            frame_length = 2048
-            hop_length = 512
-            
-            # Calculate energy per frame
-            frames = librosa.util.frame(waveform, frame_length=frame_length, hop_length=hop_length)
-            frame_energy = np.mean(frames ** 2, axis=0)
-            
-            # Identify silence frames (very low energy)
-            silence_threshold = np.percentile(frame_energy, 10)
-            silence_frames = frame_energy < silence_threshold
-            
-            # Calculate silence duration distribution
-            silence_runs = []
-            current_run = 0
-            
-            for is_silent in silence_frames:
-                if is_silent:
-                    current_run += 1
-                elif current_run > 0:
-                    silence_runs.append(current_run)
-                    current_run = 0
-            
-            if current_run > 0:
-                silence_runs.append(current_run)
-            
-            if len(silence_runs) < 2:
-                return 0.5
-            
-            # AI tends to have very uniform silence lengths
-            silence_cv = np.std(silence_runs) / (np.mean(silence_runs) + 1e-6)
-            
-            # Low variation = suspicious
-            score = 1.0 - min(silence_cv, 1.0)
-            
-            return float(np.clip(score, 0, 1))
-            
-        except Exception:
-            return 0.5
-    
-    def analyze(self, waveform: np.ndarray) -> SignalScores:
-        """Run all signal analyses.
-        
-        Args:
-            waveform: Audio waveform (16kHz, mono)
-            
-        Returns:
-            SignalScores with all metrics
-        """
-        return SignalScores(
-            prosody_score=self.calculate_prosody_score(waveform),
-            breath_score=self.calculate_breath_score(waveform),
-            spectral_score=self.calculate_spectral_score(waveform),
-            formant_score=self.calculate_formant_score(waveform),
-            silence_score=self.calculate_silence_score(waveform)
-        )
-    
-    def get_average_score(self, scores: SignalScores) -> float:
-        """Calculate weighted average of all scores.
-        
-        Args:
-            scores: Signal scores
-            
-        Returns:
-            Weighted average score
-        """
-        weights = {
-            "prosody": 0.15,
-            "breath": 0.25,
-            "spectral": 0.30,
-            "formant": 0.15,
-            "silence": 0.15
-        }
-        
-        weighted = (
-            scores.prosody_score * weights["prosody"] +
-            scores.breath_score * weights["breath"] +
-            scores.spectral_score * weights["spectral"] +
-            scores.formant_score * weights["formant"] +
-            scores.silence_score * weights["silence"]
-        )
-        
-        return float(weighted)
-
-
-# Create singleton instance
-signal_analyzer = SignalAnalyzer()

app/main.py

@@ -22,10 +22,9 @@ app = FastAPI(
     
     VoiceGuard detects whether an audio sample is AI-generated (deepfake) or genuine human speech.
     
+    ### Features
     ### Features
     - 🎯 **Multi-Language Support**: Tamil, English, Hindi, Malayalam, Telugu
-    - 📊 **Signal Analysis**: 5 detection signals (prosody, breath, spectral, formant, silence)
-    - 🔥 **Visual Heatmaps**: Spectrogram visualization showing artifact locations
     - 📝 **Explanations**: Human-readable reasoning for each detection
     
     ### How It Works
@@ -51,10 +50,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Mount static files for heatmaps
-os.makedirs(settings.HEATMAP_DIR, exist_ok=True)
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
 # Mount frontend files
 frontend_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "frontend")
 if os.path.exists(frontend_dir):

app/visualization/__init__.py

@@ -1 +0,0 @@
-"""Visualization Package."""

app/visualization/heatmap.py

@@ -1,220 +0,0 @@
-"""Heatmap Visualization Module.
-
-Generates spectrogram heatmaps with artifact highlighting.
-"""
-
-import os
-import uuid
-import numpy as np
-import matplotlib
-matplotlib.use('Agg')  # Non-GUI backend
-import matplotlib.pyplot as plt
-import librosa
-import librosa.display
-from typing import Optional, Tuple
-
-from app.config import settings
-from app.core.signal_analyzer import SignalScores
-
-
-class HeatmapGenerator:
-    """Generates spectrogram heatmaps with attention overlays."""
-    
-    def __init__(self, output_dir: str = None):
-        """Initialize generator.
-        
-        Args:
-            output_dir: Directory to save heatmap images
-        """
-        self.output_dir = output_dir or settings.HEATMAP_DIR
-        os.makedirs(self.output_dir, exist_ok=True)
-    
-    def generate_spectrogram(
-        self, 
-        waveform: np.ndarray, 
-        sr: int = 16000
-    ) -> np.ndarray:
-        """Generate Mel spectrogram from waveform.
-        
-        Args:
-            waveform: Audio waveform
-            sr: Sample rate
-            
-        Returns:
-            Mel spectrogram in dB scale
-        """
-        mel_spec = librosa.feature.melspectrogram(
-            y=waveform, 
-            sr=sr, 
-            n_mels=128,
-            fmax=8000
-        )
-        mel_db = librosa.power_to_db(mel_spec, ref=np.max)
-        return mel_db
-    
-    def create_attention_overlay(
-        self, 
-        spectrogram: np.ndarray,
-        scores: SignalScores,
-        duration: float
-    ) -> np.ndarray:
-        """Create attention overlay showing artifact regions.
-        
-        This creates a heatmap based on signal scores to highlight
-        suspicious regions in the spectrogram.
-        
-        Args:
-            spectrogram: Mel spectrogram
-            scores: Signal analysis scores
-            duration: Audio duration in seconds
-            
-        Returns:
-            Attention weights array (same shape as spectrogram)
-        """
-        n_mels, n_frames = spectrogram.shape
-        attention = np.zeros((n_mels, n_frames))
-        
-        # Average score determines overall intensity
-        avg_score = (
-            scores.prosody_score + 
-            scores.breath_score + 
-            scores.spectral_score + 
-            scores.formant_score + 
-            scores.silence_score
-        ) / 5
-        
-        # Create regions based on individual scores
-        frame_third = n_frames // 3
-        
-        # Early region (prosody/rhythm issues)
-        if scores.prosody_score > 0.5:
-            attention[:, :frame_third] += scores.prosody_score * 0.6
-        
-        # Mid region (breath/silence issues)
-        if scores.breath_score > 0.5:
-            attention[:, frame_third:2*frame_third] += scores.breath_score * 0.8
-        
-        if scores.silence_score > 0.5:
-            attention[64:, frame_third:2*frame_third] += scores.silence_score * 0.5
-        
-        # Late region (formant issues)
-        if scores.formant_score > 0.5:
-            attention[:64, 2*frame_third:] += scores.formant_score * 0.6
-        
-        # Spectral artifacts throughout
-        if scores.spectral_score > 0.5:
-            # Focus on middle frequencies where vocoder artifacts appear
-            attention[32:96, :] += scores.spectral_score * 0.4
-        
-        # Normalize to 0-1
-        if np.max(attention) > 0:
-            attention = attention / np.max(attention)
-        
-        # Apply some smoothing
-        from scipy.ndimage import gaussian_filter
-        attention = gaussian_filter(attention, sigma=3)
-        
-        return attention
-    
-    def create_heatmap(
-        self,
-        waveform: np.ndarray,
-        scores: SignalScores,
-        duration: float,
-        classification: str,
-        sr: int = 16000
-    ) -> str:
-        """Create and save heatmap visualization.
-        
-        Args:
-            waveform: Audio waveform
-            scores: Signal analysis scores
-            duration: Audio duration
-            classification: Detection result
-            sr: Sample rate
-            
-        Returns:
-            Path to saved heatmap image
-        """
-        # Generate spectrogram
-        mel_db = self.generate_spectrogram(waveform, sr)
-        
-        # Create attention overlay
-        attention = self.create_attention_overlay(mel_db, scores, duration)
-        
-        # Create figure
-        fig, ax = plt.subplots(figsize=(12, 4))
-        
-        # Plot spectrogram
-        img = librosa.display.specshow(
-            mel_db, 
-            sr=sr, 
-            x_axis='time', 
-            y_axis='mel',
-            ax=ax,
-            cmap='viridis'
-        )
-        
-        # Overlay attention heatmap
-        # Red for AI, green for human
-        cmap = 'Reds' if classification == "AI_GENERATED" else 'Greens'
-        ax.imshow(
-            attention, 
-            aspect='auto', 
-            alpha=0.5, 
-            cmap=cmap,
-            extent=[0, duration, 0, mel_db.shape[0]],
-            origin='lower'
-        )
-        
-        # Styling
-        ax.set_title(
-            f'Detection Heatmap - {classification}',
-            fontsize=14,
-            fontweight='bold',
-            color='white' if classification == "AI_GENERATED" else 'darkgreen'
-        )
-        ax.set_xlabel('Time (seconds)')
-        ax.set_ylabel('Mel Frequency')
-        
-        # Colorbar
-        plt.colorbar(img, ax=ax, format='%+2.0f dB')
-        
-        # Background color
-        fig.patch.set_facecolor('#1e293b')
-        ax.set_facecolor('#1e293b')
-        ax.tick_params(colors='#94a3b8')
-        ax.xaxis.label.set_color('#f1f5f9')
-        ax.yaxis.label.set_color('#f1f5f9')
-        
-        plt.tight_layout()
-        
-        # Save
-        filename = f"{uuid.uuid4().hex[:12]}.png"
-        filepath = os.path.join(self.output_dir, filename)
-        
-        fig.savefig(
-            filepath, 
-            dpi=150, 
-            facecolor='#1e293b',
-            edgecolor='none',
-            bbox_inches='tight'
-        )
-        plt.close(fig)
-        
-        return filename
-    
-    def get_heatmap_url(self, filename: str) -> str:
-        """Get API URL for heatmap.
-        
-        Args:
-            filename: Heatmap filename
-            
-        Returns:
-            API URL path
-        """
-        return f"/api/v1/heatmap/{filename}"
-
-
-# Create singleton instance
-heatmap_generator = HeatmapGenerator()

requirements.txt

@@ -1,14 +1,11 @@
 # VoiceGuard Backend Requirements
 # ================================
 
-# Gradio UI
-gradio>=4.44.0
-
 # Audio Processing
 librosa>=0.10.1
 soundfile>=0.12.1
 numpy
-scipy>=1.11.4
+pydub>=0.25.1
 
 # Machine Learning
 torch>=2.0.0
@@ -22,6 +19,3 @@ python-multipart>=0.0.9
 pydantic==2.5.3
 pydantic-settings==2.1.0
 python-dotenv==1.0.0
-
-# Visualization
-matplotlib==3.8.2