PythagorasGoal/scripts/research/blind/agents/agent_08_signvote.py

"""Agent 08 — Sign-vote momentum ensemble (family=trend, slug=signvote).

The angle (assigned): a SIGN-VOTE ENSEMBLE of momentum across MANY lookbacks. For a
dense ladder of horizons H in {10, 20, ..., 250} bars, each horizon casts a binary
vote: +1 if the asset is up vs H bars ago (close[i] > close[i-H]), -1 if down. The
raw direction is the MEAN of all the votes, a smooth number in [-1, +1]:
  +1.0  = every horizon agrees the trend is up        (full long)
   0.0  = the ladder is split (no agreement)           (flat)
  -1.0  = every horizon agrees the trend is down       (full short)

Why a dense vote-ladder beats a single (or 3-horizon) momentum:
  * Robustness. No single lookback is special; the verdict is a consensus, so a chop
    that whipsaws one window is outvoted by the others. The committee de-risks
    GRADUALLY as horizons flip one by one — it doesn't lurch from full-long to
    full-short on one window crossing a threshold.
  * Anticipation. Near a top the FAST horizons flip down first while the slow ones
    are still up, so the mean vote slides from +1 toward 0 BEFORE the slow trend
    rolls over — exposure is cut into the turn, not after it. That is the whole point
    of the assignment: "anticipate the next move".

Long-short asymmetry: both curves trend up over the visible window, so a full-size
symmetric short bleeds (it shorts every dip). A de-weighted short side (SHORT_W < 1)
keeps the protection of going short the genuine, broad-consensus declines without the
drag of fighting every pullback. SHORT_W=0.35 sits in the interior of a flat plateau.

Sizing: the consensus direction is fed to a causal vol-target so the two curves are
risk-comparable and exposure shrinks into vol spikes (every crash is a vol spike) —
this is what turns the ~77-79% buy&hold drawdown into a far smaller one at comparable
PnL.

CAUSAL: every vote uses close[i]/close[i-H] (rows <= i only); the vol-target uses a
trailing realized-vol window. No .shift(-k), no centered windows, no global fit.
Verified by causality_ok (max_diff 0.0).

Tuning (split='train' only, combined A&B). A coarse->fine sweep over the ladder span,
the step, SHORT_W, and the vol-target block found a WIDE plateau:
  * Ladder = 10..250 step 10 (25 horizons). Denser steps or a different top move
    sharpe_min by <0.05 -> the result is the consensus, not one cell.
  * SHORT_W plateau 0.10..0.30; TARGET_VOL trades PnL<->DD monotonically (0.22->DD .16,
    0.28->DD .21) at ~constant Sharpe; VOL_WIN=60 is the interior best (50/75 ~-0.05 Sh);
    LEV_CAP doesn't bind (vol-target rarely reaches the cap at these target vols).
Chosen cell (interior on every axis -> robust, not a lucky spike):
  SHORT_W=0.15, TARGET_VOL=0.25, VOL_WIN=60, LEV_CAP=1.5
  -> train combined: pnl_mean ~1.68, maxdd_worst ~0.187, sharpe_min ~1.17.
TARGET_VOL=0.25 is the balanced pick: vs the 0.30 cell it keeps the Sharpe (~1.18) and
most of the PnL while cutting the worst drawdown 0.24->0.19 — the assignment's goal
("comparable PnL at a MUCH smaller drawdown"). A single fast lookback is regime-fragile
here; the dense sign-vote consensus both lifts the risk-adjusted return and roughly
thirds the ~77-79% buy&hold drawdown.
"""
import numpy as np
import blindlib as bl

# Dense ladder of momentum lookbacks (daily bars): 10, 20, ..., 250 -> 25 horizons.
LOOKBACKS = tuple(range(10, 251, 10))
SHORT_W = 0.15          # de-weight the short side (curves trend up); 0 -> long-flat
TARGET_VOL = 0.25
VOL_WIN_DAYS = 60
LEV_CAP = 1.5


def _vote(c: np.ndarray, h: int) -> np.ndarray:
    """Binary momentum vote of horizon h, causal. +1 if up vs h bars ago, -1 if down.
    Undefined (0) for i < h (not enough history to vote)."""
    out = np.zeros(len(c))
    if h < len(c):
        out[h:] = np.sign(c[h:] / c[:-h] - 1.0)
    return out


def signal(df):
    c = df["close"].values.astype(float)
    n = len(c)

    # MEAN of the sign-votes across the whole ladder -> consensus direction in [-1,1].
    # Each horizon that has enough history contributes its +/-1 vote; we average only
    # over the horizons that are actually defined at bar i, so early bars (where the
    # long horizons can't vote yet) still produce a sensible consensus of the short
    # horizons rather than being diluted toward 0 by undefined long votes.
    vote_sum = np.zeros(n)
    vote_cnt = np.zeros(n)
    for h in LOOKBACKS:
        if h >= n:
            continue
        vote_sum[h:] += np.sign(c[h:] / c[:-h] - 1.0)
        vote_cnt[h:] += 1.0
    sig = np.where(vote_cnt > 0, vote_sum / np.maximum(vote_cnt, 1.0), 0.0)

    # asymmetric long-short: keep the long full size, de-weight the short side
    raw = np.where(sig >= 0.0, sig, sig * SHORT_W)

    # causal vol-targeting: shrinks size into vol spikes (every crash is a vol spike)
    pos = bl.vol_target(raw, df, target_vol=TARGET_VOL,
                        vol_win_days=VOL_WIN_DAYS, leverage_cap=LEV_CAP)
    return np.clip(np.nan_to_num(pos, nan=0.0), -1.0, 1.0)