Update app.py

app.py

@@ -1,87 +1,239 @@
+# app.py
 import gradio as gr
 from transformers import pipeline
 from PIL import Image, ExifTags
-import cv2
 import numpy as np
 
-# Model Hugging Face untuk AI vs Human
-detector = pipeline("image-classification", model="microsoft/resnet-50")
+# Try import cv2 (opencv-headless). If not available, fallback ke numpy-only functions.
+try:
+    import cv2
+    HAS_CV2 = True
+except Exception:
+    cv2 = None
+    HAS_CV2 = False
 
-def analyze_image(image):
-    # Convert ke format OpenCV
-    img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+# ------------------------
+# Load HF detector (may require torch installed in requirements.txt)
+# ------------------------
+try:
+    hf_detector = pipeline("image-classification", model="umm-maybe/AI-image-detector")
+except Exception as e:
+    hf_detector = None
+    print("Warning: hf_detector gagal dimuat:", e)
 
-    # ---- 1. Prediksi dengan model HF ----
-    preds = detector(image)
-    ai_score = 0.0
-    human_score = 0.0
-    for p in preds:
-        if "artificial" in p["label"].lower() or "ai" in p["label"].lower():
-            ai_score += p["score"]
-        else:
-            human_score += p["score"]
+# ------------------------
+# Forensic helper functions (works with or without cv2)
+# ------------------------
+def pil_to_gray_array(img: Image.Image):
+    return np.array(img.convert("L"), dtype=np.float32)
+
+def estimate_blur(img: Image.Image):
+    arr = pil_to_gray_array(img)
+    if HAS_CV2:
+        return float(cv2.Laplacian(arr.astype(np.uint8), cv2.CV_64F).var())
+    # fallback: gradient variance
+    gx, gy = np.gradient(arr)
+    return float(np.var(gx + gy))
 
-    # Normalisasi biar total 1
-    total = ai_score + human_score
-    if total > 0:
-        ai_score /= total
-        human_score /= total
+def estimate_noise(img: Image.Image):
+    arr = pil_to_gray_array(img)
+    if HAS_CV2:
+        # remove low-frequency via gaussian blur then std
+        blurred = cv2.GaussianBlur(arr, (5,5), 0)
+        noise = arr - blurred
+        return float(np.std(noise))
+    # fallback
+    blurred = np.mean(arr)
+    noise = arr - blurred
+    return float(np.std(noise))
 
-    # ---- 2. Analisis blur/noise ----
-    gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
-    blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
-    noise_score = np.std(gray)
+def block_highfreq_ratio(img: Image.Image, block=8):
+    # compute ratio of high-frequency energy per 8x8 block via FFT (fallback for DCT)
+    arr = pil_to_gray_array(img)
+    h, w = arr.shape
+    # pad to multiple of block
+    ph = ((block - (h % block)) % block)
+    pw = ((block - (w % block)) % block)
+    if ph or pw:
+        arr = np.pad(arr, ((0, ph), (0, pw)), mode='reflect')
+    H, W = arr.shape
+    total_energy = 0.0
+    low_energy = 0.0
+    # iterate blocks (vectorized)
+    for i in range(0, H, block):
+        for j in range(0, W, block):
+            b = arr[i:i+block, j:j+block]
+            # 2D FFT
+            F = np.fft.fft2(b)
+            mag = np.abs(F)
+            total_energy += mag.sum()
+            # low freq: center-ish -> take top-left 2x2 as low freq approx
+            low_energy += mag[0:2, 0:2].sum()
+    if total_energy <= 1e-9:
+        return 0.0
+    high_ratio = float((total_energy - low_energy) / total_energy)  # 0..1
+    return high_ratio
 
-    # Semakin kecil blur/noise → semakin cenderung AI
-    blur_factor = 1.0 if blur_score < 100 else 0.0
-    noise_factor = 1.0 if noise_score < 20 else 0.0
+def edge_std(img: Image.Image):
+    arr = pil_to_gray_array(img)
+    if HAS_CV2:
+        edges = cv2.Canny(arr.astype(np.uint8), 100, 200)
+        return float(np.std(edges))
+    gx, gy = np.gradient(arr)
+    edges = np.hypot(gx, gy)
+    return float(np.std(edges))
 
-    # ---- 3. Cek metadata kamera ----
-    has_metadata = False
+def has_camera_exif(img: Image.Image):
     try:
-        exif = image._getexif()
-        if exif is not None:
-            for tag, value in exif.items():
-                decoded = ExifTags.TAGS.get(tag, tag)
-                if decoded in ["Make", "Model"]:
-                    has_metadata = True
+        exif = img._getexif()
+        if not exif:
+            return False
+        for tag, val in exif.items():
+            name = ExifTags.TAGS.get(tag, tag)
+            if name in ("Make", "Model", "LensModel", "FNumber", "ExposureTime"):
+                return True
     except:
         pass
+    return False
+
+# ------------------------
+# Scoring / Ensemble logic
+# ------------------------
+def final_ai_score_from_components(hf_label, hf_conf, blur, noise, hfreq_ratio, edges, exif_present):
+    # hf_conf is 0..1
+    # 1) HF detector contribution
+    if hf_label is None:
+        hf_contrib = 0.0
+    else:
+        lab = hf_label.lower()
+        if any(x in lab for x in ("fake","artificial","ai")):
+            hf_contrib = hf_conf * 100.0
+        elif "human" in lab or "real" in lab:
+            # do not trust 'human' fully; translate into moderate ai signal
+            hf_contrib = (1.0 - hf_conf) * 100.0 * 0.6
+        else:
+            hf_contrib = (1.0 - hf_conf) * 100.0 * 0.8
+
+    # 2) Forensic contributions -> produce scores 0..100 where larger = more likely AI
+    # noise: low noise => AI-ish
+    noise_norm = noise / 100.0  # normalize roughly; adjust if needed
+    noise_score = max(0.0, min(1.0, 1.0 - noise_norm)) * 100.0
+
+    # blur: low variance (very smooth) => AI-ish
+    blur_norm = blur / 500.0
+    blur_score = max(0.0, min(1.0, 1.0 - blur_norm)) * 100.0
+
+    # high-frequency ratio: very low high-freq => too-smooth => AI-ish (we expect hfreq_ratio small -> AI)
+    # hfreq_ratio is 0..1, low -> AI
+    hfreq_score = max(0.0, min(1.0, 0.2 - hfreq_ratio) / 0.2) * 100.0  # thresholding at ~0.2
+
+    # edges: low edge std => AI-ish
+    edges_norm = edges / 30.0
+    edge_score = max(0.0, min(1.0, 1.0 - edges_norm)) * 100.0
+
+    # combine forensic scores (weights can be tuned)
+    forensic_score = (0.35 * noise_score + 0.30 * blur_score + 0.20 * hfreq_score + 0.15 * edge_score)
 
-    metadata_factor = 0.0 if has_metadata else 1.0
+    # 3) Combine HF + Forensic
+    combined = 0.6 * hf_contrib + 0.4 * forensic_score  # 0..100
+
+    # 4) EXIF adjustment: if EXIF present, reduce AI score significantly
+    if exif_present:
+        combined = max(0.0, combined - 30.0)
+
+    # Clamp
+    combined = max(0.0, min(100.0, combined))
+    return combined, {
+        "hf_contrib": hf_contrib,
+        "forensic_score": forensic_score,
+        "noise_score": noise_score,
+        "blur_score": blur_score,
+        "hfreq_score": hfreq_score,
+        "edge_score": edge_score
+    }
+
+# ------------------------
+# Main detect function
+# ------------------------
+def detect_image(img: Image.Image):
+    try:
+        # ensure PIL image
+        if not isinstance(img, Image.Image):
+            img = Image.fromarray(np.array(img))
+
+        # HF detector inference (if available)
+        hf_label = None
+        hf_conf = 0.0
+        if hf_detector is not None:
+            try:
+                res = hf_detector(img, top_k=1)
+                if isinstance(res, list) and len(res) > 0:
+                    hf_label = res[0].get("label", "")
+                    hf_conf = float(res[0].get("score", 0.0))
+            except Exception as e:
+                # fallback: ignore
+                hf_label = None
+                hf_conf = 0.0
+
+        # Forensic measures
+        blur = estimate_blur(img)
+        noise = estimate_noise(img)
+        hfreq = block_highfreq_ratio(img)
+        edges = edge_std(img)
+        exif_ok = has_camera_exif(img)
+
+        # Compute final AI score (0..100)
+        ai_score, comps = final_ai_score_from_components(hf_label, hf_conf, blur, noise, hfreq, edges, exif_ok)
+        real_score = round(100.0 - ai_score, 2)
+        ai_score = round(ai_score, 2)
+
+        # Interpretations / labels
+        if ai_score >= 90:
+            verdict = "🤖 Gambar ini TERLALU MOGOK: Hasil AI (sangat tinggi)"
+        elif ai_score >= 60:
+            verdict = "🤖 Gambar ini kemungkinan besar DIHASILKAN AI"
+        elif ai_score <= 15:
+            verdict = "✅ Gambar ini tampak ASLI (sangat tinggi)"
+        elif ai_score <= 40:
+            verdict = "✅ Gambar ini kemungkinan besar ASLI"
+        else:
+            verdict = f"⚖️ Gambar ini {ai_score}% AI / {real_score}% Asli"
 
-    # ---- 4. Ensemble skor ----
-    final_score = (
-        0.6 * ai_score +
-        0.2 * blur_factor +
-        0.1 * noise_factor +
-        0.1 * metadata_factor
-    )
+        # Build output message
+        out = f"""
+### Hasil Deteksi:
+{verdict}
 
-    result = "AI Generated" if final_score > 0.5 else "Foto Asli"
+**Persentase:** {ai_score}% AI  /  {real_score}% Asli
 
-    # ---- 5. Hasil detail ----
-    details = f"""
-    🔍 Hasil Deteksi:
-    {result}
+**Model Prediksi:** {hf_label if hf_label else 'N/A'} ({hf_conf:.2f})
+**Forensik (angka):**
+- Blur (var Laplacian / grad-var): {blur:.2f}
+- Noise (std highpass): {noise:.2f}
+- HighFreq Ratio (block FFT): {hfreq:.3f}
+- Edge STD: {edges:.2f}
+- EXIF Kamera: {"Ada" if exif_ok else "Tidak"}
 
-    Skor Model AI-detector: {ai_score:.2f}
-    Skor Human: {human_score:.2f}
-    Blur Score: {blur_score:.2f}
-    Noise Score: {noise_score:.2f}
-    Metadata Kamera: {"Ada" if has_metadata else "Tidak Ada"}
-    Final Score: {final_score:.2f}
-    """
-    return details
+**Komponen skor (internal):**
+- hf_contrib: {comps['hf_contrib']:.2f}
+- forensic_score: {comps['forensic_score']:.2f}
+- noise_score: {comps['noise_score']:.2f}
+- blur_score: {comps['blur_score']:.2f}
+- hfreq_score: {comps['hfreq_score']:.2f}
+- edge_score: {comps['edge_score']:.2f}
+"""
+        return out
+    except Exception as e:
+        return f"⚠️ Terjadi error saat deteksi: {str(e)}"
 
 # Gradio UI
-demo = gr.Interface(
-    fn=analyze_image,
+iface = gr.Interface(
+    fn=detect_image,
     inputs=gr.Image(type="pil"),
-    outputs="text",
-    title="AI vs Real Image Detector",
-    description="Upload foto untuk mendeteksi apakah gambar asli atau hasil AI."
+    outputs="markdown",
+    title="Improved Hybrid AI vs Real Detector",
+    description="Gabungan model HF + forensik (noise, blur, DCT/FFT block, edge, EXIF). Tidak ada jaminan 100%."
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch()