在算法交易中 Kohonen 神经网络的实际应用。 第 I 部分 工具

Stanislav Korotky | 18 二月, 2019

在 mql5.com 网站上有一些探讨 Kohonen 神经网络主题的文章，例如 在 MetaTrader 5 中使用自组织特征映像（Kohonen 映像） 和 自组织特征映射（Kohonen 映像）- 重访主题。 它们向读者介绍了构建此类神经网络的一般原则，并运用这些映像直观地分析众多财经市场。

然而，实际上，用于算法交易的 Kohonen 网络仅限于一种方法，亦即如同 EA 优化结果所构建的拓扑映像的直观分析。 在此情况下，某个人的价值判断，或者更确切地说，某个人从一张图片中得出合理结论的眼光和能力，或许是关键因素，有关表述数据的附带网络属性，就像螺栓和螺栓问题。

换言之，神经网络算法的特征并未完全使用，即，它们在使用时不会自动提取知识或支持特别推荐的决策。 在本文中，我们所研究的问题是遵照更加正规的方式定义机器人的最佳参数集合。 此外，我们会应用 Kohonen 网络来预测财经范围。 但是，在继续处理这些已有问题之前，我们应该修改现有的源代码，修复一些内容，并进行一些改进。

如果您不熟悉“网络”，“层”，“神经元”（“节点”），“链接”，“权重”，“学习率”，“学习范围”等术语，以及与 Kohonen 网络相关的其他概念，那么强烈建议您首先阅读上述文章。 我们应在这个问题上自我充实，因为若是重新教授这些基本概念会显著令发表文章冗长。

修正错误

我们将调用在上述文章中前面部分发表的 CSOM 和 CSOMNode 类，并着眼于后者的补充。 其中的关键代码片段实际上是相同的，且继承了相同的问题。

首先，应当注意的是，出于某种原因，上述类中的神经元已进行索引，即通过像素坐标作为构造函数参数来识别和定义。 这不太合乎逻辑，并且在某些方面令计算和调试复杂化。 特别是在此方法下，表述设定会影响计算。 试想一下：有两个完全相似的网络，其格子大小相同，它们正在使用相同的数据集，相同的设定和随机数据生成器初始化进行学习。 然而，获得的结果是不同的，恰恰是因为一个网络的图像大于另一个网络。 这是个错误。

我们将通过数字来检索神经元：在数组 m_node（CSOM 类）中的每个神经元，其坐标 x 和 y 分别对应于 Kohonen 网络输出层中的列号和行号。 每个神经元将采用 CSOMNode::InitNode(x, y) 方法替代 CSOMNode::InitNode(x1, y1, x2, y2) 方法进行初始化。 当我们进行可视化时，以像素为单位更改映像大小，神经元坐标将保持不变。

在继承的源代码中，未使用输入数据常规化。 不过，在输入矢量的不同分量（特征）有不同数值范围的情况下，它会非常重要。 这是 EA 的优化结果，并汇集不同指标数据的情况。 至于优化结果，我们可以看到，有数十万的总利润其数值较小，例如锋锐比率的分数，或恢复因子的一位数值。

您不应该使用这种不同规模的数据来教育 Kohonen 网络，因为网络实际上只考虑较大的分量而忽略较小的分量。 您可以在下面的图像中看到这一点，此图利用我们在本文中逐步深入研究的程序获得，该程序附加在文章末尾。 该程序允许生成随机输入矢量，其中三个分量分别定义在 [0, 1000]，[0,1] 和 [-1, +1] 范围内。 特殊输入 UseNormalization 允许启用/禁用常规化。

我们来看看 Kohonen 网络的最终结构，它处在与矢量三维相关的三个平面上。 首先，网络学习结果未经常规化。

Kohonen 网络学习结果未经输入常规化

现在，同例经过常规化。

Kohonen 网络输入常规化的学习结果

神经元权重适应程度与颜色梯度成比例。 显然，在非常规化条件下，网络仅在第一平面中学习拓扑分区（分类），而第二和第三分量则被微小噪音充满。 也就是说，网络的分析能力已经实现了三分之一。 启用常规化后，空间排列在所有三个平面中都可见。

许多常规化方法是已知的，但最常用的一种，可能是从每个分量中减去整个选择的平均值，然后将其除以标准偏差，即西格玛或均方根。 这会将变换数据的平均值设置为零，标准偏差设置为一体。

 (1)

更新后的 CSOM 类，方法 Normalize 中采用了此技术。 很明显，您应该首先计算输入数据集的每个分量的平均值和西格玛值，这在方法 InitNormalization 中完成（见下文）。

通过两次运行算法计算平均值和标准偏差的典型公式：应首先找到平均值，然后将其用于计算西格玛值。

                             (2)

     (3)

在我们的源代码中，我们的单次运行算法基于以下公式：

 (4)

显然，入口处的常规化需要一个逆反操作 — 逆常规化 — 在出口处，即，将网络的输出值变换到实际数值的范围。 这是通过方法 CSOM::Denormalize 完成的。

由于常规化的数值在零附近对称下降，我们将在开始教育网络之前改变神经元权重的初始化原则 — 替代范围 [0, 1]，现在是范围 [-1, +1]（参见方法 CSOMNode::InitNode）。 这将提高网络学习的效率。

另一个要修正的方面是学习迭代的计次。 在源类中，迭代应理解为给网络指定每次单独的输入矢量。 因此，应依据教育选择的规模来修正迭代次数。 回想一下，Kohonen 网络学习和信息融合原则假设每个样本都会指定给网络很多次。 例如，如果选择中有 100 个入口，那么迭代次数若要等于 10000 则必须每个入口平均指定 100 次。 但是，如果选择生成 1000 个入口，则迭代次数必须为变 100000。 更便利和传统的方法是定义所谓的“学习时期”的次数，即，所有样本被随机地投喂到网络的每个周期中。 次数将在参数 EpochNumber 中设置。 由于引入它，学习持续时间在参数上与数据集的大小分离。

这一点尤为重要，因为总输入集可以分为两个部分：教育的选择，和所谓的验证选择。 后者用于跟踪网络学习质量。 问题在于教育期间，令网络适配输入有一个“翻面”：网络开始适配特定样本的特征，这样做，丧失了对未知数据进行概括和充分处理的能力（除了用于教育）。 归根结底，学习的理念通常是为了在未来利用网络检测特征的能力。

在所研究的程序中，输入参数 ValidationSetPercent 负责启用验证。 默认情况下，它等于 0，并且所有数据都用于学习。 如果我们指定为 10，那么只有 90％ 的样本用于学习，而对于剩余的 10％，在每次迭代（时期）上计算常规化均方差，并且在误差开始增长的时刻，停止学习过程 。

 (5)

常规化包括将均方差除以数据本身的离散度，这导致索引始终低于 1。 当分别考虑每个矢量时，这个均方差实际上是量化误差，因为它是基于其分量和相关神经元突触的权重之间的差值，在所有神经元中给出了这个矢量的最佳近似值。 我们应该记得，这个获胜神经元在 Kohonen 网络中被称为 BMU（最佳匹配单元）或 BMN（最佳匹配节点）— 在 CSOM 类中，GetBestMatchingNode 方法和类似技术负责搜索它。

启用验证后，迭代次数将超过参数 EpochNumber中 指定的次数。 由于 Kohonen 网络架构的特性，只有在网络通过了 EpochNumber 时期上的自组织阶段后，才能执行验证。 在该阶段完成时，学习速率和范围显著降低，以至开始权重的微调，然后收敛阶段开始。 在这里，使用验证集来进行学习的“早期停止”。

是否使用验证取决于问题的特殊性。 此外，验证集可用于匹配网络规模。 出于本文的目的，我们不打算讨论这个问题。 我们只是运用著名的经验规则，将网络规模与教育数据的次数联系起来：

N ~ 5 * sqrt(M)          (6)

其中 N 是网络中神经元的数量，M 是输入矢量的数量。 对于具有正方形输出层的 Kohonen 网络，我们得到大小：

S = sqrt(5 * sqrt(M))  (7)

其中 S 是垂直和水平的神经元数量。 我们将这个数值引入参数 CellsX 和 CellsY。

原始源代码中要修正的最后一个问题与处理六边形网格有关。 已知 Kohonen 映像由矩形或六边形的细胞（神经元）布局来构建，并且在源代码中两种模式最初都已实现。 然而，六边形网格仅显示为六边形细胞，但计算时则完全作为矩形网格。 若要在此处找到误差的根源，我们来研究下面的示意图。

神经元邻域几何：矩形和六边形网格

此处展示了两个几何网格的随机神经元围绕逻辑（在本例中，坐标为 3;3）。 围绕半径为 1。 在正方形网格中，神经元有 4 个直接邻域，而在六边形网格中有 6 个。 把每个细胞外围交替移动半个细胞来实现细化外观。 不过，这并没有改变它们的内部坐标，并且就算法而言，六边形网格中围绕的神经元像以前一样显现 — 它以粉红色标记。

显然，这是错误的，应该通过包含以黄色高亮显示的神经元来修正。

从形式上讲，该算法是根据细胞坐标之间的距离，利用相邻邻域和作为凸减径向函数来计算周边的。 换言之，邻域不是神经元的二元属性（相邻与否），而是由高斯公式计算的连续数量：

 (8)

此处，d ji 是神经元 j 和 i 之间的距离（连续编号是均值，而非坐标 x 和 y）; 且西格玛值是邻域的有效宽度或学习期间逐渐递减的学习半径。 在学习开始时，用对称的“钟”覆盖邻域会比紧密相邻的神经元拥有更大的空间。

由于这个公式取决于距离，它也会扭曲邻域，这是因坐标没有被正确修正。 所以，以下源代码来自 CSOM::Train 方法：

      for(int i = 0; i < total_nodes; i++)
      {
         double DistToNodeSqr = (m_som_nodes[winningnode].X() - m_som_nodes[i].X()) * (m_som_nodes[winningnode].X() - m_som_nodes[i].X())
                              + (m_som_nodes[winningnode].Y() - m_som_nodes[i].Y()) * (m_som_nodes[winningnode].Y() - m_som_nodes[i].Y());

已得到补充：

      bool odd = ((winningnode % m_ycells) % 2) == 1;
      for(int i = 0; i < total_nodes; i++)
      {
        bool odd_i = ((i % m_ycells) % 2) == 1;
        double shiftx = 0;

        if(m_hexCells && odd != odd_i)
        {
          if(odd && !odd_i)
          {
            shiftx = +0.5;
          }
          else // 反之亦然 (!odd && odd_i)
          {
            shiftx = -0.5;
          }
        }
        double DistToNodeSqr = (m_node[winningnode].GetX() - (m_node[i].GetX() + shiftx)) * (m_node[winningnode].GetX() - (m_node[i].GetX() + shiftx))
                             + (m_node[winningnode].GetY() - m_node[i].GetY()) * (m_node[winningnode].GetY() - m_node[i].GetY());

修正 'shiftx' 的方向取决于两个神经元的所在行为偶数或奇数的比率，在这两个神经元之间计算距离。 如果神经元处于同等水平的行中，则无需修正。 如果获胜的神经元处于奇数行，那么偶数行看起来从它向右移动半个细胞，因此，shiftx 等于 +0.5。 如果获胜的神经元处于偶数行，则奇数行显示为向左移动半个细胞，因此，shiftx 等于 -0.5。

现在，尤为重要的是注意以下原始字符串：

        if(DistToNodeSqr < WS)
        {
          double influence = MathExp(-DistToNodeSqr / (2 * WS));
          m_node[i].AdjustWeights(data, learning_rate, influence);
        }

事实上，这个条件运算符可以确保计算得到一些加速，因为忽略了一个超出西格玛邻域的神经元。 然而，就学习质量而言，高斯公式是理想的，并且这种干预是不合理的。 如果太远的神经元应该被忽略，那么应该是三个西格玛，而不仅仅是一个。 在我们修正了六边形网格的计算之后，更为关键的是，由于位于相邻行中的相邻神经元之间的距离等于 sqrt(1*1 + 0.5*0.5) = 1.118，即高于 1。 在附带的源代码中，此条件运算符被加以注释。 如果您确实需要加速计算，请使用选项：

        if(DistToNodeSqr < 9 * WS)

可视化

尽管 Kohonen 网络主要与可视图形映像相关联，但它们的拓扑和学习算法可以在没有任何用户界面的情况下完美地工作。 特别是，预测或压缩信息的问题无须任何可视分析，并且图像的分类可以将结果作为数字传递，即， 一个类的编号或一个事件的概率。 因此，Kohonen 网络的功能分为两个类。 在 CSOM 类中，仅保留了计算，数据加载和存储以及网络加载和存储。 除此之外，还创建了 CSOMDisplay 的派生类，其中放置了所有图形。 在我看来，这是个比第 2 篇文献中提议的更简单、更合理的层次结构。 将来，我们将使用 CSOMDisplay 来解决选择最佳 EA 参数的问题，而 CSOM 将用于预测。

应该注意的是网格类型的特征，即 ，无论是矩形还是六边形，都属于基本类，因为它影响距离的计算。 除了垂直和水平方向上的节点数量，以及数据输入空间的维度外，网格类型是体系结构的一部分，应保存在文件中。 从文件加载网络时，应从文件里读取所有这些参数，而非从程序设置中读取。 其他设置仅影响视觉呈现，诸如以像素为单位的映像大小，显示细胞边界或显示字幕，不会保存在网络文件中，并且一旦网络教育之后，可重复和随机更改。

应该注意的是，未更新的类不会呈现带控件的图形用户界面 — 所有设置都是通过 MQL 程序的输入来指定。 与此同时，CSOMDisplay 类仍然实现了一些有用的功能。

回想一下，前面如何使用 Kohonen 网络的示例中，有一个名为 MaxPictures 的输入。 它在新的实现里依然存在。 它作为 maxpict 传递给方法 CSOMDisplay::Init，并设置图表中一行内显示的网络映像（平面）的数量。 将此参数与整体图像大小的 ImageW 和 ImageH 一起处理，我们可以找到一个选项，令所有映像都适合屏幕。 但是，当有许多映像时，譬如您必须分析 EA 的许多设置，其规模需要大幅降低，而这很不方便。 在这种情况下，您可以将参数 MaxPictures 设置为 0 来激活新模式。

在此模式下，在图表上所生成映像不是以像素坐标对齐的对象 OBJ_BITMAP_LABEL，而是与时间刻度对齐的对象 OBJ_BITMAP。 此类映像的大小可以增加，直到占满图表的整个高度，您可以使用常用的水平滚动条滚动它们，方法是用鼠标或滚轮或使用键盘拖拽它们。 映像数量不再限于屏幕尺寸。 然而，您应该确保柱线数量足够。

增加映像大小令我们更详尽地研究它们，尤其是类 CSOMDisplay 在细胞内可选择显示各种信息，例如相关平面的突触权重值，教育集矢量的命中数，平均值和命中细胞的所有矢量的相关特征值的离散度。 默认情况下不显示此信息，但如果您将鼠标光标停放在一个或另一个细胞上，则始终会弹出提示显示此信息。 弹出提示中还会显示当前平面的名称和神经元坐标。

此外，在任意神经元上双击将在当前映像和所有其他映像中同时高亮显示互补色的神经元。 这令我们可以同时直观比较所有特征的神经元活动。

最后，应当注意的是整个图形已经移到标准类 CCanvas 之中。 这会精简外部依赖的代码，但它也有副作用：Y 坐标现在按照自上而下的方式计数，而不像以前那样自下而上。 这导致在映像上方显示包含分量名称及其数值范围的图例，而非在其下方。 只是，这种变化似乎无关紧要。

改进

在我们处理已有问题之前，需要对神经网络类进行一些改进。 除了表示特定特征的 2D 空间中的突触权重的标准映像之外，我们还将准备一些服务映像的计算和显示，这些服务映射是 Kohonen 网络的事实标准。 展望未来，我们会说在应用实验阶段，我们需要它们当中的中许多。

我们来定义附加维度的索引，总共会有 5 个。

#define EXTRA_DIMENSIONS 5
#define DIM_HITCOUNT (m_dimension + 0)
#define DIM_UMATRIX  (m_dimension + 1)
#define DIM_NODEMSE  (m_dimension + 2) // 每个节点的量化误差：平均方差（标准差的平方）
#define DIM_CLUSTERS (m_dimension + 3)
#define DIM_OUTPUT   (m_dimension + 4)

U 型矩阵

首先，我们将计算 U 型矩阵，一个统一的距离矩阵，以便评估学习过程中在网络内产生的拓扑。 对于网络中的每个神经元，该矩阵包含该神经元与其直接相邻神经元之间的平均距离。 由于 Kohonen 网络将特征的多维空间显示在映像的二维空间中。 折叠发生在这个二维空间中。 换言之，尽管 Kohonen 网络的特性是保持初始空间固有的排列，但它在整个 2D 空间中同样无法实现，并且神经元的地理接近度变得虚幻。 恰好 U 型矩阵用于检测这些区域。 其中，神经元权重与其相邻神经元权重之间存在较大差值的区域显示为“峰值”，而神经元非常相似的区域则显示为“洼地”。

若要计算神经元和特征矢量之间的距离，则有 CSOMNode::CalculateDistance 方法。 我们将为它创建一个对应的方法，它将指针指向另一个神经元而来替代向量（数组 'double'）。

double CSOMNode::CalculateDistance(const CSOMNode *other) const
{
  double vector[];
  other.GetCodeVector(vector);
  return CalculateDistance(vector);
}

此处，方法 GetCodeVector 获取另一个神经元的权重数组，并立即将其按照常规方式计算距离。

为了获得统一的神经元距离，有必要计算到其所有相邻神经元的距离并求它们的平均值。 由于相邻神经元的遍历是网络网格的若干操作的常见任务，我们将为遍历创建一个基类，然后在其后代中实现单独算法，包括汇总距离。

#define NBH_SQUARE_SIZE    4
#define NBH_HEXAGONAL_SIZE 6

template<typename T>
class Neighbourhood
{
  protected:
    int neighbours[];
    int nbhsize;
    bool hex;
    int m_ycells;

  public:
    Neighbourhood(const bool _hex, const int ysize)
    {
      hex = _hex;
      m_ycells = ysize;

      if(hex)
      {
        nbhsize = NBH_HEXAGONAL_SIZE;
        ArrayResize(neighbours, NBH_HEXAGONAL_SIZE);
        neighbours[0] = -1; // 上 (可视)
        neighbours[1] = +1; // 下 (可视)
        neighbours[2] = -m_ycells; // 左
        neighbours[3] = +m_ycells; // 右
        /* 模板，在下面的循环中动态应用
        // 奇数行
        neighbours[4] = -m_ycells - 1; // 左上
        neighbours[5] = -m_ycells + 1; // 左下
        // 偶数行
        neighbours[4] = +m_ycells - 1; // 右上
        neighbours[5] = +m_ycells + 1; // 右下
        */
      }
      else
      {
        nbhsize = NBH_SQUARE_SIZE;
        ArrayResize(neighbours, NBH_SQUARE_SIZE);
        neighbours[0] = -1; // 上 (可视)
        neighbours[1] = +1; // 下 (可视)
        neighbours[2] = -m_ycells; // 左
        neighbours[3] = +m_ycells; // 右
      }
    
    }
    ~Neighbourhood()
    {
      ArrayResize(neighbours, 0);
    }

    T loop(const int ind, const CSOMNode &p_node[])
    {
      int nodes = ArraySize(p_node);
      int j = ind % m_ycells;
      
      if(hex)
      {
        int oddy = ((j % 2) == 1) ? -1 : +1;
        neighbours[4] = oddy * m_ycells - 1;
        neighbours[5] = oddy * m_ycells + 1;
      }
      
      reset();

      for(int k = 0; k < nbhsize; k++)
      {
        if(ind + neighbours[k] >= 0 && ind + neighbours[k] < nodes)
        {
          // 跳过包边
          if(j == 0) // 顶行
          {
            if(k == 0 || k == 4) continue;
          }
          else if(j == m_ycells - 1) // 底行
          {
            if(k == 1 || k == 5) continue;
          }
          
          iterate(p_node[ind], p_node[ind + neighbours[k]]);
        }
      }
      
      return getResult();
    }
    
    virtual void reset() = 0;
    virtual void iterate(const CSOMNode &node1, const CSOMNode &node2) = 0;
    virtual T getResult() const = 0;
};

根据传递给构造函数的网格类型，邻域数量 nbhsize 等于 4 和 6。 与当前神经元相关的相邻神经元数量的增量存储在“neighbours”数组当中。 例如，在正方形网格中，从高层神经元减一层，或从底层神经元加一层来得到上一层相邻神经元。 左右相邻神经元的数字与网格的列高度不同，因此该值作为 ysize 传递给构造函数。

相邻神经元的真实遍历由方法 'loop' 执行。 类 Neighborhood 当中不包含任何神经元数组，因此它作为参数传递给方法 'loop'。

在循环中此方法跨越数组“neighbours”，并另行检查相邻神经元的数量是否超出网格，要考虑增量。 对于全部的有效数字，调用抽象方法 'iterate'，其中要传递当前神经元和围绕神经元之一的链接。

在循环之前调用抽象方法 'reset'，在循环之后调用抽象方法 getResult。 一组三个抽象方法允许在后代类中准备和执行相邻神经元的枚举并生成结果。 “loop”方法构造概念对应于已知的 OOP 设计范式 — 模板方法。 在此，我们应该将范式本名中的“模板”术语与模板的语言范式区分开来，模板的语言范式也在类 Neighbourhood 中使用，因为它是模板，即 ，它由某个变量类型 T 进行参数化。特别是，'loop' 方法本身和方法 getResult 返回T类型的值。

基于类 Neighbourhood，我们将编写一个类来计算 U 型矩阵。

class UMatrixNeighbourhood: public Neighbourhood<double>
{
  private:
    int n;
    double d;
    
  public:
    UMatrixNeighbourhood(const bool _hex, const int ysize): Neighbourhood(_hex, ysize)
    {
    }
    
    virtual void reset() override
    {
      n = 0;
      d = 0.0;
    }
    
    virtual void iterate(const CSOMNode &node1, const CSOMNode &node2) override
    {
      d += node1.CalculateDistance(&node2);
      n++;
    }
    
    virtual double getResult() const override
    {
      return d / n;
    }
};

处理类型是双精度。 通过其基类，距离的计算是相当透明的。

我们将在方法 CSOM::CalculateDistances 中计算整个映像的距离。

void CSOM::CalculateDistances()
{
  UMatrixNeighbourhood umnh(m_hexCells, m_ycells);
  
  for(int i = 0; i < m_xcells * m_ycells; i++)
  {
    double d = umnh.loop(i, m_node);
    
    if(d > m_max[DIM_UMATRIX])
    {
      m_max[DIM_UMATRIX] = d;
    }
    
    m_node[i].SetDistance(d);
  }
}

统一距离的值保存在神经元的对象中。 稍后，当显示所有平面时，我们将能够使用调色板以标准方式定义距离值，并在计算中包括附加尺寸 DIM_UMATRIX。 为了正确地缩放调色板，我们在该方法中保存了相关数组 m_max 元素范围内的最高距离值（所有实现原理与先前的实现保持不变）。

命中次数和量化误差

下一个附加维度将收集特定神经元中学习矢量命中数的统计数据。 换言之，它是所用数据填充神经元的密度。 在特定神经元中越高，其权重因子在统计上越合理。 在网络中，神经元也许发生较小甚或为零的数据覆盖。 也许会有很多，这也许说是选择网络大小或在多维空间的 2D 投影中拓扑扭曲的问题。 通过以下方法计算样品到某个神经元的命中率：

void CSOMNode::RegisterPatternHit(const double &vector[])
{
  m_hitCount++;
  double e = 0;
  for(int i = 0; i < m_dimension; i++) 
  {
    m_sum[i] += vector[i];
    m_sumP2[i] += vector[i] * vector[i];
    e += (m_weights[i] - vector[i]) * (m_weights[i] - vector[i]);
  }
  m_mse += e / m_dimension;
}

计数本身在第一个 m_hitCount++ 字符串中执行，其中内部计数器增加。 其余执行其他有用的工作的代码，将在下面讨论。

我们将自 CSOM 类完成学习之后调用方法 RegisterPatternHit，在那里我们将创建一个特殊的统计方法来处理每个矢量。

double CSOM::AddPatternStats(const double &data[])
{
  static double vector[];
  ArrayCopy(vector, data);
  
  int ind = GetBestMatchingIndex(vector);
  
  m_node[ind].RegisterPatternHit(vector);

  double code[];
  m_node[ind].GetCodeVector(code);
  Denormalize(code);
  
  double mse = 0;
  
  for(int i = 0; i < m_dimension; i++)
  {
    mse += (data[i] - code[i]) * (data[i] - code[i]);
  }
  
  mse /= m_dimension;
  
  return mse;
}

作为一个题外话，应该注意这里使用的方法 GetBestMatchingIndex，以及 GetBestMatchingXYZ 方法组中的其他一些方法，常规化了自身内部的传入数据，因此有必要传递一个矢量的副本。 否则，在调用代码中可能稀里糊涂地修改了源数据。

除了重新编码 hit 之外，该方法还计算当前神经元和所传递矢量的量化误差。 为此目的，从获胜的神经元中调用所谓的代码 vector，即 ，突触权重数组，并计算权重和输入矢量之间的分量差值的平方和。

对于 AddPatternStatsm，它立即从另一个方法 CSOM::CalculateStats 调用，它只为所有输入分配循环。

double CSOM::CalculateStats(const bool complete = true)
{
  double data[];
  ArrayResize(data, m_dimension);
  double trainedMSE = 0.0;
  
  for(int i = complete ? 0 : m_validationOffset; i < m_nSet; i++)
  {
    ArrayCopy(data, m_set, 0, m_dimension * i, m_dimension);
    trainedMSE += AddPatternStats(data, complete);
  }
  
  double nmse = trainedMSE / m_dataMSE;
  if(complete) Print("Overall NMSE=", nmse);

  return nmse;
}

该方法对所有量化误差进行求和，并将它们与输入数据的离散度 m_dataMSE 进行比较 — 这正是上述验证和学习停止章节里描述的 NMSE 计算。 该方法提到了在创建 CSOM 对象时指定的变量 m_validationOffset，此对象基于是否将输入数据集划分为学习和验证子集。

您猜对了，方法 CalculateStats 在 Train 方法内的每个时期被调用（如果收敛阶段已经开始），我们可以通过返回值判断整个网络误差是否已经开始增加，即 ，是否到了停止时刻。

预先计算离散度 m_dataMSE，使用以下方法：

void CSOM::CalculateDataMSE()
{
  double data[];

  m_dataMSE = 0.0;
  
  for(int i = m_validationOffset; i < m_nSet; i++)
  {
    ArrayCopy(data, m_set, 0, m_dimension * i, m_dimension);

    double mse = 0;
    for(int k = 0; k < m_dimension; k++)
    {
      mse += (data[k] - m_mean[k]) * (data[k] - m_mean[k]);
    }
    
    mse /= m_dimension;
    m_dataMSE += mse;
  }
}

我们已经在数据常规化阶段中获得了每个分量的平均值 m_mean。

void CSOM::InitNormalization(const bool normalization = true)
{
  ArrayResize(m_max, m_dimension + EXTRA_DIMENSIONS);
  ArrayResize(m_min, m_dimension + EXTRA_DIMENSIONS);
  ArrayInitialize(m_max, 0);
  ArrayInitialize(m_min, 0);
  ArrayResize(m_mean, m_dimension);
  ArrayResize(m_sigma, m_dimension);

  for(int j = 0; j < m_dimension; j++)
  {
    double maxv = -DBL_MAX;
    double minv = +DBL_MAX;
    
    if(normalization)
    {
      m_mean[j] = 0;
      m_sigma[j] = 0;
    }
    
    for(int i = 0; i < m_nSet; i++)
    {
      double v = m_set[m_dimension * i + j];
      if(v > maxv) maxv = v;
      if(v < minv) minv = v;
      if(normalization)
      {
        m_mean[j] += v;
        m_sigma[j] += v * v;
      }
    }
    
    m_max[j] = maxv;
    m_min[j] = minv;
    
    if(normalization && m_nSet > 0)
    {
      m_mean[j] /= m_nSet;
      m_sigma[j] = MathSqrt(m_sigma[j] / m_nSet - m_mean[j] * m_mean[j]);
    }
    else
    {
      m_mean[j] = 0;
      m_sigma[j] = 1;
    }
  }
}

转向附加平面，应该注意的是，在 CSOMNode::RegisterPatternHit 中计算后，每个神经元都能够使用以下方法返回相关的统计数据：

int CSOMNode::GetHitsCount() const
{
  return m_hitCount;
}

double CSOMNode::GetHitsMean(const int plane) const
{
  if(m_hitCount == 0) return 0;
  return m_sum[plane] / m_hitCount;
}

double CSOMNode::GetHitsDeviation(const int plane) const
{
  if(m_hitCount == 0) return 0;
  double z = m_sumP2[plane] / m_hitCount - m_sum[plane] / m_hitCount * m_sum[plane] / m_hitCount;
  if(z < 0) return 0;
  return MathSqrt(z);
}

double CSOMNode::GetMSE() const
{
  if(m_hitCount == 0) return 0;
  return m_mse / m_hitCount;
}

因此，我们得到填充两个平面的数据 — 通过神经元和量化误差显示输入矢量的数量。

网络响应

下一个附加平面将是对特定样本的礼让（yield）映像和网络响应。 应该回想一下，在向网络投喂信号时，除了获胜的神经元，所有其他神经元的激活程度都较小。 比较主动响应偏移的可能性有助于定义由网络提议的解决方案的稳定性。

网络响应计算最简单。 在 CSOMNode 类中，我们将编写以下方法：

double CSOMNode::CalculateOutput(const double &vector[])
{
  m_output = CalculateDistance(vector);
  return m_output;
}

我们将为网络类中的每个神经元调用它。

void CSOM::CalculateOutput(const double &vector[], const bool normalize = false)
{
  double temp[];
  ArrayCopy(temp, vector);
  if(normalize) Normalize(temp);
  m_min[DIM_OUTPUT] = DBL_MAX;
  m_max[DIM_OUTPUT] = -DBL_MAX;
  for(int i = 0; i < ArraySize(m_node); i++)
  {
    double x = m_node[i].CalculateOutput(temp);
    if(x < m_min[DIM_OUTPUT]) m_min[DIM_OUTPUT] = x;
    if(x > m_max[DIM_OUTPUT]) m_max[DIM_OUTPUT] = x;
  }
}

如果不能向程序提供测试矢量，则默认计算响应，即零矢量。

#include <Math/Alglib/dataanalysis.mqh>

void CSOM::Clusterize(const int clusterNumber)
{
  int count = m_xcells * m_ycells;
  CMatrixDouble xy(count, m_dimension);
  int info;
  CMatrixDouble clusters;
  int membership[];
  double weights[];
  
  for(int i = 0; i < count; i++)
  {
    m_node[i].GetCodeVector(weights);
    xy[i] = weights;
  }

  CKMeans::KMeansGenerate(xy, count, m_dimension, clusterNumber, KMEANS_RETRY_NUMBER, info, clusters, membership);
  Print("KMeans result: ", info);
  if(info == 1) // ok
  {
    for(int i = 0; i < m_xcells * m_ycells; i++)
    {
      m_node[i].SetCluster(membership[i]);
    }
    
    ArrayResize(m_clusters, clusterNumber * m_dimension);
    for(int j = 0; j < clusterNumber; j++)
    {
      for(int i = 0; i < m_dimension; i++)
      {
        m_clusters[j * m_dimension + i] = clusters[i][j];
      }
    }
  }
}

m_node[i].SetCluster(membership[i]);

double CSOMNode::GetMSE() const
{
  if(m_hitCount == 0) return 0;
  return m_mse / m_hitCount;
}

class ClusterNeighbourhood: public Neighbourhood<int>
{
  private:
    int cluster;

  public:
    ClusterNeighbourhood(const bool _hex, const int ysize): Neighbourhood(_hex, ysize)
    {
    }
    
    virtual void reset() override
    {
      cluster = -1;
    }
    
    virtual void iterate(const CSOMNode &node1, const CSOMNode &node2) override
    {
      int x = node2.GetCluster();
      if(x > -1)
      {
        if(cluster != -1) cluster = MathMin(cluster, x);
        else cluster = x;
      }
    }
    
    virtual int getResult() const override
    {
      return cluster;
    }
};

void CSOM::Clusterize()
{
  double array[][2];
  int n = m_xcells * m_ycells;
  ArrayResize(array, n);
  for(int i = 0; i < n; i++)
  {
    if(m_node[i].GetHitsCount() > 0)
    {
      array[i][0] = m_node[i].GetDistance() * MathSqrt(m_node[i].GetMSE());
    }
    else
    {
      array[i][0] = DBL_MAX;
    }
    array[i][1] = i;
    m_node[i].SetCluster(-1);
  }
  ArraySort(array);
  
  ClusterNeighbourhood clnh(m_hexCells, m_ycells);

  int count = 0; // 聚类数量
  ArrayResize(m_clusters, 0);
  
  for(int i = 0; i < n; i++)
  {
    // 如果已经分配则跳过
    if(m_node[(int)array[i][1]].GetCluster() > -1) continue;
    
    // 检查当前节点是否与任何现有聚类相邻
    int r = clnh.loop((int)array[i][1], m_node);
    if(r > -1) // 邻居已经属于聚类
    {
      m_node[(int)array[i][1]].SetCluster(r);
    }
    else // 我们需要新的聚类
    {
      ArrayResize(m_clusters, (count + 1) * m_dimension);
      
      double vector[];
      m_node[(int)array[i][1]].GetCodeVector(vector);
      ArrayCopy(m_clusters, vector, count * m_dimension, 0, m_dimension);
      
      m_node[(int)array[i][1]].SetCluster(count++);
    }
  }
}

CSOMDisplay KohonenMap;

void OnInit()
{
  ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, true);
  EventSetMillisecondTimer(1);
}

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
  KohonenMap.OnChartEvent(id, lparam, dparam, sparam);
}

void OnTimer()
{
  EventKillTimer();
  
  MathSrand(RandomSeed);
  
  bool hasOneTestPattern = false;
  
  if(NetFileName != "")
  {
    if(!KohonenMap.Load(NetFileName)) return;
    KohonenMap.DisplayInit(ImageW, ImageH, MaxPictures, ColorScheme, ShowBorders, ShowTitles);

    Comment("Map ", NetFileName, " is loaded; size: ", KohonenMap.GetWidth(), "*", KohonenMap.GetHeight(), "; features: ", KohonenMap.GetFeatureCount());

    if(DataFileName != "")
    {
      if(!KohonenMap.LoadPatterns(DataFileName))
      {
        Print("Data loading error, file: ", DataFileName);

        // 生成随机测试矢量
        int n = KohonenMap.GetFeatureCount();
        double min, max;
        double v[];
        ArrayResize(v, n);
        for(int i = 0; i < n; i++)
        {
          KohonenMap.GetFeatureBounds(i, min, max);
          v[i] = (max - min) * rand() / 32767 + min;
        }
        KohonenMap.AddPattern(v, "RANDOM");
        Print("Random Input:");
        ArrayPrint(v);
        double y[];
        CSOMNode *node = KohonenMap.GetBestMatchingFeatures(v, y);
        Print("Matched Node Output (", node.GetX(), ",", node.GetY(), "); Hits:", node.GetHitsCount(), "; Error:", node.GetMSE(),"; Cluster N", node.GetCluster(), ":");
        ArrayPrint(y);
        KohonenMap.CalculateOutput(v, true);
        hasOneTestPattern = true;
      }
    }

  }
  else // 未提供网络文件，因此假定进行训练
  {
    if(DataFileName == "")
    {
      // 生成无缩放值的 3D 演示矢量 {[0,+1000], [0,+1], [-1,+1]}
      // 将它们投喂到网络中以便比较有无常规化的结果
      // 注意 标题应该是有效的 BMP 文件名
      string titles[] = {"R1000", "R1", "R2"};
      KohonenMap.AssignFeatureTitles(titles);
      double x[3];
      for(int i = 0; i < 1000; i++)
      {
        x[0] = 1000.0 * rand() / 32767;
        x[1] = 1.0 * rand() / 32767;
        x[2] = -2.0 * rand() / 32767 + 1.0;
        KohonenMap.AddPattern(x, StringFormat("%f %f %f", x[0], x[1], x[2]));
      }
    }

    else // 提供了一个数据文件
    {
      if(!KohonenMap.LoadPatterns(DataFileName))
      {
        Print("Data loading error, file: ", DataFileName);
        return;
      }
    }

    KohonenMap.Init(CellsX, CellsY, ImageW, ImageH, MaxPictures, ColorScheme, HexagonalCell, ShowBorders, ShowTitles);
    
    if(ValidationSetPercent > 0 && ValidationSetPercent < 50)
    {
      KohonenMap.SetValidationSection((int)(KohonenMap.GetDataCount() * (1.0 - ValidationSetPercent / 100.0)));
    }

    KohonenMap.Train(EpochNumber, UseNormalization, ShowProgress);

    if(ClusterNumber > 1)
    {
      KohonenMap.Clusterize(ClusterNumber);
    }
    else
    {
      KohonenMap.Clusterize();
    }
  }

  if(!hasOneTestPattern)
  {
    double vector[];
    ArrayResize(vector, KohonenMap.GetFeatureCount());
    ArrayInitialize(vector, 0);
    KohonenMap.CalculateOutput(vector);
  }

  KohonenMap.Render(); // 将映像绘制到内部 BMP 缓冲区中

  if(hasOneTestPattern)
    KohonenMap.ShowAllPatterns();
  else
    KohonenMap.ShowAllNodes(); // 在 BMP 缓冲区中绘制细胞内标签

  if(ClusterNumber != 0)
  {
    KohonenMap.ShowClusters(); // 标记聚类
  }

  KohonenMap.ShowBMP(SaveImages); // 在图表上将文件显示为位图图像，可选择保存到文件中

  if(NetFileName == "")
  {
    KohonenMap.Save(KohonenMap.GetID());
  }
}

Pass 0 from 1000 0%
Pass 78 from 1000 7%
Pass 157 from 1000 15%
Pass 232 from 1000 23%
Pass 310 from 1000 31%
Pass 389 from 1000 38%
Pass 468 from 1000 46%
Pass 550 from 1000 55%
Pass 631 from 1000 63%
Pass 710 from 1000 71%
Pass 790 from 1000 79%
Pass 870 from 1000 87%
Pass 951 from 1000 95%
Overall NMSE=0.09420336270396877
Training completed at pass 1000, NMSE=0.09420336270396877
Clusters [14]:
"R1000" "R1"    "R2"   
N0
754.83131   0.36778   0.25369
N1
341.39665   0.41402  -0.26702
N2
360.72925   0.86826  -0.69173
N3
798.15569   0.17846  -0.37911
N4
470.30648   0.52326   0.06442
Map file SOM-20181205-134437.som saved

FileOpen error ?.csv : 5004
Data loading error, file: ?
Random Input:
457.17510   0.29727   0.57621
Matched Node Output (8,3); Hits:5; Error:0.05246704285146882; Cluster N0:
497.20453   0.28675   0.53213