Нейросети — это просто (Часть 40): Подходы к использованию Go-Explore на большом объеме данных

Введение

В предыдущей статье "Нейросети — это просто (Часть 39): Go-Explore — иной подход к исследованию" мы ознакомились с алгоритмом Go-Explore и его способностью хорошо исследовать окружающую среду. Напомню, что данный алгоритм включает 2 этапа:

• Фаза 1 — исследование
  
• Фаза 2 — обучение политики на базе примеров

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

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

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

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

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

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

1. Сложности использования Go-Explore с увеличением периода обучения

С увеличением периода обучения алгоритма Go-Explore возникают определенные сложности, которые могут затруднить его использование. Некоторые из них включают:

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

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

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

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

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

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

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

Также можно использовать различные подходы к выбору действий, такие как методы исследования с уверенностью (confidence-based exploration), которые позволяют агенту исследовать новые регионы пространства состояний, учитывая не только вероятность получения вознаграждения, но и уверенность в своих знаниях о задаче. Это может помочь избежать проблемы "застревания" в локальных оптимумах и обеспечить более эффективное исследование пространства состояний.

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

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

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

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

Также можно использовать методы обучения, которые учитывают изменение среды во время обучения, например методы, основанные на обучении с подкреплением с использованием моделей (model-based RL), которые строят модель среды и используют ее для прогнозирования будущих состояний и наград. Это позволяет агенту адаптироваться к изменениям в среде и принимать более обоснованные решения.

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

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

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

2. Варианты оптимизации подхода

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

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

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

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

Для определения значения константы мы воспользуемся простой математикой. В среднем один календарный месяц содержит 21-22 рабочих дня. Чтобы избежать ошибок, мы будем использовать максимальное значение рабочих дней — 22. За 4 месяца будет 88 рабочих дней.

При тестировании моделей мы используем таймфрейм H1. В сутках 24 часа. Таким образом, для обучения модели нам потребуется буфер из 2112 элементов (88 * 24). Эти расчеты учитывают возможные максимальные значения и немного превышают реальное количество баров, что позволяет не бояться критической ошибки выхода за размеры массива. Однако, при обучении на котировках включая выходные дни (к примеру, криптовалюта), следует использовать календарные дни для расчета размера буфера, учитывая полный период обучения и особенности котировок инструмента.

#define                    Buffer_Size  2112

Вторым узким местом является сортировка примеров перед их сохранением. Практика показала, что сортировка данных может занимать больше времени, чем сам процесс прохода по историческим данным и сбора этих состояний. С увеличением периода обучения будет расти и объем данных для сортировки. Поэтому мы решили отказаться от сортировки данных. В результате функция OnTesterDeinit в советнике Faza1.mq5 получила следующий вид:

//+------------------------------------------------------------------+
//| TesterDeinit function                                            |
//+------------------------------------------------------------------+
void OnTesterDeinit()
  {
//---
   int total = ArraySize(Total);
   printf("total %d", total);
   Print("Saving...");
   SaveTotalBase();
   Print("Saved");
  }

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

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

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

      Base[action_count - 1].value = ( Base[action_count - 1].state[241] - state[241] + 
                                       Base[action_count - 1].state[240] - state[240] ) / 2.0f;

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

input double               MaxPosition = 0.1;

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

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

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

   switch(act)
     {
      case 0:
         if(buy_value >= MaxPosition || !Trade.Buy(Symb.LotsMin(), Symb.Name()))
            act = 3;
         break;
      case 1:
         if(sell_value >= MaxPosition || !Trade.Sell(Symb.LotsMin(), Symb.Name()))
            act = 3;
         break;
      case 2:
         for(int i = PositionsTotal() - 1; i >= 0; i--)
            if(PositionGetSymbol(i) == Symb.Name())
               if(!Trade.PositionClose(PositionGetInteger(POSITION_IDENTIFIER)))
                 {
                  act = 3;
                  break;
                 }
         break;
     }

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

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

input int                  MaxLifeTime = 48;

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

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

   int total = PositionsTotal();
   datetime time_current = TimeCurrent();
   int first_order = 0;
   for(int i = 0; i < total; i++)
     {
      if(PositionGetSymbol(i) != Symb.Name())
         continue;
      switch((int)PositionGetInteger(POSITION_TYPE))
        {
         case POSITION_TYPE_BUY:
            buy_value += PositionGetDouble(POSITION_VOLUME);
            buy_profit += PositionGetDouble(POSITION_PROFIT);
            break;
         case POSITION_TYPE_SELL:
            sell_value += PositionGetDouble(POSITION_VOLUME);
            sell_profit += PositionGetDouble(POSITION_PROFIT);
            break;
        }
      first_order = MathMax((int)(PositionGetInteger(POSITION_TIME) - time_current) / PeriodSeconds(TimeFrame), first_order);
     }

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

   int act = (first_order < MaxLifeTime ? SampleAction(4) : 2);

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

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

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

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

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

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

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

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

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

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

• MinStartSteps — минимальное количество шагов до начала семплирования
• MaxSteps — максимальное количество шагов семплирования (размер эпизода)
• MinProfit — минимальная прибыль для сохранения в базу примеров.

input int                  MinStartSteps = 96;
input int                  MaxSteps = 120;
input double               MinProfit = 10;

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

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

В методе OnInit нашего советника Faza1.mq5 после загрузки созданной ранее базы примеров мы сначала отбираем примеры, удовлетворяющие требованию по количеству пройденных шагов.

   if(LoadTotalBase())
     {
      int total = ArraySize(Total);
      Cell temp[];
      ArrayResize(temp, total);
      int count = 0;
      for(int i = 0; i < total; i++)
         if(Total[i].total_actions >= MinStartSteps)
           {
            temp[count] = Total[i];
            count++;
           }

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

      if(count > 0)
        {
         count = (int)(((double)(MathRand() * MathRand()) / MathPow(32768.0, 2.0)) * (count - 1));
         StartCell = temp[count];
        }
      else
        {
         count = (int)(((double)(MathRand() * MathRand()) / MathPow(32768.0, 2.0)) * (total - 1));
         StartCell = Total[count];
        }
     }

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

void OnTick()
  {
//---
   if(!IsNewBar())
      return;
   bar++;
   if(bar < StartCell.total_actions)
     {
      switch(StartCell.actions[bar])
        {
         case 0:
            Trade.Buy(Symb.LotsMin(), Symb.Name());
            break;
         case 1:
            Trade.Sell(Symb.LotsMin(), Symb.Name());
            break;
         case 2:
            for(int i = PositionsTotal() - 1; i >= 0; i--)
               if(PositionGetSymbol(i) == Symb.Name())
                  Trade.PositionClose(PositionGetInteger(POSITION_IDENTIFIER));
            break;
        }
      return;
     }

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

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

   int act = (action_count < MaxSteps || first_order < MaxLifeTime ? SampleAction(4) : 2);

И через один ход инициализируем завершение работы советника.

   if(action_count > MaxSteps)
      ExpertRemove();

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

//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
//---
   double ret = 0.0;
//---
   double profit = TesterStatistics(STAT_PROFIT);
   action_count--;
   if(profit >= MinProfit)
      FrameAdd(MQLInfoString(MQL_PROGRAM_NAME), action_count, profit, Base);
//---
   return(ret);
  }

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

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

Сбор примеров для обучения модели мы, как и в предыдущей статье будем осуществлять на исторических данных инструмента EURUSD таймфрейма H1. Только на этот раз мы будем использовать исторические данные за 4 месяца 2023 года.

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

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

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

Пороговое значение прибыли мы указываем близкое к 0. Ведь это первый проход и нам достаточно получить небольшую прибыль.

В результате перового прохода процесса оптимизации мы видим несколько успешных проходов с достижением прибыли в 46 USD за первые 2 недели января 2023 года. Профит-фактор таких проходов достигает значения 1.55

Перед запуском оптимизации мы произведем некоторые изменения в параметрах. Чтобы сбор примеров осуществлялся в различные временные отрезки, мы добавим в нашу оптимизируемую переменную минимальное количество шагов до начала семплирования. Значения этой переменной будут варьироваться от 1 до 3 недель с шагом в неделю. Кроме того, мы улучшим полученные результаты, увеличив пороговое значение прибыли до 40 USD.

По результатам второго прохода оптимизации мы видим увеличение прибыли до 84 USD за январь 2023 года. Хотя и наблюдается снижение профит-фактора до 1.38.

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

Увеличим минимальное значение количество шагов до начала семплирования на вторую неделю января 2023 года и проведем еще один процесс оптимизации. На это раз мы увеличим значение минимальной доходности до 80 USD. Ведь мы стремимся к поиску наиболее прибыльной стратегии.

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

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

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

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

Заключение

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

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

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

Ссылки

1. Go-Explore: a New Approach for Hard-Exploration Problems
2. Нейросети — это просто (Часть 35): Модуль внутреннего любопытства (Intrinsic Curiosity Module)
3. Нейросети — это просто (Часть 36): Реляционные модели обучения с подкреплением (Relational Reinforcement Learning)
4. Нейросети — это просто (Часть 37): Разреженное внимание (Sparse Attention)
5. Нейросети — это просто (Часть 38): Исследование с самоконтролем через несогласие (Self-Supervised Exploration via Disagreement)
6. Нейросети — это просто (Часть 39): Go-Explore — иной подход к исследованию

Программы, используемые в статье

#	Имя	Тип	Описание
1	Faza1.mq5	Советник	Советник первой фазы
2	Faza2.mql5	Советник	Советник второй фазы
3	GE-lerning.mq5	Советник	Советник тонкой настройки политики
4	Cell.mqh	Библиотека класса	Структура описания состояния системы
5	FQF.mqh	Библиотека класса	Библиотека класса организации работы полностью параметризированной модели
6	NeuroNet.mqh	Библиотека класса	Библиотека классов для создания нейронной сети
7	NeuroNet.cl	Библиотека	Библиотека кода программы OpenCL