entire

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,32 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# IDEs
-.vscode/
-.idea/
-
-# OS
-.DS_Store
-Thumbs.db
-
-# App specific
-*.mp3
-*.wav
-*.log
-
-# Sensitive
-config.yml
-*.json
-credentials-file.json
-/weights/

Dockerfile

@@ -1,22 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Install system dependencies for audio processing
-RUN apt-get update && apt-get install -y \
-    ffmpeg \
-    libsndfile1 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first for caching
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY . .
-
-# Expose port 7860 (HuggingFace Spaces default)
-EXPOSE 7860
-
-# Run the application
-CMD ["python", "run.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,27 +1,12 @@
 ---
-title: AI Voice Detection API
-emoji: 🎤
+title: Voice Detection Api
+emoji: 📊
 colorFrom: blue
-colorTo: purple
+colorTo: blue
 sdk: docker
 pinned: false
 license: mit
+short_description: api for buildathon
 ---
 
-# AI Voice Detection API
-
-Detect AI-generated voices using advanced acoustic analysis and neural network patterns.
-
-## API Endpoints
-
-- `POST /api/v1/detect` - Detect if audio is AI-generated
-- `GET /api/v1/health` - Health check
-- `GET /docs` - API documentation
-
-## Usage
-
-```bash
-curl -X POST "https://YOUR-SPACE.hf.space/api/v1/detect" \
-  -H "Content-Type: application/json" \
-  -d '{"audioUrl": "https://example.com/audio.mp3"}'
-```
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/__init__.py

@@ -1,3 +0,0 @@
-"""
-AI Voice Detection System - App Package
-"""

app/api/__init__.py

@@ -1,3 +0,0 @@
-"""
-API Package
-"""

app/api/routes.py

@@ -1,276 +0,0 @@
-"""
-API Routes for Voice Detection
-
-Defines all API endpoints for the voice detection service.
-"""
-import base64
-import tempfile
-import os
-from typing import Optional
-from fastapi import APIRouter, HTTPException, status, BackgroundTasks, Security, Request
-from fastapi.security import APIKeyHeader
-import httpx
-from pydantic import ValidationError
-
-from .schemas import (
-    DetectRequest,
-    ExternalTesterRequest,
-    DetectResponse,
-    HealthResponse,
-    ErrorResponse,
-    LanguageCode
-)
-from ..models.ensemble_detector import EnsembleVoiceDetector, create_detector
-
-
-_detector: Optional[EnsembleVoiceDetector] = None
-
-
-def get_detector(language: str = "en") -> EnsembleVoiceDetector:
-    """Get or create detector instance"""
-    global _detector
-    if _detector is None:
-        _detector = create_detector(language=language)
-    return _detector
-
-
-router = APIRouter(prefix="/api/v1", tags=["Voice Detection"])
-
-
-@router.post(
-    "/detect",
-    response_model=DetectResponse,
-    # ... (responses dict)
-    summary="Detect AI-Generated Voice",
-    description="..."
-)
-async def detect_voice(
-    request: DetectRequest,
-    api_key: str = Security(APIKeyHeader(name="X-API-Key", auto_error=False))
-) -> DetectResponse:
-    """
-    Detect if the provided audio is AI-generated or human.
-    """
-    # Optional API Key Validation
-    # We allow the key to be missing for public testing/hackathon judges.
-    if api_key:
-        # In a real app, validate against DB/Env
-        pass
-    
-    temp_path = None
-    
-    try:
-        audio_bytes = None
-        
-        if request.audio_url:
-            # Download from URL
-            async with httpx.AsyncClient() as client:
-                try:
-                    resp = await client.get(request.audio_url, follow_redirects=True, timeout=30.0)
-                    resp.raise_for_status()
-                    audio_bytes = resp.content
-                except Exception as e:
-                    raise HTTPException(
-                        status_code=status.HTTP_400_BAD_REQUEST,
-                        detail=f"Failed to download audio from URL: {str(e)}"
-                    )
-        elif request.audio_base64:
-            # Decode Base64
-            try:
-                audio_bytes = base64.b64decode(request.audio_base64)
-            except Exception as e:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"Invalid Base64 encoding: {str(e)}"
-                )
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Either 'audio_url' or 'audio_base64' must be provided."
-            )
-            
-        if len(audio_bytes) > 10 * 1024 * 1024:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Audio file too large. Maximum size is 10MB."
-            )
-        
-        if len(audio_bytes) < 1000:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Audio file too small. Minimum duration is 1 second."
-            )
-        
-        # Write audio to temporary file
-        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
-            f.write(audio_bytes)
-            temp_path = f.name
-        
-        # Get language from request or default to English
-        language = request.language_hint.value if request.language_hint else "en"
-        
-        detector = get_detector(language=language)
-
-        
-        result = detector.detect(temp_path)
-        
-        return DetectResponse(
-            classification=result["classification"],
-            confidence=result["confidence"],
-            explanation=result["explanation"]["key_indicators"]
-        )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Detection failed: {str(e)}"
-        )
-    finally:
-        # Cleanup temp file
-        if temp_path and os.path.exists(temp_path):
-            try:
-                os.unlink(temp_path)
-            except OSError:
-                pass
-
-
-@router.post(
-    "/detect-external",
-    response_model=DetectResponse,
-    summary="Detect AI-Generated Voice (External Tester Compatible)",
-    description="Alternative endpoint compatible with external testing tools"
-)
-async def detect_voice_external(
-    request: ExternalTesterRequest
-) -> DetectResponse:
-    """
-    Detect if the provided audio is AI-generated or human.
-    Compatible with external endpoint testers.
-    """
-    temp_path = None
-    
-    try:
-        # Convert external tester format to internal format
-        audio_bytes = base64.b64decode(request.Audio_Base64_Format)
-        
-        if len(audio_bytes) > 10 * 1024 * 1024:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Audio file too large. Maximum size is 10MB."
-            )
-        
-        if len(audio_bytes) < 1000:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Audio file too small. Minimum duration is 1 second."
-            )
-        
-        # Write audio to temporary file
-        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
-            f.write(audio_bytes)
-            temp_path = f.name
-        
-        # Get language from request
-        language = request.Language.lower()
-        
-        detector = get_detector(language=language)
-        
-        result = detector.detect(temp_path)
-        
-        result["language_detected"] = language
-        
-        return DetectResponse(**result)
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Detection failed: {str(e)}"
-        )
-    finally:
-        # Cleanup temp file
-        if temp_path and os.path.exists(temp_path):
-            try:
-                os.unlink(temp_path)
-            except OSError:
-                pass
-
-
-@router.get(
-    "/health",
-    response_model=HealthResponse,
-    summary="Health Check",
-    description="Check the health status of the voice detection service"
-)
-async def health_check() -> HealthResponse:
-    """
-    Check if the service is healthy and all models are loaded.
-    """
-    import torch
-    
-    detector = get_detector()
-    
-    return HealthResponse(
-        status="healthy",
-        version="1.0.0",
-        models_loaded={
-            "wav2vec": hasattr(detector, 'wav2vec_detector'),
-            "spectrogram_cnn": hasattr(detector, 'spectrogram_detector'),
-            "personaplex": hasattr(detector, 'personaplex_detector')
-        },
-        device="cuda" if torch.cuda.is_available() else "cpu"
-    )
-
-
-@router.get(
-    "/languages",
-    summary="Supported Languages",
-    description="Get list of supported languages for voice detection"
-)
-async def get_languages():
-    """Get supported languages"""
-    return {
-        "languages": [
-            {"code": "ta", "name": "Tamil"},
-            {"code": "en", "name": "English"},
-            {"code": "hi", "name": "Hindi"},
-            {"code": "ml", "name": "Malayalam"},
-            {"code": "te", "name": "Telugu"}
-        ]
-    }
-
-
-@router.get(
-    "/tools",
-    summary="Detectable AI Tools",
-    description="Get list of AI voice synthesis tools that can be detected"
-)
-async def get_detectable_tools():
-    """Get list of detectable AI tools"""
-    return {
-        "tools": [
-            {
-                "id": "nvidia_personaplex",
-                "name": "NVIDIA PersonaPlex/Riva",
-                "description": "NVIDIA's conversational AI voice synthesis"
-            },
-            {
-                "id": "elevenlabs",
-                "name": "ElevenLabs",
-                "description": "ElevenLabs voice cloning and synthesis"
-            },
-            {
-                "id": "azure_neural",
-                "name": "Microsoft Azure Neural TTS",
-                "description": "Azure Cognitive Services Neural TTS"
-            },
-            {
-                "id": "google_wavenet",
-                "name": "Google WaveNet/Neural2",
-                "description": "Google Cloud Text-to-Speech"
-            }
-        ]
-    }

app/api/schemas.py

@@ -1,185 +0,0 @@
-"""
-Pydantic Schemas for API Request/Response Validation
-"""
-from pydantic import BaseModel, Field
-from typing import Dict, List, Optional, Any
-from enum import Enum
-
-
-class LanguageCode(str, Enum):
-    """Supported language codes"""
-    TAMIL = "ta"
-    ENGLISH = "en"
-    HINDI = "hi"
-    MALAYALAM = "ml"
-    TELUGU = "te"
-
-
-class ClassificationType(str, Enum):
-    """Voice classification types"""
-    AI_GENERATED = "ai_generated"
-    HUMAN = "human"
-    UNKNOWN = "unknown"
-
-
-class ConfidenceLevel(str, Enum):
-    """Confidence level descriptors"""
-    HIGH = "high"
-    MEDIUM = "medium"
-    LOW = "low"
-
-
-# ============== Request Schemas ==============
-
-class DetectRequest(BaseModel):
-    """Request schema for voice detection endpoint"""
-    audio_base64: Optional[str] = Field(
-        default=None,
-        description="Base64-encoded MP3 audio data (mutually exclusive with audio_url)",
-        min_length=100,
-        examples=["SGVsbG8gV29ybGQ..."],
-        alias="audioBase64"
-    )
-    audio_url: Optional[str] = Field(
-        default=None,
-        description="URL to audio file (MP3, WAV, etc.) (mutually exclusive with audio_base64)",
-        alias="audioUrl"
-    )
-    language_hint: Optional[LanguageCode] = Field(
-        default=None,
-        description="Optional hint for expected language (improves accuracy)"
-    )
-    
-    class Config:
-        populate_by_name = True
-        json_schema_extra = {
-            "example": {
-                "audio_url": "https://example.com/sample.mp3",
-                "language_hint": "en"
-            }
-        }
-
-
-class ExternalTesterRequest(BaseModel):
-    """Request schema compatible with external endpoint tester"""
-    Language: str = Field(
-        ...,
-        description="Language code (en, ta, hi, ml, te)",
-        examples=["en"]
-    )
-    Audio_Format: str = Field(
-        default="mp3",
-        description="Audio format (mp3, wav, etc.)",
-        alias="Audio Format"
-    )
-    Audio_Base64_Format: str = Field(
-        ...,
-        description="Base64-encoded audio data",
-        alias="Audio Base64 Format"
-    )
-    
-    class Config:
-        populate_by_name = True
-
-
-
-# ============== Response Schemas ==============
-
-class TechnicalDetails(BaseModel):
-    """Technical analysis details"""
-    spectral_artifacts: List[str] = Field(default_factory=list)
-    temporal_patterns: List[str] = Field(default_factory=list)
-    synthesis_markers: List[str] = Field(default_factory=list)
-
-
-class ExplanationResponse(BaseModel):
-    """Detailed explanation of detection result"""
-    summary: str = Field(
-        ...,
-        description="Human-readable summary of the detection"
-    )
-    confidence_level: ConfidenceLevel = Field(
-        ...,
-        description="Confidence level (high/medium/low)"
-    )
-    technical_details: TechnicalDetails = Field(
-        ...,
-        description="Technical analysis breakdown"
-    )
-    key_indicators: List[str] = Field(
-        ...,
-        description="Top indicators that led to the classification"
-    )
-    model_contributions: Dict[str, float] = Field(
-        ...,
-        description="Weight contribution of each detection model"
-    )
-
-
-class ComponentResult(BaseModel):
-    """Result from an individual detection component"""
-    classification: Optional[str] = None
-    confidence: Optional[float] = None
-    ai_probability: Optional[float] = None
-
-
-class DetectedTool(BaseModel):
-    """Information about detected AI voice tool"""
-    tool_id: str
-    tool_name: str
-    confidence: float
-    reasons: List[str]
-
-
-class DetailedAnalysis(BaseModel):
-    """Detailed analysis from all detection components"""
-    wav2vec_indicators: List[str] = Field(default_factory=list)
-    spectrogram_indicators: List[str] = Field(default_factory=list)
-    personaplex_indicators: List[str] = Field(default_factory=list)
-    detected_tools: List[DetectedTool] = Field(default_factory=list)
-
-
-class DetectResponse(BaseModel):
-    """Response schema for voice detection endpoint"""
-    classification: ClassificationType = Field(
-        ...,
-        description="Classification result: ai_generated or human"
-    )
-    confidence: float = Field(
-        ...,
-        ge=0.0,
-        le=1.0,
-        description="Confidence score between 0 and 1"
-    )
-    explanation: List[str] = Field(
-        ...,
-        description="List of key indicators explaining the classification"
-    )
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "classification": "ai_generated",
-                "confidence": 0.85,
-                "explanation": [
-                    "Unusually smooth spectral distribution typical of neural vocoders",
-                    "Low temporal variation suggesting synthetic generation",
-                    "Periodic patterns suggesting neural vocoder"
-                ]
-            }
-        }
-
-
-class HealthResponse(BaseModel):
-    """Health check response"""
-    status: str = "healthy"
-    version: str
-    models_loaded: Dict[str, bool]
-    device: str
-
-
-class ErrorResponse(BaseModel):
-    """Error response schema"""
-    error: str
-    detail: Optional[str] = None
-    code: str

app/audio_utils.py

@@ -1,76 +0,0 @@
-"""
-Audio Utilities - Shared audio loading functions with MP3 support
-"""
-import os
-from typing import Tuple
-import numpy as np
-import soundfile as sf
-from scipy import signal
-import logging
-
-logger = logging.getLogger(__name__)
-
-try:
-    import torch
-    TORCH_AVAILABLE = True
-except ImportError:
-    TORCH_AVAILABLE = False
-
-
-def load_audio(audio_path: str, target_sr: int = 16000) -> Tuple[np.ndarray, int]:
-    """
-    Load audio file with MP3 support using soundfile.
-    Returns: Tuple of (audio_array, sample_rate)
-    """
-    samples, sr = sf.read(audio_path, dtype='float32')
-    
-    if len(samples.shape) > 1:
-        samples = samples.mean(axis=1)
-    
-    if sr != target_sr:
-        samples = resample_audio(samples, sr, target_sr)
-    
-    return samples, target_sr
-
-
-def resample_audio(samples: np.ndarray, orig_sr: int, target_sr: int) -> np.ndarray:
-    """Resample audio using scipy"""
-    if orig_sr == target_sr:
-        return samples
-    
-    duration = len(samples) / orig_sr
-    new_length = int(duration * target_sr)
-    
-    resampled = signal.resample(samples, new_length)
-    
-    return resampled.astype(np.float32)
-
-
-def load_audio_torch(audio_path: str, target_sr: int = 16000) -> "torch.Tensor":
-    """Load audio and return as torch tensor"""
-    samples, sr = load_audio(audio_path, target_sr)
-    if TORCH_AVAILABLE:
-        return torch.from_numpy(samples).float()
-    else:
-        raise ImportError("PyTorch is required for load_audio_torch")
-
-
-def extract_advanced_features(audio_path: str, sample_rate: int = 16000) -> dict:
-    """Extract advanced features using librosa (Flux, MFCC)"""
-    import librosa
-    try:
-        # Load short segment for speed (max 10s)
-        y, sr = librosa.load(audio_path, duration=10, sr=sample_rate)
-        
-        # Spectral Flux (Change in spectrum over time)
-        onset_env = librosa.onset.onset_strength(y=y, sr=sr)
-        flux = float(np.mean(onset_env))
-        
-        # MFCC Variance (Timbre complexity)
-        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
-        mfcc_var = float(np.mean(np.var(mfcc, axis=1)))
-        
-        return {"spectral_flux": flux, "mfcc_variance": mfcc_var}
-    except Exception as e:
-        logger.error(f"Error extracting advanced features: {e}")
-        return {"spectral_flux": 0.0, "mfcc_variance": 0.0}

app/config.py

@@ -1,67 +0,0 @@
-"""
-AI Voice Detection System Configuration
-"""
-import os
-from pathlib import Path
-
-# Base paths
-BASE_DIR = Path(__file__).parent.parent
-WEIGHTS_DIR = BASE_DIR / "weights"
-CACHE_DIR = BASE_DIR / ".cache"
-
-# Create directories
-WEIGHTS_DIR.mkdir(exist_ok=True)
-CACHE_DIR.mkdir(exist_ok=True)
-
-# Model configurations
-class ModelConfig:
-    # IndicWav2Vec - Best for Indian languages
-    INDICWAV2VEC_MODEL = "ai4bharat/indicwav2vec-hindi"
-    
-    # Multilingual Wav2Vec2 as fallback
-    XLSR_MODEL = "facebook/wav2vec2-large-xlsr-53"
-    
-    # Language detection
-    LANG_ID_MODEL = "speechbrain/lang-id-voxlingua107"
-    
-    # Audio settings
-    SAMPLE_RATE = 16000
-    MAX_AUDIO_LENGTH = 60  # seconds
-    MIN_AUDIO_LENGTH = 1   # seconds
-    
-    # Detection thresholds
-    CONFIDENCE_THRESHOLD = 0.7
-    ENSEMBLE_WEIGHTS = {
-        "wav2vec": 0.5,
-        "spectrogram_cnn": 0.3,
-        "acoustic_rules": 0.2
-    }
-
-# Supported languages
-SUPPORTED_LANGUAGES = {
-    "ta": "Tamil",
-    "en": "English", 
-    "hi": "Hindi",
-    "ml": "Malayalam",
-    "te": "Telugu"
-}
-
-# AI Tools signatures for detection
-AI_TOOL_SIGNATURES = {
-    "nvidia_personaplex": {
-        "description": "NVIDIA PersonaPlex/Riva TTS",
-        "markers": ["hifi_gan_vocoder", "low_latency_synthesis"]
-    },
-    "elevenlabs": {
-        "description": "ElevenLabs Voice Synthesis",
-        "markers": ["multilingual_v2", "voice_cloning"]
-    },
-    "azure_tts": {
-        "description": "Microsoft Azure TTS",
-        "markers": ["neural_voice", "ssml_prosody"]
-    },
-    "google_tts": {
-        "description": "Google Cloud TTS",
-        "markers": ["wavenet", "neural2"]
-    }
-}

app/main.py

@@ -1,107 +0,0 @@
-"""
-AI Voice Detection API - Main Application
-
-FastAPI application for detecting AI-generated voices across
-multiple Indian languages with NVIDIA PersonaPlex detection.
-"""
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-import time
-import logging
-
-from .api.routes import router as api_router
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-
-app = FastAPI(
-    title="AI Voice Detection API",
-    description="API for detecting AI-generated voices using NVIDIA PersonaPlex signature matching and acoustic analysis.",
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    contact={
-        "name": "AI Voice Detection Team",
-        "email": "contact@example.com"
-    },
-    license_info={
-        "name": "MIT License"
-    }
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Increase max request body size (50MB for audio files)
-
-
-
-@app.get("/")
-async def root():
-    """Root endpoint for health checks"""
-    return {"status": "ok", "message": "AI Voice Detection API"}
-
-
-@app.middleware("http")
-async def add_timing_header(request: Request, call_next):
-    """Add response timing header"""
-    start_time = time.time()
-    response = await call_next(request)
-    process_time = time.time() - start_time
-    response.headers["X-Process-Time"] = f"{process_time:.4f}"
-    return response
-
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    """Handle unexpected exceptions"""
-    logger.error(f"Unexpected error: {exc}", exc_info=True)
-    return JSONResponse(
-        status_code=500,
-        content={
-            "error": "Internal server error",
-            "detail": str(exc),
-            "code": "INTERNAL_ERROR"
-        }
-    )
-
-
-app.include_router(api_router)
-
-
-@app.get("/", tags=["Root"])
-async def root():
-    """
-    Root endpoint with API information.
-    """
-    return {
-        "name": "AI Voice Detection API",
-        "version": "1.0.0",
-        "description": "Detect AI-generated voices in multiple languages",
-        "docs": "/docs",
-        "health": "/api/v1/health",
-        "detect": "/api/v1/detect"
-    }
-
-
-@app.on_event("startup")
-async def startup_event():
-    """Initialize models on startup"""
-    logger.info("Starting AI Voice Detection API...")
-    logger.info("Models will be loaded on first request (lazy loading)")
-
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Cleanup on shutdown"""
-    logger.info("Shutting down AI Voice Detection API...")

app/models/__init__.py

@@ -1,17 +0,0 @@
-"""
-Models Package - AI Voice Detection Models
-"""
-from .wav2vec_detector import Wav2VecDetector, IndicWav2VecDetector
-from .spectrogram_cnn import SpectrogramDetector, SpectrogramCNN
-from .personaplex_detector import PersonaPlexDetector
-from .ensemble_detector import EnsembleVoiceDetector, create_detector
-
-__all__ = [
-    "Wav2VecDetector",
-    "IndicWav2VecDetector", 
-    "SpectrogramDetector",
-    "SpectrogramCNN",
-    "PersonaPlexDetector",
-    "EnsembleVoiceDetector",
-    "create_detector"
-]

app/models/ensemble_detector.py

@@ -1,310 +0,0 @@
-"""
-Ensemble Voice Detector
-
-Combines multiple detection methods (Wav2Vec2, Spectrogram CNN, PersonaPlex)
-with weighted fusion for robust AI voice detection.
-"""
-import torch
-import numpy as np
-from typing import Dict, List, Optional, Any
-from concurrent.futures import ThreadPoolExecutor
-import traceback
-import logging
-
-logger = logging.getLogger(__name__)
-
-from .wav2vec_detector import Wav2VecDetector, IndicWav2VecDetector
-from .spectrogram_cnn import SpectrogramDetector
-from .personaplex_detector import PersonaPlexDetector
-
-
-class EnsembleVoiceDetector:
-    """
-    Ensemble detector that combines multiple AI voice detection methods.
-    
-    Components:
-    1. Wav2Vec2/IndicWav2Vec - Deep acoustic pattern analysis
-    2. Spectrogram CNN - Visual pattern detection in mel spectrograms
-    3. PersonaPlex Detector - AI tool signature matching
-    
-    Uses weighted fusion to combine predictions for robust detection.
-    """
-    
-    DEFAULT_WEIGHTS = {
-        "wav2vec": 0.45,      # Primary - best for language-specific patterns
-        "spectrogram": 0.35,  # Secondary - catches vocoder artifacts
-        "personaplex": 0.20   # Tertiary - identifies specific tools
-    }
-    
-    def __init__(
-        self,
-        language: str = "en",
-        device: str = None,
-        weights: Dict[str, float] = None,
-        enable_parallel: bool = True
-    ):
-        """
-        Initialize ensemble detector.
-        
-        Args:
-            language: Primary language code (en, hi, ta, te, ml)
-            device: Torch device (cuda/cpu)
-            weights: Custom weights for ensemble fusion
-            enable_parallel: Enable parallel inference for speed
-        """
-        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
-        self.language = language
-        self.weights = weights or self.DEFAULT_WEIGHTS
-        self.enable_parallel = enable_parallel
-        
-        logger.info(f"[EnsembleDetector] Initializing with language={language}, device={self.device}")
-        
-        self._init_detectors()
-        
-    def _init_detectors(self):
-        """Initialize all component detectors"""
-        logger.info("[EnsembleDetector] Loading Wav2Vec detector...")
-        try:
-            self.wav2vec_detector = IndicWav2VecDetector(
-                language=self.language,
-                device=self.device
-            )
-        except Exception as e:
-            logger.warning(f"[EnsembleDetector] Warning: IndicWav2Vec failed, using base model: {e}")
-            self.wav2vec_detector = Wav2VecDetector(
-                model_name="facebook/wav2vec2-base",
-                device=self.device
-            )
-        
-        logger.info("[EnsembleDetector] Loading Spectrogram detector...")
-        self.spectrogram_detector = SpectrogramDetector(device=self.device)
-        
-        logger.info("[EnsembleDetector] Loading PersonaPlex detector...")
-        self.personaplex_detector = PersonaPlexDetector()
-        
-        logger.info("[EnsembleDetector] All detectors loaded successfully!")
-    
-    def _run_detector(self, detector_name: str, audio_path: str) -> Dict:
-        """Run a single detector with error handling"""
-        try:
-            if detector_name == "wav2vec":
-                return self.wav2vec_detector.detect(audio_path)
-            elif detector_name == "spectrogram":
-                return self.spectrogram_detector.detect(audio_path)
-            elif detector_name == "personaplex":
-                return self.personaplex_detector.detect(audio_path)
-            else:
-                raise ValueError(f"Unknown detector: {detector_name}")
-        except Exception as e:
-            logger.error(f"[EnsembleDetector] Error in {detector_name}: {e}")
-            traceback.print_exc()
-            return {
-                "classification": "unknown",
-                "confidence": 0.0,
-                "model_scores": {"ai_probability": 0.5, "human_probability": 0.5},
-                "error": str(e)
-            }
-    
-    def detect(self, audio_path: str) -> Dict:
-        """
-        Perform ensemble detection on audio file.
-        
-        Args:
-            audio_path: Path to audio file
-            
-        Returns:
-            Comprehensive detection result with ensemble fusion
-        """
-        results = {}
-        
-        # Run detectors (parallel or sequential)
-        if self.enable_parallel:
-            with ThreadPoolExecutor(max_workers=3) as executor:
-                futures = {
-                    name: executor.submit(self._run_detector, name, audio_path)
-                    for name in ["wav2vec", "spectrogram", "personaplex"]
-                }
-                results = {name: future.result() for name, future in futures.items()}
-        else:
-            for name in ["wav2vec", "spectrogram", "personaplex"]:
-                results[name] = self._run_detector(name, audio_path)
-        
-        ensemble_result = self._fuse_results(results)
-        
-        ensemble_result["component_results"] = {
-            name: {
-                "classification": r.get("classification"),
-                "confidence": r.get("confidence"),
-                "ai_probability": r.get("model_scores", {}).get("ai_probability")
-            }
-            for name, r in results.items()
-        }
-        
-        ensemble_result["detailed_analysis"] = {
-            "wav2vec_indicators": results["wav2vec"].get("indicators", []),
-            "spectrogram_indicators": results["spectrogram"].get("indicators", []),
-            "personaplex_indicators": results["personaplex"].get("indicators", []),
-            "detected_tools": results["personaplex"].get("detected_tools", [])
-        }
-        
-        return ensemble_result
-    
-    def _fuse_results(self, results: Dict[str, Dict]) -> Dict:
-        """
-        Fuse results from multiple detectors using weighted voting.
-        
-        Uses AI probability from each detector weighted by confidence.
-        """
-        weighted_ai_prob = 0.0
-        total_weight = 0.0
-        all_indicators = []
-        
-        for detector_name, result in results.items():
-            if "error" in result:
-                continue
-                
-            weight = self.weights.get(detector_name, 0.33)
-            ai_prob = result.get("model_scores", {}).get("ai_probability", 0.5)
-            confidence = result.get("confidence", 0.5)
-            
-            # Weight by both assigned weight and detector confidence
-            effective_weight = weight * confidence
-            weighted_ai_prob += ai_prob * effective_weight
-            total_weight += effective_weight
-            
-            # Collect indicators
-            all_indicators.extend(result.get("indicators", []))
-        
-        # Normalize
-        if total_weight > 0:
-            final_ai_prob = weighted_ai_prob / total_weight
-        else:
-            final_ai_prob = 0.5
-        
-        # Determine classification
-        is_ai = final_ai_prob >= 0.5
-        
-        # Confidence is the probability of the winning class
-        base_confidence = final_ai_prob if is_ai else (1.0 - final_ai_prob)
-        
-        # Boost confidence if detectors agree
-        agreement = self._calculate_agreement(results)
-        if agreement > 0.8:
-            # Boost towards 1.0
-            confidence = base_confidence + (1.0 - base_confidence) * 0.2
-        else:
-            confidence = base_confidence
-        
-        # Select top indicators
-        unique_indicators = list(dict.fromkeys(all_indicators))[:5]
-        
-        # Determine detected AI tool
-        detected_tools = results.get("personaplex", {}).get("detected_tools", [])
-        primary_tool = detected_tools[0]["tool_name"] if detected_tools else None
-        
-        return {
-            "classification": "ai_generated" if is_ai else "human",
-            "confidence": round(confidence, 4),
-            "ai_probability": round(final_ai_prob, 4),
-            "human_probability": round(1 - final_ai_prob, 4),
-            "ai_tool_detected": primary_tool,
-            "detector_agreement": round(agreement, 4),
-            "indicators": unique_indicators,
-            "explanation": self._generate_explanation(
-                is_ai, confidence, unique_indicators, primary_tool, results
-            )
-        }
-    
-    def _calculate_agreement(self, results: Dict[str, Dict]) -> float:
-        """Calculate agreement between detectors (0-1)"""
-        classifications = []
-        
-        for result in results.values():
-            if "error" not in result:
-                classifications.append(result.get("classification") == "ai_generated")
-        
-        if not classifications:
-            return 0.0
-        
-        # Agreement is proportion of detectors that agree with majority
-        ai_count = sum(classifications)
-        human_count = len(classifications) - ai_count
-        majority_count = max(ai_count, human_count)
-        
-        return majority_count / len(classifications)
-    
-    def _generate_explanation(
-        self,
-        is_ai: bool,
-        confidence: float,
-        indicators: List[str],
-        tool_detected: Optional[str],
-        results: Dict
-    ) -> Dict:
-        """Generate comprehensive explanation for the detection"""
-        
-        # Determine confidence level
-        if confidence >= 0.8:
-            confidence_level = "high"
-            summary_prefix = "Strong evidence"
-        elif confidence >= 0.6:
-            confidence_level = "medium"
-            summary_prefix = "Moderate evidence"
-        else:
-            confidence_level = "low"
-            summary_prefix = "Weak evidence"
-        
-        if is_ai:
-            summary = f"{summary_prefix} of AI-generated voice detected"
-            if tool_detected:
-                summary += f" (likely {tool_detected})"
-        else:
-            summary = f"{summary_prefix} suggests this is authentic human speech"
-        
-        # Technical details
-        technical_details = {
-            "spectral_artifacts": [],
-            "temporal_patterns": [],
-            "synthesis_markers": []
-        }
-        
-        # Categorize indicators
-        for ind in indicators:
-            ind_lower = ind.lower()
-            if any(kw in ind_lower for kw in ["spectral", "frequency", "band", "harmonic"]):
-                technical_details["spectral_artifacts"].append(ind)
-            elif any(kw in ind_lower for kw in ["temporal", "time", "variation", "smooth"]):
-                technical_details["temporal_patterns"].append(ind)
-            elif any(kw in ind_lower for kw in ["vocoder", "synthesis", "signature", "neural"]):
-                technical_details["synthesis_markers"].append(ind)
-            else:
-                # Default to synthesis markers for AI indicators
-                if is_ai:
-                    technical_details["synthesis_markers"].append(ind)
-                else:
-                    technical_details["temporal_patterns"].append(ind)
-        
-        return {
-            "summary": summary,
-            "confidence_level": confidence_level,
-            "technical_details": technical_details,
-            "key_indicators": indicators[:3],
-            "model_contributions": {
-                name: round(self.weights[name], 2)
-                for name in self.weights
-            }
-        }
-
-
-def create_detector(language: str = "en", device: str = None) -> EnsembleVoiceDetector:
-    """
-    Factory function to create an ensemble detector.
-    
-    Args:
-        language: Primary language code (en, hi, ta, te, ml)
-        device: Torch device (cuda/cpu/auto)
-        
-    Returns:
-        Configured EnsembleVoiceDetector instance
-    """
-    return EnsembleVoiceDetector(language=language, device=device)

app/models/personaplex_detector.py

@@ -1,282 +0,0 @@
-"""
-NVIDIA PersonaPlex and AI Tool Signature Detection
-
-Detects specific AI voice synthesis tools by analyzing their unique
-acoustic signatures and vocoder fingerprints.
-"""
-import torch
-import numpy as np
-import torchaudio
-import torchaudio.transforms as T
-from typing import Dict, List, Optional, Tuple
-from scipy import signal
-from scipy.fft import fft, fftfreq
-
-# Import audio utilities for MP3 support
-from ..audio_utils import load_audio
-
-
-class PersonaPlexDetector:
-    """
-    Specialized detector for NVIDIA PersonaPlex and other AI voice synthesis tools.
-    
-    NVIDIA PersonaPlex uses HiFi-GAN vocoder which has characteristic patterns:
-    - Specific frequency artifacts in 6-8kHz range
-    - Phase correlation patterns from real-time synthesis
-    - Low-latency inference artifacts
-    """
-    
-    def __init__(self, sample_rate: int = 16000):
-        self.sample_rate = sample_rate
-        self.resampler_cache = {}
-        
-        # Known AI tool signatures
-        self.signatures = {
-            "nvidia_personaplex": {
-                "name": "NVIDIA PersonaPlex/Riva",
-                "vocoder": "HiFi-GAN",
-                "frequency_artifacts": (6000, 8000),  # Hz range
-                "phase_coherence_threshold": 0.85,
-                "spectral_tilt_range": (-2, 0),
-            },
-            "elevenlabs": {
-                "name": "ElevenLabs",
-                "vocoder": "Proprietary Neural",
-                "frequency_artifacts": (7000, 10000),
-                "phase_coherence_threshold": 0.80,
-                "spectral_tilt_range": (-3, -1),
-            },
-            "azure_neural": {
-                "name": "Microsoft Azure Neural TTS",
-                "vocoder": "Neural Vocoder",
-                "frequency_artifacts": (5000, 7000),
-                "phase_coherence_threshold": 0.82,
-                "spectral_tilt_range": (-2.5, -0.5),
-            },
-            "google_wavenet": {
-                "name": "Google WaveNet/Neural2",
-                "vocoder": "WaveNet",
-                "frequency_artifacts": (6500, 9000),
-                "phase_coherence_threshold": 0.78,
-                "spectral_tilt_range": (-2, 0.5),
-            }
-        }
-    
-    def _load_audio(self, audio_path: str) -> np.ndarray:
-        """Load audio file and return numpy array with MP3 support"""
-        # Use audio_utils which supports MP3 via soundfile
-        samples, sr = load_audio(audio_path, target_sr=self.sample_rate)
-        return samples
-    
-    def _compute_stft(self, audio: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-        """Compute Short-Time Fourier Transform"""
-        nperseg = 1024
-        noverlap = nperseg // 2
-        
-        frequencies, times, Zxx = signal.stft(
-            audio, 
-            fs=self.sample_rate,
-            nperseg=nperseg,
-            noverlap=noverlap
-        )
-        
-        return frequencies, times, Zxx
-    
-    def _analyze_frequency_artifacts(self, frequencies: np.ndarray, Zxx: np.ndarray) -> Dict:
-        """Analyze frequency-domain artifacts typical of neural vocoders"""
-        magnitude = np.abs(Zxx)
-        phase = np.angle(Zxx)
-        
-        analysis = {}
-        
-        # Analyze different frequency bands
-        for band_name, (low_hz, high_hz) in [
-            ("low", (0, 2000)),
-            ("mid", (2000, 5000)),
-            ("high", (5000, 8000)),
-            ("very_high", (8000, self.sample_rate // 2))
-        ]:
-            mask = (frequencies >= low_hz) & (frequencies < high_hz)
-            if mask.any():
-                band_mag = magnitude[mask, :]
-                analysis[f"{band_name}_band_energy"] = float(np.mean(band_mag))
-                analysis[f"{band_name}_band_std"] = float(np.std(band_mag))
-        
-        # Check for vocoder-specific artifacts in 6-8kHz range
-        vocoder_mask = (frequencies >= 6000) & (frequencies <= 8000)
-        if vocoder_mask.any():
-            vocoder_band = magnitude[vocoder_mask, :]
-            
-            # Neural vocoders often show unnaturally consistent energy in this band
-            analysis["vocoder_band_consistency"] = float(
-                1.0 - (np.std(vocoder_band.mean(axis=0)) / (np.mean(vocoder_band) + 1e-8))
-            )
-            
-            # Check for periodic patterns (grid artifacts)
-            fft_of_band = np.abs(fft(vocoder_band.mean(axis=0)))
-            analysis["vocoder_periodicity"] = float(
-                np.max(fft_of_band[1:20]) / (np.mean(fft_of_band) + 1e-8)
-            )
-        else:
-            analysis["vocoder_band_consistency"] = 0.0
-            analysis["vocoder_periodicity"] = 0.0
-        
-        return analysis
-    
-    def _analyze_phase_coherence(self, Zxx: np.ndarray) -> Dict:
-        """
-        Analyze phase coherence patterns.
-        AI-generated audio often shows higher phase coherence due to deterministic synthesis.
-        """
-        phase = np.angle(Zxx)
-        
-        # Compute phase difference between adjacent frames
-        phase_diff = np.diff(phase, axis=1)
-        
-        # Unwrap phase differences
-        phase_diff = np.mod(phase_diff + np.pi, 2 * np.pi) - np.pi
-        
-        analysis = {
-            "phase_coherence": float(1.0 - np.std(phase_diff)),
-            "phase_consistency": float(np.mean(np.abs(phase_diff) < 0.5)),
-            "phase_periodicity": float(
-                np.corrcoef(phase_diff[:, :-1].flatten(), phase_diff[:, 1:].flatten())[0, 1]
-                if phase_diff.shape[1] > 1 else 0
-            )
-        }
-        
-        return analysis
-    
-    def _compute_spectral_tilt(self, frequencies: np.ndarray, magnitude: np.ndarray) -> float:
-        """
-        Compute spectral tilt (slope of spectral envelope).
-        AI voices often have different spectral tilt than natural voices.
-        """
-        # Use frequencies up to 8kHz
-        mask = frequencies <= 8000
-        freqs = frequencies[mask]
-        mags = magnitude[mask, :].mean(axis=1)
-        
-        if len(freqs) < 2:
-            return 0.0
-        
-        # Log-log regression for spectral tilt
-        log_freqs = np.log(freqs + 1)
-        log_mags = np.log(mags + 1e-8)
-        
-        # Simple linear regression
-        slope = np.polyfit(log_freqs, log_mags, 1)[0]
-        
-        return float(slope)
-    
-    def _match_signatures(self, freq_analysis: Dict, phase_analysis: Dict, spectral_tilt: float) -> List[Dict]:
-        """Match analysis results against known AI tool signatures"""
-        matches = []
-        
-        for tool_id, sig in self.signatures.items():
-            score = 0.0
-            reasons = []
-            
-            # Check phase coherence
-            if phase_analysis["phase_coherence"] >= sig["phase_coherence_threshold"]:
-                score += 0.3
-                reasons.append(f"Phase coherence matches {sig['vocoder']} pattern")
-            
-            # Check spectral tilt
-            tilt_low, tilt_high = sig["spectral_tilt_range"]
-            if tilt_low <= spectral_tilt <= tilt_high:
-                score += 0.25
-                reasons.append("Spectral tilt consistent with synthesis")
-            
-            # Check vocoder band artifacts
-            if freq_analysis["vocoder_band_consistency"] > 0.7:
-                score += 0.25
-                reasons.append("Vocoder frequency artifacts detected")
-            
-            # Check periodicity (neural vocoder grid)
-            if freq_analysis["vocoder_periodicity"] > 1.5:
-                score += 0.2
-                reasons.append("Periodic synthesis patterns found")
-            
-            if score > 0.4:  # Threshold for reporting
-                matches.append({
-                    "tool_id": tool_id,
-                    "tool_name": sig["name"],
-                    "confidence": score,
-                    "reasons": reasons
-                })
-        
-        # Sort by confidence
-        matches.sort(key=lambda x: x["confidence"], reverse=True)
-        
-        return matches
-    
-    def detect(self, audio_path: str) -> Dict:
-        """
-        Detect AI voice synthesis tool signatures.
-        
-        Args:
-            audio_path: Path to audio file
-            
-        Returns:
-            Dictionary with detection results including matched tools
-        """
-        audio = self._load_audio(audio_path)
-        
-        frequencies, times, Zxx = self._compute_stft(audio)
-        magnitude = np.abs(Zxx)
-        
-        freq_analysis = self._analyze_frequency_artifacts(frequencies, Zxx)
-        
-        phase_analysis = self._analyze_phase_coherence(Zxx)
-        
-        spectral_tilt = self._compute_spectral_tilt(frequencies, magnitude)
-        
-        matched_tools = self._match_signatures(freq_analysis, phase_analysis, spectral_tilt)
-        
-        is_ai = len(matched_tools) > 0 and matched_tools[0]["confidence"] > 0.5
-        
-        ai_probability = max([m["confidence"] for m in matched_tools]) if matched_tools else 0.2
-        
-        result = {
-            "classification": "ai_generated" if is_ai else "human",
-            "confidence": ai_probability if is_ai else (1 - ai_probability),
-            "model_scores": {
-                "ai_probability": ai_probability,
-                "human_probability": 1 - ai_probability
-            },
-            "detected_tools": matched_tools[:3] if matched_tools else [],
-            "primary_tool": matched_tools[0]["tool_name"] if matched_tools else None,
-            "frequency_analysis": freq_analysis,
-            "phase_analysis": phase_analysis,
-            "spectral_tilt": spectral_tilt,
-            "indicators": self._generate_indicators(is_ai, matched_tools, freq_analysis, phase_analysis)
-        }
-        
-        return result
-    
-    def _generate_indicators(
-        self, 
-        is_ai: bool, 
-        matched_tools: List[Dict],
-        freq_analysis: Dict,
-        phase_analysis: Dict
-    ) -> List[str]:
-        """Generate human-readable indicators"""
-        indicators = []
-        
-        if is_ai and matched_tools:
-            top_match = matched_tools[0]
-            indicators.append(f"Signature matches {top_match['tool_name']} ({top_match['confidence']:.0%} confidence)")
-            indicators.extend(top_match["reasons"][:2])
-        elif is_ai:
-            if phase_analysis["phase_coherence"] > 0.7:
-                indicators.append("Unusually high phase coherence suggesting deterministic synthesis")
-            if freq_analysis["vocoder_band_consistency"] > 0.6:
-                indicators.append("Vocoder artifacts detected in 6-8kHz band")
-        else:
-            indicators.append("No known AI synthesis tool signatures detected")
-            if phase_analysis["phase_coherence"] < 0.6:
-                indicators.append("Phase patterns consistent with natural recording")
-        
-        return indicators

app/models/spectrogram_cnn.py

@@ -1,349 +0,0 @@
-"""
-Mel Spectrogram CNN Classifier for Voice Deepfake Detection
-
-Uses CNN to analyze mel spectrograms for visual artifacts
-indicative of AI-generated speech (vocoder patterns, unnatural harmonics).
-"""
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import numpy as np
-import torchaudio
-import torchaudio.transforms as T
-from typing import Dict, Tuple, Optional
-import logging
-
-logger = logging.getLogger(__name__)
-
-# Import audio utilities for MP3 support
-from ..audio_utils import load_audio_torch, extract_advanced_features
-
-
-class SpectrogramCNN(nn.Module):
-    """
-    CNN architecture for analyzing mel spectrograms.
-    Inspired by ResNet but optimized for audio deepfake detection.
-    """
-    
-    def __init__(self, num_classes: int = 2):
-        super().__init__()
-        
-        # Initial convolution
-        self.conv1 = nn.Sequential(
-            nn.Conv2d(1, 32, kernel_size=7, stride=2, padding=3),
-            nn.BatchNorm2d(32),
-            nn.ReLU(),
-            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        )
-        
-        # Residual-style blocks
-        self.block1 = self._make_block(32, 64)
-        self.block2 = self._make_block(64, 128)
-        self.block3 = self._make_block(128, 256)
-        
-        # Attention mechanism for focusing on relevant frequency bands
-        self.attention = nn.Sequential(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Flatten(),
-            nn.Linear(256, 64),
-            nn.ReLU(),
-            nn.Linear(64, 256),
-            nn.Sigmoid()
-        )
-        
-        # Global pooling and classifier
-        self.global_pool = nn.AdaptiveAvgPool2d(1)
-        self.classifier = nn.Sequential(
-            nn.Flatten(),
-            nn.Dropout(0.3),
-            nn.Linear(256, 128),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(128, num_classes)
-        )
-        
-        self._initialize_weights()
-    
-    def _make_block(self, in_channels: int, out_channels: int) -> nn.Module:
-        """Create a convolutional block with skip connection"""
-        return nn.Sequential(
-            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU(),
-            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
-            nn.BatchNorm2d(out_channels),
-            nn.ReLU()
-        )
-    
-    def _initialize_weights(self):
-        """Initialize weights with Xavier uniform"""
-        for module in self.modules():
-            if isinstance(module, nn.Conv2d):
-                nn.init.kaiming_normal_(module.weight, mode='fan_out', nonlinearity='relu')
-            elif isinstance(module, nn.BatchNorm2d):
-                nn.init.constant_(module.weight, 1)
-                nn.init.constant_(module.bias, 0)
-            elif isinstance(module, nn.Linear):
-                nn.init.xavier_uniform_(module.weight)
-                if module.bias is not None:
-                    nn.init.zeros_(module.bias)
-    
-    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        """
-        Forward pass returning logits and attention weights.
-        
-        Args:
-            x: Input mel spectrogram [B, 1, H, W]
-            
-        Returns:
-            logits: Classification logits [B, 2]
-            attention_weights: Frequency attention weights [B, 256]
-        """
-        # Feature extraction
-        x = self.conv1(x)
-        x = self.block1(x)
-        x = self.block2(x)
-        x = self.block3(x)
-        
-        # Attention
-        attn = self.attention(x)
-        x = x * attn.unsqueeze(-1).unsqueeze(-1)
-        
-        # Classification
-        x = self.global_pool(x)
-        logits = self.classifier(x)
-        
-        return logits, attn
-
-
-class SpectrogramDetector:
-    """
-    Mel Spectrogram-based detector for AI-generated voice detection.
-    
-    Converts audio to mel spectrograms and uses CNN to detect
-    visual patterns indicative of neural vocoders.
-    """
-    
-    def __init__(self, device: str = None):
-        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
-        
-        logger.info(f"[SpectrogramDetector] Using device: {self.device}")
-        
-        # Initialize CNN model
-        self.model = SpectrogramCNN(num_classes=2)
-        self.model.to(self.device)
-        self.model.eval()
-        
-        # Mel spectrogram parameters
-        self.sample_rate = 16000
-        self.n_mels = 128
-        self.n_fft = 1024
-        self.hop_length = 256
-        self.target_length = 128  # Fixed width for CNN input
-        
-        # Mel transform
-        self.mel_transform = T.MelSpectrogram(
-            sample_rate=self.sample_rate,
-            n_fft=self.n_fft,
-            hop_length=self.hop_length,
-            n_mels=self.n_mels
-        )
-        
-        self.resampler_cache = {}
-    
-    def _load_audio(self, audio_path: str) -> torch.Tensor:
-        """Load and resample audio with MP3 support"""
-        # Use audio_utils which supports MP3 via soundfile
-        waveform = load_audio_torch(audio_path, target_sr=self.sample_rate)
-        return waveform.unsqueeze(0)  # Add channel dim
-    
-    def _create_mel_spectrogram(self, waveform: torch.Tensor) -> torch.Tensor:
-        """Convert waveform to normalized mel spectrogram"""
-        # Compute mel spectrogram
-        mel_spec = self.mel_transform(waveform)
-        
-        # Convert to log scale (dB)
-        mel_spec = torch.log(mel_spec + 1e-9)
-        
-        # Normalize
-        mel_spec = (mel_spec - mel_spec.mean()) / (mel_spec.std() + 1e-8)
-        
-        # Resize to fixed width
-        if mel_spec.shape[-1] != self.target_length:
-            mel_spec = F.interpolate(
-                mel_spec.unsqueeze(0),
-                size=(self.n_mels, self.target_length),
-                mode='bilinear',
-                align_corners=False
-            ).squeeze(0)
-        
-        return mel_spec
-    
-    def _analyze_spectrogram(self, mel_spec: torch.Tensor) -> Dict:
-        """Analyze spectrogram for AI-typical patterns"""
-        spec = mel_spec.squeeze().numpy()
-        
-        analysis = {}
-        
-        # Check for unnaturally smooth regions
-        gradient = np.gradient(spec, axis=1)
-        analysis["temporal_smoothness"] = float(1.0 / (np.std(gradient) + 1e-8))
-        
-        # Check frequency band energy distribution
-        low_band = spec[:32, :].mean()
-        mid_band = spec[32:96, :].mean()
-        high_band = spec[96:, :].mean()
-        
-        analysis["low_band_energy"] = float(low_band)
-        analysis["mid_band_energy"] = float(mid_band)  
-        analysis["high_band_energy"] = float(high_band)
-        
-        # Check for vocoder grid patterns (common in neural TTS)
-        fft_spec = np.abs(np.fft.fft2(spec))
-        analysis["periodicity_score"] = float(fft_spec[1:10, 1:10].mean() / fft_spec.mean())
-        
-        # Harmonic-to-noise ratio approximation
-        sorted_spec = np.sort(spec.flatten())[::-1]
-        top_10_pct = sorted_spec[:int(len(sorted_spec) * 0.1)].mean()
-        bottom_50_pct = sorted_spec[int(len(sorted_spec) * 0.5):].mean()
-        analysis["hnr_approx"] = float(top_10_pct / (bottom_50_pct + 1e-8))
-        
-        return analysis
-    
-    def detect(self, audio_path: str) -> Dict:
-        """
-        Detect if audio is AI-generated using spectrogram analysis.
-        
-        Args:
-            audio_path: Path to audio file
-            
-        Returns:
-            Dictionary with detection results
-        """
-        waveform = self._load_audio(audio_path)
-        mel_spec = self._create_mel_spectrogram(waveform)
-        
-        spec_analysis = self._analyze_spectrogram(mel_spec)
-        
-        spec_analysis['energy_cv'] = self._compute_energy_cv(waveform)
-        
-        adv_features = extract_advanced_features(audio_path, self.sample_rate)
-        spec_analysis.update(adv_features)
-        
-        ai_score = self._compute_ai_score_from_spectrogram(spec_analysis)
-        
-        ai_score = max(0.0, min(1.0, ai_score))
-        
-        is_ai = ai_score >= 0.5
-        confidence = abs(ai_score - 0.5) * 2
-        
-        result = {
-            "classification": "ai_generated" if is_ai else "human",
-            "confidence": confidence,
-            "model_scores": {
-                "ai_probability": ai_score,
-                "human_probability": 1 - ai_score
-            },
-            "spectrogram_analysis": spec_analysis,
-            "frequency_attention": [],
-            "indicators": self._generate_indicators(1 if is_ai else 0, spec_analysis)
-        }
-        
-        return result
-        
-    def _compute_energy_cv(self, waveform: torch.Tensor) -> float:
-        """Compute Coefficient of Variation of energy"""
-        if waveform.dim() > 1:
-            waveform = waveform.squeeze()
-            
-        chunk_size = len(waveform) // 10
-        if chunk_size == 0: return 0.0
-        
-        energies = []
-        for i in range(10):
-            chunk = waveform[i*chunk_size:(i+1)*chunk_size]
-            energies.append(float(torch.sqrt(torch.mean(chunk ** 2))))
-            
-        energy_std = np.std(energies) if energies else 0
-        energy_mean = np.mean(energies) if energies else 1
-        return float(energy_std / (energy_mean + 1e-8))
-    
-    def _compute_ai_score_from_spectrogram(self, analysis: Dict) -> float:
-        """
-        Compute AI probability from spectrogram analysis.
-        
-        AI-generated voices typically have:
-        - Higher temporal smoothness (consistent spectrum)
-        - Low energy variation (consistent volume, less natural pausing)
-        - Specific band energy distributions
-        """
-        score = 0.5  # Start neutral
-        
-        # 1. Energy CV - STRONGEST INDICATOR (prioritize this)
-        # High variation (>0.5) is very typical of human speech (pauses/breathing)
-        # Low variation (<0.2) is typical of AI
-        energy_cv = analysis.get("energy_cv", 0.25)
-        if energy_cv > 0.7:
-            score -= 0.30  # Very strong human signal
-        elif energy_cv > 0.5:
-            score -= 0.20  # Strong human signal
-        elif energy_cv > 0.35:
-            score -= 0.10  # Moderate human signal
-        elif energy_cv < 0.2:
-            score += 0.10  # Consistent energy = AI like
-        
-        # 2. Advanced Features
-        flux = analysis.get("spectral_flux", 0)
-        mfcc_var = analysis.get("mfcc_variance", 0)
-        
-        # Flux Heuristic - widened threshold
-        if flux > 2.4:
-            score += 0.20  # Strong AI signal
-        elif flux > 2.0:
-            score += 0.10  # Moderate AI signal
-        elif flux < 1.8 and flux > 0.1:
-            score -= 0.10  # Natural human transitions
-            
-        # MFCC Var Heuristic
-        if mfcc_var > 1900:
-            score -= 0.20  # High complexity = human
-        
-        # 3. Temporal smoothness (de-prioritized - often misleading)
-        # Only use extreme values
-        smoothness = analysis.get("temporal_smoothness", 1.0)
-        if smoothness > 5.0:
-            score += 0.10  # Very unnaturally smooth
-        
-        # Additional features removed as unreliable for edge cases
-        # (periodicity, high_band, hnr can cause false positives on clean recordings)
-        
-        return score
-    
-    
-    def _generate_indicators(self, pred_class: int, analysis: Dict) -> list:
-        """Generate human-readable indicators"""
-        indicators = []
-        
-        if pred_class == 1:  # AI detected
-            if analysis["temporal_smoothness"] > 5:
-                indicators.append("Unnaturally smooth spectrogram transitions")
-            
-            if analysis["periodicity_score"] > 2:
-                indicators.append("Periodic patterns suggesting neural vocoder")
-            
-            if analysis["high_band_energy"] < -2:
-                indicators.append("Reduced high-frequency content typical of TTS")
-                
-            if not indicators:
-                indicators.append("Spectrogram patterns consistent with AI synthesis")
-        else:  # Human
-            if analysis["hnr_approx"] > 10:
-                indicators.append("Strong harmonic structure of natural voice")
-            
-            if analysis["temporal_smoothness"] < 3:
-                indicators.append("Natural variation in spectral features")
-                
-            if not indicators:
-                indicators.append("Spectrogram shows natural speech characteristics")
-        
-        return indicators

app/models/wav2vec_detector.py

@@ -1,338 +0,0 @@
-"""
-Wav2Vec2-based Voice Detector for Indian Languages
-
-Uses IndicWav2Vec/XLSR models to detect AI-generated speech by analyzing
-deep acoustic representations learned from raw waveforms.
-"""
-import torch
-import torch.nn as nn
-import numpy as np
-from typing import Dict, Tuple, Optional
-from transformers import AutoModel, AutoProcessor
-import torchaudio
-import torchaudio.transforms as T
-import librosa
-import numpy as np
-import logging
-
-logger = logging.getLogger(__name__)
-
-# Import audio utilities for MP3 support
-from ..audio_utils import load_audio_torch, extract_advanced_features
-
-
-class Wav2VecClassificationHead(nn.Module):
-    """Classification head for deepfake detection on top of Wav2Vec2"""
-    
-    def __init__(self, hidden_size: int = 768, num_classes: int = 2):
-        super().__init__()
-        self.classifier = nn.Sequential(
-            nn.Linear(hidden_size, 512),
-            nn.ReLU(),
-            nn.Dropout(0.3),
-            nn.Linear(512, 256),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(256, num_classes)
-        )
-        
-    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        # Pool over time dimension (mean pooling)
-        pooled = hidden_states.mean(dim=1)
-        return self.classifier(pooled)
-
-
-class Wav2VecDetector:
-    """
-    Wav2Vec2-based detector for AI-generated voice detection.
-    
-    Uses pretrained Wav2Vec2 models (IndicWav2Vec for Indian languages)
-    with a fine-tuned classification head for deepfake detection.
-    """
-    
-    def __init__(self, model_name: str = "facebook/wav2vec2-base", device: str = None):
-        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
-        self.model_name = model_name
-        
-        logger.info(f"[Wav2VecDetector] Loading model: {model_name}")
-        logger.info(f"[Wav2VecDetector] Using device: {self.device}")
-        
-        # Load pretrained Wav2Vec2 model
-        self.processor = AutoProcessor.from_pretrained(model_name)
-        self.wav2vec = AutoModel.from_pretrained(model_name)
-        self.wav2vec.to(self.device)
-        self.wav2vec.eval()
-        
-        # Initialize classification head
-        hidden_size = getattr(self.wav2vec.config, 'hidden_size', 768)
-        self.classifier = Wav2VecClassificationHead(hidden_size=hidden_size)
-        self.classifier.to(self.device)
-        
-        # Initialize with pretrained-like weights for demo
-        # In production, load fine-tuned weights
-        self._initialize_classifier_weights()
-        
-        self.sample_rate = 16000
-        self.resampler_cache = {}
-        
-    def _initialize_classifier_weights(self):
-        """Initialize classifier with reasonable default weights"""
-        for module in self.classifier.modules():
-            if isinstance(module, nn.Linear):
-                nn.init.xavier_uniform_(module.weight)
-                if module.bias is not None:
-                    nn.init.zeros_(module.bias)
-    
-    def _load_audio(self, audio_path: str) -> torch.Tensor:
-        """Load and preprocess audio file with MP3 support"""
-        # Use audio_utils which supports MP3 via soundfile
-        waveform = load_audio_torch(audio_path, target_sr=self.sample_rate)
-        return waveform
-    
-    def _extract_features(self, waveform: torch.Tensor) -> Dict[str, np.ndarray]:
-        """Extract acoustic features for analysis"""
-        features = {}
-        
-        # Compute energy
-        features["energy"] = float(torch.sqrt(torch.mean(waveform ** 2)))
-        
-        # Compute zero crossing rate
-        signs = torch.sign(waveform)
-        sign_changes = torch.abs(signs[1:] - signs[:-1])
-        features["zero_crossing_rate"] = float(sign_changes.mean())
-        
-        # Compute spectral features using STFT
-        n_fft = 1024
-        hop_length = 256
-        
-        stft = torch.stft(
-            waveform, 
-            n_fft=n_fft, 
-            hop_length=hop_length,
-            return_complex=True
-        )
-        magnitude = torch.abs(stft)
-        
-        # Spectral centroid (simplified)
-        freqs = torch.linspace(0, self.sample_rate / 2, magnitude.shape[0])
-        centroid = (freqs.unsqueeze(1) * magnitude).sum(dim=0) / (magnitude.sum(dim=0) + 1e-8)
-        features["spectral_centroid_mean"] = float(centroid.mean())
-        features["spectral_centroid_std"] = float(centroid.std())
-        
-        # Spectral flatness (measure of noise-like vs tonal)
-        geometric_mean = torch.exp(torch.log(magnitude + 1e-8).mean(dim=0))
-        arithmetic_mean = magnitude.mean(dim=0)
-        flatness = geometric_mean / (arithmetic_mean + 1e-8)
-        features["spectral_flatness"] = float(flatness.mean())
-        
-        return features
-    
-    def detect(self, audio_path: str) -> Dict:
-        """
-        Detect if audio is AI-generated or human.
-        
-        Args:
-            audio_path: Path to audio file
-            
-        Returns:
-            Dictionary with detection results
-        """
-        waveform = self._load_audio(audio_path)
-        
-        acoustic_features = self._extract_features(waveform)
-        
-        ai_score = self._compute_ai_score_from_acoustics(acoustic_features, waveform, audio_path)
-        
-        with torch.no_grad():
-            inputs = self.processor(
-                waveform.numpy(), 
-                sampling_rate=self.sample_rate,
-                return_tensors="pt",
-                padding=True
-            )
-            inputs = {k: v.to(self.device) for k, v in inputs.items()}
-            
-            # Get hidden states from Wav2Vec2
-            outputs = self.wav2vec(**inputs)
-            hidden_states = outputs.last_hidden_state
-        
-        # Analyze hidden state statistics
-        hidden_stats = self._analyze_hidden_states(hidden_states)
-        
-        # Add hidden state analysis to AI score
-        ai_score = self._adjust_score_with_hidden_states(ai_score, hidden_stats)
-        
-        # Clamp to 0-1
-        ai_score = max(0.0, min(1.0, ai_score))
-        
-        is_ai = ai_score >= 0.5
-        confidence = abs(ai_score - 0.5) * 2  # Scale distance from threshold
-        
-        result = {
-            "classification": "ai_generated" if is_ai else "human",
-            "confidence": confidence,
-            "model_scores": {
-                "ai_probability": ai_score,
-                "human_probability": 1 - ai_score
-            },
-            "acoustic_features": acoustic_features,
-            "hidden_state_analysis": hidden_stats,
-            "indicators": self._generate_indicators(1 if is_ai else 0, acoustic_features, hidden_stats)
-        }
-        
-        return result
-    
-
-    def _compute_ai_score_from_acoustics(self, features: Dict, waveform: torch.Tensor, audio_path: str = None) -> float:
-        """
-        Compute AI probability score using acoustic heuristics.
-        
-        Prioritized features:
-        1. Energy CV - strongest human indicator (pauses/breathing)
-        2. MFCC Variance - timbral complexity
-        3. Spectral Flux - vocoder artifacts
-        4. Flatness - synthesis noise
-        """
-        score = 0.5  # Start neutral
-        
-        # 1. Energy CV - STRONGEST INDICATOR (compute first)
-        chunk_size = len(waveform) // 10
-        energy_cv = 0.25
-        if chunk_size > 0:
-            energies = []
-            for i in range(10):
-                chunk = waveform[i*chunk_size:(i+1)*chunk_size]
-                energies.append(float(torch.sqrt(torch.mean(chunk ** 2))))
-            energy_cv = np.std(energies) / (np.mean(energies) + 1e-8)
-            
-            if energy_cv > 0.7:
-                score -= 0.30  # Very strong human signal
-            elif energy_cv > 0.5:
-                score -= 0.20  # Strong human signal
-            elif energy_cv > 0.35:
-                score -= 0.10  # Moderate human signal
-            elif energy_cv < 0.2:
-                score += 0.10  # Consistent AI
-        
-        # 2. Advanced Features (Librosa)
-        adv_features = {"spectral_flux": 0, "mfcc_variance": 0}
-        if audio_path:
-            adv_features = extract_advanced_features(audio_path, self.sample_rate)
-            
-        flux = adv_features["spectral_flux"]
-        mfcc_var = adv_features["mfcc_variance"]
-        
-        # MFCC Variance Heuristic
-        if mfcc_var > 1900:
-            score -= 0.25  # High complexity -> Human
-        
-        # Spectral Flux Heuristic - widened thresholds
-        if flux > 2.4:
-            score += 0.20  # Strong AI
-        elif flux > 2.0:
-            score += 0.10  # Moderate AI
-        elif flux < 1.8 and flux > 0.1:
-            score -= 0.10  # Human transitions
-        
-        # 3. Spectral flatness (secondary)
-        flatness = features.get("spectral_flatness", 0.25)
-        if flatness > 0.38:
-            score += 0.12  # High noise = AI
-        elif flatness < 0.22:
-            score -= 0.08  # Clean harmonic = Human
-            
-        return score
-    
-    
-    def _adjust_score_with_hidden_states(self, score: float, hidden_stats: Dict) -> float:
-        """Adjust AI score based on Wav2Vec2 hidden state analysis"""
-        
-        # Temporal variance: Lower variance often indicates synthetic speech
-        temp_var = hidden_stats.get("temporal_variance", 0.1)
-        if temp_var < 0.05:
-            score += 0.08
-        elif temp_var > 0.2:
-            score -= 0.08
-        
-        # Activation sparsity: AI voices may have different sparsity patterns
-        sparsity = hidden_stats.get("activation_sparsity", 0.5)
-        if sparsity > 0.7 or sparsity < 0.2:
-            score += 0.05  # Unusual sparsity pattern
-        
-        return score
-    
-    
-    def _analyze_hidden_states(self, hidden_states: torch.Tensor) -> Dict:
-        """Analyze hidden state patterns for explainability"""
-        hs = hidden_states.squeeze(0)  # Remove batch dim
-        
-        stats = {
-            "temporal_variance": float(hs.var(dim=0).mean()),
-            "feature_variance": float(hs.var(dim=1).mean()),
-            "activation_sparsity": float((hs.abs() < 0.1).float().mean()),
-            "mean_activation": float(hs.mean()),
-            "max_activation": float(hs.max()),
-        }
-        
-        return stats
-    
-    def _generate_indicators(
-        self, 
-        pred_class: int, 
-        acoustic: Dict, 
-        hidden_stats: Dict
-    ) -> list:
-        """Generate human-readable indicators for the detection"""
-        indicators = []
-        
-        if pred_class == 1:  # AI detected
-            # Check for AI-typical patterns
-            if acoustic["spectral_flatness"] > 0.3:
-                indicators.append("Unusually smooth spectral distribution typical of neural vocoders")
-            
-            if hidden_stats["temporal_variance"] < 0.1:
-                indicators.append("Low temporal variation suggesting synthetic generation")
-            
-            if acoustic["spectral_centroid_std"] < 500:
-                indicators.append("Consistent spectral characteristics unlike natural speech variation")
-                
-            if not indicators:
-                indicators.append("Deep acoustic patterns suggest synthetic generation")
-        else:  # Human detected
-            if acoustic["spectral_flatness"] < 0.2:
-                indicators.append("Natural harmonic structure consistent with human voice")
-            
-            if hidden_stats["temporal_variance"] > 0.15:
-                indicators.append("High temporal variation typical of natural speech")
-                
-            if not indicators:
-                indicators.append("Acoustic patterns consistent with natural human speech")
-        
-        return indicators
-
-
-class IndicWav2VecDetector(Wav2VecDetector):
-    """
-    Specialized detector using IndicWav2Vec for Indian languages.
-    Inherits from Wav2VecDetector with Indian language optimizations.
-    """
-    
-    INDIC_MODELS = {
-        "hi": "ai4bharat/indicwav2vec-hindi",
-        "ta": "ai4bharat/indicwav2vec_v1_tamil", 
-        "te": "ai4bharat/indicwav2vec_v1_telugu",
-        "ml": "ai4bharat/indicwav2vec_v1_malayalam",
-        "en": "facebook/wav2vec2-base"  # English fallback
-    }
-    
-    def __init__(self, language: str = "hi", device: str = None):
-        # Select model based on language
-        model_name = self.INDIC_MODELS.get(language, "facebook/wav2vec2-base")
-        
-        try:
-            super().__init__(model_name=model_name, device=device)
-            self.language = language
-        except Exception as e:
-            print(f"[IndicWav2VecDetector] Failed to load {model_name}, falling back to base model")
-            super().__init__(model_name="facebook/wav2vec2-base", device=device)
-            self.language = "en"

build.sh

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# exit on error
-set -o errexit
-pip install --upgrade pip
-pip install -r requirements.txt

deployment.md

@@ -1,71 +0,0 @@
-# 🌍 Deployment Guide: Exposing Your API
-
-Since you have the code running locally on your machine, the fastest way to make it accessible to the world (and link it to your domain) is using a **Tunnel**.
-
-## Option A: Cloudflare Tunnel (Recommended for Custom Domains)
-This is free, secure, and allows you to use your own domain (e.g., `api.yourdomain.com`).
-
-### 1. Install Cloudflare Tunnel (`cloudflared`)
-Run this in PowerShell to download the verified Windows executable:
-```powershell
-# Create a folder for tools
-mkdir c:\tools
-cd c:\tools
-
-# Download cloudflared
-Invoke-WebRequest -Uri https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe -OutFile cloudflared.exe
-```
-
-### 2. Login to Cloudflare
-This connects your machine to your Cloudflare account (where your domain is managed).
-```powershell
-.\cloudflared.exe tunnel login
-```
-*   A browser window will open. Select the domain you want to use.
-
-### 3. Create a Tunnel
-```powershell
-.\cloudflared.exe tunnel create voice-api
-```
-*   Copy the **Tunnel ID** (a long UUID like `d4c3b2a1-...`) from the output.
-
-### 4. Route Your Domain to Localhost
-Replace `<UUID>` with your Tunnel ID and `api.yourdomain.com` with your desired domain.
-```powershell
-# 1. Configure the tunnel target
-# Create a config.yml file
-echo "url: http://localhost:8000" > config.yml
-echo "tunnel: <UUID>" >> config.yml
-echo "credentials-file: C:\Users\baksh\.cloudflared\<UUID>.json" >> config.yml
-
-# 2. Assign the domain DNS
-.\cloudflared.exe tunnel route dns voice-api api.yourdomain.com
-```
-
-### 5. Run it!
-```powershell
-.\cloudflared.exe tunnel run voice-api
-```
-**Success!** Your local server (`localhost:8000`) is now live at `https://api.yourdomain.com`.
-
----
-
-## Option B: Ngrok (Fastest, Random URL)
-If you don't use Cloudflare for DNS, or just want a quick link:
-
-1.  **Download Ngrok**: [https://ngrok.com/download](https://ngrok.com/download)
-2.  **Run**:
-    ```powershell
-    ngrok http 8000
-    ```
-3.  **Result**: It will give you a URL like `https://a1b2-c3d4.ngrok-free.app`. Use this in the endpoint tester.
-
----
-
-## 🔒 Important: Update Test Scripts
-Once you have your public URL, test it using the verify script:
-
-```python
-# Update verify_tester_config.py
-API_URL = "https://api.yourdomain.com/api/v1/detect" 
-```

render.yaml

@@ -1,13 +0,0 @@
-services:
-  - type: web
-    name: voice-detection-api
-    env: python
-    plan: free  # Change to 'starter' for always-on service
-    buildCommand: pip install -r requirements.txt
-    startCommand: python run.py --host 0.0.0.0 --port $PORT
-    envVars:
-      - key: PYTHON_VERSION
-        value: 3.11.0
-      - key: PORT
-        generateValue: true  # Render will auto-assign
-    healthCheckPath: /api/v1/health

requirements.txt

@@ -1,24 +0,0 @@
-# FastAPI
-fastapi>=0.109.0
-uvicorn[standard]>=0.27.0
-pydantic>=2.5.3
-python-multipart>=0.0.6
-
-# Audio Processing
-librosa>=0.10.1
-soundfile>=0.12.1
-pydub>=0.25.1
-
-# ML/DL - Core (use available versions)
-torch>=2.5.0
-torchaudio>=2.5.0
-transformers>=4.36.2
-
-# IndicWav2Vec and SpeechBrain
-speechbrain>=1.0.0
-
-# Utilities
-numpy>=1.26.0
-scipy>=1.12.0
-scikit-learn>=1.4.0
-httpx>=0.26.0

run.py

@@ -1,40 +0,0 @@
-"""
-Production Server Entry Point
-
-Run with: python run.py
-"""
-import uvicorn
-import argparse
-
-
-def main():
-    parser = argparse.ArgumentParser(description="AI Voice Detection API Server")
-    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
-    parser.add_argument("--port", type=int, default=8001, help="Port to bind to")
-    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
-    parser.add_argument("--workers", type=int, default=1, help="Number of workers")
-    
-    args = parser.parse_args()
-    
-    print(f"""
-╔══════════════════════════════════════════════════════════════╗
-║           AI Voice Detection API Server                      ║
-╠══════════════════════════════════════════════════════════════╣
-║  🚀 Starting server...                                       ║
-║  📍 URL: http://{args.host}:{args.port}                              ║
-║  📚 Docs: http://{args.host}:{args.port}/docs                        ║
-║  🔍 API: http://{args.host}:{args.port}/api/v1/detect                ║
-╚══════════════════════════════════════════════════════════════╝
-    """)
-    
-    uvicorn.run(
-        "app.main:app",
-        host=args.host,
-        port=args.port,
-        reload=args.reload,
-        workers=args.workers if not args.reload else 1
-    )
-
-
-if __name__ == "__main__":
-    main()

test_api.py

@@ -1,149 +0,0 @@
-"""
-Test script for AI Voice Detection API
-
-Usage:
-    python test_api.py <path_to_audio.mp3>
-    python test_api.py --generate-sample  # Generate test sample
-"""
-import base64
-import requests
-import json
-import sys
-import os
-
-
-API_URL = "http://localhost:8001"
-
-
-def encode_audio(file_path: str) -> str:
-    """Encode audio file to base64"""
-    with open(file_path, 'rb') as f:
-        return base64.b64encode(f.read()).decode('utf-8')
-
-
-def test_detection(audio_path: str, language: str = "en"):
-    """Test the detection endpoint"""
-    print(f"\n{'='*60}")
-    print(f"Testing AI Voice Detection")
-    print(f"{'='*60}")
-    print(f"Audio file: {audio_path}")
-    print(f"Language hint: {language}")
-    
-    # Encode audio
-    print("\n[1/3] Encoding audio to Base64...")
-    audio_base64 = encode_audio(audio_path)
-    print(f"      Encoded size: {len(audio_base64)} characters")
-    
-    # Prepare request
-    payload = {
-        "audio_base64": audio_base64,
-        "language_hint": language
-    }
-    
-    # Send request
-    print("\n[2/3] Sending request to API...")
-    try:
-        response = requests.post(
-            f"{API_URL}/api/v1/detect",
-            json=payload,
-            timeout=120  # Detection can take time
-        )
-        
-        process_time = response.headers.get('X-Process-Time', 'N/A')
-        print(f"      Response time: {process_time}s")
-        print(f"      Status code: {response.status_code}")
-        
-    except requests.exceptions.ConnectionError:
-        print("\n❌ ERROR: Could not connect to API server")
-        print("   Make sure the server is running: python run.py --reload")
-        return
-    except Exception as e:
-        print(f"\n❌ ERROR: {e}")
-        return
-    
-    # Parse response
-    print("\n[3/3] Detection Result:")
-    print(f"{'='*60}")
-    
-    if response.status_code == 200:
-        result = response.json()
-        
-        # Classification
-        classification = result['classification']
-        confidence = result['confidence']
-        emoji = "🤖" if classification == "ai_generated" else "👤"
-        
-        print(f"\nClassification: {classification.upper()}")
-        print(f"Confidence: {confidence:.1%}")
-        
-        # Explanation
-        explanation = result['explanation']
-        print("\nExplanation:")
-        for indicator in explanation.get('key_indicators', []):
-            print(f"   • {indicator}")
-        
-    else:
-        print(f"\n❌ Error: {response.status_code}")
-        print(response.json())
-
-
-def test_health():
-    """Test the health endpoint"""
-    print("\n[Health Check]")
-    try:
-        response = requests.get(f"{API_URL}/api/v1/health")
-        print(f"Status: {response.json()}")
-    except Exception as e:
-        print(f"Error: {e}")
-
-
-def create_test_sample():
-    """Create a simple test audio sample using basic sine waves"""
-    import numpy as np
-    from scipy.io import wavfile
-    
-    print("\n[Creating test audio sample]")
-    
-    # Generate 3 seconds of audio
-    sample_rate = 16000
-    duration = 3
-    t = np.linspace(0, duration, sample_rate * duration)
-    
-    # Simple speech-like signal (not real speech, just for testing)
-    signal = np.sin(2 * np.pi * 200 * t)  # Fundamental
-    signal += 0.5 * np.sin(2 * np.pi * 400 * t)  # Harmonic
-    signal += 0.3 * np.sin(2 * np.pi * 600 * t)  # Harmonic
-    signal += 0.1 * np.random.randn(len(t))  # Noise
-    
-    # Normalize
-    signal = signal / np.max(np.abs(signal)) * 0.8
-    signal = (signal * 32767).astype(np.int16)
-    
-    # Save as WAV (API will handle conversion)
-    output_path = "test_sample.wav"
-    wavfile.write(output_path, sample_rate, signal)
-    print(f"Created: {output_path}")
-    
-    return output_path
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage: python test_api.py <audio_file.mp3>")
-        print("       python test_api.py --health")
-        print("       python test_api.py --generate-sample")
-        sys.exit(1)
-    
-    if sys.argv[1] == "--health":
-        test_health()
-    elif sys.argv[1] == "--generate-sample":
-        sample_path = create_test_sample()
-        test_detection(sample_path)
-    else:
-        audio_path = sys.argv[1]
-        if not os.path.exists(audio_path):
-            print(f"Error: File not found: {audio_path}")
-            sys.exit(1)
-        
-        language = sys.argv[2] if len(sys.argv) > 2 else "en"
-        test_detection(audio_path, language)

verify_tester_config.py

@@ -1,37 +0,0 @@
-import requests
-import json
-import sys
-
-API_URL = "http://localhost:8000/api/v1/detect"
-SAMPLE_AUDIO_URL = "https://www2.cs.uic.edu/~i101/SoundFiles/CantinaBand3.wav"  # Public domain sample
-
-def test_url_detection():
-    print(f"\nTesting URL Detection with: {SAMPLE_AUDIO_URL}")
-    
-    payload = {
-        "audio_url": SAMPLE_AUDIO_URL,
-        "language_hint": "en"
-    }
-    
-    headers = {
-        "X-API-Key": "hackathon_secret_key"
-    }
-    
-    try:
-        response = requests.post(API_URL, json=payload, headers=headers)
-        
-        if response.status_code == 200:
-            print("✅ URL Detection Success!")
-            result = response.json()
-            print(f"   Classification: {result['classification']}")
-            print(f"   Confidence: {result['confidence']:.2%}")
-        else:
-            print(f"❌ Failed: {response.status_code}")
-            print(response.text)
-            
-    except Exception as e:
-        print(f"❌ Error: {str(e)}")
-
-if __name__ == "__main__":
-    print("=== Verifying Hackathon Tester Configuration ===")
-    test_url_detection()