Sync from GitHub: 7e71c6b91cb36cef701b24bb05297201488f3df3

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/data/data/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/README.md

@@ -1,3 +1,15 @@
+---
+title: P2-ETF-CNN-LSTM-ALTERNATIVE-APPROACHES
+emoji: 🧠
+colorFrom: green
+colorTo: blue
+sdk: streamlit
+sdk_version: "1.32.0"
+python_version: "3.10"
+app_file: app.py
+pinned: false
+---
+
 # P2-ETF-CNN-LSTM-ALTERNATIVE-APPROACHES
 
 Macro-driven ETF rotation using three augmented CNN-LSTM variants.  

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/data/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/data/loader.py

@@ -0,0 +1,215 @@
+"""
+data/loader.py
+Loads master_data.parquet from HF Dataset.
+Validates freshness against the last NYSE trading day.
+No external pings — all data comes from HF Dataset only.
+"""
+
+import pandas as pd
+import numpy as np
+import streamlit as st
+from huggingface_hub import hf_hub_download
+from datetime import datetime, timedelta
+import pytz
+import os
+
+try:
+    import pandas_market_calendars as mcal
+    NYSE_CAL_AVAILABLE = True
+except ImportError:
+    NYSE_CAL_AVAILABLE = False
+
+DATASET_REPO = "P2SAMAPA/fi-etf-macro-signal-master-data"
+PARQUET_FILE = "master_data.parquet"
+
+# Columns expected in the dataset
+REQUIRED_ETF_COLS   = ["TLT_Ret", "TBT_Ret", "VNQ_Ret", "SLV_Ret", "GLD_Ret"]
+BENCHMARK_COLS      = ["SPY_Ret", "AGG_Ret"]
+TBILL_COL           = "DTB3"          # 3m T-bill column in HF dataset
+TARGET_ETFS         = REQUIRED_ETF_COLS   # 5 targets (no CASH in returns, CASH handled in strategy)
+
+
+# ── NYSE calendar helpers ─────────────────────────────────────────────────────
+
+def get_last_nyse_trading_day(as_of: datetime = None) -> datetime.date:
+    """Return the most recent NYSE trading day before or on as_of (default: today EST)."""
+    est = pytz.timezone("US/Eastern")
+    if as_of is None:
+        as_of = datetime.now(est)
+
+    today = as_of.date()
+
+    if NYSE_CAL_AVAILABLE:
+        try:
+            nyse = mcal.get_calendar("NYSE")
+            # Look back up to 10 days to find last trading day
+            start = today - timedelta(days=10)
+            schedule = nyse.schedule(start_date=start, end_date=today)
+            if len(schedule) > 0:
+                return schedule.index[-1].date()
+        except Exception:
+            pass
+
+    # Fallback: skip weekends
+    candidate = today
+    while candidate.weekday() >= 5:
+        candidate -= timedelta(days=1)
+    return candidate
+
+
+def is_nyse_trading_day(date) -> bool:
+    """Return True if date is a NYSE trading day."""
+    if NYSE_CAL_AVAILABLE:
+        try:
+            nyse = mcal.get_calendar("NYSE")
+            schedule = nyse.schedule(start_date=date, end_date=date)
+            return len(schedule) > 0
+        except Exception:
+            pass
+    return date.weekday() < 5
+
+
+# ── Data loading ──────────────────────────────────────────────────────────────
+
+@st.cache_data(ttl=3600, show_spinner=False)
+def load_dataset(hf_token: str) -> pd.DataFrame:
+    """
+    Download master_data.parquet from HF Dataset and return as DataFrame.
+    Cached for 1 hour. Index is parsed as DatetimeIndex.
+    """
+    try:
+        path = hf_hub_download(
+            repo_id=DATASET_REPO,
+            filename=PARQUET_FILE,
+            repo_type="dataset",
+            token=hf_token,
+        )
+        df = pd.read_parquet(path)
+
+        # Ensure DatetimeIndex
+        if not isinstance(df.index, pd.DatetimeIndex):
+            if "Date" in df.columns:
+                df = df.set_index("Date")
+            elif "date" in df.columns:
+                df = df.set_index("date")
+            df.index = pd.to_datetime(df.index)
+
+        df = df.sort_index()
+        return df
+
+    except Exception as e:
+        st.error(f"❌ Failed to load dataset from HuggingFace: {e}")
+        return pd.DataFrame()
+
+
+# ── Freshness check ───────────────────────────────────────────────────────────
+
+def check_data_freshness(df: pd.DataFrame) -> dict:
+    """
+    Check whether the dataset contains data for the last NYSE trading day.
+
+    Returns a dict:
+        {
+            "fresh": bool,
+            "last_date_in_data": date,
+            "expected_date": date,
+            "message": str
+        }
+    """
+    if df.empty:
+        return {
+            "fresh": False,
+            "last_date_in_data": None,
+            "expected_date": None,
+            "message": "Dataset is empty.",
+        }
+
+    last_date_in_data = df.index[-1].date()
+    expected_date     = get_last_nyse_trading_day()
+
+    fresh = last_date_in_data >= expected_date
+
+    if fresh:
+        message = f"✅ Dataset is up to date through **{last_date_in_data}**."
+    else:
+        message = (
+            f"⚠️ **{expected_date}** data not yet updated in dataset. "
+            f"Latest available: **{last_date_in_data}**. "
+            f"Please check back later — the dataset updates daily after market close."
+        )
+
+    return {
+        "fresh": fresh,
+        "last_date_in_data": last_date_in_data,
+        "expected_date": expected_date,
+        "message": message,
+    }
+
+
+# ── Feature / target extraction ───────────────────────────────────────��───────
+
+def get_features_and_targets(df: pd.DataFrame):
+    """
+    Extract input feature columns and target ETF return columns from the dataset.
+
+    Returns:
+        input_features : list of column names
+        target_etfs    : list of ETF return column names (e.g. TLT_Ret)
+        tbill_rate     : latest 3m T-bill rate as a float (annualised, e.g. 0.045)
+    """
+    # Target ETF return columns
+    target_etfs = [c for c in REQUIRED_ETF_COLS if c in df.columns]
+
+    if not target_etfs:
+        raise ValueError(
+            f"No target ETF columns found. Expected: {REQUIRED_ETF_COLS}. "
+            f"Found in dataset: {list(df.columns)}"
+        )
+
+    # Input features: Z-scores, vol, regime, yield curve, credit, rates, VIX terms
+    exclude = set(target_etfs + BENCHMARK_COLS + [TBILL_COL])
+    input_features = [
+        c for c in df.columns
+        if c not in exclude
+        and (
+            c.endswith("_Z")
+            or c.endswith("_Vol")
+            or "Regime" in c
+            or "YC_"    in c
+            or "Credit_" in c
+            or "Rates_"  in c
+            or "VIX_"    in c
+            or "Spread"  in c
+            or "DXY"     in c
+            or "VIX"     in c
+            or "T10Y"    in c
+        )
+    ]
+
+    # 3m T-bill rate (for CASH return & Sharpe)
+    tbill_rate = 0.045   # default fallback
+    if TBILL_COL in df.columns:
+        raw = df[TBILL_COL].dropna()
+        if len(raw) > 0:
+            last_val = raw.iloc[-1]
+            # DTB3 is typically in percent (e.g. 5.25 means 5.25%)
+            tbill_rate = float(last_val) / 100 if last_val > 1 else float(last_val)
+
+    return input_features, target_etfs, tbill_rate
+
+
+# ── Column info helper (for sidebar display) ──────────────────────────────────
+
+def dataset_summary(df: pd.DataFrame) -> dict:
+    """Return a brief summary dict for sidebar display."""
+    if df.empty:
+        return {}
+    return {
+        "rows":       len(df),
+        "columns":    len(df.columns),
+        "start_date": df.index[0].strftime("%Y-%m-%d"),
+        "end_date":   df.index[-1].strftime("%Y-%m-%d"),
+        "etfs_found": [c for c in REQUIRED_ETF_COLS if c in df.columns],
+        "benchmarks": [c for c in BENCHMARK_COLS     if c in df.columns],
+        "tbill_found": TBILL_COL in df.columns,
+    }

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/README.md

@@ -1,19 +1,115 @@
+# P2-ETF-CNN-LSTM-ALTERNATIVE-APPROACHES
+
+Macro-driven ETF rotation using three augmented CNN-LSTM variants.  
+Winner selected by **highest raw annualised return** on the out-of-sample test set.
+
+---
+
+## Architecture Overview
+
+| Approach | Core Idea | Key Addition |
+|---|---|---|
+| **1 — Wavelet** | DWT decomposes each macro signal into frequency subbands before the CNN | Separates trend / cycle / noise |
+| **2 — Regime-Conditioned** | HMM detects macro regimes; one-hot regime label concatenated into the network | Removes non-stationarity |
+| **3 — Multi-Scale Parallel** | Three CNN towers (kernels 3, 7, 21 days) run in parallel before the LSTM | Captures momentum + cycle + trend simultaneously |
+
 ---
-title: P2 ETF CNN LSTM ALTERNATIVE APPROACHES
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
+
+## ETF Universe
+
+| Ticker | Description |
+|---|---|
+| TLT | 20+ Year Treasury Bond |
+| TBT | 20+ Year Treasury Short (2×) |
+| VNQ | Real Estate (REIT) |
+| SLV | Silver |
+| GLD | Gold |
+| CASH | 3m T-bill rate (from HF dataset) |
+
+Benchmarks (chart only, not traded): **SPY**, **AGG**
+
+---
+
+## Data
+
+All data sourced exclusively from:  
+**`P2SAMAPA/fi-etf-macro-signal-master-data`** (HuggingFace Dataset)  
+File: `master_data.parquet`
+
+No external API calls (no yfinance, no FRED).  
+The app checks daily whether the prior NYSE trading day's data is present in the dataset.
+
 ---
 
-# Welcome to Streamlit!
+## Project Structure
+
+```
+├── .github/
+│   └── workflows/
+│       └── sync.yml            # Auto-sync GitHub → HF Space on push to main
+│
+├── app.py                      # Streamlit orchestrator (UI wiring only)
+│
+├── data/
+│   └── loader.py               # HF dataset load, freshness check, column validation
+│
+├── models/
+│   ├── base.py                 # Shared: sequences, splits, scaling, callbacks
+│   ├── approach1_wavelet.py    # Wavelet CNN-LSTM
+│   ├── approach2_regime.py     # Regime-Conditioned CNN-LSTM
+│   └── approach3_multiscale.py # Multi-Scale Parallel CNN-LSTM
+│
+├── strategy/
+│   └── backtest.py             # execute_strategy, metrics, winner selection
+│
+├── signals/
+│   └── conviction.py           # Z-score conviction scoring
+│
+├── ui/
+│   ├── components.py           # Banner, conviction panel, metrics, audit trail
+│   └── charts.py               # Plotly equity curve + comparison bar chart
+│
+├── utils/
+│   └── calendar.py             # NYSE calendar, next trading day, EST time
+│
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## Secrets Required
+
+| Secret | Where | Purpose |
+|---|---|---|
+| `HF_TOKEN` | GitHub + HF Space | Read HF dataset · Sync HF Space |
+
+Set in:
+- GitHub: `Settings → Secrets → Actions → New repository secret`
+- HF Space: `Settings → Repository secrets`
+
+---
+
+## Deployment
+
+Push to `main` → GitHub Actions (`sync.yml`) automatically syncs to HF Space.
+
+### Local development
+
+```bash
+pip install -r requirements.txt
+export HF_TOKEN=your_token
+streamlit run app.py
+```
+
+---
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Output UI
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+1. **Data freshness warning** — alerts if prior NYSE trading day data is missing
+2. **Next Trading Day Signal** — date + ETF from the winning approach
+3. **Signal Conviction** — Z-score gauge + per-ETF probability bars
+4. **Performance Metrics** — Annualised Return, Sharpe, Hit Ratio, Max DD
+5. **Approach Comparison Table** — all three approaches side by side
+6. **Equity Curves** — all three approaches + SPY + AGG benchmarks
+7. **Audit Trail** — last 20 trading days for the winning approach

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/app.py

@@ -0,0 +1,273 @@
+"""
+app.py
+P2-ETF-CNN-LSTM-ALTERNATIVE-APPROACHES
+Streamlit orchestrator — UI wiring only, no business logic here.
+"""
+
+import os
+import streamlit as st
+import pandas as pd
+import numpy as np
+
+# ── Module imports ────────────────────────────────────────────────────────────
+from data.loader      import load_dataset, check_data_freshness, get_features_and_targets, dataset_summary
+from utils.calendar   import get_est_time, is_sync_window, get_next_signal_date
+from models.base      import build_sequences, train_val_test_split, scale_features, returns_to_labels
+from models.approach1_wavelet    import train_approach1, predict_approach1
+from models.approach2_regime     import train_approach2, predict_approach2
+from models.approach3_multiscale import train_approach3, predict_approach3
+from strategy.backtest  import execute_strategy, select_winner, build_comparison_table
+from signals.conviction import compute_conviction
+from ui.components import (
+    show_freshness_status, show_signal_banner, show_conviction_panel,
+    show_metrics_row, show_comparison_table, show_audit_trail,
+)
+from ui.charts import equity_curve_chart, comparison_bar_chart
+
+# ── Page config ───────────────────────────────────────────────────────────────
+st.set_page_config(
+    page_title="P2-ETF-CNN-LSTM",
+    page_icon="🧠",
+    layout="wide",
+)
+
+# ── Secrets ───────────────────────────────────────────────────────────────────
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+
+# ── Sidebar ───────────────────────────────────────────────────────────────────
+with st.sidebar:
+    st.header("⚙️ Configuration")
+
+    now_est = get_est_time()
+    st.write(f"🕒 **EST:** {now_est.strftime('%H:%M:%S')}")
+    if is_sync_window():
+        st.success("✅ Sync Window Active")
+    else:
+        st.info("⏸️ Sync Window Inactive")
+
+    st.divider()
+
+    start_yr = st.slider("📅 Start Year", 2010, 2024, 2016)
+    fee_bps  = st.slider("💰 Fee (bps)", 0, 50, 10)
+    lookback = st.slider("📐 Lookback (days)", 20, 60, 30, step=5)
+    epochs   = st.number_input("🔁 Max Epochs", 20, 300, 100, step=10)
+
+    st.divider()
+
+    split_option = st.selectbox("📊 Train/Val/Test Split", ["70/15/15", "80/10/10"], index=0)
+    split_map    = {"70/15/15": (0.70, 0.15), "80/10/10": (0.80, 0.10)}
+    train_pct, val_pct = split_map[split_option]
+
+    include_cash = st.checkbox("💵 Include CASH class", value=True,
+                               help="Model can select CASH (earns T-bill rate) as an alternative to any ETF")
+
+    st.divider()
+
+    run_button = st.button("🚀 Run All 3 Approaches", type="primary", use_container_width=True)
+
+# ── Title ─────────────────────────────────────────────────────────────────────
+st.title("🧠 P2-ETF-CNN-LSTM")
+st.caption("Approach 1: Wavelet  ·  Approach 2: Regime-Conditioned  ·  Approach 3: Multi-Scale Parallel")
+st.caption("Winner selected by highest raw annualised return on out-of-sample test set.")
+
+# ── Load data (always, to check freshness) ────────────────────────────────────
+if not HF_TOKEN:
+    st.error("❌ HF_TOKEN secret not found. Please add it to your HF Space / GitHub secrets.")
+    st.stop()
+
+with st.spinner("📡 Loading dataset from HuggingFace..."):
+    df = load_dataset(HF_TOKEN)
+
+if df.empty:
+    st.stop()
+
+# ── Freshness check ───────────────────────────────────────────────────────────
+freshness = check_data_freshness(df)
+show_freshness_status(freshness)
+
+# ── Dataset summary in sidebar ────────────────────────────────────────────────
+with st.sidebar:
+    st.divider()
+    st.subheader("📦 Dataset Info")
+    summary = dataset_summary(df)
+    if summary:
+        st.write(f"**Rows:** {summary['rows']:,}")
+        st.write(f"**Range:** {summary['start_date']} → {summary['end_date']}")
+        st.write(f"**ETFs:** {', '.join([e.replace('_Ret','') for e in summary['etfs_found']])}")
+        st.write(f"**Benchmarks:** {', '.join([b.replace('_Ret','') for b in summary['benchmarks']])}")
+        st.write(f"**T-bill col:** {'✅' if summary['tbill_found'] else '❌'}")
+
+# ── Main execution ────────────────────────────────────────────────────────────
+if not run_button:
+    st.info("👈 Configure parameters in the sidebar and click **🚀 Run All 3 Approaches** to begin.")
+    st.stop()
+
+# ── Filter by start year ──────────────────────────────────────────────────────
+df = df[df.index.year >= start_yr].copy()
+st.write(f"📅 **Data:** {df.index[0].strftime('%Y-%m-%d')} → {df.index[-1].strftime('%Y-%m-%d')}  "
+         f"({df.index[-1].year - df.index[0].year + 1} years)")
+
+# ── Feature / target extraction ───────────────────────────────────────────────
+try:
+    input_features, target_etfs, tbill_rate = get_features_and_targets(df)
+except ValueError as e:
+    st.error(str(e))
+    st.stop()
+
+st.info(f"🎯 **Targets:** {len(target_etfs)} ETFs  ·  **Features:** {len(input_features)} signals  ·  "
+        f"**T-bill rate:** {tbill_rate*100:.2f}%")
+
+# ── Prepare sequences ─────────────────────────────────────────────────────────
+X_raw    = df[input_features].values.astype(np.float32)
+y_raw    = df[target_etfs].values.astype(np.float32)
+n_etfs   = len(target_etfs)
+n_classes = n_etfs + (1 if include_cash else 0)   # +1 for CASH
+
+# Fill NaNs with column means
+col_means = np.nanmean(X_raw, axis=0)
+for j in range(X_raw.shape[1]):
+    mask = np.isnan(X_raw[:, j])
+    X_raw[mask, j] = col_means[j]
+
+X_seq, y_seq = build_sequences(X_raw, y_raw, lookback)
+y_labels     = returns_to_labels(y_seq, include_cash=include_cash)
+
+X_train, y_train_r, X_val, y_val_r, X_test, y_test_r = train_val_test_split(X_seq, y_seq, train_pct, val_pct)
+_, y_train_l, _, y_val_l, _, y_test_l                 = train_val_test_split(X_seq, y_labels, train_pct, val_pct)
+
+X_train_s, X_val_s, X_test_s, _ = scale_features(X_train, X_val, X_test)
+
+train_size = len(X_train)
+val_size   = len(X_val)
+
+# Test dates (aligned with y_test)
+test_start  = lookback + train_size + val_size
+test_dates  = df.index[test_start: test_start + len(X_test)]
+test_slice  = slice(test_start, test_start + len(X_test))
+
+st.success(f"✅ Sequences — Train: {train_size} · Val: {val_size} · Test: {len(X_test)}")
+
+# ── Train all three approaches ────────────────────────────────────────────────
+results      = {}
+trained_info = {}   # store extra info needed for conviction
+
+progress = st.progress(0, text="Starting training...")
+
+# ── Approach 1: Wavelet ───────────────────────────────────────────────────────
+with st.spinner("🌊 Training Approach 1 — Wavelet CNN-LSTM..."):
+    try:
+        model1, hist1, _ = train_approach1(
+            X_train_s, y_train_l,
+            X_val_s,   y_val_l,
+            n_classes=n_classes, epochs=int(epochs),
+        )
+        preds1, proba1 = predict_approach1(model1, X_test_s)
+        results["Approach 1"] = execute_strategy(
+            preds1, proba1, y_test_r, test_dates, target_etfs, fee_bps, tbill_rate, include_cash,
+        )
+        trained_info["Approach 1"] = {"proba": proba1}
+        st.success("✅ Approach 1 complete")
+    except Exception as e:
+        st.warning(f"⚠️ Approach 1 failed: {e}")
+        results["Approach 1"] = None
+
+progress.progress(33, text="Approach 1 done...")
+
+# ── Approach 2: Regime-Conditioned ───────────────────────────────────────────
+with st.spinner("🔀 Training Approach 2 — Regime-Conditioned CNN-LSTM..."):
+    try:
+        model2, hist2, hmm2, regime_cols2 = train_approach2(
+            X_train_s, y_train_l,
+            X_val_s,   y_val_l,
+            X_flat_all=X_raw,
+            feature_names=input_features,
+            lookback=lookback,
+            train_size=train_size,
+            val_size=val_size,
+            n_classes=n_classes, epochs=int(epochs),
+        )
+        preds2, proba2 = predict_approach2(
+            model2, X_test_s, X_raw, regime_cols2, hmm2,
+            lookback, train_size, val_size,
+        )
+        results["Approach 2"] = execute_strategy(
+            preds2, proba2, y_test_r, test_dates, target_etfs, fee_bps, tbill_rate, include_cash,
+        )
+        trained_info["Approach 2"] = {"proba": proba2}
+        st.success("✅ Approach 2 complete")
+    except Exception as e:
+        st.warning(f"⚠️ Approach 2 failed: {e}")
+        results["Approach 2"] = None
+
+progress.progress(66, text="Approach 2 done...")
+
+# ── Approach 3: Multi-Scale ───────────────────────────────────────────────────
+with st.spinner("📡 Training Approach 3 — Multi-Scale CNN-LSTM..."):
+    try:
+        model3, hist3 = train_approach3(
+            X_train_s, y_train_l,
+            X_val_s,   y_val_l,
+            n_classes=n_classes, epochs=int(epochs),
+        )
+        preds3, proba3 = predict_approach3(model3, X_test_s)
+        results["Approach 3"] = execute_strategy(
+            preds3, proba3, y_test_r, test_dates, target_etfs, fee_bps, tbill_rate, include_cash,
+        )
+        trained_info["Approach 3"] = {"proba": proba3}
+        st.success("✅ Approach 3 complete")
+    except Exception as e:
+        st.warning(f"⚠️ Approach 3 failed: {e}")
+        results["Approach 3"] = None
+
+progress.progress(100, text="All approaches complete!")
+progress.empty()
+
+# ── Select winner ─────────────────────────────────────────────────────────────
+winner_name = select_winner(results)
+winner_res  = results.get(winner_name)
+
+if winner_res is None:
+    st.error("❌ All approaches failed. Please check your data and configuration.")
+    st.stop()
+
+# ── Next trading date ─────────────────────────────────────────────────────────
+next_date = get_next_signal_date()
+
+st.divider()
+
+# ── Signal banner (winner) ────────────────────────────────────────────────────
+show_signal_banner(winner_res["next_signal"], next_date, winner_name)
+
+# ── Conviction panel ──────────────────────────────────────────────────────────
+winner_proba = trained_info[winner_name]["proba"]
+conviction   = compute_conviction(winner_proba[-1], target_etfs, include_cash)
+show_conviction_panel(conviction)
+
+st.divider()
+
+# ── Winner metrics ────────────────────────────────────────────────────────────
+st.subheader(f"📊 {winner_name} — Performance Metrics")
+show_metrics_row(winner_res, tbill_rate)
+
+st.divider()
+
+# ── Comparison table ──────────────────────────────────────────────────────────
+st.subheader("🏆 Approach Comparison (Winner = Highest Raw Annualised Return)")
+comparison_df = build_comparison_table(results, winner_name)
+show_comparison_table(comparison_df)
+
+# ── Comparison bar chart ──────────────────────────────────────────────────────
+st.plotly_chart(comparison_bar_chart(results, winner_name), use_container_width=True)
+
+st.divider()
+
+# ── Equity curves ─────────────────────────────────────────────────────────────
+st.subheader("📈 Out-of-Sample Equity Curves — All Approaches vs Benchmarks")
+fig = equity_curve_chart(results, winner_name, test_dates, df, test_slice, tbill_rate)
+st.plotly_chart(fig, use_container_width=True)
+
+st.divider()
+
+# ── Audit trail (winner) ──────────────────────────────────────────────────────
+st.subheader(f"📋 Audit Trail — {winner_name} (Last 20 Trading Days)")
+show_audit_trail(winner_res["audit_trail"])

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.13.5-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY src/ ./src/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/README.md

@@ -0,0 +1,19 @@
+---
+title: P2 ETF CNN LSTM ALTERNATIVE APPROACHES
+emoji: 🚀
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+- streamlit
+pinned: false
+short_description: Streamlit template space
+---
+
+# Welcome to Streamlit!
+
+Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+
+If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
+forums](https://discuss.streamlit.io).

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/requirements.txt

@@ -0,0 +1,3 @@
+altair
+pandas
+streamlit

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/src/streamlit_app.py

@@ -0,0 +1,40 @@
+import altair as alt
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+"""
+# Welcome to Streamlit!
+
+Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
+If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
+forums](https://discuss.streamlit.io).
+
+In the meantime, below is an example of what you can do with just a few lines of code:
+"""
+
+num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
+num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
+
+indices = np.linspace(0, 1, num_points)
+theta = 2 * np.pi * num_turns * indices
+radius = indices
+
+x = radius * np.cos(theta)
+y = radius * np.sin(theta)
+
+df = pd.DataFrame({
+    "x": x,
+    "y": y,
+    "idx": indices,
+    "rand": np.random.randn(num_points),
+})
+
+st.altair_chart(alt.Chart(df, height=700, width=700)
+    .mark_point(filled=True)
+    .encode(
+        x=alt.X("x", axis=None),
+        y=alt.Y("y", axis=None),
+        color=alt.Color("idx", legend=None, scale=alt.Scale()),
+        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
+    ))

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/requirements.txt

@@ -1,3 +1,29 @@
-altair
-pandas
-streamlit
+# Core
+streamlit>=1.32.0
+pandas>=2.0.0
+numpy>=1.24.0
+
+# Hugging Face
+huggingface_hub>=0.21.0
+datasets>=2.18.0
+
+# Machine Learning
+tensorflow>=2.14.0
+scikit-learn>=1.3.0
+xgboost>=2.0.0
+
+# Wavelet (Approach 1)
+PyWavelets>=1.5.0
+
+# Regime detection (Approach 2)
+hmmlearn>=0.3.0
+
+# Visualisation
+plotly>=5.18.0
+
+# NYSE Calendar
+pandas_market_calendars>=4.3.0
+pytz>=2024.1
+
+# Parquet
+pyarrow>=14.0.0

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/models/base.py

@@ -0,0 +1,199 @@
+"""
+models/base.py
+Shared utilities for all three CNN-LSTM variants:
+  - Data preparation (sequences, train/val/test split)
+  - Common Keras layers / callbacks
+  - Predict + evaluate helpers
+"""
+
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import RobustScaler
+import tensorflow as tf
+from tensorflow import keras
+
+# ── Reproducibility ───────────────────────────────────────────────────────────
+SEED = 42
+tf.random.set_seed(SEED)
+np.random.seed(SEED)
+
+
+# ── Sequence builder ──────────────────────────────────────────────────────────
+
+def build_sequences(features: np.ndarray, targets: np.ndarray, lookback: int):
+    """
+    Build supervised sequences for CNN-LSTM input.
+
+    Args:
+        features : 2-D array [n_days, n_features]
+        targets  : 2-D array [n_days, n_etfs]  (raw returns)
+        lookback : number of past days per sample
+
+    Returns:
+        X : [n_samples, lookback, n_features]
+        y : [n_samples, n_etfs]   (raw returns for the next day)
+    """
+    X, y = [], []
+    for i in range(lookback, len(features)):
+        X.append(features[i - lookback: i])
+        y.append(targets[i])
+    return np.array(X, dtype=np.float32), np.array(y, dtype=np.float32)
+
+
+# ── Train / val / test split ──────────────────────────────────────────────────
+
+def train_val_test_split(X, y, train_pct=0.70, val_pct=0.15):
+    """Split sequences into train / val / test preserving temporal order."""
+    n = len(X)
+    t1 = int(n * train_pct)
+    t2 = int(n * (train_pct + val_pct))
+
+    return (
+        X[:t1],  y[:t1],
+        X[t1:t2], y[t1:t2],
+        X[t2:],  y[t2:],
+    )
+
+
+# ── Feature scaling ───────────────────────────────────────────────────────────
+
+def scale_features(X_train, X_val, X_test):
+    """
+    Fit RobustScaler on training data only, apply to val and test.
+    Operates on the flattened feature dimension.
+
+    Returns scaled arrays with same shape as inputs.
+    """
+    n_train, lb, n_feat = X_train.shape
+    scaler = RobustScaler()
+
+    # Fit on train
+    scaler.fit(X_train.reshape(-1, n_feat))
+
+    def _transform(X):
+        shape = X.shape
+        return scaler.transform(X.reshape(-1, n_feat)).reshape(shape)
+
+    return _transform(X_train), _transform(X_val), _transform(X_test), scaler
+
+
+# ── Label builder (classification: argmax of returns) ────────────────────────
+
+def returns_to_labels(y_raw, include_cash=True, cash_threshold=0.0):
+    """
+    Convert raw return matrix to integer class labels.
+
+    If include_cash=True, adds a CASH class (index = n_etfs) when
+    the best ETF return is below cash_threshold.
+
+    Args:
+        y_raw           : [n_samples, n_etfs]
+        include_cash    : whether to allow CASH class
+        cash_threshold  : minimum ETF return to prefer over CASH
+
+    Returns:
+        labels : [n_samples] integer class indices
+    """
+    best = np.argmax(y_raw, axis=1)
+    if include_cash:
+        best_return = y_raw[np.arange(len(y_raw)), best]
+        cash_idx    = y_raw.shape[1]
+        labels      = np.where(best_return < cash_threshold, cash_idx, best)
+    else:
+        labels = best
+    return labels.astype(np.int32)
+
+
+# ── Common Keras callbacks ────────────────────────────────────────────────────
+
+def get_callbacks(patience_es=15, patience_lr=8, min_lr=1e-6):
+    """Standard early stopping + reduce-LR callbacks shared by all models."""
+    return [
+        keras.callbacks.EarlyStopping(
+            monitor="val_loss",
+            patience=patience_es,
+            restore_best_weights=True,
+            verbose=0,
+        ),
+        keras.callbacks.ReduceLROnPlateau(
+            monitor="val_loss",
+            factor=0.5,
+            patience=patience_lr,
+            min_lr=min_lr,
+            verbose=0,
+        ),
+    ]
+
+
+# ── Common output head ────────────────────────────────────────────────────────
+
+def classification_head(x, n_classes: int, dropout: float = 0.3):
+    """
+    Shared dense output head for all three CNN-LSTM variants.
+
+    Args:
+        x         : input tensor
+        n_classes : number of ETF classes (+ 1 for CASH if applicable)
+        dropout   : dropout rate
+
+    Returns:
+        output tensor with softmax activation
+    """
+    x = keras.layers.Dense(64, activation="relu")(x)
+    x = keras.layers.Dropout(dropout)(x)
+    x = keras.layers.Dense(n_classes, activation="softmax")(x)
+    return x
+
+
+# ── Prediction helper ─────────────────────────────────────────────────────────
+
+def predict_classes(model, X_test: np.ndarray) -> np.ndarray:
+    """Return integer class predictions from a Keras model."""
+    proba = model.predict(X_test, verbose=0)
+    return np.argmax(proba, axis=1), proba
+
+
+# ── Metrics helper ────────────────────────────────────────────────────────────
+
+def evaluate_returns(
+    preds: np.ndarray,
+    proba: np.ndarray,
+    y_raw_test: np.ndarray,
+    target_etfs: list,
+    tbill_rate: float,
+    fee_bps: int,
+    include_cash: bool = True,
+):
+    """
+    Given integer class predictions and raw return matrix,
+    compute strategy returns and summary metrics.
+
+    Returns:
+        strat_rets      : np.ndarray of daily net returns
+        ann_return      : annualised return (float)
+        cum_returns     : cumulative return series
+        last_proba      : probability vector for the last prediction
+        next_etf        : name of ETF predicted for next session
+    """
+    n_etfs     = len(target_etfs)
+    strat_rets = []
+
+    for i, cls in enumerate(preds):
+        if include_cash and cls == n_etfs:
+            # CASH: earn daily T-bill rate
+            daily_tbill = tbill_rate / 252
+            net = daily_tbill - (fee_bps / 10000)
+        else:
+            ret = y_raw_test[i][cls]
+            net = ret - (fee_bps / 10000)
+        strat_rets.append(net)
+
+    strat_rets  = np.array(strat_rets)
+    cum_returns = np.cumprod(1 + strat_rets)
+    ann_return  = (cum_returns[-1] ** (252 / len(strat_rets))) - 1
+
+    last_proba  = proba[-1]
+    next_cls    = int(np.argmax(last_proba))
+    next_etf    = "CASH" if (include_cash and next_cls == n_etfs) else target_etfs[next_cls].replace("_Ret", "")
+
+    return strat_rets, ann_return, cum_returns, last_proba, next_etf

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/models/approach1_wavelet.py

@@ -0,0 +1,167 @@
+"""
+models/approach1_wavelet.py
+Approach 1: Wavelet Decomposition CNN-LSTM
+
+Pipeline:
+  Raw macro signals
+  → DWT (db4, level=3) per signal → multi-band channel stack
+  → 1D CNN (64 filters, k=3) → MaxPool → (32 filters, k=3)
+  → LSTM (128 units)
+  → Dense 64 → Softmax (n_etfs + 1 CASH)
+"""
+
+import numpy as np
+import pywt
+import tensorflow as tf
+from tensorflow import keras
+from models.base import classification_head, get_callbacks
+
+WAVELET   = "db4"
+LEVEL     = 3
+
+
+# ── Wavelet feature engineering ───────────────────────────────────────────────
+
+def _wavelet_decompose_signal(signal: np.ndarray, wavelet: str, level: int) -> np.ndarray:
+    """
+    Decompose a 1-D signal into DWT subbands and return them stacked.
+
+    For a signal of length T:
+      coeffs = [cA_n, cD_n, cD_{n-1}, ..., cD_1]
+    We interpolate each subband back to length T so we can stack them.
+
+    Returns: array of shape [T, level+1]
+    """
+    T      = len(signal)
+    coeffs = pywt.wavedec(signal, wavelet, level=level)
+    bands  = []
+    for c in coeffs:
+        # Interpolate back to original length
+        band = np.interp(
+            np.linspace(0, len(c) - 1, T),
+            np.arange(len(c)),
+            c,
+        )
+        bands.append(band)
+    return np.stack(bands, axis=-1)   # [T, level+1]
+
+
+def apply_wavelet_transform(X: np.ndarray, wavelet: str = WAVELET, level: int = LEVEL) -> np.ndarray:
+    """
+    Apply DWT to every feature channel across all samples.
+
+    Args:
+        X : [n_samples, lookback, n_features]
+
+    Returns:
+        X_wt : [n_samples, lookback, n_features * (level+1)]
+    """
+    n_samples, lookback, n_features = X.shape
+    n_bands   = level + 1
+    X_wt      = np.zeros((n_samples, lookback, n_features * n_bands), dtype=np.float32)
+
+    for s in range(n_samples):
+        for f in range(n_features):
+            decomposed = _wavelet_decompose_signal(X[s, :, f], wavelet, level)   # [T, n_bands]
+            start = f * n_bands
+            X_wt[s, :, start: start + n_bands] = decomposed
+
+    return X_wt
+
+
+# ── Model builder ─────────────────────────────────────────────────────────────
+
+def build_wavelet_cnn_lstm(
+    input_shape: tuple,
+    n_classes: int,
+    dropout: float = 0.3,
+    lstm_units: int = 128,
+) -> keras.Model:
+    """
+    Build Wavelet CNN-LSTM model.
+
+    Args:
+        input_shape : (lookback, n_features * n_bands)  — post-DWT shape
+        n_classes   : number of output classes (ETFs + CASH)
+        dropout     : dropout rate
+        lstm_units  : LSTM hidden size
+
+    Returns:
+        Compiled Keras model
+    """
+    inputs = keras.Input(shape=input_shape, name="wavelet_input")
+
+    # CNN block 1
+    x = keras.layers.Conv1D(64, kernel_size=3, padding="causal", activation="relu")(inputs)
+    x = keras.layers.BatchNormalization()(x)
+    x = keras.layers.MaxPooling1D(pool_size=2)(x)
+
+    # CNN block 2
+    x = keras.layers.Conv1D(32, kernel_size=3, padding="causal", activation="relu")(x)
+    x = keras.layers.BatchNormalization()(x)
+    x = keras.layers.Dropout(dropout)(x)
+
+    # LSTM
+    x = keras.layers.LSTM(lstm_units, dropout=dropout, recurrent_dropout=0.1)(x)
+
+    # Output head
+    outputs = classification_head(x, n_classes, dropout)
+
+    model = keras.Model(inputs, outputs, name="Approach1_Wavelet_CNN_LSTM")
+    model.compile(
+        optimizer=keras.optimizers.Adam(learning_rate=1e-3),
+        loss="sparse_categorical_crossentropy",
+        metrics=["accuracy"],
+    )
+    return model
+
+
+# ── Full train pipeline ───────────────────────────────────────────────────────
+
+def train_approach1(
+    X_train, y_train,
+    X_val,   y_val,
+    n_classes: int,
+    epochs: int = 100,
+    batch_size: int = 32,
+    dropout: float = 0.3,
+    lstm_units: int = 128,
+):
+    """
+    Apply wavelet transform then train the CNN-LSTM.
+
+    Args:
+        X_train/val : [n, lookback, n_features]  (scaled, pre-wavelet)
+        y_train/val : [n] integer class labels
+        n_classes   : total output classes
+
+    Returns:
+        model    : trained Keras model
+        history  : training history
+        wt_shape : post-DWT input shape (for inference)
+    """
+    # Apply DWT
+    X_train_wt = apply_wavelet_transform(X_train)
+    X_val_wt   = apply_wavelet_transform(X_val)
+
+    input_shape = X_train_wt.shape[1:]   # (lookback, n_features * n_bands)
+    model       = build_wavelet_cnn_lstm(input_shape, n_classes, dropout, lstm_units)
+
+    history = model.fit(
+        X_train_wt, y_train,
+        validation_data=(X_val_wt, y_val),
+        epochs=epochs,
+        batch_size=batch_size,
+        callbacks=get_callbacks(),
+        verbose=0,
+    )
+
+    return model, history, input_shape
+
+
+def predict_approach1(model, X_test: np.ndarray) -> tuple:
+    """Apply DWT to test set then predict. Returns (class_preds, proba)."""
+    X_test_wt = apply_wavelet_transform(X_test)
+    proba     = model.predict(X_test_wt, verbose=0)
+    preds     = np.argmax(proba, axis=1)
+    return preds, proba

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/models/approach2_regime.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/models/approach3_multiscale.py

@@ -0,0 +1,150 @@
+"""
+models/approach3_multiscale.py
+Approach 3: Multi-Scale Parallel CNN-LSTM
+
+Pipeline:
+  Raw macro signals
+  → 3 parallel CNN towers: kernel 3 (short), 7 (medium), 21 (long)
+  → Concatenate [96 features]
+  → LSTM (128 units)
+  → Dense 64 → Softmax (n_etfs + 1 CASH)
+"""
+
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from models.base import classification_head, get_callbacks
+
+# Kernel sizes represent: momentum (3d), weekly cycle (7d), monthly trend (21d)
+KERNEL_SIZES  = [3, 7, 21]
+FILTERS_EACH  = 32   # 32 × 3 towers = 96 concatenated features
+
+
+# ── Model builder ─────────────────────────────────────────────────────────────
+
+def build_multiscale_cnn_lstm(
+    input_shape: tuple,
+    n_classes: int,
+    kernel_sizes: list = None,
+    filters: int = FILTERS_EACH,
+    dropout: float = 0.3,
+    lstm_units: int = 128,
+) -> keras.Model:
+    """
+    Multi-scale parallel CNN-LSTM.
+
+    Three CNN towers with different kernel sizes run in parallel on the
+    same input, capturing momentum, weekly cycle, and monthly trend
+    simultaneously. Their outputs are concatenated before the LSTM.
+
+    Args:
+        input_shape  : (lookback, n_features)
+        n_classes    : number of output classes (ETFs + CASH)
+        kernel_sizes : list of kernel sizes for each tower
+        filters      : number of Conv1D filters per tower
+        dropout      : dropout rate
+        lstm_units   : LSTM hidden size
+
+    Returns:
+        Compiled Keras model
+    """
+    if kernel_sizes is None:
+        kernel_sizes = KERNEL_SIZES
+
+    inputs = keras.Input(shape=input_shape, name="multiscale_input")
+
+    towers = []
+    for k in kernel_sizes:
+        # Each tower: Conv → BN → Conv → BN → GlobalAvgPool
+        t = keras.layers.Conv1D(
+            filters, kernel_size=k, padding="causal", activation="relu",
+            name=f"conv1_k{k}"
+        )(inputs)
+        t = keras.layers.BatchNormalization(name=f"bn1_k{k}")(t)
+        t = keras.layers.Conv1D(
+            filters, kernel_size=k, padding="causal", activation="relu",
+            name=f"conv2_k{k}"
+        )(t)
+        t = keras.layers.BatchNormalization(name=f"bn2_k{k}")(t)
+        t = keras.layers.Dropout(dropout, name=f"drop_k{k}")(t)
+        towers.append(t)
+
+    # Concatenate along the feature dimension — keeps temporal axis intact for LSTM
+    if len(towers) > 1:
+        merged = keras.layers.Concatenate(axis=-1, name="tower_concat")(towers)
+    else:
+        merged = towers[0]
+
+    # LSTM integrates multi-scale temporal features
+    x = keras.layers.LSTM(lstm_units, dropout=dropout, recurrent_dropout=0.1, name="lstm")(merged)
+
+    # Output head
+    outputs = classification_head(x, n_classes, dropout)
+
+    model = keras.Model(inputs, outputs, name="Approach3_MultiScale_CNN_LSTM")
+    model.compile(
+        optimizer=keras.optimizers.Adam(learning_rate=1e-3),
+        loss="sparse_categorical_crossentropy",
+        metrics=["accuracy"],
+    )
+    return model
+
+
+# ── Full train pipeline ───────────────────────────────────────────────────────
+
+def train_approach3(
+    X_train, y_train,
+    X_val,   y_val,
+    n_classes: int,
+    epochs: int = 100,
+    batch_size: int = 32,
+    dropout: float = 0.3,
+    lstm_units: int = 128,
+    kernel_sizes: list = None,
+):
+    """
+    Build and train the multi-scale CNN-LSTM.
+
+    Args:
+        X_train/val : [n, lookback, n_features]
+        y_train/val : [n] integer class labels
+        n_classes   : total output classes
+
+    Returns:
+        model   : trained Keras model
+        history : training history
+    """
+    if kernel_sizes is None:
+        kernel_sizes = KERNEL_SIZES
+
+    # Guard: lookback must be >= largest kernel
+    lookback = X_train.shape[1]
+    valid_kernels = [k for k in kernel_sizes if k <= lookback]
+    if not valid_kernels:
+        valid_kernels = [min(3, lookback)]
+
+    model = build_multiscale_cnn_lstm(
+        input_shape=X_train.shape[1:],
+        n_classes=n_classes,
+        kernel_sizes=valid_kernels,
+        dropout=dropout,
+        lstm_units=lstm_units,
+    )
+
+    history = model.fit(
+        X_train, y_train,
+        validation_data=(X_val, y_val),
+        epochs=epochs,
+        batch_size=batch_size,
+        callbacks=get_callbacks(),
+        verbose=0,
+    )
+
+    return model, history
+
+
+def predict_approach3(model, X_test: np.ndarray) -> tuple:
+    """Predict on test set. Returns (class_preds, proba)."""
+    proba = model.predict(X_test, verbose=0)
+    preds = np.argmax(proba, axis=1)
+    return preds, proba

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/strategy/backtest.py

@@ -0,0 +1,193 @@
+"""
+strategy/backtest.py
+Strategy execution, performance metrics, and benchmark calculations.
+Supports CASH as a class (earns T-bill rate when selected).
+"""
+
+import numpy as np
+import pandas as pd
+from datetime import datetime
+
+
+# ── Strategy execution ────────────────────────────────────────────────────────
+
+def execute_strategy(
+    preds: np.ndarray,
+    proba: np.ndarray,
+    y_raw_test: np.ndarray,
+    test_dates: pd.DatetimeIndex,
+    target_etfs: list,
+    fee_bps: int,
+    tbill_rate: float,
+    include_cash: bool = True,
+) -> dict:
+    """
+    Execute strategy from model predictions.
+
+    Args:
+        preds       : [n] integer class predictions
+        proba       : [n, n_classes] softmax probabilities
+        y_raw_test  : [n, n_etfs] actual next-day ETF returns
+        test_dates  : DatetimeIndex aligned with y_raw_test
+        target_etfs : list of ETF return column names e.g. ["TLT_Ret", ...]
+        fee_bps     : transaction fee in basis points
+        tbill_rate  : annualised 3m T-bill rate (e.g. 0.045)
+        include_cash: whether CASH is a valid class (index = n_etfs)
+
+    Returns:
+        dict with keys:
+            strat_rets, cum_returns, ann_return, sharpe,
+            hit_ratio, max_dd, max_daily_dd, cum_max,
+            audit_trail, next_signal, next_proba
+    """
+    n_etfs      = len(target_etfs)
+    daily_tbill = tbill_rate / 252
+    today       = datetime.now().date()
+
+    strat_rets  = []
+    audit_trail = []
+
+    for i, cls in enumerate(preds):
+        if include_cash and cls == n_etfs:
+            signal_etf   = "CASH"
+            realized_ret = daily_tbill
+        else:
+            cls          = min(cls, n_etfs - 1)
+            signal_etf   = target_etfs[cls].replace("_Ret", "")
+            realized_ret = float(y_raw_test[i][cls])
+
+        net_ret = realized_ret - (fee_bps / 10000)
+        strat_rets.append(net_ret)
+
+        trade_date = test_dates[i]
+        if trade_date.date() < today:
+            audit_trail.append({
+                "Date":       trade_date.strftime("%Y-%m-%d"),
+                "Signal":     signal_etf,
+                "Realized":   realized_ret,
+                "Net_Return": net_ret,
+            })
+
+    strat_rets = np.array(strat_rets, dtype=np.float64)
+
+    # Next signal (last prediction)
+    last_cls   = int(preds[-1])
+    next_proba = proba[-1]
+
+    if include_cash and last_cls == n_etfs:
+        next_signal = "CASH"
+    else:
+        last_cls    = min(last_cls, n_etfs - 1)
+        next_signal = target_etfs[last_cls].replace("_Ret", "")
+
+    metrics = _compute_metrics(strat_rets, tbill_rate)
+
+    return {
+        **metrics,
+        "strat_rets":  strat_rets,
+        "audit_trail": audit_trail,
+        "next_signal": next_signal,
+        "next_proba":  next_proba,
+    }
+
+
+# ── Performance metrics ───────────────────────────────────────────────────────
+
+def _compute_metrics(strat_rets: np.ndarray, tbill_rate: float) -> dict:
+    if len(strat_rets) == 0:
+        return {}
+
+    cum_returns = np.cumprod(1 + strat_rets)
+    n           = len(strat_rets)
+    ann_return  = float(cum_returns[-1] ** (252 / n) - 1)
+
+    excess      = strat_rets - tbill_rate / 252
+    sharpe      = float(np.mean(excess) / (np.std(strat_rets) + 1e-9) * np.sqrt(252))
+
+    recent      = strat_rets[-15:]
+    hit_ratio   = float(np.mean(recent > 0))
+
+    cum_max     = np.maximum.accumulate(cum_returns)
+    drawdown    = (cum_returns - cum_max) / cum_max
+    max_dd      = float(np.min(drawdown))
+    max_daily   = float(np.min(strat_rets))
+
+    return {
+        "cum_returns": cum_returns,
+        "ann_return":  ann_return,
+        "sharpe":      sharpe,
+        "hit_ratio":   hit_ratio,
+        "max_dd":      max_dd,
+        "max_daily_dd":max_daily,
+        "cum_max":     cum_max,
+    }
+
+
+def compute_benchmark_metrics(returns: np.ndarray, tbill_rate: float) -> dict:
+    """Compute metrics for a benchmark return series."""
+    return _compute_metrics(returns, tbill_rate)
+
+
+# ── Winner selection ──────────────────────────────────────────────────────────
+
+def select_winner(results: dict) -> str:
+    """
+    Given a dict of {approach_name: result_dict}, return the approach name
+    with the highest annualised return (raw, not risk-adjusted).
+
+    Args:
+        results : {"Approach 1": {...}, "Approach 2": {...}, "Approach 3": {...}}
+
+    Returns:
+        winner_name : str
+    """
+    best_name   = None
+    best_return = -np.inf
+
+    for name, res in results.items():
+        if res is None:
+            continue
+        ret = res.get("ann_return", -np.inf)
+        if ret > best_return:
+            best_return = ret
+            best_name   = name
+
+    return best_name
+
+
+# ── Comparison table ──────────────────────────────────────────────────────────
+
+def build_comparison_table(results: dict, winner_name: str) -> pd.DataFrame:
+    """
+    Build a summary DataFrame comparing all three approaches.
+
+    Args:
+        results     : {name: result_dict}
+        winner_name : name of the winner
+
+    Returns:
+        pd.DataFrame with one row per approach
+    """
+    rows = []
+    for name, res in results.items():
+        if res is None:
+            rows.append({
+                "Approach":       name,
+                "Ann. Return":    "N/A",
+                "Sharpe":         "N/A",
+                "Hit Ratio (15d)":"N/A",
+                "Max Drawdown":   "N/A",
+                "Winner":         "",
+            })
+            continue
+
+        rows.append({
+            "Approach":        name,
+            "Ann. Return":     f"{res['ann_return']*100:.2f}%",
+            "Sharpe":          f"{res['sharpe']:.2f}",
+            "Hit Ratio (15d)": f"{res['hit_ratio']*100:.0f}%",
+            "Max Drawdown":    f"{res['max_dd']*100:.2f}%",
+            "Winner":          "⭐ WINNER" if name == winner_name else "",
+        })
+
+    return pd.DataFrame(rows)

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/signals/conviction.py

@@ -0,0 +1,93 @@
+"""
+signals/conviction.py
+Signal conviction scoring via Z-score of model probabilities.
+"""
+
+import numpy as np
+
+
+CONVICTION_THRESHOLDS = {
+    "Very High": 2.0,
+    "High":      1.0,
+    "Moderate":  0.0,
+    # Below 0.0 → "Low"
+}
+
+
+def compute_conviction(proba: np.ndarray, target_etfs: list, include_cash: bool = True) -> dict:
+    """
+    Compute Z-score conviction for the selected signal.
+
+    Args:
+        proba       : 1-D softmax probability vector [n_classes]
+        target_etfs : list of ETF return column names (e.g. ["TLT_Ret", ...])
+        include_cash: whether CASH is the last class
+
+    Returns:
+        dict with keys:
+            best_idx        : int
+            best_name       : str  (ETF ticker or "CASH")
+            z_score         : float
+            label           : str  ("Very High" / "High" / "Moderate" / "Low")
+            scores          : np.ndarray (raw proba)
+            etf_names       : list of display names
+            sorted_pairs    : list of (name, score) sorted high→low
+    """
+    scores    = np.array(proba, dtype=float)
+    best_idx  = int(np.argmax(scores))
+    n_etfs    = len(target_etfs)
+
+    # Display names
+    etf_names = [e.replace("_Ret", "") for e in target_etfs]
+    if include_cash:
+        etf_names = etf_names + ["CASH"]
+
+    best_name = etf_names[best_idx] if best_idx < len(etf_names) else "CASH"
+
+    # Z-score
+    mean = np.mean(scores)
+    std  = np.std(scores)
+    z    = float((scores[best_idx] - mean) / std) if std > 1e-9 else 0.0
+
+    # Label
+    label = "Low"
+    for lbl, threshold in CONVICTION_THRESHOLDS.items():
+        if z >= threshold:
+            label = lbl
+            break
+
+    # Sorted pairs for UI bar chart
+    sorted_pairs = sorted(
+        zip(etf_names, scores),
+        key=lambda x: x[1],
+        reverse=True,
+    )
+
+    return {
+        "best_idx":     best_idx,
+        "best_name":    best_name,
+        "z_score":      z,
+        "label":        label,
+        "scores":       scores,
+        "etf_names":    etf_names,
+        "sorted_pairs": sorted_pairs,
+    }
+
+
+def conviction_color(label: str) -> str:
+    """Return hex accent colour for a conviction label."""
+    return {
+        "Very High": "#00b894",
+        "High":      "#00cec9",
+        "Moderate":  "#fdcb6e",
+        "Low":       "#d63031",
+    }.get(label, "#888888")
+
+
+def conviction_icon(label: str) -> str:
+    return {
+        "Very High": "🟢",
+        "High":      "🟢",
+        "Moderate":  "🟡",
+        "Low":       "🔴",
+    }.get(label, "⚪")

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/ui/components.py

@@ -0,0 +1,229 @@
+"""
+ui/components.py
+Reusable Streamlit UI blocks:
+  - Freshness warning banner
+  - Next trading day signal banner
+  - Signal conviction panel
+  - Metrics row
+  - Audit trail table
+  - Comparison summary table
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+
+from signals.conviction import conviction_color, conviction_icon
+
+
+# ── Freshness warning ─────────────────────────────────────────────────────────
+
+def show_freshness_status(freshness: dict):
+    """Display data freshness status. Stops app if data is stale."""
+    if freshness.get("fresh"):
+        st.success(freshness["message"])
+    else:
+        st.warning(freshness["message"])
+
+
+# ── Next trading day banner ───────────────────────────────────────────────────
+
+def show_signal_banner(next_signal: str, next_date, approach_name: str):
+    """Large coloured banner showing the winning approach's next signal."""
+    is_cash = next_signal == "CASH"
+    bg      = "linear-gradient(135deg, #2d3436 0%, #1a1a2e 100%)" if is_cash else \
+              "linear-gradient(135deg, #00d1b2 0%, #00a896 100%)"
+
+    st.markdown(f"""
+    <div style="background:{bg}; padding:25px; border-radius:15px;
+                text-align:center; box-shadow:0 8px 16px rgba(0,0,0,0.3);
+                margin:16px 0;">
+      <div style="color:rgba(255,255,255,0.7); font-size:12px;
+                  letter-spacing:3px; margin-bottom:6px;">
+        {approach_name.upper()} · NEXT TRADING DAY SIGNAL
+      </div>
+      <h1 style="color:white; font-size:44px; margin:0 0 8px 0;
+                 font-weight:800; text-shadow:2px 2px 4px rgba(0,0,0,0.3);">
+        🎯 {next_date.strftime('%Y-%m-%d')} → {next_signal}
+      </h1>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+# ── Signal conviction panel ───────────────────────────────────────────────────
+
+def show_conviction_panel(conviction: dict):
+    """
+    White-background conviction panel with Z-score gauge and per-ETF bars.
+    Uses separate st.markdown calls per ETF row to avoid Streamlit HTML escaping.
+    """
+    label      = conviction["label"]
+    z_score    = conviction["z_score"]
+    best_name  = conviction["best_name"]
+    sorted_pairs = conviction["sorted_pairs"]
+
+    color      = conviction_color(label)
+    icon       = conviction_icon(label)
+
+    z_clipped  = max(-3.0, min(3.0, z_score))
+    bar_pct    = int((z_clipped + 3) / 6 * 100)
+
+    max_score  = max(s for _, s in sorted_pairs) if sorted_pairs else 1.0
+    if max_score <= 0:
+        max_score = 1.0
+
+    # ── Header + gauge ────────────────────────────────────────────────────────
+    st.markdown(f"""
+    <div style="background:#ffffff; border:1px solid #ddd;
+                border-left:5px solid {color}; border-radius:12px 12px 0 0;
+                padding:18px 24px 12px 24px; margin:12px 0 0 0;
+                box-shadow:0 2px 8px rgba(0,0,0,0.07);">
+
+      <div style="display:flex; align-items:center; gap:12px;
+                  margin-bottom:14px; flex-wrap:wrap;">
+        <span style="font-size:20px;">{icon}</span>
+        <span style="font-size:18px; font-weight:700; color:#1a1a1a;">Signal Conviction</span>
+        <span style="background:#f0f0f0; border:1px solid {color};
+                     color:{color}; font-weight:700; font-size:14px;
+                     padding:3px 12px; border-radius:8px;">
+          Z = {z_score:.2f} &sigma;
+        </span>
+        <span style="margin-left:auto; background:{color}; color:#fff;
+                     font-weight:700; padding:4px 16px;
+                     border-radius:20px; font-size:13px;">
+          {label}
+        </span>
+      </div>
+
+      <div style="display:flex; justify-content:space-between;
+                  font-size:11px; color:#999; margin-bottom:4px;">
+        <span>Weak &minus;3&sigma;</span>
+        <span>Neutral 0&sigma;</span>
+        <span>Strong +3&sigma;</span>
+      </div>
+      <div style="background:#f0f0f0; border-radius:8px; height:14px;
+                  overflow:hidden; position:relative; border:1px solid #e0e0e0;
+                  margin-bottom:14px;">
+        <div style="position:absolute; left:50%; top:0; width:2px;
+                    height:100%; background:#ccc;"></div>
+        <div style="width:{bar_pct}%; height:100%;
+                    background:linear-gradient(90deg,#fab1a0,{color});
+                    border-radius:8px;"></div>
+      </div>
+
+      <div style="font-size:12px; color:#999; margin-bottom:2px;">
+        Model probability by ETF (ranked high &rarr; low):
+      </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # ── Per-ETF rows ──────────────────────────────────────────────────────────
+    for i, (name, score) in enumerate(sorted_pairs):
+        is_winner  = (name == best_name)
+        is_last    = (i == len(sorted_pairs) - 1)
+        bar_w      = int(score / max_score * 100)
+        name_style = "font-weight:700; color:#00897b;" if is_winner else "color:#444;"
+        bar_color  = color if is_winner else "#b2dfdb" if score > max_score * 0.5 else "#e0e0e0"
+        star       = " ★" if is_winner else ""
+        bottom_r   = "0 0 12px 12px" if is_last else "0"
+        border_bot = "border-bottom:1px solid #f0f0f0;" if not is_last else ""
+
+        st.markdown(f"""
+        <div style="background:#ffffff; border:1px solid #ddd; border-top:none;
+                    border-radius:{bottom_r}; padding:7px 24px; {border_bot}
+                    box-shadow:0 2px 8px rgba(0,0,0,0.07);">
+          <div style="display:flex; align-items:center; gap:12px;">
+            <span style="width:44px; text-align:right; font-size:13px; {name_style}">{name}{star}</span>
+            <div style="flex:1; background:#f5f5f5; border-radius:4px;
+                        height:14px; overflow:hidden; border:1px solid #e8e8e8;">
+              <div style="width:{bar_w}%; height:100%;
+                          background:{bar_color}; border-radius:4px;"></div>
+            </div>
+            <span style="width:56px; font-size:12px; color:#888; text-align:right;">{score:.4f}</span>
+          </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+    st.caption(
+        "Z-score = std deviations the top ETF's probability sits above the mean of all ETF probabilities. "
+        "Higher → model is more decisive."
+    )
+
+
+# ── Metrics row ───────────────────────────────────────────────────────────────
+
+def show_metrics_row(result: dict, tbill_rate: float):
+    """Five-column metric display."""
+    col1, col2, col3, col4, col5 = st.columns(5)
+
+    col1.metric(
+        "📈 Annualised Return",
+        f"{result['ann_return']*100:.2f}%",
+        delta=f"vs T-bill: {(result['ann_return'] - tbill_rate)*100:.2f}%",
+    )
+    col2.metric(
+        "📊 Sharpe Ratio",
+        f"{result['sharpe']:.2f}",
+        delta="Risk-Adjusted" if result['sharpe'] > 1 else "Below Threshold",
+    )
+    col3.metric(
+        "🎯 Hit Ratio (15d)",
+        f"{result['hit_ratio']*100:.0f}%",
+        delta="Strong" if result['hit_ratio'] > 0.6 else "Weak",
+    )
+    col4.metric(
+        "📉 Max Drawdown",
+        f"{result['max_dd']*100:.2f}%",
+        delta="Peak to Trough",
+    )
+    col5.metric(
+        "⚠️ Max Daily DD",
+        f"{result['max_daily_dd']*100:.2f}%",
+        delta="Worst Day",
+    )
+
+
+# ── Comparison table ──────────────────────────────────────────────────────────
+
+def show_comparison_table(comparison_df: pd.DataFrame):
+    """Styled comparison table for all three approaches."""
+    def highlight_winner(row):
+        if "WINNER" in str(row.get("Winner", "")):
+            return ["background-color: rgba(0,200,150,0.15); font-weight:bold"] * len(row)
+        return [""] * len(row)
+
+    styled = comparison_df.style.apply(highlight_winner, axis=1).set_properties(**{
+        "text-align": "center",
+        "font-size": "14px",
+    }).set_table_styles([
+        {"selector": "th", "props": [("font-size", "14px"), ("font-weight", "bold"),
+                                      ("text-align", "center")]},
+        {"selector": "td", "props": [("padding", "10px")]},
+    ])
+    st.dataframe(styled, use_container_width=True)
+
+
+# ── Audit trail ───────────────────────────────────────────────────────────────
+
+def show_audit_trail(audit_trail: list):
+    """Last 20 days styled audit trail."""
+    if not audit_trail:
+        st.info("No audit trail data available.")
+        return
+
+    df = pd.DataFrame(audit_trail).tail(20)[["Date", "Signal", "Net_Return"]]
+
+    def color_return(val):
+        return "color: #00c896; font-weight:bold" if val > 0 else "color: #ff4b4b; font-weight:bold"
+
+    styled = df.style.applymap(color_return, subset=["Net_Return"]).format(
+        {"Net_Return": "{:.2%}"}
+    ).set_properties(**{
+        "font-size": "16px",
+        "text-align": "center",
+    }).set_table_styles([
+        {"selector": "th", "props": [("font-size", "16px"), ("font-weight", "bold"),
+                                      ("text-align", "center")]},
+        {"selector": "td", "props": [("padding", "10px")]},
+    ])
+    st.dataframe(styled, use_container_width=True, height=500)

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/ui/charts.py

@@ -0,0 +1,144 @@
+"""
+ui/charts.py
+All Plotly chart builders for the Streamlit UI.
+"""
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+
+
+APPROACH_COLOURS = {
+    "Approach 1": "#00ffc8",
+    "Approach 2": "#7c6aff",
+    "Approach 3": "#ff6b6b",
+}
+BENCHMARK_COLOURS = {
+    "SPY": "#ff4b4b",
+    "AGG": "#ffa500",
+}
+
+
+def equity_curve_chart(
+    results: dict,
+    winner_name: str,
+    plot_dates: pd.DatetimeIndex,
+    df: pd.DataFrame,
+    test_slice: slice,
+    tbill_rate: float,
+) -> go.Figure:
+    """
+    Equity curve chart showing all three approaches + SPY + AGG benchmarks.
+
+    Args:
+        results     : {approach_name: result_dict}
+        winner_name : highlighted approach
+        plot_dates  : DatetimeIndex for x-axis
+        df          : full DataFrame (for benchmark columns)
+        test_slice  : slice object to extract test-period benchmark returns
+        tbill_rate  : for benchmark metric calculation
+    """
+    from strategy.backtest import compute_benchmark_metrics
+
+    fig = go.Figure()
+
+    # ── Strategy lines ────────────────────────────────────────────────────────
+    for name, res in results.items():
+        if res is None:
+            continue
+        colour = APPROACH_COLOURS.get(name, "#aaaaaa")
+        width  = 3 if name == winner_name else 1.5
+        dash   = "solid" if name == winner_name else "dot"
+
+        n = min(len(res["cum_returns"]), len(plot_dates))
+
+        fig.add_trace(go.Scatter(
+            x=plot_dates[:n],
+            y=res["cum_returns"][:n],
+            mode="lines",
+            name=f"{name} {'★' if name == winner_name else ''}",
+            line=dict(color=colour, width=width, dash=dash),
+            fill="tozeroy" if name == winner_name else None,
+            fillcolor=f"rgba({_hex_to_rgb(colour)},0.07)" if name == winner_name else None,
+        ))
+
+    # ── Benchmark: SPY ────────────────────────────────────────────────────────
+    if "SPY_Ret" in df.columns:
+        spy_rets = df["SPY_Ret"].iloc[test_slice].values
+        n        = min(len(spy_rets), len(plot_dates))
+        spy_m    = compute_benchmark_metrics(spy_rets[:n], tbill_rate)
+        fig.add_trace(go.Scatter(
+            x=plot_dates[:n],
+            y=spy_m["cum_returns"],
+            mode="lines",
+            name="SPY (Equity BM)",
+            line=dict(color=BENCHMARK_COLOURS["SPY"], width=1.5, dash="dot"),
+        ))
+
+    # ── Benchmark: AGG ────────────────────────────────────────────────────────
+    if "AGG_Ret" in df.columns:
+        agg_rets = df["AGG_Ret"].iloc[test_slice].values
+        n        = min(len(agg_rets), len(plot_dates))
+        agg_m    = compute_benchmark_metrics(agg_rets[:n], tbill_rate)
+        fig.add_trace(go.Scatter(
+            x=plot_dates[:n],
+            y=agg_m["cum_returns"],
+            mode="lines",
+            name="AGG (Bond BM)",
+            line=dict(color=BENCHMARK_COLOURS["AGG"], width=1.5, dash="dot"),
+        ))
+
+    fig.update_layout(
+        template="plotly_dark",
+        height=460,
+        hovermode="x unified",
+        showlegend=True,
+        legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01, font=dict(size=11)),
+        xaxis_title="Date",
+        yaxis_title="Cumulative Return (×)",
+        margin=dict(l=50, r=30, t=20, b=50),
+    )
+    return fig
+
+
+def comparison_bar_chart(results: dict, winner_name: str) -> go.Figure:
+    """
+    Horizontal bar chart comparing annualised returns across all three approaches.
+    """
+    names   = []
+    returns = []
+    colours = []
+
+    for name, res in results.items():
+        if res is None:
+            continue
+        names.append(name)
+        returns.append(res["ann_return"] * 100)
+        colours.append(APPROACH_COLOURS.get(name, "#aaaaaa"))
+
+    fig = go.Figure(go.Bar(
+        x=returns,
+        y=names,
+        orientation="h",
+        marker_color=colours,
+        text=[f"{r:.1f}%" for r in returns],
+        textposition="auto",
+    ))
+
+    fig.update_layout(
+        template="plotly_dark",
+        height=200,
+        xaxis_title="Annualised Return (%)",
+        margin=dict(l=100, r=30, t=10, b=40),
+        showlegend=False,
+    )
+    return fig
+
+
+# ── Helper ────────────────────────────────────────────────────────────────────
+
+def _hex_to_rgb(hex_color: str) -> str:
+    """Convert #rrggbb to 'r,g,b' string for rgba()."""
+    h = hex_color.lstrip("#")
+    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+    return f"{r},{g},{b}"

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/utils/calendar.py

@@ -0,0 +1,91 @@
+"""
+utils/calendar.py
+NYSE calendar utilities:
+  - Next trading day for signal display
+  - Market open check
+  - EST time helper
+"""
+
+from datetime import datetime, timedelta
+import pytz
+
+try:
+    import pandas_market_calendars as mcal
+    NYSE_CAL_AVAILABLE = True
+except ImportError:
+    NYSE_CAL_AVAILABLE = False
+
+
+def get_est_time() -> datetime:
+    """Return current datetime in US/Eastern timezone."""
+    return datetime.now(pytz.timezone("US/Eastern"))
+
+
+def is_market_open_today() -> bool:
+    """Return True if today is a NYSE trading day."""
+    today = get_est_time().date()
+    if NYSE_CAL_AVAILABLE:
+        try:
+            nyse     = mcal.get_calendar("NYSE")
+            schedule = nyse.schedule(start_date=today, end_date=today)
+            return len(schedule) > 0
+        except Exception:
+            pass
+    return today.weekday() < 5
+
+
+def get_next_signal_date() -> datetime.date:
+    """
+    Determine the date for which the model's signal applies.
+
+    Rules:
+      - If today is a NYSE trading day AND it is before 09:30 EST
+        → signal applies to TODAY (market hasn't opened yet)
+      - Otherwise
+        → signal applies to the NEXT NYSE trading day
+    """
+    now_est = get_est_time()
+    today   = now_est.date()
+
+    market_not_open_yet = (
+        now_est.hour < 9 or
+        (now_est.hour == 9 and now_est.minute < 30)
+    )
+
+    if NYSE_CAL_AVAILABLE:
+        try:
+            nyse     = mcal.get_calendar("NYSE")
+            schedule = nyse.schedule(
+                start_date=today,
+                end_date=today + timedelta(days=10),
+            )
+            if len(schedule) == 0:
+                return today   # fallback
+
+            first_day = schedule.index[0].date()
+
+            # Today is a trading day and market hasn't opened → today
+            if first_day == today and market_not_open_yet:
+                return today
+
+            # Otherwise find first trading day strictly after today
+            for ts in schedule.index:
+                d = ts.date()
+                if d > today:
+                    return d
+
+            return schedule.index[-1].date()
+        except Exception:
+            pass
+
+    # Fallback: simple weekend skip
+    candidate = today if market_not_open_yet else today + timedelta(days=1)
+    while candidate.weekday() >= 5:
+        candidate += timedelta(days=1)
+    return candidate
+
+
+def is_sync_window() -> bool:
+    """True if current EST time is in the 07:00-08:00 or 19:00-20:00 window."""
+    now = get_est_time()
+    return (7 <= now.hour < 8) or (19 <= now.hour < 20)

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/models/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/signals/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/strategy/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/ui/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/hf_space/utils/__init__.py

@@ -0,0 +1 @@
+

hf_space/hf_space/hf_space/hf_space/hf_space/models/models/__init__.py

@@ -0,0 +1 @@
+# models package

hf_space/hf_space/hf_space/hf_space/signals/__init__.py

@@ -1 +1 @@
-
+# strategy package

hf_space/hf_space/hf_space/strategy/__init__.py

@@ -1 +1 @@
-
+# strategy package

hf_space/hf_space/signals/__init__.py

@@ -1 +1 @@
-# strategy package
+# signals package

hf_space/ui/__init__.py

@@ -1 +1 @@
-
+# ui package

utils/__init__.py

@@ -1 +1 @@
-
+# utils package