Algoritmos de otimização populacionais: Otimizador lobo-cinzento (GWO)

Conteúdo

1. Introdução
2. Descrição do algoritmo
3. Funções de teste
4. Resultado dos testes

1. Introdução

O algoritmo do lobo-cinzento é uma técnica meta-heurística estocástica de inteligência de enxame, desenvolvida em 2014, cuja ideia é baseada no modelo de caça em bando dos lobos cinzentos. Existem quatro tipos de lobos: alfa, beta, delta e ômega. O lobo alfa tem mais peso nas tomadas de decisão e na gestão da matilha, seguido pelo lobo beta e depois pelo lobo delta, que obedecem ao lobo alfa e têm poder sobre o restante da matilha. O lobo ômega sempre obedece aos lobos dominantes.

No modelo matemático de hierarquia dos lobos, o lobo alfa-α é considerado o líder da matilha, e suas ordens devem ser cumpridas pelos demais membros. Lobos beta-β são subordinados que auxiliam o alfa na tomada de decisões e são considerados os melhores candidatos para se tornarem o próximo alfa. Os lobos delta-δ devem obedecer ao alfa e beta, mas dominam o lobo ômega-ω. Os lobos ômega-ω são considerados os membros menos importantes da matilha e só podem comer após os outros membros. O lobo alfa é considerado a solução mais favorável.

A segunda e a terceira melhores soluções são, respectivamente, os lobos beta e delta. O restante das soluções são consideradas como lobo ômega. Supõe-se que os lobos mais aptos (alfa, beta e delta), ou seja, aqueles mais próximos da presa, serão os primeiros a abordá-la. Após cada abordagem, é determinado quem será o alfa, beta e delta, nesta fase os lobos são reorganizados. A reorganização ocorre até que os lobos se unam em uma matilha, que será a direção ideal para um ataque com a mínima distância.

Durante o algoritmo, ocorrem três etapas principais, nas quais os lobos procuram, cercam e atacam a presa. Durante a busca, os lobos alfa, beta e delta, que estão mais próximos da presa, são identificados. Os demais lobos, obedecendo aos líderes, começam a cercar a presa ou continuam se movendo aleatoriamente em busca da melhor opção.

2. Descrição do algoritmo

A hierarquia no bando é mostrada esquematicamente na Figura 1.  A distribuição de papéis entre os membros do bando, alfa desempenha um papel dominante.

Figura 1. Hierarquia em uma manada de lobos.

Modelo matemático e algoritmo
Hierarquia social:

• A melhor solução é o lobo alfa (α).
• A segunda melhor solução é o lobo beta (β).
• Terceira melhor solução é o lobo delta (δ).
• Outras soluções possíveis são os lobos omega (ω).

Ambiente da presa: quando já existem as melhores soluções alfa, beta e delta, as ações posteriores dependem do ômega.

Figura 2. Etapas da caça: busca, cerco, ataque.

Todas as iterações do algoritmo são compostas por três etapas: busca, ambiente e caça. Na versão canônica do algoritmo, um coeficiente chamado "a" é introduzido para melhorar a convergência, diminuindo gradualmente a zero a cada iteração. Enquanto o coeficiente for maior que 1, a inicialização dos lobos está em andamento. Nessa fase, a posição da presa é completamente desconhecida, portanto, os lobos devem ser distribuídos aleatoriamente.

Após a etapa de "busca", o valor da função de aptidão é determinado e só então é possível avançar para a etapa de "ambiente". Nessa etapa, o coeficiente "a" é maior que 1, o que significa que alfa, beta e delta estão se afastando de suas posições anteriores, permitindo assim a identificação da posição estimada da presa. Quando o coeficiente "a" se torna igual a 1, inicia-se a fase de "ataque" e, antes do fim das iterações, o coeficiente tende a 0, fazendo com que os lobos se aproximem da presa e sugerindo que a melhor posição tenha sido encontrada. No entanto, se um dos lobos encontrar uma solução melhor nessa fase, a posição da presa será atualizada e a hierarquia dos lobos será reorganizada, mas o coeficiente ainda tenderá a 0. O processo de mudança de "a" é representado por uma função não linear e as etapas são esquematicamente mostradas na Figura 2.

Durante todas as iterações do algoritmo, os lobos ômega mantêm seu comportamento inalterado, seguindo o centro geométrico entre a posição dos indivíduos dominantes atuais. Na Figura 3, alfa, beta e delta se afastam de suas posições anteriores em uma direção aleatória com um raio determinado pelos coeficientes, enquanto os lobos ômega se movem em direção ao centro entre eles. No entanto, eles não se movem exatamente para o centro, mas com uma certa probabilidade de desvio dentro do raio. Os raios são determinados pelo coeficiente a, que diminui progressivamente ao longo das iterações, fazendo com que os raios diminuam proporcionalmente.

Figura 3. Diagrama do movimento do ômega em relação ao alfa, beta e delta.

O pseudocódigo do algoritmo GWO é o seguinte:

1) Inicializar aleatoriamente a população de lobos cinzentos.
2) Calcular a aptidão de cada membro da população.
3) Líderes da matilha:
-α = o membro com o melhor valor de aptidão
-β = o segundo melhor membro (em termos de aptidão)
-δ = o terceiro melhor membro (em termos de valor de aptidão)
Atualizar a posição de todos os lobos ômega usando fórmulas dependentes de α, β, δ.
4) Calcular a aptidão de cada membro da população.
5) Repetir o passo 3.

Vamos agora analisar o código do algoritmo. Uma adição que fiz à versão original foi a possibilidade de definir o número de lobos líderes na matilha. Agora é possível escolher qualquer número de líderes, desde um até o tamanho total do grupo. Essa opção pode ser útil em tarefas específicas e permite maior flexibilidade no uso do algoritmo.

Vamos começar com a unidade fundamental do algoritmo: o lobo, que representa uma solução para o problema. Essa unidade é composta por uma matriz de coordenadas e um valor de aptidão que indica a qualidade da solução. Tanto os líderes quanto os demais membros da matilha são representados pela mesma estrutura, o que simplifica o algoritmo e permite a utilização das mesmas estruturas em operações de loop. Durante as iterações, os papéis dos lobos mudam várias vezes, e as funções de aptidão são determinadas exclusivamente pela posição na matriz após a classificação, sendo que os líderes são posicionados no início da matriz. É importante destacar que essa estrutura é a mesma para todos os lobos, independentemente de sua posição na hierarquia.

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

A classe que representa a matilha de lobos é compacta e fácil de entender. Nela, são definidos os limites e etapas dos parâmetros a serem otimizados, a melhor posição da presa, o melhor valor de solução e funções auxiliares.

//——————————————————————————————————————————————————————————————————————————————
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
};
//——————————————————————————————————————————————————————————————————————————————

Tradicionalmente, a inicialização ocorre após a declaração da classe na descrição do algoritmo. Aqui, redefinimos para um mínimo o valor double da aptidão dos lobos, distribuímos o tamanho das matrizes.

//——————————————————————————————————————————————————————————————————————————————
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;
  }
}
//——————————————————————————————————————————————————————————————————————————————

O primeiro método público, chamado em cada iteração, é o mais difícil e volumoso de entender. É nele que se encontra a lógica principal do algoritmo, e o seu desempenho é garantido por um mecanismo probabilístico estritamente descrito por fórmulas. Vamos analisar este método passo a passo. Na primeira iteração, quando a posição da presa pretendida é desconhecida, verificamos o sinalizador e, em seguida, enviamos os lobos em uma direção aleatória, gerando valores a partir dos máximos e mínimos dos parâmetros a serem otimizados.

//----------------------------------------------------------------------------
//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;
}

Na descrição canônica do algoritmo, as fórmulas que operam em vetores podem ser difíceis de compreender, mas no código a lógica é mais clara. Por isso, o cálculo dos lobos ômega é realizado antes do cálculo dos lobos alfa, beta e delta, para que os valores anteriores do líder sejam utilizados.

O coeficiente a é o principal componente que possibilita os três estágios de caça (busca, cerco e ataque), sendo sua variação não linear determinada pela iteração atual e pelo número total de iterações, tendendo a zero.
Componentes da fórmula Ai e Ci:

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

Onde r1 e r2 são números aleatórios no intervalo [0,0;1,0].
Na expressão

Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);

as coordenadas dos lobos são ajustadas de acordo com os valores médios dos lobos líderes. Uma vez que é possível especificar qualquer número de líderes no algoritmo, é necessário realizar uma soma das coordenadas em um loop. Em seguida, o valor resultante é dividido pelo número de líderes. Essa operação é executada para cada coordenada separadamente, gerando um novo valor de r1 e r2 a cada iteração. A nova posição dos lobos ômega é ajustada com base nas posições dos líderes, levando em consideração sua própria posição atual.

//----------------------------------------------------------------------------
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]);
}

Agora, vamos analisar o cálculo dos líderes. Para eles, os coeficientes a, Ai e Ci são calculados para cada coordenada. A diferença é que a posição dos líderes varia em relação às melhores coordenadas de produção no momento atual e sua própria posição. Os líderes circulam em torno da presa, controlando os lobos menores durante a busca, cerco e ataque.

//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]);
}

Este é o segundo método público chamado em cada iteração. Aqui, o status dos líderes da matilha é atualizado e os lobos são classificados pelo valor de aptidão. Caso sejam encontradas melhores coordenadas de presas do que as armazenadas em toda a matilha, os valores são atualizados.

//——————————————————————————————————————————————————————————————————————————————
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. Funções de teste

Em artigos anteriores, já abordamos as funções Skin, Forest, Megacity. Essas funções de teste atendem a todos os critérios de complexidade para testar algoritmos de otimização. No entanto, há uma característica que não foi considerada e, para tornar os testes mais objetivos, é importante implementá-la. Os requisitos são:

1. O extremo global não deve estar nas bordas do intervalo. Se o algoritmo não tiver uma verificação fora do intervalo, o algoritmo poderá mostrar excelentes resultados. Isso porque há um defeito interno que faz com que os valores fiquem nas bordas.
2. O extremo global não deve estar no centro das coordenadas do intervalo. Nesse caso, será considerada a geração de valores médios em um intervalo.
3. O mínimo global deve estar no centro das coordenadas. Isso é necessário para excluir deliberadamente as situações descritas no parágrafo 2.
4. O cálculo dos resultados da função de teste deve levar em consideração o momento em que números gerados aleatoriamente em todo o domínio da função (quando a função é multivariável) darão um resultado médio de cerca de 50% do máximo, embora na verdade esses resultados são obtidos por acaso.
   

Considerando esses requisitos, foi necessário revisar os limites das funções de teste e deslocar os centros da faixa para o mínimo dos valores da função. Em resumo, isso foi feito para garantir a maior plausibilidade e objetividade nos resultados dos algoritmos de otimização de teste. Consequentemente, em novas funções de teste, o algoritmo de otimização baseado na geração de números aleatórios apresentou um desempenho geral naturalmente inferior, o que é esperado. A tabela de classificação atualizada pode ser encontrada no final do artigo.

Função Skin é uma função suave que possui vários extremos locais que podem confundir algoritmos de otimização, fazendo-os ficar presos em um deles. O único extremo global é caracterizado por valores que mudam fracamente nas proximidades. Essa função é um bom exemplo para demonstrar a capacidade do algoritmo de dividir as áreas de estudo e não se concentrar em nenhuma área em particular. Em particular, o algoritmo da colônia de abelhas (ABC) se comporta bem nesse tipo de função.

Figura 4. Função de teste Skin.

A função Forest possui múltiplos extremos suaves e alguns não diferenciáveis. É um teste desafiador para algoritmos de otimização, que precisam encontrar o único ponto máximo global em uma tarefa complicada, especialmente quando a função tem várias variáveis. O algoritmo da colônia de formigas (ACO) se destacou nessa tarefa, apresentando um comportamento distinto que abre caminhos de forma surpreendente.

Figura 5. Função de teste Forest.

A função Megacity representa um problema de otimização discreta com um único extremo global e vários extremos locais. A superfície de estudo é extremamente complexa, o que torna um bom teste para algoritmos que requerem um gradiente. Além disso, há um "piso" uniforme que também representa um mínimo, tornando ainda mais difícil determinar a direção para o máximo global.

Figura 6. Função de teste Megacity.

As funções de teste foram atualizadas com verificações dos argumentos de entrada para evitar valores fora do intervalo permitido. Na versão anterior das funções, os algoritmos de otimização podiam receber valores da função que estavam fora do intervalo definido, o que poderia levar a resultados imprecisos.

4. Resultado dos testes

Foram realizadas alterações nas funções de teste, o que motivou a atualização da bancada de teste. Na parte direita da tela, é possível visualizar os gráficos de convergência dos algoritmos de otimização. A linha verde representa as funções com duas variáveis, a azul as com 40 variáveis e a vermelha as com 1000 variáveis. O círculo preto maior indica a posição do máximo global da função, enquanto o círculo preto menor representa a posição do valor da solução do algoritmo de otimização atual. O retículo de linhas brancas indica o centro geométrico das funções de teste, que corresponde ao mínimo global. Esse elemento é introduzido para facilitar a percepção visual do comportamento dos algoritmos testados. Os pontos brancos indicam as soluções intermediárias médias. Os pequenos pontos coloridos representam os pares de coordenadas da dimensão correspondente, e a cor indica a posição ordinal da dimensão da função de teste.

Os resultados dos testes atualizados dos algoritmos de otimização discutidos nos artigos anteriores sobre o novo estande podem ser vistos na tabela atualizada. A linha que apresentava a velocidade de convergência foi removida da tabela, já que essa informação pode ser facilmente visualizada na animação do estande, e sua inclusão sobrecarregaria a percepção do leitor. Além disso, foi adicionada uma coluna com a descrição de cada algoritmo testado.

Resultados dos testes ACOm (Ant Colony Optimization):

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

Resultados dos testes ABCm (Artificial Bee Colony):

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

Resultados dos testes ABC (Artificial Bee Colony):

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 executa 10000 resultado: 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

Resultados dos testes PSO (Particle Swarm Optimization)

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

Resultados dos testes RND (Random):

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

  GWO na função de teste Skin.

GWO na função de teste Forest.

  GWO na função de teste Megacity.

Resultados dos testes 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

O grey wolf optimization (GWO), ou algoritmo de otimização dos lobos-cinzentos em português, é um dos algoritmos de otimização bio-inspirados mais recentes que se baseia na simulação da caça de uma matilha de lobos cinzentos. Em média, o algoritmo tem se mostrado muito eficiente em vários tipos de funções, tanto em termos de precisão para encontrar um extremo quanto em termos de velocidade de convergência. Em alguns testes, ele é o líder na tabela de classificação. Os principais indicadores de desempenho do algoritmo "lobos-cinzentos" são melhores do que os do algoritmo de otimização de enxame de partículas, que é um dos algoritmos "clássicos" da classe de algoritmos de otimização bioinspirados.

Ao mesmo tempo, a complexidade computacional do algoritmo de otimização dos lobos-cinzentos é comparável à do algoritmo de otimização de enxame de partículas. Devido às inúmeras vantagens do algoritmo de otimização GWO, muitos trabalhos sobre sua modificação surgiram pouco tempo depois que o algoritmo foi publicado pela primeira vez. A única desvantagem do algoritmo é a baixa precisão das coordenadas encontradas em funções com uma única solução ótima muito acentuada.

Além disso, a baixa acurácia do extremo encontrado foi observada em todas as dimensões da função Forest, sendo os piores resultados entre todos os participantes da tabela. Embora o algoritmo tenha se mostrado excelente na função Smooth Skin, sendo o líder, principalmente na função Large Skin. O GWO também é o terceiro na tabela a alcançar 100% de acurácia no máximo global na função Megacity.

AO	Descrição	Skin			Forest			Megacity (discrete)			Final result
		2 params (1 F)	40 params (20 F)	1000 params (500 F)	2 params (1 F)	40 params (20 F)	1000 params (500 F)	2 params (1 F)	40 params (20 F)	1000 params (500 F)
ACOm	otimização de colônia de formigas	0,98229	0,79108	0,12602	1,00000	0,62077	0,11521	0,38333	0,44000	0,02377	0,49805222
ABCm	colônia artificial de abelhas M	1,00000	0,63922	0,08076	0,99908	0,20112	0,03785	1,00000	0,16333	0,02823	0,46106556
ABC	colônia artificial de abelhas	0,99339	0,73381	0,11118	0,99934	0,21437	0,04215	0,85000	0,16833	0,03130	0,46043000
GWO	otimizador de lobo cinzento	0,99900	0,48033	0,18924	0,83844	0,08755	0,02555	1,00000	0,10000	0,02187	0,41577556
PSO	otimização de enxame de partículas	0,99627	0,38080	0,05089	0,93772	0,14540	0,04856	1,00000	0,09333	0,02233	0,40836667
RND	aleatório	0,99932	0,44276	0,06827	0,83126	0,11524	0,03048	0,83333	0,09000	0,02403	0,38163222

Conclusões

Prós:
1. Rápido.
2. Alta convergência para funções suaves com um grande número de variáveis.

Contras:
1. Não universal.
2. Bloqueio em extremos locais.
3. Baixa escalabilidade em funções discretas e não diferenciáveis.