English Русский Español Deutsch 日本語 Português
preview
交易中的神经网络:异质性感知元参数学习(关键组件)

交易中的神经网络:异质性感知元参数学习(关键组件)

MetaTrader 5 — 交易系统 |
25 0
Dmitriy Gizlyk
Dmitriy Gizlyk

引言

在前一篇文章中,我们探讨了HimNet框架——这是一个不仅能分析数据,还能理解其上下文的实用工具。 在交易中,这意味着该模型能够区分流动性高的时期和交易清淡的时期。HimNet会自动适应这些变化。

HimNet的架构简单且合乎逻辑:将长度为T、覆盖N个位置的时间序列片段作为输入。 首先,该模型生成两种可训练的嵌入——时间嵌入和空间嵌入。 时间嵌入(一天中的时刻、星期几)能够捕捉周期和市场状态——早间开盘时的激增、日间的回落以及夜间的低迷。 空间嵌入为每个位置或交易代码分配一个独立向量,用于编码时间序列的特征。 所有这些向量都存储在字典中,并在训练过程中得到优化。 它们充当对元参数池的查询,并使模型能够根据图卷积的行为,为不同的市场情境选择不同的权重。 这种动态生成机制既具备元学习的灵活性,又无需消耗大量内存和计算资源。

HimNet的核心是采用切比雪夫基增强的图循环模块(图卷积门控循环单元GCRU)。 这种架构设计使模型既具有深度,又兼具实用性。GCRU将交易场所网络视为一个图:每个节点代表一个交易代码或一个交易场所,而边则反映相关性、跨市场点差或某种经验关系。 切比雪夫多项式为K跳聚合提供了一种紧凑的实现方式:模型考虑距离不超过K条边的邻居的影响,却无需进行计算密集型的谱对角化——计算快速、具有局部性且数值稳定。 简而言之,该框架的作者并不计算图的完整谱,而是逐步构建一组矩阵,以捕捉直接邻居、邻居的邻居等节点的影响,然后结合上下文综合这些影响。

编码在HimNet中沿两条并行信息流进行。 第一条信息流(空间编码器)扫描交易场所的特征:订单簿深度、典型成交量以及对新闻的历史反应。 第二条信息流(时间编码器)捕捉随时间变化的市场状态:市场开盘、新闻流、夜间平静期或数据发布时段。 这两个编码器都会生成隐藏表示,这些表示随后被合并为一个统一的潜在张量。 这并非机械式的求和,而是对语义的精细卷积:时间决定敏感程度,而空间决定聚合方式。 由此,我们得到当前市场状态的统一图景。

解码器将这一统一表示投影为时空嵌入,该嵌入用作查询,以访问ST元参数池。 该池返回一组针对这一特定时空组合的参数,这些参数直接构成GCRU模块的权重,该模块位于解码器中。 换句话说,该框架的作者会根据当前市场状态实时重组循环处理结构:开盘时采用一组权重和敏感度,而在夜间时段则采用另一组。 随后,解码器通过逐步迭代,为指定的预测时域生成预测。

从代数和数值计算的角度来看,对于每个状态,我们计算切比雪夫多项式在K个阶次上的结果,将其拼接起来,再通过元参数池根据嵌入查询生成的矩阵进行变换。 梯度会回流到池参数和嵌入向量中。 因此,该模型不仅学会了进行预测,还学会了识别有用的时空上下文。 实际上,这提供了一种适应机制,使模型能够选择在特定时刻最合适的运行模式。

在实际交易中,这会带来切实的好处。 当主交易时段开始时,HimNet会自动强化其参数,以快速应对成交量激增,从而减少滑点。 在流动性较低的时期,该模型会做出更为保守的预测并减少错误入场,从而防范单笔交易引发的瞬时异常尖峰的风险。 这意味着,当流动性消失时,点差会相应扩大,同时对虚假跳空的过滤也会更加严格。 一旦出现突发冲击,ST模型将切换至防御模式,从而提高预测的稳健性,并降低陷入市场陷阱的风险。

从技术角度来看,该架构依然务实且适合工业应用:元参数池结构紧凑,不会导致内存和计算资源消耗呈爆炸式增长,而基于切比雪夫多项式幂次的计算在GPU上可轻松实现扩展。

超参数本质上是模型灵活性与响应速度之间的合理折中。 这些超参数通过在具有代表性的市场情景下进行验证来选定。 可解释性在此并非仅仅是装饰:通过观察池中各候选项的激活情况以及自适应图的热力图,我们可以快速了解模型当前识别出了哪些市场状态、为何做出某些预测,以及应采用哪些执行规则。

在实际应用层面,这体现为一套具体的控制手段——从自动切换至保守模式的触发机制,到用于风险管理的透明报告——使HimNet既易于管理,又便于交易员和工程师理解。

因此,HimNet 将强大的局部聚合、自适应元学习和实用的工程实现相结合。 这不仅仅是一个经过改进的预测模型——它是一个能够理解市场状态并据此调整行为的工具,同时对交易员和风险管理人员而言,其行为依然可预测且易于管理。

下图展示了作者绘制的HimNet框架示意图。

第一篇文章的实践部分证实了这一想法在现实工程环境中是可行的。 我们将切比雪夫多项式构建和误差反向传播这些计算密集型操作交由GPU执行,具体方式是实现OpenCL内核ChebStep和ChebStepGrad。

在主程序方面,实现了CChebPolinom对象,该对象封装了内核,并为推理和梯度计算提供了统一的接口。 最终形成了一条混合处理流水线:训练快速,推理可靠。

在本文中,我们将继续实现HimNet框架中的方法,所用语言为MQL5。



图卷积对象

在接下来的工作阶段,我们将着手创建一个图卷积对象,该对象将利用切比雪夫基进行K跳聚合。 该模块在执行过程中发挥着关键作用:它接收已准备好的特征窗口,向CChebPolinom请求已计算好的矩阵𝑇𝑘,并根据当前的元参数,构建可供模型后续处理的输出序列。 重要的是,它必须同时具备灵活性、速度和可预测性:通过支持各种元参数化模式来体现灵活性,并通过严格的内存管理和数值检查来确保速度和可预测性。

新的CNeuronHimNetGrapConv对象在架构上被设计为一种实用的模块化适配器,用于连接时序特征窗口与图卷积——它将数据准备、矩阵运算调用以及与OpenCL内核的集成整合在一起,避免实现细节干扰模型的高层逻辑。

class CNeuronHimNetGrapConv   :  public CNeuronTransposeRCDOCL
  {
protected:
   CNeuronBaseOCL    cX_G;

public:
                     CNeuronHimNetGrapConv(void) {};
                    ~CNeuronHimNetGrapConv(void) {};
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint count, uint window, uint cheb_k,
                          ENUM_OPTIMIZATION optimization_type, uint batch) override;
   //---
   virtual bool      FeedForward(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support);
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support);
   //---
   virtual bool      Load(const int file_handle) override;
   //---
   virtual int       Type(void)        const                      {  return defNeuronHimNetGrapConv; }
   virtual void      SetOpenCL(COpenCLMy *obj);
   virtual uint      GetCount(void) override const { return iWindow; }
   virtual uint      GetWindow(void) override const { return GetDimension(); }
   virtual uint      GetChebK(void) const { return iCount; }
  };

该类内部包含一个结构紧凑但必不可少的辅助对象 `cX_G`。 它充当工作缓冲区,确保计算各阶段之间能够快速交换数据。 由于该对象是静态声明的,因此该类的构造函数和析构函数可以留空——初始化和内存清理在整个生命周期内仅执行一次,在创建或销毁实例时不会产生任何不必要的开销。

该类的新实例在Init方法中进行初始化。 在此方法中,我们首先调用父类的同名方法;该父类定义了神经元的通用接口。

bool CNeuronHimNetGrapConv::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                                 uint count, uint window, uint cheb_k,
                                 ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronTransposeRCDOCL::Init(numOutputs, myIndex, open_cl, cheb_k,
                                    count, window, optimization_type, batch))
      return false;
   if(!cX_G.Init(0, 0, OpenCL, Neurons(), optimization, iBatch))
      return false;
//---
   return true;
  }

接下来,初始化辅助缓冲区cX_G;它用作已拼接数据的工作区,并存储矩阵乘法的结果。 如果这些操作中有任何一项失败,Init将返回false,且该对象仍处于安全状态。

前向传播方法FeedForward起着指挥者的作用。 首先,该方法会严格检查作为参数接收的对象的兼容性:传入的NeuronOCL和Support必须存在。 此外,Support的Dimension和Steps值必须符合预期,与模块设置一致。

bool CNeuronHimNetGrapConv::FeedForward(CNeuronBaseOCL *NeuronOCL,
                                        CChebPolinom *Support)
  {
   if(!NeuronOCL || !Support)
      return false;
   if(Support.GetDimension() != iWindow ||
      Support.GetSteps() != iCount)
      return false;
   if(NeuronOCL.Neurons() != (Neurons() / iCount))
      return false;

它还会检查源数据对象中的神经元数量是否与预期形状相符。 这些检查并非只是走过场;它们能确保下面的矩阵运算不会在GPU上悄无声息地引发灾难。

接下来是关键的矩阵乘法运算,其中将所得的切比雪夫多项式与待分析时间序列的张量相乘。 该运算的结果存储在cX_G缓冲区中。

if(!MatMul(Support.getOutput(), NeuronOCL.getOutput(), cX_G.getOutput(),
           iWindow, iWindow, GetDimension(), iCount, false))
   return false;

正是这一操作,将变换后的表示T0 X、T1 X、……、Tk X拼接为X_G。 用交易中的情形来打个比方:Support是各个序列之间的关系图(切比雪夫多项式),NeuronOCL是多模态时间序列的特征窗口,而cX_G则是原始数据经过分析后的版本,其中每个单独的序列都已考虑了邻居的影响。 后续需要继续传递的,正是这个经过调整的矩阵。

然而,需要注意的是,矩阵乘法的结果是若干组经过调整的源数据,具有不同的邻域层级,形状为{K-hop, N, C}。 而这并不是该对象输出端所预期的数据表示形式。 因此,作为前向传播方法的最后一步,我们将cX_G传递给父类中的同名方法,该方法会将张量转置为预期的表示形式。 这一流程使代码模块化,从而简化了测试和优化工作。

如果任何阶段出现问题,该方法会干净利落地返回false,且不会产生任何副作用。

一旦前向传播计算出该层的响应,接下来这一同样重要的阶段就是误差梯度传播。 正是在这一环节,整个架构才具备了从历史数据中学习并适应实际市场情景的能力。

calcInputGradients方法首先通过一个代码块来检查接收到的参数:即指向上一层和切比雪夫多项式矩阵的指针是否有效。 该检查起到了某种“安全网”的作用,可在模型结构出现不一致时,防止计算结果出现错误。

bool CNeuronHimNetGrapConv::calcInputGradients(CNeuronBaseOCL *NeuronOCL,
      CChebPolinom *Support)
  {
   if(!NeuronOCL || !Support)
      return false;
   if(Support.GetDimension() != iWindow ||
      Support.GetSteps() != iCount)
      return false;
   if(NeuronOCL.Neurons() != (Neurons() / iCount))
      return false;

接下来,该方法会检查维度:步数(K跳)和窗口大小必须符合预期。 这一步非常重要,因为图卷积对维度不匹配非常敏感——此处的任何错误都可能引发错误梯度的连锁反应,从而导致整个训练过程脱轨。

如果检查通过,我们就直接进入误差梯度分配过程。 首先,我们将从模型后续层获得的梯度进行转置,使其与卷积输出的表示形式相匹配。

   if(!CNeuronTransposeRCDOCL::calcInputGradients(cX_G.AsObject()))
      return false;
   if(!MatMulGrad(Support.getOutput(), Support.getGradient(),
                  NeuronOCL.getOutput(), NeuronOCL.getGradient(),
                  cX_G.getGradient(), iWindow, iWindow,
                  GetDimension(), iCount, false))
      return false;
//---
   return true;
  }

最后一步是将误差梯度分配给输入数据和切比雪夫多项式。 在此步骤中,该方法实际上将误差的累积效应分配到前向传播时信息所经过的相同通道中,只是此时传播方向相反。 我们将使用从父对象继承而来的MatMulGrad方法。 因此,我们得到了两种类型的梯度。 第一种是相对于该层输入数据本身的梯度,该梯度随后将用于调整前面各层的权重。 第二种是相对于切比雪夫展开系数的梯度,使框架能够在市场依赖关系随时间变化时调整图结构表示。

最终的归纳分析正是在这一阶段进行:系统据此确定哪些连接是有用的,哪些是多余的,并为下一个优化周期奠定基础。

从实际应用的角度来看,CNeuronHimNetGrapConv正是模型让交易员“听见”信号的环节。 它将原始报价窗口转换为经过局部调整的信号。 该类架构经过专门设计,旨在确保这些转换过程快速、可重现且可解释。 该类及其所有方法的完整代码见附件。


循环模块

我们已经考察了基于切比雪夫多项式的基本图卷积模块的内部结构,并了解了输入数据流和误差梯度流在这个相对紧凑的单元内如何分配。现在,是时候向上提升一个层次,转向将局部图处理与隐藏状态的动态变化联系起来的节点。 这就是模型实际记忆形成的地方,正是这一组件确保了信息在时间步之间不会丢失,而是被无缝地编织进图结构中。 这里指的是CNeuronHimNetGCRU类——这一核心组件在模型的时间组件和空间组件之间充当信号调度器。 该对象的结构如下所示。

class CNeuronHimNetGCRU    :  public CNeuronBaseOCL
  {
protected:
   CNeuronBaseOCL          cInpAndHidden;
   CNeuronHimNetGrapConv   cZ_R;
   CNeuronConvOCL          cZ_R_emb;
   CNeuronBaseOCL          cZe_Re;
   CNeuronBaseOCL          cZ;
   CNeuronBaseOCL          cR;
   CNeuronBaseOCL          cCandidate;
   CNeuronHimNetGrapConv   cHC;
   CNeuronConvOCL          cHC_emb;
   CNeuronBaseOCL          cHCe;

public:
                     CNeuronHimNetGCRU(void) {};
                    ~CNeuronHimNetGCRU(void) {};
   //---
   virtual bool      Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                          uint units, uint window, uint window_out,
                          uint cheb_k, uint embed_dim,
                          ENUM_OPTIMIZATION optimization_type, uint batch);
   //---
   virtual bool      feedForward(CNeuronBaseOCL *NeuronOCL,
                                 CChebPolinom *Support,
                                 CNeuronBaseOCL *Embedding);
   virtual bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL,
                                        CChebPolinom *Support,
                                        CNeuronBaseOCL *Embedding);
   virtual bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL,
                                        CChebPolinom *Support,
                                        CNeuronBaseOCL *Embedding);
   //---
   virtual int       Type(void)   const   {  return defNeuronHimNetGCRU;   }
   //--- methods for working with files
   virtual bool      Save(int const file_handle);
   virtual bool      Load(int const file_handle);
   //---
   virtual bool      WeightsUpdate(CNeuronBaseOCL *source, float tau) override;
   virtual void      SetOpenCL(COpenCLMy *obj) override;
   virtual void      SetActivationFunction(ENUM_ACTIVATION value) override { };
  };

在这种情况下,仅仅对节点的邻居进行卷积运算,或将数据传入循环单元,已经不够了。 众所周知,金融市场很少呈现线性行为:货币对形成相互关联的群组,股票随所属行业板块联动,而大宗商品往往与出口国货币同步波动。 正因如此,仅靠时序模型是不够的——它需要一张连接图,而图卷积恰恰提供了这张图。 但图卷积本身是静态的。 要实时决定是增强还是减弱EURUSD的信号,就需要考虑相邻货币对GBPUSD和EURGBP走势相反的情况。 需要控制逻辑。 这正是该类所实现的功能。

该模块包含的不仅是时序模型开发者所熟悉的门控循环单元(GRU)机制,而是适配图结构的版本。 在前面的图卷积类中,我们处理的组件集合相当精简,而这里的配置则复杂得多。 内部组件数量可观,但每个组件在整体运行中都有明确的职责。 随着该对象各个方法的实现,我们将逐步介绍这些组件的作用,以免过早引入过多细节,增加读者的负担。 需要注意的是,所有这些内部对象都是静态声明的,这使得类更易于管理,同时也省去了创建繁琐的构造函数和析构函数的麻烦——它们保持为空,就像润滑良好的门一样,既不会发出吱吱声,也不需要在每次运行算法时花费额外精力。

从类的总体结构转向其具体工作细节,我们自然就来到了Init初始化方法。 这里就是布置棋子的地方——所有随后决定计算过程动态的内部组件,都在这里创建并准备就绪。 Init方法就像是幕后指挥家的指挥棒:虽然外部代码只是简单地调用它,但在内部,却会展开一系列复杂而井然有序的步骤,用于准备每个模块。

bool CNeuronHimNetGCRU::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl,
                             uint units, uint window, uint window_out,
                             uint cheb_k, uint embed_dim,
                             ENUM_OPTIMIZATION optimization_type, uint batch)
  {
   if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, units * window_out,
                                                   optimization_type, batch))
      return false;
   activation = None;

一切都始于初始化父类。 神经网络层继承的所有基础接口都在这里创建。 请注意,神经元的数量定义为序列中元素的数量与对象输出处特征窗口大小的乘积——从而为完整的时序上下文预先分配了计算空间。

紧接着,激活函数就被重置为零。 这是有意为之:在这个阶段,保持中性非常重要,这样后续层才能获得一张干净的画布,以便应用各自的激活函数。

接下来,内部组件的初始化序列开始执行。 第一个组件——cInpAndHidden——起着连接输入数据与隐藏状态的门户作用。 其维度由输入和输出特征窗口的总和乘以序列中的元素个数决定,这使其能够积累后续处理所需的所有信息。

   int index = 0;
   if(!cInpAndHidden.Init(0, index, OpenCL, (window + window_out)*units, optimization, iBatch))
      return false;
   cInpAndHidden.SetActivationFunction(None);

接下来,cZ_R登场;它负责构建组合矩阵Z和R,二者是门控循环单元(GRU)的关键门。 此时,处理图结构的机制便发挥了作用:该方法接受待分析数据的张量形状以及切比雪夫多项式的项数,后者直接影响图近似的深度。

   index++;
   if(!cZ_R.Init(0, index, OpenCL, units, window + window_out, cheb_k, optimization, iBatch))
      return false;
   cZ_R.SetActivationFunction(None);

初始化链中的下一个环节是cZ_R_emb对象——它是嵌入与卷积动态过程之间的一座桥梁。 其任务是生成卷积参数矩阵——不是机械地生成,而是依据得到的嵌入来生成——以便随后在计算流程中应用这些参数。

这不仅仅是一个辅助变量,更是一个关键的中介:在这里,对各个序列之间的联系进行智能重组,从而将这些序列从一组零散的观测结果转化为一张连贯的相互关系图谱。 如果将其与金融市场进行类比,这一步骤就像一位经验丰富的分析师的工作:他将原始的交易活动数据转化为一种格式,使趋势、相关性以及滞后依赖关系逐渐显现,从而能够预测未来的价格走势。

   index++;
   if(!cZ_R_emb.Init(0, index, OpenCL, embed_dim, embed_dim,
                     2 * cheb_k * (window + window_out) * window_out,
                     1, units, optimization, iBatch))
      return false;
   cZ_R_emb.SetActivationFunction(None);
   index++;
   if(!cZe_Re.Init(0, index, OpenCL, 2 * window_out * units, optimization, iBatch))
      return false;
   cZe_Re.SetActivationFunction(None);
   index++;
   if(!cZ.Init(0, index, OpenCL, window_out * units, optimization, iBatch))
      return false;
   cZ.SetActivationFunction(None);
   index++;
   if(!cR.Init(0, index, OpenCL, window_out * units, optimization, iBatch))
      return false;
   cR.SetActivationFunction(None);

随后,该方法初始化几个更轻量级但同样重要的模块:cZe_Re、cZ和cR。 这些模块生成最终的Z和R向量,可灵活控制信息的遗忘与更新。 其维度直接取决于特征窗口以及结果张量中序列元素的数量——实际上,这反映了模型记住当前市场上下文的能力。

接下来,创建cCandidate——这是一个负责计算新候选状态的组件。 其维度继承自已初始化的cInpAndHidden,这突显了输入信号与所提出的隐藏状态模型之间的密切关系。

   index++;
   if(!cCandidate.Init(0, index, OpenCL, cInpAndHidden.Neurons(), optimization, iBatch))
      return false;
   cCandidate.SetActivationFunction(None);

第二个主要模块——cHC——是另一个在更新后的状态层面上运行的图卷积模块。 它拥有自己的卷积参数cHC_emb,这些参数是基于获得的嵌入构建的,但系数不同。 最后一个元素是cHCe,它最终构成了更新后隐藏状态的表示。

   index++;
   if(!cHC.Init(0, index, OpenCL, units, window + window_out, cheb_k, optimization, iBatch))
      return false;
   cHC.SetActivationFunction(None);
   index++;
   if(!cHC_emb.Init(0, index, OpenCL, embed_dim, embed_dim,
                    (window + window_out) * window_out * cheb_k,
                    1, units, optimization, iBatch))
      return false;
   cHC_emb.SetActivationFunction(None);
   index++;
   if(!cHCe.Init(0, index, OpenCL, window_out * units, optimization, iBatch))
      return false;
   cHCe.SetActivationFunction(None);
//---
   if(!Output.Fill(0))
      return false;
//---
   return true;
  }

所有模块初始化完成后,将进行最后的准备工作:将结果缓冲区清零。 别忘了,我们正在处理一个循环模块。 清除结果缓冲区可确保模型从一个干净的状态开始,不受过去噪声的影响。

这一切只是乍看之下显得复杂。 实际上,这是一种精简的架构,其中每个模块都各司其职:从初步的数据封装,到在图门控循环单元(Graph GRU)结构中精细调节信息的遗忘与更新。 这对金融市场任务至关重要:模型必须既能考虑局部价格波动(窗口内),又能考虑其全局背景(通过图近似),同时在灵活应对新事件时,不失历史动能。

既然我们已经详细探讨了初始化过程,现在是时候深入了解基于图的循环模块的工作原理,并看看前向传播方法feedForward是如何让该架构运转起来的。 首先,我们仔细检查所有必要组件是否就绪:主源数据缓冲区、切比雪夫多项式张量以及嵌入。 如果其中哪怕缺少一个,该过程就不会启动。 这就像交易员在开仓前会检查所有指标和数据一样:如果不掌握全局,就无法做出预测。

bool CNeuronHimNetGCRU::feedForward(CNeuronBaseOCL *NeuronOCL,
                                    CChebPolinom *Support,
                                    CNeuronBaseOCL *Embedding)
  {
   if(!NeuronOCL || !Support || !Embedding)
      return false;
   if(!SwapOutputs())
      return false;

接下来,交换指向当前结果和上一次结果的数据缓冲区的指针,从而形成循环记忆。 这一步很重要,因为过去会影响未来——正如昨天的市场波动塑造了今天的预期。

接下来,请注意,在初始化过程中,我们并未将该模块的配置参数存储在单独的变量中。 这是有意为之。 毕竟,内部组件中已经保存了这些配置参数。 而且我们可以将它们提取出来。

   uint cheb_k = cZ_R.GetChebK();
   uint units = cZ_R.GetCount();
   uint window_out = Neurons() / units;
   uint window = cZ_R.GetWindow() - window_out;

只有在准备工作完成后,我们才会着手安排整个流程。 源数据和先前状态被拼接到cInpAndHidden对象中,形成一个单一的信息流。 这股数据流融合了新闻、指标与信号,已为后续处理做好准备。

   if(!Concat(NeuronOCL.getOutput(), PrevOutput, cInpAndHidden.getOutput(), window, window_out, units))
      return false;

接下来,cZ_R开始发挥作用,在其中利用切比雪夫多项式执行图卷积:相邻节点相互影响,但这种影响仅限于K跳邻域内,从而确保资源的高效利用和计算的稳定性。

   if(!cZ_R.FeedForward(cInpAndHidden.AsObject(), Support))
      return false;
   if(!cZ_R_emb.FeedForward(Embedding))
      return false;

与此同时,cZ_R_emb基于嵌入生成卷积参数矩阵,就像厨师为菜肴添加调味料以带出细微风味:时间和空间特征得以妥善组织,供后续处理使用。

卷积结果经乘法运算并通过 sigmoid 激活函数后,拆分为Z门和R门。 它们控制信息流,决定过去的信息中哪些应当保留、哪些应当更新。

   if(!MatMul(cZ_R.getOutput(), cZ_R_emb.getOutput(), cZe_Re.getOutput(), 1,
                 (window + window_out)*cheb_k, 2 * window_out, units, true))
      return false;
   if(!Activation(cZe_Re.getOutput(), cZe_Re.getOutput(), SIGMOID))
      return false;
   if(!DeConcat(cZ.getOutput(), cR.getOutput(), cZe_Re.getOutput(), window_out,
                                                            window_out, units))
      return false;

接下来,通过将当前输入与修改后的上一个状态相结合,形成一个候选状态cCandidate。 该状态被输入到第二个图卷积模块cHC中,其中通过 cHC_emb 以类似的方式生成新参数,再将结果送入双曲正切函数,形成更新后的隐藏状态。

   if(!ElementMult(cZ.getOutput(), PrevOutput, cZ.getPrevOutput()))
      return false;
   if(!Concat(NeuronOCL.getOutput(), cZ.getPrevOutput(), cCandidate.getOutput(),
                                                      window, window_out, units))
      return false;
   if(!cHC.FeedForward(cCandidate.AsObject(), Support))
      return false;
   if(!cHC_emb.FeedForward(Embedding))
      return false;
   if(!MatMul(cHC.getOutput(), cHC_emb.getOutput(), cHCe.getOutput(), 1, 
                  (window + window_out)*cheb_k, window_out, units, true))
      return false;
   if(!Activation(cHCe.getOutput(), cHCe.getOutput(), TANH))
      return false;
   if(!GateElementMult(PrevOutput, cHCe.getOutput(), cR.getOutput(), Output))
      return false;
//---
   return true;
  }

在最后阶段,通过R门将上一个状态与候选状态逐元素结合,输出的预测结果可供分析或由解码器进一步处理。 如果用金融市场的语言来描述,每一步都代表着多层信号过滤:将历史走势、相邻资产、时间特征以及内部嵌入相结合,从而形成准确且稳定的预测。 这里的feedForward方法就像一位指挥家,协调着由众多乐器组成的管弦乐团,将杂乱无章的市场数据转化为一曲和谐的预测交响乐。

既然我们已经详细介绍了前向传播,现在应该转向另一个同样重要的环节——误差梯度传播。 如果说前向传播可以比作交易员根据当前数据制定预测,那么反向传播就是交易员在交易日结束后坐下来,翻开交易日志,分析哪些信号奏效了、哪些预测失准了的时刻。 根据这一分析,模型的内部参数会得到调整,使其在次日能够做出更准确的预测。

calcInputGradients方法首先会全面检查所有组件:输入数据张量、切比雪夫多项式对象以及嵌入。

bool CNeuronHimNetGCRU::calcInputGradients(CNeuronBaseOCL *NeuronOCL,
      CChebPolinom *Support,
      CNeuronBaseOCL *Embedding)
  {
   if(!NeuronOCL || !Support || !Embedding)
      return false;
//---
   uint cheb_k = cZ_R.GetChebK();
   uint units = cZ_R.GetCount();
   uint window_out = Neurons() / units;
   uint window = cZ_R.GetWindow() - window_out;

只有在确认一切就绪后,我们才会继续计算关键参数:切比雪夫多项式的阶数、序列中的元素个数,以及输入和输出的特征维度。 这些值构成了误差梯度传播的框架,决定了误差信号将如何在架构中传播。

第一步是处理通过R门将隐藏状态与候选状态逐元素结合这一操作的梯度。 该操作考虑了所有参与组件的影响。 这好比评估每个指标对策略业绩的贡献:修正幅度取决于各信号对预测的影响程度,影响大的多调,影响小的少调。

   if(!GateElementMultGrad(PrevOutput, cR.getPrevOutput(),
                           cHCe.getOutput(), cHCe.getGradient(),
                           cR.getOutput(), cR.getGradient(),
                           Gradient, None, TANH, cR.Activation()))
      return false;

随后,误差梯度经由矩阵乘法运算传播,用于更新cHC和cHC_emb模块。 这类似于过滤市场信号:误差会经过所有层,并被细致地分配,使网络的每个组件都得到相应程度的修正。

   if(!MatMulGrad(cHC.getOutput(), cHC.getGradient(),
                  cHC_emb.getOutput(), cHC_emb.getGradient(),
                  cHCe.getGradient(), 1, (window + window_out)*cheb_k,
                  window_out, units, true))
      return false;

调用calcInputGradients方法来处理cHC,可确保将梯度正确传播至候选隐藏状态,这就像我们不仅评估单笔交易的结果,还评估这些交易在整体交易策略中的相互关系。

   if(!cHC.calcInputGradients(cCandidate.AsObject(), Support))
      return false;
   if(!DeConcat(NeuronOCL.getGradient(), cZ.getPrevOutput(), cCandidate.getGradient(),
                window, window_out, units))
      return false;

接下来是拆分操作——将误差梯度分配给输入数据与候选隐藏状态两个部分。

将误差梯度经由逐元素乘法运算传播,再将其拼接,即可得到Z门和R门的正确梯度。 通过激活函数的导数对所得值进行调整,以确保误差缩放正确,从而防止模型过载。

   if(!ElementMultGrad(cZ.getOutput(), cZ.getGradient(),
                       PrevOutput, cCandidate.getPrevOutput(),
                       cZ.getPrevOutput(), None, None))
      return false;
   if(!Concat(cZ.getGradient(), cR.getGradient(), cZe_Re.getGradient(),
              window_out, window_out, units))
      return false;
   if(!DeActivation(cZe_Re.getOutput(), cZe_Re.getGradient(), cZe_Re.getGradient(), SIGMOID))
      return false;

其中,切比雪夫多项式受到了特别关注。 首先,将从cHC对象中获取的先前梯度保存下来。 接下来,对calcInputGradients方法进行调用,以计算cZ_R的输入梯度,随后将累积的梯度仔细求和。 这使得模型能够考虑图中相邻节点的直接和间接影响,从而确保图卷积权重的更新既稳定又准确。

   if(!MatMulGrad(cZ_R.getOutput(), cZ_R.getGradient(),
                  cZ_R_emb.getOutput(), cZ_R_emb.getGradient(),
                  cZe_Re.getGradient(), 1, (window + window_out)*cheb_k,
                  2 * window_out, units, true))
      return false;
   CBufferFloat* temp = Support.getGradient();
   if(!Support.SetGradient(Support.getPrevOutput(), false) ||
      !cZ_R.calcInputGradients(cInpAndHidden.AsObject(), Support) ||
      !SumAndNormilize(temp, Support.getGradient(), temp, Support.GetDimension(), false, 0, 0, 0, 1) ||
      !Support.SetGradient(temp, false))
      return false;

主信息流处理的最后一步是将两条信息路径中的信息合并,并将梯度传递至原始数据层。 随后通过激活函数的导数进行调整。

   if(!DeConcat(cInpAndHidden.getPrevOutput(), cCandidate.getPrevOutput(),
                cInpAndHidden.getGradient(), window, window_out, units))
      return false;
   if(!SumAndNormilize(NeuronOCL.getGradient(), cInpAndHidden.getPrevOutput(),
                       NeuronOCL.getGradient(), window, false, 0, 0, 0, 1))
      return false;
   if(NeuronOCL.Activation() != None)
      if(!DeActivation(NeuronOCL.getOutput(), NeuronOCL.getGradient(), 
                       NeuronOCL.getGradient(), NeuronOCL.Activation()))
         return false;

接下来,嵌入也会经过类似的处理:通过cHC_emb和cZ_R_emb调整其梯度。 随后将这些梯度求和,以确保所有参数的更新保持一致。

   if(!Embedding.CalcHiddenGradients(cHC_emb.AsObject()))
      return false;
   temp = Embedding.getGradient();
   if(!Embedding.SetGradient(Embedding.getPrevOutput(), false) ||
      !Embedding.CalcHiddenGradients(cZ_R_emb.AsObject()) ||
      !SumAndNormilize(temp, Embedding.getGradient(), temp, cZ_R_emb.GetWindow(), false, 0, 0, 0, 1) ||
      !Embedding.SetGradient(temp, false))
      return false;
//---
   return true;
  }

因此,calcInputGradients构成了一套精密的系统,用于在整个GCRU架构中重新分配误差。 实际上,这就像一位交易员,他不仅能发现策略中的缺陷,还会详细分析每个组成部分——包括时间和空间模式、资产之间的关系以及对市场事件的反应——并利用这些信息来提高未来预测的准确性。 这种方法使模型训练过程生动、动态,并尽可能贴近现实市场的运作逻辑。

接下来,我们来谈谈该机制中看似最不起眼的部分——更新权重。 然而,内部逻辑经过精心设计的架构往往如此:看似简单,背后却隐藏着一套设计精良的参数管理层次结构。 整个庞杂的系统——包括门、切比雪夫多项式、矩阵乘法和激活操作——最终都归结为正确配置两个关键对象:cZ_R_emb和cHC_emb。 这就好比一个由数十个齿轮组成的复杂钟表机构,整个机芯的走时精度实际上仅由两个调节轴决定。

updateInputWeights方法首先进行一项简单但至关重要的检查:嵌入对象是否存在。 如果没有它,更新就毫无意义,因为模型正是通过它来吸收图中的空间关系和语义关系。 如果该对象不存在,则该方法立即终止并返回false。

bool CNeuronHimNetGCRU::updateInputWeights(CNeuronBaseOCL *NeuronOCL,
                                           CChebPolinom *Support,
                                           CNeuronBaseOCL *Embedding)
  {
   if(!Embedding)
      return false;
//---
   if(!cZ_R_emb.UpdateInputWeights(Embedding))
      return false;
   if(!cHC_emb.UpdateInputWeights(Embedding))
      return false;
//---
   return true;
  }

随后,控制权移交给两个主要的可训练参数存储区:首先更新负责Z-R模块的权重(cZ_R_emb),接着更新负责H-C候选模块的权重(cHC_emb)。 这两次UpdateInputWeights调用依次执行,就像两颗精密的调节螺丝,各自作用于计算节点中相应的部分。

值得强调的是,这种简洁性源于合理的架构设计。 所有其他层、中间缓冲区和门在反向传播过程中已经收到了相应的梯度。 这里,我们实际是将这些更改落实到那些真正决定模型长期行为的参数上。 换句话说,如果将前一个方法(calcInputGradients)比作分析过去错误的原因,那么updateInputWeights就是对交易系统进行调整的操作:我们不仅得出结论,还将这些结论融入系统设置中,从而使明天的预测更加准确和稳定。

这种方法不仅使架构高效,而且具有可预测性:只需在两个点上进行修改,就能控制庞大的计算链,同时保持其完整性和一致性。

今天我们已经做了大量工作,现在正好可以稍作休息。 在下一篇文章中,我们将继续沿着这条路走下去。 让我们将已经开始的工作进行到底,完成整个实现,然后用真实的历史数据进行测试,看看理论在实践中如何体现。



结论

在本文中,我们重点探讨了整个架构中的一个关键组件,并逐步分析了其工作原理——从内部连接的形成,到误差梯度传播机制,再到参数更新过程。 我们看到,这些乍看之下似乎各自独立的模块开始以统一的节奏相互协作,形成了一个有机整体,已可在真实市场条件下进行训练和运行。 特别需要强调的是,这样一个结构完善的系统仅依赖于两个具有可训练参数的对象,这使其不仅结构紧凑,而且控制起来也具有可预测性。

在这一阶段,我们已经构建出未来计算链中一个近乎完备的组件,它已准备好承载真实交易数据带来的计算负载。 在下一篇文章中,我们将迈出关键一步:将所有组件整合到一个统一的架构中,对历史时间序列进行全面测试,并检验我们创建的算法不仅能在多大程度上重现过去的模式,还能在多大程度上从容应对瞬息万变的市场走势。


参考文献


本文中使用的软件

# 名称 类型 描述
1 Study.mq5 智能交易系统 用于离线模型训练的智能交易系统
2 StudyOnline.mq5 智能交易系统 用于在线模型训练的智能交易系统
3 Test.mq5 智能交易系统 用于模型测试的智能交易系统
4 Trajectory.mqh 类库 用于描述系统状态和模型架构的结构体
5 NeuroNet.mqh 类库 用于构建神经网络的类库
6 NeuroNet.cl 库 OpenCL程序代码库


本文由MetaQuotes Ltd译自俄文
原文地址: https://www.mql5.com/ru/articles/19250

附加的文件 |
MQL5.zip (3013.86 KB)
交易中的神经网络:异质性感知元参数学习(结论) 交易中的神经网络:异质性感知元参数学习(结论)
本文介绍了使用MQL5实现HimNet框架的具体方案,该方案可直接集成到自动化交易中。 我们展示了异质性自适应元参数如何将该模型转变为一种通用工具,使其能够应对波动率的变化。
基于 GPT 语言模型的交易机器人 基于 GPT 语言模型的交易机器人
本文介绍了 TimeGPT 的完整实现。这是一种基于 Transformer 的专用架构,用于在 MetaTrader 5 平台上预测金融时间序列。文中讨论了注意力机制对金融数据的适配、价格变化的选择性令牌化(tokenization)、面向硬件特性的优化以及先进的学习技术。文中还包括实际测试结果:在 24 根 K 线的预测跨度上达到 87% 的预测准确率,且在 CPU 上训练仅需 15 分钟。我们还提供了一个可直接使用、带自动重训练功能的交易 EA。
掌握 MQL5 — 从入门到精通(第七部分):MQL 应用程序调试基础 掌握 MQL5 — 从入门到精通(第七部分):MQL 应用程序调试基础
调试是编程周期中不可或缺的一部分。本文讨论了在 MetaTrader 5 环境中运行的应用程序常见的调试技术。
市场模拟:仓位视图(五) 市场模拟:仓位视图(五)
尽管前一篇文章已经有所展示,这一切乍一看似乎很简单。实际上,仍存在几个问题,以及许多尚待完成的任务。亲爱的读者,你可能会认为一切都很简单明了。由于缺乏经验,你可能会简单地接受任何呈现给你的东西。而这是一个你应该尽力避免的错误。更糟糕的是,试图在不真正理解所使用内容的情况下使用它。初学者通常会经历一个复制粘贴的阶段。如果你不想永远停留在这一阶段,你应该学会如何使用某些工具。程序员最常用的工具之一是文档。其次是测试,辅以日志文件。接下来,我们将探讨如何做到这一点。