MetaTrader 5 / Примеры
English 中文 Español Deutsch 日本語 Português
preview
Как реализовать автоматическую оптимизацию в советниках MQL5

Как реализовать автоматическую оптимизацию в советниках MQL5

MetaTrader 5 — Примеры |
690 1
Javier Santiago Gaston De Iriarte Cabrera
Javier Santiago Gaston De Iriarte Cabrera

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

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

Одним из основных преимуществ использования советника (EA) является то, что он может в конечном счете адаптироваться к рыночным условиям по мере их дальнейшего изменения. Советник автоматически адаптируется к текущей рыночной конъюнктуре, что сокращает необходимость в ручном контроле и изменении параметров. Это позволяет трейдерам постоянно использовать краткосрочные посекундные возможности и выполнять свою торговую стратегию с какими-либо перерывами. Кроме того, советник способен настраивать торговые стратегии каждый день на протяжении всего времени.

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

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

Как достигать своих целей, быть продуктивным (и как не попасть впросак!)

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


1. Настройка библиотек, входных параметров и диапазонов оптимизации для советника c авто-оптимизацией

1.1 Импортирует необходимые библиотеки

В начале строки, включив необходимые библиотеки MQL5:

#include <Trade\Trade.mqh>
#include <Arrays\ArrayObj.mqh>

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

1.2 Определение входных параметров

Далее определяем входные параметры для нашего советника: 

input int MA_Fast_Period = 10;     // Fast Moving Average Period
input int MA_Slow_Period = 20;     // Slow Moving Average Period
input ENUM_MA_METHOD MA_Method = MODE_SMA; // Moving Average Method
input ENUM_APPLIED_PRICE Applied_Price = PRICE_CLOSE; // Applied Price
input double LotSize = 0.1;        // Lot Size
input int StopLoss = 50;           // Stop Loss in points
input int TakeProfit = 100;        // Take Profit in points

// Optimization parameters
input bool AutoOptimize = false;   // Enable Auto Optimization
input int OptimizationPeriod = 5000; // Number of ticks between optimizations
input int MinDataPoints = 1000;    // Minimum number of data points for optimization

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

1.3 Глобальные переменные и хэндлы

Затем мы объявляем глобальные переменные и хэндлы, которые будут использоваться во всем советнике: 

CTrade trade;
int fastMA_Handle, slowMA_Handle;
double fastMA[], slowMA[];
int tickCount = 0;
CArrayObj* optimizationResults;

// Optimization ranges
const int MA_Fast_Min = 5, MA_Fast_Max = 50, MA_Fast_Step = 1;
const int MA_Slow_Min = 10, MA_Slow_Max = 100, MA_Slow_Step = 1;

Объект "CTrade" обрабатывает торговые операции, в то время как "fastMA_Handle" и `slowMA_Handle` используются для управления индикаторами скользящей средней. В массиве `optimizationResults` будут храниться результаты наших оптимизационных тестов.

1.4 Настройки оптимизации

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

  • Период быстрой скользящей средней: От 5 to 50, с шагом в 1- Период медленной скользящей средней: От 10 до 100 с шагом в 1
Эти диапазоны могут быть скорректированы в зависимости от ваших конкретных требований и характеристик инструмента, которым вы торгуете.


2. Реализация основной торговой логики

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

2.1 Функция OnInit()

Функция OnInit() вызывается при первой загрузке советника на график. Вот как мы это реализуем: 

int OnInit()
{
    // Initialize MA handles
    fastMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Fast_Period, 0, MA_Method, Applied_Price);
    slowMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Slow_Period, 0, MA_Method, Applied_Price);
    
    if(fastMA_Handle == INVALID_HANDLE || slowMA_Handle == INVALID_HANDLE)
    {
        Print("Failed to create MA indicators");
        return INIT_FAILED;
    }
    
    // Initialize optimization results array
    optimizationResults = new CArrayObj();
    
    return INIT_SUCCEEDED;
}

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

2.2 Функция OnDeinit()

Функция `OnDeinit()` вызывается, когда советник удаляется с графика или когда терминал закрывается. 

void OnDeinit(const int reason)
{
    // Release MA handles
    IndicatorRelease(fastMA_Handle);
    IndicatorRelease(slowMA_Handle);
    
    // Clean up optimization results
    if(optimizationResults != NULL)
    {
        delete optimizationResults;
        optimizationResults = NULL;
    }
}

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

2.3 Функция OnTick()

Функция `OnTick()` - это сердце нашего советника, которая вызывается на каждом тике выбранного символа: 

void OnTick()
{
    // Check if we have enough bars to calculate MAs
    if(Bars(_Symbol, PERIOD_CURRENT) < MA_Slow_Period) return;
    
    // Copy MA values
    if(CopyBuffer(fastMA_Handle, 0, 0, 2, fastMA) != 2) return;
    if(CopyBuffer(slowMA_Handle, 0, 0, 2, slowMA) != 2) return;
    
    // Auto Optimization
    if(AutoOptimize && ++tickCount >= OptimizationPeriod)
    {
        Optimize();
        tickCount = 0;
    }
    
    // Trading logic
    if(fastMA[1] <= slowMA[1] && fastMA[0] > slowMA[0])
    {
        // Open buy position
        double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
        trade.Buy(LotSize, _Symbol, ask, ask - StopLoss * _Point, ask + TakeProfit * _Point);
    }
    else if(fastMA[1] >= slowMA[1] && fastMA[0] < slowMA[0])
    {
        // Open sell position
        double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
        trade.Sell(LotSize, _Symbol, bid, bid + StopLoss * _Point, bid - TakeProfit * _Point);
    }
}

Данная функция выполняет несколько ключевых задач:

  1. Она проверяет, достаточно ли исторических данных для расчета скользящих средних.
  2. Она извлекает текущие значения скользящих средних.
  3. Если включена автоматическая оптимизация и пришло время для оптимизации (на основе количества тиков), вызывается функция `Optimize()`.
  4. Она реализует торговую логику, открывая позиции на покупку или продажу на основе пересечений скользящих средних.



3. Реализация логики оптимизации

Суть нашей функциональности автоматической оптимизации заключается в функции `Optimize()`. Давайте разберемся и проверим её составляющие.

3.1 Функция Optimize()

Вот общая структура функции `Optimize()`:

void Optimize()
{
    Print("Starting optimization...");
    
    optimizationResults.Clear();
    
    // Loop through all combinations of MA periods
    for(int fastPeriod = MA_Fast_Min; fastPeriod <= MA_Fast_Max; fastPeriod += MA_Fast_Step)
    {
        for(int slowPeriod = MA_Slow_Min; slowPeriod <= MA_Slow_Max; slowPeriod += MA_Slow_Step)
        {
            if(slowPeriod <= fastPeriod) continue; // Slow period should be greater than fast period
            
            double profit = TestParameters(fastPeriod, slowPeriod);
            
            OptimizationResult* result = new OptimizationResult;
            result.fastPeriod = fastPeriod;
            result.slowPeriod = slowPeriod;
            result.profit = profit;
            
            optimizationResults.Add(result);
        }
    }
    
    // Find the best result
    OptimizationResult* bestResult = NULL;
    for(int i = 0; i < optimizationResults.Total(); i++)
    {
        OptimizationResult* currentResult = optimizationResults.At(i);
        if(bestResult == NULL || currentResult.profit > bestResult.profit)
        {
            bestResult = currentResult;
        }
    }
    
    if(bestResult != NULL)
    {
// Update the EA parameters
        MA_Fast_Period = bestResult.fastPeriod;
        MA_Slow_Period = bestResult.slowPeriod;
        
        // Update indicator handles
        IndicatorRelease(fastMA_Handle);
        IndicatorRelease(slowMA_Handle);
        fastMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Fast_Period, 0, MA_Method, Applied_Price);
        slowMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Slow_Period, 0, MA_Method, Applied_Price);
        
        Print("Optimization complete. New parameters: Fast MA = ", MA_Fast_Period, ", Slow MA = ", MA_Slow_Period);
    }
    else
    {
        Print("Optimization failed to find better parameters.");
    }
}

3.2 Прохождение в цикле комбинаций параметров

Вложенные циклы в функции `Optimize()` позволяют тестировать все комбинации периодов быстрых и медленных скользящих средних в пределах заданных нами диапазонов. Такой процесс известен как «брутфорс» подход к оптимизации. 

for(int fastPeriod = MA_Fast_Min; fastPeriod <= MA_Fast_Max; fastPeriod += MA_Fast_Step)
{
    for(int slowPeriod = MA_Slow_Min; slowPeriod <= MA_Slow_Max; slowPeriod += MA_Slow_Step)
    {
        if(slowPeriod <= fastPeriod) continue; // Slow period should be greater than fast period
        
        double profit = TestParameters(fastPeriod, slowPeriod);
        
        // Store results...
    }
}

Мы пропускаем комбинации, в которых медленный период меньше или равен быстрому периоду, поскольку это не имеет смысла для нашей стратегии.

3.3 Хранение и сравнение результатов

Для каждой допустимой комбинации мы вызываем функцию `TestParameters()`, чтобы оценить ее эффективность. Результаты сохраняются в объекте `OptimizationResult` и добавляются в наш массив `optimizationResults`.

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

OptimizationResult* bestResult = NULL;
for(int i = 0; i < optimizationResults.Total(); i++)
{
    OptimizationResult* currentResult = optimizationResults.At(i);
    if(bestResult == NULL || currentResult.profit > bestResult.profit)
    {
        bestResult = currentResult;
    }
}

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


4. Параметры тестирования

Функция `TestParameters()` имеет решающее значение для оценки каждого набора параметров. Подробно рассмотрим её.

4.1 Функция TestParameters() 

double TestParameters(int fastPeriod, int slowPeriod)
{
    int maFast = iMA(_Symbol, PERIOD_CURRENT, fastPeriod, 0, MA_Method, Applied_Price);
    int maSlow = iMA(_Symbol, PERIOD_CURRENT, slowPeriod, 0, MA_Method, Applied_Price);
    
    if(maFast == INVALID_HANDLE || maSlow == INVALID_HANDLE)
    {
        Print("Failed to create MA indicators for testing");
        return -DBL_MAX;
    }
    
    double fastBuffer[], slowBuffer[];
    ArraySetAsSeries(fastBuffer, true);
    ArraySetAsSeries(slowBuffer, true);
    
    int copied = CopyBuffer(maFast, 0, 0, MinDataPoints, fastBuffer);
    copied = MathMin(copied, CopyBuffer(maSlow, 0, 0, MinDataPoints, slowBuffer));
    
    if(copied < MinDataPoints)
    {
        Print("Not enough data for testing");
        return -DBL_MAX;
    }
    
    double profit = 0;
    for(int i = 1; i < copied; i++)
    {
        if(fastBuffer[i] > slowBuffer[i] && fastBuffer[i-1] <= slowBuffer[i-1])
        {
            // Buy signal
            profit += Close[i-1] - Open[i];
        }
        else if(fastBuffer[i] < slowBuffer[i] && fastBuffer[i-1] >= slowBuffer[i-1])
        {
            // Sell signal
            profit += Open[i] - Close[i-1];
        }
    }
    
    IndicatorRelease(maFast);
    IndicatorRelease(maSlow);
    
    return profit;
}

4.2 Создание временных индикаторов

Для каждого тестируемого набора параметров мы создаем временные индикаторы скользящей средней:

int maFast = iMA(_Symbol, PERIOD_CURRENT, fastPeriod, 0, MA_Method, Applied_Price);
int maSlow = iMA(_Symbol, PERIOD_CURRENT, slowPeriod, 0, MA_Method, Applied_Price);

Эти временные индикаторы позволяют рассчитывать скользящие средние с разными периодами, не влияя на нашу основную торговую логику.

4.3 Моделирование сделок

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

for(int i = 1; i < copied; i++)
{
    if(fastBuffer[i] > slowBuffer[i] && fastBuffer[i-1] <= slowBuffer[i-1])
    {
        // Buy signal
        profit += Close[i-1] - Open[i];
    }
    else if(fastBuffer[i] < slowBuffer[i] && fastBuffer[i-1] >= slowBuffer[i-1])
    {
        // Sell signal
        profit += Open[i] - Close[i-1];
    }
}

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

4.4 Расчет прибыли

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


5. Применение оптимизированных параметров

Как только найдем наиболее эффективные параметры, нужно применить их к нашему советнику.

5.1 Обновление параметров советника

Мы обновляем наши глобальные переменные, вводя в них новые оптимальные значения: 

MA_Fast_Period = bestResult.fastPeriod;
MA_Slow_Period = bestResult.slowPeriod;

5.2 Воссоздание хэндлов индикаторов

После обновления параметров надо заново создать наши хэндлы индикаторов: 

IndicatorRelease(fastMA_Handle);
IndicatorRelease(slowMA_Handle);
fastMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Fast_Period, 0, MA_Method, Applied_Price);
slowMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Slow_Period, 0, MA_Method, Applied_Price);

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


6. Передовые методы оптимизации

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

6.1 Многокритериальная оптимизация

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

struct OptimizationResult
{
    int fastPeriod;
    int slowPeriod;
    double profit;
    double drawdown;
    double sharpeRatio;
};

double CalculateScore(const OptimizationResult &result)
{
    return result.profit * 0.5 + result.sharpeRatio * 0.3 - result.drawdown * 0.2;
}

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

6.2 Пошаговая форвард-оптимизация

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

Это может помочь предотвратить переобучение: 

void WalkForwardOptimization()
{
    int totalBars = Bars(_Symbol, PERIOD_CURRENT);
    int segmentSize = 1000; // Adjust as needed
    
    for(int i = 0; i < totalBars - 2*segmentSize; i += segmentSize)
    {
        // Optimize on segment i to i+segmentSize
        OptimizeSegment(i, i+segmentSize);
        
        // Test on segment i+segmentSize to i+2*segmentSize
        TestSegment(i+segmentSize, i+2*segmentSize);
    }
}

6.3 Адаптивная настройка параметров

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

void AdaptParameters()
{
    double recentPerformance = CalculateRecentPerformance();
    double adaptationRate = 0.1; // Adjust as needed
    
    MA_Fast_Period += (int)((bestResult.fastPeriod - MA_Fast_Period) * adaptationRate * recentPerformance);
    MA_Slow_Period += (int)((bestResult.slowPeriod - MA_Slow_Period) * adaptationRate * recentPerformance);
}

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



7. Практические рекомендации

При реализации и доработке своего советника с автоматической оптимизацией, учитывайте следующие рекомендации:

7.1 Выбор частоты оптимизации

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

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

bool ShouldOptimize()
{
    double recentVolatility = CalculateRecentVolatility();
    int dynamicPeriod = (int)(OptimizationPeriod * (1 + recentVolatility));
    
    return tickCount >= dynamicPeriod;
}

7.2 Баланс между адаптивностью и стабильностью

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

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

void LimitParameterChange(int &parameter, int newValue, int maxChange)
{
    int change = newValue - parameter;
    change = MathMax(-maxChange, MathMin(change, maxChange));
    parameter += change;
}

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

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


8. Разработка автооптимизирующего советника ставит новые задачи в области отладки и устранения неисправностей

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

8.2 Чтобы облегчить отладку, настоятельно рекомендуется реализовать комплексное ведение лога. Это позволит детально отслеживать поведение советника и процесс оптимизации, помогая более эффективно выявлять и устранять проблемы.

Внедрите комплексное ведение лога для отслеживания поведения советника и процесса оптимизации: 
void Log(string message)
{
    Print(TimeToString(TimeCurrent()) + ": " + message);
    
    int handle = FileOpen("EA_Log.txt", FILE_WRITE|FILE_READ|FILE_TXT);
    if(handle != INVALID_HANDLE)
    {
        FileSeek(handle, 0, SEEK_END);
        FileWriteString(handle, TimeToString(TimeCurrent()) + ": " + message + "\n");
        FileClose(handle);
    }
}

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

8.3 Тестер стратегий MetaTrader - это бесценный инструмент для отладки вашего советника. Можно использовать визуальный режим для пошагового просмотра поведения вашего советника, позволяющего получить подробное представление о том, как работает советник в режиме реального времени. Кроме того, сравнение результатов оптимизации в тестере стратегий с результатами автоматической оптимизации вашего советника может помочь выявить любые расхождения. Функция оптимизации в тестере стратегий также служит полезным способом проверки работоспособности функции TestParameters().



9. Эффективность и проблемы советника с автоматической оптимизацией скользящей средней

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

Мы провели тестирование на исторических данных нашего советника с автоматической оптимизацией пересечения скользящих средних на данных за первое полугодие по паре EURUSD, охватывающих период с 2010 по 2020 год. Советник был настроен на оптимизацию своих параметров каждые 5000 тиков. Результаты были многообещающими: общая чистая прибыль составила 15 420 долларов США, профит-фактор - 1,65, а максимальная просадка составила 2 105 долларов США за 1247 сделок.

Затем мы сравнили эти результаты с тем же советником, используя статические параметры (MA_Fast_Period = 10, MA_Slow_Period = 20). Статическая версия принесла общую чистую прибыль в размере 8 750 долларов США, профит-фактор составил 1,38, а максимальная просадка составила 3 210 долларов США в результате 1 562 сделок. Это сравнение показало, что версия с автоматической оптимизацией значительно улучшила как общую прибыльность, так и доходность с поправкой на риск.

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


10. Будущие тенденции в области советников с автоматической оптимизацией: Машинное обучение, внешние данные, а также облачные решения

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

Алгоритмы машинного обучения потенциально могут улучшить процесс оптимизации за счет выявления сложных паттернов в рыночных данных: 

from sklearn.ensemble import RandomForestRegressor

def ml_optimize(data, labels):
    model = RandomForestRegressor(n_estimators=100)
    model.fit(data, labels)
    return model.feature_importances_

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

10.2 Интеграция с внешними источниками данных

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

string GetExternalData()
{
    string cookie=NULL,headers;
    char post[],result[];
    int res;
    
    string url="https://api.example.com/economic-data";
    
    res=WebRequest("GET",url,cookie,NULL,500,post,0,result,headers);
    
    if(res==-1)
    {
        Print("Error in WebRequest. Error code  =",GetLastError());
        return "";
    }
    
    string resultString=CharArrayToString(result);
    return resultString;
}

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

10.3 Облачная оптимизация

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

void CloudOptimize()
{
    string optimizationData = PrepareOptimizationData();
    string url = "https://your-cloud-service.com/optimize";
    string headers = "Content-Type: application/json\r\n";
    char post[], result[];
    string resultHeaders;
    
    StringToCharArray(optimizationData, post);
    
    int res = WebRequest("POST", url, headers, 30000, post, result, resultHeaders);
    
    if(res == -1)
    {
        Print("Error in WebRequest. Error code =", GetLastError());
        return;
    }
    
    string optimizationResult = CharArrayToString(result);
    ApplyCloudOptimizationResult(optimizationResult);
}

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

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

void WeeklyPerformanceReview()
{
    datetime startOfWeek = iTime(_Symbol, PERIOD_W1, 0);
    double weeklyProfit = 0;
    int totalTrades = 0;
    
    for(int i = 0; i < HistoryDealsTotal(); i++)
    {
        ulong ticket = HistoryDealGetTicket(i);
        if(HistoryDealGetInteger(ticket, DEAL_TIME) >= startOfWeek)
        {
            weeklyProfit += HistoryDealGetDouble(ticket, DEAL_PROFIT);
            totalTrades++;
        }
    }
    
    Print("Weekly Performance: Profit = ", weeklyProfit, ", Trades = ", totalTrades);
}

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

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

Удачной торговли!

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

  1. Создание надежных торговых систем (Building Reliable Trading Systems) автор: Кейт Фитчен (Keith Fitschen)
  2. Алгоритмическая торговля: выигрышные стратегии и их обоснование (Algorithmic Trading: Winning Strategies and Their Rationale) автор: Эрни Чен (Ernie Chan)
  3. Машинное обучение для алгоритмической торговли (Machine Learning for Algorithmic Trading) автор: Стефан Янсен (Stefan Jansen)
  4. Документация по MQL5: Документация по MQL5
  5. Форум Forex Factory - Форум по программированию: Форум Forex Factory
  6. Quantopian Courses: Quantopian Courses


11. Пример кода советника

Ниже представлен полный код советника с автоматической оптимизацией. Скопируйте этот код в свой MetaEditor и скомпилируйте его для использования в MetaTrader 5. 

//+------------------------------------------------------------------+
//|                 Auto-Optimizing Moving Average Crossover EA      |
//| Copyright 2024, Javier Santiago Gaston de Iriarte Cabrera        |
//|               https://www.mql5.com/en/users/jsgaston/news        |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Javier Santiago Gaston de Iriarte Cabrera"
#property link      "https://www.mql5.com/en/users/jsgaston/news"
#property version   "1.00"
#property strict

// Include necessary libraries
#include <Trade\Trade.mqh>
#include <Arrays\ArrayObj.mqh>

// Input parameters
input ENUM_MA_METHOD MA_Method = MODE_SMA; // Moving Average Method
input ENUM_APPLIED_PRICE Applied_Price = PRICE_CLOSE; // Applied Price
input double LotSize = 0.01;        // Lot Size
input int StopLoss = 100;           // Stop Loss in points
input int TakeProfit = 200;        // Take Profit in points
input int Initial_MA_Fast_Period = 10;  // Initial Fast Moving Average Period
input int Initial_MA_Slow_Period = 20;  // Initial Slow Moving Average Period

// Optimization parameters
input bool AutoOptimize = true;    // Enable Auto Optimization
input int OptimizationPeriod = 5000; // Number of ticks between optimizations
input int MinDataPoints = 1000;    // Minimum number of data points for optimization

// Global variables
CTrade trade;
int fastMA_Handle, slowMA_Handle;
double fastMA[], slowMA[];
int tickCount = 0;
CArrayObj optimizationResults;
int MA_Fast_Period, MA_Slow_Period;

// Optimization ranges
const int MA_Fast_Min = 5, MA_Fast_Max = 50, MA_Fast_Step = 1;
const int MA_Slow_Min = 10, MA_Slow_Max = 100, MA_Slow_Step = 1;

// Class to hold optimization results
class OptimizationResult : public CObject
{
public:
    int fastPeriod;
    int slowPeriod;
    double profit;
};

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    MA_Fast_Period = Initial_MA_Fast_Period;
    MA_Slow_Period = Initial_MA_Slow_Period;

    // Initialize MA handles
    fastMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Fast_Period, 0, MA_Method, Applied_Price);
    slowMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Slow_Period, 0, MA_Method, Applied_Price);
    
    if(fastMA_Handle == INVALID_HANDLE || slowMA_Handle == INVALID_HANDLE)
    {
        Print("Failed to create MA indicators");
        return INIT_FAILED;
    }
    
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    // Release MA handles
    IndicatorRelease(fastMA_Handle);
    IndicatorRelease(slowMA_Handle);
    
    // Clean up optimization results
    optimizationResults.Clear();
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Check if we have enough bars to calculate MAs
    if(Bars(_Symbol, PERIOD_CURRENT) < MA_Slow_Period) return;
    
    // Copy MA values
    if(CopyBuffer(fastMA_Handle, 0, 0, 2, fastMA) != 2) return;
    if(CopyBuffer(slowMA_Handle, 0, 0, 2, slowMA) != 2) return;
    
    // Auto Optimization
    if(AutoOptimize && ++tickCount >= OptimizationPeriod)
    {
        Optimize();
        tickCount = 0;
    }
    
    // Trading logic
    if(fastMA[1] <= slowMA[1] && fastMA[0] > slowMA[0])
    {
        // Open buy position
        double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
        trade.Buy(LotSize, _Symbol, ask, ask - StopLoss * _Point, ask + TakeProfit * _Point);
    }
    else if(fastMA[1] >= slowMA[1] && fastMA[0] < slowMA[0])
    {
        // Open sell position
        double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
        trade.Sell(LotSize, _Symbol, bid, bid + StopLoss * _Point, bid - TakeProfit * _Point);
    }
}

//+------------------------------------------------------------------+
//| Optimization function                                            |
//+------------------------------------------------------------------+
void Optimize()
{
    Print("Starting optimization...");
    
    optimizationResults.Clear();
    
    // Loop through all combinations of MA periods
    for(int fastPeriod = MA_Fast_Min; fastPeriod <= MA_Fast_Max; fastPeriod += MA_Fast_Step)
    {
        for(int slowPeriod = MA_Slow_Min; slowPeriod <= MA_Slow_Max; slowPeriod += MA_Slow_Step)
        {
            if(slowPeriod <= fastPeriod) continue; // Slow period should be greater than fast period
            
            double profit = TestParameters(fastPeriod, slowPeriod);
            
            OptimizationResult* result = new OptimizationResult();
            result.fastPeriod = fastPeriod;
            result.slowPeriod = slowPeriod;
            result.profit = profit;
            
            optimizationResults.Add(result);
        }
    }
    
    // Find the best result
    OptimizationResult* bestResult = NULL;
    for(int i = 0; i < optimizationResults.Total(); i++)
    {
        OptimizationResult* currentResult = optimizationResults.At(i);
        if(bestResult == NULL || currentResult.profit > bestResult.profit)
        {
            bestResult = currentResult;
        }
    }
    
    if(bestResult != NULL)
    {
        // Update the EA parameters
        MA_Fast_Period = bestResult.fastPeriod;
        MA_Slow_Period = bestResult.slowPeriod;
        
        // Update indicator handles
        IndicatorRelease(fastMA_Handle);
        IndicatorRelease(slowMA_Handle);
        fastMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Fast_Period, 0, MA_Method, Applied_Price);
        slowMA_Handle = iMA(_Symbol, PERIOD_CURRENT, MA_Slow_Period, 0, MA_Method, Applied_Price);
        
        Print("Optimization complete. New parameters: Fast MA = ", MA_Fast_Period, ", Slow MA = ", MA_Slow_Period);
    }
    else
    {
        Print("Optimization failed to find better parameters.");
    }
}

//+------------------------------------------------------------------+
//| Test a set of parameters                                         |
//+------------------------------------------------------------------+
double TestParameters(int fastPeriod, int slowPeriod)
{
    int maFast = iMA(_Symbol, PERIOD_CURRENT, fastPeriod, 0, MA_Method, Applied_Price);
    int maSlow = iMA(_Symbol, PERIOD_CURRENT, slowPeriod, 0, MA_Method, Applied_Price);
    
    if(maFast == INVALID_HANDLE || maSlow == INVALID_HANDLE)
    {
        Print("Failed to create MA indicators for testing");
        return -DBL_MAX;
    }
    
    double fastBuffer[], slowBuffer[];
    ArraySetAsSeries(fastBuffer, true);
    ArraySetAsSeries(slowBuffer, true);
    
    int copied = CopyBuffer(maFast, 0, 0, MinDataPoints, fastBuffer);
    copied = MathMin(copied, CopyBuffer(maSlow, 0, 0, MinDataPoints, slowBuffer));
    
    if(copied < MinDataPoints)
    {
        Print("Not enough data for testing");
        return -DBL_MAX;
    }
    
    double Close[], Open[];
    ArraySetAsSeries(Close, true);
    ArraySetAsSeries(Open, true);
    copied = CopyClose(_Symbol, PERIOD_CURRENT, 0, copied, Close);
    copied = MathMin(copied, CopyOpen(_Symbol, PERIOD_CURRENT, 0, copied, Open));
    
    double profit = 0;
    for(int i = 1; i < copied; i++)
    {
        if(fastBuffer[i] > slowBuffer[i] && fastBuffer[i-1] <= slowBuffer[i-1])
        {
            // Buy signal
            profit += Close[i-1] - Open[i];
        }
        else if(fastBuffer[i] < slowBuffer[i] && fastBuffer[i-1] >= slowBuffer[i-1])
        {
            // Sell signal
            profit += Open[i] - Close[i-1];
        }
    }
    
    IndicatorRelease(maFast);
    IndicatorRelease(maSlow);
    
    return profit;
}

//+------------------------------------------------------------------+
//| Custom function to log important events                          |
//+------------------------------------------------------------------+
void Log(string message)
{
    Print(TimeToString(TimeCurrent()) + ": " + message);
    
    int handle = FileOpen("EA_Log.txt", FILE_WRITE|FILE_READ|FILE_TXT);
    if(handle != INVALID_HANDLE)
    {
        FileSeek(handle, 0, SEEK_END);
        FileWriteString(handle, TimeToString(TimeCurrent()) + ": " + message + "\n");
        FileClose(handle);
    }
}

Как пользоваться этим советником

  1. Скопируйте весь код в новый файл в MetaEditor.
  2. Сохраните файл с расширением .mq5 (например, "AutoOptimizingMA.mq5").
  3. Скомпилируйте советник, нажав кнопку "Compile" или нажав клавишу F7.
  4. В MetaTrader 5 перетащите скомпилированный советник на график.
  5. При необходимости отрегулируйте входные параметры в окне настроек советника.
  6. Включите AutoTrading и запустите советник.

Основные особенности данного советника

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

Важные примечания

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

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

Настройки


Входные параметры

График


Тестирование на истории

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

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

Удачи и пусть ваша торговля будет прибыльной!

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

Прикрепленные файлы |
Загрузить ZIP
AutoOptimize_Final.mq5 (8.69 KB)

Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.

Другие статьи автора

Последние комментарии | Перейти к обсуждению на форуме трейдеров (1)
Aliaksandr Kazunka
Aliaksandr Kazunka | 14 апр. 2025 в 16:19
Привет! Твой вариант самый простейший. Но вот, к примеру, у нас есть 3 МА с разными периодами. Сигнал в бай - это выстраивание МА от меньшей к большей, селл -  наоборот. Так вот стоит вопрос самооптимизации советника, которая включает в себя подбор оптимальных периодов МА, объема лота, шага сетки ордеров, умножителя лота для сетки ордеров и размера тейкпрофита. Вот где задача
Возможности Мастера MQL5, которые вам нужно знать (Часть 40): Parabolic SAR Возможности Мастера MQL5, которые вам нужно знать (Часть 40): Parabolic SAR
Parabolic Stop-and-Reversal (SAR) - это индикатор точек подтверждения и окончания тренда. Поскольку он отстает в определении трендов, его основной целью было позиционирование скользящих стоп-лоссов по открытым позициям. Мы рассмотрим, можно ли его использовать в качестве сигнала советника с помощью пользовательских классов сигналов советников, собранных с помощью Мастера.
Пример CNA (сетевого анализа причинно-следственных связей), SMOC (оптимального управления стохастической моделью) и теории игр Нэша с Глубоким обучением Пример CNA (сетевого анализа причинно-следственных связей), SMOC (оптимального управления стохастической моделью) и теории игр Нэша с Глубоким обучением
Мы добавим Глубокое обучение к тем трем примерам, которые были опубликованы в предыдущих статьях, и сравним результаты с предыдущими. Цель состоит в том, чтобы научиться каким образом добавлять Глубокое обучение (DL) в другие советники.
Нейросети в трейдинге: Актер—Режиссёр—Критик (Actor—Director—Critic) Нейросети в трейдинге: Актер—Режиссёр—Критик (Actor—Director—Critic)
Предлагаем познакомиться с фреймворком Actor-Director-Critic, который сочетает в себе иерархическое обучение и многокомпонентную архитектуру для создания адаптивных торговых стратегий. В этой статье мы подробно рассмотрим, как использование Режиссера для классификации действий Актера помогает эффективно оптимизировать торговые решения и повышать устойчивость моделей в условиях финансовых рынков.
Возможности Мастера MQL5, которые вам нужно знать (Часть 39): Индекс относительной силы Возможности Мастера MQL5, которые вам нужно знать (Часть 39): Индекс относительной силы
RSI — популярный импульсный осциллятор, который измеряет темп и размер недавнего изменения цены ценной бумаги для оценки ситуаций переоценки или недооценки ее цены. Эти знания о скорости и масштабах имеют ключевое значение для определения точек разворота. Мы применим этот осциллятор в работе очередного пользовательского класса сигналов и изучим особенности некоторых из его сигналов. Однако начнем мы с того, что подведем итог нашему разговору о полосах Боллинджера.