Update app.py

app.py

@@ -1,6 +1,7 @@
 """
-RCEA Lite v1.0 — OKX Edition
-Regime-Conditioned Evidence Accumulation. Causal HMM. No supervised ML.
+RCEA Lite v1.0 — OKX Edition + BOCPD
+Regime-Conditioned Evidence Accumulation with Bayesian Online Changepoint Detection.
+Causal. No supervised ML.
 """
 
 import math, time, warnings
@@ -31,6 +32,14 @@ FEAT_COLS = ["ret", "atr_norm", "ema_diff_norm", "efficiency", "rsi_dev", "dist_
 TF_MAP = {"15m": "15m", "1h": "1H", "4h": "4H", "1d": "1D"}
 TARGET_BARS = 1000
 
+# BOCPD config
+BOCPD_HAZARD = 1.0 / 250.0    # expected run length ~250 bars
+BOCPD_MAX_RUN = 300           # truncate run-length distribution
+BOCPD_PRIOR_MU = 0.0
+BOCPD_PRIOR_KAPPA = 0.1
+BOCPD_PRIOR_ALPHA = 0.1
+BOCPD_PRIOR_BETA = 1e-4
+
 
 # ---------- Helpers ----------
 def _f(x):
@@ -67,6 +76,99 @@ def _rsi(c, p=14):
     return 100.0 - 100.0 / (1.0 + rs)
 
 
+# ---------- BOCPD (Bayesian Online Changepoint Detection) ----------
+def _student_t_pdf(x, mu, kappa, alpha, beta):
+    """
+    Posterior predictive of Normal-Inverse-Gamma (Student-t).
+    Vectorised over arrays of (mu, kappa, alpha, beta) with scalar x.
+    """
+    scale2 = beta * (kappa + 1.0) / (alpha * kappa)
+    scale2 = np.maximum(scale2, 1e-12)
+    df = 2.0 * alpha
+    z = (x - mu) / np.sqrt(scale2)
+    # log pdf of student-t
+    log_norm = (math.lgamma((df + 1.0) / 2.0)
+                - math.lgamma(df / 2.0)
+                - 0.5 * np.log(df * np.pi)
+                - 0.5 * np.log(scale2))
+    return np.exp(log_norm - 0.5 * (df + 1.0) * np.log1p(z * z / df))
+
+
+def bocpd_changepoint_prob(returns: np.ndarray,
+                            hazard: float = BOCPD_HAZARD,
+                            max_run: int = BOCPD_MAX_RUN) -> np.ndarray:
+    """
+    Adams & MacKay (2007) BOCPD with Normal-Inverse-Gamma conjugate prior.
+    Returns per-bar changepoint probability P(r_t = 0 | x_1..t), causal.
+    """
+    n = len(returns)
+    cp_prob = np.zeros(n)
+
+    R = np.array([1.0])  # run-length distribution, index = run length
+    mu_arr = np.array([BOCPD_PRIOR_MU])
+    kappa_arr = np.array([BOCPD_PRIOR_KAPPA])
+    alpha_arr = np.array([BOCPD_PRIOR_ALPHA])
+    beta_arr = np.array([BOCPD_PRIOR_BETA])
+
+    for t in range(n):
+        x = returns[t]
+
+        # 1. Predictive probability for each current run-length hypothesis
+        pred = _student_t_pdf(x, mu_arr, kappa_arr, alpha_arr, beta_arr)
+
+        # 2. Growth probabilities (run continues) + changepoint probability
+        growth = R * pred * (1.0 - hazard)
+        cp = np.sum(R * pred * hazard)
+        cp_prob[t] = cp / (cp + growth.sum() + 1e-300) if (cp + growth.sum()) > 1e-300 else 0.0
+
+        # 3. New run-length distribution
+        R_new = np.empty(len(R) + 1)
+        R_new[0] = cp
+        R_new[1:] = growth
+        # Renormalise
+        s = R_new.sum()
+        if s < 1e-300:
+            R_new = np.array([1.0])
+        else:
+            R_new = R_new / s
+
+        # 4. Update sufficient statistics (NIG conjugate update)
+        new_mu = np.empty(len(R_new))
+        new_kappa = np.empty(len(R_new))
+        new_alpha = np.empty(len(R_new))
+        new_beta = np.empty(len(R_new))
+
+        # New run (changepoint): reset to prior
+        new_mu[0] = BOCPD_PRIOR_MU
+        new_kappa[0] = BOCPD_PRIOR_KAPPA
+        new_alpha[0] = BOCPD_PRIOR_ALPHA
+        new_beta[0] = BOCPD_PRIOR_BETA
+
+        # Existing runs: NIG update
+        new_kappa[1:] = kappa_arr + 1.0
+        new_mu[1:] = (kappa_arr * mu_arr + x) / new_kappa[1:]
+        new_alpha[1:] = alpha_arr + 0.5
+        new_beta[1:] = (beta_arr
+                        + 0.5 * kappa_arr * (x - mu_arr) ** 2 / new_kappa[1:])
+
+        # 5. Truncate to max_run
+        if len(R_new) > max_run:
+            R_new = R_new[:max_run]
+            new_mu = new_mu[:max_run]
+            new_kappa = new_kappa[:max_run]
+            new_alpha = new_alpha[:max_run]
+            new_beta = new_beta[:max_run]
+            R_new = R_new / R_new.sum()
+
+        R = R_new
+        mu_arr = new_mu
+        kappa_arr = new_kappa
+        alpha_arr = new_alpha
+        beta_arr = new_beta
+
+    return cp_prob
+
+
 # ---------- OKX API ----------
 def _req(path, params, timeout=TIMEOUT):
     last = None
@@ -93,42 +195,29 @@ def _req(path, params, timeout=TIMEOUT):
 
 
 def fetch_pairs(n=30):
-    """Fetch USDT spot pairs ranked by 24h quote volume on OKX."""
     inst = _req("/api/v5/public/instruments", {"instType": "SPOT"})
     if not inst:
         print("[RCEA] instruments unavailable", flush=True)
         return []
-
     usdt_syms = set()
     for i in inst:
         if i.get("state") != "live" or i.get("quoteCcy") != "USDT":
             continue
         sym, base = i.get("instId", ""), i.get("baseCcy", "").upper()
-        if not sym or not base:
-            continue
-        if any(base.startswith(p) for p in LEV_PRE):
-            continue
-        if any(sym.upper().endswith(p) for p in LEV_SUF):
-            continue
+        if not sym or not base: continue
+        if any(base.startswith(p) for p in LEV_PRE): continue
+        if any(sym.upper().endswith(p) for p in LEV_SUF): continue
         usdt_syms.add(sym)
-
     if not usdt_syms:
-        print("[RCEA] no USDT spot pairs found", flush=True)
-        return []
-
+        print("[RCEA] no USDT spot pairs found", flush=True); return []
     tick = _req("/api/v5/market/tickers", {"instType": "SPOT"})
-    if not tick:
-        print("[RCEA] tickers unavailable", flush=True)
-        return []
-
+    if not tick: return []
     cand = []
     for t in tick:
         sym = t.get("instId", "")
-        if sym not in usdt_syms:
-            continue
+        if sym not in usdt_syms: continue
         q = _f(t.get("volCcy24h"))
-        if q and q > 0:
-            cand.append((sym, q))
+        if q and q > 0: cand.append((sym, q))
     cand.sort(key=lambda x: x[1], reverse=True)
     out = [c[0] for c in cand[:n]]
     print(f"[RCEA] {len(out)} OKX USDT pairs resolved", flush=True)
@@ -136,55 +225,30 @@ def fetch_pairs(n=30):
 
 
 def fetch_klines(inst_id, timeframe, target_bars=TARGET_BARS):
-    """
-    Fetch OHLCV from OKX with pagination ('after' = oldest ts so far).
-    Excludes unconfirmed candles (confirm != '1').
-    """
     bar = TF_MAP[timeframe]
-    all_rows = []
-    after = None
-    max_pages = 10
-
+    all_rows = []; after = None; max_pages = 10
     for page in range(max_pages):
         params = {"instId": inst_id, "bar": bar, "limit": "300"}
-        if after:
-            params["after"] = str(after)
+        if after: params["after"] = str(after)
         raw = _req("/api/v5/market/candles", params)
-        if not raw:
-            break
-
+        if not raw: break
         got_new = 0
         for k in raw:
-            if not isinstance(k, list) or len(k) < 9:
-                continue
-            if k[8] != "1":
-                continue
+            if not isinstance(k, list) or len(k) < 9: continue
+            if k[8] != "1": continue
             o, h, l, c, v = _f(k[1]), _f(k[2]), _f(k[3]), _f(k[4]), _f(k[5])
-            if None in (o, h, l, c, v) or min(o, h, l, c) <= 0:
-                continue
-            all_rows.append({"ts": int(k[0]),
-                             "open": o, "high": h, "low": l, "close": c, "volume": v})
+            if None in (o, h, l, c, v) or min(o, h, l, c) <= 0: continue
+            all_rows.append({"ts": int(k[0]), "open": o, "high": h,
+                             "low": l, "close": c, "volume": v})
             got_new += 1
-
-        if got_new == 0:
-            break
-
-        try:
-            after = int(raw[-1][0])
-        except (IndexError, ValueError):
-            break
-
-        if len(all_rows) >= target_bars:
-            break
+        if got_new == 0: break
+        try: after = int(raw[-1][0])
+        except (IndexError, ValueError): break
+        if len(all_rows) >= target_bars: break
         time.sleep(0.12)
-
-    if len(all_rows) < MIN_HMM:
-        return None
-
-    df = (pd.DataFrame(all_rows)
-          .drop_duplicates(subset=["ts"])
-          .sort_values("ts")
-          .reset_index(drop=True))
+    if len(all_rows) < MIN_HMM: return None
+    df = (pd.DataFrame(all_rows).drop_duplicates(subset=["ts"])
+          .sort_values("ts").reset_index(drop=True))
     return df[["open", "high", "low", "close", "volume"]]
 
 
@@ -261,8 +325,13 @@ def forward_filter(m, f):
     return post
 
 
-# ---------- Evidence ----------
-def evidence(f, rp, lam):
+# ---------- Evidence (with BOCPD blending) ----------
+def evidence(f, rp, lam, cp_prob):
+    """
+    Compute evidence with BOCPD-aware regime blending.
+    When changepoint probability is high, shrink regime posteriors toward uniform
+    -> evidence naturally dampens to neutral, avoiding stale-regime bets.
+    """
     n = len(f)
     c = f["close"].values; ef = f["ema_fast"].values; es = f["ema_slow"].values
     eff = f["efficiency"].values; mom = f["momentum"].values; am = f["atr_move"].values
@@ -279,54 +348,59 @@ def evidence(f, rp, lam):
         em[i] = np.tanh(s * 2.0)
         contr = max(0.0, 1.0 - vr[i])
         ec[i] = np.tanh(bo[i] * (0.5 + 0.5 * contr) * 2.0)
-    raw = rp[:, 0] * et + rp[:, 1] * em + rp[:, 2] * ec
+
+    # Blend posterior toward uniform proportional to changepoint probability
+    # If CP prob = 1, posteriors become uniform -> E_raw shrinks toward 0
+    rp_blended = rp * (1.0 - cp_prob[:, None]) + (1.0 / HMM_K) * cp_prob[:, None]
+
+    raw = rp_blended[:, 0] * et + rp_blended[:, 1] * em + rp_blended[:, 2] * ec
     acc = np.zeros(n); acc[0] = raw[0]
     for i in range(1, n): acc[i] = lam * acc[i - 1] + (1 - lam) * raw[i]
     pl = np.array([_sig(4.0 * x) for x in acc])
-    return acc, pl, 1.0 - pl
+    return acc, pl, 1.0 - pl, rp_blended
 
 
 # ---------- Signal + Backtest ----------
-def latest_signal(f, rp, acc, pl, ps, thr, mconf):
+def latest_signal(f, rp, rp_blended, acc, pl, ps, thr, mconf, cp_prob):
     i = len(f) - 1
     if i < MIN_SIG: return None
-    p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+    p = rp_blended[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+    # Do not trade when a changepoint is likely
     if conf < mconf: return None
     e, l, s = float(acc[i]), float(pl[i]), float(ps[i])
     sig = "LONG" if e > thr and l > 0.5 else "SHORT" if e < -thr and s > 0.5 else "NO TRADE"
     return {"signal": sig, "evidence": e, "P_long": l, "P_short": s,
             "regime_probs": {REGIME_NAMES[j]: float(p[j]) for j in range(HMM_K)},
             "dominant_regime": REGIME_NAMES[dom], "regime_conf": conf,
+            "changepoint": float(cp_prob[i]),
             "close": float(f["close"].values[i])}
 
 
-def backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold):
+def backtest(sym, f, rp, rp_blended, acc, pl, ps, thr, mconf, maxhold, cp_prob):
     n = len(f); c = f["close"].values; h = f["high"].values; lo = f["low"].values
     atr = f["atr"].values
     trades = []; in_pos = False; ei = eprice = d = sp = tp = 0
     reg = ""; rconf = 0.0
 
-    # Backtest begins immediately after HMM training window + purge + embargo.
     train_end = int(n * TRAIN_FRAC)
     start = train_end + PURGE + EMBARGO
-    start = max(start, 30)          # need indicator warm-up
-    start = min(start, n - 2)
+    start = max(start, 30); start = min(start, n - 2)
 
-    # DEBUG metrics
+    # DEBUG
     if start < n:
         pass_thr = int((np.abs(acc[start:]) > thr).sum())
-        pass_conf = int((rp[start:].max(axis=1) >= mconf).sum())
-        both = int(((np.abs(acc[start:]) > thr) &
-                    (rp[start:].max(axis=1) >= mconf)).sum())
-        print(f"[BT] {sym}: n={n} start={start} window={n-start} "
-              f"|acc|=[{np.abs(acc[start:]).min():.3f},{np.abs(acc[start:]).max():.3f}] "
-              f"thr_pass={pass_thr} conf_pass={pass_conf} both={both}",
+        pass_conf = int((rp_blended[start:].max(axis=1) >= mconf).sum())
+        pass_cp = int((cp_prob[start:] < 0.5).sum())
+        print(f"[BT] {sym}: n={n} window={n-start} "
+              f"thr_pass={pass_thr} conf_pass={pass_conf} cp_clear={pass_cp}",
               flush=True)
 
     for i in range(start, n):
         if not in_pos:
-            p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+            p = rp_blended[i]; dom = int(np.argmax(p)); conf = float(p[dom])
             if conf < mconf: continue
+            # Do not enter right at a changepoint
+            if cp_prob[i] > 0.5: continue
             ed = 1 if acc[i] > thr and pl[i] > 0.5 else -1 if acc[i] < -thr and ps[i] > 0.5 else 0
             if ed == 0 or atr[i] < 1e-12: continue
             eprice = c[i] * (1.0 + SLIPPAGE * ed); d = ed; ei = i; in_pos = True
@@ -449,25 +523,32 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
                 print(f"[RCEA] {sym}: HMM fit failed (n={len(f)})", flush=True)
                 failed.append(sym); continue
             rp = forward_filter(m, f)
-            acc, pl, ps = evidence(f, rp, lam)
-            s = latest_signal(f, rp, acc, pl, ps, thr, mconf)
+            # BOCPD on log returns (causal)
+            rets = f["ret"].values
+            cp_prob = bocpd_changepoint_prob(rets)
+            acc, pl, ps, rp_blended = evidence(f, rp, lam, cp_prob)
+            s = latest_signal(f, rp, rp_blended, acc, pl, ps, thr, mconf, cp_prob)
             if s: s["symbol"] = sym; signals.append(s)
-            sym_trades = backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold)
+            sym_trades = backtest(sym, f, rp, rp_blended, acc, pl, ps, thr, mconf,
+                                  maxhold, cp_prob)
             trades.extend(sym_trades)
-            print(f"[RCEA] {sym}: candles={len(f)} signal={s['signal'] if s else 'NONE'} "
-                  f"trades={len(sym_trades)}", flush=True)
+            print(f"[RCEA] {sym}: candles={len(f)} "
+                  f"cp_max={cp_prob.max():.3f} cp_recent={cp_prob[-1]:.3f} "
+                  f"signal={s['signal'] if s else 'NONE'} trades={len(sym_trades)}",
+                  flush=True)
             analyzed += 1
         except Exception as e:
             print(f"[RCEA] {sym}: EXC {e}", flush=True); failed.append(sym)
     progress(1.0, desc="Done")
 
-    scan = ["# RCEA Lite — OKX Market Scan",
+    scan = ["# RCEA Lite — OKX + BOCPD",
             f"**Timeframe:** {timeframe} | **OKX bar:** {TF_MAP[timeframe]}",
             f"**Coins requested:** {n_coins}",
             f"**Analyzed:** {analyzed}",
             f"**Failed:** {len(failed)}",
             f"**Total trades:** {len(trades)}",
             f"**Threshold:** {thr} | **λ:** {lam} | **MinConf:** {mconf} | **MaxHold:** {maxhold}",
+            f"**BOCPD hazard:** {BOCPD_HAZARD:.4f} (~{int(1/BOCPD_HAZARD)} bars per regime)",
             f"**UTC:** {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}"]
     if len(trades) < 30:
         scan.append(f"\n⚠️ Only {len(trades)} trades. Try threshold=0.04, "
@@ -480,6 +561,7 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
             "Evidence": round(s["evidence"], 4),
             "P(Long)": round(s["P_long"], 4), "P(Short)": round(s["P_short"], 4),
             "Regime": s["dominant_regime"], "Regime Conf": round(s["regime_conf"], 4),
+            "Changepoint": round(s["changepoint"], 4),
             "P(Trend)": round(s["regime_probs"]["TREND"], 4),
             "P(MeanRev)": round(s["regime_probs"]["MEAN_REVERSION"], 4),
             "P(Compress)": round(s["regime_probs"]["COMPRESSION"], 4),
@@ -488,8 +570,8 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
         sig_df = sig_df.sort_values(["_p", "Evidence"], ascending=[True, False]).drop(columns="_p")
     else:
         sig_df = pd.DataFrame(columns=["Symbol", "Signal", "Evidence", "P(Long)", "P(Short)",
-                                        "Regime", "Regime Conf", "P(Trend)", "P(MeanRev)",
-                                        "P(Compress)", "Close"])
+                                        "Regime", "Regime Conf", "Changepoint", "P(Trend)",
+                                        "P(MeanRev)", "P(Compress)", "Close"])
 
     if trades:
         tr_df = pd.DataFrame([{
@@ -527,9 +609,9 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
 
 
 # ---------- UI ----------
-with gr.Blocks(title="RCEA Lite v1.0 — OKX") as demo:
-    gr.Markdown("# RCEA Lite v1.0 — OKX Edition\n"
-                "HMM regime detection (causal forward filtering) · No supervised ML · Data: OKX")
+with gr.Blocks(title="RCEA Lite v1.0 — OKX + BOCPD") as demo:
+    gr.Markdown("# RCEA Lite v1.0 — OKX + BOCPD\n"
+                "HMM regime detection + Bayesian Online Changepoint Detection · Causal · No supervised ML")
     with gr.Row():
         with gr.Column(scale=1):
             tf = gr.Dropdown(["15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
@@ -549,8 +631,9 @@ with gr.Blocks(title="RCEA Lite v1.0 — OKX") as demo:
         with gr.Tab("🪙 Coins"): coin_tbl = gr.Dataframe(interactive=False)
     btn.click(run, inputs=[tf, nc, thr_i, lam_i, mc_i, mh_i],
               outputs=[scan_out, met_out, sig_tbl, tr_tbl, reg_tbl, coin_tbl])
-    gr.Markdown("---\n**Data source:** OKX public REST API. "
-                "Net of 0.10% commission + 0.05% slippage per side.")
+    gr.Markdown("---\n**BOCPD** (Adams & MacKay 2007): Bayesian changepoint probability per bar. "
+                "When CP > 0.5, new entries are blocked and posteriors shrink toward uniform. "
+                "**Data:** OKX. **Costs:** 0.10% + 0.05% per side.")
 
 
 if __name__ == "__main__":