Upload 3 files

app.py

@@ -0,0 +1,105 @@
+import gradio as gr
+import os
+import tempfile
+import time
+from facecomparison_multi_resume import DeepfakeDetector
+from PIL import Image
+
+# ===================================================================
+# 1. MENGAMBIL KUNCI API DARI ENVIRONMENT VARIABLES (SECRETS)
+#    Nama-nama ini harus sama persis dengan yang Anda set di Hugging Face Secrets!
+# ===================================================================
+
+API_KEYS = {
+    "qwen": os.environ.get("OPENROUTER_API_KEY_QWEN"),
+    "gpt": os.environ.get("OPENROUTER_API_KEY_GPT"),
+    "gemini": os.environ.get("OPENROUTER_API_KEY_GEMINI"),
+    "llama": os.environ.get("OPENROUTER_API_KEY_LLAMA"),
+    "cohere": os.environ.get("OPENROUTER_API_KEY_COHERE"),
+}
+
+MODEL_NAMES = ["qwen", "gpt", "gemini", "llama", "cohere"]
+
+# ===================================================================
+# 2. FUNGSI UTAMA UNTUK ANALISIS SATU GAMBAR
+# ===================================================================
+
+def analyze_image_with_llms(image_pil):
+    """
+    Menerima gambar PIL, memanggil 5 LLM secara berurutan, dan mengembalikan hasilnya.
+    """
+    if image_pil is None:
+        return "N/A", "N/A", "N/A", "N/A", "N/A"
+
+    # Simpan gambar yang diunggah sementara
+    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
+        # Gunakan mode RGB untuk kompatibilitas yang lebih baik
+        image_pil.convert("RGB").save(tmp_file.name, "JPEG", quality=90)
+        temp_path = tmp_file.name
+
+    all_results = {}
+    
+    for model_name in MODEL_NAMES:
+        api_key = API_KEYS.get(model_name)
+        
+        if not api_key:
+            all_results[model_name] = f"❌ Key Missing"
+            continue
+
+        try:
+            # Inisialisasi Detektor
+            detector = DeepfakeDetector(
+                api_key=api_key,
+                model_name=model_name,
+                use_face_detector=True # Tetap gunakan cropping RetinaFace
+            )
+            
+            # Panggil fungsi deteksi inti
+            result, _, _ = detector.detect_deepfake_llm(temp_path)
+            
+            # Ubah output yang ambigu menjadi 'ERROR' untuk tampilan UI yang bersih
+            if result == "UNKNOWN" or result == "ERROR":
+                 all_results[model_name] = f"⚠️ LLM Gagal Tebak"
+            else:
+                 all_results[model_name] = result
+            
+        except Exception as e:
+            all_results[model_name] = f"❌ API Error: {str(e)[:50]}"
+
+        # Tambahkan delay untuk menghindari Rate Limit OpenRouter
+        time.sleep(1.5) 
+
+    # Bersihkan file sementara
+    os.unlink(temp_path)
+
+    # Kembalikan hasil dalam urutan yang benar
+    return (
+        all_results.get("qwen", "Error"),
+        all_results.get("gpt", "Error"),
+        all_results.get("gemini", "Error"),
+        all_results.get("llama", "Error"),
+        all_results.get("cohere", "Error"),
+    )
+
+# ===================================================================
+# 3. INTERFACE GRADIOL
+# ===================================================================
+
+iface = gr.Interface(
+    fn=analyze_image_with_llms,
+    inputs=gr.Image(type="pil", label="🖼️ Upload Wajah untuk Analisis Deepfake"),
+    outputs=[
+        gr.Textbox(label="1. Qwen Prediction", type="text"),
+        gr.Textbox(label="2. GPT-4o Prediction", type="text"),
+        gr.Textbox(label="3. Gemini 2.5 Flash Prediction", type="text"),
+        gr.Textbox(label="4. Llama 3.2 Vision Prediction", type="text"),
+        gr.Textbox(label="5. Cohere Command R+ Prediction", type="text")
+    ],
+    title="🔬 Perbandingan LLM Multimodal untuk Deteksi Deepfake Wajah",
+    description="Unggah gambar wajah. 5 LLM Multimodal (via OpenRouter) akan menganalisis dan menebak: **REAL** atau **FAKE**.",
+    allow_flagging="never",
+    theme=gr.themes.Soft()
+)
+
+if __name__ == "__main__":
+    iface.launch()

facecomparison_multi_resume.py

@@ -0,0 +1,1251 @@
+# # #!/usr/bin/env python3
+# # import os
+# # import csv
+# # import time
+# # import base64
+# # from pathlib import Path
+# # from tqdm import tqdm
+# # import logging
+# # from PIL import Image
+# # import io
+# # from datetime import datetime
+# # from openai import OpenAI
+# # import numpy as np
+
+# # # === RetinaFace Configuration ===
+# # try:
+# #     from retinaface import RetinaFace
+# #     RETINAFACE_AVAILABLE = True
+# # except ImportError:
+# #     RETINAFACE_AVAILABLE = False
+# #     print("❌ ERROR: RetinaFace library not found. Please run 'pip install retina-face'. Running without face cropping.")
+
+# # # === LOGGING CONFIG ===
+# # os.makedirs("logs", exist_ok=True)
+# # logging.basicConfig(
+# #     filename=f"logs/run_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log",
+# #     level=logging.INFO,
+# #     format="%(asctime)s - %(levelname)s - %(message)s",
+# # )
+# # logger = logging.getLogger(__name__)
+
+
+# # class DeepfakeDetector:
+# #     """Deepfake Detection System (Qwen / GPT / Gemini / Llama / Cohere) with RetinaFace + adaptive delay"""
+
+# #     def __init__(self, api_key, model_name="qwen", debug_mode=False, start_from=0, use_face_detector=True):
+# #         self.api_key = api_key
+# #         self.model_name = model_name.lower()
+# #         self.debug_mode = debug_mode
+# #         self.start_from = start_from
+# #         self.dataset_folder = "dataset"
+# #         self.results_folder = "result"
+# #         self.csv_filename = f"result_{self.model_name}_{start_from}.csv"
+
+# #         # === OpenRouter API client ===
+# #         self.client = OpenAI(
+# #             base_url="https://openrouter.ai/api/v1",
+# #             api_key=self.api_key,
+# #         )
+# #         self.extra_headers = {
+# #             "HTTP-Referer": "https://github.com/retinaface-comparison",
+# #             "X-Title": "Deepfake Detection Adaptive"
+# #         }
+
+# #         # === Model map (5 LLMs) ===
+# #         self.model_map = {
+# #             "qwen": "qwen/qwen3-vl-8b-instruct",
+# #             "gpt": "openai/chatgpt-4o-latest",
+# #             "gemini": "google/gemini-2.5-flash",
+# #             "llama": "meta-llama/llama-3.2-90b-vision-instruct",
+# #             "cohere": "cohere/command-r-plus-08-2024",
+# #         }
+
+# #         if self.model_name not in self.model_map:
+# #             raise ValueError("❌ Invalid model name. Choose from: qwen, gpt, gemini, llama, cohere")
+
+# #         logger.info(f"Model selected: {self.model_name.upper()} ({self.model_map[self.model_name]})")
+
+# #         os.makedirs(self.results_folder, exist_ok=True)
+# #         self.use_face_detector = use_face_detector and RETINAFACE_AVAILABLE
+# #         self.target_size = 512
+
+# #         # Adaptive delay system
+# #         self.delay = 0.5
+# #         self.fail_count = 0
+# #         self.success_count = 0
+
+# #         print(f"\nModel: {self.model_name.upper()} | RetinaFace Cropping: {'ON' if self.use_face_detector else 'OFF'}")
+
+# #     # === Image handling (RetinaFace) ===
+# #     def preprocess_image_with_retinaface(self, image_path):
+# #         if not self.use_face_detector or not RETINAFACE_AVAILABLE:
+# #             return self.encode_image_simple(image_path)
+
+# #         try:
+# #             faces = RetinaFace.detect_faces(image_path)
+# #             if not faces:
+# #                 logger.warning(f"No face detected in {image_path}")
+# #                 return self.encode_image_simple(image_path)
+
+# #             # Ambil wajah utama
+# #             first_face = list(faces.values())[0]
+# #             facial_area = first_face.get("facial_area", None)
+# #             if not facial_area or len(facial_area) != 4:
+# #                 return self.encode_image_simple(image_path)
+
+# #             x1, y1, x2, y2 = facial_area
+# #             img = Image.open(image_path).convert("RGB")
+# #             cropped_img = img.crop((x1, y1, x2, y2))
+# #             cropped_img = cropped_img.resize((self.target_size, self.target_size))
+
+# #             buf = io.BytesIO()
+# #             cropped_img.save(buf, format="JPEG", quality=90, optimize=True)
+# #             encoded = base64.b64encode(buf.getvalue()).decode("utf-8")
+# #             return f"data:image/jpeg;base64,{encoded}"
+
+# #         except Exception as e:
+# #             logger.error(f"RetinaFace error on {image_path}: {e}")
+# #             return self.encode_image_simple(image_path)
+
+# #     def encode_image_simple(self, image_path):
+# #         try:
+# #             with open(image_path, "rb") as f:
+# #                 encoded = base64.b64encode(f.read()).decode("utf-8")
+# #                 return f"data:image/jpeg;base64,{encoded}"
+# #         except Exception as e:
+# #             logger.error(f"Encode error: {e}")
+# #             return None
+
+# #     def validate_image(self, image_path):
+# #         try:
+# #             if not os.path.exists(image_path):
+# #                 return False
+# #             with Image.open(image_path) as img:
+# #                 img.verify()
+# #             return True
+# #         except Exception:
+# #             return False
+
+# #     def normalize_output(self, content):
+# #         if not content:
+# #             return "UNKNOWN"
+# #         text = content.strip().upper()
+# #         if any(w in text for w in ["REAL", "GENUINE", "HUMAN"]):
+# #             return "REAL"
+# #         if any(w in text for w in ["FAKE", "DEEPFAKE", "AI", "SYNTHETIC", "GENERATED"]):
+# #             return "FAKE"
+# #         if "NOT FAKE" in text or "LOOKS REAL" in text:
+# #             return "REAL"
+# #         if "PROBABLY FAKE" in text or "MAYBE FAKE" in text:
+# #             return "FAKE"
+# #         return "UNKNOWN"
+
+# #     def reverify_qwen(self, img_b64, prev_result):
+# #         prompt = (
+# #             "Re-analyze this face image for deepfake signs. "
+# #             "Focus on lighting, symmetry, and unnatural skin artifacts. "
+# #             "Respond with one word only: REAL or FAKE."
+# #         )
+# #         print(f"🔁 Re-verifying Qwen result (was {prev_result})...")
+# #         try:
+# #             resp = self.client.chat.completions.create(
+# #                 extra_headers=self.extra_headers,
+# #                 model=self.model_map["qwen"],
+# #                 messages=[{
+# #                     "role": "user",
+# #                     "content": [
+# #                         {"type": "image_url", "image_url": {"url": img_b64}},
+# #                         {"type": "text", "text": prompt}
+# #                     ]
+# #                 }],
+# #                 max_tokens=50,
+# #                 temperature=0.1,
+# #             )
+# #             content = resp.choices[0].message.content.strip().upper()
+# #             if "FAKE" in content:
+# #                 print("✅ Changed to FAKE after second check")
+# #                 return "FAKE"
+# #             elif "REAL" in content:
+# #                 print("✅ Confirmed REAL after second check")
+# #                 return "REAL"
+# #             else:
+# #                 print("⚠️ Still ambiguous after recheck")
+# #                 return prev_result
+# #         except Exception as e:
+# #             print(f"⚠️ Qwen re-verification failed: {e}")
+# #             return prev_result
+
+# #     # === Deteksi utama ===
+# #     def detect_deepfake_llm(self, image_path):
+# #         prompt = (
+# #             "You are a forensic image analyst. Analyze this face image for any deepfake or AI manipulation. "
+# #             "Consider lighting, eyes, skin, and blending. Respond with only one word: REAL or FAKE."
+# #         )
+
+# #         if not self.validate_image(image_path):
+# #             return "ERROR", None, "invalid"
+
+# #         img_b64 = self.preprocess_image_with_retinaface(image_path)
+# #         if not img_b64:
+# #             return "ERROR", None, "invalid"
+
+# #         model_id = self.model_map[self.model_name]
+# #         method = "retinaface_crop" if self.use_face_detector else "original"
+
+# #         try:
+# #             resp = self.client.chat.completions.create(
+# #                 extra_headers=self.extra_headers,
+# #                 model=model_id,
+# #                 messages=[{
+# #                     "role": "user",
+# #                     "content": [
+# #                         {"type": "image_url", "image_url": {"url": img_b64}},
+# #                         {"type": "text", "text": prompt}
+# #                     ]
+# #                 }],
+# #                 max_tokens=50,
+# #                 temperature=0.1,
+# #             )
+# #             content = resp.choices[0].message.content
+# #             result = self.normalize_output(content)
+
+# #             if self.model_name == "qwen" and result == "REAL":
+# #                 result = self.reverify_qwen(img_b64, result)
+
+# #             return result, content, method
+
+# #         except Exception as e:
+# #             logger.error(f"Detection failed: {e}")
+# #             return "ERROR", None, method
+
+# #     # === Dataset & Resume ===
+# #     def get_images(self):
+# #         dataset_path = Path(self.dataset_folder)
+# #         real_path = dataset_path / "face_real"
+# #         fake_path = dataset_path / "face_fake"
+# #         if not real_path.exists() or not fake_path.exists():
+# #             print("❌ Dataset folders missing.")
+# #             return []
+# #         real_images = sorted(list(real_path.glob("*.jpg")))[:500]
+# #         fake_images = sorted(list(fake_path.glob("*.jpg")))[:500]
+# #         return [(str(p), "REAL") for p in real_images] + [(str(p), "FAKE") for p in fake_images]
+
+# #     def load_existing_results(self):
+# #         csv_path = os.path.join(self.results_folder, self.csv_filename)
+# #         if not os.path.exists(csv_path):
+# #             return []
+# #         results = []
+# #         with open(csv_path, "r", encoding="utf-8") as f:
+# #             reader = csv.reader(f)
+# #             next(reader)
+# #             for row in reader:
+# #                 if len(row) >= 5:
+# #                     results.append((row[0], row[1], row[2], row[3], row[4]))
+# #         logger.info(f"Loaded {len(results)} existing results")
+# #         return results
+
+# #     def save_results_to_csv(self, results):
+# #         csv_path = os.path.join(self.results_folder, self.csv_filename)
+# #         with open(csv_path, "w", newline="", encoding="utf-8") as f:
+# #             writer = csv.writer(f)
+# #             writer.writerow(["filename", "ground_truth", "llm_result", "model_name", "method"])
+# #             writer.writerows(results)
+# #         logger.info(f"Saved {len(results)} results to {csv_path}")
+
+# #     # === Adaptive delay logic ===
+# #     def adjust_delay(self):
+# #         if self.fail_count > 5:
+# #             self.delay = min(self.delay + 0.2, 2.0)
+# #             logger.warning(f"Increasing delay to {self.delay:.1f}s due to failures.")
+# #             self.fail_count = 0
+# #         elif self.success_count > 10:
+# #             self.delay = max(self.delay - 0.1, 0.3)
+# #             logger.info(f"Reducing delay to {self.delay:.1f}s (stable).")
+# #             self.success_count = 0
+
+# #     def run_detection(self, resume=True):
+# #         all_images = self.get_images()
+# #         if not all_images:
+# #             return
+
+# #         results = self.load_existing_results() if resume else []
+# #         processed = {r[0] for r in results}
+# #         remaining = [(p, gt) for p, gt in all_images if os.path.basename(p) not in processed]
+
+# #         print(f"\n=== STARTING {self.model_name.upper()} DETECTION ===")
+# #         print(f"Total: {len(all_images)} | Already done: {len(processed)} | Remaining: {len(remaining)}")
+
+# #         with tqdm(total=len(remaining), desc=f"{self.model_name.upper()}") as pbar:
+# #             for img_path, truth in remaining:
+# #                 try:
+# #                     result, response, method = self.detect_deepfake_llm(img_path)
+# #                     results.append((os.path.basename(img_path), truth, result, self.model_name, method))
+# #                     self.success_count += 1
+# #                 except Exception as e:
+# #                     logger.error(f"Fatal error: {e}")
+# #                     results.append((os.path.basename(img_path), truth, "ERROR", self.model_name, "error"))
+# #                     self.fail_count += 1
+
+# #                 pbar.set_description(f"{os.path.basename(img_path)} -> {result}")
+# #                 pbar.update(1)
+# #                 self.save_results_to_csv(results)
+# #                 self.adjust_delay()
+# #                 time.sleep(self.delay)
+
+# #         print(f"\n✅ Detection completed for {self.model_name.upper()}")
+# #         print(f"Results saved to: {os.path.join(self.results_folder, self.csv_filename)}")
+
+# #!/usr/bin/env python3
+# #!/usr/bin/env python3
+# import os
+# import csv
+# import time
+# import base64
+# from pathlib import Path
+# from tqdm import tqdm
+# import logging
+# from PIL import Image
+# import io
+# from datetime import datetime
+# from openai import OpenAI
+# import numpy as np
+# import math # Diperlukan untuk perhitungan akurasi
+
+# # RetinaFace Configuration
+# try:
+#     #retinaface
+#     from retinaface import RetinaFace 
+#     RETINAFACE_AVAILABLE = True
+# except ImportError:
+#     RETINAFACE_AVAILABLE = False
+#     print("❌ ERROR: RetinaFace library not found. Running without face cropping.")
+
+# # === LOGGING CONFIG ===
+# os.makedirs("logs", exist_ok=True)
+# logging.basicConfig(
+#     filename=f"logs/run_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log",
+#     level=logging.INFO,
+#     format="%(asctime)s - %(levelname)s - %(message)s",
+# )
+# logger = logging.getLogger(__name__)
+
+
+# class DeepfakeDetector:
+#     """Deepfake Detection System (Qwen / GPT / Gemini / Llama / Cohere) with RetinaFace + adaptive delay"""
+
+#     def __init__(self, api_key, model_name="qwen", debug_mode=False, start_from=0, use_face_detector=True):
+#         self.api_key = api_key
+#         self.model_name = model_name.lower()
+#         self.debug_mode = debug_mode
+#         self.start_from = start_from
+#         self.dataset_folder = "dataset"
+#         self.results_folder = "result"
+#         self.csv_filename = f"result_{self.model_name}_{start_from}.csv"
+
+#         # OpenRouter API client 
+#         self.client = OpenAI(
+#             base_url="https://openrouter.ai/api/v1",
+#             api_key=self.api_key,
+#         )
+#         self.extra_headers = {
+#             "HTTP-Referer": "https://github.com/retinaface-comparison",
+#             "X-Title": "Deepfake Detection Adaptive"
+#         }
+
+#         # Model map (5 LLMs via OpenRouter) 
+#         self.model_map = {
+#             "qwen": "qwen/qwen3-vl-8b-instruct",
+#             "gpt": "openai/chatgpt-4o-latest",
+#             "gemini": "google/gemini-2.5-flash",
+#             "llama": "meta-llama/llama-3.2-90b-vision-instruct",
+#             "cohere": "cohere/command-r-plus-08-2024",
+#         }
+
+#         if self.model_name not in self.model_map:
+#             raise ValueError("❌ Invalid model name. Choose from: qwen, gpt, gemini, llama, cohere")
+
+#         logger.info(f"Model selected: {self.model_name.upper()} ({self.model_map[self.model_name]})")
+
+#         os.makedirs(self.results_folder, exist_ok=True)
+#         self.use_face_detector = use_face_detector and RETINAFACE_AVAILABLE
+#         self.target_size = 512
+
+#         # waktu delay
+#         self.delay = 0.3
+#         self.fail_count = 0
+#         self.success_count = 0
+
+#         print(f"\nModel: {self.model_name.upper()} | RetinaFace Cropping: {'ON' if self.use_face_detector else 'OFF'}")
+
+#     # Image handling (RetinaFace)
+#     def preprocess_image_with_retinaface(self, image_path):
+#         if not self.use_face_detector or not RETINAFACE_AVAILABLE:
+#             return self.encode_image_simple(image_path)
+
+#         try:
+#             # Perlu diubah ke string karena RetinaFace kadang tidak menerima objek Path
+#             faces = RetinaFace.detect_faces(str(image_path)) 
+#             if not faces:
+#                 logger.warning(f"No face detected in {image_path}")
+#                 return self.encode_image_simple(image_path)
+
+#             first_face = list(faces.values())[0]
+#             facial_area = first_face.get("facial_area", None)
+#             if not facial_area or len(facial_area) != 4:
+#                 return self.encode_image_simple(image_path)
+
+#             x1, y1, x2, y2 = facial_area
+#             img = Image.open(image_path).convert("RGB")
+            
+#             # Tambahkan margin (ekstraksi)
+#             margin_ratio = 0.2
+#             w, h = x2 - x1, y2 - y1
+#             margin_x = int(w * margin_ratio)
+#             margin_y = int(h * margin_ratio)
+            
+#             x1 = max(0, x1 - margin_x)
+#             y1 = max(0, y1 - margin_y)
+#             x2 = min(img.width, x2 + margin_x)
+#             y2 = min(img.height, y2 + margin_y)
+            
+#             cropped_img = img.crop((x1, y1, x2, y2))
+#             cropped_img = cropped_img.resize((self.target_size, self.target_size), Image.Resampling.LANCZOS)
+
+#             buf = io.BytesIO()
+#             cropped_img.save(buf, format="JPEG", quality=90, optimize=True)
+#             encoded = base64.b64encode(buf.getvalue()).decode("utf-8")
+#             return f"data:image/jpeg;base64,{encoded}"
+
+#         except Exception as e:
+#             logger.error(f"RetinaFace error on {image_path}: {e}")
+#             return self.encode_image_simple(image_path)
+
+#     def encode_image_simple(self, image_path):
+#         try:
+#             with open(image_path, "rb") as f:
+#                 encoded = base64.b64encode(f.read()).decode("utf-8")
+#                 return f"data:image/jpeg;base64,{encoded}"
+#         except Exception as e:
+#             logger.error(f"Encode error: {e}")
+#             return None
+
+#     def validate_image(self, image_path):
+#         try:
+#             if not os.path.exists(image_path):
+#                 return False
+#             with Image.open(image_path) as img:
+#                 img.verify()
+#             return True
+#         except Exception:
+#             return False
+
+#     def normalize_output(self, content):
+#         """
+#         Normalizes verbose LLM output to a single word: REAL, FAKE, or UNKNOWN.
+#         """
+#         if not content:
+#             return "UNKNOWN"
+        
+#         text = content.strip().upper()
+        
+#         # Mencari kata kunci FAKE 
+#         if any(w in text for w in ["FAKE", "DEEPFAKE", "AI GENERATED", "SYNTHETIC"]):
+#             return "FAKE"
+            
+#         # Mencari kata kunci REAL
+#         if any(w in text for w in ["REAL", "GENUINE", "HUMAN", "NOT FAKE"]):
+#             return "REAL"
+        
+#         # Upaya kedua: Coba ambil kata pertama/kata kunci di tengah respons
+#         words = text.split()
+#         if words:
+#             for word in words[:3]: # Cek 3 kata pertama
+#                 if "REAL" in word: return "REAL"
+#                 if "FAKE" in word: return "FAKE"
+
+#         logger.warning(f"Output ambiguous/unpredictable: {content}")
+#         return "UNKNOWN"
+
+#     def reverify_qwen(self, img_b64, prev_result):
+#         # Logika re-verifikasi
+#         prompt = (
+#             "Re-analyze this face image for deepfake signs. "
+#             "Focus on lighting, symmetry, and unnatural skin artifacts. "
+#             "Respond with one word only: REAL or FAKE."
+#         )
+#         print(f"🔁 Re-verifying Qwen result (was {prev_result})...")
+#         try:
+#             resp = self.client.chat.completions.create(
+#                 extra_headers=self.extra_headers,
+#                 model=self.model_map["qwen"],
+#                 messages=[{
+#                     "role": "user",
+#                     "content": [
+#                         {"type": "image_url", "image_url": {"url": img_b64}},
+#                         {"type": "text", "text": prompt}
+#                     ]
+#                 }],
+#                 max_tokens=50,
+#                 temperature=0.1,
+#             )
+#             content = resp.choices[0].message.content.strip().upper()
+#             if "FAKE" in content:
+#                 print("Changed to FAKE after second check")
+#                 return "FAKE"
+#             elif "REAL" in content:
+#                 print("Confirmed REAL after second check")
+#                 return "REAL"
+#             else:
+#                 print("Still ambiguous after recheck")
+#                 return prev_result
+#         except Exception as e:
+#             print(f"Qwen re-verification failed: {e}")
+#             return prev_result
+            
+#     # Fungsi Fallback
+#     def retinaface_simple_fallback(self, image_path):
+#         """Applies a heuristic rule if LLM returns an error."""
+#         if not self.use_face_detector or not RETINAFACE_AVAILABLE:
+#             return 'UNKNOWN_FALLBACK'
+        
+#         try:
+#             # Panggil deteksi wajah (menggunakan str(image_path))
+#             faces = RetinaFace.detect_faces(str(image_path))
+#             if not faces:
+#                 return 'UNKNOWN_FALLBACK'
+            
+#             best_score = max(f['score'] for f in faces.values())
+            
+#             # Aturan Heuristik: Jika skor kepercayaan wajah sangat tinggi, REAL.
+#             if best_score > 0.995: 
+#                 return 'REAL'
+#             else:
+#                 return 'UNKNOWN_FALLBACK'
+                
+#         except Exception:
+#             return 'UNKNOWN_FALLBACK'
+
+#     # Deteksi utama
+#     def detect_deepfake_llm(self, image_path):
+#         prompt = (
+#             "You are a forensic image analyst. Analyze this face image for any deepfake or AI manipulation. "
+#             "Consider lighting, eyes, skin, and blending. Respond with only one word: REAL or FAKE."
+#         )
+
+#         if not self.validate_image(image_path):
+#             return "ERROR", None, "invalid"
+
+#         img_b64 = self.preprocess_image_with_retinaface(image_path)
+#         if not img_b64:
+#             return "ERROR", None, "invalid"
+
+#         model_id = self.model_map[self.model_name]
+#         method = "retinaface_crop" if self.use_face_detector else "original"
+
+#         try:
+#             resp = self.client.chat.completions.create(
+#                 extra_headers=self.extra_headers,
+#                 model=model_id,
+#                 messages=[{
+#                     "role": "user",
+#                     "content": [
+#                         {"type": "image_url", "image_url": {"url": img_b64}},
+#                         {"type": "text", "text": prompt}
+#                     ]
+#                 }],
+#                 max_tokens=50,
+#                 temperature=0.1,
+#             )
+#             content = resp.choices[0].message.content
+#             result = self.normalize_output(content)
+
+#             if self.model_name == "qwen" and result == "REAL":
+#                 result = self.reverify_qwen(img_b64, result)
+
+#             return result, content, method
+
+#         except Exception as e:
+#             logger.error(f"Detection failed: {e}")
+            
+#             # Tambahkan logika Fallback RetinaFace
+#             fallback_result = self.retinaface_simple_fallback(image_path)
+#             logger.warning(f"LLM Failed. Applying Fallback Logic: {fallback_result}")
+            
+#             if fallback_result == 'REAL':
+#                  # Jika heuristik RetinaFace yakin gambar BERKUALITAS BAGUS, prediksi REAL
+#                  return 'REAL', "RetinaFace Heuristic", "retinaface_crop_FALLBACK"
+            
+#             else:
+#                  return "FAKE", "RetinaFace Heuristic (Assumed FAKE)", "retinaface_crop" 
+    
+#     # === Dataset & Resume ===
+#     def get_images(self):
+#         dataset_path = Path(self.dataset_folder)
+#         real_path = dataset_path / "face_real"
+#         fake_path = dataset_path / "face_fake"
+#         if not real_path.exists() or not fake_path.exists():
+#             print("❌ Dataset folders missing.")
+#             return []
+            
+#         # Batasi gambar menjadi 500 REAL dan 500 FAKE (total 1000)
+#         real_images = sorted(list(real_path.glob("*.jpg")))[:500]
+#         fake_images = sorted(list(fake_path.glob("*.jpg")))[:500]
+        
+#         return [(str(p), "REAL") for p in real_images] + [(str(p), "FAKE") for p in fake_images]
+
+#     def load_existing_results(self):
+#         csv_path = os.path.join(self.results_folder, self.csv_filename)
+#         if not os.path.exists(csv_path):
+#             return []
+#         results = []
+#         with open(csv_path, "r", encoding="utf-8") as f:
+#             reader = csv.reader(f)
+#             next(reader)
+#             for row in reader:
+#                 # baris memiliki 5 kolom
+#                 if len(row) >= 5:
+#                     results.append((row[0], row[1], row[2], row[3], row[4]))
+#         logger.info(f"Loaded {len(results)} existing results")
+#         return results
+
+#     def save_results_to_csv(self, results):
+#         csv_path = os.path.join(self.results_folder, self.csv_filename)
+#         with open(csv_path, "w", newline="", encoding="utf-8") as f:
+#             writer = csv.writer(f)
+#             writer.writerow(["filename", "ground_truth", "llm_result", "model_name", "method"])
+#             writer.writerows(results)
+#         logger.info(f"Saved {len(results)} results to {csv_path}")
+
+#     # logika delay
+#     def adjust_delay(self):
+#         # Logika adaptive delay 
+#         if self.fail_count > 5:
+#             self.delay = min(self.delay + 0.2, 2.0)
+#             logger.warning(f"Increasing delay to {self.delay:.1f}s due to failures.")
+#             self.fail_count = 0
+#         elif self.success_count > 10:
+#             self.delay = max(self.delay - 0.1, 0.3)
+#             logger.info(f"Reducing delay to {self.delay:.1f}s (stable).")
+#             self.success_count = 0
+
+#     def run_detection(self, resume=True):
+#         all_images = self.get_images()
+#         if not all_images:
+#             return
+
+#         results = self.load_existing_results() if resume else []
+#         processed = {r[0] for r in results}
+#         remaining = [(p, gt) for p, gt in all_images if os.path.basename(p) not in processed]
+
+#         print(f"\n=== STARTING {self.model_name.upper()} DETECTION ===")
+#         print(f"Total: {len(all_images)} | Already done: {len(processed)} | Remaining: {len(remaining)}")
+
+#         with tqdm(total=len(remaining), desc=f"{self.model_name.upper()}") as pbar:
+#             for img_path, truth in remaining:
+#                 try:
+#                     result, response, method = self.detect_deepfake_llm(img_path)
+#                     results.append((os.path.basename(img_path), truth, result, self.model_name, method))
+#                     self.success_count += 1
+#                 except Exception as e:
+#                     logger.error(f"Fatal error: {e}")
+#                     results.append((os.path.basename(img_path), truth, "ERROR", self.model_name, "error"))
+#                     self.fail_count += 1
+
+#                 pbar.set_description(f"{os.path.basename(img_path)} -> {result}")
+#                 pbar.update(1)
+#                 self.save_results_to_csv(results)
+#                 self.adjust_delay()
+#                 time.sleep(self.delay)
+
+#         print(f"\n✅ Deteksi selesai untuk {self.model_name.upper()}")
+#         print(f"Hasil simpan ke: {os.path.join(self.results_folder, self.csv_filename)}")
+
+# #!/usr/bin/env python3
+# import os
+# import csv
+# import time
+# import base64
+# from pathlib import Path
+# from tqdm import tqdm
+# import logging
+# from PIL import Image
+# import io
+# from datetime import datetime
+# from openai import OpenAI
+# import numpy as np
+# import math 
+
+# # === RetinaFace Configuration ===
+# try:
+#     from retinaface import RetinaFace 
+#     RETINAFACE_AVAILABLE = True
+# except ImportError:
+#     RETINAFACE_AVAILABLE = False
+#     print("❌ ERROR: RetinaFace library not found. Please run 'pip install retina-face'. Running without face cropping.")
+
+# # === LOGGING CONFIG ===
+# os.makedirs("logs", exist_ok=True)
+# logging.basicConfig(
+#     filename=f"logs/run_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log",
+#     level=logging.INFO,
+#     format="%(asctime)s - %(levelname)s - %(message)s",
+# )
+# logger = logging.getLogger(__name__)
+
+
+# class DeepfakeDetector:
+#     """Deepfake Detection System (Qwen / GPT / Gemini / Llama / Cohere) with RetinaFace + adaptive delay"""
+
+#     def __init__(self, api_key, model_name="qwen", debug_mode=False, start_from=0, use_face_detector=True):
+#         self.api_key = api_key
+#         self.model_name = model_name.lower()
+#         self.debug_mode = debug_mode
+#         self.start_from = start_from
+#         self.dataset_folder = "dataset"
+#         self.results_folder = "result"
+#         self.csv_filename = f"result_{self.model_name}_{start_from}.csv"
+
+#         # === OpenRouter API client (Menggunakan OpenRouter untuk semua model) ===
+#         self.client = OpenAI(
+#             base_url="https://openrouter.ai/api/v1",
+#             api_key=self.api_key,
+#         )
+#         self.extra_headers = {
+#             "HTTP-Referer": "https://github.com/retinaface-comparison",
+#             "X-Title": "Deepfake Detection Adaptive"
+#         }
+
+#         # === Model map (5 LLMs via OpenRouter) ===
+#         self.model_map = {
+#             "qwen": "qwen/qwen3-vl-8b-instruct",
+#             "gpt": "openai/chatgpt-4o-latest",
+#             "gemini": "google/gemini-2.5-flash",
+#             "llama": "meta-llama/llama-3.2-90b-vision-instruct",
+#             "cohere": "cohere/command-r-plus-08-2024",
+#         }
+
+#         if self.model_name not in self.model_map:
+#             raise ValueError("❌ Invalid model name. Choose from: qwen, gpt, gemini, llama, cohere")
+
+#         logger.info(f"Model selected: {self.model_name.upper()} ({self.model_map[self.model_name]})")
+
+#         os.makedirs(self.results_folder, exist_ok=True)
+#         self.use_face_detector = False and RETINAFACE_AVAILABLE
+#         self.target_size = 512
+
+#         # waktu delay
+#         self.delay = 0.3
+#         self.fail_count = 0
+#         self.success_count = 0
+
+#         print(f"\nModel: {self.model_name.upper()} | RetinaFace Cropping: {'ON' if self.use_face_detector else 'OFF'}")
+
+#     # === Image handling (RetinaFace) ===
+#     def preprocess_image_with_retinaface(self, image_path):
+#         if not self.use_face_detector or not RETINAFACE_AVAILABLE:
+#             return self.encode_image_simple(image_path)
+
+#         try:
+#             # Perlu diubah ke string karena RetinaFace kadang tidak menerima objek Path
+#             faces = RetinaFace.detect_faces(str(image_path)) 
+#             if not faces:
+#                 logger.warning(f"No face detected in {image_path}")
+#                 return self.encode_image_simple(image_path)
+
+#             first_face = list(faces.values())[0]
+#             facial_area = first_face.get("facial_area", None)
+#             if not facial_area or len(facial_area) != 4:
+#                 return self.encode_image_simple(image_path)
+
+#             x1, y1, x2, y2 = facial_area
+#             img = Image.open(image_path).convert("RGB")
+            
+#             # Tambahkan margin (ekstraksi)
+#             margin_ratio = 0.2
+#             w, h = x2 - x1, y2 - y1
+#             margin_x = int(w * margin_ratio)
+#             margin_y = int(h * margin_ratio)
+            
+#             x1 = max(0, x1 - margin_x)
+#             y1 = max(0, y1 - margin_y)
+#             x2 = min(img.width, x2 + margin_x)
+#             y2 = min(img.height, y2 + margin_y)
+            
+#             cropped_img = img.crop((x1, y1, x2, y2))
+#             cropped_img = cropped_img.resize((self.target_size, self.target_size), Image.Resampling.LANCZOS)
+
+#             buf = io.BytesIO()
+#             cropped_img.save(buf, format="JPEG", quality=90, optimize=True)
+#             encoded = base64.b64encode(buf.getvalue()).decode("utf-8")
+#             return f"data:image/jpeg;base64,{encoded}"
+
+#         except Exception as e:
+#             logger.error(f"RetinaFace error on {image_path}: {e}")
+#             return self.encode_image_simple(image_path)
+
+#     def encode_image_simple(self, image_path):
+#         try:
+#             with open(image_path, "rb") as f:
+#                 encoded = base64.b64encode(f.read()).decode("utf-8")
+#                 return f"data:image/jpeg;base64,{encoded}"
+#         except Exception as e:
+#             logger.error(f"Encode error: {e}")
+#             return None
+
+#     def validate_image(self, image_path):
+#         try:
+#             if not os.path.exists(image_path):
+#                 return False
+#             with Image.open(image_path) as img:
+#                 img.verify()
+#             return True
+#         except Exception:
+#             return False
+
+#     def normalize_output(self, content):
+#         """
+#         Normalizes verbose LLM output to a single word: REAL, FAKE, or UNKNOWN.
+#         """
+#         if not content:
+#             return "UNKNOWN"
+        
+#         text = content.strip().upper()
+        
+#         # Mencari kata kunci FAKE (atau sinonim)
+#         if any(w in text for w in ["FAKE", "DEEPFAKE", "AI GENERATED", "SYNTHETIC"]):
+#             return "FAKE"
+            
+#         # Mencari kata kunci REAL (atau sinonim)
+            
+#         if any(w in text for w in ["REAL", "GENUINE", "HUMAN", "NOT FAKE"]):
+#             return "REAL"
+        
+#         # Upaya kedua: Coba ambil kata pertama/kata kunci di tengah respons
+#         words = text.split()
+#         if words:
+#             for word in words[:3]: # Cek 3 kata pertama
+#                 if "REAL" in word: return "REAL"
+#                 if "FAKE" in word: return "FAKE"
+
+#         logger.warning(f"Output ambiguous/unpredictable: {content}")
+#         return "UNKNOWN"
+
+#     def reverify_qwen(self, img_b64, prev_result):
+#         # Logika re-verifikasi
+#         prompt = (
+#             "Re-analyze this face image for deepfake signs. "
+#             "Focus on lighting, symmetry, and unnatural skin artifacts. "
+#             "Respond with one word only: REAL or FAKE."
+#         )
+#         print(f"🔁 Re-verifying Qwen result (was {prev_result})...")
+#         try:
+#             resp = self.client.chat.completions.create(
+#                 extra_headers=self.extra_headers,
+#                 model=self.model_map["qwen"],
+#                 messages=[{
+#                     "role": "user",
+#                     "content": [
+#                         {"type": "image_url", "image_url": {"url": img_b64}},
+#                         {"type": "text", "text": prompt}
+#                     ]
+#                 }],
+#                 max_tokens=50,
+#                 temperature=0.1,
+#             )
+#             content = resp.choices[0].message.content.strip().upper()
+#             if "FAKE" in content:
+#                 print("Changed to FAKE after second check")
+#                 return "FAKE"
+#             elif "REAL" in content:
+#                 print("Confirmed REAL after second check")
+#                 return "REAL"
+#             else:
+#                 print("Still ambiguous after recheck")
+#                 return prev_result
+#         except Exception as e:
+#             print(f"Qwen re-verification failed: {e}")
+#             return prev_result
+            
+#     # Fungsi Fallback Sederhana RetinaFace (Heuristik) DIHAPUS
+
+#     # === Deteksi utama ===
+#     def detect_deepfake_llm(self, image_path):
+#         prompt = (
+#             "You are a forensic image analyst. Analyze this face image for any deepfake or AI manipulation. "
+#             "Consider lighting, eyes, skin, and blending. Respond with only one word: REAL or FAKE."
+#         )
+
+#         if not self.validate_image(image_path):
+#             return "ERROR", None, "invalid"
+
+#         img_b64 = self.preprocess_image_with_retinaface(image_path)
+#         if not img_b64:
+#             return "ERROR", None, "invalid"
+
+#         model_id = self.model_map[self.model_name]
+#         method = "retinaface_crop" if self.use_face_detector else "original"
+
+#         try:
+#             resp = self.client.chat.completions.create(
+#                 extra_headers=self.extra_headers,
+#                 model=model_id,
+#                 messages=[{
+#                     "role": "user",
+#                     "content": [
+#                         {"type": "image_url", "image_url": {"url": img_b64}},
+#                         {"type": "text", "text": prompt}
+#                     ]
+#                 }],
+#                 max_tokens=50,
+#                 temperature=0.1,
+#             )
+#             content = resp.choices[0].message.content
+#             result = self.normalize_output(content)
+
+#             if self.model_name == "qwen" and result == "REAL":
+#                 result = self.reverify_qwen(img_b64, result)
+
+#             return result, content, method
+
+#         except Exception as e:
+#             logger.error(f"Detection failed: {e}")
+            
+#             # --- LOGIKA KETIKA LLM GAGAL (TIDAK ADA TEBAKAN) ---
+#             # Jika LLM gagal, catat sebagai ERROR.
+#             return "ERROR", None, "API_FAILURE" # Mengganti 'error' dengan 'API_FAILURE' untuk kejelasan
+    
+#     # === Dataset & Resume ===
+#     def get_images(self):
+#         dataset_path = Path(self.dataset_folder)
+#         real_path = dataset_path / "face_real"
+#         fake_path = dataset_path / "face_fake"
+#         if not real_path.exists() or not fake_path.exists():
+#             print("❌ Dataset folders missing.")
+#             return []
+            
+#         # Batasi gambar menjadi 500 REAL dan 500 FAKE (total 1000)
+#         real_images = sorted(list(real_path.glob("*.jpg")))[:500]
+#         fake_images = sorted(list(fake_path.glob("*.jpg")))[:500]
+        
+#         return [(str(p), "REAL") for p in real_images] + [(str(p), "FAKE") for p in fake_images]
+
+#     def load_existing_results(self):
+#         csv_path = os.path.join(self.results_folder, self.csv_filename)
+#         if not os.path.exists(csv_path):
+#             return []
+#         results = []
+#         with open(csv_path, "r", encoding="utf-8") as f:
+#             reader = csv.reader(f)
+#             next(reader)
+#             for row in reader:
+#                 # Pastikan baris memiliki 5 kolom
+#                 if len(row) >= 5:
+#                     results.append((row[0], row[1], row[2], row[3], row[4]))
+#         logger.info(f"Loaded {len(results)} existing results")
+#         return results
+
+#     def save_results_to_csv(self, results):
+#         csv_path = os.path.join(self.results_folder, self.csv_filename)
+#         with open(csv_path, "w", newline="", encoding="utf-8") as f:
+#             writer = csv.writer(f)
+#             writer.writerow(["filename", "ground_truth", "llm_result", "model_name", "method"])
+#             writer.writerows(results)
+#         logger.info(f"Saved {len(results)} results to {csv_path}")
+
+#     # === Adaptive delay logic ===
+#     def adjust_delay(self):
+#         # Logika adaptive delay
+#         if self.fail_count > 5:
+#             self.delay = min(self.delay + 0.2, 2.0)
+#             logger.warning(f"Increasing delay to {self.delay:.1f}s due to failures.")
+#             self.fail_count = 0
+#         elif self.success_count > 10:
+#             self.delay = max(self.delay - 0.1, 0.3)
+#             logger.info(f"Reducing delay to {self.delay:.1f}s (stable).")
+#             self.success_count = 0
+
+#     def run_detection(self, resume=True):
+#         all_images = self.get_images()
+#         if not all_images:
+#             return
+
+#         results = self.load_existing_results() if resume else []
+#         processed = {r[0] for r in results}
+#         remaining = [(p, gt) for p, gt in all_images if os.path.basename(p) not in processed]
+
+#         print(f"\n=== STARTING {self.model_name.upper()} DETECTION ===")
+#         print(f"Total: {len(all_images)} | Already done: {len(processed)} | Remaining: {len(remaining)}")
+
+#         with tqdm(total=len(remaining), desc=f"{self.model_name.upper()}") as pbar:
+#             for img_path, truth in remaining:
+#                 try:
+#                     result, response, method = self.detect_deepfake_llm(img_path)
+#                     results.append((os.path.basename(img_path), truth, result, self.model_name, method))
+#                     self.success_count += 1
+#                 except Exception as e:
+#                     logger.error(f"Fatal error: {e}")
+#                     results.append((os.path.basename(img_path), truth, "ERROR", self.model_name, "error"))
+#                     self.fail_count += 1
+
+#                 pbar.set_description(f"{os.path.basename(img_path)} -> {result}")
+#                 pbar.update(1)
+#                 self.save_results_to_csv(results)
+#                 self.adjust_delay()
+#                 time.sleep(self.delay)
+
+#         print(f"\n✅ Deteksi selesai untuk {self.model_name.upper()}")
+#         print(f"Hasil simpan ke: {os.path.join(self.results_folder, self.csv_filename)}")
+
+import os
+import time
+import base64
+from pathlib import Path
+import logging
+from PIL import Image
+import io
+from datetime import datetime
+from openai import OpenAI
+import numpy as np 
+# Hapus: import csv (Tidak diperlukan untuk inference Gradio)
+# Hapus: import tqdm (Tidak diperlukan untuk inference Gradio)
+# Hapus: import math (Tidak diperlukan untuk inference Gradio)
+
+# === RetinaFace Configuration ===
+try:
+    from retinaface import RetinaFace 
+    RETINAFACE_AVAILABLE = True
+except ImportError:
+    RETINAFACE_AVAILABLE = False
+    # Di lingkungan Gradio, pesan ini biasanya tidak terlihat, tapi biarkan saja.
+    # print("❌ ERROR: RetinaFace library not found. Running without face cropping.")
+
+# === LOGGING CONFIG ===
+os.makedirs("logs", exist_ok=True)
+logging.basicConfig(
+    filename=f"logs/run_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+class DeepfakeDetector:
+    """Deepfake Detection System (Qwen / GPT / Gemini / Llama / Cohere) for Single Image Inference"""
+
+    # Hapus: start_from=0, karena tidak relevan untuk single inference
+    def __init__(self, api_key, model_name="qwen", use_face_detector=True):
+        self.api_key = api_key
+        self.model_name = model_name.lower()
+        # self.debug_mode = debug_mode # Dihapus, karena tidak digunakan
+        
+        # Hapus properti terkait resume/dataset: self.start_from, self.dataset_folder, self.results_folder, self.csv_filename
+
+        # === OpenRouter API client ===
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=self.api_key,
+        )
+        self.extra_headers = {
+            # Ganti Referer agar sesuai dengan Hugging Face Space Anda nanti
+            "HTTP-Referer": "https://huggingface.co/spaces/[your-username]/[your-space-name]", 
+            "X-Title": f"Deepfake Detection Gradio ({self.model_name.upper()})"
+        }
+
+        # === Model map (5 LLMs via OpenRouter) ===
+        self.model_map = {
+            "qwen": "qwen/qwen3-vl-8b-instruct",
+            "gpt": "openai/chatgpt-4o-latest",
+            "gemini": "google/gemini-2.5-flash",
+            "llama": "meta-llama/llama-3.2-90b-vision-instruct",
+            "cohere": "cohere/command-r-plus-08-2024",
+        }
+
+        if self.model_name not in self.model_map:
+            raise ValueError("❌ Invalid model name. Choose from: qwen, gpt, gemini, llama, cohere")
+
+        logger.info(f"Model selected: {self.model_name.upper()} ({self.model_map[self.model_name]})")
+
+        # Hapus os.makedirs(self.results_folder, exist_ok=True) karena tidak menyimpan hasil.
+        
+        # PENTING: use_face_detector sekarang harus diinisialisasi berdasarkan input
+        self.use_face_detector = use_face_detector and RETINAFACE_AVAILABLE
+        self.target_size = 512
+
+        # Hapus: Properti terkait Adaptive delay (self.delay, self.fail_count, self.success_count)
+
+        # print(f"\nModel: {self.model_name.upper()} | RetinaFace Cropping: {'ON' if self.use_face_detector else 'OFF'}")
+
+    # === Image handling (RetinaFace) ===
+    # FUNGSI INI TETAP TIDAK BERUBAH
+    def preprocess_image_with_retinaface(self, image_path):
+        if not self.use_face_detector or not RETINAFACE_AVAILABLE:
+            return self.encode_image_simple(image_path)
+
+        try:
+            faces = RetinaFace.detect_faces(str(image_path)) 
+            if not faces:
+                logger.warning(f"No face detected in {image_path}")
+                return self.encode_image_simple(image_path)
+
+            first_face = list(faces.values())[0]
+            facial_area = first_face.get("facial_area", None)
+            if not facial_area or len(facial_area) != 4:
+                return self.encode_image_simple(image_path)
+
+            x1, y1, x2, y2 = facial_area
+            img = Image.open(image_path).convert("RGB")
+            
+            # Tambahkan margin (ekstraksi)
+            margin_ratio = 0.2
+            w, h = x2 - x1, y2 - y1
+            margin_x = int(w * margin_ratio)
+            margin_y = int(h * margin_ratio)
+            
+            x1 = max(0, x1 - margin_x)
+            y1 = max(0, y1 - margin_y)
+            x2 = min(img.width, x2 + margin_x)
+            y2 = min(img.height, y2 + margin_y)
+            
+            cropped_img = img.crop((x1, y1, x2, y2))
+            cropped_img = cropped_img.resize((self.target_size, self.target_size), Image.Resampling.LANCZOS)
+
+            buf = io.BytesIO()
+            cropped_img.save(buf, format="JPEG", quality=90, optimize=True)
+            encoded = base64.b64encode(buf.getvalue()).decode("utf-8")
+            return f"data:image/jpeg;base64,{encoded}"
+
+        except Exception as e:
+            logger.error(f"RetinaFace error on {image_path}: {e}")
+            return self.encode_image_simple(image_path)
+
+    # FUNGSI INI TETAP TIDAK BERUBAH
+    def encode_image_simple(self, image_path):
+        try:
+            with open(image_path, "rb") as f:
+                encoded = base64.b64encode(f.read()).decode("utf-8")
+                return f"data:image/jpeg;base64,{encoded}"
+        except Exception as e:
+            logger.error(f"Encode error: {e}")
+            return None
+
+    # FUNGSI INI TETAP TIDAK BERUBAH
+    def validate_image(self, image_path):
+        try:
+            if not os.path.exists(image_path):
+                return False
+            with Image.open(image_path) as img:
+                img.verify()
+            return True
+        except Exception:
+            return False
+
+    # FUNGSI INI TETAP TIDAK BERUBAH
+    def normalize_output(self, content):
+        """
+        Normalizes verbose LLM output to a single word: REAL, FAKE, or UNKNOWN.
+        """
+        if not content:
+            return "UNKNOWN"
+        
+        text = content.strip().upper()
+        
+        if any(w in text for w in ["FAKE", "DEEPFAKE", "AI GENERATED", "SYNTHETIC"]):
+            return "FAKE"
+            
+        if any(w in text for w in ["REAL", "GENUINE", "HUMAN", "NOT FAKE"]):
+            return "REAL"
+        
+        words = text.split()
+        if words:
+            for word in words[:3]:
+                if "REAL" in word: return "REAL"
+                if "FAKE" in word: return "FAKE"
+
+        logger.warning(f"Output ambiguous/unpredictable: {content}")
+        return "UNKNOWN"
+
+    # FUNGSI INI TETAP TIDAK BERUBAH
+    def reverify_qwen(self, img_b64, prev_result):
+        prompt = (
+            "Re-analyze this face image for deepfake signs. "
+            "Focus on lighting, symmetry, and unnatural skin artifacts. "
+            "Respond with one word only: REAL or FAKE."
+        )
+        # print(f"🔁 Re-verifying Qwen result (was {prev_result})...") # Komen untuk lingkungan UI
+        try:
+            resp = self.client.chat.completions.create(
+                extra_headers=self.extra_headers,
+                model=self.model_map["qwen"],
+                messages=[{
+                    "role": "user",
+                    "content": [
+                        {"type": "image_url", "image_url": {"url": img_b64}},
+                        {"type": "text", "text": prompt}
+                    ]
+                }],
+                max_tokens=50,
+                temperature=0.1,
+            )
+            content = resp.choices[0].message.content.strip().upper()
+            if "FAKE" in content:
+                # print("Changed to FAKE after second check")
+                return "FAKE"
+            elif "REAL" in content:
+                # print("Confirmed REAL after second check")
+                return "REAL"
+            else:
+                # print("Still ambiguous after recheck")
+                return prev_result
+        except Exception as e:
+            # print(f"Qwen re-verification failed: {e}")
+            return prev_result
+            
+    # === Deteksi utama ===
+    # FUNGSI INI TETAP TIDAK BERUBAH (Inti dari Single Inference)
+    def detect_deepfake_llm(self, image_path):
+        prompt = (
+            "You are a forensic image analyst. Analyze this face image for any deepfake or AI manipulation. "
+            "Consider lighting, eyes, skin, and blending. Respond with only one word: REAL or FAKE."
+        )
+
+        if not self.validate_image(image_path):
+            return "ERROR", None, "invalid"
+
+        img_b64 = self.preprocess_image_with_retinaface(image_path)
+        if not img_b64:
+            return "ERROR", None, "invalid"
+
+        model_id = self.model_map[self.model_name]
+        method = "retinaface_crop" if self.use_face_detector else "original"
+
+        try:
+            resp = self.client.chat.completions.create(
+                extra_headers=self.extra_headers,
+                model=model_id,
+                messages=[{
+                    "role": "user",
+                    "content": [
+                        {"type": "image_url", "image_url": {"url": img_b64}},
+                        {"type": "text", "text": prompt}
+                    ]
+                }],
+                max_tokens=50,
+                temperature=0.1,
+            )
+            content = resp.choices[0].message.content
+            result = self.normalize_output(content)
+
+            if self.model_name == "qwen" and result == "REAL":
+                result = self.reverify_qwen(img_b64, result)
+
+            return result, content, method
+
+        except Exception as e:
+            logger.error(f"Detection failed: {e}")
+            return "ERROR", None, "API_FAILURE" 
+    
+    # === Dataset & Resume ===
+    # HAPUS SEMUA FUNGSI BERIKUT: get_images, load_existing_results, save_results_to_csv, adjust_delay, run_detection
+    # Fungsi-fungsi tersebut tidak diperlukan untuk aplikasi web Gradio
+    pass # Pass diletakkan di sini hanya sebagai penanda bahwa sisanya telah dihapus.

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+openai
+Pillow
+tqdm
+numpy
+retina-face