群体优化算法：思维进化计算（MEC）算法

目录

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

1. 概述

进化计算是计算智能、机器学习和人工智能的一个子领域。它广泛用于优化问题、机器人设计、创建决策树、调整数据分析算法、训练神经网络和调整超参数。进化计算不是使用经典的数值方法，而是利用生物进化的灵感来开发好的解决方案。当没有已知的适应度函数导数时，或者当适应度函数具有许多局部极值时，它们尤其有用，这些极值可能会阻碍序列方法。

在解决复杂的高维问题时，进化计算中使用的群体算法比经典算法具有许多优势。它们可以更有效地找到与最优解足够接近的次优解，这在实际优化问题中通常是可以接受的。

进化计算中一种有趣的方法是Chengai和他的合著者于1998年提出的思维进化计算（Mind Evolutionary Computation，MEC）算法。与所预期的人脑建模不同，MEC算法对人类社会行为的某些方面进行建模。在这种算法中，每个人都被视为在一群人中发挥作用的智能体。在做出决定时，个人会感到受到其团队成员和其他团队成员的影响。要想在社会上获得崇高的地位，个人必须向团队中最成功的人学习。同时，为了使他的团队比其他团队更成功，所有个人在团队间竞争中都必须遵循相同的原则。MEC算法的一个重要方面是组内个体之间以及组之间的信息交换。这反映出需要持续和自由地交换信息，以成功发展一个由聪明的个人组成的社会。

MEC算法分别使用负责局部搜索和全局搜索的局部竞争和异化操作来实现所提出的概念。该算法使用留言板来存储有关种群进化历史的信息。基于该信息来控制优化过程。

2. 算法

MEC算法可以被解释为由领先和滞后组组成的多种群算法。假设每组中的代理数量相同。每个组都有自己的本地留言板，还有一个用于整个多种群的通用全局留言板。

MEC算法的原始版本被称为简单MEC（SMEC），使用了组初始化、局部竞争和异化操作。

初始化操作创建组并将它们放置在搜索区域中。对于每个组，都会生成一个随机向量，该向量与组中的个体相识别。然后，确定组中剩余代理的初始坐标，使用正态分布定律将它们随机放置在组中的个体周围。

局部竞争操作实现对每组的最大适应度函数的局部搜索。对于每个组，都会从其留言板上读取有关当前获胜代理的信息。然后，确定组中剩余代理的新坐标，并使用正态分布定律将其随机放置在获胜者周围。计算组代理的新帐户，并确定具有最大当前帐户的新组获胜者。有关新获胜者的信息发布在小组留言板上。

异化操作控制着全局搜索。首先，读取消息公告板中所有组的帐户。然后将这些账户相互比较。如果领头小组的得分低于其中一个落后小组的得分，那么后者将取代领头者，领头小组将变得落后。如果一个组的得分低于所有落后组的得分，则该组将从群体中移除。使用初始化操作初始化新组，而不是删除组。

因此，MEC算法是一种包括初始化、局部竞争和异化操作的多种群算法。

以上是算法创建者对简单MEC算法的一般描述。在我看来，这样的描述使我们很难理解多维空间中搜索策略的基本原理。因此，出现了许多问题，例如“什么是留言板，它与群体中特定个人的特征有何不同？”和其他问题，所以让我们仔细看看这些微妙之处。

上面已经说过，该算法模拟了人类社会及其成员之间的互动。想象“观念”概念最简单明了的方法是，它可以是科学的观念，也可以是艺术的、文学的或任何其他的。社会上总是有占主导地位的思想和另类的思想。与作者不同的是，我不会根据群体将思想划分为“领先和落后”。正如我们将在下面看到的，与基本版本相比，这将给算法带来一些优势。由于每个想法至少包括一个理论（理论是适应度函数的优化参数），一个想法可以有思想分支，就像在科学中有各种科学理论和运动一样。图1示意性地显示了标记为i1、i2等的思想。每个想法都可以在思维能力（算法的外部参数）确定的范围内给出分支。分支离想法越远，可能性就越小（意识形态分支的概率和边界显示为不断扩大的同心圆）。如果该思想显示出其自身比其意识形态父思想更一致（适应度函数的值更好），那么该分支将取代父思想（作为意识形态分支的结果的新思想在图中显示为i5）。在图中，我们可以看到，跨越意识形态边界没有任何限制，这意味着出现具有相同理论的意识形态分支是可能的。

图1. 想法 i1、i2、i3、i4、它们的边界、边界的交叉点以及由于思想i1的分支而出现的新思想i5

思想分支在每个思想中实现局部竞争，并在局部极值附近提供搜索。所有思想的多个分支代表多个群体，而单个思想及其分支代表单个群体。每个想法只存储其理论和实践价值，用户程序指的是思想分支，而不是想法本身。

为了确保全局搜索，有必要确保在群体中出现超出当前想法的新想法，否则这些想法将陷入局部极值，并且不会出现更好的适应度函数值。异化（销毁）的过程就是为了这个目的。我们将使用与原始算法中略有不同的方案来交换主导组（绿色）思想和替代组（蓝色）思想。在对每个群体的想法进行单独分类后，我们从占主导地位的群体中去除最差的想法，用另一个群体中最好的想法取代它，从而确保想法的交流。在备选组的空位上，我们放置了一个新的想法，它是从优势组（不包括最后一个）中随机选择的想法的摘要中组装而成的。为了提供可变性，可以在这个动作中添加随机成分，我将其留给优化算法研究人员可能进行的进一步实验。从优势群体的思想中选择摘要增加了算法的组合能力。下面的图2显示了从一个替代组中替换一个想法并创建一个新想法的示意图。

图 2替换备选小组的想法并创建一个新小组

让我们编写MEC伪代码来简化算法代码的进一步编写：

1.1如果是第一次运行算法
1.1.1 根据想法领域（主导和替代）随机创建两组想法

1.2 在第二次和后续运行算法的情况下
1.2.1 对于根据Levy定律*创建分支的主导思想，其中一个分支将是主导思想的理论组合的结果。
1.2.2 对于另一种想法，所有想法分支都是根据Levy定律创建的*

2 计算意识形态分支的价值

3.1 如果有更好的意识形态分支，请替换相应的思想
3.2 分别对优势组和备选组进行排序
3.3 将占主导地位的群体的最差想法替换为替代群体的更好想法
3.4 不要在替代组中创建一个空的想法，而是基于主导组**的元素创建一个新的想法（除了最后一个被替换的元素之外的所有元素）


* - 而不是作者提出的正态分布
** -而不是创建作者提出的随机理论

我们可以从伪代码中看出，原来的算法已经发生了变化。

首先，我们使用了Levy飞行定律，而不是算法作者提出的正态分布定律，这增加了算法的研究和精化能力。注意，如果我们试图使用Levy飞行定律来代替正态分布或均匀分布，那么它并不总是能够提高每个优化算法的效率。这主要是由于算法搜索策略的特殊性。例如，在上一篇文章中，我们研究了混合蛙跳算法。我试图在蛙跳中使用Levy飞行定律，而不是正态分布，这并没有显著改善搜索性能。

其次，原始算法在搜索策略中没有提供任何组合机制。让我们试着弄清楚为什么这一点极其重要。例如，想象几个篮子里装着铝（轻）球和一个金（重）球。我们的任务是将球收集到一个空篮子中，使它们都是金球，同时我们可以平稳地改变篮子中每个新球的化学成分，但不知道这是否会增加质量，或者简单地随机取一个放在其中一个篮子中的球。我们知道其中一个一定是金球，我们只能称整个篮筐的重量，而不能单独称球的重量。一旦我们有了一个装满的篮子，我们就必须称重，挑战是最大限度地增加篮子的重量。这个问题表明，通过简单的组合，我们可以用更少的步骤收集一篮金球。

让我们继续介绍算法代码。

算法的基本逻辑单元是想法，它也将代表一个想法分支。S_Idea结构非常适合描述一个想法。这是一个包含关于坐标和想法适用性的信息的对象。该结构的特点是Init方法，便于用负值DBL_MAX初始化适应度。

//——————————————————————————————————————————————————————————————————————————————
struct S_Idea
{
  void Init (int size)
  {
    ArrayResize (c, size);
    f = -DBL_MAX;
  }
  double c []; //coordinates
  double f;    //fitness
};
//——————————————————————————————————————————————————————————————————————————————

在C_AO_MEC类中，描述MEC算法。它包含许多变量以及使用这些变量的方法。

类变量：
- cB: 包含最佳坐标的数组
- fB: 最佳坐标的适应度函数值
- idBr: 包含意识形态分支的数组

- rangeMax: 包含最大搜索值的数组
- rangeMin: 包含最小搜索值的数组
- rangeStep: 包含搜索步骤的数组

- leadIdeolGroup: 包含主要意识形态团体的数组
- alteIdeolGroup: 包含替代意识形态团体的数组
- tempIdeolGroup: 包含临时意识形态团体的数组

- coordinatesNumber: 坐标数
- populationSize: 群体大小
- ideasNumber: 想法数量
- thoughtPower: 思想的力量
- ideasBr: 意识形态分支的数量
- leadIdGroupSize: 领先思想小组的大小
- alteIdGroupSize: 替换类意识形态团体的大小

- vect: 使用坐标增量的矢量
- ind: 索引数组
- val: 数值数组
- revision: 修改标志

类方法：
- Init: 使用传递参数初始化类
- Moving: 执行移动
- Revision

- Sorting: 对意识形态组进行排序
- SeInDiSp: 搜索间隙计算
- RNDfromCI: 从给定间隔生成随机数

//——————————————————————————————————————————————————————————————————————————————
class C_AO_MEC
{
  //----------------------------------------------------------------------------
  public: double cB   []; //best coordinates
  public: double fB;      //FF of the best coordinates
  public: S_Idea idBr []; //ideological branches


  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search


  public: void Init (const int    coordinatesNumberP,   //coordinates number
                     const int    populationSizeP,      //population size
                     const int    ideasNumberP,         //ideas number
                     const double thoughtPowerP);       //thought power

  public: void Moving   ();
  public: void Revision ();

  //----------------------------------------------------------------------------
  private: S_Idea leadIdeolGroup []; //leading ideological group
  private: S_Idea alteIdeolGroup []; //alternative ideological group
  private: S_Idea tempIdeolGroup []; //temporal ideological group

  private: int    coordinatesNumber; //coordinates number
  private: int    populationSize;    //population size
  private: int    ideasNumber;       //ideas number
  private: double thoughtPower;      //thought power
  private: int    ideasBr;           //number of ideological branches
  private: int    leadIdGroupSize;   //leading ideological group size
  private: int    alteIdGroupSize;   //alternative ideological group size

  private: double vect    [];        //vector
  private: int    ind     [];
  private: double val     [];
  private: bool   revision;

  private: void   Sorting   (S_Idea &ideas []);
  private: double SeInDiSp  (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI (double min, double max);
};
//——————————————————————————————————————————————————————————————————————————————

Init初始化方法执行以下操作：

- 在代码的开头，设置随机数生成器的初始值，并将变量fB设置为“double”类型的最小值。
- 接下来，coordinatesNumber、populationSize、ideasNumber和thingPower变量被设置为传递给Init函数的值。
- ideasBr、leadIdGroupSize和alteIdGroupSize的值是基于populationSize和ideasNumber值计算的。
- 使用ArrayResize函数调整rangeMax、rangeMin、rangeStep、vect、ind、val、tempIdeolGroup和cB数组的大小
- 然后使用“for”循环和Init函数在leadIdeolGroup和alteIdeolGroup数组中创建意识形态类的对象
- 意识形态类对象接下来使用“for”循环和Init函数在idBr数组中创建

//——————————————————————————————————————————————————————————————————————————————
void C_AO_MEC::Init (const int    coordinatesNumberP,   //coordinates number
                     const int    populationSizeP,      //population size
                     const int    ideasNumberP,         //ideas number
                     const double thoughtPowerP)        //thought power
{
  MathSrand ((int)GetMicrosecondCount ()); // reset of the generator
  fB       = -DBL_MAX;
  revision = false;

  coordinatesNumber = coordinatesNumberP;
  populationSize    = populationSizeP;
  ideasNumber       = ideasNumberP;
  thoughtPower      = thoughtPowerP;

  ideasBr         = populationSize / ideasNumber;
  leadIdGroupSize = ideasNumber / 2;
  alteIdGroupSize = ideasNumber - leadIdGroupSize;

  ArrayResize (rangeMax,       coordinatesNumber);
  ArrayResize (rangeMin,       coordinatesNumber);
  ArrayResize (rangeStep,      coordinatesNumber);
  ArrayResize (vect,           coordinatesNumber);
  ArrayResize (ind,            alteIdGroupSize, alteIdGroupSize);
  ArrayResize (val,            alteIdGroupSize, alteIdGroupSize);
  ArrayResize (tempIdeolGroup, alteIdGroupSize, alteIdGroupSize);
  ArrayResize (cB,             coordinatesNumber);

  ArrayResize (leadIdeolGroup, leadIdGroupSize);
  for (int i = 0; i < leadIdGroupSize; i++) leadIdeolGroup [i].Init (coordinatesNumber);

  ArrayResize (alteIdeolGroup, alteIdGroupSize);
  for (int i = 0; i < alteIdGroupSize; i++) alteIdeolGroup [i].Init (coordinatesNumber);

  ArrayResize (idBr, populationSize);
  for (int i = 0; i < populationSize; i++) idBr [i].Init (coordinatesNumber);
}
//——————————————————————————————————————————————————————————————————————————————

创建Moving思想分支的方法执行了MEC搜索策略的核心逻辑。部分代码仅在算法的第一次迭代中执行，其余代码在每次迭代中执行。

在第一次迭代中，有必要初始化一个向量，该向量填充了基于范围和思维能力计算的值（这是分支过程中的增量），并在两组中创建想法——主导和替代。要做到这一点，我们将以相等的概率将两组的想法（它们是等效的）分散到整个搜索领域。

//============================================================================
if (!revision)
{
  fB = -DBL_MAX;
  int cnt = 0;

  for (int c = 0; c < coordinatesNumber; c++) vect [c] = (rangeMax [c] - rangeMin [c]) * thoughtPower;

  //--------------------------------------------------------------------------
  for (int i = 0; i < leadIdGroupSize; i++)
  {
    for (int c = 0; c < coordinatesNumber; c++)    
    {
      coord = RNDfromCI (rangeMin [c], rangeMax [c]);
      leadIdeolGroup [i].c [c] = SeInDiSp (coord, rangeMin [c], rangeMax [c], rangeStep [c]);
    }
    leadIdeolGroup [i].f = -DBL_MAX;
  }

  //--------------------------------------------------------------------------
  for (int i = 0; i < alteIdGroupSize; i++)
  {
    for (int c = 0; c < coordinatesNumber; c++)
    {
      coord = RNDfromCI (rangeMin [c], rangeMax [c]);
      alteIdeolGroup [i].c [c] = SeInDiSp (coord, rangeMin [c], rangeMax [c], rangeStep [c]);
    }
    alteIdeolGroup [i].f = -DBL_MAX;
  }

  revision = true;
}

此外，在第一次和随后的迭代中，我们将产生意识形态分支，因为我们已经创造了思想本身。我们恰恰对意识形态分支感兴趣，我们可以使用适应度函数对其进行评估。

创建分支的主要操作是根据Levy的飞行定律，通过思维能力系数进行归一化，从而转移到思想的抽象。我们将根据以下等式对备选组的所有想法以及除最后一个想法外的所有主导组的想法进行此操作：

coord = leadIdeolGroup [i].c [c] + r1 * vect [c] * pow (r2, -2.0);

对于优势群体的最后一个想法，我们将从该群体中随机选择一个想法并取相应指数的理论：

r1 = RNDfromCI (0.0, leadIdGroupSize - 1);
idBr [cnt].c [c] = leadIdeolGroup [(int)r1].c [c];

以下是为这两个群体创建意识形态分支的完整代码：

//----------------------------------------------------------------------------
for (int i = 0; i < leadIdGroupSize; i++)
{
  for (int b = 0; b < ideasBr; b++)
  {
    if (b < ideasBr -1)
    {
      for (int c = 0; c < coordinatesNumber; c++)
      {
        r1 = RNDfromCI (0.0, 1.0);
        r1 = r1 > 0.5 ? 1.0 : -1.0;
        r2 = RNDfromCI (1.0, 20.0);

        coord = leadIdeolGroup [i].c [c] + r1 * vect [c] * pow (r2, -2.0);
        idBr [cnt].c [c] = SeInDiSp (coord, rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }
    else
    {
      for (int c = 0; c < coordinatesNumber; c++)
      {
        r1 = RNDfromCI (0.0, leadIdGroupSize - 1);
        idBr [cnt].c [c] = leadIdeolGroup [(int)r1].c [c];
      }
    }

    cnt++;
  }
}

//----------------------------------------------------------------------------
for (int i = 0; i < alteIdGroupSize; i++)
{
  for (int b = 0; b < ideasBr; b++)
  {
    for (int c = 0; c < coordinatesNumber; c++)
    {
      r1 = RNDfromCI (0.0, 1.0);
      r1 = r1 > 0.5 ? 1.0 : -1.0;
      r2 = RNDfromCI (1.0, 20.0);

      coord = alteIdeolGroup [i].c [c] + r1 * vect [c] * pow (r2, -2.0);
      idBr [cnt].c [c] = SeInDiSp (coord, rangeMin [c], rangeMax [c], rangeStep [c]);
    }

    cnt++;
  }
}

Revision方法旨在根据评估思想分支的结果修订思想，并更新全球解决方案指标。该代码执行以下步骤：

1. cnt和pos变量被初始化。

2. 替换最好的想法：从全球意识形态分支（idBr）中寻找最好的意识形态分支发生在领先群体（leadIdeolGroup）中每个领先者的循环中。对于每个分支，我们检查其适应度函数值（f）是否大于当前前导的值，然后将位置（pos）设置为等于当前索引（cnt）。如果找到了更好的想法，函数值和引线坐标将使用该想法的值进行更新。如果新思想的特征值也大于当前最佳特征值（fB），则fB和最佳思想的坐标（cB）也被更新。

3. 备选解决方案组（alteIdeolGroup）也是如此。

4. 排序思想组：按照适应度函数值的降序对领先者和备选思路组进行排序。

5. 替换最坏的想法：领先者组（leadIdeolGroup）中的最坏想法被替换为替代解决方案组（alteIdeolGroup）的最佳想法。

6. 创建新想法：对于备选解决方案组（alteIdeolGroup）中的每个坐标（c），基于主导组（leadIdeolGroup）的元素创建新想法。坐标是从占主导地位的领先者群体中随机选择的。

//——————————————————————————————————————————————————————————————————————————————
void C_AO_MEC::Revision ()
{
  int cnt = 0;
  int pos = -1;

  //----------------------------------------------------------------------------
  //4. If there is a better ideological branch, replace the corresponding idea
  for (int i = 0; i < leadIdGroupSize; i++)
  {
    pos = -1;
    for (int b = 0; b < ideasBr; b++)
    {
      if (idBr [cnt].f > leadIdeolGroup [i].f) pos = cnt;

      cnt++;
    }

    if (pos != -1)
    {
      leadIdeolGroup [i].f = idBr [pos].f;
      ArrayCopy (leadIdeolGroup [i].c, idBr [pos].c, 0, 0, WHOLE_ARRAY);

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

  //----------------------------------------------------------------------------
  for (int i = 0; i < alteIdGroupSize; i++)
  {
    pos = -1;
    for (int b = 0; b < ideasBr; b++)
    {
      if (idBr [cnt].f > alteIdeolGroup [i].f) pos = cnt;

      cnt++;
    }

    if (pos != -1)
    {
      alteIdeolGroup [i].f = idBr [pos].f;
      ArrayCopy (alteIdeolGroup [i].c, idBr [pos].c, 0, 0, WHOLE_ARRAY);

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

  //----------------------------------------------------------------------------
  //5. Sort two groups of ideas.
  Sorting (leadIdeolGroup);
  Sorting (alteIdeolGroup);

  //----------------------------------------------------------------------------
  //6. Replace the worst idea of the first group with the best idea from the second group
  leadIdeolGroup [leadIdGroupSize - 1] = alteIdeolGroup [0];

  //----------------------------------------------------------------------------
  //7. Instead of an empty idea, create a new idea based on elements of the dominant group 
  double rnd   = 0.0;
  double coord = 0.0;
  for (int c = 0; c < coordinatesNumber; c++)
  {
    rnd = RNDfromCI (0.0, leadIdGroupSize - 2);
    alteIdeolGroup [0].c [c] = leadIdeolGroup [(int)rnd].c [c];
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. 测试结果

在测试台上打印思维进化算法的操作：

C_AO_MEC:50;10;0.3
=============================
5 Rastrigin's; Func runs 10000 result: 78.73205273291103
Score: 0.97553
25 Rastrigin's; Func runs 10000 result: 58.554840607439516
Score: 0.72553
500 Rastrigin's; Func runs 10000 result: 42.32395504312925
Score: 0.52442
=============================
5 Forest's; Func runs 10000 result: 1.2024830541165685
Score: 0.68018
25 Forest's; Func runs 10000 result: 0.4588423143844061
Score: 0.25954
500 Forest's; Func runs 10000 result: 0.08756810826330522
Score: 0.04953
=============================
5 Megacity's; Func runs 10000 result: 5.279999999999999
Score: 0.44000
25 Megacity's; Func runs 10000 result: 2.048
Score: 0.17067
500 Megacity's; Func runs 10000 result: 0.4364
Score: 0.03637
=============================
All score: 3.86178

当观察MEC算法的动画时，我们可以看到集中在局部极端的代理集群的形成。趋同的质量给评级表中有价值的位置带来了希望。

  在 Rastrigin 测试函数上的MEC。

  在Forest测试函数上的MEC。

  在Megacity测试函数上的MEC。

在分析优化算法测试结果排行表时可以看出，MEC算法的性能非常高，排名第五。MEC在Rastrigin、Forest和Megacity函数上表现出了优异的结果，尽管这些测试函数的表面完全不同。具有10个参数的Megacity函数取得了特别令人印象深刻的结果。然而，值得注意的是，与比较分析中的其他参与者相比，MEC在优化参数较少的函数上表现出更高的效率。这更多是一个缺点。 

#	AO	描述	Rastrigin			Rastrigin 最终	Forest			Forest 最终	Megacity (discrete)			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	SSG	树苗播种和生长（saplings sowing and growing）	1.00000	1.00000	0.55665	2.55665	0.72740	0.94522	1.00000	2.67262	0.76364	0.85977	1.00000	2.62340	100.000
2	HS	和声搜索（harmony search）	0.99676	0.95282	0.48178	2.43136	1.00000	0.98931	0.44806	2.43736	1.00000	1.00000	0.41537	2.41537	92.329
3	ACOm	蚁群优化M（ant colony optimization M）	0.34611	0.17985	0.17044	0.69640	0.86888	1.00000	0.77362	2.64249	1.00000	0.88930	0.05606	1.94536	65.347
4	IWO	入侵性杂草优化（invasive weed optimization）	0.95828	0.67083	0.29807	1.92719	0.70773	0.46349	0.31773	1.48896	0.80000	0.42067	0.33289	1.55356	61.104
5	MEC	思维进化计算（mind evolutionary computation）	0.99270	0.51040	0.22800	1.73110	0.60762	0.40658	0.25459	1.26880	0.93335	0.41328	0.26170	1.60833	56.227
6	COAm	布谷鸟优化算法M（COAm）	0.92400	0.46794	0.26004	1.65199	0.58378	0.34034	0.16526	1.08939	0.72727	0.33025	0.17083	1.22835	47.612
7	FAm	萤火虫算法M（firefly algorithm M）	0.59825	0.33980	0.17135	1.10941	0.51073	0.42299	0.49790	1.43161	0.34545	0.28044	0.35258	0.97847	41.537
8	ABC	人工蜂群（artificial bee colony）	0.78170	0.32715	0.20822	1.31707	0.53837	0.21455	0.13344	0.88636	0.56364	0.26569	0.13926	0.96858	36.849
9	GSA	重力搜索算法（gravitational search algorithm）	0.70167	0.45217	0.00000	1.15384	0.31660	0.36416	0.33204	1.01280	0.59395	0.35054	0.00000	0.94448	36.028
10	BA	蝙蝠算法（bat algorithm）	0.40526	0.63761	0.84451	1.88738	0.20841	0.17477	0.25989	0.64308	0.29698	0.09963	0.17371	0.57032	35.888
11	BFO	细菌觅食优化（bacterial foraging optimization）	0.67203	0.30963	0.11813	1.09979	0.39702	0.26623	0.20652	0.86976	0.52122	0.33211	0.18932	1.04264	34.693
12	EM	类电磁算法（electroMagnetism-like algorithm）	0.12235	0.46278	1.00000	1.58513	0.00000	0.03498	0.34880	0.38377	0.00000	0.00000	0.10924	0.10924	22.091
13	SFL	混合蛙跳（shuffled frog-leaping）	0.40072	0.23739	0.26548	0.90360	0.20153	0.04147	0.02652	0.26952	0.27273	0.05535	0.06639	0.39446	15.203
14	MA	猴子算法（monkey algorithm）	0.33192	0.33451	0.14644	0.81287	0.10012	0.07891	0.08932	0.26836	0.21818	0.04243	0.10720	0.36781	13.603
15	FSS	鱼群搜索（fish school search）	0.46812	0.25337	0.11302	0.83451	0.12840	0.05013	0.06516	0.24369	0.16971	0.04796	0.08283	0.30050	12.655
16	PSO	粒子群优化（particle swarm optimisation）	0.20449	0.08200	0.07160	0.35809	0.18895	0.10486	0.21738	0.51119	0.23636	0.05903	0.01957	0.31496	10.031
17	RND	随机（random）	0.16826	0.09743	0.08019	0.34589	0.13496	0.04810	0.04715	0.23021	0.16971	0.03875	0.04922	0.25767	5.302
18	GWO	灰狼优化器（grey wolf optimizer）	0.00000	0.00000	0.02256	0.02256	0.06570	0.00000	0.00000	0.06570	0.32727	0.07378	0.02557	0.42663	1.000

总结

思维进化计算（MEC）算法是一种基于生物进化原理的高效、强大的优化方法。它具有许多显著的优点，使其对解决复杂的优化问题具有吸引力。

思维算法的进化可以应用于广泛的问题，包括函数优化、搜索最优参数值、机器学习问题等。它不需要了解目标函数的分析形式，可以处理连续、离散或组合的解空间。

MEC易于并行化，允许使用多个计算资源来加快优化过程。这在处理需要大量计算或迭代的问题时尤其有用。

MEC有一定的陷入局部极值的趋势，但这一缺点主要表现在离散函数和锯齿函数上。当设计适应度函数时，这个缺点可以被认为是微不足道的。

MEC在解决方案空间维度较高的问题上表现相对较好。该算法尚未得到广泛研究，有改进的潜力。

一般来说，MEC算法是一种强大的优化工具，具有灵活性、通用性和对局部极值的良好刻画。这些优点使其成为解决各个领域中复杂优化问题的有吸引力的选择。算法逻辑的简单性在定制的非标准软件解决方案中尤其有用。

为了更直观地表示各个算法的优点和缺点，可以使用图3中的色标来表示上表。

图3. 根据相关测试的算法颜色等级

算法测试结果的直方图如下所示（从0到100，越多越好，在档案中有一个脚本，用于使用本文中描述的方法计算评级表）：

Figure 4. 测试算法最终结果的直方图

MEC 的优点和缺点：

优点：
1. 最小数量的外部参数。
2. 高效解决各种问题。
3. 计算资源负载低。
4. 易于实施。

缺点:
1. 在使用水平“平板”的功能上卡住。

每一篇文章都有一个归档，其中包含以前所有文章的算法代码的最新版本。然而，应该注意的是，我不对规范算法描述的绝对准确性负责。我经常根据自己的经验和个人意见添加自己的想法和改进。文章中给出的结论和判断是基于实验结果。