# Copyright 2026, Allan Munene Mutiiria. # https://t.me/Forex_Algo_Trader import os import math import warnings from datetime import datetime, timezone import numpy as np import torch import torch.nn as nn import MetaTrader5 as mt5 # What the terminal is asked for SYMBOL = "XAUUSDm" TIMEFRAME = mt5.TIMEFRAME_M15 MAX_BARS = 400000 # How far ahead a label looks, and how far price must travel to earn one HORIZON = 33 BARRIER = 2.5 # The shape of the network, which is also the shape the viewer draws INPUTS = 16 HIDDEN_A = 24 HIDDEN_B = 12 OUTPUTS = 3 # How many recent bars are written out for the MQL5 side to check itself against PROOF_BARS = 300 # How the training runs EPOCHS = 400 BATCH = 256 LEARN = 0.004 TEST_SHARE = 0.20 CHECK_SHARE = 0.15 PATIENCE = 40 torch.manual_seed(7) np.random.seed(7) def pull_bars(): """Read the symbol's history straight out of the running terminal.""" if not mt5.initialize(): raise SystemExit(f"cannot reach the terminal: {mt5.last_error()}") info = mt5.symbol_info(SYMBOL) if info is None: mt5.shutdown() raise SystemExit(f"{SYMBOL} is not in the Market Watch") if not info.visible: mt5.symbol_select(SYMBOL, True) # A symbol just made visible holds nothing yet, so a small request wakes # the terminal up before the real one is made mt5.copy_rates_from_pos(SYMBOL, TIMEFRAME, 0, 10) # How many bars one request may return is a terminal setting rather than a # fixed number, so the ask is halved until the terminal answers rates = None want = MAX_BARS while want >= 10000: rates = mt5.copy_rates_from_pos(SYMBOL, TIMEFRAME, 0, want) if rates is not None and len(rates) > 0: print(f" asked for {want:,} bars, received {len(rates):,}") break want //= 2 point = info.point fallback = info.spread * point mt5.shutdown() if rates is None or len(rates) < 5000: got = 0 if rates is None else len(rates) raise SystemExit( f"only {got:,} bars came back for {SYMBOL} at this timeframe.\n" " Open that chart, press Home to load the history, and raise\n" " Tools, Options, Charts, Max bars in chart if it is set low") # Every bar carries the spread it saw, so the middle of those is what a # trade normally pays. Reading it once would catch whatever minute the # script happened to run in, and at rollover that is several times wider if "spread" in rates.dtype.names: seen = np.sort(rates["spread"].astype(np.float64)) * point spread = float(seen[len(seen) // 2]) print(f" spread across the sample: typical {spread:.3f}, " f"quietest {seen[len(seen) // 20]:.3f}, worst {seen[-len(seen) // 20]:.3f}") else: spread = fallback return rates, spread def true_range(high, low, close): """The range a bar covered, counting any gap from the bar before it.""" prev = np.roll(close, 1) prev[0] = close[0] return np.maximum(high - low, np.maximum(abs(high - prev), abs(low - prev))) def moving_average(x, span): """A smoothed average that weights recent bars more heavily.""" out = np.empty_like(x) out[0] = x[0] k = 2.0 / (span + 1.0) for i in range(1, len(x)): out[i] = x[i] * k + out[i - 1] * (1.0 - k) return out def rolling_mean(x, n): """The plain average of the last n values, ending at each position.""" c = np.cumsum(np.insert(x, 0, 0.0)) out = np.empty_like(x) out[:n] = x[:n].mean() if n > 1 else x[:n] out[n:] = (c[n + 1:] - c[1:-n]) / n return out def rolling_max(x, n): """The highest value over the last n bars, ending at each position.""" out = np.copy(x) for i in range(1, len(x)): out[i] = x[max(0, i - n + 1):i + 1].max() return out def rolling_min(x, n): """The lowest value over the last n bars, ending at each position.""" out = np.copy(x) for i in range(1, len(x)): out[i] = x[max(0, i - n + 1):i + 1].min() return out def build_features(rates): """Turn raw bars into sixteen numbers that carry no price level.""" o = rates["open"].astype(np.float64) h = rates["high"].astype(np.float64) l = rates["low"].astype(np.float64) c = rates["close"].astype(np.float64) t = rates["time"].astype(np.int64) tr = true_range(h, l, c) atr14 = rolling_mean(tr, 14) atr50 = rolling_mean(tr, 50) # A floor keeps a flat stretch from dividing by nothing safe = np.maximum(atr14, 1e-9) hi20, lo20 = rolling_max(h, 20), rolling_min(l, 20) hi50, lo50 = rolling_max(h, 50), rolling_min(l, 50) span20 = np.maximum(hi20 - lo20, 1e-9) span50 = np.maximum(hi50 - lo50, 1e-9) ema12 = moving_average(c, 12) ema50 = moving_average(c, 50) rng = np.maximum(h - l, 1e-9) hour = (t // 3600) % 24 def back(x, n): """The same series shifted n bars into the past.""" s = np.roll(x, n) s[:n] = x[0] return s f = np.column_stack([ (c - back(c, 1)) / safe, # momentum over one bar (c - back(c, 3)) / safe, # over three (c - back(c, 6)) / safe, # over six (c - back(c, 12)) / safe, # over the label horizon (c - back(c, 24)) / safe, # over two hours (c - lo20) / span20, # place inside the recent range (c - lo50) / span50, # place inside the longer range atr14 / np.maximum(atr50, 1e-9), # is the market faster than usual (c - o) / rng, # who won this bar (h - np.maximum(o, c)) / rng, # rejection from above (np.minimum(o, c) - l) / rng, # rejection from below (c - ema12) / safe, # stretch against the short mean (c - ema50) / safe, # stretch against the long mean (ema12 - ema50) / safe, # trend strength np.sin(2.0 * math.pi * hour / 24), # session, as an angle np.cos(2.0 * math.pi * hour / 24), ]) return f, h, l, c, atr14 def build_labels(h, l, c, atr): """Walk each bar forward until price touches a barrier above or below.""" n = len(c) y = np.zeros(n, dtype=np.int64) for i in range(n - HORIZON - 1): reach = atr[i] * BARRIER if reach <= 0.0: continue up, dn = c[i] + reach, c[i] - reach y[i] = 1 # The first barrier touched decides the label, so the walk stops there for k in range(i + 1, i + 1 + HORIZON): if h[k] >= up: y[i] = 2 break if l[k] <= dn: y[i] = 0 break return y class Net(nn.Module): """Three dense layers, which is the shape the neuron view can draw.""" def __init__(self): super().__init__() self.l1 = nn.Linear(INPUTS, HIDDEN_A) self.a1 = nn.ReLU() self.l2 = nn.Linear(HIDDEN_A, HIDDEN_B) self.a2 = nn.ReLU() self.l3 = nn.Linear(HIDDEN_B, OUTPUTS) self.sm = nn.Softmax(dim=1) def forward(self, x): return self.sm(self.l3(self.a2(self.l2(self.a1(self.l1(x)))))) def report(name, pred, truth): """Say how often the model was right, and whether that beats guessing.""" acc = float((pred == truth).mean()) names = ["down", "flat", "up"] print(f"\n {name}: {acc * 100:.2f}% of all {len(truth):,} bars called correctly") print(" predicted") print(" " + "".join(f"{n:>8s}" for n in names) + " found") hits = [] for a in range(3): row = [int(((truth == a) & (pred == b)).sum()) for b in range(3)] total = max(sum(row), 1) hits.append(row[a] / total) print(f" actual {names[a]:>4s}" + "".join(f"{v:8d}" for v in row) + f"{hits[a] * 100:9.1f}%") balanced = sum(hits) / 3.0 print(f" averaged over the three classes: {balanced * 100:.2f}% " f"against {100 / 3:.2f}% for a coin") # What a trader needs is not how often a class was found but whether a # call can be trusted, so each column is scored against how often that # class turns up at all print("\n when it made a call") edge = [] for b in range(3): said = int((pred == b).sum()) if said == 0: print(f" it never said {names[b]}") continue right = int(((pred == b) & (truth == b)).sum()) / said base = float((truth == b).mean()) edge.append(right - base) print(f" said {names[b]:4s} {said:6,} times, right {right * 100:5.1f}%, " f"that class occurs {base * 100:5.1f}%, edge {(right - base) * 100:+5.1f} points") return acc, balanced, (max(edge) if edge else 0.0) def expectancy(pred, truth, reach, cost): """Turn the calls into money, and check they beat trading without a model.""" names = ["down", "flat", "up"] print(f"\n taking every signal, winning or losing {reach:.2f} and paying {cost:.2f}") best = -1e9 for b in (0, 2): took = int((pred == b).sum()) if took == 0: continue # A call is right when price reached its barrier, wrong when it reached the other win = int(((pred == b) & (truth == b)).sum()) lose = int(((pred == b) & (truth == (2 - b))).sum()) went = int(((pred == b) & (truth == 1)).sum()) net = (win - lose) * reach - took * cost per = net / took best = max(best, per) # A rate under half loses at any spread, which separates a costs # problem from a model that simply calls the wrong way rate = win / max(win + lose, 1) print(f" {names[b]:4s} {took:6,} taken right {win:5,} wrong {lose:5,} " f"nowhere {went:5,} won {rate * 100:.1f}% per trade {per:+.3f}") if rate < 0.5: print(f" under half, so this call loses even with no spread at all") # A market that drifted one way pays anyone who leaned that way, model or # not, so the signals are measured against simply taking every bar print("\n against trading every bar without a model") blind = -1e9 for b in (0, 2): win = int((truth == b).sum()) lose = int((truth == (2 - b)).sum()) took = len(truth) per = ((win - lose) * reach - took * cost) / took blind = max(blind, per) print(f" always {names[b]:4s} {took:6,} trades won " f"{win / max(win + lose, 1) * 100:.1f}% per trade {per:+.3f}") # Every signal is held for the whole horizon, so most of them overlap one # another. An account holds one position and waits, so the signals are # walked in order and any that arrives while a trade is open is passed over print("\n taking one position at a time, as an account really would") real, proven = -1e9, False for b in (0, 2): held, taken, win, lose = 0, 0, 0, 0 for i in range(len(pred)): if held > 0: held -= 1 continue if pred[i] != b: continue taken += 1 held = HORIZON if truth[i] == b: win += 1 elif truth[i] == (2 - b): lose += 1 if taken == 0: continue net = (win - lose) * reach - taken * cost if net / taken > real: real = net / taken # A handful of trades cannot tell an edge from a coin, so the spread of # a coin over the same count is stated beside the result res = max(win + lose, 1) rate = win / res swing = 1.96 * math.sqrt(0.25 / res) sure = abs(rate - 0.5) > swing print(f" {names[b]:4s} {taken:6,} trades right {win:5,} wrong {lose:5,} " f"won {rate * 100:.1f}% per trade {net / taken:+.3f} total {net:+,.0f}") if sure and net > 0.0: proven = True print(f" a coin over {res:,} trades lands between " f"{(0.5 - swing) * 100:.1f}% and {(0.5 + swing) * 100:.1f}%, so this is " f"{'outside that' if sure else 'inside that and cannot be told from luck'}") return real, blind, proven def save_onnx(model, folder): """Write the trained network where the terminal and the viewer can read it.""" path = os.path.join(folder, "model.onnx") model.eval() # The legacy exporter emits a plain Gemm chain, which the viewer draws in full, # so its deprecation notice is expected rather than a problem to fix warnings.filterwarnings("ignore", category=DeprecationWarning) torch.onnx.export( model, torch.zeros(1, INPUTS, dtype=torch.float32), path, input_names=["input"], output_names=["output"], opset_version=13, dynamo=False, ) return path def main(): print("Reading history from the terminal") rates, spread = pull_bars() print(f" {len(rates):,} bars of {SYMBOL}") feats, h, l, c, atr = build_features(rates) labels = build_labels(h, l, c, atr) # The first fifty bars have no history behind them, the last few no future keep = slice(50, len(c) - HORIZON - 1) X = feats[keep].astype(np.float32) y = labels[keep] when = rates["time"][keep].astype(np.int64) # A row with no number in it would poison the training good = np.isfinite(X).all(axis=1) X, y, when = X[good], y[good], when[good] counts = np.bincount(y, minlength=3) share = counts / counts.sum() * 100 print(f"\n labels: down {share[0]:.1f}%, flat {share[1]:.1f}%, up {share[2]:.1f}%") print(f" a barrier of {BARRIER} ATR costs {spread * 2 / (atr.mean() * BARRIER) * 100:.0f}% of a win") if share[1] > 45.0: print(f" flat covers {share[1]:.0f}% of the bars, which crowds out the two") print(" that matter, so lower BARRIER or lengthen HORIZON") elif share[1] < 5.0: print(f" flat covers only {share[1]:.0f}% of the bars, so raise BARRIER") # The split is by time, because a shuffled one lets the model see its own future n = len(X) cutA = int(n * (1.0 - TEST_SHARE - CHECK_SHARE)) cutB = int(n * (1.0 - TEST_SHARE)) Xtr, ytr = X[:cutA], y[:cutA] Xck, yck = X[cutA:cutB], y[cutA:cutB] Xte, yte = X[cutB:], y[cutB:] # Naming the dates makes it obvious that nothing from the test months # was ever seen during training def span(a, b): first = datetime.fromtimestamp(int(when[a]), timezone.utc) last = datetime.fromtimestamp(int(when[b - 1]), timezone.utc) return f"{first:%d %b %Y} to {last:%d %b %Y}" # A model can only learn what the sample contains, so the span is stated # plainly rather than assumed to be enough years = (int(when[n - 1]) - int(when[0])) / (365.25 * 24 * 3600) print(f"\n the sample covers {years:.1f} years") if years < 2.0: print(" that is likely one or two market moods, so a pattern found here") print(" may not survive the next one") print(f" training on {len(Xtr):,} bars {span(0, cutA)}") print(f" checking on {len(Xck):,} bars {span(cutA, cutB)}") print(f" testing on {len(Xte):,} bars {span(cutB, n)}") # The scale is taken from the training bars only, then applied to all three mean = Xtr.mean(axis=0) std = np.maximum(Xtr.std(axis=0), 1e-6) Xtr = (Xtr - mean) / std Xck = (Xck - mean) / std Xte = (Xte - mean) / std net = Net() # Rarer classes are weighted up so the model cannot just answer with the common one weight = torch.tensor(len(ytr) / (3.0 * np.maximum(np.bincount(ytr, minlength=3), 1)), dtype=torch.float32) loss_fn = nn.CrossEntropyLoss(weight=weight) opt = torch.optim.Adam(net.parameters(), lr=LEARN) # The rate eases off when the check score stops improving plan = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, mode="max", factor=0.5, patience=12) tX, ty = torch.tensor(Xtr), torch.tensor(ytr) cX, cy = torch.tensor(Xck), torch.tensor(yck) best, bestAt, bestState = 0.0, 15, None print("\n training") for epoch in range(EPOCHS): # A fresh order each pass stops the model learning the sequence itself net.train() order = torch.randperm(len(tX)) total = 0.0 for start in range(0, len(tX), BATCH): idx = order[start:start + BATCH] opt.zero_grad() # The loss reads the scores before Softmax, so it is taken one layer in out = net.l3(net.a2(net.l2(net.a1(net.l1(tX[idx]))))) loss = loss_fn(out, ty[idx]) loss.backward() opt.step() total += loss.item() * len(idx) # The check bars decide when to stop, so the test bars stay untouched net.eval() with torch.no_grad(): pck = net(cX).argmax(dim=1) hits = [float(((cy == a) & (pck == a)).sum()) / max(float((cy == a).sum()), 1.0) for a in range(3)] score = sum(hits) / 3.0 plan.step(score) if score > best and epoch >= 15: best, bestAt = score, epoch bestState = {k: v.clone() for k, v in net.state_dict().items()} if (epoch + 1) % 25 == 0: print(f" epoch {epoch + 1:4d} loss {total / len(tX):.4f} " f"check {score * 100:.2f}% best {best * 100:.2f}%") # Nothing is gained by running on once the check score has stalled if epoch - bestAt >= PATIENCE: print(f" stopped at epoch {epoch + 1}, no gain for {PATIENCE} rounds") break # The weights kept are the ones that scored best on bars held back from training if bestState is not None: net.load_state_dict(bestState) print(f" kept the weights from epoch {bestAt + 1}") net.eval() with torch.no_grad(): ptr = net(torch.tensor(Xtr)).argmax(dim=1).numpy() pte = net(torch.tensor(Xte)).argmax(dim=1).numpy() print("") report("on the bars it trained on", ptr, ytr) acc, balanced, edge = report("on the bars it never saw", pte, yte) # The model is trained with class weights, so it is judged on the balanced # score rather than on how often it agrees with the most common answer base = float(np.bincount(yte, minlength=3).max()) / len(yte) # Statistics that cannot pay the spread are not an edge, so the calls are priced real, blind, proven = expectancy(pte, yte, float(atr.mean()) * BARRIER, spread * 2.0) print("") print(f" a coin scores 33.33% balanced, this model scores {balanced * 100:.2f}%") print(f" always answering the most common class scores {base * 100:.2f}% of all bars") if balanced > 0.36: print(f" the calls carry an edge of up to {edge * 100:.1f} points over the base rate") else: print(" it does not separate the classes at all") # Only the one position at a time figure describes an account, so the # verdict follows that rather than the signal count if real <= 0.0: print(f" traded one position at a time the best side loses {real:.3f} a trade,") print(" so these weights carry no edge worth acting on") elif not proven: print(f" the best side makes {real:+.3f} a trade, but over so few trades a coin") print(" would do the same often enough that this is not yet an edge") elif real <= blind: print(f" traded properly the best side makes {real:+.3f}, but trading every bar") print(f" one way makes {blind:+.3f}, so the gain is drift rather than the model") else: print(f" traded one position at a time the best side makes {real:+.3f} against") print(f" {blind:+.3f} for trading blind, and it clears the range a coin would") print(" reach, so the model is adding something of its own") # The shared folder is the one the terminal and every tester agent can both # read, so everything the programs need is written there and nowhere else folder = os.path.dirname(os.path.abspath(__file__)) while os.path.basename(folder) != "MQL5" and os.path.dirname(folder) != folder: folder = os.path.dirname(folder) root = os.path.dirname(os.path.dirname(folder)) target = os.path.join(root, "Common", "Files", "ONNX Model Viewer Part 4") os.makedirs(target, exist_ok=True) path = save_onnx(net, target) with open(os.path.join(target, "model_scale.txt"), "w") as f: f.write(" ".join(f"{v:.10g}" for v in mean) + "\n") f.write(" ".join(f"{v:.10g}" for v in std) + "\n") # The MQL5 side has to build these same sixteen numbers from live bars. # Writing the last few hundred out lets it prove that it does, because a # feature that is close but not equal produces a confident wrong answer proof = os.path.join(target, "model_proof.csv") raw = feats[keep][good] with open(proof, "w") as f: f.write("time," + ",".join(f"f{i}" for i in range(INPUTS)) + "\n") for i in range(max(0, len(raw) - PROOF_BARS), len(raw)): f.write(str(int(when[i])) + "," + ",".join(f"{v:.10g}" for v in raw[i]) + "\n") print(f"\n wrote {path}") print(f" wrote {os.path.join(target, 'model_scale.txt')}") print(f" wrote {proof}, holding {min(PROOF_BARS, len(raw)):,} bars to check against") if __name__ == "__main__": main()