Fix AI detector stability, serialization, and test accuracy (#13)

Fixes applied:
- Guard corrupted images (cv2.imdecode None check)
- NaN protection in JPEG blockiness (empty list guard)
- numpy.bool_ wrapped with bool() for Pydantic serialization
- Dynamic FFT center_size: min(30, crow, ccol) for small images
- float() on all numpy scalars in return dicts

Test fixes:
- Replace 1x1px fixture with 100x100px gradient + Gaussian noise
- Update size_mb assertion from < 0.01 to < 1.0

Result: 25/25 tests passing

backend/services/ai_detector.py

@@ -0,0 +1,357 @@
+"""
+AI-generated image detection service.
+Uses statistical analysis and heuristics to detect AI-generated images.
+
+Detection Signals:
+1. Noise pattern consistency  - Sensor noise modeling (Laplacian variance)
+2. Frequency domain analysis  - FFT spectral fingerprinting
+3. JPEG compression artifacts - DCT block boundary detection
+4. Color distribution entropy - HSV histogram analysis
+
+Mathematical basis:
+- Noise:     Consistency = σ_local / μ_local  (lower = suspicious)
+- Frequency: Ratio = LowFreqEnergy / HighFreqEnergy
+- Entropy:   H(X) = -Σ p(x)log p(x)
+"""
+import numpy as np
+import cv2
+from scipy import fft
+from scipy.stats import entropy
+from typing import Dict, Any
+from PIL import Image
+from io import BytesIO
+
+from backend.core.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class AIDetector:
+    """
+    AI-generated image detector using statistical analysis.
+
+    Why statistical approach?
+    - No heavy model downloads required
+    - Fast inference (< 1 second)
+    - Interpretable signal breakdown
+    - Works fully offline
+    """
+
+    def __init__(self, image_bytes: bytes, filename: str):
+        """
+        Initialize detector with image data.
+
+        Args:
+            image_bytes: Raw image file content
+            filename: Original filename for logging
+
+        Raises:
+            ValueError: If image is corrupted or unreadable
+        """
+        self.image_bytes = image_bytes
+        self.filename = filename
+
+        # Load via PIL (for metadata-aware loading)
+        self.pil_image = Image.open(BytesIO(image_bytes))
+
+        # Load via OpenCV (for numerical analysis)
+        self.cv_image = cv2.imdecode(
+            np.frombuffer(image_bytes, np.uint8),
+            cv2.IMREAD_COLOR
+        )
+
+
+        if self.cv_image is None:
+            raise ValueError(f"Invalid or corrupted image file: {filename}")
+
+        self.cv_gray = cv2.cvtColor(self.cv_image, cv2.COLOR_BGR2GRAY)
+
+        logger.info(f"Initialized AI detector for {filename} "
+                    f"({self.cv_gray.shape[1]}x{self.cv_gray.shape[0]}px)")
+
+    def analyze_noise_patterns(self) -> Dict[str, Any]:
+        """
+        Analyze noise patterns using Laplacian operator.
+
+        Mathematical basis:
+            L(x,y) = ∇²I(x,y)  (second derivative = high freq noise)
+            Consistency = σ_local / μ_local
+
+        Real photos:  Noise ~ N(0, σ²) - natural Gaussian sensor noise
+        AI images:    Low stochastic variation → lower variance diversity
+
+        Returns:
+            Dictionary with noise metrics
+        """
+        # Laplacian extracts high-frequency noise components
+        laplacian = cv2.Laplacian(self.cv_gray, cv2.CV_64F)
+        noise_variance = laplacian.var()
+
+        # Local variance analysis (real photos have higher local diversity)
+        kernel_size = 5
+        img_float = self.cv_gray.astype(float)
+        mean_local = cv2.blur(img_float, (kernel_size, kernel_size))
+        sqr_mean = cv2.blur(img_float ** 2, (kernel_size, kernel_size))
+        local_variance = sqr_mean - mean_local ** 2
+
+        local_var_mean = local_variance.mean()
+        local_var_std = local_variance.std()
+
+        # Consistency ratio: lower = more uniform = more suspicious
+        noise_consistency = local_var_std / (local_var_mean + 1e-10)
+
+        logger.info(
+            f"Noise analysis: variance={noise_variance:.2f}, "
+            f"consistency={noise_consistency:.4f}"
+        )
+
+        return {
+            "noise_variance": float(noise_variance),
+            "local_variance_mean": float(local_var_mean),
+            "noise_consistency": float(noise_consistency),
+            "suspicious": bool(noise_consistency < 0.3)
+        }
+
+    def analyze_frequency_domain(self) -> Dict[str, Any]:
+        """
+        Analyze frequency domain via 2D FFT.
+
+        Mathematical basis:
+            F(u,v) = Σ I(x,y) · e^(-j2π(ux+vy))
+            Ratio = LowFreqEnergy / HighFreqEnergy
+            H(X) = -Σ p(x)log p(x)  (spectral entropy)
+
+        Real photos:  Energy decays gradually with frequency
+        AI images:    Abnormal high-frequency spikes or flat spectrum
+
+        Returns:
+            Dictionary with frequency metrics
+        """
+        # 2D Fast Fourier Transform
+        f_transform = fft.fft2(self.cv_gray)
+        f_shift = fft.fftshift(f_transform)  # Zero frequency to center
+        magnitude_spectrum = np.abs(f_shift)
+
+        rows, cols = self.cv_gray.shape
+        crow, ccol = rows // 2, cols // 2
+
+        # If center_size=30 on a 40x40 image → index goes out of bounds
+        center_size = min(30, crow, ccol)
+
+        # Low freq = center region, High freq = everything else
+        low_freq = magnitude_spectrum[
+            crow - center_size:crow + center_size,
+            ccol - center_size:ccol + center_size
+        ].sum()
+        high_freq = magnitude_spectrum.sum() - low_freq
+        freq_ratio = low_freq / (high_freq + 1e-10)
+
+        # Spectral entropy: lower = less natural frequency distribution
+        spectrum_flat = magnitude_spectrum.flatten()
+        spectrum_normalized = spectrum_flat / (spectrum_flat.sum() + 1e-10)
+        spectral_entropy = float(entropy(spectrum_normalized + 1e-10))
+
+        logger.info(
+            f"Frequency analysis: ratio={freq_ratio:.4f}, "
+            f"entropy={spectral_entropy:.2f}"
+        )
+
+        return {
+            "frequency_ratio": float(freq_ratio),
+            "spectral_entropy": spectral_entropy,
+            "suspicious": bool(freq_ratio > 15.0)
+        }
+
+    def analyze_jpeg_artifacts(self) -> Dict[str, Any]:
+        """
+        Analyze JPEG DCT block boundary artifacts.
+
+        Mathematical basis:
+            JPEG uses 8x8 DCT blocks with quantization
+            Block discontinuity = boundary artifact strength
+
+        Real photos:  Authentic JPEG compression boundary patterns
+        AI images:    Often over-smoothed or lack realistic artifacts
+
+        Returns:
+            Dictionary with JPEG metrics
+        """
+        blockiness_scores = []
+
+        for i in range(0, self.cv_gray.shape[0] - 8, 8):
+            for j in range(0, self.cv_gray.shape[1] - 8, 8):
+                block = self.cv_gray[i:i + 8, j:j + 8].astype(float)
+                v_diff = np.abs(block[:, 7] - block[:, 0]).mean()
+                h_diff = np.abs(block[7, :] - block[0, :]).mean()
+                blockiness_scores.append(v_diff + h_diff)
+
+        # np.mean([]) returns nan which breaks probability math downstream
+        blockiness = float(np.mean(blockiness_scores)) if blockiness_scores else 0.0
+
+        # Edge density: lower = smoother = more suspicious
+        edges = cv2.Canny(self.cv_gray, 100, 200)
+        edge_density = float(
+            edges.sum() / (self.cv_gray.shape[0] * self.cv_gray.shape[1])
+        )
+
+        logger.info(
+            f"JPEG analysis: blockiness={blockiness:.2f}, "
+            f"edge_density={edge_density:.6f}"
+        )
+
+        return {
+            "blockiness": blockiness,
+            "edge_density": edge_density,
+            "suspicious": bool(blockiness < 2.0 or edge_density < 0.01)
+        }
+
+    def analyze_color_distribution(self) -> Dict[str, Any]:
+        """
+        Analyze color distribution via HSV histogram entropy.
+
+        Mathematical basis:
+            H(X) = -Σ p(x)log p(x)  applied to hue histogram
+            Lower entropy = less color diversity = more suspicious
+
+        Real photos:  Natural color variance and distribution
+        AI images:    Sometimes oversaturated or unnaturally uniform
+
+        Returns:
+            Dictionary with color metrics
+        """
+        # HSV separates color (H), saturation (S), brightness (V)
+        hsv = cv2.cvtColor(self.cv_image, cv2.COLOR_BGR2HSV)
+
+        h_var = float(hsv[:, :, 0].var())
+        s_var = float(hsv[:, :, 1].var())
+        v_var = float(hsv[:, :, 2].var())
+
+        # Hue histogram entropy
+        hist_h = cv2.calcHist([hsv], [0], None, [180], [0, 180])
+        hist_normalized = hist_h / (hist_h.sum() + 1e-10)
+        color_entropy = float(entropy(hist_normalized.flatten() + 1e-10))
+
+        mean_saturation = float(hsv[:, :, 1].mean())
+
+        logger.info(
+            f"Color analysis: entropy={color_entropy:.2f}, "
+            f"sat={mean_saturation:.2f}"
+        )
+
+        return {
+            "hue_variance": h_var,
+            "saturation_variance": s_var,
+            "value_variance": v_var,
+            "color_entropy": color_entropy,
+            "mean_saturation": mean_saturation,
+            "suspicious": bool(mean_saturation > 150)
+        }
+
+    def calculate_ai_probability(self, signals: Dict[str, Dict]) -> float:
+        """
+        Combine detection signals into single probability score.
+
+        Weighted ensemble of normalized signals.
+        Weights reflect empirical reliability of each signal.
+
+        Args:
+            signals: All detection signal dictionaries
+
+        Returns:
+            float: AI probability 0.0 (authentic) → 1.0 (AI-generated)
+        """
+        suspicious_count = sum([
+            signals["noise"]["suspicious"],
+            signals["frequency"]["suspicious"],
+            signals["jpeg"]["suspicious"],
+            signals["color"]["suspicious"]
+        ])
+
+        weights = {
+            "noise_consistency": 0.25,
+            "frequency_ratio":   0.25,
+            "blockiness":        0.20,
+            "color_entropy":     0.15,
+            "edge_density":      0.15
+        }
+
+        # Normalize each signal to [0, 1] where 1 = most suspicious
+        normalized_scores = {
+            "noise_consistency": max(0.0, 1.0 - signals["noise"]["noise_consistency"] / 0.5),
+            "frequency_ratio":   min(1.0, signals["frequency"]["frequency_ratio"] / 20.0),
+            "blockiness":        max(0.0, 1.0 - signals["jpeg"]["blockiness"] / 5.0),
+            "color_entropy":     max(0.0, 1.0 - signals["color"]["color_entropy"] / 5.0),
+            "edge_density":      max(0.0, 1.0 - signals["jpeg"]["edge_density"] / 0.05)
+        }
+
+        probability = sum(
+            score * weights[name]
+            for name, score in normalized_scores.items()
+        )
+
+        # Boost confidence when multiple independent signals agree
+        if suspicious_count >= 3:
+            probability = min(1.0, probability * 1.2)
+
+        logger.info(
+            f"AI probability: {probability:.3f} "
+            f"({suspicious_count}/4 signals suspicious)"
+        )
+
+        return float(probability)
+
+    def detect(self) -> Dict[str, Any]:
+        """
+        Run complete AI detection pipeline.
+
+        Returns:
+            Comprehensive detection report as JSON-serializable dict
+        """
+        logger.info(f"Starting AI detection for {self.filename}")
+
+        # Run all 4 independent detection signals
+        noise_signals = self.analyze_noise_patterns()
+        freq_signals  = self.analyze_frequency_domain()
+        jpeg_signals  = self.analyze_jpeg_artifacts()
+        color_signals = self.analyze_color_distribution()
+
+        all_signals = {
+            "noise":     noise_signals,
+            "frequency": freq_signals,
+            "jpeg":      jpeg_signals,
+            "color":     color_signals
+        }
+
+        ai_probability = self.calculate_ai_probability(all_signals)
+
+        # Classify based on probability threshold
+        if ai_probability > 0.7:
+            classification = "likely_ai_generated"
+            confidence     = "high"
+        elif ai_probability > 0.4:
+            classification = "possibly_ai_generated"
+            confidence     = "medium"
+        else:
+            classification = "likely_authentic"
+            confidence     = "high" if ai_probability < 0.2 else "medium"
+
+        report = {
+            "ai_probability": ai_probability,
+            "classification": classification,
+            "confidence": confidence,
+            "detection_signals": all_signals,
+            "summary": {
+                # int() ensures JSON-serializable (not numpy.int64)
+                "suspicious_signals_count": int(sum(
+                    s["suspicious"] for s in all_signals.values()
+                )),
+                "total_signals": len(all_signals)
+            }
+        }
+
+        logger.info(
+            f"Detection complete: {classification} "
+            f"(probability={ai_probability:.3f})"
+        )
+
+        return report

backend/tests/conftest.py

@@ -1,31 +1,58 @@
 """
-Shared test fixtures and configuration.
-Why: Reusable test setup across all test files.
+Shared test fixtures.
+Why: Reusable, realistic test data across all test files.
 """
 import pytest
+import numpy as np
+from io import BytesIO
+from PIL import Image
 from fastapi.testclient import TestClient
 from backend.main import app
 
 
 @pytest.fixture
 def client():
-    """
-    TestClient fixture for API testing.
-    Why: Provides synchronous client for easy testing.
-    """
+    """Synchronous test client for API endpoint testing."""
     return TestClient(app)
 
 
 @pytest.fixture
 def sample_image_bytes():
     """
-    Mock image file bytes for testing.
-    Why: Testing file uploads without real files.
+    Generate a realistic 100x100 test image.
+
+    Why 100x100 with noise?
+    - 1x1 pixel → all statistical metrics = 0 (meaningless)
+    - Gradient + Gaussian noise → simulates real camera photo
+    - Provides meaningful data for:
+        * Laplacian variance (noise analysis)
+        * FFT (frequency domain)
+        * 8x8 block analysis (JPEG artifacts)
+        * Color entropy (HSV histogram)
     """
-    # 1x1 PNG image (smallest valid PNG)
-    return (
-        b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01'
-        b'\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89'
-        b'\x00\x00\x00\nIDATx\x9cc\x00\x01\x00\x00\x05\x00\x01'
-        b'\r\n-\xb4\x00\x00\x00\x00IEND\xaeB`\x82'
-    )
+    np.random.seed(42)  # Deterministic for reproducible tests
+
+    # Build 100x100 RGB image with gradient base
+    img_array = np.zeros((100, 100, 3), dtype=np.uint8)
+
+    for i in range(100):
+        for j in range(100):
+            img_array[i, j] = [
+                int(i * 2.5),           # R: vertical gradient
+                int(j * 2.5),           # G: horizontal gradient
+                int((i + j) * 1.25)     # B: diagonal gradient
+            ]
+
+    # Add Gaussian noise (simulates camera sensor noise)
+    # Real photos: Noise ~ N(0, σ²), σ ≈ 10-20 for typical cameras
+    noise = np.random.normal(0, 15, img_array.shape).astype(np.int16)
+    img_array = np.clip(
+        img_array.astype(np.int16) + noise, 0, 255
+    ).astype(np.uint8)
+
+    # Encode as PNG bytes
+    buffer = BytesIO()
+    Image.fromarray(img_array, 'RGB').save(buffer, format='PNG')
+    buffer.seek(0)
+
+    return buffer.read()

backend/tests/test_validators.py

@@ -42,6 +42,6 @@ def test_validate_file_complete(sample_image_bytes):
     assert result["mime_type"] == "image/png"
     assert result["extension"] == "png"
     assert result["size_bytes"] > 0
-    assert result["size_mb"] < 0.01
+    assert result["size_mb"] < 1.0
     assert result["filename"] == "test.png"