Algoritmos de otimização populacional: sistema imune micro-artificial (Micro Artificial Immune System, Micro-AIS)

Conteúdo:

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

1. Introdução

O sistema imunológico é um mecanismo incrível que desempenha um papel importante na proteção do nosso corpo contra ameaças externas. Como um escudo invisível, ele combate bactérias, vírus e fungos, mantendo nosso organismo saudável. Mas e se pudéssemos usar esse mecanismo poderoso para resolver problemas complexos de otimização e aprendizado É exatamente essa abordagem que é utilizada no método de otimização que usa o sistema imunológico artificial (Artificial Immune System, AIS).

O sistema imunológico do corpo é uma rede complexa de células, tecidos e órgãos que protege o organismo contra infecções, doenças e outras influências externas. Ele funciona reconhecendo e destruindo substâncias estranhas e microrganismos, como bactérias, vírus, fungos, etc.

O algoritmo AIS modela esses processos, utilizando os conceitos de antígenos (dados de entrada), anticorpos (soluções) e células assassinas (processos de otimização) para resolver problemas de forma otimizada. Os antígenos representam os dados de entrada que precisam ser otimizados. Os anticorpos representam as possíveis soluções para o problema. As células assassinas representam os processos de otimização que buscam as melhores soluções para o problema de otimização.

Nos anos 1990, foi proposto um método de otimização conhecido como Artificial Immune System (AIS). As pesquisas iniciais sobre esse método começaram ainda em meados dos anos 1980, quando Farmer, Packard e Perelson (1986) e Bersini e Varela (1990), em seus trabalhos sobre redes imunológicas, fizeram contribuições significativas para o desenvolvimento e aplicação do AIS.

Desde então, o método AIS continua a se desenvolver e ser objeto de pesquisas constantes na comunidade científica. Muitas variações e modificações desse método foram propostas, assim como sua aplicação em várias tarefas de otimização e aprendizado. O sistema imunológico do corpo desempenha um papel importante também na proteção contra influências externas, como infecções e tumores. Ele tem a capacidade de reconhecer e detectar anomalias e atacar agentes hostis, mantendo a capacidade de diferenciar e armazenar informações sobre eles para uso futuro.

O Micro-AIS (Micro-Immune Algorithm) é uma modificação do algoritmo do sistema imunológico (AIS) desenvolvida para resolver problemas de otimização. Ele se diferencia do AIS convencional por usar um modelo mais simples do sistema imunológico e operações mais simples de processamento de informações imunológicas.

A ideia principal do Micro-AIS é criar e evoluir uma população de agentes que imitam as células imunológicas. Esses agentes se movimentam no espaço de busca de soluções sem interagir entre si e sem trocar informações sobre as soluções. Dessa forma, os agentes podem aprender e se adaptar às condições mutáveis do problema.

No AIS tradicional, é utilizado um modelo complexo do sistema imunológico, que inclui muitos tipos de células e moléculas, como células B, células T, anticorpos, citocinas, etc. No Micro-AIS, é utilizado um modelo mais simples, que inclui apenas anticorpos. Além disso, o Micro-AIS utiliza operações de processamento de informações imunológicas mais simples, como mutação e seleção.

Uma das vantagens do Micro-AIS em relação ao AIS é sua simplicidade e facilidade de implementação. No entanto, em alguns casos, um modelo mais complexo do sistema imunológico pode ser mais eficaz para resolver problemas complexos.

De modo geral, a escolha entre o Micro-AIS e o AIS tradicional depende da tarefa específica e do contexto de aplicação. Se a tarefa de otimização for relativamente simples e exigir uma solução rápida, o Micro-AIS pode ser uma boa opção. Se a tarefa for mais complexa e exigir uma solução mais precisa, o AIS tradicional pode ser mais adequado.

2. Descrição do algoritmo

No Micro-AIS, o conceito de afinidade (affinity) é usado para determinar a adequação, sendo um indicador da similaridade entre o anticorpo e o antígeno. A afinidade mede o grau de semelhança entre o anticorpo e o antígeno. Quanto maior a afinidade, mais semelhantes são o anticorpo e o antígeno. No Micro-AIS, a afinidade é usada para selecionar os melhores anticorpos, que serão usados para criar novos anticorpos por meio de mutação e cruzamento. Os anticorpos com maior afinidade têm maior probabilidade de serem selecionados para a criação de novos anticorpos.

A afinidade pode ser definida como a distância entre o vetor de características do objeto e o vetor de pesos do classificador. Quanto menor a distância, mais semelhantes são os vetores, e maior é a afinidade. De maneira geral, a afinidade pode ser definida como uma função de distância entre dois números de ponto flutuante. A função de distância pode ser escolhida dependendo da tarefa específica e dos requisitos do algoritmo Micro-AIS. Por exemplo, para tarefas de otimização, a distância é geralmente definida como distância euclidiana, distância de Manhattan ou outro tipo de distância.

No entanto, experimentos com Micro-AIS mostraram que o uso da afinidade não é a abordagem mais eficaz nessa estratégia de busca, e em vez disso, pode-se usar diretamente o valor da função de adaptação.

No Micro-AIS original, é utilizada uma aplicação probabilística de mutações nos genes, onde, quanto maior a adaptação, menor a probabilidade de mutação. Essa abordagem também precisou ser abandonada devido à ineficácia, mas isso pode ser facilmente verificado com a adição de algumas linhas de código.

Pseudocódigo do Micro-AIS:

1. Criar uma população de clones de anticorpos e distribuí-los aleatoriamente no espaço de busca. Anticorpos e seus clones representam potenciais soluções para o problema de otimização. Clones são criados por meio da geração aleatória do genótipo, que determina os valores dos parâmetros do problema de otimização.
   
2. Determinar a adaptação, que é uma medida da qualidade da solução. O valor da adaptação pode ser calculado avaliando a função objetivo para cada anticorpo.
   
3. Para cada anticorpo, criar clones em quantidade correspondente à regra de progressão decrescente. O primeiro anticorpo em adaptação cria mais clones do que o segundo, o segundo mais do que o terceiro, e assim por diante. A quantidade de clones corresponde não ao grau de adaptação, mas a uma regra de progressão fixa. Anticorpos mais adaptados criam sempre mais clones do que os menos adaptados, mantendo uma proporção constante.
   
4. Aplicar mutação aos genes dos clones. Para cada clone, ocorre uma mutação no genótipo, permitindo a criação de novas soluções e a exploração do espaço de parâmetros do problema de otimização.
   
5. Determinar a adaptação dos clones.
   
6. Após a mutação e o cálculo da adaptação, a população de clones é adicionada à população parental de anticorpos.
   
7. Ordenar a população (anticorpos + clones) em ordem decrescente de adaptação. Isso permite selecionar as melhores soluções para criar uma nova população de clones na próxima iteração, implementando a competição entre clones descendentes e anticorpos parentais.
   
8. Repetir a partir do passo 2 até que o critério de parada seja atingido. O critério de parada pode ser pré-definido, por exemplo, alcançar um determinado valor de adaptação ou um número máximo de iterações.
   

A mutação dos genes dos clones é realizada pela geração de números aleatórios com distribuição uniforme, usando a fórmula:

X' = X + dist * rnd * k * mutation

onde:

• X' : novo valor do gene (coordenada) do clone
• X: valor do gene do anticorpo parental
• dist: incremento em relação ao gene parental
• rnd: número aleatório com distribuição uniforme no intervalo [-1.0;1.0]
• k: coeficiente de decaimento uniforme, dependente da época atual
• mutation: coeficiente de mutação, basicamente um fator de escala do incremento (parâmetro externo)

O coeficiente "k" é calculado pela fórmula:

k = (epochs - epochsCNT) / epochs

onde:

• epochs: número máximo de épocas
• epochsCNT: contador de épocas (iterações)

O tamanho do incremento "dist" é a distância do valor máximo do parâmetro a ser otimizado até "X" caso "rnd" seja maior que 0, e de "X" até o valor mínimo do parâmetro caso contrário.

Isso permite que a mutação altere aleatoriamente os valores dos parâmetros da solução, assegurando a exploração do espaço do problema. O coeficiente de decaimento "k" diminui a probabilidade de mudanças muito bruscas nos parâmetros nas iterações posteriores, melhorando a convergência do algoritmo para a solução ótima e refinando as coordenadas encontradas.

Escrevemos a estrutura do anticorpo, S_Agent. A estrutura que representa um anticorpo contém dois campos:

• c: array de coordenadas do agente
• f: valor da adaptação
  

O método "Init" inicializa os campos da estrutura, ajustando o tamanho do array "c" e atribuindo ao campo "f" o valor inicial "-DBL_MAX".

//——————————————————————————————————————————————————————————————————————————————
struct S_Agent
{
  void Init (int coords)
  {
    ArrayResize (c, coords);
    f = -DBL_MAX;
  }

  double c []; //coordinates
  double f;    //fitness
};
//——————————————————————————————————————————————————————————————————————————————

Declaramos a classe C_AO_Micro_AIS com vários campos e métodos definidos para implementar o algoritmo.

Campos da classe:

• cB: array das melhores coordenadas.
• fB: indicador de adaptação para as melhores coordenadas.
• a: array de agentes do tipo "S_Agent".
• rangeMax: array de valores máximos do intervalo de busca.
• rangeMin: array de valores mínimos do intervalo de busca.
• rangeStep: array dos passos de busca.

As variáveis "coords", "popSize", "minClonesNumber", "cloneStep", "mutation", "epochs" recebem parâmetros externos do algoritmo.

Métodos da classe:

• Init: inicializa os campos da classe com os valores definidos.
• Moving: executa o movimento dos agentes.
• Revision: realiza a revisão.

Também são definidos métodos privados "SeInDiSp", "RNDfromCI", "Sorting" para normalização, geração de números aleatórios e ordenação, respectivamente.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_Micro_AIS
{
  //----------------------------------------------------------------------------
  public: double  cB [];  //best coordinates
  public: double  fB;     //FF of the best coordinates
  public: S_Agent a  [];  //agent

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

  public: void Init (const int    coordsP,          //coordinates number
                     const int    popSizeP,         //population size
                     const int    minClonesNumberP, //minimum number of clones
                     const int    cloneStepP,       //clone step
                     const double mutationP,        //mutation
                     const int    epochP);          //total epochs

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

  //----------------------------------------------------------------------------
  private: int    coords;          //coordinates number
  private: int    popSize;         //population size
  private: int    minClonesNumber; //minimum number of clones
  private: int    cloneStep;       //clone step
  private: double mutation;        //mutation
  private: int    epochs;          //total epochs
  private: int    epochsCNT;       //epoch counter
  private: int    parentsNumb;     //number of parents
  private: bool   revision;

  private: S_Agent parents [];  //parents
  private: int     ind     [];
  private: double  val     [];
  private: S_Agent pTemp   [];

  private: int     cCnt    [];  //clone counters for each antibody

  private: double SeInDiSp           (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI          (double min, double max);
  private: void   Sorting            (S_Agent &p [], int size);
};
//——————————————————————————————————————————————————————————————————————————————

Para inicializar um objeto da classe, implementamos o método "Init" para inicializar os campos da classe com os valores definidos.

No início do método, ocorre a inicialização do gerador de números aleatórios usando a função "MathSrand" e o reset de seu estado usando a função "GetMicrosecondCount".

Depois, as variáveis "fB" e "revision" recebem os valores "-DBL_MAX" e "false", respectivamente, e os campos privados são inicializados com os parâmetros de entrada do método.

Em seguida, são calculados os valores do array "cCnt", usado para armazenar o número de clones para cada anticorpo, utilizando um laço e a fórmula da progressão, onde o primeiro termo da progressão é "a1", a diferença da progressão é "d" e a soma de todos os termos da progressão é "Sn". Os valores da progressão são salvos no array "cCnt".

Depois, o método define o valor da variável "parentsNumb" como o tamanho do array "cCnt".

Em seguida, os tamanhos dos arrays "ind", "val", "pTemp", "a", "parents", "rangeMax", "rangeMin", "rangeStep" e "cB" são ajustados. Os tamanhos dos arrays são definidos de acordo com os valores "popSize" e "parentsNumb".

Depois, em um laço, são inicializados os elementos do array "a" usando o método "Init" da classe "S_Agent", e os elementos do array "parents" também são inicializados usando o método "Init".

No final do método, os tamanhos dos arrays "rangeMax", "rangeMin", "rangeStep" e "cB" são ajustados de acordo com o valor de "coords".

Assim, o método "Init" executa a inicialização dos campos da classe "C_AO_Micro_AIS" e o cálculo dos valores da progressão para o array "cCnt".

//——————————————————————————————————————————————————————————————————————————————
void C_AO_Micro_AIS::Init (const int    coordsP,          //coordinates number
                           const int    popSizeP,         //population size
                           const int    minClonesNumberP, //minimum number of clones
                           const int    cloneStepP,       //clone step
                           const double mutationP,        //mutation
                           const int    epochP)           //total epochs
{
  MathSrand ((int)GetMicrosecondCount ()); // reset of the generator
  fB       = -DBL_MAX;
  revision = false;

  coords          = coordsP;
  popSize         = popSizeP;
  minClonesNumber = minClonesNumberP;
  cloneStep       = cloneStepP;
  mutation        = mutationP;
  epochs          = epochP;
  epochsCNT       = 1;

  //----------------------------------------------------------------------------
  int Sn = popSize;         //sum
  int a1 = minClonesNumber; //first member of progression
  int d  = cloneStep;       //progression difference

  int an   = 0;             //n th member of progression,
  int Ssum = 0;

  ArrayResize (cCnt, 1);

  for (int n = 1;; n++)
  {
    an = a1 + (n - 1) * d;
    Ssum = n * (a1 + an) / 2;

    if (Ssum == Sn)
    {
      ArrayResize (cCnt, n);
      cCnt [n - 1] = an;
      break;
    }
    else
    {
      if (Ssum < Sn)
      {
        ArrayResize (cCnt, n);
        cCnt [n - 1] = an;
      }
      else
      {
        if (n == 1)
        {
          ArrayResize (cCnt, n);
          cCnt [n - 1] = Sn;
          break;
        }
        else
        {
          n--;
          an = a1 + (n - 1) * d;
          int diff = Sn - ((n) * (a1 + an) / 2);

          int index = ArraySize (cCnt) - 1;

          while (true)
          {
            if (index < 0) index = ArraySize (cCnt) - 1;

            cCnt [index]++;

            index--;
            diff--;

            if (diff <= 0) break;
          }

          break;
        }
      }
    }
  }
  
  
  parentsNumb   = ArraySize (cCnt);
  ArrayReverse (cCnt, 0, WHOLE_ARRAY);

  ArrayResize (ind,   popSize + parentsNumb);
  ArrayResize (val,   popSize + parentsNumb);
  ArrayResize (pTemp, popSize + parentsNumb);
  ArrayResize (a,     popSize);
  for (int i = 0; i < popSize; i++) a [i].Init (coords);

  ArrayResize (parents, popSize + parentsNumb);
  for (int i = 0; i < popSize + parentsNumb; i++) parents [i].Init (coords);

  ArrayResize (rangeMax,  coords);
  ArrayResize (rangeMin,  coords);
  ArrayResize (rangeStep, coords);
  ArrayResize (cB,        coords);
}
//——————————————————————————————————————————————————————————————————————————————

Com o método "Moving", implementamos o movimento dos anticorpos pelo espaço de busca.

No início do método, verifica-se o valor da variável "revision". Se for "false", os clones dos anticorpos são posicionados no espaço de busca gerando coordenadas com distribuição uniforme.

Após a geração dos clones dos anticorpos na população, a variável "revision" recebe o valor "true" e o método é encerrado.

Se o valor da variável "revision" não for "false", o próximo bloco de código é executado.

Depois, segue um laço "for" aninhado, que itera sobre o número de agentes pais "parentsNumb". Dentro desse laço ocorre o seguinte:

• um laço "for" aninhado itera sobre o número de clones para o anticorpo pai "cCnt[i]".
• dentro deste laço, um laço "for" itera sobre todas as coordenadas "c" do agente.
• o valor da coordenada "a[indx].c[c]" é definido como o valor da coordenada "parents[i].c[c]".

Depois, o próximo bloco de código é executado:

• calcula-se o valor da variável "k" como a diferença entre "epochs" e "epochsCNT", dividida por "epochs".
• gera-se um número aleatório "rnd" no intervalo de [-1.0;1.0].
• se "rnd" for maior que 0.0, calcula-se o valor da variável "dist" como a diferença entre "rangeMax[c]" e "a[indx].c[c]". Caso contrário, "dist" é igual à diferença entre "a[indx].c[c]" e "rangeMin[c]".
• o valor de "a[indx].[c]" é recalculado usando a fórmula "a[indx].[c] + dist * rnd * k * mutation". Aqui, "mutation" é o coeficiente de mutação.
• o valor de "a[indx].c[c]" passa pela função "SeInDiSp", que normaliza esse valor no intervalo de "rangeMin[c]" a "rangeMax[c]" com passo "rangeStep[c]".

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

    revision = true;
    return;
  }

  //----------------------------------------------------------------------------
  int    indx = 0;
  double min  =  DBL_MAX;
  double max  = -DBL_MAX;
  double dist = 0.0;
  int    cnt  = 0;
  double rnd  = 0.0;
  
  for (int i = 0; i < parentsNumb; i++)
  {
    for (int cl = 0; cl < cCnt [i]; cl++)
    {
      for (int c = 0; c < coords; c++)
      {
        a [indx].c [c] = parents [i].c [c];
        
        //----------------------------------------------------------------------
        double k = ((double)epochs - (double)epochsCNT) / (double)epochs;
        rnd = RNDfromCI (-1.0, 1.0);

        if (rnd > 0.0) dist = (rangeMax [c] - a [indx].c [c]);
        else           dist = (a [indx].c [c] - rangeMin [c]);

        a [indx].c [c] = a [indx].c [c] + dist * rnd * k * mutation;
        a [indx].c [c] = SeInDiSp  (a [indx].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      }

      indx++;
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Por fim, implementamos o método "Revision". Esse método realiza a revisão do estado atual da população de agentes no algoritmo Micro-AIS.

O primeiro bloco de código, separado por um comentário, atualiza a melhor solução global verificando a população de clones e seus valores de adaptação.

Depois, em um laço, os clones são copiados para a população de anticorpos pais no final do array.

Após isso, a função "Sorting" é chamada com os argumentos "parents" e "parentsNumb + popSize". Essa função ordena o array "parents" pelo valor do indicador de adaptação em ordem decrescente.

No final do método, a variável "epochsCNT" é incrementada, responsável por contar o número de épocas no algoritmo.

Assim, o método "Revision" revisa o estado atual da população de anticorpos (agentes), encontra o agente com o melhor valor de adaptação e atualiza o array de agentes pais.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_Micro_AIS::Revision ()
{
  //----------------------------------------------------------------------------
  int indx = -1;

  for (int i = 0; i < popSize; i++)
  {
    if (a [i].f > fB) indx = i;
  }

  if (indx != -1)
  {
    fB = a [indx].f;
    ArrayCopy (cB, a [indx].c, 0, 0, WHOLE_ARRAY);
  }

  //----------------------------------------------------------------------------
  for (int i = parentsNumb; i < parentsNumb + popSize; i++)
  {
    parents [i] = a [i - parentsNumb];
  }

  Sorting (parents, parentsNumb + popSize);
  
  epochsCNT++;
}
//——————————————————————————————————————————————————————————————————————————————

3. Resultados dos testes

Impressão do funcionamento do algoritmo de sistema imune micro-artificial em um banco de testes:

C_AO_Micro_AIS:50:1:2:0.3
=============================
5 Hilly's; Func runs: 10000; result: 0.7954680903046107
25 Hilly's; Func runs: 10000; result: 0.5192246492565626
500 Hilly's; Func runs: 10000; result: 0.30860655744850657
=============================
5 Forest's; Func runs: 10000; result: 0.7295587642801589
25 Forest's; Func runs: 10000; result: 0.36878621216829993
500 Forest's; Func runs: 10000; result: 0.09398090798741626
=============================
5 Megacity's; Func runs: 10000; result: 0.37666666666666665
25 Megacity's; Func runs: 10000; result: 0.15866666666666668
500 Megacity's; Func runs: 10000; result: 0.028016666666666672
=============================
All score: 3.37898 (37.54%)

Desde o artigo anterior, passamos a utilizar valores absolutos nos resultados dos testes, facilitando a orientação e comparação dos resultados de diferentes algoritmos na tabela. O resultado "37.54%" não é excepcional, mas ainda assim está na metade superior da tabela.

A visualização do processo de otimização mostrou que o algoritmo é persistente na exploração de extremos locais significativos para alcançar uma solução melhor. Isso leva à concentração de agentes em diferentes áreas do espaço. O gráfico de convergência mostrou um comportamento incomum. Normalmente, nos algoritmos considerados, observa-se um rápido aumento na convergência na primeira metade das iterações, seguido por uma desaceleração gradual no ritmo de convergência. No entanto, neste algoritmo, o gráfico de convergência tem uma forma em S. Um rápido aumento na convergência é observado apenas nos primeiros 10-20% das iterações, depois a velocidade de convergência diminui, mas próximo ao fim da otimização, há novamente uma aceleração significativa na convergência.

Esse comportamento do gráfico de convergência pode ser explicado pela estratégia de estreitamento do intervalo de incrementos nas mutações de acordo com uma lei linear. No entanto, a convergência não ocorre de forma linear devido ao "acúmulo" desigual de informações pelo algoritmo sobre a superfície da função de teste. O estreitamento do intervalo de mutação começa a desempenhar um papel mais significativo apenas próximo ao fim da otimização. A substituição da lei linear de estreitamento do intervalo de mutação por outras leis não lineares não melhorou a convergência, mas há espaço para a criatividade dos pesquisadores na escolha de outras leis de estreitamento.

O gráfico de convergência deixa a desejar, mas seu formato sugere o potencial para melhorias adicionais na estratégia de busca.

  Micro-AIS na função de teste Hilly.

  Micro-AIS na função de teste Forest.

  Micro-AIS na função de teste Megacity.

O algoritmo Micro-AIS alcançou uma posição respeitável no 11º lugar da tabela de classificação, superando algoritmos conhecidos e populares como o algoritmo de otimização por cuco, a colônia de abelhas artificiais e o recozimento simulado. Isso demonstra a eficácia e o potencial desse algoritmo na resolução de problemas complexos de otimização.

No entanto, a tabela de cores mostra uma redução no desempenho em funções com um grande número de variáveis, indicando uma fraca capacidade de escalabilidade do algoritmo. Isso pode estar relacionado ao fato de que o Micro-AIS utiliza um modelo mais simples de sistema imunológico e operações mais básicas de processamento de informações imunológicas, o que pode limitar sua capacidade de encontrar a solução ideal em espaços de grande dimensionalidade.

Contudo, isso não significa que o Micro-AIS não possa ser usado para resolver problemas com um grande número de variáveis. É possível que seu desempenho possa ser melhorado através de modificações no algoritmo ou da combinação com outros métodos de otimização.

№	AO	Description	Hilly			Hilly final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result	% of MAX
			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	(P+O)ES	(P+O) evolution strategies	0,99934	0,91895	0,56297	2,48127	1,00000	0,93522	0,39179	2,32701	0,83167	0,64433	0,21155	1,68755	6,496	72,18
2	SDSm	stochastic diffusion search M	0,93066	0,85445	0,39476	2,17988	0,99983	0,89244	0,19619	2,08846	0,72333	0,61100	0,10670	1,44103	5,709	63,44
3	SIA	simulated isotropic annealing	0,95784	0,84264	0,41465	2,21513	0,98239	0,79586	0,20507	1,98332	0,68667	0,49300	0,09053	1,27020	5,469	60,76
4	DE	differential evolution	0,95044	0,61674	0,30308	1,87026	0,95317	0,78896	0,16652	1,90865	0,78667	0,36033	0,02953	1,17653	4,955	55,06
5	HS	harmony search	0,86509	0,68782	0,32527	1,87818	0,99999	0,68002	0,09590	1,77592	0,62000	0,42267	0,05458	1,09725	4,751	52,79
6	SSG	saplings sowing and growing	0,77839	0,64925	0,39543	1,82308	0,85973	0,62467	0,17429	1,65869	0,64667	0,44133	0,10598	1,19398	4,676	51,95
7	(PO)ES	(PO) evolution strategies	0,79025	0,62647	0,42935	1,84606	0,87616	0,60943	0,19591	1,68151	0,59000	0,37933	0,11322	1,08255	4,610	51,22
8	ACOm	ant colony optimization M	0,88190	0,66127	0,30377	1,84693	0,85873	0,58680	0,15051	1,59604	0,59667	0,37333	0,02472	0,99472	4,438	49,31
9	MEC	mind evolutionary computation	0,69533	0,53376	0,32661	1,55569	0,72464	0,33036	0,07198	1,12698	0,52500	0,22000	0,04198	0,78698	3,470	38,55
10	IWO	invasive weed optimization	0,72679	0,52256	0,33123	1,58058	0,70756	0,33955	0,07484	1,12196	0,42333	0,23067	0,04617	0,70017	3,403	37,81
11	Micro-AIS	micro artificial immune system	0,79547	0,51922	0,30861	1,62330	0,72956	0,36879	0,09398	1,19233	0,37667	0,15867	0,02802	0,56335	3,379	37,54
12	COAm	cuckoo optimization algorithm M	0,75820	0,48652	0,31369	1,55841	0,74054	0,28051	0,05599	1,07704	0,50500	0,17467	0,03380	0,71347	3,349	37,21
13	SDOm	spiral dynamics optimization M	0,74601	0,44623	0,29687	1,48912	0,70204	0,34678	0,10944	1,15826	0,42833	0,16767	0,03663	0,63263	3,280	36,44
14	NMm	Nelder-Mead method M	0,73807	0,50598	0,31342	1,55747	0,63674	0,28302	0,08221	1,00197	0,44667	0,18667	0,04028	0,67362	3,233	35,92
15	FAm	firefly algorithm M	0,58634	0,47228	0,32276	1,38138	0,68467	0,37439	0,10908	1,16814	0,28667	0,16467	0,04722	0,49855	3,048	33,87
16	GSA	gravitational search algorithm	0,64757	0,49197	0,30062	1,44016	0,53962	0,36353	0,09945	1,00260	0,32667	0,12200	0,01917	0,46783	2,911	32,34
17	ABC	artificial bee colony	0,63377	0,42402	0,30892	1,36671	0,55103	0,21874	0,05623	0,82600	0,34000	0,14200	0,03102	0,51302	2,706	30,06
18	BFO	bacterial foraging optimization	0,54626	0,43533	0,31907	1,30066	0,41626	0,23156	0,06266	0,71048	0,35500	0,15233	0,03627	0,54360	2,555	28,39
19	BA	bat algorithm	0,59761	0,45911	0,35242	1,40915	0,40321	0,19313	0,07175	0,66810	0,21000	0,10100	0,03517	0,34617	2,423	26,93
20	SA	simulated annealing	0,55787	0,42177	0,31549	1,29513	0,34998	0,15259	0,05023	0,55280	0,31167	0,10033	0,02883	0,44083	2,289	25,43
21	IWDm	intelligent water drops M	0,54501	0,37897	0,30124	1,22522	0,46104	0,14704	0,04369	0,65177	0,25833	0,09700	0,02308	0,37842	2,255	25,06
22	PSO	particle swarm optimisation	0,59726	0,36923	0,29928	1,26577	0,37237	0,16324	0,07010	0,60572	0,25667	0,08000	0,02157	0,35823	2,230	24,77
23	MA	monkey algorithm	0,59107	0,42681	0,31816	1,33604	0,31138	0,14069	0,06612	0,51819	0,22833	0,08567	0,02790	0,34190	2,196	24,40
24	SFL	shuffled frog-leaping	0,53925	0,35816	0,29809	1,19551	0,37141	0,11427	0,04051	0,52618	0,27167	0,08667	0,02402	0,38235	2,104	23,38
25	FSS	fish school search	0,55669	0,39992	0,31172	1,26833	0,31009	0,11889	0,04569	0,47467	0,21167	0,07633	0,02488	0,31288	2,056	22,84
26	RND	random	0,52033	0,36068	0,30133	1,18234	0,31335	0,11787	0,04354	0,47476	0,25333	0,07933	0,02382	0,35648	2,014	22,37
27	GWO	grey wolf optimizer	0,59169	0,36561	0,29595	1,25326	0,24499	0,09047	0,03612	0,37158	0,27667	0,08567	0,02170	0,38403	2,009	22,32
28	CSS	charged system search	0,44252	0,35454	0,35201	1,14907	0,24140	0,11345	0,06814	0,42299	0,18333	0,06300	0,02322	0,26955	1,842	20,46
29	EM	electroMagnetism-like algorithm	0,46250	0,34594	0,32285	1,13129	0,21245	0,09783	0,10057	0,41085	0,15667	0,06033	0,02712	0,24412	1,786	19,85

Considerações finais

O método de otimização utilizando o sistema imune micro-artificial (Micro-AIS) é uma abordagem interessante e promissora para a resolução de problemas de otimização, baseada nos princípios de funcionamento do sistema imunológico. Ele permite usar um mecanismo poderoso do sistema imunológico para resolver tarefas complexas de otimização e aprendizado.

Entre as vantagens do Micro-AIS, podemos destacar a pequena quantidade de parâmetros externos e a implementação simples do algoritmo. Isso o torna bastante atraente para uso em problemas práticos.

No entanto, o algoritmo Micro-AIS também apresenta desvantagens. Ele tende a ficar preso em extremos locais e possui baixa convergência. Além disso, o desempenho do algoritmo diminui em funções com um grande número de variáveis, o que evidencia sua fraca capacidade de escalabilidade.

Apesar disso, o Micro-AIS é um método de otimização promissor que pode ser aprimorado por meio de modificações no algoritmo ou da combinação com outros métodos de otimização. Em geral, o método de otimização utilizando o sistema imune micro-artificial representa uma contribuição importante na área de otimização e pode ser uma ferramenta útil na resolução de problemas complexos em diversas áreas, como aprendizado de máquina, inteligência artificial, bioinformática, entre outras.

O algoritmo deixa uma impressão como um "template" que pode ser aprimorado com diversos métodos e expandir suas capacidades de busca, favorecido por sua arquitetura simples, o que realmente abre um vasto campo para experimentação com esse algoritmo muito interessante.

Figura 1. Graduação de cores dos algoritmos nos testes correspondentes.

Figura 2. Histograma dos resultados dos testes dos algoritmos (na escala de 0 a 100, onde quanto maior, melhor,

sendo 100 o resultado teórico máximo possível. O script para cálculo da tabela de classificação está anexado ao arquivo).

Prós e contras do algoritmo de sistema imune micro-artificial (Micro-AIS):

Prós:

1. Poucos parâmetros externos.
2. Implementação simples do algoritmo.

Contras:

1. Tendência a ficar preso em extremos locais.
   
2. Baixa convergência.
   

Um arquivo com as versões atualizadas dos códigos dos algoritmos descritos em artigos anteriores está anexado. O autor do artigo não se responsabiliza pela precisão absoluta na descrição dos algoritmos canônicos, pois muitas modificações foram feitas para melhorar suas capacidades de busca. As conclusões e julgamentos apresentados nos artigos são baseados nos resultados dos experimentos realizados.