Update app.py

app.py

@@ -1,239 +1,78 @@
-# app.py
-import gradio as gr
-from transformers import pipeline
-from PIL import Image, ExifTags
+import cv2
 import numpy as np
+from PIL import Image, ExifTags
+from transformers import pipeline
 
-# 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
-
-# ------------------------
-# 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)
-
-# ------------------------
-# 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)
+# === Load dua model AI detector ===
+detector1 = pipeline("image-classification", model="umm-maybe/AI-image-detector")
+detector2 = pipeline("image-classification", model="fal-ai/ai-or-not")
 
-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))
+# === Forensik sederhana ===
+def forensic_analysis(img_path):
+    img = cv2.imread(img_path)
 
-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))
+    # Blur score (varian Laplacian)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
 
-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
+    # Noise score (std dev setelah highpass filter)
+    noise = cv2.GaussianBlur(gray, (3, 3), 0)
+    highpass = cv2.subtract(gray, noise)
+    noise_score = np.std(highpass)
 
-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))
+    # High frequency ratio (FFT)
+    f = np.fft.fft2(gray)
+    fshift = np.fft.fftshift(f)
+    magnitude_spectrum = np.abs(fshift)
+    hfreq_ratio = np.mean(magnitude_spectrum > np.percentile(magnitude_spectrum, 95))
 
-def has_camera_exif(img: Image.Image):
+    # EXIF check
     try:
-        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
+        pil_img = Image.open(img_path)
+        exif = pil_img._getexif()
+        exif_exists = exif is not None
     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
+        exif_exists = False
 
-    # 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)
-
-    # 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
+    return {
+        "blur": round(blur_score, 2),
+        "noise": round(noise_score, 2),
+        "hfreq_ratio": round(hfreq_ratio, 3),
+        "exif": exif_exists
     }
 
-# ------------------------
-# 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
+# === Deteksi AI vs Asli dengan ensemble ===
+def detect_ai(img_path):
+    results1 = detector1(img_path)
+    results2 = detector2(img_path)
 
-        # 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)
+    # Ambil skor "AI" (label bisa berbeda di tiap model)
+    score1 = max([r['score'] for r in results1 if "artificial" in r['label'].lower()] + [0])
+    score2 = max([r['score'] for r in results2 if "ai" in r['label'].lower()] + [0])
 
-        # 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)
+    ai_score = (score1 + score2) / 2 * 100
+    real_score = 100 - ai_score
 
-        # 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"
+    forensic = forensic_analysis(img_path)
 
-        # Build output message
-        out = f"""
-### Hasil Deteksi:
-{verdict}
-
-**Persentase:** {ai_score}% AI  /  {real_score}% Asli
-
-**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"}
-
-**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)}"
+    # Aturan custom
+    if ai_score > 60:
+        verdict = "🟥 AI"
+    elif real_score > 60 and forensic["exif"]:
+        verdict = "🟩 Asli"
+    else:
+        verdict = "⚠️ Meragukan"
 
-# Gradio UI
-iface = gr.Interface(
-    fn=detect_image,
-    inputs=gr.Image(type="pil"),
-    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%."
-)
+    return {
+        "AI_score": round(ai_score, 2),
+        "Real_score": round(real_score, 2),
+        "Forensic": forensic,
+        "Verdict": verdict
+    }
 
+# === Contoh pemakaian ===
 if __name__ == "__main__":
-    iface.launch()
+    img_path = "download.jpeg"  # ganti sesuai nama file upload
+    result = detect_ai(img_path)
+    print("Hasil Deteksi:")
+    print(result)