ML Engine¶

Overview¶

A machine-learning engine that learns from the market which signals of another indicator (or of a strategy) tend to work, and gives each new signal a probability. On a chart it filters the signals of any indicator; in the pack's strategies it is the ML Engine core setting - it can block weak signals and forecast the position size.

The position size forecast works only inside a strategy - it learns from the strategy's own trades: in the pack's strategies with Quantity → Mode = ML (see the ML Engine core page), in your own NinjaScript strategy as shown under In your own strategy. On a chart the indicator filters signals only.

How it works¶

1. Add the indicator whose signals you want to filter, then the ML Engine with that indicator as its Input series - the signals must be above 0 for long and below 0 for short.
2. The engine trains an ensemble of models on the signals and what followed them, and retrains as new outcomes arrive.
3. Each signal shows its probability; signals below Min probability are filtered out.

Parameters¶

ML Engine¶

Direction Ensemble Models¶

Direction Feature Params¶

ML Metrics Filter¶

Panel Style¶

Probability Style¶

Quantity Forecast¶

Quantity Ensemble Models¶

The models of the quantity forecast - set from a strategy, like the group above.

The ML panel¶

The panel shows how well the engine is doing right now. Click ML in its first line to fold it to the summary; click a section's title to fold that section. Where it sits, its size and opacity are set under Panel Style.

Summary (always shown):

• rows / pending - the examples the engine has learnt from, and the signals still waiting for their outcome. On the right - what the engine is doing now (learning, retraining).
• live AUC - how well the probabilities separate the signals that won from those that lost, measured on the recent live signals: above 0.55 green, 0.50-0.55 yellow, below 0.50 red. It needs 30 resolved signals first.
• thr / b/e - the probability threshold the signals are filtered by (auto or fixed), and the break-even: the win rate the signals need with the label's stop and target to pay off.
• ensemble - the ensemble's scores on the data held back from its training: AUC, F1, accuracy, precision, recall.

Commitment of Traders¶

The direction models also use the COT report. Turn on Control Center → Tools → Options → Market Data → Download COT data at startup; without it the engine works with its other features.

In your own strategy¶

The ML Engine can filter the signals of any NinjaScript strategy - an ordinary managed strategy with EnterLong / EnterShort, no ASF core needed. Your strategy writes its raw signal into a series; the engine passes the signals it believes in and blocks the rest.

The short form¶

MLEngine( input , ... ) has a default for every setting - the same values the indicator has on a chart. Pass only the series, and by name only what you want to change:

ml = MLEngine( baseSignal );                                        // all defaults
ml = MLEngine( baseSignal , minProbability: 0.55 , barsAhead: 30 );  // two settings changed

Named arguments do not depend on their position, so your code keeps compiling when a new engine version adds a setting. Do not use the positional form NinjaTrader generates (every setting, in order): it breaks with any change of the engine's settings.

A complete strategy¶

An EMA cross filtered by the engine, with the size from the quantity forecast:

using NinjaTrader.Cbi;
using NinjaTrader.Data;
using NinjaTrader.NinjaScript.Indicators;

namespace NinjaTrader.NinjaScript.Strategies
{
    public class MyMLStrategy : Strategy
    {
        private EMA fast , slow;
        private Series<double> baseSignal;
        private Indicators.ASF.MLEngine ml;

        protected override void OnStateChange()
        {
            if ( State == State.SetDefaults )
            {
                Name      = "My ML Strategy";
                Calculate = Calculate.OnBarClose;
            }
            else if ( State == State.Configure )
            {
                AddDataSeries( BarsPeriod.BarsPeriodType , BarsPeriod.Value );   // index 1: a copy of the chart's bars
                AddDataSeries( BarsPeriodType.Day , 1 );                         // index 2: daily bars
            }
            else if ( State == State.DataLoaded )
            {
                fast       = EMA( 9 );
                slow       = EMA( 21 );
                baseSignal = new Series<double>( this , MaximumBarsLookBack.Infinite );

                ml = MLEngine( baseSignal , minProbability: 0.55 );
                AddChartIndicator( ml );
            }
        }

        protected override void OnBarUpdate()
        {
            if ( BarsInProgress != 0 || CurrentBars[0] < 22 || CurrentBars[1] < 1 || CurrentBars[2] < 1 )
                return;

            // Your raw signal: +1 long, -1 short, 0 nothing.
            baseSignal[0] = CrossAbove( fast , slow , 1 ) ?  1
                          : CrossBelow( fast , slow , 1 ) ? -1
                          : 0;

            int qty = ml.GetRecommendedContracts( DefaultQuantity );

            // Only what the engine let through is traded.
            if ( ml.MLSignal[0] > 0 )
                EnterLong( qty , "Long" );
            else if ( ml.MLSignal[0] < 0 )
                EnterShort( qty , "Short" );
        }

        protected override void OnPositionUpdate( Position position , double averagePrice , int quantity , MarketPosition marketPosition )
        {
            // The quantity model learns from each closed trade.
            if ( position.MarketPosition == MarketPosition.Flat && ml != null )
                ml.UpdateStrategySnapshot( SystemPerformance.AllTrades.TradesPerformance );
        }
    }
}

Without the quantity forecast, size the entries yourself and leave out GetRecommendedContracts and OnPositionUpdate.

Every setting¶

The same call with every setting named, at its default value. Copy it and change what you need - or delete the lines you keep at their defaults. It needs using NinjaTrader.Gui.Tools; and using NinjaTrader.NinjaScript.Indicators.ASF.MyMLEngineEnums;.

ml = MLEngine( baseSignal ,

    // Signal and labels
    minProbability:               0.5,      // probability a signal needs to pass (0 = the best F1 threshold)
    topSignalsPercent:            0,        // pass only the best N % of signals (0 = off)
    barsAhead:                    60,       // bars a signal has to reach its target or stop
    labelStopTicks:               40,       // stop for labelling the signals, in ticks
    labelTargetTicks:             55,       // target for labelling the signals, in ticks
    signalOffsetBars:             0,        // bars back the input signal is read

    // Training
    recordsBeforeRetrain:         10,       // new labelled signals before the models retrain
    retrainMode:                  MLRetrainMode.Always,   // Always, UntilEdge, Off
    freezeAtAuc:                  0.56,     // UntilEdge: the AUC at which training stops
    useAutoWeights:               true,     // weight the models by their quality

    // Direction models
    useLightGbm:                  true,
    useFastTree:                  true,
    useFastForest:                true,
    useSdcaLogisticRegression:    true,
    useLbfgsLogisticRegression:   true,
    useAveragedPerceptron:        true,
    useSgdCalibrated:             true,

    // Features
    featureStep:                  7,        // bars between the points the features are read at
    featurePoints:                4,        // points the features are read at
    aTRPeriod:                    14,
    slopeStartBarsAgo:            14,
    slopeEndBarsAgo:              0,
    mACDFast:                     12,
    mACDSlow:                     26,
    mACDSmooth:                   9,
    deltaSource:                  MLDeltaSource.Bars,     // Bars (estimate) or Ticks (exact, needs tick data)
    hostTickSeries:               false,    // true if your strategy's index 1 is a 1-tick series anyway
    deltaType:                    CumulativeDeltaType.UpDownTick,
    deltaPeriod:                  CumulativeDeltaPeriod.Session,
    deltaSizeFilter:              0,
    resolution:                   VWAPResolution.Standard,

    // Metrics filter - block the signals while the models are weak
    useMetricsFilter:             false,
    minAuc:                       0,
    minF1:                        0,
    minAccuracy:                  0,
    minPrecision:                 0,
    minRecall:                    0,

    // Quantity forecast
    useQuantityForecast:          true,
    minContracts:                 1,
    maxContracts:                 10,
    maxQtyStepPerTrade:           1,        // largest change of size from one entry to the next
    useQtyAutoWeights:            true,
    useQtyMetricsFilter:          false,
    minQtyR2:                     -1.0,
    maxQtyMAE:                    1000000.0,
    useQtyLightGbm:               true,
    useQtyFastTree:               true,
    useQtyFastForest:             true,
    useQtySdca:                   true,
    useQtyFastTreeTweedie:        true,
    useQtyOnlineGradientDescent:  true,
    useQtyLbfgsPoissonRegression: true,

    // Display
    enableLogging:                false,    // the engine's log in the Output window
    showProbability:              true,     // the probability over each signal
    showHud:                      true,     // the ML panel
    hudPosition:                  TableTextPosition.TopRight,
    hudScale:                     100,
    tableOpacity:                 75,
    probFont:                     new SimpleFont( "Consolas" , 11 ),
    probBrush:                    Brushes.DodgerBlue,
    probVerticalOffsetTicks:      0 );

// Label against the stop and target you really trade (here 40 / 55 ticks).
ml.SetRiskModel( 40 , 55 , CalculationMode.Ticks );

The argument names follow the setting names; the signal settings are explained under Parameters, the quantity settings in the comments above.

Requirements¶

• NinjaTrader Order Flow+ (order-flow features).

Version history¶

v.3.6.4.0 - October 2026

• Changed: the position size forecast and its settings only inside a strategy; on a chart the engine filters signals.