Построение моделей волатильности в MQL5 (Часть III): Реализация алгоритма SLSQP для оценки моделей
Содержание
- Введение
- Анализ расхождений
- Оптимизатор последовательного программирования методом наименьших квадратов (SLSQP)
- Обзор реализации SLSQP на MQL5
- Определение целевой функции и ограничений
- Настройка и инициализация
- Выполнение и результаты
- Интеграция решателя SLSQP
- Заключение
Введение
Библиотека волатильности, портированная на 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, в ходе которого на обеих платформах выполнялся вызов целевой функции и производилось сравнение результатов. Ниже приведены результаты трёх запусков с различными спецификациями модели.

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

Условия ККТ представляют собой набор необходимых математических требований, определяющих, когда оптимизатор успешно нашел оптимальное решение задачи с ограничениями. Оптимизация с ограничениями представляет особую сложность, поскольку абсолютный минимум целевой функции может находиться в недопустимой области. В то время как при оптимизации без ограничений достаточно просто найти точку, в которой градиент равен нулю, условия ККТ позволяют распространить этот принцип на области с ограничениями за счёт использования множителей Лагранжа. Эти множители действуют подобно математическим силам реакции ограничений, удерживая решатель в допустимой области. Чтобы точка считалась оптимальным решением, она должна одновременно удовлетворять четырем критериям.
- Допустимость прямой задачи: решение должно строго удовлетворять всем условиям и не может нарушать ни одно из ограничений-равенств и ограничений-неравенств.
- Допустимость двойственной задачи: множители Лагранжа для активных ограничений-неравенств должны быть неотрицательными, чтобы градиентные силы были направлены в допустимую область, а не в недопустимую.
- Условие дополняющей нежёсткости: для каждого ограничения-неравенства либо оно должно выполняться как равенство, либо его множитель должен быть равен нулю — в последнем случае ограничение не препятствует дальнейшему продвижению и оставляет свободу перемещения.
- Стационарность: градиенты целевой функции и всех активных ограничений должны полностью компенсировать друг друга, что указывает на то, что дальнейшее перемещение в допустимом направлении не может привести к снижению значения целевой функции.
Условия 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
Чтобы интегрировать решатель 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
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.