"""ANALISI DI IMPATTO (sola lettura, da docs/TODO.md): bug bfill di `_daily_equity`. IL BUG (scripts/analysis/honest_improve2.py:30): daily = s.resample("1D").last().reindex(idx).ffill().bfill() La serie `s` e' a PUNTI-TRADE (un valore di capitale per ogni exit). Il `reindex(idx)` taglia PRIMA di forward-fillare: i giorni di IDX precedenti al primo trade DENTRO la finestra restano NaN (il ffill non ha un valore precedente in-finestra da propagare) e il `.bfill()` finale li riempie col capitale DOPO il primo trade in-finestra. Effetti: 1. l'ancora a idx[0] e' il capitale post-primo-trade-in-finestra, NON il capitale portato avanti dall'ultimo trade PRIMA della finestra; 2. il rendimento del primo trade in-finestra viene CANCELLATO dalla serie daily (la testa e' piatta al valore post-trade -> pct_change = 0 anche il giorno del trade). CORREZIONE (qui, solo per confronto): ffill PRIMA del reindex (carry-forward su tutta la storia trade) + testa pre-primo-trade-assoluto = capitale iniziale 1000. MAI valori dal futuro. Sleeve canonici interessati (serie a punti-trade -> testa di IDX scoperta): DIP01_BTC, PR_ETHBTC, PR_ETHBTC_15M, PR_LTCETH, PR_ADAETH, PR_BTCLTC, PR_ETHSOL, TSM01, XS01 (questi due quasi-densi: punti daily/12h -> impatto atteso ~0). TR01_basket / ROT02_rot passano da _daily_equity ma con punti PER-BARRA (densi dal 2018) -> verificati comunque qui via monkeypatch runtime (nessun file canonico toccato). I fade (combine_portfolio.py:52) e SH01 (shape_ml_validate.py:124) usano lo stesso pattern reindex+bfill ma su equity PER-BARRA con dati che iniziano prima di IDX[0] -> il bfill e' un no-op (verificato: nessun NaN in testa). NB: le metriche OOS canoniche affettano la STESSA serie daily a SPLIT (metrics(dr, lo=SPLIT)); la distorsione sta solo in testa (2021) -> l'OOS e' invariato per costruzione se il primo trade in-finestra precede lo SPLIT. Questo script lo misura. Uso: uv run python scripts/analysis/daily_equity_bfill_impact.py """ from __future__ import annotations import sys from pathlib import Path import numpy as np import pandas as pd PROJECT_ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(PROJECT_ROOT)) import scripts.analysis.honest_improve2 as hi2 from scripts.analysis.honest_improve2 import _norm, dip_market_gated from scripts.analysis.combine_portfolio import IDX, SPLIT, OOS_DATE, metrics, port_returns from scripts.analysis.pairs_research import pairs_sim, pairs_sim_flat from scripts.analysis.tsmom_research import tsmom_sim from scripts.strategies.PR01_pairs_reversion import PAIRS as PAIR_DEFS from scripts.strategies.XS01_cross_sectional import xsec_sim from scripts.portfolios._defs import PORTFOLIOS from src.portfolio import weighting as W INIT = 1000.0 # ---------------- le due convenzioni ---------------- def daily_equity_buggy(ts_list, cap_list, idx): """Replica ESATTA di honest_improve2._daily_equity (per parity-check).""" s = pd.Series(cap_list, index=pd.to_datetime(ts_list, utc=True)) s = s[~s.index.duplicated(keep="last")].sort_index() return s.resample("1D").last().reindex(idx).ffill().bfill() def daily_equity_fixed(ts_list, cap_list, idx, init=INIT): """CORRETTA: ancora = capitale portato avanti dall'ultimo trade PRIMA della finestra (ffill prima del reindex); pre-primo-trade assoluto = capitale iniziale.""" s = pd.Series(cap_list, index=pd.to_datetime(ts_list, utc=True)) s = s[~s.index.duplicated(keep="last")].sort_index() daily = s.resample("1D").last().ffill() # carry-forward su TUTTA la storia daily = daily.reindex(idx).ffill() # coda oltre l'ultimo trade return daily.fillna(init) # testa pre-primo-trade: capitale iniziale def head_info(ts_list, cap_list, idx): """(primo giorno con trade dentro IDX, rendimento di testa perso dal bfill %).""" s = pd.Series(cap_list, index=pd.to_datetime(ts_list, utc=True)) s = s[~s.index.duplicated(keep="last")].sort_index() raw = s.resample("1D").last().reindex(idx) # senza fill: NaN = nessun trade quel giorno first = raw.first_valid_index() if first is None: return None, 0.0 fixed = daily_equity_fixed(ts_list, cap_list, idx) lost = (fixed.loc[first] / fixed.iloc[0] - 1) * 100 # ritorno idx[0]->primo trade-day return first.date(), float(lost) def m2(eq: pd.Series): dr = eq.pct_change().fillna(0.0) return metrics(dr), metrics(dr, lo=SPLIT) def fmt_pair(label, b, f): d_sh = f["sharpe"] - b["sharpe"] d_dd = f["dd"] - b["dd"] d_rt = f["ret"] - b["ret"] return (f" {label:<22s}" f"Sh {b['sharpe']:6.2f}->{f['sharpe']:6.2f} ({d_sh:+.3f}) " f"DD {b['dd']:6.2f}->{f['dd']:6.2f} ({d_dd:+.3f}pp) " f"ret {b['ret']:+9.1f}->{f['ret']:+9.1f} ({d_rt:+8.2f}pp)") def main(): print("=" * 110) print(" IMPATTO bug bfill _daily_equity (honest_improve2.py:30) — attuale vs corretto") print(f" IDX {IDX[0].date()} -> {IDX[-1].date()} | OOS da {OOS_DATE} (slice a SPLIT={SPLIT} sui rendimenti daily)") print("=" * 110) # ---------------- [1] baseline canonica (bfill cosi' com'e') ---------------- print("\n[1] build_everything() canonico (2-3 min)...") from scripts.analysis.report_families import build_everything S, pairs, tsm, shape = build_everything() base = {**S, **pairs, **tsm, **shape} # ---------------- [2] ri-simula gli sleeve a punti-trade ---------------- print("[2] ri-simulazione sleeve a punti-trade (parity-check + versione corretta)...") raw: dict[str, tuple] = {} d = dip_market_gated("BTC", market_n=0, return_equity=True) raw["DIP01_BTC"] = (d["eq_ts"], d["eq_v"]) for a, b_, p in PAIR_DEFS: r = pairs_sim(a, b_, **p) raw[f"PR_{a}{b_}"] = (r["eq_ts"], r["eq_v"]) r15 = pairs_sim_flat("ETH", "BTC", tf="15m", n=66, z_in=1.674, z_exit=1.0, max_bars=35, flat_skip=True, pos=0.075) raw["PR_ETHBTC_15M"] = (r15["eq_ts"], r15["eq_v"]) t = tsmom_sim() raw["TSM01"] = (t["eq_ts"], t["eq_v"]) x = xsec_sim() raw["XS01"] = (x["eq_ts"], x["eq_v"]) fixed: dict[str, pd.Series] = {} print(f"\n {'sleeve':<16s}{'parity(max|diff|)':>18s}{'1o trade in IDX':>17s}{'ret testa perso%':>18s}") for k, (ts, v) in raw.items(): bug = _norm(daily_equity_buggy(ts, v, IDX)) par = float((bug - base[k]).abs().max()) fixed[k] = _norm(daily_equity_fixed(ts, v, IDX)) first, lost = head_info(ts, v, IDX) flag = "" if par < 1e-9 else " <-- PARITY FAIL" print(f" {k:<16s}{par:>18.2e}{str(first):>17s}{lost:>+18.3f}{flag}") # TR01/ROT02: passano da _daily_equity ma con punti per-barra (densi) -> # ricalcolo con monkeypatch RUNTIME della funzione (nessun file toccato). orig_de = hi2._daily_equity try: hi2._daily_equity = daily_equity_fixed tr_f = _norm(hi2._tr_basket_daily(["BNB", "BTC", "DOGE", "SOL", "XRP"], IDX)) rot_f = _norm(hi2._rot_daily_equity(IDX)) finally: hi2._daily_equity = orig_de for k, sf in (("TR01_basket", tr_f), ("ROT02_rot", rot_f)): diff = float((sf - base[k]).abs().max()) print(f" {k:<16s}{'(denso)':>18s}{'—':>17s}{diff:>18.2e} (diff fixed-vs-base: atteso ~0)") fixed[k] = sf # ---------------- [3] metriche per sleeve: attuale vs corretto ---------------- print("\n" + "=" * 110) print(" (3) SLEEVE a punti-trade — FULL e OOS, attuale(bfill) -> corretto(carry-forward)") print("=" * 110) rows_oos_delta = {} for k in fixed: bf, bo = m2(base[k]) ff, fo = m2(fixed[k]) print(fmt_pair(f"{k} FULL", bf, ff)) print(fmt_pair(f"{k} OOS ", bo, fo)) rows_oos_delta[k] = (ff["sharpe"] - bf["sharpe"], ff["dd"] - bf["dd"], fo["sharpe"] - bo["sharpe"], fo["dd"] - bo["dd"]) # ---------------- [4] PORT06: attuale vs corretto ---------------- print("\n" + "=" * 110) print(" (4) PORT06 (cap PAIRS 0.33 + SHAPE 0.0588) — attuale vs corretto") print("=" * 110) p = PORTFOLIOS["PORT06"] def port_m(members): ids = p.sleeve_ids dr = pd.DataFrame({i: members[i].pct_change().fillna(0.0) for i in ids}) w = W.weight_vector(p.weighting, ids, dr, weights=p.weights, caps=p.caps, clusters=p.clusters, lookback=p.vol_lookback) drp = port_returns({i: members[i] for i in ids}, w) return metrics(drp), metrics(drp, lo=SPLIT) members_fix = {**base, **fixed} bf, bo = port_m(base) ff, fo = port_m(members_fix) print(fmt_pair("PORT06 FULL", bf, ff)) print(fmt_pair("PORT06 OOS ", bo, fo)) # ---------------- [5] verdetto ---------------- print("\n" + "=" * 110) print(" (5) VERDETTO (soglie materialita': >0.1 Sharpe o >0.5pp DD su PORT06 OOS)") print("=" * 110) d_sh_oos = abs(fo["sharpe"] - bo["sharpe"]) d_dd_oos = abs(fo["dd"] - bo["dd"]) d_sh_full = abs(ff["sharpe"] - bf["sharpe"]) d_dd_full = abs(ff["dd"] - bf["dd"]) materiale = d_sh_oos > 0.1 or d_dd_oos > 0.5 print(f" PORT06 OOS : dSharpe {fo['sharpe']-bo['sharpe']:+.4f} dDD {fo['dd']-bo['dd']:+.4f}pp" f" -> {'MATERIALE' if materiale else 'NON materiale'}") print(f" PORT06 FULL: dSharpe {ff['sharpe']-bf['sharpe']:+.4f} dDD {ff['dd']-bf['dd']:+.4f}pp") worst = sorted(rows_oos_delta.items(), key=lambda kv: -abs(kv[1][0]) - abs(kv[1][1]) / 10) print(" Sleeve piu' toccati (dSharpe FULL, dDD FULL, dSharpe OOS, dDD OOS):") for k, (ds, dd_, dso, ddo) in worst[:5]: print(f" {k:<16s} FULL {ds:+.3f} / {dd_:+.3f}pp OOS {dso:+.3f} / {ddo:+.3f}pp") print("\n Nota strutturale: l'OOS canonico e' uno slice a SPLIT della stessa serie daily;") print(" la distorsione bfill vive solo in testa (prima del primo trade in IDX) -> se il") print(" primo trade in-finestra precede lo SPLIT, l'OOS e' INVARIATO per costruzione.") if __name__ == "__main__": main()