Warrior_EA/references/MQL5/Experts/DADS/Study.mq5

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                                     Research.mq5 |

//|                                                   Copyright DNG<EFBFBD> |

//|                                https://www.mql5.com/en/users/dng |

//+------------------------------------------------------------------+

#property copyright "Copyright DNG<00>"

#property link      "https://www.mql5.com/en/users/dng"

#property version   "1.00"

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

#include "Trajectory.mqh"

//+------------------------------------------------------------------+

//| Input parameters                                                 |

//+------------------------------------------------------------------+

input int                  Iterations     = 1000;

input int                  DiscriminatorBatch   =  500;

input int                  AgentBatch     = 500;

input int                  SchedulerBatch  = 500;

input float                DiscountFactor  = 0.99f;

bool                 TrainMode = true;

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

STrajectory          Buffer[];

CFQF                 Actor;

CFQF                 Scheduler;

CNet                 Discriminator;

int                  Models = 1;

//---

float                dError;

datetime             dtStudied;

//---

CBufferFloat         State;

CBufferFloat         StateSkill;

CBufferFloat         *Result;

vector<float>        ActorResult;

vector<float>        SchedulerResult;

vector<float>        DiscriminatorResult;

//+------------------------------------------------------------------+

//| Expert initialization function                                   |

//+------------------------------------------------------------------+

int OnInit()

  {

//---

   ResetLastError();

   if(!LoadTotalBase())

     {

      PrintFormat("Error of load study data: %d", GetLastError());

      return INIT_FAILED;

     }

//--- load models

   float temp;

   if(!Actor.Load(FileName + "Act.nnw", dtStudied, true) ||

      !Scheduler.Load(FileName + "Sch.nnw", dtStudied, true) ||

      !Discriminator.Load(FileName + "Dscr.nnw", temp, temp, temp, dtStudied, true))

     {

      CArrayObj *actor = new CArrayObj();

      CArrayObj *scheduler = new CArrayObj();

      CArrayObj *discriminator = new CArrayObj();

      if(!CreateDescriptions(actor, scheduler, discriminator))

        {

         delete actor;

         delete scheduler;

         delete discriminator;

         return INIT_FAILED;

        }

      if(!Actor.Create(actor) ||

         !Scheduler.Create(scheduler) ||

         !Discriminator.Create(discriminator))

        {

         delete actor;

         delete scheduler;

         delete discriminator;

         return INIT_FAILED;

        }

      delete actor;

      delete scheduler;

      delete discriminator;

      //---

#ifdef FileName

      if(!Actor.UpdateTarget(FileName + ".nnw") ||

         !Scheduler.UpdateTarget(FileName + ".nnw"))

#else

      if(!Actor.UpdateTarget("FQF.upd") ||

         !Scheduler.UpdateTarget("FQF.nnw"))

#endif

         return INIT_FAILED;

     }

//---

   Discriminator.getResults(DiscriminatorResult);

   if(DiscriminatorResult.Size() != NSkills * AccountDescr)

     {

      PrintFormat("The scope of the discriminator does not match the skills count (%d <> %d)", NSkills, Result.Total());

      return INIT_FAILED;

     }

   Scheduler.getResults(SchedulerResult);

   Scheduler.SetUpdateTarget(MathMax(Iterations*SchedulerBatch / 100, 500000 / SchedulerBatch));

   if(SchedulerResult.Size() != NSkills)

     {

      PrintFormat("The scope of the scheduler does not match the skills count (%d <> %d)", NSkills, Result.Total());

      return INIT_FAILED;

     }

   Actor.getResults(ActorResult);

   Actor.SetUpdateTarget(MathMax(Iterations*AgentBatch / 100, 500000 / AgentBatch * NSkills));

   if(ActorResult.Size() != NActions)

     {

      PrintFormat("The scope of the actor does not match the actions count (%d <> %d)", NActions, Result.Total());

      return INIT_FAILED;

     }

//---

   if(!EventChartCustom(ChartID(), 1, 0, 0, "Init"))

     {

      PrintFormat("Error of create study event: %d", GetLastError());

      return INIT_FAILED;

     }

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| Expert deinitialization function                                 |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

  {

//---

   Actor.Save(FileName + "Act.nnw", TimeCurrent(), true);

   Scheduler.Save(FileName + "Sch.nnw", TimeCurrent(), true);

   Discriminator.Save(FileName + "Dscr.nnw", 0, 0, 0, TimeCurrent(), true);

   delete Result;

  }

//+------------------------------------------------------------------+

//| ChartEvent function                                              |

//+------------------------------------------------------------------+

void OnChartEvent(const int id,

                  const long &lparam,

                  const double &dparam,

                  const string &sparam)

  {

//---

   if(id == 1001)

      Train();

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool SaveTotalBase(void)

  {

   int total = ArraySize(Buffer);

   if(total < 0)

      return true;

   int handle = FileOpen(FileName + ".bd", FILE_WRITE | FILE_BIN | FILE_COMMON);

   if(handle < 0)

      return false;

   if(FileWriteInteger(handle, total) < INT_VALUE)

     {

      FileClose(handle);

      return false;

     }

   for(int i = 0; i < total; i++)

      if(!Buffer[i].Save(handle))

        {

         FileClose(handle);

         return false;

        }

   FileFlush(handle);

   FileClose(handle);

//---

   return true;

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool LoadTotalBase(void)

  {

   int handle = FileOpen(FileName + ".bd", FILE_READ | FILE_BIN | FILE_COMMON | FILE_SHARE_READ);

   if(handle < 0)

      return false;

   int total = FileReadInteger(handle);

   if(total <= 0)

     {

      FileClose(handle);

      return false;

     }

   if(ArrayResize(Buffer, total) < total)

     {

      FileClose(handle);

      return false;

     }

   for(int i = 0; i < total; i++)

      if(!Buffer[i].Load(handle))

        {

         FileClose(handle);

         return false;

        }

   FileClose(handle);

//---

   return true;

  }

//+------------------------------------------------------------------+

//| Train function                                                   |

//+------------------------------------------------------------------+

void Train(void)

  {

   int total_tr = ArraySize(Buffer);

   uint ticks = GetTickCount();

   vector<float> account, reward;

   int bar, action;

   int skill, shift;

//---

   for(int iter = 0; (iter < Iterations && !IsStopped()); iter ++)

     {

      for(int phase = 0; phase < 3; phase++)

        {

         int batch = 0;

         switch(phase)

           {

            case 0:

               batch = DiscriminatorBatch;

               break;

            case 1:

               batch = AgentBatch;

               break;

            case 2:

               batch = SchedulerBatch;

               break;

            default:

               PrintFormat("Incorrect phase %d");

               batch = 0;

               break;

           }

         for(int batch_iter = 0; batch_iter < batch; batch_iter++)

           {

            int tr = (int)(((double)MathRand() / 32767.0) * (total_tr - 1));

            int i = (int)((MathRand() * MathRand() / MathPow(32767, 2)) * (Buffer[tr].Total - 2));

            State.AssignArray(Buffer[tr].States[i].state);

            float PrevBalance = Buffer[tr].States[MathMax(i - 1, 0)].account[0];

            float PrevEquity = Buffer[tr].States[MathMax(i - 1, 0)].account[1];

            State.Add((Buffer[tr].States[i].account[0] - PrevBalance) / PrevBalance);

            State.Add(Buffer[tr].States[i].account[1] / PrevBalance);

            State.Add((Buffer[tr].States[i].account[1] - PrevEquity) / PrevEquity);

            State.Add(Buffer[tr].States[i].account[2] / PrevBalance);

            State.Add(Buffer[tr].States[i].account[4] / PrevBalance);

            State.Add(Buffer[tr].States[i].account[5]);

            State.Add(Buffer[tr].States[i].account[6]);

            State.Add(Buffer[tr].States[i].account[7] / PrevBalance);

            State.Add(Buffer[tr].States[i].account[8] / PrevBalance);

            //---

            bar = (HistoryBars - 1) * BarDescr;

            double cl_op = Buffer[tr].States[i + 1].state[bar];

            double prof_1l = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE_PROFIT) * cl_op /