Update app.py

app.py

@@ -1,757 +1,85 @@
-"""
-Bitcoin Market Signal Engine — Semi-Institutional Adaptive Quant Engine
-========================================================================
-Hugging Face Spaces · Gradio UI (unchanged from v1)
-
-Architecture:
-    Part 1  — Time Decay Weighting
-    Part 2  — Source Quality Weighting
-    Part 3  — Market Regime Detection
-    Part 4  — Volatility-Adjusted Threshold
-    Part 5  — Technical Confluence Filter
-    Part 6  — On-Chain Bias
-    Part 7  — Confidence & Dominance Metrics
-    Part 8  — Sentiment Divergence Detection
-    Part 9  — Online Learning / Weight Persistence
-    Final   — Signal Assembly & JSON Output
-"""
-
-from __future__ import annotations
-
-import json
-import math
-import re
-import statistics
-import traceback
-from datetime import datetime, timezone
-from email.utils import parsedate_to_datetime
-from pathlib import Path
-
-import feedparser
 import gradio as gr
-import numpy as np
-import pandas as pd
-from transformers import pipeline
+import torch
+from transformers import AutoTokenizer
+from peft import AutoPeftModelForSequenceClassification
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# Constants & Config
-# ═══════════════════════════════════════════════════════════════════════════════
+# =========================
+# MODEL
+# =========================
 
-RSS_URL = (
-    "https://news.google.com/rss/search"
-    "?q=Bitcoin&hl=en-US&gl=US&ceid=US:en"
-)
-
-SOURCE_WEIGHTS: dict[str, float] = {
-    "bloomberg": 1.30,
-    "reuters":   1.25,
-    "coindesk":  1.15,
-}
+MODEL_PATH = "."
 
-WEIGHT_FILE         = Path("model_weights.json")
-SIGNAL_HISTORY_FILE = Path("signal_history.json")
+device = "cuda" if torch.cuda.is_available() else "cpu"
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# Model (loaded once at startup)
-# ═══════════════════════════════════════════════════════════════════════════════
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
 
-print("Loading DistilBERT sentiment model...")
-sentiment_pipe = pipeline(
-    "sentiment-analysis",
-    model="distilbert-base-uncased-finetuned-sst-2-english",
-    device=-1,        # CPU; set to 0 if GPU available
-    truncation=True,
-    max_length=512,
+model = AutoPeftModelForSequenceClassification.from_pretrained(
+    MODEL_PATH,
+    torch_dtype=torch.float16 if device == "cuda" else torch.float32
 )
-print("Model ready.")
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Preprocessing
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def preprocess(text: str) -> str:
-    text = text.replace("%", "percent").replace("$", "USD")
-    text = re.sub(r"[^a-zA-Z0-9 ]", " ", text)
-    return re.sub(r"\s+", " ", text).strip().lower()
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 1 — Time Decay Weighting
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def compute_time_weight(published: str | None) -> float | None:
-    """
-    weight = exp(-age_hours / 6).
-    Returns None  → ignore headline (unrecoverable parse failure).
-    Returns 0.5   → published missing/empty.
-    """
-    if not published:
-        return 0.5
-
-    for parser in (
-        parsedate_to_datetime,
-        lambda s: datetime.fromisoformat(s),
-    ):
-        try:
-            dt = parser(published)
-            if dt.tzinfo is None:
-                dt = dt.replace(tzinfo=timezone.utc)
-            age_h = max((datetime.now(timezone.utc) - dt).total_seconds() / 3600, 0)
-            return math.exp(-age_h / 6)
-        except Exception:
-            continue
-
-    return None  # both parsers failed → drop headline
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 2 — Source Quality Weighting
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def compute_source_weight(source_name: str | None) -> float:
-    if not source_name:
-        return 1.0
-    name_lower = source_name.lower()
-    for key, w in SOURCE_WEIGHTS.items():
-        if key in name_lower:
-            return w
-    return 1.0
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# RSS Fetch + Classify
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def fetch_headlines(max_items: int = 30) -> list[dict]:
-    feed = feedparser.parse(RSS_URL)
-    entries = feed.entries[:max_items]
-    if not entries:
-        raise ValueError("RSS feed returned no items.")
-    results = []
-    for e in entries:
-        source = (
-            getattr(getattr(e, "source", None), "title", None)
-            or e.get("source", {}).get("title", "")
-        )
-        results.append({
-            "raw":       e.get("title", ""),
-            "link":      e.get("link", ""),
-            "published": e.get("published", ""),
-            "source":    source,
-        })
-    return results
-
-
-def classify_headlines(headlines: list[dict]) -> list[dict]:
-    """
-    Run DistilBERT → apply Parts 1 & 2 → return scored list.
-    Headlines with unrecoverable timestamps are dropped.
-    """
-    cleaned  = [preprocess(h["raw"]) for h in headlines]
-    raw_preds = sentiment_pipe(cleaned, batch_size=16)
-
-    scored = []
-    for h, pred in zip(headlines, raw_preds):
-        label      = pred["label"]
-        confidence = float(pred["score"])
-        numeric    = confidence if label == "POSITIVE" else -confidence
-
-        time_w = compute_time_weight(h.get("published"))
-        if time_w is None:
-            continue  # drop
-
-        source_w    = compute_source_weight(h.get("source"))
-        final_score = numeric * time_w * source_w
-
-        scored.append({
-            **h,
-            "clean":        preprocess(h["raw"]),
-            "label":        label,
-            "confidence":   round(confidence, 6),
-            "numeric_score": round(numeric,    6),
-            "time_weight":  round(time_w,      6),
-            "source_weight": source_w,
-            "final_score":  round(final_score, 6),
-        })
-    return scored
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 3 — Market Regime Detection
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def _ema(arr: np.ndarray, period: int) -> np.ndarray:
-    out = np.empty(len(arr))
-    out[0] = arr[:period].mean() if len(arr) >= period else arr[0]
-    k = 2 / (period + 1)
-    for i in range(1, len(arr)):
-        out[i] = arr[i] * k + out[i - 1] * (1 - k)
-    return out
-
-
-def detect_regime(price_df: pd.DataFrame | None) -> dict:
-    BASE = 0.05
-    empty = {"regime": "UNKNOWN", "adx": None, "atr": None,
-             "ema200_slope": None, "threshold": BASE}
-
-    if price_df is None or len(price_df) < 50:
-        return empty
-
-    df = price_df.copy()
-    df.columns = [c.lower() for c in df.columns]
-    high, low, close = df["high"].values, df["low"].values, df["close"].values
-
-    n = 14
-    tr       = np.maximum(high[1:] - low[1:],
-               np.maximum(np.abs(high[1:] - close[:-1]),
-                          np.abs(low[1:]  - close[:-1])))
-    plus_dm  = np.where((high[1:] - high[:-1]) > (low[:-1] - low[1:]),
-                        np.maximum(high[1:] - high[:-1], 0), 0.0)
-    minus_dm = np.where((low[:-1] - low[1:]) > (high[1:] - high[:-1]),
-                        np.maximum(low[:-1] - low[1:], 0), 0.0)
-
-    atr14    = _ema(tr, n)
-    plus_di  = 100 * _ema(plus_dm,  n) / (atr14 + 1e-9)
-    minus_di = 100 * _ema(minus_dm, n) / (atr14 + 1e-9)
-    dx       = 100 * np.abs(plus_di - minus_di) / (plus_di + minus_di + 1e-9)
-    adx      = float(_ema(dx, n)[-1])
-    atr      = float(atr14[-1])
-
-    high_vol = atr >= float(np.percentile(atr14, 80))
-
-    ema200_slope = 0.0
-    if len(close) >= 200:
-        e200 = _ema(close[-200:], 200)
-        ema200_slope = float(e200[-1] - e200[-5])
-
-    if adx > 25:
-        regime, threshold = "TRENDING", BASE
-    elif adx < 20:
-        regime, threshold = "RANGING", 0.08
-    else:
-        regime, threshold = "NEUTRAL_REGIME", BASE
-
-    if high_vol:
-        regime    = f"{regime}+HIGH_VOL"
-        threshold += 0.03
-
-    return {"regime": regime, "adx": round(adx, 4), "atr": round(atr, 4),
-            "ema200_slope": round(ema200_slope, 6), "threshold": round(threshold, 4)}
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 4 — Volatility-Adjusted Threshold
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def compute_dynamic_threshold(price_df: pd.DataFrame | None,
-                              regime_threshold: float) -> dict:
-    if price_df is None or len(price_df) < 30:
-        return {"realized_volatility": None,
-                "dynamic_threshold": regime_threshold,
-                "final_threshold": regime_threshold}
-
-    close    = price_df["close"].values[-30:]
-    log_ret  = np.diff(np.log(close + 1e-9))
-    real_vol = float(np.std(log_ret) * math.sqrt(365))
-    dynamic  = max(0.05, min(0.15, 0.05 + real_vol * 0.2))
-    final    = max(regime_threshold, dynamic)
-
-    return {"realized_volatility": round(real_vol, 6),
-            "dynamic_threshold":   round(dynamic,  4),
-            "final_threshold":     round(final,    4)}
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 5 — Technical Confluence Filter
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def apply_technical_confluence(raw_signal: str, confidence: float,
-                                price_df: pd.DataFrame | None,
-                                funding_rate: float | None = None) -> dict:
-    if price_df is None or len(price_df) < 50:
-        return {"confirmed_signal": raw_signal, "confidence": round(confidence, 4),
-                "rsi": None, "ema200": None,
-                "confluence_notes": ["No price data — confluence skipped"]}
-
-    df    = price_df.copy()
-    df.columns = [c.lower() for c in df.columns]
-    close  = df["close"].values
-    volume = df["volume"].values if "volume" in df.columns else None
-
-    # RSI(14)
-    delta    = np.diff(close)
-    gain     = np.where(delta > 0, delta, 0.0)
-    loss     = np.where(delta < 0, -delta, 0.0)
-    avg_gain = float(np.convolve(gain, np.ones(14) / 14, "valid")[-1])
-    avg_loss = float(np.convolve(loss, np.ones(14) / 14, "valid")[-1])
-    rsi      = 100 - (100 / (1 + avg_gain / (avg_loss + 1e-9)))
-
-    # EMA200
-    if len(close) >= 200:
-        k = 2 / 201
-        ema200 = close[-200]
-        for p in close[-199:]:
-            ema200 = p * k + ema200 * (1 - k)
-    else:
-        ema200 = float(np.mean(close))
-
-    price_now = float(close[-1])
-    notes     = [f"RSI(14)={rsi:.2f}", f"EMA200={ema200:.2f}", f"Price={price_now:.2f}"]
-    confirmed = raw_signal
-
-    if raw_signal == "LONG" and not (rsi < 45 and price_now > ema200):
-        confirmed = "NEUTRAL"
-        notes.append("LONG suppressed: RSI/EMA200 not met")
-    elif raw_signal == "SHORT" and not (rsi > 55 and price_now < ema200):
-        confirmed = "NEUTRAL"
-        notes.append("SHORT suppressed: RSI/EMA200 not met")
-
-    if confirmed != "NEUTRAL":
-        if volume is not None and len(volume) >= 21:
-            avg_vol = float(np.mean(volume[-21:-1]))
-            if volume[-1] > 1.5 * avg_vol:
-                confidence += 0.15
-                notes.append("+0.15: volume spike")
-        if funding_rate is not None:
-            if confirmed == "LONG"  and funding_rate < -0.01:
-                confidence += 0.10
-                notes.append("+0.10: extreme negative funding (contrarian bullish)")
-            elif confirmed == "SHORT" and funding_rate > 0.01:
-                confidence += 0.10
-                notes.append("+0.10: extreme positive funding (contrarian bearish)")
-
-    return {"confirmed_signal": confirmed, "confidence": round(min(confidence, 1.0), 4),
-            "rsi": round(rsi, 4), "ema200": round(ema200, 4), "confluence_notes": notes}
-
-
-# ═══════════════════════════���═══════════════════════════════════════════════════
-# Part 6 — On-Chain Bias
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def compute_onchain_bias(onchain: dict | None) -> dict:
-    if not onchain:
-        return {"onchain_bias": "NEUTRAL", "onchain_notes": ["No on-chain data"]}
-
-    inflow     = onchain.get("exchange_inflow",  0)
-    outflow    = onchain.get("exchange_outflow", 0)
-    avg_in     = onchain.get("avg_inflow",  1)
-    avg_out    = onchain.get("avg_outflow", 1)
-    bearish = bullish = 0
-    notes: list[str] = []
 
-    if avg_in > 0 and inflow > 2 * avg_in:
-        bearish += 1
-        notes.append("Inflow spike >2x avg → bearish")
-    if avg_out > 0 and outflow > 2 * avg_out:
-        bullish += 1
-        notes.append("Outflow spike >2x avg → bullish")
+model.to(device)
+model.eval()
 
-    if bearish > 0 and bullish > 0:
-        bias = "CONFLICT"
-        notes.append("Conflict → NEUTRAL override")
-    elif bearish > 0:
-        bias = "BEARISH"
-    elif bullish > 0:
-        bias = "BULLISH"
-    else:
-        bias = "NEUTRAL"
 
-    return {"onchain_bias": bias, "onchain_notes": notes}
+# =========================
+# PREDICTION
+# =========================
 
+def predict(text):
 
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 7 — Confidence & Dominance Metrics
-# ═══════════════════════════════════════════════════════════════════════════════
+    if not text or not text.strip():
+        return {
+            "Bullish": 0.0,
+            "Neutral": 0.0,
+            "Bearish": 0.0
+        }
 
-def compute_dominance_metrics(scored: list[dict], avg_score: float,
-                               threshold: float) -> dict:
-    scores = [s["final_score"] for s in scored]
-    n      = len(scores)
-    std_dev       = statistics.stdev(scores) if n > 1 else 0.0
-    bull_count    = sum(1 for s in scores if s > 0)
-    bear_count    = sum(1 for s in scores if s < 0)
-    bull_dom      = bull_count / n * 100 if n else 0.0
-    bear_dom      = bear_count / n * 100 if n else 0.0
-
-    labels = [s["label"] for s in scored]
-    entropy = 0.0
-    for lbl in set(labels):
-        p = labels.count(lbl) / n
-        if p > 0:
-            entropy -= p * math.log2(p)
-
-    if avg_score > 0.08 and bull_dom > 65:
-        strength = "STRONG LONG"
-    elif avg_score > threshold:
-        strength = "WEAK LONG"
-    elif avg_score < -0.08 and bear_dom > 65:
-        strength = "STRONG SHORT"
-    elif avg_score < -threshold:
-        strength = "WEAK SHORT"
-    else:
-        strength = "NEUTRAL"
-
-    risk = ("HIGH" if std_dev > 0.3 or entropy > 0.95
-            else "MEDIUM" if std_dev > 0.15 else "LOW")
-
-    return {"signal_strength": strength, "risk_level": risk,
-            "bull_dominance_pct": round(bull_dom, 2),
-            "bear_dominance_pct": round(bear_dom, 2),
-            "score_std_dev": round(std_dev, 6),
-            "entropy": round(entropy, 6)}
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 8 — Sentiment Divergence Detection
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def detect_divergence(price_df: pd.DataFrame | None,
-                       sentiment_history: list[float]) -> dict:
-    no_div = {"divergence_type": "NONE", "early_reversal_warning": False,
-              "divergence_notes": []}
-
-    if price_df is None or len(price_df) < 10:
-        return {**no_div, "divergence_notes": ["Insufficient price data"]}
-    if len(sentiment_history) < 2:
-        return {**no_div, "divergence_notes": ["Need ≥2 sentiment history points"]}
-
-    close        = price_df["close"].values[-10:]
-    price_trend  = float(close[-1]) - float(close[0])
-    sent_trend   = sentiment_history[-1] - sentiment_history[0]
-    notes        = [f"Price Δ={price_trend:+.4f}", f"Sentiment Δ={sent_trend:+.4f}"]
-
-    if price_trend < 0 and sent_trend > 0:
-        return {"divergence_type": "BULLISH_DIVERGENCE", "early_reversal_warning": True,
-                "divergence_notes": notes + ["Lower lows + improving sentiment → bullish reversal"]}
-    if price_trend > 0 and sent_trend < 0:
-        return {"divergence_type": "BEARISH_DIVERGENCE", "early_reversal_warning": True,
-                "divergence_notes": notes + ["Higher highs + declining sentiment → bearish reversal"]}
-
-    return {**no_div, "divergence_notes": notes}
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Part 9 — Online Learning / Weight Persistence
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def load_model_weight() -> float:
-    try:
-        if WEIGHT_FILE.exists():
-            return float(max(0.5, min(2.0,
-                json.loads(WEIGHT_FILE.read_text()).get("model_weight", 1.0))))
-    except Exception:
-        pass
-    return 1.0
-
-
-def save_model_weight(w: float) -> None:
-    try:
-        WEIGHT_FILE.write_text(json.dumps({"model_weight": round(w, 6)}))
-    except Exception:
-        pass
-
-
-def record_signal(direction: str, price: float | None) -> None:
-    try:
-        history: list[dict] = []
-        if SIGNAL_HISTORY_FILE.exists():
-            history = json.loads(SIGNAL_HISTORY_FILE.read_text())
-        history.append({"timestamp": datetime.now(timezone.utc).isoformat(),
-                         "predicted_direction": direction,
-                         "price_at_signal": price,
-                         "evaluated": False})
-        SIGNAL_HISTORY_FILE.write_text(json.dumps(history[-200:], indent=2))
-    except Exception:
-        pass
-
-
-def evaluate_past_signals(current_price: float | None) -> float:
-    weight = load_model_weight()
-    if current_price is None or not SIGNAL_HISTORY_FILE.exists():
-        return weight
-    try:
-        history: list[dict] = json.loads(SIGNAL_HISTORY_FILE.read_text())
-        now = datetime.now(timezone.utc)
-        updated = False
-        for rec in history:
-            if rec.get("evaluated"):
-                continue
-            try:
-                age_h = (now - datetime.fromisoformat(rec["timestamp"])).total_seconds() / 3600
-            except Exception:
-                continue
-            if age_h < 6 or rec.get("price_at_signal") is None:
-                continue
-            direction  = rec.get("predicted_direction", "NEUTRAL")
-            delta      = current_price - float(rec["price_at_signal"])
-            correct    = (direction == "LONG" and delta > 0) or (direction == "SHORT" and delta < 0)
-            weight     = max(0.5, min(2.0, weight * (1.01 if correct else 0.99)))
-            rec["evaluated"] = True
-            updated = True
-        if updated:
-            SIGNAL_HISTORY_FILE.write_text(json.dumps(history[-200:], indent=2))
-            save_model_weight(weight)
-    except Exception:
-        pass
-    return weight
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Weighted Average
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def compute_weighted_average(scored: list[dict]) -> float:
-    total_w = sum(abs(s["time_weight"] * s["source_weight"]) for s in scored)
-    if total_w == 0:
-        return 0.0
-    return sum(s["final_score"] * abs(s["time_weight"] * s["source_weight"])
-               for s in scored) / total_w
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Final Signal Assembly
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def assemble_signal(scored: list[dict],
-                    price_df: pd.DataFrame | None = None,
-                    onchain: dict | None = None,
-                    funding_rate: float | None = None,
-                    sentiment_history: list[float] | None = None,
-                    current_price: float | None = None) -> dict:
-
-    # Parts 3 & 4 — Regime + Threshold
-    regime_info    = detect_regime(price_df)
-    vol_info       = compute_dynamic_threshold(price_df, regime_info["threshold"])
-    final_threshold = vol_info["final_threshold"]
-
-    # Weighted score (Parts 1+2 already in final_score)
-    avg_score = compute_weighted_average(scored)
-
-    # Part 9 — Online learning
-    model_weight   = evaluate_past_signals(current_price)
-    adjusted_score = avg_score * model_weight
-
-    # Raw signal
-    if adjusted_score > final_threshold:
-        raw_signal = "LONG"
-    elif adjusted_score < -final_threshold:
-        raw_signal = "SHORT"
-    else:
-        raw_signal = "NEUTRAL"
-
-    # Part 7 — Dominance
-    dominance    = compute_dominance_metrics(scored, adjusted_score, final_threshold)
-    raw_conf     = min(abs(adjusted_score) / (final_threshold + 1e-9), 1.0)
-
-    # Part 5 — Confluence
-    confluence        = apply_technical_confluence(raw_signal, raw_conf, price_df, funding_rate)
-    confirmed_signal  = confluence["confirmed_signal"]
-    confidence_score  = confluence["confidence"]
-
-    # Part 6 — On-chain
-    onchain_result = compute_onchain_bias(onchain)
-    onchain_bias   = onchain_result["onchain_bias"]
-    if onchain_bias == "CONFLICT":
-        confirmed_signal = "NEUTRAL"
-
-    # Part 8 — Divergence
-    hist      = sentiment_history or [avg_score]
-    divergence = detect_divergence(price_df, hist)
-
-    # Record for future evaluation
-    price_now = (float(price_df["close"].values[-1])
-                 if price_df is not None and len(price_df) > 0 else current_price)
-    record_signal(confirmed_signal, price_now)
-
-    # Explanation
-    explanation = " | ".join([
-        f"Signal={confirmed_signal} (raw={raw_signal})",
-        f"WeightedScore={adjusted_score:.4f} threshold=±{final_threshold}",
-        f"Regime={regime_info['regime']} ADX={regime_info['adx']}",
-        f"RealVol={vol_info['realized_volatility']} dynThresh={vol_info['dynamic_threshold']}",
-        f"ModelWeight={model_weight:.4f} Strength={dominance['signal_strength']}",
-        f"OnChain={onchain_bias}",
-        f"Divergence={divergence['divergence_type']}",
-        f"Risk={dominance['risk_level']} Confidence={confidence_score:.4f}",
-        *(confluence.get("confluence_notes") or []),
-        *(["⚠ " + divergence["divergence_type"]] if divergence["early_reversal_warning"] else []),
-    ])
-
-    return {
-        # — Core spec-required fields —
-        "timestamp":              datetime.now(timezone.utc).isoformat(),
-        "headline_count":         len(scored),
-        "regime":                 regime_info["regime"],
-        "dynamic_threshold":      final_threshold,
-        "weighted_average_score": round(adjusted_score, 6),
-        "final_signal":           confirmed_signal,
-        "signal_strength":        dominance["signal_strength"],
-        "confidence_score":       confidence_score,
-        "risk_level":             dominance["risk_level"],
-        "onchain_bias":           onchain_bias,
-        "divergence_type":        divergence["divergence_type"],
-        "early_reversal_warning": divergence["early_reversal_warning"],
-        "explanation_string":     explanation,
-        # — Extended diagnostics —
-        "model_weight":           round(model_weight, 6),
-        "realized_volatility":    vol_info["realized_volatility"],
-        "adx":                    regime_info["adx"],
-        "atr":                    regime_info["atr"],
-        "ema200_slope":           regime_info["ema200_slope"],
-        "bull_dominance_pct":     dominance["bull_dominance_pct"],
-        "bear_dominance_pct":     dominance["bear_dominance_pct"],
-        "score_std_dev":          dominance["score_std_dev"],
-        "entropy":                dominance["entropy"],
-        "onchain_notes":          onchain_result["onchain_notes"],
-        "divergence_notes":       divergence["divergence_notes"],
-        "confluence_notes":       confluence.get("confluence_notes", []),
-        "top_positive_headlines": [s["raw"] for s in
-            sorted(scored, key=lambda x: x["final_score"], reverse=True)
-            if s["final_score"] > 0][:5],
-        "top_negative_headlines": [s["raw"] for s in
-            sorted(scored, key=lambda x: x["final_score"])
-            if s["final_score"] < 0][:5],
-    }
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Gradio Handler  (UI unchanged from v1)
-# ═══════════════════════════════════════════════════════════════════════════════
-
-def run_analysis(max_headlines: int, show_detail: bool) -> tuple:
-    try:
-        headlines = fetch_headlines(int(max_headlines))
-        scored    = classify_headlines(headlines)
-
-        if not scored:
-            return "", "", [], "No scoreable headlines after filtering."
-
-        result = assemble_signal(
-            scored,
-            price_df=None,       # inject real pd.DataFrame(OHLCV) here
-            onchain=None,        # inject on-chain dict here
-            funding_rate=None,   # inject float here
-            sentiment_history=None,
-            current_price=None,
-        )
-
-        signal_md = (
-            f"## Signal: **{result['final_signal']}**  ({result['signal_strength']})\n\n"
-            f"- **Weighted avg score:** `{result['weighted_average_score']}`\n"
-            f"- **Confidence:** `{result['confidence_score']}`  "
-            f"**Risk:** `{result['risk_level']}`\n"
-            f"- **Regime:** `{result['regime']}`  "
-            f"**Threshold:** `{result['dynamic_threshold']}`\n"
-            f"- **On-chain bias:** `{result['onchain_bias']}`  "
-            f"**Divergence:** `{result['divergence_type']}`\n"
-            f"- **Model weight:** `{result['model_weight']}`  "
-            f"**Headlines:** {result['headline_count']}\n"
-            f"- **Timestamp:** {result['timestamp']}\n\n"
-            f"> {result['explanation_string']}"
-        )
-
-        core_keys = [
-            "timestamp", "headline_count", "regime", "dynamic_threshold",
-            "weighted_average_score", "final_signal", "signal_strength",
-            "confidence_score", "risk_level", "onchain_bias",
-            "divergence_type", "early_reversal_warning", "explanation_string",
-            "top_positive_headlines", "top_negative_headlines",
-        ]
-        json_out = json.dumps({k: result[k] for k in core_keys}, indent=2)
-
-        detail_rows = []
-        if show_detail:
-            detail_rows = [
-                [
-                    i + 1,
-                    s["label"],
-                    f"{s['numeric_score']:+.4f}",
-                    f"{s['time_weight']:.4f}",
-                    f"{s['source_weight']:.2f}",
-                    f"{s['final_score']:+.4f}",
-                    s.get("source") or "—",
-                    s["raw"][:110],
-                ]
-                for i, s in enumerate(scored)
-            ]
-
-        return signal_md, json_out, detail_rows, ""
-
-    except Exception as exc:
-        return "", "", [], f"Error: {exc}\n{traceback.format_exc()}"
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# Gradio UI  (structure unchanged from v1)
-# ═══════════════════════════════════════════════════════════════════════════════
-
-with gr.Blocks(
-    title="Bitcoin Market Signal Engine v2",
-    theme=gr.themes.Monochrome(),
-    css="""
-        #signal-md { font-size: 1.15rem; }
-        #json-box textarea { font-family: monospace; font-size: 0.82rem; }
-        footer { display: none !important; }
-    """,
-) as demo:
-
-    gr.Markdown(
-        """
-        # ₿ Bitcoin Market Signal Engine · v2 — Adaptive Quant Edition
-        DistilBERT NLP · Time decay · Source quality · Regime detection ·
-        Technical confluence · On-chain bias · Divergence · Online learning
-        """
+    inputs = tokenizer(
+        text,
+        return_tensors="pt",
+        truncation=True,
+        max_length=512
     )
 
-    with gr.Row():
-        max_h   = gr.Slider(5, 30, value=20, step=1, label="Max headlines to fetch")
-        show_d  = gr.Checkbox(value=True, label="Show per-headline detail table")
-        run_btn = gr.Button("▶ Run Analysis", variant="primary")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
 
-    signal_out = gr.Markdown(elem_id="signal-md", label="Market Signal")
+    with torch.no_grad():
+        outputs = model(**inputs)
+        probabilities = torch.softmax(outputs.logits, dim=-1)[0]
 
-    json_out = gr.Code(
-        label="JSON Output (spec-compliant)",
-        language="json",
-        elem_id="json-box",
-    )
-
-    detail_tbl = gr.Dataframe(
-        headers=["#", "Label", "NLP Score", "Time W",
-                 "Source W", "Final Score", "Source", "Headline"],
-        label="Headline Sentiment Detail",
-        wrap=True,
-    )
+    labels = ["Bearish", "Neutral", "Bullish"]
 
-    error_box = gr.Textbox(label="Errors", interactive=False)
+    result = {
+        labels[i]: float(probabilities[i])
+        for i in range(len(labels))
+    }
 
-    run_btn.click(
-        fn=run_analysis,
-        inputs=[max_h, show_d],
-        outputs=[signal_out, json_out, detail_tbl, error_box],
-    )
+    return result
+
+
+# =========================
+# GRADIO UI
+# =========================
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Textbox(
+        label="Crypto Text",
+        placeholder="Bitcoin ETF inflows increased sharply today...",
+        lines=5
+    ),
+    outputs=gr.Label(
+        label="Crypto Sentiment",
+        num_top_classes=3
+    ),
+    title="CryptoBERT Sentiment",
+    description="Bullish / Neutral / Bearish crypto sentiment analysis"
+)
 
-    gr.Markdown(
-        """
-        ---
-        **9-module pipeline:**
-        RSS fetch → preprocess → DistilBERT →
-        **[1]** time-decay weight →
-        **[2]** source-quality weight →
-        **[3]** regime detection (ADX / ATR / EMA200) →
-        **[4]** volatility-adjusted threshold →
-        **[5]** technical confluence (RSI / EMA200 / volume / funding) →
-        **[6]** on-chain bias →
-        **[7]** dominance & entropy →
-        **[8]** sentiment divergence →
-        **[9]** online learning →
-        **final signal assembly**
 
-        *Inject a real OHLCV `pd.DataFrame` and on-chain dict into `assemble_signal()`
-        to activate Parts 3–8 fully.*
-        """
-    )
+# =========================
+# START
+# =========================
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()