Update app.py

app.py

@@ -18,6 +18,7 @@ Not: Eğitim/araştırma amaçlıdır, yatırım tavsiyesi değildir.
 
 import asyncio
 import json
+import math
 import os
 
 import gradio as gr
@@ -493,55 +494,89 @@ def _select(Xtr, ftr, k, thr=0.95):
     return keep
 
 
-def _fit_predict(Xtr, ytr, Xte, w=None, ftr=None, k=0):
-    """Ensemble: HGB + ExtraTrees + Logistic -> olasılık ortalaması (k>0 ise fold-içi özellik seçimi)."""
+def _fit_predict(Xtr, ytr, Xte, w=None, ftr=None, k=0, with_train=False):
+    """Ensemble: HGB + ExtraTrees + Logistic -> olasılık ortalaması.
+    k>0: fold-içi özellik seçimi. with_train: eğitim verisi üzerindeki olasılıkları da döndür (aşırı uyum ölçümü için)."""
     if k and ftr is not None:
         sel = _select(Xtr, ftr, k)
         Xtr, Xte = Xtr[sel], Xte[sel]
-    ps = []
+    ps, pt = [], []
     for name, m in _models().items():
         if name == "lr":
-            m.fit(Xtr.fillna(0), ytr, logisticregression__sample_weight=w)
-            ps.append(m.predict_proba(Xte.fillna(0))[:, 1])
+            A, B = Xtr.fillna(0), Xte.fillna(0)
+            m.fit(A, ytr, logisticregression__sample_weight=w)
         elif name == "et":
-            m.fit(Xtr.fillna(0), ytr, sample_weight=w)
-            ps.append(m.predict_proba(Xte.fillna(0))[:, 1])
+            A, B = Xtr.fillna(0), Xte.fillna(0)
+            m.fit(A, ytr, sample_weight=w)
         else:
-            m.fit(Xtr, ytr, sample_weight=w)
-            ps.append(m.predict_proba(Xte)[:, 1])
-    return np.mean(ps, axis=0)
+            A, B = Xtr, Xte
+            m.fit(A, ytr, sample_weight=w)
+        ps.append(m.predict_proba(B)[:, 1])
+        if with_train:
+            pt.append(m.predict_proba(A)[:, 1])
+    p = np.mean(ps, axis=0)
+    return (p, np.mean(pt, axis=0)) if with_train else p
 
 
-def _backtest(p, fwd, horizon, thr, fee):
-    """Örtüşmeyen (her `horizon` barda bir) işlemlerle net getiri istatistikleri."""
+def _trades(p, fwd, horizon, thr, fee):
+    """Örtüşmeyen (her `horizon` barda bir) işlemlerin net getirileri."""
     p, fwd = p[::horizon], fwd[::horizon]
     pos = np.where(p > thr, 1, np.where(p < 1 - thr, -1, 0))
     pnl = pos * fwd - np.abs(pos) * fee
-    n = int((pos != 0).sum())
+    return pnl[pos != 0]
+
+
+def _stats(tr):
+    n = len(tr)
     if n < 20:
         return {"n": n, "mean": 0.0, "t": 0.0, "hit": np.nan, "pf": np.nan}
-    tr = pnl[pos != 0]
     gp, gl = tr[tr > 0].sum(), -tr[tr < 0].sum()
     return {"n": n, "mean": float(tr.mean()),
             "t": float(tr.mean() / (tr.std() / np.sqrt(n) + 1e-12)),
             "hit": float((tr > 0).mean()), "pf": float(gp / gl) if gl > 0 else np.inf}
 
 
+def _backtest(p, fwd, horizon, thr, fee):
+    return _stats(_trades(p, fwd, horizon, thr, fee))
+
+
+def _nested(p, f, sizes, horizon, fee, grid=(0.52, 0.54, 0.56, 0.58, 0.60, 0.62)):
+    """Dürüst backtest: eşik her fold için YALNIZCA önceki fold'ların OOS'unda seçilir, sonra o fold'a uygulanır."""
+    bounds = np.cumsum([0] + list(sizes))
+    trades = []
+    for j in range(1, len(sizes)):
+        pp, ff = p[:bounds[j]], f[:bounds[j]]
+        best_thr, best_m = 0.55, -np.inf
+        for thr in (0.55,) + tuple(grid):
+            r = _backtest(pp, ff, horizon, thr, fee)
+            if r["n"] >= 30 and r["mean"] > best_m:
+                best_thr, best_m = thr, r["mean"]
+        trades.append(_trades(p[bounds[j]:bounds[j + 1]], f[bounds[j]:bounds[j + 1]], horizon, best_thr, fee))
+    return _stats(np.concatenate(trades) if trades else np.array([]))
+
+
 def _walk(X, Y, F, W, horizon, n_folds, k):
-    """Purged expanding-window walk-forward; OOS olasılıkları ve satır indeksleri."""
+    """Purged expanding-window walk-forward. Döner: OOS olasılık, satır indeksi, fold boyutları, ort. train-test AUC farkı."""
     n = len(X)
     edges = np.linspace(int(n * 0.4), n, n_folds + 1).astype(int)
-    oos_p, oos_idx = [], []
+    oos_p, oos_idx, sizes, gaps = [], [], [], []
     for j in range(n_folds):
         tr_end, te0, te1 = edges[j] - horizon, edges[j], edges[j + 1]
         if tr_end < 80:
             continue
-        oos_p.append(_fit_predict(X.iloc[:tr_end], Y.iloc[:tr_end], X.iloc[te0:te1],
-                                  W[:tr_end], F[:tr_end], k))
+        p, ptr = _fit_predict(X.iloc[:tr_end], Y.iloc[:tr_end], X.iloc[te0:te1],
+                              W[:tr_end], F[:tr_end], k, with_train=True)
+        try:
+            gaps.append(roc_auc_score(Y.iloc[:tr_end], ptr) - roc_auc_score(Y.iloc[te0:te1], p))
+        except ValueError:
+            pass
+        oos_p.append(p)
         oos_idx.extend(range(te0, te1))
+        sizes.append(te1 - te0)
     if not oos_p:
         raise ValueError("Walk-forward için yeterli veri yok. Mum sayısını artır.")
-    return np.concatenate(oos_p), np.array(oos_idx)
+    return (np.concatenate(oos_p), np.array(oos_idx), sizes,
+            float(np.mean(gaps)) if gaps else float("nan"))
 
 
 def predict(df: pd.DataFrame, horizon: int, fee: float = 0.0006, n_folds: int = 5, ext=None,
@@ -580,17 +615,21 @@ def predict(df: pd.DataFrame, horizon: int, fee: float = 0.0006, n_folds: int =
     # ve büyük hareketlere daha fazla ağırlık ver.
     W = np.clip(np.abs(F) / (TM + 1e-12), 0.05, 3.0)
 
-    # --- Purged walk-forward (expanding window), fold-içi özellik seçimiyle ---
-    oos_p, oos_idx = _walk(X, Y, F, W, horizon, n_folds, max_feat)
-    yo, fo = Y.values[oos_idx], F[oos_idx]
+    # --- Geliştirme (ilk %80) / hiç dokunulmayan hold-out (son %20) ---
+    n_all = len(X)
+    n_dev = int(n_all * 0.8)
+    Xd, Yd, Fd, Wd = X.iloc[:n_dev], Y.iloc[:n_dev], F[:n_dev], W[:n_dev]
+
+    oos_p, oos_idx, sizes, gap = _walk(Xd, Yd, Fd, Wd, horizon, n_folds, max_feat)
+    yo, fo = Yd.values[oos_idx], Fd[oos_idx]
 
     # Teşhis (ablation): yalnızca temel (fiyat/hacim) özelliklerle aynı test
     base_cols = [c for c in cols if not c.startswith(("ts_", "dv_"))]
     auc_base = None
     if len(base_cols) < len(cols):
-        pb, ib = _walk(X[base_cols], Y, F, W, horizon, n_folds, max_feat)
+        pb, ib, _, _ = _walk(Xd[base_cols], Yd, Fd, Wd, horizon, n_folds, max_feat)
         try:
-            auc_base = float(roc_auc_score(Y.values[ib], pb))
+            auc_base = float(roc_auc_score(Yd.values[ib], pb))
         except ValueError:
             auc_base = 0.5
 
@@ -600,14 +639,33 @@ def predict(df: pd.DataFrame, horizon: int, fee: float = 0.0006, n_folds: int =
         auc = float(roc_auc_score(yo, oos_p))
     except ValueError:
         auc = 0.5
+    # AUC anlamlılığı: H0 (AUC=0.5) altında SE ≈ sqrt(1/(3·n_eff)); örtüşen etiketler için n_eff = n/ufuk
+    n_eff = max(len(oos_p) / horizon, 2.0)
+    z = (auc - 0.5) / math.sqrt(1.0 / (3.0 * n_eff))
+    auc_p = 0.5 * math.erfc(z / math.sqrt(2.0))
 
-    # Eşik taraması (yalnızca OOS üzerinde, işlem sayısı ≥ 30 şartıyla)
+    # Eşik taraması (yalnızca OOS üzerinde, işlem sayısı ≥ 30 şartıyla) — iyimser
     best = {"thr": 0.55, **_backtest(oos_p, fo, horizon, 0.55, fee)}
     for thr in (0.52, 0.54, 0.56, 0.58, 0.60, 0.62):
         r = _backtest(oos_p, fo, horizon, thr, fee)
         if r["n"] >= 30 and r["mean"] > best["mean"]:
             best = {"thr": thr, **r}
 
+    # Dürüst (nested) backtest: eşik hiç görmediği fold'a uygulanır
+    nested = _nested(oos_p, fo, sizes, horizon, fee)
+
+    # Hold-out: gelişitirmede hiç kullanılmayan son %20; seçilen eşikle bir kez değerlendirilir
+    ho = None
+    tr_end = n_dev - horizon
+    if tr_end >= 200 and n_all - n_dev >= 100:
+        ph = _fit_predict(X.iloc[:tr_end], Y.iloc[:tr_end], X.iloc[n_dev:], W[:tr_end], F[:tr_end], max_feat)
+        try:
+            auc_h = float(roc_auc_score(Y.values[n_dev:], ph))
+        except ValueError:
+            auc_h = 0.5
+        ho = {"auc": auc_h, "bars": len(ph),
+              **_stats(_trades(ph, F[n_dev:], horizon, best["thr"], fee))}
+
     # Son model: tüm veriyle, canlı tahmin
     final_p = _fit_predict(X, Y, feats.iloc[[-1]][cols].ffill().fillna(0), W, F, max_feat)
     p_up = float(final_p[0])
@@ -620,6 +678,7 @@ def predict(df: pd.DataFrame, horizon: int, fee: float = 0.0006, n_folds: int =
         "center": center, "low": center - move, "high": center + move,
         "thr": best["thr"], "bt": best, "n_oos": len(oos_p), "fee": fee,
         "n_ext": n_ext, "n_feat": len(cols), "auc_base": auc_base, "max_feat": max_feat,
+        "gap": gap, "auc_p": auc_p, "nested": nested, "holdout": ho,
     }
 
 
@@ -683,8 +742,20 @@ def run(symbol, timeframe, exchange, horizon, limit, use_deriv=True, max_feat=40
 
     p, thr, bt = res["p_up"], res["thr"], res["bt"]
     signal = "LONG" if p > thr else "SHORT" if p < 1 - thr else "NÖTR"
-    has_edge = res["auc"] > 0.52 and bt["mean"] > 0 and bt["t"] > 1.5 and bt["n"] >= 30
-    edge = "✅ var (OOS, ücret sonrası)" if has_edge else "⚠️ kanıtlanamadı"
+    nest, ho = res["nested"], res["holdout"]
+    checks = [
+        ("AUC > 0.52 ve p < 0.05", res["auc"] > 0.52 and res["auc_p"] < 0.05),
+        ("Train–test AUC farkı < 0.20 (aşırı uyum düşük)", res["gap"] < 0.20),
+        ("Nested net getiri > 0 ve t > 1.5 (≥30 işlem)", nest["n"] >= 30 and nest["mean"] > 0 and nest["t"] > 1.5),
+        ("Hold-out AUC > 0.50", ho is not None and ho["auc"] > 0.50),
+        ("Hold-out net getiri > 0 (≥20 işlem)", ho is not None and ho["n"] >= 20 and ho["mean"] > 0),
+    ]
+    passed = sum(ok for _, ok in checks)
+    edge = f"✅ {passed}/5 kriter" if passed >= 4 else f"⚠️ {passed}/5 kriter — kanıtlanamadı"
+    checks_md = "**Aşırı uyum / güvenilirlik göstergesi**\n\n" + "\n".join(
+        f"- {'✅' if ok else '❌'} {name}" for name, ok in checks)
+    ho_txt = (f"AUC {ho['auc']:.3f} · {ho['n']} işlem · net {ho['mean']:.3%} (t = {ho['t']:.2f}) · {ho['bars']} bar"
+              if ho is not None else "veri yetersiz")
     md = f"""### {symbol} · {timeframe} · {int(horizon)} bar sonrası
 | | |
 |---|---|
@@ -697,9 +768,15 @@ def run(symbol, timeframe, exchange, horizon, limit, use_deriv=True, max_feat=40
 | Ort. net getiri / işlem | {bt['mean']:.3%} (t = {bt['t']:.2f}, ücret {res['fee']:.2%}/işlem) |
 | Özellik sayısı | {res['n_feat']} (Tickscope/türev: {res['n_ext']}) → fold başına en fazla {res['max_feat']} seçilir |
 | AUC yalnızca temel özelliklerle | {('%.3f' % res['auc_base']) if res['auc_base'] is not None else '—'} (ek veri kaynakları yardım ediyor mu?) |
+| Train–test AUC farkı (aşırı uyum) | {res['gap']:.3f} |
+| AUC anlamlılığı (tek yönlü p) | {res['auc_p']:.3f} |
+| Nested (dürüst) net getiri / işlem | {nest['mean']:.3%} (t = {nest['t']:.2f}, {nest['n']} işlem) |
+| Hold-out (dokunulmamış son %20) | {ho_txt} |
 | Model edge | {edge} |
 
-*Walk-forward (purged) out-of-sample sonuçlar. Eşik OOS'ta seçildiği için hafif iyimser olabilir. Eğitim/araştırma amaçlıdır; yatırım tavsiyesi değildir.*"""
+{checks_md}
+
+*Üstteki OOS/backtest satırları geliştirme kısmında (ilk %80) walk-forward ve eşik OOS'ta seçildiği için iyimserdir; güvenilir olanlar nested ve hold-out satırlarıdır. Eğitim/araştırma amaçlıdır; yatırım tavsiyesi değildir.*"""
 
     # Grafik
     tail = df.tail(150)