Automated backend deployment from GitHub Actions

.env.example

@@ -0,0 +1,14 @@
+# Server Configuration
+API_HOST=0.0.0.0
+API_PORT=8000
+DEBUG=true
+
+# CORS
+CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000
+
+# Model Configuration (future)
+MODEL_PATH=../models/
+MODEL_NAME=echoguard_v1
+
+# Database (future)
+# DATABASE_URL=sqlite:///./echoguard.db

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create a non-root user for Hugging Face Spaces security
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copy application code
+COPY --chown=user . $HOME/app
+
+# Expose port (Hugging Face Spaces default is 7860)
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,12 @@
+---
+title: EchoGuard Backend API
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---
+
+# EchoGuard Backend API
+
+This is the deep learning backend for the EchoGuard application.
+It processes audio files to detect deepfakes using Wav2Vec2 models and DSP forensics.

app/__init__.py

@@ -0,0 +1 @@
+# EchoGuard Backend

app/config.py

@@ -0,0 +1,32 @@
+import os
+
+from pydantic_settings import BaseSettings
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    api_host: str = "0.0.0.0"
+    api_port: int = 8000
+    debug: bool = True
+    cors_origins: str = "*"
+    model_path: str = "../models/"
+    model_name: str = "echoguard_v1"
+
+    # Upload limits
+    max_file_size_mb: int = 30
+    max_duration_seconds: int = 300  # 5 minutes
+
+    # Storage
+    upload_dir: str = "./uploads"
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+        protected_namespaces = ("settings_",)
+
+
+settings = Settings()

app/exceptions.py

@@ -0,0 +1,45 @@
+"""Custom exception classes for the EchoGuard API."""
+
+from fastapi import HTTPException, status
+
+
+class FileTooLargeError(HTTPException):
+    """Raised when uploaded file exceeds the maximum size limit."""
+
+    def __init__(self, file_size_mb: float, max_size_mb: int):
+        super().__init__(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f"File size ({file_size_mb:.1f} MB) exceeds maximum allowed size ({max_size_mb} MB).",
+        )
+
+
+class InvalidFileTypeError(HTTPException):
+    """Raised when uploaded file has an unsupported format."""
+
+    def __init__(self, file_type: str, allowed_types: list[str]):
+        super().__init__(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            detail=f"File type '{file_type}' is not supported. Allowed types: {', '.join(allowed_types)}.",
+        )
+
+
+class AudioTooLongError(HTTPException):
+    """Raised when audio duration exceeds the maximum limit."""
+
+    def __init__(self, duration_seconds: float, max_seconds: int):
+        max_minutes = max_seconds / 60
+        duration_minutes = duration_seconds / 60
+        super().__init__(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Audio duration ({duration_minutes:.1f} min) exceeds maximum allowed duration ({max_minutes:.0f} min).",
+        )
+
+
+class AudioProcessingError(HTTPException):
+    """Raised when audio file cannot be read or processed."""
+
+    def __init__(self, reason: str = "Unknown error"):
+        super().__init__(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Failed to process audio file: {reason}",
+        )

app/main.py

@@ -0,0 +1,144 @@
+"""EchoGuard API — FastAPI application entry point."""
+
+import time
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+
+from app.config import settings
+from app.routers import analysis
+
+logger = logging.getLogger(__name__)
+
+_startup_time = time.time()
+
+from app.state import model_info
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    model_info.status = "loading"
+    
+    try:
+        from transformers import AutoModelForAudioClassification, AutoFeatureExtractor
+        
+        model_name_gary = "garystafford/wav2vec2-deepfake-voice-detector"
+        model_info.gary_feature_extractor = AutoFeatureExtractor.from_pretrained(model_name_gary)
+        model_info.gary_model = AutoModelForAudioClassification.from_pretrained(model_name_gary)
+        
+        model_name_bisher = "Bisher/wav2vec2_ASV_deepfake_audio_detection"
+        model_info.bisher_feature_extractor = AutoFeatureExtractor.from_pretrained(model_name_bisher)
+        model_info.bisher_model = AutoModelForAudioClassification.from_pretrained(model_name_bisher)
+
+        model_info.status = "ready"
+        logger.info("Loaded both DL models for ensemble detection.")
+    except Exception as e:
+        model_info.status = "failed"
+        model_info.error = str(e)
+        logger.error(f"Failed to load DL models: {e}")
+        
+    yield
+    
+    model_info.gary_feature_extractor = None
+    model_info.gary_model = None
+    model_info.bisher_feature_extractor = None
+    model_info.bisher_model = None
+
+app = FastAPI(
+    title="EchoGuard API",
+    description=(
+        "AI-powered deepfake audio detection API. "
+        "Upload WAV or MP3 files for analysis. "
+        "Maximum file size: 30 MB. Maximum duration: 5 minutes."
+    ),
+    version="0.1.0",
+    docs_url="/api/docs",
+    redoc_url="/api/redoc",
+    openapi_url="/api/openapi.json",
+    lifespan=lifespan,
+)
+
+origins = [origin.strip() for origin in settings.cors_origins.split(",")]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """Handle Pydantic/FastAPI validation errors with a clean JSON response."""
+    errors = exc.errors()
+    detail = "; ".join(
+        f"{err.get('loc', ['unknown'])[-1]}: {err.get('msg', 'validation error')}"
+        for err in errors
+    )
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={
+            "error": "validation_error",
+            "detail": detail,
+            "status_code": 422,
+        },
+    )
+
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """Catch-all handler for unexpected exceptions."""
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "error": "internal_server_error",
+            "detail": "An unexpected error occurred. Please try again later.",
+            "status_code": 500,
+        },
+    )
+
+
+
+app.include_router(analysis.router, prefix="/api")
+
+@app.get(
+    "/",
+    summary="API Root",
+    description="Returns basic information about the EchoGuard API.",
+    tags=["System"],
+)
+async def root():
+    """Root endpoint providing basic API information."""
+    return {
+        "name": "EchoGuard Deepfake Detection API",
+        "version": "0.1.0",
+        "status": "online",
+        "documentation": "/api/docs",
+        "endpoints": {
+            "health_check": "/api/health",
+            "analyze_audio": "/api/analyze"
+        }
+    }
+
+@app.get(
+    "/api/health",
+    summary="Health check",
+    description="Returns the current health status and uptime of the EchoGuard API.",
+    tags=["System"],
+)
+async def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "healthy" if model_info.status == "ready" else "degraded",
+        "service": "EchoGuard API",
+        "version": "0.1.0",
+        "uptime_seconds": round(time.time() - _startup_time, 2),
+        "model_status": model_info.status,
+        "model_error": model_info.error
+    }

app/models.py

@@ -0,0 +1,102 @@
+"""Pydantic models for API request/response schemas."""
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Union
+from enum import Enum
+
+
+class PredictionLabel(str, Enum):
+    """Possible prediction outcomes."""
+    AI_GENERATED = "AI Generated"
+    HUMAN = "Human"
+    UNCERTAIN = "Uncertain"
+
+class MetricDetail(BaseModel):
+    score: int
+    confidence: str
+    reason: str
+
+class ForensicMetrics(BaseModel):
+    voice_naturalness: Union[int, MetricDetail]
+    audio_quality: Union[int, MetricDetail]
+    characteristics: List[str]
+    advanced: Dict[str, str]
+
+class TimelineSegment(BaseModel):
+    start: float
+    end: float
+    label: str
+    human_probability: float
+    ai_probability: float
+class AnalysisResponse(BaseModel):
+    """Response schema for the /analyze endpoint."""
+    id: str = Field(..., description="Unique analysis ID")
+    filename: str = Field(..., description="Original uploaded filename")
+    duration_seconds: float = Field(..., description="Audio duration in seconds")
+    file_size_bytes: int = Field(..., description="File size in bytes")
+    
+    # DL Preprocessing Data
+    sample_rate: int = Field(..., description="Audio sample rate in Hz")
+    channels: int = Field(..., description="Number of audio channels (1 for mono)")
+    peak_amplitude: float = Field(..., description="Peak amplitude after normalization")
+    waveform: list[float] = Field(..., description="Downsampled waveform array (max 500 points)")
+    spectrogram_image: str = Field(..., description="Base64 encoded PNG of the Mel Spectrogram")
+    processed_audio_path: str = Field(..., description="Path to the cached processed WAV file")
+
+    # Prediction
+    prediction: str = Field(..., description="Prediction label: 'AI Generated', 'Human', or 'Uncertain'")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score between 0 and 1")
+    human_probability: float = Field(..., description="Human probability")
+    ai_probability: float = Field(..., description="AI probability")
+    
+    # Forensics
+    forensics: ForensicMetrics = Field(..., description="Simplified forensics metrics")
+    timeline: List[TimelineSegment] = Field(..., description="1-second chunk analysis")
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+                    "filename": "suspicious_call.wav",
+                    "duration_seconds": 12.5,
+                    "file_size_bytes": 1024000,
+                    "sample_rate": 16000,
+                    "channels": 1,
+                    "peak_amplitude": 0.85,
+                    "waveform": [0.12, -0.23, 0.45],
+                    "spectrogram_image": "data:image/png;base64,iVBORw0KGgo...",
+                    "processed_audio_path": "backend/cache/a1b2c3d4_processed.wav",
+                    "prediction": "AI Generated",
+                    "confidence": 0.92,
+                    "human_probability": 0.08,
+                    "ai_probability": 0.92,
+                    "forensics": {
+                        "voice_naturalness": 40,
+                        "audio_quality": 85,
+                        "speech_stability": 92,
+                        "characteristics": ["⚠ Limited voice variation detected"],
+                        "advanced": {"Mean Pitch (Hz)": "120.5"}
+                    },
+                    "timeline": [
+                        {"start": 0.0, "end": 1.0, "label": "Suspicious", "human_probability": 0.1, "ai_probability": 0.9}
+                    ]
+                }
+            ]
+        }
+    }
+
+
+class HealthResponse(BaseModel):
+    """Response schema for the /health endpoint."""
+    status: str
+    service: str
+    version: str
+    uptime_seconds: float
+
+
+class ErrorResponse(BaseModel):
+    """Standard error response schema."""
+    error: str = Field(..., description="Error type identifier")
+    detail: str = Field(..., description="Human-readable error description")
+    status_code: int = Field(..., description="HTTP status code")

app/routers/__init__.py

@@ -0,0 +1 @@
+# EchoGuard Routers

app/routers/analysis.py

@@ -0,0 +1,245 @@
+"""Audio analysis endpoint with file validation and mock response."""
+
+import uuid
+import os
+import tempfile
+import random
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, UploadFile, File, Request, status, HTTPException
+from fastapi.responses import JSONResponse
+import logging
+import soundfile as sf
+
+from app.state import model_info
+from app.services.detector import EnsembleDetector
+from app.services.forensics import ForensicsAnalyzer
+logger = logging.getLogger(__name__)
+
+from app.config import settings
+from app.models import AnalysisResponse, ErrorResponse
+from app.exceptions import (
+    FileTooLargeError,
+    InvalidFileTypeError,
+    AudioTooLongError,
+    AudioProcessingError,
+)
+
+router = APIRouter(tags=["Analysis"])
+
+ALLOWED_EXTENSIONS = {".wav", ".mp3", ".m4a"}
+ALLOWED_CONTENT_TYPES = {
+    "audio/wav",
+    "audio/x-wav",
+    "audio/wave",
+    "audio/mpeg",
+    "audio/mp3",
+    "audio/m4a",
+    "audio/mp4",
+    "audio/x-m4a",
+    "application/octet-stream",  # fallback for some clients
+}
+
+MAX_FILE_SIZE_BYTES = settings.max_file_size_mb * 1024 * 1024
+
+
+def _get_file_extension(filename: str | None) -> str:
+    """Extract and normalize file extension."""
+    if not filename:
+        return ""
+    return os.path.splitext(filename)[1].lower()
+
+
+def _validate_file_type(filename: str | None, content_type: str | None) -> None:
+    """Validate that the uploaded file is wav or mp3."""
+    ext = _get_file_extension(filename)
+    if ext not in ALLOWED_EXTENSIONS:
+        raise InvalidFileTypeError(
+            file_type=ext or "unknown",
+            allowed_types=sorted(ALLOWED_EXTENSIONS),
+        )
+
+
+def _validate_file_size(file_size: int) -> None:
+    """Validate that the file does not exceed the size limit."""
+    if file_size > MAX_FILE_SIZE_BYTES:
+        raise FileTooLargeError(
+            file_size_mb=file_size / (1024 * 1024),
+            max_size_mb=settings.max_file_size_mb,
+        )
+
+
+def _get_audio_duration(file_path: str, extension: str) -> float:
+    """Get audio duration in seconds."""
+    try:
+        import mutagen
+        audio = mutagen.File(file_path)
+        if audio is not None and audio.info is not None:
+            return audio.info.length  # mutagen returns seconds
+    except Exception:
+        pass
+        
+    try:
+        import librosa
+        return librosa.get_duration(path=file_path)
+    except Exception as e:
+        raise AudioProcessingError(
+            reason=f"Could not read audio duration. Ensure it is a valid {extension} file. ({str(e)})"
+        )
+
+
+def _validate_duration(duration_seconds: float) -> None:
+    """Validate that the audio duration does not exceed the limit."""
+    if duration_seconds > settings.max_duration_seconds:
+        raise AudioTooLongError(
+            duration_seconds=duration_seconds,
+            max_seconds=settings.max_duration_seconds,
+        )
+
+
+def _generate_prediction(
+    analysis_id: str,
+    filename: str,
+    file_size_bytes: int,
+    processed_data: dict,
+    detection_result,
+    forensics_data: dict,
+    timeline_segments: list
+) -> dict:
+    """Generate final response using the real DL detector results."""
+    
+    explanation = "Analysis completed successfully."
+    
+    return {
+        "id": analysis_id,
+        "filename": filename,
+        "duration_seconds": round(processed_data["duration"], 2),
+        "file_size_bytes": file_size_bytes,
+        "prediction": detection_result.prediction,
+        "confidence": round(detection_result.confidence, 4),
+        "human_probability": round(detection_result.human_probability, 4),
+        "ai_probability": round(detection_result.ai_probability, 4),
+        "forensics": forensics_data,
+        "timeline": timeline_segments,
+        "sample_rate": processed_data["sample_rate"],
+        "channels": processed_data["channels"],
+        "peak_amplitude": processed_data["peak_amplitude"],
+        "waveform": processed_data["waveform"],
+        "spectrogram_image": processed_data["spectrogram_image"],
+        "processed_audio_path": processed_data["processed_audio_path"],
+    }
+
+
+@router.post(
+    "/analyze",
+    response_model=AnalysisResponse,
+    status_code=status.HTTP_200_OK,
+    responses={
+        413: {"model": ErrorResponse, "description": "File too large"},
+        415: {"model": ErrorResponse, "description": "Unsupported file type"},
+        422: {"model": ErrorResponse, "description": "Audio too long or unprocessable"},
+        500: {"model": ErrorResponse, "description": "Internal server error"},
+    },
+    summary="Analyze audio for deepfake detection",
+    description=(
+        "Upload a WAV or MP3 audio file for AI-powered deepfake detection analysis. "
+        "Maximum file size: 30 MB. Maximum duration: 5 minutes."
+    ),
+)
+async def analyze_audio(file: UploadFile = File(..., description="Audio file (.wav or .mp3)")):
+    """
+    Analyze an uploaded audio file for deepfake detection.
+    """
+    if model_info.status != "ready":
+        raise HTTPException(
+            status_code=503, 
+            detail=f"DL model is not ready. Status: {model_info.status}"
+        )
+        
+    from app.utils.audio import AudioProcessor
+
+    analysis_id = str(uuid.uuid4())
+
+    _validate_file_type(file.filename, file.content_type)
+
+    try:
+        content = await file.read()
+    except Exception:
+        raise AudioProcessingError(reason="Failed to read uploaded file.")
+
+    file_size = len(content)
+    _validate_file_size(file_size)
+
+    ext = _get_file_extension(file.filename)
+    tmp_path = None
+    processed_data = None
+
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=ext) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        duration = _get_audio_duration(tmp_path, ext)
+        _validate_duration(duration)
+
+        processor = AudioProcessor()
+        cache_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "cache"))
+        processed_data = processor.process(tmp_path, cache_dir, analysis_id)
+
+    except (FileTooLargeError, InvalidFileTypeError, AudioTooLongError, AudioProcessingError):
+        raise  # Re-raise known validation errors
+    except Exception as e:
+        error_msg = str(e)
+        if not error_msg or "NoBackendError" in str(type(e)):
+            error_msg = "The audio file format is not supported or the file is corrupted. (Missing decoding backend)"
+        raise AudioProcessingError(reason=error_msg)
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+    if not processed_data:
+        raise AudioProcessingError(reason="Failed to process audio features.")
+
+    try:
+        waveform, sr = sf.read(processed_data["processed_audio_path"], dtype="float32")
+        
+        from app.services.detector import EnsembleDetector
+        detector = EnsembleDetector(
+            model_info.gary_model, model_info.gary_feature_extractor,
+            model_info.bisher_model, model_info.bisher_feature_extractor,
+            sample_rate=16000
+        )
+        detection_result = detector.analyze(waveform, sample_rate=sr)
+        
+        timeline_segments = detector.analyze_timeline(waveform, sample_rate=sr)
+        
+        forensics_data = ForensicsAnalyzer.analyze(waveform, sr, ai_probability=detection_result.ai_probability)
+        
+        logger.info(
+            f"Analysis complete - ID: {analysis_id} | "
+            f"Duration: {processed_data['duration']:.2f}s | "
+            f"Inference Time: {detection_result.inference_time_ms:.2f}ms | "
+            f"Prediction: {detection_result.prediction} | "
+            f"Confidence: {detection_result.confidence:.4f} | "
+            f"AI Prob: {detection_result.ai_probability:.4f} | "
+            f"Human Prob: {detection_result.human_probability:.4f}"
+        )
+        
+    except Exception as e:
+        logger.error(f"Detection failed: {str(e)}")
+        raise AudioProcessingError(reason=f"Model inference failed: {str(e)}")
+
+    result = _generate_prediction(
+        analysis_id=analysis_id,
+        filename=file.filename or "unknown",
+        file_size_bytes=file_size,
+        processed_data=processed_data,
+        detection_result=detection_result,
+        forensics_data=forensics_data,
+        timeline_segments=timeline_segments
+    )
+
+    return result

app/services/detector.py

@@ -0,0 +1,189 @@
+import time
+import torch
+import numpy as np
+from dataclasses import dataclass
+
+@dataclass
+class DetectionResult:
+    human_probability: float
+    ai_probability: float
+    prediction: str
+    confidence: float
+    inference_time_ms: float
+
+class EnsembleDetector:
+    """
+    Runs inference on multiple deepfake detection models and aggregates the results.
+    Specifically uses a 'Max-Ensemble' strategy: The final AI probability is the 
+    maximum AI probability across all models. This ensures robustness against both
+    standard synthetic voices and SOTA deepfakes (like ElevenLabs).
+    """
+    def __init__(self, gary_model, gary_fe, bisher_model, bisher_fe, sample_rate: int = 16000):
+        self.gary_model = gary_model
+        self.gary_fe = gary_fe
+        self.bisher_model = bisher_model
+        self.bisher_fe = bisher_fe
+        self.target_sample_rate = sample_rate
+
+    def _get_probs(self, model, fe, waveform) -> tuple[float, float]:
+        """Returns (human_prob, ai_prob) for a single model."""
+        inputs = fe(
+            waveform, 
+            sampling_rate=self.target_sample_rate, 
+            return_tensors="pt", 
+            padding=True
+        )
+        with torch.no_grad():
+            logits = model(**inputs).logits
+            probabilities = torch.nn.functional.softmax(logits, dim=-1)
+            
+        id2label = model.config.id2label
+        fake_idx = 1
+        for idx, label in id2label.items():
+            l_lower = label.lower()
+            if "fake" in l_lower or "spoof" in l_lower or "ai" in l_lower:
+                fake_idx = idx
+                break
+        
+        human_idx = 1 if fake_idx == 0 else 0
+        probs = probabilities[0].tolist()
+        return probs[human_idx], probs[fake_idx]
+
+    def analyze(self, waveform: np.ndarray, sample_rate: int = 16000) -> DetectionResult:
+        if sample_rate != self.target_sample_rate:
+            raise ValueError(f"Detector requires sample rate of {self.target_sample_rate}Hz. Got {sample_rate}Hz.")
+
+        start_time = time.time()
+        
+        # Cap waveform to 10 seconds to prevent OOM and quadratic attention lag
+        max_samples = 10 * self.target_sample_rate
+        if len(waveform) > max_samples:
+            waveform = waveform[:max_samples]
+            
+        try:
+            # 1. Run Garystafford model
+            g_hp, g_ap = self._get_probs(self.gary_model, self.gary_fe, waveform)
+            
+            # 2. Run Bisher model
+            b_hp, b_ap = self._get_probs(self.bisher_model, self.bisher_fe, waveform)
+            
+            # 3. Aggregate (Max-Ensemble for AI probability)
+            final_ai_prob = max(g_ap, b_ap)
+            final_human_prob = 1.0 - final_ai_prob
+            
+            is_human = final_human_prob > final_ai_prob
+            prediction = "LIKELY HUMAN" if is_human else "LIKELY AI GENERATED"
+            confidence = final_human_prob if is_human else final_ai_prob
+            
+            inference_time_ms = (time.time() - start_time) * 1000
+            
+            return DetectionResult(
+                human_probability=final_human_prob,
+                ai_probability=final_ai_prob,
+                prediction=prediction,
+                confidence=confidence,
+                inference_time_ms=inference_time_ms
+            )
+            
+        except Exception as e:
+            raise RuntimeError(f"Deepfake ensemble detection failed during inference: {str(e)}")
+
+    def _get_batch_probs(self, model, fe, chunks, batch_size=10) -> list[tuple[float, float]]:
+        """Returns list of (human_prob, ai_prob) for a batch of chunks."""
+        all_probs = []
+        
+        # Determine the fake index dynamically once
+        id2label = model.config.id2label
+        fake_idx = 1
+        for idx, label in id2label.items():
+            l_lower = label.lower()
+            if "fake" in l_lower or "spoof" in l_lower or "ai" in l_lower:
+                fake_idx = idx
+                break
+        human_idx = 1 if fake_idx == 0 else 0
+        
+        # Process in smaller batches to prevent OOM
+        for i in range(0, len(chunks), batch_size):
+            batch = chunks[i:i+batch_size]
+            inputs = fe(
+                batch, 
+                sampling_rate=self.target_sample_rate, 
+                return_tensors="pt", 
+                padding=True
+            )
+            with torch.no_grad():
+                logits = model(**inputs).logits
+                probabilities = torch.nn.functional.softmax(logits, dim=-1)
+                
+            probs_list = probabilities.tolist()
+            all_probs.extend([(p[human_idx], p[fake_idx]) for p in probs_list])
+            
+        return all_probs
+
+    def analyze_timeline(self, waveform: np.ndarray, sample_rate: int = 16000) -> list:
+        if sample_rate != self.target_sample_rate:
+            raise ValueError(f"Detector requires sample rate of {self.target_sample_rate}Hz. Got {sample_rate}Hz.")
+        
+        window_size = sample_rate # 1 second windows
+        segments = []
+        num_windows = len(waveform) // window_size
+        
+        chunks = []
+        for i in range(num_windows):
+            start_sample = i * window_size
+            end_sample = start_sample + window_size
+            chunks.append(waveform[start_sample:end_sample])
+            
+        has_remainder = False
+        if len(waveform) % window_size > int(window_size * 0.1):
+            start_sample = num_windows * window_size
+            chunks.append(waveform[start_sample:])
+            has_remainder = True
+            
+        if not chunks:
+            return []
+            
+        try:
+            g_probs = self._get_batch_probs(self.gary_model, self.gary_fe, chunks)
+            b_probs = self._get_batch_probs(self.bisher_model, self.bisher_fe, chunks)
+            
+            for i in range(len(chunks)):
+                g_hp, g_ap = g_probs[i]
+                b_hp, b_ap = b_probs[i]
+                
+                final_ap = max(g_ap, b_ap)
+                final_hp = 1.0 - final_ap
+                
+                if final_hp > 0.70:
+                    lbl = "Human-like"
+                elif final_ap > 0.70:
+                    lbl = "Suspicious"
+                else:
+                    lbl = "Neutral"
+                    
+                start_sec = float(i)
+                end_sec = float(i + 1)
+                
+                if has_remainder and i == len(chunks) - 1:
+                    end_sec = float(len(waveform) / sample_rate)
+                    
+                segments.append({
+                    "start": start_sec,
+                    "end": end_sec,
+                    "label": lbl,
+                    "human_probability": float(final_hp),
+                    "ai_probability": float(final_ap)
+                })
+        except Exception as e:
+            for i in range(len(chunks)):
+                start_sec = float(i)
+                end_sec = float(i + 1) if not (has_remainder and i == len(chunks) - 1) else float(len(waveform) / sample_rate)
+                segments.append({
+                    "start": start_sec,
+                    "end": end_sec,
+                    "label": "Neutral",
+                    "human_probability": 0.5,
+                    "ai_probability": 0.5
+                })
+                
+        return segments

app/services/forensics.py

@@ -0,0 +1,237 @@
+import numpy as np
+import librosa
+
+class ForensicsAnalyzer:
+    """
+    Independent Audio Forensics Engine.
+    Evaluates raw DSP features to compute Voice Naturalness and Audio Quality.
+    Completely independent of deep learning models and classifier predictions.
+    """
+
+    @staticmethod
+    def analyze(waveform: np.ndarray, sr: int, ai_probability: float = 0.0) -> dict:
+        # ai_probability is kept in the signature strictly for API compatibility.
+        # It is NEVER referenced or used in any score, characteristic, or calculation.
+        
+        # --- 1. Multi-Window Analysis ---
+        window_duration = 5 * sr
+        if len(waveform) > 15 * sr:
+            # Extract 3 representative windows
+            w1 = waveform[:window_duration]
+            mid_start = len(waveform) // 2 - window_duration // 2
+            w2 = waveform[mid_start : mid_start + window_duration]
+            w3 = waveform[-window_duration:]
+            windows = [w1, w2, w3]
+        elif len(waveform) > window_duration:
+            w1 = waveform[:window_duration]
+            w2 = waveform[-window_duration:]
+            windows = [w1, w2]
+        else:
+            windows = [waveform]
+
+        metrics = {
+            "pitch_std": [],
+            "pitch_range": [],
+            "mean_pitch": [],
+            "pause_ratio": [],
+            "speech_ratio": [],
+            "sc_mean": [],
+            "sb_mean": [],
+            "rms_cons": [],
+            "zcr_cons": []
+        }
+
+        for w in windows:
+            if len(w) == 0:
+                continue
+
+            # --- Adaptive Pause & Speech Detection ---
+            # Using 20th percentile of RMS energy as adaptive baseline statistic
+            rms = librosa.feature.rms(y=w)[0]
+            if len(rms) > 0:
+                p20 = np.percentile(rms, 20)
+                p95 = np.percentile(rms, 95)
+                # Adaptive silence threshold: p20 + 10% of dynamic range
+                adaptive_threshold = p20 + 0.10 * max(0.0, p95 - p20)
+                
+                pause_ratio = float(np.mean(rms < adaptive_threshold))
+                speech_ratio = 1.0 - pause_ratio
+                
+                # RMS Consistency via percentile-based normalization
+                # If dynamic range or variance is smooth, consistency is high
+                rms_cv = np.std(rms) / (np.mean(rms) + 1e-6)
+                rms_cons = float(np.clip(100.0 * np.exp(-1.5 * rms_cv), 0.0, 100.0))
+            else:
+                adaptive_threshold = 0.0
+                pause_ratio = 1.0
+                speech_ratio = 0.0
+                rms_cons = 0.0
+
+            metrics["pause_ratio"].append(pause_ratio)
+            metrics["speech_ratio"].append(speech_ratio)
+            metrics["rms_cons"].append(rms_cons)
+
+            # --- Pitch Dynamics ---
+            try:
+                f0 = librosa.yin(w, fmin=librosa.note_to_hz('C2'), fmax=librosa.note_to_hz('C7'), sr=sr)
+                min_len = min(len(f0), len(rms))
+                f0_trimmed = f0[:min_len]
+                rms_trimmed = rms[:min_len]
+                
+                # Filter strictly for active speech frames above adaptive threshold
+                valid_f0 = f0_trimmed[rms_trimmed >= adaptive_threshold]
+                if len(valid_f0) > 5:
+                    f0_std = float(np.std(valid_f0))
+                    f0_mean = float(np.mean(valid_f0))
+                    # Pitch range: 90th percentile - 10th percentile to avoid spurious outlier jumps
+                    f0_range = float(np.percentile(valid_f0, 90) - np.percentile(valid_f0, 10))
+                    
+                    metrics["pitch_std"].append(f0_std)
+                    metrics["pitch_range"].append(f0_range)
+                    metrics["mean_pitch"].append(f0_mean)
+                else:
+                    metrics["pitch_std"].append(0.0)
+                    metrics["pitch_range"].append(0.0)
+                    metrics["mean_pitch"].append(0.0)
+            except Exception:
+                metrics["pitch_std"].append(0.0)
+                metrics["pitch_range"].append(0.0)
+                metrics["mean_pitch"].append(0.0)
+
+            # --- Spectral & Temporal Quality ---
+            sc = librosa.feature.spectral_centroid(y=w, sr=sr)[0]
+            sb = librosa.feature.spectral_bandwidth(y=w, sr=sr)[0]
+            zcr = librosa.feature.zero_crossing_rate(y=w)[0]
+
+            metrics["sc_mean"].append(float(np.mean(sc)))
+            metrics["sb_mean"].append(float(np.mean(sb)))
+            
+            # ZCR consistency: exponential decay normalization of zero-crossing variation
+            zcr_cv = np.std(zcr) / (np.mean(zcr) + 1e-6)
+            zcr_cons = float(np.clip(100.0 * np.exp(-1.0 * zcr_cv), 0.0, 100.0))
+            metrics["zcr_cons"].append(zcr_cons)
+
+        # Safely average all windowed metrics
+        avg_pitch_std = float(np.mean(metrics["pitch_std"])) if metrics["pitch_std"] else 0.0
+        avg_pitch_range = float(np.mean(metrics["pitch_range"])) if metrics["pitch_range"] else 0.0
+        avg_mean_pitch = float(np.mean(metrics["mean_pitch"])) if metrics["mean_pitch"] else 0.0
+        avg_pause_ratio = float(np.mean(metrics["pause_ratio"])) if metrics["pause_ratio"] else 0.0
+        avg_speech_ratio = float(np.mean(metrics["speech_ratio"])) if metrics["speech_ratio"] else 0.0
+        avg_sc_mean = float(np.mean(metrics["sc_mean"])) if metrics["sc_mean"] else 0.0
+        avg_sb_mean = float(np.mean(metrics["sb_mean"])) if metrics["sb_mean"] else 0.0
+        avg_rms_cons = float(np.mean(metrics["rms_cons"])) if metrics["rms_cons"] else 0.0
+        avg_zcr_cons = float(np.mean(metrics["zcr_cons"])) if metrics["zcr_cons"] else 0.0
+
+        # --- 2. PURE DSP SCORING: VOICE NATURALNESS ---
+        # Depends strictly on: pitch variation, pitch range, pause ratio
+        # Non-linear Gaussian/exponential normalization across full 0-100 spectrum
+        
+        # 1) Pitch variation score (ideal conversational speech std is ~35 Hz)
+        pitch_std_score = float(np.clip(100.0 * np.exp(-((avg_pitch_std - 38.0) / 30.0)**2), 0.0, 100.0))
+        
+        # 2) Pitch range score (ideal conversational range is ~80-160 Hz between 10th and 90th percentile)
+        pitch_range_score = float(np.clip(100.0 * (1.0 - np.exp(-avg_pitch_range / 50.0)), 0.0, 100.0))
+        
+        # 3) Pause ratio score (ideal conversational pause ratio is ~15% to 30%)
+        pause_score = float(np.clip(100.0 * np.exp(-((avg_pause_ratio - 0.22) / 0.16)**2), 0.0, 100.0))
+        
+        # Combine purely from DSP weights without artificial score clamping
+        raw_naturalness = 0.40 * pitch_std_score + 0.35 * pitch_range_score + 0.25 * pause_score
+        voice_naturalness_val = int(np.round(np.clip(raw_naturalness, 0.0, 100.0)))
+
+        # --- 3. PURE DSP SCORING: AUDIO QUALITY ---
+        # Depends strictly on: spectral centroid, spectral bandwidth, RMS consistency, ZCR consistency
+        
+        # 1) Spectral Centroid score (ideal voice clarity is ~1800-3000 Hz)
+        sc_score = float(np.clip(100.0 * np.exp(-((avg_sc_mean - 2300.0) / 1400.0)**2), 0.0, 100.0))
+        
+        # 2) Spectral Bandwidth score (square-root normalization for rich harmonic structure)
+        sb_score = float(np.clip(100.0 * np.sqrt(min(avg_sb_mean, 2600.0) / 2600.0), 0.0, 100.0))
+        
+        # Combine purely from DSP quality components
+        raw_quality = 0.30 * sc_score + 0.30 * sb_score + 0.20 * avg_rms_cons + 0.20 * avg_zcr_cons
+        audio_quality_val = int(np.round(np.clip(raw_quality, 0.0, 100.0)))
+
+        # --- 4. DETECTED CHARACTERISTICS (DERIVED EXCLUSIVELY FROM DSP) ---
+        characteristics = []
+        
+        # Pitch evaluations
+        if avg_pitch_std < 12.0:
+            characteristics.append("⚠ Voice sounds flat or monotone")
+        elif avg_pitch_std > 70.0:
+            characteristics.append("⚠ Unnatural jumps in voice pitch")
+        else:
+            characteristics.append("✓ Lively and natural speaking voice")
+            
+        # Rhythm evaluations
+        if avg_pause_ratio < 0.08:
+            characteristics.append("⚠ Robotic speaking rhythm with no pauses")
+        elif avg_pause_ratio > 0.45:
+            characteristics.append("⚠ Unusually long awkward silences")
+        else:
+            characteristics.append("✓ Natural conversational breathing and pauses")
+            
+        # Spectral frequency evaluations
+        if avg_sb_mean < 1100.0:
+            characteristics.append("⚠ Audio sounds muffled or compressed")
+        elif avg_sc_mean >= 1500.0:
+            characteristics.append("✓ Crisp and clear recording quality")
+        else:
+            characteristics.append("⚠ Sound is muffled or lacks detail")
+            
+        # Recording consistency evaluations
+        if avg_rms_cons >= 70.0 and avg_zcr_cons >= 70.0:
+            characteristics.append("✓ Steady volume and clean recording")
+        elif avg_rms_cons < 50.0:
+            characteristics.append("⚠ Volume levels jump around during recording")
+
+        characteristics = characteristics[:4]
+
+        # --- 5. STRUCTURED RESULTS & CONFIDENCE ---
+        # Determine confidence and reasons based strictly on DSP signal characteristics
+        if voice_naturalness_val >= 75:
+            nat_conf = "High"
+            nat_reason = "Sounds like a real person talking naturally"
+        elif voice_naturalness_val >= 50:
+            nat_conf = "Medium"
+            nat_reason = "Normal speaking rhythm and voice tone"
+        else:
+            nat_conf = "High" if len(windows) >= 2 else "Medium"
+            nat_reason = "Voice sounds flat, robotic, or artificial"
+
+        if audio_quality_val >= 75:
+            qual_conf = "High"
+            qual_reason = "Clear and steady microphone sound"
+        elif audio_quality_val >= 50:
+            qual_conf = "Medium"
+            qual_reason = "Good audio clarity and balance"
+        else:
+            qual_conf = "Medium"
+            qual_reason = "Muffled sound or uneven volume levels"
+
+        structured_naturalness = {
+            "score": voice_naturalness_val,
+            "confidence": nat_conf,
+            "reason": nat_reason
+        }
+
+        structured_quality = {
+            "score": audio_quality_val,
+            "confidence": qual_conf,
+            "reason": qual_reason
+        }
+
+        # --- 6. ADVANCED ANALYSIS (COLLAPSED & UNDERSTANDABLE) ---
+        advanced = {
+            "Mean Pitch": f"{avg_mean_pitch:.1f} Hz",
+            "Pitch Variation": f"{avg_pitch_std:.1f} Hz",
+            "Spectral Profile": f"{int(avg_sc_mean)} Hz",
+            "Recording Consistency": f"{int(avg_rms_cons)}%"
+        }
+
+        return {
+            "voice_naturalness": structured_naturalness,
+            "audio_quality": structured_quality,
+            "characteristics": characteristics,
+            "advanced": advanced
+        }

app/state.py

@@ -0,0 +1,9 @@
+class ModelInfo:
+    status: str = "uninitialized"
+    error: str | None = None
+    gary_feature_extractor = None
+    gary_model = None
+    bisher_feature_extractor = None
+    bisher_model = None
+
+model_info = ModelInfo()

app/utils/audio.py

@@ -0,0 +1,141 @@
+import os
+import io
+import base64
+import librosa
+import numpy as np
+import soundfile as sf
+import matplotlib
+import matplotlib.pyplot as plt
+
+# Use non-interactive backend for matplotlib to prevent thread issues
+matplotlib.use('Agg')
+
+# Register bundled ffmpeg binary so audioread can decode M4A/AAC files
+try:
+    import imageio_ffmpeg
+    import audioread.ffdec
+    _ffmpeg_exe = imageio_ffmpeg.get_ffmpeg_exe()
+    audioread.ffdec.COMMANDS = (_ffmpeg_exe, 'ffmpeg', 'avconv')
+except ImportError:
+    pass  # ffmpeg not bundled; M4A support may be unavailable
+
+class AudioProcessor:
+    """
+    Utility class for AI audio preprocessing.
+    Handles mono conversion, resampling, normalization, silence trimming,
+    waveform extraction, and Mel Spectrogram generation.
+    """
+
+    def __init__(self, target_sr: int = 16000, max_waveform_points: int = 500, max_cache_files: int = 5):
+        self.target_sr = target_sr
+        self.max_waveform_points = max_waveform_points
+        self.max_cache_files = max_cache_files
+
+    def _cleanup_cache(self, cache_dir: str):
+        """Keep only the most recent 'max_cache_files' processed files in the cache."""
+        try:
+            files = [os.path.join(cache_dir, f) for f in os.listdir(cache_dir) if f.endswith('_processed.wav')]
+            if len(files) <= self.max_cache_files:
+                return
+            
+            # Sort files by modification time, oldest first
+            files.sort(key=os.path.getmtime)
+            
+            # Delete oldest files exceeding the limit
+            files_to_delete = files[:-self.max_cache_files]
+            for f in files_to_delete:
+                try:
+                    os.remove(f)
+                except OSError:
+                    pass
+        except Exception as e:
+            print(f"Error cleaning up cache: {e}")
+
+    def process(self, file_path: str, cache_dir: str, analysis_id: str) -> dict:
+        """
+        Executes the full preprocessing pipeline on the given audio file.
+        
+        Args:
+            file_path: Absolute path to the uploaded temporary audio file.
+            cache_dir: Directory to save the processed output.
+            analysis_id: Unique UUID to use for filename generation.
+            
+        Returns:
+            Dictionary containing waveform, spectrogram image, and metadata.
+        """
+        # Ensure cache directory exists
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        # 1. Load, convert to mono, and resample
+        # librosa automatically converts to mono if mono=True (which is the default)
+        y, sr = librosa.load(file_path, sr=self.target_sr, mono=True)
+
+        # 2. Normalize amplitude to range [-1.0, 1.0]
+        y_normalized = librosa.util.normalize(y)
+
+        # 4. Save processed audio to cache for future Wav2Vec2 inference
+        processed_audio_path = os.path.join(cache_dir, f"{analysis_id}_processed.wav")
+        sf.write(processed_audio_path, y_normalized, self.target_sr)
+
+        # 5. Extract Waveform (downsample to max 500 points)
+        if len(y_normalized) > self.max_waveform_points:
+            # We use an integer step size to slice the numpy array quickly
+            step = len(y_normalized) // self.max_waveform_points
+            # Alternative is taking max/avg per bin, but simple slice is fast and acceptable for overview
+            # Better approach for UI: calculate RMS or max amplitude per bin
+            y_split = np.array_split(y_normalized, self.max_waveform_points)
+            waveform = [float(np.max(np.abs(bin))) for bin in y_split]
+        else:
+            waveform = [float(val) for val in y_normalized]
+
+        # 6. Generate Mel Spectrogram
+        # Compute mel-scaled spectrogram
+        S = librosa.feature.melspectrogram(y=y_normalized, sr=self.target_sr, n_mels=128, fmax=8000)
+        # Convert power spectrogram to dB (log scale)
+        S_dB = librosa.power_to_db(S, ref=np.max)
+
+        # Render image with dark mode styling
+        fig, ax = plt.subplots(figsize=(10, 4))
+        
+        # Display the spectrogram
+        img = librosa.display.specshow(S_dB, sr=self.target_sr, x_axis='time', y_axis='mel', fmax=8000, ax=ax, cmap='magma')
+        
+        # Add labels and style axes for dark UI
+        ax.set_ylabel('Frequency (Hz)', color='#9ca3af', fontsize=10, labelpad=8)
+        ax.set_xlabel('Time (s)', color='#9ca3af', fontsize=10, labelpad=8)
+        
+        # Style the ticks
+        ax.tick_params(colors='#9ca3af', labelsize=9)
+        
+        # Remove top and right spines for a cleaner look
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+        ax.spines['bottom'].set_color('#4b5563')
+        ax.spines['left'].set_color('#4b5563')
+        
+        # Save to buffer
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', bbox_inches='tight', transparent=True, dpi=120)
+        plt.close(fig)
+        
+        # Encode to Base64
+        buf.seek(0)
+        img_b64 = base64.b64encode(buf.read()).decode('utf-8')
+        spectrogram_b64 = f"data:image/png;base64,{img_b64}"
+        
+        # Calculate final metadata
+        duration = librosa.get_duration(y=y_normalized, sr=self.target_sr)
+        peak_amp = float(np.max(np.abs(y_normalized)))
+
+        # Clean up old cache files
+        self._cleanup_cache(cache_dir)
+
+        return {
+            "sample_rate": self.target_sr,
+            "duration": duration,
+            "channels": 1,
+            "peak_amplitude": peak_amp,
+            "waveform": waveform,
+            "spectrogram_image": spectrogram_b64,
+            "processed_audio_path": processed_audio_path
+        }

requirements.txt

@@ -0,0 +1,18 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+pydantic-settings==2.5.0
+pydantic==2.9.0
+mutagen==1.47.0
+aiofiles==24.1.0
+librosa==0.10.2
+numpy==1.26.4
+soundfile==0.12.1
+matplotlib==3.9.0
+torch>=2.1.0
+torchvision>=0.16.0
+torchaudio>=2.1.0
+transformers>=4.35.0
+psutil>=5.9.0
+imageio-ffmpeg>=0.6.0

scripts/benchmark_models.py

@@ -0,0 +1,130 @@
+import os
+import glob
+import json
+import time
+import librosa
+import torch
+from transformers import AutoModelForAudioClassification, AutoFeatureExtractor
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+def get_audio_files():
+    # Load all class_0 (Real/Human) and class_1 (Fake/AI) from the data directory
+    # class_0 -> label 0
+    # class_1 -> label 1
+    files = []
+    
+    # Path is relative to the backend folder when running this script, so ../data
+    data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "data"))
+    
+    class_0_files = glob.glob(os.path.join(data_dir, "class_0", "*.wav")) + glob.glob(os.path.join(data_dir, "class_0", "*.mp3"))
+    for f in class_0_files:
+        files.append((f, 0))
+        
+    class_1_files = glob.glob(os.path.join(data_dir, "class_1", "*.wav")) + glob.glob(os.path.join(data_dir, "class_1", "*.mp3"))
+    for f in class_1_files:
+        files.append((f, 1))
+        
+    return files
+
+def get_fake_label_index(id2label):
+    # Dynamically find which index corresponds to "fake", "spoof", "ai"
+    # and which is "real", "human", "bonafide"
+    fake_idx = 1 # default
+    for idx, label in id2label.items():
+        l_lower = label.lower()
+        if "fake" in l_lower or "spoof" in l_lower or "ai" in l_lower:
+            fake_idx = idx
+            break
+    return fake_idx
+
+def benchmark():
+    models_to_test = [
+        "garystafford/wav2vec2-deepfake-voice-detector",
+        "Bisher/wav2vec2_ASV_deepfake_audio_detection"
+    ]
+    
+    audio_files = get_audio_files()
+    if not audio_files:
+        print("No audio files found in ../../data/class_0 or ../../data/class_1")
+        return
+        
+    print(f"Found {len(audio_files)} total audio files for benchmarking.")
+    
+    results = {}
+    
+    for model_name in models_to_test:
+        print(f"\n======================================")
+        print(f"Loading Model: {model_name}")
+        
+        try:
+            feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
+            model = AutoModelForAudioClassification.from_pretrained(model_name)
+            
+            fake_idx = get_fake_label_index(model.config.id2label)
+            print(f"Dynamic Label Mapping -> Fake/AI is index {fake_idx}")
+            
+            y_true = []
+            y_pred = []
+            
+            start_time = time.time()
+            
+            for file_path, true_label in audio_files:
+                # Target sample rate is typically 16000 for wav2vec2 models
+                target_sr = feature_extractor.sampling_rate if hasattr(feature_extractor, "sampling_rate") else 16000
+                
+                y, sr = librosa.load(file_path, sr=target_sr, mono=True)
+                
+                inputs = feature_extractor(y, sampling_rate=target_sr, return_tensors="pt", padding=True)
+                
+                with torch.no_grad():
+                    logits = model(**inputs).logits
+                    probabilities = torch.nn.functional.softmax(logits, dim=-1)
+                    probs = probabilities[0].tolist()
+                    
+                predicted_idx = 0 if probs[0] > probs[1] else 1
+                
+                # If predicted_idx matches fake_idx, the model predicted Fake (1). Else Real (0).
+                predicted_label = 1 if predicted_idx == fake_idx else 0
+                
+                y_true.append(true_label)
+                y_pred.append(predicted_label)
+                
+            elapsed = time.time() - start_time
+            
+            # Calculate metrics
+            accuracy = accuracy_score(y_true, y_pred)
+            # Use zero_division=0 to handle cases where it predicts all one class
+            precision = precision_score(y_true, y_pred, zero_division=0)
+            recall = recall_score(y_true, y_pred, zero_division=0)
+            f1 = f1_score(y_true, y_pred, zero_division=0)
+            
+            print(f"Metrics for {model_name}:")
+            print(f"  Accuracy:  {accuracy:.4f}")
+            print(f"  Precision: {precision:.4f}")
+            print(f"  Recall:    {recall:.4f}")
+            print(f"  F1 Score:  {f1:.4f}")
+            print(f"  Time:      {elapsed:.2f}s")
+            
+            results[model_name] = {
+                "accuracy": round(accuracy, 4),
+                "precision": round(precision, 4),
+                "recall": round(recall, 4),
+                "f1_score": round(f1, 4),
+                "total_time_seconds": round(elapsed, 2)
+            }
+            
+        except Exception as e:
+            print(f"Error benchmarking {model_name}: {e}")
+            results[model_name] = {
+                "error": str(e)
+            }
+            
+    # Save results
+    output_file = os.path.join(os.path.dirname(__file__), "..", "..", "benchmark_results.json")
+    with open(output_file, "w") as f:
+        json.dump(results, f, indent=4)
+        
+    print(f"\nBenchmark complete. Results saved to {output_file}")
+
+if __name__ == "__main__":
+    benchmark()