Если вы занимаетесь алгоритмической торговлей, вы скорее всего слышали о нейронных сетях. Кажется, вот он, путь к созданию святого грааля. Однако в этом я не уверен, потому что для получения прибыльной системы требуется больше, чем просто добавить в торгового робота нейросеть. Более того, нужно четко понимать, во что вы ввязываетесь при использовании нейронных сетей, потому что иногда успех или неудача, т.е. прибыли или убыток, зависят от мельчайших деталей.

Лично я думаю, что нейронные сети не помогут тем, кто не хочет марать руки. Ведь с ними постоянно нужно тратить время на анализ ошибок модели, предварительную обработку и масштабирование входных данных, и многое другое, о чем мы поговорим в этой статье.

Давайте начнем эту статью с определения искусственной нейронной сети.

Что такое искусственная нейронная сеть?

Это очень важно помнить. Запомните эти пункты, чтобы не разбираться во всем этом самостоятельно.

Давайте посмотрим на архитектуру нейронной сети, над которой мы работаем, чтобы вы четко понимали, чем мы здесь занимаемся.

В этой нейросети только один слой, поэтому в функции прямого прохода, показанной выше, нет циклов. При этом, если следовать тому же матричному подходу и использовать соответствующие размеры, вы сможете реализовать архитектуру любой сложности.

Итак, выше показан прямой проход с матрицей W. Давайте теперь посмотрим, как найти веса для нашей модели.

Генерация весов

Генерация подходящих весов для нейронной сети — это не просто инициализация случайных значений. Я узнал на горьком опыте, что неправильный подход вызывает всевозможные проблемы с обратным распространением, которые заставляют усомниться в этом сложном коде и заниматься его отладкой.

Если инициализировать веса неправильно, весь процесс обучения можно сделать излишне трудоемким и долгим. Сеть может застрять на локальных минимумах и очень медленно сходиться.

На первом шаге мы выбираем случайные значения, я предпочитаю использовать случайное состояние 42.

   this.W = matrix_utils.Random(0.0, 1.0,1,m_inputs, RANDOM_STATE);

Большинство людей останавливаются на этом шаге — генерируют веса и думают, что это все. После выбора случайных величин нужно инициализировать веса, используя Glorot или Инициализацию Ге (He Initialization).

Инициализация Xavier/Glorot лучше всего работает с сигмовидными и тангенциальными функциями активации, в то время как инициализация Ге работает с RELU и его вариантами.

Инициализация Ге (He)

Таким образом, после инициализации весов у нас идет нормализация.

   this.W = matrix_utils.Random(0.0, 1.0,1,m_inputs, RANDOM_STATE);
   this.W = this.W * 1/sqrt(m_inputs); //He initialization

Поскольку эта нейронная сеть имеет один слой, у нас только одна матрица для переноса весов.

Функции активации нейронов

Это нейронная сеть регрессионного типа, а функции активации этой сети являются просто вариантами функции активации регрессии. RELU:

enum activation
  {
   AF_ELU_ = AF_ELU,
   AF_EXP_ = AF_EXP,
   AF_GELU_ = AF_GELU,
   AF_LINEAR_ = AF_LINEAR,
   AF_LRELU_ = AF_LRELU,
   AF_RELU_ = AF_RELU,
   AF_SELU_ = AF_SELU,
   AF_TRELU_ = AF_TRELU,
   AF_SOFTPLUS_ = AF_SOFTPLUS
  };

Эти функции активации, выделенные красным, в числе других доступны в стандартной библиотекой (Документация).

Функции потерь

Функции потерь для этой регрессионной нейронной сети:

enum loss
  {
    LOSS_MSE_ = LOSS_MSE,
    LOSS_MAE_ = LOSS_MAE,
    LOSS_MSLE_ = LOSS_MSLE,
    LOSS_HUBER_ = LOSS_HUBER
  };

В стандартной библиотеке есть и другие функции активации, подробнее о которых можно почитать в документации.

Обратный проход с использованием дельта-правила

Дельта-правило — это правило обучения градиентного спуска для обновления весов входных данных искусственных нейронов в однослойной нейронной сети. Это частный случай более общего алгоритма обратного распространения. Для нейрона j с активационной функцией g(x), дельта-правило веса Wji на позиции i для нейрона j будет таким:

Отлично, теперь у нас есть формула, так что нам просто нужно ее реализовать, верно? Нет.

Проблема с этой формулой в том, что как бы просто она ни выглядела, она очень сложна при преобразовании ее в код и требует пары циклов for. Такая практика в нейронных сетях может свести с ума. Правильная формула, которая нам нужна, это та, которая использует матричные операции. Вот она:

Давайте посмотрим, как это выглядит при переносе формулы в код.

for (ulong iter=0; iter<m_rows; iter++)
   {
        OUTPUT = ForwardPass(m_x_matrix.Row(iter)); //forward pass
        pred = matrix_utils.MatrixToVector(OUTPUT);
              
        actual[0] = m_y_vector[iter];
              
        preds[iter] = pred[0];
        actuals[iter] = actual[0];
              
//---
              
        INPUT = matrix_utils.VectorToMatrix(m_x_matrix.Row(iter));
              
        vector loss_v = pred.LossGradient(actual, ENUM_LOSS_FUNCTION(L_FX));
              
        LOSS_DX.Col(loss_v, 0);
              
        OUTPUT.Derivative(OUTPUT, ENUM_ACTIVATION_FUNCTION(A_FX));
              
        OUTPUT = LOSS_DX * OUTPUT;
              
        INPUT = INPUT.Transpose();
        DX_W = OUTPUT.MatMul(INPUT);
               
        this.W -= (alpha * DX_W); //Weights update by gradient descent
 }

Преимущество использования для машинного обучения библиотеки матриц от MQL5 вместо массивов заключается в том, что нам не нужно производить никаких расчетов, я имею в виду, что не нужно самостоятельно считать производные функции потерь, производные функции активации — вообще ничего.

Чтобы обучить модель, нужно учесть две вещи: по крайней мере на данный момент эпохи и скорость обучения обозначаются как альфа. Если вы читали предыдущую статью из этой серии, в которой мы говорили о градиентном спуске, вы понимаете, о чем я говорю.

Эпохи. Одна эпоха — это когда весь набор данных полностью проходит цикл вперед и назад по сети. Простыми словами, это когда сеть увидела все данные. Чем больше количество эпох, тем больше времени требуется для обучения нейронной сети и тем лучше она может быть обучена.

Альфа — это размер шага, с которым алгоритм градиентного спуска движется к глобальному и локальному минимуму. Альфа обычно представляет собой небольшое значение от 0,1 до 0,00001. Чем больше это значение, тем быстрее сходится сеть, но тем выше риск пройти мимо локального минимума.

Ниже приведен полный код этого дельта-правила:

   for (ulong epoch=0; epoch<epochs && !IsStopped(); epoch++)
      {
         for (ulong iter=0; iter<m_rows; iter++)
            {
              OUTPUT = ForwardPass(m_x_matrix.Row(iter));
              pred = matrix_utils.MatrixToVector(OUTPUT);
              
              actual[0] = m_y_vector[iter];
              
              preds[iter] = pred[0];
              actuals[iter] = actual[0];
              
           //---
              
              INPUT = matrix_utils.VectorToMatrix(m_x_matrix.Row(iter));
              
              vector loss_v = pred.LossGradient(actual, ENUM_LOSS_FUNCTION(L_FX));
              
              LOSS_DX.Col(loss_v, 0);
              
              OUTPUT.Derivative(OUTPUT, ENUM_ACTIVATION_FUNCTION(A_FX));
              
              OUTPUT = LOSS_DX * OUTPUT;
              
              INPUT = INPUT.Transpose();
              DX_W = OUTPUT.MatMul(INPUT);
               
              this.W -= (alpha * DX_W);
            }
         
         printf("[ %d/%d ] Loss = %.8f | accuracy %.3f ",epoch+1,epochs,preds.Loss(actuals,ENUM_LOSS_FUNCTION(L_FX)),metrics.r_squared(actuals, preds));
      }

Теперь все готово. Пришло время обучить нейронную сеть понимать небольшую закономерность в наборе данных.

#include <MALE5\Neural Networks\selftrain NN.mqh>
#include <MALE5\matrix_utils.mqh>

CRegNeuralNets *nn;
CMatrixutils matrix_utils;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
    matrix Matrix = {
                     {1,2,3},
                     {2,3,5},
                     {3,4,7},
                     {4,5,9},
                     {5,6,11}
                   };
   
   matrix x_matrix; vector y_vector;
   
   matrix_utils.XandYSplitMatrices(Matrix,x_matrix,y_vector);
   
   nn = new CRegNeuralNets(x_matrix,y_vector,0.01,100, AF_RELU_, LOSS_MSE_); //Training the Network
   
   
//---
   return(INIT_SUCCEEDED);
  }

Функция XandYSplitMatrices разбивает матрицу на матрицу x и вектор y.

Результаты обучения:

CS      0       20:30:00.878    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [1/100] Loss = 56.22401001 | accuracy -6.028 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [2/100] Loss = 2.81560904 | accuracy 0.648 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [3/100] Loss = 0.11757813 | accuracy 0.985 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [4/100] Loss = 0.01186759 | accuracy 0.999 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [5/100] Loss = 0.00127888 | accuracy 1.000 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [6/100] Loss = 0.00197030 | accuracy 1.000 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [7/100] Loss = 0.00173890 | accuracy 1.000 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [8/100] Loss = 0.00178597 | accuracy 1.000 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [9/100] Loss = 0.00177543 | accuracy 1.000 
CS      0       20:30:00.879    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [10/100] Loss = 0.00177774 | accuracy 1.000 
…
…
…
CS      0       20:30:00.883    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [100/100] Loss = 0.00177732 | accuracy 1.000 

Всего после 5 эпох точность нейронной сети составила 100%. Это хорошо, потому что эта задача очень простая, и более быстрого обучение было ожидаемо.

Теперь, когда эта нейронная сеть обучена, давайте протестируем ее на новых значениях {7,8}. Мы с вами знаем, что результат равен 15.

   vector new_data = {7,8};
   
   Print("Test ");
   Print(new_data," pred = ",nn.ForwardPass(new_data));
   

Выводимая информация:

CS      0       20:37:36.331    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      Test 
CS      0       20:37:36.331    Self Trained NN EA (Apple_Inc_(AAPL.O),H1)      [7,8] pred = [[14.96557787153696]]

Давайте дадим этой модели реальный набор данных и посмотрим, что она сделает.

Я использовал данные по акциям Tesla и Apple в качестве независимых переменных для предсказания индекса NASDAQ (NAS 100). Я как-то прочитал в интернете статью на CNBC о том, что акции шести технологических компаний составляют половину стоимости NASDAQ. Две из них это Apple и Tesla. В этом примере я буду использовать эти две акции в качестве независимых переменных для обучения нейронной сети.

input string symbol_x = "Apple_Inc_(AAPL.O)"; 
input string symbol_x2 = "Tesco_(TSCO.L)";

input ENUM_COPY_RATES copy_rates_x = COPY_RATES_OPEN; 
input int n_samples = 100; 

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {

   matrix x_matrix(n_samples,2); vector y_vector;

   vector x_vector; 
  //---
   x_vector.CopyRates(symbol_x,PERIOD_CURRENT,copy_rates_x,0,n_samples);
   x_matrix.Col(x_vector, 0); 
   x_vector.CopyRates(symbol_x2, PERIOD_CURRENT,copy_rates_x,0,n_samples);
   x_matrix.Col(x_vector, 1); 
   
   y_vector.CopyRates(Symbol(), PERIOD_CURRENT,COPY_RATES_CLOSE,0,n_samples);
    
   nn = new CRegNeuralNets(x_matrix,y_vector,0.01,1000, AF_RELU_, LOSS_MSE_);

После запуска скрипта вот что получилось в журнале:

CS      0       21:29:20.698    Self Trained NN EA (NAS100,M30) [ 1/1000 ] Loss = 353809311769.08959961 | accuracy -27061631.733 
CS      0       21:29:20.698    Self Trained NN EA (NAS100,M30) [ 2/1000 ] Loss = 149221473.48209998 | accuracy -11412.427 
CS      0       21:29:20.699    Self Trained NN EA (NAS100,M30) [ 3/1000 ] Loss = 149221473.48209998 | accuracy -11412.427 
CS      0       21:29:20.699    Self Trained NN EA (NAS100,M30) [ 4/1000 ] Loss = 149221473.48209998 | accuracy -11412.427 
CS      0       21:29:20.699    Self Trained NN EA (NAS100,M30) [ 5/1000 ] Loss = 149221473.48209998 | accuracy -11412.427 
CS      0       21:29:20.699    Self Trained NN EA (NAS100,M30) [ 6/1000 ] Loss = 149221473.48209998 | accuracy -11412.427 
....
....
CS      0       21:29:20.886    Self Trained NN EA (NAS100,M30) [ 1000/1000 ] Loss = 149221473.48209998 | accuracy -11412.427 

Что?! И это мы получили после всего того, что сделали. Подобные вещи часто происходят в нейронных сетях, поэтому очень важно иметь четкое понимать, как работает нейросеть, независимо от того, какой фреймворк или библиотеку Python вы используете.

Нормализация и масштабирование данных

Не устану повторять, насколько это важно. Хотя не все выборки дают лучшие результаты при нормализации, например, если нормализовать этот простой датасет, который мы использовали сначала для проверки работоспособности нейросети, результаты будут ужасными. Нейросеть будет возвращать значения хуже — я проверял.

Существует множество методов нормализации. Три наиболее часто используемых из них:

1. Min-Max Scaler
2. Нормализация по среднему
3. Стандартизация или нормализация Z-оценки

Это важнее, чем вы можете подумать

Если вы до этого работали с Python в области машинного обучения, вы, вероятно, встречали функцию train_test_split от sklearn.

Цель разделения выборки на обучающие и тестовые данные состоит не только в том, чтобы поделить данные, но и в том, чтобы рандомизировать датасет, чтобы он не находился в исходном порядке. Я объясню. Поскольку нейросети и другие алгоритмы машинного обучения стремятся понять закономерности в данных, наличие данных в том же порядке, из которого они были извлечены, может быть плохо — моделям легче понять закономерности, когда данные представлены в том же порядке. Это не лучший способ обучения моделей, потому что для нас важно не расположение данных, а сами закономерности.

void TrainNetwork()
 {
//--- collecting the data

   matrix Matrix(n_samples,3); vector y_vector;
   vector x_vector; 
   
   x_vector.CopyRates(symbol_x,PERIOD_CURRENT,copy_rates_x,0,n_samples);
   Matrix.Col(x_vector, 0); 
   x_vector.CopyRates(symbol_x2, PERIOD_CURRENT,copy_rates_x,0,n_samples);
   Matrix.Col(x_vector, 1); 
   
   y_vector.CopyRates(Symbol(), PERIOD_CURRENT,COPY_RATES_CLOSE,0,n_samples);
   Matrix.Col(y_vector, 2);
   
//---

   matrix x_train, x_test; vector y_train, y_test;
   
   matrix_utils.TrainTestSplitMatrices(Matrix, x_train, y_train, x_test, y_test, 0.7, 42);
   
   nn = new CRegNeuralNets(x_train,y_train,0.01,1000, AF_RELU_, LOSS_MSE_,NORM_MIN_MAX_SCALER);
   
   vector test_pred = nn.ForwardPass(x_test);
    
   printf("Testing Accuracy =%.3f",metrics.r_squared(y_test, test_pred));
 }

После сбора обучающих данных мы ввели функцию TrainTestSplitMatrices с random state 42.

void TrainTestSplitMatrices(matrix &matrix_,matrix &x_train,vector &y_train,matrix &x_test, vector &y_test,double train_size=0.7,int random_state=-1)

Прогнозирование рынка в реальном времени

Чтобы делать прогнозы в реальном времени, в функции Ontick должен быть код для сбора данных и размещения их во входной вектор функции прямого прохода нейронной сети.

void OnTick()
  {
//---
     if (!train_nn)
       TrainNetwork(); //Train the network only once
     train_nn = true; 
     
     vector x1, x2;
     
     x1.CopyRates(symbol_x,PERIOD_CURRENT,copy_rates_x,0,1); //only the current candle
     x2.CopyRates(symbol_x2,PERIOD_CURRENT,copy_rates_x,0,1); //only the current candle
     
     vector inputs = {x1[0], x2[0]}; //current values of x1 and x2 instruments | Apple & Tesla
     
     matrix OUT = nn.ForwardPass(inputs); //Predicted Nasdaq value
     
     double pred = OUT[0][0];
     
     Comment("pred ",OUT);
 }

Теперь наша нейронная сеть может делать прогнозы. Попробуем использовать ее в торговле. Для этого создадим стратегию.

Логика торговли

Торговая логика проста: если предсказанная нейронной сетью цена выше текущей, открываем сделку на покупку с тейк-профитом на уровне спрогнозированной цены, умноженной на значение входного параметра take profit. И наоборот для сделок на продажу. В каждой сделке ставится стоп-лосс, равный количеству пунктов тейк-профита, помноженных на значение параметра stop loss. Как это выглядит в MetaEditor.

     stops_level = (int)SymbolInfoInteger(Symbol(),SYMBOL_TRADE_STOPS_LEVEL);
     Lots = SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
     spread = (double)SymbolInfoInteger(Symbol(), SYMBOL_SPREAD);
     
     MqlTick ticks;
     SymbolInfoTick(Symbol(), ticks);
     
     if (MathAbs(pred - ticks.ask) + spread > stops_level)
        {
          if (pred > ticks.ask && !PosExist(POSITION_TYPE_BUY))
            {
               target_gap  = pred - ticks.bid;
               
               m_trade.Buy(Lots, Symbol(), ticks.ask, ticks.bid - ((target_gap*stop_loss) * Point()) , ticks.bid + ((target_gap*take_profit) * Point()),"Self Train NN | Buy");
            }
         
          if (pred < ticks.bid && !PosExist(POSITION_TYPE_SELL))
            {
               target_gap = ticks.ask - pred;
               
               m_trade.Sell(Lots, Symbol(), ticks.bid, ticks.ask + ((target_gap*stop_loss) * Point()), ticks.ask - ((target_gap*take_profit) * Point()), "Self Train NN | Sell");
            } 
        }

Такая логика. Посмотрим, как советник работает в МТ5.

Этот простой советник может совершать сделки самостоятельно. Пока мы не можем оценить его работу — слишком рано. Перейдем в тестер стратегий.

Результаты тестера стратегий

Могут быть сложности с запуском алгоритмов машинного обучения в тестере стратегий, потому нужно убедиться, что алгоритмы работают гладко и быстрою. Ну и конечно, нужно убедиться, что советник генерирует прибыль. 

Я запускал тесты с 2023.01.01 по 2023.02.23 на четырехчасовом графике на основе реальных тиков. Тестировались последние тики, так как подозреваю, что такой тест будет намного лучшего качества по сравнению тестированием на старых данных.

Мы настроили функцию, которая обучает нашу модель, на запуск на самом первом тике жизненного цикла тестирования, поэтому процесс обучения и тестирования модели был выполнен мгновенно. Посмотрим, как работает модель, а потом проверим графики и все, что предоставляет тестер стратегий.

CS      0       15:50:47.676    Tester  NAS100,H4 (Pepperstone-Demo): generating based on real ticks
CS      0       15:50:47.677    Tester  NAS100,H4: testing of Experts\Advisors\Self Trained NN EA.ex5 from 2023.01.01 00:00 to 2023.02.23 00:00 started with inputs:
CS      0       15:50:47.677    Tester    symbol_x=Apple_Inc_(AAPL.O)
CS      0       15:50:47.677    Tester    symbol_x2=Tesco_(TSCO.L)
CS      0       15:50:47.677    Tester    copy_rates_x=1
CS      0       15:50:47.677    Tester    n_samples=200
CS      0       15:50:47.677    Tester    =
CS      0       15:50:47.677    Tester    slippage=100
CS      0       15:50:47.677    Tester    stop_loss=2.0
CS      0       15:50:47.677    Tester    take_profit=2.0
CS      3       15:50:49.209    Ticks   NAS100 : 2023.02.21 23:59 - real ticks absent for 2 minutes out of 1379 total minute bars within a day

CS      0       15:50:51.466    History Tesco_(TSCO.L),H4: history begins from 2022.01.04 08:00
CS      0       15:50:51.467    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 1/1000 ] Loss = 0.14025037 | accuracy -1.524 
CS      0       15:50:51.468    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 2/1000 ] Loss = 0.05244676 | accuracy 0.056 
CS      0       15:50:51.468    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 3/1000 ] Loss = 0.04488896 | accuracy 0.192 
CS      0       15:50:51.468    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 4/1000 ] Loss = 0.04114715 | accuracy 0.259 
CS      0       15:50:51.468    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 5/1000 ] Loss = 0.03877407 | accuracy 0.302 
CS      0       15:50:51.469    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 6/1000 ] Loss = 0.03725228 | accuracy 0.329 
CS      0       15:50:51.469    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 7/1000 ] Loss = 0.03627591 | accuracy 0.347 
CS      0       15:50:51.469    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 8/1000 ] Loss = 0.03564933 | accuracy 0.358 
CS      0       15:50:51.470    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 9/1000 ] Loss = 0.03524708 | accuracy 0.366 
CS      0       15:50:51.470    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 10/1000 ] Loss = 0.03498872 | accuracy 0.370 


CS      0       15:50:51.662    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 1000/1000 ] Loss = 0.03452066 | accuracy 0.379 
CS      0       15:50:51.662    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   Testing Accuracy =0.717

Точность обучения составила 37,9%, но точность тестирования оказалась 71,7%. Как так?

Подозреваю, дело в качестве обучения. Всегда нужно следите за тем, чтобы данные для обучения и тестирования имели достойное качество, а каждый пропуск данных может иметь последствия. Поскольку мы проверяем результаты в тестере стратегий, мы должны быть уверены, что результаты тестирования на истории получены от хорошей модели, для построения которой мы приложили много усилий.

По окончании работы тестера стратегий результаты не удивили, большинство сделок, открытых этим советником, завершились с убытком в размере 78,27%.

Поскольку мы не оптимизировали стоп-лосс и тейк-профит, думаю, можно оптимизировать эти значения и другие параметры.

Я провел короткую оптимизацию и подобрал следующие значения: copy_rates_x: COPY_RATES_LOW, n_samples: 2950, Slippage: 1, Stop loss: 7.4, Take profit: 5.0.

На этот раз модель показала точность обучения 61,5% и точность тестирования 63,5% в начале в тестере стратегий. Кажется приемлемым.

CS      0       17:11:52.100    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   [ 1000/1000 ] Loss = 0.05890808 | accuracy 0.615 
CS      0       17:11:52.101    Self Trained NN EA (NAS100,H4)  2023.01.03 01:00:00   Testing Accuracy =0.635