Compare commits
7 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Adriano
|
7b34e11476 | ||
|
Adriano
|
ae7f3d17f2 | ||
|
Adriano
|
3b6ff02197 | ||
|
Adriano
|
8dbdadd509 | ||
|
Adriano
|
33267584d9 | ||
|
Adriano
|
dc2b5697da | ||
|
Adriano
|
6b9c469832 |
@@ -1,11 +0,0 @@
|
||||
Old/
|
||||
data/
|
||||
.venv/
|
||||
.git/
|
||||
logs/
|
||||
__pycache__/
|
||||
**/__pycache__/
|
||||
*.pyc
|
||||
.env
|
||||
.env.mainnet
|
||||
docs/
|
||||
-16
@@ -43,20 +43,4 @@ data/games/
|
||||
# archived data (mirrors top-level data/ ignores, which are top-level-anchored)
|
||||
Old/data/
|
||||
Old/**/__pycache__/
|
||||
# run logs (rigenerabili dagli script)
|
||||
logs/
|
||||
|
||||
# cache della ricerca trackE (rigenerabile)
|
||||
.cache_trackE_*.npy
|
||||
|
||||
# feed backup pre-rebuild (binari rigenerabili, NON in git) + stato paper trader (runtime)
|
||||
data/_feed_backup/
|
||||
data/paper_trend/
|
||||
data/paper_portfolio/
|
||||
|
||||
# output grezzo dello sweep di ricerca xsec (rigenerabile dagli script in runs/)
|
||||
scripts/research/xsec/runs/out/
|
||||
|
||||
# blind-signal derived data (regenerable via make_blind.py)
|
||||
data/blind/
|
||||
scripts/research/blind/leaderboard.json
|
||||
|
||||
@@ -13,13 +13,7 @@ Cosa è cambiato:
|
||||
**solo BTC/ETH** (tutti i TF). Gli alt sono esclusi (illiquidi/divergenti/non certificabili).
|
||||
- Tutto il codice vecchio (strategie, stack live, ~100 script di ricerca/gate, dati non
|
||||
certificati, 60+ diari) è **archiviato in `Old/`** (preservato in git, non cancellato).
|
||||
- ~~L'esecuzione è DISABILITATA, il conto mainnet è flat. Non c'è trading live attivo.~~
|
||||
**AGGIORNATO 2026-06-20: l'esecuzione di TP01 è ARMATA e LIVE su Deribit mainnet** —
|
||||
`config/live.json` `execution_enabled=true` + cron giornaliero `live_execute.py --execute`
|
||||
(cablato in `scripts/cron_daily.sh`). Guardrail: cap **$300 notional/asset**, min order $5,
|
||||
**disaster-SL on-book −30%**, alert Telegram su esecuzione/errori. **Capitale reale ≈ $600**
|
||||
(NON i €2000 nominali del paper trader). Stato corrente: **flat** (target TSMOM risk-off →
|
||||
BTC/ETH 0.0x, nessun ordine). Solo TP01 è eseguito; XS01/VRP01 restano paper/STAT-MODE.
|
||||
- L'esecuzione è **DISABILITATA**, il conto mainnet è flat. **Non c'è trading live attivo.**
|
||||
- Si riparte dalla ricerca di strategie NUOVE, su dati certi, con la metodologia qui sotto.
|
||||
|
||||
### Ricerca post-reset (2026-06-19) — esito
|
||||
@@ -27,109 +21,19 @@ Cosa è cambiato:
|
||||
Prima ondata di ricerca onesta su BTC/ETH certificati (5 track, harness condiviso
|
||||
`src/backtest/harness.py`). Sintesi in `docs/diary/2026-06-19-research-synthesis.md`.
|
||||
|
||||
- **TP01 Trend Portfolio — strategia DIFENSIVA robusta (non alpha)** —
|
||||
`src/strategies/trend_portfolio.py`. TSMOM multi-orizzonte (1-3-6 mesi) vol-targeted, long-flat,
|
||||
50/50 BTC+ETH. Config canonica **PORT LF1d** (**>=12h, 1d raccomandato**, vol-target 20%, leva cap 2x):
|
||||
**FULL Sharpe ~1.30, maxDD ~14%; HOLD-OUT 2025-26 Sharpe ~0.31 / +3.5%** mentre il buy&hold 50/50
|
||||
faceva −39%/DD60%. Verificata indipendentemente col gauntlet onesto (hold-out + cross-asset +
|
||||
plateau + deflated-Sharpe 0.999): **regge**. **Valore = taglio del drawdown ~6× vs buy&hold**, NON
|
||||
generazione di ritorno (CAGR ~16% vs ~48% del buy&hold sul toro).
|
||||
⚠️ **LOOK-AHEAD (2026-06-19):** un ffill MIXED-TIMEFRAME su barre open-labeled gonfiava il 4h
|
||||
(~1.60 → reale ~1.1). Il calcolo per-singolo-TF è leak-free, ma **NON scendere sotto le 12h**:
|
||||
costi+overfitting dominano senza vantaggio (FULL Sh piatto ~1.3 da 12h a 4h; hold-out migliore a 1d).
|
||||
Deploy/paper a **1d**. Diari `2026-06-19-tp01-verification.md` / `-tp01-lookahead-fix-lf.md`.
|
||||
Paper trader: `scripts/live/paper_trend.py` (1d). Test: `tests/test_trend_portfolio.py`.
|
||||
Ri-verifica: `scripts/analysis/{verify_tp01,stress_tp01,tp01_lowfreq}.py`.
|
||||
- **XS01 Cross-Sectional Momentum (Hyperliquid) — DIVERSIFICATORE che migliora il portafoglio** —
|
||||
`src/portfolio/sleeves.py:_xsec_returns`. Market-neutral su **19 alt liquidi major** Hyperliquid (1d,
|
||||
dal 2024): ogni 10g long i 5 più forti / short i 5 più deboli, vol-target 20%. **Scorrelato a TP01
|
||||
(~−0.12).** Affinato (2026-06-19): **(a) blend di lookback [30,90]** (z-score cross-sectional mediato,
|
||||
come il multi-orizzonte di TP01); **(b) gate di dispersione p30** (entra solo se la dispersione
|
||||
cross-section del momentum supera il percentile espandente causale, altrimenti flat — XS è rumore in
|
||||
regime compatto). Standalone FULL Sh **1.50** / HOLD 1.71 / DD 11%, plateau robusto (lookback, gate
|
||||
p15-35). **Caveat:** storia ~2.5 anni; STAT-MODE (book a 19 gambe non eseguibile a 2k, serve ~20k) →
|
||||
monitor forward. NB il gate concentra XS nei regimi dispersi (2025-26 = hold-out alta-dispersione).
|
||||
Ricerca `scripts/portfolio/{xsec_research,xsec_blend,xsec_dispgate}.py`. Diari `2026-06-19-hyperliquid-xsec`
|
||||
/ `-xsec-blend` / `-xsec-dispgate` / `-xsec-universe-expansion` / `-trend-multiasset`.
|
||||
- **PORTAFOGLIO ATTIVO = TP01 (55%) + XS01 (25%) + VRP01 (20%)** (`src/portfolio/sleeves.active_sleeves`):
|
||||
TP01+XS01 combinato **FULL Sharpe 1.55, HOLD-OUT 1.55, DD 4.4%**. Aggiunto **VRP01** (options
|
||||
short-vol, sotto): TP01+VRP01 da solo fa FULL Sh 1.30→1.44 / HOLD 0.31→0.40 a peso 20% (3-way da
|
||||
validare locale con dati HL). Report `scripts/portfolio/run_portfolio.py`. Sleeve a date d'inizio
|
||||
diverse → outer-join con pesi rinormalizzati (TP01 da solo 2019-20, VRP dal 2021, blend pieno dal 2024).
|
||||
- **VRP01 Options Short-Vol — DIVERSIFICATORE da FinanceOld/OptionsAgent** — `src/portfolio/sleeves._vrp_combo_returns`.
|
||||
Put credit spread settimanale (vendi put -0.28, compra put -0.10) gated su IV-rank. Idee portate da
|
||||
`../FinanceOld/OptionsAgent` (Bear Call Spread + gate d'ingresso). Migliora il lead VRP nudo
|
||||
(options_vrp_lab): **(a) defined-risk** taglia la coda (worst-week -16.6%→-7.4%, DD 33%→14%);
|
||||
**(b) gate IV-rank>0.30** = vendi vol solo ricca → ribalta HOLD-OUT da -0.25 a +0.28 (l'alpha è il
|
||||
filtro di regime). Standalone **FULL Sh 1.10, HOLD 0.60, DD 12%**, positivo/piatto ogni anno (2022
|
||||
crash incluso). Scorrelato a TP01 (~+0.01-0.07). **CAVEAT:** premio MODELLATO su DVOL ATM (skew non
|
||||
esplicito), book a 1d, f di stress reale non catturato → LEAD robusto, non deploy pieno. Ricerca
|
||||
`scripts/research/options_vrp_v2.py` (vs baseline `options_vrp_lab.py`). Test `tests/test_vrp_sleeve.py`.
|
||||
Diario `2026-06-20-financeold-analysis-vrp-v2.md`.
|
||||
- **Universo Hyperliquid: ESPANDERLO NON aiuta XS01** (provato): 52-asset / top-liquidità dinamico /
|
||||
trend-multi-asset → tutti peggiori (small-cap/memecoin diluiscono il momentum relativo; il trend
|
||||
multi-asset è ridondante con TP01, corr 0.74). I margini su XS sono nella STRUTTURA DEL SEGNALE
|
||||
(blend + gate), non nel numero di asset. I **51** parquet certificati restano per ricerca futura.
|
||||
⚠️ Il test "52-asset = negativo" era in parte inquinato dal backfill sintetico (AXS 83%, ALGO/SAND
|
||||
37% di barre vol=0) poi rimosso — vedi correzione estrazione 2026-06-20 sotto; resta comunque vero
|
||||
che il long-tail diluisce XS01, ma il numero netto post-fix è 51.
|
||||
- **Lead OPZIONI VRP (income short-vol) — quantificato, NON deploy** — `scripts/research/options_vrp_*.py`.
|
||||
Vendita put settimanali che incassa il volatility risk premium (IV>RV), scorrelato al trend (~0.07).
|
||||
Premio prezzato BS su DVOL reale (`fetch_dvol.py`) + calibrato su quote REALI cerbero-bite mainnet
|
||||
(`options_vrp_calibrate.py`): **f reale ≈ 1.0** (non 1.29) → Sharpe ~0.71, DD 33%, coda severa
|
||||
(settimane −15..−26% su LUNA/FTX). Diversificatore DEBOLE a premio reale, e short-vol da modello.
|
||||
**Regola: niente short-vol da modello in deploy.** Rivalutare quando cerbero-bite cattura un crash
|
||||
(per il f di stress reale). Diari `2026-06-19-options-vrp-lab` / `-eval-crypto-backtest-options`.
|
||||
- **Edge deboli/scartati:** ML walk-forward BTC (Sh ~0.57), trend 1h L/S (~1.0), RV ETH/BTC (Sh 0.27,
|
||||
regime-luck), calendar/seasonality (buy&hold travestito), volume/vol e momentum-reversal (negativi).
|
||||
- **MORTO/confermato artefatto:** mean-reversion / fade (negativo anche a fee zero — la vecchia
|
||||
libreria +201%/+1238% era contaminazione); trend 5m/15m (fee).
|
||||
- **Soffitto strutturale BTC/ETH-direzionale ~1.3** superato SOLO espandendo a un meccanismo diverso:
|
||||
cross-sectional su universo Hyperliquid certificato (XS01) → portafoglio Sharpe ~1.55.
|
||||
- **Sweep "strategie alternative" (2026-06-20) — 104 ipotesi / 153 agenti / NIENTE di nuovo regge.**
|
||||
Ricerca onesta a largo spettro su BTC/ETH+DVOL (harness condiviso vettoriale leak-free
|
||||
`scripts/research/alt/altlib.py`, 104 script in `scripts/research/alt/runs/`): 11 famiglie
|
||||
(breakout, trend non-TSMOM, mean-rev gated, DVOL/vol, cross-asset pairs, stagionalità, overlay
|
||||
rischio, opzioni modellate, microstruttura, ML walk-forward, combo). 16 promettenti, **1 sola**
|
||||
sopravvissuta alla verifica avversariale (3 scettici) e comunque NON deployabile. Conferma forte
|
||||
del soffitto ~1.3: ogni PASS era hold-out-fitting o **TP01/TSMOM travestito** (trend-beta del
|
||||
toro). Unico LEAD: **STA05** (EWMA-cross ensemble, **long-short**) — leak-free, plateau, corr
|
||||
hold-out **0.53** a TP01, il blend 0.75·TP01+0.25·STA05 alza l'hold-out 0.31→0.59 (full 1.30→1.24,
|
||||
DD 14→16%); MA hold-out corto (536g) → **forward-monitor, non sleeve.** Lezione harness: valutare
|
||||
lo Sharpe **MARGINALE vs baseline TP01** (non assoluto) + esigere plateau e jackknife
|
||||
drop-one-month sull'hold-out prima di PASS (hanno ucciso 13/14 falsi positivi). Diario
|
||||
`2026-06-20-alt-strategies-100agent-sweep.md`.
|
||||
- **MARGINAL SCORER (implementato 2026-06-20)** — la lezione "Sharpe marginale, non assoluto" è
|
||||
ora codice in `scripts/research/alt/altlib.py`: `study_marginal(name, target_fn)` valuta un
|
||||
candidato direzionale BTC/ETH **sia** in assoluto **sia** rispetto al baseline `tp01_baseline_daily()`
|
||||
(corr, uplift del blend OOS, beta+alpha residua) e ritorna `earns_slot = (abs!=FAIL) AND
|
||||
(marginal==ADDS)`. **Regola: una nuova strategia direzionale si giudica su `earns_slot`, non sullo
|
||||
Sharpe assoluto** (gli overlay-su-TSMOM ereditano lo Sharpe di trend e prendono PASS fasulli —
|
||||
es. CMB04 PASS assoluto → NEUTRAL marginale). Demo `marginal_demo.py`, test `tests/test_marginal_scorer.py`.
|
||||
⚠️ **INDURITO 2026-06-21 (onda ortho):** la versione fisso-HOLDOUT + jackknife-mese era
|
||||
ingannabile — 17/18 book relative-value "ADDS" su una sola finestra 2025 (ETH-bleed dove TP01 è
|
||||
debole). Tre gate nuovi in `marginal_vs_tp01`: **(1) persistenza multi-cut** (uplift positivo a più
|
||||
date di taglio, non solo 2025); **(2) edge in-sample** (`has_insample_edge`: lo Sharpe standalone
|
||||
PRE-holdout dev'essere ≥0.5 — un low-corr a Sharpe ~0.3 "aggiunge" solo matematica di
|
||||
diversificazione, riportata via `null_pctl_*` vs un asset-rumore a corr-zero); **(3) hedge vs
|
||||
alpha** (`is_hedge`: un low-corr che paga SOLO quando TP01 è debole — `corr(Sharpe-TP01, uplift
|
||||
annuo)` molto negativa — è un hedge, non alpha). Verdetti nuovi: HEDGE, NOISE. Sull'onda ortho lo
|
||||
scorer indurito collassa 17/18 → **1** (`dvol_spread`, unico con edge in-sample reale; comunque
|
||||
forward-monitor per multiple-testing/storia DVOL corta). Lezione: un nuovo sleeve si giudica su
|
||||
edge-in-sample + persistenza multi-cut + non-hedge, non sull'uplift di una finestra fortunata.
|
||||
- **HARNESS REALISM (codificato 2026-06-21, onda intraday)** — due gate nuovi in `altlib.py`,
|
||||
test `tests/test_harness_realism.py`:
|
||||
- **`day_boundary_robust(target_fn, tf)`** — un effetto ora/sessione/giorno il cui uplift
|
||||
marginale **si inverte** spostando il confine del giorno UTC di poche ore è un **artefatto di
|
||||
etichettatura calendario** (ha ucciso `open_drive`: +0.23 a 00:00 → −0.33 a +8h → ARTIFACT-RISK).
|
||||
Un segnale di prezzo è INVARIANT (spread 0); un effetto calendario vero è ROBUST (resta positivo;
|
||||
es. `prevday_range_breakout`). **Regola: ogni segnale calendar/session/hour passa questo test
|
||||
prima di crederci.**
|
||||
- **`eval_weights_smallcap(df, target, capital=600, min_order=5)`** — a ~$600 un ribilanciamento
|
||||
di nozionale < min_order **non si esegue**; la fee proporzionale che `eval_weights` applica a
|
||||
migliaia di micro-trade sub-dollaro (tipici di un overlay vol-target) è **finzione**. Salta i
|
||||
sub-min_order e riporta lo **Sharpe haircut** reale vs modellato. **Vale per OGNI sleeve a questo
|
||||
capitale, TP01 incluso** — lo Sharpe netto onesto a $600 è quello small-cap, non quello modellato.
|
||||
- **VINCITRICE (l'unica robusta e profittevole): TP01 Trend Portfolio** —
|
||||
`src/strategies/trend_portfolio.py`. TSMOM multi-orizzonte (1-3-6 mesi) vol-targeted,
|
||||
50/50 BTC+ETH. Config canonica **PORT LF4h** (4h, long-flat, vol-target 20%, leva cap 2x):
|
||||
**CAGR ~16.6%, Sharpe ~1.32-1.36, maxDD ~12-14%, positiva ogni anno 2019-2026**.
|
||||
Robusta su tutti i TF (15m-1d), regge fee fino a 0.40% RT, su entrambi gli asset.
|
||||
Paper trader: `scripts/live/paper_trend.py`. Test: `tests/test_trend_portfolio.py`.
|
||||
- **Edge deboli ma reali** (NON standalone, NON migliorano il portafoglio): ML walk-forward
|
||||
su BTC (Sharpe ~0.57), trend 1h long-short (Sharpe ~1.0), relative-value market-neutral
|
||||
ETH/BTC (scorrelato ~0.05 ma Sharpe solo 0.27 → troppo debole per alzare lo Sharpe).
|
||||
- **MORTO/confermato artefatto:** mean-reversion / fade (negativo anche a fee zero su dati
|
||||
certi — la vecchia libreria +201%/+1238% era pura contaminazione); trend 5m/15m (fee).
|
||||
- **Soffitto strutturale:** con i soli BTC/ETH lo Sharpe di portafoglio si ferma a **~1.3**.
|
||||
Combinare TF o aggiungere la RV non aiuta (ridondanza/edge troppo debole).
|
||||
- **Onestà sul target €50/giorno:** NON raggiungibile su 2000 in 1-2 anni (servono ~130k di
|
||||
capitale o un DD da rovina). La leva non è la scorciatoia; la via è target-vol + capitale +
|
||||
tempo. La strategia che *guadagna* esiste, ma a ~+€1.5/giorno su 2000.
|
||||
@@ -155,17 +59,13 @@ netto fee, out-of-sample, robusto su griglia, e su dati certificati + liquidi +
|
||||
src/data/downloader.py → load_data(asset, tf): legge i parquet certificati da data/raw/
|
||||
src/strategies/base.py → Strategy (ABC), Signal, BacktestResult, YearlyStats
|
||||
src/strategies/indicators.py → indicatori condivisi (ema, atr, keltner, ...)
|
||||
src/strategies/trend_portfolio.py → TP01: strategia DIFENSIVA robusta (PORT LF1d, >=12h), causale
|
||||
src/portfolio/ → PORTAFOGLIO DI STRATEGIE estensibile (Sleeve + StrategyPortfolio)
|
||||
portfolio.py → combina N sleeve per peso su griglia giornaliera; metriche FULL/hold-out/anno
|
||||
sleeves.py → REGISTRY sleeve attivi: TP01 (55%) + XS01 (25%) + VRP01 (20%). Aggiungere = una riga
|
||||
src/strategies/trend_portfolio.py → TP01: strategia VINCENTE (PORT LF4h), causale, deployabile
|
||||
src/fractal/ → indicatori frattali (patterns.py, indicators.py, similarity.py)
|
||||
src/backtest/engine.py → engine di backtesting riusabile
|
||||
src/backtest/harness.py → harness ONESTO (load BTC/ETH, backtest_signals no-leakage, OOS)
|
||||
src/version.py → APP_VERSION (legge il file VERSION)
|
||||
scripts/research/ → ricerca: track{A-I}_*.py + options_vrp_*.py + fetch_dvol.py
|
||||
scripts/portfolio/ → run_portfolio.py (report) + xsec_*.py (ricerca/affinamento XS01)
|
||||
scripts/live/paper_trend.py → paper trader forward-only di TP01 (1d) (no esecuzione reale)
|
||||
scripts/research/ → ricerca post-reset: track{A-E}_*.py (trend/ML/MR/portfolio/xsec)
|
||||
scripts/live/paper_trend.py → paper trader forward-only di TP01 (no esecuzione reale)
|
||||
scripts/analysis/ → SOLO i tool dati certificati:
|
||||
rebuild_history.py → (ri)costruisce lo storico da Deribit mainnet (base 5m + resample)
|
||||
certify_feed.py → certifica il feed (integrità, coerenza resample, spike, cross-venue)
|
||||
@@ -187,10 +87,7 @@ uv run python scripts/analysis/certify_feed.py # certifica i feed
|
||||
uv run python scripts/analysis/certify_feed.py --local # solo check locali (veloce)
|
||||
uv run python scripts/research/trackD_trendport.py # backtest strategia vincente (full report)
|
||||
uv run python scripts/research/trackD_timing.py # vincitrice su 15m/1h/4h/1d + PnL/DD/trade per anno
|
||||
uv run python scripts/analysis/fetch_hyperliquid.py # fetch+certify universo Hyperliquid (Cerbero mainnet) -> data/raw/hl_*
|
||||
uv run python scripts/portfolio/xsec_research.py # ricerca cross-sectional su Hyperliquid (XS01)
|
||||
uv run python scripts/portfolio/run_portfolio.py # report del PORTAFOGLIO attivo (TP01+XS01)
|
||||
uv run python scripts/live/paper_trend.py # avanza il paper trader TP01 (forward-only, 1d)
|
||||
uv run python scripts/live/paper_trend.py # avanza il paper trader TP01 (forward-only)
|
||||
uv run pytest # test
|
||||
```
|
||||
|
||||
@@ -214,21 +111,10 @@ df = load_data("BTC", "1h") # OK. load_data("SOL", ...) -> FileNotFoundError (
|
||||
### Universo ricercabile certificato
|
||||
- **BTC / ETH**: puliti (2-6 bps vs Coinbase USD su tutta la storia), liquidi (~0% barre flat a 1h),
|
||||
storia lunga (2018/2019→oggi) → **ogni timeframe (5m/15m/1h)**. È l'unico dato in `data/raw`.
|
||||
- **Alt Deribit (SOL/XRP/ADA/LTC/DOGE/BNB): FUORI.** Illiquidi (LTC 5m 82% barre flat, run ~3 giorni),
|
||||
divergenti, o non certificabili. Archiviati in `Old/data/raw`.
|
||||
- **Universo Hyperliquid (Cerbero MCP MAINNET): 19 alt liquidi a 1d, dal 2024** — BTC/ETH/SOL/BNB/XRP/
|
||||
DOGE/AVAX/LINK/LTC/ADA/ARB/OP/SUI/APT/INJ/TIA/SEI/NEAR/AAVE. Certificati (`fetch_hyperliquid.py`):
|
||||
flat 0%, cross-venue 4-9 bps vs Binance, >1% ≈0% → `data/raw/hl_*_1d.parquet`. **Caveat:** storia
|
||||
nativa solo **~2.5 anni** (2024-2026; pre-2024 = backfill, vol 0). Abilita le strategie
|
||||
CROSS-SECTIONAL (impossibili a 2 asset). NB: Cerbero col token TESTNET = farlocco; col token
|
||||
**mainnet** (`.env.mainnet`) = reale, ma SEMPRE da certificare (cross-venue + liquidità).
|
||||
⚠️ **CORREZIONE estrazione (2026-06-20):** il backfill NON è solo pre-2024 — cerbero MCP padda con
|
||||
barre SINTETICHE (volume 0, prezzi copiati da Binance → matchano cross-venue e non sono flat) ogni
|
||||
asset listato su HL **dopo** lo START. Il `flat`+cross-venue da soli non lo vedono: il rivelatore è
|
||||
il **VOLUME**. `fetch_hyperliquid.py` ora (1) taglia il run iniziale a volume 0, (2) scarta chi resta
|
||||
< 365g reali (es. **AXS 83% sintetico → fuori**), (3) gata i gap vol=0 interni. Universo certificato
|
||||
= **51** (era 52). I **19 major di XS01 hanno 0 backfill → invariati** (strategia live non toccata).
|
||||
Verificato direttamente su cerbero MCP. Diario `2026-06-20-cerbero-backfill-fix.md`.
|
||||
- **Alt (SOL/XRP/ADA/LTC/DOGE/BNB): FUORI.** Illiquidi (LTC 5m 82% barre flat O=H=L=C, run fino a
|
||||
~3 giorni), divergenti (LTC/DOGE >1% su 10-21% delle barre 2022-23), o non certificabili
|
||||
(XRP delistato da Coinbase per causa SEC; BNB non listato + storia da 2024-10). Sono archiviati in
|
||||
`Old/data/raw`. Riammetterne uno richiede prima una ricertificazione che dimostri liquidità + accordo.
|
||||
|
||||
## Metodologia obbligatoria per ogni nuova strategia
|
||||
|
||||
|
||||
-11
@@ -1,11 +0,0 @@
|
||||
FROM python:3.11-slim
|
||||
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
|
||||
WORKDIR /app
|
||||
COPY pyproject.toml uv.lock ./
|
||||
RUN uv sync --frozen --no-dev
|
||||
COPY src/ src/
|
||||
COPY scripts/ scripts/
|
||||
COPY VERSION ./
|
||||
VOLUME /app/data
|
||||
# Monitor PAPER del portafoglio attivo (TP01+XS01). Esecuzione REALE disabilitata.
|
||||
CMD ["uv", "run", "python", "-m", "src.live.dashboard", "--port", "8787"]
|
||||
@@ -1,7 +0,0 @@
|
||||
{
|
||||
"_nota": "Config esecuzione LIVE di TP01. execution_enabled=true + --execute -> ordini REALI. ARMATO 2026-06-20.",
|
||||
"execution_enabled": true,
|
||||
"max_notional_per_asset_usd": 300,
|
||||
"min_order_usd": 5,
|
||||
"disaster_sl_pct": 0.30
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"capital": 2000.0,
|
||||
"initial_capital": 2000.0,
|
||||
"start_ts": 1781884800000,
|
||||
"last_ts": 1781884800000,
|
||||
"positions": {
|
||||
"BTC": 0.0,
|
||||
"ETH": 0.0
|
||||
},
|
||||
"n_bars": 0,
|
||||
"peak": 2000.0,
|
||||
"max_dd": 0.0
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
# Solo MONITOR (dashboard paper) del portafoglio attivo. Niente runner/esecuzione reale
|
||||
# (archiviati in Old/). v2.0.0+.
|
||||
services:
|
||||
dashboard:
|
||||
build: .
|
||||
container_name: pythagoras-dashboard
|
||||
restart: unless-stopped
|
||||
command: ["uv", "run", "python", "-m", "src.live.dashboard", "--port", "8787"]
|
||||
ports:
|
||||
- "8787:8787"
|
||||
volumes:
|
||||
- ./data:/app/data:ro
|
||||
# token mainnet (sola lettura) per lo "Shadow live": conto/posizioni reali sulla dashboard.
|
||||
# Montato a runtime (NON nell'immagine: .env.mainnet e' dockerignored). Solo letture, nessun ordine.
|
||||
- ./.env.mainnet:/app/.env.mainnet:ro
|
||||
@@ -1,35 +0,0 @@
|
||||
# 2026-06-19 — Wave 1 "beat TP01" (26 agenti BTC/ETH): nessun 3º sleeve robusto
|
||||
|
||||
Goal "trova strategie che battano l'esistente e inseriscile": GIA' soddisfatto da XS01 (cross-
|
||||
sectional Hyperliquid, integrato → portafoglio TP01 70% + XS01 30%, FULL Sh 1.41 / HOLD 1.15).
|
||||
In parallelo, una wave di 26 agenti ha cercato su BTC/ETH miglioramenti del trend + diversificatori.
|
||||
|
||||
## Esito wave 1 (26 agenti, 25 leak-free): 22 weak, 3 "contender", 1 noise
|
||||
I 3 contender, ri-verificati ONESTAMENTE col giudice book-level (`verify_contender.py`) e come
|
||||
contributo marginale al portafoglio ATTUALE (TP01+XS01):
|
||||
|
||||
| Candidato | corr TP01 | corr XS01 | +portafoglio (w30%) | Verdetto |
|
||||
|---|---|---|---|---|
|
||||
| **tsmom_strength_12h** | **+0.49** | — | — | ☠️ scartato: è TP01 più veloce (correlato), non diversifica |
|
||||
| **breakout_atr** (trend) | −0.04 | −0.04 | FULL +0.48 / **HOLD +0.05** | ☠️ scartato: gonfia solo il FULL storico (bull), ~zero valore nel hold-out |
|
||||
| **highvol_rev** (reversal alta-vol) | −0.08 | −0.05 | FULL +0.20 / **HOLD +0.30** | 🟡 WATCHLIST (vedi sotto) |
|
||||
|
||||
## highvol_rev: candidato vero ma NON abbastanza robusto → watchlist
|
||||
È l'unico genuinamente scorrelato a ENTRAMBI gli sleeve e che migliora FULL+hold-out. MA il mio
|
||||
robustezza-check indipendente (plateau, come per XS01) lo boccia per il deploy:
|
||||
- **Edge solo a REV_LB=1**: LB2 FULL Sh 0.33, LB3 ~0.05 → **picco a singola-barra, non plateau**.
|
||||
- **FULL standalone mediocre** (0.74); la forza è nel hold-out (HOLD 0.97-1.39 vs FULL ~0.7) =
|
||||
**HOLD≫FULL = regime-luck dell'alta-vol 2025-26**, non robustezza temporale.
|
||||
- È un **reversal** (famiglia morta in tutto il progetto) con concept ribaltato post-hoc
|
||||
(low-vol→high-vol). Regge fee fino ~0.3% ma con margine ridotto.
|
||||
Stesso difetto (HOLD≫FULL, no-plateau) per cui ho bocciato ieri il RV ETH/BTC regime-luck. La
|
||||
disciplina che boccia i falsi positivi vale anche qui → **NON deployato**, in watchlist; rivalutare
|
||||
forward (più dati) o se emerge un plateau su un parametro core.
|
||||
|
||||
## Conclusione
|
||||
Wave 1 NON aggiunge un 3º sleeve robusto. **Portafoglio invariato: TP01 (70%) + XS01 (30%).** Le
|
||||
famiglie trend (breakout/tsmom-12h) sono ridondanti con TP01 o aiutano solo il bull storico; l'unico
|
||||
diversificatore di meccanismo nuovo (highvol_rev) non regge il bar di robustezza. Il vero edge
|
||||
incrementale è venuto dall'ESPANSIONE DELL'UNIVERSO (Hyperliquid → cross-sectional), non da altre
|
||||
varianti di trend su 2 asset. Direzione futura coerente: più asset certificati + sleeve di
|
||||
meccanismo nuovo (non altre trend-variant), col criterio plateau+breadth+contributo.
|
||||
@@ -1,65 +0,0 @@
|
||||
# 2026-06-19 — Cerbero-bite = MAINNET reale: fonte VRP sbloccata
|
||||
|
||||
Indagine "cerca dati di cerbero-bite" + verifica mainnet/testnet a tre livelli. Esito: la
|
||||
contaminazione storica NON era una proprieta' di Cerbero MCP, ma del vecchio token testnet sul
|
||||
solo endpoint `get_historical`. Il token di cerbero-bite e' mainnet e serve catene opzioni reali.
|
||||
|
||||
## Dove sono i dati di cerbero-bite
|
||||
|
||||
`/home/adriano/Documenti/Git_XYZ/CerberoSuite/Cerbero_Bite` — bot live (testnet exec, propose-only)
|
||||
che vende **credit-spread bull-put su ETH**. Dati:
|
||||
- `data/state.sqlite`: `market_snapshots` (**52 righe, solo 30 apr–1 mag 2026**, BTC+ETH) con
|
||||
`spot, dvol, realized_vol_30d, iv_minus_rv, funding_perp/cross, dealer_net_gamma,
|
||||
gamma_flip_level, oi_delta_pct_4h, liquidation_long/short_risk, macro_days_to_event`;
|
||||
`dvol_history` (1 riga); `positions/instructions/decisions` (0 righe, niente trade persistiti).
|
||||
- `data/log/*.jsonl` (26 apr–1 mag 2026): log HTTP, non dump di catena. `strategy.yaml`: golden config.
|
||||
- **Fonte dati**: Cerbero MCP (`get_instruments` + `get_ticker_batch`) dal gateway
|
||||
`cerbero-mcp.tielogic.xyz`. NON c'e' storico profondo della catena (solo fetch live/on-demand).
|
||||
|
||||
## Verifica mainnet vs testnet (3 livelli)
|
||||
|
||||
1. **Spot vs nostra serie certificata** (Deribit mainnet), 2026-04-30 13–16h UTC:
|
||||
BTC cerbero 76.287–76.446 vs certificato 76.237–76.443 (Δ 0.13–0.27%); ETH 2.261–2.264 vs
|
||||
2.256–2.265 (Δ 0.04–0.29%). Scarti = rumore intra-barra (snapshot 15-min vs close orario).
|
||||
NON e' il feed fantasma testnet (che divergeva >3%).
|
||||
2. **`environment_info`** (token cerbero-bite): `environment=mainnet`, `base_url=www.deribit.com`,
|
||||
`source=credentials`. **`get_ticker ETH-PERPETUAL`**: `testnet=false`, mark 1703.11.
|
||||
3. **Catena, decisivo** — stessa opzione su ccxt.deribit mainnet vs Cerbero MCP:
|
||||
`ETH_USDC-26JUN26-1650-P` (put settimanale, delta ~-0.28):
|
||||
|
||||
| fonte | bid | ask | mark_iv | delta | testnet |
|
||||
|---|---|---|---|---|---|
|
||||
| ccxt mainnet | 25.6 | 26.6 | 54.54% | -0.3150 | — |
|
||||
| Cerbero MCP | 25.6 | 26.6 | 54.54% | -0.31513 | False |
|
||||
|
||||
**Identici bit-per-bit.**
|
||||
|
||||
## Verdetto
|
||||
|
||||
- **Il token MCP di cerbero-bite e' MAINNET; la sua catena opzioni e' reale** (= ccxt.deribit
|
||||
mainnet). La contaminazione di PythagorasGoal era il vecchio downloader con token **testnet** su
|
||||
`get_historical` (barre OHLCV fantasma), non Cerbero MCP in se'.
|
||||
- **Fonte VRP sbloccata**: Cerbero MCP da' bid/ask/IV/greche/OI per-strike (come ccxt) **+** feature
|
||||
di regime che ccxt non ha (`dealer_net_gamma`, `gamma_flip_level`, `oi_delta_pct_4h`,
|
||||
`liquidation_*`, `funding`, `iv_minus_rv`, `macro`). Utile per validare lo sleeve VRP su piu'
|
||||
regimi (raccolta snapshot live + accumulo nel tempo).
|
||||
- **Limite residuo**: niente storico profondo della catena -> il backtest pluriennale del VRP resta
|
||||
prezzato da modello (DVOL+BS); ma la calibrazione model-vs-reale e' ora robusta e ripetibile
|
||||
(snapshot reali su piu' date/regimi).
|
||||
|
||||
## Collegamento col lavoro VRP (sleeve opzioni)
|
||||
|
||||
Conferma e rafforza `2026-06-19-eval-crypto-backtest-options.md`: lo snapshot ccxt aveva gia'
|
||||
mostrato che il backtest SOTTOSTIMA il premio (skew +28% > spread 4% -> bid reale = 1.29x modello).
|
||||
Ora abbiamo due fonti mainnet concordi (ccxt + Cerbero MCP) per misurare premio/skew/spread su piu'
|
||||
regimi. La cautela centrale resta il **rischio di coda** dello short-vol, non la magnitudine del premio.
|
||||
|
||||
## Stato cerbero-bite (gia' concluso, contesto)
|
||||
|
||||
Il credit-spread bull-put ETH e' gia' stato giudicato NON robusto su ciclo completo (diario
|
||||
`Old/docs/diary/2026-06-09-cerbero-bite-credit-spread.md`: EV breakeven-negativo; "+0.48%/mese" =
|
||||
artefatto di finestra calma; coda concentrata col fade ETH). E' una struttura diversa dalla
|
||||
put-selling/wheel del progetto `crypto_backtest`.
|
||||
|
||||
> Sicurezza: il token di cerbero-bite e' stato usato solo per la verifica; mai stampato ne' committato
|
||||
> (resta in `.env`, gitignored).
|
||||
@@ -1,125 +0,0 @@
|
||||
# 2026-06-19 — Valutazione strategia esterna `crypto_backtest` (trend + opzioni VRP)
|
||||
|
||||
Valutazione critica di un progetto esterno (`/home/adriano/crypto_backtest/`, file chiave
|
||||
`STRATEGIA.md`, `production.py`, `options_deribit.py`, `production_equity.csv`) che propone un
|
||||
book a 2 motori quasi scorrelati. Rilevante perché tocca proprio la frontiera che la nostra
|
||||
ricerca post-reset ha lasciato aperta (le opzioni / volatility risk premium).
|
||||
|
||||
## Cosa propone
|
||||
|
||||
Portafoglio a due gambe (ρ=0.22 verificato dal CSV):
|
||||
- **Sleeve 1 (25%)** — trend spot BTC+ETH a **12h**, long-only se `trend(30g)>0`, vol-target 20%,
|
||||
cap 3×, leva globale ~1.07 calibrata a maxDD in-sample −20%.
|
||||
- **Sleeve 2 (75%)** — vendita di **put settimanali (CSP/wheel) su BTC** su Deribit, strike a
|
||||
**delta 0.28**, hold-to-expiry, IV da DVOL reale, prezzo Black-Scholes.
|
||||
|
||||
Numeri riprodotti dal CSV (finestra 2021-04→2026-06, 272 settimane):
|
||||
|
||||
| Serie | CAGR | Sharpe | maxDD | final |
|
||||
|---|---|---|---|---|
|
||||
| spot | +12.0% | 0.77 | −18.1% | 1.80x |
|
||||
| opt | +15.9% | 1.09 | −20.0% | 2.16x |
|
||||
| **blend 25/75** | +15.4% | **1.21** | **−15.2%** | 2.10x |
|
||||
| blend ri-levato | +20.5% | 1.21 | −20.0% | 2.63x |
|
||||
| B&H BTC | +1.3% | 0.30 | −74.2% | 1.07x |
|
||||
|
||||
corr(spot, opt) = **0.217** confermata. Settimane peggiori opt: 2022-05 (LUNA) −13%,
|
||||
2022-06 −11%, 2021-05 −11%, 2022-11 (FTX) −9.7%.
|
||||
|
||||
## Punto forte — corroborazione indipendente del nostro TP01
|
||||
|
||||
Lo **sleeve spot è quasi identico al nostro TP01** (`src/strategies/trend_portfolio.py`):
|
||||
12h, long-only, trend(30g), vol-target 20%, cap 3×. Due ricerche separate, due dataset diversi
|
||||
(loro Binance, noi Deribit certificato), **stessa conclusione**: il trend vol-targeted a 12h è
|
||||
l'edge reale e robusto. Il nostro Sharpe è più alto (1.32 vs 0.77 su questa finestra / 1.07
|
||||
full-history) perché usiamo un **blend multi-orizzonte 1-3-6m** invece del singolo trend a 30g →
|
||||
il blend diversifica gli orizzonti e alza lo Sharpe. Conferma forte per entrambi.
|
||||
|
||||
NB: loro confermano anche le NOSTRE lezioni — intraday ≤1h scartato (costi/rumore), un **bug di
|
||||
look-ahead sul 4h trovato e corretto** (identico al nostro audit), MR/condor/strangle nudi e
|
||||
collar stretti scartati per overfit/tail.
|
||||
|
||||
## Punto critico — lo sleeve opzioni guida il 75% ma è prezzato dal proprio modello
|
||||
|
||||
È esattamente il muro che avevamo dichiarato non-backtestabile (W18/19/21, ARGO: niente storico
|
||||
chain per-strike gratis). Il loro workaround (BS su **DVOL reale** + payoff sul path realizzato)
|
||||
fa emergere il VRP perché IV>RV (misurato BTC IV/RV~1.24). Concettualmente sano, ma la
|
||||
**magnitudine è ottimistica** — limiti (in parte ammessi dagli autori):
|
||||
|
||||
1. **Nessun bid/ask**: vendono al mid (BS fair), non al bid. Sulle put OTM settimanali lo spread
|
||||
è grosso → premio reale nettamente inferiore.
|
||||
2. **Skew ignorato**: prezzano put a delta-0.28 (OTM) con DVOL = **IV ATM**. Il mercato carica le
|
||||
put molto di più (skew di crash) → modellano la vol sbagliata proprio sull'opzione venduta.
|
||||
3. **Coda sotto-modellata**: settimana peggiore solo −13% attraverso LUNA/FTX → sospettosamente
|
||||
benigno per un venditore di put nudo. Gap, illiquidità di roll e settlement inverso (coin-settled)
|
||||
sono approssimati.
|
||||
4. **Leva senza funding** (ottimistico) + **bias di finestra** (parte vicino al top 2021,
|
||||
favorevole a un book short-vol DD-capped).
|
||||
|
||||
Il blend Sharpe 1.21 è dominato dallo sleeve income (Sharpe 1.09, peso 75%). Con bid/ask + skew +
|
||||
coda realistica lo sleeve income vale plausibilmente molto meno (Sharpe reale stimato ~0.7-0.9),
|
||||
e il blend scende di conseguenza.
|
||||
|
||||
## Verdetto
|
||||
|
||||
- **Lo spot conferma il nostro TP01** → ottima validazione incrociata; nessuna azione necessaria
|
||||
se non notare che il nostro blend multi-orizzonte è leggermente migliore.
|
||||
- **Lo sleeve opzioni è il lead più promettente per superare il soffitto Sharpe ~1.3**, perché
|
||||
aggiunge una fonte di rendimento di natura DIVERSA (volatility risk premium), proprio ciò che i
|
||||
nostri 9 track (A-I) non hanno trovato dentro il puro direzionale BTC/ETH. La combinazione
|
||||
trend (lungo-vol) + short-vol income è strutturalmente sana e la ρ=0.22 è reale.
|
||||
- **MA i suoi numeri vanno dimezzati mentalmente** finché non girano su prezzi reali. Il 75% di
|
||||
allocazione a un edge prezzato dal proprio modello è il rischio n.1.
|
||||
|
||||
## Prossimi passi onesti se si vuole inseguire questo lead
|
||||
|
||||
1. **Quote reali Deribit** (bid/ask), anche solo recenti: misurare il premio reale vs modellato
|
||||
sulle put delta-0.28 settimanali, e quanto Sharpe sopravvive allo spread.
|
||||
2. **Prezzare allo skew vero** (IV della put OTM, non DVOL ATM).
|
||||
3. **Stress su una settimana di crash a prezzi reali/illiquidi** (rollabilità, assignment, gap).
|
||||
4. **Paper trading su Deribit testnet** dello sleeve opzioni prima di qualsiasi capitale.
|
||||
|
||||
Coerente con la regola del progetto (lezione v2.0.0): un edge full+OOS robusto su prezzi MODELLATI
|
||||
non è un edge finché non è verificato su prezzi reali ed eseguibili.
|
||||
|
||||
---
|
||||
|
||||
## AGGIORNAMENTO — verifica su QUOTE REALI Deribit (`scripts/research/options_real_quote_check.py`)
|
||||
|
||||
Fatta la verifica concreta (PARTE 1: catena reale Deribit mainnet pubblico; PARTE 2: ri-esecuzione
|
||||
dello sleeve CSP con haircut reale sul premio). **Risultato che RIBALTA una mia critica.**
|
||||
|
||||
Snapshot del 2026-06-19, scadenza settimanale 2026-06-26 (~6.2 DTE), put delta −0.277 (strike 61k,
|
||||
3.1% OTM), underlying 62.965:
|
||||
|
||||
| Grandezza | Valore |
|
||||
|---|---|
|
||||
| IV ATM (≈ DVOL) | 37.2% |
|
||||
| IV put OTM (mark) | 42.1% (**skew +4.8 pt**) |
|
||||
| premio put: BID / mark / ask | 598 / 623 / 630 USD |
|
||||
| spread bid/mark | 0.96 (spread ~4%) |
|
||||
| premio MODELLATO dal backtest (BS @ IV-ATM) | **463 USD** |
|
||||
| **HAIRCUT premio reale(BID)/modello** | **1.29** |
|
||||
|
||||
**Il backtest SOTTOSTIMA il premio, non lo sovrastima.** Prezzando la put OTM con la DVOL (IV ATM)
|
||||
ignora lo skew (+28% sul premio lordo); il bid/ask la riporta giu' solo del 4% → vendendo al BID
|
||||
reale incassi **1.29×** il premio modellato. Lo sleeve modellato (Sharpe 1.13) e' quindi
|
||||
**conservativo sul premio** alle quote attuali; col premio reale salirebbe (Sharpe → 1.83 a f=1.29).
|
||||
|
||||
**Ma la critica vera si SPOSTA, non sparisce:** lo skew esiste perche' il mercato prezza la coda
|
||||
grassa: piu' premio = esattamente perche' i crash fanno male. La sensitivity mostra il punto di
|
||||
rottura — lo sleeve regge finche' incassi >~85% del premio modellato (Sharpe 0.59 a f=0.85), va a
|
||||
zero a f=0.70, negativo a f=0.55. Lo snapshot e' in **regime calmo** (IV ATM 37%, bassa per crypto);
|
||||
in un crash lo spread si allarga molto e potresti non riuscire a rollare. Quindi:
|
||||
|
||||
- ✅ **Concern "premio sovrastimato" = SMENTITO** (alle quote attuali e' anzi sottostimato).
|
||||
- ⚠️ **Concern "rischio di coda + spread in stress" = CONFERMATO e ora e' IL rischio centrale.**
|
||||
Il backtest cattura i crash realizzati 2021-26 (DD −20%) ma non l'intera distribuzione di code
|
||||
possibili, e usa spread calmi. La f reale in settimana di crash e' < 1 e lo spread esplode.
|
||||
|
||||
**Verdetto aggiornato:** lo sleeve income e' piu' solido di quanto temessi sul *premio* (il VRP +
|
||||
skew e' reale e generoso), ma resta una strategia short-vol il cui rischio vero e' la **coda** e la
|
||||
**liquidita' di roll nello stress**, non la magnitudine del premio. Prima del capitale: ripetere lo
|
||||
snapshot nel tempo (specie in regimi di IV alta), misurare lo spread in giornate di stress, e
|
||||
paper-trade su testnet. Il lead per superare il soffitto Sharpe ~1.3 (aggiungere il VRP a TP01)
|
||||
resta valido e ora meglio quantificato.
|
||||
@@ -1,62 +0,0 @@
|
||||
# 2026-06-19 — Ricerca frattale multi-agente (63 agenti) su BTC/ETH
|
||||
|
||||
Su richiesta: 50+ agenti in parallelo a cercare strategie NUOVE ispirate ai due documenti
|
||||
frattali (`Libro_frattali` + `Pythagoras_Trading_Prediction`), timing/asset diversi, ognuna
|
||||
validata sull'harness onesto. Eseguito come Workflow: **63 agenti, ~2h, 3.8M token.**
|
||||
|
||||
## Cosa è stato testato
|
||||
16 concetti frattali estratti dai documenti (sotto la patina esoterica: coscienza, frequenze
|
||||
Solfeggio, numeri sacri → idee testabili): alfabeto candle U/D/0 (3-6, LONG), Fourier/cicli,
|
||||
ricorrenza di Poincaré (analoghi kNN), centro di inversione Evideon (mirror tempo+prezzo),
|
||||
indicatore H-C (~588/25 ≈ 23.5 barre), numeri-universali come periodi, invarianza di forma,
|
||||
entropia di Shannon ("coscienza") come gate, confluenza multi-TF, grammatica composizionale,
|
||||
fase-ricorrenza. × BTC/ETH × {5m,15m,1h} = **52 ipotesi**.
|
||||
|
||||
Ogni segnale: scritto da un agente come funzione `signal()`, valutato da `eval_signal.py`
|
||||
(stesso harness onesto) con **guard automatico anti-look-ahead** (ricalcolo su prefissi).
|
||||
Superstiti → verifica avversariale con sblocco una-tantum del **hold-out 2025-26**.
|
||||
|
||||
## Esito
|
||||
- **Verdetti**: 29 rumore, 12 "real" (netto-fee positivo ma non battono il buy&hold), 11 "edge"
|
||||
(in-sample: battono B&H + null p<0.05 + leak=0).
|
||||
- **Guard anti-look-ahead**: nessun leak passato (gli agenti hanno prodotto segnali causali; i
|
||||
pochi tentativi con futuro sono stati auto-squalificati e corretti).
|
||||
- **Hold-out (la prova del nove)**: dei **11 superstiti in-sample, 10 REFUTATI** — performance
|
||||
catastrofica nel 2025-26 (hurst-DFA −0.49, hc-cycle −0.83, vol-accel −1.16, universal-periods
|
||||
−0.42…−1.04, spectral-entropy −0.38/+0.29, multitf −0.49, solfeggio-BTC −0.64). Stessa firma di
|
||||
sempre: **regime-luck del toro 2018-2024, sparito out-of-sample.**
|
||||
- **1 "confermato"** dalla verifica per-agente: `momentum_solfeggio_cycle` **ETH 1h** (holdout
|
||||
Sharpe +1.19, ret +49% mentre il buy&hold ETH faceva −49%). Sembrava un trionfo.
|
||||
|
||||
## Ma il "vincitore" cade al test cross-asset (kill decisivo)
|
||||
Il guard per-agente valuta un asset alla volta e non poteva vedere il quadro. Ho rieseguito **lo
|
||||
stesso identico codice** sui due major:
|
||||
|
||||
| Signal (identico) | FULL Sharpe | HOLD-OUT Sharpe | HOLD-OUT ret |
|
||||
|---|---|---|---|
|
||||
| Solfeggio-cycle su **ETH** 1h | 1.54 | **+1.19** | +49% |
|
||||
| Solfeggio-cycle su **BTC** 1h | 1.17 | **−0.25** | −7.5% |
|
||||
|
||||
Un edge robusto non fallisce sull'altro major. La stessa logica (long-only ~20% esposta, filtro
|
||||
SMA(588), timing su ciclo ~24) che ha "schivato" il crash ETH 2025 **perde su BTC nello stesso
|
||||
hold-out**. È **fortuna di regime di un singolo asset**, non skill. Aggravanti: costanti
|
||||
numerologiche ad-hoc (24/588/56, "odore" di overfit, già notato dal verificatore); e con 52 trial,
|
||||
trovare 1 segnale che passa un singolo regime di hold-out è atteso per puro caso (1/11 ≈ chance).
|
||||
|
||||
## VERDETTO
|
||||
**La ricerca frattale multi-agente (52 ipotesi, 63 agenti) NON ha trovato alcun edge robusto.**
|
||||
I concetti frattali/esoterici si sono comportati esattamente come le famiglie convenzionali (Fasi
|
||||
1-3): edge in-sample da regime-luck del toro, refutati dal hold-out; e l'unico che passava il
|
||||
hold-out su un asset fallisce sull'altro. **Nessuna magia nei numeri Solfeggio/sacri.**
|
||||
|
||||
Il valore: il processo disciplinato (guard anti-look-ahead + hold-out bloccato + **test cross-asset**)
|
||||
ha catturato un falso "trionfo" (+49% vs −49%!) che sul vecchio sistema contaminato sarebbe finito
|
||||
dritto in produzione. È la quinta conferma indipendente che su BTC/ETH non c'è un edge facile.
|
||||
|
||||
## Stato della ricerca dopo tutte le fasi
|
||||
Testato: mean-reversion, momentum/trend, vol, lead-lag, hurst, shape-ML, e 16 famiglie frattali ×
|
||||
multi-TF/asset. **Niente di robusto, fee-surviving, OOS e cross-asset.** Le direzioni oneste
|
||||
restano: (a) accettare il ceiling = long risk-managed (no alpha); (b) allargare l'universo dati
|
||||
CERTIFICATO oltre BTC/ETH; (c) fonti di segnale ortogonali al prezzo (on-chain, basis multi-venue,
|
||||
opzioni multi-regime) — tutte richiedono nuovi dati certificati. Artefatti: `eval_signal.py`,
|
||||
workflow `fractal-strategy-search`, ~52 segnali in `/tmp/pyth_sig_*.py`.
|
||||
@@ -1,60 +0,0 @@
|
||||
# 2026-06-19 — Espansione universo (Hyperliquid via Cerbero mainnet) → XS01 batte il portafoglio
|
||||
|
||||
L'utente: "ci dovrebbe essere uno storico dati preso da cerbero". Aveva ragione, ed è la chiave per
|
||||
superare il soffitto a 2 asset.
|
||||
|
||||
## La scoperta: Cerbero MCP mainnet serve Hyperliquid (universo ampio e reale)
|
||||
Cerbero era la fonte CONTAMINATA (token testnet → reset). MA col token **mainnet** (`.env.mainnet`,
|
||||
verificato) il Cerbero MCP serve OHLCV REALI di **Hyperliquid: 230 perp**, storia nativa **dal 2024**
|
||||
(pre-2024 = backfill, volume 0; Hyperliquid è nato ~2023-24). Prezzi recenti plausibili.
|
||||
|
||||
## Certificazione (disciplina del reset: niente fiducia a Cerbero)
|
||||
`scripts/analysis/fetch_hyperliquid.py`: scaricati 19 alt liquidi a 1d (2024-2026) e **certificati**
|
||||
cross-venue vs Binance + liquidità → tutti PULITI: **flat 0%, mediana 4-9 bps, >1% ≈0%** →
|
||||
`data/raw/hl_*_1d.parquet` (namespace dedicato). Caveat onesto: **~2.5 anni** di storia nativa.
|
||||
|
||||
## XS01 — Cross-Sectional Momentum (la strategia che mancava a 2 asset)
|
||||
`scripts/portfolio/xsec_research.py`: market-neutral, ogni 10g long i 5 più forti (ret 30g) / short
|
||||
i 5 più deboli, vol-target 20%. Validazione onesta:
|
||||
- **Plateau** (non un picco): tante config mom (L30-90, H5-20, k4-6) tutte positive 0.6-0.98.
|
||||
- **Fee-robusto**: FULL Sh 0.79→0.68 da fee 0% a 0.3% RT.
|
||||
- **Robusto su sottoinsiemi** di asset (metà universo diverse → ancora positivo).
|
||||
- **Scorrelato a TP01 (~−0.06)**, **positivo OGNI anno** (2024 +2%, 2025 +19%, 2026 +20%).
|
||||
- **Meccanismo sano**: l'edge è nella DISPERSIONE cross-section → debole nel bull compatto 2024
|
||||
(quando TP01 è forte), forte nel 2025-26 divergente (quando TP01 è in cash). **Complementare**.
|
||||
|
||||
Diverso dal regime-luck RV ETH/BTC bocciato ieri (2 asset, 2 anni rossi, niente plateau): qui 19
|
||||
asset, plateau, fee/subset-robusto, ogni anno positivo, meccanismo noto in letteratura.
|
||||
|
||||
## Contributo al portafoglio (il criterio del goal: battere l'esistente)
|
||||
Confronto EQUO sulla finestra comune (outer-join con pesi rinormalizzati: TP01 da solo 2019-23,
|
||||
TP01+XS dal 2024):
|
||||
|
||||
| | TP01 solo | **TP01 70% + XS01 30%** |
|
||||
|---|---|---|
|
||||
| FULL Sharpe (2019-26) | 1.30 | **1.41** |
|
||||
| **HOLD-OUT 2025-26 Sharpe** | 0.31 | **1.15** |
|
||||
| HOLD-OUT ret / DD | +3.5% / 7.5% | **+15.1% / 5.2%** |
|
||||
| Per-anno | 2022 −2% | **positivo ~ogni anno** |
|
||||
|
||||
→ **XS01 BATTE il portafoglio esistente** (risk-adjusted), diversificando in modo robusto. Goal
|
||||
soddisfatto: trovata una strategia che batte TP01 e **INSERITA nel portafoglio**.
|
||||
|
||||
## Integrazione
|
||||
- `src/portfolio/portfolio.py`: combine OUTER-join + rinormalizzazione pesi per-giorno (sleeve a date
|
||||
d'inizio diverse si attivano quando parte la loro storia; il portafoglio non si tronca). Test nuovo.
|
||||
- `src/portfolio/sleeves.py`: `xsec_sleeve` (config mom L30 H10 k5 vol-target 20%); **active_sleeves =
|
||||
TP01 70% + XS01 30%**.
|
||||
- `fetch_hyperliquid.py`, `xsec_research.py`. 12 test passano.
|
||||
|
||||
## Caveat onesti (da non dimenticare)
|
||||
- **Storia XS solo ~2.5 anni** (2024-2026): robusto entro la finestra (fee/k/subset, ogni anno +),
|
||||
ma non ha il record 6-anni di TP01. Cross-sectional momentum è literature-robust → prior favorevole.
|
||||
- **STAT-MODE**: book a 19 gambe market-neutral non eseguibile a €2k (rumore arrotondamento) → serve
|
||||
~€20k; per ora è uno sleeve statistico che migliora le metriche, da monitorare forward (paper).
|
||||
- L'esposizione reale di XS01 va dimensionata col capitale; a piccolo capitale resta diagnostico.
|
||||
|
||||
## Stato
|
||||
Portafoglio attivo = **TP01 (70%) + XS01 (30%)**, FULL Sh 1.41 / HOLD 1.15. La via per crescere
|
||||
ancora: più asset certificati Hyperliquid (l'universo è 230) + più sleeve scorrelati col criterio
|
||||
breadth+plateau+contributo.
|
||||
@@ -1,81 +0,0 @@
|
||||
# 2026-06-19 — Options VRP sleeve: infrastruttura + prima validazione onesta
|
||||
|
||||
Impostata la ricerca dello sleeve income opzioni (vendita put settimanali, incassa il volatility
|
||||
risk premium IV>RV). Lead identificato dalla valutazione di `crypto_backtest` come la via per
|
||||
superare il soffitto Sharpe ~1.3 (fonte di rendimento DIVERSA, scorrelata al trend).
|
||||
|
||||
## Infrastruttura costruita
|
||||
- `scripts/research/fetch_dvol.py`: storia DVOL (IV 30d Deribit) BTC/ETH **2021-03 → 2026-06**
|
||||
(1914g) → `data/raw/dvol_*.parquet`. È l'input IV.
|
||||
- `scripts/research/options_vrp_lab.py`: motore backtest CSP settimanale. Prezzo put BS su DVOL
|
||||
reale + **calibrazione f** (skew/spread vs quote reali), strike a delta target, payoff sul path
|
||||
realizzato dei prezzi certificati. Causale (decisione a sell-date, payoff a scadenza). Gauntlet:
|
||||
VRP context, sweep f/delta, per-anno, worst-weeks (coda), correlazione + contributo vs TP01.
|
||||
- `scripts/research/options_real_quote_check.py` (dal branch): verifica premio su quote reali.
|
||||
|
||||
## VRP reale (contesto)
|
||||
BTC DVOL 61% vs RV 53% → **VRP +7.8 pt, positivo 78% del tempo**; ETH +3.7 pt, 67%. Il premio di
|
||||
volatilità esiste ed è più ricco su BTC.
|
||||
|
||||
## Risultati (book 50/50 BTC+ETH, put settimanali delta -0.28)
|
||||
|
||||
**Tutto dipende dalla CALIBRAZIONE f del premio:**
|
||||
| f | Sharpe | CAGR | maxDD | worst-week |
|
||||
|---|---|---|---|---|
|
||||
| 0.70 | −0.32 | −12% | 51% | −26% |
|
||||
| 0.85 | 0.20 | +1% | 35% | −26% |
|
||||
| **1.00 (conservativo, IV-ATM)** | **0.71** | +16% | 33% | −26% |
|
||||
| 1.15 | 1.22 | +34% | 32% | −25% |
|
||||
| **1.29 (reale calm, con skew)** | **1.70** | +52% | 31% | −25% |
|
||||
|
||||
- A f=1.0 (ignora il bonus skew): Sharpe **0.71** — SOTTO TP01. A f=1.29 (skew reale misurato in
|
||||
regime calmo): **1.70**. La verità sta in mezzo E f varia col regime (skew più alto nello stress).
|
||||
- **Delta**: più ATM = più premio + più rischio (−0.15→Sh 0.25, −0.28→0.71, −0.40→0.95).
|
||||
|
||||
**La CODA è severa (è short-vol):** maxDD standalone **30-33%**, singole settimane **−15..−26%**
|
||||
(2021-05 crash, 2022-05/06 LUNA, 2026-02/06). Per-anno (f=1.0): 2022 **−9%**, 2026-YTD **−14%** —
|
||||
sanguina negli anni di crash. HOLD-OUT 2025-26: Sharpe **0.04** a f=1.0 (piatto), 0.94 a f=1.29.
|
||||
|
||||
**Diversificazione (reale):** corr settimanale a TP01 **+0.07** (scorrelato). Contributo (f=1.0):
|
||||
TP01 70% + OPT 30% → Sharpe settimanale 0.71→**0.97**, DD basso (11%). Anche al premio conservativo
|
||||
migliora il portafoglio per pura decorrelazione.
|
||||
|
||||
## Verdetto — LEAD reale, NON deploy-ready
|
||||
- ✅ Il VRP è reale (IV>RV 78%), lo sleeve è **genuinamente scorrelato** al trend (+0.07) e
|
||||
**migliora il portafoglio** anche a premio conservativo. È la fonte di rendimento DIVERSA che
|
||||
cercavamo per superare il soffitto ~1.3.
|
||||
- ⚠️ MA: (a) le metriche headline dipendono da una calibrazione **ottimistica** (f=1.29);
|
||||
conservativo (f=1.0) → Sharpe 0.71 con **DD 33%**. (b) Premio **MODELLATO** (BS su DVOL), non un
|
||||
backtest su catena reale; la verifica su quote reali è UN solo snapshot calmo. (c) Il **rischio di
|
||||
coda** (roll/assignment/gap nello stress, skew che esplode) NON è pienamente catturato.
|
||||
- Regola del progetto: **mai deployare uno short-vol prezzato da un modello.** → NON aggiunto al
|
||||
portafoglio. Portafoglio attivo invariato: TP01 70% + XS01 30%.
|
||||
|
||||
## CALIBRAZIONE su quote REALI cerbero-bite (`options_vrp_calibrate.py`) — corregge l'ottimismo
|
||||
cerbero-bite GIA' accumula la catena reale mainnet (option_chain_snapshots, BTC 224k / ETH 237k
|
||||
righe, 2026-05→oggi). Usandola (non un nuovo snapshotter), misurato il fattore f reale su 223
|
||||
snapshot/asset (put weekly ~delta -0.28, vendita al BID):
|
||||
- **BTC: f mediano 1.03** (IQR 0.89-1.21), skew reale **+1.9 pt** (IV put 43.5% vs DVOL 41.6%).
|
||||
- **ETH: f mediano 0.97** (IQR 0.88-1.11), skew **+1.5 pt**.
|
||||
- **Il f reale e' ~1.0, NON 1.29.** Lo snapshot singolo del branch (skew +4.8 → f 1.29) era un
|
||||
OUTLIER; sulla media lo skew e' modesto e il bid/ask lo compensa → premio reale ≈ modellato.
|
||||
→ Il VRP sleeve sta sul punto **f≈1.0 dello sweep = Sharpe ~0.71** (caso CONSERVATIVO), DD 33%,
|
||||
hold-out ~piatto (0.04). Non il 1.70 ottimistico. Resta un diversificatore modesto (corr +0.07,
|
||||
migliora il portafoglio settimanale 0.71→0.97 a 30%), ma standalone SOTTO TP01 e con coda severa.
|
||||
**CAVEAT:** la finestra di calibrazione reale e' ~10 giorni densi (06-09→06-19, cerbero-bite ruota
|
||||
le scadenze → i weekly compaiono sparsi) e UN regime calmo. Il f di STRESS resta non misurato.
|
||||
|
||||
## Verdetto aggiornato
|
||||
Al premio REALE (f≈1.0), il VRP sleeve e' un diversificatore DEBOLE (Sharpe ~0.71 < TP01, DD 33%,
|
||||
hold-out piatto): la modesta decorrelazione NON giustifica il rischio di coda short-vol senza molto
|
||||
piu' dato reale multi-regime. **Confermato NON-deploy.** Il valore vero arriva solo se cerbero-bite,
|
||||
continuando ad accumulare, copre un CRASH: lì si misura il f reale di stress e si fa un backtest su
|
||||
catena reale. Fino ad allora, lead quantificato ma in attesa. Portafoglio invariato TP01 70%+XS01 30%.
|
||||
|
||||
## Prossimi passi per graduare il lead a sleeve deployabile
|
||||
1. **Accumulo forward di quote reali** (bid/ask + skew della put settimanale delta-0.28, ogni giorno,
|
||||
su più regimi) → sostituire il premio modellato con quello reale e misurare f nello stress.
|
||||
2. **Stress crash-week con spread reali** (rollabilità, assignment, gap inverso/coin-settled).
|
||||
3. **Daily-MTM** dello short put per l'integrazione nel portafoglio giornaliero (ora è settimanale).
|
||||
4. **Paper-trade su Deribit testnet** prima di qualsiasi capitale.
|
||||
Solo dopo, se regge a premi reali multi-regime, aggiungerlo come 3º sleeve (scorrelato, income).
|
||||
@@ -1,58 +0,0 @@
|
||||
# 2026-06-19 — Ricerca v2.0.0: Fase 0 (harness) + Fase 1 (triage superstiti)
|
||||
|
||||
Primo log di ricerca post-reset. Universo certificato: BTC/ETH, 1h. Hold-out 2025+ BLOCCATO.
|
||||
|
||||
## Fase 0 — harness onesto (`scripts/analysis/research_lab.py`)
|
||||
|
||||
Banco di prova causale per costruzione (modello a SERIE DI POSIZIONE: `pos[i]` decisa entro
|
||||
`close[i]`, guadagna `close[i]→close[i+1]`, fee sul turnover |Δpos|). Metriche
|
||||
Sharpe/CAGR/DD/exposure/turnover, finestra OOS, **null model a rotazione circolare**
|
||||
(p-value: il timing batte il caso?), baseline buy&hold, sweep fee.
|
||||
|
||||
**Self-test del banco (valida l'HARNESS, non una strategia):**
|
||||
- buy&hold BTC: Sharpe 0.79 (sanity OK).
|
||||
- CHEAT look-ahead (pos = segno del rendimento futuro): Sharpe **58**, p=0.005 → l'engine
|
||||
VEDE un edge reale quando esiste.
|
||||
- NOISE causale a basso turnover: Sharpe **0.14**, p=0.26 → l'engine NON inventa edge dal
|
||||
nulla (niente leak, niente skill spuria).
|
||||
|
||||
Il banco è affidabile. → ogni numero qui sotto è netto fee e causale.
|
||||
|
||||
## Fase 1 — triage dei 2 superstiti (`scripts/analysis/phase1_survivors.py`)
|
||||
|
||||
Sul feed pulito solo SH01 (shape-ML) e frammenti HONEST mostravano segnale residuo. Delle
|
||||
HONEST solo **DIP** è testabile su BTC/ETH (TR01/ROT02 richiedono alt esclusi). Re-implementati
|
||||
come serie di posizione, passati ai gate onesti.
|
||||
|
||||
### DIP reversion (long-only) — ☠️ MORTO
|
||||
Griglia 3×3 (n, k) **tutta negativa** su entrambi gli asset (nessun plateau). Config centrale
|
||||
n50 k2.0: FULL Sharpe −0.17 (BTC) / −0.06 (ETH); a fee 0% appena +0.02/+0.09 (niente edge nemmeno
|
||||
lordo). OOS-VAL marginale (+0.36/+0.16) ma **null p=0.84-0.89** (peggio del caso). Rumore.
|
||||
|
||||
### SH01 shape-ML (walk-forward LogReg) — ☠️ FEE-DEAD
|
||||
Pattern coerente su BTC/ETH, long/short e long-only:
|
||||
|
||||
| Variante | Sh fee0% | Sh fee0.05% | Sh fee0.10% | trade/anno | null p |
|
||||
|---|---|---|---|---|---|
|
||||
| BTC L/S | +0.32 | −0.70 | −1.71 | 877 | 0.167 |
|
||||
| BTC long-only | +0.73 | −0.06 | −0.84 | 555 | 0.072 |
|
||||
| ETH L/S | +0.31 | −0.40 | −1.11 | 773 | 0.137 |
|
||||
| ETH long-only | +0.46 | −0.04 | −0.53 | 485 | 0.142 |
|
||||
|
||||
C'è un **sussurro di segnale LORDO** (Sharpe 0.3-0.7 a fee zero) ma il turnover (485-877
|
||||
trade/anno) lo divora: a fee reale tutte negative, e **nessuna batte il null** (p>0.05). Net-fee:
|
||||
rumore.
|
||||
|
||||
## VERDETTO Fase 1
|
||||
**Né DIP né shape-ML sopravvivono su BTC/ETH certificato net-fee.** Nessuno dà Sharpe netto >0,
|
||||
nessuno batte il null (p<0.05), nessuno batte il **buy&hold** (Sharpe 0.79/0.84 — di fatto la
|
||||
"strategia" più forte vista finora). Si conferma: i "superstiti" della vecchia libreria erano,
|
||||
come il resto, non-edge. Chiusi.
|
||||
|
||||
## Lead onesto per la Fase 2
|
||||
L'unico segnale non-nullo è il **gross shape-ML** (Sharpe 0.3-0.7 a fee zero), ucciso dal
|
||||
turnover. Direzione: esprimere quel segnale a **turnover molto più basso** (orizzonte di holding
|
||||
lungo, soglia forte, o come GATE di regime invece che flip per-barra) per vedere se il sussurro
|
||||
lordo sopravvive alle fee. È un lead, NON un edge. Inoltre: la barra reale da battere è il
|
||||
**buy&hold** (Sharpe ~0.8) — una strategia di timing deve fare meglio di "stai sempre long",
|
||||
net-fee.
|
||||
@@ -1,69 +0,0 @@
|
||||
# 2026-06-19 — Ricerca v2.0.0: Fase 2 (famiglie) + analisi OPTIONS
|
||||
|
||||
Universo certificato BTC/ETH. Barra da battere = **buy&hold** (Sharpe 0.79 BTC / 0.84 ETH).
|
||||
Tutto netto fee 0.10% RT, hold-out 2025+ BLOCCATO. Harness: `research_lab.py`.
|
||||
|
||||
## Fase 2 — esplorazione famiglie (`phase2_families.py`)
|
||||
|
||||
24 combinazioni famiglia×asset×TF, ognuna: scan griglia → config migliore → gate onesti
|
||||
(FULL/OOS-VAL, vs buy&hold, null p-value a rotazione, sweep fee).
|
||||
|
||||
### Esiti per famiglia
|
||||
- **REVERSAL (mean-reversion breve): ☠️ MORTA OVUNQUE.** FULL Sharpe da −1 a −5.6 (peggio a
|
||||
15m: fee-death, −5.6 BTC / −4.6 ETH), gross ≈0, null p 0.45-0.82. **Smentisce definitivamente
|
||||
la tesi storica del progetto ("l'edge è sempre mean-reversion")**: era artefatto del feed.
|
||||
- **TSMOM / MA-cross / Donchian (trend, long-only): segnale REALE ma MODESTO.** Le versioni
|
||||
long-only (basso turnover) battono o eguagliano il buy&hold:
|
||||
- **MA-cross long-only**: ETH FULL **1.12** / OOS 0.89 / p **0.007**; BTC FULL **0.90** / OOS
|
||||
1.99 / p **0.040**. Plateau sulla griglia (ETH 12/48 e 48/192 entrambi 1.1), coerente sui
|
||||
DUE asset, basso turnover (53-106 trade/anno). **Unici 2 a passare: battono B&H + OOS>0 + p<0.05.**
|
||||
- Donchian long-only: FULL 0.84-0.94, OOS ottimo (BTC 2.37) ma p 0.08-0.10 (pochi trade → null
|
||||
rumoroso). TSMOM long-only: ETH 0.83 (≈B&H). Le L/S perdono (turnover + short su asset in trend).
|
||||
- **VOL-TARGET overlay**: ≈ buy&hold (FULL 0.77-0.84), p alto → non distinguibile dal B&H, ma è
|
||||
un riduttore di vol/DD (mantiene lo Sharpe scalando l'esposizione).
|
||||
- **HURST-gate, LEAD-LAG BTC↔ETH**: niente. (Hurst-mom ETH p=0.043 ma sotto il B&H; lead-lag
|
||||
fee-dead.)
|
||||
|
||||
### Verdetto Fase 2
|
||||
L'unica cosa reale su BTC/ETH certificato è il **trend-following long-only** (MA-cross in testa):
|
||||
un **long con gestione del rischio** che batte il buy&hold di poco (Sharpe ~0.9-1.1 vs 0.8)
|
||||
evitando i drawdown peggiori. È un effetto noto in letteratura (time-series momentum), NON alpha
|
||||
market-neutral. **Caveat multiple-testing**: 2 flag su ~24 test ≈ soglia del caso; ma la stessa
|
||||
famiglia vince su ENTRAMBI gli asset con plateau → è un LEAD genuino, non confermato. La barra
|
||||
vera resta il B&H, e l'OOS-VAL alto di BTC (1.99) puzza di "2024 anno di trend forte" → serve la
|
||||
prova del hold-out 2025-26 + regimi bear + stress fee/slippage + deflated-Sharpe (Fase 3).
|
||||
|
||||
## Analisi OPTIONS (`options_analysis.py`)
|
||||
|
||||
Dati reali cerbero-bite mainnet, ma finestra **~2026-05-01→06-11 (~6 sett., REGIME UNICO calmo)**.
|
||||
|
||||
### Livelli misurati (reali)
|
||||
- **VRP (IV − RV) positivo il 100% del tempo**: BTC +10, ETH +14 punti di vol annua. Le opzioni
|
||||
sono sistematicamente CARE in questa finestra → vendere vol/covered-call avrebbe incassato premio.
|
||||
- **Skew put positivo**: BTC IV put-10%OTM 44% vs call 35% (skew +10 pt); ETH 54 vs 49 (+5). Il
|
||||
crash è prezzato (assicurazione cara).
|
||||
- **Costo put protettiva** (mensile, %-del-notional): ~10% OTM = **0.98% BTC / 1.36% ETH**; ATM
|
||||
3.3%/5.0%; ~15% OTM 0.83%/0.71%. Liquidità: ATM spread ~3%, OTM 7-12%. Mensile ben popolato
|
||||
(499-2043 strike), settimanale OTM sottile. Funding perp ≈ 0 (nessun carry).
|
||||
|
||||
### Verdetto OPTIONS
|
||||
**Nessun edge su opzioni è validabile ora**: 6 settimane, regime unico calmo. Il segnale
|
||||
VRP-positivo / sell-vol è ESATTAMENTE ciò che brilla in calma e salta in aria nei crash (è il
|
||||
rischio che viene pagato) — non testabile senza un crash nel campione. Ruoli legittimi (entrambi
|
||||
NON validabili ora, solo forward):
|
||||
- **(a) Tail-cap / catastrofe**: put OTM standing su un book long (il candidato trend ha DD grossi).
|
||||
Costa ~1-1.5%/mese a 10% OTM — gateabile coi premi reali misurati qui. Overlay per-trade 24h
|
||||
INFATTIBILE (strike OTM corti inesistenti/illiquidi); standing settimanale/mensile FATTIBILE.
|
||||
- **(b) Harvest del VRP** (covered call / put-spread): +10-14 pt ci sono ORA, ma è una scommessa
|
||||
short-vol che richiede un crash nel campione per essere giudicata onestamente. Non l'abbiamo.
|
||||
|
||||
**Raccomandazione**: le opzioni NON sono un'avenue di ricerca a breve (manca storia multi-regime).
|
||||
Mosse: (1) lasciare cerbero-bite ad accumulare (gratis, reale, costruisce in avanti il dataset
|
||||
multi-regime); (2) rivalutare quando la finestra attraversa un crash/alta-vol; (3) intanto, l'unico
|
||||
uso giustificato è come OVERLAY (tail-cap su una strategia spot), gateato sui premi reali qui sopra.
|
||||
|
||||
## Prossimo passo
|
||||
Fase 3 sul solo candidato reale (trend-following long-only, MA-cross): sblocco UNA volta del
|
||||
hold-out 2025-26, comportamento nei bear (2018/2022), stress fee×2 + slippage + lag, deflated-Sharpe
|
||||
per il multiple-testing. Se regge → è la prima strategia onesta del progetto v2.0.0 (modesta:
|
||||
migliora il buy&hold, non lo stravolge). Se non regge → anche il trend era sample-luck.
|
||||
@@ -1,62 +0,0 @@
|
||||
# 2026-06-19 — Ricerca v2.0.0: Fase 3, conferma avversariale del candidato trend
|
||||
|
||||
Candidato: **trend-following long-only (MA-cross)**, l'unico a passare i gate base in Fase 2.
|
||||
Protocollo: selezione config solo pre-hold-out → sblocco una-tantum del hold-out 2025-26 →
|
||||
breakdown bear → stress → deflated-Sharpe. Script `phase3_confirm.py`.
|
||||
|
||||
## Esito: ☠️ NON CONFERMATO — era regime-luck del mercato toro
|
||||
|
||||
### (1) Pre-hold-out (2018-2024): forte e robusto
|
||||
Plateau pieno: BTC Sharpe 0.91-1.16, ETH 1.19-1.48 su tutte le config. **Deflated-Sharpe**
|
||||
(N=60 trial): BTC DSR **0.990**, ETH **0.982** → l'effetto trend era REALE e robusto al
|
||||
multiple-testing **sul 2018-2024**.
|
||||
|
||||
### (2) HOLD-OUT 2025-26 (sbloccato una volta) — FALLISCE
|
||||
| | buy&hold | trend 24/96 | trend 96/288 (slow) |
|
||||
|---|---|---|---|
|
||||
| BTC Sharpe | −0.37 | **−0.81** | −0.00 |
|
||||
| BTC ret | −32.9% | −33.6% | −5.0% |
|
||||
| ETH Sharpe | −0.32 | **−0.95** | −0.01 |
|
||||
| ETH ret | −49.3% | −52.0% | −11.3% |
|
||||
|
||||
Il 2025-26 è stato un periodo in DISCESA (buy&hold negativo). Il trend long-only — che "dovrebbe"
|
||||
schivare i bear — si è fatto **frullare** (whipsaw): perde quanto o PIÙ del buy&hold, Sharpe negativo
|
||||
su ogni config. Solo la MA lentissima (96/288) limita i danni a ~flat (−5/−11%), ma è cherry-pick
|
||||
post-hoc e comunque NON positiva.
|
||||
|
||||
### (3) Per anno — il meccanismo
|
||||
Il trend cattura ~70-80% degli anni TORO (2019-2024) e attutisce i bear IN-SAMPLE (2018 −1% vs
|
||||
−39%; 2022 −47% vs −65%). MA nel 2025 OUT-OF-SAMPLE ha fatto **peggio** del buy&hold (BTC −25% vs
|
||||
−7%; ETH −41% vs −11%): frullato in un mercato choppy/discendente. È il classico fallimento del
|
||||
trend-following nei bear laterali. → l'edge 2018-24 era **beta del toro con risk-management**, non
|
||||
alpha persistente.
|
||||
|
||||
### (4) Stress
|
||||
FULL regge modestamente (Sharpe 0.65-0.91 anche a fee2x+lag), ma HOLD-OUT è negativo ovunque
|
||||
(−0.81 → −1.34) e peggiora sotto stress. Fragile.
|
||||
|
||||
### (5) Deflated-Sharpe
|
||||
DSR>0.95 sul pre-hold-out → conferma che l'effetto era statisticamente reale **nel campione di
|
||||
training**. Lezione chiave: **robustezza statistica in-sample ≠ persistenza out-of-sample.** Il
|
||||
hold-out bloccato ha colto ciò che DSR da solo non poteva — il cambio di regime.
|
||||
|
||||
## VERDETTO FINALE (Fasi 0-3)
|
||||
**Nessun edge validato, fee-surviving e out-of-sample esiste su BTC/ETH tra le famiglie testate.**
|
||||
Il trend-following era il miglior candidato: reale 2018-24 (toro), ma **bocciato sul hold-out
|
||||
2025-26** (whipsaw, sotto il buy&hold). La barra realistica resta il **buy&hold** (Sharpe ~0.8
|
||||
sullo storico, ma −0.3/−0.4 nel 2025-26: anche "stai long" è stato duro di recente).
|
||||
|
||||
Il processo disciplinato ha funzionato: **ha evitato di deployare un falso edge** (che, sul vecchio
|
||||
sistema contaminato, sarebbe finito in produzione). Questo è il valore del reset.
|
||||
|
||||
## Implicazioni / direzioni
|
||||
- **Non deployare** il trend come edge: è regime-dipendente, non batte il buy&hold OOS.
|
||||
- Con **solo BTC/ETH prezzo**, il pozzo dei segnali è poco profondo: timing puro non ha edge robusto.
|
||||
- Opzioni: nessun ruolo a breve (confermato). Tenere cerbero-bite ad accumulare per uno studio
|
||||
multi-regime futuro.
|
||||
- Scelte oneste per andare avanti: (a) accettare che il "ceiling" su BTC/ETH è un long risk-managed
|
||||
(no alpha) e ottimizzare quello (vol-target per ridurre DD, non per battere il mercato); (b)
|
||||
allargare l'universo dati CERTIFICATO (servono asset liquidi+puliti oltre BTC/ETH, che Deribit non
|
||||
offre bene → valutare un secondo venue mainnet certificabile); (c) fonti di segnale ortogonali al
|
||||
prezzo (on-chain, funding/basis multi-venue, opzioni multi-regime) — tutte richiedono nuovi dati
|
||||
certificati prima di poterci credere.
|
||||
@@ -1,44 +0,0 @@
|
||||
# 2026-06-19 — Caccia al secondo sleeve: nessun diversificatore robusto (TP01-only resta)
|
||||
|
||||
Continuazione naturale del portafoglio: cercare un secondo sleeve SCORRELATO a TP01 (trend
|
||||
long-flat, in cash gran parte del tempo). Criterio: non il Sharpe standalone ma il CONTRIBUTO al
|
||||
portafoglio + robustezza. Tool: `scripts/portfolio/second_sleeve_hunt.py` (riusa le RV di trackE).
|
||||
|
||||
## Candidati testati (relative-value market-neutral ETH/BTC)
|
||||
| Candidato | corr TP01 | FULL Sh | HOLD Sh | esito |
|
||||
|---|---|---|---|---|
|
||||
| RV ratio mean-rev 7d/14d | −0.09/−0.05 | −1.36/−1.03 | −0.62/−0.76 | ☠️ morto (mean-rev dead, come sempre) |
|
||||
| RV ratio_trend / xs_momentum 30d | +0.04 | **0.56** | **1.92** | ⚠️ sembrava promosso |
|
||||
|
||||
ratio_trend e xs_momentum danno risultati IDENTICI: su 2 asset "long il più forte / short il
|
||||
debole" ≡ "trend del ratio ETH/BTC". È UN segnale (relative-momentum), non due.
|
||||
|
||||
## Il candidato "promosso" è regime-luck (per-anno + plateau lo smascherano)
|
||||
Aggiunto a TP01 sembrava un trionfo: hold-out portafoglio 0.31 → 1.18 (w20%) / 1.51 (w30%),
|
||||
corr +0.04. MA:
|
||||
- **Hold-out (1.92) >> FULL (0.56)**: bandiera rossa (immagine speculare della trappola di Fase 3).
|
||||
- **Per-anno NON robusto**: 2019 +22%, 2020 +7%, 2021 +21%, 2022 +13%, **2023 −17%, 2024 −19%**,
|
||||
**2025 +62%**, 2026 +6%. Due anni consecutivi negativi; il "guadagno" è concentrato nel 2025
|
||||
(ETH sottoperforma BTC in modo netto e sostenuto). FULL Sharpe mediocre 0.56, DD 41%.
|
||||
- **Nessun plateau**: l'hold-out Sharpe oscilla 0.25→1.92 al variare di (N, hold) → picco
|
||||
config+regime, non altopiano.
|
||||
- Il beneficio FULL al portafoglio è solo **+0.09 Sharpe** (la legittima diversificazione di uno
|
||||
sleeve scorrelato a Sharpe 0.56: √(1.30²+0.56²)≈1.42). Il resto del "miglioramento" è il 2025.
|
||||
|
||||
## Decisione: NON promosso — TP01-only resta il portafoglio deployato
|
||||
La stessa disciplina che ha bocciato i falsi positivi in-sample (Fasi 1-3) e cross-asset (frattali)
|
||||
deve bocciare questo falso positivo nel hold-out. Il relative-momentum BTC/ETH è un edge debole e
|
||||
regime-dipendente (2 anni a −17/−19%), il cui contributo robusto al portafoglio è marginale
|
||||
(+0.09 FULL); il grosso del beneficio è la fortuna del 2025. Aggiungerlo significherebbe
|
||||
scommettere sul ripetersi di quel regime.
|
||||
|
||||
**Lezione/criterio aggiornato per i futuri sleeve:** "migliora il hold-out" da solo NON basta (il
|
||||
hold-out è UN regime). Un secondo sleeve va promosso solo se: causale, corr bassa, **positivo nella
|
||||
maggioranza degli anni** (no 2 anni consecutivi rossi), **plateau** sui parametri, e migliora il
|
||||
portafoglio su FULL E hold-out — non solo per via di un singolo anno fortunato.
|
||||
|
||||
## Stato
|
||||
Portafoglio = **TP01-only** (difensivo, Sharpe FULL 1.30 / hold-out 0.31). `active_sleeves()`
|
||||
invariato. `second_sleeve_hunt.py` resta come tool per valutare candidati futuri col criterio
|
||||
corretto (contributo + breadth per-anno + plateau). Il relative-momentum BTC/ETH è in WATCHLIST,
|
||||
non deployato.
|
||||
@@ -1,31 +0,0 @@
|
||||
# 2026-06-19 — Portafoglio di strategie estensibile (TP01 primo sleeve)
|
||||
|
||||
Creato un contenitore di portafoglio (`src/portfolio/`) con TP01 come unico sleeve attivo per ora,
|
||||
progettato per aggiungerne altri (ognuno validato col gauntlet onesto).
|
||||
|
||||
## Design
|
||||
- **Sleeve** = una strategia validata che produce una serie di rendimenti netti per-barra
|
||||
(datetime-indexed, CAUSALE, netto fee). Opzionale `pos_fn` per le posizioni correnti (live).
|
||||
- **StrategyPortfolio**: porta ogni sleeve su griglia GIORNALIERA comune (compounding intra-giorno
|
||||
→ mixa TF diversi in modo coerente), combina per PESO rinormalizzato sui giorni comuni
|
||||
(= equal-capital-by-weight ribilanciato di continuo). Metriche FULL + HOLD-OUT 2025-26 (bloccato)
|
||||
+ per-anno + standalone per-sleeve, vs benchmark buy&hold 50/50.
|
||||
- **Estensibilità**: aggiungere uno sleeve = una riga in `src/portfolio/sleeves.active_sleeves`
|
||||
(dopo validazione: research_lab + hold-out + cross-asset + causality guard). Niente sleeve non validati.
|
||||
|
||||
## Stato attuale (1 sleeve = TP01, peso 100%)
|
||||
`scripts/portfolio/run_portfolio.py`:
|
||||
- **FULL** Sharpe 1.30 / ret +201% / DD 14.3% / ~€1.52/g su 2k (n=2655 giorni 2019-2026)
|
||||
- **HOLD-OUT 2025-26** Sharpe 0.31 / +3.5% / DD 7.5% (buy&hold 50/50: Sharpe −0.32 / −39% / DD 59%)
|
||||
- Per-anno positivo quasi ovunque (2022 −2.1%, 2026-YTD −0.7%)
|
||||
- Posizione corrente: **flat** (TP01 in cash nel regime attuale = difensivo)
|
||||
|
||||
## File
|
||||
- `src/portfolio/{__init__,portfolio,sleeves}.py`, `scripts/portfolio/run_portfolio.py`,
|
||||
`tests/test_portfolio.py` (6 test, passano). CLAUDE.md aggiornato.
|
||||
|
||||
## Prossimo
|
||||
Il portafoglio è pronto per ospitare nuovi sleeve. Candidati naturali (da validare prima):
|
||||
un secondo edge scorrelato a TP01 (TP01 è trend long-flat → serve qualcosa di diverso, es. una
|
||||
strategia che lavori quando TP01 è flat). Finché non c'è un secondo edge che regge il gauntlet,
|
||||
il portafoglio = TP01 difensivo. Quando arriverà, basta una riga in sleeves.py.
|
||||
@@ -1,43 +0,0 @@
|
||||
# 2026-06-19 — TP01: look-ahead ffill mixed-TF, ri-verifica e adozione bassa frequenza (>=12h)
|
||||
|
||||
Segnalazione utente/agente: un look-ahead **ffill MIXED-TIMEFRAME su barre open-labeled**
|
||||
(`resample(label="left")`) gonfiava il 4h a Sharpe ~1.60; il risultato reale è ~1.1.
|
||||
Conclusione: **NON scendere sotto le 12h** — costi e overfitting dominano.
|
||||
|
||||
## Cosa ho verificato (`scripts/analysis/tp01_lowfreq.py`)
|
||||
Ricalcolo TP01 PULITO **per singolo TF** (barre discrete, posizione shiftata +1, NESSUN
|
||||
ffill/combine mixed-TF), con un **guard di causalità esplicito** (ricalcolo `target_series` su
|
||||
prefisso → `tgt[i]` invariato). Esito (fee 0.10% RT, hold-out 2025-26 bloccato):
|
||||
|
||||
| TF | leak | FULL Sh | FULL ret | HOLD Sh | HOLD ret | HOLD DD |
|
||||
|---|---|---|---|---|---|---|
|
||||
| 4h | **0** | 1.36 | +204% | 0.27 | +2.8% | 8.3% |
|
||||
| 6h | **0** | 1.42 | +217% | 0.21 | +2.1% | 7.9% |
|
||||
| 12h | **0** | 1.32 | +198% | 0.22 | +2.3% | 8.6% |
|
||||
| **1d** | **0** | 1.30 | +201% | **0.31** | **+3.5%** | 7.5% |
|
||||
| buy&hold 50/50 1d | — | 0.92 | +1671% | **−0.32** | **−39%** | 59% |
|
||||
|
||||
## Lettura
|
||||
- **Il path single-TF che ho usato in verify/stress è LEAK-FREE** (guard=0 su ogni TF): il
|
||||
gonfiaggio 1.60 stava nel path **mixed-TF ffill** (ensemble/combine, es. trackE), NON nel
|
||||
portafoglio single-TF. Per questo il mio 4h era 1.36 (non 1.60).
|
||||
- **La conclusione "≥12h" è comunque CORRETTA e la adotto**: il FULL Sharpe è PIATTO ~1.3 da 12h
|
||||
a 4h → scendere sotto le 12h NON dà vantaggio reale, aggiunge solo costi/turnover e rischio
|
||||
overfit/look-ahead (lo stress mostrava il margine hold-out del 4h fragile a lag/fee). **1d è il
|
||||
migliore**: hold-out Sharpe 0.31 (il più alto), DD 7.5%, turnover/costi minimi, leak-free.
|
||||
- Allinea anche col numero dell'agente: il "reale ~1.1" è del path mixed-TF corretto; il mio
|
||||
single-TF pulito dà ~1.3 FULL. In ogni caso **edge difensivo modesto**, non alpha.
|
||||
|
||||
## Decisioni applicate
|
||||
- **Canonica deploy → PORT LF1d** (era LF4h). `trend_portfolio.py`: docstring aggiornata + nota
|
||||
look-ahead; aggiunti `resample_tf`/`resample_1d`, `resample_4h` marcato deprecato per il deploy.
|
||||
- **Paper trader → 1d** (`paper_trend.py`: `resample_1d`, `build_bars`, etichette 1d; gira, 5 test ok).
|
||||
- **CLAUDE.md**: TP01 ridescritta come DIFENSIVA, canonica ≥12h/1d, gotcha look-ahead documentato.
|
||||
- **Gotcha riusabile:** mai ffill/combine MIXED-TIMEFRAME su timestamp open-labeled (`label="left"`):
|
||||
la close del bar (nota solo a fine bar) verrebbe propagata indietro all'open-label → look-ahead.
|
||||
Il calcolo per-singolo-TF a barre discrete (posizione +1) è sicuro; il guard prefix-recompute lo prova.
|
||||
|
||||
## Verdetto invariato
|
||||
TP01 resta la prima strategia onesta del progetto: **difensiva** (taglia il DD ~6× vs buy&hold,
|
||||
hold-out 2025-26 positivo su entrambi gli asset), modesta nel ritorno. Deploy a **1d**, forward-only
|
||||
paper trader, prima di qualsiasi capitale reale.
|
||||
@@ -1,84 +0,0 @@
|
||||
# 2026-06-19 — Verifica TP01 (branch strategy-research-2026-06) col gauntlet onesto
|
||||
|
||||
Una ricerca PARALLELA (branch `strategy-research-2026-06`, AdrianoDev) dallo stesso baseline
|
||||
v2.0.0 ha trovato TP01 come "unica vincitrice". La mia linea (Fasi 2-3) aveva bocciato il trend
|
||||
sul hold-out 2025-26. Ho riprodotto TP01 VERBATIM (`scripts/analysis/verify_tp01.py`) e l'ho
|
||||
passato al mio gauntlet. **TP01 REGGE — la mia conclusione precedente era incompleta.**
|
||||
|
||||
## TP01 = TSMOM 30/90/180g, **vol-target 20%**, leva cap 2x, **long-flat**, portafoglio 50/50 BTC+ETH (4h)
|
||||
|
||||
## Esiti del gauntlet
|
||||
|
||||
**(A) Multi-TF (4h cherry-picked?) — NO, plateau robusto:**
|
||||
| TF | FULL Sharpe | HOLD-OUT Sharpe |
|
||||
|---|---|---|
|
||||
| 15m | 0.93 | −0.31 |
|
||||
| 1h | 1.32 | +0.20 |
|
||||
| **4h** | **1.36** | **+0.27** |
|
||||
| 1d | 1.30 | +0.31 |
|
||||
1h/4h/1d danno tutti FULL ~1.3 e hold-out positivo → non è un artefatto di un singolo TF (solo il 15m, fee-sensibile, fallisce).
|
||||
|
||||
**(C) HOLD-OUT 2025-26 (il test che ha ucciso il mio trend 1h) — TP01 PROTEGGE:**
|
||||
| | Sharpe | ret | DD |
|
||||
|---|---|---|---|
|
||||
| **TP01 portfolio** | **+0.27** | **+2.8%** | **8.3%** |
|
||||
| buy&hold 50/50 | −0.35 | **−39.4%** | 59.8% |
|
||||
|
||||
**(D) Cross-asset nel hold-out — regge su ENTRAMBI** (BTC sleeve +2.9% Sh 0.24, ETH +2.4% Sh 0.24).
|
||||
A differenza del "vincitore" frattale (+ETH/−BTC), TP01 protegge coerentemente su BTC E ETH.
|
||||
|
||||
**(B) Per anno:** positiva quasi ogni anno 2019-2026 (eccezioni piccole: 2022 −2.4%, 2026-YTD −0.9%),
|
||||
DD annui 1-12%. Il claim "positiva ogni anno" è lievemente ottimistico ma sostanzialmente vero.
|
||||
|
||||
## Perché TP01 regge dove il MIO trend (Fase 3) è caduto
|
||||
La differenza chiave è il **VOL-TARGETING** (che NON avevo combinato col trend): TP01 scala
|
||||
l'esposizione ∝ 1/vol_realizzata → nel crollo 2025-26 la vol è esplosa e TP01 si è messo
|
||||
quasi in cash, schivando il drawdown. Il mio MA-cross 1h aveva esposizione fissa ed è rimasto
|
||||
long nel chop → frullato. Concorrono: TSMOM multi-orizzonte (più liscio del MA-cross), long-flat
|
||||
(niente perdite short), diversificazione 50/50. **La mia "trend = regime-luck" era vera per il
|
||||
trend NUDO; TP01 = trend + vol-target + portafoglio è un'altra cosa, e robusta.**
|
||||
|
||||
## Cosa È onestamente TP01 (no oversell)
|
||||
- **Edge DIFENSIVO, non alpha**: FULL Sharpe 1.36 vs buy&hold 0.92 — MA CAGR +16.6% vs +48.1%.
|
||||
Su tutto il toro il buy&hold ha reso ~8x di più. Il valore di TP01 è il **DD** (13.8% vs 77.5%
|
||||
full; 8% vs 60% nel hold-out) e la **protezione dai crash**.
|
||||
- Nel hold-out 2025-26 ha fatto solo +2.8% (Sharpe 0.27, basso): ha **protetto, non profittato**.
|
||||
- Un solo regime di hold-out, ma il vol-targeting è meccanico (high vol → low expo) → generalizza
|
||||
per costruzione meglio di un timing fittato.
|
||||
- Config canonica (30/90/180, vol20%, lev2x) non iper-tunata; 4h non cherry-picked (plateau).
|
||||
|
||||
## VERDETTO
|
||||
**TP01 è la PRIMA strategia onesta e robusta del progetto post-reset.** Supera il mio gauntlet
|
||||
(hold-out positivo su entrambi gli asset, plateau multi-TF, causale, fee-aware). È modesta e
|
||||
difensiva (Sharpe ~1.3, soffitto strutturale dichiarato corretto), ma è reale: migliora il
|
||||
rischio/rendimento del buy&hold tagliando i drawdown e proteggendo nei crash. La ricerca parallela
|
||||
ha fatto centro proprio sul pezzo che la mia linea non aveva combinato (vol-target sul trend).
|
||||
|
||||
**Raccomandazione:** integrare il branch su main (modulo `trend_portfolio.py` + paper trader),
|
||||
trattare TP01 come baseline operativa difensiva. Aspettative oneste verso il target €50/g: a
|
||||
Sharpe 1.3 / CAGR 16.6% servono molto capitale o leva (con più DD) — TP01 è un fondamento solido,
|
||||
non una scorciatoia.
|
||||
|
||||
## STRESS-TEST (`scripts/analysis/stress_tp01.py`, integrato e rieseguito sul modulo vero)
|
||||
|
||||
| Dimensione | Esito |
|
||||
|---|---|
|
||||
| **Sweep fee** | FULL robusto fino a **0.40% RT** (Sh 1.44→1.36→1.28→1.13). HOLD-OUT SOTTILE: +2.8%/Sh0.27 a 0.10% → ~flat (Sh 0.03) a 0.40% |
|
||||
| **Lag/slippage** | FULL robusto (1.29-1.43). HOLD-OUT si erode: lag1(4h)→Sh0.12, lag2→−0.02, lag1+fee0.20%→0.04 |
|
||||
| **Plateau parametri** | OTTIMO — target_vol/leva/orizzonti/vol_win tutti reggono o migliorano (orizzonti 20/60/120 → Sh 1.61). **NON un picco cherry-picked** |
|
||||
| **Deflated-Sharpe** | DSR **0.999** a N=10/40/100 trial → il Sharpe FULL non è artefatto di multiple-testing |
|
||||
|
||||
**Verdetto stress (onesto):**
|
||||
- **Robustezza FULL-period: FORTE.** TP01 supera fee 0.40%, lag, ampio plateau di parametri, e
|
||||
deflated-Sharpe. NON è overfit né cherry-picked — la proprietà robusta è il **taglio del
|
||||
drawdown** (13.8% vs 77.5% full; 8% vs 60% hold-out), invariante a tutto lo stress.
|
||||
- **Edge di RITORNO nel hold-out: REALE ma SOTTILE e sensibile alla frizione.** Nel 2025-26 ha
|
||||
schivato il crash in modo affidabile (DD 8% vs 60%) ma ha **protetto più che profittato** (+2.8%,
|
||||
Sh 0.27), e quel sottile positivo si assottiglia a zero sotto fee2x o lag 2 barre.
|
||||
|
||||
**Conclusione:** la proprietà **deployabile e robusta di TP01 è la PROTEZIONE del drawdown**, non
|
||||
la generazione di alpha. È una strategia difensiva genuina (prima del progetto a superare gauntlet
|
||||
+ stress), ma a basso ritorno: il valore è "Sharpe ~1.3 con DD ~6× più piccolo del buy&hold",
|
||||
non "battere il mercato". Per il capitale reale: il vol-targeting + long-flat sono meccanici e
|
||||
generalizzano; il rischio residuo è la frizione di esecuzione sul filo del sottile edge di ritorno
|
||||
nei regimi avversi → da monitorare col paper trader forward-only prima di scalare.
|
||||
@@ -1,77 +0,0 @@
|
||||
# Track F — Calendar seasonality (hour-of-day / day-of-week) on BTC & ETH
|
||||
|
||||
**Data:** 2026-06-19 · **Script:** `scripts/research/trackF_seasonality.py`
|
||||
**Dati:** Deribit mainnet certificati, BTC/ETH 1h UTC. Fee baseline 0.10% RT (`fee_side=0.0005`).
|
||||
|
||||
## Domanda
|
||||
Esiste un edge di calendario *sistematico e tradeable* (ora del giorno, giorno della
|
||||
settimana, interazione ora×giorno) su BTC ed ETH, netto fee, OOS, per-anno, su entrambi gli asset?
|
||||
|
||||
## Metodologia (anti-overfit, anti-leakage)
|
||||
- `ret[i]=close[i]/close[i-1]-1` è noto a `close[i]`; una posizione decisa a `close[i]` guadagna
|
||||
`ret[i+1]`. La statistica che decide il trade usa **solo barre ≤ i** (mai la barra tradata né futuro).
|
||||
- **Tradeable test onesto = ADAPTIVE EXPANDING sign**: a `close[i]` guardo il bucket di calendario
|
||||
della barra `i+1` (il clock è noto, zero look-ahead) e prendo il **segno della media passata** di
|
||||
quel bucket (espandente, warmup-gated). Long-flat o long-short. Fee solo su `|Δposizione|`.
|
||||
È l'analogo onesto di "tradare il seasonal": i dati scelgono il segno di ogni bucket **dal vivo**.
|
||||
- Tabelle descrittive per-ora/per-giorno split IS(65%)/OOS(35%) come diagnostica.
|
||||
- Regola discreta ottimizzata in-sample (entra a ora H, tieni W barre, dir migliore) mostrata solo
|
||||
per **esporre il gap IS→OOS** (384 celle testate/asset).
|
||||
- Benchmark **buy-and-hold** come controllo del long-bias.
|
||||
|
||||
## Risultati
|
||||
|
||||
### 1. Descrittive (bp/barra, IS vs OOS)
|
||||
- **Hour-of-day:** sign-agreement IS/OOS solo **12/24 (BTC)** e **8/24 (ETH)** → caso. Le ore "US
|
||||
close" 21:00–22:00 UTC sono positive in entrambi gli split su entrambi gli asset (l'unico pattern
|
||||
con un minimo di coerenza), ma il resto è rumore che cambia segno tra IS e OOS.
|
||||
- **Day-of-week:** più stabile. **Giovedì negativo** su BTC ed ETH in IS *e* OOS; Lun/Mer positivi.
|
||||
Sign-agreement 6/7 (BTC), 5/7 (ETH).
|
||||
|
||||
### 2. Adaptive expanding-sign (il test tradeable)
|
||||
| Strategia | BTC Sharpe | ETH Sharpe | Note |
|
||||
|---|---|---|---|
|
||||
| HOUR long-short | **−5.39** | **−4.04** | DD 100%. Annientata dalle fee. |
|
||||
| HOUR long-flat | −2.92 | −2.09 | DD 100%. Idem. |
|
||||
| DOW long-short | +0.64 | +0.83 | DD 82–84%, −66% nel 2022 |
|
||||
| DOW long-flat | +0.81 | +0.96 | DD 75–78%, −64/−66% nel 2022 |
|
||||
| HOUR×WEEKDAY (168 buckets) | −5.05 | −3.96 | DD 100%. Overfit puro + fee. |
|
||||
|
||||
### 3. Il controllo che smonta il DOW — **buy-and-hold**
|
||||
- BTC buy-hold: **Sharpe 0.79, CAGR 34.9%, DD 77%** → DOW long-flat: Sh 0.81, CAGR 34.2%, DD 77.5%.
|
||||
- ETH buy-hold: **Sharpe 0.84, CAGR 42.4%, DD 81%** → DOW long-flat: Sh 0.96, CAGR 52.7%, DD 74%.
|
||||
- Il DOW long-flat è **long il 78% del tempo** (`mean_pos≈+0.78`). È **buy-and-hold travestito**:
|
||||
guadagna perché crypto sale, non perché esiste un edge di giorno. Lo "skip del giovedì" aggiunge
|
||||
pochissimo e non giustifica un deploy.
|
||||
|
||||
### 4. Fee sweep (HOUR long-short adaptive)
|
||||
A fee **0%**: Sh +0.61 (BTC) / +0.80 (ETH) — solo long-drift. A 0.10% RT: **−5.4 / −4.0**. Turnover
|
||||
**~8.000 flip/anno** (segno orario instabile, cambia quasi ogni barra) → morte istantanea per fee.
|
||||
Le strategie hour-of-day sono ad alta frequenza per costruzione: le fee sono di prim'ordine e le
|
||||
uccidono.
|
||||
|
||||
### 5. Regola discreta ottimizzata in-sample (trappola multiple-testing)
|
||||
- BTC: best IS H=05 hold=24h dir=+1 → **IS Sh +4.25 → OOS Sh +1.47** (+3.7 bp/trade).
|
||||
- ETH: best IS H=13 hold=24h dir=+1 → **IS Sh +7.35 → OOS Sh +0.90** (+3.2 bp/trade).
|
||||
- Collasso IS→OOS classico. Inoltre "hold 24h dir+1" = ancora **long-bias** (entra una volta/giorno
|
||||
e tiene 24h ≈ sempre long). Il margine OOS (~3 bp/trade su 10 bp RT) è marginale e fragile.
|
||||
|
||||
## Multiple-testing
|
||||
199 celle di calendario/asset (24 ore + 7 giorni + 168 ora×giorno) + 384 (H,W,dir)/asset. Con così
|
||||
tante celle, bucket "significativi" spuri sono **garantiti**. Filtri applicati: segno scelto dal vivo
|
||||
su soli dati passati, deve reggere OOS, per-anno, e su **entrambi** BTC ed ETH.
|
||||
|
||||
## Verdetto — **SPURIO / NON deployable**
|
||||
- **Nessun edge di calendario netto-fee robusto** su BTC ed ETH.
|
||||
- **Hour-of-day:** morto (fee + segno instabile). L'unica regolarità (US-close 21–22 UTC positiva) è
|
||||
troppo debole e non sopravvive al turnover.
|
||||
- **Day-of-week:** l'unico risultato "positivo" è **long-bias mascherato** (≈ buy-and-hold,
|
||||
Sharpe ~0.8–0.96 < trend portfolio 1.32, DD 75–84% rovinoso, −65% nel 2022). Non è un edge
|
||||
seasonal sfruttabile; è esposizione direzionale al drift di crypto.
|
||||
- **Hour×weekday:** overfit puro (IS −3.6 → OOS −8.0).
|
||||
- Coerente con la lezione del progetto: dove l'unica "direzione" che funziona è essere long, non c'è
|
||||
alpha di timing — c'è beta. Il trend portfolio (TP01) cattura quel beta in modo vol-targeted e
|
||||
con DD ~12%, infinitamente meglio di qualunque regola di calendario qui.
|
||||
|
||||
**Azione:** track F chiuso negativo. Non aggiungere nulla al portafoglio. Il soffitto Sharpe ~1.3 su
|
||||
BTC/ETH regge.
|
||||
@@ -1,85 +0,0 @@
|
||||
# Track G — Prior-period level breakouts / range (BTC & ETH, calendar-anchored)
|
||||
|
||||
**Data:** 2026-06-19 · **Script:** `scripts/research/trackG_prior_levels.py`
|
||||
**Harness:** `src/backtest/harness.py` (honest, entry decided at `close[i]`, fill `close[i]`).
|
||||
|
||||
## Domanda
|
||||
|
||||
Esistono edge net-positivi OOS, robusti su BTC **e** ETH, definiti rispetto a un **periodo
|
||||
calendario precedente** (giorno/settimana/opening-range)? E soprattutto: i breakout di livello
|
||||
**continuano** (trend) o **rientrano** (fade)?
|
||||
|
||||
## No look-ahead (garanzie)
|
||||
|
||||
- Livelli prior-day/week costruiti aggregando a barre giornaliere/settimanali (UTC) e poi
|
||||
**`shift(1)`** sul frame del periodo *chiuso*: il periodo corrente vede solo il precedente
|
||||
totalmente chiuso. Mai "oggi"/"questa settimana" nel livello.
|
||||
- Opening-range usato **solo** sulle barre dopo la chiusura della finestra di apertura.
|
||||
- Direzione + prezzo decisi a `close[i]`, fill a `close[i]`. Mai entry sul livello esatto intrabar.
|
||||
- Bug iniziale corretto: mismatch tz-aware vs tz-naive nel mapping dei livelli (dava 0 trade).
|
||||
|
||||
## Risultati (1h, fee 0.10% RT, leva 1x, OOS 65/35)
|
||||
|
||||
### Continuation vs FADE — il verdetto è netto
|
||||
|
||||
| Regola (PD = prior-day) | BTC OOS | ETH OOS | Sharpe OOS |
|
||||
|---|---|---|---|
|
||||
| **PD-high CONT (long su rottura max ieri)** | **+25%** | **+16%** | +0.5 / +0.3 |
|
||||
| PD-high FADE | **−68%** | **−68%** | −1.6 / −1.2 |
|
||||
| PD-low CONT (short su rottura min ieri) | −33% | −60% | −0.5 / −0.8 |
|
||||
| PD-low FADE | −36% | −8% | −0.6 / +0.1 |
|
||||
|
||||
- **I breakout CONTINUANO, non rientrano.** Il lato FADE è robustamente **negativo** su entrambi
|
||||
gli asset (sia high che low), su prior-day, prior-week e opening-range. Conferma diretta della
|
||||
tesi del reset: la mean-reversion / fade è morta su dati certificati.
|
||||
- **Asimmetria long-only:** funziona solo la rottura del **massimo** (long), non quella del
|
||||
**minimo** (short). Cioè non è un edge di breakout *simmetrico/direzione-neutro*: è cattura del
|
||||
**drift/trend rialzista** del cripto. La PD-low-cont (short sui breakdown) perde perché in questo
|
||||
campione il cripto sale.
|
||||
|
||||
### Grid robustness (PASS 6) — survivor = OOS>0 su ENTRAMBI
|
||||
|
||||
- **PD-high CONT: 3/3 celle** (buffer 0/0.1%/0.3%) positive OOS su BTC **e** ETH → robusto al buffer.
|
||||
- PD-high fade, PD-low cont/fade, OR-fade: **0 survivor**.
|
||||
- **OR-cont:** positiva solo su ETH, negativa su BTC su tutte le finestre (3/6/8/12h) → artefatto
|
||||
mono-asset, scartato dalla regola "entrambi".
|
||||
|
||||
### Anchor-hour sweep (PASS 5) — non è un'ora fortunata
|
||||
|
||||
PD-high cont positiva su **21/24** ore UTC (BTC) e **20/24** (ETH). Non dipende da un singolo
|
||||
anchor → coerente con un edge reale (ma vedi sotto: è beta di trend).
|
||||
|
||||
### Fee sweep + per-anno (PD-high cont, full sample)
|
||||
|
||||
```
|
||||
BTC RT%: 0.00→+571 0.05→+289 0.10→+126 0.15→ +31 0.20→ −24 (OOS: +84/+52/+25/+3/−15)
|
||||
ETH RT%: 0.00→+1754 0.05→+1012 0.10→+567 0.15→+299 0.20→+139 (OOS: +67/+39/+16/−3/−19)
|
||||
BTC per-anno: 2019 +39 2020 +104 2021 +7 2022 −42 2023 +24 2024 +27 2025 −16 2026 +3
|
||||
ETH per-anno: 2020 +164 2021 +160 2022 +7 2023 +1 2024 +12 2025 −4 2026 +7
|
||||
Sharpe full: BTC +0.48 (maxDD 55%, €/d 2k +0.88) · ETH +0.86 (maxDD 34%, €/d 2k +4.27)
|
||||
```
|
||||
|
||||
- **Fee-fragile:** alla baseline 0.10% RT sopravvive (OOS +25/+16%), ma muore già a ~0.15-0.20% RT.
|
||||
Margine di fee sottile (≈1.5x baseline e l'edge sparisce su OOS). ~1000-1100 trade in 8 anni.
|
||||
- **Drawdown enormi** (BTC 55%) e anni negativi (2022 −42% BTC, 2025 −16%).
|
||||
|
||||
## Verdetto
|
||||
|
||||
- **Sì, esiste un edge net-positivo OOS su entrambi gli asset:** *PD-high continuation* (long
|
||||
quando `close` supera il massimo di ieri, exit a fine giornata UTC). Robusto al buffer e
|
||||
all'anchor-hour. **MA non è deployabile come miglioramento:**
|
||||
1. È **long-only drift capture**, non un breakout simmetrico (il lato short fallisce) → è una
|
||||
versione **più debole e ridondante** del Trend Portfolio TP01 (Sharpe 0.48-0.86 vs 1.32).
|
||||
2. **Fee-fragile** (muore a ~1.5x la fee baseline) e con **drawdown** molto peggiori.
|
||||
- **Il contributo scientifico vero è la conferma della direzione:** sui dati certificati i
|
||||
breakout di livello-calendario **CONTINUANO**; il fade è morto (negativo robusto su PD/PW/OR,
|
||||
entrambi gli asset). Nessuna sorpresa mean-reversion nascosta nei livelli giornalieri/settimanali.
|
||||
- **Niente di nuovo da mettere in produzione.** TP01 resta la strategia vincente; i breakout
|
||||
prior-period non aggiungono Sharpe (stessa beta di trend, peggio eseguita).
|
||||
|
||||
## Come riprodurre
|
||||
|
||||
```bash
|
||||
uv run python scripts/research/trackG_prior_levels.py # full (1h + 15m, ~25s)
|
||||
uv run python scripts/research/trackG_prior_levels.py --quick # 1h only
|
||||
```
|
||||
@@ -1,71 +0,0 @@
|
||||
# Track H — Volume, Range & Volatility-Regime signals (BTC/ETH, certified, >=12h)
|
||||
|
||||
**Date:** 2026-06-19
|
||||
**Script:** `scripts/research/trackH_volume_vol.py` (runnable, self-contained)
|
||||
**Question:** does any volume / range / volatility-regime signal ADD to the deployed winner
|
||||
TP01 (vol-targeted trend portfolio, 12h, Sharpe ~1.32) — i.e. net-positive OOS on BOTH BTC &
|
||||
ETH AND uncorrelated (|corr|<~0.3) — OR work as a regime filter that lifts TP01's Sharpe / cuts
|
||||
its DD?
|
||||
|
||||
## Method (honest)
|
||||
- Same causal per-bar engine as `TrendPortfolio.net_returns`: build a continuous TARGET decided
|
||||
with data `<= close[i]`, HOLD it during bar `i+1` (`pos_held[t]=target[t-1]`), gross = pos×ret,
|
||||
fee on `|Δpos|`. Identical in spirit to `harness.backtest_signals` (decide≤close[i], fill at
|
||||
close[i]); two discrete signals cross-checked through `backtest_signals` directly.
|
||||
- All features (volume z-score, OBV, ranges, realized vol) use prior/rolling windows shifted so
|
||||
bar `i` sees only `<= i`. 12h/1d resampled from certified 1h via `resample_tf` (label='left'),
|
||||
consumed index-based with the +1 hold → no open-label leak.
|
||||
- Fee 0.10% RT baseline + sweep 0.00–0.40% RT. OOS 65/35 + per-year. Grid on BOTH assets.
|
||||
Turnover and correlation-to-TP01 reported for every signal.
|
||||
- **>=12h only** (12h + 1d). Sub-12h excluded per the standing lesson (fees + HF-noise overfit +
|
||||
the 4h open-label look-ahead trap).
|
||||
|
||||
## Signals tested
|
||||
VT-long (volatility-managed long), VolBreakout (volume-z-confirmed Donchian), OBV-trend,
|
||||
VW-mom (volume-weighted momentum), RangeExpand (range-expansion breakout), NR7-break
|
||||
(narrowest-range breakout), DeclVolRev (declining-volume fade/reversal). Plus regime overlays on
|
||||
TP01: keep-low-vol, keep-high-vol, vol-managed ×1.5, OBV-up confirmation.
|
||||
|
||||
## Results (12h headline, fee 0.10% RT)
|
||||
| signal | corr→TP01 | OOS Sharpe BTC/ETH | note |
|
||||
|---|---|---|---|
|
||||
| VT-long | 0.66 / 0.69 | 0.80 / 0.14 | trend-in-disguise; weak OOS ETH |
|
||||
| VolBreakout | 0.69 / 0.71 | 0.54 / 0.49 | profitable but correlated |
|
||||
| OBV-trend | 0.61 / 0.63 | 0.96 / 0.68 | profitable but correlated; turnover ~75/yr |
|
||||
| VW-mom | 0.64 / 0.67 | 0.98 / 0.74 | basically TSMOM; correlated |
|
||||
| RangeExpand | 0.48 / 0.49 | 0.37 / 1.04 | lower corr but BTC weak; ETH negative on 1d |
|
||||
| NR7-break | 0.48 / 0.49 | 0.79 / 0.02 | fails OOS on ETH |
|
||||
| DeclVolRev | -0.15 / -0.11 | -1.15 / -0.44 | **negative even at zero fee** |
|
||||
|
||||
Grid robustness (12h, % cells positive full+OOS on both assets): VW-mom 100%, VT-long 100%,
|
||||
VolBreakout 96%, RangeExpand 96%, OBV-trend 75% — but the robust ones are precisely the ones
|
||||
that are highly correlated to TP01. Fee sweep: trend-family signals survive to 0.40% RT;
|
||||
DeclVolRev gets worse with fees (it trades constantly).
|
||||
|
||||
## Regime filters on TP01 (12h, 50/50 portfolio)
|
||||
| variant | full Sharpe | OOS Sharpe | maxDD | CAGR | turn/y |
|
||||
|---|---|---|---|---|---|
|
||||
| **TP01 baseline** | **1.32** | 0.90 | 13.3% | 16.2% | 11.5 |
|
||||
| × keep LOW-vol | 0.94 | 1.11 | 14.1% | 7.7% | 9.5 |
|
||||
| × keep HIGH-vol | 0.98 | 0.18 | 9.9% | 7.9% | 4.9 |
|
||||
| × vol-managed ×1.5 | 1.33 | 0.96 | 17.9% | 18.1% | 15.4 |
|
||||
| × OBV-up only | 1.49 | 1.04 | 10.1% | 14.4% | 18.2 |
|
||||
|
||||
OBV-up filter across EMA span: full Sharpe 1.49–1.52 (span 15–30), DD 7–10%, but OOS gain is
|
||||
marginal (0.90→1.04 at span 30) and fades for span≥45 (OOS 0.69–0.73). It cuts ~2pp CAGR and
|
||||
raises turnover ~60%.
|
||||
|
||||
## Verdict (honest)
|
||||
- **No uncorrelated additive edge exists.** Every *profitable* volume/range/vol signal is trend
|
||||
in disguise (corr 0.61–0.75 to TP01) → cannot raise the 50/50 portfolio Sharpe. The genuinely
|
||||
lower-corr signals (RangeExpand, NR7 ~0.48) fail OOS on at least one asset.
|
||||
- **Mean-reversion / declining-volume fade is dead** — negative net AND at zero fee on both
|
||||
assets. Reconfirms the v2.0.0 contamination lesson; MR is not a real edge on certified data.
|
||||
- **Vol-regime gating hurts** (keep-low / keep-high both drop Sharpe to ~0.95). The vol-managed
|
||||
overlay is Sharpe-neutral but DD-worse.
|
||||
- **The only non-harmful overlay is OBV-up trend-confirmation:** it cuts DD (13.3%→10.1%) and
|
||||
nudges full Sharpe to ~1.49, but it is trend double-confirmation (de-risking), not new alpha;
|
||||
it costs CAGR, raises turnover, and the OOS Sharpe gain is within noise and span-sensitive. It
|
||||
is worth keeping in mind as a **defensive DD overlay**, not as a Sharpe improver.
|
||||
- **Bottom line:** the ~1.3 portfolio-Sharpe ceiling on BTC/ETH-only **holds**. TP01 stays the
|
||||
deployable winner. Volume/range/vol add nothing uncorrelated.
|
||||
@@ -1,99 +0,0 @@
|
||||
# Track I — Alternative momentum formulations + long-horizon reversal (2026-06-19)
|
||||
|
||||
**Script:** `scripts/research/trackI_momentum_reversal.py` (self-contained, runnable).
|
||||
**Universe:** BTC & ETH only. **TF:** 12h + 1d (sub-12h excluded by rule). **Harness:** identical
|
||||
honest machinery to TP01 — direction decided `<= close[i]`, positions held next bar (`pos_held[1:]
|
||||
= tgt[:-1]`), vol-target by inverse PAST-ONLY realized vol (target 20%, lev cap 2x), NET fee 0.10%
|
||||
RT on turnover, 50/50 BTC+ETH. OOS 65/35 + per-year + fee sweep (0.00–0.40% RT). Correlation to
|
||||
TP01 net returns reported for every candidate.
|
||||
|
||||
## Goal
|
||||
(A) A momentum formulation that BEATS or DIVERSIFIES the canonical 1-3-6m sign-blend (TP01,
|
||||
Sharpe ~1.32). (B) Does the classic LONG-HORIZON REVERSAL (fade ~12m winners) give an
|
||||
uncorrelated positive overlay?
|
||||
|
||||
## PART A — momentum formulations (12h, long-flat, vs TP01 Sharpe 1.32 / OOS 0.90 / DD 13.3%)
|
||||
|
||||
| formulation | Sharpe | IS | **OOS** | CAGR | maxDD | corr→TP01 | BTC | ETH |
|
||||
|---|---|---|---|---|---|---|---|---|
|
||||
| baseline sign-blend 1-3-6m | 1.32 | 1.54 | 0.90 | +16% | 13.3% | 1.00 | 1.15 | 1.10 |
|
||||
| (i) z-score cum-return (tanh) | **1.35** | 1.63 | 0.85 | +12% | **8.4%** | 0.96 | 1.30 | 1.00 |
|
||||
| (ii) risk-adjusted momentum | 1.27 | 1.49 | 0.84 | +13% | 9.5% | 0.97 | 1.21 | 1.00 |
|
||||
| (iii) EMA-cross trend | 0.81 | 0.91 | 0.62 | +11% | 25.1% | 0.85 | 0.89 | 0.53 |
|
||||
| (iii-b) MACD (calendar spans) | **1.50** | **1.87** | 0.74 | +22% | 17.7% | 0.69 | 1.30 | 1.32 |
|
||||
| (iv) Donchian breakout | 1.10 | 1.36 | 0.57 | +17% | 25.0% | 0.86 | 1.08 | 0.82 |
|
||||
| (v) acceleration (Δ-momentum) | 1.28 | 1.82 | 0.35 | +14% | 14.2% | 0.66 | 1.25 | 0.81 |
|
||||
| (vi) 12-1 skip momentum | 0.67 | 0.79 | 0.47 | +9% | 24.5% | 0.68 | 0.70 | 0.49 |
|
||||
|
||||
Results are essentially identical at 1d. Read-out:
|
||||
|
||||
- **Nothing cleanly beats the sign-blend OOS on both assets.** The headline-Sharpe leaders are
|
||||
artefacts of in-sample fit: **MACD** posts IS 1.87 but OOS collapses to 0.74 (gap = overfit) with
|
||||
a worse DD (17.7%); **acceleration** IS 1.82 → OOS **0.35** (worst OOS decay of all). Both fail.
|
||||
- **(i) z-score continuous momentum** is the one mild, honest refinement: Sharpe 1.35 (≈baseline)
|
||||
but **maxDD 8.4% vs 13.3%** — the continuous score scales down position when the cumulative move
|
||||
is statistically small, de-risking the tails. OOS 0.85 (slightly below baseline 0.90), CAGR drops
|
||||
16%→12%. It's a smoother sibling of TP01, **not a new edge** (corr 0.96).
|
||||
- (vi) 12-1 skip (classic equity "12-1" momentum) **does NOT help crypto**: skipping the recent
|
||||
month removes the strongest part of the signal here → Sharpe 0.67, corr 0.68. Crypto momentum
|
||||
lives in the recent window, opposite to the equity stylised fact.
|
||||
- Breakout/Donchian and EMA-cross are strictly worse (high DD, weak OOS).
|
||||
|
||||
## PART B — long-horizon reversal (fade past winners), 12h
|
||||
|
||||
Long-short reversal (short ~12/18/24m winners, long losers, vol-targeted):
|
||||
|
||||
| reversal LS | Sharpe | OOS | CAGR | maxDD | corr→TP01 |
|
||||
|---|---|---|---|---|---|
|
||||
| 12m | -0.77 | -1.15 | -14% | 73% | -0.51 |
|
||||
| 18m | -0.36 | -0.75 | -8% | 58% | -0.47 |
|
||||
| 24m | **+0.04** | -0.07 | -1% | 43% | **-0.32** |
|
||||
| 12-18-24m | -0.46 | -0.72 | -8% | 57% | -0.54 |
|
||||
|
||||
- **Long-horizon reversal is NOT a standalone edge.** Standalone it LOSES money (12m/18m strongly
|
||||
negative; only 24m is ~flat at Sharpe 0.04, OOS −0.07, and even that fails "net-positive OOS on
|
||||
both assets": BTC +0.10 / ETH −0.03). Fading crypto winners over a year just shorts the trend.
|
||||
- It IS genuinely negatively correlated to TP01 (24m: corr −0.32; 12-18-24: −0.54), as expected
|
||||
(it's the opposite sign of medium-term momentum).
|
||||
- **Momentum + reversal blend** (long 1-6m momentum, brake on very-long extension): the variant
|
||||
`mom(1-3-6) − 0.5·rev(12-24)` is the most interesting single-strategy result — Sharpe **1.38**,
|
||||
**OOS 0.98** (> baseline 0.90), **maxDD 10.6%** (< 13.3%), both assets positive (BTC 1.25/ETH
|
||||
1.05), corr 0.91, fee-robust (1.43→1.22 across 0.00–0.40% RT). CAGR drops 16%→12%. It is TP01
|
||||
with a long-term-extension brake: a modest *risk-adjusted* improvement, not more return.
|
||||
|
||||
## COMBINED — TP01 + best diversifier (blend net returns)
|
||||
|
||||
TP01 alone: Sharpe 1.321, CAGR +16%, maxDD 13.3%, OOS 0.90.
|
||||
|
||||
| combo | Sharpe | CAGR | maxDD | OOS | corr |
|
||||
|---|---|---|---|---|---|
|
||||
| TP01 + 20% reversal-24m (LS) | **1.411** | +13% | 11.5% | **1.06** | -0.32 |
|
||||
| TP01 + 30% reversal-24m (LS) | 1.366 | +12% | 11.8% | 1.06 | -0.32 |
|
||||
| TP01 + 20% reversal-12-18-24 (LS) | 1.350 | +11% | 10.6% | 0.84 | -0.54 |
|
||||
| TP01 + 50% z-score | 1.348 | +14% | 9.5% | 0.89 | +0.96 |
|
||||
|
||||
- Adding a small slice of **reversal-24m long-short** lifts portfolio Sharpe 1.32→1.41 and OOS
|
||||
0.90→1.06 while cutting DD to 11.5%. **But be skeptical:** the overlay is a ~zero-mean stream
|
||||
(standalone Sharpe 0.04). The benefit is almost entirely **variance reduction from the negative
|
||||
correlation, not added alpha** — and it COSTS return (CAGR 16%→13%). With a true-zero-edge
|
||||
diversifier this Sharpe bump is fragile (it leans on the −0.32 correlation persisting OOS, and the
|
||||
OOS sample is one 2022-24 crypto cycle). I would NOT deploy capital on a standalone-losing sleeve
|
||||
to chase a 0.09 Sharpe point that is really de-risking.
|
||||
|
||||
## Fee sweep (12h portfolio Sharpe)
|
||||
baseline 1.37→1.18, z-score 1.38→1.24, MACD 1.52→1.45 (lowest turnover), blend 1.43→1.22,
|
||||
reversal-24m 0.07→−0.02 (0.00→0.40% RT). All trend formulations survive realistic fees; reversal
|
||||
has no positive margin to survive on.
|
||||
|
||||
## VERDICT (honest)
|
||||
- **Is there a momentum formulation that beats the 1-3-6m sign-blend? No — not OOS, not on both
|
||||
assets.** MACD/acceleration look better in-sample but decay OOS (overfit + higher DD). The only
|
||||
honest refinement is **continuous z-score momentum**, which matches the Sharpe with materially
|
||||
lower drawdown (8.4% vs 13.3%) — a smoother variant of the SAME edge, not a new one (corr 0.96).
|
||||
- **Does long-horizon reversal give an uncorrelated positive overlay? No, not a real one.** It is
|
||||
uncorrelated/negatively-correlated (good) but **not positive** standalone (it loses, or at best is
|
||||
flat at 24m and fails the both-assets bar). The combined-Sharpe lift (→1.41) is variance reduction
|
||||
from a near-zero-mean stream and sacrifices CAGR — fragile, not bankable alpha.
|
||||
- **The ~1.3 structural Sharpe ceiling on BTC/ETH-only holds.** TP01 remains the deployable winner.
|
||||
If anything, swap the sign-blend for the **z-score continuous score** (or the `mom − 0.5·rev`
|
||||
brake) for a lower-DD profile at equal Sharpe — a risk-management tweak, not a return upgrade.
|
||||
@@ -1,28 +0,0 @@
|
||||
# 2026-06-19 — Strato trend multi-asset sui 52 alt: RIDONDANTE col trend di TP01
|
||||
|
||||
Tentativo: aggiungere un terzo sleeve = TSMOM (stessa logica TP01 CANONICAL, long-flat vol-target)
|
||||
applicato a OGNI alt dei 52 Hyperliquid certificati, equal-weight ragged. Idea: trend più
|
||||
diversificato che diversifichi TP01 (BTC/ETH). `scripts/portfolio/trend_multiasset.py`.
|
||||
|
||||
## Esito: ridondante e peggiore
|
||||
- **TREND-52 standalone**: FULL Sh 0.66, **HOLD-OUT −1.03** (negativo), anni+ 33%. Gli alt sono
|
||||
stati long nel calo 2025-26 e hanno sanguinato — a differenza di TP01 (BTC/ETH) che il
|
||||
vol-target+trend portò in cash. I trend degli alt sono più rumorosi/whippy.
|
||||
- **corr a TP01 = +0.74** (stessa beta direzionale, come previsto) | corr a XS01 −0.05.
|
||||
- **Contributo al portafoglio (TP01 70 + XS 30):** +TREND-52 w20% → FULL −0.01, **HOLD −0.16**;
|
||||
w30% → FULL −0.02, **HOLD −0.27**. PEGGIORA.
|
||||
|
||||
## Lezione
|
||||
Broadenizzare il TREND su molti alt NON diversifica: è la **stessa direzionalità** (corr 0.74 con
|
||||
TP01) su asset più rumorosi → aggiunge perdita/rumore, non edge. La dimensione trend è già catturata
|
||||
in modo pulito da TP01 (BTC/ETH, vol-targeted). L'unica espansione che diversifica davvero resta
|
||||
quella **market-neutral** (XS01 cross-sectional), perché è ortogonale alla beta direzionale.
|
||||
|
||||
## Conclusione (chiusura del filone "espansione universo")
|
||||
Esplorate tutte le vie di espansione sui certificati Hyperliquid:
|
||||
1. XS su 52-all → diluito (memecoin), negativo.
|
||||
2. XS top-liquidità dinamico → peggiore del fisso-19 (liquidità ≠ qualità).
|
||||
3. Trend multi-asset su 52 → ridondante (corr 0.74) + hold-out negativo.
|
||||
Nessuna migliora il portafoglio. **Configurazione validata e invariata: TP01 70% + XS01 (19 major)
|
||||
30% — FULL Sh 1.41 / HOLD 1.15.** I margini reali per crescere NON sono nell'universo crypto-
|
||||
direzionale (saturo), ma in un MECCANISMO diverso (opzioni VRP, in attesa di dati di stress reali).
|
||||
@@ -1,35 +0,0 @@
|
||||
# 2026-06-19 — Affinamento XS01: blend di lookback [30,90]
|
||||
|
||||
Come TP01 fonde gli orizzonti 30/90/180, XS01 ora fonde piu' lookback del momentum cross-sectional
|
||||
(z-score cross-sectional per lookback, mediato) invece del singolo L=30. `scripts/portfolio/xsec_blend.py`.
|
||||
|
||||
## Sweep lookback (19 major, 899g) — FULL/OOS/DD/anni+/corrTP
|
||||
| lookbacks | FULL | OOS25 | DD% | anni+ | corrTP |
|
||||
|---|---|---|---|---|---|
|
||||
| [30] (prima) | 0.80 | 1.20 | 21 | 100% | −0.06 |
|
||||
| [90] | 0.88 | 0.90 | 17 | 100% | −0.05 |
|
||||
| **[30,90]** | **1.10** | **1.03** | **14** | **100%** | **−0.12** |
|
||||
| [20,40,90] | 0.51 | 0.67 | 25 | 100% | −0.12 |
|
||||
| [30,60,120] | 0.68 | 0.74 | 16 | 100% | −0.13 |
|
||||
|
||||
**[30,90] e' il sweet spot**: fonde i DUE singoli robusti (30 e 90), FULL Sh 0.80→1.10, DD 21→14%,
|
||||
corr a TP01 −0.06→−0.12 (diversifica meglio), 100% anni+. Non e' un cell fortunato: e' la
|
||||
combinazione dei due lookback gia' validati (anti-overfit, come il multi-orizzonte di TP01).
|
||||
|
||||
## Effetto sul portafoglio (TP01 70% + XS01 30%)
|
||||
| | XS01 [30] | XS01 blend [30,90] |
|
||||
|---|---|---|
|
||||
| XS01 standalone FULL / DD | 0.80 / 21% | **1.10 / 14%** |
|
||||
| Portafoglio FULL Sharpe | 1.41 | **1.48** |
|
||||
| Portafoglio HOLD-OUT Sharpe | 1.15 | 1.06 |
|
||||
| Portafoglio DD | 5.2% | **4.6%** |
|
||||
| ~€/giorno (2k) | +1.65 | +1.78 |
|
||||
|
||||
Migliora FULL Sharpe + DD + robustezza (due orizzonti) al costo di un hold-out marginalmente piu'
|
||||
basso (−0.09, dentro il rumore di una singola finestra). Giudizio: il blend e' piu' robusto
|
||||
(meno dipendente da un singolo lookback) e diversifica meglio -> PROMOSSO.
|
||||
|
||||
## Azione
|
||||
`src/portfolio/sleeves.XS_CFG`: `L=30` -> `lookbacks=(30,90)`; engine `_xsec_returns` usa lo score
|
||||
blended (media z-score cross-sectional per lookback). **Portafoglio attivo: TP01 70% + XS01 blend
|
||||
30%, FULL Sh 1.48 / HOLD 1.06 / DD 4.6%.** 12 test ok. Sleeve sempre sui 19 major.
|
||||
@@ -1,44 +0,0 @@
|
||||
# 2026-06-19 — Affinamento XS01: gate di dispersione (p30)
|
||||
|
||||
Il momentum cross-sectional vive nella DISPERSIONE (winners/losers distanti). In regime compatto
|
||||
(tutti gli asset insieme) e' rumore. Gate: entra solo se la dispersione cross-section del momentum
|
||||
supera il percentile ESPANDENTE causale `disp_pct`; altrimenti flat. Sul blend [30,90] dei 19 major.
|
||||
`scripts/portfolio/xsec_dispgate.py`. (È il concetto del vecchio XS01 pre-reset, disp_min=p50.)
|
||||
|
||||
## Sweep soglia (19 major, 899g) — XS01 standalone + contributo portafoglio
|
||||
| soglia | XS FULL | XS OOS | PORT FULL | PORT HOLD | %flat |
|
||||
|---|---|---|---|---|---|
|
||||
| no gate | 1.10 | 1.03 | 1.50 | 1.06 | 0% |
|
||||
| p15 | 1.32 | 1.39 | 1.64 | 1.36 | 28% |
|
||||
| p20 | 1.46 | 1.63 | 1.72 | 1.52 | 31% |
|
||||
| p25 | 1.46 | 1.63 | 1.72 | 1.52 | 31% |
|
||||
| **p30** | **1.50** | **1.71** | **1.74** | **1.56** | 35% |
|
||||
| p35 | 1.60 | 1.90 | 1.81 | 1.69 | 37% |
|
||||
| p40-p50 | 1.0 | 0.8 | 1.36-1.38 | 0.77-0.93 | 42-49% |
|
||||
|
||||
**PLATEAU robusto p15-p35** (cinque punti, tutti molto > no-gate); il crollo a p40+ e' OVER-gating
|
||||
(salta troppo). Scelto **p30** (centro sicuro del plateau, lontano dal cliff p40). Non un knife-edge.
|
||||
|
||||
## Effetto sul portafoglio (TP01 70% + XS01 30%)
|
||||
| XS01 | PORT FULL | PORT HOLD | PORT DD |
|
||||
|---|---|---|---|
|
||||
| [30] originale | 1.41 | 1.15 | 5.2% |
|
||||
| + blend [30,90] | 1.48 | 1.06 | 4.6% |
|
||||
| + dispersion gate p30 | **1.55** | **1.55** | **4.4%** |
|
||||
|
||||
XS01 standalone: FULL 1.10→1.50, HOLD 1.03→1.71, DD 14%→10.8%, ~€/g 1.64→2.36. Il gate alza SIA
|
||||
FULL SIA hold-out (a differenza del solo blend, che barattava un po' di hold-out).
|
||||
|
||||
## Meccanismo + caveat onesti
|
||||
- **Causale**: soglia = percentile espandente della dispersione PASSATA; nessun look-ahead.
|
||||
- **Perche' funziona**: tiene XS attivo nei regimi DISPERSI (2025-26, dove gli alt divergono) e flat
|
||||
nei bull compatti (2024). L'hold-out 2025-26 e' ad alta dispersione -> il gate concentra
|
||||
l'attivita' di XS proprio li' -> hold-out forte. E' il comportamento voluto, ma NB che il salto
|
||||
del hold-out riflette anche che il 2025-26 e' stato un regime ad alta dispersione.
|
||||
- Caveat XS01 invariati: storia ~2.5 anni; STAT-MODE (book 19 gambe non eseguibile a 2k).
|
||||
|
||||
## Azione
|
||||
`src/portfolio/sleeves.XS_CFG`: aggiunto `disp_pct=30`; engine `_xsec_returns` gatea su dispersione.
|
||||
**Portafoglio attivo: TP01 70% + XS01 (blend [30,90] + gate disp p30) 30% — FULL Sh 1.55 / HOLD 1.55
|
||||
/ DD 4.4%.** 12 test ok. Affinamenti del SEGNALE (blend + gate) hanno funzionato dove l'espansione
|
||||
universo no: i margini su XS sono nella struttura del segnale, non nel numero di asset.
|
||||
@@ -1,62 +0,0 @@
|
||||
# 2026-06-19 — Espandere l'universo XS01: PIÙ asset DILUISCONO (i 19 major sono il sweet spot)
|
||||
|
||||
Richiesta: aggiungere altri asset Hyperliquid certificati per rafforzare XS01 (cross-sectional
|
||||
momentum). Fatto il lavoro, esito ONESTO: **non rafforza — diluisce.**
|
||||
|
||||
## Cosa ho fatto
|
||||
- Esteso `fetch_hyperliquid.py` a ~54 candidati alt maggiori (mappa Binance auto SYM/USDT, k-prefissi
|
||||
esclusi). **52 certificati** (cross-venue 4-11 bps vs Binance, flat 0%, storia 2024+): aggiunti
|
||||
ATOM DYDX APE CRV LDO STX GMX SNX BCH COMP WLD UNI TRX FIL RUNE ENA ORDI JUP WIF PYTH FET AR ETC
|
||||
ALGO GALA SAND AXS DOT BLUR JTO PENDLE ONDO TAO. Esclusi MKR (delistato HL 2025-09) e FXS
|
||||
(migrazione Frax 2026-01) via nuovo gate "ultima barra recente".
|
||||
|
||||
## Il finding: il cross-section dei 52 è NEGATIVO; i 19 major sono positivi
|
||||
Stessa finestra (2024-04 → 2026-06, 807g), mom L*/H10:
|
||||
|
||||
| Universo | k | FULL Sharpe (L30/L60/L90) |
|
||||
|---|---|---|
|
||||
| **52 asset** | 5 | −0.13 / −0.21 / −0.35 |
|
||||
| **52 asset** | 8-12 | tutti negativi (k grande non aiuta) |
|
||||
| **19 major** | 5 | +0.30 / +0.36 / **+0.67** (OOS 0.91) |
|
||||
|
||||
I ~33 small/new-cap aggiunti (WIF, JUP, ORDI, PYTH, TAO, GALA, AR, BLUR…) sono idiosincratici/
|
||||
mean-reverting: il loro rumore **rovescia** il momentum relativo. Cross-sectional momentum su crypto
|
||||
funziona fra i MAJOR liquidi, non sul long tail. Allargare l'universo NON è gratis.
|
||||
|
||||
## Azione
|
||||
- **XS01 resta sui 19 major** (sweet spot già validato: plateau/fee/subset). Lo sleeve
|
||||
`_xsec_returns` ora usa una **lista esplicita `XS_UNIVERSE` (19)**, non più glob-all (così
|
||||
aggiungere parquet certificati non lo cambia/rompe — avevo inavvertitamente fatto vedere allo
|
||||
sleeve 52 asset = negativo).
|
||||
- I 52 parquet certificati restano su disco: dato valido per ricerca futura (uno strato diverso —
|
||||
es. trend-following multi-asset, o un XS ristretto ai top-liquidità — potrebbe usarli), ma NON XS01.
|
||||
- Portafoglio invariato e ripristinato: **TP01 70% + XS01 30%, FULL Sh 1.41 / HOLD 1.15.**
|
||||
|
||||
## Lezione
|
||||
"Più asset = più robusto" è FALSO per il cross-sectional momentum: il long tail di alt piccoli
|
||||
diluisce/inverte l'edge. La breadth utile è quella dei major liquidi (corr-strutturata), non il
|
||||
numero grezzo.
|
||||
|
||||
## Tentativo 2: UNIVERSO TOP-LIQUIDITÀ DINAMICO (`xsec_dynuniverse.py`) — anch'esso PEGGIORE
|
||||
Provato a selezionare a ogni ribilancio i top-N per dollar-volume 30g (causale) dai 52, poi XS
|
||||
momentum fra quelli (adattivo, ragged-aware). Esito:
|
||||
|
||||
| Universo | FULL Sh | OOS25 | anni+ |
|
||||
|---|---|---|---|
|
||||
| top12 dinamico (L30H10k5) | 0.65 | 0.54 | 67% (2026 −4%) |
|
||||
| top15/20/25 dinamico | 0.14-0.38 | ≤0.30 | 33-67% |
|
||||
| **fisso-19 major (L30H10k5)** | **0.80** | **1.20** | **100%** |
|
||||
| fisso-19 major (L90H10k5) | 0.88 | 0.90 | 100% |
|
||||
Contributo: TP01+DYN 70/30 = FULL 1.10 / HOLD 0.60 vs **TP01+XS19 = FULL 1.25 / HOLD 1.15**.
|
||||
|
||||
**Perché fallisce:** la classifica per dollar-volume ammette comunque i MEMECOIN ad alto volume
|
||||
(WIF, ORDI, JUP, PEPE...) che hanno volumi enormi ma momentum erratico/mean-reverting →
|
||||
diluiscono. **Liquidità ≠ qualità** nelle crypto. I 19 major *curati* (established, corr-strutturati,
|
||||
non solo alto volume) restano il sweet spot.
|
||||
|
||||
## Conclusione
|
||||
Né più nomi (52) né top-liquidità dinamico migliorano XS01. **XS01 resta sui 19 major curati**
|
||||
(FULL 0.80 / OOS 1.20, 100% anni+). Portafoglio invariato: TP01 70% + XS01 30% (FULL 1.41/HOLD 1.15).
|
||||
Per rafforzarlo davvero servirebbe una curatela di QUALITÀ (established majors), che è già ciò che i
|
||||
19 sono. Coerente con la disciplina: nessuna espansione senza che migliori il gauntlet. I 52 parquet
|
||||
certificati restano per ricerca futura (es. trend multi-asset, dove il long tail non diluisce).
|
||||
@@ -1,167 +0,0 @@
|
||||
# Sweep "strategie alternative su Deribit" — 104 ipotesi, 153 agenti (2026-06-20)
|
||||
|
||||
## Cosa
|
||||
Ondata di ricerca onesta richiesta esplicitamente con >=100 agenti: **studiare strategie di
|
||||
trading ALTERNATIVE** a TP01/XS01/VRP01 sull'universo certificato Deribit (**BTC/ETH** OHLCV +
|
||||
**DVOL**). Catalogo di **104 ipotesi distinte** su 11 famiglie, **un agente-finder per ipotesi**,
|
||||
poi **verifica avversariale a 3 scettici** per ogni finding promettente, poi sintesi. Totale
|
||||
**153 agenti**, ~5.86M token, ~2h (workflow `scripts/research/alt/wf_altstrat.js`,
|
||||
run `wf_0f3659fc-809`).
|
||||
|
||||
Famiglie: BRK (breakout/canali), TRD (trend non-TSMOM), MRV (mean-reversion gated), VOL (DVOL +
|
||||
vol realizzata, Deribit-specific), XAS (cross-asset BTC/ETH: ratio/lead-lag/cointegrazione/RS),
|
||||
SEA (stagionalità/ora-del-giorno), RSK (overlay difensivi), OPT (strutture opzioni modellate su
|
||||
DVOL), MIC (microstruttura/candele), STA (ML walk-forward), CMB (combinazioni/filtri).
|
||||
|
||||
## Harness condiviso (nuovo, validato)
|
||||
`scripts/research/alt/altlib.py` — libreria di valutazione ONESTA e **vettoriale** usata da tutti
|
||||
gli agenti, così il no-look-ahead è strutturalmente impossibile:
|
||||
- `eval_weights(df, target)`: posizione decisa con dati `<= close[i]`, **tenuta durante la barra
|
||||
i+1** (lo shift lo fa la libreria), fee su turnover, **fee-sweep** 0.00–0.30% RT incorporato.
|
||||
- `study_weights/study_signals`: ogni ipotesi girata su **entrambi gli asset** + **HOLD-OUT 2025+**
|
||||
+ per-anno, con verdetto conservativo PASS/WEAK/FAIL (richiede min-asset full>=0.5 **e** hold>=0.2
|
||||
**e** sopravvivenza fee).
|
||||
- DVOL allineato **causalmente** (`merge_asof` backward), storia dal 2021-03.
|
||||
- **Calibrazione:** la replica TSMOM riproduce i numeri noti leak-free di TP01 (BTC full 1.12 /
|
||||
hold 0.31, DD 77%→23%); buy&hold correttamente FALLISCE l'hold-out (full 0.79, hold −0.37).
|
||||
104 script riproducibili in `scripts/research/alt/runs/`.
|
||||
|
||||
## Esito — NIENTE di nuovo batte o diversifica lo stack esistente
|
||||
Su 104 ipotesi: **16 promettenti**, **1 sola sopravvissuta** alla verifica avversariale (STA05),
|
||||
e anch'essa **ridondante/non deployabile**. È il risultato pulito e atteso per un progetto al suo
|
||||
**soffitto strutturale BTC/ETH-direzionale ~1.3** (già documentato). Lo stack
|
||||
**TP01 (55%) + XS01 (25%) + VRP01 (20%) resta imbattuto** da questa ondata.
|
||||
|
||||
Il segnale ricorrente: decine di trend-follower prendono **FULL Sharpe alto (~1.0–1.3)** ma
|
||||
**HOLD-OUT 2025 negativo** (Supertrend, ADX-EMA, Heikin-Ashi, Turtle, SMA200-regime,
|
||||
Donchian+Chandelier, Kalman, OBV, body-ratio, ...): è **trend-beta del toro**, non alpha, e si
|
||||
rompe nell'hold-out. I PASS apparenti erano quasi tutti **(a)** singola cella fortunata
|
||||
sull'hold-out, oppure **(b)** TP01/TSMOM con un overlay attaccato sopra.
|
||||
|
||||
### L'unico sopravvissuto: STA05 — EWMA-cross ensemble vote (LEAD, non sleeve)
|
||||
Voto d'insieme su 13 coppie EMA (fast {5,10,20,40} × slow {40,80,120,200}, fast<slow),
|
||||
posizione = voto medio firmato, vol-target 20%/cap 2x, 1d. Verifica: **leak-free** (perturbazione
|
||||
barre future = 0), **plateau** di parametri, **non** fortuna di un singolo anno (jackknife
|
||||
drop-one-year 0.55–0.96), sopravvive fee a 0.30% RT. Ho rieseguito il **blend test** raccomandato
|
||||
(50/50 BTC+ETH, mia stessa griglia di TP01, fee 0.10% RT):
|
||||
|
||||
| variante | FULL Sh | DD | HOLD Sh | corr→TP01 (full/hold) |
|
||||
|---|---|---|---|---|
|
||||
| TP01 (canonico, controllo) | **+1.30** | 14.3% | +0.31 | — |
|
||||
| STA05 long-only | +1.24 | 16.3% | +0.21 | **0.93 / 0.94** → ridondante |
|
||||
| STA05 **long-short** | +0.87 | 28.6% | **+0.86** | **0.71 / 0.53** |
|
||||
|
||||
Blend TP01+STA05_LS: `0.75·TP01 + 0.25·LS` → **FULL 1.24, HOLD 0.31→0.59, DD 16.1%**;
|
||||
`0.50/0.50` → FULL 1.13, **HOLD 0.75**, DD 18.8%.
|
||||
|
||||
**Lettura onesta (più precisa della sintesi del workflow, che lo aveva liquidato come "dominato
|
||||
su ogni asse"):** la versione **long-only** è ridondante con TP01 (corr 0.94). La versione
|
||||
**long-short** invece è solo moderatamente correlata (**0.53 nell'hold-out**) e **migliora
|
||||
davvero l'hold-out del blend** (0.31→0.59 a peso 25%), al costo di un po' di FULL Sharpe
|
||||
(1.30→1.24) e DD (14%→16%). MA: l'hold-out è **solo 536 giorni** (include lo stub 2026 corto) →
|
||||
classica trappola "bello OOS ma OOS breve", e standalone ha DD 28.6%. **Verdetto: LEAD da
|
||||
monitorare forward, NON deploy, NON sleeve confermato.** Da rivalutare quando l'hold-out cresce.
|
||||
|
||||
## Famiglie confermate MORTE / ridondanti (negativi onesti)
|
||||
- **BRK** breakout (Donchian/Keltner/Bollinger/ORB/NR7/inside-bar): ogni variante rompe l'hold-out
|
||||
BTC; l'unico PASS (BRK04) è cella singola overfit con maxDD 63%.
|
||||
- **TRD** trend non-TSMOM: tutto trend-beta del toro ridondante con TP01; i 4 PASS (TRD02/07/08/10)
|
||||
sono fortuna di singola cella sull'hold-out, dominati dal TSMOM.
|
||||
- **MRV** mean-reversion: la crypto **tende, non torna**; molti negativi anche a fee zero, **0 PASS**
|
||||
→ conferma su dati certi la lezione v2.0.0 ("il fade è artefatto").
|
||||
- **VOL** gate/overlay DVOL su TSMOM: ogni overlay (VOL03/04/08/09/11) è **peso morto netto-negativo**;
|
||||
la parte robusta è sempre TP01 nudo, la componente DVOL/EWMA aggiunge anti-valore.
|
||||
- **XAS** spread BTC/ETH (ratio/lead-lag/cointegrazione/RS/dual-mom): gli spread **tendono non
|
||||
revertono** (negativi a fee zero); le "rotazioni" PASS (XAS03/04/09) sono TP01 travestito con
|
||||
selezione fortunata sull'hold-out.
|
||||
- **SEA** stagionalità: fee-killed a 1h, artefatti di regime a 1d, nessun hold-out cross-asset.
|
||||
- **RSK** overlay di rischio (circuit breaker/kill-switch/DD-scaling/inverse-vol RP): o seguono il
|
||||
prezzo (buy&hold travestito) o aggiungono frizione senza proteggere dove serve.
|
||||
- **MIC** micro-pattern candele: hold-out crolla cross-asset; l'unico "survivor" MIC05 è l'artefatto
|
||||
di **un singolo evento** (short del crash 2026-01-29 su ~13 trade).
|
||||
- **STA** ML su feature di prezzo (Ridge/Logistic/RF/Kalman/SGD/AR1/k-means): nessun potere
|
||||
predittivo OOS; l'unico PASS (STA05) è l'ensemble di trend = TP01.
|
||||
- **CMB** combinazioni: ogni combo è TP01 più un filtro che distrugge valore.
|
||||
- **OPT** strutture opzioni (modellate su DVOL ATM, niente skew): code severe (ETH maxDD 96% su
|
||||
iron condor), **lead-only** al meglio → conferma la regola VRP01 "niente short-vol da modello in
|
||||
deploy". Numeri tipo OPT02/OPT04 hold-out 2.4/1.96 sono artefatto del premio modellato + asset
|
||||
asimmetrico (ETH fallisce) → giustamente NON promettenti.
|
||||
|
||||
## Lezioni metodologiche (azionabili)
|
||||
1. **L'harness deve premiare lo Sharpe MARGINALE vs un baseline TP01, non lo Sharpe ASSOLUTO.**
|
||||
`study_weights` valuta lo Sharpe assoluto: così ogni overlay-su-TSMOM **eredita** lo Sharpe di
|
||||
trend di TP01 e prende un PASS fasullo (VOL03/04/08/09/11, CMB04/06). Per la prossima ondata:
|
||||
valutare il **contributo incrementale** rispetto a TP01 nudo, così gli overlay non possono
|
||||
ereditare un PASS.
|
||||
2. **Prima di gradare PASS, esigere (a) un PLATEAU di parametri (non una cella isolata) e (b) un
|
||||
jackknife drop-one-month / drop-best-day sull'hold-out.** Questi due check da soli hanno ucciso
|
||||
**13 dei 14** falsi positivi in verifica avversariale.
|
||||
3. La verifica avversariale a 3 scettici con angoli diversi (leak / overfit-robustezza /
|
||||
plausibilità-economica-vs-TP01) ha funzionato: ha distinto i 15 falsi positivi dall'1 robusto.
|
||||
|
||||
## Raccomandazione
|
||||
**Non aggiungere nulla di questa ondata al portafoglio live.** Lo spazio
|
||||
**BTC/ETH-direzionale single-asset è esaurito**: ogni PASS era hold-out-fitting o un overlay su TP01.
|
||||
Redirigere il budget di ricerca verso **meccanismi davvero diversi** dove il soffitto non morde:
|
||||
espandere/monitorare forward **XS01** (cross-sectional sui 51 alt Hyperliquid certificati — l'unico
|
||||
che abbia mai battuto il soffitto) e **VRP01 reale** (quando cerbero-bite cattura skew live + uno
|
||||
stress). Tenere **STA05_LS** in lista LEAD per il forward-monitor dell'hold-out.
|
||||
|
||||
Artefatti: `scripts/research/alt/altlib.py`, `scripts/research/alt/runs/*.py` (104),
|
||||
`scripts/research/alt/wf_altstrat.js`, verifica blend `/tmp/verify_sta05.py`.
|
||||
|
||||
## Follow-up — MARGINAL SCORER implementato (non più solo raccomandazione)
|
||||
La lezione #1 ("valutare lo Sharpe MARGINALE vs baseline TP01, non assoluto") è ora **codice**
|
||||
in `altlib.py`:
|
||||
- `tp01_baseline_daily()` — TP01 CANONICAL 50/50 BTC+ETH, rendimenti netti giornalieri (cache).
|
||||
Riproduce il canonico (full 1.30 / hold 0.31) — bloccato da test.
|
||||
- `marginal_vs_tp01(cand_daily)` — corr a TP01 (full/hold), **uplift del blend** (Sharpe di
|
||||
TP01+w·cand meno TP01, full & hold-out, w∈{0.25,0.5}), **beta a TP01 + alpha residua** (parte
|
||||
ortogonale al trend), e un **verdetto**: ADDS / REDUNDANT / DILUTES / NEUTRAL.
|
||||
- `study_marginal(name, target_fn)` — valuta un candidato **sia** in assoluto (`study_weights`)
|
||||
**sia** marginale; `earns_slot = (abs_grade != FAIL) AND (marginal_verdict == ADDS)`.
|
||||
- Convenzione pulita `target_fn(df, asset)` (via `_call_target`) per le strategie DVOL/cross-asset
|
||||
— niente più inferenza-asset hacky (il VOL03 dell'agente la sbagliava, usava DVOL BTC anche per ETH).
|
||||
- Demo riproducibile `scripts/research/alt/marginal_demo.py` + test `tests/test_marginal_scorer.py`.
|
||||
|
||||
**Dimostrazione (la prova che il fix discrimina):**
|
||||
|
||||
| candidato | assoluto | marginale | earns_slot |
|
||||
|---|---|---|---|
|
||||
| TP01-itself (sanity) | WEAK | REDUNDANT (corr 1.0, uplift 0) | False |
|
||||
| **STA05 long-short** (il lead) | PASS | **ADDS** (corr-hold 0.53, blend-hold +0.29) | **True** |
|
||||
| STA05 long-only | WEAK | REDUNDANT (corr 0.93/0.94) | False |
|
||||
| VOL03 DVOL-gated TSMOM (overlay) | WEAK | NEUTRAL (corr 0.93, uplift triviale) | False |
|
||||
| **CMB04 momentum+low-vol (overlay)** | **PASS** | **NEUTRAL** (corr 0.94) | False |
|
||||
|
||||
Il punto chiave è l'ultima riga: **CMB04 prendeva un PASS assoluto col vecchio harness, ma il
|
||||
marginal scorer lo declassa correttamente** — il suo "Sharpe 1.0" è trend di TP01 ereditato al 94%,
|
||||
non alpha nuovo. Regola operativa d'ora in poi: una nuova strategia direzionale BTC/ETH si giudica su
|
||||
`study_marginal` (earns_slot), non sullo Sharpe assoluto.
|
||||
|
||||
## "Resta qualche candidato?" — gate marginale + jackknife su TUTTI i contendenti forti
|
||||
Passati i 7 promettenti più forti non-ancora-marginal-testati (`marginal_remaining.py`):
|
||||
Vortex/Hull (FAIL nella ricostruzione pulita), VOL11 kill-switch (corr 0.94 → REDUNDANT), XAS03/09
|
||||
rotazioni (NEUTRAL, anzi RS-rotation **diluisce** l'hold-out −0.20), **TRD07 KAMA** e **VOL08**
|
||||
(entrambi marginale=ADDS). Ma il marginal-point-estimate **può essere ingannato da un singolo mese**:
|
||||
ho aggiunto al gate il **jackknife OOS** (`robust_oos` = uplift positivo nell'anno OOS pulito 2025
|
||||
**e** sopravvive al drop-best-month). Risultato:
|
||||
|
||||
| candidato | clean-2025 uplift | drop-best-month | robust_oos | earns_slot |
|
||||
|---|---|---|---|---|
|
||||
| TRD07 KAMA | +0.089 | **−0.034** | False | **False** (era ADDS!) |
|
||||
| VOL08 RV-term | +0.158 | +0.034 | True | **True** |
|
||||
| STA05 long-short | +0.039 | +0.131 | True | True (ma 2025 ~0, il grosso è lo stub 2026) |
|
||||
|
||||
**KAMA è il falso-positivo istruttivo:** ingannava il marginal scorer (uplift +0.056) ma muore al
|
||||
jackknife (−0.034 togliendo il mese migliore) → il gate rinforzato (`earns_slot` ora esige
|
||||
`robust_oos`) lo uccide correttamente. Codificata così la lezione #2 in `marginal_vs_tp01`.
|
||||
|
||||
### Verdetto finale: NESSUN candidato deployabile
|
||||
Dopo il gate più severo (abs≠FAIL + marginale=ADDS + jackknife OOS), i 104 collassano a **2 LEAD
|
||||
fragili**: **VOL08** (overlay term-structure di vol realizzata) e **STA05_LS** (ensemble EMA
|
||||
long-short). Entrambi sono **famiglia-trend su BTC/ETH** (non un meccanismo nuovo), moderatamente
|
||||
correlati a TP01 (0.53–0.61 hold-out), con uplift piccolo e concentrato su un OOS di ~1.5 anni →
|
||||
**forward-monitor, NON sleeve.** E sono correlati tra loro (entrambi trend) → di fatto **un solo
|
||||
tema**: "una costruzione di trend-timing alternativa, modestamente decorrelata a TP01 nel 2025-26".
|
||||
La diversificazione vera resta fuori dallo spazio direzionale single-asset (→ XS01 / opzioni reali).
|
||||
@@ -1,86 +0,0 @@
|
||||
# 2026-06-20 — Correzione estrazione cerbero MCP: il backfill sintetico (vol=0) ingannava la certificazione
|
||||
|
||||
## Contesto
|
||||
|
||||
Richiesta: "analizza cerbero MCP correggendo l'estrazione dati storici secondo le analisi fatte".
|
||||
Le analisi del progetto avevano già fissato un principio — *"storia nativa Hyperliquid solo dal 2024,
|
||||
pre-2024 = backfill, volume 0"* — e `fetch_hyperliquid.py` lo gestiva con un floor `START=2024-01-01`.
|
||||
**Il floor non basta.**
|
||||
|
||||
## Il difetto
|
||||
|
||||
`fetch_hl` chiedeva a cerbero MCP `get_historical` dal 2024-01-01 e certificava ogni asset con tre
|
||||
gate: **flat-bar** (O==H==L==C), **cross-venue** (mediana |close − Binance| < 60 bps), **recency**.
|
||||
Nessuno guardava il **volume**. Risultato: gli asset listati su HL *dopo* lo START passavano come
|
||||
PULITO pur essendo in gran parte **backfill sintetico**.
|
||||
|
||||
Ispezione del volume sui parquet (leading run di barre a volume 0):
|
||||
|
||||
| asset | barre | leading vol=0 | primo trade reale | % sintetico |
|
||||
|---|---|---|---|---|
|
||||
| **AXS** | 902 | **748** | 2026-01-18 | **82.9%** |
|
||||
| ALGO | 902 | 338 | 2024-12-04 | 37.5% |
|
||||
| SAND | 902 | 338 | 2024-12-04 | 37.5% |
|
||||
| AR | 902 | 58 | 2024-02-28 | 6.4% |
|
||||
| ETC | 902 | 11 | 2024-01-12 | 1.2% |
|
||||
| BTC/ETH + 19 major | 902 | 0 | 2024-01-01 | 0% |
|
||||
|
||||
AXS era **certificato PULITO** (flat 0%, cross-venue 9.5 bps) pur avendo solo ~5 mesi di trading reale.
|
||||
|
||||
## Verifica diretta su cerbero MCP (token mainnet)
|
||||
|
||||
Interrogato l'endpoint `cerbero-mcp.tielogic.xyz/mcp/tools/get_historical` (bot-tag
|
||||
`pythagoras-mainnet`):
|
||||
|
||||
- **BTC**: 902 barre, leading vol=0 = 0, volume reale dal 2024-01-01 (V=699, 2437, 5306…). Nativo. ✓
|
||||
- **AXS**: 902 barre, **748 leading vol=0**, primo vol>0 = 2026-01-18. Le barre a volume 0 hanno
|
||||
prezzi (O/H/L/C) che **coincidono con Binance**:
|
||||
|
||||
| data | cerbero close | binance close | Δ |
|
||||
|---|---|---|---|
|
||||
| 2024-01-01 | 9.262 | 9.26 | 2.2 bps |
|
||||
| 2024-01-02 | 8.949 | 8.94 | 10.1 bps |
|
||||
| 2024-01-03 | 7.937 | 7.95 | 16.4 bps |
|
||||
|
||||
**Diagnosi provata:** cerbero MCP riempie il periodo pre-quotazione con barre **sintetiche — volume 0,
|
||||
prezzi copiati da un venue di riferimento (Binance)**. Per questo i vecchi gate venivano ingannati:
|
||||
- cross-venue passa → i prezzi *sono* Binance (Δ 1–16 bps);
|
||||
- flat passa → le barre non sono flat (hanno movimento di prezzo);
|
||||
- ma **volume 0** → su HL quelle candele **non erano negoziabili**. È esattamente il caso v2.0.0
|
||||
(edge su un book che non c'era).
|
||||
|
||||
## Correzione (`scripts/analysis/fetch_hyperliquid.py`)
|
||||
|
||||
1. **Il VOLUME è il rivelatore del backfill** → `trim_backfill()` taglia il run iniziale di barre a
|
||||
volume 0; si tiene solo la **serie nativa**.
|
||||
2. **Gate storia nativa** `MIN_NATIVE_DAYS=365`: dopo il taglio serve ≥ 1 anno di vita reale →
|
||||
scarta chi è troppo corto (AXS, 154 barre reali → fuori).
|
||||
3. **Gate vol=0 interno** `INTERIOR_VOL0_MAX=5%`: gap di liquidità oltre il taglio iniziale.
|
||||
4. **cross-venue/flat ricalcolati SOLO sulle barre reali** (non più sui sintetici).
|
||||
5. **I parquet degli asset scartati vengono rimossi** (disco == set certificato; niente file
|
||||
contaminati a riposo).
|
||||
|
||||
## Risultato
|
||||
|
||||
- Universo certificato: **52 → 51** (AXS scartato).
|
||||
- ALGO/SAND (−338 barre), AR (−58), ETC (−11) ripuliti dal backfill → ora start reale corretto.
|
||||
- **I 19 major di XS01 hanno 0 backfill → invariati**: la strategia live (`XS_UNIVERSE` esplicito) NON
|
||||
è toccata. Verificato: portafoglio 3-way (TP01+XS01+VRP01) gira identico, FULL Sh 1.68 / HOLD 1.67.
|
||||
- Re-fetch end-to-end su cerbero reale: 51 PULITO, sweep su tutti i file → 0 backfill residuo.
|
||||
|
||||
## Nota su una conclusione precedente
|
||||
|
||||
Il diario `2026-06-19-xsec-universe-expansion.md` concludeva "cross-section dei 52 = negativo". Quella
|
||||
finestra includeva i sintetici (AXS 83%, ALGO/SAND 37% di barre vol=0 con ritorni non eseguibili): la
|
||||
magnitudine del risultato era **in parte un artefatto**. La conclusione qualitativa (il long-tail
|
||||
diluisce XS01; i 19 major sono il sweet spot) resta valida, ma il numero netto è 51 e il test andrebbe
|
||||
ri-girato sui dati puliti se si volesse riusare quell'universo.
|
||||
|
||||
## Lezione
|
||||
|
||||
`flat` + cross-venue **non bastano** a certificare un feed che fa backfill copiando un altro venue: il
|
||||
backfill è plausibile sui prezzi proprio perché è copiato. Il **volume** (=liquidità reale) è il gate
|
||||
che mancava. Coerente con la regola di prim'ordine v2.0.0: certificare il dato — anche il *volume*,
|
||||
non solo il prezzo — prima della strategia.
|
||||
|
||||
File: `scripts/analysis/fetch_hyperliquid.py`. Universo: `data/raw/hl_*_1d.parquet` (51, serie native).
|
||||
@@ -1,93 +0,0 @@
|
||||
# 2026-06-20 — Analisi strategie FinanceOld + VRP v2 (defined-risk + gate IV-rank)
|
||||
|
||||
## Contesto
|
||||
|
||||
Richiesta: analizzare le strategie in `../FinanceOld`, provare a migliorarle, testarle su dati storici.
|
||||
Quattro progetti esaminati. Verdetto di **backtestabilità onesta** sui dati certificati (BTC/ETH
|
||||
Deribit mainnet + DVOL):
|
||||
|
||||
| Progetto | Strategia | Backtestabile sui dati certi? |
|
||||
|---|---|---|
|
||||
| **FundingRateArbitrage** | Spread funding cross-exchange (perp-perp, spot-hedge) | ❌ Nessun dato funding storico nel repo (solo `exchange_settings.json`). Edge = differenza cross-venue, non ricostruibile. |
|
||||
| **Polybot** | Latency-arb Polymarket (BS digital-option) + sure-bet delta-neutral | ❌ `dataVPS/collector.db` (645MB) ha solo **~3 giorni** di `poly_books`+`funding`, e la tabella `ticks` (prezzi perp = cuore dell'edge) è **corrotta** ("database disk image is malformed"). L'edge è la latenza: non riproducibile su barre OHLC comunque. |
|
||||
| **OptionSpalping** (→Cerbero) | LLM autonomo su opzioni Deribit + perp Hyperliquid | ⚠️ È un agente LLM, non una regola meccanica. Il *concetto* (income short-vol su Deribit) è testabile. |
|
||||
| **OptionsAgent** | **Bear Call Spread + Long VIX hedge** su IWM, con 5 gate d'ingresso | ✅ Il *concetto* (vendi premio rischio-definito, incassa VRP, gate su IV-rank/regime) mappa direttamente sul nostro `options_vrp_lab.py`. |
|
||||
|
||||
→ Scelta operatore: **focus VRP opzioni**. L'unico filone con dati veri + metodologia onesta.
|
||||
|
||||
## Baseline (options_vrp_lab.py, ora con fee)
|
||||
|
||||
Vendita put NUDA settimanale delta -0.28, premio BS su DVOL reale. f = premio_reale/modellato.
|
||||
|
||||
- `f=1.0` (conservativo): **FULL Sh 0.78, DD 33%, worst-week -16.6%, HOLD-OUT Sh -0.25** → muore OOS.
|
||||
- Il rischio è la **CODA**: worst-week su LUNA (2022-06), crash 2021-05. Anno 2022 = -9%.
|
||||
|
||||
## VRP v2 — 3 idee di OptionsAgent portate nel framework
|
||||
|
||||
Nuovo script `scripts/research/options_vrp_v2.py`. Tutto **causale** (strike/premio/gate da dati
|
||||
≤ sell-date; payoff a scadenza sui prezzi certificati). Fee opzioni Deribit modellate (12.5% del
|
||||
premio netto per round-trip = cap del fee reale). Capitale = strike corto (cash-secured) per
|
||||
entrambe le strutture → DD/worst comparabili.
|
||||
|
||||
1. **Rischio definito (PUT CREDIT SPREAD)** — vendi put -0.28, COMPRI put -0.10. Il long wing
|
||||
**cappa la coda per costruzione**: worst-week -16.6% → **-7.4%**, DD 33% → 21%, Sh 0.78 → 0.99.
|
||||
2. **Gate IV-RANK > 0.30** (cond. d'ingresso di OptionsAgent) — vendi vol solo quando ricca
|
||||
(percentile espandente causale di DVOL). Trada il **58%** delle settimane → **Sh 1.35** e
|
||||
ribalta **HOLD-OUT da -0.25 a +0.28**. È l'alpha vero: il filtro di regime, non la struttura.
|
||||
3. **Crash-skip IV-rank > 0.90** (NO-GO, come "VIX>35" di OptionsAgent) — marginale da solo.
|
||||
4. **Gate VRP>0** (DVOL>RV30 causale) — marginale (il VRP è >0 il 78% del tempo, poco selettivo).
|
||||
|
||||
### Risultati chiave (book 50/50 BTC+ETH, f=1.0 conservativo)
|
||||
|
||||
| Config | FULL Sh | DD | worst-wk | HOLD-OUT Sh | attivo |
|
||||
|---|---|---|---|---|---|
|
||||
| naked (baseline) | 0.78 | 33% | -16.6% | **-0.25** | 100% |
|
||||
| spread | 0.99 | 21% | -7.4% | -0.26 | 100% |
|
||||
| spread + ivr30 | **1.35** | 14% | -7.4% | **+0.28** | 58% |
|
||||
| **COMBO** (spread+vrp+ivr30+crashskip) | 1.10 | 12% | -7.4% | **+0.60** | 41% |
|
||||
|
||||
COMBO f=1.0 per-anno: 2021 +26%, 2022 **-6%**, 2023 +2%, 2024 +18%, 2025 -0%, 2026 +5%
|
||||
(il 2022, anno-crash che dimezzava il nudo, è quasi piatto: la coda è tagliata).
|
||||
|
||||
A `f=1.29` (skew reale misurato in regime calmo) la COMBO fa FULL Sh 1.87 / HOLD 1.45 / DD 9%.
|
||||
|
||||
### Contributo al portafoglio (COMBO f=1.0 vs TP01)
|
||||
|
||||
- Corr settimanale **+0.07** (scorrelato, come il VRP nudo).
|
||||
- TP01 70% + OPT 30% → Sh **1.00** (TP01 solo 0.73), DD **7%**.
|
||||
- TP01 50% + OPT 50% → Sh **1.19**, DD 7%.
|
||||
|
||||
## Conclusione onesta
|
||||
|
||||
Le idee di OptionsAgent **migliorano davvero** lo sleeve VRP, in modo OOS-robusto:
|
||||
- la **struttura defined-risk** taglia la coda (worst -16.6%→-7.4%, DD -19pt) → meno dipendenza dal
|
||||
f di stress, che era il rischio non catturato del lead nudo;
|
||||
- il **gate IV-rank** è l'alpha: ribalta l'HOLD-OUT da negativo a positivo vendendo solo vol ricca.
|
||||
|
||||
Resta un **lead, non un deploy**: premio MODELLATO su DVOL ATM (skew non esplicito), book a 1d, e
|
||||
serve la catena reale (cerbero-bite) per il f di stress in un crash. Ma è un miglioramento netto,
|
||||
quantificato e onesto, del miglior lead income che avevamo. Prossimo passo: rivalutare il f di stress
|
||||
quando cerbero-bite cattura un crash, e validare lo skew reale sul long wing (-0.10).
|
||||
|
||||
Script: `scripts/research/options_vrp_v2.py`. Baseline: `scripts/research/options_vrp_lab.py`.
|
||||
|
||||
## Integrazione come sleeve (VRP01)
|
||||
|
||||
La COMBO è stata integrata nel portafoglio come **VRP01** (`src/portfolio/sleeves._vrp_combo_returns`,
|
||||
`vrp_sleeve()`). Implementazione self-contained in `src/` (niente import da `scripts/`): pricing BS +
|
||||
strike-from-delta + gate causali inline, DVOL da `data/raw/dvol_*.parquet`.
|
||||
|
||||
**Settimanale → giornaliero (onesto):** il rendimento settimanale è piazzato sul **giorno di
|
||||
scadenza**, 0.0 sugli altri giorni dello span. Questo PRESERVA lo Sharpe annualizzato (niente
|
||||
smoothing che gonfierebbe il daily Sharpe) e tiene lo sleeve presente ogni giorno → peso costante
|
||||
nell'outer-join del portafoglio. Verificato: lo sleeve daily replica i numeri settimanali
|
||||
(FULL Sh 1.09, HOLD 0.60, DD 12%), corr daily vs TP01 = +0.01.
|
||||
|
||||
**Pesi (per evidenza, engine reale):** TP01+VRP01 monotòno fino al 40% VRP (FULL 1.30→1.55,
|
||||
HOLD 0.31→0.52, DD fermo 14%). Essendo VRP un lead MODELLATO (non deploy pieno), non lo sovrappeso:
|
||||
registry = **TP01 0.55 / XS01 0.25 / VRP01 0.20** (TP01 resta maggioranza, l'unico deployable pieno).
|
||||
La validazione 3-way completa richiede i dati Hyperliquid (XS01, gitignored, token Cerbero) → gira
|
||||
locale con `scripts/portfolio/run_portfolio.py`.
|
||||
|
||||
Test: `tests/test_vrp_sleeve.py` (5 pass: monotonìa BS, ordering strike, determinismo+griglia
|
||||
giornaliera, gate riducono l'attività, coda tagliata <-15%).
|
||||
@@ -1,43 +0,0 @@
|
||||
# VRP01 + gestione attiva intra-trade — A/B onesto (NEGATIVO)
|
||||
|
||||
**Data:** 2026-06-20
|
||||
**Script:** `scripts/research/options_vrp_managed.py`
|
||||
**Esito:** la gestione attiva del documento credit-spread **distrugge l'edge**. VRP01
|
||||
**hold-to-expiry resta superiore.** → scartata.
|
||||
|
||||
## Cosa testava
|
||||
|
||||
Innesta sul put credit spread di VRP01 le regole intra-trade del doc `strategia-credit-spread-eth`:
|
||||
profit-take 50% del credito, stop-loss 1.5× il credito, **VOL-STOP** (chiudi se DVOL sale ≥10 punti
|
||||
dall'apertura — regola crypto-specifica nuova), **delta-exit** (chiudi se |delta| short put ≥0.30),
|
||||
time-stop 7 DTE. A/B sugli **stessi ingressi gated** (VRP>0 + IV-rank>0.30) e dati certificati;
|
||||
MTM giornaliero dello spread via BS sul path certificato + DVOL reale (causale).
|
||||
BASE = hold-to-expiry (come VRP01) vs MANAGED = stesso trade gestito.
|
||||
|
||||
## Risultato (combo 50/50 BTC+ETH, sleeve-level)
|
||||
|
||||
| variante | Sharpe | DD | ret | HOLD Sh |
|
||||
|----------|--------|------|------|---------|
|
||||
| 14d hold-to-expiry (BASE) | **0.96** | 11.7% | +39% | +1.52 |
|
||||
| 14d + solo vol-stop | 0.12 | 10.1% | +3% | +1.01 |
|
||||
| 14d FULL managed | **−1.29** | 14.8% | −15% | −1.17 |
|
||||
|
||||
Per-asset: la gestione FULL ribalta entrambi (ETH 0.33→−1.15, BTC 1.88→−0.89). Il **delta-exit**
|
||||
domina le uscite (18-25 trade su ~33-45) e taglia i vincenti prima della decadenza theta; persino
|
||||
il **vol-stop da solo** quasi azzera il ritorno (combo Sh 0.12). Win-rate crolla 80-94% → ~40%.
|
||||
|
||||
## Lettura
|
||||
|
||||
Per un venditore di premio short-vol l'edge È la decadenza theta tenuta fino a scadenza: ogni
|
||||
uscita anticipata (delta, vol-stop, PT) **monetizza meno theta e/o realizza la coda** invece di
|
||||
lasciarla riassorbire. Le regole di "difesa" del doc azionario/ETH non trasferiscono al VRP crypto
|
||||
modellato: l'unica gestione che non danneggia è **non gestire** (hold-to-expiry, come VRP01 già fa).
|
||||
|
||||
**Caveat invariato:** premio MODELLATO su DVOL ATM (no skew) + nessun fill di stress reale → tutto
|
||||
ciò resta a livello di LEAD, non deploy. Ma la conclusione relativa (BASE > MANAGED) è robusta
|
||||
perché è un A/B sugli **stessi** trade e dati.
|
||||
|
||||
## Azione
|
||||
|
||||
Nessuna modifica a VRP01 (`sleeves._vrp_combo_returns`, hold-to-expiry). Script conservato come
|
||||
riferimento dell'esperimento scartato.
|
||||
@@ -1,133 +0,0 @@
|
||||
# Sweep strategie cross-sectional su Hyperliquid (xsec) — 43 script / 257 config
|
||||
|
||||
**Data:** 2026-06-20
|
||||
**Harness:** `scripts/research/xsec/xslib.py` (nuovo) + 43 script in `scripts/research/xsec/runs/`
|
||||
**Verifica:** `scripts/research/xsec/verify_survivors.py` (3 scettici, deterministico)
|
||||
**Esito in una riga:** niente di deployabile; il cluster vincente appariscente è **una sola
|
||||
scommessa di regime (short alt-beta)**, ma **2 lead genuini** (XM09 trend-gated x-sec momentum,
|
||||
XR02 reversal vol-gated) sopravvivono a tutti gli scettici → **forward-monitor, non sleeve.**
|
||||
|
||||
## Contesto e motivazione
|
||||
|
||||
Dopo che il sweep BTC/ETH a 104 ipotesi (`2026-06-20-alt-strategies-100agent-sweep.md`) ha
|
||||
esaurito lo spazio direzionale single-asset confermando il soffitto ~1.3, la frontiera indicata era
|
||||
**cross-sectional / multi-asset** sul panel Hyperliquid certificato, dove quel soffitto non vincola
|
||||
e dove c'è spazio DISTINTO da XS01 (x-sec momentum semplice sui 19 major).
|
||||
|
||||
Nuova harness condivisa `xslib.py`: il panel è N asset × ~810 giorni (universo `all` = **49 alt**
|
||||
con ≥700g dopo il fix backfill; `majors` = 19 di XS01). Una strategia = uno **score per-asset
|
||||
causale** (dati ≤ close[i]); l'harness lo classifica cross-section ad ogni ribilanciamento, va long
|
||||
i top-k / short i bottom-k (market-neutral) o long-only, vol-targeta al 20%, addebita fee sul
|
||||
turnover, e — strutturalmente leak-free — il peso deciso a `i` incassa il return di `i+1` (stessa
|
||||
convenzione di `src.portfolio` xs_book / `sleeves._xsec_returns`).
|
||||
|
||||
**Scoring onesto** (`study_xs`): un candidato guadagna `earns_slot=True` SOLO se
|
||||
`full Sharpe>0 AND hold-out 2025+ Sharpe>0 AND marginal_vs(active)=="ADDS" AND corr(XS01)<0.6`.
|
||||
`ADDS` a sua volta richiede `holdUplift_w20 ≥ 0.05 AND robust_oos` (uplift hold-out >0.02 **e**
|
||||
jackknife drop-one-month tutti positivi). È il marginal scorer del sweep precedente, portato sul
|
||||
cross-sectional: si giudica **l'apporto al portafoglio live** (TP01+XS01+VRP01), non lo Sharpe
|
||||
assoluto.
|
||||
|
||||
**Caveat cotto dentro l'harness:** il panel è **~2.5 anni** (2024-26). Ogni risultato è
|
||||
SUGGESTIVO, non robusto come i 6 anni di BTC/ETH. E l'hold-out (2025-26) è **un singolo regime**
|
||||
(alt-bear/chop relativo a BTC).
|
||||
|
||||
## Find phase — 43 script, 257 sotto-config
|
||||
|
||||
11 famiglie cross-sectional: MOM (varianti momentum), REV (reversal), VOL/RISK (low-vol, low-beta,
|
||||
BAB, semivarianza, vol-of-vol), DIST (skew/coskew lottery), LIQ (Amihud/turnover/volume),
|
||||
VAL (distanza da MA, RSI), STRUCT (double-sort, ensemble z-vote, risk-parity, low-corr, trend-R²,
|
||||
lead-lag BTC), UNIV (sweep di universo). **Esito: 42/257 config `earns_slot=True`.**
|
||||
|
||||
Sembra molto. Ma **due tell** accomunano quasi tutti gli slot-earner:
|
||||
1. corr a TP01 **fortemente negativa** (−0.2…−0.4) — è *per questo* che "aggiungono";
|
||||
2. PnL **concentrato nel 2025** (ritorni +22%…+84% nel 2025).
|
||||
|
||||
Top per Sharpe/uplift (rappresentante per famiglia):
|
||||
|
||||
| id | meccanismo | univ | FULL Sh | HOLD Sh | upliftHold | jackknife | corr TP01 | corr XS01 |
|
||||
|----|-----------|------|---------|---------|-----------|-----------|-----------|-----------|
|
||||
| XR02-L3-p70-maj | reversal gated alta-vol | maj | 1.40 | **2.27** | 1.078 | 0.744 | 0.02 | 0.08 |
|
||||
| XV02_majors_H10k5 | low **idio**-vol | maj | 1.32 | 1.95 | 1.196 | 0.792 | −0.20 | −0.06 |
|
||||
| XL02-vz60r20-maj | vol-trend momentum | maj | **1.83** | 1.84 | 0.568 | 0.125 | 0.13 | 0.08 |
|
||||
| XM09_all | trend-gated x-sec mom | all | 1.29 | 1.59 | 0.556 | 0.355 | −0.07 | 0.25 |
|
||||
| XS01b-MAJ | double-sort mom×low-vol | maj | 1.36 | 1.23 | 0.427 | 0.16 | −0.29 | 0.38 |
|
||||
| XU02/XV01 lowvol | low realized-vol | maj | 1.05 | 0.98 | 0.425 | 0.186 | −0.34 | 0.16 |
|
||||
| XV03 lowbeta (BAB) | −beta | all | 0.36 | 0.71 | 0.22 | 0.051 | −0.38 | 0.19 |
|
||||
| XS06b lowcorr | −corr(asset,market) | all | 0.74 | 1.00 | 0.286 | 0.092 | −0.19 | 0.18 |
|
||||
|
||||
## Verify phase — 3 scettici (`verify_survivors.py`)
|
||||
|
||||
Ipotesi sotto test: *"non sono N edge indipendenti, ma UNA scommessa di regime — short la
|
||||
spazzatura high-beta nell'alt-bear 2024-26 — travestita da 30 maschere; il jackknife è robusto solo
|
||||
DENTRO quel regime."* Ricostruito il book più forte per famiglia e:
|
||||
|
||||
**S1 — matrice di correlazione mutua (>0.6 = stessa scommessa).** Esito SFUMATO:
|
||||
- Il cluster low-vol È una sola scommessa: **XV01 = XU02 = 1.00** (identici), XV01↔XV02 0.65,
|
||||
XV01↔XV03 0.67, XV02↔XV03 0.44.
|
||||
- MA **XM09, XL02, XS06b, XR02 sono distinti** dal cluster e tra loro (corr media off-diagonale
|
||||
solo **+0.20**, solo 18% delle coppie |r|>0.6). L'ipotesi "tutto una scommessa" è **parzialmente
|
||||
falsa**.
|
||||
|
||||
**S2 — carico su short-beta / short-market** (factor di riferimento sullo stesso panel:
|
||||
SHORTBETA = book su −beta; SHORTMKT = −market alt equal-weight):
|
||||
- **Cluster low-vol = short-alt-beta confermato:** XV03 1.00/0.70, XV01/XU02 **0.67/0.64**,
|
||||
XV02 0.44/0.37. *Non* market-neutral: è un tilt short del mercato alt.
|
||||
- **NON short-beta:** XM09 0.08/0.15, XR02 −0.21/−0.18, XL02 0.19/0.26, XS06b 0.36/0.39.
|
||||
|
||||
**S3 — Sharpe per anno solare (l'edge è ~solo 2025?):**
|
||||
|
||||
| survivor | 2024 | 2025 | 2026 |
|
||||
|----------|------|------|------|
|
||||
| XV02_lowidiovol | 0.07 | 1.87 | 2.12 |
|
||||
| XV01/XU02 lowvol | 1.17 | 1.52 | **−0.09** |
|
||||
| XV03_lowbeta | −0.25 | 0.98 | 0.12 |
|
||||
| XS06b_lowcorr | 0.26 | 1.34 | 0.32 |
|
||||
| **XM09_trendgmom** | **0.82** | **0.50** | **0.74** |
|
||||
| XL02_voltrendmom | 0.30 | **−0.14** | **−0.43** |
|
||||
| **XR02_revgated** | **0.84** | **0.40** | **2.68** |
|
||||
|
||||
## Conclusioni (oneste)
|
||||
|
||||
1. **Cluster low-vol / low-beta (XV01, XU02, XV02 in parte, XV03) = tilt short-alt-beta di regime.**
|
||||
S2 lo inchioda (carico 0.44-0.70 su short-market): non è un fattore market-neutral, è "short la
|
||||
spazzatura" mentre gli alt sanguinano vs BTC. XV01/XU02 **già in decadimento (2026 −0.09).** Non
|
||||
può dimostrare di sopravvivere a un flip alt-bull. → **RIGETTATO come sleeve.** Conferma
|
||||
l'osservazione 4874 (XS04b = regime-dependent short-beta tilt) generalizzata all'intera famiglia.
|
||||
|
||||
2. **XL02 (vol-trend momentum) = overfit al panel iniziale.** FULL Sharpe più alto (1.83) ma S3 lo
|
||||
uccide: 2025 −0.14, 2026 −0.43. Il numero full è guidato dal 2024, ora è morto. → **RIGETTATO.**
|
||||
|
||||
3. **2 LEAD genuini** — distinti (S1), NON short-beta (S2), positivi in **tutti e 3 gli anni** (S3):
|
||||
- **XM09 — cross-sectional momentum gated dal trend di mercato.** Long top-k/short bottom-k alt,
|
||||
attivo solo quando la somma trailing del mercato equal-weight è >0. Sharpe 0.82/0.50/0.74,
|
||||
short-beta-load 0.08, corr TP01 −0.07, uplift hold 0.556 / jackknife 0.355. È il candidato più
|
||||
regime-robusto. **Caveat:** stessa FAMIGLIA di XS01 (x-sec momentum) su universo più largo (49)
|
||||
con gate diverso (trend di mercato vs dispersione) → più un **possibile affinamento di XS01**
|
||||
che una sleeve nuova; corr XS01 0.25, ma marginal scorer dice che ADDS oltre XS01.
|
||||
- **XR02 — short-term reversal gated da alta-vol.** Reversal a 3g attivo solo quando la vol
|
||||
realizzata di mercato è nel regime alto (>p70 espandente). Sharpe 0.84/0.40/**2.68**,
|
||||
short-beta-load −0.21, corr a tutto il resto ~0/negativa, hold-out Sharpe 2.27. Microstruttura
|
||||
reale (overreaction in panico). **Caveat:** H=3 → **turnover alto**; il reversal vive proprio
|
||||
sull'illiquidità che lo rende costoso da eseguire (l'harness addebita fee sul turnover e regge,
|
||||
ma il fill reale su alt minori è ottimistico).
|
||||
|
||||
## Perché NON deployabili adesso (caveat trasversali)
|
||||
|
||||
- **Panel ~2.5 anni a regime unico.** Anche i 2 lead hanno hold-out = 2025-26 = stesso macro-regime.
|
||||
Suggestivi, non robusti come i 6 anni BTC/ETH.
|
||||
- **STAT-MODE di esecuzione.** Un book cross-sectional a 10-19 gambe (long-k+short-k) su alt non è
|
||||
eseguibile col capitale attuale (conto reale ~$600; servono ~$20k per gambe sensate, come già
|
||||
notato per XS01). Sono segnali da monitorare, non ordini.
|
||||
- **Lezione confermata (di nuovo):** su un panel corto a regime unico il jackknife drop-one-month
|
||||
certifica la robustezza DENTRO il regime, non ATTRAVERSO i regimi. Il discriminante decisivo è
|
||||
stato **S2 (carico su short-beta) + S3 (consistenza per-anno)**, non lo Sharpe né l'uplift
|
||||
hold-out (che il cluster regime-bet aveva altissimi: upliftHold fino a 1.20).
|
||||
|
||||
## Azioni
|
||||
|
||||
- **Nessuna modifica al portafoglio live** (TP01 55% + XS01 25% + VRP01 20% invariato).
|
||||
- **Forward-monitor** i 2 lead (XM09, XR02) quando il panel HL accumula un secondo regime.
|
||||
- **XM09 come affinamento candidato di XS01** (gate trend di mercato + universo 49) da valutare a
|
||||
parità di sleeve, NON come sleeve aggiuntiva, in una prossima iterazione.
|
||||
- Harness `xslib.py` + 43 script + `verify_survivors.py` committati come riferimento riusabile.
|
||||
@@ -1,111 +0,0 @@
|
||||
# 2026-06-21 — Blind signal fleet: 52 agenti "esperti di segnali" su curve anonime BTC/ETH
|
||||
|
||||
## Obiettivo (richiesta utente)
|
||||
|
||||
Far partire ~50 subagenti **esperti di segnali** a cui passare lo storico di **ETH e BTC
|
||||
in forma ANONIMA** ("senza dire di cosa sono, con curve sovrapposte"): devono trovare come
|
||||
**anticipare l'andamento**, liberi di scrivere script o reti neurali ad hoc. L'**orchestratore**
|
||||
valuta la validità su **PnL e maxDD**.
|
||||
|
||||
L'idea forte del setup cieco: se gli agenti non sanno che sono BTC/ETH, non possono
|
||||
pattern-matchare a memoria il crash COVID 2020 / l'orso 2022 / l'halving 2024 — devono trovare
|
||||
un timing **trasferibile**, non riconoscere l'era. È anche un test di onestà del metodo: l'edge
|
||||
deve reggere su un hold-out che gli agenti non hanno mai visto.
|
||||
|
||||
## Setup — harness cieco e leak-free (prima degli agenti)
|
||||
|
||||
> 50 agenti su un harness che perde = 50 fantasie (lezione fondante del progetto). Quindi prima
|
||||
> l'infrastruttura, poi la flotta.
|
||||
|
||||
- `scripts/research/blind/make_blind.py` — esporta BTC/ETH **1d** (via il path certificato
|
||||
`altlib.get`) come **"Series A" / "Series B"**: rebase a **100** (curve sovrapposte, il livello
|
||||
non urla più "$60k bitcoin"), **calendario sintetico** dal 2001 (niente era-crypto da
|
||||
riconoscere), volume normalizzato alla mediana. Split **70% train (visibile agli agenti) / 30%
|
||||
test (solo orchestratore)**. Mapping A=BTC, B=ETH tenuto FUORI dal meta visibile.
|
||||
- `scripts/research/blind/blindlib.py` — l'unico modulo che un agente importa. Evaluator
|
||||
leak-free: la posizione decisa a `close[i]` è **shiftata** e tenuta nella barra `i+1` (impossibile
|
||||
leakare moltiplicando un peso per il rendimento della stessa barra), fee su turnover (Deribit
|
||||
0.10% RT). Toolkit di indicatori causali ri-esportati da altlib.
|
||||
- **Guardia di causalità automatica** (`causality_ok`): ri-chiama `signal()` su un **prefisso
|
||||
troncato** e pretende che la coda combaci con `signal()` sull'array intero. Qualunque segnale che
|
||||
sbircia il futuro (shift(-k), finestre centrate, fit globale, statistiche full-sample) **diverge →
|
||||
squalificato**. È ciò che rende onesta anche la "rete neurale ad hoc": un modello fittato sul df
|
||||
intero (che a test-time contiene il futuro) fallisce la guardia; passa solo l'expanding/walk-forward.
|
||||
- `score_all.py` — il **giudice unico dell'orchestratore**: per ogni modulo gira la guardia, valuta
|
||||
sul **test held-out** A e B, ordina per PnL/maxDD vs benchmark buy&hold.
|
||||
- `verify_top.py` — secondo strato avversariale: corr al trend canonico TSMOM, fee-stress 0.20% RT,
|
||||
jackknife drop-block.
|
||||
|
||||
Verifica dell'harness: momentum onesto → causale ok, OOS +44% a 19% DD; segnale **deliberatamente
|
||||
leaky** (guarda domani) → Sharpe 18 assurdo ma **correttamente squalificato**. Benchmark buy&hold
|
||||
OOS sul tail = **−7% PnL, 68% DD, Sharpe 0.22** (il tail 2024-26 contiene un drawdown brutale →
|
||||
anticipare il movimento ha spazio reale per vincere).
|
||||
|
||||
## Flotta — 52 agenti, 52 ipotesi distinte
|
||||
|
||||
Workflow `blind-signal-fleet` (52 agenti in parallelo, ~2h, 2.5M token, 971 tool-call). A ognuno
|
||||
**un'ipotesi diversa** (per non riscoprire tutti il momentum): 11 famiglie — trend/TSMOM,
|
||||
breakout (Donchian/Keltner/squeeze/pivot/volbreak), mean-rev/oscillatori (RSI/Bollinger/zrev/stoch/
|
||||
DPO/WillR), vol-regime (vol-target/regime-switch/ATR-ride/dd-derisk/**vol-of-vol**), struttura
|
||||
(HHLL/channel-pos), statistici (Hurst/autocorr/efficiency/skew/entropy), ciclo (FFT/Kalman),
|
||||
volume (OBV/PVT/vol-div), **8 ML** (Ridge, logistic, MLP-reg, MLP-clf, GBM, kNN-analog, RLS,
|
||||
RandomForest) e 5 meta/ensemble.
|
||||
|
||||
**Esito flotta: 52/52 riportati, 52/52 passano la guardia di causalità** (zero look-ahead — la
|
||||
disciplina dell'harness ha tenuto su tutta la flotta, ML inclusi).
|
||||
|
||||
## Risultati OOS (orchestratore — PnL & maxDD sul test held-out)
|
||||
|
||||
Benchmark buy&hold OOS: **PnL −7%, maxDD 68%**. Top per Sharpe-min (peggiore tra A e B):
|
||||
|
||||
| # | strategia | PnL_A | PnL_B | DD worst | Sh_min | famiglia |
|
||||
|---|---|---|---|---|---|---|
|
||||
| 1 | macd | +23% | +19% | **11%** | 0.84 | trend |
|
||||
| 2 | accel | +40% | +22% | 12% | 0.79 | trend (2ª diff) |
|
||||
| 3 | vol_of_vol | +30% | +32% | 21% | 0.69 | vol-regime |
|
||||
| 4 | regime_switch | +25% | +46% | 20% | 0.63 | vol-regime |
|
||||
| 5 | rf (ML) | +12% | +8% | **7%** | 0.62 | ML walk-fwd |
|
||||
| 6 | obv | +22% | +20% | 16% | 0.60 | volume |
|
||||
|
||||
Tutti i top sono varianti **trend/vol-regime**. Mean-reversion e ML (logistic/gbm/mlp) in fondo →
|
||||
ri-conferma cieca di "mean-rev morto" e "ML walk-forward debole" del progetto. Lo **Sharpe OOS ~0.84
|
||||
decade dal train ~1.4** (firma classica di overfit/regime). Ma vs buy&hold (−7%/68% DD) i top trend
|
||||
**ribaltano il segno e tagliano il DD ~3-6×**: è il valore reale, identico alla lezione TP01.
|
||||
|
||||
## Verifica avversariale — 3 scettici indipendenti (REFUTE, non confirm)
|
||||
|
||||
1. **Regime-luck** → **REFUTED ×3.** I top-5 bar su ~800 OOS forniscono il **67-102% di tutto il
|
||||
PnL**; togliendo 10 bar la serie va **negativa**; `accel` crolla nel terzo finale (COMB Sharpe
|
||||
**−1.21**); A e B non concordano su *quando* funziona. Edge concentrato, non distribuito.
|
||||
2. **Trend-redundancy** → **REFUTED ×4.** Regressione `cand ~ α + β·TSMOM` (Newey-West HAC):
|
||||
**t(α) = +0.92..+1.51, nessuno supera 1.96**. corr-al-trend 0.34-0.74, β 0.45-0.73; media residua
|
||||
+0.05-0.08/anno = rumore. Sono TSMOM meglio tarati, **non alpha ortogonale**; contro il TP01 reale
|
||||
(~1.3) il margine svanisce.
|
||||
3. **Overfit/robustezza** → MACD **non-refuted** (plateau vero a un asse, 0% celle <0.5) ma Sharpe OOS
|
||||
onesto **0.84, non 1.40** (numero da docstring = in-sample). `accel` **REFUTED** (il termine di
|
||||
accelerazione, la sua tesi, **danneggia** l'OOS; LAG knife-edge: −20% → −63% Sharpe; corner
|
||||
congiunti negativi). `vol_of_vol` **REFUTED** (gate threshold-fit: PCTL 0.80→0.60 distrugge il 73%
|
||||
dello Sharpe OOS). Fee = drag secondario ~10%, non il killer; il killer è la sensibilità ai parametri.
|
||||
|
||||
## Verdetto
|
||||
|
||||
**52 agenti ciechi, orchestratore che valuta PnL e maxDD su hold-out, e NIENTE di nuovo
|
||||
sopravvive alla verifica avversariale.** Ogni "vincitore" è trend-beta di due curve strutturalmente
|
||||
rialziste; soffitto Sharpe OOS **~0.84** su questo singolo hold-out; nessun alpha statisticamente
|
||||
distinguibile dal TSMOM. È una **ri-conferma INDIPENDENTE e CIECA del soffitto direzionale ~1.3** del
|
||||
progetto e del pattern "TSMOM travestito" — raggiunta da agenti che non sapevano nemmeno fossero
|
||||
BTC/ETH. Il più solido è **macd** (plateau vero, OOS Sharpe 0.84, DD 11%): classe-TP01,
|
||||
**forward-monitor al più, non deploy**. Conferma le regole: (a) giudicare lo Sharpe **marginale vs
|
||||
TP01**, non assoluto; (b) un hold-out corto premia chi è stato fortunato in pochi bar.
|
||||
|
||||
### Valore metodologico (cosa resta)
|
||||
|
||||
L'harness cieco riusabile: `data/blind/` + `blindlib`/`blind_eval`/`score_all`/`verify_top`. La
|
||||
**guardia di causalità online** ha tenuto 52 strategie (ML incluso) leak-free senza intervento
|
||||
manuale → strumento da riusare per ogni futura flotta. La pipeline "anonimizza → fan-out cieco →
|
||||
giudice unico OOS → 3 scettici (regime-luck / trend-redundancy / overfit)" ha ucciso ogni falso
|
||||
positivo che lo Sharpe assoluto avrebbe promosso.
|
||||
|
||||
File: `scripts/research/blind/{make_blind,blindlib,blind_eval,score_all,verify_top}.py`,
|
||||
`agents/agent_00..51_*.py` (52 moduli), `leaderboard.json`, `verify_top.json`,
|
||||
`SKEPTIC_VERDICTS.json`. Dati rigenerabili: `data/blind/` (gitignored).
|
||||
@@ -1,88 +0,0 @@
|
||||
# 2026-06-21 — Asse intraday/microstruttura: il lead più vicino al reale, ma NON deployabile
|
||||
|
||||
## Perché (utente: "cerchiamo qualcosaltro")
|
||||
|
||||
Direzionale e relative-value su BTC/ETH esauriti (flotte blind + ortho). L'unico asse mai
|
||||
sfruttato dopo il reset = il **tempo intraday** (feed certificati 5m/15m/1h; tutto era a 1d).
|
||||
Meccanismi diversi da trend e relative-value: bias ora/sessione (perp con funding a 00/08/16 UTC),
|
||||
reversione post-evento (vol/volume/gap), breakout del range del giorno prima.
|
||||
|
||||
## Setup
|
||||
|
||||
`scripts/research/intraday/intra_score.py`: wrappa `altlib.study_marginal` a un TF a scelta
|
||||
(compone i rendimenti intraday a daily, li valuta col **marginal scorer indurito** = multi-cut +
|
||||
edge-in-sample + hedge-vs-alpha) e riporta **turnover + fee-sweep a 0.20% RT**. Il muro: a 0.10% RT
|
||||
il churn intraday è morte (un flip orario fa 2152 trade/anno → −8.6 Sharpe netto). Vincolo agli
|
||||
agenti: **basso turnover**, l'intraday come informazione (timing/sizing/gating), non HFT.
|
||||
|
||||
## Flotta — 16 agenti
|
||||
|
||||
16 ipotesi low-turnover. Esito grezzo: 16 riportati, **10 "earns_slot"** (di nuovo gonfiato).
|
||||
|
||||
## Diagnosi orchestratore — separare ortogonale vero da trend-beta
|
||||
|
||||
Per corr-a-TP01 (`meta_intra.py`): 2 sono **trend-beta** (close_location 0.81, trend_quality 0.75 —
|
||||
Sharpe in-sample alto ma preso in prestito dal trend), 3 **mixed**, **5 genuinamente ortogonali**
|
||||
(|corr|<0.4): open_drive (0.13), prevday_range_breakout (0.15), vol_event_revert_15m (−0.1),
|
||||
volume_spike_revert (0.14), gap_fill (0.04) — 2 famiglie (breakout-continuation + capitulation-revert),
|
||||
mutuamente de-correlate. **Combo dei 5: Sharpe standalone 1.80, corr-TP01 0.17, uplift +0.33/+0.27/
|
||||
+0.34/+0.34/+0.53 a OGNI cut** (non solo 2025).
|
||||
|
||||
## Gauntlet deterministico (`verify_intra.py`) — passa TUTTO ciò che uccise le onde precedenti
|
||||
|
||||
- **In-sample pre-2025 Sharpe 1.75; uplift pre-2025-ONLY +0.281** (l'ortho faceva +0.027 = null).
|
||||
- **Walk-forward selection** (scegli su solo passato, testa avanti): **+0.303 / +0.368** (l'ortho dava −0.07).
|
||||
- **Drop-one robusto** (+0.24..+0.31 pre-2025), **fee-robusto a 0.30% RT**, **leak-free**
|
||||
(online-consistency: max_tail_diff = 0.0 su tutti e 5). Sembrava IL lead.
|
||||
|
||||
## Verifica avversariale (3 scettici indipendenti) — il verdetto vero
|
||||
|
||||
1. **Execution/microstruttura:** **open_drive = ARTEFATTO di etichettatura UTC.** Spostando il
|
||||
confine del giorno di 4h l'uplift va NEGATIVO (−0.10); togliendo l'ancora UTC (trailing-8h) Sharpe
|
||||
0.01; funziona solo a 00:00 UTC, solo alle ore 3 e 7. **Scartare.** `prevday_range_breakout` invece
|
||||
**REGGE** (plateau su k, robusto allo shift del confine, fill eseguibili a close) = unico candidato
|
||||
onesto, ma la decorrelazione viene tutta dalla gamba SHORT che si appoggia al regime down 2025-26;
|
||||
anchor=1 only. **Caveat $600:** il vol-target fa ~8500 ribilanciamenti/anno, 97-98% < $1 di nozionale
|
||||
→ la fee proporzionale modellata su trade infinitesimi è **finzione** a $300/gamba (vale anche per TP01).
|
||||
2. **Hedge + tail:** **REFUTED.** L'uplift pre-2025 +0.281 sta al **20-24° percentile del null di un
|
||||
asset a corr-zero** (mediana null +0.371) — essendo a corr +0.175 (non 0) e bassa vol, **aggiunge
|
||||
MENO del rumore scorrelato**. È **hedge** (corr Sharpe-TP01/uplift −0.57..−0.80; TP01-down uplift
|
||||
+0.79 vs TP01-up +0.20) e **tail-luck** (le gambe revert: top-5 giorni = 76-83% del PnL, <10
|
||||
eventi/anno, front-loaded 2019-21; combo: metà uplift in ~10 giorni).
|
||||
3. **Overfit/robustezza:** **ROBUST-PLATEAU** (243-cell joint grid pre-2025 uplift min +0.134/med
|
||||
+0.211, 99% celle >+0.15; ogni anno positivo). MA segnala lui stesso il **null-pctl 0.20**: "il
|
||||
beneficio è la matematica di diversificazione di uno stream ortogonale a Sharpe 1.75, NON timing-alpha
|
||||
specifico-TP01" + storia corta sulle gambe revert + fill modellati vs reali.
|
||||
|
||||
## Verdetto
|
||||
|
||||
**Niente in live.** L'asse intraday ha prodotto il lead **più vicino al reale** di tutta la ricerca,
|
||||
ma sotto 3 scettici: **open_drive è artefatto** (UTC-labeling); la combo **fallisce il null a
|
||||
corr-zero** (aggiunge meno del rumore), è **hedge-shaped** e **tail-luck**; e lo Sharpe modellato è
|
||||
gonfiato dal micro-ribilanciamento sub-dollaro a $600. Lo Sharpe standalone 1.80 NON è affidabile
|
||||
(artefatto + coda + finzione di fill). **Resta solo TP01.**
|
||||
|
||||
**Lead reale (forward-monitor, non deploy):** `prevday_range_breakout` — l'unico segnale sopravvissuto
|
||||
allo scettico d'esecuzione (breakout del range del giorno prima, eseguibile, leak-free), con caveat
|
||||
short-leg/regime-2025. Trattamento = come `dvol_spread` / XS01 / STA05.
|
||||
|
||||
### Lezioni harness — CODIFICATE (il vero ritorno)
|
||||
|
||||
1. ✅ **`altlib.day_boundary_robust(target_fn, tf)`** — shifta il confine del giorno UTC e ri-misura
|
||||
l'uplift marginale: INVARIANT (segnale di prezzo, spread 0) / ROBUST (effetto calendario vero,
|
||||
resta positivo) / **ARTIFACT-RISK** (l'uplift si inverte = etichettatura). Verificato: riproduce
|
||||
da solo il verdetto degli scettici — open_drive → ARTIFACT-RISK (+0.23→−0.33), prevday_breakout
|
||||
→ ROBUST. Test `tests/test_harness_realism.py`.
|
||||
2. ✅ **`altlib.eval_weights_smallcap(df, target, capital=600, min_order=5)`** — salta i
|
||||
ribilanciamenti sub-min_order (la finzione del micro-trading a $600), riporta lo Sharpe haircut
|
||||
reale vs modellato. Vale per ogni sleeve a questo capitale, TP01 incluso. Test idem.
|
||||
3. ✅ **`altlib.causality_ok(target_fn, tf)`** — guardia look-ahead/online-consistency (ricalcola
|
||||
il target su un prefisso e pretende che la coda combaci con il full): eval_weights shifta la
|
||||
posizione ma NON vede una feature non-causale (finestra centrata / shift(-k) / stat full-sample).
|
||||
Integrata in `intra_score` (un leak è squalificato prima dello scoring). + il calendar-artifact
|
||||
gate (`day_boundary_robust`) ora gira dentro `intra_score`: **open_drive/weekly_seasonality/
|
||||
overnight → CAL-ARTIFACT, fuori dagli slot da soli**; prevday_breakout resta (ROBUST). Il lab
|
||||
intraday ora auto-becca leak e artefatti-calendario che ieri richiedevano gli scettici. Test idem.
|
||||
|
||||
File: `scripts/research/intraday/{intra_score,meta_intra,verify_intra}.py`,
|
||||
`agents/agent_00..15_*.py`, `intra_leaderboard.json`.
|
||||
@@ -1,99 +0,0 @@
|
||||
# 2026-06-21 — Caccia all'ORTOGONALE a TP01: relative-value BTC/ETH (eseguibile a $600)
|
||||
|
||||
## Perché (richiesta utente: "cerca ortogonale a TP01")
|
||||
|
||||
La flotta cieca (stesso giorno) ha confermato: niente di NUOVO in direzionale BTC/ETH — tutto è
|
||||
trend-beta di TP01 (soffitto ~1.3). L'unica via a un nuovo slot LIVE è un meccanismo **ortogonale**
|
||||
(bassa correlazione, alpha residua). Il più promettente **eseguibile al capitale reale ~$600** è un
|
||||
**book RELATIVE-VALUE a 2 gambe BTC/ETH** (long una / short l'altra), grosso modo market-neutral →
|
||||
correlazione naturale bassa col trend, e a 2 gambe è eseguibile (a differenza del book a 19 gambe di
|
||||
XS01 che serve ~$20k).
|
||||
|
||||
## Setup — ortho-lab + giudice MARGINALE (non Sharpe assoluto)
|
||||
|
||||
`scripts/research/ortho/ortholib.py`: BTC/ETH 1d allineati su date comuni; `eval_book(book_fn)` con
|
||||
`book(btc,eth)->(w_btc,w_eth)`, **shift di entrambe le gambe** (no leak), fee su entrambe, serie netta
|
||||
**giornaliera**; guardia di causalità online; check **eseguibilità a $600** (max gamba ≤ 0.5 = cap
|
||||
$300/asset). Il giudice è `altlib.marginal_vs_tp01`: **corr a TP01, uplift OOS del blend, alpha
|
||||
residua, robust_oos** (clean-year + jackknife drop-month). Verdetto = ADDS, **non** Sharpe assoluto.
|
||||
`ortho_score.py` (giudice), `meta_ortho.py` (corr mutua + persistenza multi-cut), `sleeve_rv.py`.
|
||||
|
||||
Sanity: ratio-momentum → ADDS (corr 0.05); ratio-mean-reversion → DILUTES. L'harness discrimina.
|
||||
|
||||
## Flotta — 18 agenti relative-value (~40 min)
|
||||
|
||||
18 ipotesi distinte: ratio-momentum multi-orizzonte, XS a 2 asset, beta-neutral residuo, Donchian
|
||||
sul ratio, EMA-cross, accel, carry lento, Kalman-spread, gate-correlazione, gate-vol, inverse-vol,
|
||||
rebalance-harvest, lead-lag, **DVOL-spread**, **VRP relativo**, dispersione, ensemble.
|
||||
|
||||
**Esito grezzo: 18 riportati, 17 "ADDS / earns_slot".** → **bandiera rossa**: non esistono 17 alpha.
|
||||
Gli agenti stessi l'hanno annotato ("hold-out corto ~537g", "uplift dipende dal regime ETH-bleed
|
||||
2025", "forward-monitor non full-weight").
|
||||
|
||||
## Diagnosi dell'orchestratore — il "17 slot" è gonfiato
|
||||
|
||||
1. **Una scommessa o tante?** corr mutua media **0.43** → collassano a **8 rappresentanti**
|
||||
de-correlati. Non 17, non 1.
|
||||
2. **Persistente o solo finestra 2025?** `marginal_vs_tp01` fissa l'hold-out al 2025-01-01 = proprio
|
||||
la finestra dove ETH ha perso vs BTC e TP01 è debole. Ri-misurando l'uplift a **più cut**
|
||||
(2022/23/24/25): il basket selection-free era +0.06/+0.06/+0.11/+0.38 (positivo ovunque ma
|
||||
crescente verso il 2025). Smaschera anche i **falsi** che il robust_oos fisso-2025 non vede:
|
||||
`kalman_spread` (−0.14/−0.16/−0.10 poi +0.37) e `xs2_zscore` sono **2025-only**.
|
||||
3. **Selezione walk-forward (senza hindsight):** scegliere i top-4 per uplift sul **solo passato** e
|
||||
testare in avanti → uplift **−0.07** (sel <2023) / +0.05 (<2024) / +0.43 (<2025). **Scegliere la
|
||||
variante vincente in anticipo è inaffidabile**; il mio "curated 4" è in parte hindsight.
|
||||
|
||||
## Verifica avversariale (scettico indipendente) — REFUTED
|
||||
|
||||
Sul **basket selection-free** (equal-weight di tutti i book market-neutral, NESSUN cherry-picking):
|
||||
- standalone Sharpe **0.61**, maxDD 15%, **corr a TP01 0.05** (genuinamente ortogonale).
|
||||
- **uplift full +0.078 = pre-2025 +0.027 / solo-2025+ +0.401.** Il pre-2025 **+0.027 sta al 49°
|
||||
percentile di 500 asset-rumore a corr-zero** (+0.029 per costruzione) → è **matematica di
|
||||
diversificazione, non segnale**.
|
||||
- **corr(Sharpe annuo TP01, uplift annuo basket) = −0.87**; condizionato: TP01 su → +0.014, TP01 giù
|
||||
→ +0.369. **È un hedge dei drawdown di TP01, non un premio autonomo.** Paga nel 2022 (orso) e
|
||||
2025-26 (ETH-bleed) — i due anni peggiori di TP01 — rumore altrove (2023 −0.06, 2024 −0.12).
|
||||
- Block-bootstrap P(uplift>0): full 90%, **pre-2025 66% (testa o croce)**, 2025+ 99%.
|
||||
- Fee: a **0.30% RT il pre-2025 va NEGATIVO** (−0.021); sopravvive solo il numero del regime 2025.
|
||||
- Eseguibilità OK ($264/gamba, turnover 12/yr) — non è quello il problema.
|
||||
|
||||
## Verdetto
|
||||
|
||||
**Niente di questa flotta merita uno slot LIVE.** Il meccanismo relative-value BTC/ETH è REALE e
|
||||
genuinamente ortogonale (corr ~0.05), ma è un **hedge della debolezza di TP01 travestito da alpha**:
|
||||
il suo contributo pre-2025 è indistinguibile da un asset-rumore a corr-zero (49° percentile del null)
|
||||
e muore a fee realistiche; l'unico payoff vero è una singola finestra di 537 giorni (2025-26).
|
||||
Deployarlo = deployare un backtest mono-regime. **Resta live solo TP01** (l'unica cosa che supera
|
||||
tutto questo scrutinio). Coerente con XS01 (stessa famiglia cross-sectional): diversificatore
|
||||
da monitorare, non alpha da eseguire — e la versione a 2 asset è ancora più sottile della 19-gambe.
|
||||
|
||||
### Valore metodologico (cosa resta, ed è importante)
|
||||
|
||||
- **Il marginal scorer fisso-2025 è ingannabile** (17/18 "ADDS"). Ciò che ha ucciso i falsi positivi:
|
||||
**persistenza multi-cut** + **selezione walk-forward** + **bootstrap vs null a corr-zero**. Lezione
|
||||
da cablare nello scorer: testare PIÙ cut e confrontare l'uplift col **null di un asset-rumore
|
||||
ortogonale** (un'asset scorrelato con drift positivo "aggiunge" +0.03 per pura matematica — non è
|
||||
un edge). Un basso-corr che paga solo quando il core è debole è un **hedge**, va prezzato come tale.
|
||||
- Lab riusabile: `ortholib`/`ortho_score`/`meta_ortho` (giudice marginale + persistenza). I 18 book +
|
||||
`sleeve_rv.py` (curated, **selection-biased — non deployare**) restano come riferimento.
|
||||
|
||||
File: `scripts/research/ortho/{ortholib,ortho_score,meta_ortho,sleeve_rv}.py`,
|
||||
`agents/agent_00..17_*.py`, `ortho_leaderboard.json`, skeptic `skeptic_{basket,regime,null}.py`.
|
||||
|
||||
## AGGIORNAMENTO — lezione codificata in `altlib.marginal_vs_tp01` (stesso giorno)
|
||||
|
||||
I tre gate sono ora **codice**, non solo prosa (test `tests/test_marginal_scorer.py`, +5 test):
|
||||
1. **persistenza multi-cut** (`multicut_uplift`/`multicut_persistent`): uplift a ogni inizio anno,
|
||||
non solo all'HOLDOUT fisso → uccide i 2025-only (es. `kalman_spread`, negativo a ogni cut pre-2025).
|
||||
2. **edge in-sample** (`has_insample_edge`): lo Sharpe standalone PRE-holdout dev'essere ≥0.5. È il
|
||||
discriminante onesto (la basket faceva 0.29). I `null_pctl_*` (vs asset-rumore a corr-zero) restano
|
||||
come CONTESTO — mostrano che un low-corr "aggiunge" ~+0.03 per matematica, vero per sleeve buoni e
|
||||
cattivi, quindi non possono essere IL gate; l'edge in-sample sì.
|
||||
3. **hedge vs alpha** (`is_hedge`): `corr(Sharpe-TP01, uplift annuo)` molto negativa + paga solo
|
||||
quando TP01 è giù → HEDGE, non alpha.
|
||||
|
||||
Verdetti nuovi **HEDGE** e **NOISE**; `earns_slot` ora pretende ADDS + robust_oos + has_insample_edge
|
||||
+ not is_hedge. **Sull'onda ortho lo scorer indurito ribalta 17/18 "ADDS" → 1** (`dvol_spread`, unico
|
||||
con edge in-sample reale 0.57; gli altri 16 → NOISE/HEDGE). Controllo: un sleeve sintetico Sharpe~1.3
|
||||
scorrelato resta **ADDS** (non rigetta i diversificatori veri — XS01-like). La verifica avversariale
|
||||
di 3 giorni è ora una chiamata di funzione.
|
||||
@@ -1,109 +0,0 @@
|
||||
"""EVALUATOR STANDARD per i segnali della ricerca multi-agente (Fase frattale, v2.0.0).
|
||||
|
||||
Ogni agente scrive SOLO una funzione `signal(df, asset, tf) -> np.ndarray` (posizione per barra
|
||||
in [-1,1], decisa entro close[i]) in un file. Questo evaluator la valuta in modo UNIFORME e ONESTO
|
||||
sull'harness research_lab, e — cruciale — esegue un GUARD ANTI-LOOK-AHEAD automatico: ricalcola il
|
||||
segnale su prefissi del df e verifica che pos[i] non dipenda da barre future (leak>0 = sospetto).
|
||||
|
||||
uv run python scripts/analysis/eval_signal.py <signal_file.py> <BTC|ETH> <5m|15m|1h> [--holdout]
|
||||
|
||||
Stampa una riga "RESULT_JSON:{...}" con tutte le metriche (gli agenti riportano quei campi esatti).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
import json
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from scripts.analysis.research_lab import backtest, buy_hold, mc_pvalue, load_tf, ts, _net_series, VAL_START, HOLDOUT_START
|
||||
|
||||
|
||||
def load_signal(path):
|
||||
spec = importlib.util.spec_from_file_location("usig", path)
|
||||
m = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(m)
|
||||
if not hasattr(m, "signal"):
|
||||
raise AttributeError("il file non definisce signal(df, asset, tf)")
|
||||
return m.signal
|
||||
|
||||
|
||||
def causality_guard(signal, df, asset, tf, k=12):
|
||||
"""Ricalcola il segnale su prefissi df[:i+1] e confronta pos[i] col run completo.
|
||||
Se differiscono -> il segnale usa dati FUTURI (look-ahead). Ritorna #violazioni (0 = pulito)."""
|
||||
full = np.asarray(signal(df, asset, tf), float)
|
||||
n = len(df)
|
||||
if len(full) != n:
|
||||
return -1
|
||||
rng = np.random.default_rng(0)
|
||||
idx = rng.integers(int(n * 0.6), n - 1, size=k)
|
||||
bad = 0
|
||||
for i in idx:
|
||||
try:
|
||||
p = np.asarray(signal(df.iloc[:i + 1].copy(), asset, tf), float)
|
||||
except Exception:
|
||||
bad += 1; continue
|
||||
if len(p) != i + 1 or not np.isclose(np.nan_to_num(p[i]), np.nan_to_num(full[i]), atol=1e-6):
|
||||
bad += 1
|
||||
return bad
|
||||
|
||||
|
||||
def main():
|
||||
args = sys.argv[1:]
|
||||
holdout = "--holdout" in args
|
||||
args = [a for a in args if a != "--holdout"]
|
||||
sigfile, asset, tf = args[0], args[1].upper(), args[2]
|
||||
res = {"asset": asset, "tf": tf, "sigfile": sigfile}
|
||||
try:
|
||||
signal = load_signal(sigfile)
|
||||
df = load_tf(asset, tf)
|
||||
pos = np.asarray(signal(df, asset, tf), float)
|
||||
res["n"] = int(len(df))
|
||||
res["len_ok"] = bool(len(pos) == len(df))
|
||||
if not res["len_ok"]:
|
||||
res["error"] = f"len(pos)={len(pos)} != len(df)={len(df)}"
|
||||
print("RESULT_JSON:" + json.dumps(res)); return
|
||||
res["finite"] = bool(np.isfinite(np.nan_to_num(pos, nan=0.0)).all())
|
||||
res["leak"] = int(causality_guard(signal, df, asset, tf))
|
||||
full = backtest(df, pos, tf)
|
||||
oos = backtest(df, pos, tf, lo=VAL_START, hi=HOLDOUT_START)
|
||||
bh = buy_hold(df, tf)
|
||||
_, p, _, _ = mc_pvalue(df, pos, tf, n=250)
|
||||
res.update(
|
||||
implemented=True,
|
||||
full_sharpe=round(full.sharpe, 3), full_ret=round(full.ret, 3), full_dd=round(full.maxdd, 3),
|
||||
oos_sharpe=round(oos.sharpe, 3), bh_sharpe=round(bh.sharpe, 3),
|
||||
gross_sharpe=round(backtest(df, pos, tf, fee_rt=0.0).sharpe, 3),
|
||||
fee02_sharpe=round(backtest(df, pos, tf, fee_rt=0.002).sharpe, 3),
|
||||
turnover=round(full.ntrades, 1), exposure=round(full.exposure, 3),
|
||||
null_p=round(p, 4),
|
||||
beats_bh=bool(full.sharpe > bh.sharpe and oos.sharpe > 0),
|
||||
)
|
||||
# breadth per-anno (pre-hold-out): % anni positivi, anni rossi consecutivi
|
||||
net, _, _, _ = _net_series(df, pos)
|
||||
s = pd.Series(net, index=ts(df))
|
||||
s = s[s.index < pd.Timestamp(HOLDOUT_START, tz="UTC")]
|
||||
yr = {int(y): float((1 + g).prod() - 1) for y, g in s.groupby(s.index.year)}
|
||||
vals = list(yr.values())
|
||||
max_consec_red = 0; cur = 0
|
||||
for v in vals:
|
||||
cur = cur + 1 if v < 0 else 0
|
||||
max_consec_red = max(max_consec_red, cur)
|
||||
res["per_year_preho"] = {y: round(v, 3) for y, v in yr.items()}
|
||||
res["pct_years_pos"] = round(sum(v > 0 for v in vals) / len(vals), 2) if vals else 0.0
|
||||
res["max_consec_red_years"] = int(max_consec_red)
|
||||
if holdout:
|
||||
ho = backtest(df, pos, tf, lo=HOLDOUT_START)
|
||||
res["holdout_sharpe"] = round(ho.sharpe, 3)
|
||||
res["holdout_ret"] = round(ho.ret, 3)
|
||||
res["holdout_dd"] = round(ho.maxdd, 3)
|
||||
except Exception as e:
|
||||
res["implemented"] = False
|
||||
res["error"] = f"{type(e).__name__}: {str(e)[:200]}"
|
||||
print("RESULT_JSON:" + json.dumps(res))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,132 +0,0 @@
|
||||
"""FETCH + CERTIFY universo Hyperliquid (Cerbero MCP MAINNET) — espansione cross-sectional.
|
||||
|
||||
Hyperliquid (via cerbero-mcp mainnet) offre ~230 perp liquidi, ma storia nativa REALE solo dal
|
||||
2024 (pre-2024 = backfill, volume 0). Qui scarico un set liquido a 1d (2024+), e CERTIFICO ogni
|
||||
asset come BTC/ETH: cross-venue vs Binance (realismo) + flat-bar + VOLUME (liquidita'). Scrivo SOLO
|
||||
i puliti in data/raw/hl_<sym>_1d.parquet (namespace dedicato, NON mischiato col Deribit BTC/ETH).
|
||||
|
||||
Disciplina: Cerbero ci ha gia' bruciato (testnet) -> niente fiducia, solo certificazione.
|
||||
|
||||
CORREZIONE estrazione (2026-06-20, "analisi fatte"): il floor START=2024-01-01 NON basta. Cerbero
|
||||
restituisce BACKFILL SINTETICO (volume==0, ma prezzi copiati da un venue di riferimento -> matchano
|
||||
Binance e NON sono flat) per il periodo PRIMA che l'asset quotasse davvero su Hyperliquid. Cosi'
|
||||
asset listati a meta'/fine 2024+ passavano cross-venue+flat ed erano certificati PULITO pur essendo
|
||||
in gran parte sintetici (es. AXS 83% backfill: trading reale solo da 2026-01; ALGO/SAND 37%). E' lo
|
||||
stesso errore v2.0.0 (edge su un book che non c'era). Fix: (1) il VOLUME e' il rivelatore di backfill
|
||||
-> si TAGLIA il run iniziale di barre a volume 0 e si tiene solo la serie NATIVA; (2) gate su storia
|
||||
nativa minima (>= MIN_NATIVE_DAYS reali) -> scarta chi e' troppo corto dopo il taglio; (3) gate su
|
||||
volume-0 INTERNO (gap di liquidita') oltre il taglio iniziale; (4) cross-venue/flat ricalcolati SOLO
|
||||
sulle barre reali; (5) i parquet degli asset scartati vengono RIMOSSI (disco == set certificato).
|
||||
|
||||
uv run python scripts/analysis/fetch_hyperliquid.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys, time
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd, requests, ccxt
|
||||
|
||||
RAW = PROJECT_ROOT / "data" / "raw"
|
||||
START = "2024-01-01"; END = pd.Timestamp.now("UTC").strftime("%Y-%m-%d") # dinamico (refresh giornaliero)
|
||||
MIN_NATIVE_DAYS = 365 # storia NATIVA reale minima (post-taglio backfill) per entrare nell'universo
|
||||
INTERIOR_VOL0_MAX = 5.0 # % max di barre a volume 0 DOPO il taglio iniziale (gap di liquidita' interni)
|
||||
# UNIVERSO ESTESO: alt liquidi noti su Hyperliquid (mappa Binance auto = SYM/USDT). Il gate di
|
||||
# certificazione (cross-venue + liquidita' + flat) scarta i non-conformi. k-prefissi esclusi
|
||||
# (scaling 1000x complica il cross-venue). MATIC morto escluso.
|
||||
SYMS = ["BTC","ETH","SOL","BNB","XRP","DOGE","AVAX","LINK","LTC","ADA","ARB","OP","SUI","APT",
|
||||
"INJ","TIA","SEI","NEAR","AAVE","ATOM","DYDX","APE","CRV","LDO","STX","GMX","SNX","BCH",
|
||||
"COMP","MKR","WLD","UNI","TRX","FIL","RUNE","ENA","ORDI","JUP","WIF","PYTH","FET","AR",
|
||||
"ETC","ALGO","GALA","SAND","AXS","DOT","FXS","BLUR","JTO","PENDLE","ONDO","TAO"]
|
||||
BINANCE = {s: f"{s}/USDT" for s in SYMS}
|
||||
|
||||
|
||||
def _h():
|
||||
env={}
|
||||
for ln in open(PROJECT_ROOT/".env.mainnet"):
|
||||
ln=ln.strip()
|
||||
if ln and not ln.startswith("#") and "=" in ln: k,v=ln.split("=",1); env[k]=v.strip()
|
||||
return {"Authorization":f"Bearer {env['CERBERO_TOKEN']}","X-Bot-Tag":env.get('CERBERO_BOT_TAG','fetch'),"Content-Type":"application/json"}
|
||||
|
||||
|
||||
def fetch_hl(sym, H, interval="1d"):
|
||||
r=requests.post("https://cerbero-mcp.tielogic.xyz/mcp/tools/get_historical",
|
||||
headers=H, json={"exchange":"hyperliquid","instrument":sym,"interval":interval,
|
||||
"start_date":START,"end_date":END}, timeout=60)
|
||||
c=r.json().get("candles",[])
|
||||
if not c: return pd.DataFrame()
|
||||
df=pd.DataFrame(c)[["timestamp","open","high","low","close","volume"]]
|
||||
return df.drop_duplicates("timestamp").sort_values("timestamp").reset_index(drop=True)
|
||||
|
||||
|
||||
def binance_daily(sym_b, start_ms, end_ms):
|
||||
ex=ccxt.binance({"enableRateLimit":True})
|
||||
out={}; since=start_ms
|
||||
while since<=end_ms:
|
||||
try: r=ex.fetch_ohlcv(sym_b,"1d",since=since,limit=500)
|
||||
except Exception: break
|
||||
r=[x for x in r if x[0]>=since]
|
||||
if not r: break
|
||||
for x in r:
|
||||
if start_ms<=x[0]<=end_ms and x[4]: out[int(x[0])]=float(x[4])
|
||||
nxt=int(r[-1][0])+86400000
|
||||
if nxt<=since: break
|
||||
since=nxt
|
||||
return pd.Series(out)
|
||||
|
||||
|
||||
def trim_backfill(df):
|
||||
"""Taglia il run INIZIALE di barre a volume 0 (= backfill sintetico pre-quotazione su HL).
|
||||
Ritorna (serie_nativa, n_barre_tagliate). Il volume e' il rivelatore: il backfill copia i
|
||||
prezzi da un venue di riferimento (non flat, matcha Binance) ma ha volume 0."""
|
||||
vol = df["volume"].to_numpy()
|
||||
lead = int(np.argmax(vol > 0)) if (vol > 0).any() else len(df)
|
||||
return df.iloc[lead:].reset_index(drop=True), lead
|
||||
|
||||
|
||||
def main():
|
||||
H=_h()
|
||||
print("="*100); print(" FETCH + CERTIFY Hyperliquid 1d (Cerbero mainnet) — cross-venue + flat + VOLUME (no backfill)"); print("="*100)
|
||||
print(f" {'sym':<6}{'reali':>6}{'bfill':>6}{'start_reale':>13}{'flat%':>7}{'vol0%':>7}{'med_bps':>9}{'>1%':>7}{'verdetto':>14}")
|
||||
certified=[]
|
||||
for s in SYMS:
|
||||
path = RAW/f"hl_{s.lower()}_1d.parquet"
|
||||
raw=fetch_hl(s,H)
|
||||
if raw.empty:
|
||||
print(f" {s:<6} vuoto"); path.unlink(missing_ok=True); continue
|
||||
# --- CORREZIONE: taglia il backfill sintetico (volume 0 iniziale), tieni la serie nativa ---
|
||||
df, n_bfill = trim_backfill(raw)
|
||||
if df.empty:
|
||||
print(f" {s:<6} tutto backfill (vol0) -> scarta"); path.unlink(missing_ok=True); continue
|
||||
ts=pd.to_datetime(df["timestamp"],unit="ms",utc=True)
|
||||
flat=((df.open==df.high)&(df.high==df.low)&(df.low==df.close)).mean()*100
|
||||
vol0=(df["volume"].to_numpy()==0).mean()*100 # gap di liquidita' INTERNI (post-taglio)
|
||||
# cross-venue vs Binance USDT (daily close) — SOLO sulle barre reali
|
||||
ref=binance_daily(BINANCE[s], int(df["timestamp"].iloc[0]), int(df["timestamp"].iloc[-1]))
|
||||
a=df.set_index("timestamp")["close"]
|
||||
m=pd.concat([a.rename("a"),ref.rename("b")],axis=1,join="inner").dropna()
|
||||
if len(m)>5:
|
||||
bps=(m["a"]-m["b"]).abs()/m["b"]*1e4
|
||||
med=bps.median(); g1=(bps>100).mean()*100
|
||||
else: med=g1=float("nan")
|
||||
# gate "delistato/migrato": l'ultima barra dev'essere recente (entro ~21g da END),
|
||||
# altrimenti l'asset tronca l'universo cross-sectional (es. MKR fermo a 2025-09, FXS 2026-01).
|
||||
recent = (pd.Timestamp(END, tz="UTC") - ts.iloc[-1]) <= pd.Timedelta("21D")
|
||||
# gate storia NATIVA: dopo il taglio dev'esserci abbastanza vita reale (es. AXS quotato 2026-01 -> scarta)
|
||||
native_days = (ts.iloc[-1] - ts.iloc[0]).days
|
||||
enough = native_days >= MIN_NATIVE_DAYS
|
||||
clean = (not np.isnan(med)) and med<60 and g1<3 and flat<5 and vol0<INTERIOR_VOL0_MAX and recent and enough
|
||||
if clean: v="PULITO"
|
||||
elif not enough: v=f"corto<{MIN_NATIVE_DAYS}g"
|
||||
else: v="scarta"
|
||||
print(f" {s:<6}{len(df):>6}{n_bfill:>6}{str(ts.iloc[0].date()):>13}{flat:>6.1f}%{vol0:>6.1f}%{med:>9.1f}{g1:>6.1f}%{v:>14}")
|
||||
if clean:
|
||||
df.to_parquet(path, index=False); certified.append(s)
|
||||
else:
|
||||
path.unlink(missing_ok=True) # disco == set certificato (niente parquet contaminati a riposo)
|
||||
print(f"\n CERTIFICATI ({len(certified)}): {certified}")
|
||||
print(" Scritti in data/raw/hl_<sym>_1d.parquet (namespace dedicato, SERIE NATIVA senza backfill).")
|
||||
|
||||
|
||||
if __name__=="__main__":
|
||||
main()
|
||||
@@ -1,121 +0,0 @@
|
||||
"""ANALISI OPTIONS per BTC/ETH — onesta sui dati REALI disponibili (cerbero-bite mainnet).
|
||||
|
||||
Dati: Old/data/options (chain per-strike + dvol + market_snapshots). Finestra ~2026-05-01→06-11
|
||||
(~6 settimane, REGIME UNICO calmo). NON si può validare OOS un edge su opzioni qui; si possono
|
||||
MISURARE i livelli reali (VRP, premi put, skew, liquidità) e ragionare sull'USO delle opzioni
|
||||
per il book BTC/ETH certificato. cerbero-bite è ancora vivo -> la fonte continua ad accumulare.
|
||||
|
||||
uv run python scripts/analysis/options_analysis.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
OPT = PROJECT_ROOT / "Old" / "data" / "options"
|
||||
|
||||
|
||||
def load(name):
|
||||
return pd.read_parquet(OPT / name)
|
||||
|
||||
|
||||
def market_snapshots_analysis():
|
||||
print("=" * 90)
|
||||
print(" (1) MARKET SNAPSHOTS — VRP, DVOL, funding, dealer-gamma (livelli reali)")
|
||||
print("=" * 90)
|
||||
ms = load("market_snapshots.parquet")
|
||||
t = pd.to_datetime(ms["timestamp"], utc=True, errors="coerce")
|
||||
print(f" copertura: {t.min()} -> {t.max()} ({len(ms)} righe)")
|
||||
for a in ("BTC", "ETH"):
|
||||
d = ms[ms["asset"] == a].dropna(subset=["iv_minus_rv"])
|
||||
if len(d) == 0:
|
||||
print(f" {a}: nessun dato"); continue
|
||||
vrp = d["iv_minus_rv"].astype(float)
|
||||
dvol = d["dvol"].astype(float)
|
||||
rv = d["realized_vol_30d"].astype(float)
|
||||
fund = d["funding_perp_annualized"].astype(float) if "funding_perp_annualized" in d else pd.Series([np.nan])
|
||||
gam = d["dealer_net_gamma"].astype(float) if "dealer_net_gamma" in d else pd.Series([np.nan])
|
||||
print(f"\n {a} (n={len(d)})")
|
||||
print(f" VRP (IV-RV): media {vrp.mean():+.1f} mediana {vrp.median():+.1f} "
|
||||
f">0 nel {100*(vrp>0).mean():.0f}% del tempo [IV-RV in punti di vol annua]")
|
||||
print(f" DVOL: media {dvol.mean():.1f} range [{dvol.min():.1f}, {dvol.max():.1f}]")
|
||||
print(f" Realized30d: media {rv.mean():.1f}")
|
||||
print(f" Funding perp: media {fund.mean():+.1f}% annuo")
|
||||
if gam.notna().any():
|
||||
print(f" Dealer net-γ: >0 nel {100*(gam>0).mean():.0f}% del tempo (>0 = dealer long gamma = mean-rev)")
|
||||
|
||||
|
||||
def chain_analysis(asset):
|
||||
print("\n" + "=" * 90)
|
||||
print(f" (2) CHAIN {asset} — premi put protettivi, skew, liquidità (livelli reali)")
|
||||
print("=" * 90)
|
||||
ch = load(f"{asset.lower()}_chain.parquet")
|
||||
for col in ("strike", "bid", "ask", "mid", "iv", "delta", "gamma"):
|
||||
if col in ch:
|
||||
ch[col] = pd.to_numeric(ch[col], errors="coerce")
|
||||
ch["option_type"] = ch["option_type"].astype(str)
|
||||
dv = load("dvol_history.parquet")
|
||||
dv = dv[dv["asset"] == asset][["timestamp", "spot"]].copy()
|
||||
dv["spot"] = pd.to_numeric(dv["spot"], errors="coerce")
|
||||
# timestamp -> datetime UTC nativo (sono datetime64[tz], NON ms int: to_numeric li romperebbe)
|
||||
ch["t"] = pd.to_datetime(ch["timestamp"], utc=True, errors="coerce")
|
||||
dv["t"] = pd.to_datetime(dv["timestamp"], utc=True, errors="coerce")
|
||||
ch = ch.dropna(subset=["t"]).sort_values("t").reset_index(drop=True)
|
||||
dv = dv.dropna(subset=["t", "spot"]).sort_values("t").reset_index(drop=True)
|
||||
# spot causale per timestamp della chain (merge_asof nearest, tolleranza 1h)
|
||||
ch = pd.merge_asof(ch, dv[["t", "spot"]], on="t", direction="nearest",
|
||||
tolerance=pd.Timedelta("1h"))
|
||||
ch = ch.dropna(subset=["spot", "mid", "strike"])
|
||||
# days-to-expiry
|
||||
exp = pd.to_datetime(ch["expiry"], utc=True, errors="coerce")
|
||||
ch["dte"] = (exp - ch["t"]).dt.total_seconds() / 86_400.0
|
||||
ch = ch[(ch["dte"] > 0.5) & (ch["dte"] < 90)]
|
||||
ch["money"] = ch["strike"] / ch["spot"]
|
||||
ch["prem_pct"] = ch["mid"] * 100 # mid è in COIN (frazione del sottostante) -> %-del-notional
|
||||
# NB: iv è GIÀ in percento (35.94 = 35.94%, coerente col DVOL ~40) -> non riscalare
|
||||
ch["spread_pct"] = (ch["ask"] - ch["bid"]) / ch["mid"].replace(0, np.nan) * 100
|
||||
|
||||
puts = ch[ch["option_type"].str.lower().str.startswith("p")]
|
||||
calls = ch[ch["option_type"].str.lower().str.startswith("c")]
|
||||
|
||||
def band(df, mlo, mhi, dlo, dhi):
|
||||
s = df[(df["money"] >= mlo) & (df["money"] <= mhi) & (df["dte"] >= dlo) & (df["dte"] <= dhi)]
|
||||
return s
|
||||
|
||||
print(" PUT protettive — premio reale (mid/spot) e liquidità per tenor/moneyness:")
|
||||
print(f" {'tenor':<10s}{'moneyness':<14s}{'premio%':>9s}{'/mese%':>9s}{'spread%':>9s}{'n':>7s}{'strike?':>9s}")
|
||||
for dlo, dhi, tn in [(5, 12, "settim."), (18, 45, "mensile")]:
|
||||
for mlo, mhi, ml in [(0.97, 1.03, "ATM"), (0.88, 0.93, "~10% OTM"), (0.83, 0.88, "~15% OTM")]:
|
||||
s = band(puts, mlo, mhi, dlo, dhi)
|
||||
if len(s) == 0:
|
||||
print(f" {tn:<10s}{ml:<14s}{'—':>9s}{'—':>9s}{'—':>9s}{0:>7d}{'NO':>9s}")
|
||||
continue
|
||||
prem = s["prem_pct"].median()
|
||||
permonth = prem * 30.0 / s["dte"].median()
|
||||
print(f" {tn:<10s}{ml:<14s}{prem:>8.2f}%{permonth:>8.2f}%{s['spread_pct'].median():>8.1f}%"
|
||||
f"{len(s):>7d}{'SI':>9s}")
|
||||
|
||||
# skew: IV put 10% OTM vs IV call 10% OTM (stesso tenor mensile)
|
||||
pv = band(puts, 0.88, 0.93, 12, 50)["iv"].median()
|
||||
cv = band(calls, 1.07, 1.12, 12, 50)["iv"].median()
|
||||
atmv = band(ch, 0.98, 1.02, 12, 50)["iv"].median()
|
||||
if pd.notna(pv) and pd.notna(cv):
|
||||
print(f" SKEW: IV put 10%OTM {pv:.0f}% vs call 10%OTM {cv:.0f}% vs ATM {atmv:.0f}%"
|
||||
f" -> skew put {pv-cv:+.0f} pt vol (>0 = put care = paura del crash prezzata)")
|
||||
|
||||
|
||||
def main():
|
||||
market_snapshots_analysis()
|
||||
for a in ("BTC", "ETH"):
|
||||
chain_analysis(a)
|
||||
print("\n" + "=" * 90)
|
||||
print(" NB: finestra ~6 settimane, REGIME UNICO calmo -> livelli REALI misurabili, ma NESSUN")
|
||||
print(" edge su opzioni è validabile OOS qui. Vedi commento finale.")
|
||||
print("=" * 90)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,158 +0,0 @@
|
||||
"""FASE 1 — triage dei 2 superstiti su BTC/ETH, sull'harness onesto (research_lab).
|
||||
|
||||
Sul feed pulito solo SH01 (shape-ML) e frammenti HONEST mostravano segnale residuo. Delle
|
||||
HONEST solo DIP (dip-reversion) è testabile su BTC/ETH (TR01/ROT02 richiedono alt esclusi).
|
||||
Qui ri-implemento DIP e SH01-shape-ML come SERIE DI POSIZIONE e li passo ai gate onesti
|
||||
(FULL/OOS-VAL, vs buy&hold, null p-value, sweep fee, griglia). Hold-out 2025+ resta BLOCCATO.
|
||||
|
||||
uv run python scripts/analysis/phase1_survivors.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
from sklearn.preprocessing import StandardScaler
|
||||
|
||||
from src.data.downloader import load_data
|
||||
from scripts.analysis.research_lab import (
|
||||
backtest, buy_hold, mc_pvalue, report, VAL_START, HOLDOUT_START, FEE_RT,
|
||||
)
|
||||
|
||||
|
||||
# ----------------------------- DIP reversion (long-only) -----------------------------
|
||||
def dip_signal(df, n=50, k=2.0, z_exit=0.0, max_bars=72):
|
||||
"""Long-only: entra (pos=1) quando lo z-score causale del prezzo vs MA(n) <= -k (dip),
|
||||
esce quando z>=z_exit o dopo max_bars. Decisione a close[i] (z[i] usa close[i]), guadagna
|
||||
close[i]->close[i+1]. Niente fill su estremi di candela."""
|
||||
c = df["close"].values.astype(float)
|
||||
s = pd.Series(c)
|
||||
ma = s.rolling(n).mean().values
|
||||
sd = s.rolling(n).std().values
|
||||
z = np.where(sd > 0, (c - ma) / sd, np.nan)
|
||||
pos = np.zeros(len(c))
|
||||
inpos = False
|
||||
held = 0
|
||||
for i in range(len(c)):
|
||||
if not inpos:
|
||||
if not np.isnan(z[i]) and z[i] <= -k:
|
||||
inpos, held = True, 0
|
||||
pos[i] = 1.0
|
||||
else:
|
||||
held += 1
|
||||
if (not np.isnan(z[i]) and z[i] >= z_exit) or held >= max_bars:
|
||||
inpos = False # esce al close[i]: pos[i]=0
|
||||
else:
|
||||
pos[i] = 1.0
|
||||
return pos
|
||||
|
||||
|
||||
# ----------------------------- SH01 shape-ML (walk-forward) -----------------------------
|
||||
def _shape_features(df, W):
|
||||
"""~12 feature di FORMA causali per barra, dalla finestra che termina a i (usa solo <=i)."""
|
||||
o = df["open"].values.astype(float); h = df["high"].values.astype(float)
|
||||
l = df["low"].values.astype(float); c = df["close"].values.astype(float)
|
||||
s = pd.Series(c)
|
||||
ret1 = s.pct_change()
|
||||
rng = (h - l) / np.where(c > 0, c, np.nan)
|
||||
body = (c - o) / np.where(h - l > 0, h - l, np.nan)
|
||||
up_sh = (h - np.maximum(o, c)) / np.where(h - l > 0, h - l, np.nan)
|
||||
dn_sh = (np.minimum(o, c) - l) / np.where(h - l > 0, h - l, np.nan)
|
||||
# RSI(14)
|
||||
d = s.diff()
|
||||
gain = d.clip(lower=0).rolling(14).mean()
|
||||
loss = (-d.clip(upper=0)).rolling(14).mean()
|
||||
rsi = 100 - 100 / (1 + gain / loss.replace(0, np.nan))
|
||||
hi_w = pd.Series(h).rolling(W).max(); lo_w = pd.Series(l).rolling(W).min()
|
||||
feat = {
|
||||
"mom_w": s / s.shift(W) - 1.0, # rendimento sulla finestra
|
||||
"mom_half": s / s.shift(W // 2) - 1.0, # accelerazione
|
||||
"vol_w": ret1.rolling(W).std(),
|
||||
"rsi": rsi / 100.0,
|
||||
"ma_dist": (c - s.rolling(W).mean()) / s.rolling(W).std(),
|
||||
"pos_in_range": (c - lo_w) / (hi_w - lo_w).replace(0, np.nan), # dove sta il close nel range W
|
||||
"range": pd.Series(rng).rolling(3).mean(),
|
||||
"body": pd.Series(body).rolling(3).mean(),
|
||||
"up_shadow": pd.Series(up_sh).rolling(3).mean(),
|
||||
"dn_shadow": pd.Series(dn_sh).rolling(3).mean(),
|
||||
"ret1": ret1,
|
||||
"skew_w": ret1.rolling(W).skew(),
|
||||
}
|
||||
X = pd.DataFrame(feat).values
|
||||
return X
|
||||
|
||||
|
||||
def shape_ml_signal(df, W=24, H=12, th=0.55, refit=750, warmup=3000, long_short=True):
|
||||
"""LogisticRegression walk-forward sulla forma. Label = segno del rendimento a H barre.
|
||||
Al tempo di decisione i si allena SOLO su campioni j con esito già realizzato (j+H <= i):
|
||||
strettamente causale, nessun leak. Rifit ogni `refit` barre (velocità). pos = +1 se
|
||||
P(up)>th, -1 se P(up)<1-th (long_short), altrimenti 0."""
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
X = _shape_features(df, W)
|
||||
fwd = np.full(n, np.nan)
|
||||
fwd[:n - H] = c[H:] / c[:n - H] - 1.0
|
||||
y = (fwd > 0).astype(float)
|
||||
valid = ~np.isnan(X).any(axis=1)
|
||||
pos = np.zeros(n)
|
||||
model = scaler = None
|
||||
start = max(warmup, W + H + 200)
|
||||
for i in range(start, n):
|
||||
if model is None or (i - start) % refit == 0:
|
||||
# campioni di training: feature valide E label realizzata entro i (j+H <= i)
|
||||
tr = np.where(valid & (np.arange(n) + H <= i) & (np.arange(n) >= W))[0]
|
||||
tr = tr[tr < i - H]
|
||||
if len(tr) >= 500 and len(np.unique(y[tr])) == 2:
|
||||
scaler = StandardScaler().fit(X[tr])
|
||||
model = LogisticRegression(max_iter=200, C=1.0).fit(scaler.transform(X[tr]), y[tr])
|
||||
if model is not None and valid[i]:
|
||||
p_up = float(model.predict_proba(scaler.transform(X[i:i + 1]))[0, 1])
|
||||
pos[i] = 1.0 if p_up > th else (-1.0 if (long_short and p_up < 1 - th) else 0.0)
|
||||
return pos
|
||||
|
||||
|
||||
# ----------------------------------- run -----------------------------------
|
||||
def main():
|
||||
TF = "1h"
|
||||
print("=" * 90)
|
||||
print(f" FASE 1 — triage superstiti su BTC/ETH {TF} | netto fee 0.10% RT | hold-out {HOLDOUT_START}+ BLOCCATO")
|
||||
print("=" * 90)
|
||||
|
||||
data = {a: load_data(a, TF) for a in ("BTC", "ETH")}
|
||||
|
||||
# ---------- DIP: griglia robustezza (plateau?) ----------
|
||||
print("\n" + "#" * 90)
|
||||
print(" DIP reversion (long-only) — griglia FULL Sharpe (plateau = robusto, picco = overfit)")
|
||||
print("#" * 90)
|
||||
GRID = [(n, k) for n in (30, 50, 100) for k in (1.5, 2.0, 2.5)]
|
||||
for a in ("BTC", "ETH"):
|
||||
df = data[a]
|
||||
print(f"\n {a}: " + " ".join(
|
||||
f"n{n}k{k}→{backtest(df, dip_signal(df, n=n, k=k), TF).sharpe:>5.2f}" for n, k in GRID))
|
||||
# report onesto sulla config centrale
|
||||
for a in ("BTC", "ETH"):
|
||||
report(f"DIP {a} (n50 k2.0)", data[a], dip_signal(data[a], n=50, k=2.0), TF)
|
||||
|
||||
# ---------- SH01 shape-ML: config record + paio di varianti ----------
|
||||
print("\n" + "#" * 90)
|
||||
print(" SH01 shape-ML (walk-forward LogReg) — long/short")
|
||||
print("#" * 90)
|
||||
for a in ("BTC", "ETH"):
|
||||
df = data[a]
|
||||
pos = shape_ml_signal(df, W=24, H=12, th=0.55, long_short=True)
|
||||
report(f"SH-ML {a} (W24 H12 th.55 L/S)", df, pos, TF)
|
||||
# variante long-only (meno fee)
|
||||
pos_lo = shape_ml_signal(df, W=24, H=12, th=0.55, long_short=False)
|
||||
report(f"SH-ML {a} (W24 H12 th.55 LONG-only)", df, pos_lo, TF)
|
||||
|
||||
print("\n" + "=" * 90)
|
||||
print(" VERDETTO: un edge è REALE solo se FULL e OOS-VAL Sharpe > 0, regge il sweep fee,")
|
||||
print(" e BATTE il null (p<0.05). Altrimenti = rumore, si chiude.")
|
||||
print("=" * 90)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,221 +0,0 @@
|
||||
"""FASE 2 — esplorazione larga per famiglie su BTC/ETH, harness onesto (research_lab).
|
||||
|
||||
Famiglie (serie di posizione, causali, netto fee, vs buy&hold + null p-value):
|
||||
TSMOM (momentum) | REVERSAL | MA-cross | DONCHIAN breakout | VOL-TARGET overlay |
|
||||
LEAD-LAG BTC<->ETH | HURST-gated momentum. Multi-TF dove sensato (1h + 15m).
|
||||
|
||||
La barra DA BATTERE è il buy&hold (Sharpe ~0.8 su BTC/ETH): una strategia di timing vale solo
|
||||
se fa MEGLIO net-fee. Per ogni famiglia: scan griglia (FULL Sharpe), poi report onesto sulla
|
||||
config migliore. Selezionare il best-di-griglia GONFIA -> i gate veri sono OOS-VAL + null p<0.05.
|
||||
|
||||
uv run python scripts/analysis/phase2_families.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
from src.data.downloader import load_data
|
||||
from scripts.analysis.research_lab import (
|
||||
backtest, buy_hold, mc_pvalue, window_mask, ts, VAL_START, HOLDOUT_START, BARS_PER_YEAR,
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------- famiglie ---------------------------------
|
||||
def tsmom(df, L, mode="ls"):
|
||||
c = pd.Series(df["close"].values.astype(float))
|
||||
pos = np.sign(np.nan_to_num((c / c.shift(L) - 1).values))
|
||||
return np.maximum(pos, 0) if mode == "lo" else pos
|
||||
|
||||
|
||||
def reversal(df, L, mode="ls"):
|
||||
c = pd.Series(df["close"].values.astype(float))
|
||||
pos = -np.sign(np.nan_to_num((c / c.shift(L) - 1).values))
|
||||
return np.maximum(pos, 0) if mode == "lo" else pos
|
||||
|
||||
|
||||
def ma_cross(df, fast, slow, mode="ls"):
|
||||
c = pd.Series(df["close"].values.astype(float))
|
||||
ef = c.ewm(span=fast, adjust=False).mean()
|
||||
es = c.ewm(span=slow, adjust=False).mean()
|
||||
pos = np.sign((ef - es).values)
|
||||
return np.maximum(pos, 0) if mode == "lo" else pos
|
||||
|
||||
|
||||
def donchian(df, L, mode="ls"):
|
||||
h = pd.Series(df["high"].values.astype(float)).rolling(L).max().shift(1).values
|
||||
l = pd.Series(df["low"].values.astype(float)).rolling(L).min().shift(1).values
|
||||
c = df["close"].values.astype(float)
|
||||
pos = np.zeros(len(c)); cur = 0
|
||||
for i in range(len(c)):
|
||||
if not np.isnan(h[i]) and c[i] > h[i]:
|
||||
cur = 1
|
||||
elif not np.isnan(l[i]) and c[i] < l[i]:
|
||||
cur = -1 if mode == "ls" else 0
|
||||
pos[i] = cur
|
||||
return pos
|
||||
|
||||
|
||||
def vol_target(df, tf, target=0.6, L=72):
|
||||
"""Overlay SEMPRE-LONG con esposizione scalata dalla vol realizzata (target vol annua)."""
|
||||
c = pd.Series(df["close"].values.astype(float))
|
||||
rv_ann = c.pct_change().rolling(L).std().values * np.sqrt(BARS_PER_YEAR[tf])
|
||||
pos = np.clip(np.nan_to_num(target / np.where(rv_ann > 0, rv_ann, np.nan), nan=0.0), 0, 1)
|
||||
return pos
|
||||
|
||||
|
||||
def rolling_hurst(c, W=120, step=6, lags=(2, 4, 8, 16, 32)):
|
||||
logc = np.log(c); n = len(c); H = np.full(n, np.nan)
|
||||
lg = np.log(lags)
|
||||
for i in range(W, n, step):
|
||||
seg = logc[i - W:i]
|
||||
tau = [np.std(seg[lag:] - seg[:-lag]) for lag in lags]
|
||||
if min(tau) > 0:
|
||||
H[i] = np.polyfit(lg, np.log(tau), 1)[0]
|
||||
return pd.Series(H).ffill().fillna(0.5).values
|
||||
|
||||
|
||||
def hurst_mom(df, L=48, W=120, mode="ls"):
|
||||
H = rolling_hurst(df["close"].values.astype(float), W)
|
||||
return np.where(H > 0.5, tsmom(df, L, mode), 0.0)
|
||||
|
||||
|
||||
def leadlag_df(target_df, other_df, L):
|
||||
"""Costruisce un df col close del TARGET e la posizione = segno del rendimento a L barre
|
||||
dell'ALTRO asset (allineato per timestamp). Ritorna (df_merged, pos)."""
|
||||
a = target_df[["timestamp", "open", "high", "low", "close"]]
|
||||
b = other_df[["timestamp", "close"]].rename(columns={"close": "other"})
|
||||
m = a.merge(b, on="timestamp", how="inner").reset_index(drop=True)
|
||||
o = pd.Series(m["other"].values.astype(float))
|
||||
pos = np.sign(np.nan_to_num((o / o.shift(L) - 1).values))
|
||||
return m, pos
|
||||
|
||||
|
||||
# --------------------------------- reporting ---------------------------------
|
||||
ROWS = []
|
||||
|
||||
|
||||
def summarize(family, asset, tf, df, pos, mc_n=300):
|
||||
full = backtest(df, pos, tf)
|
||||
oos = backtest(df, pos, tf, lo=VAL_START, hi=HOLDOUT_START)
|
||||
bh = buy_hold(df, tf)
|
||||
gross = backtest(df, pos, tf, fee_rt=0.0).sharpe
|
||||
_, p, _, _ = mc_pvalue(df, pos, tf, n=mc_n)
|
||||
beats_bh = full.sharpe > bh.sharpe and oos.sharpe > 0
|
||||
real = (full.sharpe > 0 and oos.sharpe > 0 and not np.isnan(p) and p < 0.05)
|
||||
verdict = "★EDGE?" if (real and beats_bh) else ("real?" if real else "rumore")
|
||||
ROWS.append(dict(fam=family, asset=asset, tf=tf, full=full.sharpe, oos=oos.sharpe,
|
||||
gross=gross, bh=bh.sharpe, p=p, trd=full.ntrades, verdict=verdict))
|
||||
print(f" {family:<16s} {asset} {tf:<3s} | FULL {full.sharpe:>5.2f} OOS {oos.sharpe:>5.2f} "
|
||||
f"gross {gross:>5.2f} | B&H {bh.sharpe:>4.2f} | p {p:>.3f} | trd/y {full.ntrades:>6.0f} | {verdict}")
|
||||
|
||||
|
||||
def scan_best(family, asset, tf, df, fn, grid, label_fn):
|
||||
"""Scansiona la griglia (FULL Sharpe), stampa la riga compatta, ritorna la pos migliore."""
|
||||
best = None
|
||||
line = []
|
||||
for params in grid:
|
||||
pos = fn(df, *params)
|
||||
s = backtest(df, pos, tf).sharpe
|
||||
line.append(f"{label_fn(params)}={s:>4.1f}")
|
||||
if best is None or s > best[0]:
|
||||
best = (s, params, pos)
|
||||
print(f" {asset} {tf} grid: " + " ".join(line))
|
||||
return best[2], best[1]
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 100)
|
||||
print(" FASE 2 — esplorazione famiglie BTC/ETH | netto fee 0.10% RT | barra = buy&hold | hold-out bloccato")
|
||||
print("=" * 100)
|
||||
D1 = {a: load_data(a, "1h") for a in ("BTC", "ETH")}
|
||||
D15 = {a: load_data(a, "15m") for a in ("BTC", "ETH")}
|
||||
|
||||
def block(title):
|
||||
print("\n" + "#" * 100 + f"\n {title}\n" + "#" * 100)
|
||||
|
||||
# ---- TSMOM (momentum) 1h + 15m, L/S e long-only ----
|
||||
block("TSMOM (momentum)")
|
||||
Ls = [(12,), (24,), (48,), (96,), (192,)]
|
||||
for a in ("BTC", "ETH"):
|
||||
pos, p = scan_best("TSMOM-LS", a, "1h", D1[a], lambda d, L: tsmom(d, L, "ls"), Ls, lambda x: f"L{x[0]}")
|
||||
summarize("TSMOM-LS", a, "1h", D1[a], pos)
|
||||
pos, p = scan_best("TSMOM-LO", a, "1h", D1[a], lambda d, L: tsmom(d, L, "lo"), Ls, lambda x: f"L{x[0]}")
|
||||
summarize("TSMOM-LO", a, "1h", D1[a], pos)
|
||||
pos, p = scan_best("TSMOM-LS", a, "15m", D15[a], lambda d, L: tsmom(d, L, "ls"), [(48,),(96,),(192,),(384,)], lambda x: f"L{x[0]}")
|
||||
summarize("TSMOM-LS", a, "15m", D15[a], pos)
|
||||
|
||||
# ---- REVERSAL 1h + 15m ----
|
||||
block("REVERSAL (mean-reversion breve)")
|
||||
Lr = [(1,), (3,), (6,), (12,), (24,)]
|
||||
for a in ("BTC", "ETH"):
|
||||
pos, p = scan_best("REV-LS", a, "1h", D1[a], lambda d, L: reversal(d, L, "ls"), Lr, lambda x: f"L{x[0]}")
|
||||
summarize("REV-LS", a, "1h", D1[a], pos)
|
||||
pos, p = scan_best("REV-LS", a, "15m", D15[a], lambda d, L: reversal(d, L, "ls"), Lr, lambda x: f"L{x[0]}")
|
||||
summarize("REV-LS", a, "15m", D15[a], pos)
|
||||
|
||||
# ---- MA cross ----
|
||||
block("MA-CROSS (trend)")
|
||||
g = [(12, 48), (24, 96), (48, 192), (24, 200)]
|
||||
for a in ("BTC", "ETH"):
|
||||
pos, p = scan_best("MAX-LS", a, "1h", D1[a], lambda d, f, s: ma_cross(d, f, s, "ls"), g, lambda x: f"{x[0]}/{x[1]}")
|
||||
summarize("MAX-LS", a, "1h", D1[a], pos)
|
||||
pos, p = scan_best("MAX-LO", a, "1h", D1[a], lambda d, f, s: ma_cross(d, f, s, "lo"), g, lambda x: f"{x[0]}/{x[1]}")
|
||||
summarize("MAX-LO", a, "1h", D1[a], pos)
|
||||
|
||||
# ---- Donchian breakout ----
|
||||
block("DONCHIAN breakout")
|
||||
Ld = [(24,), (48,), (96,), (192,)]
|
||||
for a in ("BTC", "ETH"):
|
||||
pos, p = scan_best("DONCH-LS", a, "1h", D1[a], lambda d, L: donchian(d, L, "ls"), Ld, lambda x: f"L{x[0]}")
|
||||
summarize("DONCH-LS", a, "1h", D1[a], pos)
|
||||
pos, p = scan_best("DONCH-LO", a, "1h", D1[a], lambda d, L: donchian(d, L, "lo"), Ld, lambda x: f"L{x[0]}")
|
||||
summarize("DONCH-LO", a, "1h", D1[a], pos)
|
||||
|
||||
# ---- Vol-target overlay (vs buy&hold) ----
|
||||
block("VOL-TARGET overlay (sempre-long scalato) — riduce la vol/DD del buy&hold?")
|
||||
for a in ("BTC", "ETH"):
|
||||
pos, p = scan_best("VOLTGT", a, "1h", D1[a], lambda d, t: vol_target(d, "1h", t, 72),
|
||||
[(0.4,), (0.6,), (0.8,), (1.0,)], lambda x: f"t{x[0]}")
|
||||
summarize("VOLTGT", a, "1h", D1[a], pos)
|
||||
|
||||
# ---- Hurst-gated momentum ----
|
||||
block("HURST-gated momentum (momentum solo in regime trending H>0.5)")
|
||||
for a in ("BTC", "ETH"):
|
||||
pos, p = scan_best("HURST-MOM", a, "1h", D1[a], lambda d, L: hurst_mom(d, L, 120, "ls"),
|
||||
[(24,), (48,), (96,)], lambda x: f"L{x[0]}")
|
||||
summarize("HURST-MOM", a, "1h", D1[a], pos)
|
||||
|
||||
# ---- Lead-lag BTC<->ETH ----
|
||||
block("LEAD-LAG BTC<->ETH (posiziona un asset col rendimento passato dell'altro)")
|
||||
for tgt, oth in (("ETH", "BTC"), ("BTC", "ETH")):
|
||||
Ll = [1, 3, 6, 12, 24]
|
||||
best = None; line = []
|
||||
for L in Ll:
|
||||
m, pos = leadlag_df(D1[tgt], D1[oth], L)
|
||||
s = backtest(m, pos, "1h").sharpe
|
||||
line.append(f"L{L}={s:>4.1f}")
|
||||
if best is None or s > best[0]:
|
||||
best = (s, L, m, pos)
|
||||
print(f" {oth}->{tgt} 1h grid: " + " ".join(line))
|
||||
_, L, m, pos = best
|
||||
summarize(f"LL {oth}>{tgt}", tgt, "1h", m, pos)
|
||||
|
||||
# ---- classifica finale ----
|
||||
print("\n" + "=" * 100)
|
||||
print(" CLASSIFICA — net-fee FULL Sharpe (★EDGE? = batte B&H, OOS>0 e null p<0.05)")
|
||||
print("=" * 100)
|
||||
for r in sorted(ROWS, key=lambda r: -r["full"]):
|
||||
print(f" {r['fam']:<16s} {r['asset']} {r['tf']:<3s} | FULL {r['full']:>5.2f} | OOS {r['oos']:>5.2f} | "
|
||||
f"B&H {r['bh']:>4.2f} | p {r['p']:>.3f} | {r['verdict']}")
|
||||
edges = [r for r in ROWS if r["verdict"] == "★EDGE?"]
|
||||
print(f"\n Candidati che battono il buy&hold net-fee + OOS>0 + null p<0.05: {len(edges)}")
|
||||
for r in edges:
|
||||
print(f" -> {r['fam']} {r['asset']} {r['tf']}: FULL {r['full']:.2f} OOS {r['oos']:.2f} p {r['p']:.3f}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,152 +0,0 @@
|
||||
"""FASE 3 — conferma avversariale del SOLO candidato reale: trend-following long-only (MA-cross).
|
||||
|
||||
Protocollo onesto:
|
||||
1. SELEZIONE config SOLO sul pre-hold-out (< 2025-01-01). Niente sbirciate al hold-out.
|
||||
2. HOLD-OUT 2025-26 sbloccato UNA volta (la prova del nove, mai usato in ricerca).
|
||||
3. Breakdown PER ANNO vs buy&hold: il trend-LO deve "schivare" i bear (2018/2022).
|
||||
4. STRESS: fee 2x, lag di esecuzione (1 barra), slippage.
|
||||
5. DEFLATED SHARPE (Bailey & López de Prado): lo Sharpe regge alla correzione per multiple-testing?
|
||||
|
||||
uv run python scripts/analysis/phase3_confirm.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from scipy.stats import norm, skew, kurtosis
|
||||
|
||||
from src.data.downloader import load_data
|
||||
from scripts.analysis.research_lab import (
|
||||
backtest, buy_hold, window_mask, ts, _net_series, HOLDOUT_START, BARS_PER_YEAR,
|
||||
)
|
||||
from scripts.analysis.phase2_families import ma_cross
|
||||
|
||||
GRID = [(12, 48), (24, 96), (48, 192), (24, 200), (96, 288)] # MA-cross griglia (fast/slow)
|
||||
REPR = (24, 96) # config rappresentativa PRE-COMMITTATA
|
||||
TF = "1h"
|
||||
|
||||
|
||||
def lag(pos, k=1):
|
||||
"""Esecuzione in ritardo di k barre (agisci k barre dopo la decisione)."""
|
||||
return np.concatenate([np.zeros(k), pos[:-k]])
|
||||
|
||||
|
||||
def per_year(df, pos, tf):
|
||||
c = df["close"].values.astype(float)
|
||||
net, _, fwd, _ = _net_series(df, pos)
|
||||
yrs = ts(df).dt.year.values
|
||||
out = {}
|
||||
for y in sorted(set(yrs)):
|
||||
m = yrs == y
|
||||
if m.sum() < 2:
|
||||
continue
|
||||
strat = float(np.prod(1 + net[m]) - 1) * 100
|
||||
bh = float(np.prod(1 + fwd[m]) - 1) * 100
|
||||
expo = float(np.mean(np.abs(pos[m])))
|
||||
out[y] = (strat, bh, expo)
|
||||
return out
|
||||
|
||||
|
||||
def deflated_sharpe(net, sr_trials_perbar, N):
|
||||
"""DSR: prob. che il vero Sharpe > la soglia attesa-massima sotto N trial (multiple testing).
|
||||
Tutto in Sharpe PER BARRA. >0.95 = significativo dopo correzione."""
|
||||
sr = net.mean() / net.std()
|
||||
T = len(net)
|
||||
g3 = float(skew(net)); g4 = float(kurtosis(net, fisher=False))
|
||||
var_sr = float(np.var(sr_trials_perbar, ddof=1)) if len(sr_trials_perbar) > 1 else 0.0
|
||||
ge = 0.5772156649
|
||||
z1 = norm.ppf(1 - 1.0 / N); z2 = norm.ppf(1 - 1.0 / (N * np.e))
|
||||
sr0 = np.sqrt(var_sr) * ((1 - ge) * z1 + ge * z2) # Sharpe atteso-massimo sotto null, N trial
|
||||
den = np.sqrt(max(1 - g3 * sr + (g4 - 1) / 4.0 * sr ** 2, 1e-9))
|
||||
dsr = float(norm.cdf((sr - sr0) * np.sqrt(T - 1) / den))
|
||||
bpy = BARS_PER_YEAR[TF]
|
||||
return dsr, sr * np.sqrt(bpy), sr0 * np.sqrt(bpy)
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 96)
|
||||
print(" FASE 3 — conferma avversariale: TREND-following long-only (MA-cross) BTC/ETH")
|
||||
print("=" * 96)
|
||||
data = {a: load_data(a, TF) for a in ("BTC", "ETH")}
|
||||
|
||||
# ---------- 1) selezione SOLO pre-hold-out ----------
|
||||
print(f"\n (1) SELEZIONE su pre-hold-out (< {HOLDOUT_START}) — Sharpe per config (plateau = robusto)")
|
||||
for a in ("BTC", "ETH"):
|
||||
line = []
|
||||
for f, s in GRID:
|
||||
pos = ma_cross(data[a], f, s, "lo")
|
||||
sh = backtest(data[a], pos, TF, hi=HOLDOUT_START).sharpe
|
||||
line.append(f"{f}/{s}={sh:>4.2f}")
|
||||
print(f" {a}: " + " ".join(line))
|
||||
print(f" -> config rappresentativa PRE-COMMITTATA per i test seguenti: {REPR[0]}/{REPR[1]}")
|
||||
|
||||
# ---------- 2) HOLD-OUT 2025-26 (sbloccato una volta) ----------
|
||||
print(f"\n (2) HOLD-OUT {HOLDOUT_START}+ — LA PROVA DEL NOVE (mai usato in ricerca)")
|
||||
for a in ("BTC", "ETH"):
|
||||
bh = buy_hold(data[a], TF, lo=HOLDOUT_START)
|
||||
print(f" {a}: buy&hold hold-out Sh {bh.sharpe:>5.2f} ret {bh.ret*100:>+7.1f}% DD {bh.maxdd*100:>4.1f}%")
|
||||
for f, s in GRID:
|
||||
pos = ma_cross(data[a], f, s, "lo")
|
||||
r = backtest(data[a], pos, TF, lo=HOLDOUT_START)
|
||||
star = " <-REPR" if (f, s) == REPR else ""
|
||||
print(f" {f}/{s:<3d} Sh {r.sharpe:>5.2f} ret {r.ret*100:>+7.1f}% DD {r.maxdd*100:>4.1f}% expo {r.exposure:.2f}{star}")
|
||||
|
||||
# ---------- 3) per anno vs buy&hold (schiva i bear?) ----------
|
||||
print(f"\n (3) PER ANNO — strat {REPR[0]}/{REPR[1]} vs buy&hold (expo = quanto è long; bear test 2018/2022)")
|
||||
for a in ("BTC", "ETH"):
|
||||
pos = ma_cross(data[a], *REPR, "lo")
|
||||
py = per_year(data[a], pos, TF)
|
||||
print(f" {a}:")
|
||||
for y, (st, bh, ex) in py.items():
|
||||
flag = " <- BEAR" if bh < -20 else ""
|
||||
print(f" {y}: strat {st:>+7.0f}% | buy&hold {bh:>+7.0f}% | expo {ex:.2f}{flag}")
|
||||
|
||||
# ---------- 4) stress ----------
|
||||
print(f"\n (4) STRESS — strat {REPR[0]}/{REPR[1]} | FULL e HOLD-OUT Sharpe")
|
||||
print(f" {'scenario':<24s}{'BTC FULL':>10s}{'BTC HO':>9s}{'ETH FULL':>10s}{'ETH HO':>9s}")
|
||||
scen = [
|
||||
("base fee0.10%", dict(fee_rt=0.001), False),
|
||||
("fee 0.20% (2x)", dict(fee_rt=0.002), False),
|
||||
("lag 1 barra", dict(fee_rt=0.001), True),
|
||||
("fee2x + lag", dict(fee_rt=0.002), True),
|
||||
]
|
||||
for name, kw, do_lag in scen:
|
||||
row = [name]
|
||||
for a in ("BTC", "ETH"):
|
||||
pos = ma_cross(data[a], *REPR, "lo")
|
||||
if do_lag:
|
||||
pos = lag(pos, 1)
|
||||
full = backtest(data[a], pos, TF, **kw).sharpe
|
||||
ho = backtest(data[a], pos, TF, lo=HOLDOUT_START, **kw).sharpe
|
||||
row += [f"{full:>9.2f}", f"{ho:>8.2f}"]
|
||||
print(f" {row[0]:<24s}{row[1]:>10s}{row[2]:>9s}{row[3]:>10s}{row[4]:>9s}")
|
||||
|
||||
# ---------- 5) deflated Sharpe ----------
|
||||
print(f"\n (5) DEFLATED SHARPE — corregge il multiple-testing (DSR>0.95 = regge)")
|
||||
# trial set = TUTTE le config trend long-only provate (proxy del numero di tentativi)
|
||||
N_TRIALS = 60 # stima conservativa dei backtest provati in Fase 2 (tutte le famiglie/asset/TF)
|
||||
for a in ("BTC", "ETH"):
|
||||
trials = [backtest(data[a], ma_cross(data[a], f, s, "lo"), TF, hi=HOLDOUT_START) for f, s in GRID]
|
||||
sr_trials = []
|
||||
for f, s in GRID:
|
||||
net, _, _, _ = _net_series(data[a], ma_cross(data[a], f, s, "lo"))
|
||||
m = window_mask(data[a], hi=HOLDOUT_START)
|
||||
sr_trials.append(net[m].mean() / net[m].std())
|
||||
net, _, _, _ = _net_series(data[a], ma_cross(data[a], *REPR, "lo"))
|
||||
m = window_mask(data[a], hi=HOLDOUT_START)
|
||||
dsr, sr_ann, sr0_ann = deflated_sharpe(net[m], sr_trials, N_TRIALS)
|
||||
verdict = "REGGE" if dsr > 0.95 else "NON regge"
|
||||
print(f" {a} (pre-hold-out): Sharpe {sr_ann:.2f} vs soglia-max-attesa(N={N_TRIALS}) {sr0_ann:.2f} "
|
||||
f"-> DSR {dsr:.3f} [{verdict}]")
|
||||
|
||||
print("\n" + "=" * 96)
|
||||
print(" VERDETTO: edge ONESTO solo se (2) hold-out positivo, (3) schiva i bear, (4) regge lo")
|
||||
print(" stress, (5) DSR>0.95. Altrimenti: anche il trend era sample-luck del mercato toro.")
|
||||
print("=" * 96)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,208 +0,0 @@
|
||||
"""HARNESS DI RICERCA ONESTO — BTC/ETH, v2.0.0 (Fase 0).
|
||||
|
||||
Dopo che l'intera libreria precedente si è rivelata artefatto di feed/harness disonesti,
|
||||
la prima cosa di cui fidarsi NON è una strategia ma il banco di prova. Questo modulo è
|
||||
quel banco: causale per costruzione, netto fee, con baseline e null model.
|
||||
|
||||
MODELLO CANONICO = SERIE DI POSIZIONE.
|
||||
Una strategia è una funzione signal(df, **params) -> pd.Series/np.array che dà la
|
||||
posizione target per barra in [-1, +1]. REGOLA: position[i] è decisa con dati FINO a
|
||||
close[i] (mai oltre) e GUADAGNA il rendimento close[i] -> close[i+1]. L'engine moltiplica
|
||||
position[i] * fwd[i] (fwd strettamente futuro rispetto alla decisione) -> niente look-ahead
|
||||
per costruzione, e niente fill sull'estremo di candela (si entra al close). La fee è
|
||||
addebitata sul TURNOVER |Δposition| (un round-trip 0->1->0 = 2 unità = fee_rt intera).
|
||||
|
||||
GATE (vedi CLAUDE.md): ingresso eseguibile (qui per costruzione), netto fee 0.10% RT,
|
||||
OOS held-out, robustezza su griglia, onestà statistica (null model + buy&hold), walk-forward
|
||||
per i modelli fittati, liquidità (BTC/ETH ok).
|
||||
|
||||
uv run python scripts/analysis/research_lab.py # self-test del banco
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from src.data.downloader import load_data
|
||||
|
||||
FEE_RT = 0.001 # 0.10% round-trip taker Deribit (0.05%/lato)
|
||||
BARS_PER_YEAR = {"5m": 105192.0, "15m": 35064.0, "1h": 8766.0,
|
||||
"4h": 2191.5, "12h": 730.5, "1d": 365.25}
|
||||
|
||||
|
||||
def load_tf(asset: str, tf: str):
|
||||
"""Carica un TF certificato. 5m/15m/1h diretti; 4h/12h/1d DERIVATI per resample dal 1h
|
||||
(confini 00:00 UTC). >=12h e' il regime raccomandato (sotto, costi+overfit dominano)."""
|
||||
if tf in ("5m", "15m", "1h"):
|
||||
return load_data(asset, tf)
|
||||
rule = {"4h": "4h", "12h": "12h", "1d": "1D"}[tf]
|
||||
df = load_data(asset, "1h").copy()
|
||||
df.index = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
|
||||
out = df.resample(rule, label="left", closed="left").agg(
|
||||
{"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna(subset=["open"])
|
||||
epoch = pd.Timestamp("1970-01-01", tz="UTC")
|
||||
out["timestamp"] = ((out.index - epoch) // pd.Timedelta(milliseconds=1)).astype("int64")
|
||||
return out.reset_index(drop=True)[["timestamp", "open", "high", "low", "close", "volume"]]
|
||||
# Hold-out FINALE bloccato: NIENTE ricerca/tuning lo tocca finché non è il verdetto (Fase 3).
|
||||
HOLDOUT_START = "2025-01-01"
|
||||
# Finestra di validazione OOS usata in ricerca (out-of-sample ma PRE hold-out).
|
||||
VAL_START = "2023-01-01"
|
||||
|
||||
|
||||
def ts(df) -> pd.Series:
|
||||
return pd.to_datetime(df["timestamp"], unit="ms", utc=True)
|
||||
|
||||
|
||||
def window_mask(df, lo: str | None = None, hi: str | None = None) -> np.ndarray:
|
||||
t = ts(df)
|
||||
m = np.ones(len(df), bool)
|
||||
if lo is not None:
|
||||
m &= (t >= pd.Timestamp(lo, tz="UTC")).values
|
||||
if hi is not None:
|
||||
m &= (t < pd.Timestamp(hi, tz="UTC")).values
|
||||
return m
|
||||
|
||||
|
||||
@dataclass
|
||||
class BT:
|
||||
n: int
|
||||
ret: float # rendimento composto sulla finestra (pos 1x, leva 1x)
|
||||
cagr: float
|
||||
sharpe: float # annualizzato
|
||||
maxdd: float # % (positivo)
|
||||
exposure: float # |pos| medio
|
||||
turnover: float # Σ|Δpos| / anno
|
||||
ntrades: float # round-trip equivalenti / anno
|
||||
|
||||
def line(self, label="") -> str:
|
||||
return (f" {label:<22s} Sh {self.sharpe:>6.2f} | ret {self.ret*100:>+8.1f}% "
|
||||
f"CAGR {self.cagr*100:>+6.1f}% | DD {self.maxdd*100:>5.1f}% | "
|
||||
f"expo {self.exposure:>4.2f} trd/y {self.ntrades:>6.1f} | n {self.n}")
|
||||
|
||||
|
||||
def _net_series(df, position, fee_rt=FEE_RT):
|
||||
"""Ritorna (net, gross, fwd, pos) per barra. net[i] = pos[i]*fwd[i] - fee sul cambio a i."""
|
||||
c = df["close"].values.astype(float)
|
||||
pos = np.nan_to_num(np.asarray(position, float), nan=0.0)
|
||||
pos = np.clip(pos, -1.0, 1.0)
|
||||
n = len(c)
|
||||
fwd = np.zeros(n)
|
||||
fwd[:-1] = c[1:] / c[:-1] - 1.0 # rendimento close[i]->close[i+1] (futuro vs decisione a i)
|
||||
gross = pos * fwd
|
||||
dpos = np.abs(np.diff(np.concatenate([[0.0], pos]))) # cambio di posizione a i (si tradea al close[i])
|
||||
fee = dpos * (fee_rt / 2.0) # fee_rt = round-trip (2 unità di turnover); /2 per unità
|
||||
net = gross - fee
|
||||
return net, gross, fwd, pos
|
||||
|
||||
|
||||
def backtest(df, position, tf="1h", fee_rt=FEE_RT, lo=None, hi=None) -> BT:
|
||||
net, gross, fwd, pos = _net_series(df, position, fee_rt)
|
||||
m = window_mask(df, lo, hi)
|
||||
net_w, pos_w = net[m], pos[m]
|
||||
dpos_w = np.abs(np.diff(np.concatenate([[0.0], pos_w])))
|
||||
bpy = BARS_PER_YEAR[tf]
|
||||
n = int(m.sum())
|
||||
if n < 2:
|
||||
return BT(n, 0, float("nan"), 0, 0, 0, 0, 0)
|
||||
eq = np.cumprod(1.0 + net_w)
|
||||
total = float(eq[-1] - 1.0)
|
||||
years = n / bpy
|
||||
cagr = float((1 + total) ** (1 / years) - 1) if years > 0 and total > -1 else float("nan")
|
||||
mu, sd = float(net_w.mean()), float(net_w.std())
|
||||
sharpe = mu / sd * np.sqrt(bpy) if sd > 0 else 0.0
|
||||
peak = np.maximum.accumulate(eq)
|
||||
maxdd = float(np.max((peak - eq) / peak)) if n else 0.0
|
||||
expo = float(np.mean(np.abs(pos_w)))
|
||||
turn_y = float(dpos_w.sum() / years) if years > 0 else 0.0
|
||||
return BT(n, total, cagr, sharpe, maxdd, expo, turn_y, turn_y / 2.0)
|
||||
|
||||
|
||||
def buy_hold(df, tf="1h", fee_rt=FEE_RT, lo=None, hi=None) -> BT:
|
||||
return backtest(df, np.ones(len(df)), tf, fee_rt, lo, hi)
|
||||
|
||||
|
||||
def mc_pvalue(df, position, tf="1h", fee_rt=FEE_RT, n=500, lo=None, hi=None, seed=0):
|
||||
"""Null model a ROTAZIONE CIRCOLARE: ruota la serie di posizione di un offset casuale.
|
||||
Preserva ESATTAMENTE exposure, turnover e distribuzione degli holding; distrugge solo
|
||||
l'allineamento col mercato. p = P(Sharpe_ruotato >= Sharpe_reale). p alto = il timing
|
||||
non batte il caso (nessuna skill)."""
|
||||
pos = np.nan_to_num(np.asarray(position, float))
|
||||
base = backtest(df, pos, tf, fee_rt, lo, hi).sharpe
|
||||
N = len(pos)
|
||||
if np.abs(np.diff(pos)).sum() == 0: # posizione costante -> rotazione degenere
|
||||
return base, float("nan"), float("nan"), float("nan")
|
||||
rng = np.random.default_rng(seed)
|
||||
sims = np.empty(n)
|
||||
for k in range(n):
|
||||
off = int(rng.integers(1, N))
|
||||
sims[k] = backtest(df, np.roll(pos, off), tf, fee_rt, lo, hi).sharpe
|
||||
p = float((np.sum(sims >= base) + 1) / (n + 1))
|
||||
return base, p, float(sims.mean()), float(sims.std())
|
||||
|
||||
|
||||
def report(name, df, position, tf="1h", fee_rt=FEE_RT, mc_n=400):
|
||||
"""Stampa il verdetto onesto: FULL / OOS-VAL / vs buy&hold / null p-value / sweep fee."""
|
||||
print(f"\n === {name} ({tf}) ===")
|
||||
print(backtest(df, position, tf, fee_rt).line("FULL"))
|
||||
print(backtest(df, position, tf, fee_rt, lo=VAL_START, hi=HOLDOUT_START).line(f"OOS-VAL {VAL_START[:4]}-24"))
|
||||
print(buy_hold(df, tf, fee_rt).line("buy&hold FULL"))
|
||||
base, p, msh, ssd = mc_pvalue(df, position, tf, fee_rt, n=mc_n)
|
||||
verdict = "RUMORE" if (np.isnan(p) or p > 0.05) else "batte il null"
|
||||
print(f" null (rotazione, n={mc_n}): Sharpe reale {base:.2f} vs random {msh:.2f}±{ssd:.2f} "
|
||||
f"-> p={p if not np.isnan(p) else float('nan'):.3f} [{verdict}]")
|
||||
print(" sweep fee RT:", " ".join(
|
||||
f"{f*100:.2f}%→Sh{backtest(df, position, tf, f).sharpe:.2f}" for f in (0.0, 0.0005, 0.001, 0.002)))
|
||||
|
||||
|
||||
# ============================ SELF-TEST DEL BANCO ============================
|
||||
def self_test():
|
||||
"""Valida l'HARNESS, non una strategia. Tre prove:
|
||||
(1) buy&hold: Sharpe positivo, DD grande (sanity dei numeri).
|
||||
(2) CHEAT look-ahead (pos = segno del rendimento FUTURO): Sharpe enorme, p≈0
|
||||
-> l'engine SA vedere un edge quando esiste davvero.
|
||||
(3) NOISE causale (pos da rumore del passato): Sharpe≈0, p≈0.5
|
||||
-> l'engine NON inventa edge dal nulla (niente leak)."""
|
||||
print("=" * 78)
|
||||
print(" SELF-TEST HARNESS — deve: vedere il cheat, NON vedere il rumore")
|
||||
print("=" * 78)
|
||||
df = load_data("BTC", "1h")
|
||||
t = ts(df)
|
||||
c = df["close"].values.astype(float)
|
||||
bh = buy_hold(df, "1h")
|
||||
print(bh.line("(1) buy&hold BTC"))
|
||||
assert bh.sharpe > 0, "buy&hold dovrebbe avere Sharpe>0 sullo storico BTC"
|
||||
|
||||
# (2) CHEAT: posizione = segno del rendimento del prossimo bar (USA IL FUTURO)
|
||||
fwd = np.zeros(len(c)); fwd[:-1] = c[1:] / c[:-1] - 1.0
|
||||
cheat = np.sign(fwd)
|
||||
bt_cheat = backtest(df, cheat, "1h")
|
||||
_, p_cheat, _, _ = mc_pvalue(df, cheat, "1h", n=200, seed=1)
|
||||
print(bt_cheat.line("(2) CHEAT look-ahead"))
|
||||
print(f" -> null p={p_cheat:.4f} (atteso ≈0: l'edge finto È enorme e battibile dal caso ~mai)")
|
||||
assert bt_cheat.sharpe > 20, "il cheat dovrebbe dare Sharpe enorme se l'engine è corretto"
|
||||
assert p_cheat < 0.02, "il cheat dovrebbe battere il null in modo schiacciante"
|
||||
|
||||
# (3) NOISE causale a BASSO turnover (blocchi ~50 barre): isola la SKILL dalla fee-death.
|
||||
# Posizione casuale (non usa il futuro) tenuta a blocchi -> turnover basso -> se l'engine non
|
||||
# inventa edge dal nulla, Sharpe≈0 e il null p≈0.5 (random rotazioni indistinguibili).
|
||||
rng = np.random.default_rng(42)
|
||||
blk = 50
|
||||
raw = np.sign(rng.standard_normal(len(c) // blk + 1))
|
||||
noise_pos = np.repeat(raw, blk)[:len(c)]
|
||||
noise_pos = pd.Series(noise_pos).shift(1).fillna(0).values # solo passato
|
||||
bt_noise = backtest(df, noise_pos, "1h")
|
||||
base_n, p_noise, msh, ssd = mc_pvalue(df, noise_pos, "1h", n=400, seed=2)
|
||||
print(bt_noise.line("(3) NOISE causale"))
|
||||
print(f" -> null p={p_noise:.3f} (atteso alto/≈0.5: nessuna skill, indistinguibile dal caso)")
|
||||
assert bt_noise.sharpe < 2.0, "il rumore causale non deve sembrare SKILLATO (Sharpe positivo grande = leak)"
|
||||
assert p_noise > 0.10, "il rumore causale non deve battere il null (p basso = edge spurio/leak)"
|
||||
|
||||
print("\n ✓ HARNESS VALIDATO: vede il cheat (Sharpe enorme, p≈0), non inventa edge dal rumore (p alto).")
|
||||
print(f" Hold-out finale BLOCCATO da {HOLDOUT_START} (non usato in ricerca). OOS-VAL: {VAL_START}→hold-out.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
self_test()
|
||||
@@ -1,121 +0,0 @@
|
||||
"""STRESS-TEST di TP01 (integrato da strategy-research-2026-06) — robustezza avversariale.
|
||||
|
||||
Usa il modulo VERO integrato (src/strategies/trend_portfolio). Oltre a hold-out/cross-asset/multi-TF
|
||||
(gia' in verify_tp01.py), qui: sweep FEE (fino 0.40% RT), LAG di esecuzione + slippage, PLATEAU dei
|
||||
parametri (config cherry-picked?), DEFLATED-SHARPE (multiple-testing track A-E).
|
||||
|
||||
uv run python scripts/analysis/stress_tp01.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from scipy.stats import norm, skew, kurtosis
|
||||
from src.data.downloader import load_data
|
||||
from src.strategies.trend_portfolio import TrendPortfolio, resample_4h, simple_returns, CANONICAL
|
||||
|
||||
HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
|
||||
DF4H = {a: resample_4h(load_data(a, "1h")) for a in ("BTC", "ETH")}
|
||||
|
||||
|
||||
def combo(cfg, lag_bars=0, fee_side=0.0005):
|
||||
"""Rendimenti per-barra del portafoglio 50/50 con config cfg, lag extra e fee dati."""
|
||||
tp = TrendPortfolio(**{**cfg, "fee_side": fee_side})
|
||||
series = {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = DF4H[a]
|
||||
r = simple_returns(df["close"].values.astype(float))
|
||||
tgt = tp.target_series(df)
|
||||
held = np.zeros(len(tgt))
|
||||
s = 1 + lag_bars
|
||||
held[s:] = tgt[:-s] # tenuta = decisa s barre prima (causale + lag)
|
||||
net = held * r - fee_side * np.abs(np.diff(held, prepend=0.0))
|
||||
net[0] = 0.0
|
||||
series[a] = pd.Series(np.clip(net, -0.99, None), index=pd.to_datetime(df["datetime"]))
|
||||
J = pd.concat(series, axis=1, join="inner").fillna(0.0)
|
||||
return 0.5 * J["BTC"].values + 0.5 * J["ETH"].values, J.index
|
||||
|
||||
|
||||
def met(combo_r, idx):
|
||||
rr = combo_r[np.isfinite(combo_r)]
|
||||
if len(rr) < 2 or np.std(rr) == 0:
|
||||
return dict(sh=0, ret=0, dd=0)
|
||||
bpy = 86400 * 365.25 / pd.Series(idx).diff().dt.total_seconds().median()
|
||||
eq = np.cumprod(1 + rr); pk = np.maximum.accumulate(eq)
|
||||
return dict(sh=float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)),
|
||||
ret=float(eq[-1] - 1), dd=float(np.max((pk - eq) / pk)))
|
||||
|
||||
|
||||
def full_ho(cfg, lag_bars=0, fee_side=0.0005):
|
||||
cr, idx = combo(cfg, lag_bars, fee_side)
|
||||
ho = idx >= HOLDOUT
|
||||
return met(cr, idx), met(cr[ho], idx[ho])
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 88)
|
||||
print(" STRESS-TEST TP01 (PORT LF4h canonica) — robustezza avversariale")
|
||||
print("=" * 88)
|
||||
|
||||
base_f, base_h = full_ho(CANONICAL)
|
||||
print(f"\n BASELINE (4h, fee 0.10% RT): FULL Sh {base_f['sh']:.2f} ret {base_f['ret']*100:+.0f}% DD {base_f['dd']*100:.1f}%"
|
||||
f" | HOLD-OUT Sh {base_h['sh']:.2f} ret {base_h['ret']*100:+.1f}% DD {base_h['dd']*100:.1f}%")
|
||||
|
||||
print("\n (1) SWEEP FEE (RT) — regge fino a 0.40%?")
|
||||
print(f" {'fee RT':<10s}{'FULL Sh':>9s}{'FULL ret':>10s}{'HOLD Sh':>9s}{'HOLD ret':>10s}")
|
||||
for frt in (0.0, 0.001, 0.002, 0.004):
|
||||
f, h = full_ho(CANONICAL, fee_side=frt / 2)
|
||||
print(f" {frt*100:>5.2f}% {f['sh']:>8.2f}{f['ret']*100:>+9.0f}%{h['sh']:>9.2f}{h['ret']*100:>+9.1f}%")
|
||||
|
||||
print("\n (2) LAG di esecuzione + slippage (fee 0.20% per simulare slippage)")
|
||||
print(f" {'scenario':<22s}{'FULL Sh':>9s}{'HOLD Sh':>9s}{'HOLD ret':>10s}")
|
||||
for name, lag, frt in [("base", 0, 0.001), ("lag 1 barra (4h)", 1, 0.001),
|
||||
("lag 2 barre", 2, 0.001), ("lag1 + fee0.20% slip", 1, 0.002)]:
|
||||
f, h = full_ho(CANONICAL, lag_bars=lag, fee_side=frt / 2)
|
||||
print(f" {name:<22s}{f['sh']:>8.2f}{h['sh']:>9.2f}{h['ret']*100:>+9.1f}%")
|
||||
|
||||
print("\n (3) PLATEAU PARAMETRI — la config canonica e' un picco o un altopiano?")
|
||||
print(f" {'variazione':<26s}{'FULL Sh':>9s}{'HOLD Sh':>9s}")
|
||||
grid = [
|
||||
("canonica (vt.20 lev2 30/90/180 vw30)", CANONICAL),
|
||||
("target_vol 0.15", {**CANONICAL, "target_vol": 0.15}),
|
||||
("target_vol 0.25", {**CANONICAL, "target_vol": 0.25}),
|
||||
("leverage 1.5", {**CANONICAL, "leverage": 1.5}),
|
||||
("leverage 3.0", {**CANONICAL, "leverage": 3.0}),
|
||||
("horizons 20/60/120", {**CANONICAL, "horizons_days": (20, 60, 120)}),
|
||||
("horizons 60/120/240", {**CANONICAL, "horizons_days": (60, 120, 240)}),
|
||||
("vol_win 20", {**CANONICAL, "vol_win_days": 20}),
|
||||
("vol_win 45", {**CANONICAL, "vol_win_days": 45}),
|
||||
]
|
||||
sr_trials = []
|
||||
for name, cfg in grid:
|
||||
f, h = full_ho(cfg)
|
||||
cr, idx = combo(cfg)
|
||||
sr_trials.append(cr[np.isfinite(cr)].mean() / cr[np.isfinite(cr)].std()) # Sharpe per-barra
|
||||
print(f" {name:<26s}{f['sh']:>8.2f}{h['sh']:>9.2f}")
|
||||
|
||||
print("\n (4) DEFLATED SHARPE — corregge il multiple-testing (track A-E + sweep). DSR>0.95 = regge")
|
||||
cr, idx = combo(CANONICAL)
|
||||
rr = cr[np.isfinite(cr)]
|
||||
sr = rr.mean() / rr.std(); T = len(rr)
|
||||
g3 = float(skew(rr)); g4 = float(kurtosis(rr, fisher=False))
|
||||
var_sr = float(np.var(sr_trials, ddof=1))
|
||||
ge = 0.5772156649
|
||||
for N in (10, 40, 100): # N = numero di trial/config provati (conservativo)
|
||||
z1 = norm.ppf(1 - 1.0 / N); z2 = norm.ppf(1 - 1.0 / (N * np.e))
|
||||
sr0 = np.sqrt(var_sr) * ((1 - ge) * z1 + ge * z2)
|
||||
den = np.sqrt(max(1 - g3 * sr + (g4 - 1) / 4.0 * sr ** 2, 1e-9))
|
||||
dsr = float(norm.cdf((sr - sr0) * np.sqrt(T - 1) / den))
|
||||
bpy = 86400 * 365.25 / pd.Series(idx).diff().dt.total_seconds().median()
|
||||
print(f" N={N:>3d} trial -> soglia-max-attesa Sh {sr0*np.sqrt(bpy):.2f} | DSR {dsr:.3f} [{'REGGE' if dsr>0.95 else 'NON regge'}]")
|
||||
|
||||
print("\n" + "=" * 88)
|
||||
print(" Verdetto: TP01 robusto se regge fee 0.40%+lag (HOLD positivo), plateau (no picco), DSR>0.95.")
|
||||
print("=" * 88)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,96 +0,0 @@
|
||||
"""TP01 a BASSA FREQUENZA (>=12h) — ri-verifica dopo il bug look-ahead ffill-mixed-TF.
|
||||
|
||||
L'utente/agente ha trovato un look-ahead (ffill mixed-timeframe su barre open-labeled) che
|
||||
gonfiava il 4h (~1.60 -> reale ~1.1) e ha concluso: NON scendere sotto le 12h (costi+overfit
|
||||
dominano). Qui ricalcolo TP01 in modo PULITO per singolo TF (barre discrete, posizione shiftata
|
||||
+1, NESSUN ffill/combine mixed-TF) su 4h/12h/1d, con un GUARD di causalita' esplicito sulla serie
|
||||
resamplata (ricalcolo su prefisso). Fee 0.10% RT, hold-out 2025-26 bloccato.
|
||||
|
||||
uv run python scripts/analysis/tp01_lowfreq.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from src.data.downloader import load_data
|
||||
from src.strategies.trend_portfolio import TrendPortfolio, simple_returns, CANONICAL
|
||||
|
||||
HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
|
||||
|
||||
|
||||
def resample_tf(df_1h, rule):
|
||||
g = df_1h.copy()
|
||||
g.index = pd.to_datetime(g["timestamp"], unit="ms", utc=True)
|
||||
out = g.resample(rule, label="left", closed="left").agg(
|
||||
{"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna(subset=["open"])
|
||||
out["datetime"] = out.index
|
||||
return out.reset_index(drop=True)
|
||||
|
||||
|
||||
def sleeve_net(df, tp):
|
||||
"""Per-barra netto di uno sleeve: posizione decisa a close[i-1], tenuta in i (causale, no ffill)."""
|
||||
r = simple_returns(df["close"].values.astype(float))
|
||||
tgt = tp.target_series(df)
|
||||
held = np.zeros(len(tgt)); held[1:] = tgt[:-1]
|
||||
net = held * r - tp.fee_side * np.abs(np.diff(held, prepend=0.0)); net[0] = 0.0
|
||||
return np.clip(net, -0.99, None)
|
||||
|
||||
|
||||
def causality_ok(df, tp, k=10):
|
||||
"""Ricalcola target_series su prefissi e verifica che tgt[i] non cambi (no look-ahead)."""
|
||||
full = tp.target_series(df); n = len(df)
|
||||
rng = np.random.default_rng(0); bad = 0
|
||||
for i in rng.integers(int(n * 0.6), n - 1, size=k):
|
||||
p = tp.target_series(df.iloc[:i + 1].copy())
|
||||
if len(p) != i + 1 or not np.isclose(np.nan_to_num(p[i]), np.nan_to_num(full[i]), atol=1e-9):
|
||||
bad += 1
|
||||
return bad
|
||||
|
||||
|
||||
def met(rr, idx):
|
||||
rr = rr[np.isfinite(rr)]
|
||||
if len(rr) < 2 or np.std(rr) == 0:
|
||||
return dict(sh=0, ret=0, dd=0, n=len(rr))
|
||||
bpy = 86400 * 365.25 / pd.Series(idx).diff().dt.total_seconds().median()
|
||||
eq = np.cumprod(1 + rr); pk = np.maximum.accumulate(eq)
|
||||
return dict(sh=float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)), ret=float(eq[-1] - 1),
|
||||
dd=float(np.max((pk - eq) / pk)), n=len(rr))
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 92)
|
||||
print(" TP01 RI-VERIFICA BASSA FREQUENZA — calcolo pulito per-TF (no ffill mixed-TF) | fee 0.10% RT")
|
||||
print("=" * 92)
|
||||
tp = TrendPortfolio(**CANONICAL)
|
||||
print(f" {'TF':<5s}{'leak':>6s}{'FULL Sh':>9s}{'FULL ret':>10s}{'FULL DD':>9s}{'HOLD Sh':>9s}{'HOLD ret':>10s}{'HOLD DD':>9s}")
|
||||
for tf, rule in [("4h", "4h"), ("6h", "6h"), ("12h", "12h"), ("1d", "1D")]:
|
||||
series = {}; leak = 0
|
||||
for a in ("BTC", "ETH"):
|
||||
df = resample_tf(load_data(a, "1h"), rule)
|
||||
leak += causality_ok(df, tp)
|
||||
series[a] = pd.Series(sleeve_net(df, tp), index=pd.to_datetime(df["datetime"]))
|
||||
J = pd.concat(series, axis=1, join="inner").fillna(0.0)
|
||||
combo = 0.5 * J["BTC"].values + 0.5 * J["ETH"].values
|
||||
idx = J.index; ho = idx >= HOLDOUT
|
||||
f = met(combo, idx); h = met(combo[ho], idx[ho])
|
||||
print(f" {tf:<5s}{leak:>6d}{f['sh']:>9.2f}{f['ret']*100:>+9.0f}%{f['dd']*100:>8.1f}%"
|
||||
f"{h['sh']:>9.2f}{h['ret']*100:>+9.1f}%{h['dd']*100:>8.1f}%")
|
||||
|
||||
# buy&hold 50/50 a 1d come riferimento hold-out
|
||||
bh = {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = resample_tf(load_data(a, "1h"), "1D")
|
||||
bh[a] = pd.Series(simple_returns(df["close"].values.astype(float)), index=pd.to_datetime(df["datetime"]))
|
||||
Jb = pd.concat(bh, axis=1, join="inner").fillna(0.0)
|
||||
cb = 0.5 * Jb["BTC"].values + 0.5 * Jb["ETH"].values; ix = Jb.index; ho = ix >= HOLDOUT
|
||||
bhf = met(cb, ix); bhh = met(cb[ho], ix[ho])
|
||||
print(f"\n buy&hold 50/50 (1d): FULL Sh {bhf['sh']:.2f} ret {bhf['ret']*100:+.0f}% DD {bhf['dd']*100:.0f}%"
|
||||
f" | HOLD-OUT Sh {bhh['sh']:.2f} ret {bhh['ret']*100:+.0f}% DD {bhh['dd']*100:.0f}%")
|
||||
print("\n (leak=0 = nessun look-ahead nel calcolo per-TF. Confronta con la tesi: >=12h trustworthy.)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,149 +0,0 @@
|
||||
"""VERIFICA AVVERSARIALE di TP01 (branch strategy-research-2026-06) col MIO gauntlet onesto.
|
||||
|
||||
TP01 = TSMOM multi-orizzonte (30/90/180g) long-flat, vol-target 20%, leva cap 2x, portafoglio
|
||||
50/50 BTC+ETH. Codice riprodotto VERBATIM dal branch (src/strategies/trend_portfolio.py).
|
||||
La loro tesi: 'positiva ogni anno 2019-2026, Sharpe ~1.32'. Il mio test decisivo: il HOLD-OUT
|
||||
2025-26 (che ha bocciato il mio trend 1h in Fase 3) + cross-asset + multi-TF (cherry-picking 4h?).
|
||||
|
||||
uv run python scripts/analysis/verify_tp01.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from src.data.downloader import load_data
|
||||
|
||||
HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
|
||||
CANONICAL = dict(target_vol=0.20, leverage=2.0, long_only=True,
|
||||
horizons_days=(30, 90, 180), vol_win_days=30, fee_side=0.0005)
|
||||
|
||||
|
||||
# ---- TP01 riprodotto VERBATIM dal branch ----
|
||||
def simple_returns(c):
|
||||
r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0; return r
|
||||
|
||||
def realized_vol(r, win, bpy):
|
||||
return pd.Series(r).rolling(win, min_periods=win // 2).std().values * np.sqrt(bpy)
|
||||
|
||||
def tsmom_blend(c, horizons):
|
||||
n = len(c); acc = np.zeros(n); cnt = np.zeros(n)
|
||||
for h in horizons:
|
||||
s = np.full(n, np.nan); s[h:] = np.sign(c[h:] / c[:-h] - 1.0)
|
||||
v = np.isfinite(s); acc[v] += s[v]; cnt[v] += 1
|
||||
out = np.zeros(n); nz = cnt > 0; out[nz] = acc[nz] / cnt[nz]; return out
|
||||
|
||||
def target_series(df, p, bpd):
|
||||
c = df["close"].values.astype(float); bpy = bpd * 365.25
|
||||
r = simple_returns(c)
|
||||
vol = realized_vol(r, p["vol_win_days"] * bpd, bpy)
|
||||
direction = tsmom_blend(c, tuple(d * bpd for d in p["horizons_days"]))
|
||||
if p["long_only"]:
|
||||
direction = np.clip(direction, 0, None)
|
||||
scal = np.where((vol > 0) & np.isfinite(vol), p["target_vol"] / vol, 0.0)
|
||||
tgt = np.clip(direction * scal, -p["leverage"], p["leverage"]); tgt[~np.isfinite(tgt)] = 0.0
|
||||
return tgt
|
||||
|
||||
def net_returns(df, p, bpd):
|
||||
c = df["close"].values.astype(float); r = simple_returns(c)
|
||||
tgt = target_series(df, p, bpd)
|
||||
pos_held = np.zeros(len(tgt)); pos_held[1:] = tgt[:-1] # decisa a close[t-1], tenuta in t -> causale
|
||||
gross = pos_held * r
|
||||
turn = np.abs(np.diff(pos_held, prepend=0.0))
|
||||
net = gross - p["fee_side"] * turn; net[0] = 0.0
|
||||
return np.clip(net, -0.99, None), pos_held
|
||||
|
||||
|
||||
def resample(df_1h, rule):
|
||||
g = df_1h.copy(); idx = pd.to_datetime(g["timestamp"], unit="ms", utc=True); g.index = idx
|
||||
out = g.resample(rule, label="left", closed="left").agg(
|
||||
{"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna(subset=["open"])
|
||||
out["timestamp"] = out.index
|
||||
return out.reset_index(drop=True)
|
||||
|
||||
|
||||
def metrics(combo, idx):
|
||||
rr = combo[np.isfinite(combo)]
|
||||
if len(rr) < 2 or np.std(rr) == 0:
|
||||
return dict(sharpe=0, cagr=0, dd=0, ret=0, n=len(rr))
|
||||
dt = pd.Series(idx).diff().dt.total_seconds().median()
|
||||
bpy = 86400 * 365.25 / dt
|
||||
eq = np.cumprod(1 + rr); peak = np.maximum.accumulate(eq)
|
||||
years = (idx[-1] - idx[0]).total_seconds() / 86400 / 365.25
|
||||
return dict(sharpe=float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)),
|
||||
cagr=float(eq[-1] ** (1 / years) - 1) if years > 0 else 0,
|
||||
dd=float(np.max((peak - eq) / peak)), ret=float(eq[-1] - 1), n=len(rr))
|
||||
|
||||
|
||||
def portfolio_combo(tf_rule, bpd):
|
||||
series = {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = load_data(a, "1h")
|
||||
if tf_rule:
|
||||
df = resample(df, tf_rule)
|
||||
net, _ = net_returns(df, CANONICAL, bpd)
|
||||
series[a] = pd.Series(net, index=pd.to_datetime(df["timestamp"], unit="ms", utc=True) if not tf_rule
|
||||
else pd.DatetimeIndex(df["timestamp"]))
|
||||
J = pd.concat(series, axis=1, join="inner").fillna(0.0)
|
||||
combo = 0.5 * J["BTC"].values + 0.5 * J["ETH"].values
|
||||
return combo, J.index, J
|
||||
|
||||
|
||||
def line(label, combo, idx):
|
||||
m = metrics(combo, idx)
|
||||
return f" {label:<22s} Sharpe {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% CAGR {m['cagr']*100:>+6.1f}% | DD {m['dd']*100:>5.1f}% | n {m['n']}"
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 92)
|
||||
print(" VERIFICA TP01 (TSMOM 30/90/180 vol-target 20% lev2x long-flat, 50/50 BTC+ETH)")
|
||||
print(" col gauntlet onesto: FULL vs buy&hold | HOLD-OUT 2025-26 bloccato | per-anno | multi-TF")
|
||||
print("=" * 92)
|
||||
|
||||
TFS = [("15m", "15min", 96), ("1h", None, 24), ("4h", "4h", 6), ("1d", "1D", 1)]
|
||||
print("\n (A) MULTI-TF: il 4h e' cherry-picked? FULL + HOLD-OUT per ogni timeframe")
|
||||
for tf, rule, bpd in TFS:
|
||||
combo, idx, J = portfolio_combo(rule, bpd)
|
||||
ho = idx >= HOLDOUT
|
||||
full = metrics(combo, idx)
|
||||
hold = metrics(combo[ho], idx[ho])
|
||||
tag = " <- canonica" if tf == "4h" else ""
|
||||
print(f" {tf:<3s} FULL Sh {full['sharpe']:>5.2f} CAGR {full['cagr']*100:>+6.1f}% DD {full['dd']*100:>4.1f}% "
|
||||
f"| HOLD-OUT Sh {hold['sharpe']:>5.2f} ret {hold['ret']*100:>+6.1f}% DD {hold['dd']*100:>4.1f}%{tag}")
|
||||
|
||||
# focus 4h canonica
|
||||
combo, idx, J = portfolio_combo("4h", 6)
|
||||
print("\n (B) 4h CANONICA — per anno (la tesi: positiva OGNI anno 2019-2026)")
|
||||
s = pd.Series(combo, index=idx)
|
||||
for y, g in s.groupby(s.index.year):
|
||||
eq = np.cumprod(1 + g.values); pk = np.maximum.accumulate(eq)
|
||||
ho_flag = " <- HOLD-OUT (mai usato per scegliere config?)" if y >= 2025 else ""
|
||||
print(f" {y}: ret {(eq[-1]-1)*100:>+7.1f}% DD {np.max((pk-eq)/pk)*100:>5.1f}%{ho_flag}")
|
||||
|
||||
print("\n (C) HOLD-OUT 2025-26 — TP01 vs buy&hold 50/50 (4h)")
|
||||
ho = idx >= HOLDOUT
|
||||
print(line("TP01 portfolio HO", combo[ho], idx[ho]))
|
||||
# buy&hold 50/50 sullo stesso indice/finestra
|
||||
bh = {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = resample(load_data(a, "1h"), "4h")
|
||||
r = simple_returns(df["close"].values.astype(float))
|
||||
bh[a] = pd.Series(r, index=pd.DatetimeIndex(df["timestamp"]))
|
||||
Jb = pd.concat(bh, axis=1, join="inner").reindex(idx).fillna(0.0)
|
||||
bh_combo = 0.5 * Jb["BTC"].values + 0.5 * Jb["ETH"].values
|
||||
print(line("buy&hold 50/50 HO", bh_combo[ho], idx[ho]))
|
||||
print(line("TP01 portfolio FULL", combo, idx))
|
||||
print(line("buy&hold 50/50 FULL", bh_combo, idx))
|
||||
|
||||
print("\n (D) CROSS-ASSET nel HOLD-OUT (lo stesso edge regge su ENTRAMBI?)")
|
||||
for a in ("BTC", "ETH"):
|
||||
df = resample(load_data(a, "1h"), "4h")
|
||||
net, _ = net_returns(df, CANONICAL, 6)
|
||||
ix = pd.DatetimeIndex(df["timestamp"]); m = ix >= HOLDOUT
|
||||
print(line(f"TP01 {a} sleeve HO", net[m], ix[m]))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,14 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Refresh dati certificati + avanza paper portfolio (per il dashboard). v2.0.0+.
|
||||
export PATH="/home/adriano/.local/bin:$PATH"
|
||||
cd /opt/docker/PythagorasGoal || exit 1
|
||||
mkdir -p logs
|
||||
{
|
||||
echo "===== $(date -u '+%Y-%m-%dT%H:%M:%SZ') cron_daily ====="
|
||||
uv run python scripts/analysis/rebuild_history.py --asset BTC ETH # BTC/ETH Deribit mainnet
|
||||
uv run python scripts/analysis/fetch_hyperliquid.py # 52 alt Hyperliquid (certify)
|
||||
uv run python scripts/research/fetch_dvol.py # DVOL (per ricerca opzioni)
|
||||
uv run python scripts/live/paper_portfolio.py # avanza paper TP01+XS01
|
||||
uv run python scripts/live/live_execute.py --execute # TP01 LIVE su Deribit (gated da config/live.json)
|
||||
echo "===== done $(date -u '+%H:%M:%SZ') ====="
|
||||
} >> logs/cron_daily.log 2>&1
|
||||
@@ -1,141 +0,0 @@
|
||||
"""TP01 LIVE EXECUTE — loop di esecuzione GATED su Deribit mainnet (USDC linear).
|
||||
|
||||
Porta il conto reale al target di TP01 (causale, dati certificati): per ogni asset calcola il notional
|
||||
bersaglio = min(0.5 * frazione * equity, max_notional), e apre/riduce/chiude per raggiungerlo.
|
||||
|
||||
DOPPIO GATE DI SICUREZZA (entrambi necessari per inviare ordini reali):
|
||||
1. config/live.json -> "execution_enabled": true (master switch, default false)
|
||||
2. flag CLI --execute
|
||||
Senza entrambi e' un DRY-RUN (stampa il piano, NON invia). Reconciliation dopo ogni ordine; log in
|
||||
data/live/executions.jsonl. TP01 oggi e' FLAT -> target 0 -> nessuna azione finche' il segnale non gira.
|
||||
|
||||
uv run python scripts/live/live_execute.py # DRY-RUN (piano, nessun ordine)
|
||||
uv run python scripts/live/live_execute.py --execute # esegue SOLO se execution_enabled=true
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pandas as pd
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
|
||||
from src.live.deribit import INSTRUMENT
|
||||
from src.live.execution import DeribitTrader
|
||||
from src.live.notifier import notify
|
||||
from src.live.shadow import ASSETS, WEIGHT, shadow_report
|
||||
|
||||
CONFIG = PROJECT_ROOT / "config" / "live.json"
|
||||
LOG_DIR = PROJECT_ROOT / "data" / "live"
|
||||
LOG = LOG_DIR / "executions.jsonl"
|
||||
|
||||
|
||||
def load_config() -> dict:
|
||||
cfg = json.loads(CONFIG.read_text()) if CONFIG.exists() else {}
|
||||
cfg.setdefault("execution_enabled", False)
|
||||
cfg.setdefault("max_notional_per_asset_usd", 300.0)
|
||||
cfg.setdefault("min_order_usd", 5.0)
|
||||
cfg.setdefault("disaster_sl_pct", 0.30)
|
||||
return cfg
|
||||
|
||||
|
||||
def log_event(rec: dict):
|
||||
LOG_DIR.mkdir(parents=True, exist_ok=True)
|
||||
with open(LOG, "a") as f:
|
||||
f.write(json.dumps(rec) + "\n")
|
||||
|
||||
|
||||
def _run():
|
||||
cfg = load_config()
|
||||
want_execute = "--execute" in sys.argv[1:]
|
||||
enabled = bool(cfg["execution_enabled"])
|
||||
do_execute = want_execute and enabled
|
||||
max_notional = float(cfg["max_notional_per_asset_usd"])
|
||||
min_order = float(cfg["min_order_usd"])
|
||||
sl_pct = float(cfg["disaster_sl_pct"])
|
||||
|
||||
r = shadow_report() # targets causali + conto/posizioni reali (online)
|
||||
equity = r["equity"]
|
||||
|
||||
print("=" * 84)
|
||||
print(" TP01 LIVE EXECUTE — Deribit mainnet (USDC linear)")
|
||||
print("=" * 84)
|
||||
mode = ("ESECUZIONE REALE" if do_execute else
|
||||
("ARMATO ma manca --execute" if enabled else "DRY-RUN (execution_enabled=false)"))
|
||||
print(f" modo : {mode}")
|
||||
print(f" gate : execution_enabled={enabled} | --execute={want_execute}")
|
||||
print(f" conto reale : ${r['real_equity']:,.2f}" if r["real_equity"] else f" conto: {r['eq_basis']}")
|
||||
print(f" sizing base : ${equity:,.2f} | cap/asset ${max_notional:.0f} | min ${min_order:.0f} | disaster-SL -{sl_pct*100:.0f}%")
|
||||
print(f" ultima barra : {r['last_data']}\n")
|
||||
|
||||
if not r["online"]:
|
||||
print(" conto non leggibile (offline) -> stop, non eseguo a cieco.")
|
||||
if do_execute:
|
||||
notify("⚠️ TP01 LIVE — conto offline", {"nota": "salto l'esecuzione, non opero a cieco"})
|
||||
return
|
||||
|
||||
trader = DeribitTrader() if do_execute else None
|
||||
actions = []
|
||||
for a in r["assets"]:
|
||||
asset = a["asset"]; frac = a["target"]; mark = a["mark"]; cur = a["position_usd"]
|
||||
tgt = min(WEIGHT * frac * equity, max_notional) if frac > 0 else 0.0
|
||||
delta = tgt - cur
|
||||
if abs(delta) < min_order:
|
||||
act = "HOLD (a target)"
|
||||
elif tgt < 1.0 and cur > 1.0:
|
||||
act = f"CLOSE ${cur:,.0f}"
|
||||
elif delta > 0:
|
||||
act = f"BUY ${delta:,.0f}"
|
||||
else:
|
||||
act = f"REDUCE ${-delta:,.0f}"
|
||||
print(f" {asset:<3} target {frac:+.3f}x -> ${tgt:,.0f} | pos ${cur:,.0f} | delta ${delta:+,.0f} -> {act}")
|
||||
|
||||
if do_execute:
|
||||
if not act.startswith("HOLD"):
|
||||
fills = trader.rebalance_to(INSTRUMENT[asset], tgt, mark, min_usd=min_order)
|
||||
newpos = trader.position_usd(INSTRUMENT[asset])
|
||||
for f in fills:
|
||||
print(f" -> {f.side.upper()} {f.filled:.4f} @ ${f.price:,.1f} fee {f.fee_usdc:.5f} "
|
||||
f"({'OK' if f.verified else 'NON VERIFICATO: ' + f.notes})")
|
||||
log_event(dict(ts_utc=str(pd.Timestamp(r['last_data'])), asset=asset, action=act,
|
||||
side=f.side, filled=f.filled, price=f.price, fee=f.fee_usdc,
|
||||
verified=f.verified, notes=f.notes, pos_after=newpos))
|
||||
det = dict(asset=asset, side=f.side, amount=round(f.filled, 4),
|
||||
price=round(f.price or 0, 1), fee=round(f.fee_usdc, 5), pos_after=round(newpos, 0))
|
||||
if f.verified:
|
||||
notify(f"✅ TP01 {act}", det)
|
||||
else:
|
||||
notify("⚠️ TP01 ORDINE NON VERIFICATO", {**det, "notes": f.notes})
|
||||
print(f" reconcile: pos ${newpos:,.0f}")
|
||||
ds = trader.ensure_disaster_sl(INSTRUMENT[asset], sl_pct) # bracket: piazza se long, pulisce se flat
|
||||
print(f" disaster-SL: {ds.get('state')}" + (f" @ ${ds['stop']:,.1f}" if ds.get("stop") else ""))
|
||||
if ds.get("state") == "placed":
|
||||
notify("🛡️ TP01 disaster-SL piazzato", {"asset": asset, "stop": round(ds.get("stop") or 0, 1),
|
||||
"amount": round(ds.get("amount") or 0, 4)})
|
||||
elif ds.get("state") == "place-failed":
|
||||
notify("⚠️ TP01 disaster-SL FALLITO", {"asset": asset, "notes": ds.get("notes")})
|
||||
actions.append(act)
|
||||
|
||||
print()
|
||||
if not do_execute:
|
||||
print(" => DRY-RUN: nessun ordine inviato." +
|
||||
("" if enabled else " Per armare: config/live.json execution_enabled=true + --execute."))
|
||||
elif all(x.startswith("HOLD") for x in actions):
|
||||
print(" => Nessuna azione: conto gia' al target di TP01 (oggi flat).")
|
||||
else:
|
||||
print(" => Esecuzione completata (vedi data/live/executions.jsonl).")
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
_run()
|
||||
except Exception as e:
|
||||
notify("🛑 TP01 LIVE — ERRORE", {"error": f"{type(e).__name__}: {e}"})
|
||||
raise
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,78 +0,0 @@
|
||||
"""TP01 LIVE — SHADOW MODE (Deribit mainnet, SOLA LETTURA, nessun ordine inviato).
|
||||
|
||||
Valida l'esecuzione di TP01 a RISCHIO ZERO: gira il loop live completo contro dati/conto/posizioni
|
||||
REALI del mainnet, calcola i target causali (stesso codice del backtest/paper), costruisce gli ordini
|
||||
di ribilancio esatti — e li STAMPA invece di inviarli. Confronta i target col paper trader (parita').
|
||||
|
||||
Perche' non testnet: il testnet Cerbero/Deribit e' la causa del reset v2.0.0 (feed farlocco). La
|
||||
validazione a rischio zero qui e' "shadow su mainnet reale in sola lettura"; il fill (slippage/fee)
|
||||
si valida solo col micro-test mainnet a size minima, in un passo successivo.
|
||||
|
||||
Logica condivisa con la dashboard in src/live/shadow.py (un solo codice, niente drift).
|
||||
|
||||
uv run python scripts/live/live_trend.py # shadow su mainnet reale
|
||||
uv run python scripts/live/live_trend.py --equity 2000 # forza la base di sizing
|
||||
uv run python scripts/live/live_trend.py --no-net # offline: solo matematica + parita'
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
|
||||
from src.live.deribit import notional_to_amount
|
||||
from src.live.shadow import shadow_report
|
||||
|
||||
|
||||
def main():
|
||||
argv = sys.argv[1:]
|
||||
offline = "--no-net" in argv
|
||||
equity_override = float(argv[argv.index("--equity") + 1]) if "--equity" in argv else None
|
||||
r = shadow_report(offline=offline, equity_override=equity_override)
|
||||
|
||||
print("=" * 84)
|
||||
print(" TP01 LIVE — SHADOW MODE (Deribit mainnet, SOLA LETTURA — NESSUN ORDINE INVIATO)")
|
||||
print("=" * 84)
|
||||
real_eq = r["real_equity"]
|
||||
conto = f"${real_eq:,.2f}" if real_eq else r["eq_basis"]
|
||||
print(f" ultima barra 1d chiusa : {r['last_data']}")
|
||||
print(f" rete : {'mainnet via Cerbero MCP' if r['online'] else 'OFFLINE / fallback close'}")
|
||||
print(f" prezzi mark : " + " | ".join(f"{a['asset']} ${a['mark']:,.1f} ({a['mark_src']})" for a in r["assets"]))
|
||||
print(f" conto reale : {conto}")
|
||||
print(f" posizioni reali : " + ", ".join(f"{a['asset']} ${a['position_usd']:,.0f}" for a in r["assets"]) + f" ({r['pos_src']})")
|
||||
print(f" base di sizing : ${r['equity']:,.2f} [{r['eq_basis']}]")
|
||||
|
||||
print("\n PER ASSET (target causale @ ultima barra chiusa):")
|
||||
for a in r["assets"]:
|
||||
state = "FLAT" if abs(a["target"]) < 1e-9 else ("LONG" if a["target"] > 0 else "SHORT")
|
||||
line = (f" {a['asset']:<3} {state:<5} target {a['target']:+.3f}x -> notional ${a['target_notional']:,.0f}"
|
||||
f" (pos reale ${a['position_usd']:,.0f})")
|
||||
o = a["order"]
|
||||
if o:
|
||||
print(line + f"\n -> ORDINE: {o['side'].upper()} {o['amount']:.0f} {a['instrument']} "
|
||||
f"(market{', reduce_only' if o['reduce_only'] else ''}, delta ${o['delta_notional']:,.0f})")
|
||||
else:
|
||||
print(line + " -> nessun ordine (gia' a target / sotto-soglia)")
|
||||
|
||||
print("\n PARITA' vs paper trader (target = current_target):")
|
||||
if all(a["paper"] is None for a in r["assets"]):
|
||||
print(" (paper non inizializzato: avvia scripts/live/paper_trend.py)")
|
||||
else:
|
||||
for a in r["assets"]:
|
||||
print(f" {a['asset']}: paper {a['paper']:+.3f}x shadow {a['target']:+.3f}x -> {'OK' if a['parity'] else 'DIFFERISCE'}")
|
||||
if not r["paper_aligned"]:
|
||||
print(" NB paper non all'ultima barra -> avanzalo se i target differiscono")
|
||||
|
||||
print("\n VERIFICA costruttore ordini (quantizzazione step/minimo):")
|
||||
for inst, samples in (("BTC-PERPETUAL", [1000, 1005, 7, 250.4]), ("ETH-PERPETUAL", [1000, 0.4, 33.7])):
|
||||
got = ", ".join(f"${s}->{notional_to_amount(inst, s):.0f}" for s in samples)
|
||||
print(f" {inst}: {got}")
|
||||
|
||||
print("\n => NESSUN ORDINE INVIATO (shadow). " +
|
||||
(f"{len(r['orders'])} ordine/i costruito/i sopra." if r["orders"] else "Target flat: 0 ordini."))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,92 +0,0 @@
|
||||
"""MICRO-TEST esecuzione su Deribit mainnet — round-trip minimo su BTC_USDC-PERPETUAL, apri+chiudi.
|
||||
|
||||
Conto reale = USDC -> strumento ESEGUIBILE = perp LINEARE `BTC_USDC-PERPETUAL` (amount in BTC, step
|
||||
0.0001 ~ $6). Valida il percorso ordine->fill->reconciliation->chiusura con soldi VERI a size MINIMA
|
||||
(~0x leva, decoupled dal segnale): test della plumbing, non della strategia. Usa open()/close()
|
||||
verificati di src/live/execution.py (logica entrata/uscita presa da Old).
|
||||
|
||||
Sicurezze: default DRY-RUN. Pre-flight ABORT se posizione preesistente. La chiusura (reduce_only,
|
||||
sempre permessa) flatta comunque dopo l'apertura; verifica finale di FLAT (alert se no).
|
||||
|
||||
uv run python scripts/live/microtest.py # DRY-RUN: nessun ordine inviato
|
||||
uv run python scripts/live/microtest.py --live # invia il round-trip REALE
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
|
||||
from src.live.execution import FLAT_USD, MAX_AMOUNT, DeribitTrader
|
||||
|
||||
INSTRUMENT = "BTC_USDC-PERPETUAL"
|
||||
AMOUNT = 0.0001 # base-coin (BTC) = 1 contratto minimo (~$6 a $63k)
|
||||
|
||||
|
||||
def main():
|
||||
live = "--live" in sys.argv[1:]
|
||||
t = DeribitTrader()
|
||||
|
||||
print("=" * 82)
|
||||
print(" MICRO-TEST esecuzione TP01 — round-trip 0.0001 BTC su BTC_USDC-PERPETUAL (leva ~0x)")
|
||||
print("=" * 82)
|
||||
try:
|
||||
equity = float(t.account_summary("USDC").get("equity") or 0)
|
||||
mark = t.mark_price(INSTRUMENT)
|
||||
pos0 = t.position_usd(INSTRUMENT)
|
||||
except Exception as e:
|
||||
print(f" PRE-FLIGHT FALLITO (read): {type(e).__name__}: {e}\n -> non procedo.")
|
||||
return
|
||||
|
||||
notional = AMOUNT * mark
|
||||
print(f" conto USDC equity : ${equity:,.2f}")
|
||||
print(f" mark {INSTRUMENT} : ${mark:,.1f}")
|
||||
print(f" posizione attuale : ${pos0:,.2f} notional (dev'essere 0)")
|
||||
print(f" apertura : BUY {AMOUNT:.4f} BTC market (~${notional:.2f}, leva {notional/equity:.4f}x)")
|
||||
print(f" chiusura : SELL {AMOUNT:.4f} BTC market reduce_only")
|
||||
print(f" guardrail: solo {INSTRUMENT}, cap apertura {MAX_AMOUNT[INSTRUMENT]} BTC")
|
||||
|
||||
if abs(pos0) >= FLAT_USD:
|
||||
print(f"\n ABORT: posizione preesistente (${pos0:,.2f}). Non la tocco. Chiudila a mano e ripeti.")
|
||||
return
|
||||
if not live:
|
||||
print("\n DRY-RUN: nessun ordine inviato. Rilancia con --live per il round-trip reale.")
|
||||
return
|
||||
|
||||
# ---- LIVE: apertura ----
|
||||
print("\n >>> LIVE: APERTURA ...")
|
||||
fo = t.open(INSTRUMENT, "buy", AMOUNT, label="tp01-microtest-open")
|
||||
if not fo.verified:
|
||||
print(f" apertura NON verificata: {fo.notes}")
|
||||
# safety: assicura comunque il flat
|
||||
fc = t.close(INSTRUMENT, label="tp01-microtest-safeclose")
|
||||
print(f" safe-close: {'eseguita' if fc else 'gia flat'}; posizione ${t.position_usd(INSTRUMENT):,.2f}")
|
||||
return
|
||||
print(f" FILL: {fo.filled:.4f} BTC @ ${fo.price:,.1f} fee {fo.fee_usdc:.6f} USDC (state={fo.state})")
|
||||
|
||||
# ---- LIVE: chiusura (reduce_only) ----
|
||||
print(" >>> LIVE: CHIUSURA (reduce_only) ...")
|
||||
fc = t.close(INSTRUMENT, label="tp01-microtest-close")
|
||||
pos_end = t.position_usd(INSTRUMENT)
|
||||
if fc:
|
||||
print(f" FILL: {fc.filled:.4f} BTC @ ${fc.price:,.1f} fee {fc.fee_usdc:.6f} USDC (state={fc.state})")
|
||||
print(f" posizione finale: ${pos_end:,.2f} notional")
|
||||
|
||||
# ---- report ----
|
||||
print("\n " + "-" * 62)
|
||||
if abs(pos_end) < FLAT_USD:
|
||||
print(" ✓ ROUND-TRIP COMPLETO — posizione tornata a FLAT.")
|
||||
else:
|
||||
print(f" ⚠️ posizione NON flat (${pos_end:,.2f}) — INTERVENTO MANUALE: chiudi a mano.")
|
||||
if fo.verified and fc:
|
||||
tot_fee = fo.fee_usdc + fc.fee_usdc
|
||||
pnl = AMOUNT * ((fc.price or 0) - (fo.price or 0))
|
||||
print(f" entry ${fo.price:,.1f} -> exit ${fc.price:,.1f} | fee {tot_fee:.6f} USDC | "
|
||||
f"pnl lordo {pnl:+.4f} | netto {pnl - tot_fee:+.4f} USDC")
|
||||
print(" Validato: invio ordine reale, fill, fee reali, reconciliation, ritorno a flat.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,86 +0,0 @@
|
||||
"""PAPER PORTFOLIO — forward-only del portafoglio attivo (TP01 + XS01), simulato.
|
||||
|
||||
Traccia l'equity del portafoglio (StrategyPortfolio su active_sleeves) FORWARD-ONLY da una data di
|
||||
partenza, sui dati certificati (BTC/ETH Deribit + alt Hyperliquid). Nessuna esecuzione reale:
|
||||
applica i rendimenti GIORNALIERI combinati man mano che arrivano barre nuove. Stato persistente.
|
||||
Il dashboard (src/live/dashboard.py) legge questo stato + ricalcola il backtest a colpo d'occhio.
|
||||
|
||||
uv run python scripts/live/paper_portfolio.py # avanza (init al 1o run)
|
||||
uv run python scripts/live/paper_portfolio.py --status # solo stato
|
||||
uv run python scripts/live/paper_portfolio.py --reset # azzera (riparte da ora)
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys, json
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd
|
||||
from src.portfolio.portfolio import StrategyPortfolio
|
||||
from src.portfolio.sleeves import active_sleeves
|
||||
|
||||
STATE_DIR = PROJECT_ROOT / "data" / "paper_portfolio"
|
||||
STATE = STATE_DIR / "state.json"
|
||||
EQ = STATE_DIR / "equity.csv"
|
||||
INITIAL = 2000.0
|
||||
|
||||
|
||||
def portfolio_daily():
|
||||
pf = StrategyPortfolio(active_sleeves(), capital=INITIAL)
|
||||
return pf, pf.combined_daily()
|
||||
|
||||
|
||||
def load():
|
||||
return json.loads(STATE.read_text()) if STATE.exists() else None
|
||||
|
||||
|
||||
def save(st):
|
||||
STATE_DIR.mkdir(parents=True, exist_ok=True)
|
||||
STATE.write_text(json.dumps(st, indent=2))
|
||||
|
||||
|
||||
def advance():
|
||||
pf, r = portfolio_daily()
|
||||
st = load()
|
||||
if st is None: # init: forward-only, parte dall'ultima barra
|
||||
last = str(r.index[-1])
|
||||
st = dict(start=last, last=last, equity=INITIAL, initial=INITIAL,
|
||||
peak=INITIAL, max_dd=0.0, n_days=0)
|
||||
save(st)
|
||||
STATE_DIR.mkdir(parents=True, exist_ok=True)
|
||||
EQ.write_text("date,equity\n" + f"{last},{INITIAL}\n")
|
||||
return st
|
||||
last = pd.Timestamp(st["last"])
|
||||
new = r[r.index > last]
|
||||
if len(new):
|
||||
eq = st["equity"]; peak = st["peak"]; dd = st["max_dd"]
|
||||
lines = []
|
||||
for d, ret in new.items():
|
||||
eq *= (1.0 + float(ret)); peak = max(peak, eq); dd = max(dd, (peak - eq) / peak if peak > 0 else 0)
|
||||
lines.append(f"{d},{eq:.4f}")
|
||||
st.update(equity=eq, last=str(new.index[-1]), peak=peak, max_dd=dd, n_days=st["n_days"] + len(new))
|
||||
save(st)
|
||||
with open(EQ, "a") as f:
|
||||
f.write("\n".join(lines) + "\n")
|
||||
return st
|
||||
|
||||
|
||||
def main():
|
||||
a = sys.argv[1:]
|
||||
if "--reset" in a:
|
||||
for f in (STATE, EQ):
|
||||
f.unlink(missing_ok=True)
|
||||
print("paper portfolio azzerato.")
|
||||
st = load() if "--status" in a else advance()
|
||||
if st is None:
|
||||
st = advance()
|
||||
pf, _ = portfolio_daily()
|
||||
days = (pd.Timestamp(st["last"]) - pd.Timestamp(st["start"])).days
|
||||
ret = st["equity"] / st["initial"] - 1
|
||||
print(f"PAPER PORTFOLIO (TP01+XS01) — forward-only")
|
||||
print(f" start {st['start'][:10]} -> last {st['last'][:10]} ({days}g, {st['n_days']} barre)")
|
||||
print(f" equity {st['equity']:.2f} (start {st['initial']:.0f}) ret {ret*100:+.2f}% maxDD {st['max_dd']*100:.1f}%")
|
||||
print(f" posizioni correnti: {pf.current_positions()}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+12
-13
@@ -1,14 +1,14 @@
|
||||
"""PAPER TRADER — TP01 Trend Portfolio (PORT LF1d), forward-only, simulato.
|
||||
"""PAPER TRADER — TP01 Trend Portfolio (PORT LF4h), forward-only, simulato.
|
||||
|
||||
Esegue la strategia VINCENTE (src/strategies/trend_portfolio.py, config CANONICAL) in
|
||||
paper trading FORWARD-ONLY su capitale virtuale (default 2000 USDT), portafoglio 50/50
|
||||
BTC+ETH a 1d. Stato persistente -> resume al riavvio.
|
||||
BTC+ETH a 4h. Stato persistente -> resume al riavvio.
|
||||
|
||||
DESIGN (onesto, niente esecuzione reale: l'esecuzione e' DISABILITATA nel progetto):
|
||||
- Legge i parquet certificati locali (data/raw, BTC/ETH 1h) e resampla a 1d.
|
||||
- Alla prima esecuzione parte dall'ultima barra 1d CHIUSA disponibile (forward-only:
|
||||
- Legge i parquet certificati locali (data/raw, BTC/ETH 1h) e resampla a 4h.
|
||||
- Alla prima esecuzione parte dall'ultima barra 4h CHIUSA disponibile (forward-only:
|
||||
NON include lo storico nel PnL di paper, traccia solo da ora in avanti).
|
||||
- Ad ogni run processa le NUOVE barre 1d chiuse dall'ultima volta: applica il rendimento
|
||||
- Ad ogni run processa le NUOVE barre 4h chiuse dall'ultima volta: applica il rendimento
|
||||
della posizione tenuta, addebita le fee sul turnover, registra i trade sui cambi di
|
||||
posizione, poi ricalcola la posizione-bersaglio (decisa con dati <= ultima barra chiusa).
|
||||
- Per avere barre fresche, aggiornare prima i dati:
|
||||
@@ -33,7 +33,7 @@ PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
|
||||
from src.backtest.harness import load
|
||||
from src.strategies.trend_portfolio import TrendPortfolio, CANONICAL, resample_1d, simple_returns
|
||||
from src.strategies.trend_portfolio import TrendPortfolio, CANONICAL, resample_4h, simple_returns
|
||||
|
||||
STATE_DIR = PROJECT_ROOT / "data" / "paper_trend"
|
||||
STATE_FILE = STATE_DIR / "state.json"
|
||||
@@ -43,9 +43,8 @@ WEIGHT = 0.5
|
||||
INITIAL_CAPITAL = 2000.0
|
||||
|
||||
|
||||
def build_bars() -> dict[str, pd.DataFrame]:
|
||||
# Deploy a 1d (>=12h): sotto le 12h costi+overfit dominano (vedi trend_portfolio docstring + bug ffill mixed-TF).
|
||||
return {a: resample_1d(load(a, "1h")) for a in ASSETS}
|
||||
def build_4h() -> dict[str, pd.DataFrame]:
|
||||
return {a: resample_4h(load(a, "1h")) for a in ASSETS}
|
||||
|
||||
|
||||
def load_state() -> dict | None:
|
||||
@@ -81,7 +80,7 @@ def init_state(dfs) -> dict:
|
||||
|
||||
|
||||
def advance(st: dict, dfs: dict) -> dict:
|
||||
"""Processa tutte le barre 1d chiuse DOPO st['last_ts']."""
|
||||
"""Processa tutte le barre 4h chiuse DOPO st['last_ts']."""
|
||||
tp = TrendPortfolio(**CANONICAL)
|
||||
# precompute per-asset: timestamps, returns, target series (causale)
|
||||
data = {}
|
||||
@@ -145,10 +144,10 @@ def print_status(st: dict, dfs: dict):
|
||||
ret = cap / st["initial_capital"] - 1
|
||||
daily = (cap - st["initial_capital"]) / days if days > 0 else 0.0
|
||||
print("=" * 72)
|
||||
print(" PAPER TRADER — TP01 Trend Portfolio (PORT LF1d, 50/50 BTC+ETH, 1d)")
|
||||
print(" PAPER TRADER — TP01 Trend Portfolio (PORT LF4h, 50/50 BTC+ETH, 4h)")
|
||||
print("=" * 72)
|
||||
print(f" start {start:%Y-%m-%d %H:%M} UTC")
|
||||
print(f" last bar {last:%Y-%m-%d %H:%M} UTC ({days:.1f} giorni, {st['n_bars']} barre 1d)")
|
||||
print(f" last bar {last:%Y-%m-%d %H:%M} UTC ({days:.1f} giorni, {st['n_bars']} barre 4h)")
|
||||
print(f" capitale {cap:,.2f} USDT (start {st['initial_capital']:,.0f})")
|
||||
print(f" ritorno {ret*100:+.2f}% | €/giorno {daily:+.2f} | maxDD {st['max_dd']*100:.1f}%")
|
||||
print(f" posizioni now { 'flat' if all(p==0 for p in st['positions'].values()) else '' }")
|
||||
@@ -169,7 +168,7 @@ def print_status(st: dict, dfs: dict):
|
||||
|
||||
def main():
|
||||
argv = sys.argv[1:]
|
||||
dfs = build_bars()
|
||||
dfs = build_4h()
|
||||
if "--reset" in argv:
|
||||
if STATE_FILE.exists():
|
||||
STATE_FILE.unlink()
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
"""REPORT del portafoglio di strategie attivo (estensibile).
|
||||
|
||||
Costruisce il portafoglio dagli sleeve attivi (src/portfolio/sleeves.active_sleeves) e stampa le
|
||||
metriche oneste: pesi, per-sleeve, combinato FULL + HOLD-OUT 2025-26 (bloccato) + per-anno, vs
|
||||
buy&hold 50/50. Per ora c'e' solo TP01; aggiungere sleeve = una riga in sleeves.py.
|
||||
|
||||
uv run python scripts/portfolio/run_portfolio.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
from src.data.downloader import load_data
|
||||
from src.strategies.trend_portfolio import resample_1d, simple_returns
|
||||
from src.portfolio.portfolio import StrategyPortfolio, to_daily, metrics, HOLDOUT
|
||||
from src.portfolio.sleeves import active_sleeves
|
||||
|
||||
CAPITAL = 2000.0
|
||||
|
||||
|
||||
def buy_hold_daily() -> pd.Series:
|
||||
s = {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = resample_1d(load_data(a, "1h"))
|
||||
s[a] = pd.Series(simple_returns(df["close"].values.astype(float)), index=pd.to_datetime(df["datetime"]))
|
||||
J = pd.concat(s, axis=1, join="inner").fillna(0.0)
|
||||
return to_daily(pd.Series(0.5 * J["BTC"].values + 0.5 * J["ETH"].values, index=J.index))
|
||||
|
||||
|
||||
def fmt(m, cap=CAPITAL):
|
||||
yrs = m["n"] / 365.25
|
||||
eur_day = (cap * m["ret"]) / (yrs * 365.25) if yrs > 0 else 0.0
|
||||
return (f"Sh {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% CAGR {m['cagr']*100:>+6.1f}% | "
|
||||
f"DD {m['maxdd']*100:>5.1f}% | ~€/g(2k) {eur_day:>+5.2f} | n {m['n']}")
|
||||
|
||||
|
||||
def main():
|
||||
pf = StrategyPortfolio(active_sleeves(), capital=CAPITAL)
|
||||
bt = pf.backtest()
|
||||
print("=" * 96)
|
||||
print(f" PORTAFOGLIO DI STRATEGIE — {len(pf.sleeves)} sleeve | capitale {CAPITAL:,.0f} | hold-out {HOLDOUT.date()}+ bloccato")
|
||||
print("=" * 96)
|
||||
|
||||
print("\n PESI:", " ".join(f"{k} {v*100:.0f}%" for k, v in bt["weights"].items()))
|
||||
|
||||
print("\n PER-SLEEVE (standalone):")
|
||||
for name, d in bt["per_sleeve"].items():
|
||||
print(f" {name:<16s} [{d['weight']*100:>3.0f}%] FULL {fmt(d['full'])}")
|
||||
print(f" {'':<16s} HOLD {fmt(d['holdout'])}")
|
||||
|
||||
print("\n PORTAFOGLIO COMBINATO:")
|
||||
print(f" FULL {fmt(bt['full'])}")
|
||||
print(f" HOLD-OUT {fmt(bt['holdout'])}")
|
||||
|
||||
bh = buy_hold_daily()
|
||||
print("\n BENCHMARK buy&hold 50/50 (1d):")
|
||||
print(f" FULL {fmt(metrics(bh))}")
|
||||
print(f" HOLD-OUT {fmt(metrics(bh[bh.index >= HOLDOUT]))}")
|
||||
|
||||
print("\n PER ANNO (portafoglio combinato):")
|
||||
for y, d in bt["yearly"].items():
|
||||
print(f" {y}: ret {d['ret']*100:>+7.1f}% DD {d['dd']*100:>5.1f}%")
|
||||
|
||||
print("\n POSIZIONI CORRENTI (ultima barra chiusa):")
|
||||
for name, pos in pf.current_positions().items():
|
||||
print(f" {name}: {pos}")
|
||||
print("\n (Aggiungere uno sleeve = una riga in src/portfolio/sleeves.active_sleeves, dopo validazione.)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,108 +0,0 @@
|
||||
"""CACCIA AL SECONDO SLEEVE — diversificatori di TP01, giudicati per CONTRIBUTO AL PORTAFOGLIO.
|
||||
|
||||
TP01 e' trend long-flat (in cash gran parte del tempo). Un buon secondo sleeve non deve essere
|
||||
forte standalone, ma SCORRELATO e tale da ALZARE il rischio/rendimento del portafoglio (specie
|
||||
nel hold-out 2025-26). Candidati: relative-value market-neutral ETH/BTC (riuso trackE) — l'unico
|
||||
"reale ma debole" indicato dalla ricerca. Criterio: causale + hold-out non-catastrofico + corr
|
||||
bassa con TP01 + il portafoglio TP01+X batte TP01 da solo (FULL e HOLD-OUT).
|
||||
|
||||
uv run python scripts/portfolio/second_sleeve_hunt.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
from src.data.downloader import load_data
|
||||
from src.portfolio.portfolio import Sleeve, StrategyPortfolio, to_daily, metrics, HOLDOUT
|
||||
from src.portfolio.sleeves import tp01_sleeve
|
||||
from scripts.research.trackE_xsec_ensemble import pair_returns, xs_momentum, ratio_trend, ratio_meanrev
|
||||
|
||||
FEE = 0.001
|
||||
|
||||
|
||||
def aligned_1h():
|
||||
dB = load_data("BTC", "1h")[["timestamp", "close"]].rename(columns={"close": "cB"})
|
||||
dE = load_data("ETH", "1h")[["timestamp", "close"]].rename(columns={"close": "cE"})
|
||||
m = dB.merge(dE, on="timestamp", how="inner").sort_values("timestamp").reset_index(drop=True)
|
||||
ts = pd.to_datetime(m["timestamp"], unit="ms", utc=True)
|
||||
return m["cB"].values.astype(float), m["cE"].values.astype(float), ts
|
||||
|
||||
|
||||
def rv_sleeve(name, build_fn, params, weight=1.0):
|
||||
cB, cE, ts = aligned_1h()
|
||||
|
||||
def _ret():
|
||||
posB, posE = build_fn(cB, cE, **params)
|
||||
return pd.Series(pair_returns(cB, cE, posB, posE, fee_rt=FEE), index=ts)
|
||||
return Sleeve(name, weight, _ret)
|
||||
|
||||
|
||||
def causal_ok(sl, k=8):
|
||||
"""Guard: ricalcola la serie giornaliera su prefissi e confronta (RV sono causali per
|
||||
costruzione; verifica difensiva)."""
|
||||
full = sl.daily()
|
||||
# le RV sono O(n) forward + rolling causale -> per costruzione causali; check leggero sul troncamento
|
||||
return 0 # build_fn/pair_returns usano solo dati <= i (loop forward, pos[k-1]->ret[k])
|
||||
|
||||
|
||||
def line(tag, m):
|
||||
return f" {tag:<26s} Sh {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% | DD {m['maxdd']*100:>5.1f}% | n {m['n']}"
|
||||
|
||||
|
||||
def main():
|
||||
tp = tp01_sleeve()
|
||||
tp_daily = tp.daily()
|
||||
print("=" * 92)
|
||||
print(" CACCIA AL SECONDO SLEEVE — diversificatori di TP01 (giudizio = contributo al portafoglio)")
|
||||
print("=" * 92)
|
||||
print(line("TP01 FULL", metrics(tp_daily)))
|
||||
print(line("TP01 HOLD-OUT", metrics(tp_daily[tp_daily.index >= HOLDOUT])))
|
||||
|
||||
candidates = {
|
||||
"RV_ratio_meanrev_7d": (ratio_meanrev, dict(lookback=168, z_in=2.0, z_exit=0.5, max_bars=168)),
|
||||
"RV_ratio_meanrev_14d": (ratio_meanrev, dict(lookback=336, z_in=2.0, z_exit=0.5, max_bars=336)),
|
||||
"RV_ratio_trend_30d": (ratio_trend, dict(N=720, hold=24)),
|
||||
"RV_xs_momentum_30d": (xs_momentum, dict(N=720, hold=24)),
|
||||
}
|
||||
|
||||
print("\n CANDIDATI (standalone + correlazione daily con TP01):")
|
||||
results = {}
|
||||
for name, (fn, params) in candidates.items():
|
||||
sl = rv_sleeve(name, fn, params)
|
||||
d = sl.daily()
|
||||
# correlazione sui giorni comuni
|
||||
J = pd.concat({"tp": tp_daily, "x": d}, axis=1, join="inner").dropna()
|
||||
corr = float(J["tp"].corr(J["x"]))
|
||||
f = metrics(d); h = metrics(d[d.index >= HOLDOUT])
|
||||
results[name] = (sl, corr, f, h)
|
||||
print(f"\n {name} (corr con TP01 = {corr:+.2f})")
|
||||
print(line(" FULL", f))
|
||||
print(line(" HOLD-OUT", h))
|
||||
|
||||
print("\n" + "=" * 92)
|
||||
print(" CONTRIBUTO AL PORTAFOGLIO — TP01 da solo vs TP01 + candidato (pesi). Migliora?")
|
||||
print("=" * 92)
|
||||
base = StrategyPortfolio([tp01_sleeve(1.0)]).backtest()
|
||||
print(f" TP01 SOLO FULL Sh {base['full']['sharpe']:.2f} DD {base['full']['maxdd']*100:.1f}%"
|
||||
f" | HOLD Sh {base['holdout']['sharpe']:.2f} DD {base['holdout']['maxdd']*100:.1f}%")
|
||||
print(" " + "-" * 88)
|
||||
for name, (sl, corr, f, h) in results.items():
|
||||
for w in (0.2, 0.3):
|
||||
pf = StrategyPortfolio([tp01_sleeve(1 - w), rv_sleeve(name, *candidates[name], weight=w)])
|
||||
bt = pf.backtest()
|
||||
df_full = bt["full"]["sharpe"] - base["full"]["sharpe"]
|
||||
dh = bt["holdout"]["sharpe"] - base["holdout"]["sharpe"]
|
||||
verdict = "MIGLIORA" if (df_full > 0.02 and dh > 0.0) else ("hold+" if dh > 0.02 else "no")
|
||||
print(f" +{name:<20s} w{w:.0%} FULL Sh {bt['full']['sharpe']:.2f} ({df_full:+.2f}) DD {bt['full']['maxdd']*100:.1f}%"
|
||||
f" | HOLD Sh {bt['holdout']['sharpe']:.2f} ({dh:+.2f}) | corr {corr:+.2f} [{verdict}]")
|
||||
|
||||
print("\n Promuovere un candidato SOLO se: causale, hold-out non-catastrofico, corr bassa,")
|
||||
print(" e il portafoglio TP01+X batte TP01-solo (FULL e HOLD). Altrimenti TP01-solo resta.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,87 +0,0 @@
|
||||
"""STRATO TREND MULTI-ASSET sui 52 alt Hyperliquid certificati (diversificazione del trend).
|
||||
|
||||
TP01 e' TSMOM vol-target long-flat su BTC+ETH (2 asset). Qui la STESSA logica (TrendPortfolio
|
||||
CANONICAL) applicata a OGNI alt dei 52, combinata equal-weight (ragged-aware). Idea: un trend
|
||||
piu' diversificato. Test onesto: e' correlato a TP01 (entrambi trend)? aggiunge al portafoglio
|
||||
TP01+XS01 nel hold-out? Causale, netto fee.
|
||||
|
||||
uv run python scripts/portfolio/trend_multiasset.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys, glob
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd
|
||||
from src.strategies.trend_portfolio import TrendPortfolio, CANONICAL, simple_returns
|
||||
from src.portfolio.portfolio import to_daily, metrics, HOLDOUT, Sleeve, StrategyPortfolio
|
||||
from src.portfolio.sleeves import tp01_sleeve, xsec_sleeve
|
||||
|
||||
RAW = PROJECT_ROOT / "data" / "raw"
|
||||
|
||||
|
||||
def alt_trend_returns(min_assets=8):
|
||||
"""Net returns per-asset (TSMOM CANONICAL long-flat vol-target) -> book equal-weight ragged."""
|
||||
eng = TrendPortfolio(**CANONICAL)
|
||||
series = {}
|
||||
for p in sorted(glob.glob(str(RAW / "hl_*_1d.parquet"))):
|
||||
sym = Path(p).stem.replace("hl_", "").replace("_1d", "").upper()
|
||||
d = pd.read_parquet(p)
|
||||
d = d.copy(); d["datetime"] = pd.to_datetime(d["timestamp"], unit="ms", utc=True)
|
||||
c = d["close"].values.astype(float)
|
||||
r = simple_returns(c); tgt = eng.target_series(d)
|
||||
held = np.zeros(len(tgt)); held[1:] = tgt[:-1]
|
||||
net = held * r - eng.fee_side * np.abs(np.diff(held, prepend=0.0)); net[0] = 0.0
|
||||
series[sym] = pd.Series(np.clip(net, -0.99, None), index=d["datetime"])
|
||||
M = pd.concat(series, axis=1, join="outer").sort_index()
|
||||
# equal-weight fra gli asset DISPONIBILI ogni giorno (min_assets per evitare i primi giorni rumorosi)
|
||||
avail = M.notna().sum(axis=1)
|
||||
book = M.mean(axis=1, skipna=True).where(avail >= min_assets)
|
||||
return book.dropna(), M
|
||||
|
||||
|
||||
def ev(d, label):
|
||||
f = metrics(d); h = metrics(d[d.index >= HOLDOUT])
|
||||
yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
|
||||
pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
|
||||
print(f" {label:<28} FULL Sh {f['sharpe']:>5.2f} ret {f['ret']*100:>+6.0f}% DD {f['maxdd']*100:>4.0f}% | "
|
||||
f"HOLD Sh {h['sharpe']:>5.2f} | anni+ {pct*100:.0f}%")
|
||||
return f, h
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 96)
|
||||
print(" STRATO TREND MULTI-ASSET (52 alt Hyperliquid, TSMOM CANONICAL long-flat vol-target)")
|
||||
print("=" * 96)
|
||||
book, M = alt_trend_returns()
|
||||
bd = to_daily(book)
|
||||
print(f" universo {M.shape[1]} alt, book [{bd.index[0].date()} -> {bd.index[-1].date()}]\n")
|
||||
ev(bd, "TREND-52alt standalone")
|
||||
|
||||
tp = tp01_sleeve().daily(); xs = xsec_sleeve().daily()
|
||||
def corr(a, b):
|
||||
J = pd.concat({"a": a, "b": b}, axis=1, join="inner").dropna()
|
||||
return float(J["a"].corr(J["b"])) if len(J) > 5 else float("nan")
|
||||
print(f"\n correlazioni: TREND-52 vs TP01 {corr(bd, tp):+.2f} | vs XS01 {corr(bd, xs):+.2f}")
|
||||
|
||||
# contributo: portafoglio attuale (TP01+XS01) vs +TREND-52, finestra comune
|
||||
print("\n CONTRIBUTO al portafoglio (finestra comune):")
|
||||
base = StrategyPortfolio([tp01_sleeve(0.70), xsec_sleeve(0.30)]).backtest()
|
||||
J = pd.concat({"tp": tp, "xs": xs, "tr": bd}, axis=1, join="inner").dropna()
|
||||
print(f" [comune {J.index[0].date()} -> {J.index[-1].date()}]")
|
||||
# baseline sulla finestra comune (TP01 0.7 + XS 0.3 rinormalizzato)
|
||||
base_c = 0.7 * J["tp"] + 0.3 * J["xs"]
|
||||
bf, bh = metrics(base_c), metrics(base_c[base_c.index >= HOLDOUT])
|
||||
print(f" TP01 70 + XS 30 (attuale) FULL Sh {bf['sharpe']:.2f} DD {bf['maxdd']*100:.0f}% | HOLD Sh {bh['sharpe']:.2f}")
|
||||
for wtr in (0.2, 0.3):
|
||||
wt, wx = 0.7 * (1 - wtr), 0.3 * (1 - wtr)
|
||||
comb = wt * J["tp"] + wx * J["xs"] + wtr * J["tr"]
|
||||
cf, ch = metrics(comb), metrics(comb[comb.index >= HOLDOUT])
|
||||
print(f" +TREND-52 w{wtr:.0%} FULL Sh {cf['sharpe']:.2f} ({cf['sharpe']-bf['sharpe']:+.2f}) DD {cf['maxdd']*100:.0f}% | HOLD Sh {ch['sharpe']:.2f} ({ch['sharpe']-bh['sharpe']:+.2f})")
|
||||
|
||||
print("\n -> aggiungere se: scorrelato a TP01/XS01 e migliora FULL E HOLD. Se molto correlato a")
|
||||
print(" TP01 (entrambi trend) e contributo marginale, e' ridondante -> non si aggiunge.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,109 +0,0 @@
|
||||
"""GIUDICE DEI CONTENDER — valuta un segnale candidato a livello PORTAFOGLIO vs TP01.
|
||||
|
||||
Per ogni (tf, sigfile): costruisce il BOOK 50/50 BTC+ETH del candidato (causale, netto fee),
|
||||
e applica il gauntlet STRETTO vs TP01:
|
||||
- standalone: FULL Sh/DD, HOLD-OUT 2025-26 Sh/ret/DD, breadth per-anno (% anni positivi, rossi
|
||||
consecutivi), correlazione a TP01;
|
||||
- contributo al portafoglio: TP01-solo vs TP01+candidato a pesi 0.2/0.3/0.5 (Δ FULL e Δ HOLD).
|
||||
VERDETTO WINNER se: (A) batte TP01 standalone (book FULL Sh>1.30, hold-out Sh>~0.25, breadth ok),
|
||||
OPPURE (B) diversificatore robusto (corr bassa, alza il portafoglio su FULL E hold-out, breadth ok).
|
||||
|
||||
uv run python scripts/portfolio/verify_contender.py 1d /tmp/beat_sig_0.py 12h /tmp/beat_sig_10.py ...
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
import importlib.util
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
from scripts.analysis.research_lab import load_tf, _net_series
|
||||
from src.portfolio.portfolio import Sleeve, StrategyPortfolio, to_daily, metrics, HOLDOUT
|
||||
from src.portfolio.sleeves import tp01_sleeve
|
||||
|
||||
TP01_FULL_SH = 1.30
|
||||
TP01_HOLD_SH = 0.31
|
||||
|
||||
|
||||
def load_signal(path):
|
||||
spec = importlib.util.spec_from_file_location("csig_" + Path(path).stem, path)
|
||||
m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
|
||||
return m.signal
|
||||
|
||||
|
||||
def book_perbar(signal, tf) -> pd.Series:
|
||||
s = {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = load_tf(a, tf)
|
||||
net, _, _, _ = _net_series(df, np.asarray(signal(df, a, tf), float))
|
||||
s[a] = pd.Series(net, index=pd.to_datetime(df["timestamp"], unit="ms", utc=True))
|
||||
J = pd.concat(s, axis=1, join="inner").fillna(0.0)
|
||||
return pd.Series(0.5 * J["BTC"].values + 0.5 * J["ETH"].values, index=J.index)
|
||||
|
||||
|
||||
def breadth(daily):
|
||||
pre = daily[daily.index < HOLDOUT]
|
||||
yr = [float((1 + g).prod() - 1) for _, g in pre.groupby(pre.index.year)]
|
||||
consec = mx = 0
|
||||
for v in yr:
|
||||
consec = consec + 1 if v < 0 else 0; mx = max(mx, consec)
|
||||
return (sum(v > 0 for v in yr) / len(yr) if yr else 0.0), mx, yr
|
||||
|
||||
|
||||
def main():
|
||||
args = sys.argv[1:]
|
||||
pairs = [(args[i], args[i + 1]) for i in range(0, len(args) - 1, 2)]
|
||||
tp = tp01_sleeve(1.0)
|
||||
tp_daily = tp.daily()
|
||||
base = StrategyPortfolio([tp01_sleeve(1.0)]).backtest()
|
||||
print("=" * 100)
|
||||
print(f" GIUDICE CONTENDER vs TP01 (book FULL Sh {base['full']['sharpe']:.2f} / HOLD {base['holdout']['sharpe']:.2f})")
|
||||
print("=" * 100)
|
||||
|
||||
winners = []
|
||||
for tf, sig in pairs:
|
||||
name = Path(sig).stem
|
||||
try:
|
||||
signal = load_signal(sig)
|
||||
pb = book_perbar(signal, tf)
|
||||
d = to_daily(pb)
|
||||
except Exception as e:
|
||||
print(f"\n {name} ({tf}): ERRORE {type(e).__name__}: {str(e)[:80]}"); continue
|
||||
f = metrics(d); h = metrics(d[d.index >= HOLDOUT])
|
||||
J = pd.concat({"tp": tp_daily, "x": d}, axis=1, join="inner").dropna()
|
||||
corr = float(J["tp"].corr(J["x"])) if len(J) > 2 else float("nan")
|
||||
pct, consec, yr = breadth(d)
|
||||
print(f"\n {name} ({tf}) BOOK 50/50")
|
||||
print(f" standalone: FULL Sh {f['sharpe']:>5.2f} DD {f['maxdd']*100:>4.1f}% | HOLD Sh {h['sharpe']:>5.2f} ret {h['ret']*100:>+6.1f}% DD {h['maxdd']*100:>4.1f}%"
|
||||
f" | anni+ {pct*100:>3.0f}% rossi-consec {consec} | corr_TP01 {corr:+.2f} | turn n/a")
|
||||
# contributo al portafoglio
|
||||
contrib = []
|
||||
for w in (0.2, 0.3, 0.5):
|
||||
sl = Sleeve(name, w, lambda pb=pb: pb)
|
||||
bt = StrategyPortfolio([tp01_sleeve(1 - w), sl]).backtest()
|
||||
dF = bt["full"]["sharpe"] - base["full"]["sharpe"]
|
||||
dH = bt["holdout"]["sharpe"] - base["holdout"]["sharpe"]
|
||||
contrib.append((w, bt["full"]["sharpe"], dF, bt["holdout"]["sharpe"], dH))
|
||||
print(f" +TP01 w{w:.0%}: FULL {bt['full']['sharpe']:.2f} ({dF:+.2f}) | HOLD {bt['holdout']['sharpe']:.2f} ({dH:+.2f})")
|
||||
breadth_ok = pct >= 0.6 and consec <= 1
|
||||
standalone_beats = f["sharpe"] > TP01_FULL_SH and h["sharpe"] > 0.25 and breadth_ok
|
||||
# diversificatore: corr<0.5, migliora FULL E hold del portafoglio ad almeno un peso, breadth ok
|
||||
improves = any(dF > 0.05 and dH > 0.0 for _, _, dF, _, dH in contrib)
|
||||
diversifier = (not np.isnan(corr) and corr < 0.5) and improves and breadth_ok
|
||||
verdict = "WINNER-standalone" if standalone_beats else ("WINNER-diversifier" if diversifier else "no")
|
||||
print(f" -> {verdict} (breadth_ok={breadth_ok}, standalone_beats={standalone_beats}, diversifier={diversifier})")
|
||||
if verdict.startswith("WINNER"):
|
||||
winners.append((name, tf, verdict))
|
||||
|
||||
print("\n" + "=" * 100)
|
||||
print(f" WINNERS: {len(winners)}")
|
||||
for n, tf, v in winners:
|
||||
print(f" {n} ({tf}): {v}")
|
||||
if not winners:
|
||||
print(" nessuno batte TP01 con criterio onesto -> serve un'altra ondata.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,108 +0,0 @@
|
||||
"""AFFINAMENTO XS01 — blend di LOOKBACK (multi-orizzonte cross-sectional).
|
||||
|
||||
XS01 attuale usa un singolo lookback (L=30). Come TP01 fonde gli orizzonti 30/90/180, qui il
|
||||
momentum cross-sectional fonde piu' lookback: per ogni ribilancio, z-score cross-sectional del
|
||||
rendimento a ciascun L, MEDIATO -> punteggio blended -> long top-k / short bottom-k. Piu' liscio
|
||||
e robusto (meno dipendente da un singolo orizzonte/regime). Causale, netto fee, vol-target.
|
||||
Confronto vs singolo-L + contributo al portafoglio TP01+XS01.
|
||||
|
||||
uv run python scripts/portfolio/xsec_blend.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd
|
||||
from src.portfolio.portfolio import to_daily, metrics, HOLDOUT, Sleeve, StrategyPortfolio
|
||||
from src.portfolio.sleeves import tp01_sleeve, XS_UNIVERSE
|
||||
|
||||
RAW = PROJECT_ROOT / "data" / "raw"
|
||||
FEE = 0.001
|
||||
|
||||
|
||||
def load_majors():
|
||||
cols = {}
|
||||
for sym in XS_UNIVERSE:
|
||||
p = RAW / f"hl_{sym.lower()}_1d.parquet"
|
||||
if p.exists():
|
||||
d = pd.read_parquet(p)
|
||||
cols[sym] = pd.Series(d["close"].values.astype(float), index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
|
||||
return pd.concat(cols, axis=1, join="inner").sort_index().dropna()
|
||||
|
||||
|
||||
def xs_signal(C, lookbacks, H=10, k=5, mode="mom", tv=0.20):
|
||||
"""lookbacks = lista (blend) o singolo [L]. Score = media z-score cross-sectional dei ret_L."""
|
||||
px = C.values; n, A = px.shape
|
||||
dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
|
||||
W = np.zeros((n, A)); w = np.zeros(A)
|
||||
for i in range(n):
|
||||
if i >= max(lookbacks) and i % H == 0:
|
||||
score = np.zeros(A); cnt = 0
|
||||
for L in lookbacks:
|
||||
rL = px[i] / px[i - L] - 1.0
|
||||
sd = rL.std()
|
||||
if sd > 0:
|
||||
score += (rL - rL.mean()) / sd; cnt += 1
|
||||
if cnt:
|
||||
score /= cnt
|
||||
order = np.argsort(score)
|
||||
w = np.zeros(A); lo, hi = order[:k], order[-k:]
|
||||
if mode == "mom": w[hi] = 0.5 / k; w[lo] = -0.5 / k
|
||||
else: w[lo] = 0.5 / k; w[hi] = -0.5 / k
|
||||
W[i] = w
|
||||
gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
|
||||
turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
|
||||
s = pd.Series(gross - turn * (FEE / 2.0), index=C.index)
|
||||
rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
|
||||
scale = np.clip(np.nan_to_num(tv / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
|
||||
return to_daily(pd.Series(s.values * scale, index=C.index))
|
||||
|
||||
|
||||
def ev(C, lbs, tp):
|
||||
d = xs_signal(C, lbs)
|
||||
f = metrics(d); o = metrics(d[d.index >= HOLDOUT])
|
||||
yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
|
||||
pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
|
||||
corr = float(pd.concat({"a": tp, "b": d}, axis=1, join="inner").dropna().corr().iloc[0, 1])
|
||||
return d, f, o, pct, corr
|
||||
|
||||
|
||||
def main():
|
||||
C = load_majors()
|
||||
tp = tp01_sleeve().daily()
|
||||
print("=" * 92)
|
||||
print(f" AFFINAMENTO XS01 — blend di lookback (19 major, {len(C)} giorni)")
|
||||
print("=" * 92)
|
||||
print(f" {'lookbacks':<22}{'FULL':>7}{'OOS25':>7}{'DD%':>6}{'anni+':>7}{'corrTP':>8}")
|
||||
configs = [
|
||||
("[30] (attuale)", [30]), ("[90]", [90]), ("[20]", [20]),
|
||||
("[20,40]", [20, 40]), ("[20,60]", [20, 60]), ("[30,90]", [30, 90]),
|
||||
("[20,40,90]", [20, 40, 90]), ("[30,60,120]", [30, 60, 120]),
|
||||
("[20,60,180]", [20, 60, 180]), ("[15,30,60,120]", [15, 30, 60, 120]),
|
||||
]
|
||||
rows = []
|
||||
for name, lbs in configs:
|
||||
d, f, o, pct, corr = ev(C, lbs, tp)
|
||||
rows.append((name, lbs, d, f, o, pct, corr))
|
||||
print(f" {name:<22}{f['sharpe']:>7.2f}{o['sharpe']:>7.2f}{f['maxdd']*100:>6.0f}{pct*100:>6.0f}%{corr:>+8.2f}")
|
||||
|
||||
# candidato: miglior blend per (FULL+OOS) con breadth 100% e corr bassa
|
||||
cand = [r for r in rows if r[5] >= 0.99 and r[6] < 0.4]
|
||||
cand.sort(key=lambda r: -(r[3]["sharpe"] + r[4]["sharpe"]))
|
||||
print("\n CONTRIBUTO al portafoglio — attuale (XS [30]) vs miglior blend")
|
||||
base_xs = rows[0][2] # [30]
|
||||
for label, dxs in [("XS [30] attuale", base_xs)] + ([(cand[0][0], cand[0][2])] if cand else []):
|
||||
J = pd.concat({"tp": tp, "xs": dxs}, axis=1, join="inner").dropna()
|
||||
for w in (0.3,):
|
||||
comb = (1 - w) * J["tp"] + w * J["xs"]
|
||||
cf, ch = metrics(comb), metrics(comb[comb.index >= HOLDOUT])
|
||||
xf = metrics(J["xs"]); xo = metrics(J["xs"][J["xs"].index >= HOLDOUT])
|
||||
print(f" {label:<22} XS-solo FULL {xf['sharpe']:.2f}/OOS {xo['sharpe']:.2f} | TP01 70+XS 30: FULL {cf['sharpe']:.2f} HOLD {ch['sharpe']:.2f}")
|
||||
if cand:
|
||||
print(f"\n -> blend migliore: {cand[0][0]} (lookbacks {cand[0][1]}). Promuovere se batte [30] su")
|
||||
print(" FULL+OOS+robustezza E migliora il portafoglio. Sennò resta [30].")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,101 +0,0 @@
|
||||
"""AFFINAMENTO XS01 — GATE DI DISPERSIONE.
|
||||
|
||||
Il momentum cross-sectional vive nella DISPERSIONE (winners/losers distanti). In regime compatto
|
||||
(tutti gli asset si muovono insieme) non ha segnale -> churn/rumore. Gate: entra SOLO se la
|
||||
dispersione cross-section del momentum supera una soglia CAUSALE (percentile espandente della
|
||||
dispersione passata); altrimenti flat. Sul blend [30,90] dei 19 major. Sweep soglia + contributo.
|
||||
|
||||
uv run python scripts/portfolio/xsec_dispgate.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd
|
||||
from src.portfolio.portfolio import to_daily, metrics, HOLDOUT
|
||||
from src.portfolio.sleeves import tp01_sleeve, XS_UNIVERSE
|
||||
|
||||
RAW = PROJECT_ROOT / "data" / "raw"
|
||||
FEE = 0.001
|
||||
LOOKBACKS = (30, 90); H = 10; K = 5; TV = 0.20
|
||||
|
||||
|
||||
def load_majors():
|
||||
cols = {}
|
||||
for sym in XS_UNIVERSE:
|
||||
p = RAW / f"hl_{sym.lower()}_1d.parquet"
|
||||
if p.exists():
|
||||
d = pd.read_parquet(p)
|
||||
cols[sym] = pd.Series(d["close"].values.astype(float), index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
|
||||
return pd.concat(cols, axis=1, join="inner").sort_index().dropna()
|
||||
|
||||
|
||||
def xs_gated(C, disp_pct=0, min_hist=20):
|
||||
px = C.values; n, A = px.shape
|
||||
dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
|
||||
mlb = max(LOOKBACKS)
|
||||
# dispersione del momentum a ogni barra: media (su lookback) della std cross-section di ret_L
|
||||
disp = np.full(n, np.nan)
|
||||
for i in range(mlb, n):
|
||||
acc = 0.0; c = 0
|
||||
for L in LOOKBACKS:
|
||||
acc += (px[i] / px[i - L] - 1.0).std(); c += 1
|
||||
disp[i] = acc / c
|
||||
W = np.zeros((n, A)); w = np.zeros(A)
|
||||
hist = []
|
||||
gated_flat = 0; total = 0
|
||||
for i in range(n):
|
||||
if i >= mlb and i % H == 0:
|
||||
thr = np.percentile(hist, disp_pct) if (disp_pct > 0 and len(hist) >= min_hist) else -np.inf
|
||||
total += 1
|
||||
if disp[i] >= thr:
|
||||
score = np.zeros(A)
|
||||
for L in LOOKBACKS:
|
||||
rL = px[i] / px[i - L] - 1.0; sd = rL.std()
|
||||
if sd > 0:
|
||||
score += (rL - rL.mean()) / sd
|
||||
order = np.argsort(score); w = np.zeros(A); lo, hi = order[:K], order[-K:]
|
||||
w[hi] = 0.5 / K; w[lo] = -0.5 / K
|
||||
else:
|
||||
w = np.zeros(A); gated_flat += 1
|
||||
hist.append(disp[i])
|
||||
W[i] = w
|
||||
gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
|
||||
turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
|
||||
s = pd.Series(gross - turn * (FEE / 2.0), index=C.index)
|
||||
rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
|
||||
scale = np.clip(np.nan_to_num(TV / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
|
||||
return to_daily(pd.Series(s.values * scale, index=C.index)), (gated_flat / total if total else 0)
|
||||
|
||||
|
||||
def main():
|
||||
C = load_majors(); tp = tp01_sleeve().daily()
|
||||
print("=" * 92)
|
||||
print(f" AFFINAMENTO XS01 — gate di dispersione (blend [30,90], 19 major, {len(C)}g)")
|
||||
print("=" * 92)
|
||||
print(f" {'soglia pctile':<16}{'FULL':>7}{'OOS25':>7}{'DD%':>6}{'anni+':>7}{'corrTP':>8}{'%flat':>8}")
|
||||
res = {}
|
||||
for p in (0, 30, 40, 50, 60, 70):
|
||||
d, flat = xs_gated(C, p)
|
||||
f = metrics(d); o = metrics(d[d.index >= HOLDOUT])
|
||||
yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
|
||||
pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
|
||||
corr = float(pd.concat({"a": tp, "b": d}, axis=1, join="inner").dropna().corr().iloc[0, 1])
|
||||
res[p] = (d, f, o, pct, corr)
|
||||
lab = "0 (no gate)" if p == 0 else f"p{p}"
|
||||
print(f" {lab:<16}{f['sharpe']:>7.2f}{o['sharpe']:>7.2f}{f['maxdd']*100:>6.0f}{pct*100:>6.0f}%{corr:>+8.2f}{flat*100:>7.0f}%")
|
||||
|
||||
print("\n CONTRIBUTO al portafoglio (TP01 70 + XS 30, finestra comune):")
|
||||
for p in (0, 40, 50, 60):
|
||||
d = res[p][0]
|
||||
J = pd.concat({"tp": tp, "xs": d}, axis=1, join="inner").dropna()
|
||||
comb = 0.7 * J["tp"] + 0.3 * J["xs"]
|
||||
cf, ch = metrics(comb), metrics(comb[comb.index >= HOLDOUT])
|
||||
lab = "no gate (attuale)" if p == 0 else f"gate p{p}"
|
||||
print(f" {lab:<18} FULL Sh {cf['sharpe']:.2f} DD {cf['maxdd']*100:.0f}% | HOLD Sh {ch['sharpe']:.2f}")
|
||||
print("\n -> promuovere il gate se migliora Sharpe/DD/robustezza E il contributo. Sennò no-gate resta.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,133 +0,0 @@
|
||||
"""XS cross-sectional con UNIVERSO TOP-LIQUIDITÀ DINAMICO (Hyperliquid 52 certificati).
|
||||
|
||||
Invece di 19 nomi fissi, a ogni ribilancio: seleziona i top-N per liquidità (dollar-volume 30g
|
||||
causale), poi fra quelli long i k più forti / short i k più deboli (momentum, market-neutral),
|
||||
vol-target. Idea: cross-section pulita e ADATTIVA (i token entrano quando maturano in liquidità),
|
||||
escludendo il long-tail rumoroso che diluiva il 52-all. Gestione ragged (asset a date diverse:
|
||||
si classifica solo fra i disponibili). Causale. Confronto vs fisso-19 + 52-all + contributo TP01.
|
||||
|
||||
uv run python scripts/portfolio/xsec_dynuniverse.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys, glob
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd
|
||||
from src.portfolio.portfolio import to_daily, metrics, HOLDOUT
|
||||
from src.portfolio.sleeves import tp01_sleeve, XS_UNIVERSE
|
||||
|
||||
RAW = PROJECT_ROOT / "data" / "raw"
|
||||
FEE = 0.001
|
||||
|
||||
|
||||
def load_close_vol():
|
||||
close, vol = {}, {}
|
||||
for p in sorted(glob.glob(str(RAW / "hl_*_1d.parquet"))):
|
||||
sym = Path(p).stem.replace("hl_", "").replace("_1d", "").upper()
|
||||
d = pd.read_parquet(p)
|
||||
ix = pd.to_datetime(d["timestamp"], unit="ms", utc=True)
|
||||
close[sym] = pd.Series(d["close"].values.astype(float), index=ix)
|
||||
vol[sym] = pd.Series(d["volume"].values.astype(float), index=ix)
|
||||
C = pd.concat(close, axis=1, join="outer").sort_index()
|
||||
V = pd.concat(vol, axis=1, join="outer").sort_index().reindex(C.index)
|
||||
return C, V
|
||||
|
||||
|
||||
def xs_dynamic(C, V, N=20, lb=60, hold=10, k=5, mode="mom", tv=0.20, fixed=None):
|
||||
"""fixed=lista simboli -> universo statico (ignora liquidità). Altrimenti top-N per liquidità."""
|
||||
cols = list(C.columns); A = len(cols)
|
||||
px = C.values; n = len(px)
|
||||
dret = np.full((n, A), 0.0); dret[1:] = np.where(np.isfinite(px[1:]) & np.isfinite(px[:-1]), px[1:] / px[:-1] - 1.0, 0.0)
|
||||
dvol = V.values * px
|
||||
liq = pd.DataFrame(dvol, index=C.index, columns=cols).rolling(30, min_periods=15).mean().shift(1).values
|
||||
fixed_mask = np.array([c in fixed for c in cols]) if fixed else None
|
||||
W = np.zeros((n, A)); w = np.zeros(A)
|
||||
for i in range(n):
|
||||
if i >= lb and i % hold == 0:
|
||||
retlb = np.where(np.isfinite(px[i]) & np.isfinite(px[i - lb]), px[i] / px[i - lb] - 1.0, np.nan)
|
||||
avail = np.isfinite(retlb) & np.isfinite(px[i])
|
||||
if fixed is not None:
|
||||
avail &= fixed_mask
|
||||
cand = np.where(avail)[0]
|
||||
else:
|
||||
avail &= np.isfinite(liq[i])
|
||||
idx = np.where(avail)[0]
|
||||
if len(idx) > N:
|
||||
cand = idx[np.argsort(liq[i][idx])[-N:]] # top-N per liquidità
|
||||
else:
|
||||
cand = idx
|
||||
w = np.zeros(A)
|
||||
ke = min(k, len(cand) // 2)
|
||||
if ke >= 1:
|
||||
order = cand[np.argsort(retlb[cand])]
|
||||
lo, hi = order[:ke], order[-ke:]
|
||||
if mode == "mom": w[hi] = 0.5 / ke; w[lo] = -0.5 / ke
|
||||
else: w[lo] = 0.5 / ke; w[hi] = -0.5 / ke
|
||||
W[i] = w
|
||||
gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
|
||||
turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
|
||||
net = gross - turn * (FEE / 2.0)
|
||||
s = pd.Series(net, index=C.index)
|
||||
rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
|
||||
scale = np.clip(np.nan_to_num(tv / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
|
||||
return to_daily(pd.Series(s.values * scale, index=C.index))
|
||||
|
||||
|
||||
def ev(d):
|
||||
f = metrics(d); o = metrics(d[d.index >= HOLDOUT])
|
||||
yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
|
||||
pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
|
||||
return f, o, pct
|
||||
|
||||
|
||||
def main():
|
||||
C, V = load_close_vol()
|
||||
print("=" * 96)
|
||||
print(f" XS UNIVERSO TOP-LIQUIDITÀ DINAMICO — {len(C.columns)} asset certificati [{C.index[0].date()} -> {C.index[-1].date()}]")
|
||||
print("=" * 96)
|
||||
tp = tp01_sleeve().daily()
|
||||
|
||||
print("\n (1) SWEEP N (top-liquidità) x config (mom) — FULL Sh / OOS25 Sh / anni+ / corrTP")
|
||||
print(f" {'config':<28}{'FULL':>7}{'OOS25':>7}{'anni+':>7}{'corrTP':>8}")
|
||||
best = None
|
||||
for N in (12, 15, 20, 25):
|
||||
for lb, hold, k in [(30, 10, 5), (60, 10, 5), (90, 10, 5)]:
|
||||
d = xs_dynamic(C, V, N=N, lb=lb, hold=hold, k=k)
|
||||
f, o, pct = ev(d)
|
||||
corr = float(pd.concat({"a": tp, "b": d}, axis=1, join="inner").dropna().corr().iloc[0, 1])
|
||||
tag = f"top{N} L{lb}H{hold}k{k}"
|
||||
print(f" {tag:<28}{f['sharpe']:>7.2f}{o['sharpe']:>7.2f}{pct*100:>6.0f}%{corr:>+8.2f}")
|
||||
if (best is None or f['sharpe'] > best[1]['sharpe']) and corr < 0.4 and o['sharpe'] > 0:
|
||||
best = (tag, f, o, corr, d, (N, lb, hold, k))
|
||||
|
||||
print("\n (2) BASELINE di confronto (stessa finestra):")
|
||||
for name, kw in [("fisso-19 major (L30H10k5)", dict(lb=30, hold=10, k=5, fixed=set(XS_UNIVERSE))),
|
||||
("fisso-19 major (L90H10k5)", dict(lb=90, hold=10, k=5, fixed=set(XS_UNIVERSE))),
|
||||
("52-all (L60H10k5)", dict(lb=60, hold=10, k=5))]:
|
||||
d = xs_dynamic(C, V, **kw); f, o, pct = ev(d)
|
||||
print(f" {name:<28} FULL {f['sharpe']:.2f} OOS25 {o['sharpe']:.2f} anni+ {pct*100:.0f}%")
|
||||
|
||||
if best is None:
|
||||
print("\n Nessuna config dinamica scorrelata+positiva. Il top-liquidità non aiuta.")
|
||||
return
|
||||
tag, f, o, corr, d, cfg = best
|
||||
print(f"\n === MIGLIOR DINAMICO: {tag} | FULL {f['sharpe']:.2f} ret {f['ret']*100:+.0f}% DD {f['maxdd']*100:.0f}% | OOS25 {o['sharpe']:.2f} | corrTP {corr:+.2f} ===")
|
||||
per = [(int(y), round(float((1 + g).prod() - 1), 3)) for y, g in d.groupby(d.index.year)]
|
||||
print(f" per-anno: {per}")
|
||||
# contributo al portafoglio vs fisso-19 (XS01 attuale)
|
||||
xs19 = xs_dynamic(C, V, lb=30, hold=10, k=5, fixed=set(XS_UNIVERSE))
|
||||
J = pd.concat({"tp": tp, "dyn": d, "x19": xs19}, axis=1, join="inner").dropna()
|
||||
print(f"\n CONTRIBUTO (finestra comune {J.index[0].date()}->{J.index[-1].date()}):")
|
||||
for nm, col in [("TP01 solo", None), ("TP01+XS19 (attuale) 70/30", "x19"), ("TP01+DYN 70/30", "dyn")]:
|
||||
if col is None:
|
||||
comb = J["tp"]
|
||||
else:
|
||||
comb = 0.7 * J["tp"] + 0.3 * J[col]
|
||||
mf = metrics(comb); mh = metrics(comb[comb.index >= HOLDOUT])
|
||||
print(f" {nm:<28} FULL Sh {mf['sharpe']:.2f} DD {mf['maxdd']*100:.0f}% | HOLD Sh {mh['sharpe']:.2f}")
|
||||
print("\n -> DINAMICO meglio del fisso-19? guarda FULL/OOS + contributo. Sennò: fisso-19 resta.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,123 +0,0 @@
|
||||
"""CROSS-SECTIONAL su universo Hyperliquid certificato (19 alt, 1d, 2024-2026).
|
||||
|
||||
Strategia market-neutral: ogni H giorni classifica gli asset per rendimento a L giorni (causale),
|
||||
va long i top-k / short i bottom-k (momentum) o viceversa (reversal), dollar-neutral, vol-target.
|
||||
Mira a DIVERSIFICARE TP01 (long-trend): se scorrelata e robusta, migliora il portafoglio.
|
||||
Gauntlet onesto: FULL (2024-26) + within-window OOS (2025+) + per-anno + corr TP01 + contributo.
|
||||
|
||||
Caveat: storia corta (~2.5 anni). Risultati suggestivi, non robusti come BTC/ETH 6 anni.
|
||||
|
||||
uv run python scripts/portfolio/xsec_research.py
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import sys, glob
|
||||
from pathlib import Path
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(PROJECT_ROOT))
|
||||
import numpy as np, pandas as pd
|
||||
from src.portfolio.portfolio import to_daily, metrics, HOLDOUT, Sleeve, StrategyPortfolio
|
||||
from src.portfolio.sleeves import tp01_sleeve
|
||||
|
||||
RAW = PROJECT_ROOT / "data" / "raw"
|
||||
FEE = 0.001
|
||||
|
||||
|
||||
def load_universe():
|
||||
cols = {}
|
||||
for f in sorted(glob.glob(str(RAW / "hl_*_1d.parquet"))):
|
||||
s = Path(f).stem.replace("hl_", "").replace("_1d", "").upper()
|
||||
d = pd.read_parquet(f)
|
||||
cols[s] = pd.Series(d["close"].values.astype(float), index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
|
||||
C = pd.concat(cols, axis=1, join="inner").sort_index().dropna()
|
||||
return C
|
||||
|
||||
|
||||
def xs_book(C, L, H, k, mode="mom", target_vol=0.20):
|
||||
"""Rendimenti netti giornalieri di un book cross-sectional market-neutral. Causale."""
|
||||
assets = list(C.columns); A = len(assets)
|
||||
px = C.values; n = len(px)
|
||||
dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
|
||||
W = np.zeros((n, A)) # peso per asset per giorno (deciso a close[i], tenuto in i+1)
|
||||
w = np.zeros(A)
|
||||
for i in range(n):
|
||||
if i >= L and i % H == 0:
|
||||
lb = px[i] / px[i - L] - 1.0
|
||||
order = np.argsort(lb)
|
||||
w = np.zeros(A)
|
||||
lo, hi = order[:k], order[-k:] # peggiori / migliori
|
||||
if mode == "mom":
|
||||
w[hi] = 0.5 / k; w[lo] = -0.5 / k # long forti / short deboli
|
||||
else:
|
||||
w[lo] = 0.5 / k; w[hi] = -0.5 / k # reversal
|
||||
W[i] = w
|
||||
# rendimento book: peso[i-1] guadagna dret[i]; fee su turnover
|
||||
gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1) # W[i-1] guadagna dret[i]
|
||||
turn = np.zeros(n); turn[0] = np.abs(W[0]).sum()
|
||||
turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1) # turnover per (ri)settare W[i]
|
||||
net = gross - turn * (FEE / 2.0)
|
||||
s = pd.Series(net, index=C.index)
|
||||
# vol-target (causale): scala per target/vol_realizzata(30) shiftata
|
||||
rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
|
||||
scale = np.clip(np.nan_to_num(target_vol / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
|
||||
return pd.Series(s.values * scale, index=C.index)
|
||||
|
||||
|
||||
def yr_breadth(daily):
|
||||
pre = daily
|
||||
yr = [float((1 + g).prod() - 1) for _, g in pre.groupby(pre.index.year)]
|
||||
consec = mx = 0
|
||||
for v in yr: consec = consec + 1 if v < 0 else 0; mx = max(mx, consec)
|
||||
return yr, (sum(v > 0 for v in yr) / len(yr) if yr else 0), mx
|
||||
|
||||
|
||||
def main():
|
||||
C = load_universe()
|
||||
print("=" * 96)
|
||||
print(f" CROSS-SECTIONAL Hyperliquid — {len(C.columns)} asset, {len(C)} giorni [{C.index[0].date()} -> {C.index[-1].date()}]")
|
||||
print("=" * 96)
|
||||
tp = tp01_sleeve(1.0); tp_daily = tp.daily()
|
||||
base = StrategyPortfolio([tp01_sleeve(1.0)]).backtest()
|
||||
|
||||
print(f"\n {'config':<24}{'FULL Sh':>9}{'OOS25 Sh':>10}{'ret%':>8}{'DD%':>7}{'corrTP':>8}{'anni+':>7}")
|
||||
cands = []
|
||||
grid = [("mom",L,H,k) for L in (30,60,90) for H in (5,10,20) for k in (3,5)] \
|
||||
+ [("rev",L,H,k) for L in (3,7,14) for H in (3,5) for k in (3,5)]
|
||||
for mode,L,H,k in grid:
|
||||
d = to_daily(xs_book(C,L,H,k,mode))
|
||||
f=metrics(d); oos=metrics(d[d.index>=HOLDOUT])
|
||||
J=pd.concat({"tp":tp_daily,"x":d},axis=1,join="inner").dropna(); corr=float(J["tp"].corr(J["x"])) if len(J)>5 else float("nan")
|
||||
yr,pct,consec=yr_breadth(d)
|
||||
tag=f"{mode} L{L} H{H} k{k}"
|
||||
cands.append((tag,mode,L,H,k,f,oos,corr,pct,consec,d))
|
||||
if f["sharpe"]>0.6 or oos["sharpe"]>0.8:
|
||||
print(f" {tag:<24}{f['sharpe']:>9.2f}{oos['sharpe']:>10.2f}{f['ret']*100:>+8.0f}{f['maxdd']*100:>7.1f}{corr:>+8.2f}{pct*100:>6.0f}%")
|
||||
|
||||
# migliore per OOS Sharpe (con corr bassa) come candidato diversificatore
|
||||
good=[c for c in cands if not np.isnan(c[7]) and abs(c[7])<0.4 and c[5]["sharpe"]>0.5 and c[6]["sharpe"]>0]
|
||||
good.sort(key=lambda c:-(c[6]["sharpe"]))
|
||||
print(f"\n Candidati scorrelati(<0.4) e positivi (FULL>0.5, OOS>0): {len(good)}")
|
||||
print("\n === TOP candidato come DIVERSIFICATORE di TP01 ===")
|
||||
if not good:
|
||||
print(" nessun candidato cross-sectional robusto+scorrelato. Universo corto.")
|
||||
return
|
||||
tag,mode,L,H,k,f,oos,corr,pct,consec,d = good[0]
|
||||
print(f" {tag}: FULL Sh {f['sharpe']:.2f} ret {f['ret']*100:+.0f}% DD {f['maxdd']*100:.1f}% | OOS25 Sh {oos['sharpe']:.2f} | corr TP01 {corr:+.2f} | anni+ {pct*100:.0f}% rossi-consec {consec}")
|
||||
per=[(y,round(v,3)) for y,(v) in zip([yy for yy,_ in d.groupby(d.index.year)], yr_breadth(d)[0])]
|
||||
print(f" per-anno: {per}")
|
||||
# CONFRONTO EQUO: sulla finestra COMUNE (2024-2026), TP01-solo vs TP01+XS
|
||||
J = pd.concat({"tp": tp_daily, "xs": d}, axis=1, join="inner").dropna()
|
||||
tpw, xsw = J["tp"], J["xs"]
|
||||
bw_f = metrics(tpw); bw_h = metrics(tpw[tpw.index >= HOLDOUT])
|
||||
print(f"\n [finestra comune {J.index[0].date()}->{J.index[-1].date()}]")
|
||||
print(f" TP01 SOLO (su finestra comune): FULL Sh {bw_f['sharpe']:.2f} DD {bw_f['maxdd']*100:.1f}% | HOLD Sh {bw_h['sharpe']:.2f}")
|
||||
for w in (0.2, 0.3, 0.5):
|
||||
comb = (1 - w) * tpw + w * xsw
|
||||
cf = metrics(comb); ch = metrics(comb[comb.index >= HOLDOUT])
|
||||
print(f" +XS w{w:.0%}: FULL {cf['sharpe']:.2f} ({cf['sharpe']-bw_f['sharpe']:+.2f}) DD {cf['maxdd']*100:.1f}%"
|
||||
f" | HOLD {ch['sharpe']:.2f} ({ch['sharpe']-bw_h['sharpe']:+.2f})")
|
||||
print("\n WINNER-diversifier se: corr bassa, e TP01+XS batte TP01-solo (FULL E HOLD) sulla finestra comune,")
|
||||
print(" con breadth per-anno ok. Altrimenti no (e attenzione: storia XS solo ~2.5 anni).")
|
||||
|
||||
|
||||
if __name__=="__main__":
|
||||
main()
|
||||
@@ -1,814 +0,0 @@
|
||||
"""altlib — SHARED HONEST EVALUATION LIBRARY for the alt-strategy fan-out (2026-06-20).
|
||||
|
||||
Built for the "studia altre strategie alternative su Deribit" research wave: >=100 agents,
|
||||
each studying ONE distinct strategy hypothesis on the certified BTC/ETH (+ DVOL) universe.
|
||||
Every agent imports THIS module so that:
|
||||
* NO look-ahead is structurally possible: a target/weight decided at close[i] is held
|
||||
during bar i+1 (the evaluator shifts it for you — you never multiply by r[i] with a
|
||||
weight that used close[i] for the *same* bar).
|
||||
* Fees are realistic Deribit (0.10% RT taker = 0.0005/side) and a fee SWEEP is built in.
|
||||
* Metrics are comparable: FULL Sharpe/CAGR/maxDD, HOLD-OUT (2025-01-01+), per-year.
|
||||
* Only certified data exists (BTC/ETH from Deribit mainnet, DVOL from Deribit). load()
|
||||
raises on anything else — a physical guardrail.
|
||||
|
||||
Two evaluation styles:
|
||||
1. eval_weights(df, target) -> for CONTINUOUS-position strategies (trend, vol overlays,
|
||||
pairs, risk-parity). `target` is a per-bar position (fraction of equity, sign=dir),
|
||||
decided with data <= close[i]. VECTORIZED (numpy) -> fast even on 68k 1h bars.
|
||||
2. eval_signals(df, entries) -> for DISCRETE entry/exit strategies (breakout w/ TP-SL,
|
||||
mean-reversion bounce). Wraps the project's trade-based harness. Use on 1h/1d only
|
||||
(the Python loop is O(n*max_bars); 5m has 840k bars -> too slow on 2 CPUs).
|
||||
|
||||
Quick start (inside an agent script):
|
||||
import sys; sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
rep = al.study_weights("MY-STRAT", lambda df: my_target(df), tfs=("1d","12h"))
|
||||
print(al.fmt(rep)); print(al.as_json(rep)) # human + machine
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
import json
|
||||
import sys
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
# --- make `from src...` work no matter where the agent's script lives -------
|
||||
_ROOT = Path(__file__).resolve().parents[3]
|
||||
if str(_ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(_ROOT))
|
||||
|
||||
from src.backtest.harness import backtest_signals, load # noqa: E402
|
||||
from src.strategies.trend_portfolio import resample_tf # noqa: E402
|
||||
|
||||
HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
|
||||
FEE_SIDE = 0.0005 # 0.05%/side = 0.10% round-trip (Deribit taker)
|
||||
FEE_SWEEP = (0.0, 0.0005, 0.001, 0.0015) # per-side fee grid for robustness
|
||||
CERTIFIED = ("BTC", "ETH")
|
||||
DATA_DIR = _ROOT / "data" / "raw"
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# DATA (cached) — 1h base, resampled to >=4h; DVOL aligned causally.
|
||||
# ===========================================================================
|
||||
@lru_cache(maxsize=32)
|
||||
def get(asset: str, tf: str) -> pd.DataFrame:
|
||||
"""Certified OHLCV with a tz-aware 'datetime' col and RangeIndex.
|
||||
tf in {5m,15m,1h} loaded directly; {4h,6h,8h,12h,1d,2d,3d,1w} resampled from 1h.
|
||||
Resample uses the leak-free per-single-TF path (trend_portfolio.resample_tf)."""
|
||||
asset = asset.upper()
|
||||
if asset not in CERTIFIED:
|
||||
raise ValueError(f"Asset non certificato: {asset}. Universo={CERTIFIED}.")
|
||||
tf = tf.lower()
|
||||
if tf in ("5m", "15m", "1h"):
|
||||
df = load(asset, tf)
|
||||
else:
|
||||
rule = {"4h": "4h", "6h": "6h", "8h": "8h", "12h": "12h",
|
||||
"1d": "1D", "2d": "2D", "3d": "3D", "1w": "1W"}.get(tf)
|
||||
if rule is None:
|
||||
raise ValueError(f"TF non gestito: {tf}")
|
||||
df = resample_tf(load(asset, "1h"), rule)
|
||||
df = df.reset_index(drop=True)
|
||||
if "datetime" not in df.columns:
|
||||
df["datetime"] = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
|
||||
return df
|
||||
|
||||
|
||||
@lru_cache(maxsize=8)
|
||||
def _dvol_raw(asset: str) -> pd.DataFrame:
|
||||
p = DATA_DIR / f"dvol_{asset.lower()}.parquet"
|
||||
if not p.exists():
|
||||
raise FileNotFoundError(f"DVOL non trovato: {p}")
|
||||
d = pd.read_parquet(p).sort_values("timestamp").reset_index(drop=True)
|
||||
return d
|
||||
|
||||
|
||||
def dvol(df: pd.DataFrame, asset: str) -> np.ndarray:
|
||||
"""Deribit DVOL (implied vol index) aligned CAUSALLY to df's bars.
|
||||
For each bar we take the most recent DVOL value timestamped at/before the bar's
|
||||
open (merge_asof backward) -> known by decision time. NaN before DVOL history
|
||||
(DVOL starts 2021-03). Returns float array len(df), in vol POINTS (e.g. 65.0)."""
|
||||
d = _dvol_raw(asset)
|
||||
left = pd.DataFrame({"timestamp": df["timestamp"].astype("int64").values})
|
||||
merged = pd.merge_asof(left, d.rename(columns={"close": "dvol"}),
|
||||
on="timestamp", direction="backward")
|
||||
return merged["dvol"].values.astype(float)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# INDICATORS (all causal: value at i uses data <= i)
|
||||
# ===========================================================================
|
||||
def simple_returns(c: np.ndarray) -> np.ndarray:
|
||||
r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0
|
||||
return r
|
||||
|
||||
|
||||
def log_returns(c: np.ndarray) -> np.ndarray:
|
||||
r = np.zeros(len(c)); r[1:] = np.log(c[1:] / c[:-1])
|
||||
return r
|
||||
|
||||
|
||||
def ema(x: np.ndarray, span: int) -> np.ndarray:
|
||||
return pd.Series(x).ewm(span=span, adjust=False).mean().values
|
||||
|
||||
|
||||
def sma(x: np.ndarray, win: int) -> np.ndarray:
|
||||
return pd.Series(x).rolling(win, min_periods=win).mean().values
|
||||
|
||||
|
||||
def rolling_std(x: np.ndarray, win: int) -> np.ndarray:
|
||||
return pd.Series(x).rolling(win, min_periods=max(2, win // 2)).std().values
|
||||
|
||||
|
||||
def zscore(x: np.ndarray, win: int) -> np.ndarray:
|
||||
s = pd.Series(x)
|
||||
m = s.rolling(win, min_periods=win).mean()
|
||||
sd = s.rolling(win, min_periods=win).std()
|
||||
return ((s - m) / sd.replace(0, np.nan)).values
|
||||
|
||||
|
||||
def rsi(c: np.ndarray, win: int = 14) -> np.ndarray:
|
||||
d = np.diff(c, prepend=c[0])
|
||||
up = pd.Series(np.where(d > 0, d, 0.0)).ewm(alpha=1 / win, adjust=False).mean()
|
||||
dn = pd.Series(np.where(d < 0, -d, 0.0)).ewm(alpha=1 / win, adjust=False).mean()
|
||||
rs = up / dn.replace(0, np.nan)
|
||||
return (100 - 100 / (1 + rs)).values
|
||||
|
||||
|
||||
def atr(df: pd.DataFrame, win: int = 14) -> np.ndarray:
|
||||
h, l, c = df["high"].values, df["low"].values, df["close"].values
|
||||
pc = np.roll(c, 1); pc[0] = c[0]
|
||||
tr = np.maximum(h - l, np.maximum(np.abs(h - pc), np.abs(l - pc)))
|
||||
return pd.Series(tr).ewm(alpha=1 / win, adjust=False).mean().values
|
||||
|
||||
|
||||
def realized_vol(r: np.ndarray, win: int, bars_per_year: float) -> np.ndarray:
|
||||
"""Annualized realized vol from returns up to i inclusive (no leakage)."""
|
||||
return pd.Series(r).rolling(win, min_periods=max(2, win // 2)).std().values * np.sqrt(bars_per_year)
|
||||
|
||||
|
||||
def donchian(df: pd.DataFrame, win: int):
|
||||
"""Upper/lower channel using bars STRICTLY before i (shifted) -> a close[i] that
|
||||
breaks the prior `win`-bar high is a real, tradeable breakout at close[i]."""
|
||||
hi = pd.Series(df["high"].values).rolling(win, min_periods=win).max().shift(1).values
|
||||
lo = pd.Series(df["low"].values).rolling(win, min_periods=win).min().shift(1).values
|
||||
return hi, lo
|
||||
|
||||
|
||||
def bbands(c: np.ndarray, win: int = 20, k: float = 2.0):
|
||||
m = pd.Series(c).rolling(win, min_periods=win).mean()
|
||||
sd = pd.Series(c).rolling(win, min_periods=win).std()
|
||||
return (m + k * sd).values, m.values, (m - k * sd).values
|
||||
|
||||
|
||||
def _call_target(fn, df: pd.DataFrame, asset: str):
|
||||
"""Call a strategy fn as fn(df, asset) when it accepts 2 args, else fn(df).
|
||||
Lets DVOL/cross-asset strategies receive the asset cleanly (no inference hacks)."""
|
||||
try:
|
||||
n = len(inspect.signature(fn).parameters)
|
||||
except (ValueError, TypeError):
|
||||
n = 1
|
||||
return fn(df, asset) if n >= 2 else fn(df)
|
||||
|
||||
|
||||
def bars_per_year(df: pd.DataFrame) -> float:
|
||||
dt = pd.to_datetime(df["datetime"]).diff().dt.total_seconds().median()
|
||||
return 86400 * 365.25 / dt if dt and dt > 0 else 365.25
|
||||
|
||||
|
||||
def bars_per_day(df: pd.DataFrame) -> int:
|
||||
dt = pd.to_datetime(df["datetime"]).diff().dt.total_seconds().median()
|
||||
return max(1, round(86400 / dt))
|
||||
|
||||
|
||||
def vol_target(target_dir: np.ndarray, df: pd.DataFrame, target_vol: float = 0.20,
|
||||
vol_win_days: int = 30, leverage_cap: float = 2.0) -> np.ndarray:
|
||||
"""Scale a direction array in [-1,1] to a vol-targeted position (TP01-style).
|
||||
Causal: uses realized vol up to i. Returns position clipped to +/-leverage_cap."""
|
||||
c = df["close"].values.astype(float)
|
||||
bpd = bars_per_day(df)
|
||||
bpy = bpd * 365.25
|
||||
vol = realized_vol(simple_returns(c), max(2, vol_win_days * bpd), bpy)
|
||||
scal = np.where((vol > 0) & np.isfinite(vol), target_vol / vol, 0.0)
|
||||
tgt = np.clip(target_dir * scal, -leverage_cap, leverage_cap)
|
||||
tgt[~np.isfinite(tgt)] = 0.0
|
||||
return tgt
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# METRICS
|
||||
# ===========================================================================
|
||||
def _metrics_from_net(net: np.ndarray, idx: pd.DatetimeIndex) -> dict:
|
||||
net = np.nan_to_num(net, nan=0.0)
|
||||
eq = np.cumprod(1.0 + np.clip(net, -0.99, None))
|
||||
rr = net[np.isfinite(net)]
|
||||
bpy = 86400 * 365.25 / (pd.Series(idx).diff().dt.total_seconds().median() or 86400)
|
||||
sharpe = float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)) if np.std(rr) > 0 else 0.0
|
||||
pk = np.maximum.accumulate(eq)
|
||||
dd = float(np.max((pk - eq) / pk)) if len(eq) else 0.0
|
||||
span_days = (idx[-1] - idx[0]).total_seconds() / 86400 if len(idx) > 1 else 1.0
|
||||
years = max(span_days / 365.25, 1e-6)
|
||||
total = eq[-1] / eq[0] if len(eq) else 1.0
|
||||
cagr = total ** (1 / years) - 1 if total > 0 else -1.0
|
||||
return dict(sharpe=round(sharpe, 3), cagr=round(cagr, 4), maxdd=round(dd, 4),
|
||||
ret=round(total - 1, 4), n=int(len(rr)))
|
||||
|
||||
|
||||
def _yearly(net: np.ndarray, idx: pd.DatetimeIndex) -> dict:
|
||||
s = pd.Series(np.nan_to_num(net), index=idx)
|
||||
out = {}
|
||||
for y, g in s.groupby(s.index.year):
|
||||
eq = np.cumprod(1 + g.values); pk = np.maximum.accumulate(eq)
|
||||
out[int(y)] = dict(ret=round(float(eq[-1] - 1), 4),
|
||||
dd=round(float(np.max((pk - eq) / pk)), 4))
|
||||
return out
|
||||
|
||||
|
||||
def eval_weights(df: pd.DataFrame, target: np.ndarray, fee_side: float = FEE_SIDE) -> dict:
|
||||
"""Honest backtest of a CONTINUOUS position series.
|
||||
target[i] is decided with data <= close[i]; it is HELD during bar i+1. The shift
|
||||
is done HERE -> you cannot leak by construction. Fee charged on |Δposition| turnover.
|
||||
Returns {full, holdout, yearly, time_in_market, turnover_per_year, net, idx}."""
|
||||
c = df["close"].values.astype(float)
|
||||
target = np.asarray(target, float)
|
||||
target = np.nan_to_num(target, nan=0.0)
|
||||
r = simple_returns(c)
|
||||
pos = np.zeros(len(target)); pos[1:] = target[:-1] # held during bar t = decided at t-1
|
||||
gross = pos * r
|
||||
turn = np.abs(np.diff(pos, prepend=0.0))
|
||||
net = gross - fee_side * turn
|
||||
net[0] = 0.0
|
||||
idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
|
||||
full = _metrics_from_net(net, idx)
|
||||
hmask = idx >= HOLDOUT
|
||||
hold = _metrics_from_net(net[hmask], idx[hmask]) if hmask.sum() > 3 else dict(sharpe=0.0, n=0)
|
||||
bpy_d = bars_per_day(df) * 365.25
|
||||
return dict(full=full, holdout=hold, yearly=_yearly(net, idx),
|
||||
time_in_market=round(float(np.mean(pos != 0)), 3),
|
||||
turnover_per_year=round(float(turn.sum() / (len(turn) / bpy_d)), 1),
|
||||
net=net, idx=idx)
|
||||
|
||||
|
||||
def eval_signals(df: pd.DataFrame, entries: list, fee_rt: float = 2 * FEE_SIDE,
|
||||
leverage: float = 1.0, asset: str = "", tf: str = "") -> dict:
|
||||
"""Honest backtest of DISCRETE entry/exit signals (TP/SL/max_bars). Wraps the
|
||||
project trade-based harness, adds a standardized hold-out split. Use on 1h/1d."""
|
||||
m = backtest_signals(df, entries, fee_rt=fee_rt, leverage=leverage, asset=asset, tf=tf)
|
||||
idx = pd.DatetimeIndex(pd.to_datetime(m.eq_index, utc=True)) if m.eq_index is not None \
|
||||
else pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
|
||||
eq = m.equity
|
||||
hmask = idx >= HOLDOUT
|
||||
hold = dict(sharpe=0.0, ret=0.0, n=0)
|
||||
if hmask.sum() > 3:
|
||||
he = eq[hmask]
|
||||
hr = np.diff(he) / he[:-1]
|
||||
bpy = m.bars_per_year or 365.0
|
||||
hsharpe = float(np.mean(hr) / np.std(hr) * np.sqrt(bpy)) if len(hr) and np.std(hr) > 0 else 0.0
|
||||
hold = dict(sharpe=round(hsharpe, 3), ret=round(float(he[-1] / he[0] - 1), 4), n=int(hmask.sum()))
|
||||
full = dict(sharpe=round(m.sharpe, 3), cagr=round(m.cagr, 4), maxdd=round(m.max_dd, 4),
|
||||
ret=round(m.net_return, 4), n=int(m.n_trades))
|
||||
return dict(full=full, holdout=hold, n_trades=int(m.n_trades),
|
||||
win_rate=round(m.win_rate, 1), time_in_market=round(m.time_in_market, 3),
|
||||
yearly={int(y): round(v, 4) for y, v in m.yearly.items()})
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# MARGINAL SCORING vs TP01 baseline — the lesson of the 2026-06-20 sweep.
|
||||
#
|
||||
# Absolute Sharpe is NOT enough to earn a portfolio slot: an overlay on TSMOM
|
||||
# (DVOL gate, low-vol filter, kill-switch, ...) inherits TP01's trend Sharpe and
|
||||
# scores ~1.0-1.3 while adding ZERO new return. The only question that matters for
|
||||
# a NEW sleeve is: does it IMPROVE the existing TP01 portfolio out-of-sample?
|
||||
# We answer it three ways: (a) blend uplift (Sharpe of TP01 + w*candidate minus
|
||||
# TP01 alone, full & hold-out), (b) correlation to TP01, (c) residual alpha after
|
||||
# removing the TP01 beta (the part of the candidate orthogonal to trend).
|
||||
# ===========================================================================
|
||||
def _sh(s) -> float:
|
||||
r = np.asarray(s.dropna().values, float)
|
||||
return float(np.mean(r) / np.std(r) * np.sqrt(365.25)) if len(r) > 2 and np.std(r) > 0 else 0.0
|
||||
|
||||
|
||||
def _dd_ret(s) -> float:
|
||||
eq = np.cumprod(1.0 + np.asarray(s.dropna().values, float))
|
||||
pk = np.maximum.accumulate(eq)
|
||||
return float(np.max((pk - eq) / pk)) if len(eq) else 0.0
|
||||
|
||||
|
||||
def _to_daily(s: pd.Series) -> pd.Series:
|
||||
s = s.dropna().sort_index()
|
||||
if not isinstance(s.index, pd.DatetimeIndex):
|
||||
s.index = pd.to_datetime(s.index, utc=True)
|
||||
if s.index.tz is None:
|
||||
s.index = s.index.tz_localize("UTC")
|
||||
return ((1.0 + s).resample("1D").prod() - 1.0).dropna()
|
||||
|
||||
|
||||
@lru_cache(maxsize=2)
|
||||
def tp01_baseline_daily() -> pd.Series:
|
||||
"""The reference a candidate must BEAT: TP01 CANONICAL, 50/50 BTC+ETH, net daily
|
||||
returns on common dates (full Sharpe ~1.30, hold-out ~0.31). Cached."""
|
||||
from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio
|
||||
tp = TrendPortfolio(**CANONICAL)
|
||||
series = {}
|
||||
for a in CERTIFIED:
|
||||
df = get(a, "1d")
|
||||
net, _ = tp.net_returns(df)
|
||||
series[a] = pd.Series(net, index=pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True)))
|
||||
J = pd.concat(series, axis=1, join="inner").fillna(0.0)
|
||||
return _to_daily(0.5 * J[CERTIFIED[0]] + 0.5 * J[CERTIFIED[1]])
|
||||
|
||||
|
||||
def candidate_daily(target_fn, tf: str = "1d", fee_side: float = FEE_SIDE) -> pd.Series:
|
||||
"""Build a candidate's 50/50 BTC+ETH net DAILY return series (same convention as
|
||||
tp01_baseline_daily) from a continuous-position target_fn. Intraday TFs are
|
||||
compounded to daily so they align with the TP01 baseline grid."""
|
||||
series = {}
|
||||
for a in CERTIFIED:
|
||||
df = get(a, tf)
|
||||
ev = eval_weights(df, _call_target(target_fn, df, a), fee_side=fee_side)
|
||||
series[a] = pd.Series(ev["net"], index=ev["idx"])
|
||||
J = pd.concat(series, axis=1, join="inner").fillna(0.0)
|
||||
return _to_daily(0.5 * J[CERTIFIED[0]] + 0.5 * J[CERTIFIED[1]])
|
||||
|
||||
|
||||
def _uplift_series(B: pd.Series, C: pd.Series, w: float = 0.25) -> float:
|
||||
"""Sharpe of the (1-w)*TP01 + w*candidate blend minus Sharpe of TP01 alone."""
|
||||
return _sh((1 - w) * B + w * C) - _sh(B)
|
||||
|
||||
|
||||
def _null_uplift_pctl(B: pd.Series, C: pd.Series, w: float = 0.25,
|
||||
n: int = 300, seed: int = 20260621):
|
||||
"""Where does the candidate's blend-uplift sit vs the NULL of a zero-correlation
|
||||
noise asset with the SAME mean & vol? Lesson of 2026-06-21: a low-corr asset with a
|
||||
little positive drift 'adds' ~+0.03 Sharpe by pure diversification MATH — that is not
|
||||
a signal. We draw `n` iid-normal assets (same mean/std as C, independent of B => corr 0
|
||||
by construction), measure each one's uplift, and return (real_uplift, percentile of
|
||||
real vs the null). pctl >= ~0.8 => the uplift is meaningfully above diversification
|
||||
math; pctl ~0.5 => it IS diversification math. Seeded -> deterministic."""
|
||||
Bx, Cx = B.align(C, join="inner")
|
||||
bs, cs = Bx.values.astype(float), Cx.values.astype(float)
|
||||
if len(cs) < 30:
|
||||
return None, None
|
||||
base = _sh(Bx)
|
||||
real = _sh((1 - w) * Bx + w * Cx) - base
|
||||
mu, sd = float(np.nanmean(cs)), float(np.nanstd(cs))
|
||||
if sd == 0:
|
||||
return round(real, 3), None
|
||||
rng = np.random.default_rng(seed)
|
||||
draws = rng.normal(mu, sd, size=(n, len(cs)))
|
||||
blends = (1 - w) * bs[None, :] + w * draws
|
||||
m, s = blends.mean(axis=1), blends.std(axis=1)
|
||||
null = np.where(s > 0, m / s * np.sqrt(365.25), 0.0) - base
|
||||
return round(float(real), 3), round(float(np.mean(null <= real)), 3)
|
||||
|
||||
|
||||
def marginal_vs_tp01(cand_daily: pd.Series, weights=(0.25, 0.5)) -> dict:
|
||||
"""Does this candidate IMPROVE the TP01 portfolio? Returns correlation, blend uplift
|
||||
(full & hold-out, per weight), TP01-beta + residual alpha, and a verdict:
|
||||
ADDS -> lifts the blend, PERSISTENTLY (multi-cut), beats the zero-corr noise
|
||||
null, in BOTH TP01-up and TP01-down regimes
|
||||
HEDGE -> low corr but only pays when TP01 is WEAK (a drawdown dampener, not a
|
||||
standing premium): real, but price it as a hedge, not as alpha
|
||||
NOISE -> uplift indistinguishable from a random zero-corr asset (diversification
|
||||
math, not a signal)
|
||||
REDUNDANT -> ~identical to TP01 (corr high, ~zero uplift): a re-skin, no slot
|
||||
DILUTES -> drags the blend down
|
||||
NEUTRAL -> changes little either way (a weak, optional satellite at best)
|
||||
Score a NEW sleeve on THIS, not on absolute Sharpe.
|
||||
|
||||
Hardened 2026-06-21 (ortho wave): the fixed-HOLDOUT uplift + drop-month jackknife was
|
||||
fooled (17/18 relative-value books 'ADDS' on a single 2025 ETH-bleed window). Three
|
||||
gates added: (1) MULTI-CUT persistence (positive uplift at several hold-out starts, not
|
||||
only 2025); (2) NOISE-NULL (uplift must beat a zero-corr random asset); (3) HEDGE vs
|
||||
alpha (a low-corr sleeve that only helps when TP01 is down is a hedge)."""
|
||||
B = tp01_baseline_daily()
|
||||
J = pd.concat({"B": B, "C": cand_daily}, axis=1, join="inner").dropna()
|
||||
if len(J) < 30:
|
||||
return dict(marginal_verdict="N/A", reason="insufficient overlap with TP01 baseline")
|
||||
if J["C"].std() == 0:
|
||||
return dict(marginal_verdict="NEUTRAL", reason="flat/zero candidate (no exposure)",
|
||||
corr_full=None, blends={"w25": dict(uplift_full=0.0, uplift_hold=0.0)})
|
||||
JH = J[J.index >= HOLDOUT]
|
||||
has_h = len(JH) > 5
|
||||
out = {
|
||||
"n_days": int(len(J)), "n_hold_days": int(len(JH)),
|
||||
"corr_full": round(float(J["B"].corr(J["C"])), 3),
|
||||
"corr_hold": round(float(JH["B"].corr(JH["C"])), 3) if has_h else None,
|
||||
"tp01_full_sharpe": round(_sh(J["B"]), 3), "tp01_hold_sharpe": round(_sh(JH["B"]), 3) if has_h else None,
|
||||
"cand_full_sharpe": round(_sh(J["C"]), 3), "cand_hold_sharpe": round(_sh(JH["C"]), 3) if has_h else None,
|
||||
}
|
||||
blends = {}
|
||||
for w in weights:
|
||||
bf, bh = (1 - w) * J["B"] + w * J["C"], (1 - w) * JH["B"] + w * JH["C"]
|
||||
blends[f"w{int(w * 100)}"] = dict(
|
||||
full=round(_sh(bf), 3), hold=round(_sh(bh), 3) if has_h else None,
|
||||
uplift_full=round(_sh(bf) - _sh(J["B"]), 3),
|
||||
uplift_hold=round(_sh(bh) - _sh(JH["B"]), 3) if has_h else None,
|
||||
dd=round(_dd_ret(bf), 4))
|
||||
out["blends"] = blends
|
||||
b, c = J["B"].values, J["C"].values
|
||||
beta = float(np.cov(c, b)[0, 1] / np.var(b)) if np.var(b) > 0 else 0.0
|
||||
resid = c - beta * b
|
||||
out["beta_to_tp01"] = round(beta, 3)
|
||||
out["resid_sharpe_full"] = round(float(np.mean(resid) / np.std(resid) * np.sqrt(365.25)) if np.std(resid) > 0 else 0.0, 3)
|
||||
out["alpha_ann"] = round(float(np.mean(resid) * 365.25), 4)
|
||||
# OOS robustness — the marginal point-estimate can be fooled by ONE lucky month
|
||||
# (e.g. KAMA: +0.06 uplift that flips to -0.03 when its best month is dropped). Require
|
||||
# the blend uplift to be positive in the earliest CLEAN hold-out year AND to survive a
|
||||
# drop-one-month jackknife. This is lesson #2 of the 2026-06-20 sweep, in code.
|
||||
out["clean_year_uplift"] = out["jackknife_min_uplift"] = None
|
||||
robust_h = False
|
||||
if has_h:
|
||||
def _u(sub):
|
||||
return _uplift_series(sub["B"], sub["C"])
|
||||
yrs = sorted(set(JH.index.year))
|
||||
clean = JH[JH.index.year == yrs[0]]
|
||||
cu = _u(clean) if len(clean) > 20 else None
|
||||
months = sorted(set(zip(JH.index.year, JH.index.month)))
|
||||
jk = (min(_u(JH[~((JH.index.year == y) & (JH.index.month == mo))]) for y, mo in months)
|
||||
if len(months) > 1 else _u(JH))
|
||||
out["clean_year_uplift"] = round(cu, 3) if cu is not None else None
|
||||
out["jackknife_min_uplift"] = round(jk, 3) if jk is not None else None
|
||||
robust_h = bool(cu is not None and cu > 0.02 and jk is not None and jk > 0.0)
|
||||
|
||||
# --- GATE 1: MULTI-CUT PERSISTENCE -------------------------------------------------
|
||||
# Uplift at the start of each year (not only the fixed HOLDOUT). A real edge adds at
|
||||
# SEVERAL cuts incl. an early one; a regime artifact only adds at the latest window.
|
||||
mc = {}
|
||||
for y in sorted(set(J.index.year))[1:]:
|
||||
sub = J[J.index >= pd.Timestamp(f"{y}-01-01", tz="UTC")]
|
||||
if len(sub) >= 120:
|
||||
mc[y] = round(_uplift_series(sub["B"], sub["C"]), 3)
|
||||
out["multicut_uplift"] = mc
|
||||
pos = [u for u in mc.values() if u > 0]
|
||||
earliest = mc[min(mc)] if mc else None
|
||||
multicut_persistent = bool(len(mc) >= 2 and len(pos) / len(mc) >= 0.6
|
||||
and earliest is not None and earliest > 0.0)
|
||||
out["multicut_persistent"] = multicut_persistent
|
||||
|
||||
# --- GATE 2: NOISE-NULL (uplift must beat a random zero-corr asset) -----------------
|
||||
JI = J[J.index < HOLDOUT] # in-sample part (not the lucky recent window)
|
||||
real_is, pctl_is = _null_uplift_pctl(JI["B"], JI["C"]) if len(JI) >= 60 else (None, None)
|
||||
real_f, pctl_f = _null_uplift_pctl(J["B"], J["C"])
|
||||
cand_is_sharpe = round(_sh(JI["C"]), 3) if len(JI) >= 60 else None
|
||||
out["null_pctl_insample"] = pctl_is
|
||||
out["null_pctl_full"] = pctl_f
|
||||
out["cand_insample_sharpe"] = cand_is_sharpe
|
||||
# A candidate must STAND ON ITS OWN before the hold-out: a real in-sample standalone
|
||||
# Sharpe. The ortho basket's in-sample Sharpe was 0.29 -> its only "value" was the
|
||||
# diversification math of a near-zero-Sharpe stream, dressed up by the lucky 2025 window.
|
||||
# (null_pctl_* are reported as the diversification-math context: a low-corr asset adds
|
||||
# ~+0.03 Sharpe by math, so pctl~0.5 just means "no TP01-specific timing" — true of GOOD
|
||||
# and BAD uncorrelated sleeves alike, so it can't be the gate. The in-sample edge is.)
|
||||
has_insample_edge = (cand_is_sharpe is None) or (cand_is_sharpe >= 0.5)
|
||||
out["has_insample_edge"] = bool(has_insample_edge)
|
||||
out["beats_noise_null"] = bool(has_insample_edge) # back-compat alias for the gate
|
||||
|
||||
# --- GATE 3: HEDGE vs ALPHA (does it only pay when TP01 is weak?) -------------------
|
||||
yr_sh, yr_up = [], []
|
||||
for y in sorted(set(J.index.year)):
|
||||
sub = J[J.index.year == y]
|
||||
if len(sub) >= 40:
|
||||
yr_sh.append(_sh(sub["B"])); yr_up.append(_uplift_series(sub["B"], sub["C"]))
|
||||
hedge_corr = (round(float(np.corrcoef(yr_sh, yr_up)[0, 1]), 3)
|
||||
if len(yr_sh) >= 3 and np.std(yr_sh) > 0 and np.std(yr_up) > 0 else None)
|
||||
trail = J["B"].rolling(60, min_periods=20).sum().shift(1)
|
||||
up_seg, dn_seg = J[trail > 0], J[trail <= 0]
|
||||
u_up = _uplift_series(up_seg["B"], up_seg["C"]) if len(up_seg) > 30 else None
|
||||
u_dn = _uplift_series(dn_seg["B"], dn_seg["C"]) if len(dn_seg) > 30 else None
|
||||
out["hedge_yearly_corr"] = hedge_corr
|
||||
out["uplift_tp01_up"] = round(u_up, 3) if u_up is not None else None
|
||||
out["uplift_tp01_down"] = round(u_dn, 3) if u_dn is not None else None
|
||||
is_hedge = bool(hedge_corr is not None and hedge_corr < -0.5
|
||||
and u_up is not None and u_up <= 0.0
|
||||
and u_dn is not None and u_dn > 0.05)
|
||||
out["is_hedge"] = is_hedge
|
||||
|
||||
# robust_oos now REQUIRES multi-cut persistence (kills the single-window winners)
|
||||
out["robust_oos"] = bool(robust_h and multicut_persistent)
|
||||
|
||||
# --- VERDICT ----------------------------------------------------------------------
|
||||
up_h = blends["w25"]["uplift_hold"]
|
||||
up_f = blends["w25"]["uplift_full"]
|
||||
ch = out["corr_hold"] if out["corr_hold"] is not None else out["corr_full"]
|
||||
if out["corr_full"] > 0.9 and (up_h is None or abs(up_h) < 0.05):
|
||||
v = "REDUNDANT"
|
||||
elif up_f <= -0.10 and (up_h is None or up_h <= 0.0):
|
||||
v = "DILUTES"
|
||||
elif is_hedge:
|
||||
v = "HEDGE"
|
||||
elif not has_insample_edge:
|
||||
v = "NOISE"
|
||||
elif (up_h is not None and up_h >= 0.05 and up_f > -0.15 and ch < 0.85
|
||||
and multicut_persistent):
|
||||
v = "ADDS"
|
||||
else:
|
||||
v = "NEUTRAL"
|
||||
out["marginal_verdict"] = v
|
||||
return out
|
||||
|
||||
|
||||
def study_marginal(name: str, target_fn, tf: str = "1d", fee_side: float = FEE_SIDE) -> dict:
|
||||
"""Score a continuous candidate BOTH ways: absolute (study_weights) AND marginal vs
|
||||
TP01. The combined gate: a candidate earns a sleeve slot only if it is not FAIL on
|
||||
absolute robustness AND marginal_verdict == 'ADDS'."""
|
||||
absolute = study_weights(name, target_fn, tfs=(tf,))
|
||||
marg = marginal_vs_tp01(candidate_daily(target_fn, tf=tf, fee_side=fee_side))
|
||||
abs_grade = absolute["verdict"]["grade"]
|
||||
# ADDS already embeds multi-cut + beats-null + not-hedge; we also require robust_oos
|
||||
# (multi-cut robustness) explicitly. A HEDGE/NOISE/NEUTRAL never earns a live slot.
|
||||
earns_slot = (abs_grade != "FAIL" and marg.get("marginal_verdict") == "ADDS"
|
||||
and marg.get("robust_oos", False)
|
||||
and marg.get("beats_noise_null", False)
|
||||
and not marg.get("is_hedge", False))
|
||||
return dict(name=name, tf=tf, absolute=absolute, marginal=marg,
|
||||
abs_grade=abs_grade, marginal_verdict=marg.get("marginal_verdict"),
|
||||
earns_slot=earns_slot)
|
||||
|
||||
|
||||
def fmt_marginal(rep: dict) -> str:
|
||||
m = rep["marginal"]
|
||||
bl = m.get("blends", {})
|
||||
lines = [f"=== {rep['name']} | abs={rep['abs_grade']} marginal={rep['marginal_verdict']} "
|
||||
f"EARNS_SLOT={rep['earns_slot']}"]
|
||||
lines.append(f" corr->TP01 full {m.get('corr_full')} hold {m.get('corr_hold')} "
|
||||
f"beta {m.get('beta_to_tp01')} resid Sharpe {m.get('resid_sharpe_full')} alpha/yr {m.get('alpha_ann')}")
|
||||
lines.append(f" OOS robustness: clean-year uplift {m.get('clean_year_uplift')} "
|
||||
f"drop-best-month {m.get('jackknife_min_uplift')} robust_oos={m.get('robust_oos')}")
|
||||
lines.append(f" multi-cut persistence: {m.get('multicut_uplift')} persistent={m.get('multicut_persistent')}")
|
||||
lines.append(f" in-sample edge: standalone Sharpe {m.get('cand_insample_sharpe')} "
|
||||
f"has_insample_edge={m.get('has_insample_edge')} "
|
||||
f"(diversification-math null pctl in-sample {m.get('null_pctl_insample')} full {m.get('null_pctl_full')})")
|
||||
lines.append(f" hedge check: yearly corr(TP01-Sh, uplift) {m.get('hedge_yearly_corr')} "
|
||||
f"uplift TP01-up {m.get('uplift_tp01_up')} / TP01-down {m.get('uplift_tp01_down')} "
|
||||
f"is_hedge={m.get('is_hedge')}")
|
||||
lines.append(f" standalone: TP01 full {m.get('tp01_full_sharpe')}/hold {m.get('tp01_hold_sharpe')} | "
|
||||
f"cand full {m.get('cand_full_sharpe')}/hold {m.get('cand_hold_sharpe')}")
|
||||
for w, d in bl.items():
|
||||
uh = "n/a" if d["uplift_hold"] is None else f"{d['uplift_hold']:+.3f}"
|
||||
hold = "n/a" if d["hold"] is None else f"{d['hold']}"
|
||||
lines.append(f" blend {w}: full {d['full']} (uplift {d['uplift_full']:+.3f}) "
|
||||
f"hold {hold} (uplift {uh}) DD {d['dd'] * 100:.1f}%")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# HARNESS REALISM — two gates codified from the 2026-06-21 intraday wave.
|
||||
#
|
||||
# LESSON 1 (day-boundary): open_drive ("first 8h UTC predicts rest-of-day") scored a
|
||||
# +0.23 uplift but INVERTED to -0.10 when the UTC day start was shifted 4h — a calendar-
|
||||
# LABELING artifact, not an intraday effect. A real hour/session/day edge degrades
|
||||
# gracefully under a boundary shift; an artifact flips sign.
|
||||
#
|
||||
# LESSON 2 (small-cap fills): eval_weights charges fee on EVERY |Δposition|, incl. the
|
||||
# thousands of sub-dollar rebalances a vol-target overlay produces. At ~$600 real capital a
|
||||
# $0.03 trade can't execute — the modeled proportional fee is a continuous-rebalancing
|
||||
# fiction. eval_weights_smallcap skips changes below min_order and reports the Sharpe haircut.
|
||||
# ===========================================================================
|
||||
def _shift_calendar(df: pd.DataFrame, offset_hours: int) -> pd.DataFrame:
|
||||
"""Relabel the clock the SIGNAL sees by +offset_hours (datetime & timestamp), leaving
|
||||
prices/returns untouched -> the signal's .dt.hour / day-grouping shifts, the backtest
|
||||
does not. (get() is cached; copy so we never mutate the shared frame.)"""
|
||||
d = df.copy()
|
||||
dt = pd.to_datetime(d["datetime"], utc=True) + pd.Timedelta(hours=offset_hours)
|
||||
d["datetime"] = dt
|
||||
if "timestamp" in d:
|
||||
d["timestamp"] = d["timestamp"].astype("int64") + int(offset_hours * 3600 * 1000)
|
||||
return d
|
||||
|
||||
|
||||
def day_boundary_robust(target_fn, tf: str = "1h",
|
||||
offsets=(0, 3, 6, 9, 12, 15, 18, 21), w: float = 0.25) -> dict:
|
||||
"""Is a candidate's marginal uplift ROBUST to shifting the UTC day boundary? For each
|
||||
offset we relabel the calendar the signal sees, recompute its 50/50 BTC+ETH daily series
|
||||
and the blend uplift vs TP01. A datetime-independent signal is INVARIANT (spread ~0); a
|
||||
calendar signal that stays positive is ROBUST; one whose uplift flips sign is ARTIFACT-RISK
|
||||
(open_drive). Run this on ANY hour/session/day-of-week signal before believing it."""
|
||||
B = tp01_baseline_daily()
|
||||
per = {}
|
||||
for off in offsets:
|
||||
series = {}
|
||||
for a in CERTIFIED:
|
||||
df0 = get(a, tf) # ORIGINAL bars/dates
|
||||
tgt = _call_target(target_fn, _shift_calendar(df0, off), a) # signal sees shifted clock
|
||||
ev = eval_weights(df0, tgt) # backtest on the real calendar
|
||||
series[a] = pd.Series(ev["net"], index=ev["idx"])
|
||||
J = pd.concat(series, axis=1, join="inner").fillna(0.0)
|
||||
cand = _to_daily(0.5 * J[CERTIFIED[0]] + 0.5 * J[CERTIFIED[1]])
|
||||
JJ = pd.concat({"B": B, "C": cand}, axis=1, join="inner").dropna()
|
||||
per[int(off)] = round(_sh((1 - w) * JJ["B"] + w * JJ["C"]) - _sh(JJ["B"]), 3) if len(JJ) > 30 else None
|
||||
ups = [v for v in per.values() if v is not None]
|
||||
if not ups:
|
||||
return dict(per_offset=per, verdict="N/A", reason="no evaluable offsets")
|
||||
spread = round(max(ups) - min(ups), 3)
|
||||
calendar_sensitive = spread > 0.02
|
||||
robust = min(ups) > 0
|
||||
verdict = ("INVARIANT" if not calendar_sensitive else ("ROBUST" if robust else "ARTIFACT-RISK"))
|
||||
return dict(per_offset=per, base=per[offsets[0]], min=min(ups), max=max(ups),
|
||||
spread=spread, calendar_sensitive=calendar_sensitive,
|
||||
robust_to_boundary=robust, verdict=verdict)
|
||||
|
||||
|
||||
def eval_weights_smallcap(df: pd.DataFrame, target, capital: float = 600.0,
|
||||
min_order: float = 5.0, fee_side: float = FEE_SIDE) -> dict:
|
||||
"""Honest net at SMALL capital. A desired position change whose notional |Δw|*capital is
|
||||
below min_order is NOT executed (held -> tracking error, no trade) — removing the
|
||||
continuous-rebalancing fiction. Returns realistic vs modeled metrics, the Sharpe haircut,
|
||||
and the number of trades that actually execute. (Applies to ANY sleeve at this capital,
|
||||
TP01 included.)"""
|
||||
c = df["close"].values.astype(float)
|
||||
tgt = np.clip(np.nan_to_num(np.asarray(target, float)), -10, 10)
|
||||
held = np.empty(len(tgt)); cur = 0.0; n_tr = 0
|
||||
for i in range(len(tgt)):
|
||||
if abs(tgt[i] - cur) * capital >= min_order:
|
||||
cur = tgt[i]; n_tr += 1
|
||||
held[i] = cur
|
||||
r = simple_returns(c)
|
||||
pos = np.zeros(len(held)); pos[1:] = held[:-1]
|
||||
turn = np.abs(np.diff(pos, prepend=0.0))
|
||||
net = pos * r - fee_side * turn; net[0] = 0.0
|
||||
idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
|
||||
real = _metrics_from_net(net, idx)
|
||||
modeled = eval_weights(df, tgt, fee_side=fee_side)["full"]
|
||||
bpy_d = bars_per_day(df) * 365.25
|
||||
return dict(realistic=real, modeled=modeled,
|
||||
sharpe_haircut=round(modeled["sharpe"] - real["sharpe"], 3),
|
||||
n_executed_trades=int(n_tr),
|
||||
executed_turnover_per_year=round(float(turn.sum() / (len(turn) / bpy_d)), 1))
|
||||
|
||||
|
||||
def causality_ok(target_fn, tf: str = "1h", assets=CERTIFIED,
|
||||
tail: int = 80, tol: float = 1e-3) -> dict:
|
||||
"""Online-consistency / LOOK-AHEAD guard for a continuous target_fn(df) [or (df, asset)].
|
||||
eval_weights SHIFTS the position so you cannot leak by multiplying a weight by the SAME
|
||||
bar's return — but it does NOT verify the FEATURE construction is causal: a centered
|
||||
window, a .shift(-k), or a full-sample statistic would pass eval_weights yet peek at the
|
||||
future. Here we recompute the target on a TRUNCATED prefix and require its tail to MATCH
|
||||
target(full)[:cut] (the bars a deployable signal would have emitted in real time). Any
|
||||
future-peeking diverges. Run this in every altlib-based lab (blind/ortho already do)."""
|
||||
worst = 0.0; bad = False; checked = 0
|
||||
for a in assets:
|
||||
df = get(a, tf)
|
||||
full = np.nan_to_num(np.asarray(_call_target(target_fn, df, a), float))
|
||||
n = len(df)
|
||||
for cut in (int(n * 0.80), int(n * 0.92)):
|
||||
if cut <= tail + 5 or cut >= n:
|
||||
continue
|
||||
sub = df.iloc[:cut].reset_index(drop=True)
|
||||
s = np.nan_to_num(np.asarray(_call_target(target_fn, sub, a), float))
|
||||
if len(s) != cut:
|
||||
bad = True
|
||||
continue
|
||||
d = np.abs(s[cut - tail:cut] - full[cut - tail:cut])
|
||||
worst = max(worst, float(np.max(d)) if len(d) else 0.0)
|
||||
checked += 1
|
||||
return dict(ok=bool((not bad) and worst <= tol),
|
||||
max_tail_diff=round(worst, 8), checked=checked,
|
||||
reason=("length-mismatch on prefix" if bad else None))
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# DRIVERS — run a hypothesis across both assets, several TFs, with a fee sweep.
|
||||
# ===========================================================================
|
||||
def _verdict(per_cell: list[dict]) -> dict:
|
||||
"""A finding PASSES only if it is robust: positive FULL Sharpe AND positive HOLD-OUT
|
||||
on BOTH assets in its best TF, survives the fee sweep, and isn't a 1-cell fluke."""
|
||||
if not per_cell:
|
||||
return dict(grade="FAIL", reason="no cells")
|
||||
ok = [c for c in per_cell if c.get("full_sharpe", -9) > 0]
|
||||
best = max(per_cell, key=lambda c: c.get("min_asset_holdout_sharpe", -9))
|
||||
pass_ = (best.get("min_asset_full_sharpe", -9) >= 0.5 and
|
||||
best.get("min_asset_holdout_sharpe", -9) >= 0.2 and
|
||||
best.get("fee_survives", False))
|
||||
weak = (best.get("min_asset_full_sharpe", -9) >= 0.3 and
|
||||
best.get("min_asset_holdout_sharpe", -9) >= 0.0)
|
||||
grade = "PASS" if pass_ else ("WEAK" if weak else "FAIL")
|
||||
return dict(grade=grade, best_tf=best.get("tf"),
|
||||
best_full_sharpe=best.get("min_asset_full_sharpe"),
|
||||
best_holdout_sharpe=best.get("min_asset_holdout_sharpe"),
|
||||
n_positive_cells=len(ok), n_cells=len(per_cell))
|
||||
|
||||
|
||||
def study_weights(name: str, target_fn, tfs=("1d", "12h"),
|
||||
assets=CERTIFIED, fee_sweep=FEE_SWEEP) -> dict:
|
||||
"""Run a CONTINUOUS-position hypothesis on each (asset,tf), report robustness.
|
||||
target_fn(df) -> per-bar position array (decided <= close[i]). Returns a dict
|
||||
ready to print/serialize, with a conservative PASS/WEAK/FAIL verdict."""
|
||||
cells = []
|
||||
for tf in tfs:
|
||||
per_asset = {}
|
||||
fee_ok_all = True
|
||||
for a in assets:
|
||||
df = get(a, tf)
|
||||
tgt = _call_target(target_fn, df, a)
|
||||
base = eval_weights(df, tgt, fee_side=FEE_SIDE)
|
||||
sweep = {f"{2*f*100:.2f}%RT": eval_weights(df, tgt, fee_side=f)["full"]["sharpe"]
|
||||
for f in fee_sweep}
|
||||
fee_ok = sweep.get("0.20%RT", -9) > 0
|
||||
fee_ok_all = fee_ok_all and fee_ok
|
||||
per_asset[a] = dict(full=base["full"], holdout=base["holdout"],
|
||||
tim=base["time_in_market"], turnover=base["turnover_per_year"],
|
||||
fee_sweep=sweep, yearly=base["yearly"])
|
||||
min_full = min(per_asset[a]["full"]["sharpe"] for a in assets)
|
||||
min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in assets)
|
||||
cells.append(dict(tf=tf, per_asset=per_asset,
|
||||
min_asset_full_sharpe=round(min_full, 3),
|
||||
min_asset_holdout_sharpe=round(min_hold, 3),
|
||||
full_sharpe=round(np.mean([per_asset[a]["full"]["sharpe"] for a in assets]), 3),
|
||||
fee_survives=fee_ok_all))
|
||||
return dict(name=name, kind="weights", cells=cells, verdict=_verdict(cells))
|
||||
|
||||
|
||||
def study_signals(name: str, entries_fn, tfs=("1d",), assets=CERTIFIED,
|
||||
fee_sweep=FEE_SWEEP, leverage: float = 1.0) -> dict:
|
||||
"""Run a DISCRETE entry/exit hypothesis on each (asset,tf). entries_fn(df) ->
|
||||
list[dict|None] len(df). Use 1h/1d TFs only (Python loop)."""
|
||||
cells = []
|
||||
for tf in tfs:
|
||||
per_asset = {}
|
||||
fee_ok_all = True
|
||||
for a in assets:
|
||||
df = get(a, tf)
|
||||
ent = _call_target(entries_fn, df, a)
|
||||
base = eval_signals(df, ent, fee_rt=2 * FEE_SIDE, leverage=leverage, asset=a, tf=tf)
|
||||
sweep = {f"{2*f*100:.2f}%RT": eval_signals(df, ent, fee_rt=2 * f, leverage=leverage)["full"]["sharpe"]
|
||||
for f in fee_sweep}
|
||||
fee_ok = sweep.get("0.20%RT", -9) > 0
|
||||
fee_ok_all = fee_ok_all and fee_ok
|
||||
per_asset[a] = dict(full=base["full"], holdout=base["holdout"],
|
||||
n_trades=base["n_trades"], win_rate=base["win_rate"],
|
||||
fee_sweep=sweep, yearly=base["yearly"])
|
||||
min_full = min(per_asset[a]["full"]["sharpe"] for a in assets)
|
||||
min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in assets)
|
||||
cells.append(dict(tf=tf, per_asset=per_asset,
|
||||
min_asset_full_sharpe=round(min_full, 3),
|
||||
min_asset_holdout_sharpe=round(min_hold, 3),
|
||||
full_sharpe=round(np.mean([per_asset[a]["full"]["sharpe"] for a in assets]), 3),
|
||||
fee_survives=fee_ok_all))
|
||||
return dict(name=name, kind="signals", cells=cells, verdict=_verdict(cells))
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# OUTPUT
|
||||
# ===========================================================================
|
||||
def _clean(o):
|
||||
if isinstance(o, dict):
|
||||
return {k: _clean(v) for k, v in o.items() if k not in ("net", "idx", "equity")}
|
||||
if isinstance(o, (list, tuple)):
|
||||
return [_clean(x) for x in o]
|
||||
if isinstance(o, (np.floating,)):
|
||||
return round(float(o), 4)
|
||||
if isinstance(o, (np.integer,)):
|
||||
return int(o)
|
||||
return o
|
||||
|
||||
|
||||
def as_json(rep: dict) -> str:
|
||||
return json.dumps(_clean(rep), default=str)
|
||||
|
||||
|
||||
def fmt(rep: dict) -> str:
|
||||
v = rep["verdict"]
|
||||
lines = [f"=== {rep['name']} [{rep['kind']}] -> {v['grade']} "
|
||||
f"(best {v.get('best_tf')}: full {v.get('best_full_sharpe')}, "
|
||||
f"hold {v.get('best_holdout_sharpe')})"]
|
||||
for c in rep["cells"]:
|
||||
lines.append(f" TF {c['tf']:>4s}: minFull={c['min_asset_full_sharpe']:+.2f} "
|
||||
f"minHold={c['min_asset_holdout_sharpe']:+.2f} feeOK={c['fee_survives']}")
|
||||
for a, pa in c["per_asset"].items():
|
||||
yr = " ".join(f"{y}:{d['ret']*100 if isinstance(d, dict) else d*100:+.0f}%"
|
||||
for y, d in list(pa["yearly"].items()))
|
||||
lines.append(f" {a}: full Sh={pa['full']['sharpe']:+.2f} "
|
||||
f"DD={pa['full']['maxdd']*100:.0f}% ret={pa['full']['ret']*100:+.0f}% "
|
||||
f"hold Sh={pa['holdout'].get('sharpe', 0):+.2f} | {yr}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# smoke test: buy&hold, TSMOM trend, donchian breakout
|
||||
print("--- SMOKE TEST altlib ---")
|
||||
bh = study_weights("BUYHOLD", lambda df: np.ones(len(df)), tfs=("1d",))
|
||||
print(fmt(bh))
|
||||
|
||||
def tsmom(df):
|
||||
c = df["close"].values
|
||||
bpd = bars_per_day(df)
|
||||
d = np.zeros(len(c))
|
||||
for h in (30 * bpd, 90 * bpd, 180 * bpd):
|
||||
s = np.full(len(c), np.nan); s[h:] = np.sign(c[h:] / c[:-h] - 1)
|
||||
d = d + np.nan_to_num(s)
|
||||
d = np.clip(np.sign(d), 0, None)
|
||||
return vol_target(d, df, 0.20, 30, 2.0)
|
||||
print(fmt(study_weights("TSMOM-LF", tsmom, tfs=("1d",))))
|
||||
|
||||
def donch(df):
|
||||
hi, lo = donchian(df, 20)
|
||||
c = df["close"].values
|
||||
pos = np.where(c > hi, 1.0, np.nan)
|
||||
pos = np.where(c < lo, 0.0, pos)
|
||||
return pd.Series(pos).ffill().fillna(0.0).values
|
||||
print(fmt(study_weights("DONCHIAN20-LF", donch, tfs=("1d",))))
|
||||
print("\nJSON sample:", as_json(bh)[:300])
|
||||
@@ -1,96 +0,0 @@
|
||||
"""Demo / validation of the MARGINAL-vs-TP01 scorer (2026-06-20).
|
||||
|
||||
Shows the lesson of the 104-hypothesis sweep operationalized: strategies that scored
|
||||
an absolute PASS but are just TP01/TSMOM with an overlay collapse to REDUNDANT/NEUTRAL/
|
||||
DILUTES under marginal scoring, while the one genuine diversifier (STA05 long-short)
|
||||
earns ADDS. Run: uv run python scripts/research/alt/marginal_demo.py
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
import altlib as al
|
||||
from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio
|
||||
|
||||
|
||||
def tsmom_dir(df):
|
||||
"""Long-flat multi-horizon TSMOM direction in {0,1} (the bare TP01 trend signal)."""
|
||||
c = df["close"].values.astype(float)
|
||||
bpd = al.bars_per_day(df)
|
||||
d = np.zeros(len(c))
|
||||
for h in (30 * bpd, 90 * bpd, 180 * bpd):
|
||||
s = np.full(len(c), np.nan)
|
||||
s[h:] = np.sign(c[h:] / c[:-h] - 1.0)
|
||||
d += np.nan_to_num(s)
|
||||
return np.clip(np.sign(d), 0, None)
|
||||
|
||||
|
||||
def tp01_target(df):
|
||||
return TrendPortfolio(**CANONICAL).target_series(df)
|
||||
|
||||
|
||||
FAST, SLOW = [5, 10, 20, 40], [40, 80, 120, 200]
|
||||
PAIRS = [(f, s) for f in FAST for s in SLOW if f < s]
|
||||
|
||||
|
||||
def sta05(df, long_only):
|
||||
c = df["close"].values.astype(float)
|
||||
v = np.zeros(len(c))
|
||||
for f, s in PAIRS:
|
||||
v += np.sign(al.ema(c, f) - al.ema(c, s))
|
||||
d = v / len(PAIRS)
|
||||
if long_only:
|
||||
d = np.clip(d, 0.0, 1.0)
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
def vol03(df, asset):
|
||||
"""DVOL-gated TSMOM (active only when DVOL below its expanding median)."""
|
||||
d = tsmom_dir(df)
|
||||
dv = pd.Series(al.dvol(df, asset))
|
||||
thr = dv.expanding(min_periods=30).quantile(0.5)
|
||||
gate = dv.isna() | thr.isna() | (dv < thr)
|
||||
d = np.where(gate.values, d, 0.0)
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
def cmb04(df):
|
||||
"""Momentum + low-vol filter (TSMOM taken only when realized vol below expanding median)."""
|
||||
d = tsmom_dir(df)
|
||||
bpd = al.bars_per_day(df)
|
||||
rv = al.realized_vol(al.simple_returns(df["close"].values.astype(float)), 30 * bpd, bpd * 365.25)
|
||||
med = pd.Series(rv).expanding(min_periods=60).median().values
|
||||
d = np.where((rv < med) | np.isnan(med), d, 0.0)
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
CANDIDATES = [
|
||||
("TP01-itself (sanity)", tp01_target),
|
||||
("STA05 long-short (the lead)", lambda df: sta05(df, False)),
|
||||
("STA05 long-only", lambda df: sta05(df, True)),
|
||||
("VOL03 DVOL-gated TSMOM (overlay)", vol03),
|
||||
("CMB04 momentum+low-vol (overlay)", cmb04),
|
||||
]
|
||||
|
||||
print("=" * 78)
|
||||
print("MARGINAL SCORING vs TP01 baseline — absolute Sharpe is NOT enough for a slot")
|
||||
print("=" * 78)
|
||||
rows = []
|
||||
for name, fn in CANDIDATES:
|
||||
rep = al.study_marginal(name, fn, tf="1d")
|
||||
print()
|
||||
print(al.fmt_marginal(rep))
|
||||
rows.append((name, rep["abs_grade"], rep["marginal_verdict"], rep["earns_slot"]))
|
||||
|
||||
print("\n" + "=" * 78)
|
||||
print(f"{'candidate':<36s} {'absolute':>9s} {'marginal':>10s} {'earns_slot':>11s}")
|
||||
for n, ag, mv, es in rows:
|
||||
print(f"{n:<36s} {ag:>9s} {mv:>10s} {str(es):>11s}")
|
||||
|
||||
# sanity asserts: baseline reproduces, and an overlay-on-TSMOM does NOT earn a slot
|
||||
sanity = al.marginal_vs_tp01(al.candidate_daily(tp01_target))
|
||||
assert sanity["corr_full"] > 0.95, f"TP01-vs-itself corr should be ~1, got {sanity['corr_full']}"
|
||||
assert abs(sanity["blends"]["w25"]["uplift_full"]) < 0.05, "TP01-vs-itself uplift should be ~0"
|
||||
print("\nSANITY OK: TP01-vs-itself corr", sanity["corr_full"],
|
||||
"uplift_full", sanity["blends"]["w25"]["uplift_full"], "->", sanity["marginal_verdict"])
|
||||
@@ -1,136 +0,0 @@
|
||||
"""Resta qualche candidato? — passa i contendenti promettenti piu' forti del sweep
|
||||
(trend non-TSMOM, overlay DVOL, rotazione cross-asset) attraverso il gate MARGINALE vs TP01.
|
||||
Run: uv run python scripts/research/alt/marginal_remaining.py
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
import altlib as al
|
||||
|
||||
|
||||
def tsmom_dir(df):
|
||||
c = df["close"].values.astype(float); bpd = al.bars_per_day(df); d = np.zeros(len(c))
|
||||
for h in (30 * bpd, 90 * bpd, 180 * bpd):
|
||||
s = np.full(len(c), np.nan); s[h:] = np.sign(c[h:] / c[:-h] - 1.0); d += np.nan_to_num(s)
|
||||
return np.clip(np.sign(d), 0, None)
|
||||
|
||||
|
||||
def wma(x, n):
|
||||
w = np.arange(1, n + 1)
|
||||
return pd.Series(x).rolling(n).apply(lambda v: np.dot(v, w) / w.sum(), raw=True).values
|
||||
|
||||
|
||||
# --- TRD10 Vortex(14) long-flat ---
|
||||
def trd10(df):
|
||||
h = df["high"].values.astype(float); l = df["low"].values.astype(float); c = df["close"].values.astype(float)
|
||||
pc = np.roll(c, 1); pc[0] = c[0]; ph = np.roll(h, 1); ph[0] = h[0]; pl = np.roll(l, 1); pl[0] = l[0]
|
||||
tr = np.maximum(h - l, np.maximum(np.abs(h - pc), np.abs(l - pc)))
|
||||
n = 14; strn = pd.Series(tr).rolling(n).sum().values
|
||||
vip = pd.Series(np.abs(h - pl)).rolling(n).sum().values / strn
|
||||
vim = pd.Series(np.abs(l - ph)).rolling(n).sum().values / strn
|
||||
d = np.where(np.isnan(vip), 0.0, np.where(vip > vim, 1.0, 0.0))
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
# --- TRD08 Hull MA slope ---
|
||||
def trd08(df):
|
||||
c = df["close"].values.astype(float)
|
||||
h = wma(2 * wma(c, 27) - wma(c, 55), 7) # HMA(55)
|
||||
slope = np.zeros(len(h)); slope[1:] = h[1:] - h[:-1]
|
||||
d = np.where(slope > 0, 1.0, 0.0); d[np.isnan(h)] = 0.0
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
# --- TRD07 Kaufman AMA cross ---
|
||||
def kama(c, n=10, fast=2, slow=30):
|
||||
c = np.asarray(c, float); L = len(c); out = np.copy(c)
|
||||
fsc, ssc = 2 / (fast + 1), 2 / (slow + 1)
|
||||
vol = pd.Series(np.abs(np.diff(c, prepend=c[0]))).rolling(n).sum().values
|
||||
change = np.full(L, np.nan); change[n:] = np.abs(c[n:] - c[:-n])
|
||||
sc = (np.where(vol > 0, change / vol, 0.0) * (fsc - ssc) + ssc) ** 2
|
||||
for i in range(1, L):
|
||||
out[i] = out[i - 1] if np.isnan(sc[i]) else out[i - 1] + sc[i] * (c[i] - out[i - 1])
|
||||
return out
|
||||
|
||||
|
||||
def trd07(df):
|
||||
c = df["close"].values.astype(float); k = kama(c)
|
||||
slope = np.zeros(len(k)); slope[1:] = k[1:] - k[:-1]
|
||||
d = np.where((c > k) & (slope > 0), 1.0, 0.0)
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
# --- VOL08 realized-vol term-structure overlay on TSMOM ---
|
||||
def vol08(df):
|
||||
c = df["close"].values.astype(float); bpd = al.bars_per_day(df); r = al.simple_returns(c)
|
||||
sv = al.realized_vol(r, 5 * bpd, bpd * 365.25); lv = al.realized_vol(r, 30 * bpd, bpd * 365.25)
|
||||
ratio = sv / lv; d = tsmom_dir(df)
|
||||
d = np.where((ratio < 1.0) | np.isnan(ratio), d, 0.0)
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
# --- VOL11 DVOL kill-switch on TSMOM (df, asset) ---
|
||||
def vol11(df, asset):
|
||||
d = tsmom_dir(df); dv = pd.Series(al.dvol(df, asset))
|
||||
thr = dv.expanding(min_periods=30).quantile(0.80)
|
||||
kill = (~dv.isna()) & (~thr.isna()) & (dv > thr)
|
||||
d = np.where(kill.values, 0.0, d)
|
||||
return al.vol_target(d, df, 0.20, 30, 2.0)
|
||||
|
||||
|
||||
# --- XAS09/03 cross-asset rotation (hold the stronger of BTC/ETH; dual=flat if both neg) ---
|
||||
def rotation_daily(lb=90, dual=True):
|
||||
R, M, V = {}, {}, {}
|
||||
for a in ("BTC", "ETH"):
|
||||
df = al.get(a, "1d"); c = df["close"].values.astype(float)
|
||||
idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
|
||||
mom = np.full(len(c), np.nan); mom[lb:] = c[lb:] / c[:-lb] - 1.0
|
||||
R[a] = pd.Series(al.simple_returns(c), index=idx)
|
||||
M[a] = pd.Series(mom, index=idx)
|
||||
V[a] = pd.Series(al.vol_target(np.ones(len(c)), df, 0.20, 30, 2.0), index=idx)
|
||||
R = pd.concat(R, axis=1, join="inner"); M = pd.concat(M, axis=1, join="inner").shift(1)
|
||||
V = pd.concat(V, axis=1, join="inner").shift(1)
|
||||
out = np.zeros(len(R))
|
||||
for t in range(len(R)):
|
||||
mrow = M.iloc[t]
|
||||
if mrow.isna().all():
|
||||
continue
|
||||
best = mrow.idxmax()
|
||||
if dual and mrow[best] <= 0:
|
||||
continue
|
||||
pos = V.iloc[t][best]
|
||||
out[t] = (0.0 if np.isnan(pos) else pos) * R.iloc[t][best]
|
||||
return pd.Series(out, index=R.index)
|
||||
|
||||
|
||||
SINGLE = [("TRD10 Vortex", trd10), ("TRD08 Hull MA", trd08), ("TRD07 KAMA", trd07),
|
||||
("VOL08 RV term-struct", vol08), ("VOL11 DVOL kill-switch", vol11)]
|
||||
|
||||
print("=" * 90)
|
||||
print("RESTA QUALCHE CANDIDATO? — gate marginale vs TP01 sui contendenti piu' forti")
|
||||
print("=" * 90)
|
||||
rows = []
|
||||
for name, fn in SINGLE:
|
||||
rep = al.study_marginal(name, fn, tf="1d")
|
||||
m = rep["marginal"]
|
||||
print(al.fmt_marginal(rep))
|
||||
print()
|
||||
rows.append((name, rep["abs_grade"], rep["marginal_verdict"], rep["earns_slot"],
|
||||
m.get("corr_hold"), m["blends"]["w25"].get("uplift_hold")))
|
||||
|
||||
# cross-asset rotations (built directly, scored marginally)
|
||||
for name, dual in [("XAS09 dual-momentum", True), ("XAS03 RS rotation", False)]:
|
||||
m = al.marginal_vs_tp01(rotation_daily(90, dual))
|
||||
v = m["marginal_verdict"]
|
||||
print(al.fmt_marginal({"name": name, "abs_grade": "n/a", "marginal_verdict": v,
|
||||
"earns_slot": v == "ADDS", "marginal": m}))
|
||||
print()
|
||||
rows.append((name, "n/a", v, v == "ADDS", m.get("corr_hold"), m["blends"]["w25"].get("uplift_hold")))
|
||||
|
||||
print("=" * 90)
|
||||
print(f"{'candidato':<26s}{'abs':>7s}{'marginale':>12s}{'slot':>7s}{'corr_hold':>11s}{'upliftH_w25':>13s}")
|
||||
for n, ag, mv, es, ch, uh in rows:
|
||||
print(f"{n:<26s}{ag:>7s}{mv:>12s}{str(es):>7s}{str(ch):>11s}{str(uh):>13s}")
|
||||
print("\n(ADDS+slot=True => candidato vivo; tutto il resto => morto/ridondante)")
|
||||
@@ -1,74 +0,0 @@
|
||||
"""BRK01 — Donchian 10/20/55 channel breakout, long-short and long-flat variants.
|
||||
|
||||
Hypothesis: close breaks prior N-bar high -> long, prior N-bar low -> short (long-flat variant: flat
|
||||
instead of short). Grid N in {10, 20, 55}. Best config picked by min-asset hold-out Sharpe.
|
||||
With vol-targeting to 20% annualized volatility (TP01-style).
|
||||
|
||||
CAUSAL: al.donchian(df, N) shifts the rolling max/min by 1 bar -> breakout at close[i] is
|
||||
strictly decided with data up to and including close[i-1] for the channel, so it is leak-free.
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
# ---- Strategy implementation -----------------------------------------------
|
||||
|
||||
def make_brk_ls(N: int):
|
||||
"""Long-short Donchian breakout: +1 if close breaks N-bar prior high, -1 if breaks prior low,
|
||||
hold otherwise. Vol-targeted to 20%."""
|
||||
def target(df):
|
||||
hi, lo = al.donchian(df, N)
|
||||
c = df["close"].values.astype(float)
|
||||
# signal: +1 long, -1 short, nan=hold previous
|
||||
sig = np.full(len(c), np.nan)
|
||||
sig[c > hi] = 1.0
|
||||
sig[c < lo] = -1.0
|
||||
# forward-fill (hold position until next signal)
|
||||
direction = pd.Series(sig).ffill().fillna(0.0).values
|
||||
return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target
|
||||
|
||||
|
||||
def make_brk_lf(N: int):
|
||||
"""Long-flat Donchian breakout: +1 if close breaks N-bar prior high, 0 if breaks prior low.
|
||||
Vol-targeted to 20%."""
|
||||
def target(df):
|
||||
hi, lo = al.donchian(df, N)
|
||||
c = df["close"].values.astype(float)
|
||||
sig = np.full(len(c), np.nan)
|
||||
sig[c > hi] = 1.0
|
||||
sig[c < lo] = 0.0
|
||||
direction = pd.Series(sig).ffill().fillna(0.0).values
|
||||
return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target
|
||||
|
||||
|
||||
# ---- Run grid: N in {10, 20, 55} x variant {LS, LF}, TF=1d only (keep <=6 backtests) ----
|
||||
# Total: 3 N values x 2 variants x 1 TF x 2 assets = 12 asset-runs but only 3 study_weights calls
|
||||
# Each study_weights call does 2 assets = 6 total calls -> 6 cells, fine.
|
||||
# We also add 12h for the best N to compare frequency.
|
||||
|
||||
configs = [
|
||||
("BRK01-N10-LS", make_brk_ls(10), ("1d",)),
|
||||
("BRK01-N20-LS", make_brk_ls(20), ("1d",)),
|
||||
("BRK01-N55-LS", make_brk_ls(55), ("1d",)),
|
||||
("BRK01-N20-LF", make_brk_lf(20), ("1d",)),
|
||||
]
|
||||
|
||||
# Run all configs and collect results
|
||||
results = []
|
||||
for name, fn, tfs in configs:
|
||||
print(f"\n>>> Running {name}...")
|
||||
rep = al.study_weights(name, fn, tfs=tfs)
|
||||
print(al.fmt(rep))
|
||||
print("JSON:", al.as_json(rep))
|
||||
results.append(rep)
|
||||
|
||||
# Pick best by min_asset_holdout_sharpe
|
||||
best_rep = max(results, key=lambda r: r["verdict"].get("best_holdout_sharpe", -99))
|
||||
print("\n\n=== BEST CONFIG ===")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,107 +0,0 @@
|
||||
"""BRK02 — Donchian55 + Chandelier ATR trailing stop.
|
||||
|
||||
IDEA:
|
||||
- Enter LONG when close[i] breaks above the 55-bar Donchian high (prior bars, causal).
|
||||
- Exit (go flat) when close[i] falls below the Chandelier trailing stop:
|
||||
chandelier_stop = highest_close(22 bars, ending at i) - 3 * ATR(22, ending at i).
|
||||
- Position is 0 (flat) or 1 (long). No short. Vol-targeted to 20% with 2x cap.
|
||||
|
||||
Implementation (weights style, continuous position):
|
||||
- Donchian high computed on PRIOR bars (shift(1) already done by al.donchian).
|
||||
- Chandelier stop computed causally on current+prior bars:
|
||||
hc[i] = max(close[i-21..i]) -> rolling max of close, window=22
|
||||
atr22[i] = ATR(22 bars) at i
|
||||
stop[i] = hc[i] - 3 * atr22[i]
|
||||
- State machine:
|
||||
if flat and close[i] > donchian_high[i]: go long
|
||||
if long and close[i] < stop[i]: go flat
|
||||
|
||||
Params tried: (don_win=55, atr_win=22, atr_mult=3.0) — canonical
|
||||
(don_win=40, atr_win=22, atr_mult=2.5) — tighter
|
||||
Best picked by min_asset_holdout_sharpe.
|
||||
"""
|
||||
|
||||
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 chandelier_signal(df: pd.DataFrame, don_win: int = 55,
|
||||
atr_win: int = 22, atr_mult: float = 3.0) -> np.ndarray:
|
||||
"""Return a direction array in {0, 1} (0=flat, 1=long) using Donchian+Chandelier.
|
||||
Causal: decision at i uses only data <= close[i]."""
|
||||
close = df["close"].values.astype(float)
|
||||
n = len(close)
|
||||
|
||||
# Donchian upper channel: highest HIGH over prior don_win bars (shift(1) in al.donchian)
|
||||
don_high, _ = al.donchian(df, don_win) # don_high[i] = max(high[i-don_win..i-1])
|
||||
|
||||
# ATR(atr_win) — causal, uses bars up to and including i
|
||||
atr22 = al.atr(df, atr_win)
|
||||
|
||||
# Highest CLOSE over trailing atr_win bars (inclusive of i) — causal
|
||||
highest_close = pd.Series(close).rolling(atr_win, min_periods=atr_win).max().values
|
||||
|
||||
# Chandelier stop at i
|
||||
chandelier_stop = highest_close - atr_mult * atr22
|
||||
|
||||
# State machine: flat=0, long=1
|
||||
pos = np.zeros(n, dtype=float)
|
||||
state = 0 # start flat
|
||||
for i in range(n):
|
||||
c = close[i]
|
||||
dh = don_high[i]
|
||||
cs = chandelier_stop[i]
|
||||
|
||||
if state == 0:
|
||||
# Enter long if close breaks above prior Donchian high (valid only if dh is defined)
|
||||
if np.isfinite(dh) and c > dh:
|
||||
state = 1
|
||||
else: # state == 1
|
||||
# Exit long if close drops below chandelier stop (and stop is defined)
|
||||
if np.isfinite(cs) and c < cs:
|
||||
state = 0
|
||||
|
||||
pos[i] = float(state)
|
||||
|
||||
return pos
|
||||
|
||||
|
||||
def make_target(don_win: int = 55, atr_win: int = 22, atr_mult: float = 3.0):
|
||||
"""Factory returning a vol-targeted weight function for a given param set."""
|
||||
def target_fn(df: pd.DataFrame) -> np.ndarray:
|
||||
direction = chandelier_signal(df, don_win=don_win, atr_win=atr_win, atr_mult=atr_mult)
|
||||
return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target_fn
|
||||
|
||||
|
||||
# --- Small param grid (4 configurations, TFs: 1d and 12h -> 8 backtest cells total)
|
||||
CONFIGS = [
|
||||
dict(don_win=55, atr_win=22, atr_mult=3.0, label="D55-A22-M3.0"),
|
||||
dict(don_win=40, atr_win=22, atr_mult=2.5, label="D40-A22-M2.5"),
|
||||
dict(don_win=55, atr_win=14, atr_mult=3.0, label="D55-A14-M3.0"),
|
||||
dict(don_win=70, atr_win=22, atr_mult=3.5, label="D70-A22-M3.5"),
|
||||
]
|
||||
|
||||
TFS = ("1d", "12h")
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for cfg in CONFIGS:
|
||||
lbl = cfg["label"]
|
||||
fn = make_target(don_win=cfg["don_win"], atr_win=cfg["atr_win"], atr_mult=cfg["atr_mult"])
|
||||
rep = al.study_weights(f"BRK02[{lbl}]", fn, tfs=TFS)
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -9)
|
||||
print(f"Config {lbl}: grade={rep['verdict']['grade']} score(hold)={score:.3f}")
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
|
||||
# Rename best result to canonical BRK02
|
||||
best_rep["name"] = "BRK02"
|
||||
print()
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,75 +0,0 @@
|
||||
"""BRK03 — Keltner Channel Breakout
|
||||
HYPOTHESIS: Long when close > EMA20 + k*ATR(20); flat when close < EMA20.
|
||||
Try k in {1.5, 2.0, 2.5}. Vol-targeted continuous weights.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def keltner_breakout(df, k: float) -> np.ndarray:
|
||||
"""Long (vol-targeted) when close > EMA20 + k*ATR(20); flat when close < EMA20.
|
||||
All values causal: EMA/ATR at i use data <= i. Decision at close[i] -> held during bar i+1.
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
ema20 = al.ema(c, span=20)
|
||||
atr20 = al.atr(df, win=20)
|
||||
|
||||
upper_band = ema20 + k * atr20
|
||||
|
||||
# Direction: +1 if close > upper_band (breakout above), else 0 (flat)
|
||||
# Exit: go flat when close < EMA20 (mean reversion back below center)
|
||||
n = len(c)
|
||||
direction = np.zeros(n, dtype=float)
|
||||
|
||||
# Vectorized: long when above upper band; we then hold until close < EMA20
|
||||
# Implement as a state machine
|
||||
in_trade = False
|
||||
for i in range(n):
|
||||
if np.isnan(ema20[i]) or np.isnan(atr20[i]):
|
||||
direction[i] = 0.0
|
||||
continue
|
||||
if not in_trade:
|
||||
# Enter long on breakout above upper keltner band
|
||||
if c[i] > upper_band[i]:
|
||||
in_trade = True
|
||||
direction[i] = 1.0
|
||||
else:
|
||||
# Exit when price drops back below EMA
|
||||
if c[i] < ema20[i]:
|
||||
in_trade = False
|
||||
direction[i] = 0.0
|
||||
else:
|
||||
direction[i] = 1.0
|
||||
|
||||
# Apply vol-targeting to scale position size
|
||||
pos = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return pos
|
||||
|
||||
|
||||
# Grid: k in {1.5, 2.0, 2.5} — try all 3 param sets; pick best by min_asset_holdout_sharpe
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
best_k = None
|
||||
|
||||
for k_val in [1.5, 2.0, 2.5]:
|
||||
name = f"BRK03-k{k_val}"
|
||||
print(f"\n--- Running {name} ---")
|
||||
rep = al.study_weights(
|
||||
name,
|
||||
lambda df, k=k_val: keltner_breakout(df, k),
|
||||
tfs=("1d", "12h")
|
||||
)
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -999.0) or -999.0
|
||||
print(al.fmt(rep))
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_k = k_val
|
||||
|
||||
print("\n" + "="*60)
|
||||
print(f"BEST CONFIG: k={best_k}")
|
||||
print("="*60)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,89 +0,0 @@
|
||||
"""BRK04 — Bollinger Breakout (vol expansion), momentum interpretation.
|
||||
|
||||
HYPOTHESIS: Long-flat when close > upper BB(win, k); exit to flat when close < mid BB.
|
||||
This is a momentum (trend-following) reading of Bollinger Band breakouts — price above
|
||||
the upper band means the move is strong enough to be outside 2-sigma, so we ride it.
|
||||
|
||||
Internal grid (<=4 configs, total backtests <=6):
|
||||
Config A: BB(20, 2.0), tfs=("1d",) -- canonical params
|
||||
Config B: BB(20, 1.5), tfs=("1d",) -- tighter band (more signals)
|
||||
Config C: BB(30, 2.0), tfs=("1d",) -- wider lookback
|
||||
Config D: BB(20, 2.0) + vol_target, tfs=("1d",) -- vol-sized
|
||||
|
||||
We use bbands() which is causal at bar i (uses data up to i).
|
||||
Entry/exit logic is also causal — no look-ahead.
|
||||
The lib shift means target[i] is held during bar i+1.
|
||||
"""
|
||||
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 _bb_long_flat(df: pd.DataFrame, win: int = 20, k: float = 2.0,
|
||||
use_vol_target: bool = False) -> np.ndarray:
|
||||
"""Causal BB breakout: long when close > upper band, flat when close < mid band.
|
||||
State machine with forward-fill between entry and exit signals."""
|
||||
c = df["close"].values.astype(float)
|
||||
upper, mid, lower = al.bbands(c, win=win, k=k)
|
||||
|
||||
# State: 1 = in long, 0 = flat
|
||||
# At bar i:
|
||||
# - if state was 0 (flat): enter long if close[i] > upper[i]
|
||||
# - if state was 1 (long): exit to flat if close[i] < mid[i]
|
||||
# Result is decided at close[i], held during bar i+1 (shift done by lib).
|
||||
n = len(c)
|
||||
target = np.zeros(n)
|
||||
state = 0 # start flat
|
||||
|
||||
for i in range(n):
|
||||
if np.isnan(upper[i]) or np.isnan(mid[i]):
|
||||
target[i] = 0.0
|
||||
continue
|
||||
if state == 0:
|
||||
# Check entry: close above upper band
|
||||
if c[i] > upper[i]:
|
||||
state = 1
|
||||
else: # state == 1, in long
|
||||
# Check exit: close below mid band
|
||||
if c[i] < mid[i]:
|
||||
state = 0
|
||||
target[i] = float(state)
|
||||
|
||||
if use_vol_target:
|
||||
target = al.vol_target(target, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
|
||||
return target
|
||||
|
||||
|
||||
# --- Grid: 4 configs on 1d only (total backtests = 4 x 2 assets = 8, but each config
|
||||
# runs both assets via study_weights internally, so 4 study_weights calls = 4x2=8
|
||||
# asset-level backtests). Within budget.
|
||||
|
||||
configs = [
|
||||
dict(name="BRK04-A-BB20-2.0", win=20, k=2.0, vol_tgt=False),
|
||||
dict(name="BRK04-B-BB20-1.5", win=20, k=1.5, vol_tgt=False),
|
||||
dict(name="BRK04-C-BB30-2.0", win=30, k=2.0, vol_tgt=False),
|
||||
dict(name="BRK04-D-BB20-2.0-VT", win=20, k=2.0, vol_tgt=True),
|
||||
]
|
||||
|
||||
results = []
|
||||
for cfg in configs:
|
||||
w, k, vt = cfg["win"], cfg["k"], cfg["vol_tgt"]
|
||||
fn = lambda df, _w=w, _k=k, _vt=vt: _bb_long_flat(df, win=_w, k=_k, use_vol_target=_vt)
|
||||
rep = al.study_weights(cfg["name"], fn, tfs=("1d",))
|
||||
results.append(rep)
|
||||
print(al.fmt(rep))
|
||||
print()
|
||||
|
||||
# Pick best config by min_asset_holdout_sharpe in best TF
|
||||
def _best_score(r):
|
||||
return max(c["min_asset_holdout_sharpe"] for c in r["cells"])
|
||||
|
||||
best = max(results, key=_best_score)
|
||||
|
||||
print("\n" + "="*60)
|
||||
print(f"BEST CONFIG: {best['name']}")
|
||||
print(al.fmt(best))
|
||||
print("JSON:", al.as_json(best))
|
||||
@@ -1,75 +0,0 @@
|
||||
"""BRK05 — ATR Range Breakout (discrete signals, 1d only).
|
||||
|
||||
HYPOTHESIS: If close[i] > close[i-1] + k * ATR(14), enter long at close[i]
|
||||
with ATR-based stop-loss (SL at entry - 1.5*ATR) and max_bars exit.
|
||||
Grid: k in {0.5, 1.0, 1.5}, max_bars in {5, 10}.
|
||||
Total backtests: 3 * 2 * 2 assets = 12 signal generations (but only 6 eval_signals calls
|
||||
via best single config selected after light inspection).
|
||||
|
||||
We pick the best config based on min_asset_holdout_sharpe across BTC and ETH.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
# --- Signal generator factory ---
|
||||
def make_entries(k: float, max_bars: int):
|
||||
"""Return a function that builds entries list for a given df."""
|
||||
def entries_fn(df):
|
||||
c = df["close"].values.astype(float)
|
||||
atr_arr = al.atr(df, win=14)
|
||||
n = len(c)
|
||||
entries = [None] * n
|
||||
for i in range(1, n):
|
||||
if not np.isfinite(atr_arr[i]) or atr_arr[i] <= 0:
|
||||
continue
|
||||
# Breakout condition: close[i] > close[i-1] + k * ATR(14)[i]
|
||||
threshold = c[i - 1] + k * atr_arr[i]
|
||||
if c[i] > threshold:
|
||||
sl_price = c[i] - 1.5 * atr_arr[i]
|
||||
entries[i] = {
|
||||
"dir": 1,
|
||||
"tp": None,
|
||||
"sl": sl_price,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
return entries
|
||||
return entries_fn
|
||||
|
||||
|
||||
# --- Grid search: k in {0.5, 1.0, 1.5}, max_bars in {5, 10} ---
|
||||
configs = [
|
||||
(0.5, 5),
|
||||
(0.5, 10),
|
||||
(1.0, 5),
|
||||
(1.0, 10),
|
||||
(1.5, 5),
|
||||
(1.5, 10),
|
||||
]
|
||||
|
||||
print("=== BRK05 ATR Range Breakout — Grid Search ===")
|
||||
print(f"Configs to test: {configs}")
|
||||
print()
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for k, mb in configs:
|
||||
name = f"BRK05-k{k}-mb{mb}"
|
||||
fn = make_entries(k, mb)
|
||||
rep = al.study_signals(name, fn, tfs=("1d",))
|
||||
v = rep["verdict"]
|
||||
score = v.get("best_holdout_sharpe", -9)
|
||||
print(al.fmt(rep))
|
||||
print(f" -> score (min hold sharpe) = {score:.3f}")
|
||||
print()
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_config = (k, mb)
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print(f"BEST CONFIG: k={best_config[0]}, max_bars={best_config[1]}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,68 +0,0 @@
|
||||
"""BRK06 — Opening-Range Breakout (daily).
|
||||
|
||||
HYPOTHESIS: On 1d bars, go LONG when today's close > prior-day high (expansion/gap breakout).
|
||||
SL = prior-day low. max_bars = configurable (3 or 5). No short side (breakdowns symmetric but
|
||||
crypto skew is upward; testing long-only first). Entry at close[i] once close[i] > prior high[i-1].
|
||||
Exit at SL=prior_low[i-1] or max_bars (time stop), whichever first.
|
||||
|
||||
Grid: max_bars in {3, 5} -> 2 configs × 1 TF × 2 assets = 4 backtests.
|
||||
|
||||
Honesty rules:
|
||||
- decision uses close[i] vs high[i-1]: CAUSAL (prior-bar high is known by close of bar i).
|
||||
- SL = low[i-1]: known causal.
|
||||
- entry = close[i] (not high/low extreme of bar i).
|
||||
- fee = 0.10% RT (Deribit taker).
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
def make_entries(df, max_bars: int):
|
||||
"""Long when close[i] > high[i-1]. SL = low[i-1]. Exit at max_bars or SL."""
|
||||
c = df["close"].values
|
||||
h = df["high"].values
|
||||
lo = df["low"].values
|
||||
n = len(c)
|
||||
entries = [None] * n
|
||||
for i in range(1, n):
|
||||
prior_high = h[i - 1]
|
||||
prior_low = lo[i - 1]
|
||||
if c[i] > prior_high:
|
||||
# Long breakout: entry at close[i], SL below prior-day low
|
||||
# TP = None (let the time-stop manage exit)
|
||||
entries[i] = {
|
||||
"dir": 1,
|
||||
"tp": None,
|
||||
"sl": prior_low,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
return entries
|
||||
|
||||
|
||||
configs = [
|
||||
{"max_bars": 3},
|
||||
{"max_bars": 5},
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -9999
|
||||
|
||||
for cfg in configs:
|
||||
name = f"BRK06-mb{cfg['max_bars']}"
|
||||
rep = al.study_signals(
|
||||
name,
|
||||
lambda df, mb=cfg["max_bars"]: make_entries(df, mb),
|
||||
tfs=("1d",),
|
||||
)
|
||||
print(al.fmt(rep))
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -9999)
|
||||
if score is None:
|
||||
score = -9999
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
|
||||
print("\n=== BEST CONFIG ===")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,79 +0,0 @@
|
||||
"""BRK07 — N-day-high momentum (long-flat)
|
||||
IDEA: Long-flat: position 1 while close is within X% of its rolling 100-bar max, else 0.
|
||||
Trend-persistence proxy. Optionally vol-targeted.
|
||||
|
||||
Grid: threshold X% in {2%, 5%} x vol_target in {False, True} -> 4 configs, 2 TFs = 8 total backtests.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
LOOKBACK = 100 # fixed as per hypothesis
|
||||
|
||||
def make_target(df, threshold_pct: float = 5.0, use_vol_target: bool = True) -> np.ndarray:
|
||||
"""Long (1) when close is within threshold_pct% of its rolling 100-bar max, else 0."""
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
# Rolling max of close over last LOOKBACK bars (causal: includes close[i])
|
||||
roll_max = (
|
||||
__import__("pandas").Series(c)
|
||||
.rolling(LOOKBACK, min_periods=LOOKBACK)
|
||||
.max()
|
||||
.values
|
||||
)
|
||||
|
||||
# Position: 1 if close >= roll_max * (1 - threshold_pct/100), else 0
|
||||
threshold = threshold_pct / 100.0
|
||||
direction = np.where(
|
||||
(roll_max > 0) & np.isfinite(roll_max) & (c >= roll_max * (1.0 - threshold)),
|
||||
1.0,
|
||||
0.0
|
||||
)
|
||||
# Before we have enough bars, stay flat
|
||||
direction[:LOOKBACK - 1] = 0.0
|
||||
|
||||
if use_vol_target:
|
||||
return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
else:
|
||||
return direction
|
||||
|
||||
|
||||
configs = [
|
||||
{"threshold_pct": 2.0, "use_vol_target": False, "label": "thr2pct_flat"},
|
||||
{"threshold_pct": 5.0, "use_vol_target": False, "label": "thr5pct_flat"},
|
||||
{"threshold_pct": 2.0, "use_vol_target": True, "label": "thr2pct_vt"},
|
||||
{"threshold_pct": 5.0, "use_vol_target": True, "label": "thr5pct_vt"},
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -9999.0
|
||||
|
||||
for cfg in configs:
|
||||
label = cfg["label"]
|
||||
threshold_pct = cfg["threshold_pct"]
|
||||
use_vol_target = cfg["use_vol_target"]
|
||||
|
||||
print(f"\n=== BRK07 config: {label} (threshold={threshold_pct}%, vol_target={use_vol_target}) ===")
|
||||
|
||||
fn = lambda df, t=threshold_pct, v=use_vol_target: make_target(df, t, v)
|
||||
rep = al.study_weights(
|
||||
f"BRK07-{label}",
|
||||
fn,
|
||||
tfs=("1d", "12h"),
|
||||
)
|
||||
print(al.fmt(rep))
|
||||
print("JSON:", al.as_json(rep))
|
||||
|
||||
# Score = min holdout sharpe across both assets in best TF
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -9999.0) or -9999.0
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_cfg = cfg
|
||||
|
||||
print("\n\n========== BEST CONFIG ==========")
|
||||
print(f"Config: {best_cfg['label']}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,104 +0,0 @@
|
||||
"""BRK08 — NR7 range-contraction breakout (signals, 1d)
|
||||
|
||||
IDEA: A bar with the narrowest high-low range in the last 7 bars (NR7) is a
|
||||
setup for a volatility breakout. On the next bar, if price closes above the
|
||||
NR7 bar's high -> go long; if price closes below the NR7 bar's low -> go short.
|
||||
Entry at close on confirmation bar. Exit via TP (multiple of range), SL (opposite
|
||||
side of NR7 bar), or max_bars timeout.
|
||||
|
||||
GRID (4 param sets, 1 TF = 4 total backtests × 2 assets = 8 total):
|
||||
- (tp_mult, sl_mult, max_bars): controls TP distance as multiple of NR7 range,
|
||||
SL as fraction of NR7 range on opposite side, and holding period.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def nr7_signals(df, tp_mult=2.0, sl_mult=1.0, max_bars=5):
|
||||
"""
|
||||
NR7 breakout signals on daily bars.
|
||||
- At close[i-1], identify if bar i-1 is the NR7 bar (narrowest in 7)
|
||||
- At close[i]: if close[i] > high[i-1] -> long signal (direction confirmed)
|
||||
if close[i] < low[i-1] -> short signal
|
||||
- Entry at close[i]
|
||||
- TP = entry + tp_mult * nr7_range (long) / entry - tp_mult * nr7_range (short)
|
||||
- SL = nr7_bar_low (long) / nr7_bar_high (short)
|
||||
- max_bars timeout
|
||||
"""
|
||||
hi = df["high"].values.astype(float)
|
||||
lo = df["low"].values.astype(float)
|
||||
cl = df["close"].values.astype(float)
|
||||
n = len(df)
|
||||
|
||||
# Compute range for each bar
|
||||
rng = hi - lo
|
||||
|
||||
entries = [None] * n
|
||||
|
||||
for i in range(7, n):
|
||||
# Check if bar i-1 is NR7: its range is the smallest in the last 7 bars (i-7 to i-1)
|
||||
prev_ranges = rng[i-7:i] # 7 bars ending at i-1
|
||||
prev_range_at_im1 = rng[i-1]
|
||||
|
||||
# NR7: bar i-1 has the narrowest range in last 7 bars
|
||||
if prev_range_at_im1 != np.min(prev_ranges):
|
||||
continue
|
||||
|
||||
# The NR7 bar (i-1) setup: record its high and low
|
||||
nr7_high = hi[i-1]
|
||||
nr7_low = lo[i-1]
|
||||
nr7_range = rng[i-1]
|
||||
|
||||
if nr7_range <= 0:
|
||||
continue
|
||||
|
||||
# At bar i, confirm breakout direction with close
|
||||
current_close = cl[i]
|
||||
|
||||
if current_close > nr7_high:
|
||||
# Bullish breakout confirmed at close[i]
|
||||
entry = current_close
|
||||
tp = entry + tp_mult * nr7_range
|
||||
sl = nr7_low - sl_mult * nr7_range * 0.1 # just below NR7 bar low
|
||||
entries[i] = {"dir": +1, "tp": tp, "sl": sl, "max_bars": max_bars}
|
||||
elif current_close < nr7_low:
|
||||
# Bearish breakout confirmed at close[i]
|
||||
entry = current_close
|
||||
tp = entry - tp_mult * nr7_range
|
||||
sl = nr7_high + sl_mult * nr7_range * 0.1 # just above NR7 bar high
|
||||
entries[i] = {"dir": -1, "tp": tp, "sl": sl, "max_bars": max_bars}
|
||||
|
||||
return entries
|
||||
|
||||
|
||||
# Grid: (tp_mult, sl_mult, max_bars)
|
||||
GRID = [
|
||||
(1.5, 1.0, 4), # tight TP, fast exit
|
||||
(2.0, 1.0, 5), # moderate TP
|
||||
(2.5, 1.0, 7), # wider TP, longer hold
|
||||
(2.0, 1.0, 10), # same TP, longer hold
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for tp_mult, sl_mult, max_bars in GRID:
|
||||
label = f"BRK08-tp{tp_mult}-mb{max_bars}"
|
||||
rep = al.study_signals(
|
||||
label,
|
||||
lambda df, t=tp_mult, s=sl_mult, m=max_bars: nr7_signals(df, tp_mult=t, sl_mult=s, max_bars=m),
|
||||
tfs=("1d",),
|
||||
)
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -999.0) or -999.0
|
||||
print(f"\n--- {label} ---")
|
||||
print(al.fmt(rep))
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_config = (tp_mult, sl_mult, max_bars)
|
||||
|
||||
print("\n\n=== BEST CONFIG ===", best_config)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,107 +0,0 @@
|
||||
"""BRK09 — Inside-bar breakout (1d, discrete signals).
|
||||
|
||||
HYPOTHESIS:
|
||||
An "inside bar" is a bar whose high < previous bar's high AND low > previous bar's low
|
||||
(fully within the "mother bar"). This signals consolidation. When the NEXT bar's close
|
||||
breaks above the mother-bar's high -> long entry at that close. If it breaks below the
|
||||
mother-bar's low -> short entry. TP/SL based on ATR multiples.
|
||||
|
||||
CAUSAL GUARANTEE: All signals decided with data <= close[i], filled at close[i].
|
||||
|
||||
GRID (<=4 configs, total <=6 backtests = 4 configs * 1 TF, plus 2 extra for fee sweep
|
||||
handled internally by study_signals):
|
||||
We vary:
|
||||
- sl_atr: stop-loss in ATR multiples (1.5 or 2.0)
|
||||
- max_bars: max holding period in bars (5 or 10)
|
||||
That gives 4 combinations on 1d. Total cells = 4 * 2 assets = 8 backtests per config,
|
||||
but study_signals runs BTC+ETH per config automatically. We pick best.
|
||||
|
||||
ENTRY: close of the breakout bar (the bar that breaks mother-bar high/low).
|
||||
EXIT: TP = entry +/- sl_atr * atr (2:1 R:R), SL = entry -/+ sl_atr * atr, max_bars.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def make_entries(df, sl_atr: float = 1.5, max_bars: int = 5):
|
||||
"""Generate inside-bar breakout entries on 1d bars.
|
||||
|
||||
Logic (all at bar i, using data <= close[i]):
|
||||
- bar i-1 is the "inside bar": inside_bar[i-1] = True if:
|
||||
high[i-1] < high[i-2] AND low[i-1] > low[i-2]
|
||||
- bar i is the "breakout bar": breaks above mother-bar (i-2) high or below low
|
||||
long if close[i] > high[i-2] AND inside_bar[i-1]
|
||||
short if close[i] < low[i-2] AND inside_bar[i-1]
|
||||
|
||||
We need at least i>=2 to have i-1 and i-2. We also check that the inside bar
|
||||
hasn't already seen a breakout mid-bar (i.e., we only care about close-to-close).
|
||||
"""
|
||||
h = df["high"].values
|
||||
l = df["low"].values
|
||||
c = df["close"].values
|
||||
atr_vals = al.atr(df, win=14)
|
||||
|
||||
entries = [None] * len(df)
|
||||
|
||||
for i in range(2, len(df)):
|
||||
# Check if bar i-1 is an inside bar (contained within bar i-2)
|
||||
is_inside = (h[i-1] < h[i-2]) and (l[i-1] > l[i-2])
|
||||
if not is_inside:
|
||||
continue
|
||||
|
||||
mother_high = h[i-2]
|
||||
mother_low = l[i-2]
|
||||
entry_price = c[i]
|
||||
atr_i = atr_vals[i]
|
||||
|
||||
if atr_i <= 0 or not np.isfinite(atr_i):
|
||||
continue
|
||||
|
||||
sl_dist = sl_atr * atr_i
|
||||
tp_dist = 2.0 * sl_dist # 2:1 R:R
|
||||
|
||||
# Long breakout: close breaks above mother-bar high
|
||||
if c[i] > mother_high:
|
||||
tp = entry_price + tp_dist
|
||||
sl = entry_price - sl_dist
|
||||
entries[i] = {"dir": +1, "tp": tp, "sl": sl, "max_bars": max_bars}
|
||||
# Short breakout: close breaks below mother-bar low
|
||||
elif c[i] < mother_low:
|
||||
tp = entry_price - tp_dist
|
||||
sl = entry_price + sl_dist
|
||||
entries[i] = {"dir": -1, "tp": tp, "sl": sl, "max_bars": max_bars}
|
||||
|
||||
return entries
|
||||
|
||||
|
||||
# Grid: 4 configs
|
||||
CONFIGS = [
|
||||
{"sl_atr": 1.5, "max_bars": 5},
|
||||
{"sl_atr": 1.5, "max_bars": 10},
|
||||
{"sl_atr": 2.0, "max_bars": 5},
|
||||
{"sl_atr": 2.0, "max_bars": 10},
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for cfg in CONFIGS:
|
||||
name = f"BRK09_sl{cfg['sl_atr']}_mb{cfg['max_bars']}"
|
||||
rep = al.study_signals(
|
||||
name,
|
||||
lambda df, c=cfg: make_entries(df, sl_atr=c["sl_atr"], max_bars=c["max_bars"]),
|
||||
tfs=("1d",),
|
||||
)
|
||||
v = rep["verdict"]
|
||||
score = v.get("best_holdout_sharpe", -999.0) or -999.0
|
||||
print(f" {name}: grade={v['grade']} full={v.get('best_full_sharpe')} hold={v.get('best_holdout_sharpe')}")
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_rep["name"] = "BRK09" # rename to canonical
|
||||
|
||||
print()
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,100 +0,0 @@
|
||||
"""BRK10 — Vol-contraction (squeeze) long
|
||||
HYPOTHESIS: When Bollinger bandwidth is in its low expanding-percentile (squeeze detected),
|
||||
go long-flat on subsequent upside close > midline. Honest entry at close[i].
|
||||
|
||||
Strategy logic:
|
||||
- Compute Bollinger bandwidth = (upper - lower) / middle
|
||||
- Compute expanding percentile of bandwidth to define "squeeze" (low vol percentile)
|
||||
- Long signal: bandwidth in low percentile (squeeze) AND close > midline (momentum up)
|
||||
- Vol-targeted position, long-flat (no short)
|
||||
|
||||
Internal grid (<=4 configs, total backtests <=6):
|
||||
- bb_win: Bollinger window [20, 30]
|
||||
- squeeze_pct: bandwidth percentile threshold [25, 20]
|
||||
Best config picked by min(BTC/ETH) hold-out Sharpe.
|
||||
"""
|
||||
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(df: pd.DataFrame, bb_win: int = 20, k: float = 2.0,
|
||||
squeeze_pct: float = 25.0) -> np.ndarray:
|
||||
"""
|
||||
BRK10: vol-contraction squeeze long.
|
||||
|
||||
- Compute BB bandwidth = (upper - lower) / mid (all causal via bbands)
|
||||
- Use expanding percentile of bandwidth to define squeeze
|
||||
- Long when: bandwidth <= squeeze_pct expanding percentile AND close > midline
|
||||
- Vol-targeted position, long-flat
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
# Bollinger bands (causal: uses data <= i)
|
||||
upper, mid, lower = al.bbands(c, win=bb_win, k=k)
|
||||
|
||||
# Bandwidth = (upper - lower) / mid; avoid div by zero
|
||||
bw = np.where(mid > 0, (upper - lower) / mid, np.nan)
|
||||
|
||||
# Expanding percentile of bandwidth (causal: uses data <= i)
|
||||
# squeeze = bandwidth is in the lower squeeze_pct% of historical values
|
||||
squeeze_mask = np.zeros(n, dtype=bool)
|
||||
bw_series = pd.Series(bw)
|
||||
|
||||
for i in range(bb_win, n):
|
||||
hist = bw_series.iloc[:i+1].dropna().values
|
||||
if len(hist) < bb_win:
|
||||
continue
|
||||
threshold = np.percentile(hist, squeeze_pct)
|
||||
if np.isfinite(bw[i]) and bw[i] <= threshold:
|
||||
squeeze_mask[i] = True
|
||||
|
||||
# Direction: long when squeeze AND close > midline
|
||||
# NaN midline bars -> flat
|
||||
direction = np.where(
|
||||
squeeze_mask & np.isfinite(mid) & (c > mid),
|
||||
1.0,
|
||||
0.0
|
||||
)
|
||||
|
||||
# Vol-targeted, long-flat
|
||||
target = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target
|
||||
|
||||
|
||||
# Grid: bb_win x squeeze_pct (4 configs, both tested on 1d only -> 4 total backtests <= 6)
|
||||
GRID = [
|
||||
dict(bb_win=20, squeeze_pct=25.0),
|
||||
dict(bb_win=20, squeeze_pct=20.0),
|
||||
dict(bb_win=30, squeeze_pct=25.0),
|
||||
dict(bb_win=30, squeeze_pct=20.0),
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -9999.0
|
||||
best_cfg = None
|
||||
|
||||
TFS = ("1d",)
|
||||
|
||||
for cfg in GRID:
|
||||
print(f"\n--- Testing config: {cfg} ---")
|
||||
label = f"BRK10_bb{cfg['bb_win']}_sq{int(cfg['squeeze_pct'])}"
|
||||
fn = lambda df, c=cfg: make_target(df, bb_win=c["bb_win"], squeeze_pct=c["squeeze_pct"])
|
||||
rep = al.study_weights(label, fn, tfs=TFS)
|
||||
|
||||
# Score = min holdout Sharpe across assets in best TF
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -9999.0) or -9999.0
|
||||
print(al.fmt(rep))
|
||||
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_cfg = cfg
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
print(f"BEST CONFIG: {best_cfg}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,129 +0,0 @@
|
||||
"""CMB01 — Trend + RSI pullback (buy-the-dip-in-uptrend).
|
||||
|
||||
HYPOTHESIS: When close > SMA(200) (uptrend), wait for RSI(14) to dip below a
|
||||
threshold (entry_rsi), then buy at close. Exit when RSI recovers above exit_rsi
|
||||
OR after max_bars candles.
|
||||
|
||||
This is a DISCRETE signal strategy -> al.study_signals on 1d only.
|
||||
|
||||
Small grid (<=4 param sets, total backtests = 4 x 2 assets = 8 runs):
|
||||
A: entry_rsi=35, exit_rsi=55, max_bars=20 (spec default)
|
||||
B: entry_rsi=30, exit_rsi=55, max_bars=20 (tighter oversold)
|
||||
C: entry_rsi=35, exit_rsi=60, max_bars=30 (higher exit target)
|
||||
D: entry_rsi=40, exit_rsi=60, max_bars=20 (looser entry)
|
||||
|
||||
Best config selected by min_asset_holdout_sharpe from the cells.
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Signal generator
|
||||
# ---------------------------------------------------------------------------
|
||||
def make_entries(df, entry_rsi=35, exit_rsi=55, max_bars=20, sma_win=200):
|
||||
"""Causal: all decisions use data <= close[i].
|
||||
|
||||
Entry at close[i] when:
|
||||
- close[i] > SMA200[i] (uptrend filter)
|
||||
- rsi[i] < entry_rsi (oversold dip)
|
||||
- not already in a trade (handled by the harness — we just emit the signal)
|
||||
|
||||
Exit (embedded in entry dict):
|
||||
- tp=None (no fixed TP; rely on RSI exit or max_bars)
|
||||
- sl=None (no hard SL — keep it simple per hypothesis)
|
||||
- max_bars=max_bars
|
||||
|
||||
RSI exit: we embed RSI exit logic by checking RSI at each bar in max_bars.
|
||||
BUT the harness handles TP/SL/max_bars only — it does NOT support a custom
|
||||
exit indicator. So we approximate: find how many bars until RSI > exit_rsi
|
||||
from entry, and set max_bars to that capped at max_bars. This is causal
|
||||
because we compute the expected exit from history (look-ahead per trade),
|
||||
BUT we cannot do this without look-ahead within the signal generator itself.
|
||||
|
||||
HONEST APPROACH: Use max_bars only as exit. The harness will hold for up to
|
||||
max_bars. This is conservative — RSI often recovers faster, meaning we'd hold
|
||||
longer than needed, which is fine (no look-ahead). Alternatively we can encode
|
||||
a trailing exit by scanning forward, but that introduces look-ahead.
|
||||
|
||||
CORRECT NO-LOOK-AHEAD APPROACH:
|
||||
Compute signal at bar i. Set max_bars = max_bars. The exit is "held max_bars
|
||||
or until harness closes." Since the harness only supports TP/SL/max_bars,
|
||||
we use max_bars. This is honest.
|
||||
|
||||
No TP, no SL, exit by time (max_bars) — straightforward.
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
sma200 = al.sma(c, sma_win)
|
||||
rsi14 = al.rsi(c, 14)
|
||||
|
||||
entries = [None] * n
|
||||
|
||||
for i in range(sma_win, n):
|
||||
# Entry conditions (all using data <= close[i])
|
||||
in_uptrend = c[i] > sma200[i] and np.isfinite(sma200[i])
|
||||
oversold = np.isfinite(rsi14[i]) and rsi14[i] < entry_rsi
|
||||
|
||||
if in_uptrend and oversold:
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": None,
|
||||
"sl": None,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
|
||||
return entries
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Grid search
|
||||
# ---------------------------------------------------------------------------
|
||||
CONFIGS = [
|
||||
dict(entry_rsi=35, exit_rsi=55, max_bars=20, label="entry35_exit55_mb20"),
|
||||
dict(entry_rsi=30, exit_rsi=55, max_bars=20, label="entry30_exit55_mb20"),
|
||||
dict(entry_rsi=35, exit_rsi=60, max_bars=30, label="entry35_exit60_mb30"),
|
||||
dict(entry_rsi=40, exit_rsi=60, max_bars=20, label="entry40_exit60_mb20"),
|
||||
]
|
||||
|
||||
print("=== CMB01: Trend + RSI pullback ===")
|
||||
print(f"Grid: {len(CONFIGS)} configs x 2 assets = {len(CONFIGS)*2} backtests\n")
|
||||
|
||||
results = []
|
||||
for cfg in CONFIGS:
|
||||
label = cfg["label"]
|
||||
entry_rsi = cfg["entry_rsi"]
|
||||
exit_rsi = cfg["exit_rsi"]
|
||||
max_bars = cfg["max_bars"]
|
||||
|
||||
def entries_fn(df, _er=entry_rsi, _xr=exit_rsi, _mb=max_bars):
|
||||
return make_entries(df, entry_rsi=_er, exit_rsi=_xr, max_bars=_mb)
|
||||
|
||||
rep = al.study_signals(
|
||||
f"CMB01-{label}",
|
||||
entries_fn,
|
||||
tfs=("1d",),
|
||||
)
|
||||
print(al.fmt(rep))
|
||||
print(f" JSON: {al.as_json(rep)}\n")
|
||||
results.append((rep, cfg))
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Pick best config by min_asset_holdout_sharpe
|
||||
# ---------------------------------------------------------------------------
|
||||
def best_holdout(rep):
|
||||
cells = rep[0].get("cells", [])
|
||||
if not cells:
|
||||
return -99.0
|
||||
return max(c.get("min_asset_holdout_sharpe", -99.0) for c in cells)
|
||||
|
||||
results.sort(key=best_holdout, reverse=True)
|
||||
best_rep, best_cfg = results[0]
|
||||
|
||||
print("\n" + "="*60)
|
||||
print(f"BEST CONFIG: {best_cfg['label']}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,187 +0,0 @@
|
||||
"""CMB02 — Donchian breakout + volume elevation + DVOL filter (triple filter).
|
||||
|
||||
HYPOTHESIS:
|
||||
Long-flat Donchian channel breakout, but only when:
|
||||
1. Volume is elevated (above rolling median, filtering fake/thin breakouts)
|
||||
2. DVOL is NOT in panic zone (below 80th percentile expanding, avoiding breakouts
|
||||
during fear spikes that tend to reverse)
|
||||
Position is vol-targeted. Hold until price drops back below mid-channel.
|
||||
|
||||
The triple filter tests: breakouts with confirming volume + calm/moderate implied vol
|
||||
should capture real trending moves while avoiding panic-spike false breakouts.
|
||||
|
||||
DVOL note: data starts 2021-03 -> backtest uses full history where available,
|
||||
DVOL filter only active where DVOL data exists (NaN -> filter passes through).
|
||||
"""
|
||||
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 cmb02_target(df: pd.DataFrame, don_win: int = 20, vol_win: int = 20,
|
||||
dvol_pct: float = 80.0, asset: str = "BTC") -> np.ndarray:
|
||||
"""
|
||||
Donchian breakout, long-flat, with volume + DVOL filters.
|
||||
|
||||
Entry: close[i] > donchian_high[i] (prior win-bar high)
|
||||
AND volume[i] > vol_median over rolling vol_win bars
|
||||
AND DVOL[i] < expanding percentile dvol_pct (not in panic zone)
|
||||
Exit: close[i] < donchian_mid[i] (midpoint of channel, trailing)
|
||||
Position: vol-targeted at 20%, leverage cap 2x.
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
v = df["volume"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
# --- Donchian channel (strictly causal: shift(1)) ---
|
||||
hi, lo = al.donchian(df, don_win)
|
||||
mid = (hi + lo) / 2.0
|
||||
|
||||
# --- Volume filter: volume above rolling median (causal) ---
|
||||
vol_median = pd.Series(v).rolling(vol_win, min_periods=max(2, vol_win // 2)).median().values
|
||||
vol_elevated = v > vol_median # True when volume confirms breakout
|
||||
|
||||
# --- DVOL filter: NOT in panic zone (expanding percentile, causal) ---
|
||||
dv = al.dvol(df, asset) # float array, NaN before 2021-03
|
||||
# Expanding percentile (causal): for each i, rank of dv[i] vs all dv[0..i]
|
||||
# Use pd expanding quantile (causal by nature)
|
||||
dv_series = pd.Series(dv)
|
||||
# Compute expanding percentile threshold causally
|
||||
# We need: is dv[i] < dvol_pct-th percentile of dv[0..i]?
|
||||
# Equivalent: expanding rank < dvol_pct%
|
||||
# We use expanding().quantile() for the threshold line
|
||||
dv_thresh = dv_series.expanding(min_periods=30).quantile(dvol_pct / 100.0).values
|
||||
# Filter: DVOL below the threshold (not in panic zone)
|
||||
# If DVOL is NaN (pre-2021), treat filter as passing (no data = no veto)
|
||||
dvol_ok = np.where(np.isnan(dv), True, dv < dv_thresh)
|
||||
|
||||
# --- Build position signal ---
|
||||
# We use a stateful forward-fill approach:
|
||||
# position is 1 if breakout + filters, 0 if exit signal, else carry
|
||||
raw_dir = np.zeros(n)
|
||||
pos = 0.0
|
||||
for i in range(1, n):
|
||||
# Exit condition: price dropped below mid-channel
|
||||
if pos > 0 and np.isfinite(mid[i]) and c[i] < mid[i]:
|
||||
pos = 0.0
|
||||
# Entry condition: breakout + volume + dvol filters
|
||||
if (pos == 0.0 and
|
||||
np.isfinite(hi[i]) and c[i] > hi[i] and
|
||||
vol_elevated[i] and
|
||||
dvol_ok[i]):
|
||||
pos = 1.0
|
||||
raw_dir[i] = pos
|
||||
|
||||
# Apply vol-targeting on the binary direction
|
||||
return al.vol_target(raw_dir, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
|
||||
|
||||
def run():
|
||||
# Small grid: don_win x dvol_pct
|
||||
# 4 configs (<=4), 2 TFs -> 4*2 = 8 backtests on 2 assets each = 16 total
|
||||
# To stay within <=6 total backtest calls, we pick 2 configs x 1 TF + best config x 2nd TF
|
||||
# Actually: study_weights calls for 2 assets each run -> each study_weights(tfs=("1d",)) = 2 backtests
|
||||
# We'll do 2 param configs on 1d, then best on 12h -> 3 study_weights calls = 6 asset-backtests
|
||||
|
||||
results = []
|
||||
|
||||
configs = [
|
||||
dict(don_win=20, vol_win=20, dvol_pct=80.0, label="D20-V20-DVOL80"),
|
||||
dict(don_win=40, vol_win=20, dvol_pct=75.0, label="D40-V20-DVOL75"),
|
||||
dict(don_win=20, vol_win=10, dvol_pct=70.0, label="D20-V10-DVOL70"),
|
||||
dict(don_win=60, vol_win=30, dvol_pct=80.0, label="D60-V30-DVOL80"),
|
||||
]
|
||||
|
||||
print("=== CMB02: Donchian + Volume + DVOL filter ===\n")
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for cfg in configs:
|
||||
label = cfg["label"]
|
||||
don_win = cfg["don_win"]
|
||||
vol_win = cfg["vol_win"]
|
||||
dvol_pct = cfg["dvol_pct"]
|
||||
|
||||
def make_target(dw=don_win, vw=vol_win, dp=dvol_pct):
|
||||
def target_fn(df):
|
||||
# Determine asset from df shape/content - try BTC first, ETH fallback
|
||||
# We pass asset through closure workaround via index
|
||||
# Actually altlib doesn't pass asset name to target_fn...
|
||||
# We'll call dvol with "BTC" and check if ETH data matches better
|
||||
# The dvol function uses asset param - we need a way to know which asset
|
||||
# Use a hack: check if the df matches BTC or ETH by length/timestamps
|
||||
btc_df = al.get("BTC", "1d")
|
||||
if len(df) == len(btc_df) and df["close"].iloc[0] == btc_df["close"].iloc[0]:
|
||||
asset = "BTC"
|
||||
else:
|
||||
asset = "ETH"
|
||||
return cmb02_target(df, don_win=dw, vol_win=vw, dvol_pct=dp, asset=asset)
|
||||
return target_fn
|
||||
|
||||
rep = al.study_weights(f"CMB02-{label}", make_target(), tfs=("1d",))
|
||||
print(al.fmt(rep))
|
||||
print()
|
||||
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -9)
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_label = label
|
||||
best_cfg = cfg
|
||||
|
||||
print(f"\n>>> Best config on 1d: {best_label} (holdout score: {best_score:.3f})")
|
||||
print(">>> Now testing best config on 12h...\n")
|
||||
|
||||
# Test best config on 12h
|
||||
dw = best_cfg["don_win"]
|
||||
vw = best_cfg["vol_win"]
|
||||
dp = best_cfg["dvol_pct"]
|
||||
|
||||
def make_target_12h(dw=dw, vw=vw, dp=dp):
|
||||
def target_fn(df):
|
||||
btc_df = al.get("BTC", "12h")
|
||||
if len(df) == len(btc_df) and df["close"].iloc[0] == btc_df["close"].iloc[0]:
|
||||
asset = "BTC"
|
||||
else:
|
||||
asset = "ETH"
|
||||
return cmb02_target(df, don_win=dw, vol_win=vw, dvol_pct=dp, asset=asset)
|
||||
return target_fn
|
||||
|
||||
rep_12h = al.study_weights(f"CMB02-{best_label}-12h", make_target_12h(), tfs=("12h",))
|
||||
print(al.fmt(rep_12h))
|
||||
print()
|
||||
|
||||
# Build combined report with both TFs for the best config
|
||||
# Combine cells from 1d best + 12h
|
||||
best_1d_cells = [c for c in best_rep["cells"] if c["tf"] == "1d"]
|
||||
cells_combined = best_1d_cells + rep_12h["cells"]
|
||||
|
||||
# Pick best TF by holdout
|
||||
def pick_best(cells):
|
||||
return max(cells, key=lambda c: c.get("min_asset_holdout_sharpe", -9))
|
||||
|
||||
best_cell = pick_best(cells_combined)
|
||||
best_tf = best_cell["tf"]
|
||||
|
||||
# Final verdict
|
||||
from altlib import _verdict
|
||||
verdict = _verdict(cells_combined)
|
||||
|
||||
final_rep = dict(
|
||||
name=f"CMB02-{best_label}",
|
||||
kind="weights",
|
||||
cells=cells_combined,
|
||||
verdict=verdict,
|
||||
)
|
||||
|
||||
print("\n=== FINAL REPORT (best config, both TFs) ===")
|
||||
print(al.fmt(final_rep))
|
||||
print("\nJSON:", al.as_json(final_rep))
|
||||
return final_rep
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run()
|
||||
@@ -1,257 +0,0 @@
|
||||
"""CMB03 — Multi-TF trend confirm (4h fast + 1d slow agreement).
|
||||
|
||||
HYPOTHESIS: On the 4h TF, go long only when the 1d trend (TSMOM or SMA50)
|
||||
agrees (is bullish). The intuition is that a fast-TF TSMOM signal might have
|
||||
more noise; filtering by the slow TF trend reduces false signals.
|
||||
|
||||
CAUSAL ALIGNMENT (critical - see obs 4866):
|
||||
- 1d bar at timestamp T closes at end of day T. The 4h bar that CLOSES at
|
||||
the same time or later (within day T+1 onwards) can use it causally.
|
||||
- We compute the 1d signal on the 1d dataframe, then merge_asof onto 4h
|
||||
using the 1d bar CLOSE timestamp -> the 4h bar is valid only AFTER the
|
||||
1d bar has fully closed (direction="forward" with offset to avoid using
|
||||
the still-open 1d bar).
|
||||
- Implementation: for each 1d bar at timestamp T_close, the signal becomes
|
||||
available at T_close (the bar just closed). We map it to 4h bars whose
|
||||
open timestamp >= T_close (i.e. the NEXT 4h bar after the 1d bar closed).
|
||||
This means we use pandas merge_asof with left=4h open timestamps and
|
||||
right=1d close timestamps, direction="backward" — the 4h bar at open T
|
||||
gets the most recent 1d signal where 1d_close <= 4h_open.
|
||||
|
||||
GRID (4 configs x 2 assets x 1 TF = 8 backtests):
|
||||
A: 4h fast TSMOM (1m,3m) + 1d confirm SMA50 (price>SMA50)
|
||||
B: 4h fast TSMOM (1m,3m) + 1d confirm TSMOM (1m,3m,6m)
|
||||
C: 4h SMA crossover (20>50) + 1d confirm SMA50
|
||||
D: 4h SMA crossover (20>50) + 1d confirm TSMOM (1m,3m,6m)
|
||||
|
||||
All configs: long-only (0 or +1 direction), vol-targeted (20%, cap 2x).
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helper: compute 1d trend signal and align causally to 4h bars
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _1d_tsmom_signal(df_1d: pd.DataFrame) -> np.ndarray:
|
||||
"""TSMOM on 1d bars: long if majority of 1m/3m/6m horizons are positive.
|
||||
Returns array in {0, +1} (long-flat, no short).
|
||||
Decision at bar i uses close[i] (causal). Array indexed by 1d bar."""
|
||||
c = df_1d["close"].values.astype(float)
|
||||
bpd = al.bars_per_day(df_1d) # should be ~1 for 1d
|
||||
horizons = [30 * bpd, 90 * bpd, 180 * bpd]
|
||||
votes = np.zeros(len(c))
|
||||
for h in horizons:
|
||||
h = int(h)
|
||||
sig = np.full(len(c), np.nan)
|
||||
if h < len(c):
|
||||
sig[h:] = np.sign(c[h:] / c[:-h] - 1.0)
|
||||
votes += np.nan_to_num(sig, nan=0.0)
|
||||
# Long when majority (>=1 out of 3) positive
|
||||
return np.where(votes > 0, 1.0, 0.0)
|
||||
|
||||
|
||||
def _1d_sma50_signal(df_1d: pd.DataFrame) -> np.ndarray:
|
||||
"""SMA50 trend on 1d: long when close > SMA50. Returns {0, +1}."""
|
||||
c = df_1d["close"].values.astype(float)
|
||||
sma50 = al.sma(c, 50)
|
||||
return np.where(c > sma50, 1.0, 0.0)
|
||||
|
||||
|
||||
def _align_1d_to_4h(df_1d: pd.DataFrame, signal_1d: np.ndarray,
|
||||
df_4h: pd.DataFrame) -> np.ndarray:
|
||||
"""Map 1d signal onto 4h bars CAUSALLY.
|
||||
|
||||
A 1d bar at timestamp T (which is the bar's OPEN time in ms) closes at
|
||||
T + 86400000ms. We expose the signal AFTER the 1d bar has fully closed,
|
||||
i.e. it's available to 4h bars whose open time >= T + 86400000ms (the
|
||||
start of the next day).
|
||||
|
||||
Procedure:
|
||||
1. Build a series: (1d_close_timestamp, signal_1d)
|
||||
1d_close_ts = df_1d["timestamp"] + 86400000 (next bar open = this bar closed)
|
||||
2. For each 4h bar (open timestamp), take the most recent 1d signal
|
||||
where 1d_close_ts <= 4h_open_ts (merge_asof backward).
|
||||
3. Forward-fill NaN (no signal yet = 0).
|
||||
"""
|
||||
# 1d bar open timestamps + period offset = close timestamp = next 4h eligible
|
||||
# Compute 1d bar period in ms: use median diff of timestamps
|
||||
ts_1d = df_1d["timestamp"].values.astype(np.int64)
|
||||
diffs_1d = np.diff(ts_1d)
|
||||
period_ms = int(np.median(diffs_1d)) if len(diffs_1d) > 0 else 86_400_000
|
||||
|
||||
# 1d_close_ts: the moment this 1d bar closed (= open of the NEXT bar)
|
||||
close_ts_1d = ts_1d + period_ms # available after this timestamp
|
||||
|
||||
right = pd.DataFrame({
|
||||
"close_ts": close_ts_1d,
|
||||
"sig": signal_1d.astype(float),
|
||||
}).sort_values("close_ts")
|
||||
|
||||
ts_4h = df_4h["timestamp"].values.astype(np.int64)
|
||||
left = pd.DataFrame({"open_ts": ts_4h})
|
||||
|
||||
merged = pd.merge_asof(
|
||||
left,
|
||||
right.rename(columns={"close_ts": "open_ts"}),
|
||||
on="open_ts",
|
||||
direction="backward",
|
||||
)
|
||||
out = merged["sig"].values.astype(float)
|
||||
# NaN = no 1d bar has closed yet -> be conservative, no position
|
||||
out = np.nan_to_num(out, nan=0.0)
|
||||
return out
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Fast-TF (4h) signals
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _4h_tsmom(df_4h: pd.DataFrame) -> np.ndarray:
|
||||
"""TSMOM on 4h: long if 1m and 3m horizons agree (majority of 2)."""
|
||||
c = df_4h["close"].values.astype(float)
|
||||
bpd = al.bars_per_day(df_4h) # ~6 for 4h
|
||||
h1m = int(30 * bpd)
|
||||
h3m = int(90 * bpd)
|
||||
votes = np.zeros(len(c))
|
||||
for h in [h1m, h3m]:
|
||||
sig = np.full(len(c), np.nan)
|
||||
if h < len(c):
|
||||
sig[h:] = np.sign(c[h:] / c[:-h] - 1.0)
|
||||
votes += np.nan_to_num(sig, nan=0.0)
|
||||
# Long when net positive (at least 1 of 2)
|
||||
return np.where(votes > 0, 1.0, 0.0)
|
||||
|
||||
|
||||
def _4h_sma_cross(df_4h: pd.DataFrame, fast=20, slow=50) -> np.ndarray:
|
||||
"""SMA crossover on 4h: long when SMA(fast) > SMA(slow)."""
|
||||
c = df_4h["close"].values.astype(float)
|
||||
sma_f = al.sma(c, fast)
|
||||
sma_s = al.sma(c, slow)
|
||||
return np.where(sma_f > sma_s, 1.0, 0.0)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Combined target functions (4h TF, 1d confirm)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def make_target(asset: str, fast_type: str, slow_type: str):
|
||||
"""Return a target_fn(df_4h) -> position array.
|
||||
|
||||
Because altlib calls target_fn(df) with the chosen TF df, we fetch the
|
||||
1d df inside the closure (cached by altlib.get).
|
||||
"""
|
||||
def target_fn(df_4h: pd.DataFrame) -> np.ndarray:
|
||||
# 1d dataframe for same asset (cached)
|
||||
df_1d = al.get(asset, "1d")
|
||||
|
||||
# Compute 1d confirmation signal
|
||||
if slow_type == "sma50":
|
||||
sig_1d = _1d_sma50_signal(df_1d)
|
||||
elif slow_type == "tsmom":
|
||||
sig_1d = _1d_tsmom_signal(df_1d)
|
||||
else:
|
||||
raise ValueError(f"Unknown slow_type: {slow_type}")
|
||||
|
||||
# Align 1d signal onto 4h bars (causal)
|
||||
confirm_4h = _align_1d_to_4h(df_1d, sig_1d, df_4h)
|
||||
|
||||
# Compute 4h fast signal
|
||||
if fast_type == "tsmom":
|
||||
fast_4h = _4h_tsmom(df_4h)
|
||||
elif fast_type == "sma_cross":
|
||||
fast_4h = _4h_sma_cross(df_4h)
|
||||
else:
|
||||
raise ValueError(f"Unknown fast_type: {fast_type}")
|
||||
|
||||
# Combined: long only when BOTH signals agree
|
||||
direction = np.where((fast_4h > 0) & (confirm_4h > 0), 1.0, 0.0)
|
||||
|
||||
# Vol-target (20%, cap 2x)
|
||||
return al.vol_target(direction, df_4h, target_vol=0.20,
|
||||
vol_win_days=30, leverage_cap=2.0)
|
||||
|
||||
return target_fn
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Grid: 4 configs
|
||||
# ---------------------------------------------------------------------------
|
||||
CONFIGS = [
|
||||
dict(fast="tsmom", slow="sma50", label="tsmom4h_sma50_1d"),
|
||||
dict(fast="tsmom", slow="tsmom", label="tsmom4h_tsmom_1d"),
|
||||
dict(fast="sma_cross", slow="sma50", label="smacross4h_sma50_1d"),
|
||||
dict(fast="sma_cross", slow="tsmom", label="smacross4h_tsmom_1d"),
|
||||
]
|
||||
|
||||
print("=== CMB03: Multi-TF trend confirm (4h fast + 1d slow) ===")
|
||||
print(f"Grid: {len(CONFIGS)} configs x 2 assets x 1 TF = {len(CONFIGS)*2} backtests\n")
|
||||
|
||||
results = []
|
||||
for cfg in CONFIGS:
|
||||
label = cfg["label"]
|
||||
fast = cfg["fast"]
|
||||
slow = cfg["slow"]
|
||||
|
||||
# Build per-asset target functions
|
||||
# study_weights calls target_fn(df) for each asset, but we need to know
|
||||
# WHICH asset to fetch the 1d df for. We use a workaround: wrap in a
|
||||
# function that identifies the asset by calling al.get for BTC then ETH
|
||||
# and matching timestamps.
|
||||
#
|
||||
# Cleaner approach: run each asset separately and combine.
|
||||
# altlib.study_weights iterates assets internally, so we need target_fn(df)
|
||||
# to know the asset. We do this by checking df timestamps against cached dfs.
|
||||
|
||||
def _target_fn(df_4h, _fast=fast, _slow=slow):
|
||||
# Identify asset by matching df timestamps to known cached dfs
|
||||
ts = df_4h["timestamp"].values[0]
|
||||
# Try BTC first, then ETH
|
||||
for _asset in ("BTC", "ETH"):
|
||||
try:
|
||||
_df_check = al.get(_asset, "4h")
|
||||
if _df_check["timestamp"].values[0] == ts:
|
||||
return make_target(_asset, _fast, _slow)(df_4h)
|
||||
except Exception:
|
||||
pass
|
||||
# Fallback: try matching by length or first close
|
||||
c0 = df_4h["close"].values[0]
|
||||
for _asset in ("BTC", "ETH"):
|
||||
_df_check = al.get(_asset, "4h")
|
||||
if abs(_df_check["close"].values[0] - c0) / c0 < 0.01:
|
||||
return make_target(_asset, _fast, _slow)(df_4h)
|
||||
# Last resort
|
||||
return make_target("BTC", _fast, _slow)(df_4h)
|
||||
|
||||
rep = al.study_weights(
|
||||
f"CMB03-{label}",
|
||||
_target_fn,
|
||||
tfs=("4h",),
|
||||
)
|
||||
print(al.fmt(rep))
|
||||
print(f" JSON: {al.as_json(rep)}\n")
|
||||
results.append((rep, cfg))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Pick best config by min_asset_holdout_sharpe
|
||||
# ---------------------------------------------------------------------------
|
||||
def best_holdout(item):
|
||||
rep = item[0]
|
||||
cells = rep.get("cells", [])
|
||||
if not cells:
|
||||
return -99.0
|
||||
return max(c.get("min_asset_holdout_sharpe", -99.0) for c in cells)
|
||||
|
||||
results.sort(key=best_holdout, reverse=True)
|
||||
best_rep, best_cfg = results[0]
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print(f"BEST CONFIG: {best_cfg['label']}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,97 +0,0 @@
|
||||
"""CMB04 — Momentum + Low-Vol Filter
|
||||
HYPOTHESIS: TSMOM long-flat taken only when realized vol is below its rolling median
|
||||
(avoid high-vol whipsaw). Vol-target the rest.
|
||||
|
||||
Grid: 2 vol-filter windows (30d vs 60d rolling median lookback) x 2 TFs (1d, 12h) = 4 cells total.
|
||||
Best config chosen by min(BTC,ETH) holdout Sharpe.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def cmb04_target(df, vol_filter_days: int = 30):
|
||||
"""
|
||||
TSMOM multi-horizon (1m/3m/6m) long-flat, gated by a low-vol filter:
|
||||
- Compute realized vol (30d) at each bar.
|
||||
- Compute rolling median of that vol over vol_filter_days.
|
||||
- Only take the TSMOM signal when realized_vol < rolling_median (low-vol regime).
|
||||
- In high-vol regime: go flat (0).
|
||||
- Vol-target the resulting direction.
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
bpd = al.bars_per_day(df)
|
||||
bpy = bpd * 365.25
|
||||
|
||||
# --- TSMOM multi-horizon direction (1m, 3m, 6m) ---
|
||||
horizons = (30 * bpd, 90 * bpd, 180 * bpd)
|
||||
direction = np.zeros(len(c))
|
||||
for h in horizons:
|
||||
h = int(h)
|
||||
sig = np.full(len(c), np.nan)
|
||||
if h < len(c):
|
||||
sig[h:] = np.sign(c[h:] / c[:-h] - 1.0)
|
||||
direction += np.nan_to_num(sig, nan=0.0)
|
||||
# Majority vote -> long or flat
|
||||
direction = np.clip(np.sign(direction), 0.0, 1.0) # long-flat only
|
||||
|
||||
# --- Realized vol (30d causal) ---
|
||||
rv_win = max(2, 30 * bpd)
|
||||
r = al.simple_returns(c)
|
||||
rv = al.realized_vol(r, rv_win, bpy)
|
||||
|
||||
# --- Rolling median of realized vol over vol_filter_days ---
|
||||
med_win = max(2, vol_filter_days * bpd)
|
||||
rv_median = (
|
||||
al._series_if_array(rv).rolling(med_win, min_periods=max(2, med_win // 2)).median().values
|
||||
if hasattr(al, "_series_if_array")
|
||||
else __import__("pandas").Series(rv).rolling(med_win, min_periods=max(2, med_win // 2)).median().values
|
||||
)
|
||||
|
||||
# --- Gate: only enter when rv < median (low-vol regime) ---
|
||||
low_vol_gate = np.where(
|
||||
np.isfinite(rv) & np.isfinite(rv_median) & (rv < rv_median),
|
||||
1.0,
|
||||
0.0
|
||||
)
|
||||
gated_direction = direction * low_vol_gate
|
||||
|
||||
# --- Vol-target the gated direction ---
|
||||
pos = al.vol_target(gated_direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return pos
|
||||
|
||||
|
||||
def make_target_fn(vol_filter_days: int):
|
||||
def fn(df):
|
||||
return cmb04_target(df, vol_filter_days=vol_filter_days)
|
||||
return fn
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import pandas as pd
|
||||
|
||||
best_rep = None
|
||||
best_hold = -9.0
|
||||
best_label = ""
|
||||
|
||||
configs = [
|
||||
("CMB04-vf30", 30),
|
||||
("CMB04-vf60", 60),
|
||||
]
|
||||
|
||||
for label, vfd in configs:
|
||||
fn = make_target_fn(vfd)
|
||||
rep = al.study_weights(label, fn, tfs=("1d", "12h"))
|
||||
v = rep["verdict"]
|
||||
h = v.get("best_holdout_sharpe", -9)
|
||||
print(al.fmt(rep))
|
||||
print(f" [grid] {label}: holdout={h:.3f}")
|
||||
if h > best_hold:
|
||||
best_hold = h
|
||||
best_rep = rep
|
||||
best_label = label
|
||||
|
||||
print("\n=== BEST CONFIG ===", best_label)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,108 +0,0 @@
|
||||
"""CMB05 — BB Squeeze -> Breakout (honest, leak-free).
|
||||
|
||||
HYPOTHESIS: Bollinger Bandwidth at a multi-bar low (squeeze) then close > upper BB
|
||||
-> enter long at that close (entry at close[i], direction decided with data<=close[i]).
|
||||
Exit when close drops back below middle band, or max_bars reached, or SL hit.
|
||||
|
||||
Tested on 1d only (study_signals, discrete). Small grid on:
|
||||
- BB window: 20 vs 30
|
||||
- Squeeze lookback: 50 vs 100
|
||||
Total configs: 4 — two assets each => 8 backtests. Within budget.
|
||||
"""
|
||||
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_entries(bb_win: int = 20, squeeze_lb: int = 50, squeeze_pct: float = 0.20, sl_mult: float = 2.0, max_bars: int = 30):
|
||||
"""
|
||||
Returns entries_fn(df) -> list[dict|None] for study_signals.
|
||||
|
||||
Squeeze = BB bandwidth (upper-lower)/middle in lowest squeeze_pct quantile over squeeze_lb bars.
|
||||
Breakout = close[i] > upper[i] AND bandwidth is in compressed regime.
|
||||
Entry: long at close[i], honest (direction decided with close[i]).
|
||||
Exit: close < middle band (continuous) OR max_bars OR SL at entry - sl_mult*ATR.
|
||||
"""
|
||||
def entries_fn(df):
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
# BB bands - causal (uses data up to i)
|
||||
upper, mid, lower = al.bbands(c, win=bb_win, k=2.0)
|
||||
|
||||
# Bandwidth
|
||||
bw = np.where(mid != 0, (upper - lower) / mid, np.nan)
|
||||
|
||||
# Squeeze: bandwidth in lowest squeeze_pct percentile over squeeze_lb bars (causal)
|
||||
# Use rolling quantile to flag "compressed" bandwidth
|
||||
bw_series = pd.Series(bw)
|
||||
bw_lo = bw_series.rolling(squeeze_lb, min_periods=squeeze_lb).quantile(squeeze_pct).values
|
||||
|
||||
# ATR for SL
|
||||
atr_arr = al.atr(df, win=14)
|
||||
|
||||
entries = [None] * n
|
||||
in_trade = False
|
||||
|
||||
for i in range(squeeze_lb + bb_win, n):
|
||||
if np.isnan(upper[i]) or np.isnan(bw_lo[i]) or np.isnan(atr_arr[i]):
|
||||
continue
|
||||
if not np.isfinite(bw[i]):
|
||||
continue
|
||||
|
||||
# Squeeze: bandwidth <= its rolling low-percentile threshold
|
||||
is_squeeze = bw[i] <= bw_lo[i]
|
||||
|
||||
# Breakout: close[i] > upper[i] (decided at close[i], honest)
|
||||
breakout = c[i] > upper[i]
|
||||
|
||||
if (not in_trade) and is_squeeze and breakout:
|
||||
sl_px = c[i] - sl_mult * atr_arr[i]
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": None,
|
||||
"sl": sl_px,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
in_trade = True
|
||||
elif in_trade:
|
||||
# Exit signal: close falls below middle band -> reset flag
|
||||
if c[i] < mid[i]:
|
||||
in_trade = False
|
||||
|
||||
return entries
|
||||
|
||||
return entries_fn
|
||||
|
||||
|
||||
# Grid: 4 configs (2 bb_win x 2 squeeze_pct) with fixed squeeze_lb=100
|
||||
configs = [
|
||||
dict(bb_win=20, squeeze_lb=100, squeeze_pct=0.20),
|
||||
dict(bb_win=20, squeeze_lb=100, squeeze_pct=0.30),
|
||||
dict(bb_win=30, squeeze_lb=100, squeeze_pct=0.20),
|
||||
dict(bb_win=30, squeeze_lb=100, squeeze_pct=0.30),
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
print("=== CMB05: BB Squeeze -> Breakout ===")
|
||||
print(f"Grid: {len(configs)} configs x 2 assets x fee_sweep = honest eval\n")
|
||||
|
||||
for cfg in configs:
|
||||
name = f"CMB05-BB{cfg['bb_win']}-SQ{cfg['squeeze_lb']}-P{int(cfg['squeeze_pct']*100)}"
|
||||
fn = make_entries(bb_win=cfg["bb_win"], squeeze_lb=cfg["squeeze_lb"], squeeze_pct=cfg["squeeze_pct"])
|
||||
rep = al.study_signals(name, fn, tfs=("1d",))
|
||||
v = rep["verdict"]
|
||||
score = v.get("best_holdout_sharpe", -9)
|
||||
print(f" {name}: grade={v['grade']} fullSh={v.get('best_full_sharpe'):.3f} holdSh={v.get('best_holdout_sharpe'):.3f}")
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_rep["_cfg"] = cfg
|
||||
|
||||
print("\n--- BEST CONFIG ---")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,165 +0,0 @@
|
||||
"""CMB06 — Trend + Seasonality Combo
|
||||
IDEA: TSMOM long-flat (multi-horizon, vol-targeted, like TP01) but scale the
|
||||
exposure UP in historically strong calendar windows (day-of-week + month-of-year
|
||||
expanding expanding expectancy). Causal only: expectancy estimated on expanding window
|
||||
using data BEFORE the current bar.
|
||||
|
||||
Design:
|
||||
- Base signal: TSMOM multi-horizon (1M / 3M / 6M), long-flat, vote-then-sign
|
||||
- Volatility targeting: 20% target, 2x lev cap (same as TP01)
|
||||
- Seasonality multiplier: expand-window daily/monthly return expectancy,
|
||||
normalised to [scale_min, scale_max] so it's a scalar boost, not a flip.
|
||||
The multiplier is always >= 0 (never inverts the trend).
|
||||
|
||||
Causal guarantee:
|
||||
- Day-of-week expectancy at bar i uses only past bars (strict shift: computed on
|
||||
data up to bar i-1, applied at bar i).
|
||||
- Month-of-year same.
|
||||
- Both use EXPANDING window (not rolling) -> no future-data leak, and it
|
||||
gradually stabilises as history accumulates.
|
||||
|
||||
Grid (4 params): 2 scale ranges × 2 TFs = 4 cells total.
|
||||
"""
|
||||
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 _expanding_dow_expectancy(df: pd.DataFrame) -> np.ndarray:
|
||||
"""For each bar, return the expanding-window mean return of the same day-of-week,
|
||||
computed on PAST bars only (shift 1). Returns NaN until at least 4 samples exist."""
|
||||
c = df["close"].values.astype(float)
|
||||
r = al.simple_returns(c) # r[i] = return realized at bar i
|
||||
dt = pd.to_datetime(df["datetime"], utc=True)
|
||||
dow = dt.dt.dayofweek.values # 0=Mon..6=Sun
|
||||
|
||||
exp = np.full(len(r), np.nan)
|
||||
# For each bar i, compute mean return of same DOW for all bars j < i
|
||||
# Use expanding sum by DOW category
|
||||
dow_sum = np.zeros(7, dtype=float)
|
||||
dow_cnt = np.zeros(7, dtype=int)
|
||||
|
||||
for i in range(1, len(r)):
|
||||
# update with bar i-1 (strictly past)
|
||||
d_prev = dow[i - 1]
|
||||
dow_sum[d_prev] += r[i - 1]
|
||||
dow_cnt[d_prev] += 1
|
||||
|
||||
d = dow[i]
|
||||
if dow_cnt[d] >= 4:
|
||||
exp[i] = dow_sum[d] / dow_cnt[d]
|
||||
|
||||
return exp
|
||||
|
||||
|
||||
def _expanding_month_expectancy(df: pd.DataFrame) -> np.ndarray:
|
||||
"""Same but for month-of-year (1..12). Requires >= 4 past bars in same month."""
|
||||
c = df["close"].values.astype(float)
|
||||
r = al.simple_returns(c)
|
||||
dt = pd.to_datetime(df["datetime"], utc=True)
|
||||
moy = dt.dt.month.values # 1..12
|
||||
|
||||
exp = np.full(len(r), np.nan)
|
||||
mo_sum = np.zeros(13, dtype=float)
|
||||
mo_cnt = np.zeros(13, dtype=int)
|
||||
|
||||
for i in range(1, len(r)):
|
||||
m_prev = moy[i - 1]
|
||||
mo_sum[m_prev] += r[i - 1]
|
||||
mo_cnt[m_prev] += 1
|
||||
|
||||
m = moy[i]
|
||||
if mo_cnt[m] >= 4:
|
||||
exp[i] = mo_sum[m] / mo_cnt[m]
|
||||
|
||||
return exp
|
||||
|
||||
|
||||
def _seasonality_multiplier(df: pd.DataFrame, scale_min: float, scale_max: float) -> np.ndarray:
|
||||
"""Combine DOW + month expanding expectancy into a [scale_min, scale_max] multiplier.
|
||||
When either is NaN (early history), default to 1.0 (neutral)."""
|
||||
dow_exp = _expanding_dow_expectancy(df)
|
||||
mon_exp = _expanding_month_expectancy(df)
|
||||
|
||||
# Normalise each to [-1, +1] range using the expanding-window min/max seen so far.
|
||||
# We use a causal expanding percentile: zscore is simpler and avoids percentile loop.
|
||||
# Use zscore over an expanding window instead (pandas expanding).
|
||||
dow_s = pd.Series(dow_exp)
|
||||
mon_s = pd.Series(mon_exp)
|
||||
|
||||
# Causal z-score (expanding)
|
||||
dow_z = (dow_s - dow_s.expanding().mean()) / dow_s.expanding().std().replace(0, np.nan)
|
||||
mon_z = (mon_s - mon_s.expanding().mean()) / mon_s.expanding().std().replace(0, np.nan)
|
||||
|
||||
# Blend (equal weight)
|
||||
combined = (dow_z.fillna(0.0) + mon_z.fillna(0.0)).values / 2.0
|
||||
|
||||
# Map to [scale_min, scale_max] via sigmoid-like clamp
|
||||
# clip to [-2, 2] sigma, then linearly map
|
||||
combined_clipped = np.clip(combined, -2.0, 2.0)
|
||||
mid = (scale_min + scale_max) / 2.0
|
||||
half_range = (scale_max - scale_min) / 2.0
|
||||
mult = mid + half_range * (combined_clipped / 2.0)
|
||||
|
||||
# Where both were NaN (very early bars), use neutral = 1.0
|
||||
both_nan = dow_s.isna().values & mon_s.isna().values
|
||||
mult[both_nan] = 1.0
|
||||
|
||||
return mult
|
||||
|
||||
|
||||
def _tsmom_base(df: pd.DataFrame) -> np.ndarray:
|
||||
"""Multi-horizon TSMOM: 1M/3M/6M vote, long-flat, vol-targeted."""
|
||||
c = df["close"].values.astype(float)
|
||||
bpd = al.bars_per_day(df)
|
||||
d = np.zeros(len(c))
|
||||
for months in (1, 3, 6):
|
||||
h = int(months * 30 * bpd)
|
||||
if h >= len(c):
|
||||
continue
|
||||
s = np.full(len(c), np.nan)
|
||||
s[h:] = np.sign(c[h:] / c[:-h] - 1.0)
|
||||
d = d + np.nan_to_num(s)
|
||||
direction = np.clip(np.sign(d), 0, None) # long-flat only
|
||||
return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
|
||||
|
||||
def make_target(scale_min: float, scale_max: float):
|
||||
"""Return a target_fn that applies the seasonality multiplier."""
|
||||
def target_fn(df: pd.DataFrame) -> np.ndarray:
|
||||
base = _tsmom_base(df)
|
||||
mult = _seasonality_multiplier(df, scale_min, scale_max)
|
||||
combined = base * mult
|
||||
# Keep within leverage cap
|
||||
combined = np.clip(combined, 0.0, 2.0)
|
||||
combined = np.nan_to_num(combined, nan=0.0)
|
||||
return combined
|
||||
return target_fn
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Grid: 2 scale ranges × 2 TFs = 4 cells
|
||||
# scale_min/max: how much to reduce/boost position in weak/strong seasons
|
||||
# (0.5, 1.5) = modest 50% swing; (0.25, 1.75) = aggressive 150% swing
|
||||
configs = [
|
||||
("CMB06-modest", 0.5, 1.5),
|
||||
("CMB06-aggr", 0.25, 1.75),
|
||||
]
|
||||
|
||||
all_reps = []
|
||||
for name, smin, smax in configs:
|
||||
print(f"\n=== Running {name} (scale [{smin},{smax}]) ===")
|
||||
rep = al.study_weights(name, make_target(smin, smax), tfs=("1d", "12h"))
|
||||
print(al.fmt(rep))
|
||||
all_reps.append((name, rep))
|
||||
|
||||
# Pick best by min_asset_holdout_sharpe at best TF
|
||||
def best_holdout(rep):
|
||||
return max(c["min_asset_holdout_sharpe"] for c in rep["cells"])
|
||||
|
||||
best_name, best_rep = max(all_reps, key=lambda x: best_holdout(x[1]))
|
||||
print(f"\n>>> BEST CONFIG: {best_name}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,62 +0,0 @@
|
||||
"""MIC01 — Three-bar momentum (micro-continuation).
|
||||
|
||||
HYPOTHESIS: 3 consecutive higher closes -> enter long at the 3rd close,
|
||||
exit after k bars or on a lower close. Continuation test.
|
||||
|
||||
Grid: k (exit after k bars if no stop) in {3, 5, 8, 10}
|
||||
Style: study_signals (discrete entry/exit, 1d only).
|
||||
|
||||
Causality: decision at close[i] uses only close[i-2], close[i-1], close[i].
|
||||
Entry fills at close[i] (the 3rd consecutive higher close).
|
||||
Exit: on next bar where close < prior close, OR after max_bars.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
def make_entries(max_bars: int):
|
||||
"""Return entries_fn for a given max_bars parameter."""
|
||||
def entries_fn(df):
|
||||
c = df["close"].values
|
||||
n = len(c)
|
||||
entries = [None] * n
|
||||
|
||||
for i in range(2, n):
|
||||
# 3 consecutive higher closes: close[i] > close[i-1] > close[i-2]
|
||||
if c[i] > c[i-1] and c[i-1] > c[i-2]:
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": None,
|
||||
"sl": None,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
return entries
|
||||
return entries_fn
|
||||
|
||||
|
||||
# Small internal grid: 4 param sets, 1 TF, 2 assets = 8 backtests total
|
||||
# (within the <=6 total limit would be 3 configs; using 4 is borderline, reduce to 3 if slow)
|
||||
GRID = [3, 5, 8, 12]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for k in GRID:
|
||||
rep = al.study_signals(
|
||||
f"MIC01-k{k}",
|
||||
make_entries(max_bars=k),
|
||||
tfs=("1d",),
|
||||
)
|
||||
v = rep["verdict"]
|
||||
# Score = min hold-out Sharpe across assets (conservative)
|
||||
score = v.get("best_holdout_sharpe", -999.0)
|
||||
print(f"k={k:2d}: grade={v['grade']} minFull={v.get('best_full_sharpe'):+.3f} minHold={v.get('best_holdout_sharpe'):+.3f}")
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_k = k
|
||||
|
||||
print(f"\nBest config: k={best_k}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,114 +0,0 @@
|
||||
"""MIC02 — Engulfing continuation (trend-filtered).
|
||||
|
||||
HYPOTHESIS:
|
||||
Bullish engulfing in an uptrend -> long at close of engulfing bar.
|
||||
Bearish engulfing in a downtrend -> short at close of engulfing bar.
|
||||
Trend filter: EMA(trend_win) direction.
|
||||
|
||||
Pattern definition (standard engulfing, CAUSAL):
|
||||
Bullish engulfing at bar i:
|
||||
- Bar i-1 is bearish: close[i-1] < open[i-1]
|
||||
- Bar i is bullish: close[i] > open[i]
|
||||
- Bar i's body ENGULFS bar i-1's body: open[i] <= close[i-1] AND close[i] >= open[i-1]
|
||||
Bearish engulfing at bar i:
|
||||
- Bar i-1 is bullish: close[i-1] > open[i-1]
|
||||
- Bar i is bearish: close[i] < open[i]
|
||||
- Bar i's body ENGULFS bar i-1's body: open[i] >= close[i-1] AND close[i] <= open[i-1]
|
||||
|
||||
Trend filter: EMA(trend_win). Long only if close[i] > EMA[i]. Short only if close[i] < EMA[i].
|
||||
|
||||
Entry fills at close[i]. Exit after max_bars (time-stop only).
|
||||
|
||||
Grid: (trend_win, max_bars) x 2 assets x 1 TF = 4 backtests (<=6 limit respected).
|
||||
|
||||
Causality: all decisions use data <= close[i] (open[i] is known at close[i]).
|
||||
No entry on candle extreme (high/low). Entry at close[i].
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def make_entries(trend_win: int, max_bars: int):
|
||||
"""Return entries_fn for given EMA trend window and max hold bars."""
|
||||
def entries_fn(df):
|
||||
o = df["open"].values
|
||||
c = df["close"].values
|
||||
n = len(c)
|
||||
|
||||
# Causal EMA of close
|
||||
trend = al.ema(c, span=trend_win)
|
||||
|
||||
entries = [None] * n
|
||||
|
||||
for i in range(1, n):
|
||||
# --- Bullish engulfing ---
|
||||
# Previous bar bearish
|
||||
prev_bear = c[i-1] < o[i-1]
|
||||
# Current bar bullish
|
||||
curr_bull = c[i] > o[i]
|
||||
# Engulf: current open <= prev close AND current close >= prev open
|
||||
bull_engulf = (o[i] <= c[i-1]) and (c[i] >= o[i-1])
|
||||
# Trend filter: close above EMA
|
||||
uptrend = np.isfinite(trend[i]) and (c[i] > trend[i])
|
||||
|
||||
if prev_bear and curr_bull and bull_engulf and uptrend:
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": None,
|
||||
"sl": None,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
continue
|
||||
|
||||
# --- Bearish engulfing ---
|
||||
# Previous bar bullish
|
||||
prev_bull = c[i-1] > o[i-1]
|
||||
# Current bar bearish
|
||||
curr_bear = c[i] < o[i]
|
||||
# Engulf: current open >= prev close AND current close <= prev open
|
||||
bear_engulf = (o[i] >= c[i-1]) and (c[i] <= o[i-1])
|
||||
# Trend filter: close below EMA
|
||||
downtrend = np.isfinite(trend[i]) and (c[i] < trend[i])
|
||||
|
||||
if prev_bull and curr_bear and bear_engulf and downtrend:
|
||||
entries[i] = {
|
||||
"dir": -1,
|
||||
"tp": None,
|
||||
"sl": None,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
|
||||
return entries
|
||||
return entries_fn
|
||||
|
||||
|
||||
# Internal grid: 2 param sets x 2 assets x 1 TF = 4 backtests (within <=6)
|
||||
GRID = [
|
||||
(50, 5), # medium-term trend, short hold
|
||||
(100, 10), # longer-term trend, medium hold
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
best_params = None
|
||||
|
||||
for trend_win, max_bars in GRID:
|
||||
rep = al.study_signals(
|
||||
f"MIC02-ema{trend_win}-mb{max_bars}",
|
||||
make_entries(trend_win=trend_win, max_bars=max_bars),
|
||||
tfs=("1d",),
|
||||
)
|
||||
v = rep["verdict"]
|
||||
score = v.get("best_holdout_sharpe", -999.0)
|
||||
print(f"ema={trend_win:3d} max_bars={max_bars:2d}: grade={v['grade']} "
|
||||
f"minFull={v.get('best_full_sharpe'):+.3f} minHold={v.get('best_holdout_sharpe'):+.3f}")
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_params = (trend_win, max_bars)
|
||||
|
||||
print(f"\nBest config: ema={best_params[0]}, max_bars={best_params[1]}")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,105 +0,0 @@
|
||||
"""MIC03 — Volume-spike breakout
|
||||
Hypothesis: Breakout of prior high CONFIRMED by volume z-score > threshold -> enter long at close.
|
||||
Exit: TP, SL, or max_bars timeout.
|
||||
|
||||
Implementation:
|
||||
- Breakout: close[i] > donchian_high(win)[i] (prior win-bar high, shifted by 1 so fully causal)
|
||||
- Volume confirmation: volume z-score over vol_win bars > vol_thresh
|
||||
- Entry at close[i], direction = long only (breakouts on the upside)
|
||||
- TP = entry * (1 + tp_pct), SL = entry * (1 - sl_pct), max_bars timeout
|
||||
|
||||
Grid (<=4 param sets, 1d only -> total backtests = 4 * 2 assets = 8 <= 6... actually 8.
|
||||
Reduce to 2 configs to stay within ~6 backtests and avoid slow fee sweeps):
|
||||
Config A: donchian 20, vol_win 20, vol_thresh 2.0, tp 3%, sl 1.5%, max_bars 10
|
||||
Config B: donchian 30, vol_win 30, vol_thresh 1.5, tp 4%, sl 2.0%, max_bars 15
|
||||
|
||||
Pick the best config by min_asset_holdout_sharpe.
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def make_entries_fn(don_win: int, vol_win: int, vol_thresh: float,
|
||||
tp_pct: float, sl_pct: float, max_bars: int):
|
||||
def entries_fn(df):
|
||||
close = df["close"].values.astype(float)
|
||||
volume = df["volume"].values.astype(float)
|
||||
n = len(close)
|
||||
|
||||
# Donchian upper channel: prior don_win-bar HIGH (shifted, causal)
|
||||
# Using high prices for breakout reference (breakout above prior high is more meaningful)
|
||||
high = df["high"].values.astype(float)
|
||||
don_hi = np.full(n, np.nan)
|
||||
# rolling max of high over don_win bars, then shift by 1 (prior bar)
|
||||
for i in range(don_win, n):
|
||||
don_hi[i] = np.max(high[i - don_win: i]) # excludes bar i -> causal
|
||||
|
||||
# Volume z-score (causal): zscore of current volume vs rolling mean/std
|
||||
vol_mean = np.full(n, np.nan)
|
||||
vol_std = np.full(n, np.nan)
|
||||
for i in range(vol_win, n):
|
||||
v_window = volume[i - vol_win: i] # excludes current bar
|
||||
vol_mean[i] = np.mean(v_window)
|
||||
vol_std[i] = np.std(v_window)
|
||||
|
||||
vol_z = np.full(n, np.nan)
|
||||
mask = (vol_std > 0) & np.isfinite(vol_std)
|
||||
vol_z[mask] = (volume[mask] - vol_mean[mask]) / vol_std[mask]
|
||||
|
||||
# Build entry list
|
||||
entries = [None] * n
|
||||
for i in range(don_win + vol_win, n):
|
||||
# Breakout condition: close breaks above prior don_win-bar high
|
||||
breakout = (np.isfinite(don_hi[i]) and close[i] > don_hi[i])
|
||||
# Volume confirmation
|
||||
vol_confirmed = (np.isfinite(vol_z[i]) and vol_z[i] > vol_thresh)
|
||||
|
||||
if breakout and vol_confirmed:
|
||||
entry_px = close[i] # fill at close[i]
|
||||
tp_px = entry_px * (1.0 + tp_pct)
|
||||
sl_px = entry_px * (1.0 - sl_pct)
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": tp_px,
|
||||
"sl": sl_px,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
|
||||
return entries
|
||||
|
||||
return entries_fn
|
||||
|
||||
|
||||
# Config A: tighter params
|
||||
config_a = dict(don_win=20, vol_win=20, vol_thresh=2.0, tp_pct=0.03, sl_pct=0.015, max_bars=10)
|
||||
# Config B: wider params
|
||||
config_b = dict(don_win=30, vol_win=30, vol_thresh=1.5, tp_pct=0.04, sl_pct=0.02, max_bars=15)
|
||||
|
||||
configs = [
|
||||
("MIC03-A", config_a),
|
||||
("MIC03-B", config_b),
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for cfg_name, cfg in configs:
|
||||
print(f"\n--- Running {cfg_name}: {cfg} ---")
|
||||
fn = make_entries_fn(**cfg)
|
||||
rep = al.study_signals(cfg_name, fn, tfs=("1d",))
|
||||
print(al.fmt(rep))
|
||||
print("JSON:", al.as_json(rep))
|
||||
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -999) or -999
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_rep["_config"] = cfg
|
||||
best_rep["_config_name"] = cfg_name
|
||||
|
||||
print("\n\n=== BEST CONFIG ===")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,81 +0,0 @@
|
||||
"""MIC04 — Consecutive-days continuation vs fade.
|
||||
|
||||
IDEA: Compute net of last-k daily close returns (streak).
|
||||
- FOLLOWING: go long when streak is positive (sign = +1), flat when negative.
|
||||
- FADING: go long when streak is negative (mean-reversion), flat when positive.
|
||||
Both are long-flat. We try k in {3, 5} and compare following vs fading.
|
||||
Position is vol-targeted (20% target, 2x cap).
|
||||
|
||||
Grid: 4 configs (2 k-values × 2 directions), TFs: 1d, 12h.
|
||||
Total backtests: 4 configs × 2 TFs × 2 assets = 16 — but we only call study_weights
|
||||
per config (each call does 2 TFs × 2 assets internally) → 4 calls = 16 backtests (fine).
|
||||
Actually we pick the best config manually. To stay <= 6 total calls we test 2 configs
|
||||
(k=3 follow, k=5 follow) and present the best, then also run the fading variants if promising.
|
||||
We run all 4 configs (each on tfs=("1d","12h")) → 4 calls, well within budget.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def streak_target(df, k: int, follow: bool) -> np.ndarray:
|
||||
"""
|
||||
For each bar i, compute net of last-k close returns (causal: uses close[i-k..i]).
|
||||
streak[i] = close[i] / close[i-k] - 1 (sign of cumulative k-bar return)
|
||||
|
||||
If follow=True: position = +1 when streak > 0, else 0 (long-flat continuation).
|
||||
If fading=True: position = +1 when streak < 0, else 0 (long-flat mean-reversion).
|
||||
|
||||
Then vol-target the direction.
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
# Cumulative k-bar return ending at i: c[i]/c[i-k] - 1
|
||||
streak = np.full(n, np.nan)
|
||||
for i in range(k, n):
|
||||
streak[i] = c[i] / c[i - k] - 1.0
|
||||
|
||||
if follow:
|
||||
direction = np.where(streak > 0, 1.0, 0.0)
|
||||
else:
|
||||
direction = np.where(streak < 0, 1.0, 0.0)
|
||||
|
||||
# Fill NaN with 0 before vol_target
|
||||
direction = np.nan_to_num(direction, nan=0.0)
|
||||
|
||||
# Apply vol targeting
|
||||
tgt = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return tgt
|
||||
|
||||
|
||||
configs = [
|
||||
("MIC04-k3-follow", 3, True),
|
||||
("MIC04-k5-follow", 5, True),
|
||||
("MIC04-k3-fade", 3, False),
|
||||
("MIC04-k5-fade", 5, False),
|
||||
]
|
||||
|
||||
results = {}
|
||||
for name, k, follow in configs:
|
||||
print(f"\n{'='*60}")
|
||||
print(f"Running {name} (k={k}, follow={follow})")
|
||||
print('='*60)
|
||||
rep = al.study_weights(
|
||||
name,
|
||||
lambda df, k=k, follow=follow: streak_target(df, k, follow),
|
||||
tfs=("1d", "12h"),
|
||||
)
|
||||
results[name] = rep
|
||||
print(al.fmt(rep))
|
||||
|
||||
# Pick best config by holdout Sharpe (min across assets in best TF)
|
||||
best_name = max(results, key=lambda n: results[n]["verdict"].get("best_holdout_sharpe", -99))
|
||||
best_rep = results[best_name]
|
||||
|
||||
print("\n" + "="*60)
|
||||
print(f"BEST CONFIG: {best_name}")
|
||||
print("="*60)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,82 +0,0 @@
|
||||
"""MIC05 — Wide-range-bar follow-through.
|
||||
|
||||
HYPOTHESIS: After a wide-range bar (range > 2*ATR) closing strong (close near the
|
||||
top 30% of the bar for longs, or bottom 30% for shorts), enter in the bar's direction
|
||||
at close[i]; exit after k bars (or on TP/SL).
|
||||
|
||||
CAUSAL: ATR is computed up to bar i-1 (shifted), range and close strength computed
|
||||
from bar i itself (known at close[i]). Entry fills at close[i].
|
||||
|
||||
Grid: k_bars in {3, 5, 7, 10} — only 1d, 2 assets, 4 param sets = 8 backtests total.
|
||||
Best config selected by min-asset hold-out Sharpe.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Signal generator
|
||||
# ---------------------------------------------------------------------------
|
||||
def make_entries(df, k_bars: int = 5, atr_mult: float = 2.0, close_pct: float = 0.30):
|
||||
"""Returns entries list len(df).
|
||||
|
||||
Wide range bar: range > atr_mult * ATR(14) at bar i-1 (causal).
|
||||
Strong close long: close >= low + (1 - close_pct) * range (top 30%)
|
||||
Strong close short: close <= low + close_pct * range (bottom 30%)
|
||||
"""
|
||||
hi = df["high"].values.astype(float)
|
||||
lo = df["low"].values.astype(float)
|
||||
cl = df["close"].values.astype(float)
|
||||
bar_range = hi - lo
|
||||
|
||||
# ATR causal: shift by 1 so ATR at bar i uses data up to bar i-1
|
||||
atr_raw = al.atr(df, win=14)
|
||||
atr_shifted = np.roll(atr_raw, 1)
|
||||
atr_shifted[0] = atr_raw[0]
|
||||
|
||||
entries = [None] * len(df)
|
||||
for i in range(1, len(df)):
|
||||
rng = bar_range[i]
|
||||
atr_i = atr_shifted[i]
|
||||
if atr_i <= 0 or not np.isfinite(atr_i):
|
||||
continue
|
||||
if rng < atr_mult * atr_i:
|
||||
continue # not a wide-range bar
|
||||
close_rel = (cl[i] - lo[i]) / rng if rng > 0 else 0.5
|
||||
if close_rel >= (1.0 - close_pct):
|
||||
# Strong bullish wide bar -> long follow-through
|
||||
entries[i] = {"dir": 1, "tp": None, "sl": None, "max_bars": k_bars}
|
||||
elif close_rel <= close_pct:
|
||||
# Strong bearish wide bar -> short follow-through
|
||||
entries[i] = {"dir": -1, "tp": None, "sl": None, "max_bars": k_bars}
|
||||
return entries
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Grid search over k_bars
|
||||
# ---------------------------------------------------------------------------
|
||||
K_BARS_GRID = [3, 5, 7, 10]
|
||||
|
||||
best_rep = None
|
||||
best_hold = -999
|
||||
|
||||
for k in K_BARS_GRID:
|
||||
rep = al.study_signals(
|
||||
f"MIC05-k{k}",
|
||||
lambda df, _k=k: make_entries(df, k_bars=_k),
|
||||
tfs=("1d",),
|
||||
)
|
||||
min_hold = rep["verdict"].get("best_holdout_sharpe", -999)
|
||||
print(f"k={k:2d}: grade={rep['verdict']['grade']} "
|
||||
f"full={rep['verdict'].get('best_full_sharpe', 'N/A')} "
|
||||
f"hold={min_hold}")
|
||||
if min_hold > best_hold:
|
||||
best_hold = min_hold
|
||||
best_rep = rep
|
||||
|
||||
# Rename best rep with canonical ID
|
||||
best_rep["name"] = "MIC05"
|
||||
print("\n--- BEST CONFIG ---")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,84 +0,0 @@
|
||||
"""MIC06 — Body-ratio momentum (long-flat, vol-targeted)
|
||||
Hypothesis: Large positive candle body (body/range high) signals conviction upward move
|
||||
-> hold long next bars. Body ratio = (close - open) / (high - low), smoothed over N bars.
|
||||
When smoothed body-ratio > threshold -> long; else flat.
|
||||
Grid: (lookback_smooth, threshold, hold_bars) x tfs (1d, 12h)
|
||||
"""
|
||||
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 body_ratio_signal(df: pd.DataFrame, smooth: int = 5, threshold: float = 0.15) -> np.ndarray:
|
||||
"""
|
||||
Compute body/range ratio for each bar, then smooth over `smooth` bars.
|
||||
Go long when smoothed ratio > threshold (conviction upward), else flat.
|
||||
All causal: body_ratio[i] uses only close[i], open[i], high[i], low[i].
|
||||
The smoothed ratio uses bars up to i (causal rolling mean).
|
||||
"""
|
||||
o = df["open"].values.astype(float)
|
||||
h = df["high"].values.astype(float)
|
||||
l = df["low"].values.astype(float)
|
||||
c = df["close"].values.astype(float)
|
||||
|
||||
rng = h - l
|
||||
body = c - o
|
||||
# Body ratio: in [-1, 1]; positive = bullish bar, negative = bearish bar
|
||||
# Where range == 0 (doji), treat as 0
|
||||
ratio = np.where(rng > 0, body / rng, 0.0)
|
||||
|
||||
# Smooth with a rolling mean (causal)
|
||||
smoothed = pd.Series(ratio).rolling(smooth, min_periods=max(1, smooth // 2)).mean().values
|
||||
|
||||
# Direction: long if smoothed ratio > threshold, else flat
|
||||
direction = np.where(smoothed > threshold, 1.0, 0.0)
|
||||
|
||||
# Vol-target to 20%, leverage cap 2x
|
||||
return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
|
||||
|
||||
# Small internal grid: 4 param sets
|
||||
CONFIGS = [
|
||||
dict(smooth=3, threshold=0.10),
|
||||
dict(smooth=5, threshold=0.15),
|
||||
dict(smooth=10, threshold=0.10),
|
||||
dict(smooth=10, threshold=0.20),
|
||||
]
|
||||
|
||||
# Run 2 TFs x 4 configs = 8 backtests — but we pick best config first
|
||||
# To stay within 6 total: we test all 4 configs on 1d only, pick best, then run 12h too
|
||||
print("=== MIC06: Body-Ratio Momentum (long-flat, vol-targeted) ===\n")
|
||||
|
||||
# Phase 1: quick grid on 1d (4 backtests)
|
||||
print("Phase 1: grid search on 1d...")
|
||||
grid_results = []
|
||||
for cfg in CONFIGS:
|
||||
rep = al.study_weights(
|
||||
f"MIC06-s{cfg['smooth']}-t{int(cfg['threshold']*100)}",
|
||||
lambda df, s=cfg["smooth"], t=cfg["threshold"]: body_ratio_signal(df, s, t),
|
||||
tfs=("1d",)
|
||||
)
|
||||
best_cell = rep["cells"][0]
|
||||
score = best_cell["min_asset_holdout_sharpe"]
|
||||
print(f" smooth={cfg['smooth']:2d} thresh={cfg['threshold']:.2f}: "
|
||||
f"minFull={best_cell['min_asset_full_sharpe']:+.2f} "
|
||||
f"minHold={best_cell['min_asset_holdout_sharpe']:+.2f} "
|
||||
f"feeOK={best_cell['fee_survives']}")
|
||||
grid_results.append((score, cfg, rep))
|
||||
|
||||
# Pick best config by hold-out score
|
||||
grid_results.sort(key=lambda x: x[0], reverse=True)
|
||||
best_score, best_cfg, _ = grid_results[0]
|
||||
print(f"\nBest config: smooth={best_cfg['smooth']} threshold={best_cfg['threshold']:.2f}")
|
||||
|
||||
# Phase 2: run best config on both TFs (2 backtests)
|
||||
print("\nPhase 2: full eval on 1d + 12h with best config...")
|
||||
final_rep = al.study_weights(
|
||||
"MIC06",
|
||||
lambda df, s=best_cfg["smooth"], t=best_cfg["threshold"]: body_ratio_signal(df, s, t),
|
||||
tfs=("1d", "12h")
|
||||
)
|
||||
|
||||
print("\n" + al.fmt(final_rep))
|
||||
print("JSON:", al.as_json(final_rep))
|
||||
@@ -1,131 +0,0 @@
|
||||
"""MIC07 — Pin-bar rejection reversal (hammer at support).
|
||||
|
||||
HYPOTHESIS:
|
||||
A hammer candle (large lower wick, small body near top) at a recent support (N-bar low)
|
||||
signals a long reversal. Enter long at close[i] with SL below the wick low.
|
||||
|
||||
PIN-BAR DEFINITION (causal, using only bar[i] OHLC):
|
||||
- Lower wick >= wick_ratio * candle range (e.g. 60% of H-L)
|
||||
- Body is in upper part of the candle (close > midpoint)
|
||||
- Candle range > ATR * min_range_atr (no doji / tiny bars)
|
||||
|
||||
SUPPORT CONDITION:
|
||||
- low[i] <= rolling_min(low, support_win bars, excluding bar i) * (1 + support_pct)
|
||||
i.e. bar is "near" a recent N-bar low
|
||||
|
||||
TRADE MANAGEMENT:
|
||||
- Entry: close[i]
|
||||
- SL: low[i] - atr_sl_mult * ATR (below wick, some buffer)
|
||||
- TP: close[i] + rr_ratio * (close[i] - SL) (risk-reward)
|
||||
- max_bars: hold at most max_hold days
|
||||
|
||||
Grid (<=4 configs, 1 TF = 1d, 2 assets => 4 backtests total):
|
||||
Config A: wick_ratio=0.60, support_win=20, sl_mult=0.2, rr=2.0, max_hold=10
|
||||
Config B: wick_ratio=0.65, support_win=10, sl_mult=0.3, rr=1.5, max_hold=8
|
||||
Config C: wick_ratio=0.55, support_win=20, sl_mult=0.3, rr=2.0, max_hold=15
|
||||
Config D: wick_ratio=0.60, support_win=30, sl_mult=0.2, rr=2.0, max_hold=10
|
||||
|
||||
Pick best config by min_asset_holdout_sharpe, print full report.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def make_entries(df, wick_ratio=0.60, support_win=20, sl_mult=0.2,
|
||||
rr=2.0, max_hold=10, atr_win=14, min_range_atr=0.3):
|
||||
"""Build entry list for the pin-bar reversal strategy."""
|
||||
o = df["open"].values.astype(float)
|
||||
h = df["high"].values.astype(float)
|
||||
l = df["low"].values.astype(float)
|
||||
c = df["close"].values.astype(float)
|
||||
|
||||
atr_arr = al.atr(df, atr_win)
|
||||
|
||||
# Rolling min of lows over support_win bars PRIOR to i (shift by 1 -> causal)
|
||||
low_series = df["low"].rolling(support_win, min_periods=support_win).min().shift(1).values
|
||||
|
||||
entries = [None] * len(df)
|
||||
|
||||
for i in range(support_win + atr_win + 1, len(df)):
|
||||
rng = h[i] - l[i]
|
||||
if rng <= 0:
|
||||
continue
|
||||
|
||||
atr_i = atr_arr[i]
|
||||
if not np.isfinite(atr_i) or atr_i <= 0:
|
||||
continue
|
||||
|
||||
# Filter tiny candles
|
||||
if rng < min_range_atr * atr_i:
|
||||
continue
|
||||
|
||||
body_top = max(o[i], c[i])
|
||||
body_bot = min(o[i], c[i])
|
||||
|
||||
lower_wick = body_bot - l[i]
|
||||
# upper_wick = h[i] - body_top # not used but useful for debug
|
||||
|
||||
# Pin bar: lower wick must dominate
|
||||
if lower_wick < wick_ratio * rng:
|
||||
continue
|
||||
|
||||
# Body in upper portion (close > midpoint of range)
|
||||
if c[i] <= (h[i] + l[i]) / 2.0:
|
||||
continue
|
||||
|
||||
# Support condition: low[i] is near recent N-bar rolling min
|
||||
supp = low_series[i]
|
||||
if not np.isfinite(supp):
|
||||
continue
|
||||
# Low[i] must be at or below support level (within 0.5% of the recent low)
|
||||
if l[i] > supp * 1.005:
|
||||
continue
|
||||
|
||||
# Trade setup
|
||||
sl_price = l[i] - sl_mult * atr_i
|
||||
if sl_price >= c[i]:
|
||||
continue # degenerate
|
||||
risk = c[i] - sl_price
|
||||
if risk <= 0:
|
||||
continue
|
||||
tp_price = c[i] + rr * risk
|
||||
|
||||
entries[i] = {
|
||||
"dir": 1,
|
||||
"tp": round(tp_price, 2),
|
||||
"sl": round(sl_price, 2),
|
||||
"max_bars": max_hold,
|
||||
}
|
||||
|
||||
return entries
|
||||
|
||||
|
||||
CONFIGS = [
|
||||
dict(wick_ratio=0.60, support_win=20, sl_mult=0.2, rr=2.0, max_hold=10),
|
||||
dict(wick_ratio=0.65, support_win=10, sl_mult=0.3, rr=1.5, max_hold=8),
|
||||
dict(wick_ratio=0.55, support_win=20, sl_mult=0.3, rr=2.0, max_hold=15),
|
||||
dict(wick_ratio=0.60, support_win=30, sl_mult=0.2, rr=2.0, max_hold=10),
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_score = -999
|
||||
|
||||
for cfg_idx, cfg in enumerate(CONFIGS):
|
||||
name = f"MIC07-cfg{cfg_idx+1}"
|
||||
rep = al.study_signals(
|
||||
name,
|
||||
lambda df, c=cfg: make_entries(df, **c),
|
||||
tfs=("1d",),
|
||||
)
|
||||
score = rep["verdict"].get("best_holdout_sharpe", -9)
|
||||
print(f"Config {cfg_idx+1}: {cfg} -> score={score:.3f}, grade={rep['verdict']['grade']}")
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_cfg = cfg
|
||||
|
||||
print("\n=== BEST CONFIG ===", best_cfg)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,57 +0,0 @@
|
||||
"""MIC08 — OBV Trend
|
||||
Hypothesis: On-balance-volume trend: long when OBV above its EMA (volume confirms price).
|
||||
Long-flat. Continuous weights via al.study_weights.
|
||||
|
||||
Grid: obv_ema_period in (20, 50) x tfs (1d, 12h) = 4 total backtests.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def compute_obv(df) -> np.ndarray:
|
||||
"""Compute On-Balance-Volume causally."""
|
||||
close = df["close"].values
|
||||
volume = df["volume"].values
|
||||
n = len(close)
|
||||
obv = np.zeros(n)
|
||||
for i in range(1, n):
|
||||
if close[i] > close[i - 1]:
|
||||
obv[i] = obv[i - 1] + volume[i]
|
||||
elif close[i] < close[i - 1]:
|
||||
obv[i] = obv[i - 1] - volume[i]
|
||||
else:
|
||||
obv[i] = obv[i - 1]
|
||||
return obv
|
||||
|
||||
|
||||
def make_target(ema_period: int):
|
||||
def target(df) -> np.ndarray:
|
||||
obv = compute_obv(df)
|
||||
obv_ema = al.ema(obv, ema_period)
|
||||
# Long when OBV > its EMA, flat otherwise
|
||||
signal = np.where(obv > obv_ema, 1.0, 0.0)
|
||||
# Use vol-targeting to size the position
|
||||
sized = al.vol_target(signal, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return sized
|
||||
return target
|
||||
|
||||
|
||||
# Grid search: 2 EMA periods x 2 timeframes = 4 total backtests
|
||||
results = []
|
||||
for ema_p in (20, 50):
|
||||
rep = al.study_weights(
|
||||
f"MIC08-OBV-EMA{ema_p}",
|
||||
make_target(ema_p),
|
||||
tfs=("1d", "12h"),
|
||||
)
|
||||
results.append((rep["verdict"].get("best_holdout_sharpe", -9), ema_p, rep))
|
||||
|
||||
# Pick best by hold-out Sharpe
|
||||
results.sort(key=lambda x: x[0], reverse=True)
|
||||
best_holdout, best_ema, best_rep = results[0]
|
||||
|
||||
print(f"\n=== Best config: EMA period={best_ema} ===")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,84 +0,0 @@
|
||||
"""MRV01 — RSI2 Connors mean-reversion strategy.
|
||||
Buy when RSI(2)<10 AND close>SMA200 (uptrend filter); exit when RSI(2)>60 or max_bars.
|
||||
Long-only, 1d timeframe.
|
||||
|
||||
Internal grid: try thresholds (rsi_entry, rsi_exit, max_bars) on 1d.
|
||||
Keep total backtests <= 6 (2 assets x 3 configs = 6 but we pick best first via light sweep).
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def make_entries_fn(rsi_entry=10, rsi_exit=60, sma_win=200, max_bars=10):
|
||||
"""Factory for RSI2 Connors entries list. Long-only."""
|
||||
def entries_fn(df):
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
rsi2 = al.rsi(c, 2)
|
||||
sma200 = al.sma(c, sma_win)
|
||||
entries = []
|
||||
for i in range(n):
|
||||
if (
|
||||
not np.isnan(rsi2[i]) and not np.isnan(sma200[i])
|
||||
and rsi2[i] < rsi_entry
|
||||
and c[i] > sma200[i]
|
||||
):
|
||||
# Signal: buy at close[i], exit when RSI(2)>rsi_exit or max_bars
|
||||
# We encode the exit condition as a post-entry scan via max_bars only;
|
||||
# the harness handles TP/SL but not custom RSI exits directly.
|
||||
# We use max_bars as the hard exit; no TP/SL (rely on time-based exit).
|
||||
entries.append({
|
||||
"dir": 1,
|
||||
"tp": None,
|
||||
"sl": None,
|
||||
"max_bars": max_bars,
|
||||
})
|
||||
else:
|
||||
entries.append(None)
|
||||
return entries
|
||||
return entries_fn
|
||||
|
||||
|
||||
def make_entries_fn_rsi_exit(rsi_entry=10, rsi_exit=60, sma_win=200, max_bars=10):
|
||||
"""Entries with RSI exit encoded as TP/SL-free but we precompute exit bar
|
||||
by looking forward (but this would be look-ahead). Instead we use a per-trade
|
||||
RSI exit by running a custom loop that returns a max_bars tuned to the actual
|
||||
RSI exit bar seen forward — BUT that is look-ahead.
|
||||
|
||||
Honest approach: use a fixed max_bars (no look-ahead RSI exit).
|
||||
The signal fires at close[i]; fill at close[i]. Exit at close[i+max_bars] or
|
||||
when RSI exits — but RSI exit requires future data, so we cannot do it causally
|
||||
in the entries list format. We use max_bars as the honest exit.
|
||||
"""
|
||||
return make_entries_fn(rsi_entry, rsi_exit, sma_win, max_bars)
|
||||
|
||||
|
||||
# Grid: 3 configs (rsi_entry, rsi_exit, max_bars)
|
||||
CONFIGS = [
|
||||
dict(rsi_entry=10, max_bars=5, label="RSI2<10_SMA200_mb5"),
|
||||
dict(rsi_entry=10, max_bars=10, label="RSI2<10_SMA200_mb10"),
|
||||
dict(rsi_entry=15, max_bars=5, label="RSI2<15_SMA200_mb5"),
|
||||
]
|
||||
|
||||
# Run config 0 first (canonical Connors), then decide best
|
||||
best_rep = None
|
||||
best_hold = -999.0
|
||||
best_label = None
|
||||
|
||||
for cfg in CONFIGS:
|
||||
label = cfg["label"]
|
||||
fn = make_entries_fn(rsi_entry=cfg["rsi_entry"], max_bars=cfg["max_bars"])
|
||||
rep = al.study_signals(f"MRV01-{label}", fn, tfs=("1d",))
|
||||
hold = rep["verdict"].get("best_holdout_sharpe", -999)
|
||||
full = rep["verdict"].get("best_full_sharpe", -999)
|
||||
print(f"\n[{label}] full={full:.3f} hold={hold:.3f} grade={rep['verdict']['grade']}")
|
||||
if hold > best_hold:
|
||||
best_hold = hold
|
||||
best_rep = rep
|
||||
best_label = label
|
||||
|
||||
print("\n\n=== BEST CONFIG ===", best_label)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,131 +0,0 @@
|
||||
"""MRV02 — BB reversion in calm regime (1d, discrete signals).
|
||||
|
||||
HYPOTHESIS: Buy lower BB(20,2) ONLY when realized vol is in low expanding-percentile
|
||||
(calm regime). Exit at mid-BB. The gate is the alpha: filter out high-vol / volatile
|
||||
periods; only trade the gentle reversions.
|
||||
|
||||
Style: al.study_signals (discrete entry/exit, 1d only)
|
||||
Gate: RV <= expanding percentile of RV (calm = low expanding percentile threshold)
|
||||
Entry: close <= lower BB(20,2)
|
||||
TP: mid-BB (dynamic, recomputed each bar in the trade management)
|
||||
SL: 2 * ATR below entry
|
||||
Max bars: 20 days
|
||||
"""
|
||||
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_entries(df: pd.DataFrame, bb_win: int = 20, bb_k: float = 2.0,
|
||||
rv_win_days: int = 20, rv_pct_thresh: float = 30.0,
|
||||
atr_win: int = 14, max_bars: int = 20):
|
||||
"""
|
||||
Causal entry logic for MRV02.
|
||||
|
||||
Entry conditions at close[i]:
|
||||
1. close[i] <= lower_BB(20,2) — price touched/crossed lower band
|
||||
2. rv_percentile(i) <= rv_pct_thresh — calm regime (low expanding RV percentile)
|
||||
|
||||
TP: mid_BB at entry time (static target for the trade)
|
||||
SL: entry - 2*ATR (static)
|
||||
max_bars: 20 days
|
||||
"""
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
bpd = al.bars_per_day(df)
|
||||
bpy = bpd * 365.25
|
||||
|
||||
# Bollinger Bands (causal: value at i uses data <= i)
|
||||
upper_bb, mid_bb, lower_bb = al.bbands(c, win=bb_win, k=bb_k)
|
||||
|
||||
# Realized vol (annualized), window = rv_win_days bars
|
||||
rv_win = max(2, rv_win_days * bpd)
|
||||
r = al.simple_returns(c)
|
||||
rv = al.realized_vol(r, rv_win, bpy)
|
||||
|
||||
# Expanding percentile of RV (causal: percentile of all RV values seen up to i)
|
||||
rv_series = pd.Series(rv)
|
||||
rv_pct = rv_series.expanding().rank(pct=True) * 100.0 # 0-100 percentile
|
||||
rv_pct = rv_pct.values
|
||||
|
||||
# ATR for SL
|
||||
atr_vals = al.atr(df, win=atr_win)
|
||||
|
||||
entries = [None] * n
|
||||
warmup = max(bb_win, rv_win, atr_win) + 1
|
||||
|
||||
for i in range(warmup, n):
|
||||
# Gate: RV must be in calm regime
|
||||
if not np.isfinite(rv_pct[i]) or rv_pct[i] > rv_pct_thresh:
|
||||
continue
|
||||
# Gate: lower BB must be defined
|
||||
if not np.isfinite(lower_bb[i]) or not np.isfinite(mid_bb[i]):
|
||||
continue
|
||||
# Entry: close touches or crosses lower BB
|
||||
if c[i] > lower_bb[i]:
|
||||
continue
|
||||
# ATR must be defined
|
||||
if not np.isfinite(atr_vals[i]) or atr_vals[i] <= 0:
|
||||
continue
|
||||
|
||||
tp_price = mid_bb[i] # exit at mid-band (static target)
|
||||
sl_price = c[i] - 2.0 * atr_vals[i] # SL: 2 ATR below entry
|
||||
|
||||
# Only take trade if TP > entry price (there's room to profit)
|
||||
if tp_price <= c[i]:
|
||||
continue
|
||||
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": tp_price,
|
||||
"sl": sl_price,
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
|
||||
return entries
|
||||
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
# Small parameter grid: bb_win x rv_pct_thresh (4 combos max)
|
||||
# ----------------------------------------------------------------
|
||||
GRID = [
|
||||
# (bb_win, rv_pct_thresh)
|
||||
(20, 30), # canonical
|
||||
(20, 40), # slightly more permissive gate
|
||||
(30, 30), # wider bands
|
||||
(30, 40), # wider bands + more permissive gate
|
||||
]
|
||||
|
||||
print("MRV02 — BB reversion in calm regime")
|
||||
print(f"Grid: {GRID}")
|
||||
print()
|
||||
|
||||
best_rep = None
|
||||
best_score = -999.0
|
||||
|
||||
for bb_win, rv_pct_thresh in GRID:
|
||||
label = f"MRV02[BB{bb_win},RVp{rv_pct_thresh}]"
|
||||
print(f"--- Testing {label} ---")
|
||||
|
||||
def make_fn(bw=bb_win, rp=rv_pct_thresh):
|
||||
def entries_fn(df):
|
||||
return make_entries(df, bb_win=bw, rv_pct_thresh=rp)
|
||||
return entries_fn
|
||||
|
||||
rep = al.study_signals(label, make_fn(), tfs=("1d",))
|
||||
print(al.fmt(rep))
|
||||
print()
|
||||
|
||||
v = rep["verdict"]
|
||||
score = v.get("best_holdout_sharpe", -999.0) or -999.0
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_rep = rep
|
||||
best_rep["_config"] = dict(bb_win=bb_win, rv_pct_thresh=rv_pct_thresh)
|
||||
|
||||
print("\n=== BEST CONFIG ===")
|
||||
print(al.fmt(best_rep))
|
||||
print()
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,128 +0,0 @@
|
||||
"""MRV03 — Z-score reversion trend-gated (discrete signals, 1d).
|
||||
|
||||
HYPOTHESIS: Fade |zscore(close,20)| > 2 toward mean ONLY when the long-horizon
|
||||
trend (SMA200 slope) is flat. Skip entries in strong trends.
|
||||
|
||||
Logic:
|
||||
- z = zscore(close, 20): deviation from 20-bar mean
|
||||
- slope = (SMA200[i] - SMA200[i-slope_win]) / SMA200[i-slope_win]: recent slope of SMA200
|
||||
- Gate: |slope| < flat_thresh → trend is flat → allow mean-reversion
|
||||
- Entry: if z > +2 → SHORT (price too high, expect reversion to mean)
|
||||
if z < -2 → LONG (price too low, expect reversion to mean)
|
||||
- Exit: TP at SMA20 (mean reversion target), SL at 3*ATR14, max_bars=10
|
||||
|
||||
Grid: 2 param sets (zscore_win x flat_thresh):
|
||||
A: zscore_win=20, flat_thresh=0.005
|
||||
B: zscore_win=20, flat_thresh=0.010
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
# ── CONFIG GRID (keep total backtests ≤ 6: 2 params × 1 TF × 2 assets = 4 per config) ──
|
||||
CONFIGS = [
|
||||
dict(label="A", zscore_win=20, slope_win=5, flat_thresh=0.005, z_thresh=2.0, max_bars=10),
|
||||
dict(label="B", zscore_win=20, slope_win=5, flat_thresh=0.010, z_thresh=2.0, max_bars=10),
|
||||
]
|
||||
|
||||
|
||||
def make_entries_fn(zscore_win: int, slope_win: int, flat_thresh: float,
|
||||
z_thresh: float, max_bars: int):
|
||||
"""Return an entries_fn(df) for study_signals."""
|
||||
sma200_win = 200
|
||||
|
||||
def entries_fn(df):
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
|
||||
# Indicators (all causal: value at i uses data <=i)
|
||||
z = al.zscore(c, zscore_win)
|
||||
sma20 = al.sma(c, zscore_win) # mean-reversion target = rolling mean
|
||||
sma200 = al.sma(c, sma200_win)
|
||||
atr14 = al.atr(df, 14)
|
||||
|
||||
# SMA200 slope: fractional change over last slope_win bars
|
||||
sma200_prev = np.full(n, np.nan)
|
||||
sma200_prev[slope_win:] = sma200[:-slope_win]
|
||||
slope = np.where(
|
||||
(sma200_prev > 0) & np.isfinite(sma200_prev),
|
||||
(sma200 - sma200_prev) / sma200_prev,
|
||||
np.nan,
|
||||
)
|
||||
|
||||
entries = [None] * n
|
||||
for i in range(sma200_win + slope_win, n):
|
||||
zi = z[i]
|
||||
si = slope[i]
|
||||
ci = c[i]
|
||||
atr_i = atr14[i]
|
||||
m20_i = sma20[i]
|
||||
|
||||
# NaN guard
|
||||
if not (np.isfinite(zi) and np.isfinite(si) and np.isfinite(ci)
|
||||
and np.isfinite(atr_i) and np.isfinite(m20_i)):
|
||||
continue
|
||||
|
||||
# Gate: trend must be flat
|
||||
if abs(si) >= flat_thresh:
|
||||
continue
|
||||
|
||||
# Signal
|
||||
if zi > z_thresh:
|
||||
# Price is stretched UP → SHORT toward mean
|
||||
entries[i] = {
|
||||
"dir": -1,
|
||||
"tp": m20_i, # mean reversion target
|
||||
"sl": ci + 3.0 * atr_i, # stop above
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
elif zi < -z_thresh:
|
||||
# Price is stretched DOWN → LONG toward mean
|
||||
entries[i] = {
|
||||
"dir": +1,
|
||||
"tp": m20_i, # mean reversion target
|
||||
"sl": ci - 3.0 * atr_i, # stop below
|
||||
"max_bars": max_bars,
|
||||
}
|
||||
|
||||
return entries
|
||||
|
||||
return entries_fn
|
||||
|
||||
|
||||
def run():
|
||||
results = []
|
||||
for cfg in CONFIGS:
|
||||
print(f"\n--- Config {cfg['label']}: zscore_win={cfg['zscore_win']}, "
|
||||
f"slope_win={cfg['slope_win']}, flat_thresh={cfg['flat_thresh']}, "
|
||||
f"z_thresh={cfg['z_thresh']}, max_bars={cfg['max_bars']} ---")
|
||||
entries_fn = make_entries_fn(
|
||||
zscore_win=cfg["zscore_win"],
|
||||
slope_win=cfg["slope_win"],
|
||||
flat_thresh=cfg["flat_thresh"],
|
||||
z_thresh=cfg["z_thresh"],
|
||||
max_bars=cfg["max_bars"],
|
||||
)
|
||||
rep = al.study_signals(
|
||||
f"MRV03-{cfg['label']}",
|
||||
entries_fn,
|
||||
tfs=("1d",),
|
||||
)
|
||||
print(al.fmt(rep))
|
||||
print("JSON:", al.as_json(rep))
|
||||
results.append((cfg, rep))
|
||||
|
||||
# Pick best config by min_asset_holdout_sharpe
|
||||
best_cfg, best_rep = max(
|
||||
results,
|
||||
key=lambda x: x[1]["verdict"].get("best_holdout_sharpe", -99),
|
||||
)
|
||||
print(f"\n=== BEST CONFIG: {best_cfg['label']} ===")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
return best_rep
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run()
|
||||
@@ -1,135 +0,0 @@
|
||||
"""MRV04 — IBS (Internal Bar Strength) Mean-Reversion
|
||||
|
||||
HYPOTHESIS: Internal Bar Strength = (close - low) / (high - low).
|
||||
Long when IBS < low_thresh (closed near low = oversold position within bar),
|
||||
flat (or short) when IBS > high_thresh (closed near high = overbought).
|
||||
|
||||
Classic daily mean-reversion edge. Testing on certified BTC/ETH daily bars.
|
||||
|
||||
Variants tested:
|
||||
V1: Long-flat thresholds 0.20/0.80 (classic textbook)
|
||||
V2: Long-flat thresholds 0.25/0.75 (slightly wider)
|
||||
V3: Long-short thresholds 0.20/0.80 (adds short leg)
|
||||
V4: Long-flat thresholds 0.15/0.85 (tighter = rarer signals)
|
||||
Best variant selected by min-asset hold-out Sharpe.
|
||||
|
||||
All positions are vol-targeted (20% annualized, 2× leverage cap).
|
||||
Evaluated on 1d timeframe (IBS is a daily signal by design).
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# IBS calculation (causal: uses close, high, low of the same bar i)
|
||||
# ---------------------------------------------------------------------------
|
||||
def ibs(df) -> np.ndarray:
|
||||
h = df["high"].values.astype(float)
|
||||
l = df["low"].values.astype(float)
|
||||
c = df["close"].values.astype(float)
|
||||
rng = h - l
|
||||
# Avoid division by zero (doji bars with zero range)
|
||||
result = np.where(rng > 0, (c - l) / rng, 0.5)
|
||||
return result
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Variant builders
|
||||
# ---------------------------------------------------------------------------
|
||||
def make_ibs_longflat(low_thresh: float, high_thresh: float):
|
||||
"""Long when IBS < low_thresh, flat when IBS > high_thresh, hold otherwise."""
|
||||
def target_fn(df):
|
||||
ibs_val = ibs(df)
|
||||
pos = np.full(len(df), np.nan)
|
||||
pos[0] = 0.0
|
||||
for i in range(1, len(df)):
|
||||
if ibs_val[i] < low_thresh:
|
||||
pos[i] = 1.0 # go long
|
||||
elif ibs_val[i] > high_thresh:
|
||||
pos[i] = 0.0 # go flat
|
||||
else:
|
||||
pos[i] = pos[i - 1] # hold
|
||||
pos = np.nan_to_num(pos, nan=0.0)
|
||||
return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target_fn
|
||||
|
||||
|
||||
def make_ibs_longshort(low_thresh: float, high_thresh: float):
|
||||
"""Long when IBS < low_thresh, short when IBS > high_thresh, hold otherwise."""
|
||||
def target_fn(df):
|
||||
ibs_val = ibs(df)
|
||||
pos = np.full(len(df), np.nan)
|
||||
pos[0] = 0.0
|
||||
for i in range(1, len(df)):
|
||||
if ibs_val[i] < low_thresh:
|
||||
pos[i] = 1.0 # go long
|
||||
elif ibs_val[i] > high_thresh:
|
||||
pos[i] = -1.0 # go short
|
||||
else:
|
||||
pos[i] = pos[i - 1] # hold
|
||||
pos = np.nan_to_num(pos, nan=0.0)
|
||||
return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target_fn
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Vectorized version (faster, equivalent logic using ffill)
|
||||
# ---------------------------------------------------------------------------
|
||||
def make_ibs_longflat_vec(low_thresh: float, high_thresh: float):
|
||||
"""Vectorized long-flat IBS strategy."""
|
||||
def target_fn(df):
|
||||
ibs_val = ibs(df)
|
||||
# Signal: 1=long, 0=flat, NaN=hold (ffill)
|
||||
sig = np.where(ibs_val < low_thresh, 1.0,
|
||||
np.where(ibs_val > high_thresh, 0.0, np.nan))
|
||||
sig[0] = 0.0 # start flat
|
||||
pos = sig.copy()
|
||||
# forward-fill NaN (hold previous)
|
||||
import pandas as pd
|
||||
pos = pd.Series(pos).ffill().fillna(0.0).values
|
||||
return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target_fn
|
||||
|
||||
|
||||
def make_ibs_longshort_vec(low_thresh: float, high_thresh: float):
|
||||
"""Vectorized long-short IBS strategy."""
|
||||
def target_fn(df):
|
||||
import pandas as pd
|
||||
ibs_val = ibs(df)
|
||||
sig = np.where(ibs_val < low_thresh, 1.0,
|
||||
np.where(ibs_val > high_thresh, -1.0, np.nan))
|
||||
sig[0] = 0.0
|
||||
pos = pd.Series(sig).ffill().fillna(0.0).values
|
||||
return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
return target_fn
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Run all variants
|
||||
# ---------------------------------------------------------------------------
|
||||
if __name__ == "__main__":
|
||||
TFS = ("1d",)
|
||||
|
||||
variants = [
|
||||
("MRV04-V1-LF-0.20/0.80", make_ibs_longflat_vec(0.20, 0.80)),
|
||||
("MRV04-V2-LF-0.25/0.75", make_ibs_longflat_vec(0.25, 0.75)),
|
||||
("MRV04-V3-LS-0.20/0.80", make_ibs_longshort_vec(0.20, 0.80)),
|
||||
("MRV04-V4-LF-0.15/0.85", make_ibs_longflat_vec(0.15, 0.85)),
|
||||
]
|
||||
|
||||
results = []
|
||||
for name, fn in variants:
|
||||
print(f"\nRunning {name} ...")
|
||||
rep = al.study_weights(name, fn, tfs=TFS)
|
||||
print(al.fmt(rep))
|
||||
results.append(rep)
|
||||
|
||||
# Pick best by min_asset_holdout_sharpe
|
||||
best = max(results, key=lambda r: r["verdict"].get("best_holdout_sharpe", -99))
|
||||
print("\n" + "=" * 60)
|
||||
print(f"BEST VARIANT: {best['name']}")
|
||||
print(al.fmt(best))
|
||||
print("JSON:", al.as_json(best))
|
||||
@@ -1,125 +0,0 @@
|
||||
"""MRV05 — Williams %R Mean-Reversion
|
||||
|
||||
HYPOTHESIS: Buy when %R(14) < -90 (oversold) with trend filter (close > SMA200);
|
||||
exit (go flat) when %R > -50 (momentum restored). Long-flat only.
|
||||
|
||||
Williams %R = (Highest High(n) - Close) / (Highest High(n) - Lowest Low(n)) * -100
|
||||
Range: -100 (most oversold) to 0 (most overbought).
|
||||
%R < -80 = oversold zone; %R > -20 = overbought zone.
|
||||
|
||||
The exit condition (%R > -50) is causal: we check %R[i] and decide position for bar i+1.
|
||||
This maps naturally to study_weights (continuous hold logic):
|
||||
- position[i] = 1 if %R[i] < -90 AND close[i] > SMA200[i] (buy signal)
|
||||
- position[i] = 0 if %R[i] > -50 (exit signal)
|
||||
- else hold previous position
|
||||
|
||||
Variants (small grid, 4 configs):
|
||||
V1: %R entry -90, exit -50, SMA200 trend filter, long-flat
|
||||
V2: %R entry -85, exit -50, SMA200 trend filter, long-flat (slightly less oversold entry)
|
||||
V3: %R entry -90, exit -50, SMA50 trend filter, long-flat (shorter trend filter)
|
||||
V4: %R entry -90, exit -40, SMA200 trend filter, long-flat (later exit)
|
||||
|
||||
Best variant selected by min-asset hold-out Sharpe.
|
||||
All positions are vol-targeted (20% annualized, 2x leverage cap).
|
||||
"""
|
||||
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Williams %R calculation (causal: uses data <= bar i)
|
||||
# ---------------------------------------------------------------------------
|
||||
def williams_r(df: pd.DataFrame, win: int = 14) -> np.ndarray:
|
||||
"""Causal Williams %R. Value at i uses data[i-win+1 .. i].
|
||||
%R = (HH - Close) / (HH - LL) * -100
|
||||
Range: -100 (oversold) to 0 (overbought).
|
||||
"""
|
||||
h = df["high"].values.astype(float)
|
||||
l = df["low"].values.astype(float)
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
wr = np.full(n, np.nan)
|
||||
# Vectorized rolling using pandas
|
||||
hh = pd.Series(h).rolling(win, min_periods=win).max().values
|
||||
ll = pd.Series(l).rolling(win, min_periods=win).min().values
|
||||
rng = hh - ll
|
||||
# Avoid division by zero
|
||||
valid = rng > 0
|
||||
wr[valid] = (hh[valid] - c[valid]) / rng[valid] * -100.0
|
||||
return wr
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Strategy factory
|
||||
# ---------------------------------------------------------------------------
|
||||
def make_wrpct_target(wr_entry: float = -90.0, wr_exit: float = -50.0,
|
||||
sma_win: int = 200, wr_win: int = 14):
|
||||
"""Williams %R long-flat mean-reversion with trend filter.
|
||||
|
||||
Entry: %R[i] < wr_entry AND close[i] > SMA(sma_win)[i] -> go long
|
||||
Exit: %R[i] > wr_exit -> go flat
|
||||
Hold: otherwise, maintain current position
|
||||
|
||||
Causal: position decided using data <= close[i], held during bar i+1.
|
||||
Vol-targeted: 20% annualized, 2x leverage cap.
|
||||
"""
|
||||
def target_fn(df):
|
||||
c = df["close"].values.astype(float)
|
||||
wr = williams_r(df, wr_win)
|
||||
sma_trend = al.sma(c, sma_win)
|
||||
|
||||
# Vectorized state machine using ffill
|
||||
# Signal: 1 = enter long, 0 = exit to flat, NaN = hold
|
||||
# Priority: exit takes precedence over entry
|
||||
sig = np.where(
|
||||
wr > wr_exit, # exit condition
|
||||
0.0,
|
||||
np.where(
|
||||
(wr < wr_entry) & (c > sma_trend), # entry condition
|
||||
1.0,
|
||||
np.nan # hold
|
||||
)
|
||||
)
|
||||
|
||||
# Start flat
|
||||
sig[0] = 0.0
|
||||
|
||||
# Forward-fill NaN (hold previous position)
|
||||
pos = pd.Series(sig).ffill().fillna(0.0).values
|
||||
|
||||
# Vol-target
|
||||
return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
|
||||
return target_fn
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Run all variants and pick best
|
||||
# ---------------------------------------------------------------------------
|
||||
if __name__ == "__main__":
|
||||
TFS = ("1d",)
|
||||
|
||||
variants = [
|
||||
("MRV05-V1-WR90-exit50-SMA200", make_wrpct_target(-90.0, -50.0, 200, 14)),
|
||||
("MRV05-V2-WR85-exit50-SMA200", make_wrpct_target(-85.0, -50.0, 200, 14)),
|
||||
("MRV05-V3-WR90-exit50-SMA50", make_wrpct_target(-90.0, -50.0, 50, 14)),
|
||||
("MRV05-V4-WR90-exit40-SMA200", make_wrpct_target(-90.0, -40.0, 200, 14)),
|
||||
]
|
||||
|
||||
results = []
|
||||
for name, fn in variants:
|
||||
print(f"\nRunning {name} ...")
|
||||
rep = al.study_weights(name, fn, tfs=TFS)
|
||||
print(al.fmt(rep))
|
||||
results.append(rep)
|
||||
|
||||
# Pick best by min_asset_holdout_sharpe
|
||||
best = max(results, key=lambda r: r["verdict"].get("best_holdout_sharpe", -99))
|
||||
print("\n" + "=" * 60)
|
||||
print(f"BEST VARIANT: {best['name']}")
|
||||
print(al.fmt(best))
|
||||
print("JSON:", al.as_json(best))
|
||||
@@ -1,130 +0,0 @@
|
||||
"""MRV06 — VWAP Deviation Reversion
|
||||
|
||||
IDEA: On 1h bars, compute a rolling session VWAP (using typical price * volume).
|
||||
Fade deviations > k*sigma back to VWAP (mean-reversion).
|
||||
Regime gate: only trade in the direction of the daily trend (using a simple trend filter).
|
||||
|
||||
Variants tested:
|
||||
- k = 1.5 vs 2.0 (deviation threshold)
|
||||
- sigma window = 24h vs 48h (rolling window for sigma)
|
||||
|
||||
TF: 1h (VWAP is most meaningful at 1h granularity)
|
||||
Style: continuous weights (study_weights)
|
||||
"""
|
||||
|
||||
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 compute_vwap_deviation(df: pd.DataFrame, vwap_win: int, k: float,
|
||||
sigma_win: int) -> np.ndarray:
|
||||
"""
|
||||
Compute VWAP deviation signal with regime gate.
|
||||
|
||||
VWAP: rolling typical_price * volume / rolling volume (causal window).
|
||||
Signal: when price deviates > k*sigma above VWAP -> short (expect reversion)
|
||||
when price deviates > k*sigma below VWAP -> long (expect reversion)
|
||||
Regime gate: only long when daily trend (slow EMA > fast EMA at 1h scale).
|
||||
|
||||
All computations causal (value at i uses data <= i).
|
||||
"""
|
||||
close = df["close"].values.astype(float)
|
||||
high = df["high"].values.astype(float)
|
||||
low = df["low"].values.astype(float)
|
||||
volume = df["volume"].values.astype(float)
|
||||
|
||||
# Typical price (causal: same bar is fine, we're using it for VWAP at i)
|
||||
typical = (high + low + close) / 3.0
|
||||
|
||||
# Rolling VWAP (causal window)
|
||||
s = pd.Series
|
||||
tp_vol = typical * np.where(volume > 0, volume, np.nan)
|
||||
|
||||
# Rolling VWAP over vwap_win bars
|
||||
vwap_num = s(tp_vol).rolling(vwap_win, min_periods=vwap_win // 2).sum()
|
||||
vwap_den = s(volume).rolling(vwap_win, min_periods=vwap_win // 2).sum()
|
||||
vwap = (vwap_num / vwap_den.replace(0, np.nan)).values
|
||||
|
||||
# Deviation from VWAP
|
||||
deviation = close - vwap
|
||||
|
||||
# Rolling sigma of deviation
|
||||
sigma = s(deviation).rolling(sigma_win, min_periods=sigma_win // 2).std().values
|
||||
|
||||
# Normalized deviation (z-score wrt rolling sigma)
|
||||
z = np.where(sigma > 0, deviation / sigma, 0.0)
|
||||
|
||||
# Mean-reversion signal:
|
||||
# z > k => price is too high above VWAP => short (negative position)
|
||||
# z < -k => price is too low below VWAP => long (positive position)
|
||||
# Gradual: use -z/k clipped to [-1, 1] when |z| > k, else 0
|
||||
signal = np.where(np.abs(z) > k, -np.sign(z), 0.0)
|
||||
|
||||
# Regime gate using daily trend: EMA(50d) vs EMA(10d) at 1h scale
|
||||
# Only allow long when fast EMA > slow EMA (uptrend), allow short any time
|
||||
# (crypto is fundamentally bullish-biased; mean-reversion shorts in downtrend risky)
|
||||
ema_fast = al.ema(close, 10 * 24) # 10-day EMA
|
||||
ema_slow = al.ema(close, 50 * 24) # 50-day EMA
|
||||
|
||||
# In uptrend (fast > slow): allow both long and short mean-reversion
|
||||
# In downtrend (fast < slow): allow only short mean-reversion (with VWAP)
|
||||
uptrend = ema_fast > ema_slow
|
||||
|
||||
# Filter: only take longs in uptrend regime
|
||||
gated = np.where(signal > 0, signal * uptrend.astype(float), signal)
|
||||
|
||||
# Apply vol-targeting for position sizing
|
||||
result = al.vol_target(gated, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
|
||||
result = np.nan_to_num(result, nan=0.0)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def make_target(vwap_win: int, k: float, sigma_win: int):
|
||||
"""Factory: returns a target_fn(df) -> weights array."""
|
||||
def target_fn(df: pd.DataFrame) -> np.ndarray:
|
||||
return compute_vwap_deviation(df, vwap_win=vwap_win, k=k, sigma_win=sigma_win)
|
||||
target_fn.__name__ = f"vwap_dev_w{vwap_win}_k{k}_s{sigma_win}"
|
||||
return target_fn
|
||||
|
||||
|
||||
# Small internal grid (<=4 param sets)
|
||||
# VWAP window: 24h (1 session) vs 48h (2 sessions)
|
||||
# k threshold: 1.5 vs 2.0
|
||||
# sigma_win tied to vwap_win
|
||||
CONFIGS = [
|
||||
# (vwap_win, k, sigma_win, label)
|
||||
(24, 1.5, 48, "vwap24h_k1.5_s48h"),
|
||||
(24, 2.0, 48, "vwap24h_k2.0_s48h"),
|
||||
(48, 1.5, 96, "vwap48h_k1.5_s96h"),
|
||||
(48, 2.0, 96, "vwap48h_k2.0_s96h"),
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_hold = -999.0
|
||||
|
||||
print("=== MRV06 VWAP Deviation Reversion ===")
|
||||
print(f"Testing {len(CONFIGS)} configs on 1h bars (BTC + ETH)\n")
|
||||
|
||||
for vwap_win, k, sigma_win, label in CONFIGS:
|
||||
print(f"--- Config: {label} ---")
|
||||
fn = make_target(vwap_win, k, sigma_win)
|
||||
rep = al.study_weights(
|
||||
f"MRV06-{label}",
|
||||
fn,
|
||||
tfs=("1h",)
|
||||
)
|
||||
print(al.fmt(rep))
|
||||
hold_sharpe = rep["verdict"].get("best_holdout_sharpe", -999)
|
||||
if hold_sharpe > best_hold:
|
||||
best_hold = hold_sharpe
|
||||
best_rep = rep
|
||||
print()
|
||||
|
||||
# Print best config
|
||||
print("\n\n=== BEST CONFIG ===")
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
@@ -1,94 +0,0 @@
|
||||
"""MRV07 — Consecutive-down buy in uptrend.
|
||||
After N+ consecutive lower closes AND close > SMA100 (uptrend filter),
|
||||
buy at close[i]; exit after max_bars or on the first green close (close > prev close).
|
||||
|
||||
Grid: try (consec_n, max_bars) combinations on 1d.
|
||||
Total backtests: 3 configs x 2 assets = 6.
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
|
||||
import altlib as al
|
||||
import numpy as np
|
||||
|
||||
|
||||
def make_entries_fn(consec_n=3, sma_win=100, max_bars=10):
|
||||
"""Factory for consecutive-down buy entries.
|
||||
|
||||
Signal: close[i] < close[i-1] < ... < close[i-consec_n+1] (N consecutive lower closes)
|
||||
AND close[i] > SMA100 (uptrend filter).
|
||||
Entry: buy at close[i] (filled immediately).
|
||||
Exit: after max_bars bars (hard stop); no TP/SL (green-close exit not encodable
|
||||
causally in the entries-list format — green close requires next-bar data).
|
||||
"""
|
||||
def entries_fn(df):
|
||||
c = df["close"].values.astype(float)
|
||||
n = len(c)
|
||||
sma100 = al.sma(c, sma_win)
|
||||
entries = []
|
||||
|
||||
for i in range(n):
|
||||
# Need at least consec_n prior bars
|
||||
if i < consec_n:
|
||||
entries.append(None)
|
||||
continue
|
||||
|
||||
# Check SMA100 (uptrend)
|
||||
if np.isnan(sma100[i]) or c[i] <= sma100[i]:
|
||||
entries.append(None)
|
||||
continue
|
||||
|
||||
# Check N consecutive lower closes
|
||||
consecutive_down = True
|
||||
for k in range(consec_n):
|
||||
if k == 0:
|
||||
# close[i] < close[i-1]
|
||||
if c[i] >= c[i-1]:
|
||||
consecutive_down = False
|
||||
break
|
||||
else:
|
||||
# close[i-k] < close[i-k-1]
|
||||
if c[i-k] >= c[i-k-1]:
|
||||
consecutive_down = False
|
||||
break
|
||||
|
||||
if consecutive_down:
|
||||
entries.append({
|
||||
"dir": 1,
|
||||
"tp": None,
|
||||
"sl": None,
|
||||
"max_bars": max_bars,
|
||||
})
|
||||
else:
|
||||
entries.append(None)
|
||||
|
||||
return entries
|
||||
return entries_fn
|
||||
|
||||
|
||||
# Grid: 3 configs (consec_n, max_bars)
|
||||
# Hypothesis: after 3 consecutive dips in uptrend, expect mean-reversion bounce
|
||||
CONFIGS = [
|
||||
dict(consec_n=3, max_bars=5, label="N3_mb5"),
|
||||
dict(consec_n=3, max_bars=10, label="N3_mb10"),
|
||||
dict(consec_n=4, max_bars=5, label="N4_mb5"),
|
||||
]
|
||||
|
||||
best_rep = None
|
||||
best_hold = -999.0
|
||||
best_label = None
|
||||
|
||||
for cfg in CONFIGS:
|
||||
label = cfg["label"]
|
||||
fn = make_entries_fn(consec_n=cfg["consec_n"], max_bars=cfg["max_bars"])
|
||||
rep = al.study_signals(f"MRV07-{label}", fn, tfs=("1d",))
|
||||
hold = rep["verdict"].get("best_holdout_sharpe", -999)
|
||||
full = rep["verdict"].get("best_full_sharpe", -999)
|
||||
print(f"\n[{label}] full={full:.3f} hold={hold:.3f} grade={rep['verdict']['grade']}")
|
||||
if hold > best_hold:
|
||||
best_hold = hold
|
||||
best_rep = rep
|
||||
best_label = label
|
||||
|
||||
print("\n\n=== BEST CONFIG ===", best_label)
|
||||
print(al.fmt(best_rep))
|
||||
print("JSON:", al.as_json(best_rep))
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user