Colmeia artificial de abelhas (ABHA): Testes e resultados
121
0
1. Introdução
No artigo anterior, exploramos detalhadamente o fascinante mundo do algoritmo de colmeia de abelhas ABHA, desvendando seus princípios de funcionamento. Descrevemos não apenas a estrutura e a classe, mas também apresentamos o pseudocódigo do algoritmo e analisamos minuciosamente os métodos "Moving" e "Revision". Esse conhecimento serve como base para o aprofundamento e a compreensão do algoritmo.
Neste artigo, continuaremos com esse tema, aprofundando-nos na escrita de código e cobrindo todos os métodos restantes. Como de costume, testaremos o algoritmo em várias funções de teste para avaliar sua eficiência e desempenho. Por fim, apresentaremos os resultados do trabalho do algoritmo em uma tabela classificatória.
Relembremos os principais pontos do algoritmo ABHA, baseado no modelo de estado e comportamento individual das abelhas:
- Cada abelha é representada como um agente individual, cujo comportamento é regulado por estados (iniciante, experiente, explorador, executor).
- A qualquer momento, o comportamento de uma abelha é determinado pelas informações internas e externas disponíveis para ela, bem como pelo seu estado motivacional, de acordo com um conjunto de regras específicas.
- O conjunto de regras é idêntico para cada abelha, mas, como o ambiente percebido varia para abelhas em diferentes posições espaciais, seu comportamento também difere.
- As abelhas podem exibir diferentes comportamentos dependendo de sua experiência de coleta de alimento e/ou de seu estado motivacional.
Assim, o modelo ABHA representa o comportamento das abelhas como regulado por um conjunto de regras que se adaptam às características individuais e ao ambiente circundante.
2. Continuação da implementação do algoritmo
Agora, passaremos à continuação da escrita dos métodos do algoritmo, conforme o pseudocódigo descrito no artigo anterior. Então, vamos começar.
O método "StageActivityNovice" gerencia como os iniciantes ajustam suas posições com base em buscas aleatórias ou seguindo a "dança" de outros agentes. Descrição do método:
- Parâmetros - o método recebe uma referência ao objeto "agent" do tipo "S_ABHA_Agent", que representa um "iniciante" no algoritmo.
- Valor retornado - o método não retorna nada (void).
Lógica do método:
1. Declara-se a variável "val" para armazenar a coordenada atual do agente.
2. Um laço "for" percorre todas as coordenadas do agente, onde "coords" representa o total de coordenadas (ou dimensões) no espaço de busca.
3. Dentro do laço, o valor da coordenada atual do agente é armazenado na variável "val".
4. Com base na probabilidade, define-se qual ação executar:
- Busca aleatória - se o número aleatório gerado (usando u.RNDprobab()) for menor que o valor de "randomSearchProbability", uma busca aleatória é realizada, e a coordenada "c" é atualizada usando o método "ActionRandomSearch(c)", que gera uma nova posição nessa dimensão.
- Seguir a dança - caso contrário, o agente segue a "dança" de outros agentes. Nesse caso, a coordenada "c" é atualizada com o método "ActionFollowingDance(c, val)", que utiliza o valor "val" para determinar a nova posição com base nas informações de outros agentes.
O método "StageActivityNovice" gerencia o comportamento dos iniciantes no algoritmo ABHA e, no final, realiza as seguintes ações principais:
1. Itera por cada coordenada do agente.
2. Com base em uma probabilidade aleatória, decide se o agente realizará uma busca aleatória ou seguirá a "dança" de outros agentes.
3. Atualiza a posição do agente em cada coordenada de acordo com a ação escolhida.
Esse método permite que os iniciantes se adaptem ao ambiente, utilizando tanto estratégias aleatórias quanto estratégias baseadas na interação com outros agentes.
//—————————————————————————————————————————————————————————————————————————————— //Actions 1 or 2 void C_AO_ABHA::StageActivityNovice (S_ABHA_Agent &agent) { double val; for (int c = 0; c < coords; c++) { val = agent.position [c]; if (u.RNDprobab () < randomSearchProbability) agent.position [c] = ActionRandomSearch (c); else agent.position [c] = ActionFollowingDance (c, val); } } //——————————————————————————————————————————————————————————————————————————————
O método "StageActivityExperienced" da classe "C_AO_ABHA" é responsável pelas ações dos agentes experientes no algoritmo ABHA e regula como os agentes experientes escolhem suas ações com base em probabilidades aleatórias e suas estratégias atuais.
1. Declara-se a variável "rnd", que será usada para armazenar um número aleatório gerado para tomar decisões sobre as ações do agente.
2. Um laço "for" percorre todas as coordenadas do agente, onde "coords" representa o total de coordenadas (ou dimensões) no espaço de busca.
3. Dentro do laço, para cada coordenada, gera-se um número aleatório "rnd" usando o método "RNDprobab()", que retorna um valor entre "0" e "1".
4. Se o número aleatório "rnd" for menor ou igual a "agent.p_srs" (probabilidade de busca aleatória), o agente realiza uma busca aleatória, atualizando sua posição na coordenada "c" com o método "ActionRandomSearch(c)".
Probabilidade de seguir a dança:
- Se "rnd" for maior que "agent.p_srs" e menor ou igual a "agent.p_rul" (probabilidade de seguir a dança), o agente seguirá a "dança" de outros agentes, atualizando sua posição por meio do método ActionFollowingDance (c, agent.position [c])".
Probabilidade de permanecer na fonte:
- Se nenhuma das condições anteriores for atendida, o agente permanece na fonte, atualizando sua posição com o método "ActionHiveVicinity(c, agent.bestPosition[c])", onde "agent.bestPosition[c]" representa a melhor posição conhecida pelo agente.
O método "StageActivityExperienced" gerencia o comportamento dos agentes experientes no algoritmo ABHA e realiza o seguinte:
1. Itera por cada coordenada do agente.
2. Gera um número aleatório para a escolha da ação.
3. Com base no número gerado e nas probabilidades, decide se o agente realizará uma busca aleatória, seguirá a "dança" de outros agentes ou permanecerá na fonte.
Esse método permite que agentes experientes se adaptem ao ambiente utilizando estratégias mais sofisticadas do que as dos iniciantes, aprimorando assim seus resultados na busca por recursos.
//—————————————————————————————————————————————————————————————————————————————— //actions 1 or 2 or 4 void C_AO_ABHA::StageActivityExperienced (S_ABHA_Agent &agent) { double rnd = 0; for (int c = 0; c < coords; c++) { rnd = u.RNDprobab (); // random search probability if (rnd <= agent.p_srs) { agent.position [c] = ActionRandomSearch (c); } else { // Probability of following the dance if (agent.p_srs < rnd && rnd <= agent.p_rul) { agent.position [c] = ActionFollowingDance (c, agent.position [c]); } // Probability of remaining near the source else { agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]); } } } } //——————————————————————————————————————————————————————————————————————————————
O método "StageActivitySearch" da classe "C_AO_ABHA" é responsável pelas ações dos agentes durante a etapa de busca, gerenciando como eles se deslocam no espaço de busca e atualizam suas posições com base na direção escolhida. Este método executa as seguintes ações:
1. Itera por cada coordenada do agente.
2. Para cada coordenada, chama o método "ActionMovingDirection", que determina a nova direção de movimento do agente.
3. Atualiza a posição do agente na coordenada correspondente.
Esse método possibilita que os agentes se movam ativamente no espaço de busca, ajustando suas posições conforme as direções escolhidas.
//—————————————————————————————————————————————————————————————————————————————— //Actions 3 void C_AO_ABHA::StageActivitySearch (S_ABHA_Agent &agent) { for (int c = 0; c < coords; c++) { agent.position [c] = ActionMovingDirection (agent, c); } } //——————————————————————————————————————————————————————————————————————————————
O método "StageActivitySource" da classe "C_AO_ABHA" é destinado às ações relacionadas à identificação de fontes de alimento para os agentes no modelo, atualizando suas posições com base em suas melhores posições no contexto de proximidade com a colmeia. Este método executa os seguintes passos:
1. Inicializa a variável "val".
2. Itera por cada coordenada do agente.
3. Para cada coordenada, atualiza a posição do agente chamando o método "ActionHiveVicinity", que define a nova posição do agente com base em sua melhor posição conhecida.
Esse método ajuda os agentes no estado de "executor" a focar sua atenção em uma análise detalhada das proximidades da fonte de alimento conhecida.
//—————————————————————————————————————————————————————————————————————————————— //Actions 4 void C_AO_ABHA::StageActivitySource (S_ABHA_Agent &agent) { double val = 0; for (int c = 0; c < coords; c++) { agent.position [c] = ActionHiveVicinity (c, agent.bestPosition [c]); } } //——————————————————————————————————————————————————————————————————————————————
O método "ActionRandomSearch" na classe "C_AO_ABHA" é projetado para realizar uma busca aleatória dentro de um intervalo definido de coordenadas, permitindo que o agente selecione aleatoriamente um valor dentro de um intervalo específico. Este método desempenha a função de ampliar a exploração do espaço de busca e realiza as seguintes ações:
1. Recebe o índice da coordenada para a qual é necessário gerar um valor aleatório.
2. Utiliza o método de geração de números aleatórios para obter um valor dentro do intervalo definido pelos valores mínimos e máximos para essa coordenada.
3. Retorna o valor gerado aleatoriamente do tipo "double".
//—————————————————————————————————————————————————————————————————————————————— //1. Random search (random placement in a range of coordinates) double C_AO_ABHA::ActionRandomSearch (int coordInd) { return u.RNDfromCI (rangeMin [coordInd], rangeMax [coordInd]); } //——————————————————————————————————————————————————————————————————————————————
O método "ActionFollowingDance" na classe "C_AO_ABHA" implementa a lógica de seguir o "dançarino", que implica movimentar-se na direção de um agente que já atingiu um certo nível de experiência. Este método utiliza uma abordagem probabilística para selecionar o agente a ser seguido pelo agente atual e insere ruído aleatório na direção calculada.
1. Cálculo da probabilidade total:
- Inicializa-se a variável "totalProbability", que armazenará a soma das probabilidades "p_si" de todos os agentes no estado "experiente".
- Dentro de um laço que percorre todos os agentes, verifica-se o estado de cada um, e, caso o agente seja experiente, sua probabilidade é adicionada a "totalProbability".
2. Geração de um valor aleatório e seleção do agente:
- Gera-se um valor aleatório "randomValue", que é normalizado em relação a "totalProbability".
- No próximo laço, acumula-se as probabilidades "p_si" dos agentes experientes. Assim que a probabilidade acumulada excede "randomValue", o índice do agente selecionado "ind" é armazenado, e o laço é interrompido.
3. Verificação do agente selecionado e cálculo do novo valor:
- Se nenhum agente foi selecionado (o índice "ind" permaneceu igual a "-1"), o método "ActionRandomSearch" é chamado para realizar uma busca aleatória.
- Se um agente foi selecionado, calcula-se a direção do movimento "direction" como a diferença entre a melhor posição do agente selecionado e o valor atual "val".
- Um ruído aleatório "noise" é gerado dentro do intervalo de "-1" a "1".
- O novo valor é retornado, representando o valor atual "val" ajustado pela direção e pelo ruído.
O método "ActionFollowingDance" implementa uma estratégia de seguir um agente experiente (selecionado por uma regra de roleta, onde agentes dançantes mais experientes têm maior chance de serem escolhidos), utilizando uma abordagem probabilística para a seleção do agente e adicionando ruído aleatório à direção do movimento. Isso torna o comportamento dos agentes mais diversificado e adaptativo.
——————————————————————————————————————————————————————————————————————— //2. Follow the dance (move in the direction of the dancer) double C_AO_ABHA::ActionFollowingDance (int coordInd, double val) { //---------------------------------------------------------------------------- double totalProbability = 0; for (int i = 0; i < popSize; i++) { if (agents [i].state == S_ABHA_Agent::stateExperienced) { totalProbability += agents [i].p_si; } } //---------------------------------------------------------------------------- double randomValue = u.RNDprobab () * totalProbability; double cumulativeProbability = 0; int ind = -1; for (int i = 0; i < popSize; i++) { if (agents [i].state == S_ABHA_Agent::stateExperienced) { cumulativeProbability += agents [i].p_si; if (cumulativeProbability >= randomValue) { ind = i; break; } } } //---------------------------------------------------------------------------- if (ind == -1) { return ActionRandomSearch (coordInd); } double direction = agents [ind].bestPosition [coordInd] - val; double noise = u.RNDfromCI (-1.0, 1.0); return val + direction * noise; } //——————————————————————————————————————————————————————————————————————————————
O método "ActionMovingDirection" na classe "C_AO_ABHA" é responsável por mover o agente em uma direção específica com um determinado passo. Vamos analisar o código por partes.
1. Movimento do agente:
- A posição do agente é atualizada na coordenada especificada "coordInd".
- agent.position [coordInd] representa a posição atual do agente na coordenada especificada.
- agent.stepSize é o tamanho do passo que o agente dará nessa direção.
- agent.direction [coordInd] indica a direção do movimento do agente na coordenada especificada.
- Multiplicando stepSize por direction, obtemos a magnitude do deslocamento, que é adicionada à posição atual do agente.
2. Redução do tamanho do passo:
- Após o deslocamento, o tamanho do passo stepSize é reduzido pelo fator de redução stepSizeReductionFactor.
- Isso é necessário para modelar o efeito de movimento decrescente, onde o agente começa a se mover mais lentamente para refinar a solução encontrada.
O método "ActionMovingDirection" implementa uma lógica simples de deslocamento do agente em uma direção especificada, levando em conta o tamanho do passo e sua redução após o movimento.
//—————————————————————————————————————————————————————————————————————————————— //3. Move in a given direction with a step double C_AO_ABHA::ActionMovingDirection (S_ABHA_Agent &agent, int coordInd) { agent.position [coordInd] += agent.stepSize * agent.direction [coordInd]; agent.stepSize *= stepSizeReductionFactor; return agent.position [coordInd]; } //——————————————————————————————————————————————————————————————————————————————
O método "ActionHiveVicinity" na classe "C_AO_ABHA" é projetado para definir o comportamento do agente nas proximidades de uma fonte de alimento. Este método é responsável por gerar uma nova posição em uma coordenada específica, com maior probabilidade de estar próxima à posição atual do que distante dela.
//—————————————————————————————————————————————————————————————————————————————— //4. Move in the vicinity of a food source double C_AO_ABHA::ActionHiveVicinity (int coordInd, double val) { return u.PowerDistribution (val, rangeMin [coordInd], rangeMax [coordInd], 12); } //——————————————————————————————————————————————————————————————————————————————
Agora, analisemos o método "ChangingStateForNovice" na classe "C_AO_ABHA", que é responsável por alterar o estado do agente com base em sua adaptabilidade atual ("cost") e nas informações sobre as fontes de alimento.
1. Nem o custo anterior nem o melhor custo são usados neste método.
2. Verificação do estado:
- Se o custo atual da fonte de alimento agent.cost for maior que o custo médio avgCost, o estado do agente muda para "stateExperienced". Isso indica que o agente obteve informações suficientes sobre fontes de alimento altamente lucrativas e está pronto para agir de forma mais eficiente.
3. Transição para o estado "Explorador":
- Se o custo atual não exceder o custo médio, o agente muda para o estado de explorador "stateSearch". Esse estado sugere que o agente não possui informações sobre fontes de alimento e deve começar uma busca aleatória.
4. Direção de busca aleatória:
- Um laço percorre todas as coordenadas "coords", e para cada coordenada, é atribuída ao agente uma direção aleatória. O método "RNDfromCI" gera um número aleatório dentro do intervalo especificado e é usado para determinar o tamanho do deslocamento e a direção dentro do intervalo definido por "rangeMin" e "rangeMax". Inicialização de parâmetros de busca:
5. Inicialização dos parâmetros de busca:
- Define-se o tamanho do passo "stepSize" para o movimento do agente, bem como o contador de busca "searchCounter", que rastreia o número de iterações realizadas pelo agente na busca por alimento.
O método "ChangingStateForNovice" é responsável por alterar o estado de uma abelha "iniciante" com base no valor de sua fonte de alimento. Se o valor for alto, o agente torna-se experiente. Se o valor for baixo, o agente muda para o estado de explorador, inicia uma busca aleatória e inicializa os parâmetros para essa busca.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForNovice (S_ABHA_Agent &agent) { //Current cost : Used to enter either the Experienced or Search state. //Previous cost: Not used. //Best cost : Not used. //Into Experienced. If a novice receives information about a highly profitable food source (for example, through dances of other bees), it may transition to the experienced state. //Into Search. If a novice does not receive information about food sources, it may begin a random search and enter a search state. if (agent.cost > avgCost) agent.state = S_ABHA_Agent::stateExperienced; else { agent.state = S_ABHA_Agent::stateSearch; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } //——————————————————————————————————————————————————————————————————————————————
O método "ChangingStateForExperienced" na classe "C_AO_ABHA" é projetado para gerenciar o estado de um agente experiente com base no valor atual de sua fonte de alimento e no valor anterior. Vamos analisar esse método em detalhes.
1. Alteração do parâmetro "pab":
- Se o custo atual for menor que o anterior: a abelha reduz a probabilidade de permanecer na fonte de alimento "pab". Caso "pab" seja menor que "0", é ajustado para "0".
- Se o custo atual for maior que o anterior: a abelha aumenta a probabilidade de permanecer na fonte de alimento. Caso "pab" exceda "1", é ajustado para "1".
- Se o custo atual exceder o melhor custo: quando o custo atual supera o melhor valor registrado, a probabilidade de permanecer na fonte é definida no valor máximo "1".
2. Transição para o estado "Executor" ou "Explorador":
- Se o custo atual exceder em 20% a média da população: a abelha muda para o estado "Executor" (stateSource), indicando que encontrou uma boa fonte de alimento. A probabilidade de permanecer na fonte é definida como "1".
- Se o custo atual for inferior à média: a abelha muda para o estado "Explorador" (stateSearch), sinalizando a necessidade de procurar novas fontes de alimento.
3. Direção de busca aleatória:
- Caso haja a transição para o estado "Explorador", a abelha recebe direções aleatórias para buscar novas fontes de alimento.
4. Inicialização dos parâmetros de busca:
- Define-se o tamanho do passo para o movimento do agente, bem como o contador de busca, que monitora o número de passos realizados na busca por alimento.
O método "ChangingStateForExperienced" gerencia o estado da abelha experiente com base no valor atual de sua fonte de alimento e nos valores anteriores. Ele utiliza uma lógica baseada na comparação entre os custos atuais, anteriores e melhores para determinar se a abelha deve continuar explorando a fonte de alimento ou buscar uma nova. O parâmetro "pab" (probabilidade de permanecer na fonte) é ajustado dependendo das mudanças no custo.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForExperienced (S_ABHA_Agent &agent) { //Current cost : If the current value is high and the information is valid, it can pass this information on to other bees through a dance. //Previous cost: A bee compares the current value with the previous one to determine if the situation has improved. If the current value is better, it may increase the probability of passing the information. //Best cost : A bee can use the best value to assess whether to continue exploring a given food source or to look for a new one. //Into Search. If the information about the current food source is not good enough (e.g. the current fitness value is below the threshold), a bee may enter a search state to search for new sources. //Into Food Source. If information about a food source is confirmed (e.g. the current fitness value is high and stable), a bee may switch to a food source state to analyze the source in more depth. if (agent.cost < agent.prevCost) { agent.pab -= abandonmentRate; if (agent.pab < 0.0) agent.pab = 0.0; } if (agent.cost > agent.prevCost) { agent.pab += abandonmentRate; if (agent.pab > 1.0) agent.pab = 1.0; } if (agent.cost > agent.bestCost) agent.pab = 1.0; if (agent.cost > avgCost * 1.2) { agent.state = S_ABHA_Agent::stateSource; agent.pab = 1; } else if (agent.cost < avgCost) { agent.state = S_ABHA_Agent::stateSearch; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } //——————————————————————————————————————————————————————————————————————————————
Agora, vamos detalhar o código do método "ChangingStateForSearch" da classe "C_AO_ABHA", que regula o comportamento do agente abelha durante o processo de busca por uma fonte de alimento. Este método executa as seguintes etapas:
1. Comparação entre o valor atual e o valor anterior:
- Se o valor atual "agent.cost for menor que o valor anterior agent.prevCost, isso indica que a abelha está se afastando de uma boa fonte. Nesse caso:
- A abelha altera sua direção, gerando valores aleatórios para cada direção de coordenada por meio da função u.RNDfromCI.
- Define-se o tamanho inicial do passo initialStepSize, e a abelha se prepara para continuar a exploração.
- O aumento do contador de busca searchCounter permite rastrear o número de tentativas de busca realizadas.
2. Comparação entre o valor atual e o melhor valor:
- Se o valor atual for maior que o melhor valor agent.bestCost, isso significa que a abelha encontrou uma fonte de alimento mais vantajosa. Nesse caso:
- O tamanho do passo é reduzido por um coeficiecoeficientente especificado stepSizeReductionFactor, indicando a necessidade de passos menores para refinar a solução encontrada.
- O contador de busca é redefinido para "0", já que a abelha encontrou uma fonte mais vantajosa.
3. Verificação do número máximo de tentativas de busca:
- Se o contador de busca atingir o número máximo de tentativas maxSearchAttempts, isso indica que a abelha não encontrou nenhuma fonte vantajosa após um número definido de tentativas. Nesse caso:
- O contador de busca é redefinido para "0".
- A abelha muda para o estado "Novato" (stateNovice), indicando que ela deve reiniciar a busca.
4. Verificação de uma boa fonte de alimento:
- Se o valor atual exceder em 20% o custo médio avgCost, isso indica que a abelha encontrou uma boa fonte de alimento. Nesse caso:
- A abelha muda para o estado "Executor" (stateSource), indicando que ela começará a avaliar a lucratividade da fonte.
- A probabilidade de permanecer na fonte pab é definida como "1", tornando a abelha mais inclinada a permanecer nesta fonte.
O método "ChangingStateForSearch" gerencia o comportamento da abelha no estado de busca, tomando decisões com base em comparações entre os valores atuais, anteriores e melhores de adaptabilidade. Ele permite que a abelha se adapte ao ambiente, transite para outros estados, como "Executor" ou "Novato", e ajuste o tamanho do passo com base nas fontes de alimento encontradas.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForSearch (S_ABHA_Agent &agent) { //Current cost : A bee uses its current fitness value to assess its current position and to decide whether to continue searching or change direction //Previous value: A bee compares the current value with the previous one to determine if things have improved. If the current value is better, it can continue in the same direction. //Best value : The bee uses the best value to determine whether the current food source is more profitable than the previous ones. This helps it make decisions about whether to stay put or continue searching. //Into Food Source. If a searching bee finds a food source with good characteristics (e.g., the current fitness value is better than the threshold), it can switch to the food source state to evaluate the profitability of the source. //Into Novice. If a searching bee does not find any food sources or the information is impractical, it may revert to novice. if (agent.cost < agent.prevCost) { for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter++; } if (agent.cost > agent.bestCost) { agent.stepSize *= stepSizeReductionFactor; agent.searchCounter = 0; } if (agent.searchCounter >= maxSearchAttempts) { agent.searchCounter = 0; agent.state = S_ABHA_Agent::stateNovice; return; } if (agent.cost > avgCost * 1.2) { agent.state = S_ABHA_Agent::stateSource; agent.pab = 1; } } //——————————————————————————————————————————————————————————————————————————————
O método "ChangingStateForSource" da classe "C_AO_ABHA" regula o comportamento do agente abelha durante o processo de exploração de uma fonte de alimento. Estrutura geral do método:
1. Transição para o estado "Explorador":
- Se o valor atual agent.cost for inferior ao custo médio avgCost, isso indica que a fonte de alimento atual não é vantajosa.
- A abelha reduz a probabilidade de permanecer na fonte de alimento pab pelo valor de abandonmentRate, tornando-se menos propensa a permanecer na fonte atual.
- Se o valor aleatório gerado por u.RNDprobab exceder agent.pab, a abelha decide mudar para o estado "Explorador" (stateSearch):
- A probabilidade pab é redefinida para "0".
- A abelha altera sua direção, gerando valores aleatórios para cada coordenada com o método u.RNDfromCI.
- Define-se o tamanho inicial do passo initialStepSize, e o contador de busca searchCounter é zerado.
3. Transição para o estado "Experiente":
- Se o valor atual agent.cost exceder o melhor valor agent.bestCost, isso significa que a fonte de alimento atual confirma sua lucratividade.
- Nesse caso, a abelha muda para o estado "Experiente" (stateExperienced) e passa a transmitir informações sobre a boa fonte para outras abelhas.
- A probabilidade de permanecer na fonte pab é ajustada para "1", fazendo com que a abelha permaneça na fonte com a maior probabilidade possível.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::ChangingStateForSource (S_ABHA_Agent &agent) { //Current cost : If the current value is below the threshold, it may decide that the source is not good enough and start looking for a new one. //Previous value: The bee can use the previous value to compare and determine if the situation has improved. If the current value is worse, it may signal the need to change the strategy. //Best value : A bee uses the best value to decide whether to continue exploiting the current food source or to look for a new, more profitable one. //Into Search. If the current food source turns out to be impractical (e.g. the current fitness value is worse than the threshold), a bee may switch to a search state to search for new sources. //Into Experienced. If a food source bee finds a food source that proves beneficial, it may enter the experienced state to pass on the information to other bees. if (agent.cost < avgCost) { agent.pab -= abandonmentRate; if (u.RNDprobab () > agent.pab) { agent.state = S_ABHA_Agent::stateSearch; agent.pab = 0; for (int c = 0; c < coords; c++) { agent.direction [c] = u.RNDfromCI (-(rangeMax [c] - rangeMin [c]), (rangeMax [c] - rangeMin [c])); } agent.stepSize = initialStepSize; agent.searchCounter = 0; } } if (agent.cost > agent.bestCost) { agent.state = S_ABHA_Agent::stateExperienced; agent.pab = 1; } } //—————————————————————————————————————————————————————————————————————————————
O método "CalculateProbabilities" na classe "C_AO_ABHA" calcula as probabilidades de diferentes ações para cada agente (abelha) com base em seus valores atuais. Este método executa as seguintes etapas:
1. Inicialização de variáveis:
- maxCost é inicializado com o menor valor possível, garantindo que qualquer custo do agente seja maior do que esse valor.
- minCost é inicializado com o maior valor possível, permitindo que qualquer custo do agente seja menor do que esse valor.
2. Determinação dos valores máximo e mínimo:
- Um laço percorre todos os agentes (abelhas) da população popSize.
- Dentro do laço, os valores atuais dos agentes são comparados com maxCost e minCost, atualizando-os conforme necessário.
3. Cálculo do intervalo de custos:
- costRange representa a diferença entre o custo máximo e o mínimo, permitindo a normalização das probabilidades.
4. Cálculo das probabilidades para cada agente:
- p_si - probabilidade do agente baseada em seu custo. Quanto maior o custo, maior a probabilidade (normalizada pelo intervalo).
- p_srs - probabilidade de busca aleatória, pré-definida.
- p_rul - probabilidade de seguir a dança. Quanto maior a probabilidade de permanecer na fonte, menor será a probabilidade de seguir a dança.
- p_ab - probabilidade de permanecer na fonte, igual a pab do agente.
Em seguida, calcula-se a soma de todas as três probabilidades, e cada uma delas é normalizada para que a soma total seja igual a "1". Isso é feito dividindo cada probabilidade pela soma total.
O método "CalculateProbabilities" permite que cada abelha avalie suas chances de realizar diferentes ações (busca aleatória, seguir a dança, permanecer na fonte) com base no valor atual.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::CalculateProbabilities () { double maxCost = -DBL_MAX; double minCost = DBL_MAX; for (int i = 0; i < popSize; i++) { if (agents [i].cost > maxCost) maxCost = agents [i].cost; if (agents [i].cost < minCost) minCost = agents [i].cost; } double costRange = maxCost - minCost; for (int i = 0; i < popSize; i++) { agents [i].p_si = (maxCost - agents [i].cost) / costRange; agents [i].p_srs = randomSearchProbability; // random search probability agents [i].p_rul = 1.0 - agents [i].pab; // probability of following the dance agents [i].p_ab = agents [i].pab; // probability of staying near the source double sum = agents [i].p_srs + agents [i].p_rul + agents [i].p_ab; agents [i].p_srs /= sum; agents [i].p_rul /= sum; agents [i].p_ab /= sum; } } //——————————————————————————————————————————————————————————————————————————————
O método "CalculateAverageCost" na classe "C_AO_ABHA" é projetado para calcular o custo médio "average cost" de todos os agentes (abelhas) na população. Essas informações são necessárias para analisar o estado da população e tomar decisões no contexto do algoritmo. O custo médio serve como um indicador de sucesso dos agentes e é usado em cálculos posteriores.
//—————————————————————————————————————————————————————————————————————————————— void C_AO_ABHA::CalculateAverageCost () { double totalCost = 0; for (int i = 0; i < popSize; i++) { totalCost += agents [i].cost; } avgCost = totalCost / popSize; } //———————
3. Resultados dos testes
Execução do algoritmo ABHA:
ABHA|Artificial Bee Hive Algorithm|10.0|10.0|0.1|0.1|0.99|0.5|
=============================
5 Hilly's; Func runs: 10000; result: 0.8413125195861497
25 Hilly's; Func runs: 10000; result: 0.5422730855489947
500 Hilly's; Func runs: 10000; result: 0.2630407626746883
=============================
5 Forest's; Func runs: 10000; result: 0.8785786358650522
25 Forest's; Func runs: 10000; result: 0.47779307049664316
500 Forest's; Func runs: 10000; result: 0.17181208858518054
=============================
5 Megacity's; Func runs: 10000; result: 0.5092307692307693
25 Megacity's; Func runs: 10000; result: 0.3387692307692307
500 Megacity's; Func runs: 10000; result: 0.1039692307692317
=============================
All score: 4.12678 (45.85%)
Concluímos a escrita do código e realizamos uma análise detalhada de todos os componentes do algoritmo ABHA. Agora passamos diretamente aos testes do algoritmo em funções de teste e avaliamos sua eficiência. Na visualização dos resultados do algoritmo, é possível observar uma dispersão considerável nos resultados obtidos durante os testes.
ABHA na função de teste Hilly.
ABHA na função de teste Forest.
na função de teste Megacity.
Com base nas pesquisas realizadas, o algoritmo ocupa uma posição sólida no meio da tabela de classificaçã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 | ANS | across neighbourhood search | 0,94948 | 0,84776 | 0,43857 | 2,23581 | 1,00000 | 0,92334 | 0,39988 | 2,32323 | 0,70923 | 0,63477 | 0,23091 | 1,57491 | 6,134 | 68,15 |
| 2 | CLA | code lock algorithm | 0,95345 | 0,87107 | 0,37590 | 2,20042 | 0,98942 | 0,91709 | 0,31642 | 2,22294 | 0,79692 | 0,69385 | 0,19303 | 1,68380 | 6,107 | 67,86 |
| 3 | (P+O)ES | (P+O) evolution strategies | 0,92256 | 0,88101 | 0,40021 | 2,20379 | 0,97750 | 0,87490 | 0,31945 | 2,17185 | 0,67385 | 0,62985 | 0,18634 | 1,49003 | 5,866 | 65,17 |
| 4 | CTA | comet tail algorithm | 0,95346 | 0,86319 | 0,27770 | 2,09435 | 0,99794 | 0,85740 | 0,33949 | 2,19484 | 0,88769 | 0,56431 | 0,10512 | 1,55712 | 5,846 | 64,96 |
| 5 | 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 |
| 6 | ESG | evolution of social groups | 0,99906 | 0,79654 | 0,35056 | 2,14616 | 1,00000 | 0,82863 | 0,13102 | 1,95965 | 0,82333 | 0,55300 | 0,04725 | 1,42358 | 5,529 | 61,44 |
| 7 | 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 |
| 8 | ACS | artificial cooperative search | 0,75547 | 0,74744 | 0,30407 | 1,80698 | 1,00000 | 0,88861 | 0,22413 | 2,11274 | 0,69077 | 0,48185 | 0,13322 | 1,30583 | 5,226 | 58,06 |
| 9 | TSEA | turtle shell evolution algorithm | 0,96798 | 0,64480 | 0,29672 | 1,90949 | 0,99449 | 0,61981 | 0,22708 | 1,84139 | 0,69077 | 0,42646 | 0,13598 | 1,25322 | 5,004 | 55,60 |
| 10 | 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 |
| 11 | CRO | chemical reaction optimisation | 0,94629 | 0,66112 | 0,29853 | 1,90593 | 0,87906 | 0,58422 | 0,21146 | 1,67473 | 0,75846 | 0,42646 | 0,12686 | 1,31178 | 4,892 | 54,36 |
| 12 | BSA | bird swarm algorithm | 0,89306 | 0,64900 | 0,26250 | 1,80455 | 0,92420 | 0,71121 | 0,24939 | 1,88479 | 0,69385 | 0,32615 | 0,10012 | 1,12012 | 4,809 | 53,44 |
| 13 | 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 |
| 14 | 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 |
| 15 | (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 |
| 16 | BSO | brain storm optimization | 0,93736 | 0,57616 | 0,29688 | 1,81041 | 0,93131 | 0,55866 | 0,23537 | 1,72534 | 0,55231 | 0,29077 | 0,11914 | 0,96222 | 4,498 | 49,98 |
| 17 | WOAm | wale optimization algorithm M | 0,84521 | 0,56298 | 0,26263 | 1,67081 | 0,93100 | 0,52278 | 0,16365 | 1,61743 | 0,66308 | 0,41138 | 0,11357 | 1,18803 | 4,476 | 49,74 |
| 18 | AEFA | artificial electric field algorithm | 0,87700 | 0,61753 | 0,25235 | 1,74688 | 0,92729 | 0,72698 | 0,18064 | 1,83490 | 0,66615 | 0,11631 | 0,09508 | 0,87754 | 4,459 | 49,55 |
| 19 | 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 |
| 20 | BFO-GA | bacterial foraging optimization - ga | 0,89150 | 0,55111 | 0,31529 | 1,75790 | 0,96982 | 0,39612 | 0,06305 | 1,42899 | 0,72667 | 0,27500 | 0,03525 | 1,03692 | 4,224 | 46,93 |
| 21 | ABHA | artificial bee hive algorithm | 0,84131 | 0,54227 | 0,26304 | 1,64663 | 0,87858 | 0,47779 | 0,17181 | 1,52818 | 0,50923 | 0,33877 | 0,10397 | 0,95197 | 4,127 | 45,85 |
| 22 | ASBO | adaptive social behavior optimization | 0,76331 | 0,49253 | 0,32619 | 1,58202 | 0,79546 | 0,40035 | 0,26097 | 1,45677 | 0,26462 | 0,17169 | 0,18200 | 0,61831 | 3,657 | 40,63 |
| 23 | 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 |
| 24 | 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 |
| 25 | 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 |
| 26 | 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 |
| 27 | 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 |
| 28 | 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 |
| 29 | 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 |
| 30 | 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 |
| 31 | BFO | bacterial foraging optimization | 0,61171 | 0,43270 | 0,31318 | 1,35759 | 0,54410 | 0,21511 | 0,05676 | 0,81597 | 0,42167 | 0,13800 | 0,03195 | 0,59162 | 2,765 | 30,72 |
| 32 | 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 |
| 33 | 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 |
| 34 | 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 |
| 35 | 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 |
| 36 | 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 |
| 37 | Boids | boids algorithm | 0,43340 | 0,30581 | 0,25425 | 0,99346 | 0,35718 | 0,20160 | 0,15708 | 0,71586 | 0,27846 | 0,14277 | 0,09834 | 0,51957 | 2,229 | 24,77 |
| 38 | 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 |
| 39 | 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 |
| 40 | 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 |
| 41 | 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 |
| 42 | 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 |
| 43 | 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 |
| 44 | 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 algoritmo ABHA foi submetido a testes rigorosos em diversas funções de teste, e os resultados mostraram sua competitividade em comparação com outros algoritmos baseados nos conceitos de inteligência de enxame (swarm intelligence). Durante esses testes, o ABHA demonstrou eficiência e confiabilidade.
A pesquisa destaca o potencial do algoritmo ABHA na solução não apenas de problemas tradicionais de otimização, mas também de problemas mais complexos, como otimização multicritério e problemas restritos. Minhas impressões pessoais sobre o trabalho realizado e a lógica complexa do algoritmo são as seguintes: eu esperava resultados mais impressionantes. No entanto, vale ressaltar que os resultados do ABHA são realmente únicos entre os algoritmos de enxame.
Em suma, o algoritmo pode ser avaliado como um conjunto de métodos e técnicas específicos que são aplicáveis à grande maioria dos outros algoritmos de otimização. A capacidade de reproduzir resultados e a adaptabilidade a diferentes condições tornam este algoritmo uma ferramenta promissora na área de otimização computacional. Assim, o ABHA não apenas amplia os horizontes de aplicação de algoritmos de otimização, mas também abre novas possibilidades para pesquisas em inteligência artificial e suas aplicações práticas.
Figura 1. Graduação de cores dos algoritmos para os respectivos testes. Os resultados maiores ou iguais a 0.99 estão destacados em branco.
Figura 2. Histograma dos resultados dos testes dos algoritmos (em uma escala de 0 a 100, quanto maior, melhor,
onde 100 é o resultado teórico máximo possível; o arquivo inclui um script para calcular a tabela de classificações).
Vantagens e desvantagens do algoritmo artificial de colmeia de abelhas (ABHA):
Prós:
- Bons resultados em problemas de pequena dimensão.
- Bons resultados em funções discretas.
Contras:
- Lógica e implementação complexas do algoritmo.
- Convergência baixa em problemas de grande dimensão em funções suaves.
- Grande número de parâmetros externos.
Um arquivo está anexado ao artigo com as versões atualizadas dos códigos dos algoritmos. O autor do artigo não se responsabiliza pela precisão absoluta na descrição dos algoritmos canônicos, pois muitos deles foram modificados para melhorar as capacidades de busca. As conclusões e juízos apresentados nos artigos são baseados nos resultados dos experimentos realizados.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/15486
Redes neurais em trading: Injeção de informação global em canais independentes (InjectTST)
Do básico ao intermediário: Template e Typename (IV)
Analisando exemplos de estratégias de trading no terminal do cliente
Simulação de mercado (Parte 05): Iniciando a classe C_Orders (II)
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso