| |
| """Finite, preregistered offline comparison of refresh, horizon and risk sizing. |
| |
| No broker imports, live writes or automatic promotion. Execution friction is an |
| assumption, never a statement of actual account charges. |
| """ |
| import argparse |
| from copy import copy |
| from dataclasses import asdict, replace |
| import hashlib |
| import json |
| from pathlib import Path |
| import sys |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT / "backend")) |
| from app.quant_policy import PolicyModel, PolicySpec, integer_targets, normalize_bars, target_weights |
| from app.research.policy_replay import ExecutionConfig, ShareLedger, complete_universe, replay_day, summarize, fixed_order_cost_stress |
|
|
| TRADED = ("NVDA", "SNDK", "TSLA") |
| INPUTS = (*TRADED, "MSTR") |
|
|
|
|
| def write(path, value): |
| path.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") |
|
|
|
|
| def digest(path): |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def exposure_metrics(daily, marks): |
| close = pd.DataFrame(marks).query("phase == 'bar_close'") |
| returns = pd.DataFrame(daily).net_return |
| return dict(mean_gross_exposure=float(close.gross_exposure.mean()), |
| mean_abs_net_exposure=float(close.net_exposure.abs().mean()), |
| daily_return_std=float(returns.std(ddof=1)), |
| mean_abs_daily_return=float(returns.abs().mean()), |
| mean_daily_turnover=float(pd.DataFrame(daily).turnover_equity_multiple.mean())) |
|
|
|
|
| def run(args): |
| out = Path(args.output) |
| out.mkdir(parents=True, exist_ok=False) |
| frozen = PolicyModel.load(args.model) |
| specs = [replace(frozen.spec, name="frozen_h1"), |
| *[PolicySpec(f"daily_refit_h{h}", horizon_bars=h, risk_aversion=50) for h in (1, 3, 6)], |
| PolicySpec("daily_refit_h1_risk10", horizon_bars=1, risk_aversion=10), |
| replace(frozen.spec, name="equal_weight_session")] |
| files = {s: Path(args.bars) / f"{s}.parquet" for s in INPUTS} |
| sources = [Path(__file__), ROOT / "backend/app/quant_policy.py", |
| ROOT / "backend/app/research/policy_replay.py", |
| ROOT / "backend/app/research/causal_week_replay.py"] |
| registration = dict(status="registered", registered_at=pd.Timestamp.now(tz="UTC").isoformat(), |
| start=args.start, end=args.end, capital=args.capital, traded_symbols=TRADED, |
| model_inputs=INPUTS, candidates=[asdict(s) for s in specs], |
| training="Expanding prior full sessions; same 2026-08-10 starting history for all daily refits", |
| execution="Completed-bar intent, next open, integer shares, existing 15:55 liquidation; 2 bps assumed friction", |
| evaluation="Newly evaluated historical window, not prospective or untouched holdout", |
| selection="Report all six candidates, no automatic live promotion; reduced risk aversion is an isolated sizing experiment", |
| source_hashes={str(p.relative_to(ROOT)): digest(p) for p in sources}, |
| data_hashes={s: digest(p) for s, p in files.items()}, frozen_model_sha256=digest(Path(args.model)), |
| limitations=["Yahoo OHLCV; no timestamped quotes, partial fills, borrow or latency reconstruction", |
| "Actual explicit fees and financing unverified; 0/2/5 bps are assumed friction scenarios", |
| "Contemporary three-stock universe, not point-in-time universe selection", |
| "Frozen model has different historical training window; refresh comparison includes that window difference", |
| "Risk10 is research only, same 95% gross and 70% single-name caps", |
| "Six short-window comparisons cannot establish persistent alpha"]) |
| write(out / "preregistration.json", registration) |
| for p in sources: |
| dest = out / "source" / p.relative_to(ROOT) |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| dest.write_bytes(p.read_bytes()) |
| frames = {s: normalize_bars(pd.read_parquet(p)) for s, p in files.items()} |
| |
| import exchange_calendars as xcals |
| dates = [str(d.date()) for d in xcals.get_calendar("XNYS").sessions_in_range(args.start, args.end)] |
| sessions, _, coverage = complete_universe(frames, dates) |
| write(out / "coverage.json", coverage) |
| fit_cache, results = {}, {} |
| for spec in specs: |
| ledger = ShareLedger(list(TRADED), ExecutionConfig(starting_equity=args.capital, slippage_bps=2)) |
| daily, training = [], [] |
| for day in dates: |
| model = None |
| if spec.name != "equal_weight_session": |
| if spec.name == "frozen_h1": |
| model = frozen |
| else: |
| key = (spec.horizon_bars, day) |
| if key not in fit_cache: |
| fit_cache[key] = PolicyModel.fit(frames, day, spec) |
| model = copy(fit_cache[key]) |
| if model.trained_last_session >= day: |
| raise ValueError("Training overlaps evaluation") |
| model = copy(model) |
| model.spec = spec |
| training.append(dict(date=day, last_training_session=model.trained_last_session)) |
| forecasts = model.forecast_frames({s: sessions[s][day] for s in model.symbols}) |
| indices = [model.symbols.index(s) for s in TRADED] |
| bars = {s: sessions[s][day] for s in TRADED} |
| index = bars[TRADED[0]].index |
|
|
| def decide(i, current): |
| mu = {s: float(forecasts[s].iloc[i]) for s in TRADED} |
| cov = model.covariance_at(index[i])[np.ix_(indices, indices)] |
| return target_weights(mu, cov, current, spec, symbols=TRADED, |
| shortable=dict.fromkeys(TRADED, True)) |
|
|
| benchmark = spec.name == "equal_weight_session" |
| daily.append(replay_day(ledger, bars, day, None if benchmark else decide, |
| lambda w, p, e: integer_targets(w, p, e, spec), |
| dict.fromkeys(TRADED, spec.gross_limit / len(TRADED)) if benchmark else None)) |
| print(spec.name, day, round(daily[-1]["net_pnl"], 2), flush=True) |
| folder = out / spec.name |
| folder.mkdir() |
| for name, rows in (("daily", daily), ("fills", ledger.fills), ("marks", ledger.marks)): |
| pd.DataFrame(rows).to_csv(folder / f"{name}.csv.gz", index=False, compression="gzip") |
| write(folder / "training.json", training) |
| result = dict(**summarize(daily, ledger.marks), **exposure_metrics(daily, ledger.marks), |
| fixed_order_cost_stress={str(bps): fixed_order_cost_stress(ledger.fills, ledger.marks, |
| ExecutionConfig(starting_equity=args.capital, slippage_bps=bps)) for bps in (0, 2, 5)}, |
| chronological_halves=[summarize(part, ledger.marks) for part in (daily[:len(daily)//2], daily[len(daily)//2:])]) |
| write(folder / "summary.json", result) |
| results[spec.name] = result |
| write(out / "progress.json", results) |
| write(out / "registry.json", dict(**{**registration, "status": "complete"}, results=results, |
| completed_at=pd.Timestamp.now(tz="UTC").isoformat())) |
|
|
|
|
| if __name__ == "__main__": |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument("--bars", required=True) |
| p.add_argument("--model", default=str(ROOT / "reports/quant_research_20260913/selected_policy.json")) |
| p.add_argument("--output", required=True) |
| p.add_argument("--start", default="2026-09-15") |
| p.add_argument("--end", default="2026-10-06") |
| p.add_argument("--capital", type=float, default=47006.42) |
| run(p.parse_args()) |
|
|
