Algoritmos de otimização populacionais: otimização de dinâmica espiral (Spiral Dynamics Optimization, SDO)

Conteúdo:

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

1. Introdução

Na literatura científica, há uma vasta gama de algoritmos de otimização metaheurística baseados nos diferentes aspectos da natureza e das populações. Esses algoritmos são classificados em várias categorias, como: inteligência de enxame, física, química, comportamento humano social, plantas, animais, entre outros. Existem muitos algoritmos de otimização metaheurística baseados em inteligência de enxame. Por outra parte, os algoritmos baseados em fenômenos físicos também são amplamente propostos e aplicados com sucesso em várias áreas do conhecimento.

Os algoritmos baseados na inteligência de enxame incorporam elementos de inteligência no processo de encontrar uma solução ideal. Eles modelam o comportamento de um enxame ou colônia, em que agentes individuais trocam informações e cooperam para alcançar um objetivo comum. Esses algoritmos podem ser eficazes em tarefas que requerem busca global e adaptabilidade a condições mutáveis.

Por outro lado, os algoritmos baseados na física dependem das leis e princípios da física para resolver problemas de otimização. Eles modelam fenômenos físicos, como gravidade, eletromagnetismo ou termodinâmica, e usam esses princípios para encontrar a melhor solução. Uma das principais vantagens dos algoritmos baseados na física é sua interpretação simples. Eles podem exibir de maneira precisa e consistente a dinâmica em toda a área de busca.

Além disso, alguns algoritmos baseados na física usam a proporção áurea, uma relação matemática e natural que possui propriedades especiais e ajuda a convergir rapidamente e eficientemente para a solução ideal. A proporção áurea tem sido estudada e aplicada em diversas áreas, incluindo a otimização de redes neurais artificiais, alocação de recursos e outros.

Assim, os algoritmos de otimização metaheurística baseados na física representam uma ferramenta poderosa para resolver problemas complexos de otimização. Sua precisão e o uso de princípios físicos fundamentais os tornam atraentes em vários campos onde é necessária uma busca eficiente por soluções ótimas.

O spiral dynamics optimisation (SDO) é um dos algoritmos físicos mais simples. Ele foi proposto por Tamura e Yasuda em 2011 e desenvolvido usando o fenômeno da espiral logarítmica presente na natureza. O algoritmo é simples e possui poucos parâmetros de controle. Além disso, possui alta velocidade de cálculo, capacidade de busca local, diversificação no início e intensificação em estágios posteriores.

Na natureza, existem muitas espirais, como galáxias, auroras boreais, chifres de animais, tornados, conchas marinhas, caracóis, amonitas, caudas de camaleões e cavalos-marinhos. As espirais também podem ser vistas na arte antiga criada pela humanidade no alvorecer de sua existência. Ao longo dos anos, diversos pesquisadores se esforçaram para entender as sequências espirais e suas complexidades, bem como desenvolver equações e algoritmos em torno delas. Além disso, vale ressaltar que um fenômeno espiral comum na natureza é a espiral logarítmica, que pode ser observada em galáxias e ciclones tropicais. Os processos discretos de geração da espiral logarítmica foram implementados como comportamento eficaz de busca em metaheurística, o que inspirou o desenvolvimento do algoritmo de otimização de dinâmica espiral.

Os padrões conhecidos como sequências espirais visíveis encontradas na natureza incluem plantas, árvores, ondas e muitas outras formas. Os padrões visuais na natureza podem ser modelados usando teoria do caos, fractais, espirais e outros conceitos matemáticos. Em alguns padrões naturais, as espirais e os fractais estão intimamente relacionados. Por exemplo, a espiral de Fibonacci é uma variação da espiral logarítmica baseada na proporção áurea e nos números de Fibonacci. Como é logarítmica, a curva tem a mesma aparência em todas as escalas, e também pode ser considerada um fractal.

Os padrões mencionados inspiraram os pesquisadores a desenvolver algoritmos de otimização. Há diferentes tipos de trajetórias em espiral, mas aqui estão as principais:

• Espiral de Arquimedes
• Espiral cicloide
• Espiral epitrocoide
• Espiral hipotrocoide
• Espiral logarítmica
• Espiral rosa
• Espiral de Fermat

Cada um desses tipos de espirais possui propriedades exclusivas e pode ser utilizado para modelar diversos padrões naturais. Além disso, há um interesse especial em destacar vários algoritmos de otimização inspirados na natureza, baseados no conceito de caminhos em espiral. Ao longo dos anos, pesquisadores desenvolveram vários novos algoritmos de otimização que utilizam movimento em espiral.

Além disso, o comportamento de algoritmos não espirais pode ser alterado usando caminhos espirais como uma camada adicional ou complemento para aumentar a precisão da solução ideal.

O algoritmo de otimização espiral bidimensional, proposto por Tamura e Yasuda, é um método metaheurístico de múltiplos pontos para problemas de otimização contínua bidimensional. Posteriormente, Tamura e Yasuda propuseram a otimização n-dimensional, usando a filosofia da otimização bidimensional.

2. Descrição do algoritmo

O algoritmo SDO para busca em espaços multidimensionais, descrito pelos autores, tem limitações e desvantagens:

• Não pode ser usado para problemas de otimização unidimensional e outros de dimensões ímpares.
• O agrupamento de coordenadas pelo algoritmo pode afetar a qualidade da solução em tarefas específicas e mostrar falsos positivos em testes sintéticos.

Construir trajetórias espirais no espaço multidimensional apresenta certas dificuldades. Assim, se a tarefa é limitada a um espaço unidimensional, uma espiral não pode ser construída no sentido convencional, pois para uma espiral é necessário movimento em pelo menos duas dimensões. Nesse caso, pode-se usar uma função simples para alterar o valor da coordenada ao longo do tempo, sem usar uma espiral. Se estamos falando de um problema de otimização unidimensional, a espiral não é aplicada, já que não há dimensões adicionais para o movimento em espiral.

Em espaços multidimensionais, podem ser construídas espirais para cada par de coordenadas, mas para uma coordenada restante, a espiral não pode ser definida. Por exemplo, em um espaço de 13 dimensões, podem ser construídas espirais para 6 pares de coordenadas, mas uma coordenada se moverá sem componente espiral.

Para construir espirais em espaço multidimensional, pode-se usar o método da "espiral multidimensional" ou "hiperespiral". Este método envolve a introdução de coordenadas virtuais adicionais e a definição de uma forma espiral em cada dimensão. Para construir a hiperespiral, podem ser utilizadas matrizes de rotação e algoritmos baseados na geometria de espaços multidimensionais. No entanto, essa abordagem requer cálculos mais complexos e pode ser difícil de implementar em problemas práticos de otimização.

Uma vez que os artigos usam funções multidimensionais na forma de funções bidimensionais repetidas, o SDO original pode mostrar resultados injustificadamente altos, pois ele usa a vinculação de coordenadas em pares. Assim, em outras tarefas multidimensionais, onde as coordenadas não estão interligadas, o algoritmo espiral mostrará resultados inferiores. Ou seja, para o algoritmo espiral neste exemplo com funções duplicadas serão criadas inadvertidamente condições "estufa".

Para evitar os problemas mencionados com o algoritmo espiral, proponho uma abordagem baseada na projeção da espiral bidimensional em um único eixo coordenado. Se considerarmos o movimento de um ponto em uma espiral bidimensional como o movimento de um pêndulo, então a projeção do movimento do ponto em cada uma das duas coordenadas obedecerá à projeção do movimento do pêndulo em cada coordenada. Dessa forma, podemos usar a projeção do movimento do ponto do pêndulo em cada eixo em espaço multidimensional para modelar o movimento do ponto ao longo de uma espiral em espaço bidimensional.

Ao usar o método de construção de espirais que modelam o comportamento de um pêndulo em cada coordenada em espaço multidimensional, o raio de cada "espiral virtual" pode ser diferente. Isso pode ter um efeito positivo na qualidade da otimização, pois algumas coordenadas podem estar mais próximas de ótimos conhecidos e não precisam ser alteradas significativamente.

Podemos aplicar qualquer lei de oscilação harmônica com amortecimento como a projeção da espiral bidimensional em um eixo unidimensional. Para isso, foi escolhido o oscilador harmônico simples amortecido, que é uma dependência da posição de uma partícula no tempo, dada pela fórmula:

x(t) = A*e^(-γt)*cos(ωt + φ)

onde:

• A - amplitude da oscilação
• γ - constante de amortecimento
• ω - frequência natural do oscilador
• φ - fase inicial das oscilações

Dessa fórmula, torna-se claro que o constante de amortecimento, a frequência e a fase inicial são constantes e podem ser usados como parâmetros de entrada do algoritmo, mas usaremos não três, mas dois parâmetros. A fase inicial das oscilações será usada como um componente aleatório em cada iteração (cada coordenada será deslocada na fase em relação às outras coordenadas), caso contrário, o algoritmo é totalmente determinístico e depende apenas do posicionamento inicial dos pontos no espaço.

A ideia é que, assim que um novo ótimo global for encontrado, uma nova amplitude será calculada para todos os pontos, que é a diferença entre a coordenada do extremo global e a coordenada correspondente do ponto. A partir desse momento, as amplitudes são individuais por coordenadas e armazenadas na memória de cada ponto, até que um novo extremo melhor seja encontrado e novas amplitudes sejam definidas.

Após a definição das amplitudes, cada ponto começa a oscilar com amortecimento, onde o eixo de simetria das oscilações é a coordenada conhecida do ótimo global. É conveniente avaliar visualmente o impacto dos coeficientes de amortecimento e frequência (parâmetros externos) nas figuras 1 e 2.

Figura 1. Influência da amplitude no caráter das oscilações.

Figura 2. Influência da frequência no caráter das oscilações.

Embora em nosso algoritmo todas as coordenadas sejam completamente independentes, como mencionado, não há combinações em pares ou conexões entre elas na lógica para construir espirais, se construíssemos o movimento de um ponto em um plano bidimensional, obteríamos uma espiral do seguinte tipo, como na figura 3.

Figura 3. Espiral hipotética, com parâmetros padrão do algoritmo, onde 6 é o valor da amplitude, 0.3 é o constante de amortecimento, e 4 é a frequência.

De fato, em problemas reais, assim como em funções de teste, as amplitudes para cada uma das coordenadas podem não ser iguais (diferente do algoritmo original). A diferença nas amplitudes produzirá espirais achatadas, com a menor amplitude, a coordenada correspondente é refinada mais rapidamente, pois está mais próxima do melhor valor conhecido.

Figura 4. O valor do ponto na coordenada Y está mais próximo do valor conhecido e a amplitude das oscilações é menor do que no eixo X.

Todos os gráficos são construídos em relação ao zero, pois consideramos a diferença em relação ao valor do ótimo conhecido, ou seja, o deslocamento do zero é o incremento.

Vamos passar para a descrição do código. Para começar, vamos definir a estrutura do algoritmo e compor o pseudocódigo:

1. Inicializar a população de pontos
2. Calcular o valor da função de adaptação
3. Calcular a amplitude para cada coordenada dos pontos quando um novo melhor ótimo for encontrado
4. Quando um novo melhor ótimo for encontrado, "lançar" o melhor ponto em uma direção aleatória
   
5. Calcular a nova posição dos pontos usando a fórmula de oscilações harmônicas amortecidas
6. Repetir a partir do passo 2.

O ponto 4 é especificamente adicionado e visa aumentar a resistência a ficar preso, para que os pontos não convirjam em uma "espiral" a algum extremo local e fiquem presos lá. Os autores do algoritmo não abordaram este ponto.

Para a descrição do agente (partícula, ponto), a estrutura S_Particle, que contém as seguintes variáveis, é bem adequada:

• c  [] - array das coordenadas da partícula
  
• cD[] - array das velocidades da partícula
• t - etapa da iteração, atua como "tempo" na fórmula
  
• f - valor da função de adaptação da partícula
  

Também é definida na estrutura a função Init, que é utilizada para a inicialização das variáveis da estrutura. O parâmetro coords define a quantidade de coordenadas da partícula.

//——————————————————————————————————————————————————————————————————————————————
struct S_Particle
{
  void Init (int coords)
  {
    ArrayResize (c,    coords);
    ArrayResize (cD,   coords);
    t = 0;
    f = -DBL_MAX;
  }

  double c  []; //coordinates
  double cD []; //coordinates
  int    t;     //iteration (time)
  double f;     //fitness
};
//——————————————————————————————————————————————————————————————————————————————

Definiremos a classe do algoritmo SDOm, C_AO_SDOm. A classe contém as seguintes variáveis e métodos:

• cB [] - array das melhores coordenadas
• fB - valor da função de adaptação das melhores coordenadas
• p [] - array de partículas, tipo de dado - S_Particle
• rangeMax [] - array dos valores máximos do intervalo de busca
  
• rangeMin [] - array dos valores mínimos do intervalo de busca
  
• rangeStep [] - array de etapas de busca
  
• Init - método para a inicialização dos parâmetros da classe, aceita os seguintes parâmetros: "coordinatesNumberP" - quantidade de coordenadas, "populationSize" - tamanho da população, "dampingFactorP" - constante de amortecimento, "frequencyP" - frequência, "precisionP" - precisão.
• Moving - método para mover as partículas no espaço de busca
• Revision - método para revisão e atualização das melhores coordenadas
• coords - quantidade de coordenadas
• popSiz - tamanho da população
• A, e, γ, ω, φ - componentes da fórmula do oscilador harmônico amortecido
  
• precision, revision - variáveis privadas, que são utilizadas internamente na classe
• SeInDiSp - método calcula o novo valor da coordenada no intervalo definido com o passo especificado
  
• RNDfromCI - método gera um número aleatório no intervalo definido

Este código descreve a classe C_AO_SDOm, que representa a implementação do algoritmo com funções adicionais para revisar e atualizar das melhores coordenadas.

As primeiras três variáveis da classe são o array cB, que armazena as melhores coordenadas, a variável fB, que armazena o valor da função de adaptação das melhores coordenadas, e o array p, que armazena os candidatos (partículas) da população.

As próximas três variáveis da classe são os arrays rangeMax, rangeMin e rangeStep, que armazenam os valores máximos e mínimos do intervalo de busca e as etapas de busca, respectivamente.

Além disso, a classe contém três métodos públicos: Init, Moving e Revision. O método Init é usado para a inicialização dos parâmetros da classe e criação da população inicial de partículas. O método Moving é usado para mover as partículas pelo espaço de busca. O método Revision é usado para a revisão das melhores coordenadas e atualização dos seus valores.

A classe também contém várias variáveis privadas, que são usadas internamente. São as variáveis coords e popSize, que armazenam a quantidade de coordenadas e o tamanho da população, respectivamente, a variável A, que é usada no método Moving, a variável precision, que armazena o valor da precisão, e a variável revision, que determina a necessidade de revisão das melhores coordenadas.

A classe contém vários métodos privados: Research, SeInDiSp e RNDfromCI. O método Research é usado para investigar novas coordenadas da partícula, e os métodos SeInDiSp e RNDfromCI são usados para calcular valores aleatórios no intervalo definido.

O "precision" é um parâmetro externo do algoritmo, responsável pela discretização do movimento ao longo da trajetória de oscilação amortecida; quanto maior o valor, mais precisamente a trajetória é reproduzida, enquanto um valor menor leva a uma trajetória "irregular" (isso não significa que haverá um impacto negativo no resultado, depende da especificidade da tarefa). O parâmetro foi escolhido como ótimo após uma série de meus experimentos.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_SDOm
{
  //----------------------------------------------------------------------------
  public: double     cB []; //best coordinates
  public: double     fB;    //FF of the best coordinates
  public: S_Particle p  []; //particles

  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 double dampingFactorP,       //damping factor
                     const double frequencyP,           //frequency
                     const double precisionP);          //precision

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

  //----------------------------------------------------------------------------
  private: int    coords;   //coordinates number
  private: int    popSize;  //population size

  private: double A;
  private: double e;
  private: double γ;
  private: double ω;
  private: double φ;
  private: double precision;

  private: bool   revision;

  private: double SeInDiSp  (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI (double min, double max);
};
//——————————————————————————————————————————————————————————————————————————————

O método Init da classe C_AO_SDOm é usado para inicializar os parâmetros da classe e criar a população inicial de partículas.

Inicialmente, "MathSrand" é usado para redefinir o gerador de números aleatórios e a função "GetMicrosecondCount" para inicializar o gerador.

Em seguida, o método estabelece valores iniciais para as variáveis "fB" e "revision" e atribui tamanhos ao array da população, bem como define valores para as variáveis constantes envolvidas na fórmula das oscilações amortecidas.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_SDOm::Init (const int    coordinatesNumberP,   //coordinates number
                      const int    populationSizeP,      //population size
                      const double dampingFactorP,       //damping factor
                      const double frequencyP,           //frequency
                      const double precisionP)           //precision
{
  MathSrand ((int)GetMicrosecondCount ()); // reset of the generator
  fB       = -DBL_MAX;
  revision = false;

  coords  = coordinatesNumberP;
  popSize = populationSizeP;

  e = M_E;
  γ = dampingFactorP;
  ω = frequencyP;
  φ = 0.0;
  precision = precisionP;

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

  ArrayResize (p, popSize);

  for (int i = 0; i < popSize; i++)
  {
    p [i].Init (coords);
  }
}
//——————————————————————————————————————————————————————————————————————————————

Para mover as partículas no espaço de busca, usaremos o método "Moving".

O primeiro bloco de código (if (!revision)) só é executado na primeira iteração e é destinado para o posicionamento aleatório das partículas no espaço de busca. Depois, o método configura o valor "revision" para "true", para na próxima vez usar o bloco de código padrão.

A parte seguinte do código do método é responsável pelo movimento das partículas da população. Se o valor de adaptação da partícula atual é igual ao valor de adaptação das melhores coordenadas (p[i].f == fB), então as coordenadas da partícula são atualizadas assim como no primeiro bloco de código. Isso significa que a partícula é lançada de sua posição em uma direção aleatória para evitar que todas as partículas converjam para um único ponto.

Caso contrário, o método usa a variável "t" para simular o tempo atual para cada partícula, usando o contador de iterações (que é reiniciado ao atualizar a melhor solução global). Então, as coordenadas de cada partícula são calculadas pela fórmula das oscilações harmônicas amortecidas.

A parte do código comentada adiciona um incremento aleatório ao valor calculado pela fórmula da coordenada e pode ser usada para criar um efeito visual "fogos de artifício". No entanto, esse efeito não tem valor prático e não melhora os resultados, por isso o código está comentado.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_SDOm::Moving ()
{
  //----------------------------------------------------------------------------
  if (!revision)
  {
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        p [i].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
        p [i].c [c] = SeInDiSp (p [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }

    revision = true;
    return;
  }

  //----------------------------------------------------------------------------
  int t = 0.0;

  for (int i = 0; i < popSize; i++)
  {
    if  (p [i].f == fB)
    {
      for (int c = 0; c < coords; c++)
      {
        p [i].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
        p [i].c [c] = SeInDiSp (p [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      }

      continue;
    }

    p [i].t++;
    t = p [i].t;

    for (int c = 0; c < coords; c++)
    {
      A = p [i].cD [c];
      φ = RNDfromCI (0.0, 2.0);

      p [i].c [c] = p [i].c [c] + A * pow (e, -γ * t / precision) * cos (ω * t / (precision) + φ);// + RNDfromCI (-0.01, 0.01) * (rangeMax [c] - rangeMin [c]);
      p [i].c [c] = SeInDiSp (p [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

O método Revision da classe é usado para atualizar as melhores coordenadas e calcular a diferença entre as coordenadas das partículas e a melhor solução conhecida. Essa diferença serve como amplitude inicial, e assim que uma nova melhor solução for encontrada, as partículas começarão a realizar movimentos oscilatórios em torno das melhores coordenadas conhecidas, que estão no centro desses movimentos.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_SDOm::Revision ()
{
  //----------------------------------------------------------------------------
  bool flag = false;
  for (int i = 0; i < popSize; i++)
  {
    if (p [i].f > fB)
    {
      flag = true;
      fB = p [i].f;
      ArrayCopy (cB, p [i].c, 0, 0, WHOLE_ARRAY);
    }
  }

  if (flag)
  {
    for (int i = 0; i < popSize; i++)
    {
      p [i].t = 0;

      for (int c = 0; c < coords; c++)
      {
        p [i].cD [c] = (cB [c] - p [i].c [c]);

      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. Resultados dos testes

Impressão do algoritmo de dinâmica em espiral em execução em uma bancada de teste, aparentemente - resultados nada ruins:

C_AO_SDOm:100;0.3;4.0;10000.0
=============================
5 Rastrigin's; Func runs 10000 result: 76.22736727464056
Score: 0.94450
25 Rastrigin's; Func runs 10000 result: 64.5695106264092
Score: 0.80005
500 Rastrigin's; Func runs 10000 result: 47.607500083305425
Score: 0.58988
=============================
5 Forest's; Func runs 10000 result: 1.3265635010116805
Score: 0.75037
25 Forest's; Func runs 10000 result: 0.5448141810532924
Score: 0.30817
500 Forest's; Func runs 10000 result: 0.12178250603909949
Score: 0.06889
=============================
5 Megacity's; Func runs 10000 result: 5.359999999999999
Score: 0.44667
25 Megacity's; Func runs 10000 result: 1.552
Score: 0.12933
500 Megacity's; Func runs 10000 result: 0.38160000000000005
Score: 0.03180
=============================
All score: 4.06967

Após visualizar o algoritmo SDOm encontramos algumas características distintas: o gráfico de convergência em todas as funções de teste é instável, o caráter da curva de convergência muda ao longo de todas as iterações e isso não aumenta a confiança nos resultados. Na representação com a função Megacity, eu mostrei especificamente vários testes repetidos (normalmente só um é mostrado no vídeo, para que o GIF não fique muito grande), para demonstrar a instabilidade dos resultados de teste para teste, com uma grande variação nos resultados.

No movimento das partículas, não foram notadas características especiais, exceto nas funções Forest e Megacity, onde as coordenadas das partículas se alinham em linhas bem visíveis. É difícil julgar se isso é bom ou ruim, por exemplo, no caso do algoritmo ACOm isso era um sinal de convergência de qualidade, mas no caso do SDOm isso não pode ser afirmado.

  IWDm na função de teste Rastrigin.

  SDOm na função de teste Forest.

  SDOm na função de teste Megacity.

Quando se usa o código comentado no método Moving, que é responsável por adicionar ruído aleatório à coordenada da partícula, ocorre um fenômeno interessante, semelhante a fogos de artifício, embora a mudança aleatória de fase das oscilações não seja utilizada. Presumo que após a convergência massiva das partículas para a solução conhecida, ocorre um disparo delas em diferentes direções, o que explica o efeito visual impressionante, demonstrando o emperramento do algoritmo. Isso é evidente pela coincidência do momento da "explosão" dos fogos de artifício com o início da parte horizontal do gráfico de convergência.

Demonstração de um efeito "fogos de artifício" inútil, mas bonito.

O algoritmo SDOm apresentou resultados geralmente bons e ficou em 8º lugar entre os 23 participantes da tabela de classificação. SDOm mostra resultados significativamente melhores na função suave Rastrigin. A tendência a emperrar não contribui para excelentes resultados nas funções mais complexas Forest e Megacity.

№	AO	Description	Rastrigin			Rastrigin final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result
			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	SDSm	stochastic diffusion search M	0,99809	1,00000	0,69149	2,68958	1,00000	1,00000	1,00000	3,00000	1,00000	1,00000	1,00000	3,00000	100,000
2	SDS	stochastic Diffusion Search	0,99737	0,97322	0,58904	2,55963	0,96778	0,93572	0,79649	2,69999	0,78696	0,93815	0,71804	2,44315	88,208
3	SSG	saplings sowing and growing	1,00000	0,92761	0,51630	2,44391	0,72654	0,65201	0,83760	2,21615	0,54782	0,61841	0,99522	2,16146	77,678
4	HS	harmony search	0,99676	0,88385	0,44686	2,32747	0,99882	0,68242	0,37529	2,05653	0,71739	0,71842	0,41338	1,84919	70,647
5	IWO	invasive weed optimization	0,95828	0,62227	0,27647	1,85703	0,70690	0,31972	0,26613	1,29275	0,57391	0,30527	0,33130	1,21048	48,267
6	ACOm	ant colony optimization M	0,34611	0,16683	0,15808	0,67103	0,86785	0,68980	0,64798	2,20563	0,71739	0,63947	0,05579	1,41265	47,419
7	MEC	mind evolutionary computation	0,99270	0,47345	0,21148	1,67763	0,60691	0,28046	0,21324	1,10061	0,66957	0,30000	0,26045	1,23002	44,061
8	SDOm	spiral dynamics optimization M	0,81076	0,56474	0,35334	1,72884	0,72333	0,30644	0,30985	1,33963	0,43479	0,13289	0,14695	0,71463	41,370
9	COAm	cuckoo optimization algorithm M	0,92400	0,43407	0,24120	1,59927	0,58309	0,23477	0,13842	0,95629	0,52174	0,24079	0,17001	0,93254	37,845
10	FAm	firefly algorithm M	0,59825	0,31520	0,15893	1,07239	0,51012	0,29178	0,41704	1,21894	0,24783	0,20526	0,35090	0,80398	33,152
11	ABC	artificial bee colony	0,78170	0,30347	0,19313	1,27829	0,53774	0,14799	0,11177	0,79750	0,40435	0,19474	0,13859	0,73768	29,784
12	BA	bat algorithm	0,40526	0,59145	0,78330	1,78002	0,20817	0,12056	0,21769	0,54641	0,21305	0,07632	0,17288	0,46225	29,488
13	CSS	charged system search	0,56605	0,68683	1,00000	2,25289	0,14065	0,01853	0,13638	0,29555	0,07392	0,00000	0,03465	0,10856	27,914
14	GSA	gravitational search algorithm	0,70167	0,41944	0,00000	1,12111	0,31623	0,25120	0,27812	0,84554	0,42609	0,25525	0,00000	0,68134	27,807
15	BFO	bacterial foraging optimization	0,67203	0,28721	0,10957	1,06881	0,39655	0,18364	0,17298	0,75317	0,37392	0,24211	0,18841	0,80444	27,549
16	EM	electroMagnetism-like algorithm	0,12235	0,42928	0,92752	1,47915	0,00000	0,02413	0,29215	0,31628	0,00000	0,00527	0,10872	0,11399	18,981
17	SFL	shuffled frog-leaping	0,40072	0,22021	0,24624	0,86717	0,20129	0,02861	0,02221	0,25211	0,19565	0,04474	0,06607	0,30646	13,201
18	MA	monkey algorithm	0,33192	0,31029	0,13582	0,77804	0,10000	0,05443	0,07482	0,22926	0,15652	0,03553	0,10669	0,29874	11,771
19	FSS	fish school search	0,46812	0,23502	0,10483	0,80798	0,12825	0,03458	0,05458	0,21741	0,12175	0,03947	0,08244	0,24366	11,329
20	IWDm	intelligent water drops M	0,26459	0,13013	0,07500	0,46972	0,28568	0,05445	0,05112	0,39126	0,22609	0,05659	0,05054	0,33322	10,434
21	PSO	particle swarm optimisation	0,20449	0,07607	0,06641	0,34696	0,18873	0,07233	0,18207	0,44313	0,16956	0,04737	0,01947	0,23641	8,431
22	RND	random	0,16826	0,09038	0,07438	0,33302	0,13480	0,03318	0,03949	0,20747	0,12175	0,03290	0,04898	0,20363	5,056
23	GWO	grey wolf optimizer	0,00000	0,00000	0,02093	0,02093	0,06562	0,00000	0,00000	0,06562	0,23478	0,05789	0,02545	0,31812	1,000

Considerações finais

O enfoque original para implementar a versão modificada permitiu evitar cálculos matriciais complexos, como no algoritmo original do autor, e também permitiu torná-lo universal sem estar vinculado às relações entre coordenadas para o espaço n-dimensional.

Tentei usar o conceito de "massa" na fórmula de oscilações harmônicas amortecidas, com o objetivo de individualizar o comportamento das partículas de acordo com sua adaptação. A ideia era reduzir a amplitude e a frequência para partículas com maior massa (com melhor valor de função de adaptação), enquanto as partículas mais leves deveriam ter movimentos de maior amplitude e maior frequência. Isso poderia proporcionar um maior grau de refinamento das melhores soluções conhecidas e, ao mesmo tempo, aumentar a capacidade de busca através dos movimentos "amplos" das partículas leves. Infelizmente, os resultados dos testes não mostraram a melhoria esperada com essa ideia.

A modelagem física das trajetórias das partículas no algoritmo sugere a possibilidade de aplicar conceitos físicos como velocidade, aceleração e inércia. Essa é uma questão de pesquisas futuras para um algoritmo tão interessante quanto o SDO.

Figura 5. Graduação de cores dos algoritmos de acordo com os testes correspondentes.

Figura 6. Histograma dos resultados dos testes dos algoritmos (em uma escala de 0 a 100, quanto maior, melhor,

no arquivo, script para calcular a tabela de classificação de acordo com a metodologia deste artigo).

Prós e contras do algoritmo modificado de dinâmica espiral (SDOm):

Prós:
1. Poucos parâmetros externos.
2. Implementação simples.
3. Rapidez de execução.

Contras:
1. Alta variação nos resultados.
2. Tendência a ficar preso em extremos locais.

O artigo inclui um arquivo com versões atualizadas dos códigos dos algoritmos descritos nos artigos anteriores. O autor do artigo não assume responsabilidade pela precisão absoluta na descrição dos algoritmos canônicos, muitos deles foram modificados para melhorar os recursos de pesquisa. As conclusões e opiniões apresentadas nos artigos são baseados nos resultados dos experimentos realizados.