526 lines
22 KiB
Python
# 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()
|