NN_in_Trading/Experts/VLADriver-RAG/StudyOnline.mq5

//+------------------------------------------------------------------+
//| StudyOnline.mq5                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright DNG®"
#property link      "https://www.mql5.com/ru/users/dng"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Includes                                                         |
//+------------------------------------------------------------------+
#define StudyOnline

#include "Trajectory.mqh"
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Indicators\Oscilators.mqh>
//+------------------------------------------------------------------+
//| Input parameters                                                 |
//+------------------------------------------------------------------+
input group                "---- Other ----"
input int                  Agent = 1;
input group                "---- Base Memory ----"
input bool                 LoadBaseMemorySnapshot = true;
input string               BaseMemorySnapshotPath = "VLADriverBaseMemory.snapshot";
input bool                 PublishMemoryOnOnlineMemorySize = true;
input bool                 PublishMemoryOnEpisodeClosure = true;
CNet                 cActor[2];
CNet                 cCritic[3];
CNet                 cStateEncoder;

datetime             dtStudied;
CBufferFloat         bState;
CBufferFloat         bContext;
CBufferFloat         bTime;
CBufferFloat         bGradient;
CBufferFloat         *bAction;
CBufferFloat         *Result;

double               PrevBalance = 0;
double               PrevEquity = 0;
bool                 bFirstRun = true;
bool                 bFillStack = true;
// The library owns records, centroids, snapshots and GPU retrieval.
CNeuronRAGMemory     RAGMemory;
bool                 BaseMemoryNullBound = true;
// These are execution facts only; pending events live in CNeuronRAGMemory.
ulong                OnlinePendingId = 0;
bool                 OnlinePendingExecuted = false;
datetime             OnlinePendingStartTime = 0;
double               OnlinePendingStartBalance = 0;
double               OnlinePendingStartEquity = 0;
double               OnlinePendingPeakEquity = 0;
double               OnlinePendingMaxDrawdown = 0;
double               OnlinePendingMaxMarginToEquity = 0;
bool                 OnlinePendingHasEquitySample = false;
bool                 OnlinePendingHasRiskSample = false;
ulong                OnlinePendingExecutionDeal = 0;
ulong                OnlinePendingPositionId = 0;
ulong                OnlinePendingPositionIds[];
uint                 OnlinePendingStartPosition = 0;
CBufferFloat           OnlinePendingAction;
CBufferFloat           OnlinePendingScenarioEmbedding;
bool                 OnlinePendingPrepared = false;
const float          RejectedExecutionPenaltyScale = 100.0f;
enum ENUM_VLADriverModifyResult
  {
   VLADriverModifyNoOp=0,
   VLADriverModifyAccepted=1,
   VLADriverModifyRejected=2
  };
void ClearOnlinePendingScenario(void)
  {
   OnlinePendingId = 0;
   OnlinePendingExecuted = false;
   OnlinePendingStartTime = 0;
   OnlinePendingStartBalance = 0;
   OnlinePendingStartEquity = 0;
   OnlinePendingPeakEquity = 0;
   OnlinePendingMaxDrawdown = 0;
   OnlinePendingMaxMarginToEquity = 0;
   OnlinePendingHasEquitySample = false;
   OnlinePendingHasRiskSample = false;
   OnlinePendingExecutionDeal = 0;
   OnlinePendingPositionId = 0;
   ArrayResize(OnlinePendingPositionIds,0);
   OnlinePendingStartPosition = 0;
   OnlinePendingAction.BufferInit(NActions, 0);
   OnlinePendingScenarioEmbedding.BufferInit(EmbeddingSize, 0);
   OnlinePendingPrepared = false;
  }
//+------------------------------------------------------------------+
//| Capture the observed state before the new market order is sent.  |
//+------------------------------------------------------------------+
bool AnchorOnlinePendingScenario(void)
  {
   if(OnlinePendingId != 0 || OnlinePendingPrepared || bAction == NULL)
      ReturnFalse;
   CBufferFloat *scenario_embedding = NULL;
   if(!cStateEncoder.GetLayerOutputDevice(StateScenarioLayer, scenario_embedding))
     {
      PrintFormat("%s -> %d pending scenario output failed", __FUNCTION__, __LINE__);
      ReturnFalse;
     }
   if(scenario_embedding.Total() != EmbeddingSize)
     {
      PrintFormat("%s -> %d pending scenario embedding size mismatch", __FUNCTION__, __LINE__);
      ReturnFalse;
     }
   float scenario_embedding_data[];
   uint replaced_values = 0;
   const bool scenario_read = RAGMemory.ReadScenarioEmbedding(scenario_embedding,
                              scenario_embedding_data, replaced_values);
   if(replaced_values > 0)
      PrintFormat("Online RAG scenario anchor replaced %u non-finite values", replaced_values);
   if(!scenario_read)
     {
      PrintFormat("%s -> %d pending scenario anchor read failed", __FUNCTION__, __LINE__);
      ReturnFalse;
     }
   for(int i = 0; i < NActions; i++)
      if(!OnlinePendingAction.Update(i, bAction[i]))
         ReturnFalse;
   if(!OnlinePendingScenarioEmbedding.BufferInit(EmbeddingSize,0))
      ReturnFalse;
   if(!OnlinePendingScenarioEmbedding.AssignArray(scenario_embedding_data))
      ReturnFalse;
   OnlinePendingStartTime = TimeCurrent();
   OnlinePendingStartBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   OnlinePendingStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   OnlinePendingPeakEquity=OnlinePendingStartEquity;
   OnlinePendingPrepared = true;
   return true;
   }
//+------------------------------------------------------------------+
//| Create library pending state only after a market order is known. |
//+------------------------------------------------------------------+
bool OpenConfirmedOnlinePendingScenario(const ulong deal)
  {
   if(!OnlinePendingPrepared || OnlinePendingId!=0 || deal==0 ||
      !HistoryDealSelect(deal) ||
      ulong(HistoryDealGetInteger(deal,DEAL_POSITION_ID))==0)
     {
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   float normalized_action[NActions];
   if(!NormalizeMemoryAction(RAGMemory,GetPointer(OnlinePendingAction),0,
                               OnlinePendingStartEquity,normalized_action))
     {
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   float scenario_embedding_data[EmbeddingSize];
   for(int i=0;i<EmbeddingSize;i++)
      scenario_embedding_data[i]=OnlinePendingScenarioEmbedding[i];
   OnlinePendingId=RAGMemory.OpenPending(scenario_embedding_data,normalized_action);
   if(OnlinePendingId==0 || !RegisterOnlinePendingExecution(deal))
     {
      if(OnlinePendingId!=0)
         RAGMemory.CancelPending(OnlinePendingId);
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   return true;
  }
//+------------------------------------------------------------------+
//| Apply one uniform Critic-only penalty for rejected execution.    |
//+------------------------------------------------------------------+
bool PenalizeRejectedExecution(const double requested_volume)
  {
   if(requested_volume<=0)
      return true;
   Result.Clear();
   if(!Result.Add(float(-RejectedExecutionPenaltyScale*requested_volume)) ||
      !cCritic[0].backProp(Result,GetPointer(cStateEncoder),StateTokenLayer))
     {
      PrintFormat("%s -> %d rejected execution Critic update failed",__FUNCTION__,__LINE__);
      ReturnFalse;
     }
   return true;
  }
//+------------------------------------------------------------------+
//| Classify terminal acknowledgement without treating no-op as      |
//| data.                                                            |
//+------------------------------------------------------------------+
ENUM_VLADriverModifyResult ClassifyOnlineTradeResult(const bool request_sent)
  {
   const uint retcode=Trade.ResultRetcode();
   if(request_sent && (retcode==TRADE_RETCODE_DONE || retcode==TRADE_RETCODE_DONE_PARTIAL))
      return VLADriverModifyAccepted;
   if(retcode==TRADE_RETCODE_NO_CHANGES)
      return VLADriverModifyNoOp;
   return VLADriverModifyRejected;
  }
//+------------------------------------------------------------------+
//| Check whether one position belongs to the current trade plan.   |
//+------------------------------------------------------------------+
bool OnlinePendingHasPosition(const ulong position)
  {
   if(position==0)
      ReturnFalse;
   const int total=ArraySize(OnlinePendingPositionIds);
   for(int i=0;i<total;i++)
      if(OnlinePendingPositionIds[i]==position)
         return true;
   return false;
  }
//+------------------------------------------------------------------+
//| Add a unique position identity to the current trade plan.       |
//+------------------------------------------------------------------+
bool AddOnlinePendingPosition(const ulong position)
  {
   if(position==0)
      ReturnFalse;
   if(OnlinePendingHasPosition(position))
      return true;
   const int total=ArraySize(OnlinePendingPositionIds);
   if(ArrayResize(OnlinePendingPositionIds,total+1)!=total+1)
      ReturnFalse;
   OnlinePendingPositionIds[total]=position;
   return true;
  }
//+------------------------------------------------------------------+
//| Undo a just-reserved position when event confirmation failed.    |
//+------------------------------------------------------------------+
bool RemoveOnlinePendingPosition(const ulong position)
  {
   const int total=ArraySize(OnlinePendingPositionIds);
   for(int i=0;i<total;i++)
      if(OnlinePendingPositionIds[i]==position)
        {
         for(int j=i+1;j<total;j++)
            OnlinePendingPositionIds[j-1]=OnlinePendingPositionIds[j];
         if(ArrayResize(OnlinePendingPositionIds,total-1)!=total-1)
            ReturnFalse;
         return true;
        }
   ReturnFalse;
  }
//+------------------------------------------------------------------+
//| A plan remains open while any of its netting/hedging positions   |
//| remains open.                                                    |
//+------------------------------------------------------------------+
bool OnlinePendingPositionsAreOpen(void)
  {
   if(ArraySize(OnlinePendingPositionIds)<=0)
      return false;
   for(int i=0;i<PositionsTotal();i++)
      if(PositionGetSymbol(i)==Symb.Name() &&
         OnlinePendingHasPosition(ulong(PositionGetInteger(POSITION_IDENTIFIER))))
         return true;
   return false;
  }
//+------------------------------------------------------------------+
//| Compatibility helper for partial-close classification.          |
//+------------------------------------------------------------------+
bool OnlinePendingPositionIsOpen(void)
  {
   return OnlinePendingPositionsAreOpen();
  }
//+------------------------------------------------------------------+
//| Execute TP/SL change and classify no-op, accepted and rejected.  |
//+------------------------------------------------------------------+
ENUM_VLADriverModifyResult ModifyOnlinePosition(const ENUM_POSITION_TYPE type,
                                                const double sl,const double tp)
  {
   const int total=PositionsTotal();
   const datetime earliest_update=TimeCurrent()-5*PeriodSeconds(TimeFrame);
   uint result=uint(VLADriverModifyNoOp);
   for(int i=0;i<total;i++)
     {
      if(PositionGetSymbol(i)!=Symb.Name() || PositionGetInteger(POSITION_TYPE)!=type ||
         PositionGetInteger(POSITION_TIME_UPDATE)>earliest_update)
         continue;
      bool modify=false;
      double position_sl=PositionGetDouble(POSITION_SL);
      double position_tp=PositionGetDouble(POSITION_TP);
      if(type==POSITION_TYPE_BUY)
        {
         if((sl-position_sl)>=Symb.Point())
           { position_sl=sl; modify=true; }
         if(MathAbs(tp-position_tp)>=Symb.Point())
           { position_tp=tp; modify=true; }
        }
      else
        {
         if((position_sl-sl)>=Symb.Point())
           { position_sl=sl; modify=true; }
         if(MathAbs(tp-position_tp)>=Symb.Point())
           { position_tp=tp; modify=true; }
        }
      if(!modify)
         continue;
      const ENUM_VLADriverModifyResult update=ClassifyOnlineTradeResult(
         Trade.PositionModify(PositionGetInteger(POSITION_TICKET),position_sl,position_tp));
      result|=uint(update);
     }
   return (ENUM_VLADriverModifyResult)result;
  }
//+------------------------------------------------------------------+
//| Full close is terminal and therefore never creates RAG           |
//| correction.                                                      |
//+------------------------------------------------------------------+
ENUM_VLADriverModifyResult CloseOnlineByDirection(const ENUM_POSITION_TYPE type)
  {
   return ClassifyOnlineTradeResult(CloseByDirection(type));
  }
//+------------------------------------------------------------------+
//| Partial close is an action correction only while episode         |
//| remains.                                                         |
//+------------------------------------------------------------------+
ENUM_VLADriverModifyResult CloseOnlinePartial(const ENUM_POSITION_TYPE type,
                                              const double volume)
  {
   const ENUM_VLADriverModifyResult result=ClassifyOnlineTradeResult(ClosePartial(type,volume));
   if(result!=VLADriverModifyAccepted || !OnlinePendingPositionIsOpen())
      return (result==VLADriverModifyAccepted ? VLADriverModifyNoOp : result);
   return VLADriverModifyAccepted;
  }
//+------------------------------------------------------------------+
//| Sample actual account exposure for a confirmed pending           |
//| execution.                                                       |
//+------------------------------------------------------------------+
void SampleOnlinePendingScenario(void)
  {
   if(OnlinePendingId==0 || !OnlinePendingExecuted)
      return;
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   if(MathIsValidNumber(equity) && equity > 0)
     {
      if(!OnlinePendingHasEquitySample || equity>OnlinePendingPeakEquity)
         OnlinePendingPeakEquity=equity;
      OnlinePendingMaxDrawdown=MathMax(OnlinePendingMaxDrawdown,OnlinePendingPeakEquity-equity);
      OnlinePendingHasEquitySample=true;
      double margin = AccountInfoDouble(ACCOUNT_MARGIN);
      if(MathIsValidNumber(margin) && margin >= 0)
        {
         OnlinePendingMaxMarginToEquity=MathMax(OnlinePendingMaxMarginToEquity,margin/equity);
         OnlinePendingHasRiskSample=true;
        }
     }
  }
//+------------------------------------------------------------------+
//| Bind only a confirmed market deal to the causal pending anchor.  |
//+------------------------------------------------------------------+
bool RegisterOnlinePendingExecution(const ulong deal)
  {
   if(OnlinePendingId==0 || deal==0 || !HistoryDealSelect(deal))
     {
      if(OnlinePendingId!=0)
         RAGMemory.CancelPending(OnlinePendingId);
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   ulong position_id = ulong(HistoryDealGetInteger(deal, DEAL_POSITION_ID));
   if(position_id == 0)
     {
      RAGMemory.CancelPending(OnlinePendingId);
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   if(!RAGMemory.ConfirmPendingExecution(OnlinePendingId,deal,position_id))
     {
      RAGMemory.CancelPending(OnlinePendingId);
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   OnlinePendingExecutionDeal=deal;
   OnlinePendingPositionId=position_id;
   if(!AddOnlinePendingPosition(position_id))
     {
      RAGMemory.CancelPending(OnlinePendingId);
      ClearOnlinePendingScenario();
      ReturnFalse;
     }
   OnlinePendingExecuted=true;
   SampleOnlinePendingScenario();
   return true;
  }
//+------------------------------------------------------------------+
//| Add only an accepted position correction to the pending episode. |
//+------------------------------------------------------------------+
bool RegisterOnlinePendingCorrection(const ulong deal=0)
   {
    if(OnlinePendingId==0 || !OnlinePendingExecuted || OnlinePendingPositionId==0 || bAction==NULL)
       ReturnFalse;
    ulong position=OnlinePendingPositionId;
    if(deal>0)
      {
       if(!HistoryDealSelect(deal))
          ReturnFalse;
       position=ulong(HistoryDealGetInteger(deal,DEAL_POSITION_ID));
       if(position==0 || HistoryDealGetInteger(deal,DEAL_ENTRY)!=DEAL_ENTRY_IN)
          ReturnFalse;
      }
    float normalized_action[NActions];
   for(int i=0;i<NActions;i++)
      OnlinePendingAction.Update(i,bAction[i]);
   if(!NormalizeMemoryAction(RAGMemory,GetPointer(OnlinePendingAction),0,OnlinePendingStartEquity,normalized_action) ||
       !RAGMemory.CorrectPending(OnlinePendingId,normalized_action))
      ReturnFalse;
   if(deal>0)
     {
      const bool already_added=OnlinePendingHasPosition(position);
      if(!already_added && !AddOnlinePendingPosition(position))
        {
         RAGMemory.CancelPendingCorrection(OnlinePendingId);
         ReturnFalse;
        }
      if(!RAGMemory.ConfirmPendingCorrection(OnlinePendingId,deal,position))
        {
         if(!already_added)
            RemoveOnlinePendingPosition(position);
         RAGMemory.CancelPendingCorrection(OnlinePendingId);
         ReturnFalse;
        }
      return true;
     }
   if(RAGMemory.ConfirmPendingCorrection(OnlinePendingId,OnlinePendingPositionId))
      return true;
   RAGMemory.CancelPendingCorrection(OnlinePendingId);
   ReturnFalse;
  }
//+------------------------------------------------------------------+
//| Persist one validated snapshot/manifest publication pair.        |
//+------------------------------------------------------------------+
bool SaveOnlineBaseMemory(void)
  {
   if(RAGMemory.ScenarioCount()==0)
      return true;
   return RAGMemory.SavePublishedSnapshot(BaseMemorySnapshotPath);
   }
//+------------------------------------------------------------------+
//| Rebind both Actor copies before any later forward pass.          |
//+------------------------------------------------------------------+
bool RebindOnlineRAGMemory(void)
  {
   const bool actor0_bound=cActor[0].BindRAGMemory(2,GetPointer(RAGMemory));
   const bool actor1_bound=cActor[1].BindRAGMemory(2,GetPointer(RAGMemory));
   if(actor0_bound && actor1_bound)
      return true;
   PrintFormat("%s -> %d online RAG Actor rebind failed",__FUNCTION__,__LINE__);
   DetachOnlineRAGMemory();
   ExpertRemove();
   ReturnFalse;
  }
//+------------------------------------------------------------------+
//| Detach both consumers before COW deletes the old device buffers. |
//+------------------------------------------------------------------+
bool DetachOnlineRAGMemory(void)
  {
   const bool actor0_detached=cActor[0].UnbindRAGMemory(2);
   const bool actor1_detached=cActor[1].UnbindRAGMemory(2);
   if(actor0_detached && actor1_detached)
      return true;
   PrintFormat("%s -> %d online RAG Actor detach failed",__FUNCTION__,__LINE__);
   ExpertRemove();
   ReturnFalse;
  }
//+------------------------------------------------------------------+
//| Build and swap only an immutable Base Memory snapshot.           |
//+------------------------------------------------------------------+
bool PublishOnlineMemory(const bool episode_completed)
  {
   const uint pending=RAGMemory.PendingRecordCount();
   if(pending==0 ||
      (!(PublishMemoryOnOnlineMemorySize && pending>=OnlineMemorySize) &&
       !(PublishMemoryOnEpisodeClosure && episode_completed)))
      return true;
   if(!DetachOnlineRAGMemory())
      ReturnFalse;
   if(!RAGMemory.Publish(episode_completed))
     {
      if(!RebindOnlineRAGMemory())
         ReturnFalse;
      ReturnFalse;
     }
   if(!RebindOnlineRAGMemory())
      ReturnFalse;
   BaseMemoryNullBound=false;
   return SaveOnlineBaseMemory();
  }
//+------------------------------------------------------------------+
//| Store the actual, fully closed execution as one completed case.  |
//+------------------------------------------------------------------+
void CollectOnlineCompletedScenario(void)
  {
   if(OnlinePendingId==0 || !OnlinePendingExecuted)
      return;
   if(OnlinePendingPositionId==0 && OnlinePendingExecutionDeal>0)
      OnlinePendingPositionId=ulong(HistoryDealGetInteger(OnlinePendingExecutionDeal,DEAL_POSITION_ID));
   if(OnlinePendingPositionId==0)
      return;
   if(ArraySize(OnlinePendingPositionIds)==0)
      if(!AddOnlinePendingPosition(OnlinePendingPositionId))
         return;
   if(OnlinePendingPositionsAreOpen())
      return;
   SRAGTerminalOutcome evaluated_terminal;
   // The simulator is a base/fallback only; live account/deal data below wins.
   EvaluateTerminalOutcome(RAGMemory,GetPointer(OnlinePendingAction),OnlinePendingStartBalance,
                           OnlinePendingStartPosition,evaluated_terminal);
   double reward = 0;
   double costs = 0;
   bool has_deals = false;
   if(HistorySelect(OnlinePendingStartTime, TimeCurrent()))
      for(int i = 0; i < HistoryDealsTotal(); i++)
        {
         ulong deal = HistoryDealGetTicket(i);
         if(deal==0 || !OnlinePendingHasPosition(ulong(HistoryDealGetInteger(deal,DEAL_POSITION_ID))))
            continue;
         double profit = HistoryDealGetDouble(deal, DEAL_PROFIT);
         double swap = HistoryDealGetDouble(deal, DEAL_SWAP);
         double commission = HistoryDealGetDouble(deal, DEAL_COMMISSION);
         reward += profit + swap + commission;
         costs += -MathMin(swap, 0.0) - MathMin(commission, 0.0);
         has_deals = true;
        }
   bool has_actual_reward = has_deals;
   if(!has_actual_reward && OnlinePendingStartBalance>0)
     {
      double end_balance = AccountInfoDouble(ACCOUNT_BALANCE);
      if(MathIsValidNumber(end_balance))
        {
         reward=end_balance-OnlinePendingStartBalance;
         has_actual_reward = true;
        }
     }
   bool partial_metrics=(!has_deals || !OnlinePendingHasEquitySample ||
                         !OnlinePendingHasRiskSample || OnlinePendingStartTime<=0);
   const int period_seconds = PeriodSeconds(TimeFrame);
   SRAGTerminalOutcome terminal=evaluated_terminal;
   if(has_actual_reward && period_seconds > 0)
     {
      const double risk_budget=OnlinePendingStartEquity*MemoryRiskBudgetFraction;
      RAGMemory.NormalizeTerminalOutcome(reward,OnlinePendingMaxDrawdown,costs,
                                         OnlinePendingMaxMarginToEquity*risk_budget,
                                         double(TimeCurrent()-OnlinePendingStartTime),
                                         OnlinePendingStartEquity,risk_budget,
                                         period_seconds*MathMax(NForecast,1),terminal);
     }
   else
      partial_metrics = true;
   if(partial_metrics)
      Print("Online RAG record has partial terminal metrics");
   if(!RAGMemory.ClosePending(OnlinePendingId,terminal))
     {
      PrintFormat("%s -> %d online RAG close failed", __FUNCTION__, __LINE__);
      return;
     }
   ClearOnlinePendingScenario();
   if(!PublishOnlineMemory(true))
      PrintFormat("%s -> %d online memory publication failed", __FUNCTION__, __LINE__);
  }
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!MQLInfoInteger(MQL_TESTER))
      return INIT_FAILED;
   BaseMemoryNullBound = true;
   ClearOnlinePendingScenario();
   if(!Symb.Name(_Symbol))
      return INIT_FAILED;
   Symb.Refresh();
   if(!RSI.Create(Symb.Name(), TimeFrame, RSIPeriod, RSIPrice))
      return INIT_FAILED;
   if(!CCI.Create(Symb.Name(), TimeFrame, CCIPeriod, CCIPrice))
      return INIT_FAILED;
   if(!ATR.Create(Symb.Name(), TimeFrame, ATRPeriod))
      return INIT_FAILED;
   if(!MACD.Create(Symb.Name(), TimeFrame, FastPeriod, SlowPeriod, SignalPeriod, MACDPrice))
      return INIT_FAILED;
   if(!RSI.BufferResize(StackSize + HistoryBars) || !CCI.BufferResize(StackSize + HistoryBars) ||
      !ATR.BufferResize(StackSize + HistoryBars) || !MACD.BufferResize(StackSize + HistoryBars))
     {
      PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
      return INIT_FAILED;
     }
   if(!Trade.SetTypeFillingBySymbol(Symb.Name()))
      return INIT_FAILED;
// Load Models.
   float temp;
   CArrayObj *actor = new CArrayObj();
   CArrayObj *critic = new CArrayObj();
   if(!CreateDescriptions(actor, critic))
     {
      delete actor;
      delete critic;
      return INIT_FAILED;
     }
   if(!cStateEncoder.Load(FileName + "StEnc.nnw", temp, temp, temp, dtStudied, true))
     {
      PrintFormat("Error of load StateEncoder: %d", GetLastError());
      delete actor;
      delete critic;
      return INIT_FAILED;
     }
   if(!cActor[0].Load(FileName + "Act.nnw", temp, temp, temp, dtStudied, true) ||
      !cActor[1].Load(FileName + "Act.nnw", temp, temp, temp, dtStudied, true))
     {
      Print("Create new Actor");
      if(!cActor[0].Create(actor) ||
         !cActor[1].Create(actor))
        {
         delete actor;
         delete critic;
         return INIT_FAILED;
        }
      cActor[1].SetOpenCL(cActor[0].GetOpenCL());
      cActor[1].WeightsUpdate(GetPointer(cActor[0]), 1);
     }
   bool result = true;
   for(uint i = 0; (i < cCritic.Size() && result); i++)
      if(!cCritic[i].Load(FileName + CriticCheckpointFile, temp, temp, temp, dtStudied, true))
         result = false;
   if(!result)
     {
      Print("Create new Critic model");
      for(uint i = 0; i < cCritic.Size(); i++)
         if(!cCritic[i].Create(critic))
           {
            DeleteObj(actor);
            DeleteObj(critic);
            return INIT_FAILED;
           }
      for(uint i = 1; i < cCritic.Size(); i++)
        {
         cCritic[i].SetOpenCL(cCritic[0].GetOpenCL());
         if(!cCritic[i].WeightsUpdate(GetPointer(cCritic[0]), 1))
           {
            DeleteObj(actor);
            DeleteObj(critic);
            return INIT_FAILED;
           }
        }
     }
   DeleteObj(actor);
   DeleteObj(critic);
   for(int i = 0; i < 2; i++)
     {
      cActor[i].TrainMode(i == 0);
      cCritic[i].TrainMode(i == 0);
      cCritic[i].SetOpenCL(cActor[0].GetOpenCL());
      cActor[i].Clear();
      cCritic[i].Clear();
     }
   cActor[1].SetOpenCL(cActor[0].GetOpenCL());
   for(uint i = 2; i < cCritic.Size(); i++)
     {
      cCritic[i].TrainMode(false);
      cCritic[i].SetOpenCL(cActor[0].GetOpenCL());
      cCritic[i].Clear();
     }
   cStateEncoder.TrainMode(false);
   cStateEncoder.SetOpenCL(cActor[0].GetOpenCL());
   cStateEncoder.Clear();
   CLayerDescription memory_description;
   if(!CreateRAGMemoryDescription(memory_description) ||
      !RAGMemory.Init(0,0,cActor[0].GetOpenCL(),memory_description) ||
      !RAGMemory.SetOnlineMemorySize(OnlineMemorySize))
       return INIT_FAILED;
   if(LoadBaseMemorySnapshot && RAGMemory.LoadPublishedSnapshot(BaseMemorySnapshotPath))
      BaseMemoryNullBound=false;
   else
      if(!RAGMemory.BindNullInference())
         return INIT_FAILED;
   if(!RebindOnlineRAGMemory())
      return INIT_FAILED;
    if(!bGradient.BufferInit(EmbeddingSize, 0.0f) ||
       !bGradient.BufferCreate(cActor[0].GetOpenCL()))
       return INIT_FAILED;
   cActor[0].getResults(Result);
   if(Result.Total() != NActions)
     {
      PrintFormat("The scope of the actor does not match the actions count (%d <> %d)", NActions, Result.Total());
      return INIT_FAILED;
     }
   cActor[0].GetLayerOutput(0, Result);
   if(Result.Total() != AccountDescr)
     {
      PrintFormat("Input size of Actor doesn't match context description (%d <> %d)", Result.Total(), AccountDescr);
      return INIT_FAILED;
     }
   cStateEncoder.GetLayerOutput(0, Result);
   if(Result.Total() != (HistoryBars * BarDescr))
     {
      PrintFormat("Input size of StateEncoder doesn't match market state description (%d <> %d)", Result.Total(), (HistoryBars * BarDescr));
      return INIT_FAILED;
     }
   cStateEncoder.GetLayerOutput(StateTokenLayer, Result);
   if(Result.Total() != (BarDescr * EmbeddingSize))
     {
      PrintFormat("StateEncoder RankTCM layer doesn't match Critic context (%d <> %d)", Result.Total(), (BarDescr * EmbeddingSize));
      return INIT_FAILED;
     }
   cStateEncoder.GetLayerOutput(StateScenarioLayer, Result);
   if(Result.Total() != EmbeddingSize)
     {
      PrintFormat("StateEncoder token layer doesn't match pooled scenario embedding (%d <> %d)", Result.Total(), EmbeddingSize);
      return INIT_FAILED;
     }
   PrevBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   PrevEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   bFirstRun = true;
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   CollectOnlineCompletedScenario();
   if(OnlinePendingId!=0 && !OnlinePendingExecuted)
      RAGMemory.CancelPending(OnlinePendingId);
   if(reason!=REASON_INITFAILED && !SaveOnlineBaseMemory())
      Print("Error of save Base Memory snapshot");
   if(!(reason == REASON_RECOMPILE || reason == REASON_INITFAILED))
     {
      cActor[0].Save(FileName + "Act.nnw", 0, 0, 0, TimeCurrent(), true);
      cCritic[0].Save(FileName + CriticCheckpointFile, 0, 0, 0, TimeCurrent(), true);
     }
   DeleteObj(Result);
   DeleteObj(bAction);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(bFillStack)
     {
      if(!FillStack())
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         return;
        }
      bFillStack = false;
     }
   // Capture the live equity/margin observation on every tick while pending.
   SampleOnlinePendingScenario();
   if(!IsNewBar())
      return;
   int bars = CopyRates(Symb.Name(), TimeFrame, iTime(Symb.Name(), TimeFrame, 1), HistoryBars, Rates);
   if(bars < 0)
     {
      PrintFormat("%s -> %d CopyRates failed (%d)", __FUNCTION__, __LINE__, GetLastError());
      return;
     }
   if(!ArraySetAsSeries(Rates, true))
     {
      PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
      return;
     }
   RSI.Refresh();
   CCI.Refresh();
   ATR.Refresh();
   MACD.Refresh();
   Symb.Refresh();
   Symb.RefreshRates();
   bTime.Clear();
   bTime.Reserve(HistoryBars);
   if(!CreateBuffers(0, GetPointer(bState), GetPointer(bTime), (CBufferFloat*)NULL))
     {
      PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
      return;
     }
   double buy_value = 0, sell_value = 0, buy_profit = 0, sell_profit = 0;
   bool account_has_position = false;
   double position_discount = 0;
   double multiplier = 1.0 / (60.0 * 60.0 * 10.0);
   int total = PositionsTotal();
   datetime current = TimeCurrent();
   for(int i = 0; i < total; i++)
     {
      string position_symbol=PositionGetSymbol(i);
      if(position_symbol==NULL)
         continue;
      account_has_position=true;
      if(position_symbol != Symb.Name())
         continue;
      double profit = PositionGetDouble(POSITION_PROFIT);
      switch((int)PositionGetInteger(POSITION_TYPE))
        {
         case POSITION_TYPE_BUY:
            buy_value += PositionGetDouble(POSITION_VOLUME);
            buy_profit += profit;
            break;
         case POSITION_TYPE_SELL:
            sell_value += PositionGetDouble(POSITION_VOLUME);
            sell_profit += profit;
            break;
        }
      position_discount += (current - PositionGetInteger(POSITION_TIME)) * multiplier * MathAbs(profit);
     }
// A bound position disappears only after its complete episode closes.
   CollectOnlineCompletedScenario();
   vector<float> account = vector<float>::Zeros(AccountDescr);
   account[0] = float(AccountInfoDouble(ACCOUNT_BALANCE) / EtalonBalance);
   account[1] = float((AccountInfoDouble(ACCOUNT_BALANCE) - PrevBalance) / MathMax(PrevBalance, 1.0));
   account[2] = float(AccountInfoDouble(ACCOUNT_EQUITY) / MathMax(PrevBalance, 1.0));
   account[3] = float((AccountInfoDouble(ACCOUNT_EQUITY) - PrevEquity) / MathMax(PrevEquity, 1.0));
   account[4] = (float)buy_value;
   account[5] = (float)sell_value;
   account[6] = float(buy_profit / MathMax(PrevBalance, 1.0));
   account[7] = float(sell_profit / MathMax(PrevBalance, 1.0));
   account[8] = float(position_discount / MathMax(PrevBalance, 1.0));
   double time = (double)Rates[0].time;
   double x = time / (double)(D'2024.01.01' - D'2023.01.01');
   account[9] = (float)MathSin(x != 0 ? 2.0 * M_PI * x : 0);
   x = time / (double)PeriodSeconds(PERIOD_MN1);
   account[10] = (float)MathCos(x != 0 ? 2.0 * M_PI * x : 0);
   x = time / (double)PeriodSeconds(PERIOD_W1);
   account[11] = (float)MathSin(x != 0 ? 2.0 * M_PI * x : 0);
   x = time / (double)PeriodSeconds(PERIOD_D1);
   account[12] = (float)MathSin(x != 0 ? 2.0 * M_PI * x : 0);
   if(!bContext.AssignArray(account))
     {
      PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
      return;
     }
   if(!cStateEncoder.feedForward((CBufferFloat*)GetPointer(bState), 1, false, (CBufferFloat*)NULL))
     {
      PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
      return;
     }
   if(!RAGMemory.Retrieve(GetPointer(cStateEncoder),StateScenarioLayer))
     {
      PrintFormat("%s -> %d RAG retrieval failed", __FUNCTION__, __LINE__);
      return;
     }
   if(!bFirstRun)
     {
      // Target Nets.
      if(!cActor[1].feedForward((CBufferFloat*)GetPointer(bContext), 1, false,
                                GetPointer(cStateEncoder),StateScenarioLayer)
         || !cCritic[1].feedForward(GetPointer(cActor[1]), -1, GetPointer(cStateEncoder), StateTokenLayer)
         || !cCritic[2].feedForward(GetPointer(cActor[1]), -1, GetPointer(cStateEncoder), StateTokenLayer)
        )
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         bFirstRun = true;
         return;
        }
      // Critic.
      cCritic[1].getResults(Result);
      float forward = Result[0];
      cCritic[2].getResults(Result);
      forward = MathMin(forward, Result[0]);
      float reward = float(forward * DiscFactor +
                           (PrevEquity - AccountInfoDouble(ACCOUNT_EQUITY) +
                            PrevBalance - AccountInfoDouble(ACCOUNT_BALANCE)) * PrevBalance / EtalonBalance);
      if(MathMax(buy_value, sell_value) < Symb.LotsMin())
        {
         double marg = 0;
         if(!OrderCalcMargin(ORDER_TYPE_BUY, Symb.Name(), 1, Symb.Ask(), marg))
            marg = 200;
         double point_cost = Symb.TickValue() / Symb.TickSize();
         double loss = MathAbs(bState[0]) *
                       point_cost * PrevBalance / (10 * marg);
         reward -= float(loss * PrevBalance / EtalonBalance);
        }
      Result.Clear();
      if(!Result.Add(reward)
         || !cCritic[0].backProp(Result, GetPointer(cStateEncoder), StateTokenLayer))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         return;
        }
      if((PrevEquity - AccountInfoDouble(ACCOUNT_EQUITY) + PrevBalance - AccountInfoDouble(ACCOUNT_BALANCE)) <= 0 &&
         MathAbs(bState[0]) > Symb.StopsLevel()*Symb.Point())
        {
         double point_cost = Symb.TickValue() / Symb.TickSize();
         if(point_cost > 0)
           {
            vector<float> oracul = vector<float>::Zeros(NActions);
            double marg = 0;
            if(!OrderCalcMargin(ORDER_TYPE_BUY, Symb.Name(), 1, Symb.Ask(), marg))
               marg = 200;
            double lot = MathMax(PrevBalance / (10 * marg), Symb.LotsMin());
            if(bState[0] > 0)
              {
               lot = MathMin(lot, PrevBalance / ((-100 * bState[2 * HistoryBars] + Symb.Spread() * Symb.Point()) * point_cost));
               oracul[0] = (float)MathMin(lot, 1);
               oracul[1] = (float)MathMin(3 * bState[6] / (Symb.Point() * MaxTP), 1);
               oracul[2] = (float)MathMin(bState[6] / (Symb.Point() * MaxSL), 1);
              }
            else
              {
               lot = MathMin(lot, PrevBalance / ((100 * bState[HistoryBars] + Symb.Spread() * Symb.Point()) * point_cost));
               oracul[3] = (float)MathMin(lot, 1);
               oracul[4] = (float)MathMin(3 * bState[6] / (Symb.Point() * MaxTP), 1);
               oracul[5] = (float)MathMin(bState[6] / (Symb.Point() * MaxSL), 1);
              }
            reward = float(MathAbs(bState[0]) * point_cost * lot);
            reward = float(forward * DiscFactor + reward * PrevBalance / EtalonBalance);
            if(!Result.AssignArray(oracul) ||
               !cCritic[0].feedForward(Result, 1, false, (CNet*)GetPointer(cStateEncoder), StateTokenLayer))
              {
               PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
               bFirstRun = true;
               return;
              }
            if(!Result.Update(0, reward)
               || !cCritic[0].backProp(Result, GetPointer(cStateEncoder), StateTokenLayer))
              {
               PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
               bFirstRun = true;
               return;
              }
           }
        }
      if((MathRand() % ActorUpdate) == 0)
        {
         cCritic[0].TrainMode(false);
         if(!cCritic[0].feedForward(GetPointer(cActor[0]), -1, GetPointer(cStateEncoder), StateTokenLayer))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            return;
           }
         cCritic[0].getResults(Result);
         CBufferFloat *actor_market_gradient=NULL;
         if(!cStateEncoder.GetLayerOutputDevice(StateScenarioLayer,actor_market_gradient))
           {
            PrintFormat("%s -> %d actor market gradient input failed", __FUNCTION__, __LINE__);
            return;
           }
         if(!Result.Update(0, float(MathMax(Result[0], 0) + (PrevBalance * 0.01 + PrevBalance) / EtalonBalance)) ||
            !cCritic[0].backProp(Result, GetPointer(cStateEncoder), StateTokenLayer) ||
            !cActor[0].backPropGradient(actor_market_gradient, GetPointer(bGradient), -1, true))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            return;
           }
         cCritic[0].TrainMode(true);
        }
      if(PrevBalance < 20)
         ExpertRemove();
     }
// New State.
   if(!cActor[0].feedForward((CBufferFloat*)GetPointer(bContext), 1, false,
                              GetPointer(cStateEncoder),StateScenarioLayer)
      || !cCritic[0].feedForward((CNet*)GetPointer(cActor[0]), -1, (CNet*)GetPointer(cStateEncoder), StateTokenLayer)
     )
     {
      PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
      return;
     }
   PrevBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   PrevEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   cActor[0].getResults(bAction);
   if(bAction.Total() < NActions)
      bAction.BufferInit(NActions, 0);
   double min_lot = Symb.LotsMin();
   double step_lot = Symb.LotsStep();
   double stops = (MathMax(Symb.StopsLevel(), 1) + Symb.Spread()) * Symb.Point();
   bool online_execution_attempted = false;
   if(bAction[0] >= bAction[3])
     {
      bAction.Update(0, (bAction[0] - bAction[3]));
      bAction.Update(3, 0);
     }
   else
     {
      bAction.Update(3, (bAction[3] - bAction[0]));
      bAction.Update(0, 0);
     }
// Buy Control.
   if(bAction[0] < min_lot ||
      (bAction[1] * MaxTP * Symb.Point()) <= 2 * stops ||
      (bAction[2] * MaxSL * Symb.Point()) <= stops
     )
      {
       if(buy_value > 0)
         {
          const ENUM_VLADriverModifyResult buy_close=CloseOnlineByDirection(POSITION_TYPE_BUY);
          if((buy_close&VLADriverModifyRejected)!=0 && !PenalizeRejectedExecution(buy_value))
             return;
         }
     }
   else
     {
       double buy_lot = min_lot + MathRound((double)(bAction[0] - min_lot) / step_lot) * step_lot;
       double buy_tp = NormalizeDouble(Symb.Ask() + bAction[1] * MaxTP * Symb.Point(), Symb.Digits());
       double buy_sl = NormalizeDouble(Symb.Ask() - bAction[2] * MaxSL * Symb.Point(), Symb.Digits());
        bool buy_correction=false;
        ulong buy_correction_deal=0;
       ENUM_VLADriverModifyResult buy_modify=VLADriverModifyNoOp;
       if(buy_value>0)
          buy_modify=ModifyOnlinePosition(POSITION_TYPE_BUY,buy_sl,buy_tp);
       if((buy_modify&VLADriverModifyRejected)!=0 && !PenalizeRejectedExecution(buy_lot))
          return;
       if((buy_modify&VLADriverModifyAccepted)!=0)
          buy_correction=true;
      if(buy_value != buy_lot)
        {
         if((buy_value - buy_lot) >= min_lot)
           {
            const ENUM_VLADriverModifyResult buy_partial=CloseOnlinePartial(POSITION_TYPE_BUY,buy_value-buy_lot);
            if((buy_partial&VLADriverModifyRejected)!=0 && !PenalizeRejectedExecution(buy_value-buy_lot))
               return;
            if((buy_partial&VLADriverModifyAccepted)!=0)
               buy_correction=true;
           }
          else
             if((buy_lot-buy_value)>=min_lot)
               {
                // A same-direction volume increase is a correction of the current episode.
                if(buy_value>0 && sell_value<=0)
                  {
                   const ENUM_VLADriverModifyResult buy_increase=ClassifyOnlineTradeResult(
                      Trade.Buy(buy_lot-buy_value,Symb.Name(),Symb.Ask(),buy_sl,buy_tp));
                   if((buy_increase&VLADriverModifyRejected)!=0 &&
                      !PenalizeRejectedExecution(buy_lot-buy_value))
                      return;
                   if((buy_increase&VLADriverModifyAccepted)!=0)
                     {
                      buy_correction_deal=Trade.ResultDeal();
                      if(buy_correction_deal>0)
                         buy_correction=true;
                      else
                         Print("Accepted BUY volume correction has no deal and is not added to RAG memory");
                     }
                  }
                else
                   if(buy_value<=0 && sell_value<=0 && !account_has_position && OnlinePendingId==0 &&
                      !online_execution_attempted && AnchorOnlinePendingScenario())
                     {
                      online_execution_attempted = true;
                      if(Trade.Buy(buy_lot-buy_value,Symb.Name(),Symb.Ask(),buy_sl,buy_tp))
                        {
                         if(!OpenConfirmedOnlinePendingScenario(Trade.ResultDeal()))
                           {
                            if(!PenalizeRejectedExecution(buy_lot-buy_value))
                               return;
                            ExpertRemove();
                            return;
                           }
                        }
                      else
                        {
                         ClearOnlinePendingScenario();
                         if(!PenalizeRejectedExecution(buy_lot-buy_value))
                            return;
                        }
                     }
               }
        if(buy_correction && OnlinePendingId!=0 &&
           !RegisterOnlinePendingCorrection(buy_correction_deal))
         {
          PrintFormat("%s -> %d accepted BUY RAG correction registration failed",__FUNCTION__,__LINE__);
          ExpertRemove();
          return;
         }
      }
     }
// Sell Control.
   if(bAction[3] < min_lot ||
      (bAction[4] * MaxTP * Symb.Point()) <= 2 * stops ||
      (bAction[5] * MaxSL * Symb.Point()) <= stops
     )
      {
       if(sell_value > 0)
         {
          const ENUM_VLADriverModifyResult sell_close=CloseOnlineByDirection(POSITION_TYPE_SELL);
          if((sell_close&VLADriverModifyRejected)!=0 && !PenalizeRejectedExecution(sell_value))
             return;
         }
     }
   else
     {
       double sell_lot = min_lot + MathRound((double)(bAction[3] - min_lot) / step_lot) * step_lot;
       double sell_tp = NormalizeDouble(Symb.Bid() - bAction[4] * MaxTP * Symb.Point(), Symb.Digits());
       double sell_sl = NormalizeDouble(Symb.Bid() + bAction[5] * MaxSL * Symb.Point(), Symb.Digits());
        bool sell_correction=false;
        ulong sell_correction_deal=0;
       ENUM_VLADriverModifyResult sell_modify=VLADriverModifyNoOp;
       if(sell_value>0)
          sell_modify=ModifyOnlinePosition(POSITION_TYPE_SELL,sell_sl,sell_tp);
       if((sell_modify&VLADriverModifyRejected)!=0 && !PenalizeRejectedExecution(sell_lot))
          return;
       if((sell_modify&VLADriverModifyAccepted)!=0)
          sell_correction=true;
      if(sell_value != sell_lot)
        {
         if((sell_value - sell_lot) >= min_lot)
           {
            const ENUM_VLADriverModifyResult sell_partial=CloseOnlinePartial(POSITION_TYPE_SELL,sell_value-sell_lot);
            if((sell_partial&VLADriverModifyRejected)!=0 && !PenalizeRejectedExecution(sell_value-sell_lot))
               return;
            if((sell_partial&VLADriverModifyAccepted)!=0)
               sell_correction=true;
           }
          else
             if((sell_lot-sell_value)>=min_lot)
               {
                // A same-direction volume increase is a correction of the current episode.
                if(sell_value>0 && buy_value<=0)
                  {
                   const ENUM_VLADriverModifyResult sell_increase=ClassifyOnlineTradeResult(
                      Trade.Sell(sell_lot-sell_value,Symb.Name(),Symb.Bid(),sell_sl,sell_tp));
                   if((sell_increase&VLADriverModifyRejected)!=0 &&
                      !PenalizeRejectedExecution(sell_lot-sell_value))
                      return;
                   if((sell_increase&VLADriverModifyAccepted)!=0)
                     {
                      sell_correction_deal=Trade.ResultDeal();
                      if(sell_correction_deal>0)
                         sell_correction=true;
                      else
                         Print("Accepted SELL volume correction has no deal and is not added to RAG memory");
                     }
                  }
                else
                   if(buy_value<=0 && sell_value<=0 && !account_has_position && OnlinePendingId==0 &&
                      !online_execution_attempted && AnchorOnlinePendingScenario())
                     {
                      online_execution_attempted = true;
                      if(Trade.Sell(sell_lot-sell_value,Symb.Name(),Symb.Bid(),sell_sl,sell_tp))
                        {
                         if(!OpenConfirmedOnlinePendingScenario(Trade.ResultDeal()))
                           {
                            if(!PenalizeRejectedExecution(sell_lot-sell_value))
                               return;
                            ExpertRemove();
                            return;
                           }
                        }
                      else
                        {
                         ClearOnlinePendingScenario();
                         if(!PenalizeRejectedExecution(sell_lot-sell_value))
                            return;
                        }
                     }
               }
        if(sell_correction && OnlinePendingId!=0 &&
           !RegisterOnlinePendingCorrection(sell_correction_deal))
         {
          PrintFormat("%s -> %d accepted SELL RAG correction registration failed",__FUNCTION__,__LINE__);
          ExpertRemove();
          return;
         }
      }
     }
   if((OnlinePendingId!=0 && !OnlinePendingExecuted) ||
      (OnlinePendingPrepared && OnlinePendingId==0))
     {
      if(OnlinePendingId!=0)
         RAGMemory.CancelPending(OnlinePendingId);
      ClearOnlinePendingScenario();
     }
   bFirstRun = false;
   if((int(Rates[0].time / PeriodSeconds(TimeFrame)) % TargetUpdate) == 0)
     {
      if(MathRand() / 32767.0 > 0.5)
         cCritic[1].WeightsUpdate(GetPointer(cCritic[0]), tau);
      else
         cCritic[2].WeightsUpdate(GetPointer(cCritic[0]), tau);
      cActor[1].WeightsUpdate(GetPointer(cActor[0]), tau);
     }
  }
bool FillStack(void)
  {
   int start = StackSize + HistoryBars;
   int end = 0;
   int bars = CopyRates(Symb.Name(), TimeFrame, 2, start, Rates);
   if(bars < 0)
      ReturnFalse;
   if(!RSI.BufferResize(bars) || !CCI.BufferResize(bars) ||
      !ATR.BufferResize(bars) || !MACD.BufferResize(bars))
      ReturnFalse;
   if(RSI.BarsCalculated() < bars ||
      CCI.BarsCalculated() < bars ||
      ATR.BarsCalculated() < bars ||
      MACD.BarsCalculated() < bars)
      ReturnFalse;
   RSI.Refresh();
   CCI.Refresh();
   ATR.Refresh();
   MACD.Refresh();
   if(!ArraySetAsSeries(Rates, true))
      ReturnFalse;
   bars -= end + HistoryBars;
   if(bars < 0)
      ReturnFalse;
   vector<float> result, target, neg_target;
   uint ticks = GetTickCount();
   uint tester_print = 0;
   for(uint i = 0; i < cActor.Size(); i++)
     {
      if(!cActor[i].Clear())
         ReturnFalse;
      cActor[i].TrainMode(false);
     }
   for(uint i = 0; i < cCritic.Size(); i++)
     {
      if(!cCritic[i].Clear())
         ReturnFalse;
      cCritic[i].TrainMode(false);
     }
   if(!cStateEncoder.Clear())
      ReturnFalse;
   cStateEncoder.TrainMode(false);
   for(int posit = start - HistoryBars - 1; (posit >= end && !IsStopped()); posit--)
     {
      if(!CreateBuffers(posit, GetPointer(bState), GetPointer(bTime), NULL))
         ReturnFalse;
      vector<float> account = vector<float>::Zeros(AccountDescr);
      account[0] = float(AccountInfoDouble(ACCOUNT_BALANCE) / EtalonBalance);
      account[2] = 1;
      double time = (double)bTime[0];
      double x = time / (double)(D'2024.01.01' - D'2023.01.01');
      account[9] = (float)MathSin(x != 0 ? 2.0 * M_PI * x : 0);
      x = time / (double)PeriodSeconds(PERIOD_MN1);
      account[10] = (float)MathCos(x != 0 ? 2.0 * M_PI * x : 0);
      x = time / (double)PeriodSeconds(PERIOD_W1);
      account[11] = (float)MathSin(x != 0 ? 2.0 * M_PI * x : 0);
      x = time / (double)PeriodSeconds(PERIOD_D1);
      account[12] = (float)MathSin(x != 0 ? 2.0 * M_PI * x : 0);
      if(!bContext.AssignArray(account))
         ReturnFalse;
      if(!cStateEncoder.feedForward((CBufferFloat*)GetPointer(bState), 1, false, (CBufferFloat*)NULL))
         ReturnFalse;
      if(!RAGMemory.Retrieve(GetPointer(cStateEncoder),StateScenarioLayer))
        {
         PrintFormat("%s -> %d RAG retrieval failed", __FUNCTION__, __LINE__);
         ReturnFalse;
        }
      // Feed Forward.
      for(uint i = 0; (i < cActor.Size() && !IsStopped()); i++)
         if(!cActor[i].feedForward((CBufferFloat*)GetPointer(bContext), 1, false,
                                   GetPointer(cStateEncoder),StateScenarioLayer))
            ReturnFalse;
      for(uint i = 0; (i < cCritic.Size() && !IsStopped()); i++)
         if(!cCritic[i].feedForward(GetPointer(cActor[int(i > 0)]), -1,
                                    GetPointer(cStateEncoder), StateTokenLayer))
            ReturnFalse;
      if(GetTickCount() - ticks > 500)
        {
         double percent = (1.0 - double(posit - end) / (start - end - HistoryBars - NForecast))  * 100.0;
         string str = StringFormat("%-12s %6.2f%%", "Fill stack", percent);
         if(BaseMemoryNullBound)
            str += "\nRAG Null Memory";
         Comment(str);
         ticks = GetTickCount();
         if(MQLInfoInteger(MQL_TESTER) && percent >= tester_print)
           {
            Print(str);
            tester_print += 10;
           }
        }
     }
   cActor[0].TrainMode(true);
   cCritic[0].TrainMode(true);
   Comment("");
   if(MQLInfoInteger(MQL_TESTER))
      Print("Fill stack Done");
   return true;
  }
//+------------------------------------------------------------------+