Community Scripts

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:23:23
# Model            : XGBoost
# Feature Eng.     : RSI 14, MACD (12,26,9) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/GBPUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):

    # --- RSI 14 ---
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=13, min_periods=14).mean()
    avg_loss = loss.ewm(com=13, min_periods=14).mean()
    rs = avg_gain / (avg_loss + 1e-12)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI derived features
    df["rsi_zscore"] = (df["rsi_14"] - df["rsi_14"].rolling(50).mean()) / (df["rsi_14"].rolling(50).std() + 1e-12)
    df["rsi_slope"] = df["rsi_14"].diff(3)
    df["rsi_above_50"] = np.where(df["rsi_14"] > 50, 1, 0)
    df["rsi_overbought"] = np.where(df["rsi_14"] > 70, 1, 0)
    df["rsi_oversold"] = np.where(df["rsi_14"] < 30, 1, 0)
    # RSI divergence proxy: price direction vs RSI direction
    price_dir_3 = np.sign(close.diff(3))
    rsi_dir_3 = np.sign(df["rsi_14"].diff(3))
    df["rsi_divergence"] = np.where(price_dir_3 != rsi_dir_3, 1, 0)

    # --- MACD (12, 26, 9) ---
    ema12 = close.ewm(span=12, adjust=False).mean()
    ema26 = close.ewm(span=26, adjust=False).mean()
    macd_line = ema12 - ema26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist = macd_line - signal_line
    df["macd_line"] = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"] = macd_hist

    # MACD derived features
    df["macd_hist_slope"] = macd_hist.diff(2)
    df["macd_cross_up"] = np.where((macd_line > signal_line) & (macd_line.shift(1) <= signal_line.shift(1)), 1, 0)
    df["macd_cross_dn"] = np.where((macd_line < signal_line) & (macd_line.shift(1) >= signal_line.shift(1)), 1, 0)
    df["macd_hist_positive"] = np.where(macd_hist > 0, 1, 0)
    df["macd_hist_expanding"] = np.where(macd_hist.abs() > macd_hist.abs().shift(1), 1, 0)
    df["macd_normalized"] = macd_line / (close + 1e-12)

    # --- ATR 14 ---
    tr1 = high - low
    tr2 = (high - close.shift(1)).abs()
    tr3 = (low - close.shift(1)).abs()
    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    atr14 = tr.ewm(com=13, min_periods=14).mean()
    df["atr_14"] = atr14
    df["natr_14"] = atr14 / (close + 1e-12)

    # ATR regime: high vs low volatility
    atr_ma = atr14.rolling(50).mean()
    df["atr_high_vol"] = np.where(atr14 > atr_ma * 1.2, 1, 0)
    df["atr_low_vol"] = np.where(atr14 < atr_ma * 0.8, 1, 0)

    # --- Bollinger Bands (20, 2) ---
    bb_mid = close.rolling(20).mean()
    bb_std = close.rolling(20).std()
    bb_upper = bb_mid + 2 * bb_std
    bb_lower = bb_mid - 2 * bb_std
    df["bb_pct_b"] = (close - bb_lower) / (bb_upper - bb_lower + 1e-12)
    df["bb_width"] = (bb_upper - bb_lower) / (bb_mid + 1e-12)
    df["bb_squeeze"] = np.where(df["bb_width"] < df["bb_width"].rolling(50).quantile(0.2), 1, 0)
    df["bb_upper_touch"] = np.where(close >= bb_upper * 0.999, 1, 0)
    df["bb_lower_touch"] = np.where(close <= bb_lower * 1.001, 1, 0)

    # --- Keltner Channel (20, 1.5x ATR) ---
    kc_mid = close.ewm(span=20, adjust=False).mean()
    kc_upper = kc_mid + 1.5 * atr14
    kc_lower = kc_mid - 1.5 * atr14
    df["kc_pct"] = (close - kc_lower) / (kc_upper - kc_lower + 1e-12)
    # Squeeze: BB inside KC
    df["kc_bb_squeeze"] = np.where((bb_upper < kc_upper) & (bb_lower > kc_lower), 1, 0)

    # --- Volume-like proxy: bar range & body ---
    bar_range = high - low
    bar_body = (close - open_).abs()
    df["range_norm"] = bar_range / (atr14 + 1e-12)
    df["body_ratio"] = bar_body / (bar_range + 1e-12)
    df["close_position"] = (close - low) / (bar_range + 1e-12)
    df["bullish_bar"] = np.where(close > open_, 1, 0)

    # --- Momentum & ROC ---
    df["roc_5"] = close.pct_change(5)
    df["roc_10"] = close.pct_change(10)
    df["roc_20"] = close.pct_change(20)
    df["momentum_10"] = close - close.shift(10)
    df["momentum_20"] = close - close.shift(20)

    # --- Moving Average features ---
    ema8 = close.ewm(span=8, adjust=False).mean()
    ema21 = close.ewm(span=21, adjust=False).mean()
    ema50 = close.ewm(span=50, adjust=False).mean()
    sma20 = close.rolling(20).mean()
    sma50 = close.rolling(50).mean()
    sma100 = close.rolling(100).mean()

    df["ema8_21_gap"] = (ema8 - ema21) / (close + 1e-12)
    df["ema21_50_gap"] = (ema21 - ema50) / (close + 1e-12)
    df["price_vs_ema50"] = (close - ema50) / (close + 1e-12)
    df["price_vs_sma20"] = (close - sma20) / (close + 1e-12)
    df["price_vs_sma100"] = (close - sma100) / (close + 1e-12)
    df["ema8_slope"] = ema8.diff(3) / (close + 1e-12)
    df["ema21_slope"] = ema21.diff(3) / (close + 1e-12)
    df["ema8_above_ema21"] = np.where(ema8 > ema21, 1, 0)
    df["ema21_above_ema50"] = np.where(ema21 > ema50, 1, 0)
    df["triple_ma_align_bull"] = np.where((ema8 > ema21) & (ema21 > ema50), 1, 0)
    df["triple_ma_align_bear"] = np.where((ema8 < ema21) & (ema21 < ema50), 1, 0)

    # --- Stochastic %K %D (14, 3) ---
    lowest_low_14 = low.rolling(14).min()
    highest_high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - lowest_low_14) / (highest_high_14 - lowest_low_14 + 1e-12)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_kd_diff"] = stoch_k - stoch_d
    df["stoch_overbought"] = np.where(stoch_k > 80, 1, 0)
    df["stoch_oversold"] = np.where(stoch_k < 20, 1, 0)
    df["stoch_cross_up"] = np.where((stoch_k > stoch_d) & (stoch_k.shift(1) <= stoch_d.shift(1)), 1, 0)
    df["stoch_cross_dn"] = np.where((stoch_k < stoch_d) & (stoch_k.shift(1) >= stoch_d.shift(1)), 1, 0)

    # --- Williams %R (14) ---
    df["willr_14"] = -100 * (highest_high_14 - close) / (highest_high_14 - lowest_low_14 + 1e-12)

    # --- CCI (20) ---
    tp = (high + low + close) / 3
    tp_ma = tp.rolling(20).mean()
    tp_mad = tp.rolling(20).apply(lambda x: np.mean(np.abs(x - np.mean(x))), raw=True)
    df["cci_20"] = (tp - tp_ma) / (0.015 * tp_mad + 1e-12)
    df["cci_above_zero"] = np.where(df["cci_20"] > 0, 1, 0)
    df["cci_extreme_bull"] = np.where(df["cci_20"] > 100, 1, 0)
    df["cci_extreme_bear"] = np.where(df["cci_20"] < -100, 1, 0)

    # --- Donchian Channel (20) ---
    don_high = high.rolling(20).max()
    don_low = low.rolling(20).min()
    df["donchian_pct"] = (close - don_low) / (don_high - don_low + 1e-12)
    df["donchian_breakout_up"] = np.where(close >= high.rolling(20).max().shift(1), 1, 0)
    df["donchian_breakout_dn"] = np.where(close <= low.rolling(20).min().shift(1), 1, 0)

    # --- Price pattern features ---
    df["higher_high"] = np.where((high > high.shift(1)) & (high.shift(1) > high.shift(2)), 1, 0)
    df["lower_low"] = np.where((low < low.shift(1)) & (low.shift(1) < low.shift(2)), 1, 0)
    df["inside_bar"] = np.where((high < high.shift(1)) & (low > low.shift(1)), 1, 0)
    df["outside_bar"] = np.where((high > high.shift(1)) & (low < low.shift(1)), 1, 0)

    # --- Lag features for key indicators ---
    for lag in [1, 2, 3, 4]:
        df[f"rsi_14_lag{lag}"] = df["rsi_14"].shift(lag)
        df[f"macd_hist_lag{lag}"] = df["macd_hist"].shift(lag)
        df[f"bb_pct_b_lag{lag}"] = df["bb_pct_b"].shift(lag)

    # --- Interaction features (avoiding lookahead) ---
    df["rsi_macd_bull"] = np.where((df["rsi_14"] > 50) & (df["macd_hist"] > 0), 1, 0)
    df["rsi_macd_bear"] = np.where((df["rsi_14"] < 50) & (df["macd_hist"] < 0), 1, 0)
    df["rsi_bb_oversold_bounce"] = np.where((df["rsi_14"] < 35) & (df["bb_pct_b"] < 0.2), 1, 0)
    df["rsi_bb_overbought_fade"] = np.where((df["rsi_14"] > 65) & (df["bb_pct_b"] > 0.8), 1, 0)
    df["triple_bull"] = np.where(
        (df["rsi_14"] > 50) & (df["macd_hist"] > 0) & (df["stoch_k"] > 50), 1, 0
    )
    df["triple_bear"] = np.where(
        (df["rsi_14"] < 50) & (df["macd_hist"] < 0) & (df["stoch_k"] < 50), 1, 0
    )

    # --- Volatility regime ---
    realized_vol = close.pct_change().rolling(20).std() * np.sqrt(96)
    df["realized_vol_20"] = realized_vol
    df["vol_regime_high"] = np.where(realized_vol > realized_vol.rolling(100).median(), 1, 0)

    # --- Session-aware time features ---
    if hasattr(df.index, 'hour'):
        df["hour_sin"] = np.sin(2 * np.pi * df.index.hour / 24)
        df["hour_cos"] = np.cos(2 * np.pi * df.index.hour / 24)
        df["london_session"] = np.where((df.index.hour >= 7) & (df.index.hour < 16), 1, 0)
        df["ny_session"] = np.where((df.index.hour >= 13) & (df.index.hour < 21), 1, 0)
        df["overlap_session"] = np.where((df.index.hour >= 13) & (df.index.hour < 16), 1, 0)
        df["asian_session"] = np.where((df.index.hour >= 0) & (df.index.hour < 7), 1, 0)
        df["day_of_week"] = df.index.dayofweek
        df["dow_sin"] = np.sin(2 * np.pi * df["day_of_week"] / 5)
        df["dow_cos"] = np.cos(2 * np.pi * df["day_of_week"] / 5)

    df = df.bfill().ffill()
    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "GBP/USD RSI-MACD Momentum + Volatility Regime XGBoost",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     500,
            "max_depth":        4,
            "learning_rate":    0.03,
            "subsample":        0.75,
            "colsample_bytree": 0.65,
            "min_child_weight": 5,
            "gamma":            0.15,
            "reg_alpha":        0.3,
            "reg_lambda":       1.5,
            "scale_pos_weight": 1,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "random_state":     42,
        },
        "signal_threshold": 0.56,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [7, 21],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe/Calmar) by combining RSI momentum "
            "divergence, MACD histogram dynamics, Bollinger squeeze, Stochastic crossovers, "
            "volatility regime, and session-aware time features. XGBoost with moderate depth "
            "and strong regularization prevents overfitting on 15-min GBP/USD data. "
            "Signal threshold 0.56 filters weak signals, SL/TP at 0.5%/1.0% gives 1:2 RR."
        ),
        "notes":            (
            "Differentiating from prior attempts (PF=1.08) by: (1) adding Keltner Channel "
            "squeeze interaction with Bollinger, (2) CCI and Williams %R as confirmation, "
            "Donchian breakout detection, (3) session-aware features (London/NY/overlap), "
            "(4) richer MACD/RSI interaction flags, (5) realized volatility regime, "
            "(6) stronger XGBoost regularization (alpha=0.3, lambda=1.5, min_child=5) "
            "to reduce false signals in choppy GBP/USD conditions."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:51:31
# Model            : XGBoost
# Feature Eng.     : BB (20,2.0), RSI 14, Stochastic (14,3) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/AUDUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):

    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    bb_period = 20
    bb_std    = 2.0
    bb_mid    = close.rolling(bb_period).mean()
    bb_std_val = close.rolling(bb_period).std(ddof=0)
    bb_upper  = bb_mid + bb_std * bb_std_val
    bb_lower  = bb_mid - bb_std * bb_std_val

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    df["bb_pct"]   = (close - bb_lower) / (bb_upper - bb_lower)

    # ── RSI (14) ─────────────────────────────────────────────────────────────
    rsi_period = 14
    delta      = close.diff()
    gain       = delta.clip(lower=0)
    loss       = -delta.clip(upper=0)
    avg_gain   = gain.ewm(com=rsi_period - 1, min_periods=rsi_period).mean()
    avg_loss   = loss.ewm(com=rsi_period - 1, min_periods=rsi_period).mean()
    rs         = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi"]  = 100 - (100 / (1 + rs))

    # ── Stochastic Oscillator (K=14, D=3) ────────────────────────────────────
    stoch_k_period = 14
    stoch_d_period = 3
    lowest_low     = low.rolling(stoch_k_period).min()
    highest_high   = high.rolling(stoch_k_period).max()
    denom          = (highest_high - lowest_low).replace(0, np.nan)
    df["stoch_k"]  = 100 * (close - lowest_low) / denom
    df["stoch_d"]  = df["stoch_k"].rolling(stoch_d_period).mean()
    df["stoch_kd_diff"] = df["stoch_k"] - df["stoch_d"]

    # ── Additional derived features ──────────────────────────────────────────

    # RSI overbought / oversold zone flags
    df["rsi_ob"]   = np.where(df["rsi"] > 70, 1, 0)
    df["rsi_os"]   = np.where(df["rsi"] < 30, 1, 0)
    df["rsi_mid"]  = df["rsi"] - 50.0

    # Stochastic overbought / oversold zone flags
    df["stoch_ob"] = np.where(df["stoch_k"] > 80, 1, 0)
    df["stoch_os"] = np.where(df["stoch_k"] < 20, 1, 0)

    # BB position regime: price relative to bands
    df["price_above_bb_upper"] = np.where(close > bb_upper, 1, 0)
    df["price_below_bb_lower"] = np.where(close < bb_lower, 1, 0)
    df["price_vs_bb_mid"]      = close - bb_mid

    # ATR-based volatility (14-bar)
    atr_period = 14
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    df["atr14"]  = tr.ewm(com=atr_period - 1, min_periods=atr_period).mean()
    df["natr14"] = df["atr14"] / close

    # SMA trend context
    df["sma_20"]  = close.rolling(20).mean()
    df["sma_50"]  = close.rolling(50).mean()
    df["sma_200"] = close.rolling(200).mean()
    df["price_vs_sma20"]  = (close - df["sma_20"]) / df["sma_20"]
    df["price_vs_sma50"]  = (close - df["sma_50"]) / df["sma_50"]
    df["sma20_vs_sma50"]  = (df["sma_20"] - df["sma_50"]) / df["sma_50"]

    # Momentum: rate of change
    df["roc_5"]  = close.pct_change(5)
    df["roc_10"] = close.pct_change(10)
    df["roc_20"] = close.pct_change(20)

    # MACD-style (EMA 12 - EMA 26)
    ema12        = close.ewm(span=12, min_periods=12).mean()
    ema26        = close.ewm(span=26, min_periods=26).mean()
    macd_line    = ema12 - ema26
    macd_signal  = macd_line.ewm(span=9, min_periods=9).mean()
    df["macd"]        = macd_line
    df["macd_signal"] = macd_signal
    df["macd_hist"]   = macd_line - macd_signal

    # Candle body / wick ratios
    body          = (close - open_).abs()
    candle_range  = (high - low).replace(0, np.nan)
    df["body_ratio"]  = body / candle_range
    df["upper_wick"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / candle_range
    df["lower_wick"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low) / candle_range
    df["bullish_bar"]  = np.where(close > open_, 1, 0)

    # Lagged RSI / Stoch features (1 and 2 bars back)
    df["rsi_lag1"]     = df["rsi"].shift(1)
    df["rsi_lag2"]     = df["rsi"].shift(2)
    df["stoch_k_lag1"] = df["stoch_k"].shift(1)
    df["bb_pct_lag1"]  = df["bb_pct"].shift(1)

    # RSI slope
    df["rsi_slope"] = df["rsi"] - df["rsi"].shift(3)

    # Stoch K crossing D (momentum signal)
    df["stoch_cross_up"]   = np.where((df["stoch_k"] > df["stoch_d"]) &
                                       (df["stoch_k"].shift(1) <= df["stoch_d"].shift(1)), 1, 0)
    df["stoch_cross_down"] = np.where((df["stoch_k"] < df["stoch_d"]) &
                                       (df["stoch_k"].shift(1) >= df["stoch_d"].shift(1)), 1, 0)

    # Volume (if present)
    if "volume" in df.columns:
        vol_ma = df["volume"].rolling(20).mean()
        df["vol_ratio"] = df["volume"] / vol_ma.replace(0, np.nan)
    else:
        df["vol_ratio"] = 1.0

    # ── Fill NaN from warm-up ────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "AUD/USD Stoch+BB+RSI Mean-Reversion XGBoost",
        "model_type":       "XGBClassifier",
        "model_params": {
            "n_estimators":       400,
            "max_depth":          4,
            "learning_rate":      0.04,
            "subsample":          0.75,
            "colsample_bytree":   0.70,
            "min_child_weight":   5,
            "gamma":              0.15,
            "reg_alpha":          0.10,
            "reg_lambda":         1.50,
            "objective":          "binary:logistic",
            "random_state":       42,
            "n_jobs":             -1,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [0, 23],
        "min_atr":          None,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe / Calmar). "
            "XGBoost chosen for its ability to capture non-linear interactions "
            "between Stochastic, Bollinger Bands, and RSI regimes. "
            "Shallow trees (max_depth=4) + high regularisation (reg_lambda=1.5, gamma=0.15) "
            "prevent overfitting on 15-min FX data. "
            "2:1 TP:SL ratio (1.0% / 0.5%) improves expectancy per trade. "
            "Reverse on opposite signal minimises flat time and captures regime flips."
        ),
        "notes": (
            "Features include BB width/pct, RSI(14) with overbought/oversold flags, "
            "Stochastic K/D crossovers, MACD histogram, ATR volatility, SMA trend context, "
            "candle body ratios, lagged indicators, and momentum ROC. "
            "signal_threshold=0.55 balances precision vs recall on directional calls. "
            "session_filter covers full 24h to capture Asia + London + NY sessions for AUD/USD."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:16:00
# Model            : Gradient Boosting
# Feature Eng.     : EMA (50,200), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/NZDUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── EMA 50 and EMA 200 ──────────────────────────────────────────────────
    ema_50  = close.ewm(span=50,  adjust=False).mean()
    ema_200 = close.ewm(span=200, adjust=False).mean()

    df["ema_50"]    = ema_50
    df["ema_200"]   = ema_200
    df["dm_ema_50"]  = (close - ema_50)  / ema_50
    df["dm_ema_200"] = (close - ema_200) / ema_200

    # EMA cross signal: ema_50 vs ema_200
    df["ema_cross"] = df["ema_50"] - df["ema_200"]

    # Cross direction: +1 when ema_50 > ema_200, -1 otherwise
    df["ema_cross_sign"] = np.where(df["ema_cross"] > 0, 1.0, -1.0)

    # Cross event: 1 when cross just happened (sign flip)
    prev_cross = df["ema_cross"].shift(1)
    df["ema_cross_event"] = np.where(
        (df["ema_cross"] * prev_cross) < 0, 1.0, 0.0
    )

    # ── ATR 14 ──────────────────────────────────────────────────────────────
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)

    atr = tr.ewm(span=14, adjust=False).mean()
    df["atr"]  = atr
    df["natr"] = atr / close

    # ── RSI 14 ──────────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(span=14, adjust=False).mean()
    avg_loss = loss.ewm(span=14, adjust=False).mean()
    rs  = avg_gain / (avg_loss + 1e-10)
    rsi = 100 - (100 / (1 + rs))
    df["rsi_14"] = rsi
    df["rsi_norm"] = (rsi - 50) / 50   # centred and scaled

    # ── MACD ────────────────────────────────────────────────────────────────
    ema_12   = close.ewm(span=12, adjust=False).mean()
    ema_26   = close.ewm(span=26, adjust=False).mean()
    macd     = ema_12 - ema_26
    signal   = macd.ewm(span=9, adjust=False).mean()
    df["macd"]         = macd
    df["macd_signal"]  = signal
    df["macd_hist"]    = macd - signal
    df["macd_norm"]    = macd / close
    df["macd_hist_norm"] = (macd - signal) / close

    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    sma_20  = close.rolling(20).mean()
    std_20  = close.rolling(20).std()
    bb_upper = sma_20 + 2 * std_20
    bb_lower = sma_20 - 2 * std_20
    bb_width = (bb_upper - bb_lower) / (sma_20 + 1e-10)
    bb_pos   = (close - bb_lower) / (bb_upper - bb_lower + 1e-10)
    df["bb_width"] = bb_width
    df["bb_pos"]   = bb_pos

    # ── Momentum & Rate-of-Change ────────────────────────────────────────────
    df["mom_4"]  = close.pct_change(4)
    df["mom_8"]  = close.pct_change(8)
    df["mom_16"] = close.pct_change(16)

    # ── Rolling volatility (realised vol over 20 bars) ──────────────────────
    log_ret = np.log(close / close.shift(1))
    df["rvol_20"] = log_ret.rolling(20).std()

    # ── Stochastic Oscillator (14) ───────────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - low_14) / (high_14 - low_14 + 1e-10)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_diff"] = stoch_k - stoch_d

    # ── Candle body / range features ────────────────────────────────────────
    df["body"]       = (close - open_).abs() / (high - low + 1e-10)
    df["upper_wick"] = (high - close.clip(lower=open_)) / (high - low + 1e-10)
    df["lower_wick"] = (close.clip(upper=open_) - low)  / (high - low + 1e-10)
    df["bar_dir"]    = np.where(close > open_, 1.0, -1.0)

    # ── Price position relative to EMAs ─────────────────────────────────────
    df["close_vs_ema50_sign"]  = np.where(close > ema_50,  1.0, -1.0)
    df["close_vs_ema200_sign"] = np.where(close > ema_200, 1.0, -1.0)

    # ── Lagged features (1-bar and 2-bar lags on key signals) ───────────────
    for col in ["rsi_norm", "macd_hist_norm", "mom_4", "ema_cross", "natr", "bb_pos"]:
        df[f"{col}_lag1"] = df[col].shift(1)
        df[f"{col}_lag2"] = df[col].shift(2)

    # ── Fill NaN from warm-up ────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "NZD/USD EMA Cross + ATR Gradient Boosting",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":       400,
            "max_depth":          4,
            "learning_rate":      0.03,
            "subsample":          0.8,
            "min_samples_leaf":   20,
            "max_features":       "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change":   30,
            "tol":                1e-4,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.01,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   None,
        "min_atr":          None,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe / Calmar). "
            "GradientBoostingClassifier with moderate depth (4) and low learning rate (0.03) "
            "to reduce overfitting on 15-min NZD/USD. SL=0.5%, TP=1.0% gives 1:2 RR. "
            "EMA 50/200 cross is the primary trend feature; ATR normalises volatility context. "
            "Supplementary RSI, MACD, Bollinger, Stochastic and candle-body features capture "
            "momentum and mean-reversion signals. Early stopping via n_iter_no_change guards "
            "against overfit on the training partition."
        ),
        "notes": (
            "target_horizon=4 (1 hour) matches typical intraday swing on NZD/USD. "
            "reverse on opposite signal keeps the model responsive during trending regimes. "
            "No session filter applied — NZD/USD has reasonable liquidity around the clock. "
            "min_samples_leaf=20 and subsample=0.8 add regularisation without grid search."
        ),
    }