Update src/streamlit_app.py

src/streamlit_app.py

@@ -2,7 +2,553 @@
 Fake Review Detector - Streamlit Application
 Optimized for Hugging Face Spaces deployment
 """
+"""
+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
+import matplotlib.pyplot as plt
+import matplotlib
+import requests
+import urllib.parse
+import math
+import warnings
+
+# -------------------------
+# Log Suppression
+# -------------------------
+warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+warnings.filterwarnings("ignore", category=FutureWarning, module="transformers")
+hf_logging.set_verbosity_error()
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+matplotlib.use('Agg')
+
+# -------------------------
+# Configuration
+# -------------------------
+st.set_page_config(
+    page_title="Truth Detector 🕵️‍♀️",
+    page_icon="🕵️‍♀️",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+# 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"
+
+# --- DUAL ENGINE IMAGE DETECTION ---
+IMAGE_MODEL_A = "dima806/ai_generated_image_detection"
+IMAGE_MODEL_B = "umm-maybe/AI-image-detector"
+
+MAX_TEXT_LENGTH = 5000
+
+# -------------------------
+# Secrets & Environment Management
+# -------------------------
+def get_secret(key: str, default: str = None) -> Optional[str]:
+    try:
+        if hasattr(st, 'secrets') and key in st.secrets:
+            return st.secrets[key]
+    except Exception:
+        pass
+    return os.environ.get(key, default)
+
+HF_TOKEN = get_secret("HF_TOKEN")
+OPENAI_API_KEY = get_secret("OPENAI_API_KEY")
+
+# -------------------------
+# Custom CSS for Playful UI
+# -------------------------
+def inject_custom_css():
+    st.markdown("""
+    <style>
+        /* General App Background */
+        .stApp {
+            background: linear-gradient(to bottom, #ffffff, #f8f9fa);
+        }
+        
+        /* Fun Headers */
+        h1 {
+            font-family: 'Source Sans Pro', sans-serif;
+            color: #FF4B4B;
+            text-align: center;
+            font-weight: 800;
+            letter-spacing: -1px;
+        }
+        
+        /* Rounded Buttons */
+        .stButton>button {
+            border-radius: 50px;
+            border: 2px solid #FF4B4B;
+            background-color: white;
+            color: #FF4B4B;
+            font-weight: bold;
+            transition: all 0.3s ease;
+            padding: 10px 25px;
+        }
+        .stButton>button:hover {
+            background-color: #FF4B4B;
+            color: white;
+            transform: scale(1.02);
+            border-color: #FF4B4B;
+        }
+        
+        /* Card Style for Stats */
+        .stat-card {
+            background-color: white;
+            border-radius: 20px;
+            padding: 20px;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.05);
+            text-align: center;
+            border: 1px solid #f0f0f0;
+            height: 100%;
+        }
+        .stat-value {
+            font-size: 2em;
+            font-weight: 900;
+            margin: 0;
+            color: #333;
+        }
+        .stat-label {
+            font-size: 0.9em;
+            color: #888;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            margin-top: 5px;
+        }
+        
+        /* Report Box */
+        .report-box {
+            background-color: #ffffff;
+            padding: 25px;
+            border-radius: 20px;
+            border: 2px dashed #e0e0e0;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.02);
+        }
+    </style>
+    """, unsafe_allow_html=True)
+
+# -------------------------
+# Model Loading
+# -------------------------
+@st.cache_resource(show_spinner=False)
+def load_models() -> Tuple[Dict, List[str]]:
+    models = {}
+    errors = []
+    
+    # Text Models
+    try:
+        models['fake'] = pipeline("text-classification", model=FAKE_MODEL_NAME, token=HF_TOKEN)
+    except Exception as e:
+        errors.append(f"Fake Detector: {str(e)}")
+
+    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)}")
+
+    try:
+        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)}")
+
+    # Image Models (Dual Engine)
+    models['image_engine'] = "Offline"
+    try:
+        # Load Engine A
+        models['img_a'] = pipeline("image-classification", model=IMAGE_MODEL_A, token=HF_TOKEN)
+        # Load Engine B
+        models['img_b'] = pipeline("image-classification", model=IMAGE_MODEL_B, token=HF_TOKEN)
+        models['image_engine'] = "Dual-Core (High Precision)"
+    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_A, token=HF_TOKEN)
+            models['image_engine'] = "Single-Core (Standard)"
+            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
+inject_custom_css()
+with st.spinner("🧠 Waking up the AI Brains..."):
+    ensemble, load_errors = load_models()
+
+if 'fake' not in ensemble:
+    st.error("❌ Oops! The main brain failed to load. Please refresh.")
+    st.stop()
+
+# -------------------------
+# Feature Extraction
+# -------------------------
+def calculate_complexity_score(text: str) -> float:
+    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:
+    sent_label = "Unknown"
+    sent_score = 0.0
+    top_emo = {'label': 'Unknown', 'score': 0.0}
+    emo_res = []
+
+    fake_res = models['fake'](text[:512])[0]
+    is_fake_prob = fake_res['score'] if fake_res['label'] == 'Fake' else (1 - fake_res['score'])
+    
+    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
+    
+    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 {
+        "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,
+        "raw_emotion_scores": emo_res
+    }
+
+# -------------------------
+# Friendly Explanation
+# -------------------------
+def generate_friendly_report(text: str, features: Dict) -> str:
+    if not OPENAI_API_KEY:
+        return generate_fallback_report(features)
+        
+    prompt = (
+        f"Act as a super friendly detective. Analyze this review.\n\n"
+        f"STATS:\n"
+        f"- Fake Score: {features['fake_probability']:.1f}%\n"
+        f"- Mood: {features['sentiment_label']} ({features['sentiment_confidence']:.1f}%)\n"
+        f"- Vibe: {features['primary_emotion']}\n"
+        f"- Brainy Score: {features['complexity_score']:.1f}/100\n"
+        f"- Text: {text[:600]}...\n\n"
+        f"TASK:\n"
+        f"Is this real or fake? Explain why in simple, fun terms. No robot words.\n\n"
+        f"FORMAT:\n"
+        f"3 bullets: '✍️ Style Check', '❤️ Vibe Check', '💡 The Truth'."
+    )
+    
+    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=15)
+        return response.json()["choices"][0]["message"]["content"]
+    except:
+        return generate_fallback_report(features)
+
+def generate_fallback_report(features: Dict) -> str:
+    f_prob = features['fake_probability']
+    emo = features['primary_emotion']
+    comp = features['complexity_score']
+    
+    report = "### ✍️ Style Check\n"
+    if comp < 40:
+        report += "It uses very simple words over and over. Bots often do this to be fast. Humans usually mix it up more!\n\n"
+    else:
+        report += "The writing is detailed and flowery. This usually means a real person took the time to write it.\n\n"
+        
+    report += "### ❤️ Vibe Check\n"
+    if f_prob > 70 and emo in ['joy', 'surprise']:
+        report += f"Whoa, so much '{emo}'! Fake reviews often scream 'THIS IS AMAZING' just to sell stuff.\n\n"
+    elif f_prob > 70 and emo in ['anger', 'disgust']:
+        report += f"Yikes, lots of '{emo}'. Sometimes rivals write nasty reviews to hurt a business.\n\n"
+    else:
+        report += f"The vibe feels like '{emo}', which matches the star rating perfectly.\n\n"
+        
+    report += "### 💡 The Truth\n"
+    if f_prob > 50:
+        report += f"I'm **{f_prob:.0f}% sure this is FAKE**. It just doesn't feel right!"
+    else:
+        report += "This looks like a **REAL review** from a real person. You're good!"
+        
+    return report
+
+# -------------------------
+# Visualization: Clean Radar Chart
+# -------------------------
+def create_radar_chart(features: Dict) -> plt.Figure:
+    categories = ['Fake-o-Meter', 'Feelings', 'Drama Level', 'Simple Words']
+    inv_complexity = 100 - features['complexity_score']
+    
+    values = [
+        features['fake_probability'],
+        features['sentiment_confidence'],
+        features['emotion_confidence'],
+        inv_complexity
+    ]
+    
+    N = len(categories)
+    angles = [n / float(N) * 2 * math.pi for n in range(N)]
+    values += values[:1]
+    angles += angles[:1]
+    
+    fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
+    
+    ax.set_facecolor('#ffffff')
+    plt.gcf().patch.set_facecolor('#ffffff')
+    
+    ax.plot(angles, values, linewidth=3, linestyle='solid', color='#FF4B4B')
+    ax.fill(angles, values, '#FF4B4B', alpha=0.2)
+    
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories, size=12, weight='bold', color="#444")
+    
+    ax.set_yticks([25, 50, 75, 100])
+    ax.set_yticklabels(["", "", "", ""], color="grey", size=7)
+    ax.set_ylim(0, 100)
+    
+    ax.spines['polar'].set_visible(False)
+    ax.grid(color='#eeeeee')
+    
+    return fig
+
+# -------------------------
+# Image Logic (Dual Engine)
+# -------------------------
+def get_image_from_url(url: str) -> Optional[Image.Image]:
+    try:
+        headers = {'User-Agent': 'Mozilla/5.0'}
+        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
+
+def get_google_lens_url(image_url: str) -> str:
+    return f"https://lens.google.com/uploadbyurl?url={urllib.parse.quote(image_url)}"
+
+def analyze_image_dual_engine(img, models) -> Dict:
+    score_a_ai = 0.0
+    score_b_ai = 0.0
+    
+    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']
+    
+    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']
+    
+    if 'img_b' not in models:
+        score_b_ai = score_a_ai
+    
+    avg_ai_score = (score_a_ai + score_b_ai) / 2
+    
+    # Agreement: How close are the two models?
+    # If one says 90% and other says 10%, agreement is low (0.2)
+    # If both say 90%, agreement is high (1.0)
+    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
+    }
+
+# -------------------------
+# Main UI
+# -------------------------
+def main():
+    st.markdown("""
+        <div style='text-align: center; padding-bottom: 30px;'>
+            <h1 style='margin-bottom: 0;'>🕵️‍♀️ Truth Detector</h1>
+            <p style='color: #888; font-size: 1.2em; margin-top: 5px;'>
+                Real or Fake? Let's investigate! 🔍
+            </p>
+        </div>
+    """, unsafe_allow_html=True)
+
+    tab1, tab2 = st.tabs(["📝 Check Text", "📸 Check Photo"])
+
+    # --- TAB 1: TEXT ---
+    with tab1:
+        col_in1, col_in2 = st.columns([3, 1])
+        with col_in1:
+            review_text = st.text_area("Paste review here:", height=150, placeholder="e.g., 'OMG best product ever!!!'")
+        with col_in2:
+            st.markdown("""
+            <div class="stat-card" style="padding: 15px; text-align: left;">
+                <b>🕵️ Tips:</b><br>
+                <small>
+                • Paste full reviews<br>
+                • Long text is better<br>
+                • Check English only
+                </small>
+            </div>
+            """, unsafe_allow_html=True)
+            
+        if st.button("✨ Scan for Truth", type="primary", use_container_width=True):
+            if not review_text:
+                st.toast("Please paste some text first!")
+                st.stop()
+                
+            with st.spinner("🕵️‍♀️ Investigating clues..."):
+                features = extract_deep_features(review_text, ensemble)
+                report = generate_friendly_report(review_text, features)
+                
+                st.write("") # Spacer
+                
+                # --- Fun Stat Cards ---
+                c1, c2, c3, c4 = st.columns(4)
+                
+                # 1. Fake-o-Meter
+                risk_color = "#FF4B4B" if features['fake_probability'] > 60 else "#4CAF50"
+                c1.markdown(f"""
+                    <div class="stat-card">
+                        <div class="stat-value" style="color: {risk_color}">{features['fake_probability']:.0f}%</div>
+                        <div class="stat-label">🤖 Fake-o-Meter</div>
+                    </div>
+                """, unsafe_allow_html=True)
+
+                # 2. Mood
+                c2.markdown(f"""
+                    <div class="stat-card">
+                        <div class="stat-value">{features['sentiment_label']}</div>
+                        <div class="stat-label">❤️ Mood</div>
+                    </div>
+                """, unsafe_allow_html=True)
+
+                # 3. Vibe
+                c3.markdown(f"""
+                    <div class="stat-card">
+                        <div class="stat-value">{features['primary_emotion'].title()}</div>
+                        <div class="stat-label">🎭 Vibe</div>
+                    </div>
+                """, unsafe_allow_html=True)
+
+                # 4. Brainy Score
+                c4.markdown(f"""
+                    <div class="stat-card">
+                        <div class="stat-value">{features['complexity_score']:.0f}</div>
+                        <div class="stat-label">🧠 Brainy Score</div>
+                    </div>
+                """, unsafe_allow_html=True)
+
+                st.markdown("---")
+
+                # Chart & Text
+                col_chart, col_text = st.columns([1, 1.5])
+                
+                with col_chart:
+                    st.subheader("🎯 The Shape of Truth")
+                    fig = create_radar_chart(features)
+                    st.pyplot(fig)
+                    plt.close(fig)
+                    
+                with col_text:
+                    st.subheader("📝 Detective's Notes")
+                    st.markdown(f"""<div class="report-box">{report}</div>""", unsafe_allow_html=True)
+
+    # --- TAB 2: IMAGE ---
+    with tab2:
+        st.markdown("### 📸 Is this photo real?")
+        
+        status_text = "Dual Brains Active 🧠🧠" if ensemble['image_engine'].startswith("Dual") else "Single Brain Mode 🧠"
+        st.caption(f"System Status: {status_text}")
+        
+        img_url = st.text_input("Paste Image Link (URL):")
+        
+        if st.button("🔍 Scan Photo", type="primary"):
+            if not img_url: st.stop()
+            
+            if ensemble['image_engine'] == "Failed":
+                st.error("Sorry, the photo scanner is sleeping right now.")
+                st.stop()
+                
+            with st.spinner("👀 Looking closely at pixels..."):
+                img = get_image_from_url(img_url)
+                if img:
+                    c_img, c_res = st.columns([1, 1])
+                    with c_img:
+                        st.image(img, use_column_width=True)
+                    
+                    with c_res:
+                        res = analyze_image_dual_engine(img, ensemble)
+                        
+                        ai_percent = res['avg_ai'] * 100
+                        real_percent = res['avg_real'] * 100
+                        agreement = res['agreement']
+                        
+                        # --- Playful Verdicts ---
+                        if agreement < 0.6:
+                            st.warning(f"🤔 **It's Confusing!**")
+                            st.markdown("Our AI brains disagree! One thinks it's real, the other says fake. It might be heavily edited.")
+                            with st.expander("See Brain Argument"):
+                                st.write(f"Brain A says: {res['score_a']*100:.0f}% Fake")
+                                st.write(f"Brain B says: {res['score_b']*100:.0f}% Fake")
+                        
+                        elif ai_percent > 60:
+                            st.error(f"🤖 **Definitely AI!** ({ai_percent:.0f}% sure)")
+                            st.markdown("This photo has computer-made patterns all over it.")
+                            
+                        elif real_percent > 60:
+                            st.success(f"📸 **Real Photo!** ({real_percent:.0f}% sure)")
+                            st.markdown("This looks like a genuine snapshot from a camera.")
+                            
+                        else:
+                            st.warning(f"🤷 **Hard to Tell**")
+                            st.markdown("It's right on the edge. Might be a real photo with lots of filters.")
+
+                        st.write("")
+                        st.markdown("#### Confidence Levels")
+                        st.progress(res['avg_real'], text=f"📸 Real: {real_percent:.1f}%")
+                        st.progress(res['avg_ai'], text=f"🤖 AI: {ai_percent:.1f}%")
+                        
+                        lens = get_google_lens_url(img_url)
+                        st.markdown(f"""
+                            <br>
+                            <a href="{lens}" target="_blank" style="
+                                display: block; width: 100%; text-align: center;
+                                padding: 12px; color: white; background-color: #4285F4;
+                                border-radius: 10px; text-decoration: none; font-weight: bold;
+                                box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+                            ">🔎 Double-Check on Google</a>
+                        """, unsafe_allow_html=True)
+                else:
+                    st.error("Couldn't grab that image. Is the link correct?")
+
+if __name__ == "__main__":
+    main()
 import os
 import io
 import numpy as np