数据科学与机器学习 — 神经网络(第 02 部分):前馈神经网络架构设计

有时,与您的问题最相合的网络可能是输入层中有 10 个节点,隐藏层中有 13 个节点/神经元,输出层中有大约四个节点/神经元,更不必提您将不得不微调整个网络中隐藏层的数量。 

我的观点是,我们需要一些动态的东西。 一个动态代码,我们可以在不打破程序的情况下更改参数及优化。 如果您使用 python-keras 函数库来构建神经网络,即便架构很复杂,您也能减少配置和编译的工作,这就是我希望我们能够在 MQL5 中达成的目标。

就像我在线性回归 第 3 部分(这是本系列文章中必读的内容之一)中所做的那样,我引入了模型的矩阵/向量形式,从而能够拥有无限输入数量的灵活模型。
 

矩阵来拯救

我们都知道,当涉及到优化新参数时,硬编码模型会落入钝化,整个过程很耗时,会导致头痛、背部疼痛、等等,(太不值了)

如果我们抵近观察神经网络背后的操作,您会注意到每个输入都被乘以分配给它的权重,然后它们的输出被添加到乖离之中。 矩阵运算可以很好地处理这一点。

基本上,我们找到输入和权重矩阵的点积,然后最终将其添加到乖离之中。

为了构建一个灵活的神经网络,我将尝试一个奇怪的架构,即输入层中有 2 个节点,第一个隐藏层中有 4 个节点,第二个隐藏层中有 6 个节点,第三个隐藏层中有 1 个节点,最后是输出层中的一个节点。

这是为了测试我们的矩阵逻辑在所有情况下是否均都能顺利执行

  • 当前一层(输入)的节点数量较少时,下一层(输出层)
  • 当前一层(输入)有较多节点时,下一层
  • 当输入层和下一层(输出)层中的节点数量相等时

为矩阵运算编写代码,并计算值之前,我们先做一些基本事务,从而令整个运算成为可能。

生成随机权重和乖离值。

    //Generate random bias
    for(int i=0; i 
  

我们在上一部分曾看到过这个操作,但需要注意的一点是,这些权重和乖离值应该一次生成,以便运用在世代周期。


什么是世代?

世代是神经网络中所有数据的完整传递,在前馈中是所有输入的完整前向验算,在反向传播中是完整的前向和后向验算。 简而言之,就是神经网络看过所有数据。

与我们在上一篇文章中看到的 MLP 不同,这次我们带来了一个实现,其考虑到输出层中的激活函数,用过 keras 的人可能熟悉这一点,基本上我们可以在隐藏层中拥有不同的激活函数,且其会在输出层引导输出。

CNeuralNets(fx HActivationFx,fx OActivationFx,int &NodesHL[],int outputs=NULL, bool SoftMax=false);

请注意,输入 HActivationFx 是隐藏层中的激活函数,OActivationFx 是输出层中的激活函数,NodesHL[] 是隐藏层中的节点数量。 如果该数组有 3 个元素,这意味着您有 3 个隐藏层,这些层中的节点数量将由数组中存在的元素决定,请参阅下面的代码。

int hlnodes[3] = {4,6,1};
int outputs = 1;
     
neuralnet = new CNeuralNets(SIGMOID,RELU,hlnodes,outputs);

这是我们刚在上面所见图像上的架构。 outputs 参数是可选的,如果将其保留为 NULL,则以下配置将应用于输出层:

if (m_outputLayers == NULL)
{
  if (A_fx == RELU)     m_outputLayers = 1;
  else                  m_outputLayers = ArraySize(MLPInputs);
}

如果您选择 RELU 作为隐藏层的激活函数,则输出层将有一个节点,否则最后一层中的输出数量将等于第一层中的输入数量。 如果您在隐藏层中使用 RELU 以外的其它激活函数,则您有很高机会用到分类神经网络,那么默认输出层将等于列数。 这是不可靠的,尽管输出必须等同于您的数据集中目标特征的数量,如若您尝试解决分类问题,我会在将来的更新中找到一种方法式来更改它,现在您必须手工选择输出神经元的数量。

现在,我们调用完整的 MLP 函数,并查看输出,然后我会解释为了操作成为可能,已完成的工作。

LI     
EL      0       10:10:29.996    NNTestScript (#NQ100,H1)        0.002 0.061 0.056 0.600 0.737 0.454 0.113 0.622 0.387 0.456 0.938 0.587 0.379 0.207 0.356 0.784 0.046 0.597 0.511 0.838 0.848 0.748 0.047 0.282
FF      0       10:10:29.996    NNTestScript (#NQ100,H1)        Arr size A 4
EI      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 0.00168 X A[0] = 1.000 B[0] = 0.002
QE      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 0.09745 X A[1] = 0.845 B[6] = 0.113
MR      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 0.47622 X A[2] = 1.000 B[12] = 0.379
NN      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 0.98699 X A[3] = 1.000 B[18] = 0.511
MI      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[1] = 0.06109 X A[0] = 1.000 B[1] = 0.061
ME      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[1] = 0.58690 X A[1] = 0.845 B[7] = 0.622
PR      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[1] = 0.79347 X A[2] = 1.000 B[13] = 0.207
KN      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[1] = 1.63147 X A[3] = 1.000 B[19] = 0.838
GI      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[2] = 0.05603 X A[0] = 1.000 B[2] = 0.056
GE      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[2] = 0.38353 X A[1] = 0.845 B[8] = 0.387
GS      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[2] = 0.73961 X A[2] = 1.000 B[14] = 0.356
CO      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[2] = 1.58725 X A[3] = 1.000 B[20] = 0.848
KH      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[3] = 0.59988 X A[0] = 1.000 B[3] = 0.600
OD      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[3] = 0.98514 X A[1] = 0.845 B[9] = 0.456
LS      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[3] = 1.76888 X A[2] = 1.000 B[15] = 0.784
KO      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[3] = 2.51696 X A[3] = 1.000 B[21] = 0.748
PH      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[4] = 0.73713 X A[0] = 1.000 B[4] = 0.737
FG      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[4] = 1.53007 X A[1] = 0.845 B[10] = 0.938
RS      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[4] = 1.57626 X A[2] = 1.000 B[16] = 0.046
OO      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[4] = 1.62374 X A[3] = 1.000 B[22] = 0.047
EH      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[5] = 0.45380 X A[0] = 1.000 B[5] = 0.454
DG      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[5] = 0.95008 X A[1] = 0.845 B[11] = 0.587
PS      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[5] = 1.54675 X A[2] = 1.000 B[17] = 0.597
EO      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[5] = 1.82885 X A[3] = 1.000 B[23] = 0.282
KH      0       10:10:29.996    NNTestScript (#NQ100,H1)        before rows 1 cols 6
RL      0       10:10:29.996    NNTestScript (#NQ100,H1)        IxWMatrix
HI      0       10:10:29.996    NNTestScript (#NQ100,H1)        Matrix
NS      0       10:10:29.996    NNTestScript (#NQ100,H1)        [ 
ND      0       10:10:29.996    NNTestScript (#NQ100,H1)        0.98699 1.63147 1.58725 2.51696 1.62374 1.82885
JM      0       10:10:29.996    NNTestScript (#NQ100,H1)        ] 
LG      0       10:10:29.996    NNTestScript (#NQ100,H1)        rows = 1 cols = 6

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< End of second Hidden Layer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

ML      0       10:10:29.996    NNTestScript (#NQ100,H1)        Hidden Layer 3 | Nodes 1 | Bias 0.1004
OG      0       10:10:29.996    NNTestScript (#NQ100,H1)        Inputs 6 Weights 6
NQ      0       10:10:29.996    NNTestScript (#NQ100,H1)        0.76671 0.86228 0.85694 0.93819 0.86135 0.88409
QM      0       10:10:29.996    NNTestScript (#NQ100,H1)        0.278 0.401 0.574 0.301 0.256 0.870
RD      0       10:10:29.996    NNTestScript (#NQ100,H1)        Arr size A 6
NO      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 0.21285 X A[0] = 0.767 B[0] = 0.278
QK      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 0.55894 X A[1] = 0.862 B[1] = 0.401
CG      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 1.05080 X A[2] = 0.857 B[2] = 0.574
DS      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 1.33314 X A[3] = 0.938 B[3] = 0.301
HO      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 1.55394 X A[4] = 0.861 B[4] = 0.256
CJ      0       10:10:29.996    NNTestScript (#NQ100,H1)        AxBMatrix[0] = 2.32266 X A[5] = 0.884 B[5] = 0.870
HF      0       10:10:29.996    NNTestScript (#NQ100,H1)        before rows 1 cols 1
LR      0       10:10:29.996    NNTestScript (#NQ100,H1)        IxWMatrix
NS      0       10:10:29.996    NNTestScript (#NQ100,H1)        Matrix
DF      0       10:10:29.996    NNTestScript (#NQ100,H1)        [ 
NN      0       10:10:29.996    NNTestScript (#NQ100,H1)        2.32266
DJ      0       10:10:29.996    NNTestScript (#NQ100,H1)        ] 
GM      0       10:10:29.996    NNTestScript (#NQ100,H1)        rows = 1 cols = 1

我来可视化网络,如此我们便可看到第一层上已完成的工作,其余的只是迭代完全相同的过程。

矩阵乘法已经能够精确地将第一层的权重乘以输入,如同它应该做的那样,但是,编码逻辑并不像听起来那么简单,事情可能会变得有点混乱,参阅下面的代码。 忽略其余代码,只需关注 MatrixMultiply 函数。

void   CNeuralNets::FeedForwardMLP(
                    double &MLPInputs[],
                    double &MLPOutput[])
 {    
//---

    m_hiddenLayers = m_hiddenLayers+1;
    
    ArrayResize(m_hiddenLayerNodes,m_hiddenLayers);    
    m_hiddenLayerNodes[m_hiddenLayers-1] = m_outputLayers;
         
    int HLnodes = ArraySize(MLPInputs); 
    int weight_start = 0;
    
    double Weights[], bias[];
    ArrayResize(bias,m_hiddenLayers);
    
//---
    
    int inputs=ArraySize(MLPInputs);
    int w_size = 0; //size of weights

    int cols = inputs, rows=1;
    
    double IxWMatrix[]; //dot product matrix 
    
    //Generate random bias
    for(int i=0; i 
  

网络上输入层中的最先一个转化为一个 1xn 矩阵,意味着它是 1 行,但列数未知 (n)。 我们在这一行上的 “for” 循环之前,在外部初始化这个逻辑

  int cols = inputs, rows=1;

为了获得完成乘法过程所需的总权重数,我们将输入层/上一层的数量乘以输出/下一层的数量,在这种情况下,我们在第一个隐藏层中有 2 个输入和 4 个节点,所以最后我们需要 2x4 = 8,八(8)个权重值。 更重要的技巧全可在这里找到:

 MatrixMultiply(MLPInputs,L_weights,IxWMatrix,cols,cols,rows,cols);

为了很更好地理解这一点,我们看看矩阵乘法的作用:

void MatrixMultiply(double &A[],double &B[],double &AxBMatrix[], int colsA,int rowsB,int &new_rows,int &new_cols)

最后一个输入new_rowsnew_cols 为新矩阵的行和列择选新的更新值,然后这些值在下一个矩阵里重用作行数和列数。 还记得,下一层的输入是上一层的输出吗?

这对于矩阵更为重要,因为

  • 在第一层输入矩阵中是 1x2 权重矩阵 = 2x4 : 输出矩阵 = 1x4
  • 在第二层输入矩阵 1x4 权重矩阵 = 4x6 : 输出矩阵 = 1x6
  • 第三层输入 1x6 权重矩阵 6x1 输出矩阵 = 1x1

我们知道,矩阵相乘,第一个矩阵中的列数必须等于第二个矩阵中的行数。 结果矩阵的维度则是第一个矩阵的行数,和第二个矩阵的列数。

自上述操作

最先的第一个输入是具有已知维度的输入,但权重矩阵有 8 个元素,这些元素是通过将输入和隐藏层中的节点数相乘得来的,故此我们最终可以得出结论,它的行数等于前一层/输入中的列数,仅此而已。 将 new rows 和 new columns 的值修改为旧有数值的过程,会令此逻辑成为可能(内部矩阵相乘函数)

 new_rows = rowsA;  new_cols = colsB;

有关矩阵的更多信息,请尝试标准库里的矩阵部分,或您也许想尝试本文末尾链接的函数库中所用的其它不同之处。

现在我们拥有了一个灵活的架构,我们看看如何训练这个前馈 MLP 网络,以及训练和测试的可能样子。

涉及的过程

  1. 我们训练网络 x 个世代,来查找误差最小的模型。
  2. 我们把模型的参数存储在二进制文件中,这样我们就可在其它程序中读取该文件,例如在智能系统当中。

稍等一下,我刚才是说我们查找误差最少的模型吗?好吧,我们没有,这只是前馈。

MQL5.社区中的一些人更喜欢在输入上采用这些参数来优化 EA,这确实有效,但在其中,我们只生成一次权重和乖离,并在其余的世代中用到它们,就像我们在反向传播中所做的那样,但这里唯一的事情是,一旦设置了这些值,我们就不能更新它们, 它们不可更新 -- 周期。

采用默认世代数,其设置为 1(一)。

void CNeuralNets::train_feedforwardMLP(double &XMatrix[],int epochs=1)

您可以找到一种方式来修改代码,并将权重置于脚本的输入上,您可以从那里将世代数设置为任何值,当然您也不必仅限于这种方式。 顺便说一下,这只是一个演示。 


在从未见过的数据上测试或使用模型

为了能够使用训练过的模型,我们还需要能够与其它程序共享它的参数,这可以利用文件来实现,因为我们的模型参数是数组中的双精度值,故此二进制文件是我们需要的,我们从二进制文件里读取我们存储的权重和乖离,并将它们转存在各自的数组中备用。

好的,这里是负责训练神经网络的函数。

void CNeuralNets::train_feedforwardMLP(double &XMatrix[],int epochs=1)
   {         
      double MLPInputs[]; ArrayResize(MLPInputs,m_inputs);
      double MLPOutputs[]; ArrayResize(MLPOutputs,m_outputLayers);
      
      double Weights[], bias[];
      
      setmodelParams(Weights,bias); //Generating random weights and bias
      
      for (int i=0; i>>",j+1);
                 ArrayCopy(MLPInputs,XMatrix,0,start,m_inputs);
             
                 FeedForwardMLP(MLPInputs,MLPOutputs,Weights,bias);
             
                 start+=m_inputs;
               }
         }
       
       WriteBin(Weights,bias);
   }

函数 setmodelParams() 是一个生成随机权重和乖离值的函数。 训练模型之后,我们得到权重和乖离值,然后将它们存储在二进制文件当中。

WriteBin(Weights,bias);

为了演示 MLP 中的一切都是如何操作的,我们将用此处找到的真实示例数据集。

参数 XMatrix[] 是我们训练模型时打算用到的所有输入值的矩阵,在这种情况下,我们需要将 CSV 文件导入矩阵。


我们导入数据集

好吧,我帮您做到了。

     double XMatrix[]; int rows,cols;
     
     CSVToMatrix(XMatrix,rows,cols,"NASDAQ_DATA.csv");
     MatrixPrint(XMatrix,cols,3);

上述代码片段的输出:

MN      0       12:02:13.339    NNTestScript (#NQ100,H1)        Matrix
MI      0       12:02:13.340    NNTestScript (#NQ100,H1)        [ 
MJ      0       12:02:13.340    NNTestScript (#NQ100,H1)         4173.800 13067.500 13386.600    34.800
RD      0       12:02:13.340    NNTestScript (#NQ100,H1)         4179.200 13094.800 13396.700    36.600
JQ      0       12:02:13.340    NNTestScript (#NQ100,H1)         4182.700 13108.000 13406.600    37.500
FK      0       12:02:13.340    NNTestScript (#NQ100,H1)         4185.800 13104.300 13416.800    37.100
.....
.....
.....
DK      0       12:02:13.353    NNTestScript (#NQ100,H1)         4332.700 14090.200 14224.600    43.700
GD      0       12:02:13.353    NNTestScript (#NQ100,H1)         4352.500 14162.000 14225.000    47.300
IN      0       12:02:13.353    NNTestScript (#NQ100,H1)         4401.900 14310.300 14226.200    56.100
DK      0       12:02:13.353    NNTestScript (#NQ100,H1)         4405.200 14312.700 14224.500    56.200
EE      0       12:02:13.353    NNTestScript (#NQ100,H1)         4415.800 14370.400 14223.200    60.000
OS      0       12:02:13.353    NNTestScript (#NQ100,H1)        ] 
IE      0       12:02:13.353    NNTestScript (#NQ100,H1)        rows = 744 cols = 4

现在整个 CSV 文件都被转存到 XMatrix[] 中。 干杯!

这个结果矩阵的好处在于您不必再担心神经网络的输入,因为变量 cols 从 Csv 文件中获取列数。 这些将成为神经网络的输入。 那么最后,这是整个脚本的样子:

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+

#include "NeuralNets.mqh";
CNeuralNets *neuralnet; 

//+------------------------------------------------------------------+
void OnStart()
  {
     
     int hlnodes[3] = {4,6,1};
     int outputs = 1;
     int inputs_=2;
     
     double XMatrix[]; int rows,cols;
     
     CSVToMatrix(XMatrix,rows,cols,"NASDAQ_DATA.csv");
     MatrixPrint(XMatrix,cols,3);
     
     neuralnet = new CNeuralNets(SIGMOID,RELU,cols,hlnodes,outputs);     
     
     neuralnet.train_feedforwardMLP(XMatrix);
     
     delete(neuralnet);
    
  }

简单吧? 但我们仍然需要修复几行代码,在 train_feedforwardMLP 内部,我们在单次世代迭代中添加整个数据集的迭代,这是为了完整地表示一个世代的含义。

       for (int i=0; i>>",j+1);
                 ArrayCopy(MLPInputs,XMatrix,0,start,m_inputs);
             
                 FeedForwardMLP(MLPInputs,MLPOutputs,Weights,bias);
             
                 start+=m_inputs;
               }
         }

现在我们看看在调试模式下运行此程序时的日志。

bool m_debug = true; 

调试模式也许会塞满您的硬盘空间,除非您正在调试神经网络,最好将其设置为 false;我运行过一次程序,我的日志占用了多达 21Mb 的空间。

两次迭代的简要概览:

MR      0       12:23:16.485    NNTestScript (#NQ100,H1)        <<<< 1 >>>
DE      0       12:23:16.485    NNTestScript (#NQ100,H1)        Hidden layer nodes plus the output
FS      0       12:23:16.485    NNTestScript (#NQ100,H1)        4 6 1 1
KK      0       12:23:16.485    NNTestScript (#NQ100,H1)        Hidden Layer 1 | Nodes 4 | Bias 0.3903
IN      0       12:23:16.485    NNTestScript (#NQ100,H1)        Inputs 4 Weights 16
MJ      0       12:23:16.485    NNTestScript (#NQ100,H1)         4173.80000 13067.50000 13386.60000    34.80000
DF      0       12:23:16.485    NNTestScript (#NQ100,H1)        0.060 0.549 0.797 0.670 0.420 0.914 0.146 0.968 0.464 0.031 0.855 0.240 0.717 0.288 0.372 0.805
....
PD      0       12:23:16.485    NNTestScript (#NQ100,H1)        MLP Final Output
LM      0       12:23:16.485    NNTestScript (#NQ100,H1)        1.333
HP      0       12:23:16.485    NNTestScript (#NQ100,H1)        <<<< 2 >>>
PG      0       12:23:16.485    NNTestScript (#NQ100,H1)        Hidden layer nodes plus the output
JR      0       12:23:16.485    NNTestScript (#NQ100,H1)        4 6 1 1
OH      0       12:23:16.485    NNTestScript (#NQ100,H1)        Hidden Layer 1 | Nodes 4 | Bias 0.3903
EI      0       12:23:16.485    NNTestScript (#NQ100,H1)        Inputs 4 Weights 16
FM      0       12:23:16.485    NNTestScript (#NQ100,H1)         4179.20000 13094.80000 13396.70000    36.60000
II      0       12:23:16.486    NNTestScript (#NQ100,H1)        0.060 0.549 0.797 0.670 0.420 0.914 0.146 0.968 0.464 0.031 0.855 0.240 0.717 0.288 0.372 0.805
GJ      0       12:23:16.486    NNTestScript (#NQ100,H1)        

一切都已设置完毕,并按预期运行良好。 现在,我们将模型参数存储在二进制文件之中。

模型参数存储在二进制文件之中

bool CNeuralNets::WriteBin(double &w[], double &b[])
 {
      string file_name_w = NULL, file_name_b=  NULL;
      int handle_w, handle_b;
      
      file_name_w = MQLInfoString(MQL_PROGRAM_NAME)+"\\"+"model_w.bin";
      file_name_b =  MQLInfoString(MQL_PROGRAM_NAME)+"\\"+"model_b.bin"; 
      
      FileDelete(file_name_w); FileDelete(file_name_b);
      
       handle_w = FileOpen(file_name_w,FILE_WRITE|FILE_BIN);       
       if (handle_w == INVALID_HANDLE)   {  printf("Invalid %s Handle err %d",file_name_w,GetLastError());  }
       else                                 FileWriteArray(handle_w,w);
      
       FileClose(handle_w);    
       
       handle_b = FileOpen(file_name_b,FILE_WRITE|FILE_BIN);
       if (handle_b == INVALID_HANDLE)   {  printf("Invalid %s Handle err %d",file_name_b,GetLastError());  }
       else                                 FileWriteArray(handle_b,b);
     
       FileClose(handle_b);
     
     return(true);
 }


这一步超级重要。 如前所述,它有助于与其它采用同一函数库的程序共享模型参数。 二进制文件将保存在以您的脚本文件名命名的子目录当中:

有关如何在其它程序中访问模型参数的示例:

     double weights[], bias[];
     
     int handlew = FileOpen("NNTestScript\\model_w.bin",FILE_READ|FILE_BIN);
     FileReadArray(handlew,weights);
     FileClose(handlew);
     
     int handleb = FileOpen("NNTestScript\\model_b.bin",FILE_READ|FILE_BIN);
     FileReadArray(handleb,bias);
     FileClose(handleb);
     
     Print("bias"); ArrayPrint(bias,4);
     Print("Weights"); ArrayPrint(weights,4);

输出:

HR      0       14:14:02.380    NNTestScript (#NQ100,H1)        bias
DG      0       14:14:02.385    NNTestScript (#NQ100,H1)        0.0063 0.2737 0.9216 0.4435
OQ      0       14:14:02.385    NNTestScript (#NQ100,H1)        Weights
GG      0       14:14:02.385    NNTestScript (#NQ100,H1)        [ 0] 0.5338 0.6378 0.6710 0.6256 0.8313 0.8093 0.1779 0.4027 0.5229 0.9181 0.5449 0.4888 0.9003 0.2870 0.7107 0.8477
NJ      0       14:14:02.385    NNTestScript (#NQ100,H1)        [16] 0.2328 0.1257 0.4917 0.1930 0.3924 0.2824 0.4536 0.9975 0.9484 0.5822 0.0198 0.7951 0.3904 0.7858 0.7213 0.0529
EN      0       14:14:02.385    NNTestScript (#NQ100,H1)        [32] 0.6332 0.6975 0.9969 0.3987 0.4623 0.4558 0.4474 0.4821 0.0742 0.5364 0.9512 0.2517 0.3690 0.4989 0.5482

太棒了,您现在可以从任何地方访问该文件,只要您知道名称,以及在哪里可以找到它们。
 

使用模型

这是最容易的部分。 前馈 MLP 函数已修改,添加了新的权重和乖离输入,这将有助于运行模型,从而获取最近的价格数据,或其它什么东西。

void   CNeuralNets::FeedForwardMLP(double &MLPInputs[],double &MLPOutput[],double &Weights[], double &bias[])

有关如何提取权重和乖离,并实时使用模型的完整代码。 首先我们读取参数,然后插入输入值,而非输入矩阵,因为这次我们用经过训练的模型来预测输入值的结果。 MLPOutput[] 为您提供输出数组:

     double weights[], bias[];
     
     int handlew = FileOpen("NNTestScript\\model_w.bin",FILE_READ|FILE_BIN);
     FileReadArray(handlew,weights);
     FileClose(handlew);
     
     int handleb = FileOpen("NNTestScript\\model_b.bin",FILE_READ|FILE_BIN);
     FileReadArray(handleb,bias);
     FileClose(handleb);
     
     double Inputs[]; ArrayCopy(Inputs,XMatrix,0,0,cols); //copy the four first columns from this matrix
     double Output[];
     
     neuralnet = new CNeuralNets(SIGMOID,RELU,cols,hlnodes,outputs);     
     
     neuralnet.FeedForwardMLP(Inputs,Output,weights,bias);
     
     Print("Outputs");
     ArrayPrint(Output);
     
     delete(neuralnet);

理应工作正常。

现在,您可以随意探索各种架构,并探索不同的选项,看看什么最适合您。

你可能感兴趣的:(python,深度学习,开发语言,神经网络,人工智能)