Upload agents/statistical_agent.py with huggingface_hub

agents/statistical_agent.py

@@ -10,6 +10,7 @@ import numpy as np
 from PIL import Image
 from scipy.fftpack import dct
 from scipy.stats import kurtosis as scipy_kurtosis, entropy
+from scipy.ndimage import gaussian_filter
 from typing import Dict, Any
 
 from agents.optical_agent import AgentEvidence
@@ -179,13 +180,154 @@ def analyze_gradient_sparsity(img: Image.Image) -> Dict[str, Any]:
     }
 
 
+# ─── Local Kurtosis Map ──────────────────────────────────────────────
+def analyze_local_kurtosis(img: Image.Image) -> Dict[str, Any]:
+    """
+    Natural images have spatially varying kurtosis (textured vs smooth).
+    AI images often have unnaturally uniform local statistics.
+    """
+    gray = np.array(img.convert("L")).astype(np.float64)
+    h, w = gray.shape
+    block_size = 32
+    h_crop, w_crop = (h // block_size) * block_size, (w // block_size) * block_size
+    gray = gray[:h_crop, :w_crop]
+
+    local_kurts = []
+    for i in range(0, h_crop, block_size):
+        for j in range(0, w_crop, block_size):
+            block = gray[i:i + block_size, j:j + block_size].ravel()
+            if np.std(block) > 1:
+                local_kurts.append(float(scipy_kurtosis(block, fisher=True)))
+
+    if len(local_kurts) < 10:
+        return {"test": "Local Kurtosis Map", "score": 0.0, "note": "Insufficient blocks"}
+
+    local_kurts = np.array(local_kurts)
+    kurt_std = float(np.std(local_kurts))
+    kurt_mean = float(np.mean(local_kurts))
+
+    # Natural images: high variation in local kurtosis
+    if kurt_std > 3.0:
+        score = -0.3
+        note = f"High local kurtosis variation (σ={kurt_std:.2f}, natural spatial statistics)"
+    elif kurt_std < 1.0:
+        score = 0.4
+        note = f"Unnaturally uniform local statistics (σ={kurt_std:.2f}, AI-like)"
+    else:
+        score = 0.0
+        note = f"Moderate local kurtosis variation (σ={kurt_std:.2f})"
+
+    return {
+        "test": "Local Kurtosis Map",
+        "kurtosis_std": round(kurt_std, 4),
+        "kurtosis_mean": round(kurt_mean, 4),
+        "score": score,
+        "note": note,
+    }
+
+
+# ─── Color Histogram Analysis ───────────────────────────────────────
+def analyze_color_histogram(img: Image.Image) -> Dict[str, Any]:
+    """
+    Natural images have smooth, continuous color histograms.
+    AI/GAN images can show comb-like gaps or unusual peaks in histograms.
+    """
+    rgb = np.array(img.convert("RGB"))
+
+    anomaly_scores = []
+    for c, name in enumerate(["Red", "Green", "Blue"]):
+        hist, _ = np.histogram(rgb[:, :, c].ravel(), bins=256, range=(0, 256))
+        hist = hist.astype(np.float64)
+
+        # Check for gaps (zero bins surrounded by non-zero)
+        zero_bins = np.sum(hist == 0)
+
+        # Check for comb pattern (alternating zero/nonzero)
+        diffs = np.diff((hist > 0).astype(int))
+        transitions = int(np.sum(np.abs(diffs)))
+
+        # Smoothness: ratio of histogram derivative to histogram
+        hist_smooth = gaussian_filter(hist.astype(np.float64), sigma=2)
+        smoothness = float(np.mean(np.abs(hist - hist_smooth)) / (np.mean(hist) + 1e-9))
+
+        anomaly_scores.append(smoothness)
+
+    avg_smoothness = float(np.mean(anomaly_scores))
+
+    if avg_smoothness < 0.3:
+        score = -0.2
+        note = f"Smooth color histograms (smoothness={avg_smoothness:.3f}, natural)"
+    elif avg_smoothness > 0.8:
+        score = 0.4
+        note = f"Irregular color histograms (smoothness={avg_smoothness:.3f}, manipulation artifact)"
+    else:
+        score = 0.0
+        note = f"Normal histogram smoothness ({avg_smoothness:.3f})"
+
+    return {
+        "test": "Color Histogram Analysis",
+        "histogram_smoothness": round(avg_smoothness, 4),
+        "score": score,
+        "note": note,
+    }
+
+
+# ─── Wavelet Coefficient Distribution ───────────────────────────────
+def analyze_wavelet_coefficients(img: Image.Image) -> Dict[str, Any]:
+    """
+    Natural image wavelet coefficients follow generalized Gaussian.
+    AI images show deviations, especially at high-frequency subbands.
+    Uses Haar wavelet (simple, no pywt dependency needed).
+    """
+    gray = np.array(img.convert("L")).astype(np.float64)
+    h, w = gray.shape
+    h2, w2 = h // 2 * 2, w // 2 * 2
+    gray = gray[:h2, :w2]
+
+    # Simple Haar wavelet decomposition
+    # Level 1
+    ll = (gray[0::2, 0::2] + gray[0::2, 1::2] + gray[1::2, 0::2] + gray[1::2, 1::2]) / 4
+    lh = (gray[0::2, 0::2] + gray[0::2, 1::2] - gray[1::2, 0::2] - gray[1::2, 1::2]) / 4
+    hl = (gray[0::2, 0::2] - gray[0::2, 1::2] + gray[1::2, 0::2] - gray[1::2, 1::2]) / 4
+    hh = (gray[0::2, 0::2] - gray[0::2, 1::2] - gray[1::2, 0::2] + gray[1::2, 1::2]) / 4
+
+    # Analyze high-frequency subbands
+    hf_coeffs = np.concatenate([lh.ravel(), hl.ravel(), hh.ravel()])
+    hf_coeffs = hf_coeffs[hf_coeffs != 0]
+
+    if len(hf_coeffs) < 100:
+        return {"test": "Wavelet Coefficients", "score": 0.0, "note": "Insufficient data"}
+
+    kurt = float(scipy_kurtosis(hf_coeffs, fisher=True))
+    # Generalized Gaussian: natural images have kurtosis > 3
+    # AI images: often lower kurtosis (more Gaussian-like)
+
+    if kurt > 5.0:
+        score = -0.3
+        note = f"Heavy-tailed wavelet coefficients (kurtosis={kurt:.2f}, natural)"
+    elif kurt < 1.5:
+        score = 0.4
+        note = f"Gaussian-like wavelet coefficients (kurtosis={kurt:.2f}, AI-like)"
+    else:
+        score = 0.0
+        note = f"Wavelet kurtosis={kurt:.2f}"
+
+    return {
+        "test": "Wavelet Coefficients",
+        "hf_kurtosis": round(kurt, 4),
+        "score": score,
+        "note": note,
+    }
+
+
 # ─── Main Agent Entry Point ─────────────────────────────────────────
 def run_statistical_agent(img: Image.Image) -> AgentEvidence:
     """Run all statistical priors tests."""
     findings = []
     scores = []
 
-    for fn in [analyze_dct_distribution, analyze_benford, analyze_gradient_sparsity]:
+    for fn in [analyze_dct_distribution, analyze_benford, analyze_gradient_sparsity,
+               analyze_local_kurtosis, analyze_color_histogram, analyze_wavelet_coefficients]:
         try:
             result = fn(img)
             findings.append(result)
@@ -214,7 +356,7 @@ def run_statistical_agent(img: Image.Image) -> AgentEvidence:
         agent_name="Statistical Priors Agent",
         violation_score=np.clip(avg_score, -1, 1),
         confidence=confidence,
-        failure_prob=max(0.0, 1.0 - len(scores) / 3),
+        failure_prob=max(0.0, 1.0 - len(scores) / 6),
         rationale=rationale,
         sub_findings=findings,
     )