Update app.py

app.py

@@ -1,9 +1,16 @@
-# Combined Script for Colab/Notebook Execution
-# This script handles installation, model download via gdown, 
-# and runs the dlib-free eKYC application with the buffalo_l model.
+"""
+Deepfake-Proof eKYC System (DLIB-Free)
+-------------------------------------
+This script:
+✅ Installs required dependencies
+✅ Downloads ONNX & auxiliary models via gdown
+✅ Initializes FaceAnalysis (buffalo_l)
+✅ Runs a Gradio web interface for identity + liveness verification
+"""
 
 import os
 import warnings
+import subprocess
 import numpy as np
 import cv2
 import onnxruntime as ort
@@ -14,363 +21,221 @@ import time
 import sys
 from typing import Optional, Tuple, Any
 
+# ==============================================================================
+# 1. INSTALLATION (for Colab / Local Run)
+# ==============================================================================
+print("--- 1. Installing Required Libraries ---")
+try:
+    subprocess.run([
+        "pip", "install",
+        "insightface==0.7.3", "numpy", "onnxruntime",
+        "opencv-python", "matplotlib", "tqdm", "gdown", "gradio"
+    ], check=True)
+except Exception as e:
+    print(f"⚠️ Installation failed: {e}")
+
 # Suppress warnings for a cleaner output
 warnings.filterwarnings("ignore")
 
 # ==============================================================================
-# 1. SETUP, INSTALLATION, AND MODEL DOWNLOAD (Combined Cell)
+# 2. MODEL DOWNLOAD SETUP
 # ==============================================================================
+TARGET_DIR = './models'
+os.makedirs(TARGET_DIR, exist_ok=True)
 
-print("--- 1. Installing Required Libraries ---")
-# Install core libraries and gdown, gradio. dlib is removed from the requirements
-!pip install insightface==0.7.3 numpy onnxruntime opencv-python matplotlib tqdm gdown gradio --quiet
-
-# --- Configuration: Model File IDs and Target Paths ---
-TARGET_DIR = '/content/'
-
-# Deepfake Model Paths (All ONNX models are downloaded for runtime switching)
 MODEL_PATHS = {
-    "mobilenetv3": "/content/mobilenetv3_small_100_final.onnx",
-    "efficientnet_b0": "/content/efficientnet_b0_final.onnx",
-    "edgenext": "/content/edgenext_small_final.onnx",
+    "mobilenetv3": os.path.join(TARGET_DIR, "mobilenetv3_small_100_final.onnx"),
+    "efficientnet_b0": os.path.join(TARGET_DIR, "efficientnet_b0_final.onnx"),
+    "edgenext": os.path.join(TARGET_DIR, "edgenext_small_final.onnx"),
 }
 
-# Mapping of file names to their corresponding Google Drive File IDs
-# NOTE: The DLIB and Caffe files are kept for download continuity, 
-# but are NOT used in the dlib-free logic.
 MODEL_FILES = {
-    # Deepfake Detector Components (Downloaded but not used in final logic)
+    # Deepfake Detector Components (for compatibility; not used in DLIB-free flow)
     "deploy.prototxt": "1V02QA7eOnrkKixTdnP6cvIBx4Qxqwhmw",
     "res10_300x300_ssd_iter_140000_fp16.caffemodel": "14n7DryxHqwqac9z0HzpIqtipBp5EfRvA",
     "shape_predictor_81_face_landmarks.dat": "1sixwbA4oOn7Ijmm85sAODL8AtwjCq6a9",
-
-    # Deepfake Classification ONNX Models
+    # Deepfake Classification Models
     "mobilenetv3_small_100_final.onnx": "1spFbTIL8nRmIBG_F6j6-aF01fWGVGo_f",
     "efficientnet_b0_final.onnx": "1TsHUbx0cd-55XDygQIAmEbXFUGHxBT_x",
     "edgenext_small_final.onnx": "15hnhznZVyASYhSOYOFSsgMGEfsyh1MBY"
 }
 
 def download_models_from_drive():
-    """Downloads all required model files from the provided Drive IDs."""
-    print(f"\n--- 2. Starting Deepfake Model Download to {TARGET_DIR} ---")
-
-    try:
-        import gdown
-    except ImportError:
-        # Should be installed by pip above, but double check
-        !pip install gdown --quiet
-        import gdown
-
-    os.makedirs(TARGET_DIR, exist_ok=True)
-    downloaded_files = 0
-
+    """Downloads all required model files from Google Drive."""
+    print(f"\n--- 2. Downloading Deepfake Models to {TARGET_DIR} ---")
+    import gdown
     for filename, file_id in MODEL_FILES.items():
         local_path = os.path.join(TARGET_DIR, filename)
-
         if os.path.exists(local_path) and os.path.getsize(local_path) > 0:
-            # print(f"Skipping download, {filename} already exists.")
-            downloaded_files += 1
             continue
-
         try:
-            print(f"Downloading {filename}...")
+            print(f"⬇️ Downloading {filename} ...")
             gdown.download(id=file_id, output=local_path, quiet=True, fuzzy=True)
-            if os.path.exists(local_path) and os.path.getsize(local_path) > 0:
-                downloaded_files += 1
         except Exception as e:
-            print(f"Warning: Failed to download {filename}. Error: {e}", file=sys.stderr)
+            print(f"⚠️ Failed to download {filename}: {e}")
 
 download_models_from_drive()
-print("✅ Initial setup complete. Proceeding to model initialization.")
+print("✅ Model files are ready.")
 
-# --- 2. MODEL INITIALIZATION AND CORE HELPER FUNCTIONS ---
-
-# --- 2A. CONFIGURATION ---
-# IMPORTANT: Using 'buffalo_l' as requested, which provides 5-point landmarks (lmk)
-SIM_MODEL_NAME = 'buffalo_l' 
+# ==============================================================================
+# 3. MODEL INITIALIZATION
+# ==============================================================================
+SIM_MODEL_NAME = 'buffalo_l'
 CTX_ID = -1  # CPU
-ID_MATCH_THRESHOLD = 0.50  # Similarity Threshold
-FAKE_SCORE_THRESHOLD = 0.5 # Deepfake Score Threshold
+ID_MATCH_THRESHOLD = 0.50
+FAKE_SCORE_THRESHOLD = 0.50
 
 ONNX_SESSIONS = {}
 app: Optional[FaceAnalysis] = None
 
-# --- 2B. INITIALIZE MODELS ---
-
-print("\n--- 3. Initializing Models ---")
+print("\n--- 3. Initializing Face and Deepfake Models ---")
 try:
-    # Face Analysis/Recognition Model (downloads buffalo_l)
-    print(f"Initializing FaceAnalysis model: {SIM_MODEL_NAME}")
     app = FaceAnalysis(name=SIM_MODEL_NAME, providers=['CPUExecutionProvider'])
-    
-    # Configure app to get detection, 5-point landmark (lmk), and recognition (embedding)
-    # The 'det_model' argument is removed for compatibility with insightface==0.7.3
     app.prepare(ctx_id=CTX_ID, det_size=(640, 640), det_thresh=0.5,
                 allowed_modules=['detection', 'landmark', 'recognition'])
 
-    # Initialize ONNX Deepfake Classification Models
     for model_name, path in MODEL_PATHS.items():
         if os.path.exists(path):
             ONNX_SESSIONS[model_name] = ort.InferenceSession(path, providers=['CPUExecutionProvider'])
-            print(f"Loaded {model_name.upper()} deepfake model.")
+            print(f"✅ Loaded {model_name.upper()} model.")
         else:
-            print(f"Warning: Deepfake model {model_name.upper()} not found at {path}")
+            print(f"⚠️ Missing {model_name.upper()} at {path}")
 
     if not ONNX_SESSIONS:
         raise FileNotFoundError("No ONNX deepfake models could be loaded.")
 
 except Exception as e:
-    print(f"❌ FATAL ERROR: Failed to load models. Detail: {e}")
+    print(f"❌ Model initialization failed: {e}")
     app = None
-    # We don't sys.exit(1) here to allow Gradio to show the error, but the function will handle it.
-
 
 print("✅ Model initialization complete.")
 
-# --- 2C. IDENTITY VERIFICATION HELPER FUNCTIONS (Similarity Check) ---
-
+# ==============================================================================
+# 4. HELPER FUNCTIONS
+# ==============================================================================
 def get_largest_face(faces: list) -> Optional[Any]:
-    """Returns the largest face detected."""
     if not faces: return None
-    def get_area(face):
-        bbox = face.bbox.astype(np.int32)
-        return (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
-    return max(faces, key=get_area)
+    def area(face): bbox = face.bbox.astype(np.int32); return (bbox[2]-bbox[0])*(bbox[3]-bbox[1])
+    return max(faces, key=area)
 
-def get_face_data(img_array_rgb: np.ndarray) -> Tuple[Optional[np.ndarray], Optional[np.ndarray], Optional[np.ndarray], Optional[np.ndarray]]:
-    """Extracts embedding, landmarks (5-point), BGR image, and bbox."""
+def get_face_data(img_array_rgb: np.ndarray):
     if app is None: return None, None, None, None
     img_bgr = cv2.cvtColor(img_array_rgb, cv2.COLOR_RGB2BGR)
-    all_faces = app.get(img_bgr)
-    if not all_faces:
-        return None, None, img_bgr, None
-    face = get_largest_face(all_faces)
-    # The 'face' object from FaceAnalysis provides embedding and 5-point landmarks ('lmk')
+    faces = app.get(img_bgr)
+    if not faces: return None, None, img_bgr, None
+    face = get_largest_face(faces)
     return face.embedding, face.lmk, img_bgr, face.bbox
 
-def calculate_similarity(embedding1: Optional[np.ndarray], embedding2: Optional[np.ndarray]) -> float:
-    """Calculates cosine similarity."""
-    if embedding1 is None or embedding2 is None: return 0.0
-    # Ensure embeddings are normalized before dot product for true cosine sim
-    e1_norm = embedding1 / np.linalg.norm(embedding1)
-    e2_norm = embedding2 / np.linalg.norm(embedding2)
-    similarity = np.dot(e1_norm, e2_norm)
-    return float(similarity)
+def calculate_similarity(e1, e2):
+    if e1 is None or e2 is None: return 0.0
+    e1_norm = e1 / np.linalg.norm(e1)
+    e2_norm = e2 / np.linalg.norm(e2)
+    return float(np.dot(e1_norm, e2_norm))
 
-# --- 2D. DEEPFAKE DETECTION HELPER FUNCTIONS (Liveness Check - DLIB FREE) ---
-
-def align_face_insightface(img_bgr: np.ndarray, landmarks_5pt: np.ndarray, output_size: int = 160) -> np.ndarray:
-    """
-    Alignment using 5-point landmarks provided by insightface.
-    """
-    # Standard 5-point template for alignment scaled for 160x160 output
+def align_face_insightface(img_bgr, landmarks_5pt, output_size=160):
     dst = np.array([
-        [30.2946, 51.6963],  # Left Eye
-        [65.5318, 51.6963],  # Right Eye
-        [48.0252, 71.7366],  # Nose Tip
-        [33.5493, 92.3655],  # Left Mouth Corner
-        [62.7299, 92.3655]   # Right Mouth Corner
-    ], dtype=np.float32) * (output_size / 96) 
-
+        [30.2946, 51.6963],
+        [65.5318, 51.6963],
+        [48.0252, 71.7366],
+        [33.5493, 92.3655],
+        [62.7299, 92.3655]
+    ], dtype=np.float32) * (output_size / 96)
     src = landmarks_5pt.astype(np.float32)
-
-    # Calculate similarity transform matrix
     M, _ = cv2.estimateAffinePartial2D(src, dst, method=cv2.LMEDS)
-    
-    # Apply transformation
-    aligned_face = cv2.warpAffine(img_bgr, M, (output_size, output_size), flags=cv2.INTER_CUBIC)
-    
-    return aligned_face
-
-def get_liveness_score(img_array_rgb: np.ndarray, landmarks_5pt: np.ndarray, model_choice: str) -> float:
-    """Extracts aligned face and runs deepfake inference using the selected model."""
+    return cv2.warpAffine(img_bgr, M, (output_size, output_size), flags=cv2.INTER_CUBIC)
+
+def get_liveness_score(img_rgb, landmarks_5pt, model_choice):
     if model_choice not in ONNX_SESSIONS: return 0.0
     try:
         session = ONNX_SESSIONS[model_choice]
-        img_bgr = cv2.cvtColor(img_array_rgb, cv2.COLOR_RGB2BGR)
-
-        # Align the face using the 5-point landmarks
-        face_crop_bgr = align_face_insightface(img_bgr, landmarks_5pt, output_size=160)
-
-        # Pre-process for ONNX model (C, H, W, normalization [-1, 1])
-        face_crop_rgb = cv2.cvtColor(face_crop_bgr, cv2.COLOR_BGR2RGB)
-        normalized_img = (face_crop_rgb / 255.0 - 0.5) / 0.5
-        input_tensor = np.transpose(normalized_img, (2, 0, 1))
-        input_tensor = np.expand_dims(input_tensor, axis=0).astype("float32")
-
+        img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+        face_crop = align_face_insightface(img_bgr, landmarks_5pt, 160)
+        face_rgb = cv2.cvtColor(face_crop, cv2.COLOR_BGR2RGB)
+        normalized = (face_rgb / 255.0 - 0.5) / 0.5
+        input_tensor = np.transpose(normalized, (2, 0, 1))[None, ...].astype("float32")
         input_name = session.get_inputs()[0].name
         output_name = session.get_outputs()[0].name
         logit = session.run([output_name], {input_name: input_tensor})[0]
-
-        # Convert logit to probability (Fake Confidence Score) using sigmoid
         probability = 1 / (1 + np.exp(-logit))
-        score = float(np.ravel(probability)[0]) if probability.size > 0 else 0.0
-
-        return score
-
+        return float(np.ravel(probability)[0])
     except Exception as e:
-        print(f"Liveness check failed: {e}", file=sys.stderr)
-        return 0.0 # Fail safe
+        print(f"Liveness check failed: {e}")
+        return 0.0
 
 # ==============================================================================
-# 3. UNIFIED eKYC ANALYSIS AND GRADIO INTERFACE
+# 5. UNIFIED eKYC LOGIC
 # ==============================================================================
-
-def unified_ekyc_analysis(model_choice: str, img_A_pil: Image.Image, img_B_pil: Image.Image) -> Tuple[Optional[Image.Image], Optional[Image.Image], str]:
-    """
-    Performs Identity Verification (Step 1) then Forgery Check (Step 2).
-    """
+def unified_ekyc_analysis(model_choice: str, img_A_pil: Image.Image, img_B_pil: Image.Image):
     if app is None or not ONNX_SESSIONS or model_choice not in ONNX_SESSIONS:
-        error_msg = f"""# ❌ CRITICAL FAILURE: Models failed to load. Please check console output and ensure all ONNX models are present and FaceAnalysis initialized successfully."""
-        return None, None, error_msg
-
-    start_time = time.time()
+        err = "# ❌ Models not initialized. Please restart or check logs."
+        return None, None, err
 
-    # --- Data Prep and Feature Extraction ---
-    img_A_array = np.array(img_A_pil.convert('RGB'))
-    img_B_array = np.array(img_B_pil.convert('RGB'))
+    start = time.time()
+    img_A, img_B = np.array(img_A_pil.convert('RGB')), np.array(img_B_pil.convert('RGB'))
 
-    # e1, e2: Embeddings; lmk_A, lmk_B: Landmarks (5-point); vis_A_bgr, vis_B_bgr: BGR images; bbox_A, bbox_B: Bounding Boxes
-    e1, lmk_A, vis_A_bgr, bbox_A = get_face_data(img_A_array)
-    e2, lmk_B, vis_B_bgr, bbox_B = get_face_data(img_B_array)
+    e1, lmk_A, visA, bboxA = get_face_data(img_A)
+    e2, lmk_B, visB, bboxB = get_face_data(img_B)
 
-    # 1. Basic Face Detection Check (Pre-Step)
     if e1 is None or e2 is None or lmk_A is None or lmk_B is None:
-        report = "🛑 **PRE-CHECK FAILED:** Face detection failed on one or both images. Cannot proceed."
-        return Image.fromarray(img_A_array), Image.fromarray(img_B_array), report
+        return img_A_pil, img_B_pil, "🛑 **Face not detected properly in one/both images.**"
 
-
-    # --- STEP 1: IDENTITY VERIFICATION (Similarity Check) ---
     match_score = calculate_similarity(e1, e2)
-    match_is_success = match_score > ID_MATCH_THRESHOLD
-
-    liveness_score_A = 0.0
-    liveness_score_B = 0.0
-    is_acceptance_ok = False
-    rejection_reason = None
-
-    if not match_is_success:
-        # Stop here and REJECT
-        rejection_reason = "Identity Mismatch (Step 1 Failed)"
-
-    else:
-        # --- STEP 2: FORGERY/LIVENESS CHECK (Conditional) ---
-        liveness_score_A = get_liveness_score(img_A_array, lmk_A, model_choice)
-        liveness_score_B = get_liveness_score(img_B_array, lmk_B, model_choice)
-
-        # FAKE score <= 0.50 means it is classified as REAL
-        liveness_is_real_A = liveness_score_A <= FAKE_SCORE_THRESHOLD
-        liveness_is_real_B = liveness_score_B <= FAKE_SCORE_THRESHOLD
-
-        is_acceptance_ok = liveness_is_real_A and liveness_is_real_B
-        rejection_reason = "Forgery Detected (Step 2 Failed)" if not is_acceptance_ok else "All checks passed."
-
-    # --- Final Labeling and Visualization ---
-    final_label_text = "✅ **ACCEPT IDENTITY**" if is_acceptance_ok else "❌ **REJECT IDENTITY**"
-    final_label_color = "#28a745" if is_acceptance_ok else "#dc3545"
-
-    # Set BBox Color: Red for any rejection, Green for full acceptance
-    bbox_color = (0, 255, 0) if is_acceptance_ok else (0, 0, 255) # Green (BGR) or Red (BGR)
+    match_ok = match_score > ID_MATCH_THRESHOLD
 
-    # Drawing BBoxes
-    bbox_A_int = bbox_A.astype(np.int32)
-    cv2.rectangle(vis_A_bgr, (bbox_A_int[0], bbox_A_int[1]), (bbox_A_int[2], bbox_A_int[3]), bbox_color, 4)
-    bbox_B_int = bbox_B.astype(np.int32)
-    cv2.rectangle(vis_B_bgr, (bbox_B_int[0], bbox_B_int[1]), (bbox_B_int[2], bbox_B_int[3]), bbox_color, 4)
+    liveness_A = get_liveness_score(img_A, lmk_A, model_choice) if match_ok else 0.0
+    liveness_B = get_liveness_score(img_B, lmk_B, model_choice) if match_ok else 0.0
 
-    end_time = time.time()
+    is_real_A, is_real_B = liveness_A <= FAKE_SCORE_THRESHOLD, liveness_B <= FAKE_SCORE_THRESHOLD
+    accept = match_ok and is_real_A and is_real_B
 
-    # --- Final Report Generation ---
+    bbox_color = (0, 255, 0) if accept else (0, 0, 255)
+    for vis, bbox in [(visA, bboxA), (visB, bboxB)]:
+        b = bbox.astype(int)
+        cv2.rectangle(vis, (b[0], b[1]), (b[2], b[3]), bbox_color, 3)
 
-    match_status_text = "MATCH" if match_is_success else "MISMATCH"
-    liveness_is_real_A = liveness_score_A <= FAKE_SCORE_THRESHOLD
-    liveness_is_real_B = liveness_score_B <= FAKE_SCORE_THRESHOLD
-    liveness_A_text = "REAL" if liveness_is_real_A else "FAKE"
-    liveness_B_text = "REAL" if liveness_is_real_B else "FAKE"
+    report = f"""
+    ## 🏦 ZenTej eKYC Report
+    **Final Decision:** {'✅ ACCEPT' if accept else '❌ REJECT'}  
+    **Reason:** {'All checks passed' if accept else 'Mismatch or Forgery detected'}
 
+    | Check | Value | Status |
+    |:--|:--|:--|
+    | Cosine Similarity | `{match_score:.4f}` | {'MATCH' if match_ok else 'MISMATCH'} |
+    | Live Image Fake Score | `{liveness_A:.4f}` | {'REAL' if is_real_A else 'FAKE'} |
+    | Doc Image Fake Score | `{liveness_B:.4f}` | {'REAL' if is_real_B else 'FAKE'} |
+    | Thresholds | ID>{ID_MATCH_THRESHOLD}, FAKE<={FAKE_SCORE_THRESHOLD} | |
 
-    final_report = f"""
-    ## 🏦 ZenTej eKYC Verification Report
-
-    <div style='border: 2px solid {final_label_color}; padding: 10px; border-radius: 5px; background-color: {'#e6ffe6' if is_acceptance_ok else '#ffe6e6'};'>
-    <h3 style='color: {final_label_color}; margin-top: 0;'>{final_label_text}</h3>
-    <p><strong>Reason:</strong> {rejection_reason}</p>
-    </div>
-
-    ---
-
-    ### Step 1: Identity Similarity Check
-
-    | Metric | Value | Status |
-    | :--- | :--- | :--- |
-    | **Match Score (Cosine)** | `{match_score:.4f}` | **<span style='color:{'#28a745' if match_is_success else '#dc3545'};'>{match_status_text}</span>** |
-    | **Required Threshold** | $>{ID_MATCH_THRESHOLD}$ | |
-
-    <details>
-      <summary style="font-weight: bold;">Metrics Interpretation</summary>
-      <p>The score is a **Cosine Similarity** value between 0.0 and 1.0. The system requires the score to be **greater than {ID_MATCH_THRESHOLD:.2f}** to proceed to the next step.</p>
-    </details>
-
-    ---
-
-    ### Step 2: Forgery / Liveness Check (Conditional)
-
-    (Run only if Step 1 is MATCH)
-
-    | Image | FAKE Confidence Score | Liveness Status |
-    | :--- | :--- | :--- |
-    | **Input 1 (Live)** | `{liveness_score_A:.4f}` | **<span style='color:{'#28a745' if liveness_is_real_A else '#dc3545'};'>{liveness_A_text}</span>** |
-    | **Input 2 (Document)** | `{liveness_score_B:.4f}` | **<span style='color:{'#28a745' if liveness_is_real_B else '#dc3545'};'>{liveness_B_text}</span>** |
-
-    <details>
-      <summary style="font-weight: bold;">Metrics Interpretation</summary>
-      <p>The score is the model's **Confidence that the image is a FAKE** (range: 0.0 to 1.0). A score greater than {FAKE_SCORE_THRESHOLD:.2f} results in a **FAKE** classification. Both images must be classified as **REAL** (score $\le {FAKE_SCORE_THRESHOLD:.2f}$) for Step 2 to pass.</p>
-      <p style="font-size: 0.9em;">*Model Used: {model_choice.upper()}*</p>
-    </details>
-
-    ---
-
-    *Total Processing Time: {end_time - start_time:.3f} seconds*
+    ⏱ Time: {time.time()-start:.3f}s | Model: **{model_choice.upper()}**
     """
 
-    # Prepare images for Gradio (convert BGR to RGB)
-    vis_A_rgb = cv2.cvtColor(vis_A_bgr, cv2.COLOR_BGR2RGB)
-    vis_B_rgb = cv2.cvtColor(vis_B_bgr, cv2.COLOR_BGR2RGB)
+    return Image.fromarray(cv2.cvtColor(visA, cv2.COLOR_BGR2RGB)), Image.fromarray(cv2.cvtColor(visB, cv2.COLOR_BGR2RGB)), report
 
-    return Image.fromarray(vis_A_rgb), Image.fromarray(vis_B_rgb), final_report
-
-
-# --- GRADIO FRONTEND ---
-print("\n--- 4. Initializing Gradio interface ---")
+# ==============================================================================
+# 6. GRADIO INTERFACE
+# ==============================================================================
+if __name__ == "__main__":
+    print("\n--- 4. Launching Gradio App ---")
+    models = list(ONNX_SESSIONS.keys())
+    default = "edgenext" if "edgenext" in models else (models[0] if models else None)
 
-available_models = list(ONNX_SESSIONS.keys())
-default_model = "edgenext" if "edgenext" in available_models else (available_models[0] if available_models else None)
+    if not default:
+        print("❌ No deepfake models available.")
+        sys.exit(1)
 
-if default_model is None:
-    print("FATAL: No deepfake models were loaded. Cannot launch Gradio.")
-else:
     iface = gr.Interface(
         fn=unified_ekyc_analysis,
         inputs=[
-            gr.Dropdown(
-                label="Select Deepfake Model",
-                choices=available_models,
-                value=default_model,
-                interactive=True
-            ),
-            gr.Image(
-                type="pil",
-                label="Input 1: Live Selfie (Checked for Liveness)",
-                sources=['upload', 'webcam']
-            ),
-            gr.Image(type="pil", label="Input 2: Document Photo (Checked for Identity)")
+            gr.Dropdown(label="Select Deepfake Model", choices=models, value=default),
+            gr.Image(label="Input 1: Live Selfie", type="pil", sources=["upload", "webcam"]),
+            gr.Image(label="Input 2: Document Photo", type="pil")
         ],
         outputs=[
-            gr.Image(label="Input 1 Face (Final Status BBox)", height=256, width=256),
-            gr.Image(label="Input 2 Face (Final Status BBox)", height=256, width=256),
-            gr.Markdown(label="Final eKYC Report")
+            gr.Image(label="Processed Input 1"),
+            gr.Image(label="Processed Input 2"),
+            gr.Markdown(label="Verification Report")
         ],
-        title="Deepfake-Proof eKYC System (Unified Analysis)",
-        description="Performs two-step conditional verification: Step 1: Identity Match. Step 2 (if Match): Forgery/Liveness Check on both images. Includes automatic model download and is DLIB-free.",)
+        title="DLIB-Free eKYC Deepfake-Proof Verification",
+        description="Performs two-step verification: Identity Match + Deepfake/Liveness Detection.",
+    )
 
-    iface.launch(debug=False)
+    iface.launch(server_name="0.0.0.0", server_port=7860)