Upload apex_trail_optuna.py with huggingface_hub

apex_trail_optuna.py

@@ -0,0 +1,306 @@
+"""
+Apex Trail v7 - Numba JIT Optuna Optimization
+~50-100x faster than pure Python
+"""
+import pyarrow.parquet as pq
+import numpy as np
+import optuna
+import time as time_mod
+from numba import njit
+optuna.logging.set_verbosity(optuna.logging.WARNING)
+
+PT = 0.01; PV = 1.0  # 0.01lot * 100
+
+# Load data
+print("Loading tickflow_M1...")
+df = pq.read_table("C:/Users/Black/Downloads/MT5EA/tick_data/tickflow_M1.parquet").to_pandas()
+tr = np.maximum(df['high']-df['low'],
+       np.maximum(np.abs(df['high']-df['close'].shift(1).fillna(df['close'])),
+                  np.abs(df['low']-df['close'].shift(1).fillna(df['close']))))
+df['atr'] = (tr.rolling(210, min_periods=14).mean() / PT).fillna(300)
+dm_s = df['close'].diff().abs() / PT
+df['adx'] = (dm_s.rolling(210, min_periods=14).mean() / df['atr'].clip(lower=1) * 50).clip(upper=60).fillna(25)
+df['tv'] = df['tick_count'].rolling(5, min_periods=1).mean() / 60.0
+df['sp'] = df['spread_avg']
+
+G_o=df['open'].values.astype(np.float64)
+G_h=df['high'].values.astype(np.float64)
+G_l=df['low'].values.astype(np.float64)
+G_c=df['close'].values.astype(np.float64)
+G_sp=df['sp'].values.astype(np.float64)
+G_tv=df['tv'].values.astype(np.float64)
+G_atr=df['atr'].values.astype(np.float64)
+G_adx=df['adx'].values.astype(np.float64)
+G_ao=df['ask_open'].values.astype(np.float64)
+G_ac=df['ask_close'].values.astype(np.float64)
+G_tc=df['tick_count'].values.astype(np.float64)
+G_N=len(df)
+del df
+print(f"  {G_N} bars ready")
+
+@njit(cache=True)
+def sim_core(c, h, l, ac, ao, o, sp, tv, atr, adx, tc, N,
+             sl_atr, trail_start, p2_trend, p2_norm, p2_side, p3_sq,
+             entry_interval, tick_thresh, use_be_floor, tv_exhaust, tv_recover):
+    MX = 50000
+    p_s = np.zeros(MX, np.int8)
+    p_e = np.zeros(MX, np.float64)
+    p_sl = np.zeros(MX, np.float64)
+    p_ph = np.zeros(MX, np.int8)
+    p_pk = np.zeros(MX, np.float64)
+    p_pkp = np.zeros(MX, np.float64)
+    p_op = np.zeros(MX, np.bool_)
+    p_pnl = np.zeros(MX, np.float64)
+    p_atr_e = np.zeros(MX, np.float64)
+    pc = 0
+    last_e = -999
+
+    for i in range(N):
+        B = c[i]; A = ac[i]; BH = h[i]; BL = l[i]
+        SP = sp[i]; TV = tv[i]; ATR = atr[i]; ADX = adx[i]
+        AH = BH + SP * PT; AL = BL + SP * PT
+
+        for j in range(pc):
+            if not p_op[j]:
+                continue
+            si = p_s[j]; en = p_e[j]; ea = p_atr_e[j]
+            sl_pts = ea * sl_atr
+
+            if si == 1:
+                pp_w = (BL - en) / PT
+                pp_b = (BH - en) / PT
+            else:
+                pp_w = (en - AH) / PT
+                pp_b = (en - AL) / PT
+
+            if pp_b > p_pkp[j]:
+                p_pkp[j] = pp_b
+                if si == 1:
+                    p_pk[j] = BH
+                else:
+                    p_pk[j] = AL
+
+            # SL
+            if pp_w <= -sl_pts:
+                p_op[j] = False
+                p_pnl[j] = -(sl_pts * PV / 100.0)
+                continue
+
+            # Phase 0 → 2
+            if p_ph[j] == 0 and pp_b >= ATR * trail_start:
+                p_ph[j] = 2
+                if ADX > 30:
+                    m = p2_trend
+                elif ADX > 20:
+                    m = p2_norm
+                else:
+                    m = p2_side
+                pk = p_pk[j]
+                if si == 1:
+                    ns = pk - ATR * m * PT
+                    if use_be_floor and ns < en:
+                        ns = en
+                    p_sl[j] = ns
+                else:
+                    ns = pk + ATR * m * PT
+                    if use_be_floor and ns > en:
+                        ns = en
+                    p_sl[j] = ns
+
+            # Phase 2
+            if p_ph[j] == 2:
+                if ADX > 30:
+                    m = p2_trend
+                elif ADX > 20:
+                    m = p2_norm
+                else:
+                    m = p2_side
+                td = ATR * m * PT
+                pk = p_pk[j]
+                if si == 1:
+                    ns = pk - td
+                    if use_be_floor and ns < en:
+                        ns = en
+                    if ns > p_sl[j]:
+                        p_sl[j] = ns
+                else:
+                    ns = pk + td
+                    if use_be_floor and ns > en:
+                        ns = en
+                    if p_sl[j] <= 0 or ns < p_sl[j]:
+                        p_sl[j] = ns
+                if TV < tv_exhaust and p_pkp[j] > ATR * 1.5:
+                    p_ph[j] = 3
+
+            # Phase 3
+            if p_ph[j] == 3:
+                sq = ATR * p3_sq * PT
+                pk = p_pk[j]
+                if si == 1:
+                    ns = pk - sq
+                    if use_be_floor and ns < en:
+                        ns = en
+                    if ns > p_sl[j]:
+                        p_sl[j] = ns
+                else:
+                    ns = pk + sq
+                    if use_be_floor and ns > en:
+                        ns = en
+                    if p_sl[j] <= 0 or ns < p_sl[j]:
+                        p_sl[j] = ns
+                if TV > tv_recover:
+                    p_ph[j] = 2
+
+            # Trail hit
+            if p_ph[j] >= 2 and p_sl[j] > 0:
+                hit = False
+                if si == 1 and BL <= p_sl[j]:
+                    hit = True
+                elif si == -1 and AH >= p_sl[j]:
+                    hit = True
+                if hit:
+                    if si == 1:
+                        ppts = (p_sl[j] - en) / PT
+                    else:
+                        ppts = (en - p_sl[j]) / PT
+                    p_op[j] = False
+                    p_pnl[j] = ppts * PV / 100.0
+
+        # Entry
+        if i - last_e >= entry_interval and SP < 40 and pc + 2 <= MX:
+            if tc[i] >= tick_thresh:
+                last_e = i
+                for si2_idx in range(2):
+                    si2 = 1 if si2_idx == 0 else -1
+                    ep = ao[i] if si2 == 1 else o[i]
+                    p_s[pc] = si2
+                    p_e[pc] = ep
+                    sl_d = ATR * sl_atr * PT
+                    if si2 == 1:
+                        p_sl[pc] = ep - sl_d
+                    else:
+                        p_sl[pc] = ep + sl_d
+                    p_ph[pc] = 0
+                    p_pk[pc] = ep
+                    p_pkp[pc] = 0.0
+                    p_op[pc] = True
+                    p_pnl[pc] = 0.0
+                    p_atr_e[pc] = ATR
+                    pc += 1
+            else:
+                last_e = i
+
+    # Close remaining
+    for j in range(pc):
+        if p_op[j]:
+            si = p_s[j]
+            if si == 1:
+                ppts = (c[N-1] - p_e[j]) / PT
+            else:
+                ppts = (p_e[j] - ac[N-1]) / PT
+            p_pnl[j] = ppts * PV / 100.0
+            p_op[j] = False
+
+    return p_pnl[:pc]
+
+# Warmup JIT
+print("Warming up Numba JIT...")
+t0 = time_mod.time()
+_ = sim_core(G_c, G_h, G_l, G_ac, G_ao, G_o, G_sp, G_tv, G_atr, G_adx, G_tc, G_N,
+             2.0, 1.0, 2.0, 1.5, 0.8, 0.5, 5, 259.0, True, 1.5, 5.0)
+print(f"  JIT warmup: {time_mod.time()-t0:.1f}s")
+
+# Speed test
+t0 = time_mod.time()
+pnls = sim_core(G_c, G_h, G_l, G_ac, G_ao, G_o, G_sp, G_tv, G_atr, G_adx, G_tc, G_N,
+                2.0, 1.0, 2.0, 1.5, 0.8, 0.5, 5, 259.0, True, 1.5, 5.0)
+speed = time_mod.time()-t0
+print(f"  Speed test: {speed:.2f}s per trial ({len(pnls)} trades)")
+
+def objective(trial):
+    sl_atr = trial.suggest_float("sl_atr", 1.0, 4.0, step=0.5)
+    trail_start = trial.suggest_float("trail_start", 0.5, 3.0, step=0.25)
+    p2_trend = trial.suggest_float("p2_trend", 1.0, 3.0, step=0.25)
+    p2_norm = trial.suggest_float("p2_norm", 0.75, 2.25, step=0.25)
+    p2_side = trial.suggest_float("p2_side", 0.3, 1.5, step=0.1)
+    p3_sq = trial.suggest_float("p3_sq", 0.2, 1.0, step=0.1)
+    entry_interval = trial.suggest_int("entry_interval", 3, 20)
+    tick_pct = trial.suggest_float("tick_pct", 20, 80, step=5)
+    use_be_floor = trial.suggest_categorical("use_be_floor", [True, False])
+    tv_exhaust = trial.suggest_float("tv_exhaust", 0.5, 3.0, step=0.25)
+    tv_recover = trial.suggest_float("tv_recover", 3.0, 10.0, step=0.5)
+
+    tick_thresh = np.percentile(G_tc, tick_pct)
+    be = 1.0 if use_be_floor else 0.0
+
+    pnls = sim_core(G_c, G_h, G_l, G_ac, G_ao, G_o, G_sp, G_tv, G_atr, G_adx, G_tc, G_N,
+                     sl_atr, trail_start, p2_trend, p2_norm, p2_side, p3_sq,
+                     entry_interval, tick_thresh, use_be_floor, tv_exhaust, tv_recover)
+
+    n = len(pnls)
+    if n < 50:
+        return 0.0
+
+    ws = float(np.sum(pnls[pnls > 0]))
+    ls = float(np.sum(pnls[pnls <= 0]))
+    wins = int(np.sum(pnls > 0))
+    pf = abs(ws) / max(0.01, abs(ls))
+    exp = float(np.mean(pnls))
+    wr = wins / n * 100.0
+    total = float(np.sum(pnls))
+
+    trial.set_user_attr("wr", round(wr, 1))
+    trial.set_user_attr("exp", round(exp, 2))
+    trial.set_user_attr("pnl", round(total, 0))
+    trial.set_user_attr("trades", n)
+    trial.set_user_attr("pf", round(pf, 3))
+
+    if pf < 0.5:
+        return 0.0
+    return pf * np.sqrt(n) / 100.0
+
+if __name__ == "__main__":
+    N_TRIALS = 200
+    print(f"\n{'='*60}")
+    print(f"OPTUNA | {N_TRIALS} trials | ~{speed*N_TRIALS/60:.0f} min estimated")
+    print(f"{'='*60}")
+
+    study = optuna.create_study(direction="maximize",
+                                sampler=optuna.samplers.TPESampler(seed=42))
+    t0 = time_mod.time()
+
+    def cb(study, trial):
+        if trial.number % 10 == 0:
+            b = study.best_trial
+            el = time_mod.time() - t0
+            eta = el / max(1, trial.number+1) * (N_TRIALS - trial.number - 1)
+            print(f"  T{trial.number:3d}/{N_TRIALS} | "
+                  f"Best: PF={b.user_attrs.get('pf',0):.2f} WR={b.user_attrs.get('wr',0):.1f}% "
+                  f"Exp=${b.user_attrs.get('exp',0):.2f} ${b.user_attrs.get('pnl',0):.0f} "
+                  f"({b.user_attrs.get('trades',0)} tr) | {eta/60:.0f}min left")
+
+    study.optimize(objective, n_trials=N_TRIALS, callbacks=[cb])
+    elapsed = time_mod.time() - t0
+    print(f"\nDone! {elapsed/60:.1f} minutes")
+
+    print(f"\n{'='*60}")
+    print(f"TOP 10 RESULTS")
+    print(f"{'='*60}")
+    trials = sorted(study.trials, key=lambda t: t.value if t.value else 0, reverse=True)
+    for i, t in enumerate(trials[:10]):
+        a = t.user_attrs
+        print(f"#{i+1:2d} PF={a.get('pf',0):.2f} WR={a.get('wr',0):.1f}% "
+              f"Exp=${a.get('exp',0):.2f} PnL=${a.get('pnl',0):.0f} ({a.get('trades',0)} tr) | "
+              f"SL={t.params.get('sl_atr',0)} TS={t.params.get('trail_start',0)} "
+              f"BE={t.params.get('use_be_floor','')} TV_ex={t.params.get('tv_exhaust',0)} "
+              f"P2t={t.params.get('p2_trend',0)} P2n={t.params.get('p2_norm',0)} "
+              f"P2s={t.params.get('p2_side',0)}")
+
+    print(f"\n{'='*60}")
+    print(f"BEST PARAMETERS")
+    print(f"{'='*60}")
+    bp = study.best_trial.params
+    ba = study.best_trial.user_attrs
+    print(f"PF={ba['pf']:.3f} | WR={ba['wr']:.1f}% | Exp=${ba['exp']:.2f} | PnL=${ba['pnl']:.0f} | {ba['trades']} trades")
+    for k, v in sorted(bp.items()):
+        print(f"  {k:20s} = {v}")