The one-sentence version

A binary logistic regression on a small vector of price-derived features, re-trained on a rolling window that ends strictly before the current bar, trading one position at a time with ATR-based stop-loss and take-profit levels, entered at the next bar's open.

The whole design exists to answer one question honestly:

The label

Training targets are binary, and depend only on the close price lookahead bars ahead:

label(k) = 1.0  if  close[k + lookahead] > close[k]   else   0.0

So the model is not predicting magnitude, or return, or direction over a fixed horizon in a regression sense. It is predicting whether the close will be higher a few bars later. With the stage-1 default lookahead = 3, that is a three-bar-ahead up/down call.

That is also all the model learns. It never sees P&L, never sees the stop-loss, and is never rewarded for a trade that happened to work out. It optimises classification accuracy on the log-loss of a static binary target.

Why there is no lookahead

This is the part worth understanding properly, because it is a handful of index expressions that carry the entire credibility of the results.

Batch training stops before the current bar

k_start = current - lookahead - training_bars + 1
k_end   = current - lookahead + 1          # exclusive

for k in range(max(1, k_start), k_end):
    ...
    labels.append(1.0 if close[k + lookahead] > close[k] else 0.0)

For every training sample k, the largest index the label touches is k + lookahead. Because the loop stops at k_end - 1 = current - lookahead, the largest label index read is current. The label uses close[k + lookahead] where the bar at k + lookahead has already closed by the time we are at current.

Training also explicitly skips samples whose label would reach past the end of the data: if k + lookahead >= n: continue.

Online learning uses a stale feature vector

def online_learn(i):
    if i < p["lookahead"]:
        return
    stale = i - p["lookahead"]        # the bar whose outcome is now known
    x     = valid_feats(stale)
    pr    = predict(x)
    actual = 1.0 if close[i] > close[stale] else 0.0
    error  = pr - actual
    # one SGD step on weights / bias

Each bar contributes exactly one online gradient step, and it is a step on a fully resolved prediction: the features of bar i - lookahead, compared against the close of bar i. By construction the outcome is known. The model never takes a gradient step based on a prediction whose truth is still in the future.

The model

Standard logistic regression with an L2 penalty:

Before the first successful train, predict() returns exactly 0.5 — deliberately in the dead zone between the entry thresholds, so an untrained model cannot accidentally trade.

Three separate update paths

The online step uses momentum with a decay factor, so repeated corrections in the same direction accumulate — a small amount of adaptive responsiveness between the hard re-trains.

The search space

Three groups of parameters get grid-searched, in two stages.

Stage 1 — trade geometry (64 combinations)

4 × 4 × 4 = 64 combinations, each run at max_iter = 600.

Stage 2 — training behaviour (243 per stage-1 winner)

3 × 3 × 3 × 3 = 81 combinations, run for each of the top 3 diverse stage-1 survivors — 243 runs.

The three stage-1 survivors are deliberately kept diverse: the list is de-duplicated on the whole (sl_mult, rr, lookahead) tuple, so the three are not three near-identical variants of one good point.

Final verification

The stage 1 and stage 2 results are merged, filtered to those that pass the acceptance test, sorted by score, and the top 40 are re-run at the full budget max_iter = 2000. This matters because the search ran at 600 iterations: a point that looked good under-trained may not survive proper convergence, and vice versa.

The acceptance test and the score

score = net_profit / (1 + abs(max_dd_pct) / 100)

ok    = trades >= 30  and  profit_factor > 1.0

A configuration that fails ok is assigned a score of -1e18, which effectively removes it from the ranking. So the search cannot select a high-net configuration that achieved it in twelve trades or with a profit factor below 1.

Slot selection

After verification, survivors are sorted by score and fed to a greedy selector that picks up to 5 slots subject to a correlation constraint:

The correlation is computed on the first difference of equity, not the level. Levels are dominated by the shared price trend of the instrument and would make almost everything look correlated; differencing isolates the per-bar behaviour, which is the thing being diversified.

Trade execution

One position at a time per slot. The sequence for a given signal bar i:

How positions close

On every subsequent bar the position is checked against its levels. The order is significant:

# long
if low[i]  <= sl:  closed = ("SL", sl)
elif high[i] >= tp: closed = ("TP", tp)

# short
if high[i] >= sl:  closed = ("SL", sl)
elif low[i]  <= tp: closed = ("TP", tp)

If neither level is touched, the position carries over. Any position still open at the end of the data is closed at the final close with the reason "EOData".

Breakeven and trailing stops exist in the engine but are off by default, matching the generated EAs. The pipeline describes them as "NOBE" builds.

Money and costs

P&L is computed in dollars by a single expression:

pnl = (exit_price - entry_price) × fixed_lot × lot_mult × side

side is +1 for long, −1 for short. fixed_lot is 0.01 — one micro-lot — everywhere in the pipeline. lot_mult converts a price move into money for that instrument:

The EURUSD value is not merely a table entry — it is asserted. On startup the engine derives dollars-per-pip for EURUSD at 0.01 lot and raises a SystemExit if it deviates from $0.10 by more than 5%. A units mistake would otherwise inflate or deflate every figure silently.

Spread is not charged on fills

Magic numbers

Every slot has a unique magic number, built from the feature set's base plus a timeframe offset:

magic = LR_MAGIC_BASE[set] + magic_offset + slot_index

LR_MAGIC_BASE[set] = FEATURE_SETS[set]["magic_start"] + 100

With magic_start = 301 for base9, the base is 401 and its five slots are 401–405. The timeframe offsets let several timeframes run on one account simultaneously without collision:

So base9 on M5 occupies 401–405, while the same set on M15 occupies 1401–1405. The EA scans for its own positions matching on both magic and symbol.

The features

Features are computed from a small derived-primitive library. Each set selects a subset. All divisions are guarded against 1e-10, and the whole set is standardised before use.

The eleven feature sets

The ALL9 portfolio uses the first six sets plus micro, voltrend and meanrev — nine slots from nine distinct feature definitions. ALL6 uses only the first six.

Metrics

All metrics are computed from the equity curve and the closed-trade list:

The Sharpe calculation, precisely

rets  = diff(equity) / equity[:-1]
sharpe = mean(rets) / max(std(rets), 1e-10)
         × sqrt(365 × 24 × 60 / n_bars)

The annualisation factor assumes the bars are minute bars spanning a 24/7 calendar: 365 × 24 × 60 minutes in a year, divided by the number of bars. For an M5 series that over-states the number of bars per year, since the n used is the actual bar count rather than a trading calendar. Treat the Sharpe figure as comparable between slots in the same run rather than as an absolute annualised Sharpe ratio.

Three modes the engine supports for the holdout

The engine has two hook parameters used only by the tail-holdout stage. They are implemented as plain flags rather than as a separate code path, which is why the holdout is trustworthy: it is the same simulator, restricted.

Warm mirrors what a live EA actually does: it has been training and trading before the tail begins, so it arrives at the tail with an already-adapted model. Cold is the stricter test: the model has never seen anything before the tail boundary and receives one batch train from the pre-tail history before trading. See Step 5.

A third mode: signal recording

When record_signals is set, the engine stops simulating trades entirely and instead collects raw entry signals — bar, side, entry price, SL, TP, probability — without ever holding a position.

This exists because of a structural property: the hour filter gates entries only. Training reads its own separate mask, and online learning uses the bar's own forward return rather than position P&L. The weight trajectory is therefore identical for every hour subset.