English Русский Español Deutsch 日本語 Português 한국어 Italiano Türkçe
preview
种群优化算法：灰狼优化器（GWO）

种群优化算法：灰狼优化器（GWO）

MetaTrader 5 — 示例 | 11 四月 2023, 09:33
921 0
Andrey Dik
Andrey Dik

内容

1. 概述
2  算法描述
3. 测试函数
4. 测试结果


1. 概述

灰狼算法是 2014 年开发出的一种元启发式随机群体智能算法。 它的思路是基于灰狼群狩猎模型。 狼群内有四种类型阶层：阿尔法、贝塔、德尔塔、和欧米茄。 阿尔法阶层在群体决策和管理方面拥有最大的“权重”。 接下来是贝塔和德尔塔阶层，它们服从阿尔法截仓，并拥有对狼群内其余阶层成员的压制。 欧米茄阶层的狼总是服从其余的统治阶层狼。

在狼的阶层数学模型中，阿尔法阶层狼被认为是狼群中的主导狼，它的命令应该由狼群成员执行。 贝塔阶层的从属狼协助阿尔法阶层制定决策，被认为是阿尔法角色的最佳候选。 德尔塔阶层狼应该服从阿尔法和贝塔阶层，但它们支配着欧米茄阶层。 欧米茄阶层狼被认为是狼群的替罪羊，也是重要性最低下的个体。 它们只允许在最后才能进食。 阿尔法阶层被认为是最有利的解。

第二和第三最佳解分别是贝塔和德尔塔阶层。 欧米茄阶层则认为是解的残料。 假设最适者的狼（阿尔法、贝塔、和德尔塔），即最接近猎物的狼，然后接近的是其余的狼。 每次接近后，就能判定谁是这个阶段的阿尔法、贝塔和德尔塔，然后狼群再次重新排列。 编队持续进行，直至狼群聚集在一起，这将是以最小距离进行攻击的最优方向。

在算法过程中，执行 3 个主要阶段，其中狼群搜索猎物、包围、和攻击猎物。 搜索揭示出阿尔法、贝塔和德尔塔 — 最接近猎物的狼。 而其余的，服从占主导地位的指挥，也许会开始包围猎物，或继续随机移动，以便寻找最佳选项。


2 条所述情况。 算法说明

图 1 示意性地展示狼群的阶层结构。阿尔法阶层起着主导作用。

主导

图例 1. 狼群中的社会阶层




数学模型和算法
社会阶层:

  • 优等解是由阿尔法（α）狼形成的。
  • 二等解由贝塔（β）狼形成。
  • 三等解由德尔塔（δ）狼形成。
  • 其它可能的解，由欧米茄伏（ω）狼形成。

包围猎物：当已经有最佳解的阿尔法、贝塔、和德尔塔在场时，进一步的行动取决于欧米茄。



阶段

图例 2. 狩猎阶段：搜索、包围、攻击。


算法的所有迭代都表现为三个阶段：搜索、包围、和狩猎。 该算法的规范版本具有引入的a 计算比率，以提高算法的收敛性。 该比率在每次迭代时递减，直至为零。 只要比率超过 1，狼群的初始化就会持续进行。 在这个阶段，猎物的位置是完全未知的，所以狼群应该是随机分布的。

在“搜索”阶段之后，判定适应度函数的值，然后才有可能进入“包围”阶段。 在此阶段，a 比率大于 1。 这意味着阿尔法、贝塔和德尔塔正在远离它们之前的位置，从而可以优调估算猎物的位置。 当 a 比率等于 1 时，“攻击”阶段开始，而比率在迭代结束前趋于 0。 这导致狼群接近猎物，表明已经找到了最佳位置。 虽然，如果在这个阶段，其中某只狼找到了更好的解，那么猎物的位置和狼群的层次结构将会更新，但比例仍然趋于 0。 变化的过程由非线性函数表示。 这些阶段示意如图例 2 所示。

欧米茄阶层的狼，其行为在所有世代都是不变的，包括遵循当前占主导地位的个体位置之间的几何中心。 在图例 3 中，阿尔法、贝塔和德尔塔在随机方向上偏离它们之前的位置，半径由系数给出，欧米茄移动到它们之间的中心，但在半径内有一定程度偏离它的概率。 半径决定了 a比率，正如我们记得的那样，它的变化导致半径成比例地减小。




包围

图例 3. 欧米茄相对阿尔法、贝塔和德尔塔的的运动图


GWO 算法的伪代码如下：

1) 随机初始化灰狼种群。
2) 计算种群每只个体成员的体质状况。
3) 狼群领导者:
-α = 具有最佳体质值的成员
-β = 第二等强大的成员（就体质值而言）
-δ = 第三等强大的成员（就体质值而言）
根据 α、β、δ 方程更新所有欧米茄狼的位置
4) 计算种群中每个成员的体质。
5) 重复步骤 3。

我们继续讨论算法代码。 我对原始版本所做的唯一补充就是能够设置狼群中主导狼的数量。 现在，您可以设置任意数量的主导者，最多可达整个狼群。 对于特定任务这可能很实用。

如往常一样，我们从算法的基本单元 — 狼开始，这是问题的解。 这是一个包含坐标数组和猎物值（适应度函数）的结构。 对于主导者和次等成员，结构是相同的。 这简化了算法，并允许我们在循环操作中使用相同的结构。 甚至，在所有迭代过程中，狼的角色会多次变化。 角色由排序后在数组中的位置唯一确定。 主导者位于数组的开头。

//——————————————————————————————————————————————————————————————————————————————
struct S_Wolf
{
  double c []; //coordinates
  double p;    //prey
};
//——————————————————————————————————————————————————————————————————————————————

狼群由一个紧凑且易于理解的类代表。 在此，我们声明要优化的参数范围和步长，最佳生产位置，最佳解的值，和辅助函数。

//——————————————————————————————————————————————————————————————————————————————
class C_AO_GWO //wolfpack
{
  //============================================================================
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: S_Wolf wolves    []; //wolves of the pack
  public: double cB        []; //best prey coordinates
  public: double pB;           //best prey

  public: void InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP);   //epochs number

  public: void TasksForWolves      (int epochNow);
  public: void RevisionAlphaStatus ();


  //============================================================================
  private: void   ReturnToRange (S_Wolf &wolf);
  private: void   SortingWolves ();
  private: double SeInDiSp      (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI     (double Min, double Max);

  private: int    coordinates;     //coordinates number
  private: int    wolvesNumber;    //the number of all wolves
  private: int    alphaNumber;     //Alpha beta delta number of all wolves
  private: int    epochCount;

  private: S_Wolf wolvesT    [];   //temporary, for sorting
  private: int    ind        [];   //array for indexes when sorting
  private: double val        [];   //array for sorting

  private: bool   searching;       //searching flag
};
//——————————————————————————————————————————————————————————————————————————————

传统上，类声明后跟初始化。 而在此，我们重置为狼群适应度的最小 “double” 值，并分配数组的大小。

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP)    //epochs number
{
  MathSrand (GetTickCount ());
  searching = false;
  pB        = -DBL_MAX;

  coordinates  = coordinatesP;
  wolvesNumber = wolvesNumberP;
  alphaNumber  = alphaNumberP;
  epochCount   = epochCountP;

  ArrayResize (rangeMax,  coordinates);
  ArrayResize (rangeMin,  coordinates);
  ArrayResize (rangeStep, coordinates);
  ArrayResize (cB,        coordinates);

  ArrayResize (ind, wolvesNumber);
  ArrayResize (val, wolvesNumber);

  ArrayResize (wolves,  wolvesNumber);
  ArrayResize (wolvesT, wolvesNumber);

  for (int i = 0; i < wolvesNumber; i++)
  {
    ArrayResize (wolves  [i].c, coordinates);
    ArrayResize (wolvesT [i].c, coordinates);
    wolves  [i].p = -DBL_MAX;
    wolvesT [i].p = -DBL_MAX;
  }
}
//——————————————————————————————————————————————————————————————————————————————

每次迭代时调用的第一个公开方法最令人难以理解，也是体量最庞大的。 此处是算法的主要逻辑。 事实上，该算法的性能是严格由等式描述的概率机制提供的。 我们来逐步研究此方法。 在第一次迭代中，当预期猎物的位置未知时，在检查标志后，我们只需依从来自优化参数最大值和最小值的生成值，即可将狼发往随机方向。

//----------------------------------------------------------------------------
//space has not been explored yet, then send the wolf in a random direction
if (!searching)
{
  for (int w = 0; w < wolvesNumber; w++)
  {
    for (int c = 0; c < coordinates; c++)
    {
      wolves [w].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      wolves [w].c [c] = SeInDiSp  (wolves [w].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
   
  searching = true;
  return;
}

在算法描述的规范版本中，存在运算向量的方程。 然而，它们以代码的形式表达更加清晰。 欧米茄狼的计算是在阿尔法、贝塔、和的额尔塔狼之前进行的，因为我们需要使用前面的主导者数值。

提供三个狩猎阶段（搜索、包围、和攻击）的主要组成部分是 a 比率。 它代表对当前迭代和总迭代次数的非线性依赖性，并且趋于 0。 等式的下一个组成部分是 Ai 和 Сi
  • Ai = 2.0 * a * r1 - a;
  • Ci = 2.0 * r2;
其中 r1 和 r2 是在 [0.0;1.0] 范围内的随机数。
在表达式中
Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);
狼的坐标根据领头狼的平均值进行调整。 由于可以在算法中指定任意数量的主导者，因此坐标求和是在循环中执行的。 之后，所得数额除以主导者的数量。 我们分别针对每个坐标执行此操作，每次生成新的 r1 和 r2 值。 正如我们所见，欧米茄狼的新位置是根据主导狼的位置调整的，同时考虑到它们自己当前的位置。
//----------------------------------------------------------------------------
double a  = sqrt (2.0 * (1.0 - (epochNow / epochCount)));
double r1 = 0.0;
double r2 = 0.0;

double Ai = 0.0;
double Ci = 0.0;
double Xn = 0.0;

double min = 0.0;
double max = 1.0;

//omega-----------------------------------------------------------------------
for (int w = alphaNumber; w < wolvesNumber; w++)
{
  Xn = 0.0;

  for (int c = 0; c < coordinates; c++)
  {
    for (int abd = 0; abd < alphaNumber; abd++)
    {
      r1 = RNDfromCI (min, max);
      r2 = RNDfromCI (min, max);
      Ai = 2.0 * a * r1 - a;
      Ci = 2.0 * r2;
      Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);
    }

    wolves [w].c [c] = Xn /= (double)alphaNumber;
  }

  ReturnToRange (wolves [w]);
}

此处计算主导者。 为每个坐标计算每个坐标的 a、Ai 和 Ci 比率。 唯一的区别是主导者的位置会随着当前最佳猎物的坐标和它们自身的位置而变化。 主导者围着猎物转圈，或远或近，并在攻击中控制着次要狼群。

//alpha, beta, delta----------------------------------------------------------
for (int w = 0; w < alphaNumber; w++)
{
  for (int c = 0; c < coordinates; c++)
  {
    r1 = RNDfromCI (min, max);
    r2 = RNDfromCI (min, max);

    Ai = 2.0 * a * r1 - a;
    Ci = 2.0 * r2;

    wolves [w].c [c] = cB [c] - Ai * (Ci * cB [c] - wolves [w].c [c]);
  }

  ReturnToRange (wolves [w]);
}

这是每次迭代时调用的第二个公开方法。 在此处更新群中主导者的状态。 事实上，狼是按体质值排序的。 如果找到的猎物坐标比整个群体中保存的猎物坐标更好，那么我们就需更新数值。 

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::RevisionAlphaStatus ()
{
  SortingWolves ();

  if (wolves [0].p > pB)
  {
    pB = wolves [0].p;
    ArrayCopy (cB, wolves [0].c, 0, 0, WHOLE_ARRAY);
  }
}
//——————————————————————————————————————————————————————————————————————————————


3. 测试函数

您已经知道 Skin、Forest 和 Megacity 等函数。 这些测试函数满足测试优化算法的所有复杂性标准。 不过，有一个功能没有被考虑在内。 它理应实现，以便提高测试的客观性。 其需求如下：

  1. 全局极值不应位于范围的边界上。 如果算法没有超界检查，则可能会出现的状况就是算法展示出完美的结果。 而事实上这是由于内部缺陷，这些数值都位于边界上。
  2. 全局极值不应位于范围坐标的中心。 在这种情况下，算法将考虑在某个范围内生成平均值。
  3. 全局最小值应位于坐标中心。 这是必要的，以便排除第 2 条所述情况。
  4. 测试函数结果的计算应考虑以下情况：在整个函数域（当函数是多变量时）随机生成的数字将给出大约最大值 50% 的平均结果，尽管实际上这些结果是偶然获得的。

考虑到这些需求，修改了测试函数的边界，并将范围的中心偏移到函数值的最小值。 我再次总结一下。 如此做是必要的，以便所获测试优化算法的结果合理性和客观性最大化。 因此，在新测试函数上，基于随机数生成的优化算法很自然地展现出较低的总体结果。 更新后的评级表位于文章末尾。

Skin 函数。 具有多个局部极值的平滑函数，可能会混淆优化算法，因为它可能会在其中一个极值处卡顿。 唯一的全局极值的特征是其附近的数值变化较弱。 这个函数清楚地显示了该算法可被切分到正在研究领域的能力，远不止专注于单个领域。 特别是，蜂群（ABC）算法的行为方式。

skin

图例 4. Skin 测试函数

Forest 函数。 该函数具有多个平滑极值，和若干个不可微极值。 这是对优化算法的一个有价值的测试，用来找寻“大海捞针”的能力。 找到单个全局最大值是一项非常困难的任务，尤其是在函数包含许多变量的情况下。 蚁群算法（ACO）在这项任务中以特征行为而著称，它以令人难以置信的方式为目标铺平了道路。



forest

图例 5 Forest 测试函数

Megacity 函数。 该函数是一个具有一个全局极值，和几个局部极值的离散优化问题。 极其复杂的表面为需要研究的梯度提供了优秀的测试算法。 一个完全均匀的“下限”增加了额外的复杂性，这也是一个最小值，它没有提供有关全局最大值的可能方向的任何信息。


megacity

图例 6 Megacity 测试函数

在测试函数的代码中添加传入参数是否超出数值范围的检查。 在函数的先前版本中，优化算法可能会不公平地获得大于函数在其定义范围内实际应具有的函数值。


4. 测试结果

由于对测试函数进行了更改，测试台也已随之更新。 在测试台屏幕的右侧，您仍然可以看到优化算法的收敛图。 绿线代表具有两个变量的函数收敛结果。 蓝线代表具有 40 个变量的函数。 红线表示具有 1000 个变量的函数。 较大的黑色圆圈表示函数的全局最大值的位置。 较小的黑色圆圈表示当前优化算法求解值的位置。 白线的十字准线表示检验函数的几何中心，并对应于全局最小值。 引入此功能是为了更好地直观感知测试算法的行为。 白点表示平均中间解。 彩色小点表示相应维度的坐标对。 彩色示意测试函数维度的序号位置。

更新后的表格中可以看到之前关于新测试台的文章中讨论的优化算法的测试结果。 为了在视觉上更清晰，关于收敛速度的指示线已从表格中删除 — 它可以在测试台的动画上直观地判定。 添加了包含算法描述的列。

ACOm (蚁群优化) 测试结果:

2022.11.28 12:17:00.468    Test_AO_ACO (EURUSD,M1)    =============================
2022.11.28 12:17:06.382    Test_AO_ACO (EURUSD,M1)    1 Skin's; Func runs 10000 result: 4.844203223078298
2022.11.28 12:17:06.382    Test_AO_ACO (EURUSD,M1)    Score: 0.98229
2022.11.28 12:17:14.191    Test_AO_ACO (EURUSD,M1)    20 Skin's; Func runs 10000 result: 4.043383610736287
2022.11.28 12:17:14.191    Test_AO_ACO (EURUSD,M1)    Score: 0.79108
2022.11.28 12:17:55.578    Test_AO_ACO (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.2580170651681026
2022.11.28 12:17:55.578    Test_AO_ACO (EURUSD,M1)    Score: 0.12602
2022.11.28 12:17:55.578    Test_AO_ACO (EURUSD,M1)    =============================
2022.11.28 12:18:01.491    Test_AO_ACO (EURUSD,M1)    1 Forest's; Func runs 10000 result: 1.7678766100234538
2022.11.28 12:18:01.491    Test_AO_ACO (EURUSD,M1)    Score: 1.00000
2022.11.28 12:18:09.508    Test_AO_ACO (EURUSD,M1)    20 Forest's; Func runs 10000 result: 1.0974381500585855
2022.11.28 12:18:09.508    Test_AO_ACO (EURUSD,M1)    Score: 0.62077
2022.11.28 12:18:53.348    Test_AO_ACO (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.20367726028454042
2022.11.28 12:18:53.348    Test_AO_ACO (EURUSD,M1)    Score: 0.11521
2022.11.28 12:18:53.348    Test_AO_ACO (EURUSD,M1)    =============================
2022.11.28 12:18:59.303    Test_AO_ACO (EURUSD,M1)    1 Megacity's; Func runs 10000 result: 4.6
2022.11.28 12:18:59.303    Test_AO_ACO (EURUSD,M1)    Score: 0.38333
2022.11.28 12:19:07.598    Test_AO_ACO (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 5.28
2022.11.28 12:19:07.598    Test_AO_ACO (EURUSD,M1)    Score: 0.44000
2022.11.28 12:19:53.172    Test_AO_ACO (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.2852
2022.11.28 12:19:53.172    Test_AO_ACO (EURUSD,M1)    Score: 0.02377
2022.11.28 12:19:53.172    Test_AO_ACO (EURUSD,M1)    =============================
2022.11.28 12:19:53.172    Test_AO_ACO (EURUSD,M1)    All score for C_AO_ACOm: 0.4980520084646583

（人工蜂群）测试结果:

2022.11.28 12:35:47.181    Test_AO_ABCm (EURUSD,M1)    =============================
2022.11.28 12:35:52.581    Test_AO_ABCm (EURUSD,M1)    1 Skin's; Func runs 10000 result: 4.918379986612587
2022.11.28 12:35:52.581    Test_AO_ABCm (EURUSD,M1)    Score: 1.00000
2022.11.28 12:35:59.454    Test_AO_ABCm (EURUSD,M1)    20 Skin's; Func runs 10000 result: 3.4073825805846374
2022.11.28 12:35:59.454    Test_AO_ABCm (EURUSD,M1)    Score: 0.63922
2022.11.28 12:36:32.428    Test_AO_ABCm (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.0684464927353337
2022.11.28 12:36:32.428    Test_AO_ABCm (EURUSD,M1)    Score: 0.08076
2022.11.28 12:36:32.428    Test_AO_ABCm (EURUSD,M1)    =============================
2022.11.28 12:36:38.086    Test_AO_ABCm (EURUSD,M1)    1 Forest's; Func runs 10000 result: 1.766245456669898
2022.11.28 12:36:38.086    Test_AO_ABCm (EURUSD,M1)    Score: 0.99908
2022.11.28 12:36:45.326    Test_AO_ABCm (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.35556125136004335
2022.11.28 12:36:45.326    Test_AO_ABCm (EURUSD,M1)    Score: 0.20112
2022.11.28 12:37:22.301    Test_AO_ABCm (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.06691711149962026
2022.11.28 12:37:22.301    Test_AO_ABCm (EURUSD,M1)    Score: 0.03785
2022.11.28 12:37:22.301    Test_AO_ABCm (EURUSD,M1)    =============================
2022.11.28 12:37:28.047    Test_AO_ABCm (EURUSD,M1)    1 Megacity's; Func runs 10000 result: 12.0
2022.11.28 12:37:28.047    Test_AO_ABCm (EURUSD,M1)    Score: 1.00000
2022.11.28 12:37:35.689    Test_AO_ABCm (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.9600000000000002
2022.11.28 12:37:35.689    Test_AO_ABCm (EURUSD,M1)    Score: 0.16333
2022.11.28 12:38:11.609    Test_AO_ABCm (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.33880000000000005
2022.11.28 12:38:11.609    Test_AO_ABCm (EURUSD,M1)    Score: 0.02823
2022.11.28 12:38:11.609    Test_AO_ABCm (EURUSD,M1)    =============================
2022.11.28 12:38:11.609    Test_AO_ABCm (EURUSD,M1)    All score for C_AO_ABCm: 0.4610669021761763

ABC（人工蜂群）测试结果:

2022.11.28 12:29:51.177    Test_AO_ABC (EURUSD,M1)    =============================
2022.11.28 12:29:56.785    Test_AO_ABC (EURUSD,M1)    1 Skin's; Func runs 10000 result: 4.890679983950205
2022.11.28 12:29:56.785    Test_AO_ABC (EURUSD,M1)    Score: 0.99339
2022.11.28 12:30:03.880    Test_AO_ABC (EURUSD,M1)    20 Skin's; Func runs 10000 result: 3.8035430744604133
2022.11.28 12:30:03.880    Test_AO_ABC (EURUSD,M1)    Score: 0.73381
2022.11.28 12:30:37.089    Test_AO_ABC (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.195840100227333
2022.11.28 12:30:37.089    Test_AO_ABC (EURUSD,M1)    Score: 0.11118
2022.11.28 12:30:37.089    Test_AO_ABC (EURUSD,M1)    =============================
2022.11.28 12:30:42.811    Test_AO_ABC (EURUSD,M1)    1 Forest's; Func runs 10000 result: 1.7667070507449298
2022.11.28 12:30:42.811    Test_AO_ABC (EURUSD,M1)    Score: 0.99934
2022.11.28 12:30:50.108    Test_AO_ABC (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.3789854806095275
2022.11.28 12:30:50.108    Test_AO_ABC (EURUSD,M1)    Score: 0.21437
2022.11.28 12:31:25.900    Test_AO_ABC (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.07451308481273813
2022.11.28 12:31:25.900    Test_AO_ABC (EURUSD,M1)    Score: 0.04215
2022.11.28 12:31:25.900    Test_AO_ABC (EURUSD,M1)    =============================
2022.11.28 12:31:31.510    Test_AO_ABC (EURUSD,M1)    1 Megacity's; Func runs 10000 result: 10.2
2022.11.28 12:31:31.510    Test_AO_ABC (EURUSD,M1)    Score: 0.85000
2022.11.28 12:31:38.855    Test_AO_ABC (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 2.02
2022.11.28 12:31:38.855    Test_AO_ABC (EURUSD,M1)    Score: 0.16833
2022.11.28 12:32:14.623    Test_AO_ABC (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.37559999999999993
2022.11.28 12:32:14.623    Test_AO_ABC (EURUSD,M1)    Score: 0.03130
2022.11.28 12:32:14.623    Test_AO_ABC (EURUSD,M1)    =============================
2022.11.28 12:32:14.623    Test_AO_ABC (EURUSD,M1)    All score for C_AO_ABC: 0.46043003186219245

PSO（粒子群优化）测试结果:

2022.11.28 12:01:03.967    Test_AO_PSO (EURUSD,M1)    =============================
2022.11.28 12:01:09.723    Test_AO_PSO (EURUSD,M1)    1 Skin's; Func runs 10000 result: 4.90276049713715
2022.11.28 12:01:09.723    Test_AO_PSO (EURUSD,M1)    Score: 0.99627
2022.11.28 12:01:17.064    Test_AO_PSO (EURUSD,M1)    20 Skin's; Func runs 10000 result: 2.3250668562024566
2022.11.28 12:01:17.064    Test_AO_PSO (EURUSD,M1)    Score: 0.38080
2022.11.28 12:01:52.880    Test_AO_PSO (EURUSD,M1)    500 Skin's; Func runs 10000 result: 0.943331687769892
2022.11.28 12:01:52.881    Test_AO_PSO (EURUSD,M1)    Score: 0.05089
2022.11.28 12:01:52.881    Test_AO_PSO (EURUSD,M1)    =============================
2022.11.28 12:01:58.492    Test_AO_PSO (EURUSD,M1)    1 Forest's; Func runs 10000 result: 1.6577769478566602
2022.11.28 12:01:58.492    Test_AO_PSO (EURUSD,M1)    Score: 0.93772
2022.11.28 12:02:06.105    Test_AO_PSO (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.25704414127018393
2022.11.28 12:02:06.105    Test_AO_PSO (EURUSD,M1)    Score: 0.14540
2022.11.28 12:02:44.566    Test_AO_PSO (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.08584805450831333
2022.11.28 12:02:44.566    Test_AO_PSO (EURUSD,M1)    Score: 0.04856
2022.11.28 12:02:44.566    Test_AO_PSO (EURUSD,M1)    =============================
2022.11.28 12:02:50.268    Test_AO_PSO (EURUSD,M1)    1 Megacity's; Func runs 10000 result: 12.0
2022.11.28 12:02:50.268    Test_AO_PSO (EURUSD,M1)    Score: 1.00000
2022.11.28 12:02:57.649    Test_AO_PSO (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.1199999999999999
2022.11.28 12:02:57.649    Test_AO_PSO (EURUSD,M1)    Score: 0.09333
2022.11.28 12:03:34.895    Test_AO_PSO (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.268
2022.11.28 12:03:34.895    Test_AO_PSO (EURUSD,M1)    Score: 0.02233
2022.11.28 12:03:34.895    Test_AO_PSO (EURUSD,M1)    =============================
2022.11.28 12:03:34.895    Test_AO_PSO (EURUSD,M1)    All score for C_AO_PSO: 0.40836715689743186

RND（随机）测试结果:

2022.11.28 16:45:15.976    Test_AO_RND (EURUSD,M1)    =============================
2022.11.28 16:45:21.569    Test_AO_RND (EURUSD,M1)    1 Skin's; Func runs 10000 result: 4.915522750114194
2022.11.28 16:45:21.569    Test_AO_RND (EURUSD,M1)    Score: 0.99932
2022.11.28 16:45:28.607    Test_AO_RND (EURUSD,M1)    20 Skin's; Func runs 10000 result: 2.584546688199847
2022.11.28 16:45:28.607    Test_AO_RND (EURUSD,M1)    Score: 0.44276
2022.11.28 16:46:02.695    Test_AO_RND (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.0161336237263792
2022.11.28 16:46:02.695    Test_AO_RND (EURUSD,M1)    Score: 0.06827
2022.11.28 16:46:02.695    Test_AO_RND (EURUSD,M1)    =============================
2022.11.28 16:46:09.622    Test_AO_RND (EURUSD,M1)    1 Forest's; Func runs 10000 result: 1.4695680943894533
2022.11.28 16:46:09.622    Test_AO_RND (EURUSD,M1)    Score: 0.83126
2022.11.28 16:46:17.675    Test_AO_RND (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.20373533112604475
2022.11.28 16:46:17.675    Test_AO_RND (EURUSD,M1)    Score: 0.11524
2022.11.28 16:46:54.544    Test_AO_RND (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.0538909816827325
2022.11.28 16:46:54.544    Test_AO_RND (EURUSD,M1)    Score: 0.03048
2022.11.28 16:46:54.544    Test_AO_RND (EURUSD,M1)    =============================
2022.11.28 16:47:00.219    Test_AO_RND (EURUSD,M1)    1 Megacity's; Func runs 10000 result: 10.0
2022.11.28 16:47:00.219    Test_AO_RND (EURUSD,M1)    Score: 0.83333
2022.11.28 16:47:08.145    Test_AO_RND (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.08
2022.11.28 16:47:08.145    Test_AO_RND (EURUSD,M1)    Score: 0.09000
2022.11.28 16:47:49.875    Test_AO_RND (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.28840000000000005
2022.11.28 16:47:49.875    Test_AO_RND (EURUSD,M1)    Score: 0.02403
2022.11.28 16:47:49.875    Test_AO_RND (EURUSD,M1)    =============================
2022.11.28 16:47:49.875    Test_AO_RND (EURUSD,M1)    All score for C_AO_RND: 0.38163317904126015



skin

  基于 Skin 测试函数的 GWO

forest

基于 Forest 测试函数的 GWO

megacity

  基于 Megacity 测试函数的 GWO

GWO 测试结果。

2022.11.28 13:24:09.370    Test_AO_GWO (EURUSD,M1)    =============================
2022.11.28 13:24:14.895    Test_AO_GWO (EURUSD,M1)    1 Skin's; Func runs 10000 result: 4.914175888065222
2022.11.28 13:24:14.895    Test_AO_GWO (EURUSD,M1)    Score: 0.99900
2022.11.28 13:24:22.175    Test_AO_GWO (EURUSD,M1)    20 Skin's; Func runs 10000 result: 2.7419092435309405
2022.11.28 13:24:22.175    Test_AO_GWO (EURUSD,M1)    Score: 0.48033
2022.11.28 13:25:01.381    Test_AO_GWO (EURUSD,M1)    500 Skin's; Func runs 10000 result: 1.5227848592798188
2022.11.28 13:25:01.381    Test_AO_GWO (EURUSD,M1)    Score: 0.18924
2022.11.28 13:25:01.381    Test_AO_GWO (EURUSD,M1)    =============================
2022.11.28 13:25:06.924    Test_AO_GWO (EURUSD,M1)    1 Forest's; Func runs 10000 result: 1.4822580151819842
2022.11.28 13:25:06.924    Test_AO_GWO (EURUSD,M1)    Score: 0.83844
2022.11.28 13:25:14.551    Test_AO_GWO (EURUSD,M1)    20 Forest's; Func runs 10000 result: 0.15477395149266915
2022.11.28 13:25:14.551    Test_AO_GWO (EURUSD,M1)    Score: 0.08755
2022.11.28 13:25:56.900    Test_AO_GWO (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.04517298232457319
2022.11.28 13:25:56.900    Test_AO_GWO (EURUSD,M1)    Score: 0.02555
2022.11.28 13:25:56.900    Test_AO_GWO (EURUSD,M1)    =============================
2022.11.28 13:26:02.305    Test_AO_GWO (EURUSD,M1)    1 Megacity's; Func runs 10000 result: 12.0
2022.11.28 13:26:02.305    Test_AO_GWO (EURUSD,M1)    Score: 1.00000
2022.11.28 13:26:09.475    Test_AO_GWO (EURUSD,M1)    20 Megacity's; Func runs 10000 result: 1.2
2022.11.28 13:26:09.475    Test_AO_GWO (EURUSD,M1)    Score: 0.10000
2022.11.28 13:26:48.980    Test_AO_GWO (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.2624
2022.11.28 13:26:48.980    Test_AO_GWO (EURUSD,M1)    Score: 0.02187
2022.11.28 13:26:48.980    Test_AO_GWO (EURUSD,M1)    =============================
2022.11.28 13:26:48.980    Test_AO_GWO (EURUSD,M1)    All score for C_AO_GWO: 0.41577484361261224

灰狼优化算法（GWO）是最近基于模拟灰狼群狩猎的生物启发优化算法之一。 平均而言，该算法已经证明了自身在各种类型的函数上都非常有效，无论是在查找极值的准确性方面，还是在收敛速度方面。 在某些测试中，它被证明是最好的。 “灰狼”优化算法的主要性能指标优于粒子群优化算法，在仿生优化算法类中被认为是“常规”的。

与此同时，灰狼优化算法的计算复杂度可与粒子群优化算法相媲美。 由于GWO 优化算法的众多优点，自该算法首次发布以来，在短时间内涌现出众多关于其修订版的工作。 该算法的唯一缺点是发现 Forest 尖锐极大函数的坐标精度低。

所发现的极值精度低表现在 Forest 函数的所有维度上，结果是表中所有参与者中最差的。 事实证明，该算法对平滑 Skin 函数有效，尤其是在较大维度 Skin 函数的情况下。 GWO 也是表中第三个在 Megacity 函数上实现 100% 全局最大值的排名。

算法

说明

Skin

Forest

Megacity (离散)

最终结果

2 参数 (1 F)

40 参数 (20 F)

1000 参数 (500 F)

2 参数 (1 F)

40 参数 (20 F)

1000 参数 (500 F)

2 参数 (1 F)

40 参数 (20 F)

1000 参数 (500 F)

ACOm

蚁群优化

0.98229

0.79108

0.12602

1.00000

0.62077

0.11521

0.38333

0.44000

0.02377

0.49805222

ABCm

人工蜂群 M

1.00000

0.63922

0.08076

0.99908

0.20112

0.03785

1.00000

0.16333

0.02823

0.46106556

ABC

人工蜂群

0.99339

0.73381

0.11118

0.99934

0.21437

0.04215

0.85000

0.16833

0.03130

0.46043000

GWO

灰狼优化器

0.99900

0.48033

0.18924

0.83844

0.08755

0.02555

1.00000

0.10000

0.02187

0.41577556

PSO

粒子群优化

0.99627

0.38080

0.05089

0.93772

0.14540

0.04856

1.00000

0.09333

0.02233

0.40836667

RND

随机

0.99932

0.44276

0.06827

0.83126

0.11524

0.03048

0.83333

0.09000

0.02403

0.38163222


结束语:

优点:
1. 高速。
2 条所述情况。 高收敛性平滑函数，且具有大量变量。

缺点:
1. 非通用。
2 条所述情况。 在局部极端处卡顿。
3. 离散和不可微函数的可扩展性低。


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

附加的文件 |
下载ZIP
l5_The_world_of_AO_oGWOv.zip (44.97 KB)
注意: MetaQuotes Ltd.将保留所有关于这些材料的权利。全部或部分复制或者转载这些材料将被禁止。

该作者的其他文章

前往讨论
构建自动运行的 EA（第 08 部分）：OnTradeTransaction 构建自动运行的 EA（第 08 部分）：OnTradeTransaction
在本文中，我们将目睹如何利用事件处理系统快速有效地处理与订单系统相关的问题。 配合这个系统，EA 就能更快地工作，如此它就不必持续不断地搜索所需的数据。
神经网络变得轻松（第三十四部分）：全部参数化的分位数函数 神经网络变得轻松（第三十四部分）：全部参数化的分位数函数
我们继续研究分布式 Q-学习算法。 在之前的文章中，我们研究了分布式和分位数 Q-学习算法。 在第一种算法当中，我们训练了给定数值范围的概率。 在第二种算法中，我们用给定的概率训练了范围。 在这两个发行版中，我们采用了一个先验分布知识，并训练了另一个。 在本文中，我们将研究一种算法，其允许模型针对两种分布进行训练。
DoEasy. 控件 (第 28 部分): 进度条控件中的柱线样式 DoEasy. 控件 (第 28 部分): 进度条控件中的柱线样式
在本文中，我将开发进度条控件的柱线显示样式和说明文本。
种群优化算法：人工蜂群（ABC） 种群优化算法：人工蜂群（ABC）
在本文中，我们将研究人工蜂群的算法，并用研究函数空间得到的新原理来补充我们的知识库。 在本文中，我将陈列我对经典算法版本的解释。