Update app.py

app.py

@@ -3,6 +3,7 @@ import numpy as np
 import warnings
 import feedparser
 from datetime import datetime
+import gradio as gr
 
 warnings.filterwarnings('ignore')
 print("✅ Core imports done.")
@@ -116,7 +117,6 @@ if not headlines:
 news_df = pd.DataFrame(headlines)
 news_df['published_at'] = pd.to_datetime(news_df['published_at'], errors='coerce', utc=True)
 print(f"✅ Live news loaded: {len(news_df)} headlines from {news_df['source'].nunique()} sources")
-news_df.head(3)
 
 from transformers import pipeline
 from sentence_transformers import SentenceTransformer
@@ -195,7 +195,6 @@ INVENTED_INSTITUTIONS = re.compile(
 )
 
 def get_sentiment_score(text: str) -> float:
-    """Returns float in [-1, 1]. Negative = negative sentiment."""
     try:
         result = sentiment_pipeline(text[:512])[0]
         score = result['score']
@@ -204,29 +203,22 @@ def get_sentiment_score(text: str) -> float:
         return 0.0
 
 def get_source_credibility(source: str) -> float:
-    """Lookup against known domain credibility scores."""
     for domain, score in SOURCE_CREDIBILITY.items():
         if domain.lower() in source.lower():
             return score
-    return 0.5  # unknown source → uncertain
+    return 0.5
 
 def get_citation_anomaly_score(text: str) -> float:
-    """Detects patterns common in hallucinated citations."""
     score = 0.0
-    # Fake DOI pattern
     if FAKE_DOI_PATTERN.search(text): score += 0.3
-    # Impossible year references
     if IMPOSSIBLE_YEAR.search(text): score += 0.3
-    # Suspicious institution names
     if INVENTED_INSTITUTIONS.search(text): score += 0.4
     return min(score, 1.0)
 
 def get_semantic_similarity(text: str, k: int = 3) -> float:
-    """Cosine similarity of input against top-k trusted FAISS facts."""
     try:
         emb = embedder.encode([text], convert_to_numpy=True).astype(np.float32)
         distances, _ = faiss_index.search(emb, k)
-        # Convert L2 distance to similarity (lower distance = higher similarity)
         avg_dist = np.mean(distances[0])
         similarity = 1.0 / (1.0 + avg_dist)
         return float(np.clip(similarity, 0, 1))
@@ -234,21 +226,18 @@ def get_semantic_similarity(text: str, k: int = 3) -> float:
         return 0.5
 
 def get_nli_contradiction_score(claim: str, references: list) -> float:
-    """DeBERTa NLI: fraction of references that contradict the claim."""
     try:
         result = nli_pipeline(
             claim,
             candidate_labels=["entailment", "neutral", "contradiction"],
             hypothesis_template="This claim is related to: {}",
         )
-        # Get contradiction score
         scores = dict(zip(result['labels'], result['scores']))
         return float(scores.get('contradiction', 0.0))
     except:
         return 0.5
 
 def retrieve_reference_sentences(claim: str, k: int = 5) -> list:
-    """Retrieve top-k relevant facts from FAISS index."""
     try:
         emb = embedder.encode([claim], convert_to_numpy=True).astype(np.float32)
         _, indices = faiss_index.search(emb, k)
@@ -258,40 +247,11 @@ def retrieve_reference_sentences(claim: str, k: int = 5) -> list:
 
 print("✅ Feature extraction functions defined.")
 
-# ── Compute Features on a Sample ──────────────────────────────────────────────
-SAMPLE_TEXTS = [
-    "The moon is made of cheese.",
-    "Water boils at 100°C at sea level.",
-    "Scientists discovered that 5G towers emit mind-control frequencies.",
-    "The Eiffel Tower is 330 meters tall.",
-    "According to a 2031 study from the Institute of Neural Enhancement, humans only use 10% of their brain.",
-]
-
-rows = []
-for text in SAMPLE_TEXTS:
-    refs = retrieve_reference_sentences(text)
-    row = {
-        'text': text[:60] + '...' if len(text) > 60 else text,
-        'sentiment_score': get_sentiment_score(text),
-        'source_credibility': 0.5,  # unknown source for these samples
-        'nli_contradiction_score': get_nli_contradiction_score(text, refs),
-        'citation_anomaly_score': get_citation_anomaly_score(text),
-        'semantic_similarity': get_semantic_similarity(text),
-    }
-    rows.append(row)
-
-features_df = pd.DataFrame(rows)
-print("✅ Feature matrix computed:")
-features_df
-
 # ── A. Fake News Classifier (LIAR → 3-class) ──────────────────────────────────
 from sklearn.linear_model import LogisticRegression
-from sklearn.preprocessing import LabelEncoder
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import classification_report
-import numpy as np
 
-# Collapse LIAR 6-class to 3-class
 LIAR_MAP = {
     'pants-fire': 'misinformation',
     'false': 'misinformation',
@@ -304,37 +264,27 @@ LIAR_MAP = {
 liar_sample = liar_df.sample(min(500, len(liar_df)), random_state=42).copy()
 liar_sample['label_3'] = liar_sample['label'].map(LIAR_MAP).fillna('uncertain')
 
-# Encode statements → embeddings for classifier
 print("Encoding LIAR statements...")
-X_liar = embedder.encode(liar_sample['statement'].tolist(), show_progress_bar=True)
+X_liar = embedder.encode(liar_sample['statement'].tolist(), show_progress_bar=False)
 y_liar = liar_sample['label_3'].values
 
 X_train, X_test, y_train, y_test = train_test_split(X_liar, y_liar, test_size=0.2, random_state=42)
 
 fake_news_clf = LogisticRegression(max_iter=500, random_state=42)
 fake_news_clf.fit(X_train, y_train)
-
-print("\n📊 Fake News Classifier Report:")
-print(classification_report(y_test, fake_news_clf.predict(X_test)))
 print("✅ Fake news classifier trained.")
 
 # ── B. Hallucination Scorer ───────────────────────────────────────────────────
-
 def score_hallucination(claim: str) -> dict:
-    """
-    Scores a single claim for hallucination risk.
-    Returns dict with hallucination_risk [0-100] and evidence snippets.
-    """
     try:
         references = retrieve_reference_sentences(claim, k=5)
         contradiction_score = get_nli_contradiction_score(claim, references)
         similarity = get_semantic_similarity(claim)
         citation_anomaly = get_citation_anomaly_score(claim)
 
-        # Weighted combination
         raw_risk = (
             0.50 * contradiction_score +
-            0.30 * (1 - similarity) +      # low similarity to trusted facts = higher risk
+            0.30 * (1 - similarity) + 
             0.20 * citation_anomaly
         )
         hallucination_risk = int(np.clip(raw_risk * 100, 0, 100))
@@ -349,14 +299,6 @@ def score_hallucination(claim: str) -> dict:
         return {'hallucination_risk': 50, 'contradiction_score': 0.5,
                 'semantic_similarity': 0.5, 'evidence_snippets': [], 'error': str(e)}
 
-# Test
-test_claims = [
-    "The moon is made of cheese.",
-    "Water boils at 100 degrees Celsius at sea level.",
-]
-for claim in test_claims:
-    result = score_hallucination(claim)
-    print(f"  '{claim[:50]}...' → risk: {result['hallucination_risk']}%")
 print("✅ Hallucination scorer working.")
 
 # ── C. Event Volatility Forecaster ───────────────────────────────────────────
@@ -369,14 +311,12 @@ except ImportError:
     print("⚠️  statsforecast not available, using EWMA fallback.")
 
 def compute_volatility_series(df: pd.DataFrame, window: int = 7) -> pd.Series:
-    """Rolling std of sentiment scores over headlines."""
     df = df.copy().sort_values('published_at')
     sentiments = df['headline'].apply(get_sentiment_score)
     volatility = sentiments.rolling(window=min(window, len(df)), min_periods=1).std().fillna(0)
     return volatility
 
 def forecast_volatility(series: pd.Series, horizon: int = 3) -> dict:
-    """Forecast next `horizon` periods of volatility."""
     if HAS_STATSFORECAST and len(series) >= 10:
         try:
             sf_df = pd.DataFrame({
@@ -392,33 +332,26 @@ def forecast_volatility(series: pd.Series, horizon: int = 3) -> dict:
         except:
             pass
 
-    # EWMA fallback
     ewma = series.ewm(span=min(5, len(series))).mean()
     last = ewma.iloc[-1]
     forecasted = [last * (1 + 0.02 * i) for i in range(1, horizon + 1)]
     trend = 'rising' if forecasted[-1] > series.mean() else 'stable'
     return {'method': 'EWMA', 'forecast': forecasted, 'trend': trend}
 
-volatility_series = compute_volatility_series(news_df)
-forecast_result = forecast_volatility(volatility_series)
-print(f"✅ Volatility forecast: {forecast_result['method']} → trend: {forecast_result['trend']}")
-
 # ── D. Final Risk Score Aggregator ────────────────────────────────────────────
-# Configurable weights (adjust these constants)
 W_HALLUCINATION  = 0.40
 W_FAKE_NEWS      = 0.35
 W_CITATION       = 0.15
 W_SIMILARITY     = 0.10
 
 COLOR_MAP = {
-    'confirmed':     'rgba(52, 199, 89, 0.15)',    # green
-    'uncertain':     'rgba(255, 204, 0, 0.15)',    # yellow
-    'misinformation':'rgba(255, 59, 48, 0.15)',    # red
-    'hallucination': 'rgba(175, 82, 222, 0.15)',   # purple
+    'confirmed':     'rgba(52, 199, 89, 0.15)',
+    'uncertain':     'rgba(255, 204, 0, 0.15)',
+    'misinformation':'rgba(255, 59, 48, 0.15)',
+    'hallucination': 'rgba(175, 82, 222, 0.15)',
 }
 
 def get_fake_news_probability(text: str) -> tuple[str, float]:
-    """Returns (label, probability) from fake news classifier."""
     try:
         emb = embedder.encode([text])
         proba = fake_news_clf.predict_proba(emb)[0]
@@ -430,22 +363,15 @@ def get_fake_news_probability(text: str) -> tuple[str, float]:
         return 'uncertain', 0.5
 
 def analyze_text(text: str, source: str = 'unknown') -> dict:
-    """
-    Full pipeline: text → JSON risk payload.
-    This is the function the Gradio API exposes.
-    """
     try:
-        # --- feature extraction ---
         halu_result  = score_hallucination(text)
         fake_label, fake_conf = get_fake_news_probability(text)
         citation_score = get_citation_anomaly_score(text)
         similarity     = get_semantic_similarity(text)
         credibility    = get_source_credibility(source)
 
-        # Normalise fake news label to a risk score
         fake_risk = {'misinformation': 0.9, 'uncertain': 0.5, 'credible': 0.1}.get(fake_label, 0.5)
 
-        # Aggregate
         combined_risk = (
             W_HALLUCINATION * (halu_result['hallucination_risk'] / 100) +
             W_FAKE_NEWS     * fake_risk +
@@ -454,7 +380,6 @@ def analyze_text(text: str, source: str = 'unknown') -> dict:
         )
         combined_risk = float(np.clip(combined_risk, 0, 1))
 
-        # Determine status
         if combined_risk < 0.25:
             status = 'confirmed'
         elif combined_risk < 0.55:
@@ -464,7 +389,7 @@ def analyze_text(text: str, source: str = 'unknown') -> dict:
         else:
             status = 'misinformation'
 
-        confidence = abs(combined_risk - 0.5) * 2  # distance from uncertain midpoint
+        confidence = abs(combined_risk - 0.5) * 2
 
         tooltip = (
             f"{status.title()} risk: {int(combined_risk*100)}%. "
@@ -493,6 +418,37 @@ def analyze_text(text: str, source: str = 'unknown') -> dict:
             'evidence_snippets': []
         }
 
-# Quick smoke test
-test = analyze_text("The moon is made of cheese.")
-print(f"✅ Aggregator test: status={test['status']}, risk={test['combined_risk']}")
+# ── E. Main Web Application with Gradio ───────────────────────────────────────
+def predict(text):
+    return analyze_text(text)
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🛡️ AI Risk & Fact-Checking Dashboard")
+    gr.Markdown("Analyze text for hallucination risk, fake news probability, and citation anomalies.")
+    
+    with gr.Row():
+        with gr.Column():
+            input_text = gr.Textbox(
+                lines=5, 
+                placeholder="Enter a claim or news snippet here...", 
+                label="Text to Analyze"
+            )
+            submit_btn = gr.Button("Analyze Risk", variant="primary")
+        
+        with gr.Column():
+            output_json = gr.JSON(label="Detailed Analysis Results")
+            
+    submit_btn.click(fn=predict, inputs=input_text, outputs=output_json)
+    
+    gr.Examples(
+        examples=[
+            "The moon is made of cheese.",
+            "Water boils at 100 degrees Celsius at sea level.",
+            "According to a 2031 study from the Institute of Neural Enhancement, humans only use 10% of their brain.",
+            "Global temperatures hit record highs in 2024.",
+        ],
+        inputs=input_text
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)