English
preview
Построение моделей волатильности в MQL5 (Часть III): Реализация алгоритма SLSQP для оценки моделей

Построение моделей волатильности в MQL5 (Часть III): Реализация алгоритма SLSQP для оценки моделей

MetaTrader 5 — Интеграция |
152 0
Francis Dube
Francis Dube

Содержание

  1. Введение
  2. Анализ расхождений
  3. Оптимизатор последовательного программирования методом наименьших квадратов (SLSQP)
  4. Обзор реализации SLSQP на MQL5
  5. Определение целевой функции и ограничений
  6. Настройка и инициализация
  7. Выполнение и результаты
  8. Интеграция решателя SLSQP
  9. Заключение


Введение

Библиотека волатильности, портированная на MQL5 в рамках данной серии статей, была разработана с целью воспроизведения функциональности модуля ARCH языка Python. В идеале реализация на MQL5 должна давать результаты, близкие к полученным на Python; однако тесты на одинаковых наборах данных неизменно выявляли расхождения в параметрах моделей. Хотя цель заключается не в том, чтобы точно воспроизвести каждый десятичный разряд, параметры должны находиться в пределах допустимого диапазона отклонений. Чтобы устранить эти расхождения, в данной части серии алгоритм расширенного лагранжиана с предобусловливанием из ALGLIB для оптимизации с нелинейными ограничениями (minNLC) заменён на алгоритм последовательного программирования методом наименьших квадратов (SLSQP).

Статья начинается с анализа межплатформенных расхождений на примере сравнения моделей волатильности, построенных на Python и в MetaTrader 5, чтобы объяснить необходимость замены оптимизатора. Далее мы подробно разбираем реализацию SLSQP непосредственно на языке MQL5 и демонстрируем, как интегрировать этот решатель в существующую библиотеку волатильности. В заключение мы сравниваем обновлённую библиотеку с её аналогом на Python, чтобы убедиться в согласованности результатов. Представлен полный исходный код набора инструментов на MQL5, который по результатам работы сопоставим с модулем ARCH.


Анализ расхождений

Основной причиной замены существующего механизма оптимизации является обеспечение согласованности, а не отсутствие сходимости или низкая вычислительная эффективность. Библиотека использует функцию логарифма правдоподобия в качестве целевой функции для определения параметров модели. Однако эмпирические испытания показывают, что решатель minNLC из библиотеки ALGLIB зачастую находит наборы параметров, отличающиеся от тех, которые генерирует модуль `arch` языка Python, даже при использовании одинаковых начальных значений. Это несоответствие можно продемонстрировать, запустив скрипт VolatilityModelParameterComparison.ex5. Скрипт получает данные выборки из MetaTrader 5 (MetaTrader 5) и для сравнения строит идентичные модели волатильности с настраиваемыми пользователем параметрами, используя библиотеку MQL5 и модуль ARCH языка Python.

Эта программа наглядно демонстрирует проблемы, с которыми сталкивается библиотека в настоящее время. Скрипт запускался несколько раз с различными настройками; ниже приведены результаты некоторых из этих запусков.

MEAN_CONSTANT
VOL_GJR_GARCH
DIST_NORMAL
GARCH spec
P(1) O(1) Q(1) Power(2.000000)
MT5 model parameters:
[-0.02197736805578508,0.008665530470622173,0.05,0.01,0.9249999999999999]
MT5 model LogLikelihood: 968.9105526360026
Python's Model Parameters [-0.0242805845484529,0.002293742963206083,0.01626902046373811,0.01434054744816164,0.9712268914708287]
Python's LogLikelihood: 964.9296120077307
Приведенные выше результаты отражают данные, полученные для модели GJR-GARCH, а результаты для стандартной модели GARCH представлены ниже.
MEAN_CONSTANT
VOL_GARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(1) Power(2.000000)
MT5 model parameters:
[-0.02197736805578508,0.008665530470622173,0.05,0.9299999999999999]
MT5 model LogLikelihood: 968.2234497542257
Python's Model Parameters [-0.02170062752089841,0.002653690530826297,0.02523174395053289,0.9686111317666565]
Python's LogLikelihood: 965.277797248645

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

MEAN_CONSTANT
VOL_TARCH
DIST_NORMAL
GARCH spec
P(1) O(1) Q(1) Power(1.000000)
MT5 model parameters:
[-0.02197736805578508,0.01316474874095376,0.1,0.05,0.855]
MT5 model LogLikelihood: 1049.2999012672242
Python's Model Parameters [-0.02774962124001202,0.003761918497530642,0.01425295763143413,0.02392852230367382,0.9737827811881781]
Python's LogLikelihood: 963.005988142707
Похоже, что расхождения в параметрах усиливаются по мере увеличения сложности модели.
MEAN_CONSTANT
VOL_AVGARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(1) Power(1.000000)
MT5 model parameters:
[-0.02197736805578508,0.01316474874095376,0.2,0.78]
MT5 model LogLikelihood: 1100.9969289096468
Python's Model Parameters [-0.02250404030999785,0.004185362811318036,0.03014462096952416,0.9698553790305747]
Python's LogLikelihood: 964.3159918481251

Следовательно, более простые модели, по-видимому, показывают лучшие результаты.

MEAN_CONSTANT
VOL_ARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(0) Power(2.000000)
MT5 model parameters:
[-0.01996155842932553,0.3827935932951031,0.1198093348469467]
MT5 model LogLikelihood: 993.7152272796347
Python's Model Parameters [-0.01996231775953625,0.3827906664926961,0.1198013671195205]
Python's LogLikelihood: 993.7152272209562

Прежде чем полностью возложить вину за эту неудачу на алгоритм решения, была изучена ещё одна возможная причина: ошибки во вспомогательных вычислениях. Чтобы убедиться в корректности внутренней логики библиотеки MQL5, был проведён тест: известные параметры модели, построенной с помощью Python, вручную ввели в модель в MetaTrader 5. Если бы модель на MQL5 смогла воспроизвести то же значение логарифма правдоподобия, это подтвердило бы корректность программной реализации. Было проведено кроссплатформенное тестирование с использованием скрипта LogLikelihoodVerification.mq5, в ходе которого на обеих платформах выполнялся вызов целевой функции и производилось сравнение результатов. Ниже приведены результаты трёх запусков с различными спецификациями модели.

Вывод скрипта LogLikelihoodVerification

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

Еще один способ решить эту проблему без замены оптимизатора — настроить его параметры. Решатель minNLC из библиотеки ALGLIB имеет несколько настраиваемых параметров; однако их оптимизация представляет собой сложную задачу, поскольку требует глубокого понимания как самого оптимизатора, так и более широкой задачи, к решению которой он применяется. Кроме того, это служит убедительным аргументом в пользу перехода на альтернативный оптимизатор. Учитывая, что модуль ARCH в Python использует последовательное программирование методом наименьших квадратов (SLSQP), перенос этого алгоритма на MQL5 представляет собой наиболее логичный путь к достижению согласованности результатов на обеих платформах.


Оптимизатор на основе последовательного программирования методом наименьших квадратов (SLSQP)

Последовательное программирование методом наименьших квадратов (SLSQP) основано на разложении сложной нелинейной задачи оптимизации с ограничениями на ряд упрощённых подзадач квадратичного программирования. На каждой основной итерации алгоритм строит локальную квадратичную аппроксимацию лагранжиана. Он также линеаризует ограничения. Функция Лагранжа используется в оптимизации для преобразования задачи с ограничениями в задачу без ограничений путём включения ограничений непосредственно в целевую функцию

Такой подход позволяет решателю определять оптимальное направление поиска путём решения специальной подзадачи, учитывающей как кривизну целевой функции, так и локальную геометрию области допустимых решений. В отличие от решателя minNLC из библиотеки ALGLIB, который обычно использует метод внутренних точек или подход на основе штрафных функций для учёта граничных ограничений, SLSQP применяет стратегию активного множества для непосредственной обработки ограничений-равенств и ограничений-неравенств. Решая систему условий Каруша — Куна — Таккера (ККТ) для каждой квадратичной подзадачи, SLSQP обеспечивает более строгое соблюдение границ, задаваемых ограничениями.

Обзор SLSQP

Условия ККТ представляют собой набор необходимых математических требований, определяющих, когда оптимизатор успешно нашел оптимальное решение задачи с ограничениями. Оптимизация с ограничениями представляет особую сложность, поскольку абсолютный минимум целевой функции может находиться в недопустимой области. В то время как при оптимизации без ограничений достаточно просто найти точку, в которой градиент равен нулю, условия ККТ позволяют распространить этот принцип на области с ограничениями за счёт использования множителей Лагранжа. Эти множители действуют подобно математическим силам реакции ограничений, удерживая решатель в допустимой области. Чтобы точка считалась оптимальным решением, она должна одновременно удовлетворять четырем критериям.

  1. Допустимость прямой задачи: решение должно строго удовлетворять всем условиям и не может нарушать ни одно из ограничений-равенств и ограничений-неравенств.
  2. Допустимость двойственной задачи: множители Лагранжа для активных ограничений-неравенств должны быть неотрицательными, чтобы градиентные силы были направлены в допустимую область, а не в недопустимую.
  3. Условие дополняющей нежёсткости: для каждого ограничения-неравенства либо оно должно выполняться как равенство, либо его множитель должен быть равен нулю — в последнем случае ограничение не препятствует дальнейшему продвижению и оставляет свободу перемещения.
  4. Стационарность: градиенты целевой функции и всех активных ограничений должны полностью компенсировать друг друга, что указывает на то, что дальнейшее перемещение в допустимом направлении не может привести к снижению значения целевой функции.

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

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

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


Обзор реализации SLSQP на MQL5

Реализация решателя SLSQP на языке MQL5 основана на переносе исходного алгоритма, разработанного Дитером Крафтом на языке Fortran в конце 1980-х годов. Основная логика реализована в файле slsqp.mqh и состоит из портированного функционального кода и объектно-ориентированного интерфейса — класса CSLSQP. Данная реализация поддерживает все возможности исходного алгоритма, включая граничные ограничения, ограничения-равенства и ограничения-неравенства. Для численного дифференцирования используется заголовочный файл num_diff.mqh, что позволяет решателю работать даже при отсутствии аналитических градиентов.

//+------------------------------------------------------------------+
//| OOP interface for SLSQP minimizer                                |
//+------------------------------------------------------------------+
class CSlsqp : public CObject
  {
protected:
   double            m_acc;
   slsqp_constraint  m_eq_constraints[];
   slsqp_constraint  m_ineq_constraints[];
   slsqp_stopping    m_stop;
   slsqp_result      m_slsqp_result;
   bool              check_constraints(void);

public:
                     CSlsqp(void) : m_acc(0.0) {}
                    ~CSlsqp(void)
     {
     }
   void              SetAcc(double acc_)
     {
      m_acc = acc_;
     }
   
   void              SetStopVal(double stopval)
     {
      m_stop.minf_max = stopval;
     }
   void              SetFtolRel(double ftolrel)
     {
      if(ftolrel>0.0)
         m_stop.ftol_rel = ftolrel;
     }
   void              SetXtolRel(double xtolrel)
     {
      if(xtolrel>0.0)
         m_stop.xtol_rel = xtolrel;
     }
   void              SetFtolAbs(double ftolabs)
     {
      if(ftolabs>0.0)
         m_stop.ftol_abs = ftolabs;
     }
   void              SetXtolAbs(vector& xtolabs)
     {
      ArrayResize(m_stop.xtol_abs,(int)xtolabs.Size());
      for(ulong i = 0; i<xtolabs.Size(); ++i)
          m_stop.xtol_abs[i] = xtolabs[i];
     }
   void              SetMaxEval(int maxeval)
     {
      m_stop.maxeval = fabs(maxeval);
     }
   bool              SetEqualityConstraints(CConstraints &constraints, vector &tolerances)
     {
      if(!m_eq_constraints.Size())
         if(ArrayResize(m_eq_constraints,1)!=1)
           {
            Print(__FUNCTION__, ": Error ", GetLastError());
            return false;
           }

      m_eq_constraints[0].f_data = GetPointer(constraints);
      m_eq_constraints[0].m = constraints.numConstraints();
      ArrayResize(m_eq_constraints[0].tol,m_eq_constraints[0].m);
      return Copy(m_eq_constraints[0].tol,tolerances,m_eq_constraints[0].m);
     }
   bool              SetInequalityConstraints(CConstraints &constraints, vector &tolerances)
     {
      if(!m_ineq_constraints.Size())
         if(ArrayResize(m_ineq_constraints,1)!=1)
           {
            Print(__FUNCTION__, ": Error ", GetLastError());
            return false;
           }

      m_ineq_constraints[0].f_data = GetPointer(constraints);
      m_ineq_constraints[0].m = constraints.numConstraints();
      ArrayResize(m_ineq_constraints[0].tol,m_ineq_constraints[0].m);
      return Copy(m_ineq_constraints[0].tol,tolerances,m_ineq_constraints[0].m);
     }
   bool              SetEqualityConstraints(CConstraints &constraints)
     {
      vector tolerances(constraints.numConstraints());
      tolerances.Fill(1.e-8);
      return SetEqualityConstraints(constraints,tolerances);
     }
   bool              SetInequalityConstraints(CConstraints &constraints)
     {
      vector tolerances(constraints.numConstraints());
      tolerances.Fill(1.e-8);
      return SetInequalityConstraints(constraints,tolerances);
     }
   OptimizeResult    Minimize(CFunctor &fungrad)
     {
      vector x0 = fungrad.initial_params();
      int n = (int)x0.Size();
      vector x_data = x0;

      vector low = fungrad.lower_bounds();
      vector up = fungrad.upper_bounds();

      if((low.Size()&&low.Size()!=ulong(n)) || (up.Size()&&up.Size()!=ulong(n)))
        {
         Print(__FUNCTION__,": All vector inputs should be the same size if not empty");
         return OptimizeResult();
        }

      for(int i  = 0; i<n; ++i)
         if(low[i]>up[i])
           {
            Print(__FUNCTION__ ": Invalid boundary constraints");
            return OptimizeResult();
           }

      slsqp_func ofunc = func;
      IObjective *obj = (IObjective*)GetPointer(fungrad);
      double minimum = 0.0;
      m_stop.n = n;
      m_stop.nevals_p = 0;
      m_stop.start = (double)TimeLocal();
      m_slsqp_result = slsqp_minimizer(n,ofunc,obj,ArraySize(m_ineq_constraints),m_ineq_constraints,ArraySize(m_eq_constraints),m_eq_constraints,low,up,x0,minimum,m_acc,m_stop);
      if(m_slsqp_result<0)
        {
         Print(__FUNCTION__, ": Operation failed ", EnumToString((slsqp_result)m_slsqp_result));
         return OptimizeResult();
        }

      vector out(1);
      out[0] = minimum;
      vector gg;

      return OptimizeResult(int(m_slsqp_result),m_stop.nevals_p,m_stop.slsqp_state.itermx,x0,out,m_stop.gradient);
     }
  };

Утилиты, определенные в файле num_diff.mqh, были ранее описаны в статье, посвящённой реализации оптимизатора TNC. В данном разделе рассматриваются конкретные изменения, внесённые для обеспечения поддержки оптимизатора SLSQP. Первое из этих изменений касается структуры ObjReturn: она дополнена свойствами векторного и матричного типов для обработки многомерных выходных данных.

//+------------------------------------------------------------------+
//|struct objective function return                                  |
//+------------------------------------------------------------------+
struct ObjReturn
  {
   double            f;
   vector            g;
   vector            mf;
   matrix            mg;
                     ObjReturn(void)
     {
      f = double(0);
      g = vector::Zeros(0);
      mf = vector::Zeros(0);
      mg = matrix::Zeros(0,0);
     }
                     ObjReturn(ObjReturn& other)
     {
      f = other.f;
      g = other.g;
      mf = other.mf;
      mg = other.mg;
     }
   void              operator=(ObjReturn& other)
     {
      f = other.f;
      g = other.g;
      mf = other.mf;
      mg = other.mg;
     }
  };

В базовый класс CFunctor добавлено свойство отсечения, позволяющее корректировать оптимизируемые переменные в ходе оптимизации так, чтобы они оставались в заранее заданных границах. Эту возможность можно включить вызовом нового метода setClipOption(), который принимает логическое значение (true включает отсечение, а false — отключает). Кроме того, был введён базовый класс CConstraints для управления ограничениями и функциями вычисления их градиентов. Он работает аналогично классу CFunctor и обладает теми же свойствами.

//+------------------------------------------------------------------+
//|base class representing function and its derivative               |
//+------------------------------------------------------------------+
class CConstraints:public IObjective
  {
protected:
   int               m_n,m_m;
   bool              m_clip,m_initialized;
   GradDiffOptions   m_options;
   vector            wrapped_func(vector& x)
     {
      if(!m_initialized)
         return vector::Zeros(0);
      if(m_clip)
        {
         matrix bnds = m_options.bounds;
         for(ulong i = 0; i<x.Size(); ++i)
           {
            if(x[i]<bnds[i,0])
               x[i] = bnds[i,0];
            else
               if(x[i]>bnds[i,1])
                  x[i] = bnds[i,1];
           }
        }
      vector copy = x;
      return orig_fun(copy);
     }
   matrix            wrapped_grad(vector& x,vector& f0)
     {
      if(!m_initialized)
         return matrix::Zeros(0,0);
      if(m_clip)
        {
         matrix bnds = m_options.bounds;
         for(ulong i = 0; i<x.Size(); ++i)
           {
            if(x[i]<bnds[i,0])
               x[i] = bnds[i,0];
            else
               if(x[i]>bnds[i,1])
                  x[i] = bnds[i,1];
           }
        }
      vector copy = x;
      if(m_options.method == GRAD_POINT_CALLABLE)
         return orig_grad(copy);
      IObjective* fun = (IObjective*)GetPointer(this);
      matrix ad = approx_derivative(fun,copy,f0,m_options.method,m_options.rel_step,m_options.abs_step,m_options.bounds);
      return ad;
     }
public:
                     CConstraints(void)
     {
      m_n = m_m = 0;
      m_clip = true;
      m_initialized = false;
      m_options.method = GRAD_POINT_2;
     }
                    ~CConstraints(void)
     {
     }
   bool                   initialize(vector& x)
     {
      if((m_m == 0 && m_n) || (int)x.Size()!=m_n)
        {
         Print(__FUNCTION__," ","Invalid property dimensions.", " n ", m_n, " vs ", x.Size());
         return false;
        }

      vector check = orig_fun(x);
      if(!check.Size() || check.HasNan() || MathClassify(fabs(check.Max())) == FP_INFINITE)
        {
         Print(__FUNCTION__," ","Check the implementation of the constraints function.");
         return false;
        }

      if(m_options.method == GRAD_POINT_CALLABLE)
        {
         matrix a  = orig_grad(x);
         if(a.Rows()!=m_m || a.HasNan() || MathClassify(fabs(a.Max())) == FP_INFINITE)
           {
            Print(__FUNCTION__," ","Check the implementation of the overridden constraints gradient function.");
            return false;
           }
        }
      if(m_options.bounds.Rows()!=ulong(m_n))
        {
         m_options.bounds.Resize(m_n,2);
         m_options.bounds.Fill(double("inf"));
         for(int i  = 0; i<m_n; ++i)
            m_options.bounds[i,0]*=-1.0;
         Print(__FUNCTION__, " ","WARNING:Boundary constraints not properly specified.\nOverwritten to (-inf,inf) ");
        }
      m_initialized = true;
      return m_initialized;
     }

   void              setParams(int m, int n, GradDiffOptions& opts, bool clip_to_bounds=true)
     {
      m_initialized = false;
      m_n = fabs(n);
      m_m = fabs(m);
      m_clip = clip_to_bounds;
      m_options = opts;
     }

   void              setGradientOptions(GradDiffOptions& opts)
     {
      m_initialized = false;
      m_options = opts;
     }

   void              setBounds(matrix& bounds)
     {
      m_initialized = false;
      m_options.bounds = bounds;
     }

   void              setNumConstraints(int m)
     {
      m_initialized = false;
      m_m = m;
     }

   void              setDimension(int n)
     {
      m_initialized = false;
      m_n = n;
     }

   vector            objective_function(vector& x)
     {

      return wrapped_func(x);
     }

   ObjReturn         fun_and_grad(vector& x)
     {
      ObjReturn out;
      out.mf = objective_function(x);
      out.mg = wrapped_grad(x,out.mf);
      return out;
     }
   virtual vector    orig_fun(vector& x)
     {
      return vector::Zeros(0);
     }
   virtual matrix    orig_grad(vector& x)
     {
      return matrix::Zeros(0,0);
     }
   int               numConstraints(void)
     {
      return m_m;
     }
   int               dim(void)
     {
      return m_n;
     }
   vector            lower_bounds(void)
     {
      return m_options.bounds.Col(0);
     }
   vector            upper_bounds(void)
     {
      return m_options.bounds.Col(1);
     }
  };

В следующих разделах описаны этапы развертывания решателя SLSQP в MQL5.


Определение целевой функции и ограничений

Первый шаг заключается в том, чтобы инкапсулировать целевую функцию и все ограничения в специализированные классы. Класс-обёртка целевой функции должен наследоваться от CFunctor и реализовывать метод orig_fun(). Если градиент целевой функции известен, можно дополнительно реализовать его вычисление, переопределив метод grad_fun(). Классы ограничений-равенств и ограничений-неравенств должны наследоваться от базового класса CConstraints. Ограничения-равенства задаются функциями стандартного вида: h(x) = 0. Аналогичным образом, ограничения-неравенства должны иметь следующий вид: g(x) ≤ 0, где x обозначает вектор переменных принятия решений. Метод orig_fun() класса CConstraints возвращает вектор, размер которого равен количеству ограничений. Если аналитический градиент известен, следует переопределить метод grad_fun(), чтобы он возвращал матрицу Якоби размером m на n, где m — количество ограничений, а n — количество переменных принятия решений.

//+------------------------------------------------------------------+
//| objective function                                               |
//+------------------------------------------------------------------+
class CObjectiveFunc:public CFunctor
  {
protected:
   vector            obj_gradient;
public:
                     CObjectiveFunc(void)
     {
     }
                    ~CObjectiveFunc(void)
     {
     }
   virtual double    orig_fun(vector& x)

  };
//+------------------------------------------------------------------+
//| inequality constraints                                           |
//+------------------------------------------------------------------+
class CIneqConstraints: public CConstraints
  {
private:
   vector            obj_result;
public:
                     CIneqConstraints(void)
     {
     }
                    ~CIneqConstraints(void)
     {
     }
   virtual vector    orig_fun(vector& x) override
     {

     }
  };
//+------------------------------------------------------------------+
//| equality constraints                                             |
//+------------------------------------------------------------------+
class CEqConstraints: public CConstraints
  {
private:
public:
                     CEqConstraints(void)
     {
     }
                    ~CEqConstraints(void)
     {
     }
   virtual vector    orig_fun(vector& x) override
     {

     }
  };


Настройка и инициализация

После создания экземпляров классов, производных от CFunctor и CConstraints, их необходимо инициализировать, задав начальные значения и граничные ограничения. Крайне важно обеспечить согласованность граничных ограничений, заданных для целевой функции и ограничений. Конфигурация целевой функции и её ограничений должна быть проверена путём вызова соответствующих методов initialize(), которые должны возвращать значение true для продолжения оптимизации.

CObjectiveFunc obj_func;
//---
CIneqConstraints ineq_func;
//---
CEqConstraints eq_func;
//---
vector initp = {2, 0};
//---
GradDiffOptions obj_options;
//---
obj_options.bounds = matrix::Zeros(2,2);
obj_options.bounds[0,1] = 10.;
obj_options.bounds[1,1] = 10.;
obj_options.method = GRAD_POINT_2;
//---
obj_func.setParams(obj_options);
ineq_func.setParams(1,2,obj_options);
eq_func.setParams(1,2,obj_options);
//---
if(!obj_func.initialize(initp) || !ineq_func.initialize(initp) || !eq_func.initialize(initp))
    return;

После этого можно настроить объект оптимизатора SLSQP. Ограничения-равенства и ограничения-неравенства задаются с помощью методов SetEqualityConstraints() и SetInequalityConstraints() соответственно. Эти перегруженные методы принимают либо только экземпляр класса ограничений, либо этот экземпляр вместе с вектором значений допуска. Допуски определяют допустимые величины нарушений ограничений. Например, для ограничения-равенства пользователь может задать малый допуск, допускающий незначительные численные отклонения от нуля. Размер вектора допусков должен соответствовать количеству ограничений. Если допуски явно не заданы, для каждого ограничения устанавливается допуск по умолчанию, равный 1e-8.

CSlsqp slsqp_minim;
slsqp_minim.SetInequalityConstraints(ineq_func);
slsqp_minim.SetEqualityConstraints(eq_func);

Класс CSLSQP также позволяет пользователям настраивать конкретные критерии сходимости.

  • SetXtolRel(): Настраивает относительный допуск для параметров, который используется в качестве критерия сходимости по умолчанию. Сходимость достигается, когда изменение входных параметров невелико по сравнению с их величиной. Например, относительный допуск, равный 0,0001, приводит к остановке оптимизации, если изменение входных параметров составляет менее 0,01 %. По умолчанию для этого параметра установлено значение 0,0001.
  • SetXtolAbs(): Принимает вектор абсолютных допусков для отдельных оптимизируемых переменных. Это позволяет задавать индивидуальные критерии сходимости для каждой переменной, что особенно полезно при работе с параметрами, существенно различающимися по масштабу.
  • SetFtolRel(): Устанавливает относительный допуск функции. Этот критерий останавливает оптимизацию, когда относительное изменение значения целевой функции между последовательными итерациями становится меньше заданного допуска.
  • SetFtolAbs(): Настраивает абсолютный допуск функции. Он завершает процесс оптимизации, когда модуль разности значений функции на двух последовательных итерациях становится меньше заданного порога.
  • SetMaxEval(): Задаёт жёсткий целочисленный предел числа вычислений целевой функции, при достижении которого решатель останавливается.
  • SetStopVal(): Устанавливает минимальный порог: оптимизация останавливается, как только значение целевой функции становится меньше или равно этому порогу.
  • SetAcc(): Задаёт допуск для нормы градиента (оптимальность первого порядка). Хотя в идеале градиент в точке минимума равен ровно нулю, параметр точности задаёт практический порог: процесс завершается, когда величина наклона ландшафта оптимизации становится меньше этого порога.


Выполнение и результаты

Процедура оптимизации запускается вызовом метода Minimize(), который принимает в качестве единственного аргумента экземпляр производного от CFunctor класса, представляющий целевую функцию. Этот метод возвращает структуру OptimizeResult.

//+------------------------------------------------------------------+
//|Optimization results                                              |
//+------------------------------------------------------------------+
struct OptimizeResult
  {
   int               return_code;
   int               nfeval;
   int               niter;
   vector            solution;
   vector            objective_result;
   vector            objective_gradient;

                     OptimizeResult(void)
     {
      return_code = WRONG_VALUE;
      nfeval = niter = 0;
      solution = objective_result = objective_gradient = vector::Zeros(0);
     }
                     OptimizeResult(int rc,int feval,int iter,vector &x, vector& f, vector& g)
     {
      return_code = rc;
      nfeval = feval;
      niter = iter;
      solution = x;
      objective_result = f;
      objective_gradient = g;
     }
                     OptimizeResult(OptimizeResult& other)
     {
      return_code = other.return_code;
      nfeval = other.nfeval;
      niter = other.niter;
      solution = other.solution;
      objective_result = other.objective_result;
      objective_gradient = other.objective_gradient;
     }
   void              operator=(OptimizeResult& other)
     {
      return_code = other.return_code;
      nfeval = other.nfeval;
      niter = other.niter;
      solution = other.solution;
      objective_result = other.objective_result;
      objective_gradient = other.objective_gradient;
     }
  };

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

//+------------------------------------------------------------------+
//| result                                                           |
//+------------------------------------------------------------------+
enum slsqp_result
  {
   SLSQP_FAILURE = -1,
   SLSQP_INVALID_ARGS = -2,
   SLSQP_OUT_OF_MEMORY = -3,
   SLSQP_ROUNDOFF_LIMITED = -4,
   SLSQP_FORCED_STOP = -5,
   SLSQP_NUM_FAILURES = -6,
   SLSQP_SUCCESS = 1,          /* generic success code */
   SLSQP_STOPVAL_REACHED = 2,
   SLSQP_FTOL_REACHED = 3,
   SLSQP_XTOL_REACHED = 4,
   SLSQP_MAXEVAL_REACHED = 5,
   SLSQP_MAXTIME_REACHED = 6,
   SLSQP_NUM_RESULTS
  };

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

Оптимизация с помощью численных градиентов. Скрипт slsqp_optimization_with_numerical_gradients.mq5 демонстрирует, как оптимизировать математическую функцию с помощью численных градиентов. Скрипт моделирует задачу с двумя оптимизируемыми переменными, задавая целевую функцию, одно ограничение-равенство и одно ограничение-неравенство. Для реализации этой задачи в коде создаются пользовательские классы, производные от встроенных классов CFunctor и CConstraints.

//+------------------------------------------------------------------+
//|                  slsqp_optimization_with_numerical_gradients.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include<slsqp_article\slsqp.mqh>
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---objective function object
   CObjectiveFunc obj_func;
//---inequality constraints function object
   CIneqConstraints ineq_func;
//---equality constraints function object
   CEqConstraints eq_func;
//---the initial guess
   vector initp = {2, 0};
//---gradient configuration instance
   GradDiffOptions obj_options;
//---configure upper and lower limits
   obj_options.bounds = matrix::Zeros(2,2);
   obj_options.bounds[0,1] = 10.;
   obj_options.bounds[1,1] = 10.;
//---set gradient calculation method
   obj_options.method = GRAD_POINT_2;
//---set gradient options for objective function and constraints
   obj_func.setParams(obj_options);
   ineq_func.setParams(1,2,obj_options);
   eq_func.setParams(1,2,obj_options);
//---initialize and verify configuration of all function objects
   if(!obj_func.initialize(initp) || !ineq_func.initialize(initp) || !eq_func.initialize(initp))
      return;
//---the minimizer instance
   CSlsqp slsqp_minim;
//---configure the minimizer
   slsqp_minim.SetInequalityConstraints(ineq_func);
   slsqp_minim.SetEqualityConstraints(eq_func);
//---run the optimizer
   OptimizeResult ro = slsqp_minim.Minimize(obj_func);
//---check return code
   Print("Minimization return code : ", ro.return_code);
//---print results
   if(ro.return_code>0)
     {
      Print("Solution ", ro.solution);
      Print("Minimum value of function ", ro.objective_result);
      Print("Gradient at the minimum ", ro.objective_gradient);
      Print("Number of iterations ", ro.niter);
      Print("Number of function evaluations ", ro.nfeval);
     }
  }

Целевая функция представляет собой простую поверхность в форме чаши, и задача состоит в том, чтобы найти самую низкую точку. Геометрически эта функция вычисляет квадрат расстояния от любой выбранной точки до идеальной центральной точки с координатами (1; 2,5).

//+------------------------------------------------------------------+
//| objective function                                               |
//+------------------------------------------------------------------+
class CObjectiveFunc:public CFunctor
  {
protected:
   vector            obj_gradient;
public:
                     CObjectiveFunc(void)
     {
      m_clip = true;
      obj_gradient = vector::Zeros(2);
     }
                    ~CObjectiveFunc(void)
     {
     }
   virtual double    orig_fun(vector& x) override
     {
      return pow((x[0] - 1),2) + pow((x[1] - 2.5),2);
     }
  };

При отсутствии ограничений глобальный минимум достигался бы точно в точке x = [1; 2,5], где значение функции равно 0. Ограничение-неравенство требует, чтобы любое допустимое решение лежало на параболе с ветвями, направленными вверх, или выше неё.

//+------------------------------------------------------------------+
//| inequality constraints                                           |
//+------------------------------------------------------------------+
class CIneqConstraints: public CConstraints
  {
private:
   vector            obj_result;
public:
                     CIneqConstraints(void)
     {
      obj_result =  vector::Zeros(1);
     }
                    ~CIneqConstraints(void)
     {
     }
   virtual vector    orig_fun(vector& x) override
     {
      obj_result[0] = pow(x[0],2) - x[1];
      return obj_result;
     }
  };

Ограничение-равенство, реализованное в CEqConstraints, ограничивает пространство поиска решателя диагональной прямой на двумерной плоскости.

//+------------------------------------------------------------------+
//| equality constraint                                              |
//+------------------------------------------------------------------+
class CEqConstraints: public CConstraints
  {
private:
   vector            obj_result;
public:
                     CEqConstraints(void)
     {
      obj_result =  vector::Zeros(1);
     }
                    ~CEqConstraints(void)
     {
     }
   virtual vector    orig_fun(vector& x) override
     {
      obj_result[0] = x[0] - x[1] + 2;
      return obj_result;
     }
  };

Границы области (obj_options.bounds) служат барьерами для решателя, удерживая обе переменные в безопасной рабочей области, где x0 и x1 находятся в диапазоне [0, 10]. Из-за наличия ограничений алгоритм SLSQP не может выбрать точку безусловного минимума (1; 2,5). Эта точка нарушает ограничение-равенство.

Вместо этого оптимизатор должен найти точку, лежащую точно на диагональной прямой x1 = x0 + 2, на параболе x1 = x0^2 или выше неё (x1 >= x0^2) и в пределах области, заданной диапазоном [0, 10] для каждой координаты, минимизируя при этом расстояние до идеальной точки (1; 2,5). Ниже представлены результаты процедуры оптимизации.

slsqp_optimization_with_numerical_gradients (AUDUSD,D1) Minimization return code : 4
slsqp_optimization_with_numerical_gradients (AUDUSD,D1) Solution [0.7499999938026685,2.749999984155363]
slsqp_optimization_with_numerical_gradients (AUDUSD,D1) Minimum value of function [0.1249999951763475]
slsqp_optimization_with_numerical_gradients (AUDUSD,D1) Gradient at the minimum [-0.500000013038516,0.5000000128691847]
slsqp_optimization_with_numerical_gradients (AUDUSD,D1) Number of iterations 4
slsqp_optimization_with_numerical_gradients (AUDUSD,D1) Number of function evaluations 5

Оптимизация с помощью аналитических градиентов. Скрипт slsqp_optimization_with_analytical_gradients.mq5 демонстрирует процесс оптимизации с использованием явно заданных аналитических градиентов. Скрипт моделирует двумерную нелинейную задачу оптимизации с ограничениями для вектора оптимизируемых переменных x = [x0, x1].

//+------------------------------------------------------------------+
//|                 slsqp_optimization_with_analytical_gradients.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include<slsqp_article\slsqp.mqh>
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---custom constraint parameters
   vector aa = {2,-1};
   vector bb = {0, 1};
//---gradient configuration instance
   GradDiffOptions obj_options;
//---set upper and lower limits for optimization problem
   obj_options.bounds = matrix::Zeros(2,2);
   obj_options.bounds.Fill(double("inf"));
   obj_options.bounds[0,0]*=-1.;
   obj_options.bounds[1,0] = 1.e-6;
//---configure gradient calculation method
   obj_options.method = GRAD_POINT_CALLABLE;
//---objective function object instance
   CObjectiveFunc obj_func;
//---inequality constraints function object instance
   CIneqConstraints ineq_func;
//---initial guess
   vector initp = {1.234, 5.678};
//---pass extra arguments to objective function's constraints
   ineq_func.SetInternalData(aa,bb);
//---configure gradient options for objective function and constraints
   obj_func.setParams(obj_options);
   ineq_func.setParams(2,2,obj_options);
//---initialize and verify configuration of objective function and corresponding constraints
   if(!obj_func.initialize(initp) || !ineq_func.initialize(initp))
      return;
//---optimizer instance
   CSlsqp slsqp_minim;
//---configure the optimizer
   slsqp_minim.SetXtolRel(1.e-4);
   vector ineq_tols(2);
   ineq_tols.Fill(1.e-8);
   slsqp_minim.SetInequalityConstraints(ineq_func,ineq_tols);
//---run the optimizer
   OptimizeResult ro = slsqp_minim.Minimize(obj_func);
//---check optimizer return code
   Print("Minimization return code : ", ro.return_code);
//---print results of optimization
   if(ro.return_code>0)
     {
      Print("Solution ", ro.solution);
      Print("Minimum value of function ", ro.objective_result);
      Print("Gradient at the minimum ", ro.objective_gradient);
      Print("Number of iterations ", ro.niter);
      Print("Number of function evaluations ", ro.nfeval);
     }
  }

При заданных векторах параметров a = [2, -1] и b = [0, 1], переданных механизму обработки ограничений, полная математическая система имеет следующий вид. Целевая функция (CObjectiveFunc) выделяет и минимизирует квадратный корень из второй переменной.

//+------------------------------------------------------------------+
//|objective function object                                         |
//+------------------------------------------------------------------+
class CObjectiveFunc:public CFunctor
  {
private:
   vector            obj_grad;
public:
                     CObjectiveFunc(void)
     {
      obj_grad = vector::Zeros(2);
     }
                    ~CObjectiveFunc(void)
     {
     }
   virtual double    orig_fun(vector& x) override
     {
      return sqrt(x[1]);
     }
   virtual vector    grad_fun(vector& x) override
     {
      obj_grad[0] = 0.0;
      obj_grad[1] = 0.5/sqrt(x[1]);
      return obj_grad;
     }
  };

Вектор градиента содержит частные производные по первой и второй оптимизируемым переменным соответственно. Вычисление частной производной по второй переменной вызывает ошибку деления на ноль, если эта переменная равна нулю; поэтому в obj_options.bounds задаётся нижняя граница 1e-6, обеспечивающая небольшой отступ от нуля, чтобы решатель оставался строго внутри безопасной области дифференцируемости. Класс ограничений-неравенств (CIneqConstraints) управляет векторной функцией, содержащей два отдельных граничных ограничения.

//+------------------------------------------------------------------+
//| inequality constraints                                           |
//+------------------------------------------------------------------+
class CIneqConstraints: public CConstraints
  {
private:
   vector            a, b;
   vector            f_result;
   matrix            g_result;
public:
                     CIneqConstraints(void)
     {
      f_result = vector::Zeros(2);
      g_result = matrix::Zeros(2,2);
     }
                    ~CIneqConstraints(void)
     {
     }
   void              SetInternalData(vector& a_, vector& b_)
     {
      a = a_;
      b = b_;
     }
   virtual vector    orig_fun(vector& x) override
     {
      f_result[0] = (a[0]*x[0] + b[0]) * (a[0]*x[0] + b[0]) * (a[0]*x[0] + b[0]) - x[1];
      f_result[1] = (a[1]*x[0] + b[1]) * (a[1]*x[0] + b[1]) * (a[1]*x[0] + b[1]) - x[1];
      return f_result;
     }
   virtual matrix    orig_grad(vector& x) override
     {
      g_result[0,0] = 3 * a[0] * (a[0]*x[0] + b[0]) * (a[0]*x[0] + b[0]);
      g_result[0,1] = -1.;
      g_result[1,0] = 3 * a[1] * (a[1]*x[0] + b[1]) * (a[1]*x[0] + b[1]);
      g_result[1,1] = -1.;
      return g_result;
     }
  };

При подстановке внутренних параметров a и b явные алгебраические уравнения задают ограничения для системы на основе пересекающихся кубических функций. Матрица Якоби ограничений имеет размер 2×2 и содержит частные производные каждой функции ограничения (строки) по каждой оптимизируемой переменной (столбцы).

Матрица градиента

Класс явно переопределяет метод orig_grad(), чтобы возвращать эту аналитическую матрицу. Подстановка конкретных значений a и b позволяет получить точную численную матрицу Якоби, вычисляемую при решении подзадач SLSQP.

Якобиан

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

Вывод скрипта slsqp_optimization_with_analytical_gradients.ex5



Интеграция решателя SLSQP

Чтобы интегрировать решатель SLSQP в существующую библиотеку условной волатильности, мы воспользуемся директивой препроцессора для включения условной компиляции. Таким образом, пользователи смогут выбирать оптимизатор, компилируя свои программы с заданным макросом __SLSQP__ или без него.

//+------------------------------------------------------------------+
//|                                                         mean.mqh |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#include"volatility.mqh"
#ifdef __SLSQP__
#include"..\..\slsqp.mqh"
#else
#include<Math\Alglib\delegatefunctions.mqh>
#include<Math\Alglib\optimization.mqh>
#endif

Для интеграции алгоритма SLSQP необходимо изменить класс HARX, адаптировав его к новому процессу оптимизации. Параметры модели волатильности определяются путём минимизации целевой функции с учётом двусторонних граничных ограничений и ограничений-неравенств; поэтому необходимо реализовать классы-обёртки для целевой функции и ограничений. Эти обёртки добавляются в класс HARX в качестве защищённых свойств, чтобы сохранить инкапсуляцию и в то же время предоставить решателю доступ к необходимой математической логике. Новые свойства класса заключены в блоки директив условной компиляции препроцессора.

//+------------------------------------------------------------------+
//| Heterogeneous Autoregression (HAR)                               |
//+------------------------------------------------------------------+
class HARX: public CArchModel
  {
protected:
#ifdef __SLSQP__
   class CObjectiveF: public CFunctor
     {
   private:
      vector            m_sigma,m_bc;
      matrix            m_vb;
      HARX*             m_obj;
      bool              m_centered,m_individual;
      double            m_epsilon;
      vector            obj_result;
      matrix            obj_gradient;
   public:
      //--- constructor, destructor
                     CObjectiveF(void) {}
                    ~CObjectiveF(void)
        {
         m_obj = NULL;
         obj_result = vector::Zeros(1);
         obj_gradient = matrix::Zeros(1,2);
        }
      void              setFuncParams(vector& s, vector& bc, matrix &vb, HARX &obj, bool individual=false, bool center = false, double ep=EMPTY_VALUE)
        {
         m_sigma  = s;
         m_bc = bc;
         m_vb = vb;
         m_obj = GetPointer(obj);
         m_individual = individual;
         m_centered = center;
         m_epsilon = ep;
         m_clip = true;
         m_grad_options.method = GRAD_POINT_2;
        }
      virtual double    orig_fun(vector& x) override
        {
         obj_result = CheckPointer(m_obj)!=POINTER_INVALID?m_obj.objective(x,m_sigma,m_bc,m_vb):obj_result;
         return obj_result[0];
        }
      virtual vector grad_fun(vector& x) override
        {
         obj_gradient = CheckPointer(m_obj)!=POINTER_INVALID?m_obj.jacobian(x,m_sigma,m_bc,m_vb,m_individual,m_centered,m_epsilon):obj_gradient;
         return obj_gradient.Row(0);
        }
     };
   class CIneqConstraints: public CConstraints
     {
   private:
      matrix            a;
      vector            b;
      vector            obj_result;
   public:
                     CIneqConstraints(void)
        {
        }
                    ~CIneqConstraints(void)
        {
        }
      void              setConstraints(matrix& a_, vector& b_)
        {
         a = a_;
         b = b_;
         m_m = int(a.Rows());
         m_n = int(a.Cols());
         obj_result =  vector::Zeros(m_n);
         m_options.method = GRAD_POINT_2;
        }
      virtual vector    orig_fun(vector& x) override
        {
         if(!a.Rows())
            return obj_result;
         obj_result = b - a.MatMul(x);
         return obj_result;
        }
     };
#else
Блок #else содержит существующий код, реализующий целевую функцию для оптимизатора minNLC. Класс CIneqConstraints инкапсулирует ограничения-неравенства процедуры оптимизации, а метод setConstraints() обрабатывает динамически задаваемые ограничения-неравенства. При этом целевая функция заключена в класс-обёртку CObjectiveF, производный от класса CFunctor. Его метод setFunParams() предоставляет интерфейс для задания постоянных параметров целевой функции.
#ifdef __SLSQP__
ArchModelResult   fit(double tol = 1e-4,uint maxits = 0,ENUM_COVAR_TYPE cov_type = COVAR_ROBUST, long first = 0, long last = -1)
  {
   return fit(EMPTY_VECTOR,EMPTY_VECTOR,tol,maxits,cov_type,first,last);
  }

ArchModelResult   fit(vector& startingvalues,vector& backcast,double tol = 1e-4, uint maxits = 0,ENUM_COVAR_TYPE cov_type = COVAR_ROBUST, long first = 0, long last = -1)
  {
   return ArchModelResult(m_params,pcov,r2,res_final,vol_final,cov_type,-1.0*llh[0],f_obs,l_obs);
  }
#else
ArchModelResult   fit(double scaling = 1.0, uint maxits = 0,ENUM_COVAR_TYPE cov_type = COVAR_ROBUST, long first = 0, long last = -1, double tol = 1e-9, bool guardsmoothness=false, double gradient_test_step = 0.0)
  {
   return fit(EMPTY_VECTOR,EMPTY_VECTOR,scaling,maxits,cov_type,first,last,tol,guardsmoothness,gradient_test_step);
  }
ArchModelResult   fit(vector& startingvalues,vector& backcast,double scaling = 1.0, uint maxits = 0,ENUM_COVAR_TYPE cov_type = COVAR_ROBUST, long first = 0, long last = -1, double tol = 1e-9, bool guardsmoothness=false, double gradient_test_step = 0.0)
  {
   return ArchModelResult(m_params,pcov,r2,res_final,vol_final,cov_type,-1.0*llh[0],f_obs,l_obs);
  }
#endif

Условная компиляция позволяет поддерживать в классе HARX по паре специализированных методов fit() для каждого оптимизатора, причём параметры каждого метода адаптированы к соответствующему оптимизатору. В методах fit(), адаптированных для SLSQP, исходный параметр масштабирования заменён параметром допуска, задающим относительный допуск по параметрам для определения сходимости. По умолчанию это значение установлено на 1·10⁻⁴. Кроме того, параметр `maxits` устанавливает жесткое ограничение на количество допустимых итераций.

CObject             obj;
CObjectiveF         obfunc;
CIneqConstraints    obfunc_constraints;

obfunc.setFuncParams(sigma2,bcast,vb,this);
obfunc_constraints.setConstraints(a,b);

all_bounds = all_bounds.Transpose();
obfunc.setBounds(all_bounds);
obfunc_constraints.setBounds(all_bounds);

if(!obfunc.initialize(sv) ||
   !obfunc_constraints.initialize(sv))
  {
   m_converged = false;
   return out;
  }
  
CSlsqp slsqp_minim;
slsqp_minim.SetInequalityConstraints(obfunc_constraints);
if(maxits)
   slsqp_minim.SetMaxEval(int(maxits));
if(fabs(tol))
   slsqp_minim.SetXtolRel(tol);

OptimizeResult minim_result = slsqp_minim.Minimize(obfunc);

if(minim_result.return_code<0)
  {
   Print(__FUNCTION__, " termination reason ", minim_result.return_code);
   m_converged = false;
   return out;
  }
else
  {
   m_params = minim_result.solution;
   m_converged = true;
  }
Метод fit() создаёт и инициализирует экземпляры классов-обёрток целевой функции и ограничений, прежде чем передать их решателю SLSQP. Теперь, когда наша библиотека волатильности доработана, мы можем протестировать её, скомпилировав скрипт VolatilityModelParameterComparison.mq5 с макросом __SLSQP__.
#define __SLSQP__
#include<slsqp_article\Arch\Univariate\mean.mqh>

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

USING SLSQP
MEAN_CONSTANT
VOL_GJR_GARCH
DIST_NORMAL
GARCH spec
P(1) O(1) Q(1) Power(2.000000)
MT5 model parameters:
[-0.02428054511106604,0.002293739492468097,0.01626899292823011,0.01434061687833297,0.971226894861318]
MT5 model LogLikelihood: 964.9296120064769
Python's Model Parameters [-0.0242805845484529,0.002293742963206083,0.01626902046373811,0.01434054744816164,0.9712268914708287]
Python's LogLikelihood: 964.9296120077307
//+------------------------------------------------------------------+
USING SLSQP
MEAN_CONSTANT
VOL_GARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(1) Power(2.000000)
MT5 model parameters:
[-0.0217010704352728,0.002655694264387353,0.02523836526782006,0.9686009128621481]
MT5 model LogLikelihood: 965.2777981527584
Python's Model Parameters [-0.02170062752089841,0.002653690530826297,0.02523174395053289,0.9686111317666565]
Python's LogLikelihood: 965.277797248645
//+------------------------------------------------------------------+
USING SLSQP
MEAN_CONSTANT
VOL_TARCH
DIST_NORMAL
GARCH spec
P(1) O(1) Q(1) Power(1.000000)
MT5 model parameters:
[-0.02774988476354253,0.003761754971217425,0.01425091738918219,0.02393074653396533,0.9737837093438352]
MT5 model LogLikelihood: 963.0059881813373
Python's Model Parameters [-0.02774962124001202,0.003761918497530642,0.01425295763143413,0.02392852230367382,0.9737827811881781]
Python's LogLikelihood: 963.0059881427078
//+------------------------------------------------------------------+
USING SLSQP
MEAN_CONSTANT
VOL_AVGARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(1) Power(1.000000)
MT5 model parameters:
[-0.02251447564097937,0.004184839168186854,0.03014105668755734,0.9698589433124427]
MT5 model LogLikelihood: 964.3159918165356
Python's Model Parameters [-0.02250404030999785,0.004185362811318036,0.03014462096952416,0.9698553790305747]
Python's LogLikelihood: 964.3159918481251
//+------------------------------------------------------------------+
USING SLSQP
MEAN_CONSTANT
VOL_AVARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(0) Power(1.000000)
MT5 model parameters:
[-0.02519436424425439,0.5912835460641531,0.1280667289474566]
MT5 model LogLikelihood: 993.2632358829796
Python's Model Parameters [-0.02519438925614133,0.5912835391625952,0.1280667401117837]
Python's LogLikelihood: 993.263235882966
//+------------------------------------------------------------------+
USING SLSQP
MEAN_CONSTANT
VOL_ARCH
DIST_NORMAL
GARCH spec
P(1) O(0) Q(0) Power(2.000000)
MT5 model parameters:
[-0.01996170926747607,0.3827916710157989,0.1197990642660044]
MT5 model LogLikelihood: 993.7152272187727
Python's Model Parameters [-0.01996231775953625,0.3827906664926961,0.1198013671195205]
Python's LogLikelihood: 993.7152272209562
//+------------------------------------------------------------------+

Результаты показывают, что реализация SLSQP позволила успешно достичь желаемого результата. Читатели могут повторить эти тесты, скомпилировав скрипт VolatilityModelParameterComparison.mq5 с макросом __SLSQP__ или без него, чтобы переключаться между двумя оптимизаторами.


Заключение

В результате систематического тестирования и целенаправленной отладки было установлено, что основным источником межплатформенных расхождений являлся оптимизатор, а не вычисление логарифма правдоподобия. Благодаря переносу SLSQP на MQL5 и его интеграции в процесс подгонки HARX (с явно заданными требованиями к ограничениям и границам параметров, вариантами вычисления градиента и настраиваемыми критериями остановки) библиотека волатильности на MQL5 теперь обеспечивает воспроизводимость результатов модуля ARCH для Python: оценки параметров и значения логарифма правдоподобия совпадают с эталонными результатами Python в пределах практически приемлемых численных допусков при использовании одинаковых начальных значений, способов обработки данных и спецификаций ограничений.

Помимо устранения расхождений в результатах, это обновление предоставляет пользователям MQL5 ряд практических возможностей: решатель SLSQP (CSlsqp), реализованный непосредственно на MQL5, унифицированные интерфейсы для целевых функций и ограничений (CFunctor/CConstraints), поддержку аналитических градиентов или градиентов, вычисляемых методом конечных разностей, а также настраиваемые допуски и правила остановки. Репозиторий также содержит скрипты для проверки и сравнения (LogLikelihoodVerification, VolatilityModelParameterComparison), позволяющие пользователям проверять результаты подгонки на собственных наборах данных, сопоставляя их с результатами модуля ARCH для Python. Итак, библиотека теперь обеспечивает воспроизводимый и проверяемый процесс оптимизации, результаты которого согласуются с эталонной реализацией на Python, и даёт разработчикам возможность явно контролировать процесс оптимизации и численные допуски.

Файл или папка Описание
MQL5/Include/slsqp_article/Arch Папка с заголовочными файлами для библиотеки моделирования условной волатильности
MQL5/Include/slsqp_article/Regression Папка с заголовочными файлами для различных утилит регрессионного анализа
MQL5/Include/slsqp_article/Jason.mqh Заголовочный файл библиотеки сериализации и десериализации JSON
MQL5/Include/slsqp_article/np.mqh Заголовочный файл с различными вспомогательными функциями для работы с векторами и матрицами
MQL5/Include/slsqp_article/slsqp.mqh Заголовочный файл основной реализации SLSQP
MQL5/Include/slsqp_article/win32_utils.mqh Заголовочный файл с различными определениями WIN32 API
MQL5/Scripts/slsqp_article/LogLikelihoodVerification.mq5 Скрипт, используемый для проверки реализации в MQL5 целевой функции, минимизируемой моделью условной волатильности
MQL5/Scripts/slsqp_article/mt5_volatility_processor.py Программа на языке Python, которая строит модель условной волатильности с использованием модуля ARCH
MQL5/Scripts/slsqp_article/slsqp_optimization_with_analytical_gradients.mq5 В этом скрипте показана оптимизация методом SLSQP с использованием аналитических градиентов
MQL5/Scripts/slsqp_article/slsqp_optimization_with_numerical_gradients.mq5 Скрипт демонстрирует оптимизацию методом SLSQP с использованием градиентов, вычисленных с помощью численной аппроксимации методом конечных разностей
MQL5/Scripts/slsqp_article/VolatilityModelParameterComparison.mq5 Скрипт, используемый для сравнения моделей условной волатильности, построенных на языке MQL5 (с использованием решателя SLSQP) и на языке Python

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

Прикрепленные файлы |
Альтернатива тиковому объему: Измерение рыночной активности по интервалам ожидания между котировками Альтернатива тиковому объему: Измерение рыночной активности по интервалам ожидания между котировками
Тиковый объем в основном отражает время суток, а его окончательное значение известно только после закрытия бара. Мы строим индикатор активности, который обновляется в реальном времени при каждой котировке, используя интервалы ожидания между изменениями котировок, устраняем внутридневной ритм и моделируем оставшуюся составляющую с помощью модели авторегрессионной условной длительности (ACD). Затем мы проверяем, улучшает ли этот показатель активности краткосрочные прогнозы волатильности, если текущая волатильность цены уже учтена в модели.
Разработка классического индикатора «Крестики-нолики» на языке MQL5 Разработка классического индикатора «Крестики-нолики» на языке MQL5
В данной статье на языке MQL5 реализован пользовательский индикатор «Крестики-нолики» (Point and Figure, PF), который отображает движение цены в столбцы X/O, используя фиксированный размер клетки и логику разворота через три клетки. Мы определяем базовую цену, преобразуем цены в интервалы клеток, управляем трендами и разворотами, автоматически масштабируем окно индикатора и отображаем символы с помощью объектов, обеспечивая четкое, независимое от времени представление трендов, прорывов и уровней поддержки и сопротивления.
От клонирования и коммитов к CI: Расширенные возможности MQL5 Algo Forge От клонирования и коммитов к CI: Расширенные возможности MQL5 Algo Forge
Мы разбираем возможности Algo Forge, важные для повседневной работы с MQL5: открытие репозиториев в MetaEditor, перевод README, вкладку Units, защиту веток и тегов, внесение правок в браузере, пакеты и CI на хосте с Windows. В статье приведены точные настройки и необходимые метки раннера, а также показано, как разрешать слияние (merge) только после успешной сборки. Вы получите воспроизводимые инструкции по защите кода, автоматизации компиляции и публикации артефактов.
RiskGate: Централизованное управление рисками для нескольких советников RiskGate: Централизованное управление рисками для нескольких советников
Во многих конфигурациях MetaTrader 5 на одном счете работают несколько советников, поэтому управление рисками оказывается разрозненным, а экспозиция по коррелирующим инструментам остается незамеченной. В статье представлен RiskGate — централизованный сервис, который оценивает торговые намерения советников на уровне всего счета: советники отправляют сигнал в формате JSON, а сервис возвращает поля approved, lot и reason. Вы увидите схему взаимодействия клиента и сервера, примеры правил (лимит дневного убытка, лимиты экспозиции и корреляции), архитектуру обработчика, проверенную модульными тестами, и пример советника. В результате обеспечивается согласованное управление рисками на уровне портфеля, а сами советники становятся проще.