MetaTrader 5 / 示例
English Русский Español Deutsch 日本語 Português
preview
人工部落算法（ATA）

人工部落算法（ATA）

MetaTrader 5 — 示例 |
146 0
Andrey Dik
Andrey Dik

内容

  1. 概述
  2. 算法的实现
  3. 测试结果


概述

随着技术的快速发展，以及优化任务变得更加复杂，科学家和研究人员持续在大自然中寻找灵感。这种方式的一个显著例子是由科学家 T. Chen、Y. Wang 和 J. Li 创建，并于 2012 年发表的人工部落算法（ATA）。受部落行为的启发，ATA 使用两种主要机制 — 分散和迁徙 — 来适应不断变化的条件，并找到各种问题的最优解。想象一片广阔的土地，一群人，就像他们远祖一样，团结起来寻找最佳资源。他们迁徙、交流知识和经验，制定独特的策略，来解决复杂的问题。正是这种行为成为创建 ATA 的基础 — 该算法和谐地结合了两种关键机制：分布和迁徙。

人工部落算法是一种基于仿生智能算法原理的全新优化方法。它模拟自然部落的行为，采用他们的繁殖和迁徙能力，来实现最优解。在该算法中，部落由彼此互动的个体组成，以找到全局最优。


算法的实现

ATA 算法过程从设置参数、随机初始化部落开始，之后计算适应度值。接下来，迭代计数器递增，并评估部落的当前状况。如果状况有利（代际之间最优适应度值的差异大于给定准则），则执行繁衍行为，其中个体交换信息。否则，用到迁徙行为，其中个体基于个人和整个部落两者的经验进行移动。迁徙不能连续执行，来避免过度分散。然后重新计算适应度值，并与部落和每位个体记录的最佳值进行比较。如果找到更好的解，则将其存储在内存中。检查终止条件，如果它们所有都满足，则终止迭代。否则，该过程将返回到状况评估步骤。

将全局信息纳入 ATA 可以增加部落历史经验的权重，有助于找到更好的解，并提高搜索能力。增加部落经验的权重有助于提高算法的效率，加速收敛。为达成这一点，ATA 引入了全局惯性权重，其可强化搜索能力，并加快过程。

ATA 的主要创新在于存在一个根据情况进行调整的双重行为系统：当进展良好时，用繁衍来深度探索，当陷入局部最优时，则激活迁徙，从而促进更深入的探索。个体和社会学习的结合也很重要。迁徙期间使用个体记忆（Xs），且全局记忆（Xg）由 AT_w 惯性因子加权。在繁衍期间，伙伴是随机选取的，这有助于提升多样性，并加快搜索速度。

ATA 中的参数系统简单但有效。它控制种群规模（tribe_size）、行为切换准则（AT_criterion）、以及在搜索上的全局影响（AT_w），令算法灵活而强大，据作者称，这令它能够轻松地与更复杂的算法竞争，尤其是在与小规模种群打交道时。

该算法的主要组成部分包括当进展良好、以及适应度差异大于设定准则时应用的繁衍行为。在这种情况下，个体交换部分信息。迁徙行为被应用在适应度差异较小的不良情况，涉及基于个体和全局经验的运动，同时考虑惯性权重，以此强化全局搜索。存在准则于迭代之间评估最佳适应度的变化：如果变化可观，则使用繁衍，如果变化不可观，则发生迁徙。

该算法还包括一个记忆更新系统，可持续跟踪个体和整个部落的最佳位置。当找到更好的新解时，这些位置就会被更新。

ATA 的设计特点包括参数的简单化、个性和社会学习的融合、以及繁衍和迁徙之间的自适应切换。全局惯性权重提升了搜索性能，加快了搜索最优解的速度。

所以，个体行为的规则可以描述如下：

1. 扩散。一名个体利用种群中的信息来形成子孙后代的遗传物质。如果现有环境状况有利，个体会从部落中随机选择另一名个体，经由遗传信息交换进行杂交，产生下一代。

2. 迁徙。如果现有情况不良（表明最优适应度值的代际差异小于现有准则），则个体根据自己和部落的历史经验，实现部落的迁徙。

视觉上，在算法种群中发生的关键阶段，示意性表述如下。

ATA_2

图例 1. ATA 算法种群中个体运动阶段

我们来实现 ATA 算法伪代码：

// Artificial tribe algorithm
// Main parameters:
// tribe_size - tribe population size
// ATA_criterion - threshold value of the existence criterion
// ATA_w - global inertia weight
// X - vector of the individual's position
// Xs - best historical position of the individual
// Xg - global best historical position of the tribe

ATA 算法：
    Initialization:
        Create a tribe of tribe_size individuals with X random positions
        Calculate the initial fitness values for all individuals
        Initialize Xs and Xg with the best positions found
        iteration = 0
        
    While (iteration < max_iterations):
        iteration = iteration + 1
        
        // Check if the situation is favorable
        difference = |current_best_fitness - previous_best_fitness|
        
        If (difference > ATA_criterion):
            // Good situation - perform reproduction behavior
            For each i individual:
                // Select a random partner j from the tribe
                j = random (1, tribe_size) where j ≠ i
                
                // Reproduction equations:
                r1 = random (0,1)
                Yi+1 = r1 * Yj + (1 - r1) * Xi  // New partner position
                Xi+1 = r1 * Xi + (1- r1) * Yi  // New position of the individual
                
        Otherwise:
            // Bad situation - execute migration behavior
            For each i individual:
                // Migration equation:
                r1 = random (0,1)
                r2 = random (0,1)
                Xi+1 = Xi + r1 * (Xs - Xi) + ATA_w * r2 * (Xg - Xi)
                
        // Update fitness values and best positions
        For each i individual:
            Calculate new_fitness for Xi
            
            If new_fitness is better than best_fitness_of_individual:
                Update Xs for i individual
                
            If new_fitness is better than global_best_fitness:
                Update Xg
                
        Save current_best_fitness for next iteration
        
    Return Xg as the best solution found

ATA

图例 2. ATA 算法操作的逻辑图

我们定义实现 ATA 算法的 C_AO_ATA 类。我们简述一下它的内容：

继承及主要成员：
  • 该类继承自 C_AO 基类
  • 包含析构函数和构造函数
构造函数初始化基本参数：
  • popSize = 50（部落规模）
  • AT_criterion = 0.3（有利状况准则）
  • AT_w = 1.46（惯性权重）
方法：
  • SetParams () — 从 “params” 数组中设置参数
  • Init () — 按搜索范围进行初始化
  • Moving () — 实现个体运动
  • Revision () — 评估和更新解
私密成员：
  • prevBestFitness — 存储以前的最佳值以供比较

这是算法的基本框架，其中定义其操作所需的所有参数和方法。

//——————————————————————————————————————————————————————————————————————————————
class C_AO_ATA : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_ATA () { }
  C_AO_ATA ()
  {
    ao_name = "ATA";
    ao_desc = "Artificial Tribe Algorithm";
    ao_link = "https://www.mql5.com/en/articles/16588";

    popSize      = 50;   // Population size
    AT_criterion = 0.3;  // Criteria for assessing the current situation
    AT_w         = 1.46; // Global inertial weight

    ArrayResize (params, 3);

    // Initialize parameters
    params [0].name = "popSize";      params [0].val = popSize;
    params [1].name = "AT_criterion"; params [1].val = AT_criterion;
    params [2].name = "AT_w";         params [2].val = AT_w;
  }

  void SetParams () // Method for setting parameters
  {
    popSize      = (int)params [0].val;
    AT_criterion = params     [1].val;
    AT_w         = params     [2].val;
  }

  bool Init (const double &rangeMinP  [], // Minimum search range
             const double &rangeMaxP  [], // Maximum search range
             const double &rangeStepP [], // Search step
             const int     epochsP = 0);  // Number of epochs

  void Moving   ();       // Moving method
  void Revision ();       // Revision method

  //----------------------------------------------------------------------------
  double AT_criterion;    // Criteria for assessing the current situation
  double AT_w;            // Global inertial weight

  private: //-------------------------------------------------------------------
  double prevBestFitness; // Previous best solution
};
//——————————————————————————————————————————————————————————————————————————————

C_AO_ATA 类的 Init 方法负责初始化算法。我们把它分解成几个部分：

方法参数：
  • rangeMinP [] — 每次搜索维度的最小值数组
  • rangeMaxP [] — 最大值数组
  • rangeStepP [] — 离散化步骤数组
  • epochsP — 局次数（默认为 0）
主要动作：
  • 从基类调用 StandardInit，来初始化标准参数
  • 如果 StandardInit 返回 false，则方法中断
  • 将 prevBestFitness 设置为 -DBL_MAX（对于最大化任务）
返回：
  • true初始化成功
  • false，如果标准初始化失败

这是初始化的最小实现，为算法的工作做好准备。

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_ATA::Init (const double &rangeMinP  [], // Minimum search range
                     const double &rangeMaxP  [], // Maximum search range
                     const double &rangeStepP [], // Search step
                     const int     epochsP = 0)   // Number of epochs
{
  if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false; // Initialization of standard parameters

  //----------------------------------------------------------------------------
  prevBestFitness = -DBL_MAX;
  return true;
}
//——————————————————————————————————————————————————————————————————————————————

Moving() 方法负责部落个体的运动，由两个主要部分组成：

如果这是第一次运行（revision = false）：
  • 在搜索空间中随机安置所有个体
  • 把它们的位置带至可接受的离散值
  • 标记初始放置已完成（revision = true）
如果这并非第一次运行，则计算当前 diff 状况准则，如果状况良好（diff > AT_criterion）：
  • 每名个体都随机选择一个合作伙伴
  • 他们交换有关其位置的信息
  • 基于交换信息形成新位置
如果状况很糟糕（diff ≤ AT_criterion），每名个体都会考虑：
  • 您的最佳位置
  • 全球最佳位置
  • AT_w 惯性权重

每当有任何变动时，检查所有新位置，并达到指定范围内的可接受值。此外，能注意以下细微差别：由于评估状况的准则是外部参数，并且具有无量纲值，因此有必要按最佳和最差历史适应度，归一化当前最佳适应度和前一个适应度之间的差异：diff = (fB - prevBestFitness) / (fB - fW)。正是出于这些目的，该算法不仅跟踪全局最佳解，也跟踪全局最差解。

//——————————————————————————————————————————————————————————————————————————————
void C_AO_ATA::Moving ()
{
  // Initial random positioning
  if (!revision) // If there has not been a revision yet 
  {
    for (int i = 0; i < popSize; i++) // For each particle
    {
      for (int c = 0; c < coords; c++) // For each coordinate
      {
        a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);                             // Generate random position
        a [i].c [c] = u.SeInDiSp  (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); // Convert to discrete values
      }
    }

    revision = true; // Set revision flag
    return;          // Exit the method
  }

  //----------------------------------------------------------------------------
  // Check the existence criterion
  double diff = (fB - prevBestFitness) / (fB - fW);

  double Xi   = 0.0;
  double Xi_1 = 0.0;
  double Yi   = 0.0;
  double Yi_1 = 0.0;
  double Xs   = 0.0;
  double Xg   = 0.0;
  int    p    = 0;
  double r1   = 0.0;
  double r2   = 0.0;

  if (diff > AT_criterion)
  {
    // Spread behavior (good situation)
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        p  = u.RNDminusOne (popSize);
        r1 = u.RNDprobab ();

        Xi = a [i].cP [c];
        Yi = a [p].cP [c];

        Xi_1 = r1 * Xi + (1.0 - r1) * Yi;
        Yi_1 = r1 * Yi + (1.0 - r1) * Xi;

        a [i].c [c] = u.SeInDiSp  (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
        a [p].c [c] = u.SeInDiSp  (Yi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }
  }
  else
  {
    // Migration behavior (bad situation)
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        r1 = u.RNDprobab ();
        r2 = u.RNDprobab ();

        Xi = a [i].cP [c];
        Xs = a [i].cB [c];
        Xg = cB [c];

        Xi_1 = Xi + r1 * (Xs - Xi) + AT_w * r2 * (Xg - Xi);

        a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Revision () 负责评估和更新个体移动后的最佳解。这是它的所作作为：

对于部落中的所有个体：
    • 检查全局最佳解（fB）是否得到改进
    • 更新找到的最差解（fW）
    • 检查并更新每名个体的最佳解（a [i].fB）
    • 将当前位置保存为前一个位置（在 cP 当中）
    如果找到新的最佳解（indB 不是 -1）：
      • 保存以前的最佳值（prevBestFitness = tempB）
      • 将最佳个体的坐标复制到全局最佳解（cB）当中

      本质上，这是一种“审计”部落当前状态的方法，其中所有重要指标都被更新：全局最佳/最差值、每名个体的最佳值、以及位置历史记录都被保存。

      //——————————————————————————————————————————————————————————————————————————————
void C_AO_ATA::Revision ()
{
  //----------------------------------------------------------------------------
  int    indB  = -1;                // Best particle index
  double tempB = fB;

  for (int i = 0; i < popSize; i++) // For each particle
  {
    if (a [i].f > fB)               // If the function value is better than the current best one
    {
      fB   = a [i].f;               // Update the best value of the function
      indB = i;                     // Save the index of the best particle
    }

    if (a [i].f < fW)               // If the function value is worse than the current worst one
    {
      fW   = a [i].f;               // Update the worst value of the function
    }

    if (a [i].f > a [i].fB)
    {
      a [i].fB = a [i].f;
      ArrayCopy (a [i].cB, a [i].c, 0, 0, WHOLE_ARRAY);
    }

    ArrayCopy (a [i].cP, a [i].c, 0, 0, WHOLE_ARRAY);
  }

  if (indB != -1)
  {
    prevBestFitness = tempB;
    ArrayCopy (cB, a [indB].c, 0, 0, WHOLE_ARRAY); // Copy the coordinates of the best particle
  }
}
//——————————————————————————————————————————————————————————————————————————————

      我们转去测试台上测试 ATA 算法的结果。

      ATA|Artificial Tribe Algorithm|50.0|0.3|0.5|
      =============================
      5 Hilly's; Func runs: 10000; result: 0.540711768815426
      25 Hilly's; Func runs: 10000; result: 0.31409437631469717
      500 Hilly's; Func runs: 10000; result: 0.2512638813618161
      =============================
      5 Forest's; Func runs: 10000; result: 0.40309649266442193
      25 Forest's; Func runs: 10000; result: 0.2572536671383149
      500 Forest's; Func runs: 10000; result: 0.18349902023635473
      =============================
      5 Megacity's; Func runs: 10000; result: 0.24
      25 Megacity's; Func runs: 10000; result: 0.13600000000000004
      500 Megacity's; Func runs: 10000; result: 0.09518461538461616
      =============================
      All score: 2.42110 (26.90%)

      从打印输出的算法结果、和可视化可以看出，该算法无法遵照当前参数进入我们的评级表。下面的可视化展示出该算法逃离局部陷阱的能力较弱。该算法的解种群显然缺乏多样性，这导致了其退化。

      Hilly Orig

      在 Hilly 测试函数上的 ATAm

      我们尝试专注于种群中缺乏解多样性来改进 ATA 算法。这是一个重要层面，因为多样性是有效搜索解空间的关键。在我们的修改中，我们将引入动态概率，其将取决于种群适应度的状态。

      当种群被压缩至解空间的狭窄范围内时，它就会导致算法陷入局部最优。就像在算法的原始版本中一样，我们将跟踪当前和以前的最佳全局解之间的差异，但如果这种差异证实太小，这将是种群多样化不足的一个信号，或许正在接近解崩溃。

      为了防止这种状况，我们会在一定概率下驱逐那些与当前全局解相去甚远的个体。这将在任务的可接受范围内发生，其会确保满足任务的条件，并防止其超界。我们将使用正态分布来判定被舍弃个体距当前全局解的远近。

      有趣的是，当前和以前的最佳解（表示为 “diff”）之间的差异越大，这样的异常值概率就越高。这将令我们能够适应种群的状态：当它开始陷入困境时，我们将更积极地运用迁徙阶段，这反过来又会增加脱离局部最优、并找到更优解的机会。

      因此，我们修改的 ATA 算法不仅有助于保持解的多样性，而且还能提升搜索解空间的整体效率。这能够导致更可持续的结果，以及更高品质的解。

      //——————————————————————————————————————————————————————————————————————————————
void C_AO_ATAm::Moving ()
{
  // Initial random positioning
  if (!revision) // If there has not been a revision yet 
  {
    for (int i = 0; i < popSize; i++) // For each particle
    {
      for (int c = 0; c < coords; c++) // For each coordinate
      {
        a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);                             // Generate random position
        a [i].c [c] = u.SeInDiSp  (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]); // Convert to discrete values
      }
    }

    revision = true; // Set revision flag
    return;          // Exit the method
  }

  //----------------------------------------------------------------------------
  // Check the existence criterion
  double diff = (fB - prevBestFitness) / (fB - fW);

  double Xi   = 0.0;
  double Xi_1 = 0.0;
  double Yi   = 0.0;
  double Yi_1 = 0.0;
  double Xs   = 0.0;
  double Xg   = 0.0;
  int    p    = 0;
  double r1   = 0.0;
  double r2   = 0.0;

  if (diff > AT_criterion)
  {
    // Spread behavior (good situation)
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        p  = u.RNDminusOne (popSize);
        r1 = u.RNDprobab ();

        Xi = a [i].cP [c];
        Yi = a [p].cP [c];

        Xi_1 = r1 * Xi + (1.0 - r1) * Yi;
        Yi_1 = r1 * Yi + (1.0 - r1) * Xi;

        a [i].c [c] = u.SeInDiSp  (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
        a [p].c [c] = u.SeInDiSp  (Yi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }
  }
  else
  {
    // Migration behavior (bad situation)
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        if (u.RNDprobab () < diff)
        {
          Xi_1 = u.GaussDistribution (cB [c], rangeMin [c], rangeMax [c], 1);
          a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
        }
        else
        {
          r1 = u.RNDprobab ();
          r2 = u.RNDprobab ();

          Xi = a [i].cP [c];
          Xs = a [i].cB [c];
          Xg = cB [c];

          Xi_1 = Xi + r1 * (Xs - Xi) + AT_w * r2 * (Xg - Xi);

          a [i].c [c] = u.SeInDiSp (Xi_1, rangeMin [c], rangeMax [c], rangeStep [c]);
        }
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————


      测试结果

      ATAm 算法修改版的结果：

      ATAm|Artificial Tribe Algorithm M|50.0|0.9|0.8|
      =============================
      5 Hilly's; Func runs: 10000; result: 0.7177133636761123
      25 Hilly's; Func runs: 10000; result: 0.553035897955171
      500 Hilly's; Func runs: 10000; result: 0.25234636879284034
      =============================
      5 Forest's; Func runs: 10000; result: 0.8249072382287125
      25 Forest's; Func runs: 10000; result: 0.5590392181296365
      500 Forest's; Func runs: 10000; result: 0.2047284499286112
      =============================
      5 Megacity's; Func runs: 10000; result: 0.43999999999999995
      25 Megacity's; Func runs: 10000; result: 0.18615384615384617
      500 Megacity's; Func runs: 10000; result: 0.09410769230769304
      =============================
      All score: 3.83203 (42.58%)

      这一次的结果被证实更有前景，已经值得列入评级表，这令我们能够取代另一个局外人。可视化展示出种群中个体跨解空间更加活跃的移动。然而，一个新问题出现了：结果存在明显的扩散，并且不可能完全摆脱陷入局部最优状态的困扰。

      Hilly

      在 Hilly 测试函数上的 ATAm

      Forest

      在 Forest 测试函数上的 ATAm

      Megacity

      在 Megacity 测试函数上的 ATAm

      人工部落算法在排名表中位居第 33 位。

      # 算法 说明 Hilly Hilly 最终 Forest Forest 最终 Megacity (离散) Megacity 最终 最终结果 最大 %
      10 p (5 F) 50 p (25 F) 1000 p (500 F) 10 p (5 F) 50 p (25 F) 1000 p (500 F) 10 p (5 F) 50 p (25 F) 1000 p (500 F)
      1 ANS 跨邻域搜索 0.94948 0.84776 0.43857 2.23581 1.00000 0.92334 0.39988 2.32323 0.70923 0.63477 0.23091 1.57491 6.134 68.15
      2 CLA 代码锁定算法（JOO） 0.95345 0.87107 0.37590 2.20042 0.98942 0.91709 0.31642 2.22294 0.79692 0.69385 0.19303 1.68380 6.107 67.86
      3 AMOm 动物迁徙优化 M 0.90358 0.84317 0.46284 2.20959 0.99001 0.92436 0.46598 2.38034 0.56769 0.59132 0.23773 1.39675 5.987 66.52
      4 (P+O)ES （P+O）进化策略 0.92256 0.88101 0.40021 2.20379 0.97750 0.87490 0.31945 2.17185 0.67385 0.62985 0.18634 1.49003 5.866 65.17
      5 CTA 彗尾算法（JOO） 0.95346 0.86319 0.27770 2.09435 0.99794 0.85740 0.33949 2.19484 0.88769 0.56431 0.10512 1.55712 5.846 64.96
      6 SDSm 随机扩散搜索 M 0.93066 0.85445 0.39476 2.17988 0.99983 0.89244 0.19619 2.08846 0.72333 0.61100 0.10670 1.44103 5.709 63.44
      7 AAm 射箭算法 M 0.91744 0.70876 0.42160 2.04780 0.92527 0.75802 0.35328 2.03657 0.67385 0.55200 0.23738 1.46323 5.548 61.64
      8 ESG 社会群体的进化（JOO） 0.99906 0.79654 0.35056 2.14616 1.00000 0.82863 0.13102 1.95965 0.82333 0.55300 0.04725 1.42358 5.529 61.44
      9 SIA 模拟各向同性退火（JOO） 0.95784 0.84264 0.41465 2.21513 0.98239 0.79586 0.20507 1.98332 0.68667 0.49300 0.09053 1.27020 5.469 60.76
      10 ACS 人工协作搜索 0.75547 0.74744 0.30407 1.80698 1.00000 0.88861 0.22413 2.11274 0.69077 0.48185 0.13322 1.30583 5.226 58.06
      11 ASO 无政府状态社会优化 0.84872 0.74646 0.31465 1.90983 0.96148 0.79150 0.23803 1.99101 0.57077 0.54062 0.16614 1.27752 5.178 57.54
      12 AOSm 原子环路搜索 M 0.80232 0.70449 0.31021 1.81702 0.85660 0.69451 0.21996 1.77107 0.74615 0.52862 0.14358 1.41835 5.006 55.63
      13 TSEA 龟壳进化算法（JOO） 0.96798 0.64480 0.29672 1.90949 0.99449 0.61981 0.22708 1.84139 0.69077 0.42646 0.13598 1.25322 5.004 55.60
      14 DE 差异进化 0.95044 0.61674 0.30308 1.87026 0.95317 0.78896 0.16652 1.90865 0.78667 0.36033 0.02953 1.17653 4.955 55.06
      15 CRO 化学反应优化 0.94629 0.66112 0.29853 1.90593 0.87906 0.58422 0.21146 1.67473 0.75846 0.42646 0.12686 1.31178 4.892 54.36
      16 BSA 鸟群算法 0.89306 0.64900 0.26250 1.80455 0.92420 0.71121 0.24939 1.88479 0.69385 0.32615 0.10012 1.12012 4.809 53.44
      17 HS 和谐搜索 0.86509 0.68782 0.32527 1.87818 0.99999 0.68002 0.09590 1.77592 0.62000 0.42267 0.05458 1.09725 4.751 52.79
      18 SSG 苗木播种和生长 0.77839 0.64925 0.39543 1.82308 0.85973 0.62467 0.17429 1.65869 0.64667 0.44133 0.10598 1.19398 4.676 51.95
      19 BCOm 细菌趋化性优化 M 0.75953 0.62268 0.31483 1.69704 0.89378 0.61339 0.22542 1.73259 0.65385 0.42092 0.14435 1.21912 4.649 51.65
      20 ABO 非洲水牛优化 0.83337 0.62247 0.29964 1.75548 0.92170 0.58618 0.19723 1.70511 0.61000 0.43154 0.13225 1.17378 4.634 51.49
      21 (PO)ES （PO）进化策略 0.79025 0.62647 0.42935 1.84606 0.87616 0.60943 0.19591 1.68151 0.59000 0.37933 0.11322 1.08255 4.610 51.22
      22 TSm 禁忌搜索 M 0.87795 0.61431 0.29104 1.78330 0.92885 0.51844 0.19054 1.63783 0.61077 0.38215 0.12157 1.11449 4.536 50.40
      23 BSO 头脑风暴优化 0.93736 0.57616 0.29688 1.81041 0.93131 0.55866 0.23537 1.72534 0.55231 0.29077 0.11914 0.96222 4.498 49.98
      24 WOAm 韦尔优化算法 M 0.84521 0.56298 0.26263 1.67081 0.93100 0.52278 0.16365 1.61743 0.66308 0.41138 0.11357 1.18803 4.476 49.74
      25 AEFA 人工电场算法 0.87700 0.61753 0.25235 1.74688 0.92729 0.72698 0.18064 1.83490 0.66615 0.11631 0.09508 0.87754 4.459 49.55
      26 AEO 基于人工生态系统的优化算法 0.91380 0.46713 0.26470 1.64563 0.90223 0.43705 0.21400 1.55327 0.66154 0.30800 0.28563 1.25517 4.454 49.49
      27 ACOm 蚁群优化 M 0.88190 0.66127 0.30377 1.84693 0.85873 0.58680 0.15051 1.59604 0.59667 0.37333 0.02472 0.99472 4.438 49.31
      28 BFO-GA 细菌觅食优化 - GA 0.89150 0.55111 0.31529 1.75790 0.96982 0.39612 0.06305 1.42899 0.72667 0.27500 0.03525 1.03692 4.224 46.93
      29 SOA 简单优化算法 0.91520 0.46976 0.27089 1.65585 0.89675 0.37401 0.16984 1.44060 0.69538 0.28031 0.10852 1.08422 4.181 46.45
      30 ABHA 人工蜂巢算法 0.84131 0.54227 0.26304 1.64663 0.87858 0.47779 0.17181 1.52818 0.50923 0.33877 0.10397 0.95197 4.127 45.85
      31 ACMO 大气云层模型优化 0.90321 0.48546 0.30403 1.69270 0.80268 0.37857 0.19178 1.37303 0.62308 0.24400 0.10795 0.97503 4.041 44.90
      32 ADAMm 自适应动量评估 M 0.88635 0.44766 0.26613 1.60014 0.84497 0.38493 0.16889 1.39880 0.66154 0.27046 0.10594 1.03794 4.037 44.85
      33 ATAm 人工部落算法 M 0.71771 0.55304 0.25235 1.52310 0.82491 0.55904 0.20473 1.58867 0.44000 0.18615 0.09411 0.72026 3.832 42.58
      34 ASHA 人工淋浴算法 0.89686 0.40433 0.25617 1.55737 0.80360 0.35526 0.19160 1.35046 0.47692 0.18123 0.09774 0.75589 3.664 40.71
      35 ASBO 自适应社会行为优化 0.76331 0.49253 0.32619 1.58202 0.79546 0.40035 0.26097 1.45677 0.26462 0.17169 0.18200 0.61831 3.657 40.63
      36 MEC 心智进化计算 0.69533 0.53376 0.32661 1.55569 0.72464 0.33036 0.07198 1.12698 0.52500 0.22000 0.04198 0.78698 3.470 38.55
      37 IWO 入侵杂草优化 0.72679 0.52256 0.33123 1.58058 0.70756 0.33955 0.07484 1.12196 0.42333 0.23067 0.04617 0.70017 3.403 37.81
      38 Micro-AIS 微型人工免疫系统 0.79547 0.51922 0.30861 1.62330 0.72956 0.36879 0.09398 1.19233 0.37667 0.15867 0.02802 0.56335 3.379 37.54
      39 COAm 布谷鸟优化算法M 0.75820 0.48652 0.31369 1.55841 0.74054 0.28051 0.05599 1.07704 0.50500 0.17467 0.03380 0.71347 3.349 37.21
      40 SDOm 螺旋动力学优化 M 0.74601 0.44623 0.29687 1.48912 0.70204 0.34678 0.10944 1.15826 0.42833 0.16767 0.03663 0.63263 3.280 36.44
      41 NMm Nelder-Mead 方法 M 0.73807 0.50598 0.31342 1.55747 0.63674 0.28302 0.08221 1.00197 0.44667 0.18667 0.04028 0.67362 3.233 35.92
      42 FAm 萤火虫算法 M 0.58634 0.47228 0.32276 1.38138 0.68467 0.37439 0.10908 1.16814 0.28667 0.16467 0.04722 0.49855 3.048 33.87
      43 GSA 引力搜索算法 0.64757 0.49197 0.30062 1.44016 0.53962 0.36353 0.09945 1.00260 0.32667 0.12200 0.01917 0.46783 2.911 32.34
      44 BFO 细菌觅食优化 0.61171 0.43270 0.31318 1.35759 0.54410 0.21511 0.05676 0.81597 0.42167 0.13800 0.03195 0.59162 2.765 30.72
      45 ABC 人工蜂群 0.63377 0.42402 0.30892 1.36671 0.55103 0.21874 0.05623 0.82600 0.34000 0.14200 0.03102 0.51302 2.706 30.06



      总结

      在本文中，我们详研了一种最现代的优化算法 — ATA 算法。尽管与其它方法相比，其性能并不出色，但它为我们理解动态种群状态管理、以及分析与局部最优相关问题的方法做出了宝贵的贡献。

      对 ATA 算法的兴趣不仅限于其两个主要阶段，其本身作为求解方法价值甚微。更重要的是动态选择个体运动阶段、及控制种群状态的方式。正是这一层面，令我们能够更有效地把算法适配到正变化的问题条件，并提升所获解的品质。因此，ATA 的研究为算法优化领域的进一步研究开辟了新的视野，可作为开发更先进方法的基础。

      我还确信可将各种算子应用于正在讨论的算法，这将显著提高其效率。例如，使用基于排序或交叉的选择算子可显著改善结果。

      不过，值得注意的是，当前版本的算法对解的品质没有任何依赖性，也缺乏组合属性，这限制其能力。所有这些层面都代表了进一步研究和改进的有趣方向，尽管它们超出了本文的范畴。如果任何读者决定尝试提议的变化，并在评论中分享他们的算法版本，我将非常高兴。

      表格

      图例 3. 算法的颜色渐变根据相关测试，大于或等于 0.99 的结果以白色高亮显示

      图表

      图例 4. 算法测试结果直方图（比例从 0 到 100，越高越好， 其中 100 是最大可能的理论结果，存档中有一个用于计算评级表的脚本）

      ATAm 的优缺点：

      优点：

      1. 外部参数数量少。
      2. 实现简单。
      3. 动态切换搜索策略的思路很有趣。

      缺点：

      1. 结果离散度高。
      2. 收敛精度低。
      3. 容易卡住。

      本文附有一个存档，其中包含当前版本的算法代码。文章作者对于规范算法描述的绝对准确性不予负责。其中许多都进行了修改，以便提高搜索能力。文章呈现的结论和判断是基于实验结果。

      文章中用到的程序

      # 名字 类型 说明
      1 #C_AO.mqh
      		 包含
      		 群落优化算法的父类
      2 #C_AO_enum.mqh
      		 包含
      		 群落优化算法的枚举
      3 TestFunctions.mqh
      		 包含
      		 测试函数函数库
      4
      		 TestStandFunctions.mqh
      		 包含
      		 测试台函数库
      5
      		 Utilities.mqh
      		 包含
      		 辅助函数库
      6
      		 CalculationTestResults.mqh
      		 包含
      		 计算比较结果表格的脚本
      7
      		 Testing AOs.mq5
      		 脚本 所有种群优化算法的统一测试台
      8
      		 Simple use of population optimization algorithms.mq5
      		 脚本
      		无可视化的种群优化算法的简单示例
      9
      		Test_AO_ATAm.mq5
      		 脚本 ATAm 测试台

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

      附加的文件 |
      下载ZIP
      ATAm.zip (145.57 KB)

      注意: MetaQuotes Ltd.将保留所有关于这些材料的权利。全部或部分复制或者转载这些材料将被禁止。

      本文由网站的一位用户撰写，反映了他们的个人观点。MetaQuotes Ltd 不对所提供信息的准确性负责，也不对因使用所述解决方案、策略或建议而产生的任何后果负责。

      该作者的其他文章

      前往讨论
      从基础到中级：递归 从基础到中级：递归
      在本文中，我们将探讨一个非常有趣且颇具挑战性的编程概念，尽管应该非常谨慎地对待它，因为它的误用或误解会将相对简单的程序变成不必要的复杂程序。但是，当正确使用并完全适应同样合适的情况时，递归成为解决问题的绝佳盟友，否则这些问题会更加费力和耗时。此处提供的材料仅用于教育目的。在任何情况下，除了学习和掌握所提出的概念外，都不应出于任何目的使用此应用程序。
      重新定义MQL5与MetaTrader 5指标 重新定义MQL5与MetaTrader 5指标
      MQL5中一种创新的指标信息收集方法，使开发者能够向指标传递自定义输入参数以进行即时计算，从而实现了更灵活、更高效的数据分析。这种方法在算法交易中尤为实用，因为它能突破传统限制，增强对指标所处理信息的掌控力。
      交易中的趋势准则 交易中的趋势准则
      趋势是许多交易策略的重要组成部分。在本文中，我们将考察一些用来识别趋势及其特征的工具。理解并正确解释趋势，能够显著提升交易效率，并将风险最小化。
      价格行为分析工具包开发（第九部分）：外部数据流 价格行为分析工具包开发（第九部分）：外部数据流
      本文将利用专为高级分析而设计的外部库，探索一个全新的分析维度。这些库（如pandas）提供了强大的工具，用于处理和解读复杂数据，使交易者能够更深入地洞察市场动态。通过整合此类技术，我们能够整合原始数据与可执行策略之间的差距。加入我们，共同为这一创新方法奠定基础，并释放技术与交易专业知识相结合的潜力。