Community Scripts

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:40:19
# Model            : XGBoost
# Feature Eng.     : EMA (9,21), RSI 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/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):
    # ── EMA 9 and EMA 21 ──────────────────────────────────────────────────
    ema_9  = close.ewm(span=9,  adjust=False).mean()
    ema_21 = close.ewm(span=21, adjust=False).mean()

    df["ema_9"]    = ema_9
    df["ema_21"]   = ema_21
    df["dm_ema_9"]  = (close - ema_9)  / ema_9
    df["dm_ema_21"] = (close - ema_21) / ema_21

    # EMA crossover signal: positive when fast > slow
    df["ema_cross"]       = ema_9 - ema_21
    df["ema_cross_prev"]  = df["ema_cross"].shift(1)
    # Binary: did a cross just occur?
    df["ema_cross_up"]    = np.where((df["ema_cross"] > 0) & (df["ema_cross_prev"] <= 0), 1, 0)
    df["ema_cross_down"]  = np.where((df["ema_cross"] < 0) & (df["ema_cross_prev"] >= 0), 1, 0)
    # Trend direction encoded as -1 / 1
    df["ema_trend"]       = np.where(ema_9 > ema_21, 1, -1)

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

    # RSI regime flags
    df["rsi_oversold"]   = np.where(rsi_14 < 30, 1, 0)
    df["rsi_overbought"] = np.where(rsi_14 > 70, 1, 0)
    df["rsi_mid"]        = rsi_14 - 50          # centred

    # RSI momentum (1-bar change in RSI)
    df["rsi_delta"]      = rsi_14.diff(1)
    df["rsi_delta2"]     = rsi_14.diff(3)

    # ── Additional momentum / volatility features ─────────────────────────
    # ATR-like normalised true range
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)
    atr_14 = tr.ewm(span=14, adjust=False).mean()
    df["atr_14"]  = atr_14
    df["natr_14"] = atr_14 / close          # normalised ATR

    # Rate-of-change over various horizons
    for n in [4, 8, 16]:
        df[f"roc_{n}"] = close.pct_change(n)

    # Bollinger Band width and %B (using 20-period SMA)
    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
    df["bb_width"] = (bb_upper - bb_lower) / sma_20
    df["bb_pct"]   = (close - bb_lower) / (bb_upper - bb_lower).replace(0, np.nan)

    # Candle body and wick features
    df["body"]        = (close - open_) / close
    df["upper_wick"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / close
    df["lower_wick"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low)  / close

    # Volume-normalised momentum proxy: price range relative to ATR
    df["range_vs_atr"] = (high - low) / atr_14.replace(0, np.nan)

    # Lagged EMA cross signal
    df["ema_cross_lag1"] = df["ema_cross"].shift(1)
    df["ema_cross_lag2"] = df["ema_cross"].shift(2)

    # Combined signal: RSI and EMA cross alignment
    df["rsi_ema_bull"] = np.where((rsi_14 > 50) & (ema_9 > ema_21), 1, 0)
    df["rsi_ema_bear"] = np.where((rsi_14 < 50) & (ema_9 < ema_21), 1, 0)

    # Hour-of-day (cyclical encoding) — no lookahead
    hour = df.index.hour
    df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
    df["hour_cos"] = np.cos(2 * np.pi * hour / 24)

    # Day-of-week (cyclical encoding)
    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 periods
    df = df.bfill().ffill()

    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "AUD/USD EMA Cross (9/21) + RSI14 XGBoost Scalper",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.8,
            "colsample_bytree": 0.75,
            "min_child_weight": 3,
            "gamma":            0.1,
            "reg_alpha":        0.05,
            "reg_lambda":       1.5,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "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":   [0, 23],
        "min_atr":          None,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective":        (
            "Maximise risk-adjusted return on AUD/USD 15-min bars. "
            "XGBoost chosen for its ability to capture non-linear interactions between "
            "the EMA-cross regime, RSI momentum, volatility (NATR/BB width), and time-of-day. "
            "Shallow trees (max_depth=4) with strong regularisation (reg_lambda=1.5, gamma=0.1) "
            "reduce overfitting on the limited 1-year window. "
            "2:1 R:R (SL=0.5%, TP=1.0%) improves Sharpe; reverse on opposite signal captures "
            "trend momentum without missing transitions."
        ),
        "notes":            (
            "Features: EMA-9/21 cross and distances, RSI-14 with regime flags and delta, "
            "ATR-14, NATR, Bollinger Band width/%B, 4/8/16-bar ROC, candle anatomy, "
            "time cyclical encodings. Threshold 0.54 filters marginal signals to raise precision. "
            "No session filter applied — AUD/USD has meaningful moves across Asian and London sessions."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:32:34
# 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/EURUSD_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 ──────────────────────────────────────────────────────────────
    period = 14
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=period - 1, min_periods=period).mean()
    avg_loss = loss.ewm(com=period - 1, min_periods=period).mean()
    rs = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI-derived features
    df["rsi_overbought"] = np.where(df["rsi_14"] > 70, 1, 0)
    df["rsi_oversold"]   = np.where(df["rsi_14"] < 30, 1, 0)
    df["rsi_centered"]   = df["rsi_14"] - 50.0

    # RSI momentum (change over last 3 bars)
    df["rsi_slope"] = df["rsi_14"].diff(3)

    # ── MACD (12, 26, 9) ────────────────────────────────────────────────────
    ema_12 = close.ewm(span=12, adjust=False).mean()
    ema_26 = close.ewm(span=26, adjust=False).mean()
    macd_line   = ema_12 - ema_26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist   = macd_line - signal_line

    df["macd_line"]   = macd_line
    df["signal_line"] = signal_line
    df["macd_hist"]   = macd_hist

    # MACD-derived features
    df["macd_above_signal"] = np.where(macd_line > signal_line, 1, 0)
    df["macd_hist_slope"]   = macd_hist.diff(2)
    df["macd_hist_sign"]    = np.where(macd_hist > 0, 1, -1)

    # ── Additional price-based features ─────────────────────────────────────
    # ATR (14)
    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(com=13, min_periods=14).mean()
    df["natr_14"] = df["atr_14"] / close

    # Normalised price position within recent range (20-bar)
    roll_high = high.rolling(20).max()
    roll_low  = low.rolling(20).min()
    denom = (roll_high - roll_low).replace(0, np.nan)
    df["price_position_20"] = (close - roll_low) / denom

    # 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.replace(0, np.nan)
    df["bb_pct_b"]  = (close - bb_lower) / (bb_upper - bb_lower).replace(0, np.nan)
    df["bb_width"]  = bb_width

    # SMA trend features
    sma_50  = close.rolling(50).mean()
    sma_200 = close.rolling(200).mean()
    df["sma_50"]          = sma_50
    df["price_vs_sma50"]  = (close - sma_50) / sma_50.replace(0, np.nan)
    df["price_vs_sma200"] = (close - sma_200) / sma_200.replace(0, np.nan)
    df["sma_trend"]       = np.where(sma_50 > sma_200, 1, -1)

    # Momentum / returns
    df["ret_1"]  = close.pct_change(1)
    df["ret_3"]  = close.pct_change(3)
    df["ret_8"]  = close.pct_change(8)
    df["ret_16"] = close.pct_change(16)

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

    # Volatility regime: rolling std of returns (20-bar)
    df["vol_regime"] = df["ret_1"].rolling(20).std()

    # RSI × MACD interaction
    df["rsi_macd_interact"] = df["rsi_centered"] * df["macd_hist"]

    # Volume of MACD histogram change (acceleration)
    df["macd_hist_accel"] = df["macd_hist"].diff(1)

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

    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD RSI+MACD Momentum Scalper (XGBoost)",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.75,
            "colsample_bytree": 0.75,
            "min_child_weight": 5,
            "gamma":            0.1,
            "reg_alpha":        0.05,
            "reg_lambda":       1.5,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "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":   [7, 17],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe/Calmar). "
            "XGBoost with regularisation (alpha, lambda, gamma, min_child_weight) "
            "to reduce overfitting on 15-min EUR/USD data. "
            "Shallow trees (max_depth=4) and column/row subsampling prevent "
            "memorisation of noise. Horizon=4 bars (1 hour) balances signal "
            "quality vs trade frequency. Session filter [7,17] UTC focuses on "
            "liquid London/NY overlap. SL=0.5%, TP=1.0% gives 1:2 R/R. "
            "Threshold=0.55 filters marginal predictions while keeping enough trades."
        ),
        "notes": (
            "Features: RSI-14 (centred, slope, OB/OS flags), MACD(12,26,9) "
            "(line, signal, histogram, slope, acceleration, interaction with RSI), "
            "Bollinger Bands (pct_b, width), SMA-50/200 trend offsets, "
            "ATR/NATR, 20-bar price position, momentum returns (1/3/8/16 bars), "
            "candle anatomy (body ratio, upper/lower wick), volatility regime. "
            "All features are look-ahead free and normalised where possible."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:44:26
# Model            : XGBoost
# Feature Eng.     : BB (20,2.0), 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/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_sigma = close.rolling(bb_period).std(ddof=0)
    bb_upper = bb_mid + bb_std * bb_sigma
    bb_lower = bb_mid - bb_std * bb_sigma

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    # guard against zero range
    bb_range = bb_upper - bb_lower
    df["bb_pct"]   = np.where(bb_range != 0, (close - bb_lower) / bb_range, 0.5)

    # ── ATR (14) & Normalised ATR ────────────────────────────────────────────
    atr_period = 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=atr_period, min_periods=atr_period, adjust=False).mean()
    df["atr"]  = atr
    df["natr"] = np.where(close != 0, atr / close, 0.0)

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

    # ── 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()
    df["macd"]        = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"]   = macd_line - signal_line

    # ── EMA trend features ───────────────────────────────────────────────────
    ema_20  = close.ewm(span=20, adjust=False).mean()
    ema_50  = close.ewm(span=50, adjust=False).mean()
    ema_200 = close.ewm(span=200, adjust=False).mean()
    df["ema_20"]        = ema_20
    df["ema_50"]        = ema_50
    df["ema_200"]       = ema_200
    df["close_vs_ema20"]  = (close - ema_20) / ema_20
    df["close_vs_ema50"]  = (close - ema_50) / ema_50
    df["ema20_vs_ema50"]  = (ema_20 - ema_50) / ema_50
    df["ema50_vs_ema200"] = (ema_50 - ema_200) / ema_200

    # ── Price momentum / rate-of-change ──────────────────────────────────────
    for n in [1, 4, 8, 16]:
        df[f"roc_{n}"] = close.pct_change(n)

    # ── Rolling volatility ────────────────────────────────────────────────────
    df["vol_10"]  = close.pct_change().rolling(10).std()
    df["vol_20"]  = close.pct_change().rolling(20).std()
    df["vol_ratio"] = np.where(df["vol_20"] != 0,
                               df["vol_10"] / df["vol_20"], 1.0)

    # ── Stochastic %K / %D (14, 3) ───────────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    stoch_range = high_14 - low_14
    stoch_k = np.where(stoch_range != 0,
                       100 * (close - low_14) / stoch_range, 50.0)
    df["stoch_k"] = stoch_k
    df["stoch_d"] = pd.Series(stoch_k, index=close.index).rolling(3).mean()

    # ── Candle body / wick features ──────────────────────────────────────────
    body      = (close - open_).abs()
    total_rng = (high - low).replace(0, np.nan)
    df["body_ratio"]  = body / total_rng
    df["upper_wick"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / total_rng
    df["lower_wick"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low) / total_rng
    df["candle_dir"]  = np.sign(close - open_)

    # ── BB interaction features ───────────────────────────────────────────────
    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["bb_squeeze"]           = np.where(df["bb_width"] < df["bb_width"].rolling(50).quantile(0.20), 1, 0)

    # ── RSI regime bins (replacing pd.cut) ───────────────────────────────────
    df["rsi_oversold"]  = np.where(rsi < 30, 1, 0)
    df["rsi_overbought"] = np.where(rsi > 70, 1, 0)
    df["rsi_neutral"]   = np.where((rsi >= 30) & (rsi <= 70), 1, 0)

    # ── Volume proxy (if volume column exists) ───────────────────────────────
    if "volume" in df.columns:
        vol_ma = df["volume"].rolling(20).mean()
        df["volume_ratio"] = np.where(vol_ma != 0,
                                      df["volume"] / vol_ma, 1.0)

    # ── Lagged features (1-bar lag to avoid lookahead) ───────────────────────
    for feat in ["bb_pct", "rsi_14", "macd_hist", "natr", "stoch_k"]:
        df[f"{feat}_lag1"] = df[feat].shift(1)
        df[f"{feat}_lag2"] = df[feat].shift(2)

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "AUD/USD Bollinger + ATR Mean-Rev (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":   3,
            "gamma":              0.10,
            "reg_alpha":          0.10,
            "reg_lambda":         1.50,
            "objective":          "binary:logistic",
            "random_state":       42,
            "n_jobs":             -1,
        },
        "signal_threshold": 0.56,
        "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). "
            "XGBoost with moderate depth and heavy regularisation "
            "(gamma, alpha, lambda) prevents overfit on AUD/USD 15-min data. "
            "Bollinger Bands capture mean-reversion; ATR normalises volatility; "
            "RSI + MACD confirm momentum; 2:1 TP:SL ratio supports positive expectancy."
        ),
        "notes": (
            "Features: BB (20,2) width/pct, ATR-14/NATR, RSI-14, MACD histogram, "
            "EMA 20/50/200 spreads, Stochastic %K/%D, candle-body ratios, "
            "ROC at multiple horizons, volatility ratio, BB squeeze flag, "
            "lagged versions of key features. "
            "Threshold 0.56 filters marginal signals, improving precision. "
            "target_horizon=4 (1 hour) balances signal frequency vs. noise."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:27:43
# Model            : XGBoost
# Feature Eng.     : SMA (20,50,200) + 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):
    # ── Required SMAs and distance metrics ──────────────────────────────────
    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 (momentum of the moving average itself) ───────────────────
    for p in [20, 50]:
        sma = close.rolling(p).mean()
        df[f"sma_{p}_slope"] = sma.diff(5) / sma.shift(5)

    # ── SMA cross signals ────────────────────────────────────────────────────
    sma20 = close.rolling(20).mean()
    sma50 = close.rolling(50).mean()
    sma200 = close.rolling(200).mean()
    df["sma20_50_cross"] = (sma20 - sma50) / sma50
    df["sma50_200_cross"] = (sma50 - sma200) / sma200
    df["sma20_200_cross"] = (sma20 - sma200) / sma200

    # ── Price momentum over multiple horizons ────────────────────────────────
    for lag in [1, 3, 6, 12, 24, 48]:
        df[f"ret_{lag}"] = close.pct_change(lag)

    # ── Volatility: rolling standard deviation of returns ───────────────────
    ret1 = close.pct_change(1)
    for w in [10, 20, 40]:
        df[f"vol_{w}"] = ret1.rolling(w).std()

    # ── ATR (Average True Range, normalised) ─────────────────────────────────
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    for w in [14, 28]:
        atr = tr.ewm(span=w, adjust=False).mean()
        df[f"natr_{w}"] = atr / close

    # ── Bollinger Bands (20-period, 2σ) ──────────────────────────────────────
    bb_mid  = close.rolling(20).mean()
    bb_std  = close.rolling(20).std()
    bb_up   = bb_mid + 2 * bb_std
    bb_lo   = bb_mid - 2 * bb_std
    bb_width = (bb_up - bb_lo) / bb_mid
    df["bb_pct_b"]  = (close - bb_lo) / (bb_up - bb_lo + 1e-12)
    df["bb_width"]  = bb_width
    df["bb_squeeze"]= np.where(bb_width < bb_width.rolling(50).mean(), 1.0, 0.0)

    # ── Keltner Channel (for squeeze confirmation) ───────────────────────────
    kc_mid  = close.ewm(span=20, adjust=False).mean()
    kc_atr  = tr.ewm(span=20, adjust=False).mean()
    kc_up   = kc_mid + 1.5 * kc_atr
    kc_lo   = kc_mid - 1.5 * kc_atr
    df["kc_pct"] = (close - kc_lo) / (kc_up - kc_lo + 1e-12)

    # ── RSI (Wilder) ─────────────────────────────────────────────────────────
    def wilder_rsi(src, period):
        delta = src.diff(1)
        gain  = delta.clip(lower=0)
        loss  = (-delta).clip(lower=0)
        avg_g = gain.ewm(alpha=1/period, adjust=False).mean()
        avg_l = loss.ewm(alpha=1/period, adjust=False).mean()
        rs    = avg_g / (avg_l + 1e-12)
        return 100 - 100 / (1 + rs)

    rsi14 = wilder_rsi(close, 14)
    rsi6  = wilder_rsi(close, 6)
    rsi28 = wilder_rsi(close, 28)
    df["rsi14"] = rsi14 / 100.0
    df["rsi6"]  = rsi6  / 100.0
    df["rsi28"] = rsi28 / 100.0
    df["rsi14_slope"] = rsi14.diff(3) / 100.0

    # RSI divergence proxy: price new high/low but RSI doesn't confirm
    price_high_12 = close.rolling(12).max()
    price_low_12  = close.rolling(12).min()
    rsi_high_12   = rsi14.rolling(12).max()
    rsi_low_12    = rsi14.rolling(12).min()
    df["rsi_bear_div"] = np.where(
        (close >= price_high_12 * 0.999) & (rsi14 < rsi_high_12 * 0.97), 1.0, 0.0)
    df["rsi_bull_div"] = np.where(
        (close <= price_low_12  * 1.001) & (rsi14 > rsi_low_12  * 1.03), 1.0, 0.0)

    # ── MACD ─────────────────────────────────────────────────────────────────
    ema12  = close.ewm(span=12, adjust=False).mean()
    ema26  = close.ewm(span=26, adjust=False).mean()
    macd   = ema12 - ema26
    signal = macd.ewm(span=9, adjust=False).mean()
    hist   = macd - signal
    df["macd_norm"]    = macd   / close
    df["macd_sig_norm"]= signal / close
    df["macd_hist_norm"]= hist  / close
    df["macd_hist_slope"] = hist.diff(2) / close

    # ── Stochastic Oscillator ─────────────────────────────────────────────────
    for k_period in [14, 5]:
        lo_k = low.rolling(k_period).min()
        hi_k = high.rolling(k_period).max()
        stoch_k = (close - lo_k) / (hi_k - lo_k + 1e-12) * 100
        stoch_d = stoch_k.rolling(3).mean()
        df[f"stoch_k_{k_period}"] = stoch_k / 100.0
        df[f"stoch_d_{k_period}"] = stoch_d / 100.0
        df[f"stoch_kd_{k_period}"] = (stoch_k - stoch_d) / 100.0

    # ── Williams %R ───────────────────────────────────────────────────────────
    hi14 = high.rolling(14).max()
    lo14 = low.rolling(14).min()
    df["williams_r"] = (hi14 - close) / (hi14 - lo14 + 1e-12)

    # ── CCI (Commodity Channel Index) ────────────────────────────────────────
    tp = (high + low + close) / 3.0
    tp_sma = tp.rolling(20).mean()
    tp_mad  = tp.rolling(20).apply(lambda x: np.mean(np.abs(x - x.mean())), raw=True)
    df["cci"] = (tp - tp_sma) / (0.015 * tp_mad + 1e-12) / 100.0

    # ── Volume-like proxy: candle body and wick ratios ────────────────────────
    candle_range = (high - low).replace(0, np.nan)
    df["body_ratio"]  = (close - open_).abs() / 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["bull_candle"]  = np.where(close > open_, 1.0, 0.0)

    # ── Mean reversion signal: z-score of close vs SMA20 ────────────────────
    df["zscore_20"] = (close - sma20) / (close.rolling(20).std() + 1e-12)
    df["zscore_50"] = (close - sma50) / (close.rolling(50).std() + 1e-12)

    # ── Trend strength: ADX proxy ─────────────────────────────────────────────
    plus_dm  = (high.diff(1)).clip(lower=0)
    minus_dm = (-low.diff(1)).clip(lower=0)
    overlap  = pd.concat([plus_dm, minus_dm], axis=1).min(axis=1)
    plus_dm  = plus_dm - overlap
    minus_dm = minus_dm - overlap
    atr14 = tr.ewm(span=14, adjust=False).mean()
    plus_di  = 100 * plus_dm.ewm(span=14, adjust=False).mean()  / (atr14 + 1e-12)
    minus_di = 100 * minus_dm.ewm(span=14, adjust=False).mean() / (atr14 + 1e-12)
    dx = (plus_di - minus_di).abs() / (plus_di + minus_di + 1e-12) * 100
    adx = dx.ewm(span=14, adjust=False).mean()
    df["adx"]      = adx / 100.0
    df["plus_di"]  = plus_di / 100.0
    df["minus_di"] = minus_di / 100.0
    df["di_diff"]  = (plus_di - minus_di) / 100.0

    # ── Regime detection: above/below long-term SMA ──────────────────────────
    df["bull_regime"]  = np.where(close > sma200, 1.0, 0.0)
    df["mid_regime"]   = np.where(close > sma50,  1.0, 0.0)

    # ── Lag features (auto-regressive) ───────────────────────────────────────
    for col, lags in [("rsi14", [1, 2, 4]), ("macd_hist_norm", [1, 2]), ("bb_pct_b", [1, 2])]:
        for lag in lags:
            df[f"{col}_lag{lag}"] = df[col].shift(lag)

    # ── Time-of-day features ─────────────────────────────────────────────────
    if hasattr(df.index, "hour"):
        df["hour_sin"] = np.sin(2 * np.pi * df.index.hour / 24.0)
        df["hour_cos"] = np.cos(2 * np.pi * df.index.hour / 24.0)
        df["dow_sin"]  = np.sin(2 * np.pi * df.index.dayofweek / 5.0)
        df["dow_cos"]  = np.cos(2 * np.pi * df.index.dayofweek / 5.0)

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


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "GBP/USD SMA Trend + Multi-Indicator XGBoost Classifier",
        "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.10,
            "reg_alpha":        0.10,
            "reg_lambda":       1.50,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "random_state":     42,
            "n_jobs":           -1,
        },
        "signal_threshold": 0.56,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 18],
        "min_atr":          0.0003,
        "trend_filter":     "sma_50",
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return on GBP/USD 15-min bars. "
            "Strategy combines required SMA (20/50/200) distance and cross features "
            "with ADX trend strength, RSI divergence, Bollinger squeeze, Keltner, "
            "MACD histogram slope, Stochastic, CCI, Williams %R, and candle-structure "
            "ratios. XGBoost with strong regularisation and subsampling prevents "
            "overfitting on the relatively short 1-year window. "
            "Session filter 06-18 UTC keeps execution in liquid London/NY hours; "
            "0.5% SL and 1.0% TP yield 1:2 R:R; sma_50 trend filter aligns trades "
            "with intermediate momentum to improve win rate and Sharpe."
        ),
        "notes": (
            "Differs from prior RSI/MACD/BB/Stoch attempts by: (1) foregrounding "
            "SMA cross and distance features as primary trend signals; (2) adding "
            "ADX-based regime and DI differential; (3) including RSI divergence "
            "proxy flags; (4) z-score mean-reversion features; (5) candle body/wick "
            "structure ratios as micro-structure proxies; (6) time-of-day cyclical "
            "encoding; (7) heavier regularisation (gamma, alpha, lambda) and higher "
            "min_child_weight to reduce variance on the thin dataset."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:56:13
# Model            : XGBoost
# Feature Eng.     : SMA (20,50,200) + 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/EURUSD_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 core features (required) ──────────────────────────────────────
    for period in [20, 50, 200]:
        sma = close.rolling(period).mean()
        df[f"sma_{period}"]    = sma
        df[f"dm_sma_{period}"] = (close - sma) / sma

    # ── SMA slope (momentum of the moving average itself) ─────────────────
    for period in [20, 50, 200]:
        df[f"sma_{period}_slope"] = df[f"sma_{period}"].diff(5) / df[f"sma_{period}"].shift(5)

    # ── SMA crossover signals ─────────────────────────────────────────────
    df["sma_20_50_cross"]  = df["sma_20"] - df["sma_50"]
    df["sma_50_200_cross"] = df["sma_50"] - df["sma_200"]
    df["sma_20_200_cross"] = df["sma_20"] - df["sma_200"]

    # ── Price vs SMA alignment score (how many SMAs price is above) ───────
    above_20  = np.where(close > df["sma_20"],  1, -1)
    above_50  = np.where(close > df["sma_50"],  1, -1)
    above_200 = np.where(close > df["sma_200"], 1, -1)
    df["sma_alignment"] = (above_20 + above_50 + above_200).astype(float)

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

    # ── Log returns ───────────────────────────────────────────────────────
    df["log_ret_1"] = np.log(close / close.shift(1))
    df["log_ret_4"] = np.log(close / close.shift(4))

    # ── ATR (14-period) ───────────────────────────────────────────────────
    tr1 = high - low
    tr2 = (high - close.shift(1)).abs()
    tr3 = (low  - close.shift(1)).abs()
    true_range = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    atr_14 = true_range.rolling(14).mean()
    df["atr_14"]  = atr_14
    df["natr_14"] = atr_14 / close

    # ── ATR ratio (current TR vs average — volatility burst) ──────────────
    df["atr_ratio"] = true_range / atr_14

    # ── Bollinger Bands (20, 2) ───────────────────────────────────────────
    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
    bb_width = (bb_upper - bb_lower) / bb_mid
    df["bb_pct_b"]  = (close - bb_lower) / (bb_upper - bb_lower + 1e-12)
    df["bb_width"]  = bb_width
    df["bb_zscore"] = (close - bb_mid) / (bb_std + 1e-12)

    # ── RSI (14) ──────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0).rolling(14).mean()
    loss   = (-delta.clip(upper=0)).rolling(14).mean()
    rs     = gain / (loss + 1e-12)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # ── RSI momentum ─────────────────────────────────────────────────────
    df["rsi_14_diff"] = df["rsi_14"].diff(2)

    # ── 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()
    df["macd_line"]   = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"]   = macd_line - signal_line
    df["macd_hist_diff"] = df["macd_hist"].diff(1)

    # ── Stochastic %K / %D (14, 3) ───────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - low_14) / (high_14 - 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

    # ── Williams %R (14) ─────────────────────────────────────────────────
    df["williams_r"] = -100 * (high_14 - close) / (high_14 - low_14 + 1e-12)

    # ── CCI (20) ─────────────────────────────────────────────────────────
    typical_price = (high + low + close) / 3
    tp_sma  = typical_price.rolling(20).mean()
    tp_mad  = typical_price.rolling(20).apply(lambda x: np.mean(np.abs(x - x.mean())), raw=True)
    df["cci_20"] = (typical_price - tp_sma) / (0.015 * tp_mad + 1e-12)

    # ── Rate of Change (10) ───────────────────────────────────────────────
    df["roc_10"] = (close - close.shift(10)) / (close.shift(10) + 1e-12) * 100

    # ── Volume / candle-body features (no volume data assumed) ────────────
    df["body_size"]   = (close - open_).abs() / (high - low + 1e-12)
    df["upper_wick"]  = (high - np.maximum(close, open_)) / (high - low + 1e-12)
    df["lower_wick"]  = (np.minimum(close, open_) - low)  / (high - low + 1e-12)
    df["is_bullish"]  = np.where(close > open_, 1.0, 0.0)

    # ── Rolling volatility (realised) ────────────────────────────────────
    df["vol_8"]  = df["log_ret_1"].rolling(8).std()
    df["vol_20"] = df["log_ret_1"].rolling(20).std()
    df["vol_ratio"] = df["vol_8"] / (df["vol_20"] + 1e-12)

    # ── High-low range relative to SMA ───────────────────────────────────
    df["hl_range_sma20"] = (high - low) / (df["sma_20"] + 1e-12)

    # ── Price position within recent n-bar range ──────────────────────────
    for n in [8, 20]:
        roll_low  = low.rolling(n).min()
        roll_high = high.rolling(n).max()
        df[f"price_pos_{n}"] = (close - roll_low) / (roll_high - roll_low + 1e-12)

    # ── Lagged returns as autoregressive features ─────────────────────────
    for lag in [1, 2, 3, 4, 8]:
        df[f"lag_ret_{lag}"] = df["ret_1"].shift(lag)

    # ── Distance from 20-bar high/low ────────────────────────────────────
    df["dist_high_20"] = (high.rolling(20).max() - close) / (close + 1e-12)
    df["dist_low_20"]  = (close - low.rolling(20).min())  / (close + 1e-12)

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD SMA Trend + Multi-Indicator XGBoost",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     500,
            "max_depth":        4,
            "learning_rate":    0.03,
            "subsample":        0.8,
            "colsample_bytree": 0.7,
            "min_child_weight": 3,
            "gamma":            0.1,
            "reg_alpha":        0.05,
            "reg_lambda":       1.0,
            "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":   [6, 18],
        "min_atr":          None,
        "trend_filter":     "sma_200",
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe/Calmar) on EUR/USD 15-min data. "
            "SMA triple-stack (20/50/200) provides trend context; supplementary "
            "momentum (RSI, MACD, Stochastic), volatility (ATR, BB), and "
            "mean-reversion (CCI, Williams %R) features give the XGBoost model a "
            "rich multi-regime signal set. XGBoost chosen for its ability to rank "
            "feature importance and handle non-linear interactions. Shallow trees "
            "(max_depth=4) with high n_estimators and low learning_rate reduce "
            "overfitting. 2:1 reward:risk (SL 0.5% / TP 1.0%) ensures positive "
            "expectancy even at moderate win rates. Session filter 06-18 UTC "
            "concentrates trades in liquid London/NY overlap."
        ),
        "notes":            (
            "trend_filter=sma_200 aligns trades with the dominant trend — longs "
            "only above the 200-SMA, shorts only below — acting as a regime gate "
            "to suppress counter-trend noise. signal_threshold=0.55 slightly above "
            "0.50 to reduce false positives without starving signal count. "
            "colsample_bytree=0.7 introduces randomisation across features to "
            "decorrelate trees and improve generalisation on forex data."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:01:00
# Model            : Gradient Boosting
# Feature Eng.     : BB (20,2.0), 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      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# Bollinger Bands Squeeze Breakout — GradientBoosting Strategy
# ============================================================

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_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_sigma = close.rolling(bb_period).std(ddof=0)
    bb_upper = bb_mid + bb_std * bb_sigma
    bb_lower = bb_mid - bb_std * bb_sigma

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower

    # Required derived features
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    df["bb_pct"]   = (close - bb_lower) / (bb_upper - bb_lower)

    # ── ATR (14) ─────────────────────────────────────────────────────────────
    atr_period = 14
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    atr = tr.ewm(span=atr_period, min_periods=atr_period, adjust=False).mean()

    df["atr"]  = atr
    df["natr"] = atr / close

    # ── Squeeze Detection ────────────────────────────────────────────────────
    # Squeeze = BB width is near its lowest over recent N bars (compression)
    squeeze_window = 20
    bb_width_min = df["bb_width"].rolling(squeeze_window).min()
    bb_width_max = df["bb_width"].rolling(squeeze_window).max()
    # Normalised squeeze score: 0 = fully squeezed, 1 = fully expanded
    df["squeeze_score"] = (df["bb_width"] - bb_width_min) / (bb_width_max - bb_width_min + 1e-10)

    # Squeeze flag: 1 if currently squeezed (bottom 20th percentile of width)
    df["in_squeeze"] = np.where(df["squeeze_score"] < 0.20, 1, 0)

    # Breakout direction: momentum after squeeze
    df["squeeze_breakout_up"]   = np.where((df["in_squeeze"].shift(1) == 1) & (close > bb_upper), 1, 0)
    df["squeeze_breakout_down"] = np.where((df["in_squeeze"].shift(1) == 1) & (close < bb_lower), 1, 0)

    # ── 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)

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

    # RSI distance from 50 (overbought/oversold)
    df["rsi_dist50"] = df["rsi_14"] - 50.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
    macd_signal = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_line"]   = macd_line
    df["macd_signal"] = macd_signal
    df["macd_hist"]   = macd_line - macd_signal

    # Normalise MACD by ATR to make scale-invariant
    df["macd_hist_norm"] = df["macd_hist"] / (atr + 1e-10)

    # ── Volume / Candle Body Features ────────────────────────────────────────
    body        = (close - open_).abs()
    candle_range = high - low
    df["body_ratio"]   = body / (candle_range + 1e-10)   # 0=doji, 1=full body
    df["close_pos"]    = (close - low) / (candle_range + 1e-10)  # position within bar

    # ── Trend / SMA Features ─────────────────────────────────────────────────
    df["sma_20"]  = bb_mid  # reuse already computed
    df["sma_50"]  = close.rolling(50).mean()
    df["sma_100"] = close.rolling(100).mean()

    df["price_vs_sma20"]  = (close - df["sma_20"])  / (atr + 1e-10)
    df["price_vs_sma50"]  = (close - df["sma_50"])  / (atr + 1e-10)
    df["price_vs_sma100"] = (close - df["sma_100"]) / (atr + 1e-10)

    # SMA cross: 20 vs 50
    df["sma20_vs_sma50"] = (df["sma_20"] - df["sma_50"]) / (atr + 1e-10)

    # ── BB Width Rate-of-Change (squeeze momentum) ───────────────────────────
    df["bb_width_roc3"]  = df["bb_width"].pct_change(3)
    df["bb_width_roc8"]  = df["bb_width"].pct_change(8)

    # ── Lagged BB features ───────────────────────────────────────────────────
    df["bb_pct_lag1"] = df["bb_pct"].shift(1)
    df["bb_pct_lag2"] = df["bb_pct"].shift(2)
    df["bb_pct_lag4"] = df["bb_pct"].shift(4)

    df["bb_width_lag1"] = df["bb_width"].shift(1)
    df["bb_width_lag4"] = df["bb_width"].shift(4)

    # ── Volatility Regime ────────────────────────────────────────────────────
    natr_ma = df["natr"].rolling(40).mean()
    df["vol_regime"] = np.where(df["natr"] > natr_ma, 1, 0)   # 1=high vol, 0=low vol

    # ── Price Distance from Bands (ATR-normalised) ───────────────────────────
    df["dist_upper"] = (bb_upper - close) / (atr + 1e-10)
    df["dist_lower"] = (close - bb_lower) / (atr + 1e-10)

    # ── Hour / Session (cyclical) ────────────────────────────────────────────
    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)

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "BB Squeeze Breakout + ATR Filter (GBM)",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":      400,
            "max_depth":         4,
            "learning_rate":     0.04,
            "subsample":         0.75,
            "max_features":      "sqrt",
            "min_samples_leaf":  20,
            "min_samples_split": 40,
            "n_iter_no_change":  30,
            "validation_fraction": 0.12,
            "tol":               1e-4,
            "random_state":      42,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 20],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe/Calmar). "
            "GradientBoosting chosen for its strong performance on tabular data with "
            "structured non-linear interactions. Shallow trees (depth=4) with high "
            "n_estimators and low learning_rate reduce overfitting. subsample=0.75 "
            "adds stochasticity. Early stopping via n_iter_no_change avoids "
            "over-training on the 15-min EURUSD regime. SL=0.5%/TP=1.0% gives 2:1 "
            "reward-risk, consistent with a squeeze-breakout edge. session_filter "
            "[6,20] UTC captures London+NY sessions where BB squeezes resolve cleanly. "
            "min_atr guards against ultra-low-volatility false breakouts."
        ),
        "notes": (
            "Features centre on BB squeeze mechanics: bb_width, squeeze_score, "
            "in_squeeze flag, breakout_up/down, width RoC, and lagged bb_pct. "
            "Complemented by RSI, MACD histogram (ATR-normalised), SMA trend "
            "distances, candle body ratio, and cyclical hour encoding. "
            "target_horizon=4 bars (1 hour) aligns with the typical squeeze "
            "resolution time on 15-min EURUSD. Signal threshold 0.55 filters "
            "marginal signals while preserving sufficient trade frequency."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:05:53
# Model            : Gradient Boosting
# 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/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):
    # ── RSI 14 ──────────────────────────────────────────────────────────────
    period = 14
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=period - 1, min_periods=period).mean()
    avg_loss = loss.ewm(com=period - 1, min_periods=period).mean()
    rs = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # ── MACD (12, 26, 9) ────────────────────────────────────────────────────
    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()
    macd_hist = macd_line - signal_line
    df["macd_line"] = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"] = macd_hist

    # ── RSI derived features ─────────────────────────────────────────────────
    df["rsi_14_lag1"] = df["rsi_14"].shift(1)
    df["rsi_14_lag2"] = df["rsi_14"].shift(2)
    df["rsi_14_delta"] = df["rsi_14"] - df["rsi_14_lag1"]
    df["rsi_ob"] = np.where(df["rsi_14"] > 70, 1, 0)
    df["rsi_os"] = np.where(df["rsi_14"] < 30, 1, 0)

    # ── MACD derived features ────────────────────────────────────────────────
    df["macd_hist_lag1"] = macd_hist.shift(1)
    df["macd_hist_delta"] = macd_hist - macd_hist.shift(1)
    df["macd_cross_bull"] = np.where((macd_line > signal_line) & (macd_line.shift(1) <= signal_line.shift(1)), 1, 0)
    df["macd_cross_bear"] = np.where((macd_line < signal_line) & (macd_line.shift(1) >= signal_line.shift(1)), 1, 0)
    df["macd_above_zero"] = np.where(macd_line > 0, 1, 0)
    df["macd_hist_positive"] = np.where(macd_hist > 0, 1, 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_14 = tr.ewm(span=14, adjust=False).mean()
    df["atr_14"] = atr_14
    df["natr_14"] = atr_14 / close

    # ── 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).replace(0, np.nan)
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid.replace(0, np.nan)
    df["bb_squeeze"] = np.where(df["bb_width"] < df["bb_width"].rolling(50).mean(), 1, 0)

    # ── Price momentum features ───────────────────────────────────────────────
    df["ret_1"] = close.pct_change(1)
    df["ret_4"] = close.pct_change(4)
    df["ret_8"] = close.pct_change(8)
    df["ret_16"] = close.pct_change(16)

    # ── Rolling volatility ────────────────────────────────────────────────────
    df["vol_8"] = df["ret_1"].rolling(8).std()
    df["vol_20"] = df["ret_1"].rolling(20).std()

    # ── EMA trend features ───────────────────────────────────────────────────
    ema_20 = close.ewm(span=20, adjust=False).mean()
    ema_50 = close.ewm(span=50, adjust=False).mean()
    df["ema_20"] = ema_20
    df["ema_50"] = ema_50
    df["price_vs_ema20"] = (close - ema_20) / ema_20
    df["price_vs_ema50"] = (close - ema_50) / ema_50
    df["ema20_vs_ema50"] = (ema_20 - ema_50) / ema_50

    # ── Candle body / wick features ──────────────────────────────────────────
    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["bull_candle"] = np.where(close > open_, 1, 0)

    # ── Rolling high/low position ─────────────────────────────────────────────
    roll_high_20 = high.rolling(20).max()
    roll_low_20 = low.rolling(20).min()
    roll_range_20 = (roll_high_20 - roll_low_20).replace(0, np.nan)
    df["price_position_20"] = (close - roll_low_20) / roll_range_20

    # ── RSI + MACD interaction ────────────────────────────────────────────────
    df["rsi_macd_product"] = df["rsi_14"] * macd_hist
    df["rsi_norm"] = (df["rsi_14"] - 50) / 50

    # ── Session / time features ───────────────────────────────────────────────
    if hasattr(close.index, "hour"):
        df["hour"] = close.index.hour
        df["session_london"] = np.where((close.index.hour >= 7) & (close.index.hour < 16), 1, 0)
        df["session_ny"] = np.where((close.index.hour >= 13) & (close.index.hour < 21), 1, 0)
        df["session_asia"] = np.where((close.index.hour >= 22) | (close.index.hour < 7), 1, 0)
    else:
        df["hour"] = 0
        df["session_london"] = 0
        df["session_ny"] = 0
        df["session_asia"] = 0

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

    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "AUD/USD RSI+MACD Gradient Boosting Scalper",
        "model_type": "GradientBoostingClassifier",
        "model_params": {
            "n_estimators": 400,
            "max_depth": 4,
            "learning_rate": 0.05,
            "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 on AUD/USD 15-min data using GradientBoostingClassifier. "
            "RSI-14 captures momentum extremes and divergence conditions; MACD (12,26,9) provides "
            "trend direction and momentum shifts via crossovers and histogram slope. Additional "
            "features (BB, ATR, EMA trend, candle structure, session timing) enrich the feature "
            "space. GradientBoosting with shallow trees (depth=4), moderate learning rate (0.05), "
            "and early stopping via n_iter_no_change prevents overfitting. SL=0.5%, TP=1.0% gives "
            "a 1:2 risk/reward ratio, improving Sharpe and Calmar. Threshold=0.55 filters low-confidence "
            "signals to reduce noise. Reverse on opposite signal maximizes capital efficiency."
        ),
        "notes": (
            "n_estimators=400 with early stopping balances bias-variance. max_depth=4 keeps trees "
            "shallow to reduce overfitting on FX microstructure noise. subsample=0.8 adds stochastic "
            "gradient boosting regularization. min_samples_leaf=20 prevents fitting to outlier bars. "
            "max_features='sqrt' adds feature randomization similar to random forests. "
            "target_horizon=4 (1 hour) aligns with typical AUD/USD intraday swing durations."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:33:17
# Model            : Gradient Boosting
# 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/EURUSD_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_v  = close.rolling(bb_period).std(ddof=0)
    bb_upper  = bb_mid + bb_std * bb_std_v
    bb_lower  = bb_mid - bb_std * bb_std_v

    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()
    range_hl       = (highest_high - lowest_low).replace(0, np.nan)
    df["stoch_k"]  = 100 * (close - lowest_low) / range_hl
    df["stoch_d"]  = df["stoch_k"].rolling(stoch_d_period).mean()
    df["stoch_kd_diff"] = df["stoch_k"] - df["stoch_d"]

    # ── ATR (14) ──────────────────────────────────────────────────────────────
    atr_period = 14
    prev_close = close.shift(1)
    tr         = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)
    df["atr"]  = tr.ewm(com=atr_period - 1, min_periods=atr_period).mean()
    df["natr"] = df["atr"] / close

    # ── SMA filters ──────────────────────────────────────────────────────────
    df["sma_20"]  = close.rolling(20).mean()
    df["sma_50"]  = close.rolling(50).mean()
    df["sma_200"] = close.rolling(200).mean()
    df["price_vs_sma50"]  = close / df["sma_50"]  - 1
    df["price_vs_sma200"] = close / df["sma_200"] - 1

    # ── EMA cross ────────────────────────────────────────────────────────────
    ema_fast = close.ewm(span=8,  adjust=False).mean()
    ema_slow = close.ewm(span=21, adjust=False).mean()
    df["ema_cross"] = ema_fast - ema_slow

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

    # ── Momentum / Rate-of-change ────────────────────────────────────────────
    df["roc_4"]  = close.pct_change(4)
    df["roc_8"]  = close.pct_change(8)
    df["roc_16"] = close.pct_change(16)

    # ── Candle features ───────────────────────────────────────────────────────
    df["candle_body"]   = (close - open_) / close
    df["candle_range"]  = (high - low)    / close
    df["upper_shadow"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / close
    df["lower_shadow"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low)  / close

    # ── Volatility regime ─────────────────────────────────────────────────────
    df["vol_ratio"] = df["atr"] / df["atr"].rolling(50).mean()

    # ── RSI regime bins (np.where instead of pd.cut) ─────────────────────────
    df["rsi_oversold"]  = np.where(df["rsi"] < 30, 1, 0)
    df["rsi_overbought"]= np.where(df["rsi"] > 70, 1, 0)
    df["rsi_mid"]       = np.where((df["rsi"] >= 40) & (df["rsi"] <= 60), 1, 0)

    # ── Stochastic regime bins ────────────────────────────────────────────────
    df["stoch_oversold"]   = np.where(df["stoch_k"] < 20, 1, 0)
    df["stoch_overbought"] = np.where(df["stoch_k"] > 80, 1, 0)

    # ── BB regime bins ────────────────────────────────────────────────────────
    df["bb_squeeze"]   = np.where(df["bb_width"] < df["bb_width"].rolling(50).quantile(0.20), 1, 0)
    df["bb_expansion"] = np.where(df["bb_width"] > df["bb_width"].rolling(50).quantile(0.80), 1, 0)
    df["price_below_bb_lower"] = np.where(close < bb_lower, 1, 0)
    df["price_above_bb_upper"] = np.where(close > bb_upper, 1, 0)

    # ── Volume proxy — bar range z-score ──────────────────────────────────────
    range_series        = high - low
    range_mean          = range_series.rolling(20).mean()
    range_std           = range_series.rolling(20).std(ddof=0)
    df["range_zscore"]  = (range_series - range_mean) / range_std.replace(0, np.nan)

    # ── Lagged features ───────────────────────────────────────────────────────
    for lag in [1, 2, 3, 4]:
        df[f"rsi_lag{lag}"]     = df["rsi"].shift(lag)
        df[f"stoch_k_lag{lag}"] = df["stoch_k"].shift(lag)
        df[f"bb_pct_lag{lag}"]  = df["bb_pct"].shift(lag)
        df[f"macd_hist_lag{lag}"] = df["macd_hist"].shift(lag)

    # ── Interaction features ──────────────────────────────────────────────────
    df["rsi_x_bb_pct"]       = df["rsi"] * df["bb_pct"]
    df["stoch_x_bb_pct"]     = df["stoch_k"] * df["bb_pct"]
    df["macd_x_ema_cross"]   = df["macd_hist"] * df["ema_cross"]
    df["rsi_x_stoch_kd"]     = df["rsi"] * df["stoch_kd_diff"]

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "EUR/USD Stoch+BB+RSI Gradient Boosting Mean-Rev",
        "model_type": "GradientBoostingClassifier",
        "model_params": {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.75,
            "min_samples_leaf": 20,
            "max_features":     "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change": 30,
            "tol":              1e-4,
            "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":   [6, 18],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe/Calmar) on EUR/USD 15-min data. "
            "GradientBoostingClassifier chosen for strong out-of-bag regularisation "
            "via subsample=0.75 and early stopping (n_iter_no_change=30). "
            "max_depth=4 limits overfitting on mean-reversion regime. "
            "learning_rate=0.04 with 400 trees balances bias-variance. "
            "Signal threshold 0.56 filters low-confidence signals for better precision. "
            "Session filter 06-18 UTC targets London+NY overlap with highest liquidity. "
            "SL=0.5%, TP=1.0% gives 1:2 R:R aligned with mean-reversion edge. "
            "Target horizon=4 bars (1 hour) captures short-term mean-reversion cycles."
        ),
        "notes": (
            "Features: Stochastic(14,3), BB(20,2), RSI(14) as primary signals. "
            "Supplemented by MACD, EMA cross, ATR volatility filter, candle body/shadow, "
            "range z-score, lagged versions of key oscillators, and interaction terms. "
            "Regime bins (oversold/overbought/squeeze/expansion) add non-linear context. "
            "min_atr=0.0002 avoids trading during dead/illiquid periods."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:21:53
# Model            : Gradient Boosting
# Feature Eng.     : EMA (9,21), RSI 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/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):
    # --- EMA 9 and EMA 21 (required) ---
    ema_9 = close.ewm(span=9, adjust=False).mean()
    ema_21 = close.ewm(span=21, adjust=False).mean()

    df["ema_9"] = ema_9
    df["ema_21"] = ema_21
    df["dm_ema_9"] = (close - ema_9) / ema_9
    df["dm_ema_21"] = (close - ema_21) / ema_21

    # EMA crossover signal and spread
    df["ema_cross"] = ema_9 - ema_21
    df["ema_cross_prev"] = df["ema_cross"].shift(1)
    df["ema_cross_sign"] = np.sign(df["ema_cross"])
    df["ema_cross_change"] = df["ema_cross_sign"] - np.sign(df["ema_cross_prev"])

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

    # RSI derived features
    df["rsi_14_norm"] = (rsi_14 - 50) / 50
    df["rsi_overbought"] = np.where(rsi_14 > 70, 1, 0)
    df["rsi_oversold"] = np.where(rsi_14 < 30, 1, 0)
    df["rsi_mid_cross"] = np.where(rsi_14 > 50, 1, -1)

    # --- Additional EMAs for context ---
    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
    df["ema_50_200_spread"] = (ema_50 - ema_200) / ema_200

    # --- ATR (14 periods) ---
    tr1 = high - low
    tr2 = (high - close.shift(1)).abs()
    tr3 = (low - close.shift(1)).abs()
    true_range = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    atr_14 = true_range.ewm(com=13, adjust=False).mean()
    df["atr_14"] = atr_14
    df["natr_14"] = atr_14 / 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
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_pct_b"] = (close - bb_lower) / (bb_upper - bb_lower).replace(0, np.nan)
    df["bb_width"] = (bb_upper - bb_lower) / sma_20

    # --- MACD (12, 26, 9) ---
    ema_12 = close.ewm(span=12, adjust=False).mean()
    ema_26 = close.ewm(span=26, adjust=False).mean()
    macd_line = ema_12 - ema_26
    macd_signal = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist = macd_line - macd_signal
    df["macd_line"] = macd_line
    df["macd_signal_line"] = macd_signal
    df["macd_hist"] = macd_hist
    df["macd_hist_sign"] = np.sign(macd_hist)
    df["macd_hist_change"] = np.sign(macd_hist) - np.sign(macd_hist.shift(1))

    # --- Momentum & Rate of Change ---
    df["mom_5"] = close.pct_change(5)
    df["mom_10"] = close.pct_change(10)
    df["mom_20"] = close.pct_change(20)
    df["roc_3"] = close.pct_change(3)

    # --- Candlestick features ---
    df["body"] = (close - open_) / atr_14
    df["upper_wick"] = (high - pd.concat([close, open_], axis=1).max(axis=1)) / atr_14
    df["lower_wick"] = (pd.concat([close, open_], axis=1).min(axis=1) - low) / atr_14
    df["bar_range"] = (high - low) / atr_14

    # --- Volume-proxy: price range relative momentum ---
    df["high_low_ratio"] = (high - low) / close

    # --- Stochastic Oscillator (14, 3) ---
    lowest_low = low.rolling(14).min()
    highest_high = high.rolling(14).max()
    stoch_k = 100 * (close - lowest_low) / (highest_high - lowest_low).replace(0, np.nan)
    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

    # --- Rolling volatility ---
    df["vol_10"] = close.pct_change().rolling(10).std()
    df["vol_20"] = close.pct_change().rolling(20).std()
    df["vol_ratio"] = df["vol_10"] / df["vol_20"].replace(0, np.nan)

    # --- Lagged RSI and EMA cross (for sequential signal detection) ---
    df["rsi_14_lag1"] = rsi_14.shift(1)
    df["rsi_14_lag2"] = rsi_14.shift(2)
    df["ema_cross_lag1"] = df["ema_cross"].shift(1)
    df["ema_cross_lag2"] = df["ema_cross"].shift(2)

    # --- Trend alignment: both EMAs agree ---
    df["trend_aligned_bull"] = np.where((ema_9 > ema_21) & (ema_21 > ema_50), 1, 0)
    df["trend_aligned_bear"] = np.where((ema_9 < ema_21) & (ema_21 < ema_50), 1, 0)

    # --- RSI momentum divergence proxy ---
    price_chg_5 = close.pct_change(5)
    rsi_chg_5 = rsi_14.diff(5)
    df["rsi_price_div"] = np.where(
        (price_chg_5 > 0) & (rsi_chg_5 < 0), -1,
        np.where((price_chg_5 < 0) & (rsi_chg_5 > 0), 1, 0)
    )

    # --- SMA 50 distance (for trend_filter compatibility) ---
    df["sma_50"] = close.rolling(50).mean()

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


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "AUD/USD EMA Cross RSI Gradient Boost Scalper",
        "model_type": "GradientBoostingClassifier",
        "model_params": {
            "n_estimators": 400,
            "max_depth": 4,
            "learning_rate": 0.04,
            "subsample": 0.8,
            "max_features": "sqrt",
            "min_samples_leaf": 20,
            "min_samples_split": 40,
            "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.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) on AUD/USD 15-min bars. "
            "GradientBoostingClassifier with shrinkage (lr=0.04), moderate depth (4), "
            "subsampling (0.8) and sqrt feature fraction controls overfitting on a noisy FX "
            "series. Early stopping (n_iter_no_change=30) prevents over-training. "
            "SL=0.5%/TP=1.0% gives 1:2 RR. Threshold=0.55 filters low-confidence signals. "
            "EMA 9/21 crossover with RSI 14 confirmation is the primary signal logic, "
            "reinforced by MACD, Bollinger Bands, Stochastic, and multi-period momentum."
        ),
        "notes": (
            "Features: EMA 9, 21, 50, 200 distances; RSI 14 with overbought/oversold flags; "
            "MACD histogram; Bollinger %B and width; Stochastic K/D; ATR-normalized candle "
            "body/wicks; 5/10/20-bar momentum; rolling volatility ratio; trend alignment flags; "
            "RSI-price divergence proxy. Target horizon 4 bars (1 hour ahead). "
            "All features are lagged or rolling — no lookahead bias."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:24:20
# Model            : Gradient Boosting
# 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_   = close.rolling(bb_period).std(ddof=1)
    bb_upper  = bb_mid + bb_std * bb_std_
    bb_lower  = bb_mid - bb_std * bb_std_
    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.0 - (100.0 / (1.0 + rs))

    # ── Stochastic Oscillator (K=14, D=3) ────────────────────────────────────
    stoch_k = 14
    stoch_d = 3
    low_min  = low.rolling(stoch_k).min()
    high_max = high.rolling(stoch_k).max()
    k_raw    = 100.0 * (close - low_min) / (high_max - low_min).replace(0, np.nan)
    df["stoch_k"] = k_raw
    df["stoch_d"] = k_raw.rolling(stoch_d).mean()

    # ── ATR (14) ─────────────────────────────────────────────────────────────
    atr_period = 14
    prev_close = close.shift(1)
    tr         = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)
    df["atr"]  = tr.ewm(com=atr_period - 1, min_periods=atr_period).mean()
    df["natr"] = df["atr"] / close

    # ── Trend / Momentum features ─────────────────────────────────────────────
    df["sma_20"]  = close.rolling(20).mean()
    df["sma_50"]  = close.rolling(50).mean()
    df["sma_100"] = close.rolling(100).mean()

    df["price_vs_sma20"]  = (close - df["sma_20"])  / df["sma_20"]
    df["price_vs_sma50"]  = (close - df["sma_50"])  / df["sma_50"]
    df["price_vs_sma100"] = (close - df["sma_100"]) / df["sma_100"]
    df["sma20_vs_sma50"]  = (df["sma_20"] - df["sma_50"]) / df["sma_50"]

    # ── MACD (12, 26, 9) ─────────────────────────────────────────────────────
    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

    # ── Rate-of-Change features ───────────────────────────────────────────────
    for p in [4, 8, 16]:
        df[f"roc_{p}"] = close.pct_change(p)

    # ── Volatility regime ────────────────────────────────────────────────────
    df["vol_8"]  = close.pct_change().rolling(8).std()
    df["vol_20"] = close.pct_change().rolling(20).std()
    df["vol_ratio"] = df["vol_8"] / df["vol_20"].replace(0, np.nan)

    # ── Candle body / shadow features ────────────────────────────────────────
    df["body"]        = (close - open_).abs()
    df["upper_shadow"] = high - pd.concat([close, open_], axis=1).max(axis=1)
    df["lower_shadow"] = pd.concat([close, open_], axis=1).min(axis=1) - low
    df["body_ratio"]  = df["body"] / (high - low).replace(0, np.nan)

    # ── RSI-derived features ──────────────────────────────────────────────────
    df["rsi_above_50"] = np.where(df["rsi"] > 50, 1, 0)
    df["rsi_overbought"] = np.where(df["rsi"] > 70, 1, 0)
    df["rsi_oversold"]   = np.where(df["rsi"] < 30, 1, 0)
    df["rsi_lag1"] = df["rsi"].shift(1)
    df["rsi_lag4"] = df["rsi"].shift(4)

    # ── Stochastic-derived features ───────────────────────────────────────────
    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)
    df["stoch_oversold"]   = np.where(df["stoch_k"] < 20, 1, 0)
    df["stoch_overbought"] = np.where(df["stoch_k"] > 80, 1, 0)

    # ── BB-derived features ───────────────────────────────────────────────────
    df["bb_squeeze"] = np.where(df["bb_width"] < df["bb_width"].rolling(50).quantile(0.20), 1, 0)
    df["above_bb_upper"] = np.where(close > bb_upper, 1, 0)
    df["below_bb_lower"] = np.where(close < bb_lower, 1, 0)
    df["bb_pct_lag1"]    = df["bb_pct"].shift(1)
    df["bb_pct_lag4"]    = df["bb_pct"].shift(4)

    # ── Session hour (UTC) ────────────────────────────────────────────────────
    df["hour_utc"] = df.index.hour if hasattr(df.index, "hour") else 0

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

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "AUD/USD Stochastic BB Mean-Reversion (GBM)",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":      400,
            "max_depth":         4,
            "learning_rate":     0.04,
            "subsample":         0.80,
            "min_samples_leaf":  20,
            "max_features":      "sqrt",
            "n_iter_no_change":  30,
            "validation_fraction": 0.10,
            "tol":               1e-4,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "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) on AUD/USD 15-min. "
            "GradientBoostingClassifier with moderate depth and learning rate chosen "
            "to balance bias-variance. 2:1 reward-to-risk (SL=0.5%, TP=1.0%). "
            "Stochastic crossovers, BB mean-reversion, and RSI regime signals "
            "form the core feature set; MACD, volatility, and candle features add "
            "context. Early stopping (n_iter_no_change=30) prevents overfitting."
        ),
        "notes": (
            "Features: Bollinger Bands (20,2) width/pct, RSI(14) with lag/regime flags, "
            "Stochastic(14,3) K/D with crossover detection, ATR/NATR volatility, MACD "
            "histogram, short/medium SMAs, ROC(4/8/16), volatility ratio, candle body "
            "ratios, and UTC session hour. No session or trend filter to allow full "
            "mean-reversion opportunities across all sessions."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:32:18
# 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      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# AUDUSD 15-min XGBoost Strategy
# SMA + RSI + MACD + Bollinger Bands + ATR Feature Set
# Optimized for Risk-Adjusted Return
# ============================================================

# 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):

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

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

    # ── RSI 14 ──────────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=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.replace(0, np.nan)
    df["rsi_14"] = 100.0 - (100.0 / (1.0 + rs))

    # ── MACD (12, 26, 9) ────────────────────────────────────────────────────
    ema_12     = close.ewm(span=12, adjust=False).mean()
    ema_26     = close.ewm(span=26, adjust=False).mean()
    macd_line  = ema_12 - ema_26
    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

    # ── ATR 14 + Normalised ATR ─────────────────────────────────────────────
    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(com=13, min_periods=14).mean()
    df["atr_14"] = atr
    df["natr"]   = atr / close

    # ── Price momentum / rate-of-change ────────────────────────────────────
    for n in [1, 4, 8, 16]:
        df[f"roc_{n}"] = close.pct_change(n)

    # ── Candle body & wick features ─────────────────────────────────────────
    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["candle_dir"]  = np.where(close >= open_, 1.0, -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)

    # ── Lagged RSI & MACD histogram ─────────────────────────────────────────
    for lag in [1, 2, 3]:
        df[f"rsi_14_lag{lag}"]   = df["rsi_14"].shift(lag)
        df[f"macd_hist_lag{lag}"] = df["macd_hist"].shift(lag)

    # ── RSI overbought / oversold zones ─────────────────────────────────────
    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_mid_up"] = np.where((df["rsi_14"] > 50) & (df["rsi_14"] <= 70), 1.0, 0.0)
    df["rsi_mid_dn"] = np.where((df["rsi_14"] >= 30) & (df["rsi_14"] < 50), 1.0, 0.0)

    # ── MACD cross signals ───────────────────────────────────────────────────
    df["macd_cross_up"] = np.where(
        (df["macd_line"] > df["macd_signal"]) &
        (df["macd_line"].shift(1) <= df["macd_signal"].shift(1)),
        1.0, 0.0
    )
    df["macd_cross_dn"] = np.where(
        (df["macd_line"] < df["macd_signal"]) &
        (df["macd_line"].shift(1) >= df["macd_signal"].shift(1)),
        1.0, 0.0
    )

    # ── Price position relative to SMA alignment ────────────────────────────
    df["trend_aligned_bull"] = np.where(
        (close > df["sma_20"]) & (df["sma_20"] > df["sma_50"]) & (df["sma_50"] > df["sma_200"]),
        1.0, 0.0
    )
    df["trend_aligned_bear"] = np.where(
        (close < df["sma_20"]) & (df["sma_20"] < df["sma_50"]) & (df["sma_50"] < df["sma_200"]),
        1.0, 0.0
    )

    # ── Bollinger Band squeeze (low volatility) ──────────────────────────────
    bb_width_ma = df["bb_width"].rolling(20).mean()
    df["bb_squeeze"] = np.where(df["bb_width"] < bb_width_ma, 1.0, 0.0)

    # ── Rolling close statistics ─────────────────────────────────────────────
    df["close_zscore_20"] = (close - close.rolling(20).mean()) / close.rolling(20).std(ddof=0)
    df["close_zscore_50"] = (close - close.rolling(50).mean()) / close.rolling(50).std(ddof=0)

    # ── Volatility regime ────────────────────────────────────────────────────
    natr_ma = df["natr"].rolling(20).mean()
    df["vol_regime_high"] = np.where(df["natr"] > natr_ma, 1.0, 0.0)

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "AUD/USD XGBoost SMA+RSI+MACD+BB Momentum",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":       500,
            "max_depth":          4,
            "learning_rate":      0.04,
            "subsample":          0.75,
            "colsample_bytree":   0.70,
            "min_child_weight":   5,
            "gamma":              0.1,
            "reg_alpha":          0.1,
            "reg_lambda":         1.5,
            "scale_pos_weight":   1.0,
            "objective":          "binary:logistic",
            "tree_method":        "hist",
            "random_state":       42,
        },
        "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) on AUD/USD 15-min. "
            "XGBoost with depth-4 trees and conservative regularization (reg_lambda=1.5, "
            "min_child_weight=5) to reduce overfitting on FX data. "
            "2:1 RR (SL=0.5%, TP=1.0%) ensures positive expectancy with ~40%+ win rate. "
            "Subsample + colsample add stochastic diversity. 500 estimators with lr=0.04 "
            "balances bias-variance. Threshold 0.55 filters marginal signals."
        ),
        "notes":            (
            "Features: SMA(20/50/200) with distances, Bollinger Bands width+pct, RSI-14 "
            "with zone flags, MACD histogram + crosses, ATR-14 + NATR, momentum ROC(1/4/8/16), "
            "candle body/wick ratios, trend alignment flags, BB squeeze, z-scores, vol regime. "
            "Reverse on opposite signal to capture trend reversals. Session filter disabled "
            "to capture AUD/USD Asian + London + NY sessions. Target horizon = 4 bars (1 hour)."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:53:28
# Model            : Gradient Boosting
# Feature Eng.     : BB (20,2.0), 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      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# Bollinger Bands Squeeze Breakout — GBP/USD 15-min
# ============================================================

# 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):
    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    bb_period = 20
    bb_std    = 2.0

    bb_mid   = close.rolling(bb_period).mean()
    bb_sigma = close.rolling(bb_period).std(ddof=0)
    bb_upper = bb_mid + bb_std * bb_sigma
    bb_lower = bb_mid - bb_std * bb_sigma

    bb_width = (bb_upper - bb_lower) / bb_mid
    bb_pct   = (close - bb_lower) / (bb_upper - bb_lower)

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_width"] = bb_width
    df["bb_pct"]   = bb_pct

    # ── ATR (14) & NATR ─────────────────────────────────────────────────────
    atr_period = 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=atr_period, min_periods=atr_period, adjust=False).mean()
    natr = atr / close

    df["atr"]  = atr
    df["natr"] = natr

    # ── Squeeze detection ────────────────────────────────────────────────────
    # Squeeze = BB width is in the bottom quartile over a 50-bar lookback
    bb_width_min = bb_width.rolling(50).min()
    bb_width_max = bb_width.rolling(50).max()
    bb_width_norm = (bb_width - bb_width_min) / (bb_width_max - bb_width_min + 1e-12)

    df["bb_width_norm"] = bb_width_norm
    df["squeeze"]       = np.where(bb_width_norm < 0.25, 1.0, 0.0)

    # Squeeze released: was in squeeze 1 bar ago, now width is expanding
    bb_width_chg = bb_width.diff()
    df["squeeze_release"] = np.where(
        (df["squeeze"].shift(1) == 1.0) & (bb_width_chg > 0), 1.0, 0.0
    )

    # ── BB width momentum ────────────────────────────────────────────────────
    df["bb_width_chg"]    = bb_width_chg
    df["bb_width_chg_2"]  = bb_width.diff(2)
    df["bb_width_chg_5"]  = bb_width.diff(5)

    # ── Price position relative to bands ─────────────────────────────────────
    df["close_vs_mid"]   = close - bb_mid
    df["close_vs_upper"] = close - bb_upper
    df["close_vs_lower"] = close - bb_lower

    # ── Momentum & returns ───────────────────────────────────────────────────
    df["ret_1"]  = close.pct_change(1)
    df["ret_3"]  = close.pct_change(3)
    df["ret_5"]  = close.pct_change(5)
    df["ret_10"] = close.pct_change(10)
    df["ret_20"] = close.pct_change(20)

    # ── RSI (14) ─────────────────────────────────────────────────────────────
    rsi_period = 14
    delta = close.diff()
    gain  = delta.clip(lower=0)
    loss  = (-delta).clip(lower=0)
    avg_gain = gain.ewm(span=rsi_period, min_periods=rsi_period, adjust=False).mean()
    avg_loss = loss.ewm(span=rsi_period, min_periods=rsi_period, adjust=False).mean()
    rs  = avg_gain / (avg_loss + 1e-12)
    rsi = 100.0 - 100.0 / (1.0 + rs)
    df["rsi"] = rsi

    # RSI divergence proxy: price makes new low/high but RSI does not
    df["rsi_5_min"]   = rsi.rolling(5).min()
    df["close_5_min"] = close.rolling(5).min()
    df["rsi_5_max"]   = rsi.rolling(5).max()
    df["close_5_max"] = close.rolling(5).max()

    # ── 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
    macd_signal = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist  = macd_line - macd_signal

    df["macd_line"]   = macd_line
    df["macd_signal"] = macd_signal
    df["macd_hist"]   = macd_hist
    df["macd_hist_chg"] = macd_hist.diff()

    # ── Volume-like proxy: bar range ─────────────────────────────────────────
    bar_range = high - low
    df["bar_range"]      = bar_range
    df["bar_range_norm"] = bar_range / (atr + 1e-12)

    # ── Candle body direction & size ─────────────────────────────────────────
    body = close - open_
    df["body"]       = body
    df["body_norm"]  = body / (atr + 1e-12)
    df["body_dir"]   = np.where(body > 0, 1.0, np.where(body < 0, -1.0, 0.0))

    # ── Upper / lower wick ───────────────────────────────────────────────────
    df["upper_wick"] = high - pd.concat([close, open_], axis=1).max(axis=1)
    df["lower_wick"] = pd.concat([close, open_], axis=1).min(axis=1) - low

    # ── SMA trend context ─────────────────────────────────────────────────────
    sma_50  = close.rolling(50).mean()
    sma_200 = close.rolling(200).mean()
    df["sma_50"]         = sma_50
    df["sma_200"]        = sma_200
    df["close_vs_sma50"] = (close - sma_50) / (sma_50 + 1e-12)
    df["sma50_vs_sma200"] = (sma_50 - sma_200) / (sma_200 + 1e-12)

    # ── Volatility regime ────────────────────────────────────────────────────
    natr_ma = natr.rolling(50).mean()
    df["natr_ratio"] = natr / (natr_ma + 1e-12)   # >1 = above-avg vol

    # ── Mean-reversion distance ───────────────────────────────────────────────
    df["z_score_20"] = (close - bb_mid) / (bb_sigma + 1e-12)

    # ── Rolling realized vol ─────────────────────────────────────────────────
    df["rvol_10"] = df["ret_1"].rolling(10).std()
    df["rvol_20"] = df["ret_1"].rolling(20).std()

    # ── ATR-normalised returns ────────────────────────────────────────────────
    df["ret_1_natr"] = df["ret_1"] / (natr + 1e-12)

    # ── Lagged features ───────────────────────────────────────────────────────
    for lag in [1, 2, 3, 5]:
        df[f"bb_pct_lag{lag}"]    = bb_pct.shift(lag)
        df[f"bb_width_lag{lag}"]  = bb_width.shift(lag)
        df[f"rsi_lag{lag}"]       = rsi.shift(lag)
        df[f"macd_hist_lag{lag}"] = macd_hist.shift(lag)

    # ── Hour-of-day (cyclical) ────────────────────────────────────────────────
    hour = pd.Series(df.index.hour, index=df.index).astype(float)
    df["hour_sin"] = np.sin(2 * np.pi * hour / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * hour / 24.0)

    # ── Day-of-week (cyclical) ────────────────────────────────────────────────
    dow = pd.Series(df.index.dayofweek, index=df.index).astype(float)
    df["dow_sin"] = np.sin(2 * np.pi * dow / 5.0)
    df["dow_cos"] = np.cos(2 * np.pi * dow / 5.0)

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

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "GBP/USD BB Squeeze Breakout (GradientBoosting)",

        "model_type": "GradientBoostingClassifier",
        "model_params": {
            "n_estimators":      400,
            "max_depth":         4,
            "learning_rate":     0.04,
            "subsample":         0.75,
            "min_samples_leaf":  20,
            "min_samples_split": 40,
            "max_features":      "sqrt",
            "n_iter_no_change":  30,
            "validation_fraction": 0.1,
            "tol":               1e-4,
            "random_state":      42,
        },

        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 20],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,

        "objective": (
            "Maximize risk-adjusted return (Sharpe / Calmar). "
            "GradientBoostingClassifier chosen for its strong performance on "
            "tabular financial data with noisy labels. Shallow trees (max_depth=4) "
            "with shrinkage (lr=0.04) and subsample=0.75 reduce overfitting. "
            "Early stopping (n_iter_no_change=30) prevents over-training. "
            "SL=0.5%, TP=1.0% gives a 1:2 risk/reward ratio. "
            "Session filter 06-20 UTC captures London + New York overlap for GBP/USD."
        ),
        "notes": (
            "Core signal: BB squeeze (narrow band width) followed by expansion "
            "breakout, confirmed by MACD histogram direction and RSI. "
            "ATR filter ensures minimum volatility for entries. "
            "Lagged BB features capture the squeeze build-up dynamic. "
            "Z-score and normalized returns give the model mean-reversion context. "
            "Cyclical time features allow the model to learn intraday seasonality."
        ),
    }