Algoritmos de otimização populacionais: Busca harmônica (Harmony Search, HS)

Conteúdo

1. Introdução
2. Descrição do algoritmo
3. Resultado dos testes

1. Introdução

Uma composição musical consiste em vários elementos: ritmo, melodia e harmonia. Enquanto o ritmo e a melodia formam a essência de uma peça musical, a harmonia é o que a enfeita. Uma peça ou música sem harmonia é como uma imagem não colorida em um livro infantil - ela está desenhada, mas não tem cor, brilho ou expressividade. Uma harmonia bem escolhida é um prazer para os ouvidos, aprimora o som, permitindo que desfrutemos plenamente dos maravilhosos sons de um piano, violão ou qualquer outro instrumento musical. Uma melodia pode ser cantada, mas a harmonia só pode ser tocada. A harmonia musical é um conjunto de acordes sem os quais nenhuma canção ou peça musical estaria completa e plena de som.

A harmonia surge exatamente quando unimos dois sons, um após o outro, ou em uma execução simultânea. Um sinônimo mais conciso seria "combinação". Ao combinar um som com outro, temos uma combinação na qual uma hierarquia está tentando se desenvolver à sua própria maneira. Nas escolas de música, faculdades e conservatórios, há uma disciplina especial chamada harmonia, na qual os alunos aprendem todos os acordes existentes na teoria musical, aprendem a aplicá-los na prática e até resolvem problemas de harmonia.

No processo de improvisação musical, um grupo de músicos tenta ajustar a afinação de seus instrumentos para alcançar uma harmonia agradável (o melhor estado). Na natureza, a harmonia é definida por uma relação específica entre várias ondas sonoras com diferentes frequências. A qualidade da harmonia improvisada é determinada pela apreciação estética. Para aprimorar a apreciação estética e encontrar a melhor harmonia, os músicos praticam incessantemente. Existem semelhanças entre os processos de improvisação dos músicos e otimização.

O Harmony Search (HS) é um algoritmo metaheurístico em evolução amplamente utilizado para resolver diversos problemas complexos na última década. Foi proposto pela primeira vez em 2001 por Z. W. Geem. Inspirado nos princípios fundamentais da improvisação musical e na busca harmônica, o método HS mapeia a harmonia perfeita dos sons para um extremo global em problemas de otimização multidimensional. Analogamente, o processo de improvisação dos músicos é comparado a um procedimento para encontrar esse extremo.

Durante o processo de improvisação, cada músico contribui com um som (dentro das possibilidades do seu instrumento musical) em um determinado compasso de uma peça musical. Esses sons de todos os músicos em uma orquestra formam um vetor de harmonia. Combinações de sons que criam "boas" harmonias são armazenadas na memória de cada músico e podem ser utilizadas para formar harmonias ainda melhores nos compassos seguintes da peça.

Durante a improvisação, é comum que um músico atenda a uma das três seguintes exigências: produzir um som totalmente aleatório dentro do alcance disponível de sons; reproduzir um som a partir da memória de harmonias; tocar um vetor de harmonia relacionado armazenado na mesma memória. O algoritmo HS possui características principais que permitem sua utilização tanto em problemas de otimização contínua quanto discreta.

As características distintivas do algoritmo HS são a sua simplicidade e eficiência na busca. Por isso, o algoritmo tem atraído considerável atenção dos pesquisadores e está em rápido desenvolvimento, tanto em termos teóricos quanto práticos. O HS é uma técnica metaheurística que proporciona uma alta estabilidade entre as fases de exploração e aproveitamento durante o processo de busca. Ele se inspira nas expressões criativas do ser humano, e o método para encontrar a solução ideal para um determinado problema é análogo ao método utilizado por um músico que busca encontrar uma harmonia agradável ao ouvido. O método utilizado para obter o valor da função de adequação é similar ao método utilizado para obter uma referência por meio da altura do tom de cada instrumento musical.

2. Descrição do algoritmo

O algoritmo de busca harmônica (Harmony Search, HS) possui uma lógica semelhante àquela empregada por um músico na criação de uma harmonia perfeita. O músico busca modificar diferentes tons até encontrar a harmonia ideal. As harmonias encontradas são armazenadas na memória. Na tarefa de otimização, as harmonias passam por várias variações. Caso os resultados dessas variações sejam favoráveis, a memória é atualizada, incluindo a nova harmonia e descartando aquelas indesejáveis... Entretanto, já estou confuso com os termos utilizados pelos autores do algoritmo. O que exatamente é uma harmonia? E o que são tons? Vamos tentar entender o algoritmo utilizando nossos próprios termos.

O que é uma peça musical? Embora eu não seja um músico (o que é uma pena), sou programador. Para nós e para escrever o algoritmo, será suficiente utilizar o conceito de "nota". Uma peça musical é composta por notas (acordes). A Figura 1 apresenta esquematicamente o "mecanismo" de construção de uma peça musical, sendo que a seleção de notas mostrada na Figura 1 corresponde a uma única peça musical. Essa peça pode ser facilmente identificada, se houver interesse e se tivermos um ouvido musical (mas também é possível apreciá-la sem necessariamente possuir esse talento) ou uma formação musical (embora também seja possível apreciá-la sem essa formação).

O processo de otimização do algoritmo HS consiste em mover as barras verdes com as notas ao longo das barras azuis que representam a peça musical em si. O intervalo coberto pelas barras verdes corresponde a uma oitava, que é composta por notas individuais. A peça musical (barra azul) representa uma das soluções de otimização. As notas na barra verde são os parâmetros correspondentes a serem otimizados no problema. Na memória do músico, há várias variantes da peça musical (diversas barras azuis), isso é o que chamamos de população no algoritmo.

Figura 1. Seleção de notas em uma peça musical (encontrar harmonia). A barra azul é a peça musical. As barras verdes são um conjunto de notas.

Na Figura 1, temos um exemplo de solução para um problema discreto, em que o parâmetro possui 8 etapas, sendo apresentado de forma simplificada para facilitar a compreensão do funcionamento do algoritmo. No entanto, em um problema genérico, a etapa dos parâmetros otimizados pode ter qualquer valor, e podem existir notas intermediárias, como os semitons. Os parâmetros corretos para a solução de um problema correspondem às notas corretas na composição musical.

Dessa forma, o processo de criação de uma obra musical se inicia com um conjunto aleatório de sons de um instrumento musical, dentro da faixa de frequências reproduzíveis pelo instrumento. É necessário criar variações da obra para que seja possível combinar seções individuais das notas de cada variação. Em seguida, ocorre o processo de alteração das notas nessas variações, que pode ser feito de três maneiras possíveis:

1. Alterar aleatoriamente uma das notas da obra que esteja dentro do intervalo do instrumento musical.
2. Utilizar uma nota correspondente, com o número de ordem adequado, de outras variações da obra.
3. Pegar uma nota de uma variação diferente da obra e realizar uma pequena modificação nela, seja aumentando ou diminuindo sua tonalidade.

Após obter um novo conjunto de variantes de uma obra musical, vamos avaliar cada uma das variantes em termos de harmonia sonora. Manteremos as variantes em suas posições originais na memória, desde que a nova variante seja melhor do que sua versão anterior. Uma característica única do algoritmo é que não é necessário classificar a população, que neste caso consiste em um conjunto de peças musicais: cada nova variante melhor substituirá a variante anterior de menor qualidade no mesmo lugar. Esse processo se assemelha ao funcionamento de algoritmos genéticos que simulam a evolução, onde os indivíduos mais adaptados sobrevivem. Além disso, também há semelhanças com a combinação de genes em um cromossomo.

Com base no exposto, podemos elaborar um pseudocódigo preliminar do algoritmo HS:

1. Gerar harmonias aleatórias.
2. Avaliar a qualidade das harmonias (calcular a função de adaptação).
3. Com uma probabilidade Eh, utilizar a seleção de acordes de uma harmonia escolhida aleatoriamente.
  3.1 Alterar o acorde com uma probabilidade Ep, de acordo com a fórmula, se o acorde for selecionado de alguma harmonia.
    3.1.1 Manter o acorde selecionado sem alterações.
  3.2 Gerar um novo acorde utilizando a fórmula. Avaliar a qualidade das harmonias (calcular a função de adaptação).
4. Avaliar a qualidade das harmonias (calcular a função de adaptação).
Repetir a partir da etapa 3 até que o critério de parada seja atendido.

Agora, vamos descrever os parâmetros de entrada do algoritmo, que são poucos e intuitivos.

input int    Population_P = 50;    //Population size
input double Eh_P         = 0.9;   //random selection frequency
input double Ep_P         = 0.1;   //frequency of step-by-step adjustment
input double Range_P      = 0.2;   //range

• Population_P - número de variações de uma peça na memória de um músico ou, da mesma forma, o tamanho da população;
• Eh_P - frequência com que uma variação de uma peça é selecionada da memória, o que afeta a frequência com que nos referimos a outras variantes para pegar uma nota emprestada. Um valor mais alto significa propriedades combinatórias mais altas do algoritmo;
• Ep_P - frequência com que precisamos alterar ligeiramente a nota, mais alta ou mais baixa, se a nota foi selecionada de outra variação da peça;
• Range_P - intervalo de alterações de notas na versão editada de uma obra, se ela não tiver sido retirada de outra versão. Por exemplo, 0,2 seria 20% do intervalo de notas do instrumento musical.
• 
  

No algoritmo HS, trabalhamos com harmonias (composições musicais), que podem ser descritas pela estrutura S_Harmony. Uma harmonia é composta por notas (acordes), representadas por uma matriz de parâmetros otimizáveis c []. Os melhores acordes da obra serão armazenados na matriz cB [], que conterá as composições bem-sucedidas. Faremos uso dessas composições (harmonias) para realizar permutações combinatórias e emprestar notas delas. A qualidade da harmonia é armazenada na variável h, enquanto a melhor harmonia é armazenada na variável hB.

//——————————————————————————————————————————————————————————————————————————————
struct S_Harmony //musical composition
{
  double c  []; //chords
  double cB []; //best chords
  double h;     //harmony quality
  double hB;    //best harmony quality
};
//——————————————————————————————————————————————————————————————————————————————

Na classe C_AO_HS, utilizamos uma matriz de estruturas de harmonia. As declarações de métodos e membros na classe são compactas, pois o algoritmo é notavelmente conciso e possui baixos requisitos de recursos computacionais. Ao contrário de muitos outros algoritmos de otimização, aqui não há necessidade de classificação. Precisaremos de arrays para definir os valores máximo, mínimo e passo dos parâmetros a serem otimizados, que correspondem aos intervalos e etapas dos acordes. Também teremos variáveis constantes para receber os parâmetros externos do algoritmo. Com isso, podemos prosseguir para a descrição dos métodos, onde a lógica principal do HS está encapsulada.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_HS
{
  //----------------------------------------------------------------------------
  public: S_Harmony h      []; //harmonies matrix
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: double cB        []; //best chords
  public: double hB;           //best harmony quality

  public: void Init (const int    chordsNumberP,      //chords number
                     const int    harmoniesNumberP,   //harmonies number
                     const double EhP,                //random selection frequency
                     const double EpP,                //frequency of step-by-step adjustment
                     const double rangeP,             //range
                     const int    maxIterationsP);    //max Iterations

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

  //----------------------------------------------------------------------------
  private: int    chordsNumber;      //chords number
  private: int    harmoniesNumber;   //harmonies number
  private: double Eh;                //random selection frequency
  private: double Ep;                //frequency of step-by-step adjustment
  private: double range;             //range
  private: int    maxIterations;
  private: double frequency [];      //frequency range
  private: bool   revision;

  private: double SeInDiSp  (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI (double min, double max);
  private: double Scale     (double In, double InMIN, double InMAX, double OutMIN, double OutMAX,  bool revers);
};
//——————————————————————————————————————————————————————————————————————————————

No método aberto `Init()`, realizamos a inicialização do algoritmo. Aqui definimos o tamanho das matrizes. Inicializamos o índice de qualidade da melhor harmonia encontrada com o menor valor possível do tipo `double`. Da mesma forma, inicializamos as variáveis correspondentes na matriz de estrutura de harmonia.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_HS::Init (const int    chordsNumberP,      //chords number
                    const int    harmoniesNumberP,   //harmonies number
                    const double EhP,                //random selection frequency
                    const double EpP,                //frequency of step-by-step adjustment
                    const double rangeP,             //range
                    const int    maxIterationsP)     //max Iterations
{
  MathSrand ((int)GetMicrosecondCount ()); // reset of the generator
  hB       = -DBL_MAX;
  revision = false;

  chordsNumber    = chordsNumberP;
  harmoniesNumber = harmoniesNumberP;
  Eh              = EhP;
  Ep              = EpP;
  range           = rangeP;
  maxIterations   = maxIterationsP;

  ArrayResize (rangeMax,  chordsNumber);
  ArrayResize (rangeMin,  chordsNumber);
  ArrayResize (rangeStep, chordsNumber);
  ArrayResize (frequency, chordsNumber);

  ArrayResize (h, harmoniesNumberP);

  for (int i = 0; i < harmoniesNumberP; i++)
  {
    ArrayResize (h [i].c,  chordsNumber);
    ArrayResize (h [i].cB, chordsNumber);
    h [i].h  = -DBL_MAX;
    h [i].hB = -DBL_MAX;
  }

  ArrayResize (cB, chordsNumber);
}
//——————————————————————————————————————————————————————————————————————————————

O primeiro método aberto obrigatório `Moving()` possui um parâmetro de entrada chamado `iter`, que indica a iteração atual. Na primeira iteração, quando a variável de revisão (`revision`) é falsa, precisamos inicializar as harmonias com valores aleatórios no intervalo dos instrumentos musicais. Isso é equivalente a um músico escolhendo acordes aleatoriamente. Para evitar repetição de operações, armazenamos o intervalo de frequências sonoras dos acordes (parâmetros otimizados) na matriz `frequency[]`.

//----------------------------------------------------------------------------
if (!revision)
{
  hB = -DBL_MAX;

  for (int har = 0; har < harmoniesNumber; har++)
  {
    for (int c = 0; c < chordsNumber; c++)
    {
      h [har].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      h [har].c [c] = SeInDiSp  (h [har].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      h [har].h     = -DBL_MAX;
      h [har].hB    = -DBL_MAX;

      frequency [c] = rangeMax [c] - rangeMin [c];
    }
  }

  revision = true;
}

Nas iterações seguintes, ocorre a improvisação, ou seja, as mudanças sequenciais nos acordes e suas combinações. Existem várias harmonias na memória, que serão modificadas e combinadas. Para cada nova harmonia, percorremos os acordes sequencialmente. Cada acorde tem uma probabilidade de ser selecionado aleatoriamente da memória de harmonias. Ou seja, a harmonia é escolhida aleatoriamente com igual probabilidade para todas as harmonias. Se um acorde for selecionado da memória de harmonias, também verificamos a probabilidade de alterá-lo usando a fórmula:

h [har].c [c] = h [har].c [c] + r * B * frequency [c];

Onde:

r - número aleatório no intervalo de -1 a 1
frequency - intervalo de frequência do instrumento
B - coeficiente, que é calculado de acordo com a fórmula:

B = ((maxIterations - iter) / (double)maxIterations) * (maxB - minB) + minB;

Onde:

maxIterations - número máximo de iterações
iter - iteração atual
maxB - limite máximo do coeficiente
minB - limite mínimo do coeficiente

A Figura 2 mostra a dependência do fator B das configurações do algoritmo e da iteração atual.

Figura 2. Dependência do coeficiente B das configurações maxB, minB e da iteração atual do algoritmo.

Na fórmula para calcular o coeficiente B, podemos observar que a cada iteração o valor desse coeficiente diminui. Isso permite que os extremos encontrados sejam refinados ao longo da otimização.
Se um acorde não foi selecionado da memória de harmonias, então ele será alterado para o acorde atual. A diferença na alteração do acorde em relação à alteração anterior ocorre dentro de um intervalo fixo de valores de onda sonora.

Após a conclusão do processo de alteração do acorde, verificamos se o acorde resultante está dentro dos limites aceitáveis do instrumento musical.

//----------------------------------------------------------------------------
else
{
  double r         = 0.0;
  int    harAdress = 0;
  double minB      = 0.0;
  double maxB      = 0.3;
  double B = ((maxIterations - iter) / (double)maxIterations) * (maxB - minB) + minB;

  for (int har = 0; har < harmoniesNumber; har++)
  {
    for (int c = 0; c < chordsNumber; c++)
    {
      r = RNDfromCI (0.0, 1.0);

      if (r <= Eh)
      {
        r = RNDfromCI (0.0, harmoniesNumber - 1);
        harAdress = (int)MathRound (r);
        if (harAdress < 0) harAdress = 0;
        if (harAdress > harmoniesNumber - 1) harAdress = harmoniesNumber - 1;

        h [har].c [c] = h [harAdress].cB [c];

        r = RNDfromCI (0.0, 1.0);

        if (r < Ep)
        {
          r = RNDfromCI (-1.0, 1.0);
          h [har].c [c] = h [har].c [c] + r * B * frequency [c];
        }
      }
      else
      {
        r = RNDfromCI (-1.0, 1.0);
        h [har].c [c] = h [har].cB [c] + r * range * frequency [c];
      }

      h [har].c [c] = SeInDiSp (h [har].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
}

O segundo método público, chamado em cada iteração após o cálculo da função de adaptação, é o `Revision()`. Sua finalidade é atualizar a solução global encontrada. Se a harmonia atual for melhor do que a melhor versão encontrada até o momento (h > hB), então atualizamos essa melhor versão com a harmonia atual.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_HS::Revision ()
{
  for (int har = 0; har < harmoniesNumber; har++)
  {
    if (h [har].h > hB)
    {
      hB = h [har].h;
      ArrayCopy (cB, h [har].c, 0, 0, WHOLE_ARRAY);
    }
    if (h [har].h > h [har].hB)
    {
      h [har].hB = h [har].h;
      ArrayCopy (h [har].cB, h [har].c, 0, 0, WHOLE_ARRAY);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Após uma análise cuidadosa do código, podemos observar que o algoritmo de busca de harmonia não apresenta ideias completamente novas. Ele incorpora ideias previamente utilizadas em algoritmos evolutivos, como recombinação global uniforme, mutação uniforme, mutação gaussiana e substituição do pior indivíduo a cada geração. É importante destacar que, em nosso algoritmo, a harmonia pode substituir apenas a sua melhor solução, o que difere da abordagem clássica onde a pior harmonia é substituída. Pesquisas indicam que essa implementação do algoritmo pode ser mais produtiva.

A contribuição do algoritmo de busca de harmonia reside em duas áreas: a combinação das ideias mencionadas, presente neste algoritmo, é algo novo; e a motivação musical por trás do algoritmo de busca de harmonia também é uma novidade. Poucas publicações sobre busca de harmonia abordam motivações musicais ou extensões do algoritmo. A maioria das publicações se concentra na hibridização do algoritmo de busca de harmonia com outros algoritmos evolutivos, ajuste de parâmetros ou aplicação do algoritmo a problemas específicos. Caso extensões mais focadas na música pudessem ser aplicadas ao algoritmo HS, isso ajudaria a distinguir o algoritmo como uma abordagem evolutiva única. Isso demandaria estudos da teoria musical, do processo de composição e arranjo, das teorias educacionais musicais e uma aplicação criativa dessas teorias ao algoritmo de busca de harmonia.

3. Resultado dos testes

Saída de resultados da operação do HS na bancada de teste:

2023.02.08 17:30:05.710    Test_AO_HS (EURUSD,M1)    C_AO_HS:50;0.9;0.1;0.2
2023.02.08 17:30:05.711    Test_AO_HS (EURUSD,M1)    =============================
2023.02.08 17:30:07.919    Test_AO_HS (EURUSD,M1)    5 Rastrigin's; Func runs 10000 result: 80.62868417575105
2023.02.08 17:30:07.919    Test_AO_HS (EURUSD,M1)    Score: 0.99903
2023.02.08 17:30:11.563    Test_AO_HS (EURUSD,M1)    25 Rastrigin's; Func runs 10000 result: 75.85009280972398
2023.02.08 17:30:11.563    Test_AO_HS (EURUSD,M1)    Score: 0.93983
2023.02.08 17:30:45.823    Test_AO_HS (EURUSD,M1)    500 Rastrigin's; Func runs 10000 result: 50.26867628386793
2023.02.08 17:30:45.823    Test_AO_HS (EURUSD,M1)    Score: 0.62286
2023.02.08 17:30:45.823    Test_AO_HS (EURUSD,M1)    =============================
2023.02.08 17:30:47.878    Test_AO_HS (EURUSD,M1)    5 Forest's; Func runs 10000 result: 1.7224980742302596
2023.02.08 17:30:47.878    Test_AO_HS (EURUSD,M1)    Score: 0.97433
2023.02.08 17:30:51.546    Test_AO_HS (EURUSD,M1)    25 Forest's; Func runs 10000 result: 1.0610723369605124
2023.02.08 17:30:51.546    Test_AO_HS (EURUSD,M1)    Score: 0.60020
2023.02.08 17:31:31.229    Test_AO_HS (EURUSD,M1)    500 Forest's; Func runs 10000 result: 0.13820341163584177
2023.02.08 17:31:31.229    Test_AO_HS (EURUSD,M1)    Score: 0.07817
2023.02.08 17:31:31.229    Test_AO_HS (EURUSD,M1)    =============================
2023.02.08 17:31:34.315    Test_AO_HS (EURUSD,M1)    5 Megacity's; Func runs 10000 result: 7.959999999999999
2023.02.08 17:31:34.315    Test_AO_HS (EURUSD,M1)    Score: 0.66333
2023.02.08 17:31:42.862    Test_AO_HS (EURUSD,M1)    25 Megacity's; Func runs 10000 result: 5.112
2023.02.08 17:31:42.862    Test_AO_HS (EURUSD,M1)    Score: 0.42600
2023.02.08 17:32:25.172    Test_AO_HS (EURUSD,M1)    500 Megacity's; Func runs 10000 result: 0.6492
2023.02.08 17:32:25.172    Test_AO_HS (EURUSD,M1)    Score: 0.05410

Ao analisar a impressão dos resultados dos testes do algoritmo HS, podemos notar os altos valores das funções de teste, o que nos dá esperança de que os resultados gerais dos testes serão excepcionais. Uma característica marcante da visualização do HS é a ausência de estruturas visíveis na forma de grupos de coordenadas, diferentemente de alguns algoritmos anteriores. Não há padrões aparentes no movimento dos agentes no espaço de busca, assemelhando-se ao comportamento do algoritmo de otimização RND. No entanto, os gráficos de convergência mostram uma tendência sólida e progressiva em direção à solução do problema de otimização. É importante destacar que o algoritmo HS não fica preso em mínimos locais, o que é uma vantagem.

  HS na função de teste Rastrigin.

  HS na função de teste Forest.

  HS na função de teste Megacity.

Agora é o momento de analisar os resultados na tabela e responder à pergunta principal do artigo. Em artigos anteriores, eu expressava dúvidas sobre a possibilidade de encontrar um algoritmo que superasse o líder da tabela de classificação em uma função discreta nos testes. Surpreendentemente, o algoritmo, que visualmente parece aleatório, conseguiu se tornar o líder não apenas na função discreta (o melhor em três testes), mas também nas outras funções de teste, alcançando o primeiro lugar em 6 dos 9 testes realizados. Isso demonstra o excelente desempenho do algoritmo HS e sua capacidade de superar outros algoritmos nas diferentes tarefas de otimização.

AO	Description	Rastrigin			Rastrigin final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result
		10 params (5 F)	50 params (25 F)	1000 params (500 F)		10 params (5 F)	50 params (25 F)	1000 params (500 F)		10 params (5 F)	50 params (25 F)	1000 params (500 F)
HS	busca de harmonia	1,00000	1,00000	0,57048	2,57048	1,00000	0,98931	0,57917	2,56848	1,00000	1,00000	1,00000	3,00000	100,00000
ACOm	otimização de colônia de formigas M	0,34724	0,18876	0,20182	0,73782	0,85966	1,00000	1,00000	2,85966	1,00000	0,88484	0,13497	2,01981	68,094
IWO	otimização invasiva de ervas daninhas	0,96140	0,70405	0,35295	2,01840	0,68718	0,46349	0,41071	1,56138	0,75912	0,39732	0,80145	1,95789	67,087
COAm	algoritmo de otimização de cuco M	0,92701	0,49111	0,30792	1,72604	0,55451	0,34034	0,21362	1,10847	0,67153	0,30326	0,41127	1,38606	50,422
FAm	algoritmo de vaga-lumes M	0,60020	0,35662	0,20290	1,15972	0,47632	0,42299	0,64360	1,54291	0,21167	0,25143	0,84884	1,31194	47,816
BA	algoritmo do morcego	0,40658	0,66918	1,00000	2,07576	0,15275	0,17477	0,33595	0,66347	0,15329	0,06334	0,41821	0,63484	39,711
ABC	colônia artificial de abelhas	0,78424	0,34335	0,24656	1,37415	0,50591	0,21455	0,17249	0,89295	0,47444	0,23609	0,33526	1,04579	38,937
BFO	otimização de forrageamento bacteriano	0,67422	0,32496	0,13988	1,13906	0,35462	0,26623	0,26695	0,88780	0,42336	0,30519	0,45578	1,18433	37,651
GSA	algoritmo de busca gravitacional	0,70396	0,47456	0,00000	1,17852	0,26854	0,36416	0,42921	1,06191	0,51095	0,32436	0,00000	0,83531	35,937
FSS	busca por cardume de peixes	0,46965	0,26591	0,13383	0,86939	0,06711	0,05013	0,08423	0,20147	0,00000	0,00959	0,19942	0,20901	13,215
PSO	otimização de enxame de partículas	0,20515	0,08606	0,08448	0,37569	0,13192	0,10486	0,28099	0,51777	0,08028	0,21100	0,04711	0,33839	10,208
RND	aleatório	0,16881	0,10226	0,09495	0,36602	0,07413	0,04810	0,06094	0,18317	0,00000	0,00000	0,11850	0,11850	5,469
GWO	otimizador lobo-cinzento	0,00000	0,00000	0,02672	0,02672	0,00000	0,00000	0,00000	0,00000	0,18977	0,03645	0,06156	0,28778	1,000

Vamos fazer um resumo dos resultados. No histograma dos resultados dos testes, o algoritmo HS ocupa a posição de liderança no momento da escrita deste artigo, com uma vantagem significativa em relação a outros algoritmos de otimização. Isso demonstra a força e a eficácia do algoritmo, bem como seu potencial para otimizar soluções para uma variedade de problemas complexos.

Um fator que considero muito importante e que contribui para os resultados impressionantes em diferentes tipos de funções de teste, inclusive aquelas de alta complexidade, é a incorporação de métodos (técnicas) presentes em outros algoritmos de otimização. Por exemplo, o HS não utiliza classificação do conjunto de soluções, e cada solução atualiza apenas sua própria solução local. Essa abordagem é semelhante ao algoritmo de otimização de busca do cuco, onde um novo caminho de desenvolvimento para uma solução é explorado somente se o "ovo" for melhor do que o que já está no "ninho". Além disso, os métodos utilizados no HS se assemelham aos aplicados em algoritmos genéticos, envolvendo a combinação de elementos de solução.

O algoritmo HS possui um desempenho excepcional e pode lidar com uma ampla gama de problemas complexos. Ele é especialmente adequado para problemas com muitas variáveis e pode ser aplicado tanto em funções contínuas suaves quanto em problemas discretos combinatórios. Já foram registrados casos de sucesso na aplicação do algoritmo HS em diversas áreas, como engenharia, eletrônica e logística.

Uma das vantagens do algoritmo HS é sua simplicidade de implementação, o que permite que os pesquisadores explorem e combinem diferentes estratégias de otimização. Isso indica que ainda existem muitas oportunidades para aprimorar e expandir as capacidades desse algoritmo.

Histograma apresentando os resultados do teste de algoritmo, Figura 3.

Figura 3. Histograma dos resultados finais dos testes dos algoritmos.

Prós e contras do algoritmo de busca de harmonia HS:

Prós:
1. Simplicidade de implementação.
2. Excelente convergência em todos os tipos de funções.
3. Escalabilidade impressionante.
4. Muito rápido.
5. Poucos parâmetros externos.

Contras:
Não vistos.

Para cada artigo, eu anexo um arquivo que contém versões atualizadas dos códigos dos algoritmos para todos os artigos anteriores. O artigo é a experiência acumulada do autor e opinião pessoal, as conclusões e julgamentos são baseados em experimentos.