research(alt): sweep 104 strategie alternative su Deribit (153 agenti) + marginal scorer

Ondata di ricerca onesta a largo spettro su BTC/ETH+DVOL certificati: 104 ipotesi distinte (11 famiglie), un agente-finder per ipotesi, verifica avversariale a 3 scettici sui promettenti, sintesi (153 agenti totali). Esito: NIENTE di nuovo regge -> conferma del soffitto strutturale ~1.3 BTC/ETH-direzionale; lo stack TP01+XS01+VRP01 resta imbattuto. - altlib.py: harness condiviso vettoriale leak-free (eval_weights/study_weights, fee-sweep, both-asset + hold-out 2025+). Riproduce i numeri canonici di TP01. - MARGINAL SCORER (study_marginal/marginal_vs_tp01): Sharpe INCREMENTALE vs baseline TP01 (corr, blend uplift OOS, alpha residua) + jackknife OOS (clean-year + drop-best-month). earns_slot = abs!=FAIL & ADDS & robust_oos. Smaschera gli overlay su TSMOM con PASS assoluti fasulli (CMB04, VOL11, ...) e il falso positivo KAMA (ADDS ma muore al jackknife). - runs/*.py (104) script riproducibili per ipotesi; wf_altstrat.js workflow. - Verdetto: 0 candidati deployabili; 2 LEAD fragili (VOL08, STA05_LS) da forward-monitor. - test_marginal_scorer.py blocca baseline + invarianti. Suite: 32 verde. Diario: docs/diary/2026-06-20-alt-strategies-100agent-sweep.md Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-20 19:50:39 +00:00
parent bf84bc91e2
commit 5ac4e16af8
111 changed files with 16924 additions and 0 deletions
@@ -0,0 +1,119 @@
+"""MRV11 — Bollinger %b Reversion
+HYPOTHESIS: Bollinger %b = position of close within Bollinger Bands.
+  %b = (close - lower) / (upper - lower)
+  Entry logic: go long when %b < threshold_low (deeply oversold), exit at 0.5 (middle band),
+  with SMA200 trend filter (only long when close < SMA200, i.e., in downtrend/mean-reversion regime).
+
+Style: continuous weights (al.study_weights).
+Small grid: 2 BB params x 2 thresholds = 4 configs, tested on 2 TFs = max 6 (pick best by hold-out).
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def make_target(bb_win: int, bb_k: float, entry_pctb: float, trend_win: int = 200):
+    """
+    Bollinger %b reversion target function.
+
+    - Compute %b = (close - lower) / (upper - lower)
+    - Long signal when %b < entry_pctb (close near/below lower band) AND close < SMA(trend_win)
+    - Position scales linearly from max at %b=0 to 0 at %b=0.5 (exit threshold)
+    - Vol-targeted to 20% annualized, leverage capped at 2x
+    - All decisions use data <= close[i] (causal)
+
+    Args:
+        bb_win: Bollinger Band window (20 or 30)
+        bb_k: Bollinger Band width in std devs (2.0)
+        entry_pctb: %b threshold to enter long (0.05 or 0.10)
+        trend_win: SMA window for trend filter (200 bars)
+    """
+    def _target(df: pd.DataFrame) -> np.ndarray:
+        c = df["close"].values.astype(float)
+        n = len(c)
+
+        # Bollinger Bands (causal: uses data up to i)
+        upper, mid, lower = al.bbands(c, win=bb_win, k=bb_k)
+
+        # %b = (close - lower) / (upper - lower)
+        band_width = upper - lower
+        # Avoid division by zero when bands collapse
+        pctb = np.where(band_width > 1e-10, (c - lower) / band_width, 0.5)
+
+        # Trend filter: SMA200 (only enter when we're in a range/downtrend context)
+        trend_sma = al.sma(c, trend_win)
+        # below_trend: close < SMA200 (mean-reversion opportunity more likely)
+        below_trend = c < trend_sma  # boolean array, causal
+
+        # Continuous position signal:
+        # - When %b < entry_pctb AND below SMA200: long with weight proportional to how
+        #   deep we are (1 - %b/0.5 mapped to [0,1])
+        # - When %b >= 0.5: flat (exit)
+        # - Linearly scale between entry_pctb and 0.5
+
+        # Compute raw direction:
+        # Full strength at pctb=0, zero at pctb=0.5
+        # Clamp: below entry_pctb -> scale from 0 to 1 relative to entry zone
+        raw_long = np.where(
+            (pctb < 0.5) & below_trend,
+            np.clip((0.5 - pctb) / 0.5, 0.0, 1.0),  # linear fade: 1 at pctb=0, 0 at pctb=0.5
+            0.0
+        )
+
+        # Apply NaN mask for warmup period
+        warmup = max(bb_win, trend_win)
+        raw_long[:warmup] = 0.0
+
+        # Vol-target to 20% annualized, cap 2x leverage
+        return al.vol_target(raw_long, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+
+    return _target
+
+
+# ── Grid: 4 configs (bb_win x entry_pctb) ─────────────────────────────────────
+CONFIGS = [
+    dict(bb_win=20, bb_k=2.0, entry_pctb=0.05, label="BB20k2-p05"),
+    dict(bb_win=20, bb_k=2.0, entry_pctb=0.10, label="BB20k2-p10"),
+    dict(bb_win=30, bb_k=2.0, entry_pctb=0.05, label="BB30k2-p05"),
+    dict(bb_win=30, bb_k=2.0, entry_pctb=0.10, label="BB30k2-p10"),
+]
+
+# Run all configs at 1d (the hypothesis is cleaner at daily; 4 configs x 1 TF = 4 backtests)
+# Also run best config at 12h (total = 4+2 = 6 max)
+print("=== MRV11: Bollinger %b Reversion - Grid Search ===\n")
+
+results = []
+for cfg in CONFIGS:
+    fn = make_target(cfg["bb_win"], cfg["bb_k"], cfg["entry_pctb"])
+    rep = al.study_weights(
+        f"MRV11-{cfg['label']}",
+        fn,
+        tfs=("1d",)
+    )
+    results.append((cfg, rep))
+    v = rep["verdict"]
+    cell_1d = rep["cells"][0]
+    print(f"{cfg['label']:20s}: minFull={cell_1d['min_asset_full_sharpe']:+.3f}  "
+          f"minHold={cell_1d['min_asset_holdout_sharpe']:+.3f}  "
+          f"feeOK={cell_1d['fee_survives']}  grade={v['grade']}")
+
+print()
+
+# Pick best config by hold-out Sharpe at 1d
+best_cfg, best_rep = max(results, key=lambda x: x[1]["cells"][0]["min_asset_holdout_sharpe"])
+print(f"Best config: {best_cfg['label']}")
+print()
+
+# Run best config also on 12h
+best_fn = make_target(best_cfg["bb_win"], best_cfg["bb_k"], best_cfg["entry_pctb"])
+final_rep = al.study_weights(
+    f"MRV11-{best_cfg['label']}",
+    best_fn,
+    tfs=("1d", "12h")
+)
+
+print(al.fmt(final_rep))
+print()
+print("JSON:", al.as_json(final_rep))