交易中的神经网络：具有层化记忆的智代（终篇）
604
0
概述
在上一篇文章中，我们实证了基于大语言模型（LLM）的创新智代 FinMem 框架的理论基础。该框架采用独特的层化记忆系统，能够高效处理性质和时态重要性各异的数据。
FinMem 记忆模块分为两个主要组成：
- 工作记忆 — 设计用来处理短期数据，如每日新闻和市场波动。
- 长期记忆 — 存储具有持久价值的信息，包括分析报告和研究素材。
层化记忆结构允许智代排定信息优先级，专注与当前市场条件最相关的数据。举例，短期事件会被立刻分析，而影响深刻的信息则被保存，以备未来使用。
FinMem 的剖析模块会根据特定的专业背景和市场环境调整智代的行为。参考用户的个人偏好和风险备案，智代能够优化策略，确保交易操作的最高效率。
决策制定模块将实时数据与存储记忆整合，生成兼顾短期趋势和长期模式的策略。这种认知启发的方式令智代能够维护关键市场事件，并适配新信号，显著提升投资决策的准确性和有效性。
框架作者获得的实验结果表明，FinMem 优于其它自主交易模型。即使输入数据有限，智代在信息处理和策略形成方面仍展现出卓越的效率。其管理认知负载的能力，令其能够并发分析数十个市场信号，且识别出其中最关键的。智代据其重要性结构化这些信号，即使在紧迫的时间限制下也能制定依据充分的决策。
进而，FinMem 具备独特的实时学习能力，令其高度适配不断变化的市场条件。这令智代不仅能有效处理当前任务，还能在遇到新数据时不断优调其方法。FinMem 结合了认知原理与先进技术，为在复杂且快速变化的金融市场中提供当下最新解决方案。
作者提供的 FinMem 框架信息流可视化如下。
在上一篇文章中，我们开始遵照框架作者提议的方法实现 MQL5 版本，并讲述了我们对层化记忆模块 CNeuronMemory 的解释，其与原始版本有显著不同。在我们的 FinMem 实现中，我们有意排除了大语言模型 — 这是最初概念的关键组成部分。这不可避免地影响到整个架构的各个环节。
尽管如此，我们仍尽力再现框架的核心信息流。特别是，CNeuronFinMem 对象的设计旨在保留层化数据处理方式。该对象成功整合了处理短期信息和长期策略的方法，确保在动态市场环境中稳定和可预测的绩效。
构建 FinMem 框架
回想一下，我们之前停在 CNeuronFinMem 对象中构建所提议框架的集成算法，其结构如下所示。
class CNeuronFinMem : public CNeuronRelativeCrossAttention { protected: CNeuronTransposeOCL cTransposeState; CNeuronMemory cMemory[2]; CNeuronRelativeCrossAttention cCrossMemory; CNeuronRelativeCrossAttention cMemoryToAccount; CNeuronRelativeCrossAttention cActionToAccount; //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL) override { return false; } virtual bool feedForward(CNeuronBaseOCL *NeuronOCL, CBufferFloat *SecondInput) override; virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL) override { return false; } virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL, CBufferFloat *SecondInput, CBufferFloat *SecondGradient, ENUM_ACTIVATION SecondActivation = None) override; virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL) override { return false; } virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL, CBufferFloat *SecondInput) override; public: CNeuronFinMem(void) {}; ~CNeuronFinMem(void) {}; //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint window, uint window_key, uint units_count, uint heads, uint accoiunt_descr, uint nactions, ENUM_OPTIMIZATION optimization_type, uint batch); //--- virtual int Type(void) override const { return defNeuronFinMem; } //--- virtual bool Save(int const file_handle) override; virtual bool Load(int const file_handle) override; //--- virtual bool WeightsUpdate(CNeuronBaseOCL *source, float tau) override; virtual void SetOpenCL(COpenCLMy *obj) override; //--- virtual bool Clear(void) override; };
早前，我们讨论了对象的初始化。接下来，我们将构造 feed-forward 方法，其需要两个主要参数。
第一个参数是一个张量 — 表示环境状态的多维数据数组。它包含各种市场数据，譬如当前报价、和所分析技术指标的数值。该方式令模型能够参考广谱变量，能基于综合性分析制定决策。
第二个参数是一个包含交易账户状态信息的向量。它包含当前余额、盈亏数据，以及时间戳。该组件确保实时数据可用性，并支持准确计算。
bool CNeuronFinMem::feedForward(CNeuronBaseOCL *NeuronOCL, CBufferFloat *SecondInput) { if(!cTransposeState.FeedForward(NeuronOCL)) return false;
为了对环境状态进行综合性分析，我们从处理由多维张量表示的初始数据开始。置换过程会变换数组，令其更容易搭配不同投影工作，以便更细致地提取关键特征。
接着，输入数据的两个投影被传入专用记忆模块进行深入分析。第一个模块专注研究以柱线组织的市场参数的时间动态，令模型能够捕捉并解释所分析金融产品的复杂行为。第二个模块侧重于分析多模态时间序列的单变量序列，能够检测指标间的隐藏依赖关系，并捕捉其相关性。这会创建一个当前市场状态的综合表征。
这种分析结构确保了高度的准确性，并为模型提供了灵活适配市场动态的能力 — 这是实现可靠及时财务决策的关键因素。
if(!cMemory[0].FeedForward(NeuronOCL) || !cMemory[1].FeedForward(cTransposeState.AsObject())) return false;
两个记忆模块的结果经由交叉注意力模块合并，其依据分析单变量序列来丰富多模时间序列的洞察。这不仅强化了信息的准确性和综合性，也令其更适合做出明智的决策。
if(!cCrossMemory.FeedForward(cMemory[0].AsObject(), cMemory[1].getOutput())) return false;
接下来，我们验证市场变化对账户余额的影响。为达成这一点，通过交叉注意力模块将多层市场分析结果与账户状态向量进行比较。该方法论的方式能够更准确地评估市场事件如何影响财务量值。该分析有助于识别市场活动与财务成果之间的复杂依赖关系。这对预测和风险管理尤为重要。
if(!cMemoryToAccount.FeedForward(cCrossMemory.AsObject(), SecondInput)) return false;
下一步是操作决策制定模块。于此，模型比较智代最近的行为与相应的盈亏，判定它们之间的相互依赖关系。在该阶段，我们评估当前政策的效率，以及是否需要调整。该方式防止重复的形态，提升了交易策略的灵活性 — 在高波动条件下尤具价值。
此外，模型还可以评估下一次交易作的可接受风险水平。
重点要注意，智代近期行为的张量作为第三个数据源。不过，我们要记住该方法仅支持处理两条输入数据流。故此，我们利用这样一个事实，即生成的智代动作张量，作为该对象的输出，并一直存储在其结果缓冲区中，直至下一次前馈操作。这允许我们按指向当前对象的指针来调用内部交叉注意力模块的前馈通验，类似于重复模块。
if(!cActionToAccount.FeedForward(this.AsObject(), SecondInput)) return false;
此刻，我们必须确保智代最新动作的张量被保留，直至被新数据替换 — 这保证了反向传播操作的正确执行。为达成这一点，我们替换相应数据缓冲区指针，把信息丢失的风险降至最低。
if(!SwapBuffers(Output, PrevOutput)) return false;
之后，我们调用父类方法，负责生成新的智代动作张量。该过程基于当前方法中早期获得的分析结果。如是结果，不同模块之间的连续交互链得以维护，确保高度的数据一致性和相关性。
if(!CNeuronRelativeCrossAttention::feedForward(cActionToAccount.AsObject(), cMemoryToAccount.getOutput())) return false; //--- return true; }
该方法完结时将操作的逻辑结果返回至调用程序。
所构造前馈算法展现出非线性特征，显著影响反向传播阶段的数据处理。这在 calcInputGradients 方法里实现的梯度分布算法中尤为明显。为了正确执行该过程，信息必须严格按逆序处理，镜像前馈通验的逻辑。这需要考虑模型的全部独特架构特征，开确保计算准确性和一致性。
在 calcInputGradients 方法的参数中，我们接收指向两个输入数据流对象的指针，参考每条数据流对模型最终输出的贡献，传送误差梯度。
bool CNeuronFinMem::calcInputGradients(CNeuronBaseOCL *NeuronOCL, CBufferFloat *SecondInput, CBufferFloat *SecondGradient, ENUM_ACTIVATION SecondActivation = -1) { if(!NeuronOCL || !SecondInput || !SecondGradient) return false;
在方法主体中，我们立即检查收到的指针是否相关。没有这一点，后续的操作毫无意义，因为不可能传播梯度。
回想前馈阶段会调用父类方法结束，其负责最终阶段的处理。相应地，梯度反向传播亦从父类对应方法开始。其任务是将梯度传播到两条并行数据处理路径的内部交叉注意力模块。
if(!CNeuronRelativeCrossAttention::calcInputGradients(cActionToAccount.AsObject(), cMemoryToAccount.getOutput(), cMemoryToAccount.getGradient(), (ENUM_ACTIVATION)cMemoryToAccount.Activation())) return false;
重点要注意，沿其中一条数据路径，我们递归使用前一次前馈通验的结果作为输入数据。这会在反向传播过程中创建一个连续的环路，现在必须打破它。
为了正确分派误差梯度，我们首先必须恢复缓冲区，包含之前前馈通验的结果，作为交叉注意力模块的输入，分析其与财务成果的关系。这是由替换相关缓冲区指针达成的，令数据能够无损恢复、且开销最小。
if(!SwapBuffers(Output, PrevOutput)) return false;
此外，我们还必须替换指向对象梯度缓冲区的指针，保留自下一层获得的数据。为此，我们用到足够大的缓冲区。自然地，环境-状态张量远大于智代的动作矢量。故此，我们能用该数据流中的缓冲区之一。
CBufferFloat *temp = Gradient; if(!SetGradient(cMemoryToAccount.getPrevOutput(), false)) return false;
一旦所有关键数据得以保护，我们调用交叉注意力模块的梯度分派方法，分析先前智代动作对所得财务结果的影响。
if(!calcHiddenGradients(cActionToAccount.AsObject(), SecondInput, SecondGradient, SecondActivation)) return false;
之后，我们会将所有缓冲区指针恢复到原始状态。
if(!SwapBuffers(Output, PrevOutput)) return false; Gradient = temp;
此刻，误差梯度已沿智代动作评估路径分派。我们已将相应的梯度传递至记忆流，以及账户状态向量缓冲区。然而，请注意，账户状态缓冲区参与两条数据流：记忆和智代的动作路径。我们曾沿后者传播梯度。现在，我们必须判定账户状态数据经由记忆路径后对模型最终输出的影响，然后汇总两条流的梯度。
if(!cCrossMemory.calcHiddenGradients(cMemoryToAccount.AsObject(), SecondInput, cMemoryToAccount.getPrevOutput(), SecondActivation)) return false; if(!SumAndNormilize(SecondGradient, cMemoryToAccount.getPrevOutput(), SecondGradient, 1, false, 0, 0, 0, 1)) return false;
接下来，我们根据误差梯度对模型输出的影响，沿记忆路径向下分派到原始输入数据级。于此，我们再次处置输入数据的两个投影。我们首先经由两条分析流分派梯度。
if(!cMemory[0].calcHiddenGradients(cCrossMemory.AsObject(), cMemory[1].getOutput(), cMemory[1].getGradient(), (ENUM_ACTIVATION)cMemory[1].Activation())) return false;
然后将其传播到数据置换对象。
if(!cTransposeState.calcHiddenGradients(cMemory[1].AsObject())) return false;
在该阶段，我们必须将误差梯度从两条并行记忆流，传输到原始输入数据对象。首先，我们沿一条流传播误差。
if(!NeuronOCL.calcHiddenGradients(cMemory[0].AsObject())) return false;
然后更换数据缓冲区，沿第二条波传播梯度。
temp = NeuronOCL.getGradient(); if(!NeuronOCL.SetGradient(cTransposeState.getPrevOutput(), false) || !NeuronOCL.calcHiddenGradients(cTransposeState.AsObject()) || !NeuronOCL.SetGradient(temp, false) || !SumAndNormilize(temp, cTransposeState.getPrevOutput(), temp, iWindow, false, 0, 0, 0, 1)) return false; //--- return true; }
最后，我们汇总两条信息流的梯度，并将所有缓冲指针恢复到原始状态。该方法随后返回一个逻辑结果至调用程序，标志其执行结束。
我们对构造 CNeuronFinMem 对象方法所用算法的探讨至此完毕。您能在附件中找到该类、及其所有方法的完整代码。
模型架构
我们已完成 FinMem 框架方法 CNeuronFinMem 对象的 MQL5 版本实现。该实现提供了基本功能，并为进一步集成学习算法奠定了基础。下一步是将所创建对象集成到可训练的智代模型之中，其是财务系统中的核心决策制定法组件。可训练模型的架构在 CreateDescriptions 方法中定义。
应当注意的是，FinMem 框架的步伐超出纯粹的架构设计。它还包含独有的学习算法，令模型能够适配并高效处理复杂的财务环境下的数据。不过，我们稍后会回到学习过程。目前，重点是要强调我们仅训练一个模型：智代。
在 CreateDescriptions 方法参数中，我们会收到一个指向动态数组的指针，存储正在创建的模型结构。
bool CreateDescriptions(CArrayObj *&actor) { //--- CLayerDescription *descr; //--- if(!actor) { actor = new CArrayObj(); if(!actor) 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 = 1e4; descr.activation = None; descr.optimization = ADAM; if(!actor.Add(descr)) { delete descr; return false; }
随后是我们之前开发的 FinMem 模块，它作为基础，实现了数据处理和决策形成的关键层面。
//--- layer 2 if(!(descr = new CLayerDescription())) return false; descr.type = defNeuronFinMem; //--- Windows { int temp[] = {BarDescr, AccountDescr, 2*NActions}; //Window, Account description, N Actions if(ArrayCopy(descr.windows, temp) < int(temp.Size())) return false; } descr.count = HistoryBars; descr.window_out = 32; descr.step = 4; // Heads descr.batch = 1e4; descr.activation = None; descr.optimization = ADAM; if(!actor.Add(descr)) { delete descr; return false; }
在 windows 数组中，我们为输入数据定义了三个主要张量维度：单根柱线描述、账户状态、和智代动作。后者也表示模块输出向量的维度。
值得注意的是，在这种情况下，智代的动作张量维度被设置为对应常数的两倍。该方式令我们能够为智代实现随机头d机制。按照惯例，前半部分表示分布的平均值，后半部分对应其方差。相应地，重点要记住，在初始化与智代动作张量共事的交叉注意力对象时，我们会将主输入流分为两个相等的向量。这令模块能够在输出处产生一致的均值和方差配对。
在这些所定义分布内部生成的数值，由变分自编码器的潜态层处理。
//--- layer 3 if(!(descr = new CLayerDescription())) return false; descr.type = defNeuronVAEOCL; descr.count = NActions; descr.optimization = ADAM; if(!actor.Add(descr)) { delete descr; return false; }
最后，架构以卷积层结束，其将获得的数值投射到智代所需的动作范围之内。
//--- layer 4 if(!(descr = new CLayerDescription())) return false; descr.type = defNeuronConvSAMOCL; descr.count = NActions / 3; descr.window = 3; descr.step = 3; descr.window_out = 3; descr.activation = SIGMOID; descr.optimization = ADAM; descr.probability = Rho; if(!actor.Add(descr)) { delete descr; return false; } //--- return true; }
剩下的就是将操作的结果返回给调用程序，并退出该方法。
训练程序
我们在实现 FinMem 框架作者所提议方式中取得了显著进展。在该阶段，我们已拥有一套能够有效处理财务数据，并适配复杂市场条件的模型架构。该模型的一个显著特点是其层化记忆，模拟如人类般的认知过程。
如早前所述，该框架作者不仅提议了架构原则，还有基于层化数据处理方式的训练算法。这令模型不仅能捕捉线性关系，还有参数间复杂的非线性依赖关系。在训练期间，模型访问来自多源的广谱数据，从而形成综合性财务环境表征。这反过来强化了适配变化市场条件的能力，提升了预测的准确性。
当收到包含所分析数据的训练请求时，模型会激活两个关键过程：观察和普适。该系统观察市场标签，包括分析金融产品的每日价格变化。这些标签作为“买入”或“卖出”动作的指示。这些信息能令模型识别并优先选择最相关的记忆，并基于从长期记忆每一层提取的分数进行排名。
与此同时，FinMem 的长期记忆部分保留了关键数据以备未来之用 — 关键事件和记忆。它们在更深的记忆级处理，以确保存储的耐久性。重复的交易操作和市场反应强化了存储信息的相关性，促进了决策品质的持续提升。
我们早前决定将大语言模型（LLM）排除在实现之外，也影响了训练过程。无论如何，我们努力保持框架作者提议的原始学习原则。特别在训练期间，我们将允许模型“展望未来”，类似于价格变动预测模型中所用的方式。然而，此处有一个重要的细节。在这种情况下，我们不能简单地为模型提供未来价格走势数据。我们模型的输出由交易操作的参数组成。故此，在训练期间，我们必须提供类似的数据（训练标签）作为反馈。因此，在训练期间，基于即将到来的价格走势的关于可用信息，我们将尝试生成一个几乎理想的交易决策作为参考。
现在我们来看看该提议方式如何在代码中实现。本文将只聚焦于训练方法 Train。完整的训练程序可在附件中找到：“...\Experts\FinMem\Study.mq5”。
模型训练方法的起点相当传统：我们从经验回放缓冲区生成轨迹选择概率向量，基于存储运行的盈利性，并声明必要的局部变量。
void Train(void) { //--- vector<float> probability = GetProbTrajectories(Buffer, 0.9); //--- vector<float> result, target, state; matrix<float> fstate = matrix<float>::Zeros(1, NForecast * BarDescr); bool Stop = false;
接下来，我们组织训练环路。然而，这种情况下我们是与重复模型打交道，即对输入数据的顺序敏感。因此，我们必须使用嵌套环路。在外环路中，我们从经验回放缓冲区抽取一条轨迹、及其初始状态。在内环路中，我们沿选定轨迹顺序遍历各状态。训练迭代次数和批次规模在训练程序的外部参数中定义。
for(int iter = 0; (iter < Iterations && !IsStopped() && !Stop); iter += Batch) { int tr = SampleTrajectory(probability); int start = (int)((MathRand() * MathRand() / MathPow(32767, 2)) * (Buffer[tr].Total - 2 - NForecast - Batch)); if(start <= 0) { iter -= Batch; continue; } if(!Actor.Clear()) { PrintFormat("%s -> %d", __FUNCTION__, __LINE__); Stop = true; break; } for(int i = start; i < MathMin(Buffer[tr].Total, start + Batch); i++) { if(!state.Assign(Buffer[tr].States[i].state) || MathAbs(state).Sum() == 0 || !bState.AssignArray(state)) { iter -= Batch + start - i; break; }
需要注意的是，在开始依据新轨迹进行训练之前，我们必须清除模型的记忆。因为存储的数据必须与当前被分析的环境对应。
在内环路中，我们首先从回放缓冲区提取所分析环境状态的描述，并形成账户状态向量。
重点要强调，于此我们形成的是账户状态向量，而非之前那样直接从经验缓冲区转送。之前，我们简单地重新格式化，并传递存储的信息。然而，现在我们必须考虑这样一个事实，即模型学习如何分析智代先前动作对所获财务结果的影响。相应地，账户状态向量必须根据这些动作，而这无法简单地从缓冲区传输数据来达成。
第一步是生成与所分析环境状态对应的时间戳谐波。
bTime.Clear(); double time = (double)Buffer[tr].States[i].account[7]; double x = time / (double)(D'2024.01.01' - D'2023.01.01'); bTime.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0)); x = time / (double)PeriodSeconds(PERIOD_MN1); bTime.Add((float)MathCos(x != 0 ? 2.0 * M_PI * x : 0)); x = time / (double)PeriodSeconds(PERIOD_W1); bTime.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0)); x = time / (double)PeriodSeconds(PERIOD_D1); bTime.Add((float)MathSin(x != 0 ? 2.0 * M_PI * x : 0)); if(bTime.GetIndex() >= 0) bTime.BufferWrite();
我们还提取了存储在模型缓冲区中的智代最新动作向量。
//--- Previous Action
Actor.getResults(result);
我们依据所分析环境状态最后一根柱线期间的价格变化，计算该动作的回报。我必须承认，为了简化算法，我们采用了一个基本的回报计算。我们不考虑止损或止盈触发等事件，亦无交易可能产生的佣金。进而，假设所有先前的持仓在智代最后一次操作前均已平仓。该方式可用来粗略评估模型的性能，但在进行实盘交易之前，务必仔细考虑所有市场细节和相关参数。
计算最后一次操作的回报，我们简单地将价格变化乘以智代近期动作向量的买卖交易量差值：
float profit = float(bState[0] / (_Point * 10) * (result[0] - result[3]));
回想一下，我们将价格变化视为收盘价和开盘价之间的差值。因此，看涨的蜡烛会得到一个正值，否则的话是负值。交易量的差异同样会在买入操作时给出正数值，以及卖出操作时的负数值。由此，这两个数值的乘积产生了正确的带符号的交易结果。
接下来，我们从经验回放缓冲区提取前一状态的余额和净值数据 — 即智代在前一步执行基础上的预期执行状态。
//--- Account float PrevBalance = Buffer[tr].States[MathMax(i - 1, 0)].account[0]; float PrevEquity = Buffer[tr].States[MathMax(i - 1, 0)].account[1];
如早前提示，我们假设所有先前持仓在执行新交易前已平仓。这意味着余额会根据净值水平进行调整。
bAccount.Clear(); bAccount.Add((PrevEquity - PrevBalance) / PrevBalance);
上一次交易柱线的净值变动等于上面已计算的最后一次交易操作的财务结果。
bAccount.Add((PrevEquity + profit) / PrevEquity); bAccount.Add(profit / PrevEquity);
我们仅针对交易量差值执行交易，这反映在未开仓量值之中。
bAccount.Add(MathMax(result[0] - result[3], 0)); bAccount.Add(MathMax(result[3] - result[0], 0));
相应地，我们仅报告持仓的财务结果。
bAccount.Add((bAccount[3]>0 ? profit / PrevBalance : 0)); bAccount.Add((bAccount[4]>0 ? profit / PrevBalance : 0)); bAccount.Add(0); bAccount.AddArray(GetPointer(bTime)); if(bAccount.GetIndex() >= 0) bAccount.BufferWrite();
准备好输入数据之后，我们贯穿模型执行前馈通验，在此期间将会生成新的智代动作向量。
//--- Feed Forward if(!Actor.feedForward((CBufferFloat*)GetPointer(bState), 1, false, GetPointer(bAccount))) { PrintFormat("%s -> %d", __FUNCTION__, __LINE__); Stop = true; break; }
现在，为了执行反向传播，我们需要基于即将到来的价格走势信息，准备“理想”交易操作的目标值。为此，我们从经验回放缓冲区提取指定计划时间段的数据。
//--- Look for target target = vector<float>::Zeros(NActions); bActions.AssignArray(target); if(!state.Assign(Buffer[tr].States[i + NForecast].state) || !state.Resize(NForecast * BarDescr) || MathAbs(state).Sum() == 0) { iter -= Batch + start - i; break;
把它们重新格式化至矩阵。
if(!fstate.Resize(1, NForecast * BarDescr) || !fstate.Row(state, 0) || !fstate.Reshape(NForecast, BarDescr)) { iter -= Batch + start - i; break; }
然后我们重新排序矩阵的行，令数据按时间顺序排列。
for(int i = 0; i < NForecast / 2; i++) { if(!fstate.SwapRows(i, NForecast - i - 1)) { PrintFormat("%s -> %d", __FUNCTION__, __LINE__); Stop = true; break; } }
我们预测矩阵的第一列包含每根柱线的价格变动。我们将这些数值的累计总和，来计算预测区间每个步骤的总体价格变化。
target = fstate.Col(0).CumSum();
注意，该方式并未考虑潜在的间隙。鉴于我们实验中此类事件的概率相对较低，我们愿意暂时忽略它们。然而，在准备真实交易决策时，这种简化是不可接受的。
目标智代动作向量的进一步形成取决于先前的操作。如果前一步开仓了，我们就寻找离场点。以多头交易的离场算法为例。首先，判定设置的止损水平，并声明必要的局部变量。
if(result[0] > result[3]) { float tp = 0; float sl = 0; float cur_sl = float(-(result[2] > 0 ? result[2] : 1) * MaxSL * Point()); int pos = 0;
然后我们迭代遍历预测的价格值，寻找当前止损被触及的点。在迭代期间，我们记录最大和最小值，以便设定新的止损和止盈价位。
for(int i = 0; i < NForecast; i++) { tp = MathMax(tp, target[i] + fstate[i, 1] - fstate[i, 0]); pos = i; if(cur_sl >= target[i] + fstate[i, 2] - fstate[i, 0]) break; sl = MathMin(sl, target[i] + fstate[i, 2] - fstate[i, 0]); }
在下跌的情况下，止盈值自然保留为 “0”，这将产生零动作向量。这将导致所持仓平仓，并等待下一根柱线开启。
如果预期会上涨，会生成新的智代动作向量，指定调整后的交易水平值。
if(tp > 0) { sl = float(MathMin(MathAbs(sl) / (MaxSL * Point()), 1)); tp = float(MathMin(tp / (MaxTP * Point()), 1)); result[0] = MathMax(result[0] - result[3], 0.01f); result[1] = tp; result[2] = sl; for(int i = 3; i < NActions; i++) result[i] = 0; bActions.AssignArray(result); } }
空头持仓离场的向量也如同这般形成。
else { if(result[0] < result[3]) { float tp = 0; float sl = 0; float cur_sl = float((result[5] > 0 ? result[5] : 1) * MaxSL * Point()); int pos = 0; for(int i = 0; i < NForecast; i++) { tp = MathMin(tp, target[i] + fstate[i, 2] - fstate[i, 0]); pos = i; if(cur_sl <= target[i] + fstate[i, 1] - fstate[i, 0]) break; sl = MathMax(sl, target[i] + fstate[i, 1] - fstate[i, 0]); } if(tp < 0) { sl = float(MathMin(MathAbs(sl) / (MaxSL * Point()), 1)); tp = float(MathMin(-tp / (MaxTP * Point()), 1)); result[3] = MathMax(result[3] - result[0], 0.01f); result[4] = tp; result[5] = sl; for(int i = 0; i < 3; i++) result[i] = 0; bActions.AssignArray(result); } }
当没有持仓时，所采用方式略有不同。在这种情况下，我们首先判定最接近的盛行趋势。
ulong argmin = target.ArgMin(); ulong argmax = target.ArgMax(); while(argmax > 0 && argmin > 0) { if(argmax < argmin && target[argmax] > MathAbs(target[argmin])) break; if(argmax > argmin && target[argmax] < MathAbs(target[argmin])) break; target.Resize(MathMin(argmax, argmin)); argmin = target.ArgMin(); argmax = target.ArgMax(); }
然后按该趋势形成一个动作向量。交易量设定则按当前余额中每 100 美元的最低手数。
if(argmin == 0 || argmax < argmin) { float tp = 0; float sl = 0; float cur_sl = - float(MaxSL * Point()); ulong pos = 0; for(ulong i = 0; i < argmax; i++) { tp = MathMax(tp, target[i] + fstate[i, 1] - fstate[i, 0]); pos = i; if(cur_sl >= target[i] + fstate[i, 2] - fstate[i, 0]) break; sl = MathMin(sl, target[i] + fstate[i, 2] - fstate[i, 0]); } if(tp > 0) { sl = (float)MathMin(MathAbs(sl) / (MaxSL * Point()), 1); tp = (float)MathMin(tp / (MaxTP * Point()), 1); result[0] = float(Buffer[tr].States[i].account[0] / 100 * 0.01); result[1] = tp; result[2] = sl; for(int i = 3; i < NActions; i++) result[i] = 0; bActions.AssignArray(result); } } else { if(argmax == 0 || argmax > argmin) { float tp = 0; float sl = 0; float cur_sl = float(MaxSL * Point()); ulong pos = 0; for(ulong i = 0; i < argmin; i++) { tp = MathMin(tp, target[i] + fstate[i, 2] - fstate[i, 0]); pos = i; if(cur_sl <= target[i] + fstate[i, 1] - fstate[i, 0]) break; sl = MathMax(sl, target[i] + fstate[i, 1] - fstate[i, 0]); } if(tp < 0) { sl = (float)MathMin(MathAbs(sl) / (MaxSL * Point()), 1); tp = (float)MathMin(-tp / (MaxTP * Point()), 1); result[3] = float(Buffer[tr].States[i].account[0] / 100 * 0.01); result[4] = tp; result[5] = sl; for(int i = 0; i < 3; i++) result[i] = 0; bActions.AssignArray(result); } } } } }
形成“近乎理想”的动作向量后，我们对模型进行回溯通验，把智代预测动作与目标值之间的偏差最小化。
//--- Actor Policy if(!Actor.backProp(GetPointer(bActions), (CBufferFloat*)GetPointer(bAccount), GetPointer(bGradient))) { PrintFormat("%s -> %d", __FUNCTION__, __LINE__); Stop = true; break; }
现在我们仅需通知用户训练进展，然后继续嵌套环路系统的下一次迭代。
if(GetTickCount() - ticks > 500) { double percent = double(iter + i - start) * 100.0 / (Iterations); string str = StringFormat("%-14s %6.2f%% -> Error %15.8f\n", "Actor", percent, Actor.getRecentAverageError()); Comment(str); ticks = GetTickCount(); } } }
所有训练环路迭代成功完成之后，我们会清除金融产品图表上通知用户的注释栏。我们记录训练结果，并启动程序关闭过程。
Comment(""); //--- PrintFormat("%s -> %d -> %-15s %10.7f", __FUNCTION__, __LINE__, "Actor", Actor.getRecentAverageError()); ExpertRemove(); //--- }
我们构建 FinMem 框架的 MQL5 版本的算法验证至此完毕。所有呈现的对象、其方法、及准备本文时的程序完整源代码，均可在附件中查阅。
测试
前两篇文章专注于 FinMem 框架。在这些文章中，我们遵照自己对框架作者所提议方式的解释实现了 MQL5 版本。我们现已进入最激动人心的阶段：评估已实现解决方案在真实历史数据上的有效性。
重点要强调，在实现期间，我们对 FinMem 算法做了重大修订。由此，我们评估的仅是我们自己实现的解决方案，而非原始框架。
该模型基于 EURUSD 货币对 2023 年的历史数据，采用 H1 时间帧训练。模型分析的指标设置保持其默认值。
在初始训练阶段，我们取用之前研究中形成的数据集。实现的训练算法，能为智代生成“近乎理想”的目标动作，允许在不更新训练数据集的情况下训练模型。不过，为了覆盖更广泛的账户状态，我建议尽可能定期更新训练数据集。
经过若干次训练周期，我们获得了一个模型，在训练和测试数据上均演绎出颇具稳定的盈利能力。最终测试运作基于 2024 年 1 月的历史数据，其它参数保持不变。测试结果呈现如下。
测试期间，该模型执行了 33 笔交易，其中略多于一半得以获利了结。平均和最大盈利交易均超过相应的亏损交易量值，令模型展现出余额增长趋势。这示意所提议方式的潜力，及其在实时交易中的可行性。
结束语
我们探讨了 FinMem 框架，它代表了自主交易系统演进的新阶段。该框架结合了认知原理，与基于大语言模型的现代算法。层化记忆和实时适配性，令智代即使在不稳定的市场环境中也能做出理性、且准确的投资决策。
在实际工作中，我们针对拟议方式的自我诠释，实现了 MQL5 版本，同时省略了大语言模型。实验结果确认了所提议方式的有效性，及其在真实交易中的适用性。然而，若要在实时金融市场上全面部署，该模型还需要在更具代表性的数据集上进行额外调谐和训练，并伴随更彻底的综合性测试。
参考
文章中所用程序
| # | 名称 | 类型 | 说明 |
|---|---|---|---|
| 1 | Research.mq5 | 智能系统 | 收集样本的智能系统 |
| 2 | ResearchRealORL.mq5 | 智能系统 | 利用 Real-ORL 方法收集样本的智能系统 |
| 3 | Study.mq5 | 智能系统 | 模型训练 EA |
| 4 | Test.mq5 | 智能系统 | 模型测试智能系统 |
| 5 | Trajectory.mqh | 类库 | 系统状态和模型架构描述结构 |
| 6 | NeuroNet.mqh | 类库 | 创建神经网络的类库 |
| 7 | NeuroNet.cl | 代码库 | OpenCL 程序代码 |
本文由MetaQuotes Ltd译自俄文
原文地址： https://www.mql5.com/ru/articles/16816
注意: MetaQuotes Ltd.将保留所有关于这些材料的权利。全部或部分复制或者转载这些材料将被禁止。
本文由网站的一位用户撰写，反映了他们的个人观点。MetaQuotes Ltd 不对所提供信息的准确性负责，也不对因使用所述解决方案、策略或建议而产生的任何后果负责。
风险管理（第二部分）：在图形界面中实现手数计算
市场模拟（第七部分）：套接字（一）
解密开盘区间突破（ORB）日内交易策略
