Update app.py

app.py

@@ -1,88 +1,3 @@
-#!/usr/bin/env python3
-import os
-import sys
-import traceback
-from typing import Optional, Tuple, Dict, Any, List
-
-import importlib.util
-import time
-import cv2
-import torch
-import numpy as np
-import gradio as gr
-from PIL import Image, ImageOps
-from torchvision import transforms
-import torch.nn as nn
-import torch.nn.functional as F
-import traceback
-from torchvision.models import vit_b_16
-from transformers import AutoModel, CLIPImageProcessor
-import joblib
-import zipfile
-import json
-from datetime import datetime
-import requests
-import base64
-import io
-
-
-# Check if detectron2 is installed and attempt installation if needed
-if importlib.util.find_spec("detectron") is None:
-    print("🔄 Detectron2 not found. Attempting installation...")
-    print("Installing PyTorch and Detectron2...")
-    os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
-    os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
-    print("Installation complete!")
-
-# Optional Detectron2 import
-DETECTRON2_AVAILABLE = False
-try:
-    print("Attempting to import Detectron2...")
-    from detectron2.engine import DefaultPredictor
-    from detectron2.config import get_cfg
-    from detectron2.utils.visualizer import Visualizer, ColorMode
-    from detectron2 import model_zoo
-
-    DETECTRON2_AVAILABLE = True
-    print("✅ Detectron2 imported successfully")
-except ImportError as e:
-    print(f"⚠️ Detectron2 not available: {e}")
-    DETECTRON2_AVAILABLE = False
-
-# Try to download model from Hugging Face
-huggingface_model_path = None
-try:
-    from huggingface_hub import hf_hub_download
-
-    # Try to download from your repository
-    huggingface_model_path = hf_hub_download(
-        repo_id=os.getenv('PRIVATE_REPO', 'fallback'),
-        filename="V1.pkl",
-        token=os.getenv('key')
-    )
-    print(f"✅ Model downloaded from Hugging Face: {huggingface_model_path}")
-except Exception as e:
-    print(f"⚠️ Could not download model from Hugging Face: {e}")
-    print("🔄 Will use demo mode with simulated results")
-    huggingface_model_path = None
-# --------------------------------------------------------------------------------------
-# Basics
-
-# Initialize device for model
-if torch.backends.mps.is_available():
-    RADIO_DEVICE = torch.device("mps")
-elif torch.cuda.is_available():
-    RADIO_DEVICE = torch.device("cuda")
-else:
-    RADIO_DEVICE = torch.device("cpu")
-
-# Global variables for C model
-radio_l_image_processor = None
-radio_l_model = None
-ai_detection_classifier = None
-
-
-# Preload the C model at startup
 def preload_models():
     """Preload models at startup to improve response time"""
     global radio_l_image_processor, radio_l_model
@@ -92,651 +7,28 @@ def preload_models():
         hf_repo = os.getenv('MODEL_REPO', 'fallback')
         if hf_repo and hf_repo != 'fallback':
             from transformers import AutoModel, CLIPImageProcessor
-            radio_l_image_processor = CLIPImageProcessor.from_pretrained(hf_repo)
+            
+            # Load the model first to inspect it
             radio_l_model = AutoModel.from_pretrained(hf_repo, trust_remote_code=True)
+            
+            # Debug: Print available keys
+            state_dict = radio_l_model.state_dict()
+            print("Available keys in model (first 10):")
+            for i, key in enumerate(list(state_dict.keys())[:10]):
+                print(f"  {key}")
+            
+            # Check for blocks.0.ls1 related keys
+            ls1_keys = [k for k in state_dict.keys() if 'ls1' in k]
+            if ls1_keys:
+                print(f"Found ls1 keys: {ls1_keys[:5]}")
+            
+            radio_l_image_processor = CLIPImageProcessor.from_pretrained(hf_repo)
             radio_l_model = radio_l_model.to(RADIO_DEVICE)
             radio_l_model.eval()
             print("✅ C model preloaded successfully!")
             return True
     except Exception as e:
-        print(f"⚠️ Could not preload C model: {e}")
-    return False
-
-
-# Add current directory to path (for local modules if any)
-if os.getcwd() not in sys.path:
-    sys.path.append(os.getcwd())
-
-# --------------------------------------------------------------------------------------
-# Hugging Face download (robust)
-# --------------------------------------------------------------------------------------
-
-
-
-# --------------------------------------------------------------------------------------
-# Paths / Devices
-# --------------------------------------------------------------------------------------
-DEFAULT_AI_DETECTION_MODEL_PATH = "./output/V1.pkl"
-DEFAULT_DAMAGE_MODEL_PATH = "./output/model_final.pth"  # Stage 1 (Detectron2)
-
-if torch.backends.mps.is_available():
-    DEVICE = torch.device("mps")
-elif torch.cuda.is_available():
-    DEVICE = torch.device("cuda")
-else:
-    DEVICE = torch.device("cpu")
-
-print(f"🖥️ Using device: {DEVICE}")
-
-# --------------------------------------------------------------------------------------
-# Globals
-# --------------------------------------------------------------------------------------
-image_processor: Optional[CLIPImageProcessor] = None
-model: Optional[AutoModel] = None
-ai_detection_classifier = None
-_preloaded = False
-
-# --------------------------------------------------------------------------------------
-# Detectron2 (Stage 1) availability & loader
-# --------------------------------------------------------------------------------------
-DETECTRON2_AVAILABLE = False
-try:
-    import importlib.util as _imp
-    if _imp.find_spec("detectron2") is not None:
-        from detectron2.engine import DefaultPredictor
-        from detectron2.config import get_cfg
-        from detectron2 import model_zoo
-        DETECTRON2_AVAILABLE = True
-        print("✅ Detectron2 detected")
-    else:
-        print("ℹ️ Detectron2 not installed; Stage 1 will run in demo mode")
-except Exception as _e:
-    print(f"ℹ️ Detectron2 unavailable ({_e}); Stage 1 will run in demo mode")
-    DETECTRON2_AVAILABLE = False
-
-_damage_predictor = None
-
-def load_damage_model(model_path: str, device_str: str = None):
-    """Load fine-tuned Detectron2 model once (Stage 1)."""
-    global _damage_predictor
-    if _damage_predictor is not None:
-        return _damage_predictor
-
-    if (not DETECTRON2_AVAILABLE) or (not model_path) or (not os.path.exists(model_path)):
-        print("ℹ️ Stage 1 damage model not available; using simulator")
-        return None
-
-    try:
-        cfg = get_cfg()
-        cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
-        cfg.MODEL.WEIGHTS = model_path
-        cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
-        cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1  # fine-tuned for single 'damage' class
-
-        if device_str is None:
-            device_str = "cuda" if torch.cuda.is_available() else "cpu"
-        cfg.MODEL.DEVICE = device_str
-
-        _damage_predictor = DefaultPredictor(cfg)
-        print(f"✅ Damage model loaded on {device_str}")
-        return _damage_predictor
-    except Exception as e:
-        print(f"❌ Could not load Detectron2 model: {e}")
-        return None
-
-def simulate_damage_detection(rgb_image: np.ndarray, seed_from: np.ndarray = None) -> List[Dict[str, Any]]:
-    """Deterministic fake detections for demo mode."""
-    import hashlib, random
-    h, w = rgb_image.shape[:2]
-    if seed_from is None:
-        seed_from = rgb_image
-    img_hash = hashlib.md5(seed_from.tobytes()).hexdigest()
-    seed = int(img_hash[:8], 16) % 10_000
-    random.seed(seed)
-    n = random.randint(0, 3)
-    boxes = []
-    for _ in range(n):
-        x1 = random.randint(0, max(0, w - w//3))
-        y1 = random.randint(0, max(0, h - h//3))
-        x2 = min(w-1, x1 + random.randint(w//8, w//3))
-        y2 = min(h-1, y1 + random.randint(h//8, h//3))
-        conf = round(random.uniform(0.6, 0.95), 3)
-        boxes.append({"bbox":[x1,y1,x2,y2], "score":conf, "label":"damage"})
-    return boxes
-
-def auto_install_dependencies():
-    """Attempt to install dependencies if needed"""
-    try:
-        import importlib.util
-
-        # Check for PyTorch
-        if importlib.util.find_spec("torch") is None:
-            print("Installing PyTorch...")
-            os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
-
-        # Check for Detectron2
-        if importlib.util.find_spec("detectron2") is None:
-            print("Installing Detectron2...")
-            os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
-
-        # Check for Gradio
-        if importlib.util.find_spec("gradio") is None:
-            print("Installing Gradio...")
-            os.system("pip install gradio")
-
-        print("Dependencies installation complete!")
-        return True
-    except Exception as e:
-        print(f"Error installing dependencies: {e}")
-        return False
-
-
-
-
-def run_damage_detection(pil_image: Image.Image, score_thresh: float = 0.5):
-    """
-    Returns:
-      damage_boxes: list of dicts {bbox:[x1,y1,x2,y2], score:float, label:str}
-      annotated: numpy RGB image with boxes annotated (or None on error)
-      demo: bool
-      reason: str|None
-    """
-    try:
-        rgb = np.array(pil_image.convert("RGB"))
-        predictor = load_damage_model(DEFAULT_DAMAGE_MODEL_PATH)
-        if predictor is None:
-            boxes = simulate_damage_detection(rgb, seed_from=rgb)
-            annotated = rgb.copy()
-            for i, b in enumerate(boxes):
-                x1,y1,x2,y2 = b["bbox"]
-                cv2.rectangle(annotated, (x1,y1), (x2,y2), (255,255,0), 2)
-                cv2.putText(annotated, f"Damage {i+1} {b['score']*100:.1f}%",
-                            (x1, max(0,y1-8)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255,255,0), 2)
-            return boxes, annotated, True, "predictor not available"
-        # Real inference
-        outputs = predictor(rgb)
-        instances = outputs["instances"].to("cpu")
-        boxes = []
-        if len(instances) > 0:
-            pred_boxes = instances.pred_boxes.tensor.numpy()
-            scores = instances.scores.numpy()
-            for i, (box, sc) in enumerate(zip(pred_boxes, scores)):
-                if sc >= score_thresh:
-                    x1,y1,x2,y2 = [int(v) for v in box]
-                    boxes.append({"bbox":[x1,y1,x2,y2], "score":float(sc), "label":"damage"})
-        annotated = rgb.copy()
-        for i, b in enumerate(boxes):
-            x1,y1,x2,y2 = b["bbox"]
-            cv2.rectangle(annotated, (x1,y1), (x2,y2), (255,255,0), 2)
-            cv2.putText(annotated, f"Damage {i+1} {b['score']*100:.1f}%",
-                        (x1, max(0,y1-8)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255,255,0), 2)
-        return boxes, annotated, False, None
-    except Exception as e:
-        print(f"⚠️ Stage 1 error: {e}")
-        traceback.print_exc()
-        # fall back to simulator
-        rgb = np.array(pil_image.convert("RGB"))
-        boxes = simulate_damage_detection(rgb, seed_from=rgb)
-        annotated = rgb.copy()
-        for i, b in enumerate(boxes):
-            x1,y1,x2,y2 = b["bbox"]
-            cv2.rectangle(annotated, (x1,y1), (x2,y2), (255,255,0), 2)
-            cv2.putText(annotated, f"Damage {i+1} {b['score']*100:.1f}%",
-                        (x1, max(0,y1-8)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255,255,0), 2)
-        return boxes, annotated, True, "stage1 error"
-
-# --------------------------------------------------------------------------------------
-# Stage 2: RADIO feature extractor + classifier
-# --------------------------------------------------------------------------------------
-
-
-def load_ai_detection_classifier(model_path):
-    """Load the AI detection classifier (joblib)."""
-    global ai_detection_classifier
-    if ai_detection_classifier is not None:
-        print("✅ Classifier already loaded, reusing...")
-        return ai_detection_classifier
-
-    if model_path is None or not os.path.exists(model_path):
-        print(f"❌ AI detection model not found at: {model_path}")
-        return None
-
-    try:
-        ai_detection_classifier = joblib.load(model_path)
-        print(f"✅ AI detection classifier loaded from {model_path}")
-        print(f"   Classifier type: {type(ai_detection_classifier).__name__}")
-        return ai_detection_classifier
-    except Exception as e:
-        print(f"❌ Error loading classifier: {e}")
-        return None
-
-def preprocess_image(image) -> Optional[Image.Image]:
-    """Robust image preprocessing with EXIF orientation and dtype/range fixes."""
-    try:
-        if image is None:
-            return None
-
-        if isinstance(image, Image.Image):
-            pil = image
-        elif isinstance(image, (str,)):
-            arr = cv2.imread(image, cv2.IMREAD_UNCHANGED)
-            if arr is None:
-                return None
-            if arr.ndim == 3:
-                arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
-            if arr.dtype != np.uint8:
-                arr = np.clip(arr, 0, 255).astype(np.uint8)
-            pil = Image.fromarray(arr if arr.ndim == 3 else np.stack([arr]*3, axis=-1), 'RGB')
-        elif isinstance(image, dict) and "path" in image:
-            arr = cv2.imread(image["path"], cv2.IMREAD_UNCHANGED)
-            if arr is None:
-                return None
-            if arr.ndim == 3:
-                arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
-            if arr.dtype != np.uint8:
-                arr = np.clip(arr, 0, 255).astype(np.uint8)
-            pil = Image.fromarray(arr if arr.ndim == 3 else np.stack([arr]*3, axis=-1), 'RGB')
-        else:
-            # assume numpy-like
-            arr = np.array(image)
-            if arr.ndim == 2:
-                arr = cv2.cvtColor(arr, cv2.COLOR_GRAY2RGB)
-            elif arr.ndim == 3 and arr.shape[2] == 4:
-                arr = cv2.cvtColor(arr, cv2.COLOR_RGBA2RGB)
-            if arr.dtype != np.uint8:
-                if arr.max() <= 1.0:
-                    arr = np.clip(arr, 0, 1)
-                    arr = (arr * 255.0).astype(np.uint8)
-                else:
-                    arr = np.clip(arr, 0, 255).astype(np.uint8)
-            pil = Image.fromarray(arr, 'RGB')
-
-        # Normalize EXIF orientation
-        pil = ImageOps.exif_transpose(pil)
-        return pil.convert("RGB")
-    except Exception as e:
-        print(f"❌ Preprocess error: {e}")
+        print(f"⚠️ Could not preload C model: {repr(e)}")
+        import traceback
         traceback.print_exc()
-        return None
-
-def _forward_radio(pixel_values: torch.Tensor) -> torch.Tensor:
-    with torch.no_grad():
-        if DEVICE.type == "cuda":
-            from torch.cuda.amp import autocast
-            with autocast():
-                out = model(pixel_values)
-        else:
-            out = model(pixel_values)
-
-    # Accept dict / tuple / single tensor
-    if isinstance(out, dict):
-        feats = out.get("features") or out.get("last_hidden_state") or next(iter(out.values()))
-    elif isinstance(out, (list, tuple)):
-        feats = out[-1]
-    else:
-        feats = out
-    return feats
-
-def extract_features(image, return_stats=False):
-    """Extract normalized features using RADIO model."""
-    global image_processor, model
-    if image_processor is None or model is None:
-        raise Exception("RADIO model not initialized")
-
-    if not isinstance(image, Image.Image):
-        image = preprocess_image(image)
-        if image is None:
-            raise Exception("Failed to preprocess image")
-
-    image = image.resize((224, 224), Image.Resampling.LANCZOS)
-    pixel_values = image_processor(images=image, return_tensors='pt', do_resize=True).pixel_values.to(DEVICE)
-
-    feats = _forward_radio(pixel_values)
-
-    # Pool if sequence or feature map
-    if feats.ndim == 3:       # (B, T, C)
-        feats = feats.mean(dim=1)
-    elif feats.ndim == 4:     # (B, C, H, W)
-        feats = feats.mean(dim=(2, 3))
-
-    feats = feats.detach().flatten()
-    feats = F.normalize(feats, p=2, dim=-1).cpu().flatten()
-    out_np = feats.numpy()
-
-    if return_stats:
-        stats = {
-            "mean": float(out_np.mean()),
-            "std": float(out_np.std()),
-            "min": float(out_np.min()),
-            "max": float(out_np.max()),
-            "shape": out_np.shape
-        }
-        return out_np, stats
-    return out_np
-
-def _predict_with_classifier(classifier, features: np.ndarray) -> Tuple[int, float, float]:
-    """Predict with proba mapping respecting classifier.classes_.
-    Returns (pred_label, ai_prob, real_prob). Assumes label '1' == AI, '0' == real.
-    """
-    pred = int(classifier.predict(features)[0])
-    ai_prob = real_prob = 0.5
-    if hasattr(classifier, "predict_proba"):
-        probs = classifier.predict_proba(features)[0]
-        if hasattr(classifier, "classes_"):
-            classes = list(classifier.classes_)
-            if 1 in classes:
-                ai_prob = float(probs[classes.index(1)])
-            if 0 in classes:
-                real_prob = float(probs[classes.index(0)])
-            if 0 not in classes or 1 not in classes:
-                m = float(probs.max()); ai_prob = m; real_prob = 1.0 - m
-        else:
-            m = float(probs.max()); ai_prob = m; real_prob = 1.0 - m
-    elif hasattr(classifier, "decision_function"):
-        df = float(classifier.decision_function(features)[0])
-        ai_prob = 1.0 / (1.0 + np.exp(-df))
-        real_prob = 1.0 - ai_prob
-    else:
-        ai_prob = float(pred); real_prob = 1.0 - ai_prob
-    return pred, ai_prob, real_prob
-
-def simulate_prediction(image) -> Dict[str, Any]:
-    """Fallback simulation when models/classifier aren't available."""
-    import hashlib, random
-    if isinstance(image, Image.Image):
-        arr = np.array(image.convert("RGB"))
-    elif isinstance(image, np.ndarray):
-        arr = image
-    else:
-        arr = np.array(preprocess_image(image) or Image.new("RGB",(16,16),(0,0,0)))
-
-    img_hash = hashlib.md5(arr.tobytes()).hexdigest()
-    seed = int(img_hash[:8], 16) % 1000
-    random.seed(seed)
-    ai_prob = random.uniform(0.1, 0.9)
-    is_ai = ai_prob > 0.5
-    confidence_level = "HIGH" if abs(ai_prob - 0.5) > 0.3 else "MEDIUM" if abs(ai_prob - 0.5) > 0.15 else "LOW"
-
-    return {
-        "prediction": "AI-Generated" if is_ai else "Real",
-        "ai_probability": ai_prob,
-        "real_probability": 1 - ai_prob,
-        "confidence": confidence_level,
-        "is_demo": True
-    }
-
-def _overlay_final_verdict(annotated_rgb: np.ndarray, verdict_text: str, ai_prob: float, real_prob: float, is_ai: bool):
-    out = annotated_rgb.copy()
-    color = (0,255,0) if not is_ai else (0,0,255)
-    conf = max(ai_prob, real_prob)
-    cv2.putText(out, verdict_text, (30, 50), cv2.FONT_HERSHEY_SIMPLEX, 1.0, color, 3)
-    cv2.putText(out, f"Confidence: {conf*100:.1f}%", (30, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
-    return out
-
-# --------------------------------------------------------------------------------------
-# Gradio App
-# --------------------------------------------------------------------------------------
-def create_gradio_interface():
-    """Enhanced Gradio interface with Stage 1 + Stage 2."""
-    custom_css = """
-    .gradio-container { font-family: Inter, system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, 'Helvetica Neue', Arial, 'Noto Sans', 'Apple Color Emoji', 'Segoe UI Emoji'; }
-    """
-
-    with gr.Blocks(title="AI Image Detection", css=custom_css) as app:
-        gr.HTML("""
-        <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px;">
-            <h1 style="margin: 0;">🤖 AI Image Detection</h1>
-            <p style="margin: 10px 0 0 0;">Stage 1 (Damage) + Stage 2 (AI-Generated) — with graceful fallbacks</p>
-        </div>
-        """)
-
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(
-                    type="numpy",
-                    label="Upload Image",
-                    height=400
-                )
-
-                with gr.Row():
-                    predict_btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg")
-
-                enable_damage = gr.Checkbox(value=True, label="Enable Stage 1 (Damage Detection)")
-                damage_thresh = gr.Slider(0.1, 0.95, value=0.5, step=0.05, label="Damage Score Threshold")
-
-            with gr.Column():
-                output_text = gr.Textbox(
-                    label="Prediction Result",
-                    placeholder="Upload an image and click Analyze",
-                    interactive=False,
-                    lines=2
-                )
-                output_json = gr.JSON(label="Detailed Analysis (Stage 2)")
-                damage_json = gr.JSON(label="Stage 1: Damage Detections")
-                annotated_image = gr.Image(label="Annotated Output (Damage + Verdict)")
-                status_display = gr.HTML("""
-                <div style="padding: 10px; background: #f0f4f8; border-radius: 8px; margin-top: 10px;">
-                    <p style="margin: 0; color: #64748b;">Ready for analysis...</p>
-                </div>
-                """)
-
-        # --- Analyze callback ---
-        def analyze_with_status(image, enable_damage, damage_thresh):
-            """Analyze and update all outputs (Stage 1 + Stage 2)."""
-            if image is None:
-                return (
-                    "❌ No image provided",
-                    {"error": "No image provided"},
-                    """
-                    <div style="padding: 10px; background: #fee2e2; border-radius: 8px; margin-top: 10px;">
-                        <p style="margin: 0; color: #dc2626; font-weight: bold;">❌ No image provided</p>
-                    </div>
-                    """,
-                    [],
-                    None
-                )
-
-            # Stage 2 init
-            model_initialized = (image_processor is not None and model is not None) or preload_models()
-            model_path = huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH
-            classifier = ai_detection_classifier or load_ai_detection_classifier(model_path)
-
-            demo_reasons = []
-            if not model_initialized: demo_reasons.append("feature extractor missing")
-            if classifier is None:   demo_reasons.append("classifier missing")
-
-            # Stage 2 run
-            try:
-                if demo_reasons:
-                    result2 = simulate_prediction(preprocess_image(image))
-                    result2["demo_reasons"] = demo_reasons
-                    simple_result = f"{result2['prediction']} (AI: {result2['ai_probability']:.2%}) [Demo: {', '.join(demo_reasons)}]"
-                    detailed_result = result2
-                else:
-                    feats, stats = extract_features(preprocess_image(image), return_stats=True)
-                    feats = feats.reshape(1, -1)
-                    pred, ai_prob, real_prob = _predict_with_classifier(classifier, feats)
-                    is_ai = pred == 1
-                    result_text = "AI-Generated" if is_ai else "Real"
-                    conf_score = max(ai_prob, real_prob)
-                    confidence = "HIGH" if conf_score > 0.80 else "MEDIUM" if conf_score > 0.60 else "LOW"
-                    detailed_result = {
-                        "prediction": result_text,
-                        "ai_probability": ai_prob,
-                        "real_probability": real_prob,
-                        "confidence": confidence,
-                        "confidence_score": conf_score,
-                        "is_demo": False,
-                        "feature_stats": stats
-                    }
-                    simple_result = f"{result_text} (Confidence: {conf_score:.2%}, {confidence})"
-            except Exception as e:
-                print(f"❌ Error Stage 2: {e}")
-                traceback.print_exc()
-                result2 = simulate_prediction(preprocess_image(image))
-                result2["demo_reasons"] = ["stage2 error"]
-                simple_result = f"{result2['prediction']} (AI: {result2['ai_probability']:.2%}) [Demo: stage2 error]"
-                detailed_result = result2
-
-            # Get Stage 2 values for overlay
-            is_ai = False
-            ai_prob = real_prob = 0.5
-            verdict_text = "Unknown"
-            if isinstance(detailed_result, dict) and "error" not in detailed_result:
-                is_ai = (detailed_result.get("prediction") == "AI-Generated")
-                ai_prob = float(detailed_result.get("ai_probability", 0.5))
-                real_prob = float(detailed_result.get("real_probability", 0.5))
-                verdict_text = detailed_result.get("prediction", "Unknown")
-
-            # Stage 1 (optional)
-            dmg_results = []
-            annotated = None
-            stage1_demo_reasons = []
-            try:
-                if enable_damage:
-                    pil = preprocess_image(image)
-                    if pil is not None:
-                        boxes, annotated_rgb, demo, reason = run_damage_detection(pil, float(damage_thresh))
-                        dmg_results = boxes
-                        if demo and reason:
-                            stage1_demo_reasons.append(f"Stage1:{reason}")
-                        annotated = annotated_rgb
-                    else:
-                        stage1_demo_reasons.append("Stage1:preprocess-fail")
-            except Exception as e:
-                print(f"⚠️ Stage 1 analyze error: {e}")
-                traceback.print_exc()
-                stage1_demo_reasons.append("Stage1:error")
-
-            # If no annotated yet, create from original for overlay
-            if annotated is None:
-                pil = preprocess_image(image)
-                if pil is not None:
-                    annotated = np.array(pil.convert("RGB"))
-
-            # Overlay verdict
-            if annotated is not None:
-                annotated = _overlay_final_verdict(annotated, verdict_text, ai_prob, real_prob, is_ai)
-
-            # Status HTML
-            if isinstance(detailed_result, dict) and "error" not in detailed_result:
-                if detailed_result.get("is_demo"):
-                    status_color = "#f59e0b"
-                    extra = ""
-                    demo_list = detailed_result.get('demo_reasons', [])
-                    if demo_list:
-                        extra = f" (Demo: {', '.join(demo_list)})"
-                    if stage1_demo_reasons:
-                        if extra:
-                            extra = extra[:-1] + ", " + ", ".join(stage1_demo_reasons) + ")"
-                        else:
-                            extra = f" (Stage1 demo: {', '.join(stage1_demo_reasons)})"
-                    status_text = f"⚠️ Demo Mode{extra}"
-                else:
-                    status_color = "#10b981"
-                    extra = f" (Stage1 demo: {', '.join(stage1_demo_reasons)})" if stage1_demo_reasons else ""
-                    status_text = f"✅ Analysis Complete{extra}"
-                status_html = f"""
-                <div style="padding: 10px; background: #f0f4f8; border-radius: 8px; margin-top: 10px;">
-                    <p style="margin: 0; color: {status_color}; font-weight: bold;">{status_text}</p>
-                </div>
-                """
-            else:
-                status_html = """
-                <div style="padding: 10px; background: #fee2e2; border-radius: 8px; margin-top: 10px;">
-                    <p style="margin: 0; color: #dc2626; font-weight: bold;">❌ Analysis Failed</p>
-                </div>
-                """
-
-            return simple_result, detailed_result, status_html, dmg_results, (annotated if annotated is not None else None)
-
-        def clear_all():
-            """Clear all fields."""
-            return (
-                None,  # input image
-                "",    # output_text
-                {},    # output_json
-                """
-                <div style="padding: 10px; background: #f0f4f8; border-radius: 8px; margin-top: 10px;">
-                    <p style="margin: 0; color: #64748b;">Ready for analysis...</p>
-                </div>
-                """,
-                [],    # damage_json
-                None   # annotated_image
-            )
-
-        # Wire events
-        predict_btn.click(
-            fn=analyze_with_status,
-            inputs=[input_image, enable_damage, damage_thresh],
-            outputs=[output_text, output_json, status_display, damage_json, annotated_image]
-        )
-
-        clear_btn.click(
-            fn=clear_all,
-            outputs=[input_image, output_text, output_json, status_display, damage_json, annotated_image]
-        )
-
-        # Auto-analyze on image change
-        input_image.change(
-            fn=analyze_with_status,
-            inputs=[input_image, enable_damage, damage_thresh],
-            outputs=[output_text, output_json, status_display, damage_json, annotated_image]
-        )
-
-        # Examples (add paths if you have assets)
-        gr.Examples(
-            examples=[  # ("path/to/example1.jpg"), ("path/to/example2.png")
-            ],
-            inputs=input_image,
-            label="Example Images"
-        )
-
-        with gr.Accordion("ℹ️ About This Model", open=False):
-            gr.Markdown("""
-            ### Pipeline
-            - **Stage 1 (optional)**: Detectron2 damage/zone detection (Mask R-CNN R50-FPN), with simulated fallback.
-            - **Stage 2**: RADIO visual features + scikit-learn classifier (`V1.pkl`) for AI-generated vs real.
-
-            ### Notes
-            - If the RADIO extractor or classifier is missing, the app runs in **Demo Mode** with deterministic simulation.
-            - If Detectron2 or your weights are missing, Stage 1 uses a fast simulator but keeps the UX intact.
-            """)
-
-    return app
-
-# --------------------------------------------------------------------------------------
-# Main
-# --------------------------------------------------------------------------------------
-if __name__ == "__main__":
-    print("=" * 60)
-    print("🚀 Starting AI Image Detection App (Model 2 + Stage 1)")
-    print("=" * 60)
-    print(f"📍 Device: {DEVICE}")
-    print(f"📦 Classifier Path: {huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH}")
-    print(f"🛠️ Damage Model Path: {DEFAULT_DAMAGE_MODEL_PATH} ({'exists' if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH) else 'missing'})")
-  
-    # Check if dependencies are installed
-    auto_install_dependencies()
-
-    # Preload C model at startup
-    preload_models()
-
-    # Load classifier
-    model_path = huggingface_model_path or DEFAULT_AI_DETECTION_MODEL_PATH
-    classifier_loaded = load_ai_detection_classifier(model_path) is not None
-
-    print("=" * 60)
-    print("=" * 60)
-
-
-
-
-    app = create_gradio_interface()
-    app.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
+    return False