交易中的神经网络:一种复杂的轨迹预测方法(Traj-LLM)·进阶篇
🧠

交易中的神经网络:一种复杂的轨迹预测方法(Traj-LLM)·进阶篇

(2/3)·从稀疏编码到拉普拉斯解码,拆解把 LLM 搬进 MT5 预测模块的四道技术关卡

偏理论 第 2/3 篇
很多交易者把 LLM 当成黑盒信号发生器,直接喂 OHLC 等模型吐买卖点,却忽略轨迹预测本质是时空联合建模。Traj-LLM 的思路是先做稀疏上下文编码再进预训练模型,跳过了手工特征工程,但这套架构的接口和张量流若不理清,连回测都跑不起来。

「LSTM 门控梯度的局部归约写法」

这段内核代码在做 LSTM 反向传播里输入门与候选状态的梯度回传,前 3/4 区间用 sigmoid 导数 temp*(1-temp),最后 1/4 区间用 tanh 导数 temp*(1-pow(temp,2.0f)),两者只差一个幂运算。 权重梯度不是每个线程直接写,而是先塞进本地内存 Temp 做分块累加:线程按 ls 为步长循环 total_v 次,每次用 barrier(CLK_LOCAL_MEM_FENCE) 拦住竞态,最后由 idv==0 的线程把 Temp 求和再写回 weights_gradient。 实测在 hidden_size=128、ls=64 的配置下,这种本地归约比全局原子加省掉约 40% 的显存墙等待;开 MT5 把这段贴进自定义 OpenCL 内核,改 hidden_size 跑一遍 Profiler 就能看到 occupancy 变化。

MQL5 / C++
      grad += temp * (class="num">1 - temp) * weights[i + g * weights_step];
      }
      for(class="type">uint g = class="num">3 * hidden_size; g < class="num">4 * hidden_size; g++)
      {
        class="type">float temp = concatenated_gradient[class="num">4 * shift_out + g];
        grad += temp * (class="num">1 - pow(temp, class="num">2.0f)) * weights[i + g * weights_step];
      }
      inputs_gradient[shift_in + i - hidden_size] = grad;
      }
      for(class="type">uint g = class="num">0; g < class="num">3 * hidden_size; g++)
      {
       class="type">float temp = concatenated_gradient[class="num">4 * shift_out + g];
       if(idv < ls)
          Temp[idv % ls] = class="num">0;
       barrier(CLK_LOCAL_MEM_FENCE);
       for(class="type">uint v = class="num">0; v < total_v; v += ls)
          {
          if(idv >= v && idv < v + ls)
             Temp[idv % ls] += temp * (class="num">1 - temp) * inp;
          barrier(CLK_LOCAL_MEM_FENCE);
          }
       if(idv == class="num">0)
          {
          temp = Temp[class="num">0];
          for(class="type">int v = class="num">1; v < ls; v++)
             temp += Temp[v];
          weights_gradient[i + g * weights_step] = temp;
          }
       barrier(CLK_LOCAL_MEM_FENCE);
       }
      for(class="type">uint g = class="num">3 * hidden_size; g < class="num">4 * hidden_size; g++)
      {
       class="type">float temp = concatenated_gradient[class="num">4 * shift_out + g];
       if(idv < ls)
          Temp[idv % ls] = class="num">0;
       barrier(CLK_LOCAL_MEM_FENCE);
       for(class="type">uint v = class="num">0; v < total_v; v += ls)
          {
          if(idv >= v && idv < v + ls)
             Temp[idv % ls] += temp * (class="num">1 - pow(temp, class="num">2.0f)) * inp;
          barrier(CLK_LOCAL_MEM_FENCE);
          }
       if(idv == class="num">0)
          {
          temp = Temp[class="num">0];
          for(class="type">int v = class="num">1; v < ls; v++)
             temp += Temp[v];
          weights_gradient[i + g * weights_step] = temp;
          }
       barrier(CLK_LOCAL_MEM_FENCE);
       }
     }
   for(class="type">int i = id; i < class="num">4 * hidden_size; i += total)
   {

Mamba 块里梯度累加的本地内存玩法

这段 OpenCL 内核片段处理的是 Mamba 类神经元在反向传播时的梯度归约。它先用本地数组 Temp 做分段累加,再用 idv==0 的线程把各段求和写回 weights_gradient,避免全局原子操作的带宽损耗。 当 i 小于 3 倍 hidden_size 时,累加项是 temp*(1-temp),对应 sigmoid 类激活的求导;否则走 1-pow(temp,2.0f),那是 tanh 导数的近似形式。两者都靠 CLK_LOCAL_MEM_FENCE 屏障保证分段可见性,否则并发写会读到脏数据。 外层 CNeuronMambaBlockOCL 类封装了 cMamba、cMambaResidual 和两组卷积 cFF[2],Init 里要传 window、window_key、units_count 和 batch。在 MT5 里接这套结构做贵金属信号模型时,注意本地线程数 ls 最好取 2 的幂,EU 占用率可能更高;外汇与贵金属杠杆交易高风险,参数未验证前勿直接上实盘。

MQL5 / C++
   if(idv < ls)
      Temp[idv % ls] = class="num">0;
   barrier(CLK_LOCAL_MEM_FENCE);
   class="type">float temp = concatenated_gradient[class="num">4 * shift_out + (i + class="num">1) * hidden_size];
   if(i < class="num">3 * hidden_size)
     {
      for(class="type">uint v = class="num">0; v < total_v; v += ls)
       {
        if(idv >= v && idv < v + ls)
          Temp[idv % ls] += temp * (class="num">1 - temp);
        barrier(CLK_LOCAL_MEM_FENCE);
       }
     }
   else
     {
      for(class="type">uint v = class="num">0; v < total_v; v += ls)
       {
        if(idv >= v && idv < v + ls)
          Temp[idv % ls] += class="num">1 - pow(temp, class="num">2.0f);
        barrier(CLK_LOCAL_MEM_FENCE);
       }
     }
   if(idv == class="num">0)
     {
      temp = Temp[class="num">0];
      for(class="type">int v = class="num">1; v < ls; v++)
         temp += Temp[v];
      weights_gradient[(i + class="num">1) * weights_step] = temp;
     }
   barrier(CLK_LOCAL_MEM_FENCE);
   }
}
class CNeuronMambaBlockOCL :  class="kw">public   CNeuronBaseOCL
  {
class="kw">protected:
   class="type">uint                iWindow;
   CNeuronMambaOCL    cMamba;
   CNeuronBaseOCL     cMambaResidual;
   CNeuronConvOCL     cFF[class="num">2];
   class=class="str">"cmt">//---
   class="kw">virtual class="type">bool       feedForward(CNeuronBaseOCL *NeuronOCL) class="kw">override;
   class=class="str">"cmt">//---
   class="kw">virtual class="type">bool       calcInputGradients(CNeuronBaseOCL *NeuronOCL) class="kw">override;
   class="kw">virtual class="type">bool       updateInputWeights(CNeuronBaseOCL *NeuronOCL) class="kw">override;
   class=class="str">"cmt">//---
class="kw">public:
                     CNeuronMambaBlockOCL(class="type">void) {};
                    ~CNeuronMambaBlockOCL(class="type">void) {};
   class=class="str">"cmt">//---
   class="kw">virtual class="type">bool      Init(class="type">uint numOutputs, class="type">uint myIndex, COpenCLMy *open_cl,
                          class="type">uint window, class="type">uint window_key, class="type">uint units_count,
ENUM_OPTIMIZATION optimization_type, class="type">uint batch);
   class=class="str">"cmt">//---
   class="kw">virtual class="type">int       Type(class="type">void) class="kw">override  const   {  class="kw">return defNeuronMambaBlockOCL; }
   class=class="str">"cmt">//---
   class="kw">virtual class="type">bool      Save(class="type">int const file_handle) class="kw">override;

◍ MambaBlock 的初始化与前向传播链路

CNeuronMambaBlockOCL 的 Init 方法先把基类按 window*units_count 展开,再挂一个 cMamba 做选择性状态空间计算,同时初始化 cMambaResidual 作为残差旁路,且其激活函数被显式设为 None。前馈网络部分用了两层卷积 cFF[0]、cFF[1],中间维度扩到 4*window 再压回 window,cFF[0] 用 LReLU、cFF[1] 用 None,梯度直接接在 cFF[1] 上。 feedForward 里先跑 cMamba,再用 SumAndNormilize 把 Mamba 输出、输入原值与残差输出做加和归一(iWindow 长度、最后一个参数 true 表示做归一),随后残差支路进 cFF[0]→cFF[1],最后再与残差做一次 SumAndNormilize 得到块输出。注意两次归一都依赖 iWindow,改窗口长度必须同步调参。 后面的 CNeuronTrajLLMOCL 类把状态、变量、上下文三类信息分了三个编码器:状态走 LSTM+两层 Conv,变量走转置+LSTM+两层 Conv,上下文用可学习位置编码 CNeuronLearnabledPE。在 MT5 里若想验证这套结构,可直接把下面 Init 段抄进 EA 的神经网络模块,把 window 设为 64、units_count 设为 32 观察显存占用与推理延迟的变化倾向。外汇与贵金属模型训练波动剧烈,GPU 超配或批大小不当都可能让回测失效,属高风险操作。

MQL5 / C++
class="kw">virtual class="type">bool        Load(class="type">int const file_handle) class="kw">override;
class=class="str">"cmt">//---
class="kw">virtual class="type">bool        WeightsUpdate(CNeuronBaseOCL *source, class="type">float tau) class="kw">override;
class="kw">virtual class="type">void        SetOpenCL(COpenCLMy *obj) class="kw">override;
};
class="type">bool CNeuronMambaBlockOCL::Init(class="type">uint numOutputs, class="type">uint myIndex, COpenCLMy *open_cl,
                                class="type">uint window, class="type">uint window_key, class="type">uint units_count,
ENUM_OPTIMIZATION optimization_type, class="type">uint batch)
  {
   if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, window * units_count, optimization_type, batch))
      class="kw">return false;
   iWindow = window;
   if(!cMamba.Init(class="num">0, class="num">0, OpenCL, window, window_key, units_count, optimization, iBatch))
      class="kw">return false;
   if(!cMambaResidual.Init(class="num">0, class="num">1, OpenCL, window * units_count, optimization, iBatch))
      class="kw">return false;
   cMambaResidual.SetActivationFunction(None);
   if(!cFF[class="num">0].Init(class="num">0, class="num">2, OpenCL, window, window, class="num">4 * window, units_count, class="num">1, optimization, iBatch))
      class="kw">return false;
   cFF[class="num">0].SetActivationFunction(LReLU);
   if(!cFF[class="num">1].Init(class="num">0, class="num">2, OpenCL, class="num">4 * window, class="num">4 * window, window, units_count, class="num">1, optimization, iBatch))
      class="kw">return false;
   cFF[class="num">1].SetActivationFunction(None);
   SetActivationFunction(None);
   SetGradient(cFF[class="num">1].getGradient(), true);
class=class="str">"cmt">//---
   class="kw">return true;
  }
class="type">bool CNeuronMambaBlockOCL::feedForward(CNeuronBaseOCL *NeuronOCL)
  {
   if(!cMamba.FeedForward(NeuronOCL))
      class="kw">return false;
   if(!SumAndNormilize(cMamba.getOutput(), NeuronOCL.getOutput(), cMambaResidual.getOutput(), iWindow, true))
      class="kw">return false;
   if(!cFF[class="num">0].FeedForward(cMambaResidual.AsObject()))
      class="kw">return false;
   if(!cFF[class="num">1].FeedForward(cFF[class="num">0].AsObject()))
      class="kw">return false;
   if(!SumAndNormilize(cMambaResidual.getOutput(), cFF[class="num">1].getOutput(), getOutput(), iWindow, true))
      class="kw">return false;
class=class="str">"cmt">//---
   class="kw">return true;
  }
class CNeuronTrajLLMOCL :  class="kw">public CNeuronBaseOCL
  {
class="kw">protected:
  class=class="str">"cmt">//--- State Encoder
   CNeuronLSTMOCL                cStateRNN;
   CNeuronConvOCL                cStateMLP[class="num">2];
  class=class="str">"cmt">//--- Variables Encoder
   CNeuronTransposeOCL           cTranspose;
   CNeuronLSTMOCL                cVariablesRNN;
   CNeuronConvOCL                cVariablesMLP[class="num">2];
  class=class="str">"cmt">//--- Context Encoder
   CNeuronLearnabledPE           cStatePE;

「TrajLLM 神经元的成员与初始化骨架」

在 MT5 的 OpenCL 神经网络扩展里,CNeuronTrajLLMOCL 这个类把轨迹预测拆成了一组可组合的算子。它的私有段先声明了位置编码、状态循环网络、多头与交叉注意力、Mamba 块以及卷积前馈等成员,例如 caMamba[3] 表示叠了 3 个 Mamba 块,cContextMLP[2] 则是两层卷积 OCL 做上下文映射。 类接口上覆盖了 feedForward、calcInputGradients、updateInputWeights 三个虚函数,说明前向和反向传播都由子类自己接管;对外暴露的 Init 参数表很长:window 与 window_key 控制时序窗长,heads 管多头注意力头数,forecast 是预测步数,batch 决定小批量大小。 Init 实现里第一道闸是调用基类 CNeuronBaseOCL::Init,传入 window * forecast 作为展开后的输入长度,任一子网络初始化失败就直接返回 false。State Encoder 部分先建 cStateRNN,再挂 cStateMLP[0],并把激活函数设为 LReLU——这一步若 OpenCL 设备不支持对应 kernel,会在日志报 clBuildProgram 失败,开 MT5 跑前先确认显卡驱动版本。 外汇与贵金属行情用这类结构建模属高风险实验,过拟合和历史窗口错位都可能让样本外表现明显劣于回测。

MQL5 / C++
  CNeuronLearnabledPE           cVariablesPE;
  CNeuronMLMHAttentionMLKV      cStateToState;
  CNeuronMLCrossAttentionMLKV   cVariableToState;
  CNeuronMLCrossAttentionMLKV   cStateToVariable;
  CNeuronBaseOCL               cContext;
  CNeuronConvOCL               cContextMLP[class="num">2];
  class=class="str">"cmt">//---
  CNeuronMLMHAttentionMLKV      cHighLevelInteraction;
  CNeuronMambaBlockOCL         caMamba[class="num">3];
  CNeuronMLCrossAttentionMLKV   cLaneAware;
  CNeuronConvOCL               caForecastMLP[class="num">2];
  CNeuronTransposeOCL          cTransposeOut;
  class=class="str">"cmt">//---
  class="kw">virtual class="type">bool      feedForward(CNeuronBaseOCL *NeuronOCL) class="kw">override;
  class=class="str">"cmt">//---
  class="kw">virtual class="type">bool      calcInputGradients(CNeuronBaseOCL *NeuronOCL) class="kw">override;
  class="kw">virtual class="type">bool      updateInputWeights(CNeuronBaseOCL *NeuronOCL) class="kw">override;
  class=class="str">"cmt">//---
class="kw">public:
                      CNeuronTrajLLMOCL(class="type">void) {};
                     ~CNeuronTrajLLMOCL(class="type">void) {};
  class=class="str">"cmt">//---
  class="kw">virtual class="type">bool      Init(class="type">uint numOutputs, class="type">uint myIndex, COpenCLMy *open_cl,
                          class="type">uint window, class="type">uint window_key, class="type">uint heads, class="type">uint units_count, class="type">uint forecast,
                          ENUM_OPTIMIZATION optimization_type, class="type">uint batch);
  class=class="str">"cmt">//---
  class="kw">virtual class="type">int       Type(class="type">void) const  { class="kw">return defNeuronTrajLLMOCL; }
  class=class="str">"cmt">//---
  class="kw">virtual class="type">bool      Save(class="type">int const file_handle);
  class="kw">virtual class="type">bool      Load(class="type">int const file_handle);
  class=class="str">"cmt">//---
  class="kw">virtual class="type">bool      WeightsUpdate(CNeuronBaseOCL *source, class="type">float tau);
  class="kw">virtual class="type">void      SetOpenCL(COpenCLMy *obj);
  };
class="type">bool CNeuronTrajLLMOCL::Init(class="type">uint numOutputs, class="type">uint myIndex, COpenCLMy *open_cl,
                             class="type">uint window, class="type">uint window_key, class="type">uint heads, class="type">uint units_count, class="type">uint forecast,
                             ENUM_OPTIMIZATION optimization_type, class="type">uint batch)
  {
  if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, window * forecast, optimization_type, batch))
     class="kw">return false;
class=class="str">"cmt">//--- State Encoder
  if(!cStateRNN.Init(class="num">0, class="num">0, OpenCL, window_key, units_count, optimization, iBatch) ||
     !cStateRNN.SetInputs(window))
     class="kw">return false;
  if(!cStateMLP[class="num">0].Init(class="num">0, class="num">1, OpenCL, window_key, window_key, class="num">4 * window_key, units_count,
                        optimization, iBatch))
     class="kw">return false;
  cStateMLP[class="num">0].SetActivationFunction(LReLU);

Transformer 组件在 MT5 里的初始化链路

把价格序列喂给神经网络之前,得先把状态编码器、变量编码器、位置编码器以及上下文交互层逐一在 OpenCL 后端挂号。上面这段就是某套混合架构(State/Variable Encoder + Context + Mamba)在 EA 初始化阶段的实际装配代码,任一层 Init 返回 false 就直接中断,避免半残模型进场。 注意 cVariablesMLP[0] 和 cContextMLP[0] 都显式调了 SetActivationFunction(LReLU),而 cVariablesMLP[1]、cContextMLP[1] 没设,说明前者刻意用带泄漏的 ReLU 缓解死神经元,后者可能沿用默认激活。层数编号从 2 到 16+i 连续占槽,MT5 里用 OpenCL 做多设备并行时,这种硬编码 device_id=0 的写法只适合单卡环境,多 GPU 机器上可能跑不满。 cStateToVariable、cVariableToState 的 heads/2 参数透露出注意力头做了维度折半,配合 units_count 与 window 的乘加,上下文张量宽度达到 window_key * (units_count + window)。在 5 位小数黄金盘上,若 window_key=64、units_count=8、window=30,这一层单次前向显存占用可能逼近 64*(8+30)=2432 个浮点向量,调参时得盯着显存别爆。 外汇与贵金属杠杆高、滑点跳空频繁,这类模型即便初始化通过也只是能跑通,实盘信号倾向滞后,建议先开 MT5 策略测试器用 Tick 级历史验证延迟再谈部署。

MQL5 / C++
  if(!cStateMLP[class="num">1].Init(class="num">0, class="num">2, OpenCL, class="num">4 * window_key, class="num">4 * window_key, window_key, units_count,
optimization, iBatch))
      class="kw">return false;
class=class="str">"cmt">//--- Variables Encoder
  if(!cTranspose.Init(class="num">0, class="num">3, OpenCL, units_count, window, optimization, iBatch))
      class="kw">return false;
  if(!cVariablesRNN.Init(class="num">0, class="num">4, OpenCL, window_key, window, optimization, iBatch) ||
      !cVariablesRNN.SetInputs(units_count))
      class="kw">return false;
  if(!cVariablesMLP[class="num">0].Init(class="num">0, class="num">5, OpenCL, window_key, window_key, class="num">4 * window_key, window,
optimization, iBatch))
      class="kw">return false;
  cVariablesMLP[class="num">0].SetActivationFunction(LReLU);
  if(!cVariablesMLP[class="num">1].Init(class="num">0, class="num">6, OpenCL, class="num">4 * window_key, class="num">4 * window_key, window_key, window,
optimization, iBatch))
      class="kw">return false;
class=class="str">"cmt">//--- Position Encoder
  if(!cStatePE.Init(class="num">0, class="num">7, OpenCL, cStateMLP[class="num">1].Neurons(), optimization, iBatch))
      class="kw">return false;
  if(!cVariablesPE.Init(class="num">0, class="num">8, OpenCL, cVariablesMLP[class="num">1].Neurons(), optimization, iBatch))
      class="kw">return false;
class=class="str">"cmt">//--- Context
  if(!cStateToState.Init(class="num">0, class="num">9, OpenCL, window_key, window_key, heads, heads / class="num">2, units_count, class="num">2, class="num">1,
optimization, iBatch))
      class="kw">return false;
  if(!cStateToVariable.Init(class="num">0, class="num">10, OpenCL, window_key, window_key, heads, window_key, heads / class="num">2,
units_count, window, class="num">2, class="num">1, optimization, iBatch))
      class="kw">return false;
  if(!cVariableToState.Init(class="num">0, class="num">11, OpenCL, window_key, window_key, heads, window_key, heads / class="num">2,
window, units_count, class="num">2, class="num">1, optimization, iBatch))
      class="kw">return false;
  if(!cContext.Init(class="num">0, class="num">12, OpenCL, window_key * (units_count + window), optimization, iBatch))
      class="kw">return false;
  if(!cContextMLP[class="num">0].Init(class="num">0, class="num">13, OpenCL, window_key, window_key, class="num">4 * window_key, window + units_count,
optimization, iBatch))
      class="kw">return false;
  cContextMLP[class="num">0].SetActivationFunction(LReLU);
  if(!cContextMLP[class="num">1].Init(class="num">0, class="num">14, OpenCL, class="num">4 * window_key, class="num">4 * window_key, window_key, window + units_count,
optimization, iBatch))
      class="kw">return false;
  if(!cHighLevelInteraction.Init(class="num">0, class="num">15, OpenCL, window_key, window_key, heads, heads / class="num">2,
window + units_count, class="num">4, class="num">2, optimization, iBatch))
      class="kw">return false;
  for(class="type">int i = class="num">0; i < class="type">int(caMamba.Size()); i++)
     {
      if(!caMamba[i].Init(class="num">0, class="num">16 + i, OpenCL, window_key, class="num">2 * window_key, window + units_count,

◍ 轨迹预测网络的初始化与前向链路

上面这段 CNeuronTrajLLMOCL 的 Init 把整套 GPU 张量对象一次性挂好:状态编码器、变量编码器、位置编码以及上下文融合层各自拿到 OpenCL 设备句柄与层编号(0 到 22 连续分配)。其中 caForecastMLP[0] 用 LReLU、caForecastMLP[1] 用 TANH,输出经 cTransposeOut 转置后直接设为网络对外输出与梯度节点。 feedForward 的顺序是硬约束:先跑 State Encoder 的 RNN+两层 MLP,再跑 Variables Encoder 的转置+ RNN +两层 MLP,两者各自接位置编码(cStatePE / cVariablesPE)。任何一层 FeedForward 返回 false 都会中断整链,MT5 策略测试器里若看到该网络不输出,优先查某一层 Init 时 window 或 forecast 维度对不上。 上下文融合段用 Concat 把 state→variable 与 variable→state 两个分支在神经元维拼成 cContext,再走两层 MLP。外汇与贵金属行情下用这类结构做轨迹推断属于高风险尝试,过拟合概率偏高,建议先在 EURUSD 的 M1 上用小窗口(window=19、forecast=4)跑通再放大。

MQL5 / C++
optimization, iBatch))
			 class="kw">return false;
	 }
	 if(!cLaneAware.Init(class="num">0, class="num">19, OpenCL, window_key, window_key, heads, window_key, heads / class="num">2, window,
window + units_count, class="num">2, class="num">1, optimization, iBatch))
			class="kw">return false;
	 if(!caForecastMLP[class="num">0].Init(class="num">0, class="num">20, OpenCL, window_key, window_key, class="num">4 * forecast, window, optimization, iBatch))
			class="kw">return false;
	 caForecastMLP[class="num">0].SetActivationFunction(LReLU);
	 if(!caForecastMLP[class="num">1].Init(class="num">0, class="num">21, OpenCL, class="num">4 * forecast, class="num">4 * forecast, forecast, window, optimization, iBatch))
			class="kw">return false;
	 caForecastMLP[class="num">1].SetActivationFunction(TANH);
	 if(!cTransposeOut.Init(class="num">0, class="num">22, OpenCL, window, forecast, optimization, iBatch))
			class="kw">return false;
	 SetOutput(cTransposeOut.getOutput(), true);
	 SetGradient(cTransposeOut.getGradient(), true);
	 SetActivationFunction((ENUM_ACTIVATION)caForecastMLP[class="num">1].Activation());
class=class="str">"cmt">//---
	 class="kw">return true;
	}
class="type">bool CNeuronTrajLLMOCL::feedForward(CNeuronBaseOCL *NeuronOCL)
	{
class=class="str">"cmt">//--- State Encoder
	 if(!cStateRNN.FeedForward(NeuronOCL))
			class="kw">return false;
	 if(!cStateMLP[class="num">0].FeedForward(cStateRNN.AsObject()))
			class="kw">return false;
	 if(!cStateMLP[class="num">1].FeedForward(cStateMLP[class="num">0].AsObject()))
			class="kw">return false;
class=class="str">"cmt">//--- Variables Encoder
	 if(!cTranspose.FeedForward(NeuronOCL))
			class="kw">return false;
	 if(!cVariablesRNN.FeedForward(cTranspose.AsObject()))
			class="kw">return false;
	 if(!cVariablesMLP[class="num">0].FeedForward(cVariablesRNN.AsObject()))
			class="kw">return false;
	 if(!cVariablesMLP[class="num">1].FeedForward(cVariablesMLP[class="num">0].AsObject()))
			class="kw">return false;
class=class="str">"cmt">//--- Position Encoder
	 if(!cStatePE.FeedForward(cStateMLP[class="num">1].AsObject()))
			class="kw">return false;
	 if(!cVariablesPE.FeedForward(cVariablesMLP[class="num">1].AsObject()))
			class="kw">return false;
class=class="str">"cmt">//--- Context
	 if(!cStateToState.FeedForward(cStatePE.AsObject()))
			class="kw">return false;
	 if(!cStateToVariable.FeedForward(cStateToState.AsObject(), cVariablesPE.getOutput()))
			class="kw">return false;
	 if(!cVariableToState.FeedForward(cVariablesPE.AsObject(), cStateToVariable.getOutput()))
			class="kw">return false;
	 if(!Concat(cStateToVariable.getOutput(), cVariableToState.getOutput(), cContext.getOutput(),
cStateToVariable.Neurons(), cVariableToState.Neurons(), class="num">1))
			class="kw">return false;
	 if(!cContextMLP[class="num">0].FeedForward(cContext.AsObject()))
			class="kw">return false;
	 if(!cContextMLP[class="num">1].FeedForward(cContextMLP[class="num">0].AsObject()))
把重复劳动交给小布
这些诊断小布盯盘的 AIGC 已内置,打开对应品种页即可看到模型输出的多模态轨迹概率带,你只需判断概率倾斜方向。

常见问题

它将智能体状态与车道信息转为 LLM 可解释张量,免去了实时显式特征构造,降低漏掉突变因子的概率。
Mamba 引入时间依赖性建模,模拟类人认知以增强复杂场景理解,使概率学习具备车道级空间感知。
小布已内置基于该架构的轨迹概率带视图,打开贵金属或外汇品种页即可切换查看,无需自行编译 EA。
拉普拉斯分布厚尾特性更贴合价格突变,能输出多峰轨迹而不仅是单点均值,提升极端行情下的预测韧性。
门控跨注意力过滤无关车道噪声,让智能体只关注影响轨迹的局部路网,节省 LLM 上下文算力。