English
preview
Поиск торгового преимущества (Часть 5): Использование дисперсии GARCH и LSTM с масштабированием по волатильности в советнике

Поиск торгового преимущества (Часть 5): Использование дисперсии GARCH и LSTM с масштабированием по волатильности в советнике

MetaTrader 5 — Индикаторы |
51 0
Stephen Njuki
Stephen Njuki

Введение

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

Большинство торговых подходов сосредоточено на определении того, есть ли условия для входа. Гораздо меньше внимания уделяется более узкой задаче — выбору момента фактического входа при уже выявленных условиях для входа. Это различие может стать очень важным, когда цена переходит из относительно стабильного режима в режим, в котором набирает силу рост волатильности. Другими словами, даже точно выявленный пробой может привести к неудачной сделке, если вход выполнен слишком рано, слишком поздно или при ложном расширении волатильности.

Наш пользовательский класс торговых сигналов для этой статьи использует два модуля. Первый и основной модуль — модель GARCH(1,1), которая позволяет приблизительно оценить, растет ли волатильность цены в ближайшей перспективе относительно ее недавнего базового уровня. Второй, опциональный модуль — LSTM с масштабированием по волатильности — может затем оценивать короткую последовательность нормализованных состояний волатильности цены и вносить свой вклад в итоговую оценку вероятности входа. Работа обоих модулей определяется семью режимами: пробой, выход из сжатия, возврат внутрь полос Боллинджера, импульс, движение вдоль полосы, откат и выход из диапазона; при этом используются индикаторы на основе ATR, полос Боллинджера и ценовой динамики.

Мы выдвигаем достаточно скромное предположение. GARCH может помочь определить, возникают ли подходящие условия для входа в благоприятной рыночной обстановке, тогда как LSTM помогает описать, как сформировался этот режим. Однако возможна и противоположная ситуация: информация, которую дают ATR, полосы Боллинджера и GARCH, во многом дублируется, и сеть лишь добавляет сложности, не предоставляя полезной информации. Таким образом, в данном контексте быстрая проверка предполагает переключение между версиями «только алгоритм» и «алгоритм плюс сеть» и попытку подтвердить работоспособность обеих с помощью тестирования на исторических данных и форвардного тестирования.


Реализация на MQL5

Реализация эксперимента в виде класса торговых сигналов

Наш пользовательский класс наследуется от базового класса CExpertSignal, что позволяет Мастеру MQL5 использовать его в качестве компонента формирования сигналов входа в универсальном советнике. В этом эксперименте ключевую роль играют два входных параметра. При значении «ModelMode = 0» сохраняются детерминированная оценка паттерна и фильтр GARCH. При значении «ModelMode = 1» мы сохраняем ту же структуру, но объединяем её оценку с вероятностью, рассчитанной LSTM. Параметр «SignalMode» независимо выбирает один из семи вариантов интерпретации ATR, полос Боллинджера и ценовой динамики.

Такое разделение важно, поскольку не позволяет нейронной сети превратиться во вторую, не связанную с исходной стратегию. Таким образом, обе модели используют схожую логику определения направления по паттернам и обе должны проходить фильтр GARCH. Обе модели в итоге используют схожие интерфейсы голосования LongCondition() и ShortCondition(). Таким образом, сеть служит дополнительным слоем вычисления прогноза, а не заменой базового детерминированного алгоритма.

class CSignalGARCHLSTM : public CExpertSignal
  {
protected:
   CiATR              m_atr;
   CiBands            m_bands;

   int                m_model_mode;
   int                m_signal_mode;

   int                m_atr_period;
   int                m_bands_period;
   double             m_bands_deviation;
   ENUM_APPLIED_PRICE m_applied;
   int                m_pattern_lookback;

   int                m_garch_lookback;
   double             m_garch_alpha;
   double             m_garch_beta;
   double             m_garch_omega_scale;
   double             m_min_expansion;

   double             m_raw_gate;
   double             m_entry_threshold;

   int                m_forecast_horizon;
   int                m_lstm_sequence;
   int                m_lstm_hidden;
   int                m_lstm_samples;
   int                m_lstm_epochs;
   double             m_lstm_learning_rate;
   double             m_lstm_l2;
   double             m_lstm_weight;

        //----code gap

public:
                      CSignalGARCHLSTM(void);
                     ~CSignalGARCHLSTM(void) {}

   void               ModelMode(int value)                  { m_model_mode=value;           }
  
   //--- code gap---

   virtual bool       ValidationSettings(void);
   virtual bool       InitIndicators(CIndicators *indicators);
   virtual int        LongCondition(void);
   virtual int        ShortCondition(void);

protected:
   bool               InitATR(CIndicators *indicators);
   bool               InitBands(CIndicators *indicators);

   double             ATR(const int shift)          { return(m_atr.Main(shift));    }
   double             BandBase(const int shift)     { return(m_bands.Base(shift));  }
   double             BandUpper(const int shift)    { return(m_bands.Upper(shift)); }
   double             BandLower(const int shift)    { return(m_bands.Lower(shift)); }

   bool               ValidValue(const double value);
   

   //--- code gap---

   
bool               GARCHState(const int shift,double &forecast_variance,double &forecast_sigma,double &expansion_ratio);    double             VolatilityStrength(const int shift);    double             ModeScore(const int shift);    double             Mode0BreakoutExpansion(const int shift);    double             Mode1SqueezeRelease(const int shift);    double             Mode2BandReentry(const int shift);    double             Mode3MidBandImpulse(const int shift);    double             Mode4BandWalk(const int shift);    double             Mode5PullbackContinuation(const int shift);    double             Mode6RangeBreakout(const int shift);    bool               FeatureVector(const int shift,double &features[]);    void               InitializeLSTM(double &wx[],double &wh[],double &bias[],double &wy[],double &by);    bool               BuildSequence(const int shift,double &sequence[]);    double             LSTMForward(const double &sequence[],const double &wx[],const double &wh[],const double &bias[],const double &wy[],const double by);    void               TrainOneSequence(const double &sequence[],const double target,double &wx[],double &wh[],double &bias[],double &wy[],double &by);    double             LSTMProbability(const int shift);    double             ProbabilityUp(const int shift);   };

Используемый нами конструктор задаёт начальные, а не оптимальные значения входных параметров. Мы устанавливаем период ATR равным 14, задаём стандартные параметры полос Боллинджера 20/2.0 и используем для анализа ценовой динамики окно ретроспективного анализа длиной 12 баров. Кроме того, мы используем окно GARCH из 120 значений доходности и небольшую сеть LSTM с длиной последовательности 6 шагов, 64 примерами в скользящем окне и четырьмя скрытыми нейронами. Затем мы исключаем сочетания параметров, которые могут затруднить интерпретацию эксперимента. Наиболее важное ограничение модели GARCH заключается в следующем:

f5

Где альфа и бета — положительные величины. Наша цель здесь — удерживать персистентность ниже области значений, близких к единице, где шоки могут затухать настолько медленно, что «быстрый» прогноз волатильности становится сомнительным. Кроме того, проверки ограничивают горизонт прогнозирования, длину последовательности, размер скрытого состояния, порог вероятности, скорость обучения, а также веса сети.

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSignalGARCHLSTM::CSignalGARCHLSTM(void) :
   m_model_mode(0),
   m_signal_mode(0),
   m_atr_period(14),
   m_bands_period(20),
   m_bands_deviation(2.0),
   m_applied(PRICE_CLOSE),
   m_pattern_lookback(12),
   m_garch_lookback(120),
   m_garch_alpha(0.10),
   m_garch_beta(0.85),
   m_garch_omega_scale(1.0),
   m_min_expansion(1.02),
   m_raw_gate(0.06),
   m_entry_threshold(0.60),
   m_forecast_horizon(1),
   m_lstm_sequence(6),
   m_lstm_hidden(4),
   m_lstm_samples(64),
   m_lstm_epochs(1),
   m_lstm_learning_rate(0.01),
   m_lstm_l2(0.0005),
   m_lstm_weight(0.35),
   m_cache_time(0),
   m_lstm_model_time(0),
   m_lstm_model_ready(false),
   m_lstm_by(0.0),
   m_cache_raw(0.5),
   m_cache_expansion(1.0),
   m_cache_probability(0.5)
  {
   m_used_series=USE_SERIES_OPEN+USE_SERIES_HIGH+USE_SERIES_LOW+USE_SERIES_CLOSE+USE_SERIES_TIME;
  }

//+------------------------------------------------------------------+
//| Validate settings                                                |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::ValidationSettings(void)
  {
   if(!CExpertSignal::ValidationSettings())
      return(false);

   if(m_model_mode<0 || m_model_mode>1)
     {
      Print(__FUNCTION__+": ModelMode must be 0 or 1");
      return(false);
     }
   if(m_signal_mode<0 || m_signal_mode>6)
     {
      Print(__FUNCTION__+": SignalMode must be from 0 through 6");
      return(false);
     }
   if(m_atr_period<2 || m_bands_period<3 || m_bands_deviation<=0.0)
     {
      Print(__FUNCTION__+": invalid ATR/Bands parameters");
      return(false);
     }
   if(m_pattern_lookback<3)
     {
      Print(__FUNCTION__+": PatternLookback must be at least 3");
      return(false);
     }
   if(m_garch_lookback<30)
     {
      Print(__FUNCTION__+": GARCHLookback must be at least 30");
      return(false);
     }
   if(m_garch_alpha<=0.0 || m_garch_beta<=0.0 || m_garch_alpha+m_garch_beta>=0.995)
     {
      Print(__FUNCTION__+": GARCH coefficients require alpha>0, beta>0 and alpha+beta<0.995");
      return(false);
     }
   if(m_garch_omega_scale<=0.0)
     {
      Print(__FUNCTION__+": GARCHOmegaScale must be positive");
      return(false);
     }
   if(m_min_expansion<0.80 || m_min_expansion>2.00)
     {
      Print(__FUNCTION__+": MinExpansion must be in [0.80,2.00]");
      return(false);
     }
   if(m_raw_gate<0.0 || m_raw_gate>=0.50)
     {
      Print(__FUNCTION__+": RawGate must be in [0.00,0.50)");
      return(false);
     }
   if(m_entry_threshold<=0.50 || m_entry_threshold>=1.0)
     {
      Print(__FUNCTION__+": EntryThreshold must be in (0.50,1.00)");
      return(false);
     }
   if(m_forecast_horizon<1 || m_forecast_horizon>10)
     {
      Print(__FUNCTION__+": ForecastHorizon must be from 1 through 10");
      return(false);
     }
   if(m_lstm_sequence<2 || m_lstm_sequence>32 || m_lstm_hidden<1 || m_lstm_hidden>16)
     {
      Print(__FUNCTION__+": invalid LSTM sequence or hidden width");
      return(false);
     }
   if(m_lstm_samples<20 || m_lstm_epochs<1 || m_lstm_epochs>10)
     {
      Print(__FUNCTION__+": invalid LSTM sample/epoch settings");
      return(false);
     }
   if(m_lstm_learning_rate<=0.0 || m_lstm_learning_rate>0.25 || m_lstm_l2<0.0)
     {
      Print(__FUNCTION__+": invalid LSTM learning settings");
      return(false);
     }
   if(m_lstm_weight<0.0 || m_lstm_weight>1.0)
     {
      Print(__FUNCTION__+": LSTMWeight must be between 0 and 1");
      return(false);
     }

   return(true);
  }

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

//+------------------------------------------------------------------+
//| Initialize base indicators, then register and create ATR/Bands.  |
//| Use the supplied collection and the configured symbol/timeframe. |
//| Return false for a null collection                               |
//| or any initialization failure.                                   |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::InitIndicators(CIndicators *indicators)
  {
   if(indicators==NULL)
      return(false);
   if(!CExpertSignal::InitIndicators(indicators))
      return(false);
   if(!InitATR(indicators))
      return(false);
   if(!InitBands(indicators))
      return(false);
   return(true);
  }

//+------------------------------------------------------------------+
//| Register the member ATR indicator and create its data handle.    |
//| Use the current symbol/timeframe and configured ATR period.      |
//| Return false on null collection, registration or creation error. |
//| Log registration/creation failures; no local rollback is done.   |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::InitATR(CIndicators *indicators)
  {
   if(indicators==NULL)
      return(false);
   if(!indicators.Add(GetPointer(m_atr)))
     {
      Print(__FUNCTION__+": error adding ATR object");
      return(false);
     }
   if(!m_atr.Create(m_symbol.Name(),m_period,m_atr_period))
     {
      Print(__FUNCTION__+": error initializing ATR");
      return(false);
     }
   return(true);
  }

//+------------------------------------------------------------------+
//| Register and create Bollinger Bands with zero horizontal shift.  |
//| Use configured period, deviation,                                |
//| applied price and chart market.                                  |
//| Return false on null collection, registration or creation error. |
//| Log registration/creation failures; no local rollback is done.   |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::InitBands(CIndicators *indicators)
  {
   if(indicators==NULL)
      return(false);
   if(!indicators.Add(GetPointer(m_bands)))
     {
      Print(__FUNCTION__+": error adding Bands object");
      return(false);
     }
   if(!m_bands.Create(m_symbol.Name(),m_period,m_bands_period,0,m_bands_deviation,m_applied))
     {
      Print(__FUNCTION__+": error initializing Bollinger Bands");
      return(false);
     }
   return(true);
  }

От структуры рынка к показателям

Для преобразования исходных цен в величины с ограниченным диапазоном значений, которые можно объединять в общую оценку, используется набор вспомогательных функций. Для этого используются функции «Clamp()» и «Clamp01()», ограничивающие диапазон значений; «Sigmoid()» преобразует неограниченные значения в вероятности, а «SignedUnit()» помогает сжимать отношения с учётом знака. «CandleLocation()» определяет положение цены закрытия внутри ценового бара. Функция «BandWidth()» возвращает расстояние между верхней и нижней полосами Боллинджера, а «BandPosition()» — относительное положение цены закрытия в канале Боллинджера. Скользящие средние ATR и ширины полос Боллинджера задают локальные опорные уровни, а функция «RecentRange()» определяет верхнюю и нижнюю границы предшествующего диапазона, не позволяя текущему бару пробоя переопределять диапазон, из которого он выходит.

//+------------------------------------------------------------------+
//| Return true for a finite numeric value other than EMPTY_VALUE.   |
//| This check alone does not require a positive price or indicator. |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::ValidValue(const double value)
  {
   return(value!=EMPTY_VALUE && MathIsValidNumber(value));
  }

//+------------------------------------------------------------------+
//| Restrict a numeric value to the inclusive interval [lo,hi].      |
//| Assume ordered bounds; no missing-value validation is performed. |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Clamp(const double value,const double lo,const double hi)
  {
   if(value<lo) return(lo);
   if(value>hi) return(hi);
   return(value);
  }

//+------------------------------------------------------------------+
//| Restrict a numeric score to the inclusive interval [0,1].        |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Clamp01(const double value)
  {
   return(Clamp(value,0.0,1.0));
  }

//+------------------------------------------------------------------+
//| Map a logit to a logistic probability.                           |
//| Clamp the input to [-30,30] before evaluating the exponential.   |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Sigmoid(const double value)
  {
   double z=Clamp(value,-30.0,30.0);
   return(1.0/(1.0+MathExp(-z)));
  }

//+------------------------------------------------------------------+
//| Compress a signed value using value/(1+abs(value)).              |
//| Return zero for magnitudes at or below 1e-12.                    |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::SignedUnit(const double value)
  {
   double a=MathAbs(value);
   return(a<=1.0e-12 ? 0.0 : value/(1.0+a));
  }

//+------------------------------------------------------------------+
//| Locate the close within the high-low range of the shifted bar.   |
//| Return a score in [0,1], where 1 means a close at the high.      |
//| Return neutral 0.5 for invalid prices or a nonpositive range.    |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::CandleLocation(const int shift)
  {
   double h=High(shift),l=Low(shift),c=Close(shift);
   if(!ValidValue(h) || !ValidValue(l) || !ValidValue(c) || h<=l)
      return(0.5);
   return(Clamp01((c-l)/(h-l)));
  }

//+------------------------------------------------------------------+
//| Scale the close change over lookback bars by their price range.  |
//| Include the shifted bar and map the change around neutral 0.5.   |
//| Return 0.5 for bad closes/lookback                               |
//| or a range no larger than point.                                 |
//| Skip invalid older extremes; this helper is not called here.     |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::PriceMomentum(const int shift,const int lookback)
  {
   if(lookback<1)
      return(0.5);
   double c0=Close(shift),c1=Close(shift+lookback);
   if(!ValidValue(c0) || !ValidValue(c1))
      return(0.5);

   double highest=High(shift),lowest=Low(shift);
   for(int i=1;i<=lookback;i++)
     {
      double h=High(shift+i),l=Low(shift+i);
      if(ValidValue(h) && h>highest) highest=h;
      if(ValidValue(l) && l<lowest)  lowest=l;
     }
   double range=highest-lowest;
   if(range<=m_symbol.Point())
      return(0.5);
   return(Clamp01(0.5+0.5*(c0-c1)/range));
  }

//+------------------------------------------------------------------+
//| Return upper minus lower Bollinger Band at the requested shift.  |
//| Return zero for missing bands or a nonpositive channel width.    |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::BandWidth(const int shift)
  {
   double u=BandUpper(shift),l=BandLower(shift);
   if(!ValidValue(u) || !ValidValue(l) || u<=l)
      return(0.0);
   return(u-l);
  }

//+------------------------------------------------------------------+
//| Locate the close within the shifted Bollinger channel.           |
//| Clamp to [0,1]; closes beyond the channel saturate at its ends.  |
//| Return neutral 0.5 for invalid data or a nonpositive width.      |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::BandPosition(const int shift)
  {
   double u=BandUpper(shift),l=BandLower(shift),c=Close(shift);
   if(!ValidValue(u) || !ValidValue(l) || !ValidValue(c) || u<=l)
      return(0.5);
   return(Clamp01((c-l)/(u-l)));
  }

//+------------------------------------------------------------------+
//| Average valid positive ATR values from shift over lookback bars. |
//| Skip unusable samples; return zero                               |
//| if none or lookback is below 1.                                  |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::ATRMean(const int shift,const int lookback)
  {
   if(lookback<1)
      return(0.0);
   double sum=0.0;
   int count=0;
   for(int i=0;i<lookback;i++)
     {
      double v=ATR(shift+i);
      if(ValidValue(v) && v>0.0)
        {
         sum+=v;
         count++;
        }
     }
   return(count>0 ? sum/count : 0.0);
  }

//+------------------------------------------------------------------+
//| Average positive band widths from shift over lookback bars.      |
//| Skip unusable widths; return zero                                |
//| if none or lookback is below 1.                                  |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::BandWidthMean(const int shift,const int lookback)
  {
   if(lookback<1)
      return(0.0);
   double sum=0.0;
   int count=0;
   for(int i=0;i<lookback;i++)
     {
      double v=BandWidth(shift+i);
      if(v>0.0)
        {
         sum+=v;
         count++;
        }
     }
   return(count>0 ? sum/count : 0.0);
  }

//+------------------------------------------------------------------+
//| Write the high/low extremes of bars                              |
//| shift+1 through shift+lookback.                                  |
//| Exclude the query bar so it can be                               |
//| tested against the prior range.                                  |
//| Require lookback >= 2 and valid first extremes; skip later gaps. |
//| Return true only for a positive                                  |
//| range; failure may alter outputs.                                |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::RecentRange(const int shift,const int lookback,double &highest,double &lowest)
  {
   if(lookback<2)
      return(false);
   highest=High(shift+1);
   lowest =Low(shift+1);
   if(!ValidValue(highest) || !ValidValue(lowest))
      return(false);

   for(int i=2;i<=lookback;i++)
     {
      double h=High(shift+i),l=Low(shift+i);
      if(ValidValue(h) && h>highest) highest=h;
      if(ValidValue(l) && l<lowest)  lowest=l;
     }
   return(highest>lowest);
  }

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

GARCH в качестве фильтра волатильности

Наша функция «FeatureVector()» начинается с расчёта логарифмических доходностей:

f2

Затем эти значения центрируются путём вычитания скользящего среднего для получения остатков:

f3

Среднее квадратов остатков используется как реализованная дисперсия для инициализации рекурсии. С учётом персистентности (p = alpha + beta) постоянный член в нашей реализации рассчитывается следующим образом:

f4

После получения значения omega условная дисперсия последовательно обновляется по наблюдениям от более ранних к текущим:

f5

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

f6

Когда коэффициент расширения волатильности превышает единицу, это означает, что прогнозируемая условная волатильность выше скользящего базового уровня реализованной волатильности. Затем функция «VolatilityStrength()» преобразует это соотношение во вклад с ограниченным диапазоном значений, который можно объединить с признаками направления движения.

//+------------------------------------------------------------------+
//| GARCH(1,1) one-step variance forecast.                           |
//| Returns forecast sigma relative to rolling realized sigma.       |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::GARCHState(const int shift,double &forecast_variance,double &forecast_sigma,double &expansion_ratio)
  {
   forecast_variance=0.0;
   forecast_sigma=0.0;
   expansion_ratio=1.0;

   int n=m_garch_lookback;
   double mean=0.0;
   int count=0;

   for(int i=0;i<n;i++)
     {
      double c0=Close(shift+i),c1=Close(shift+i+1);
      if(!ValidValue(c0) || !ValidValue(c1) || c0<=0.0 || c1<=0.0)
         continue;
      mean+=MathLog(c0/c1);
      count++;
     }

   if(count<n/2 || count<20)
      return(false);
   mean/=count;

   double variance=0.0;
   for(int i=0;i<n;i++)
     {
      double c0=Close(shift+i),c1=Close(shift+i+1);
      if(!ValidValue(c0) || !ValidValue(c1) || c0<=0.0 || c1<=0.0)
         continue;
      double e=MathLog(c0/c1)-mean;
      variance+=e*e;
     }
   variance/=count;
   if(variance<=1.0e-16 || !MathIsValidNumber(variance))
      return(false);

   double persistence=m_garch_alpha+m_garch_beta;
   double omega=(1.0-persistence)*variance*m_garch_omega_scale;
   if(omega<1.0e-16)
      omega=1.0e-16;

   double h=variance;
   for(int i=n-1;i>=0;i--)
     {
      double c0=Close(shift+i),c1=Close(shift+i+1);
      if(!ValidValue(c0) || !ValidValue(c1) || c0<=0.0 || c1<=0.0)
         continue;
      double e=MathLog(c0/c1)-mean;
      h=omega+m_garch_alpha*e*e+m_garch_beta*h;
      if(h<=1.0e-16 || !MathIsValidNumber(h))
         h=variance;
     }

   forecast_variance=h;
   forecast_sigma=MathSqrt(h);
   expansion_ratio=forecast_sigma/MathSqrt(variance);

   return(ValidValue(forecast_sigma) && ValidValue(expansion_ratio));
  }

double CSignalGARCHLSTM::VolatilityStrength(const int shift)
  {
   double v,s,e;
   if(!GARCHState(shift,v,s,e))
      return(0.0);
   return(Clamp01((e-0.90)/0.40));
  }

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

Семь различных гипотез входа

В качестве диспетчера мы используем функцию «ModeScore()». Каждый режим возвращает оценку, медиана которой равна 0.5. Значение выше 0.5 указывает на бычье направление, а ниже 0.5 — на медвежье. Таким образом, наши режимы представляют собой 7 отдельных гипотез, для которых используется единая шкала оценки, а не семь голосов, по которым вычисляется среднее значение.

//+------------------------------------------------------------------+
//| Select one of seven independent signal interpretations.          |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::ModeScore(const int shift)
  {
   switch(m_signal_mode)
     {
      case 0: return(Mode0BreakoutExpansion(shift));
      case 1: return(Mode1SqueezeRelease(shift));
      case 2: return(Mode2BandReentry(shift));
      case 3: return(Mode3MidBandImpulse(shift));
      case 4: return(Mode4BandWalk(shift));
      case 5: return(Mode5PullbackContinuation(shift));
      case 6: return(Mode6RangeBreakout(shift));
     }
   return(0.5);
  }

Поскольку результат выражается оценкой по шкале, функция «ModeScore()» может отсеивать паттерны со слабыми подтверждающими признаками еще до подключения необязательной нейросети. Таким образом, LSTM должна превзойти не просто примитивный базовый алгоритм с булевым выходом. Она должна давать дополнительную пользу сверх уже имеющейся оценки уверенности.

Режим 0: пробой внешней полосы и расширение волатильности

В первом режиме работы мы проверяем, требует ли пробой ценой внешней полосы Боллинджера немедленного входа в рынок. Для потенциального бычьего сигнала необходимо, чтобы цена закрытия была выше верхней полосы и выше цены открытия. Для медвежьего сигнала условия зеркальны: цена закрытия должна быть ниже нижней полосы и ниже цены открытия. При сильном сигнале 35 % его оценки приходится на расстояние выхода цены за полосу, 25 % — на рост ATR, 20 % — на положение цены закрытия в диапазоне свечи и 20 % — на силу волатильности по GARCH.

//+------------------------------------------------------------------+
//| Mode 0: close breaks an outer band as ATR and GARCH expand.      |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode0BreakoutExpansion(const int shift)
  {
   double c=Close(shift),o=Open(shift),u=BandUpper(shift),l=BandLower(shift);
   double atr0=ATR(shift),atr1=ATR(shift+1),width=BandWidth(shift);
   if(!ValidValue(c) || !ValidValue(o) || !ValidValue(u) || !ValidValue(l) ||
      !ValidValue(atr0) || !ValidValue(atr1) || width<=0.0 || atr1<=0.0)
      return(0.5);

   double vol=VolatilityStrength(shift);
   double atr_rise=Clamp01((atr0/atr1-0.95)/0.35);
   double bull=0.0,bear=0.0;

   if(c>u && c>o)
      bull=0.35*Clamp01((c-u)/(0.25*width)+0.20)+0.25*atr_rise+0.20*CandleLocation(shift)+0.20*vol;
   if(c<l && c<o)
      bear=0.35*Clamp01((l-c)/(0.25*width)+0.20)+0.25*atr_rise+0.20*(1.0-CandleLocation(shift))+0.20*vol;

   return(Clamp01(0.5+0.5*(bull-bear)));
  }

Нам нужно определить не то, есть ли пробой, а то, происходит ли он в подходящий момент для входа в рынок. GARCH действует как манометр, а LSTM может анализировать, как формируется это состояние; если сеть не дает дополнительной пользы при форвардном тестировании, то данные о пробое полос ценой и показания ATR, возможно, уже содержат необходимую ключевую информацию.

Режим 1: Выход из сжатия

Наш второй режим начинается со сжатия. Предыдущее значение ширины полос Боллинджера должно быть меньше 85 % от ее скользящего среднего за более ранний период, после чего текущая ширина и ATR должны расти. При расчете оценки выходу из сжатия отводится вес 35 %, росту ATR — 25 %, GARCH — 20 %, а расстоянию от средней линии полос Боллинджера — 20 %. Направление определяется положением цены закрытия относительно этой средней линии.

//+------------------------------------------------------------------+
//| Mode 1: prior compression releases into widening bands.          |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode1SqueezeRelease(const int shift)
  {
   double w0=BandWidth(shift),w1=BandWidth(shift+1);
   double old_mean=BandWidthMean(shift+2,m_pattern_lookback);
   double atr0=ATR(shift),atr1=ATR(shift+1),base=BandBase(shift),c=Close(shift);
   if(w0<=0.0 || w1<=0.0 || old_mean<=0.0 || !ValidValue(atr0) || !ValidValue(atr1) ||
      !ValidValue(base) || !ValidValue(c) || atr1<=0.0)
      return(0.5);

   bool squeezed=(w1<0.85*old_mean);
   bool releasing=(w0>w1 && atr0>atr1);
   if(!squeezed || !releasing)
      return(0.5);

   double release=Clamp01((w0/w1-1.0)/0.35);
   double atr_rise=Clamp01((atr0/atr1-1.0)/0.30);
   double vol=VolatilityStrength(shift);
   double pos=BandPosition(shift);
   double strength=0.35*release+0.25*atr_rise+0.20*vol+0.20*MathAbs(2.0*pos-1.0);
   double direction=(c>=base ? 1.0 : -1.0);

   return(Clamp01(0.5+0.5*direction*strength));
  }

Полосы Боллинджера характеризуют сжатие, ATR — возобновление расширения ценового диапазона, GARCH — условную дисперсию, а LSTM — переход от сжатия к выходу из него. Однако все четыре инструмента могут по-разному оценивать одно и то же событие. Если удаление сети не ухудшает результаты форвардного тестирования, её самостоятельная ценность не подтверждается.

Режим 2: Возврат внутрь полос Боллинджера

В этом режиме идея пробоя меняется на противоположную. Мы определяем условия для входа на покупку: предыдущая цена закрытия находится ниже предыдущего значения нижней полосы, а текущая цена закрытия вновь оказывается выше нижней полосы. Для продажи логика, как и следовало ожидать, зеркальна: используется верхняя полоса. При расчете оценки глубине возврата внутрь полос Боллинджера отводится вес 35 %, положению цены закрытия в диапазоне свечи — 25 %, ATR относительно его недавнего среднего значения — 20 %, а силе волатильности по GARCH — 20 %.

//+------------------------------------------------------------------+
//| Mode 2: price returns inside a band after an outer excursion.    |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode2BandReentry(const int shift)
  {
   double c0=Close(shift),c1=Close(shift+1);
   double u0=BandUpper(shift),u1=BandUpper(shift+1),l0=BandLower(shift),l1=BandLower(shift+1);
   double atr0=ATR(shift),atr_mean=ATRMean(shift+1,m_pattern_lookback);
   if(!ValidValue(c0) || !ValidValue(c1) || !ValidValue(u0) || !ValidValue(u1) ||
      !ValidValue(l0) || !ValidValue(l1) || !ValidValue(atr0) || atr_mean<=0.0)
      return(0.5);

   double vol=VolatilityStrength(shift);
   double atr_state=Clamp01((atr0/atr_mean-0.80)/0.60);
   double bull=0.0,bear=0.0;

   if(c1<l1 && c0>l0)
      bull=0.35*Clamp01((c0-l0)/MathMax(BandWidth(shift)*0.25,m_symbol.Point()))+
           0.25*CandleLocation(shift)+0.20*atr_state+0.20*vol;
   if(c1>u1 && c0<u0)
      bear=0.35*Clamp01((u0-c0)/MathMax(BandWidth(shift)*0.25,m_symbol.Point()))+
           0.25*(1.0-CandleLocation(shift))+0.20*atr_state+0.20*vol;

   return(Clamp01(0.5+0.5*(bull-bear)));
  }

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

Режим 3: Импульс у средней линии

В четвертом режиме мы рассматриваем среднюю линию полос Боллинджера. Бычий сигнал возникает, когда цена переходит с уровня предыдущего значения средней линии полос Боллинджера или ниже него на уровень выше текущего значения этой линии. Медвежья логика зеркально противоположна описанной выше, а веса распределяются следующим образом: 35 % — на расстояние, на которое цена ушла за среднюю линию полос Боллинджера, 25 % — на рост ATR, 20 % — на положение цены закрытия в диапазоне свечи и 20 % — на силу GARCH.

//+------------------------------------------------------------------+
//| Mode 3: cross of the Bollinger basis with a range impulse.       |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode3MidBandImpulse(const int shift)
  {
   double c0=Close(shift),c1=Close(shift+1),b0=BandBase(shift),b1=BandBase(shift+1);
   double atr0=ATR(shift),atr1=ATR(shift+1),width=BandWidth(shift);
   if(!ValidValue(c0) || !ValidValue(c1) || !ValidValue(b0) || !ValidValue(b1) ||
      !ValidValue(atr0) || !ValidValue(atr1) || atr1<=0.0 || width<=0.0)
      return(0.5);

   double vol=VolatilityStrength(shift);
   double atr_rise=Clamp01((atr0/atr1-0.95)/0.30);
   double bull=0.0,bear=0.0;

   if(c1<=b1 && c0>b0)
      bull=0.35*Clamp01((c0-b0)/(0.25*width))+0.25*atr_rise+0.20*CandleLocation(shift)+0.20*vol;
   if(c1>=b1 && c0<b0)
      bear=0.35*Clamp01((b0-c0)/(0.25*width))+0.25*atr_rise+0.20*(1.0-CandleLocation(shift))+0.20*vol;

   return(Clamp01(0.5+0.5*(bull-bear)));
  }

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

Режим 4: Направленное движение вдоль полосы

Пятый режим оценивает персистентность на основе шести последних наблюдений. Бычьим признаком служат неоднократные закрытия выше средней линии полос Боллинджера при положении цены в канале выше 0.60. Медвежьи признаки зеркально противоположны: неоднократные закрытия ниже средней линии полос Боллинджера при положении цены в канале ниже 0.40. Примерно две трети наблюдений должны подтверждать одно и то же направление. Мы назначаем следующие веса: 45 % — персистентности, 20 % — среднему положению цены в канале, 15 % — состоянию ATR и 20 % — силе GARCH.

//+------------------------------------------------------------------+
//| Mode 4: persistent closes in one side of the volatility channel. |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode4BandWalk(const int shift)
  {
   int n=(m_pattern_lookback<6 ? m_pattern_lookback : 6);
   int bull_count=0,bear_count=0;
   double pos_sum=0.0;

   for(int i=0;i<n;i++)
     {
      double p=BandPosition(shift+i),c=Close(shift+i),b=BandBase(shift+i);
      if(!ValidValue(c) || !ValidValue(b))
         return(0.5);
      pos_sum+=p;
      if(c>b && p>0.60) bull_count++;
      if(c<b && p<0.40) bear_count++;
     }

   double atr0=ATR(shift),atr_mean=ATRMean(shift+1,n);
   if(!ValidValue(atr0) || atr_mean<=0.0)
      return(0.5);

   double persistence_bull=(double)bull_count/n;
   double persistence_bear=(double)bear_count/n;
   double atr_state=Clamp01((atr0/atr_mean-0.85)/0.50);
   double vol=VolatilityStrength(shift);
   double mean_pos=pos_sum/n;
   double bull=0.0,bear=0.0;

   if(persistence_bull>=0.66)
      bull=0.45*persistence_bull+0.20*Clamp01((mean_pos-0.50)/0.40)+0.15*atr_state+0.20*vol;
   if(persistence_bear>=0.66)
      bear=0.45*persistence_bear+0.20*Clamp01((0.50-mean_pos)/0.40)+0.15*atr_state+0.20*vol;

   return(Clamp01(0.5+0.5*(bull-bear)));
  }

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

Режим 5: Продолжение тренда после отката

В этом режиме средняя линия полос Боллинджера рассматривается как ось тренда. Наклон средней линии полос Боллинджера и расстояние от предыдущей цены закрытия до этой линии нормируются по текущей ширине канала, так что обе величины выражены в одном масштабе. Мы считаем условия для входа бычьими, если средняя линия полос Боллинджера имеет положительный наклон, цена закрытия ранее откатилась к ней, а теперь цена вновь движется выше как этой линии, так и предыдущей цены закрытия. Медвежья логика симметрична. Мы назначаем следующие веса: 35 % — наклону средней линии полос Боллинджера, 25 % — качеству отката, 20 % — ускорению ATR и 20 % — силе GARCH.

//+------------------------------------------------------------------+
//| Mode 5: basis pullback in a trending volatility channel.         |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode5PullbackContinuation(const int shift)
  {
   double b0=BandBase(shift),b1=BandBase(shift+1),b2=BandBase(shift+2);
   double c0=Close(shift),c1=Close(shift+1),w0=BandWidth(shift);
   double atr0=ATR(shift),atr1=ATR(shift+1);
   if(!ValidValue(b0) || !ValidValue(b1) || !ValidValue(b2) || !ValidValue(c0) ||
      !ValidValue(c1) || !ValidValue(atr0) || !ValidValue(atr1) || w0<=0.0 || atr1<=0.0)
      return(0.5);

   double slope=(b0-b2)/w0;
   double pullback=MathAbs(c1-b1)/w0;
   double atr_rise=Clamp01((atr0/atr1-0.95)/0.30);
   double vol=VolatilityStrength(shift);
   double bull=0.0,bear=0.0;

   if(slope>0.02 && pullback<0.20 && c0>b0 && c0>c1)
      bull=0.35*Clamp01(slope/0.20)+0.25*Clamp01((0.20-pullback)/0.20)+0.20*atr_rise+0.20*vol;
   if(slope<-0.02 && pullback<0.20 && c0<b0 && c0<c1)
      bear=0.35*Clamp01((-slope)/0.20)+0.25*Clamp01((0.20-pullback)/0.20)+0.20*atr_rise+0.20*vol;

   return(Clamp01(0.5+0.5*(bull-bear)));
  }

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

Режим 6: Пробой недавнего диапазона

В последнем режиме диапазон между максимумом и минимумом строится по барам, предшествующим сигнальному бару. Для потенциального бычьего сигнала требуется закрытие выше максимума предыдущих баров при положении цены в канале полос Боллинджера выше 0.70; для медвежьего — закрытие ниже минимума при положении цены в канале ниже 0.30. При взвешивании расстоянию выхода за границу диапазона отводится 35 %, увеличению ширины полос Боллинджера — 20 %, росту ATR — 20 %, а силе волатильности по GARCH — 25 %.

//+------------------------------------------------------------------+
//| Mode 6: close breaks the recent price range while bands widen.   |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::Mode6RangeBreakout(const int shift)
  {
   double highest,lowest;
   if(!RecentRange(shift,m_pattern_lookback,highest,lowest))
      return(0.5);

   double c=Close(shift),w0=BandWidth(shift),w1=BandWidth(shift+1);
   double atr0=ATR(shift),atr1=ATR(shift+1),pos=BandPosition(shift);
   if(!ValidValue(c) || w0<=0.0 || w1<=0.0 || !ValidValue(atr0) || !ValidValue(atr1) || atr1<=0.0)
      return(0.5);

   double band_expand=Clamp01((w0/w1-0.95)/0.35);
   double atr_rise=Clamp01((atr0/atr1-0.95)/0.35);
   double vol=VolatilityStrength(shift);
   double bull=0.0,bear=0.0;

   if(c>highest && pos>0.70)
      bull=0.35*Clamp01((c-highest)/(0.20*w0)+0.20)+0.20*band_expand+0.20*atr_rise+0.25*vol;
   if(c<lowest && pos<0.30)
      bear=0.35*Clamp01((lowest-c)/(0.20*w0)+0.20)+0.20*band_expand+0.20*atr_rise+0.25*vol;

   return(Clamp01(0.5+0.5*(bull-bear)));
  }

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

LSTM с масштабированием по волатильности

На вход LSTM оценка выбранного режима напрямую не подаётся. Вместо этого функция «FeatureVector()» формирует шесть входных признаков: логарифмическую доходность, масштабированную по сигме GARCH; ATR относительно волатильности цены, подразумеваемой моделью GARCH; положение цены в канале полос Боллинджера; ширину полос Боллинджера относительно ATR; коэффициент расширения волатильности GARCH относительно единицы; ускорение ATR за один бар.

//+------------------------------------------------------------------+
//| Volatility-scaled LSTM feature vector.                           |
//| Features are bounded to approximately [-1,1].                    |
//+------------------------------------------------------------------+
bool CSignalGARCHLSTM::FeatureVector(const int shift,double &features[])
  {
   ArrayResize(features,GARCHLSTM_FEATURES);

   double variance,sigma,expansion;
   if(!GARCHState(shift,variance,sigma,expansion) || sigma<=0.0)
      return(false);

   double c0=Close(shift),c1=Close(shift+1);
   double atr0=ATR(shift),atr1=ATR(shift+1);
   double width=BandWidth(shift);
   double pos=BandPosition(shift);
   if(!ValidValue(c0) || !ValidValue(c1) || c0<=0.0 || c1<=0.0 ||
      !ValidValue(atr0) || !ValidValue(atr1) || atr0<=0.0 || atr1<=0.0 || width<=0.0)
      return(false);

   double r=MathLog(c0/c1);
   double sigma_price=sigma*c0;
   if(sigma_price<=m_symbol.Point())
      sigma_price=m_symbol.Point();

   features[0]=Clamp(r/(3.0*sigma),-1.0,1.0);
   features[1]=SignedUnit(atr0/sigma_price-1.0);
   features[2]=Clamp(2.0*pos-1.0,-1.0,1.0);
   features[3]=SignedUnit(width/(4.0*atr0)-1.0);
   features[4]=Clamp((expansion-1.0)/0.35,-1.0,1.0);
   features[5]=Clamp((atr0/atr1-1.0)/0.35,-1.0,1.0);

   return(true);
  }

Именно поэтому сеть называется «LSTM с масштабированием по волатильности». Вместо обучения на исходных уровнях цены GBPJPY мы в основном используем наблюдения, выраженные относительно текущей волатильности. Таким образом, в спокойные периоды подобные состояния могут выглядеть схожими с точки зрения числовых показателей. Недостаток столь же очевиден: большинство признаков формируется на основе тех же данных GARCH, ATR и полос Боллинджера, которые уже использует алгоритм. Главный аргумент в пользу дополнительной ценности сети — не новая информация, а учёт временной последовательности уже имеющейся информации.

Состояние, вентили и обучение LSTM

Наша функция «InitializeLSTM()» использует детерминированные начальные веса, вычисляемые с помощью синуса и косинуса, чтобы прогоны в тестере стратегий могли начинаться из одного и того же состояния. Затем функция «BuildSequence()» упорядочивает наблюдения с шестью признаками каждое от самых старых к самым новым.

//+------------------------------------------------------------------+
//| Deterministic LSTM initialization for repeatable tester runs.    |
//+------------------------------------------------------------------+
void CSignalGARCHLSTM::InitializeLSTM(double &wx[],double &wh[],double &bias[],double &wy[],double &by)
  {
   int h=m_lstm_hidden;
   int f=GARCHLSTM_FEATURES;
   ArrayResize(wx,4*h*f);
   ArrayResize(wh,4*h*h);
   ArrayResize(bias,4*h);
   ArrayResize(wy,h);

   for(int i=0;i<ArraySize(wx);i++)
      wx[i]=0.10*MathSin(0.731*(i+1));
   for(int i=0;i<ArraySize(wh);i++)
      wh[i]=0.07*MathCos(0.517*(i+1));
   for(int i=0;i<ArraySize(bias);i++)
      bias[i]=0.0;
   for(int j=0;j<h;j++)
      bias[j]=0.50;
   for(int j=0;j<h;j++)
      wy[j]=0.10*MathSin(0.389*(j+1));
   by=0.0;
  }

bool CSignalGARCHLSTM::BuildSequence(const int shift,double &sequence[])
  {
   int tmax=m_lstm_sequence;
   int f=GARCHLSTM_FEATURES;
   ArrayResize(sequence,tmax*f);

   for(int t=0;t<tmax;t++)
     {
      int src_shift=shift+(tmax-1-t);
      double x[];
      if(!FeatureVector(src_shift,x))
         return(false);
      for(int k=0;k<f;k++)
         sequence[t*f+k]=x[k];
     }
   return(true);
  }

При прямом проходе вентили LSTM вычисляются следующим образом:

f7,

f8,

f9,

f10,

далее:

f11

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

//+------------------------------------------------------------------+
//| LSTM forward pass.                                               |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::LSTMForward(const double &sequence[],const double &wx[],const double &wh[],const double &bias[],const double &wy[],const double by)
  {
   int hsz=m_lstm_hidden;
   int fsz=GARCHLSTM_FEATURES;
   int tmax=m_lstm_sequence;

   double h[],c[],hn[],cn[];
   ArrayResize(h,hsz);  ArrayInitialize(h,0.0);
   ArrayResize(c,hsz);  ArrayInitialize(c,0.0);
   ArrayResize(hn,hsz); ArrayInitialize(hn,0.0);
   ArrayResize(cn,hsz); ArrayInitialize(cn,0.0);

   for(int t=0;t<tmax;t++)
     {
      for(int j=0;j<hsz;j++)
        {
         double zf=bias[0*hsz+j];
         double zi=bias[1*hsz+j];
         double zo=bias[2*hsz+j];
         double zg=bias[3*hsz+j];

         for(int k=0;k<fsz;k++)
           {
            double x=sequence[t*fsz+k];
            zf+=wx[(0*hsz+j)*fsz+k]*x;
            zi+=wx[(1*hsz+j)*fsz+k]*x;
            zo+=wx[(2*hsz+j)*fsz+k]*x;
            zg+=wx[(3*hsz+j)*fsz+k]*x;
           }
         for(int k=0;k<hsz;k++)
           {
            zf+=wh[(0*hsz+j)*hsz+k]*h[k];
            zi+=wh[(1*hsz+j)*hsz+k]*h[k];
            zo+=wh[(2*hsz+j)*hsz+k]*h[k];
            zg+=wh[(3*hsz+j)*hsz+k]*h[k];
           }

         double gf=Sigmoid(zf);
         double gi=Sigmoid(zi);
         double go=Sigmoid(zo);
         double gg=MathTanh(Clamp(zg,-20.0,20.0));
         cn[j]=gf*c[j]+gi*gg;
         hn[j]=go*MathTanh(cn[j]);
        }
      for(int j=0;j<hsz;j++)
        {
         h[j]=hn[j];
         c[j]=cn[j];
        }
     }

   double z=by;
   for(int j=0;j<hsz;j++)
      z+=wy[j]*h[j];
   return(Clamp(Sigmoid(z),0.01,0.99));
  }

Функция «TrainOneSequence()» сохраняет значения вентилей, скрытого состояния и состояния ячейки, необходимые для обратного распространения ошибки во времени. Сначала ошибка вычисляется как «p-target»; затем методом обратного распространения ошибки вычисляются градиенты, их значения ограничиваются заданным диапазоном, после чего с использованием «LSTMLearningRate» применяется L2-регуляризация.

//+------------------------------------------------------------------+
//| One full BPTT update over one short sequence.                    |
//+------------------------------------------------------------------+
void CSignalGARCHLSTM::TrainOneSequence(const double &sequence[],const double target,double &wx[],double &wh[],double &bias[],double &wy[],double &by)
  {
   int hsz=m_lstm_hidden;
   int fsz=GARCHLSTM_FEATURES;
   int tmax=m_lstm_sequence;

   double hh[],cc[],gates[];
   ArrayResize(hh,(tmax+1)*hsz); ArrayInitialize(hh,0.0);
   ArrayResize(cc,(tmax+1)*hsz); ArrayInitialize(cc,0.0);
   ArrayResize(gates,tmax*4*hsz); ArrayInitialize(gates,0.0);

   for(int t=0;t<tmax;t++)
     {
      for(int j=0;j<hsz;j++)
        {
         double zf=bias[0*hsz+j],zi=bias[1*hsz+j],zo=bias[2*hsz+j],zg=bias[3*hsz+j];
         for(int k=0;k<fsz;k++)
           {
            double x=sequence[t*fsz+k];
            zf+=wx[(0*hsz+j)*fsz+k]*x;
            zi+=wx[(1*hsz+j)*fsz+k]*x;
            zo+=wx[(2*hsz+j)*fsz+k]*x;
            zg+=wx[(3*hsz+j)*fsz+k]*x;
           }
         for(int k=0;k<hsz;k++)
           {
            double hp=hh[t*hsz+k];
            zf+=wh[(0*hsz+j)*hsz+k]*hp;
            zi+=wh[(1*hsz+j)*hsz+k]*hp;
            zo+=wh[(2*hsz+j)*hsz+k]*hp;
            zg+=wh[(3*hsz+j)*hsz+k]*hp;
           }

         double gf=Sigmoid(zf),gi=Sigmoid(zi),go=Sigmoid(zo),gg=MathTanh(Clamp(zg,-20.0,20.0));
         gates[(t*4+0)*hsz+j]=gf;
         gates[(t*4+1)*hsz+j]=gi;
         gates[(t*4+2)*hsz+j]=go;
         gates[(t*4+3)*hsz+j]=gg;

         double cp=cc[t*hsz+j];
         double cn=gf*cp+gi*gg;
         cc[(t+1)*hsz+j]=cn;
         hh[(t+1)*hsz+j]=go*MathTanh(cn);
        }
     }

   double z=by;
   for(int j=0;j<hsz;j++) z+=wy[j]*hh[tmax*hsz+j];
   double p=Sigmoid(z);
   double dz=p-target;

   double gwx[],gwh[],gb[],gwy[];
   ArrayResize(gwx,ArraySize(wx));   ArrayInitialize(gwx,0.0);
   ArrayResize(gwh,ArraySize(wh));   ArrayInitialize(gwh,0.0);
   ArrayResize(gb,ArraySize(bias));  ArrayInitialize(gb,0.0);
   ArrayResize(gwy,hsz);             ArrayInitialize(gwy,0.0);

   for(int j=0;j<hsz;j++)
      gwy[j]=dz*hh[tmax*hsz+j];
   double gby=dz;

   double dh_next[],dc_next[],dh_prev[],dc_prev[],dgates[];
   ArrayResize(dh_next,hsz); ArrayInitialize(dh_next,0.0);
   ArrayResize(dc_next,hsz); ArrayInitialize(dc_next,0.0);
   ArrayResize(dh_prev,hsz); ArrayInitialize(dh_prev,0.0);
   ArrayResize(dc_prev,hsz); ArrayInitialize(dc_prev,0.0);
   ArrayResize(dgates,4*hsz); ArrayInitialize(dgates,0.0);

   for(int t=tmax-1;t>=0;t--)
     {
      ArrayInitialize(dh_prev,0.0);
      ArrayInitialize(dc_prev,0.0);
      ArrayInitialize(dgates,0.0);

      for(int j=0;j<hsz;j++)
        {
         double gf=gates[(t*4+0)*hsz+j];
         double gi=gates[(t*4+1)*hsz+j];
         double go=gates[(t*4+2)*hsz+j];
         double gg=gates[(t*4+3)*hsz+j];
         double ccur=cc[(t+1)*hsz+j];
         double cprev=cc[t*hsz+j];
         double tanhc=MathTanh(ccur);

         double dh=dh_next[j];
         if(t==tmax-1)
            dh+=dz*wy[j];

         double dgo=dh*tanhc;
         double dc=dc_next[j]+dh*go*(1.0-tanhc*tanhc);
         double dgf=dc*cprev;
         double dgi=dc*gg;
         double dgg=dc*gi;

         dc_prev[j]=dc*gf;
         dgates[0*hsz+j]=dgf*gf*(1.0-gf);
         dgates[1*hsz+j]=dgi*gi*(1.0-gi);
         dgates[2*hsz+j]=dgo*go*(1.0-go);
         dgates[3*hsz+j]=dgg*(1.0-gg*gg);
        }

      for(int g=0;g<4;g++)
        {
         for(int j=0;j<hsz;j++)
           {
            double d=Clamp(dgates[g*hsz+j],-5.0,5.0);
            gb[g*hsz+j]+=d;
            for(int k=0;k<fsz;k++)
               gwx[(g*hsz+j)*fsz+k]+=d*sequence[t*fsz+k];
            for(int k=0;k<hsz;k++)
              {
               gwh[(g*hsz+j)*hsz+k]+=d*hh[t*hsz+k];
               dh_prev[k]+=d*wh[(g*hsz+j)*hsz+k];
              }
           }
        }

      for(int j=0;j<hsz;j++)
        {
         dh_next[j]=Clamp(dh_prev[j],-5.0,5.0);
         dc_next[j]=Clamp(dc_prev[j],-5.0,5.0);
        }
     }

   double lr=m_lstm_learning_rate;
   for(int i=0;i<ArraySize(wx);i++)
      wx[i]-=lr*(Clamp(gwx[i],-5.0,5.0)+m_lstm_l2*wx[i]);
   for(int i=0;i<ArraySize(wh);i++)
      wh[i]-=lr*(Clamp(gwh[i],-5.0,5.0)+m_lstm_l2*wh[i]);
   for(int i=0;i<ArraySize(bias);i++)
      bias[i]-=lr*Clamp(gb[i],-5.0,5.0);
   for(int j=0;j<hsz;j++)
      wy[j]-=lr*(Clamp(gwy[j],-5.0,5.0)+m_lstm_l2*wy[j]);
   by-=lr*Clamp(gby,-5.0,5.0);
  }

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

Метки в скользящем окне и голосование в Мастере MQL5

Функция «LSTMProbability()» помогает обучать модель на прошлых наблюдениях, для которых метки будущего результата уже известны. При работе с текущим баром обучение выполняется один раз — в начале нового ценового бара. На последующих тиках текущего бара выполняется только прямой проход с учётом изменения входных признаков. Бинарная целевая метка указывает, закроется ли цена через «ForecastHorizon» баров выше исходной цены закрытия.

//+------------------------------------------------------------------+
//| Rolling, leakage-safe LSTM probability of an upward move.        |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::LSTMProbability(const int shift)
  {
   // For the incomplete current bar, train only once when a new bar
   // starts, using fully closed historical labels. Each incoming tick
   // then performs only a forward pass with the evolving current input.
   if(shift==0)
     {
      datetime stamp=Time(0);
      if(stamp==0)
         return(0.5);

      if(!m_lstm_model_ready || stamp!=m_lstm_model_time)
        {
         InitializeLSTM(m_lstm_wx,m_lstm_wh,m_lstm_bias,m_lstm_wy,m_lstm_by);
         int first=1+m_forecast_horizon;
         int last=first+m_lstm_samples-1;
         int trained=0;

         for(int epoch=0;epoch<m_lstm_epochs;epoch++)
           {
            for(int s=last;s>=first;s--)
              {
               double start_price=Close(s);
               double future_price=Close(s-m_forecast_horizon);
               if(!ValidValue(start_price) || !ValidValue(future_price))
                  continue;

               double seq[];
               if(!BuildSequence(s,seq))
                  continue;

               double target=(future_price>start_price ? 1.0 : 0.0);
               TrainOneSequence(seq,target,m_lstm_wx,m_lstm_wh,m_lstm_bias,m_lstm_wy,m_lstm_by);
               trained++;
              }
           }

         m_lstm_model_ready=(trained>=m_lstm_samples/2);
         m_lstm_model_time=stamp;
        }

      if(!m_lstm_model_ready)
         return(0.5);

      double query[];
      if(!BuildSequence(0,query))
         return(0.5);
      return(LSTMForward(query,m_lstm_wx,m_lstm_wh,m_lstm_bias,m_lstm_wy,m_lstm_by));
     }

   // Historical shifts are trained from a deterministic rolling window.
   double wx[],wh[],bias[],wy[],by;
   InitializeLSTM(wx,wh,bias,wy,by);

   int first=shift+m_forecast_horizon;
   int last=first+m_lstm_samples-1;
   int trained=0;

   for(int epoch=0;epoch<m_lstm_epochs;epoch++)
     {
      for(int s=last;s>=first;s--)
        {
         double start_price=Close(s);
         double future_price=Close(s-m_forecast_horizon);
         if(!ValidValue(start_price) || !ValidValue(future_price))
            continue;

         double seq[];
         if(!BuildSequence(s,seq))
            continue;

         double target=(future_price>start_price ? 1.0 : 0.0);
         TrainOneSequence(seq,target,wx,wh,bias,wy,by);
         trained++;
        }
     }

   if(trained<m_lstm_samples/2)
      return(0.5);

   double query[];
   if(!BuildSequence(shift,query))
      return(0.5);
   return(LSTMForward(query,wx,wh,bias,wy,by));
  }

Функция «ProbabilityUp()» вновь объединяет два наших механизма: при «ModelMode=0» используется только оценка режима. Однако при «ModelMode=1» мы смешиваем эту оценку с выходом нейросети:

f12

где (w) — «вес LSTM».

//+------------------------------------------------------------------+
//| Final upward entry score.                                        |
//+------------------------------------------------------------------+
double CSignalGARCHLSTM::ProbabilityUp(const int shift)
  {
   datetime stamp=Time(shift);
   // Do not bar-cache shift 0: EveryTick Wizard experts must be able
   // to react as the current bar and conditional variance evolve.
   if(shift>0 && stamp!=0 && stamp==m_cache_time)
      return(m_cache_probability);

   double raw=ModeScore(shift);
   double variance,sigma,expansion;
   if(!GARCHState(shift,variance,sigma,expansion))
      return(0.5);

   double probability=raw;
   if(m_model_mode==1)
     {
      double p_lstm=LSTMProbability(shift);
      probability=(1.0-m_lstm_weight)*raw+m_lstm_weight*p_lstm;
     }

   probability=Clamp(probability,0.01,0.99);
   if(shift>0)
      m_cache_time=stamp;
   else
      m_cache_time=0;
   m_cache_raw=raw;
   m_cache_expansion=expansion;
   m_cache_probability=probability;
   return(probability);
  }

Наконец, функции «LongCondition()» и «ShortCondition()» проверяют три условия допуска к сделке. Коэффициент расширения волатильности по GARCH должен превышать «MinExpansion»; отклонение исходной оценки паттерна от нейтрального значения 0.5 должно достигать порога «RawGate» в соответствующем направлении; а итоговая вероятность — «EntryThreshold». Система LSTM не может открыть сделку, если выбранный паттерн не подтверждает её целесообразность. Аналогично ни один из выбранных режимов не может обойти фильтр волатильности.

//+------------------------------------------------------------------+
//| Vote that price will rise.                                       |
//+------------------------------------------------------------------+
int CSignalGARCHLSTM::LongCondition(void)
  {
   int result=0;
   int idx=StartIndex();

   double variance,sigma,expansion;
   if(!GARCHState(idx,variance,sigma,expansion) || expansion<m_min_expansion)
      return(result);

   double raw=ModeScore(idx);
   if(!ValidValue(raw) || raw<0.5+m_raw_gate)
      return(result);

   double probability=ProbabilityUp(idx);
   if(probability<m_entry_threshold)
      return(result);

   result=(int)MathRound(100.0*probability);
   return(result);
  }

//+------------------------------------------------------------------+
//| Vote that price will fall.                                       |
//+------------------------------------------------------------------+
int CSignalGARCHLSTM::ShortCondition(void)
  {
   int result=0;
   int idx=StartIndex();

   double variance,sigma,expansion;
   if(!GARCHState(idx,variance,sigma,expansion) || expansion<m_min_expansion)
      return(result);

   double raw=ModeScore(idx);
   if(!ValidValue(raw) || raw>0.5-m_raw_gate)
      return(result);

   double probability_down=1.0-ProbabilityUp(idx);
   if(probability_down<m_entry_threshold)
      return(result);

   result=(int)MathRound(100.0*probability_down);
   return(result);
  }

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


Тестирование после оптимизации

Быстрое сканирование

Можно сказать, что оптимизация приносит наибольшую пользу, если проводится поэтапно. При «ModelMode=0» сначала можно провести предварительную оценку семи режимов и общих входных параметров ATR, полос Боллинджера и GARCH. К исследованию настроек LSTM можно переходить лишь после того, как удастся найти работоспособный базовый алгоритм. Наша цель — область близких друг к другу приемлемых настроек, а не одна «исключительная точка». Изолированный резкий пик на поверхности оптимизации может указывать на ненадёжность найденных настроек. Ниже мы приводим результаты отдельных прогонов стратегии, а не «полные поверхности оптимизации». Таким образом, они показывают поведение стратегии при тестировании на исторических данных и форвардном тестировании, но не позволяют судить, относятся ли выбранные входные параметры к некоторой общей закономерности и можно ли поэтому на них полагаться. Необходимы дополнительные независимые тесты и тщательная проверка.

От оптимизации к сравнению

Мы проводим тестирование на паре GBPJPY на 4-часовом таймфрейме со стартовым депозитом в размере 10 000 долларов США и кредитным плечом 1:100. Мы проводим тестирование как с использованием LSTM, так и без него, и в обоих случаях выбираем третий режим (SignalMode=2). Этот режим основан на возврате внутрь полос Боллинджера. Его основные параметры: период ATR — 35; период полос Боллинджера — 10, отклонение — 2; окно ретроспективного анализа паттерна — 18; окно ретроспективного анализа GARCH — 240; альфа — 0.10; бета — 0.73; масштаб омеги — 1.25; минимальный коэффициент расширения волатильности (Min Expansion) — 1.05; порог исходной оценки паттерна (Raw Gate) — 0.12; порог входа — 0.65.

В варианте с нейросетью параметр 'ModelMode' переключается с 0 на 1 и используются собственные настройки LSTM, которые становятся активными в этом режиме. К ним относятся: горизонт прогнозирования — 3; длина последовательности — 4; размер скрытого состояния — 2; число образцов в скользящем окне — 128; скорость обучения — 0.015; коэффициент L2-регуляризации — 0.001; LSTMWeight — 0.15. Перечисленные выше входные параметры, связанные с LSTM, неактивны, когда режим модели равен 0. При проведении этих двух тестов мы использовали параметры 'Signal_PriceLevel=28', 'Signal_TakeLevel=153.5', 'Signal_Expiration=117' и не устанавливали стоп-лосс. Таким образом, наш модуль торговых сигналов размещает отложенные лимитные ордера вместо немедленного исполнения сделки на том тике, на котором появился сигнал. Отчеты позволяют проверить, дает ли прогнозный модуль улучшение результатов в рамках системы исполнения, созданной с помощью Мастера MQL5. Мы не ставим целью провести эксперимент исключительно с рыночными ордерами и входом точно на тике появления сигнала. Исполнение отложенных ордеров и истечение срока их действия сами по себе могут влиять на то, какие сигналы приведут к сделкам.

В рамках этой оптимизации участок тестирования на исторических данных охватывал период с 1 января 2025 года по 19 января 2026 года. Форвардное тестирование проводилось на участке с 20 января 2026 года по 31 июля 2026 года. В ходе тестирования на исторических данных с выбранными «идеальными» настройками было охвачено 1622 бара H4 и около 1.54 млн тиков. Форвардное тестирование охватило 795 тыс. тиков, при этом общее число сделок было относительно небольшим. Как видно на приведенных выше изображениях, тестирование на исторических данных с использованием только базового детерминированного алгоритма принесло нам 22 тыс. долларов США по итогам 36 сделок. Если начать со сравнения результатов тестирования на исторических данных для двух вариантов, то без LSTM профит-фактор составил 2.70, коэффициент Шарпа — 3.28, а фактор восстановления — 2.66. 28 из 36 сделок оказались прибыльными, то есть доля прибыльных сделок составила 77.78 %. Максимальная просадка средств составила 8625.41 доллара США (22.02 %).

После включения LSTM число сделок по-прежнему составляло 36, а количество убыточных и прибыльных сделок было примерно таким же, как в варианте без LSTM. Однако чистая прибыль снизилась до 19 613 долларов США, профит-фактор — до 2.25, коэффициент Шарпа — до 2.99, а фактор восстановления также немного снизился — до 2.53. Основным улучшением, вероятно, стало сокращение просадки средств в долларовом выражении до 7751.17 доллара США, однако в процентах она практически не изменилась и составила 22.01 %. С внедрением LSTM валовые убытки также увеличились. История ордеров показывает, почему сводная статистика сама по себе может вводить в заблуждение. На протяжении большей части этого периода тестирования на исторических данных число сделок в обоих прогонах было примерно одинаковым, и, по-видимому, существенные различия наблюдались лишь в октябре 2025 года.

Форвардное тестирование

Тест, в котором использовался только алгоритм, показал чистую прибыль в размере 11 897.19 долларов США по результатам 22 сделок. Профит-фактор составляет 2.88, коэффициент Шарпа — 3.53, а фактор восстановления — 3.24. Восемнадцать сделок оказались прибыльными; доля прибыльных сделок составила 81.82 %. Максимальная просадка средств составила 3 677.6 доллара США, или 14.50 %.

r1

c1

Алгоритм в сочетании с сетью сохраняет прибыльность, что является хорошим признаком. Однако, как и при тестировании на исторических данных, мы отстаем от базового детерминированного алгоритма без сети. Наша чистая прибыль составила 10 437.71 доллара США по результатам 21 сделки; профит-фактор составил 2.73, коэффициент Шарпа — 3.11, а фактор восстановления — 3.02. Все эти показатели уступают показателям базового алгоритма. Доля прибыльных сделок составила 81 %, но есть один нюанс. Хотя просадка средств в долларовом выражении оказалась меньше, чем у базового алгоритма, и составила 3 454.09 доллара США, в процентном выражении она была немного выше — 14.58 %.

r2

c2

Этот отчет, по-видимому, представляет собой почти хрестоматийный пример опровержения гипотезы о преимуществе LSTM. Сеть должна была повысить точность отбора среди допустимых условий для входа при возврате внутрь полос Боллинджера. На этой форвардной выборке сеть отклоняет как минимум один случай, когда условия для входа позволяют базовому алгоритму совершить прибыльную сделку, а итоговый отчет не показывает какой-либо компенсации утраченного торгового преимущества. Уточним: сеть нельзя назвать полным провалом — при форвардном тестировании профит-фактор оставался выше 2.7, а коэффициент Шарпа — выше 3.0; более того, в обоих форвардных прогонах профит-фактор оказался выше, чем в соответствующих прогонах тестирования на исторических данных. Более узкий вывод заключается в том, что рекуррентный слой, хотя и сохранял работоспособность системы, не давал измеримой дополнительной пользы по сравнению с базовым детерминированным алгоритмом Mode-2/GARCH. Ниже приведены сводные результаты этих двух прогонов:

s1b

s2b

s1f

s2f


Заключение

Изначально мы задавались вопросом: можно ли улучшить подходящие условия для входа, выявив более благоприятное расширение волатильности. Этот класс позволяет проверить данное предположение, поскольку детерминированную оценку паттерна, фильтр волатильности GARCH и рекуррентную сеть можно рассматривать по отдельности, а не иметь дело с прогнозами «черного ящика». В отчетах приводятся два разных ответа. Во-первых, базовый детерминированный алгоритм Mode-2 на основе GARCH успешно прошел форвардное тестирование, показав достойную прибыльность и показатели с учетом риска. При всего 36 сделках в оптимизационном прогоне и 22 сделках в ходе форвардного тестирования наши результаты носят предварительный характер, однако они достаточно обнадеживают, чтобы обосновать дальнейшее тестирование лежащих в основе алгоритма условий для входа, связанных с возвратом внутрь полос Боллинджера и волатильностью.

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

Это не означает, что рекуррентные сети непригодны для прогнозирования волатильности; скорее, из этого следует более узкий и полезный вывод. В наших конфигурациях способность сети запоминать последовательности не оправдала связанного с ней усложнения. GARCH, ATR, полосы Боллинджера и паттерны возврата внутрь полос Боллинджера уже могут давать достаточно информации для принятия торговых решений. Возможно и другое объяснение: шесть признаков LSTM слишком тесно связаны с данными, уже используемыми в алгоритмическом слое, чтобы обеспечить независимое торговое преимущество.

Это нельзя было бы считать неудачным экспериментом по ряду причин. Главная из них состоит в том, что именно для этого и нужна экспресс-проверка. Эффективный процесс разработки должен позволять отбрасывать привлекательные комбинации моделей до того, как они будут закреплены в более крупной системе. Таким образом, следующий вопрос состоит не в том, как увеличить размер LSTM, а в том, может ли другой режим или принципиально иной признак дать рекуррентной памяти что-то новое для обучения. Пока мы не проведём тест, в котором явно превзойдём результаты запусков одного лишь алгоритма без LSTM вне выборки, более простая модель останется более убедительным объяснением. Можно утверждать, что в исследованиях по прогнозированию цен дисциплина может быть ценнее, чем ещё один интеллектуальный слой: каждый добавляемый компонент должен допускать замену и сравнение с другими, а в конечном счёте — и отказ от него, если на это указывают результаты.

имя Описание
05.mq5 Собранный с помощью Мастера MQL5 советник, в заголовке которого описаны используемые файлы
05-SignalGARCHVolScaledLSTM.mqh Файл пользовательского класса торговых сигналов, необходимый для сборки советника с помощью Мастера MQL5

Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/24357

Прикрепленные файлы |
05.mq5 (10.66 KB)
Тест Диболда–Мариано на MQL5: Сравниваем точность прогнозных моделей на разных инструментах Тест Диболда–Мариано на MQL5: Сравниваем точность прогнозных моделей на разных инструментах
В статье показано, как сравнить две торговые прогнозные модели в MQL5 с помощью теста Диболда–Мариано (DM) с HAC-коррекцией дисперсии и поправкой Харви–Лейборна–Ньюболда. В ней описаны детали реализации: выбор функции потерь, лаговые окна, зависящие от горизонта прогнозирования, расчет в скользящем окне, обработка результатов теста и настройка на основе манифеста, а также реализация расчетов для распределения Стьюдента без внешних библиотек. Советник отображает информационную панель с обновлением в реальном времени, а индикатор — статистику теста и границы критических значений для практического и статистически обоснованного выбора модели.
Автоматизация классических рыночных методов на языке MQL5 (Часть 8): Система следования за трендом Эда Сейкоты Автоматизация классических рыночных методов на языке MQL5 (Часть 8): Система следования за трендом Эда Сейкоты
В статье представлена полная реализация мультивалютной трендовой системы на языке MQL5: пересечения EMA для входа в рынок, ADX для исключения торговли на боковом рынке, ATR для нормализации размера позиции и монитор для ограничения совокупного риска портфеля. Мы объясняем архитектуру, детали расчетов и логику входа и выхода на дневных барах. В результате получился практичный шаблон советника для систематической портфельной торговли с учетом рисков.
Полиномиальная регрессия в реальном времени: Реализация каузального фильтра Савицкого — Голея на MQL5 Полиномиальная регрессия в реальном времени: Реализация каузального фильтра Савицкого — Голея на MQL5
Мы адаптируем фильтр Савицкого — Голея для MQL5, придавая ему строго каузальную форму для работы в реальном времени, и выводим фиксированные коэффициенты для вычисления в конечной точке. В статье представлены полноценный индикатор и советник, объясняется чувствительность к шуму при вычислении на краю окна и реализуется защитный механизм подтверждения на нескольких барах. Приведены результаты тестирования на исторических данных по нескольким торговым инструментам без выборочного отбора удачных результатов. Вы получаете готовый к компиляции код, рекомендации по настройке параметров и альтернативу скользящим средним с меньшим запаздыванием.
Торговые инструменты MQL5 (Часть 37): Добавление ленты редактирования свойств отдельных объектов в слой рисования на холсте Торговые инструменты MQL5 (Часть 37): Добавление ленты редактирования свойств отдельных объектов в слой рисования на холсте
Мы добавляем стек свойств, управляемый дескрипторами, и плавающую ленту, которая привязывается к текущему выделению на слое рисования. В статье рассматриваются список дескрипторов для каждого инструмента, API получения и установки со стороны движка с предварительным просмотром в реальном времени на основе механизма «снимок и восстановление», а также рендереры виджетов для цвета, непрозрачности, ширины линии, стиля линии, шрифтов и видимости уровней. Вы получаете возможность редактировать внешний вид объектов на месте и в режиме реального времени с помощью компактной панели, которую можно перетаскивать.