Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,10 +1,13 @@
 """
-Truth Detector - Simple & Accurate Edition
+Fake Review Detector - Streamlit Application
+Optimized for Hugging Face Spaces deployment
 """
 
 import os
 import io
 import numpy as np
+from collections import Counter
+from typing import Dict, Optional, List, Tuple
 import streamlit as st
 from transformers import pipeline, logging as hf_logging
 from PIL import Image
@@ -15,277 +18,416 @@ import urllib.parse
 import math
 import warnings
 
-# --- Setup: Silence the technical noise ---
-warnings.filterwarnings("ignore")
+# -------------------------
+# Log Suppression
+# -------------------------
+# 1. Suppress Python Warnings (Deprecation, UserWarning)
+warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+warnings.filterwarnings("ignore", category=FutureWarning, module="transformers")
+
+# 2. Suppress Hugging Face Informational Logs (Weights initialization, CPU usage)
 hf_logging.set_verbosity_error()
+
+# 3. Suppress TensorFlow/PyTorch logs if backend triggers them
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+# Set matplotlib backend for server environments
 matplotlib.use('Agg')
 
+# -------------------------
+# Configuration
+# -------------------------
 st.set_page_config(
-    page_title="Truth Detector",
-    page_icon="🔍",
+    page_title="Review Validator 🍔",
+    page_icon="🍔",
     layout="wide",
     initial_sidebar_state="collapsed"
 )
 
-# ==========================================
-# 🧠 THE AI BRAINS (Expert Configuration)
-# ==========================================
-
-# 1. Bot Detector: Checks if text was written by ChatGPT/AI
-MODEL_FAKE = "openai-community/roberta-base-openai-detector"
-
-# 2. Mood Scanner: Checks if the reviewer is Happy, Sad, or Angry
-MODEL_MOOD = "cardiffnlp/twitter-roberta-base-sentiment-latest"
+# Constants
+FAKE_MODEL_NAME = "akshit4857/autotrain-razz4-h7crd"
+SENTIMENT_MODEL_NAME = "cardiffnlp/twitter-roberta-base-sentiment-latest"
+EMOTION_MODEL_NAME = "j-hartmann/emotion-english-distilroberta-base"
+# Primary Image Model (High Precision)
+IMAGE_MODEL_PRIMARY = "dima806/ai_generated_image_detection"
+# Backup Image Model (High Reliability)
+IMAGE_MODEL_BACKUP = "umm-maybe/AI-image-detector"
 
-# 3. Grammar Checker: Checks if sentences make sense to a human
-MODEL_GRAMMAR = "textattack/roberta-base-CoLA"
+MAX_TEXT_LENGTH = 5000
 
-# 4. Image Checker A: High Precision
-MODEL_IMG_A = "dima806/ai_generated_image_detection"
-
-# 5. Image Checker B: High Reliability
-MODEL_IMG_B = "umm-maybe/AI-image-detector"
-
-# ==========================================
-
-# --- Secrets Management ---
-def get_token():
-    if hasattr(st, "secrets") and "HF_TOKEN" in st.secrets:
-        return st.secrets["HF_TOKEN"]
-    return os.environ.get("HF_TOKEN")
+# -------------------------
+# Secrets & Environment Management
+# -------------------------
+def get_secret(key: str, default: str = None) -> Optional[str]:
+    """
+    Robust secret retrieval.
+    Prioritizes Environment Variables (HF Spaces) to avoid Streamlit secrets file errors.
+    """
+    # 1. Priority: Environment Variables (Hugging Face Secrets)
+    if key in os.environ:
+        return os.environ[key]
+    
+    # 2. Fallback: Streamlit Secrets (Local .toml file)
+    try:
+        if hasattr(st, 'secrets') and key in st.secrets:
+            return st.secrets[key]
+    except Exception:
+        # Ignore errors if secrets.toml doesn't exist
+        pass
+    
+    return default
 
-HF_TOKEN = get_token()
+HF_TOKEN = get_secret("HF_TOKEN")
+OPENAI_API_KEY = get_secret("OPENAI_API_KEY")
 
-# --- Simple & Clean UI Design ---
+# -------------------------
+# Custom CSS
+# -------------------------
 def inject_custom_css():
     st.markdown("""
     <style>
-        /* Force a clean white/light look */
-        .stApp { background-color: #FFFFFF; color: #333333; }
-        
-        /* Headers */
-        h1 { color: #FF4B4B; font-weight: 800; text-align: center; }
-        h3 { color: #333333; font-weight: 700; }
-        
-        /* Stats Cards */
-        .result-card {
-            background-color: #F8F9FA;
-            border-radius: 15px;
-            padding: 20px;
-            text-align: center;
-            border: 1px solid #E0E0E0;
-            box-shadow: 0 2px 5px rgba(0,0,0,0.05);
-        }
-        .result-value { font-size: 28px; font-weight: 900; color: #333; }
-        .result-label { font-size: 14px; color: #666; text-transform: uppercase; margin-top: 5px; }
-        
-        /* Buttons */
-        .stButton>button {
-            border-radius: 50px;
-            width: 100%;
-            background-color: #FF4B4B;
-            color: white;
-            font-weight: bold;
-            border: none;
-            padding: 10px;
-        }
-        .stButton>button:hover { background-color: #D43F3F; color: white; }
+        .stApp { background: linear-gradient(to bottom, #ffffff, #f8f9fa); }
+        h1 { font-family: 'Source Sans Pro', sans-serif; color: #FF4B4B; text-align: center; font-weight: 800; }
+        .stButton>button { border-radius: 50px; border: 2px solid #FF4B4B; background-color: white; color: #FF4B4B; font-weight: bold; transition: all 0.3s ease; }
+        .stButton>button:hover { background-color: #FF4B4B; color: white; transform: scale(1.02); }
+        .stat-card { background-color: white; border-radius: 20px; padding: 15px; box-shadow: 0 4px 15px rgba(0,0,0,0.05); text-align: center; border: 1px solid #f0f0f0; height: 100%; }
+        .stat-value { font-size: 1.8em; font-weight: 900; color: #333; }
+        .stat-label { font-size: 0.8em; color: #888; text-transform: uppercase; letter-spacing: 1px; }
+        .report-box { background-color: #ffffff; padding: 25px; border-radius: 20px; border: 2px dashed #e0e0e0; }
     </style>
     """, unsafe_allow_html=True)
 
-# --- Load Models (The "Squad") ---
+# -------------------------
+# Model Loading (Ensemble)
+# -------------------------
 @st.cache_resource(show_spinner=False)
-def load_ai_squad():
-    squad = {}
+def load_models() -> Tuple[Dict, List[str]]:
+    """
+    Load all models for the ensemble with individual error handling.
+    Returns: (models_dictionary, list_of_error_messages)
+    """
+    models = {}
+    errors = []
+    
+    # 1. Fake Detector (Critical)
     try:
-        # Load Text Models
-        squad['fake'] = pipeline("text-classification", model=MODEL_FAKE, token=HF_TOKEN)
-        squad['mood'] = pipeline("sentiment-analysis", model=MODEL_MOOD, tokenizer=MODEL_MOOD, token=HF_TOKEN)
-        squad['grammar'] = pipeline("text-classification", model=MODEL_GRAMMAR, token=HF_TOKEN)
-        
-        # Load Image Models
-        try:
-            squad['img_a'] = pipeline("image-classification", model=MODEL_IMG_A, token=HF_TOKEN)
-            squad['img_b'] = pipeline("image-classification", model=MODEL_IMG_B, token=HF_TOKEN)
-            squad['img_status'] = "Double Check Mode (High Accuracy)"
-        except:
-            if 'img_a' not in squad:
-                squad['img_a'] = pipeline("image-classification", model=MODEL_IMG_A, token=HF_TOKEN)
-            squad['img_status'] = "Single Check Mode (Standard Accuracy)"
-            
+        models['fake'] = pipeline("text-classification", model=FAKE_MODEL_NAME, token=HF_TOKEN)
     except Exception as e:
-        return None, str(e)
-    return squad, None
-
-# --- Logic: Analyze Text ---
-def check_text(text, squad):
-    # 1. Bot Check
-    res_fake = squad['fake'](text[:512])[0]
-    if res_fake['label'] == 'Fake':
-        bot_score = res_fake['score']
-    else:
-        bot_score = 1 - res_fake['score']
+        errors.append(f"Fake Detector: {str(e)}")
+
+    # 2. Sentiment
+    try:
+        models['sentiment'] = pipeline("sentiment-analysis", model=SENTIMENT_MODEL_NAME, tokenizer=SENTIMENT_MODEL_NAME, token=HF_TOKEN)
+    except Exception as e:
+        errors.append(f"Sentiment Model: {str(e)}")
 
-    # 2. Mood Check
-    res_mood = squad['mood'](text[:512])[0]
+    # 3. Emotion
+    try:
+        # top_k=None replaces deprecated return_all_scores=True
+        models['emotion'] = pipeline("text-classification", model=EMOTION_MODEL_NAME, top_k=None, token=HF_TOKEN)
+    except Exception as e:
+        errors.append(f"Emotion Model: {str(e)}")
+
+    # 4. Image (With Failover Strategy)
+    models['image_engine'] = "Offline"
+    try:
+        # Try primary precision model first
+        models['img_a'] = pipeline("image-classification", model=IMAGE_MODEL_PRIMARY, token=HF_TOKEN)
+        # Try backup model
+        models['img_b'] = pipeline("image-classification", model=IMAGE_MODEL_BACKUP, token=HF_TOKEN)
+        models['image_engine'] = "Dual-Core"
+    except Exception as e:
+        print(f"Dual engine load failed: {e}")
+        try:
+            if 'img_a' not in models:
+                 models['img_a'] = pipeline("image-classification", model=IMAGE_MODEL_PRIMARY, token=HF_TOKEN)
+            models['image_engine'] = "Single-Core"
+            errors.append("Note: Running in reduced precision mode (one image model failed).")
+        except Exception as e2:
+            models['image_engine'] = "Failed"
+            errors.append(f"Image Checker failed completely: {str(e2)}")
+
+    return models, errors
+
+# Initialize models
+inject_custom_css()
+with st.spinner("🍳 Prepping the Kitchen..."):
+    ensemble, load_errors = load_models()
+
+# Handle Critical Errors
+if 'fake' not in ensemble:
+    st.error("❌ Critical Error: Failed to load the core Fake Detection model.")
+    if load_errors: 
+        st.error(f"Details: {load_errors}")
+    st.stop()
+
+if load_errors:
+    with st.expander("⚠️ System Warnings", expanded=False):
+        for err in load_errors:
+            st.warning(err)
+
+# -------------------------
+# Advanced Feature Extraction
+# -------------------------
+def calculate_complexity_score(text: str) -> float:
+    """Calculate linguistic complexity (0-100)"""
+    words = text.split()
+    if not words: return 0
+    avg_len = sum(len(w) for w in words) / len(words)
+    ttr = len(set(words)) / len(words)
+    score = (avg_len * 5) + (ttr * 50)
+    return min(100, max(0, score))
+
+def extract_deep_features(text: str, models: dict) -> Dict:
+    """Run multi-model analysis"""
+    sent_label = "Unknown"
+    sent_score = 0.0
+    top_emo = {'label': 'Unknown', 'score': 0.0}
+
+    # 1. Fake Detection
+    fake_res = models['fake'](text[:512])[0]
+    is_fake_prob = fake_res['score'] if fake_res['label'] == 'Fake' else (1 - fake_res['score'])
     
-    # 3. Grammar Check
-    res_grammar = squad['grammar'](text[:512])[0]
-    # Label 1 = Good Grammar
-    if res_grammar['label'] == 'LABEL_1':
-        grammar_score = res_grammar['score']
-    else:
-        grammar_score = 1 - res_grammar['score']
+    # 2. Sentiment
+    if 'sentiment' in models:
+        try:
+            sent_res = models['sentiment'](text[:512])[0]
+            sent_score = sent_res['score']
+            sent_label = sent_res['label']
+        except Exception: pass
+    
+    # 3. Emotion
+    if 'emotion' in models:
+        try:
+            emo_res = models['emotion'](text[:512])[0]
+            top_emo = max(emo_res, key=lambda x: x['score'])
+        except Exception: pass
+    
+    complexity = calculate_complexity_score(text)
     
     return {
-        "bot_score": bot_score * 100,
-        "mood_label": res_mood['label'],
-        "grammar_score": grammar_score * 100
+        "fake_probability": is_fake_prob * 100,
+        "sentiment_label": sent_label,
+        "sentiment_confidence": sent_score * 100,
+        "primary_emotion": top_emo['label'],
+        "emotion_confidence": top_emo['score'] * 100,
+        "complexity_score": complexity
     }
 
-# --- Logic: Analyze Image ---
-def check_image(img, squad):
-    score_a = 0.0
-    score_b = 0.0
-    
-    ai_words = ['fake', 'artificial', 'ai', 'generated']
+# -------------------------
+# AI-Powered Dynamic Explanation
+# -------------------------
+def generate_friendly_report(text: str, features: Dict) -> str:
+    """Generates a simple, friendly explanation"""
+    if not OPENAI_API_KEY:
+        return generate_fallback_report(features)
+        
+    prompt = (
+        f"Analyze this product/food review. Fake Score: {features['fake_probability']:.1f}%. "
+        f"Vibe: {features['primary_emotion']}. Text: {text[:600]}... "
+        "Explain if it sounds like a real customer or a bot. Be simple and helpful."
+    )
     
-    # Check Brain A
-    if 'img_a' in squad:
-        for r in squad['img_a'](img):
-            if any(w in r['label'].lower() for w in ai_words):
-                score_a = r['score']
+    try:
+        headers = {"Authorization": f"Bearer {OPENAI_API_KEY}", "Content-Type": "application/json"}
+        payload = {
+            "model": "gpt-4o-mini", 
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.5
+        }
+        response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload, timeout=10)
+        return response.json()["choices"][0]["message"]["content"]
+    except:
+        return generate_fallback_report(features)
+
+def generate_fallback_report(features: Dict) -> str:
+    """Simple rule-based report"""
+    f_prob = features['fake_probability']
     
-    # Check Brain B
-    if 'img_b' in squad:
-        for r in squad['img_b'](img):
-            if any(w in r['label'].lower() for w in ai_words):
-                score_b = r['score']
+    if f_prob > 50:
+        return f"⚠️ **Suspicious!** There is a {f_prob:.0f}% chance this review was written by a bot or paid service."
     else:
-        score_b = score_a # Fallback if B is missing
-        
-    avg_ai = (score_a + score_b) / 2
-    match_level = 1.0 - abs(score_a - score_b) # 1.0 = They agree perfectly
+        return "✅ **Looks Good!** This review reads like a genuine customer experience."
+
+# -------------------------
+# Visualization: Radar Chart
+# -------------------------
+def create_radar_chart(features: Dict) -> plt.Figure:
+    """Creates a multi-aspect radar chart"""
+    categories = ['Suspiciousness', 'Feelings', 'Drama', 'Simplicity']
+    inv_comp = 100 - features['complexity_score']
+    
+    values = [
+        features['fake_probability'],
+        features['sentiment_confidence'],
+        features['emotion_confidence'],
+        inv_comp
+    ]
+    
+    # Close the loop
+    values += values[:1]
+    angles = [n / 4 * 2 * math.pi for n in range(4)] + [0]
+    
+    fig, ax = plt.subplots(figsize=(4, 4), subplot_kw=dict(polar=True))
+    
+    # Styling
+    ax.set_facecolor('#ffffff')
+    plt.gcf().patch.set_facecolor('#ffffff')
     
-    return {"ai_chance": avg_ai * 100, "match": match_level}
+    ax.plot(angles, values, linewidth=2, linestyle='solid', color='#FF4B4B')
+    ax.fill(angles, values, '#FF4B4B', alpha=0.2)
+    
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories, size=9)
+    ax.set_yticks([])
+    ax.spines['polar'].set_visible(False)
+    
+    return fig
 
-# --- Helpers ---
-def get_image_from_url(url):
+# -------------------------
+# Image Functions
+# -------------------------
+def get_image_from_url(url: str) -> Optional[Image.Image]:
     try:
         headers = {'User-Agent': 'Mozilla/5.0'}
-        r = requests.get(url, headers=headers, timeout=5, stream=True)
-        return Image.open(io.BytesIO(r.content)).convert("RGB")
-    except: return None
+        response = requests.get(url, headers=headers, timeout=10, stream=True)
+        response.raise_for_status()
+        return Image.open(io.BytesIO(response.content)).convert("RGB")
+    except Exception:
+        return None
 
-# --- MAIN APP UI ---
-def main():
-    inject_custom_css()
+def analyze_image_dual_engine(img, models) -> Dict:
+    score_a_ai = 0.0
+    score_b_ai = 0.0
     
-    st.markdown("<h1>🔎 Review & Image Truth Detector</h1>", unsafe_allow_html=True)
-    st.markdown("<p style='text-align: center;'>Use AI to spot Fake Reviews and AI Images instantly.</p>", unsafe_allow_html=True)
+    # Engine A
+    if 'img_a' in models:
+        res_a = models['img_a'](img)
+        for r in res_a:
+            if r['label'].lower() in ['fake', 'artificial', 'ai', 'generated']:
+                score_a_ai = r['score']
     
-    with st.spinner("🚀 Loading AI Models..."):
-        squad, err = load_ai_squad()
+    # Engine B
+    if 'img_b' in models:
+        res_b = models['img_b'](img)
+        for r in res_b:
+            if r['label'].lower() in ['fake', 'artificial', 'ai', 'generated']:
+                score_b_ai = r['score']
+    else:
+        score_b_ai = score_a_ai
     
-    if not squad:
-        st.error(f"Error loading models: {err}")
-        st.stop()
+    avg_ai_score = (score_a_ai + score_b_ai) / 2
+    agreement = 1.0 - abs(score_a_ai - score_b_ai)
+    
+    return {
+        "avg_ai": avg_ai_score,
+        "avg_real": 1.0 - avg_ai_score,
+        "score_a": score_a_ai,
+        "score_b": score_b_ai,
+        "agreement": agreement
+    }
 
-    tab1, tab2 = st.tabs(["📝 Text Check", "📸 Image Check"])
+# -------------------------
+# Main UI
+# -------------------------
+def main():
+    st.markdown("""
+        <div style='text-align: center; padding-bottom: 20px;'>
+            <h1 style='margin:0;'>🍔 Review & Food Validator</h1>
+            <p style='color: #888;'>Is that burger real? Is that review a bot?</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+    tab1, tab2 = st.tabs(["📝 Review Text", "🍟 Food/Product Image"])
 
-    # --- TEXT CHECKER ---
+    # --- TAB 1: TEXT ---
     with tab1:
-        col1, col2 = st.columns([2, 1])
+        col1, col2 = st.columns([3, 1])
         with col1:
-            txt = st.text_area("Paste Review Here:", height=150, placeholder="e.g. This product is amazing!")
+            txt = st.text_area("Paste Review:", height=120, placeholder="e.g. 'The pizza was cold and...'")
         with col2:
-            if st.button("Analyze Text"):
-                if txt:
-                    res = check_text(txt, squad)
-                    st.session_state['text_res'] = res
-        
-        if 'text_res' in st.session_state:
-            res = st.session_state['text_res']
-            st.markdown("---")
-            
-            c1, c2, c3 = st.columns(3)
-            
-            # Simple Bot Score Card
-            color = "red" if res['bot_score'] > 50 else "green"
-            c1.markdown(f"""
-            <div class="result-card">
-                <div class="result-value" style="color:{color}">{res['bot_score']:.0f}%</div>
-                <div class="result-label">Bot Probability</div>
-            </div>""", unsafe_allow_html=True)
-            
-            # Grammar Card
-            c2.markdown(f"""
-            <div class="result-card">
-                <div class="result-value">{res['grammar_score']:.0f}%</div>
-                <div class="result-label">Grammar Quality</div>
-            </div>""", unsafe_allow_html=True)
-            
-            # Mood Card
-            c3.markdown(f"""
-            <div class="result-card">
-                <div class="result-value">{res['mood_label']}</div>
-                <div class="result-label">Overall Mood</div>
-            </div>""", unsafe_allow_html=True)
-            
-            st.write("")
-            
-            # Simple Verdict
-            if res['bot_score'] > 70:
-                st.error("🚨 **Verdict: FAKE / BOT**")
-                st.write("This text looks highly suspicious. It matches patterns used by AI generators like ChatGPT.")
-            elif res['bot_score'] > 40:
-                st.warning("🤔 **Verdict: UNSURE**")
-                st.write("It has some weird patterns, but could be a unique human writing style.")
-            else:
-                st.success("✅ **Verdict: REAL HUMAN**")
-                st.write("The writing style is natural and likely written by a real person.")
-
-    # --- IMAGE CHECKER ---
+            st.info("💡 **Tip:** Paste the full text for best results.")
+            if st.button("Scan Text", type="primary", use_container_width=True):
+                if not txt:
+                    st.toast("Please paste some text first!")
+                    st.stop()
+                    
+                with st.spinner("Analysing linguistics..."):
+                    feats = extract_deep_features(txt, ensemble)
+                    rep = generate_friendly_report(txt, feats)
+                    
+                    st.markdown("---")
+                    
+                    # Metrics
+                    c1, c2, c3, c4 = st.columns(4)
+                    c1.metric("Fake-o-Meter", f"{feats['fake_probability']:.0f}%")
+                    c2.metric("Mood", feats['sentiment_label'])
+                    c3.metric("Vibe", feats['primary_emotion'].title())
+                    c4.metric("Vocab", f"{feats['complexity_score']:.0f}/100")
+                    
+                    # Chart & Report
+                    col_c, col_r = st.columns([1, 2])
+                    with col_c:
+                        st.pyplot(create_radar_chart(feats))
+                    with col_r:
+                        st.markdown(f"<div class='report-box'>{rep}</div>", unsafe_allow_html=True)
+
+    # --- TAB 2: IMAGE ---
     with tab2:
-        st.caption(f"System Status: {squad.get('img_status')}")
-        url = st.text_input("Paste Image Link:", placeholder="https://example.com/image.jpg")
+        st.markdown("### 📸 Product & Food Verification")
+        st.caption("Step 1: Check for AI Generation. Step 2: Check if it's stolen from the web.")
+        
+        url = st.text_input("Paste Image URL (Right click image -> Copy Image Address):")
         
-        if st.button("Scan Image"):
-            if url:
-                with st.spinner("Scanning pixels..."):
-                    img = get_image_from_url(url)
-                    if img:
-                        ic1, ic2 = st.columns([1, 1])
-                        with ic1:
-                            st.image(img, use_column_width=True, caption="Your Image")
-                        with ic2:
-                            data = check_image(img, squad)
-                            ai_score = data['ai_chance']
-                            
-                            # Simple Results
-                            if data['match'] < 0.6:
-                                st.warning("🤔 **Confusing Image**")
-                                st.write("Our models disagree. This happens with heavy filters.")
-                            elif ai_score > 60:
-                                st.error(f"🤖 **Verdict: AI GENERATED** ({ai_score:.0f}%)")
-                                st.write("We found digital artifacts common in tools like Midjourney.")
-                            else:
-                                st.success(f"📸 **Verdict: REAL PHOTO** ({100-ai_score:.0f}%)")
-                                st.write("This looks like a genuine photo.")
-                            
-                            st.progress(ai_score/100, text=f"AI Probability: {ai_score:.1f}%")
-                            
-                            # Google Lens Link
-                            lens = f"https://lens.google.com/uploadbyurl?url={urllib.parse.quote(url)}"
-                            st.markdown(f"""
-                            <br><a href="{lens}" target="_blank" style="text-decoration:none;">
-                                <div style="background:#4285F4;color:white;padding:12px;border-radius:10px;text-align:center;font-weight:bold;">
-                                    🌍 Check on Google Lens
-                                </div>
-                            </a>""", unsafe_allow_html=True)
-                    else:
-                        st.error("Invalid Image Link.")
+        if st.button("🔍 Validate Image", type="primary"):
+            if not url: st.stop()
+            
+            if ensemble['image_engine'] == "Failed":
+                st.error("System Offline")
+                st.stop()
+                
+            with st.spinner("Forensic Scan in progress..."):
+                img = get_image_from_url(url)
+                if img:
+                    c_img, c_data = st.columns([1, 1])
+                    with c_img:
+                        st.image(img, use_column_width=True)
+                    
+                    with c_data:
+                        # Dual Engine Analysis
+                        res = analyze_image_dual_engine(img, ensemble)
+                        ai_p = res['avg_ai'] * 100
+                        real_p = res['avg_real'] * 100
+                        
+                        st.subheader("Step 1: AI Detection")
+                        
+                        # Verdict Logic
+                        if res['agreement'] < 0.6:
+                            st.warning("🤔 **Uncertain Result**")
+                            st.markdown("The models disagree. This might be a heavily filtered real photo.")
+                        elif ai_p > 60:
+                            st.error(f"🤖 **Likely AI Generated** ({ai_p:.0f}%)")
+                            st.markdown("Visual patterns suggest this is computer-generated.")
+                        elif real_p > 60:
+                            st.success(f"✅ **Likely Real Camera** ({real_p:.0f}%)")
+                            st.markdown("Visual noise patterns match a real camera sensor.")
+                        else:
+                            st.warning("🤷 **Inconclusive**")
+
+                        st.progress(res['avg_ai'], text=f"AI Probability: {ai_p:.1f}%")
+                        
+                        st.markdown("---")
+                        st.subheader("Step 2: Internet Check")
+                        st.markdown("Check if this photo was **stolen** from another website (Recipe blog, Stock photo, etc).")
+                        
+                        lens = f"https://lens.google.com/uploadbyurl?url={urllib.parse.quote(url)}"
+                        st.markdown(f"""
+                        <a href="{lens}" target="_blank" style="display:block;text-align:center;background:#4285F4;color:white;padding:10px;border-radius:8px;text-decoration:none;font-weight:bold;">
+                        🌍 Check if image exists online
+                        </a>
+                        """, unsafe_allow_html=True)
+                else:
+                    st.error("Could not load image. Check the link!")
 
 if __name__ == "__main__":
     main()