Community Scripts

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:37:19
# Model            : XGBoost
# Feature Eng.     : SMA (20,50,200), BB (20,2.0), RSI 14, MACD (12,26,9), 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/USDCAD_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):

    # ── SMA & distance features ──────────────────────────────────────────────
    for p in [20, 50, 200]:
        sma = close.rolling(p).mean()
        df[f"sma_{p}"] = sma
        df[f"dm_sma_{p}"] = (close - sma) / sma

    # SMA slope (rate of change of SMA over 5 bars)
    for p in [20, 50]:
        sma = df[f"sma_{p}"]
        df[f"sma_{p}_slope"] = sma.diff(5) / sma.shift(5)

    # SMA cross signals
    df["sma_20_50_cross"] = np.where(df["sma_20"] > df["sma_50"], 1.0, -1.0)
    df["sma_50_200_cross"] = np.where(df["sma_50"] > df["sma_200"], 1.0, -1.0)

    # ── Bollinger Bands ───────────────────────────────────────────────────────
    bb_mid = close.rolling(20).mean()
    bb_std = close.rolling(20).std()
    bb_upper = bb_mid + 2.0 * bb_std
    bb_lower = bb_mid - 2.0 * bb_std
    df["bb_mid"] = bb_mid
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    bb_range = bb_upper - bb_lower
    df["bb_pct"] = np.where(bb_range != 0, (close - bb_lower) / bb_range, 0.5)

    # Bollinger Band squeeze: width vs its own 20-bar average
    df["bb_squeeze"] = df["bb_width"] / df["bb_width"].rolling(20).mean()

    # Price position relative to bands
    df["bb_above_upper"] = np.where(close > bb_upper, 1.0, 0.0)
    df["bb_below_lower"] = np.where(close < bb_lower, 1.0, 0.0)

    # ── RSI ───────────────────────────────────────────────────────────────────
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = (-delta).clip(lower=0)
    avg_gain = gain.ewm(alpha=1/14, adjust=False).mean()
    avg_loss = loss.ewm(alpha=1/14, adjust=False).mean()
    rs = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI derived features
    df["rsi_norm"] = (df["rsi_14"] - 50) / 50          # centred & scaled
    df["rsi_ob"] = np.where(df["rsi_14"] > 70, 1.0, 0.0)
    df["rsi_os"] = np.where(df["rsi_14"] < 30, 1.0, 0.0)
    df["rsi_slope"] = df["rsi_14"].diff(3)

    # RSI divergence proxy: price up but RSI down (5-bar)
    price_chg_5 = close.diff(5)
    rsi_chg_5 = df["rsi_14"].diff(5)
    df["rsi_bear_div"] = np.where((price_chg_5 > 0) & (rsi_chg_5 < 0), 1.0, 0.0)
    df["rsi_bull_div"] = np.where((price_chg_5 < 0) & (rsi_chg_5 > 0), 1.0, 0.0)

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

    # MACD normalised by close price
    df["macd_line_norm"] = macd_line / close
    df["macd_hist_norm"] = df["macd_hist"] / close

    # MACD histogram slope and sign change
    df["macd_hist_slope"] = df["macd_hist"].diff(2)
    df["macd_cross"] = np.where(macd_line > signal_line, 1.0, -1.0)

    # ── ATR ───────────────────────────────────────────────────────────────────
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    df["atr_14"] = tr.ewm(alpha=1/14, adjust=False).mean()
    df["natr"]   = df["atr_14"] / close

    # ATR regime: current ATR vs 50-bar rolling mean
    df["atr_regime"] = df["atr_14"] / df["atr_14"].rolling(50).mean()

    # ── Momentum / Price Action features ─────────────────────────────────────
    # Returns at multiple horizons
    for h in [1, 2, 4, 8, 16]:
        df[f"ret_{h}"] = close.pct_change(h)

    # Candle body & shadow
    body = (close - open_).abs()
    total_range = (high - low).replace(0, np.nan)
    df["body_ratio"] = body / total_range
    df["candle_dir"] = np.where(close >= open_, 1.0, -1.0)
    upper_shadow = high - pd.concat([close, open_], axis=1).max(axis=1)
    lower_shadow = pd.concat([close, open_], axis=1).min(axis=1) - low
    df["upper_shadow_ratio"] = upper_shadow / total_range
    df["lower_shadow_ratio"] = lower_shadow / total_range

    # Rolling price z-score (mean reversion signal)
    for w in [20, 50]:
        roll_mean = close.rolling(w).mean()
        roll_std  = close.rolling(w).std().replace(0, np.nan)
        df[f"zscore_{w}"] = (close - roll_mean) / roll_std

    # Volume of volatility: rolling std of returns
    df["vol_10"] = close.pct_change().rolling(10).std()
    df["vol_20"] = close.pct_change().rolling(20).std()

    # Efficiency ratio: directional move / path length (20 bars)
    direction_move = (close - close.shift(20)).abs()
    path_length = close.diff().abs().rolling(20).sum().replace(0, np.nan)
    df["efficiency_ratio"] = direction_move / path_length

    # ── Interaction / Cross features ─────────────────────────────────────────
    # RSI × MACD hist — captures momentum agreement
    df["rsi_macd_agree"] = df["rsi_norm"] * df["macd_hist_norm"]

    # BB pct × RSI — oversold/overbought near bands
    df["bb_rsi_interact"] = df["bb_pct"] * df["rsi_norm"]

    # Trend strength: distance from SMA50 scaled by ATR
    df["trend_atr_50"] = df["dm_sma_50"] / df["natr"].replace(0, np.nan)

    # ── Session / Time features ───────────────────────────────────────────────
    if hasattr(df.index, "hour"):
        hour = df.index.hour
        df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
        df["hour_cos"] = np.cos(2 * np.pi * hour / 24)
        # London session flag
        df["london_session"] = np.where((hour >= 7) & (hour < 16), 1.0, 0.0)
        # NY session flag
        df["ny_session"] = np.where((hour >= 13) & (hour < 21), 1.0, 0.0)

    if hasattr(df.index, "dayofweek"):
        dow = df.index.dayofweek
        df["dow_sin"] = np.sin(2 * np.pi * dow / 5)
        df["dow_cos"] = np.cos(2 * np.pi * dow / 5)

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "USD/CAD Momentum-Reversion Hybrid (XGBoost, v2)",
        "model_type":       "XGBClassifier",
        "model_params": {
            "n_estimators":     600,
            "max_depth":        4,
            "learning_rate":    0.03,
            "subsample":        0.75,
            "colsample_bytree": 0.70,
            "min_child_weight": 5,
            "gamma":            0.2,
            "reg_alpha":        0.5,
            "reg_lambda":       2.0,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "n_jobs":           -1,
            "random_state":     42,
        },
        "signal_threshold": 0.54,
        "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": (
            "Maximise risk-adjusted return (Sharpe/Calmar). "
            "Deeper ensemble (600 trees) with aggressive regularisation "
            "(reg_alpha=0.5, reg_lambda=2, gamma=0.2, min_child_weight=5) "
            "to prevent overfitting on 15-min USDCAD. "
            "Rich feature set adds z-scores, efficiency ratio, session dummies, "
            "RSI divergence, candle shape and cross-indicator interactions "
            "beyond the prior attempt's plain indicators. "
            "0.5% SL / 1.0% TP gives 1:2 R:R; session filter restricts to "
            "liquid London+NY overlap hours."
        ),
        "notes": (
            "Prior attempt used plain RSI/MACD/BB/ATR/SMA and scored PF=0.98. "
            "This version adds: rolling z-scores (20,50), efficiency ratio, "
            "candle body/shadow ratios, multi-horizon returns, ATR regime, "
            "BB squeeze, RSI divergence proxies, time-of-day sin/cos encoding, "
            "and interaction terms (rsi_macd_agree, bb_rsi_interact, trend_atr). "
            "Model regularised more heavily to combat the short date range. "
            "Signal threshold lifted slightly to 0.54 to reduce marginal trades."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  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."
        ),
    }