神经网络变得简单（第 65 部分）：距离加权监督学习（DWSL）

MetaTrader 5 — 交易系统 | 19 六月 2024, 13:45

250

Dmitriy Gizlyk

概述

行为克隆方法，大部分基于监督学习的原理，展现出相当良好的结果。但它们的主要问题仍然是寻找偶像般的模型，而这些有时很难收集。反之，强化学习方法能够依据非最优原数据工作。同时，它们可以找到次优政策来达成目标。然而，在寻找最优政策时，我们时常会到一个优化问题，其与高维和随机环境更多关联。

为了弥合这两种方式之间的间隙，一群科学家提出了距离加权监督学习（DWSL）方法，并在文章《离线交互数据的距离加权监督学习》中进行了阐述。它是一种针对目标条件政的离线监督学习算法。理论上，DWSL 据来自训练集的轨迹水平上具有最小回报边界，收敛到最优政策。本文的实际算例展示出所提议方法的优于模仿学习和强化学习算法。我建议就这个 DWSL 算法深入谈谈。我们将评估它在解决实际问题方面的优势和劣势。

1. DWSL 算法

距离加权监督学习方法的作者自己设定了目标，即获得一种算法，拥有依据最大化数据集进行训练的能力。在这个范式中，他们假设智能体在确定性马尔可夫（Markov）决策过程中行动，并具有以下特征：

状态空间 S；
动作空间 A；
确定性动态化 St+1 = F(St,At)，其中 St+1 是来自状态 St 下采取动作 At 后所产生的新状态；
目标空间 G；
稀疏目标条件奖励函数 R(S,A,G)；
折扣因子 γ。

目标空间 G 是状态空间 S 的子空间，其目标提取函数 G = φ(St)，通常与 φ(St) = St+n 雷同。该算法的意向是学习目标条件策略 π(A|S,G)，它掌握了所研究的环境，能够达到设定的目标，然后坚持下去。为了获得预期的结果，我们把来自奖励函数 R(S,A,G) 的折扣回报最大化，前提是从目标分布 p(G) 达成目标 G。

虽然该问题设置与早前讨论的不同，但它与两个常规问题设置有很强的联系：随机最短路径问题，和 GCRL。

该方法的作者指出，在 GCRL 领域工作，假设存在带有标记子目标的轨迹。这些子目标由政策意向指定，这为模型提供了有关测试期间目标 p(G) 分布的信息。这限制了来自离线 GCRL 可学习的数据。原因是许多离线数据源在每条轨迹里不包含目标标记（子目标）。甚至，目标可能很难获得。

为了依据最广泛的离线数据集中学习，该方法的作者考虑了更普遍的状况。这种状况不涉及访问真实的环境动态、奖励标记、或测试时间目标分布。在训练阶段，仅使用一组来自任意最优级别状态和动作的轨迹。所取分布 p(G) 是通过对数据集中的所有状态应用目标提取函数 φ(St) 而推导的目标分布。假设对于大多数实际数据集，围绕数据分布的目标可能接近兴趣所在任务问题的目标。DWSL 方法可以使用任何稀疏奖励函数，这些可纯粹地从现有的状态-动作序列计算出来。然而，在实践中，该方法的作者发现经验估测也非常有效。

直觉上，当使用指定的奖励函数从当前状态 S 到达目标 G 时，最优目标达成策略是使用具有最小时间步骤的路径（最短路径）。但是，训练数据集中的轨迹不一定遵循最短路径。结果就是，行为克隆技术也许会展现出次优行为。

为了定位这个问题，DWSL使用监督学习来估测距离，在训练数据集的分布中评估已训练模型。该模型学习训练数据集中状态之间配对距离的整个分布。然后，它使用该分布来估测包含在每个状态数据集中距目标的最小距离。之后，它会学习遵循这些路径的政策。以下是由作者提供的 DWSL 方法的可视化。

在同一条轨迹上的任意两个状态 Si 和 Sj 之间，对于 i < j，至少有一条 “j - i” 时间步骤的路径。使用此属性，我们生成一个标记数据集，其中包含训练数据集中状态和目标之间的所有配对距离。对于从新分布中采样的每个状态-目标对，我们都从当前状态到目标的时间步数 k 进行离散分布建模，如左图 1 所示。这令我们能够通过标记数据集下的最大似然来获得该分布的参数化估测：

在实践中，分布建模作为覆盖可能距离的离散分类器。标记数据集中包含的源状态和目标状态之间的最短路径由最小时间步数 k 判定。不过，因为分布是使用函数近似来学习的，因此以这种举动估测最小距离可能会引发建模误差。为了最大程度地减少该误差，该方法的作者提议计算分布上的 LogSumExp，从而获得最小距离的软性估测值：

注意，在呈现的公式中，距离乘以 “-1” 是为获得最小估值，替代最大值。此处 α 温度超参数。当 α 趋于 “0” 时，函数 d(s, g) 的数值接近最小距离 k。

在学习了最小距离估值之后，我们打算遵循源自每个状态的已知路径。假设智能体处于状态 S，需要达成目标 G。在初始状态下，智能体可以执行两个动作（A1 或 A2）之一，分别导致状态 S1 和 S2。我们更愿意采取第一个动作，若它是通往目标步数最少（到目标的估测距离较短）路径的开始。因此，我们打算通过对目标距离的估测来权衡不同动作的可能性（上图右侧）。然而，以这种方式针对动作天真地加权，结果是所有靠近目标的数据点权重更大，因为任何远离目标的状态自然距离会更大。取而代之，我们根据与目标的估测距离的减少来权衡动作的可能性，方法作者将其称为优势。这令我们能够制定训练模型的新目标：

该方法的作者使用指数型优势来确保所有权重都是正数值。

2. 利用 MQL5 实现

在领略了距离加权监督学习方法的理论层面之后，我们可转到文章的实践部分，在该部分，我们将利用 MQL5 创建该方法的一个实现版本。如常，我们将尝试把提议的算法与我们之前积累的知识相结合。我们还将尝试复现我们对拟议方式的认知。我同意这式方法在某种程度上令我们与作者的算法保持距离，且并非它的精确复制品。由此，在测试期间所有可辨别的弱点都只与该实现有关。

原文阐述了控制机器人应用的实验。在这种条件下，目标设定在达成正面成果方面扮演着主导性角色。甚至，在每例个案中，目标都很清晰。在我的实现中，我专注于训练期间最大限度地提高机器人的盈利能力。为了简化模型，我决定不在每一步都设置一个子目标。这反过来又允许我们不训练目标设定模型。

在此，我们训练模型时将采用扮演者-评论者方式。对于捐赠者，我们将使用随机非主流扮演者-评论者（SMAC）模型。我们将用其它开发来补充它。特别是，我们将为加权轨迹添加一个来自 CWBC 的机制。但首事先行。我们从定义模型架构开始我们的工作。

2.1. 模型架构

如常，训练模型的架构在 CreateDescriptions 方法中表述。在参数中，我们将给方法传递指向 3 个模型架构定义的动态数组的指针：

扮演者
评论者
随机编码器

我应该在此提醒您，SMAC 算法是供训练随机潜在状态编码器，我们之前将其包含在扮演者架构当中，并可供评论者所用。我们将在此实现中使用该方案。

在方法的主体中，我们检查收到的指针，并在必要时创建新的对象实例。

bool CreateDescriptions(CArrayObj *actor, CArrayObj *critic, CArrayObj *convolution)
  {
//---
   CLayerDescription *descr;
//---
   if(!actor)
     {
      actor = new CArrayObj();
      if(!actor)
         return false;
     }
   if(!critic)
     {
      critic = new CArrayObj();
      if(!critic)
         return false;
     }
   if(!convolution)
     {
      convolution = new CArrayObj();
      if(!convolution)
         return false;
     }

我们将价格走势和指标读数的历史数据输入到扮演者之中，这反映在其原始数据层的大小中。

//--- Actor
   actor.Clear();
//--- Input layer
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   int prev_count = descr.count = (HistoryBars * BarDescr);
   descr.activation = None;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

我们将未处理的原初数据输入到模型当中。因此，在原初数据层之后，我们使用批量数据规范化层。它把从各个来源获得的原初数据转换为可比较的形式。

//--- layer 1
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBatchNormOCL;
   descr.count = prev_count;
   descr.batch = 1000;
   descr.activation = None;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

之后，我们尝试用卷积层来识别稳定的数据形态。为了获得原初数据归因于稳定形态的概率表示，我们调用 SoftMax 函数。

//--- layer 2
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConvOCL;
   prev_count = descr.count = HistoryBars;
   descr.window = BarDescr;
   descr.step = BarDescr;
   int prev_wout = descr.window_out = BarDescr / 2;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 3
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronSoftMaxOCL;
   descr.count = prev_count;
   descr.step = prev_wout;
   descr.optimization = ADAM;
   descr.activation = None;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 4
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConvOCL;
   prev_count = descr.count = prev_count;
   descr.window = prev_wout;
   descr.step = prev_wout;
   prev_wout = descr.window_out = 8;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 5
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronSoftMaxOCL;
   descr.count = prev_count;
   descr.step = prev_wout;
   descr.optimization = ADAM;
   descr.activation = None;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }

请注意，我们会在历史数据的每根独立烛条的上下文中搜索稳定的形态。

形态搜索结果由两个完全连接层进行分析。

//--- layer 6
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = LatentCount;
   descr.optimization = ADAM;
   descr.activation = LReLU;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 7
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   prev_count = descr.count = LatentCount;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

对于获得的数据，我们添加了帐户状态描述。

//--- layer 8
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConcatenate;
   descr.count = 2 * LatentCount;
   descr.window = prev_count;
   descr.step = AccountDescr;
   descr.optimization = ADAM;
   descr.activation = SIGMOID;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

然后生成随机潜在状态，由 SMAC 方法提供。

//--- layer 9
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronVAEOCL;
   descr.count = LatentCount;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

接下来是 2 个全连接层的决策模块。

//--- layer 10
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = LatentCount;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 11
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = LatentCount;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

在扮演者输出端，我们设置了一个变分自动编码器模块，令政策拥有了随机性。结果层的大小与智能体动作向量的维度对应。

//--- layer 12
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = 2 * NActions;
   descr.activation = SIGMOID;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 13
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronVAEOCL;
   descr.count = NActions;
   descr.optimization = ADAM;
   if(!actor.Add(descr))
     {
      delete descr;
      return false;
     }

评论者架构保持不变。模型的输入是来自扮演者隐藏层中环境状态的潜在表示。获得的数据不需要转换为可比形式。因此，在该模型中，我们不会用到批量常规化层。

//--- Critic
   critic.Clear();
//--- Input layer
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   prev_count = descr.count = LatentCount;
   descr.activation = None;
   descr.optimization = ADAM;
   if(!critic.Add(descr))
     {
      delete descr;
      return false;
     }

在潜在表示中，我们添加了扮演者的动作。

//--- layer 1
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConcatenate;
   descr.count = LatentCount;
   descr.window = prev_count;
   descr.step = NActions;
   descr.optimization = ADAM;
   descr.activation = LReLU;
   if(!critic.Add(descr))
     {
      delete descr;
      return false;
     }

级联数据由 3 个全连接层组成的决策模块进行分析。最后一层的大小与分解的奖励向量的大小对应。

//--- layer 2
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = LatentCount;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!critic.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 3
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = LatentCount;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!critic.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 4
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = NRewards;
   descr.optimization = ADAM;
   descr.activation = None;
   if(!critic.Add(descr))
     {
      delete descr;
      return false;
     }

在 CreateDescriptions 方法的末尾，我们添加了对随机编码器体系结构的描述。展望未来，我要说，在我们判定环境状态之间距离的过程中，编码器将作为一部分。为了描述环境的单一状态，我们用到 2 个向量：

历史价格和指标读数
账户状态和持仓

我们将这两个实体的级联向量馈送到编码器之中。

//--- Convolution
   convolution.Clear();
//--- Input layer
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   prev_count = descr.count = (HistoryBars * BarDescr) + AccountDescr;
   descr.activation = None;
   descr.optimization = ADAM;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }

编码器模型未经训练。因此，使用批量常规化层不会给出所需的结果。因此，为了将数据转换为某种可比较的形式，我们要用到全连接层。然后，我们将调用 SoftMax 层对数据进行常规化。

//--- layer 1
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = HistoryBars * BarDescr;
   descr.optimization = ADAM;
   descr.activation = None;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 2
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronSoftMaxOCL;
   descr.count = HistoryBars;
   descr.step = BarDescr;
   descr.optimization = ADAM;
   descr.activation = None;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }

接着是卷积层模块，该层也被 SoftMax 层覆盖。

//--- layer 3
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConvOCL;
   prev_count = descr.count = HistoryBars;
   descr.window = BarDescr;
   descr.step = BarDescr;
   prev_wout = descr.window_out = BarDescr / 2;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 4
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConvOCL;
   prev_count = descr.count = prev_count;
   descr.window = prev_wout;
   descr.step = prev_wout;
   prev_wout = descr.window_out = prev_wout / 2;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 5
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronConvOCL;
   prev_count = descr.count = prev_count;
   descr.window = prev_wout;
   descr.step = prev_wout;
   prev_wout = descr.window_out = 2;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }
//--- layer 6
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronSoftMaxOCL;
   descr.count = prev_count * prev_wout;
   descr.optimization = ADAM;
   descr.activation = None;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }

在编码器的输出端，我们使用一个全连接层，其返回所分析环境状态的嵌入。

//--- layer 7
   if(!(descr = new CLayerDescription()))
      return false;
   descr.type = defNeuronBaseOCL;
   descr.count = EmbeddingSize;
   descr.activation = LReLU;
   descr.optimization = ADAM;
   if(!convolution.Add(descr))
     {
      delete descr;
      return false;
     }
//---
   return true;
  }

2.2准备辅助方法

在讲述了所用模型的架构之后，我们转到实现模型训练算法的工作。但在实现学习过程之前，我们讨论一下实现通用算法的各个模块的方法。

首先，我们将使用轨迹的加权和优先级，这已在 CWBC 方法的框架内讨论过。为此，我们将移植 GetProbTrajectories 和 SampleTrajectory 方法。它们的算法在上一篇文章中已经详细讲述过，故我们现不再赘述。

为了训练扮演者和评论者，我们将采用的奖励和动作，已由 DWSL 方法进行加权。为了消除重复操作，我们将两个模型的目标向量计算合并到一个 GetTargets 方法之中。为了能够在一次操作中传输 2 个向量，我们将创建一个结构。

struct STarget
  {
   vector<float>     rewards;
   vector<float>     actions;
  };

由此，GetTargets 方法接收参数：

百分位数用于判定训练集中最接近的分析状态数量；
所分析状态的嵌入；
训练集中的状态嵌入矩阵；
来自训练集的奖励矩阵；
来自训练集的智能体动作矩阵。

最后 3 个矩阵相互对应。

基于工作结果，该方法返回 2 个目标向量的结构。

STarget GetTargets(int percentile, 
                   vector<float> &embedding, 
                   matrix<float> &state_embedding, 
                   matrix<float> &rewards, 
                   matrix<float> &actions
                  )
  {
   STarget result;

在方法主体中，我们声明了结果的结构，并立即检查所分析状态的嵌入大小与来自训练集中状态矩阵的对应关系。

   if(embedding.Size() != state_embedding.Cols())
     {
      PrintFormat("%s -> %d Inconsistent embedding size", __FUNCTION__, __LINE__);
      return result;
     }

接下来，我们判定所分析状态与训练集状态之间的距离。为了判定软性距离，我们调用 DWSL 方法的作者提议的 LogSumExp。

   ulong size = embedding.Size();
   ulong states = state_embedding.Rows();
   ulong k = ulong(states * percentile / 100);
   matrix<float> temp = matrix<float>::Zeros(states, size);
   for(ulong i = 0; i < size; i++)
      temp.Col(MathAbs(state_embedding.Col(i) - embedding[i]), i);
   float alpha=temp.Max();
   vector<float> dist = MathLog(MathExp(temp/(-alpha)).Sum(1))*(-alpha);

之后，我们创建奖励、动作和嵌入的局部矩阵。有关最接近状态的数据将被传输到该矩阵。

   vector<float> min_dist = vector<float>::Zeros(k);
   matrix<float> k_rewards = matrix<float>::Zeros(k, NRewards);
   matrix<float> k_actions = matrix<float>::Zeros(k, NActions);
   matrix<float> k_embedding = matrix<float>::Zeros(k + 1, size);
   matrix<float> U, V;
   vector<float> S;
   float max = dist.Percentile(percentile);
   float min = dist.Min();
   for(ulong i = 0, cur = 0; (i < states && cur < k); i++)
     {
      if(max < dist[i])
         continue;
      min_dist[cur] = dist[i];
      k_rewards.Row(rewards.Row(i), cur);
      k_actions.Row(actions.Row(i), cur);
      k_embedding.Row(state_embedding.Row(i), cur);
      cur++;
     }
   k_embedding.Row(embedding, k);

为了获得用于训练的目标奖励向量，我们需要基于与所分析状态的距离，来为所选奖励的矩阵加权。注意，最小距离将为我们给出相应奖励的最小权重。然而，这与一般逻辑相矛盾：最相关的值对于最终结果的影响很小。这很容易修复。我们简单地把距离向量乘以 “-1”。SoftMax 函数会把获得的数值转换为概率平面。现在我们只需要将得到的概率向量乘以最接近状态的所收集奖励矩阵。

   vector<float> sf;
   (min_dist*(-1)).Activation(sf, AF_SOFTMAX);
   result.rewards = sf.MatMul(k_rewards);

于此，我们还添加了核规范以鼓励扮演者学习。

   k_embedding.SVD(U, V, S);
   result.rewards[NRewards - 2] = S.Sum() / (MathSqrt(MathPow(k_embedding, 2.0f).Sum() * MathMax(k + 1, size)));
   result.rewards[NRewards - 1] = EntropyLatentState(Actor);

接下来，我们形成一个目标动作向量。这一次，我们将通过它们的优先奖励来为动作加权。与距离向量类似，我们将调用 LogSumExp 函数计算奖励向量。

   vector<float> act_sf;
   alpha=MathAbs(k_rewards).Max();   
   dist = MathLog(MathExp(k_rewards/(-alpha)).Sum(1))*(-alpha);

这次，最大奖励应该具有最大影响，故我们不需要倒置该值。我们简单地调用 SoftMax 函数将奖励转换到概率值区域。之后，我们将得到的向量乘以动作矩阵。结果被写入结构之中。然后，我们将目标值的两个向量返回给调用方。

至此，我们完成了准备工作，并转到主要算法的实现。

2.3训练数据收集 EA

接下来，我们转入离线模型训练数据的收集程序。如前，该任务将在 EA “...\DWSL\Research.mq5” 中实现。我们不会全面回顾这个 EA 的整体代码，因为它的大多数方法在早前的文章中已经用到并详述过。我们看一下主要功能。我们从 OnTick tick 处理方法开始，其主体实现了主算法。

在方法开伊始，我们检查是否有新柱线开立，并在必要时加载历史价格和指标数据。

void OnTick()
  {
//---
   if(!IsNewBar())
      return;
//---
   int bars = CopyRates(Symb.Name(), TimeFrame, iTime(Symb.Name(), TimeFrame, 1), HistoryBars, Rates);
   if(!ArraySetAsSeries(Rates, true))
      return;
//---
   RSI.Refresh();
   CCI.Refresh();
   ATR.Refresh();
   MACD.Refresh();
   Symb.Refresh();
   Symb.RefreshRates();

使用获得的数据，我们形成初始数据的缓冲区。

   float atr = 0;
   for(int b = 0; b < (int)HistoryBars; b++)
     {
      float open = (float)Rates[b].open;
      float rsi = (float)RSI.Main(b);
      float cci = (float)CCI.Main(b);
      atr = (float)ATR.Main(b);
      float macd = (float)MACD.Main(b);
      float sign = (float)MACD.Signal(b);
      if(rsi == EMPTY_VALUE || cci == EMPTY_VALUE || atr == EMPTY_VALUE || macd == EMPTY_VALUE || sign == EMPTY_VALUE)
         continue;
      //---
      int shift = b * BarDescr;
      sState.state[shift] = (float)(Rates[b].close - open);
      sState.state[shift + 1] = (float)(Rates[b].high - open);
      sState.state[shift + 2] = (float)(Rates[b].low - open);
      sState.state[shift + 3] = (float)(Rates[b].tick_volume / 1000.0f);
      sState.state[shift + 4] = rsi;
      sState.state[shift + 5] = cci;
      sState.state[shift + 6] = atr;
      sState.state[shift + 7] = macd;
      sState.state[shift + 8] = sign;
     }
   bState.AssignArray(sState.state);

以及帐户状态缓冲区。

   sState.account[0] = (float)AccountInfoDouble(ACCOUNT_BALANCE);
   sState.account[1] = (float)AccountInfoDouble(ACCOUNT_EQUITY);
//---
   double buy_value = 0, sell_value = 0, buy_profit = 0, sell_profit = 0;
   double position_discount = 0;
   double multiplyer = 1.0 / (60.0 * 60.0 * 10.0);
   int total = PositionsTotal();
   datetime current = TimeCurrent();
   for(int i = 0; i < total; i++)
     {
      if(PositionGetSymbol(i) != 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 += profit - (current - PositionGetInteger(POSITION_TIME)) * multiplyer * MathAbs(profit);
     }
   sState.account[2] = (float)buy_value;
   sState.account[3] = (float)sell_value;
   sState.account[4] = (float)buy_profit;
   sState.account[5] = (float)sell_profit;
   sState.account[6] = (float)position_discount;
   sState.account[7] = (float)Rates[0].time;
//---
   bAccount.Clear();
   bAccount.Add((float)((sState.account[0] - PrevBalance) / PrevBalance));
   bAccount.Add((float)(sState.account[1] / PrevBalance));
   bAccount.Add((float)((sState.account[1] - PrevEquity) / PrevEquity));
   bAccount.Add(sState.account[2]);
   bAccount.Add(sState.account[3]);
   bAccount.Add((float)(sState.account[4] / PrevBalance));
   bAccount.Add((float)(sState.account[5] / PrevBalance));
   bAccount.Add((float)(sState.account[6] / PrevBalance));
   double x = (double)Rates[0].time / (double)(D'2024.01.01' - D'2023.01.01');
   bAccount.Add((float)MathSin(2.0 * M_PI * x));
   x = (double)Rates[0].time / (double)PeriodSeconds(PERIOD_MN1);
   bAccount.Add((float)MathCos(2.0 * M_PI * x));
   x = (double)Rates[0].time / (double)PeriodSeconds(PERIOD_W1);
   bAccount.Add((float)MathSin(2.0 * M_PI * x));
   x = (double)Rates[0].time / (double)PeriodSeconds(PERIOD_D1);
   bAccount.Add((float)MathSin(2.0 * M_PI * x));

我们将收集到的数据传输到扮演者模型，并调用前馈方法。切记要控制操作的执行。

   if(bAccount.GetIndex() >= 0)
      if(!bAccount.BufferWrite())
         return;
//---
   if(!Actor.feedForward(GetPointer(bState), 1, false, GetPointer(bAccount)))
      return;

作为前馈验算的结果，扮演者模型生成一个动作向量，我们对其进行解密。此处，我们只删除了未产生盈利的逆操作交易量。与之前讨论过的其它工作不同，我们不会为探索环境而在结果向量中添加噪音。扮演者的随机政策，以及潜在状态的随机性，已经产生了足够的行动扩散，从而探索行动空间的直接环境。

   PrevBalance = sState.account[0];
   PrevEquity = sState.account[1];
//---
   vector<float> temp;
   Actor.getResults(temp);
//---
   double min_lot = Symb.LotsMin();
   double step_lot = Symb.LotsStep();
   double stops = MathMax(Symb.StopsLevel(), 1) * Symb.Point();
   if(temp[0] >= temp[3])
     {
      temp[0] -= temp[3];
      temp[3] = 0;
     }
   else
     {
      temp[3] -= temp[0];
      temp[0] = 0;
     }

接下来，我们将现有持仓与扮演者的预测进行比较，并在必要时执行交易操作。首先是多头持仓。

//--- buy control
   if(temp[0] < min_lot || (temp[1] * MaxTP * Symb.Point()) <= stops || (temp[2] * MaxSL * Symb.Point()) <= stops)
     {
      if(buy_value > 0)
         CloseByDirection(POSITION_TYPE_BUY);
     }
   else
     {
      double buy_lot = min_lot + MathRound((double)(temp[0] - min_lot) / step_lot) * step_lot;
      double buy_tp = NormalizeDouble(Symb.Ask() + temp[1] * MaxTP * Symb.Point(), Symb.Digits());
      double buy_sl = NormalizeDouble(Symb.Ask() - temp[2] * MaxSL * Symb.Point(), Symb.Digits());
      if(buy_value > 0)
         TrailPosition(POSITION_TYPE_BUY, buy_sl, buy_tp);
      if(buy_value != buy_lot)
        {
         if(buy_value > buy_lot)
            ClosePartial(POSITION_TYPE_BUY, buy_value - buy_lot);
         else
            Trade.Buy(buy_lot - buy_value, Symb.Name(), Symb.Ask(), buy_sl, buy_tp);
        }
     }

然后针对空头持仓重复上述步骤。

//--- sell control
   if(temp[3] < min_lot || (temp[4] * MaxTP * Symb.Point()) <= stops || (temp[5] * MaxSL * Symb.Point()) <= stops)
     {
      if(sell_value > 0)
         CloseByDirection(POSITION_TYPE_SELL);
     }
   else
     {
      double sell_lot = min_lot + MathRound((double)(temp[3] - min_lot) / step_lot) * step_lot;;
      double sell_tp = NormalizeDouble(Symb.Bid() - temp[4] * MaxTP * Symb.Point(), Symb.Digits());
      double sell_sl = NormalizeDouble(Symb.Bid() + temp[5] * MaxSL * Symb.Point(), Symb.Digits());
      if(sell_value > 0)
         TrailPosition(POSITION_TYPE_SELL, sell_sl, sell_tp);
      if(sell_value != sell_lot)
        {
         if(sell_value > sell_lot)
            ClosePartial(POSITION_TYPE_SELL, sell_value - sell_lot);
         else
            Trade.Sell(sell_lot - sell_value, Symb.Name(), Symb.Bid(), sell_sl, sell_tp);
        }
     }

在方法操作结束时，都需要从环境中收集反馈，并将数据传输到经验回放缓冲区。

   sState.rewards[0] = bAccount[0];
   sState.rewards[1] = 1.0f - bAccount[1];
   if((buy_value + sell_value) == 0)
      sState.rewards[2] -= (float)(atr / PrevBalance);
   else
      sState.rewards[2] = 0;
   for(ulong i = 0; i < NActions; i++)
      sState.action[i] = temp[i];
   sState.rewards[3] = 0;
   sState.rewards[4] = 0;
   if(!Base.Add(sState))
      ExpertRemove();
  }

此刻，数据收集过程可以认为已完成。但是这个 EA 的工作尚未完成。作为 DWSL 方法实现的一部分，我想提请您注意一个细节。在本文的理论部分，我们已经提到，DWSL 方法收敛到最优政策，在训练集的轨迹水平上具有最小回报边际。自然地，在寻找最优轨迹时，我们希望尽可能提高最低盈利能力的极限。为此，我们要针对往经验回放缓冲区添加新轨迹的过程进行修改。在缓冲区初始填充后，我们将逐渐把盈利能力最小的验算用更多盈利的验算替代。该过程是在 OnTesterPass 方法中实现的，该方法在策略测试器中处理验算完成事件。

在方法主体中，我们首先初始化局部变量。立即创建一个循环来轮询验算帧。

void OnTesterPass()
  {
//---
   ulong pass;
   string name;
   long id;
   double value;
   STrajectory array[];
   while(FrameNext(pass, name, id, value, array))
     {

在循环的主体中，我们检查帧是否与当前程序匹配。

      int total = ArraySize(Buffer);
      if(name != MQLInfoString(MQL_PROGRAM_NAME))
         continue;
      if(id <= 0)
         continue;

之后，该过程将根据经验回放缓冲区的填充方式转到分支。如果缓冲区已经填满最大指定大小，则我们在缓冲区中搜索返回值最低的验算。这可能是最高亏损、或最低盈利。

      if(total >= MaxReplayBuffer)
        {
         for(int a = 0; a < id; a++)
           {
            float min = FLT_MAX;
            int min_tr = 0;
            for(int i = 0; i < total; i++)
              {
               float prof = Buffer[i].States[Buffer[i].Total - 1].account[1];
               if(prof < min)
                 {
                  min = MathMin(prof, min);
                  min_tr = i;
                 }
              }

接下来，我们将结果值与最后一次验算的返回值进行比较。如果较高，则写入新验算的数据，取代找到的最低回报。否则，转到下一次验算。

            float prof = array[a].States[array[a].Total - 1].account[1];
            if(min <= prof)
              {
               Buffer[min_tr] = array[a];
               PrintFormat("Replace %.2f to %.2f -> bars %d", min, prof, array[a].Total);
              }
           }
        }

如果缓冲区尚未填满，简单地添加一个新验算，无需不必要的控制操作。

      else
        {
         if(ArrayResize(Buffer, total + (int)id, 10) < 0)
            return;
         ArrayCopy(Buffer, array, total, 0, (int)id);
        }
     }
  }

我们的操作依据优先级：

最大程度地填充经验回放缓冲区，为经过训练的模型提供有关环境的最完整信息。
填满经验回放缓冲区之后，选择盈利最高的验算，来构建最优策略。

附件中提供了 EA 及其所有方法的完整代码。附件还包括模型测试 EA 的代码 “...\DWSL\Test.mq5”。它具有与跳价处理方法类似的算法，但适用于在策略测试器中单次运行。我们不会在本文的范围内研究它。

2.4模型训练 EA

模型训练过程在 EA “...\DWSL\Study.mq5” 中实现。我们不会详细讨论它的所有方法。我们只看 Train 方法，它归纳了训练模型的主要算法。

在方法的主体中，我们定义了经验回放缓冲区的大小，并将其保存在局部跳价计数器状态变量之中，以便跟踪操作所花费的时间。

void Train(void)
  {
   int total_tr = ArraySize(Buffer);
   uint ticks = GetTickCount();

接下来，我们遍历所有轨迹，计数经验回放缓冲区中的状态总数。这将令我们能够准备足够大小的矩阵来记录状态嵌入，以及智能体的相应奖励和动作。我们已经看到这些矩阵在 GetTargets 方法中的作用。

   int total_states = Buffer[0].Total;
   for(int i = 1; i < total_tr; i++)
      total_states += Buffer[i].Total;
   vector<float> temp, next;
   Convolution.getResults(temp);
   matrix<float> state_embedding = matrix<float>::Zeros(total_states, temp.Size());
   matrix<float> rewards = matrix<float>::Zeros(total_states, NRewards);
   matrix<float> actions = matrix<float>::Zeros(total_states, NActions);

下一步是填充这些矩阵。为此，我们创建了一个循环系统，从经验回放缓冲区彻底搜索所有状态。在这个循环系统的主体中，我们将每个单独状态的描述收集到单一数据缓冲区之中。

   int state = 0;
   for(int tr = 0; tr < total_tr; tr++)
     {
      for(int st = 0; st < Buffer[tr].Total; st++)
        {
         State.AssignArray(Buffer[tr].States[st].state);
         float PrevBalance = Buffer[tr].States[MathMax(st - 1, 0)].account[0];
         float PrevEquity = Buffer[tr].States[MathMax(st - 1, 0)].account[1];
         State.Add((Buffer[tr].States[st].account[0] - PrevBalance) / PrevBalance);
         State.Add(Buffer[tr].States[st].account[1] / PrevBalance);
         State.Add((Buffer[tr].States[st].account[1] - PrevEquity) / PrevEquity);
         State.Add(Buffer[tr].States[st].account[2]);
         State.Add(Buffer[tr].States[st].account[3]);
         State.Add(Buffer[tr].States[st].account[4] / PrevBalance);
         State.Add(Buffer[tr].States[st].account[5] / PrevBalance);
         State.Add(Buffer[tr].States[st].account[6] / PrevBalance);
         double x = (double)Buffer[tr].States[st].account[7] / (double)(D'2024.01.01' - D'2023.01.01');
         State.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
         x = (double)Buffer[tr].States[st].account[7] / (double)PeriodSeconds(PERIOD_MN1);
         State.Add((float)MathCos(x != 0 ? 2.0 * M_PI * x : 0));
         x = (double)Buffer[tr].States[st].account[7] / (double)PeriodSeconds(PERIOD_W1);
         State.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
         x = (double)Buffer[tr].States[st].account[7] / (double)PeriodSeconds(PERIOD_D1);
         State.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));

然后，在编码器的前馈验算中，我们生成其嵌入。

         if(!Convolution.feedForward(GetPointer(State), 1, false, NULL))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            ExpertRemove();
            return;
           }
         Convolution.getResults(temp);

输出向量保存在 state_embedding 矩阵当中。

         if(!state_embedding.Row(temp, state))
            continue;

经验回放缓冲区中的相关数据保存在 “rewards” 和智能体的 “actions” 矩阵当中。

         if(!temp.Assign(Buffer[tr].States[st].rewards) ||
            !next.Assign(Buffer[tr].States[st + 1].rewards) ||
            !rewards.Row(temp - next * DiscFactor, state))
            continue;
         if(!temp.Assign(Buffer[tr].States[st].action) ||
            !actions.Row(temp, state))
            continue;

请注意，我们只把移动到下一个状态的收益添加到奖励矩阵之中。此外，如果发生任何错误，我们不会完全终止程序，而只是转到下一个状态。因此，我们并没有完成整个学习过程，而只是略微降低了比较的基准。

然后我们递增已保存嵌入的计数器。在转到循环系统的下一次迭代之前，我们会告知用户状态编码过程的进度。

         state++;
         if(GetTickCount() - ticks > 500)
           {
            string str = StringFormat("%-15s %6.2f%%", "Embedding ", state * 100.0 / (double)(total_states));
            Comment(str);
            ticks = GetTickCount();
           }
        }
     }

一旦编码过程完毕，我们将矩阵缩减到实际填充的数据量。

   if(state != total_states)
     {
      rewards.Resize(state, NRewards);
      actions.Resize(state, NActions);
      state_embedding.Reshape(state, state_embedding.Cols());
      total_states = state;
     }

下一步是准备局部变量，并规划轨迹的优先级。计算所选轨迹概率的过程是在单独的 GetProbTrajectories 方法中实现的，该方法的算法已在上一篇文章中讲解过。

   vector<float> rewards1, rewards2, target_reward;
   STarget target;
//---
   vector<float> probability = GetProbTrajectories(Buffer, 0.9);

数据准备阶段就完成了。接下来，我们转入讨论模型训练算法，其也组织在一个循环里。模型训练循环的迭代次数在 EA 的外部参数中指定。

在循环主体中，我们首先对轨迹进行采样，同时参考上面计算的概率。该过程在 SampleTrajectory 方法中实现；它的算法也在上一篇文章中研究过。然后，我们对所选轨迹上的状态进行采样。

   vector<float> probability = GetProbTrajectories(Buffer, 0.9);
   int bar = (HistoryBars - 1) * BarDescr;
   for(int iter = 0; (iter < Iterations && !IsStopped()); iter ++)
     {
      int tr = SampleTrajectory(probability);
      int i = (int)((MathRand() * MathRand() / MathPow(32767, 2)) * (Buffer[tr].Total - 2));
      if(i < 0)
        {
         iter--;
         continue;
        }

接下来，我根据完成的训练迭代结果来规划分支过程。在初始阶段，我剔除了由目标模型估测后续状态，因为未经训练的模型对状态的估测完全是随机的，并且可能导致学习过程朝着错误的方向发展。反之，由具有足够准确度的模型推算的后续状态，令我们能够估测该步骤中所用政策的预期未来回报。因此，我们可以参考后续回报确定动作的优先级。

在这个模块中，我们用环境的后续状态的描述来填充初始数据缓冲区。

         State.AssignArray(Buffer[tr].States[i + 1].state);
         float PrevBalance = Buffer[tr].States[i].account[0];
         float PrevEquity = Buffer[tr].States[i].account[1];
         Account.Clear();
         Account.Add((Buffer[tr].States[i + 1].account[0] - PrevBalance) / PrevBalance);
         Account.Add(Buffer[tr].States[i + 1].account[1] / PrevBalance);
         Account.Add((Buffer[tr].States[i + 1].account[1] - PrevEquity) / PrevEquity);
         Account.Add(Buffer[tr].States[i + 1].account[2]);
         Account.Add(Buffer[tr].States[i + 1].account[3]);
         Account.Add(Buffer[tr].States[i + 1].account[4] / PrevBalance);
         Account.Add(Buffer[tr].States[i + 1].account[5] / PrevBalance);
         Account.Add(Buffer[tr].States[i + 1].account[6] / PrevBalance);
         double x = (double)Buffer[tr].States[i + 1].account[7] / (double)(D'2024.01.01' - D'2023.01.01');
         Account.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
         x = (double)Buffer[tr].States[i + 1].account[7] / (double)PeriodSeconds(PERIOD_MN1);
         Account.Add((float)MathCos(x != 0 ? 2.0 * M_PI * x : 0));
         x = (double)Buffer[tr].States[i + 1].account[7] / (double)PeriodSeconds(PERIOD_W1);
         Account.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
         x = (double)Buffer[tr].States[i + 1].account[7] / (double)PeriodSeconds(PERIOD_D1);
         Account.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));

参考更新的政策生成智能体动作。

         if(Account.GetIndex() >= 0)
            Account.BufferWrite();
         if(!Actor.feedForward(GetPointer(State), 1, false, GetPointer(Account)))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            break;
           }

然后，由两个目标评论者模型估测结果动作。

         if(!TargetCritic1.feedForward(GetPointer(Actor), LatentLayer, GetPointer(Actor)) ||
            !TargetCritic2.feedForward(GetPointer(Actor), LatentLayer, GetPointer(Actor)))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            break;
           }

我们使用最小估值来计算预期奖励。

         TargetCritic1.getResults(rewards1);
         TargetCritic2.getResults(rewards2);
         target_reward.Assign(Buffer[tr].States[i + 1].rewards);
         if(rewards1.Sum() <= rewards2.Sum())
            target_reward = rewards1 - target_reward;
         else
            target_reward = rewards2 - target_reward;
         target_reward[NRewards - 1] = EntropyLatentState(Actor);
         target_reward *= DiscFactor;
        }

在下一阶段，我们转到训练评论者模型的过程。这些模型是采用经验回放缓冲区中的状态和动作进行训练的。

首先，我们将环境当前状态的描述复制到源数据缓冲区之中。

      //--- Q-function study
      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];
      Account.Clear();
      Account.Add((Buffer[tr].States[i].account[0] - PrevBalance) / PrevBalance);
      Account.Add(Buffer[tr].States[i].account[1] / PrevBalance);
      Account.Add((Buffer[tr].States[i].account[1] - PrevEquity) / PrevEquity);
      Account.Add(Buffer[tr].States[i].account[2]);
      Account.Add(Buffer[tr].States[i].account[3]);
      Account.Add(Buffer[tr].States[i].account[4] / PrevBalance);
      Account.Add(Buffer[tr].States[i].account[5] / PrevBalance);
      Account.Add(Buffer[tr].States[i].account[6] / PrevBalance);
      double x = (double)Buffer[tr].States[i].account[7] / (double)(D'2024.01.01' - D'2023.01.01');
      Account.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
      x = (double)Buffer[tr].States[i].account[7] / (double)PeriodSeconds(PERIOD_MN1);
      Account.Add((float)MathCos(x != 0 ? 2.0 * M_PI * x : 0));
      x = (double)Buffer[tr].States[i].account[7] / (double)PeriodSeconds(PERIOD_W1);
      Account.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
      x = (double)Buffer[tr].States[i].account[7] / (double)PeriodSeconds(PERIOD_D1);
      Account.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0));
      if(Account.GetIndex() >= 0)
         Account.BufferWrite();

收集到的数据允许我们运行扮演者的前馈验算。

      if(!Actor.feedForward(GetPointer(State), 1, false, GetPointer(Account)))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         break;
        }

请注意，我们在训练评论者之前会运行扮演者前馈验算。尽管在训练过程中，我们将使用经验回放缓冲区中的动作。这是由于会用扮演者的潜在状态作为评论者的输入。

接下来，我们从训练数据库中填充动作缓冲区，并调用评论者的前馈验算方法。

      Actions.AssignArray(Buffer[tr].States[i].action);
      if(Actions.GetIndex() >= 0)
         Actions.BufferWrite();
      //---
      if(!Critic1.feedForward(GetPointer(Actor), LatentLayer, GetPointer(Actions)) ||
         !Critic2.feedForward(GetPointer(Actor), LatentLayer, GetPointer(Actions)))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         break;
        }

我们将使用加权奖励作为训练模型的目标值。为了获得它们，我们首先将帐户状态的描述添加到环境当前状态的缓冲区之中，并生成所分析状态的嵌入。

      if(!State.AddArray(GetPointer(Account)) || !Convolution.feedForward(GetPointer(State), 1, false, NULL))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         break;
        }
      Convolution.getResults(temp);

该阶段的可用数据集足以调用前面讨论的 GetTargets 方法，其返回加权奖励和动作的向量。

      target = GetTargets(Percent, temp, state_embedding, rewards, actions);

依据目标数据，我们就可以运行评论者模型的反向传播验算。但首先，我们调用 CAGrad 方法校正误差梯度。

      Critic1.getResults(rewards1);
      Result.AssignArray(CAGrad(target.rewards + target_reward - rewards1) + rewards1);
      if(!Critic1.backProp(Result, GetPointer(Actions), GetPointer(Gradient)) ||
         !Actor.backPropGradient(GetPointer(Account), GetPointer(Gradient), LatentLayer))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         break;
        }

      Critic2.getResults(rewards2);
      Result.AssignArray(CAGrad(target.rewards + target_reward - rewards2) + rewards2);
      if(!Critic2.backProp(Result, GetPointer(Actions), GetPointer(Gradient)) ||
         !Actor.backPropGradient(GetPointer(Account), GetPointer(Gradient), LatentLayer))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         break;
        }

在下一步中，我们将更新扮演者的政策。我们之前已经运行了模型的前馈验算。此外，我们还获得了目标动作的加权向量。因此，我们拥有在监督学习模式下执行反向传播验算所需的所有数据。

      //--- Policy study
      Actor.getResults(rewards1);
      Result.AssignArray(CAGrad(target.actions - rewards1) + rewards1);
      if(!Actor.backProp(Result, GetPointer(Account), GetPointer(Gradient)))
        {
         PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
         break;
        }

正如您所见，在形成扮演者的目标动作向量时，我们用到了直接从经验回放缓冲区中提取的动作优势。因此，没有用到已训练的评论者模型。请注意，无论扮演者的政策如何，其对市场走势的影响都是微乎其微的。因此，高估正在使用的评论者优势，可能会因建模误差而令数据失真。在这样的范式中，训练评论者模型看似没有必要。但我们仍然希望考虑所研究政策对未来预期回报的影响。为此目的，我们选择在训练结果中表现出最低误差的评论者。我们还估测由新政策生成的扮演者动作。然后，将结果估值与加权估值的偏差梯度传递给扮演者，以便优化参数。

      CNet *critic = NULL;
      if(Critic1.getRecentAverageError() <= Critic2.getRecentAverageError())
         critic = GetPointer(Critic1);
      else
         critic = GetPointer(Critic2);
      if(MathAbs(critic.getRecentAverageError()) <= MaxErrorActorStudy)
        {
         if(!critic.feedForward(GetPointer(Actor), LatentLayer, GetPointer(Actor)))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            break;
           }
         critic.getResults(rewards1);
         Result.AssignArray(CAGrad(target.rewards + target_reward - rewards1) + rewards1);
         critic.TrainMode(false);
         if(!critic.backProp(Result, GetPointer(Actor)) ||
            !Actor.backPropGradient(GetPointer(Account), GetPointer(Gradient)))
           {
            PrintFormat("%s -> %d", __FUNCTION__, __LINE__);
            critic.TrainMode(true);
            break;
           }
         critic.TrainMode(true);
        }

注意，只有当我们足够信任评论者对这些动作进行了充分估测，才会执行这些操作。为了规范该过程，我们引入了一个额外的外部参数 MaxErrorActorStudy，其确定启用指定进程时，评论者估测的最大误差。

完成模型训练过程之后，我们将训练好的评论者模型的参数复制到目标模型当中。此处还应当注意的是，在初始阶段，在启用估测后续状态的过程之前，我们将训练模型的参数完全转移到目标模型。使用该机制，是为估测后续状态能够软性参数复制。

      //--- Update Target Nets
      if(iter >= StartTargetIter)
        {
         TargetCritic1.WeightsUpdate(GetPointer(Critic1), Tau);
         TargetCritic2.WeightsUpdate(GetPointer(Critic2), Tau);
        }
      else
        {
         TargetCritic1.WeightsUpdate(GetPointer(Critic1), 1);
         TargetCritic2.WeightsUpdate(GetPointer(Critic2), 1);
        }

这样就完成了一次模型训练迭代的操作。现在我们只需要通知用户模型训练过程的进度，然后转到下一次迭代。

      if(GetTickCount() - ticks > 500)
        {
         string str = StringFormat("%-15s %5.2f%% -> Error %15.8f\n", "Critic1", iter * 100.0 / (double)(Iterations), 
                                                                                    Critic1.getRecentAverageError());
         str += StringFormat("%-15s %5.2f%% -> Error %15.8f\n", "Critic2", iter * 100.0 / (double)(Iterations), 
                                                                                    Critic2.getRecentAverageError());
         str += StringFormat("%-14s %5.2f%% -> Error %15.8f\n", "Actor", iter * 100.0 / (double)(Iterations), 
                                                                                      Actor.getRecentAverageError());
         Comment(str);
         ticks = GetTickCount();
        }
     }

模型训练循环的所有迭代成功完成之后，我们清除图表上的注释字段。将学习结果告知用户，并启动 EA 终止。

   Comment("");
//---
   PrintFormat("%s -> %d -> %-15s %10.7f", __FUNCTION__, __LINE__, "Critic1", Critic1.getRecentAverageError());
   PrintFormat("%s -> %d -> %-15s %10.7f", __FUNCTION__, __LINE__, "Critic2", Critic2.getRecentAverageError());
   PrintFormat("%s -> %d -> %-15s %10.7f", __FUNCTION__, __LINE__, "Actor", Actor.getRecentAverageError());
   ExpertRemove();
//---
  }

本文的实践部分到此结束。在附件中可找到文章中用到的所有程序的完整代码。我们进入测试阶段。

3. 测试

我们已经做了大量的工作，利用 MQL5 实现了我们对 DWSL 方法的愿景。我必须承认，我们最终从前面讨论过的一定数量方法中得到了一种合成产物。这是一个相当大型的实验。我们的解决方案，其有效性可以依据历史数据来检验。这就是我们现在要做的。

与之前的所有情况一样，模型训练是依据 2023 年前 7 个月的 EURUSD H1 数据进行的。在 MetaTrader 5 策略测试器中以全参数优化模式收集训练模型的数据。在第一阶段，我们收集了 500 条随机轨迹。由于我们已经优化了 OnTesterPass 方法算法，因此我们可以运行更多一点的验算。那些显示最佳回报的验算将被选入经验回放缓冲区。

请注意，此处我们不应当致力获得随机政策的可盈利段落。在这个阶段，这是一个相当随机的过程。正如我们之前所见，贯穿整个间隔，通过随机政策获得完全可盈利验算的概率接近于 0。幸运的是，DWSL 方法能够应对任何品质的原初数据。

收集训练数据集之后，我们首次运行模型训练 EA。

在该阶段，我还未得到完全可盈利的策略。这主要归因于训练数据集的验算回报率较低。但应当注意的是，在第一个训练循环之后，重新运行与环境交互的 EA，给出的轨迹明显具有更高的回报。甚至有一回，可能是偶然的，在整个训练运行期间一直盈利。这通常明示该方法的有效性，且有望达成更好的结果。

经过几次收集轨迹和训练的迭代，我设法得到了一个可以持续产生盈利的模型。依据 2023 年 8 月的历史数据对生成的模型进行了测试，该数据未包含在训练集中。然而，由于它们直接延续训练区间，因此我们可以假设数据集具有可比性。

测试结果

根据测试结果，该模型成功盈利，盈利系数达到 1.3。余额图显示，上半月增长相当快。然后它在相当窄的范围内波动。以下测试结果可认为积极：

超过 50% 的仓位都是可盈利的。
最大盈利交易几乎是最大亏损交易的 4 倍，平均盈利交易几乎比平均亏损交易多四分之一。
两个方向都有交易（60% 做空和 40% 做多）。近 55% 的做空和 46% 的做多仓位获利了结。
最长的连串盈利在交易数量和金额上都超过了最长的连串亏损。

获得的结果通常会给人留下积极的印象。

结束语

在本文中，我们讲述了另一种有趣的训练模型方法，即距离加权监督学习。通过对可用数据进行加权评估，它允许对收集到的非最优轨迹进行离线优化，并训练非常有趣的政策。它们随后表现出良好的效果。

我们的实施结果确认了所研究方法的有效性。在训练过程中，我们获得了一项能够将所学素材推广到新数据的政策。结果就是，我们在测试期间得到了一个盈利性的余额图。

不过，我要再次提醒您，本文中讲述的所有程序仅用于演示该技术，尚未准备好在实盘交易中使用。

参考

离线交互数据的距离加权监督学习

神经网络变得简单（第 46 部分）：目标条件强化学习（GCRL）

神经网络变得简单（第 53 部分）：奖励分解

神经网络变得简单（第 57 部分）：随机边际扮演者-评论者（SMAC）

神经网络变得简单（第 62 部分）：在层次化模型中运用决策转换器

文中所用程序

#	名称	类型	说明
1	Research.mq5	EA	样本收集 EA
2	Study.mq5	EA	智能体训练 EA
3	Test.mq5	EA	模型测试 EA
4	Trajectory.mqh	类库	系统状态定义结构
5	NeuroNet.mqh	类库	创建神经网络的类库
6	NeuroNet.cl	代码库	OpenCL 程序代码库