Разработка динамического советника на нескольких парах (Часть 3): Стратегии возврата к среднему и моментума

Введение

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

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

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

Логика советника

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

В основе механизма возврата к среднему обычно используются статистические инструменты, такие как Z-оценка, которая измеряет, насколько текущая цена отклоняется от скользящей средней в контексте стандартных отклонений. Высокая положительная Z-оценка указывает на то, что цена значительно выше своего среднего значения (возможная перекупленность), в то время как низкая отрицательная Z-оценка указывает на то, что она значительно ниже него (возможная перепроданность). Трейдеры устанавливают пороги (например, +-2.0), чтобы определить достаточно значимое отклонение, оправдывающее сделку. Как только порог будет преодолен и будут выполнены дополнительные условия (такие как ослабление моментума или сигнал разворота), откроется сделка с ожиданием, что цена вернется к среднему значению. Эта стратегия наиболее эффективна на рынках с колебаниями или возвратом к среднему и требует тщательного управления рисками, так как устойчивые тренды могут аннулировать сигналы возврата, если их не учитывать.

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

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

Приступим

//+------------------------------------------------------------------+
//|                                                Dyna Mean&Mom.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade/Trade.mqh>
#include <Math/Stat/Math.mqh>
CTrade trade;

Как всегда, мы начинаем с включения необходимых классов для правильной работы нашего советника. Одно из отличий, которое можно отметить в этот раз, заключается в том, что мы также включаем библиотеку `<Math/Stat/Math.mqh>`. Это дает нам доступ к мощным статистическим инструментам, таким как математическое ожидание (среднее, mean), стандартное отклонение и расчеты Z-оценки, которые необходимы для реализации как стратегий возврата к среднему, так и стратегий моментума.

//+------------------------------------------------------------------+
//|  Enhanced Mean-Reversion + Momentum EA                           |
//+------------------------------------------------------------------+

//--- Input settings
input string Symbols = "XAUUSD,GBPUSD,USDCAD,USDJPY";
input int    TakeProfit = 150;        // TP in points
input int    StopLoss = 100;           // SL in points
input int    MAPeriod = 20;
input int    MomentumPeriod = 5;
input double Z_Threshold = 2.0;
input double Mom_Threshold = 1.5;     // Price change in standard deviations
input double RiskPercent_High = 1.5, RiskPercent_Mod = 1.0, RiskPercent_Low = 0.5;

В этом разделе кода мы определяем входные настройки для советника. Это позволяет пользователю указать список торговых символов (например, XAUUSD, GBPUSD), установить ключевые параметры управления рисками, такие как тейк-профит, стоп-лосс и процент риска, а также тонко настроить поведение стратегии с использованием статистических данных. К ним относятся период для скользящей средней, период, используемый для измерения моментума, и пороги как для Z-оценки, так и для силы моментума. Вместе эти данные помогают советнику адаптироваться к различным рыночным условиям, управляя рисками по нескольким валютным парам.

//--- Global parameters
string symb_List[];
int Num_symbs = 0;

// Indicator handles arrays
int MA_hndl[];
int STDev_hndl[];
int ATR_hndl[];

Здесь мы объявляем глобальные переменные, используемые в советнике. В него входит `symb_List[]`, массив для хранения списка торговых символов, и `Num_symbs`, который хранит общее количество символов, подлежащих обработке. Кроме того, мы определяем массивы для хэндлов индикаторов: `MA_hndl[]` для скользящей средней, `STDev_hndl[]` для стандартного отклонения и `ATR_hndl[]` для среднего истинного диапазона. Эти хэндлы используются для эффективного управления и доступа к данным индикаторов для каждого символа во время выполнения.

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit() {
    //--- Split symbol list
    ushort separator = StringGetCharacter(",", 0);
    StringSplit(Symbols, separator, symb_List);
    Num_symbs = ArraySize(symb_List);

    //--- Resize arrays
    ArrayResize(MA_hndl, Num_symbs);
    ArrayResize(STDev_hndl, Num_symbs);
    ArrayResize(ATR_hndl, Num_symbs);

    //--- Prepare each symbol
    for (int i = 0; i < Num_symbs; i++) {
        string symbol = symb_List[i];
        StringTrimLeft(symbol);
        StringTrimRight(symbol);
        
        //--- Create indicator handles
        MA_hndl[i] = iMA(symbol, PERIOD_H1, MAPeriod, 0, MODE_SMA, PRICE_CLOSE);
        STDev_hndl[i] = iStdDev(symbol, PERIOD_H1, MAPeriod, 0, MODE_SMA, PRICE_CLOSE);
        ATR_hndl[i] = iATR(symbol, PERIOD_H1, 14);
        
        if (MA_hndl[i] == INVALID_HANDLE || STDev_hndl[i] == INVALID_HANDLE || ATR_hndl[i] == INVALID_HANDLE) {
            Print("Failed to create indicator handles for ", symbol);
            return INIT_FAILED;
        }
    }
    
    //--- Set magic number for trade identification
    trade.SetExpertMagicNumber(54321);
    
    return INIT_SUCCEEDED;
}

В этом разделе мы инициализируем cоветника, когда он загружается на график. Мы начинаем с разбиения определяемой пользователем строки Symbols на массив и подсчета того, сколько символов будет обработано. Затем мы изменяем размеры массивов для хэндлов индикаторов так, чтобы они соответствовали количеству символов. Для каждого символа мы удаляем лишние пробелы и создаем хэндлы индикаторов для скользящей средней (MA), стандартного отклонения (STDev) и среднего истинного диапазона (ATR), при этом каждый индикатор рассчитывается на таймфрейме H1. Если какой-либо из хэндлов не удается инициализировать, советник выводит сообщение об ошибке и останавливается. Наконец, мы устанавливаем уникальный магический номер с помощью `trade.SetExpertMagicNumber(54321)`, чтобы было проще идентифицировать сделки, размещенные этим советником.

//+------------------------------------------------------------------+
//|          Mean and Momentum Signal Generator                      |
//+------------------------------------------------------------------+
void MeanAndMomentum(string symbol, int idx) {
    //--- Get current price data
    MqlRates current[];
    if(CopyRates(symbol, PERIOD_H1, 0, 1, current) < 1) return;
    double close = current[0].close;
    
    //--- Get historical price for momentum calculation
    MqlRates historical[];
    if(CopyRates(symbol, PERIOD_H1, MomentumPeriod, 1, historical) < 1) return;
    double histClose = historical[0].close;
    
    //--- Get indicator values
    double ma[1], stddev[1], atr[1];
    if(CopyBuffer(MA_hndl[idx], 0, 0, 1, ma) < 1) return;
    if(CopyBuffer(STDev_hndl[idx], 0, 0, 1, stddev) < 1) return;
    if(CopyBuffer(ATR_hndl[idx], 0, 0, 1, atr) < 1) return;
    
    //--- Calculate metrics
    double momentum = close - histClose;
    double zscore = (stddev[0] > 0) ? (close - ma[0]) / stddev[0] : 0;
    double momThreshold = Mom_Threshold * stddev[0]; // Dynamic momentum threshold
    
    //--- Determine signal type
    int signal = 0;
    double riskPercent = 0;
    
    bool meanReversionLong = (zscore < -Z_Threshold);
    bool meanReversionShort = (zscore > Z_Threshold);
    bool momentumLong = (momentum > momThreshold);
    bool momentumShort = (momentum < -momThreshold);
    
    //--- Signal priority: Momentum > Mean Reversion
    if(momentumLong && meanReversionLong) {
        signal = 1;
        riskPercent = RiskPercent_High; // Strong signal
    }
    else if(momentumShort && meanReversionShort) {
        signal = -1;
        riskPercent = RiskPercent_High;
    }
    else if(momentumLong) {
        signal = 1;
        riskPercent = RiskPercent_Mod;
    }
    else if(momentumShort) {
        signal = -1;
        riskPercent = RiskPercent_Mod;
    }
    else if(meanReversionLong) {
        signal = 1;
        riskPercent = RiskPercent_Low;
    }
    else if(meanReversionShort) {
        signal = -1;
        riskPercent = RiskPercent_Low;
    }
    
    //--- Exit if no signal
    if(signal == 0) return;
    
    //--- Check existing positions
    if(PositionSelect(symbol)) {
        long positionType = PositionGetInteger(POSITION_TYPE);
        if((positionType == POSITION_TYPE_BUY && signal == 1) || 
           (positionType == POSITION_TYPE_SELL && signal == -1)) {
            return; // Already in position in same direction
        }
        else {
            // Close opposite position before opening new one
            trade.PositionClose(symbol);
            Sleep(100); // Allow time for order execution
        }
    }
    
    //--- Calculate position size
    double lotSize = CalculatePositionSize(symbol, riskPercent, atr[0]);
    if(lotSize <= 0) return;
    
    //--- Execute trade
    ExecuteTrade(signal == 1 ? ORDER_TYPE_BUY : ORDER_TYPE_SELL, symbol, lotSize);
}

Функция `MeanAndMomentum()` генерирует торговые сигналы, сочетая в себе возврат к среднему и моментум для данного символа. Сначала извлекается самая последняя цена (Закрытие) и историческая цена с `MomentumPeriod` баров назад, которые используются для расчета моментума. Он также получает значения для скользящей средней, стандартного отклонения и среднего истинного диапазона (ATR), используя ранее инициализированные хэндлы индикаторов. С этими данными функция вычисляет Z-оценку , которая отражает, насколько текущая цена отклоняется от среднего значения в стандартных отклонениях, и моментум, который просто представляет собой изменение цены во времени. Динамический порог моментума также вычисляется путем масштабирования стандартного отклонения, что делает систему отзывчивой к изменяющимся условиям волатильности.

После того как эти метрики рассчитаны, функция оценивает, выполнены ли какие-либо условия для торгового сигнала. Он проверяет, указывает ли Z-оценка на возможность возврата к среднему (если цена далеко от среднего), а также достаточно ли силен моментум, чтобы предположить трендовое движение. Логика сигнала имеет многоуровневую структуру, отдавая приоритет случаям, когда как возврат к среднему, так и моментум направлены в одном направлении, присваивая таким случаям наивысший процент риска (RiskPercentage_High). Если выполнено только одно условие, система присваивает более низкий процент риска. Этот многослойный подход помогает советнику фильтровать более качественные сетапы и адаптировать свою экспозицию в зависимости от сигнала.

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

//+------------------------------------------------------------------+
//| Calculate position size based on risk and volatility             |
//+------------------------------------------------------------------+
double CalculatePositionSize(string symbol, double riskPercent, double atrValue) {
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskAmount = balance * (riskPercent / 100.0);
    
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE_LOSS);
    double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
    
    if(point <= 0 || tickValue <= 0 || tickSize <= 0) {
        Print("Invalid symbol parameters for ", symbol);
        return 0;
    }
    
    // Use ATR-based stop loss
    double slDistance = atrValue * 1.5;
    double lossPerLot = slDistance * (tickValue / tickSize);
    
    if(lossPerLot <= 0) {
        Print("Invalid loss calculation for ", symbol);
        return 0;
    }
    
    double lots = riskAmount / lossPerLot;
    lots = NormalizeLots(symbol, lots);
    
    return lots;
}

Функция `CalculatePositionSize()` определяет оптимальный размер лота для сделки на основе баланса счета трейдера, выбранного процента риска и текущей волатильности рынка, измеряемой средним истинным диапазоном (ATR). Сначала рассчитывается, какой суммой своего капитала в процентах от общего баланса счета трейдер готов рискнуть (riskAmount). Затем извлекаются ключевые торговые параметры для указанного символа, включая размер пункта, значение тика и размер тика, которые необходимы для преобразования движения цены в денежный риск.

Используя эти параметры, функция оценивает расстояние стоп-лосса, умножая значение ATR на 1.5, что позволяет учесть буфер, скорректированный на волатильность. Функция рассчитывает потенциальные убытки на стандартный лот на основе этого расстояния до стопа и значения тика на текущем символе. Затем вычисляется желаемый размер лота путем деления суммы риска на прогнозируемый убыток на один лот, что обеспечивает соответствие сделки установленному уровню риска. Наконец, функция вызывает `NormalizeLots()` для округления размера лота в соответствии с торговыми ограничениями символа и возвращает результат. Этот метод обеспечивает надлежащий размер каждой сделки в соответствии как с состоянием счета, так и с рыночными условиями.

//+------------------------------------------------------------------+
//| Normalize lot size to broker requirements                        |
//+------------------------------------------------------------------+
double NormalizeLots(string symbol, double lots) {
    double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
    double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
    
    if(lotStep > 0) {
        lots = MathRound(lots / lotStep) * lotStep;
    }
    
    lots = MathMax(minLot, MathMin(maxLot, lots));
    return lots;
}

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

//+------------------------------------------------------------------+
//| Execute trade with proper risk management                        |
//+------------------------------------------------------------------+
void ExecuteTrade(ENUM_ORDER_TYPE tradeType, string symbol, double lotSize) {
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double price = (tradeType == ORDER_TYPE_BUY) ? 
                   SymbolInfoDouble(symbol, SYMBOL_ASK) : 
                   SymbolInfoDouble(symbol, SYMBOL_BID);
    
    // Get current ATR for dynamic stop levels
    double atr[1];
    int idx = ArrayPosition(symbol);
    if(idx >= 0 && CopyBuffer(ATR_hndl[idx], 0, 0, 1, atr) > 0) {
        double slDistance = atr[0] * 1.5;
        double tpDistance = atr[0] * 2.5;
        
        double sl = (tradeType == ORDER_TYPE_BUY) ? 
                    price - slDistance : 
                    price + slDistance;
                    
        double tp = (tradeType == ORDER_TYPE_BUY) ? 
                    price + tpDistance : 
                    price - tpDistance;
        
        trade.PositionOpen(symbol, tradeType, lotSize, price, sl, tp, "MR-Mom System");
    }
    else {
        // Fallback to fixed stops if ATR fails
        double sl = (tradeType == ORDER_TYPE_BUY) ? 
                    price - (StopLoss * point) : 
                    price + (StopLoss * point);
                    
        double tp = (tradeType == ORDER_TYPE_BUY) ? 
                    price + (TakeProfit * point) : 
                    price - (TakeProfit * point);
        
        trade.PositionOpen(symbol, tradeType, lotSize, price, sl, tp, "MR-Mom System");
    }
}

Функция `ExecuteTrade()` отвечает за размещение сделки с соответствующими элементами управления рисками в зависимости от направления сделки, символа и рассчитанного размера лота. Сначала функция определяет текущую рыночную цену на основе цены Ask для покупок и цены Bid для продаж, а затем пытается получить последнее значение ATR для этого символа. Если данные по ATR доступны, она использует их для динамического расчета уровней стоп-лосса и тейк-профита: 1.5×ATR для стоп-лосса и 2.5×ATR для тейк-профита, обеспечивая, чтобы риск и вознаграждение были скорректированы в соответствии с текущей рыночной волатильностью. Затем открывается позиция с помощью метода `trade.PositionOpen()`  с рассчитанными ранее уровнями и меткой для идентификации.

//+------------------------------------------------------------------+
//| Find symbol position in array                                    |
//+------------------------------------------------------------------+
int ArrayPosition(string symbol) {
    for(int i = 0; i < Num_symbs; i++) {
        if(symb_List[i] == symbol) return i;
    }
    return -1;
}

Функция ищет заданный символ в массиве `symb_List` и возвращает его индекс; если символы не найдены, она возвращает -1. Это помогает корректно определить порядковое расположение символа в массиве для обращения к соответствующим хэндлам индикатора.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(){
   if(isNewBar()){
      for(int i = 0; i < Num_symbs; i++) {
         MeanAndMomentum(symb_List[i], i);
      }
   }
}

И наконец, сердцем cоветника является функция `OnTick()`, отвечающая за выполнение логики каждый раз, когда поступает новый тик. Чтобы избежать обработки на каждом тике, сначала проверяется, сформировалась ли новая свеча с помощью `isNewBar()`, что гарантирует, что сигналы оцениваются только один раз за свечу. Когда новая свеча подтверждается, функция проходит через все указанные символы и вызывает `MeanAndMomentum()` для каждого из них, позволяя советнику оценивать торговые возможности по нескольким парам в соответствии с последними данными рынка.

Результаты тестирования на исторических данных

Тестирование на исторических данных было проведено на часовом таймфрейме с использованием двухмесячного тестового окна (с 1 мая 2025 года по 20 июня 2025 года) со следующими входными настройками:

• TP в пунктах = 972
• SL в пунктах = 846
• Период МА = 80
• Период моментума = 43
• Z_Threshold = 3.0
• Изменение цены в стандартных отклонениях = 4.05
• Высокий процент риска = 9.75
• Умеренный процент риска = 10.0
• Низкий процент риска = 4.65

Заключение

Подведем итог:   мы разработали и внедрили динамический мультисимвольный cоветник, который сочетает в себе торговые стратегии, основанные как на возврате к среднему, так и на моментуме , и интеллектуально адаптируется к изменяющимся рыночным условиям. Используя статистические инструменты, такие как скользящие средние, стандартное отклонение (Z-оценка) и волатильность на основе ATR, мы разработали систему, способную одновременно анализировать несколько пар и принимать обоснованные торговые решения. Каждый символ отслеживается независимо, что позволяет создавать индивидуальные сигналы на основе поведения цены, волатильности и силы тренда. Стратегия отдает приоритет входам, при которых сигналы моментума и возврата к среднему совпадают, и учитывает настройки допустимого риска при выставлении размера позиций, обеспечивая эффективное управление риском.

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