Algoritmi di ottimizzazione della popolazione: Ottimizzazione Grey Wolf (GWO)

MetaTrader 5 — Esempi | 21 agosto 2023, 08:09

354

Andrey Dik

Contenuto

1. Introduzione
2. Descrizione dell'algoritmo
3. Funzioni di test
4. Risultati del test

1. Introduzione

L'algoritmo grey wolf è un algoritmo metaeuristico di intelligenza stocastica a sciame sviluppato nel 2014. L'idea si basa sul modello di caccia del branco di lupi grigi. Esistono quattro tipi di lupi: alfa, beta, delta e omega. L'alfa ha il maggior "peso" nel processo decisionale e nella gestione del branco. Seguono i beta e i delta, che obbediscono all'alfa e hanno potere sul resto dei lupi. Il lupo omega obbedisce sempre al resto dei lupi dominanti.

Nel modello matematico della gerarchia dei lupi, il lupo alfa è considerato il lupo dominante del branco e i suoi ordini devono essere eseguiti dai membri del branco. I lupi beta-β-subordinati assistono l'alfa nel processo decisionale e sono considerati i migliori candidati al ruolo di alfa. I lupi delta δ dovrebbero obbedire ad alfa e beta, ma dominano gli omega. I lupi Omega ω sono considerati i capri espiatori del branco e gli individui meno importanti. Possono mangiare solo alla fine. Alpha è considerata la soluzione più favorevole.

La seconda e la terza soluzione migliore sono rispettivamente beta e delta. Le altre soluzioni sono considerate omega. Si presume che i lupi più adatti (alfa, beta e delta), cioè quelli più vicini alla preda, saranno avvicinati dal resto dei lupi. Dopo ogni approccio, si determina chi è l'alfa, il beta e il delta in questa fase e poi i lupi vengono riorganizzati di nuovo. La formazione avviene fino a quando i lupi si riuniscono in un branco, che sarà la direzione ottimale per un attacco con una distanza minima.

Durante l'algoritmo vengono eseguite 3 fasi principali, in cui i lupi cercano la preda, la circondano e la attaccano. La ricerca rivela gli alfa, i beta e i delta - ovvero i lupi più vicini alla preda. Gli altri, obbedendo a quelli dominanti, possono iniziare a circondare la preda o continuare a muoversi a caso alla ricerca dell'opzione migliore.

2. Descrizione dell'algoritmo

La gerarchia nel branco è schematizzata nella Figura 1. L'alfa ha un ruolo dominante.

dominanza

Fig. 1. La gerarchia sociale in un branco di lupi

Modello matematico e algoritmo
Gerarchia sociale:

La soluzione migliore è rappresentata da un lupo alfa (α).
La seconda migliore soluzione da un lupo beta (β).
La terza soluzione migliore è un lupo delta(δ).
Altre possibili soluzioni da lupi omega (ω).

Circondare la preda: quando esistono già le migliori soluzioni alfa, beta e delta, le azioni successive dipendono dall'omega.

stadi

Figura 2. Fasi di caccia: ricerca, accerchiamento, attacco.

Tutte le iterazioni dell'algoritmo sono rappresentate da tre fasi: ricerca, accerchiamento e caccia. La versione canonica dell'algoritmo presenta il rapporto calcolato а introdotto per migliorare la convergenza dell'algoritmo. Il rapporto decresce fino a zero a ogni iterazione. Finché il rapporto è superiore a 1, l'inizializzazione dei lupi è in corso. In questa fase, la posizione della preda è completamente sconosciuta, quindi i lupi devono essere distribuiti in modo casuale.

Dopo la fase di "ricerca", viene determinato il valore della funzione di fitness, e solo dopo è possibile procedere alla fase di "accerchiamento". In questa fase, il rapporto a è superiore a 1. Ciò significa che alfa, beta e delta si allontanano dalle loro posizioni precedenti, consentendo così di affinare la posizione stimata della preda. Quando il rapporto а diventa uguale a 1, inizia la fase di "attacco", mentre il rapporto tende a 0 prima della fine delle iterazioni. Questo fa sì che i lupi si avvicinino alla preda, suggerendo che la posizione migliore è già stata trovata. Tuttavia, se in questa fase, uno dei lupi trova una soluzione migliore, la posizione della preda e la gerarchia dei lupi saranno aggiornate, ma il rapporto tenderà ancora a 0. Il processo di variazione di a è rappresentato da una funzione non lineare. Le fasi sono illustrate in modo schematico nella Figura 2.

Il comportamento dei lupi omega è invariato in tutti i periodi e consiste nel seguire il centro geometrico tra le posizioni degli individui attualmente dominanti. Nella Figura 3, alfa, beta e delta deviano dalla loro posizione precedente in una direzione casuale con un raggio dato dai coefficienti, e gli omega si spostano verso il centro tra di loro ma con un certo grado di probabilità deviando da esso entro il raggio. I raggi determinano il rapporto а che, come ricordiamo, cambia facendo diminuire proporzionalmente i raggi.

circostante

Fig. 3. Diagramma del movimento omega in relazione ad alfa, beta e delta

Lo pseudocodice dell'algoritmo GWO è il seguente:

1) Inizializzare casualmente la popolazione di lupi grigi.
2) Calcolare la fitness di ciascun membro della popolazione.
3) Capi branco:
-α = membro con il miglior valore di fitness
-β = secondo miglior membro (in termini di fitness)
-δ = terzo miglior membro (in termini di valore di fitness)
Aggiornare la posizione di tutti i lupi omega secondo le equazioni dipendenti da α, β, δ
4) Calcolare la fitness di ciascun membro della popolazione.
5) ripetere il passaggio 3.

Passiamo al codice dell'algoritmo. L'unica aggiunta che ho fatto alla versione originale è la possibilità di impostare il numero di lupi leader del branco. Ora è possibile impostare un numero qualsiasi di leader, fino all'intero branco. Può essere utile per compiti specifici.

Cominciamo, come al solito, con l'unità elementare dell'algoritmo - il lupo, che è una soluzione al problema. Si tratta di una struttura che include un array di coordinate e un valore per la preda (funzioni di fitness). La struttura è la stessa per i capi e i membri minori del branco. Questo semplifica l'algoritmo e ci permette di utilizzare le stesse strutture nelle operazioni di loop. Inoltre, durante tutte le iterazioni, i ruoli dei lupi cambiano più volte. I ruoli sono determinati in modo univoco dalla posizione nell'array dopo l'ordinamento. I leader si trovano all'inizio dell’array.

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

Il branco di lupi è rappresentato da una classe compatta e comprensibile. Qui si dichiarano gli intervalli e i passi dei parametri da ottimizzare, la migliore posizione di produzione, il miglior valore di soluzione e le funzioni ausiliarie.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_GWO //wolfpack
{
  //============================================================================
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: S_Wolf wolves    []; //wolves of the pack
  public: double cB        []; //best prey coordinates
  public: double pB;           //best prey

  public: void InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP);   //epochs number

  public: void TasksForWolves      (int epochNow);
  public: void RevisionAlphaStatus ();


  //============================================================================
  private: void   ReturnToRange (S_Wolf &wolf);
  private: void   SortingWolves ();
  private: double SeInDiSp      (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI     (double Min, double Max);

  private: int    coordinates;     //coordinates number
  private: int    wolvesNumber;    //the number of all wolves
  private: int    alphaNumber;     //Alpha beta delta number of all wolves
  private: int    epochCount;

  private: S_Wolf wolvesT    [];   //temporary, for sorting
  private: int    ind        [];   //array for indexes when sorting
  private: double val        [];   //array for sorting

  private: bool   searching;       //searching flag
};
//——————————————————————————————————————————————————————————————————————————————

Tradizionalmente, la dichiarazione della classe è seguita dall'inizializzazione. In questo caso, ripristiniamo il valore minimo 'double' della fitness dei lupi e distribuiamo le dimensioni degli array.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::InitPack (const int    coordinatesP,   //number of opt. parameters
                         const int    wolvesNumberP,  //wolves number
                         const int    alphaNumberP,   //alpha beta delta number
                         const int    epochCountP)    //epochs number
{
  MathSrand (GetTickCount ());
  searching = false;
  pB        = -DBL_MAX;

  coordinates  = coordinatesP;
  wolvesNumber = wolvesNumberP;
  alphaNumber  = alphaNumberP;
  epochCount   = epochCountP;

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

  ArrayResize (ind, wolvesNumber);
  ArrayResize (val, wolvesNumber);

  ArrayResize (wolves,  wolvesNumber);
  ArrayResize (wolvesT, wolvesNumber);

  for (int i = 0; i < wolvesNumber; i++)
  {
    ArrayResize (wolves  [i].c, coordinates);
    ArrayResize (wolvesT [i].c, coordinates);
    wolves  [i].p = -DBL_MAX;
    wolvesT [i].p = -DBL_MAX;
  }
}
//——————————————————————————————————————————————————————————————————————————————

Il primo metodo pubblico chiamato a ogni iterazione è il più difficile da comprendere e il più voluminoso. Ecco la logica principale dell'algoritmo. In effetti, le prestazioni dell'algoritmo sono fornite da un meccanismo probabilistico strettamente descritto da equazioni. Consideriamo questo metodo passo per passo. Alla prima iterazione, quando la posizione della preda prevista è sconosciuta, dopo aver controllato il flag, inviamo i lupi in una direzione casuale semplicemente generando i valori massimi e minimi dei parametri ottimizzati.

//----------------------------------------------------------------------------
//space has not been explored yet, then send the wolf in a random direction
if (!searching)
{
  for (int w = 0; w < wolvesNumber; w++)
  {
    for (int c = 0; c < coordinates; c++)
    {
      wolves [w].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      wolves [w].c [c] = SeInDiSp  (wolves [w].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
   
  searching = true;
  return;
}

Nella versione canonica della descrizione dell'algoritmo, ci sono equazioni che operano sui vettori. Tuttavia, sono molto più chiari sotto forma di codice. Il calcolo dei lupi omega viene eseguito prima del calcolo dei lupi alfa, beta e delta, perché è necessario utilizzare i valori del leader precedente.

Il componente principale che prevede tre fasi di caccia (ricerca, accerchiamento e attacco) è il rapporto a. Rappresenta una dipendenza non lineare dall'iterazione corrente e dal numero totale di iterazioni, e tende a 0.
Le componenti successive dell'equazione sono Ai e Сi:

Ai = 2,0 * a * r1 - a;
Ci = 2,0 * r2;

dove r1 e r2 sono numeri casuali nell'intervallo [0,0;1,0].
Nell'espressione

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

le coordinate dei lupi vengono regolate in base ai valori medi dei lupi leader. Poiché nell'algoritmo si può specificare un numero qualsiasi di leader, la somma delle coordinate viene eseguita in un ciclo. Successivamente, la cifra risultante viene divisa per il numero di leader. Eseguiamo questa operazione separatamente per ogni coordinata, generando ogni volta nuovi valori di r1 e r2. Come si può notare, la nuova posizione dei lupi omega viene regolata in base alle posizioni dei leader, tenendo conto della loro posizione attuale.

//----------------------------------------------------------------------------
double a  = sqrt (2.0 * (1.0 - (epochNow / epochCount)));
double r1 = 0.0;
double r2 = 0.0;

double Ai = 0.0;
double Ci = 0.0;
double Xn = 0.0;

double min = 0.0;
double max = 1.0;

//omega-----------------------------------------------------------------------
for (int w = alphaNumber; w < wolvesNumber; w++)
{
  Xn = 0.0;

  for (int c = 0; c < coordinates; c++)
  {
    for (int abd = 0; abd < alphaNumber; abd++)
    {
      r1 = RNDfromCI (min, max);
      r2 = RNDfromCI (min, max);
      Ai = 2.0 * a * r1 - a;
      Ci = 2.0 * r2;
      Xn += wolves [abd].c [c] - Ai * (Ci * wolves [abd].c [c] - wolves [w].c [c]);
    }

    wolves [w].c [c] = Xn /= (double)alphaNumber;
  }

  ReturnToRange (wolves [w]);
}

Ecco il calcolo dei leader. Per loro vengono calcolati i rapporti a, Ai e Ci per ciascuna coordinata. L'unica differenza è che la posizione dei leader cambia in relazione alle coordinate della preda migliore in quel momento e alle proprie posizioni. I leader girano intorno alla preda, entrando e uscendo, e controllano i lupi minori nell'attacco.

//alpha, beta, delta----------------------------------------------------------
for (int w = 0; w < alphaNumber; w++)
{
  for (int c = 0; c < coordinates; c++)
  {
    r1 = RNDfromCI (min, max);
    r2 = RNDfromCI (min, max);

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

    wolves [w].c [c] = cB [c] - Ai * (Ci * cB [c] - wolves [w].c [c]);
  }

  ReturnToRange (wolves [w]);
}

Questo è il secondo metodo pubblico richiamato a ogni iterazione. Lo stato dei leader del branco è aggiornato qui. Infatti, i lupi sono ordinati per valore di fitness. Se vengono trovate coordinate di prede migliori di quelle memorizzate nello sciame, aggiorniamo i valori.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_GWO::RevisionAlphaStatus ()
{
  SortingWolves ();

  if (wolves [0].p > pB)
  {
    pB = wolves [0].p;
    ArrayCopy (cB, wolves [0].c, 0, 0, WHOLE_ARRAY);
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. Funzioni di test

Conoscete già le funzioni Skin, Forest e Megacity. Queste funzioni di prova soddisfano tutti i criteri di complessità per la verifica degli algoritmi di ottimizzazione. Tuttavia, c'è una caratteristica che non è stata presa in considerazione. Dovrebbe essere implementata per aumentare l'obiettività del test. I requisiti sono i seguenti:

L'estremo globale non dovrebbe trovarsi ai confini dell'intervallo. Se l'algoritmo non dispone di un controllo out-of-range , è possibile che si verifichino situazioni in cui l'algoritmo mostri risultati eccellenti. Ciò è dovuto al fatto che i valori si troveranno sui bordi a causa di un difetto interno.
L'estremo globale non deve trovarsi al centro dell'intervallo delle coordinate. In questo caso, si tiene conto dell'algoritmo che genera valori mediati in un intervallo.
Il minimo globale deve essere situato al centro delle coordinate. Questo è necessario per escludere deliberatamente le situazioni descritte in p. 2.
Il calcolo dei risultati della funzione di test deve tenere conto del caso in cui i numeri generati a caso sull'intero dominio della funzione (quando la funzione è multivariabile) daranno un risultato medio di circa il 50% del massimo, anche se in realtà questi risultati sono stati ottenuti per caso.

Tenendo conto di questi requisiti, i confini delle funzioni di test sono stati rivisti e i centri dell'intervallo sono stati spostati verso i minimi dei valori delle funzioni. Permettetemi di riassumere ancora una volta. Questo è stato necessario per ottenere la massima plausibilità e oggettività dei risultati dei test degli algoritmi di ottimizzazione. Pertanto, sulle nuove funzioni test, l'algoritmo di ottimizzazione basato sulla generazione di numeri casuali ha mostrato un risultato complessivo naturalmente basso. La tabella di valutazione aggiornata si trova alla fine dell'articolo.

Funzione Skin. Una funzione regolare che presenta diversi estremi locali che possono confondere l'algoritmo di ottimizzazione che può bloccarsi in uno di essi. L'unico estremo globale è caratterizzato da valori che cambiano debolmente nelle vicinanze. Questa funzione mostra chiaramente la capacità dell'algoritmo di essere suddiviso in aree di studio, piuttosto che concentrarsi su una sola. In particolare, l'algoritmo della colonia di api (ABC) si comporta in questo modo.

Skin

Fig. 4. Test funzione Skin

Funzione Forest. Una funzione con diversi estremi regolari e diversi estremi non differenziabili. Si tratta di un valido test per gli algoritmi di ottimizzazione per la capacità di trovare un "ago in un pagliaio". Trovare un singolo punto di massimo globale è un compito molto difficile, soprattutto se la funzione contiene molte variabili. L'algoritmo della colonia di formiche (ACO) si è distinto in questo compito per il suo comportamento caratteristico, che traccia i percorsi verso l'obiettivo in modo incredibile.

Forest

Figura 5 Test funzione Forest

Funzione Megacity. La funzione è un problema di ottimizzazione discreta con un estremo globale e diversi estremi locali. La superficie estremamente complessa da studiare fornisce un buon test per gli algoritmi che richiedono un gradiente. Un'ulteriore complessità è data da un "piano" completamente uniforme, che è anche un minimo, che non fornisce alcuna informazione sulla possibile direzione verso il massimo globale.

Megacity

Figura 6 Test funzione Megacity

Nel codice delle funzioni di test sono stati aggiunti controlli sugli argomenti in entrata per verificare la presenza di valori out-of-range. Nelle versioni precedenti delle funzioni, gli algoritmi di ottimizzazione potevano ottenere ingiustamente valori della funzione più grandi di quelli che la funzione ha effettivamente nell'intervallo della sua definizione.

4. Risultati del test

A causa delle modifiche apportate alle funzioni di test, anche il banco di prova è stato aggiornato. Sul lato destro della schermata del banco, è ancora possibile vedere i grafici di convergenza degli algoritmi di ottimizzazione. La linea verde indica i risultati della convergenza su funzioni a due variabili. La linea blu rappresenta le funzioni con 40 variabili. Quella rossa indica funzioni con 1000 variabili. Il cerchio nero più grande indica la posizione del massimo globale della funzione. Il cerchio nero più piccolo indica la posizione dell'attuale valore della soluzione dell'algoritmo di ottimizzazione. Il crocino di linee bianche indica il centro geometrico delle funzioni di test e corrisponde al minimo globale. Questo è stato introdotto per una migliore percezione visiva del comportamento degli algoritmi testati. I punti bianchi indicano le soluzioni intermedie mediate. I puntini colorati indicano le coppie di coordinate della dimensione corrispondente. Il colore indica la posizione ordinale della dimensione della funzione di test.

I risultati aggiornati dei test degli algoritmi di ottimizzazione discussi negli articoli precedenti sul nuovo banco sono visibili nella tabella aggiornata. Per una maggiore chiarezza visiva, la linea relativa alla velocità di convergenza è stata rimossa dalla tabella - può essere determinata visivamente sull'animazione del banco. Aggiunta la colonna con la descrizione dell'algoritmo.

Risultati del test ACOm (Ant Colony Optimization):

2022.11.28 12:17:00.468 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:17:06.382 Test_AO_ACO (EURUSD,M1) 1 Skin's; Func cicli 10000 risultato: 4.844203223078298
2022.11.28 12:17:06.382 Test_AO_ACO (EURUSD,M1) Punteggio: 0.98229
2022.11.28 12:17:14.191 Test_AO_ACO (EURUSD,M1) 20 Skin; Func cicli 10000 risultati: 4.043383610736287
2022.11.28 12:17:14.191 Test_AO_ACO (EURUSD,M1) Punteggio: 0.79108
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) 500 Skin; Func cicli 10000 risultato: 1.2580170651681026
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) Punteggio: 0.12602
2022.11.28 12:17:55.578 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:18:01.491 Test_AO_ACO (EURUSD,M1) 1 Forest; Func cicli 10000 risultato: 1.7678766100234538
2022.11.28 12:18:01.491 Test_AO_ACO (EURUSD,M1) Punteggio: 1.00000
2022.11.28 12:18:09.508 Test_AO_ACO (EURUSD,M1) 20 Forest; Func cicli 10000 risultato: 1.0974381500585855
2022.11.28 12:18:09.508 Test_AO_ACO (EURUSD,M1) Punteggio: 0.62077
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) 500 Foresta; Func cicli 10000 risultato: 0.20367726028454042
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) Punteggio: 0.11521
2022.11.28 12:18:53.348 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:18:59.303 Test_AO_ACO (EURUSD,M1) 1 Megacity; Func cicli 10000 risultato: 4.6
2022.11.28 12:18:59.303 Test_AO_ACO (EURUSD,M1) Punteggio: 0.38333
2022.11.28 12:19:07.598 Test_AO_ACO (EURUSD,M1) 20 Megacity; Func cicli 10000 risultato: 5.28
2022.11.28 12:19:07.598 Test_AO_ACO (EURUSD,M1) Punteggio: 0.44000
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.2852
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) Punteggio: 0.02377
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) =============================
2022.11.28 12:19:53.172 Test_AO_ACO (EURUSD,M1) Tutti i punteggi per C_AO_ACOm: 0.4980520084646583

Risultato dei test (Colonia di api artificiali):

2022.11.28 12:35:47.181 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:35:52.581 Test_AO_ABCm (EURUSD,M1) 1 Skin; Func cicli 10000 risultato: 4.918379986612587
2022.11.28 12:35:52.581 Test_AO_ABCm (EURUSD,M1) Punteggio: 1.00000
2022.11.28 12:35:59.454 Test_AO_ABCm (EURUSD,M1) 20 Skin; Func cicli 10000 risultato: 3.4073825805846374
2022.11.28 12:35:59.454 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.63922
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) 500 Skin; Func cicli 10000 risultato: 1.0684464927353337
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.08076
2022.11.28 12:36:32.428 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:36:38.086 Test_AO_ABCm (EURUSD,M1) 1 Forest; Func cicli 10000 risultato: 1.766245456669898
2022.11.28 12:36:38.086 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.99908
2022.11.28 12:36:45.326 Test_AO_ABCm (EURUSD,M1) 20 Forest; Func cicli 10000 risultato: 0.35556125136004335
2022.11.28 12:36:45.326 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.20112
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) 500 Forest; Func cicli 10000 risultato: 0.06691711149962026
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.03785
2022.11.28 12:37:22.301 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:37:28.047 Test_AO_ABCm (EURUSD,M1) 1 Megacity; Func cicli 10000 risultato: 12.0
2022.11.28 12:37:28.047 Test_AO_ABCm (EURUSD,M1) Punteggio: 1.00000
2022.11.28 12:37:35.689 Test_AO_ABCm (EURUSD,M1) 20 Megacity; Func cicli 10000 risultato: 1.9600000000000002
2022.11.28 12:37:35.689 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.16333
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.33880000000000005
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) Punteggio: 0.02823
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) =============================
2022.11.28 12:38:11.609 Test_AO_ABCm (EURUSD,M1) Tutti i punteggi per C_AO_ABCm: 0.4610669021761763

Risultati del test ABC (Colonia Artificiale di Api):

2022.11.28 12:29:51.177 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:29:56.785 Test_AO_ABC (EURUSD,M1) 1 Skin; Func cicli 10000 risultato: 4.890679983950205
2022.11.28 12:29:56.785 Test_AO_ABC (EURUSD,M1) Punteggio: 0.99339
2022.11.28 12:30:03.880 Test_AO_ABC (EURUSD,M1) 20 Skin; Func cicli 10000 risultato: 3.8035430744604133
2022.11.28 12:30:03.880 Test_AO_ABC (EURUSD,M1) Punteggio: 0.73381
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) 500 Skin; Func cicli 10000 risultato: 1.195840100227333
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) Punteggio: 0.11118
2022.11.28 12:30:37.089 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:30:42.811 Test_AO_ABC (EURUSD,M1) 1 Forest; Func cicli 10000 risultato: 1.7667070507449298
2022.11.28 12:30:42.811 Test_AO_ABC (EURUSD,M1) Punteggio: 0.99934
2022.11.28 12:30:50.108 Test_AO_ABC (EURUSD,M1) 20 Forest; Func cicli 10000 risultato: 0.3789854806095275
2022.11.28 12:30:50.108 Test_AO_ABC (EURUSD,M1) Punteggio: 0.21437
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) 500 Forest; Func cicli 10000 risultato: 0.07451308481273813
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) Punteggio: 0.04215
2022.11.28 12:31:25.900 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:31:31.510 Test_AO_ABC (EURUSD,M1) 1 Megacity; Func cicli 10000 risultato: 10,2
2022.11.28 12:31:31.510 Test_AO_ABC (EURUSD,M1) Punteggio: 0.85000
2022.11.28 12:31:38.855 Test_AO_ABC (EURUSD,M1) 20 Megacity; Func cicli 10000 risultato: 2.02
2022.11.28 12:31:38.855 Test_AO_ABC (EURUSD,M1) Punteggio: 0.16833
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.37559999999999993
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) Punteggio: 0.03130
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) =============================
2022.11.28 12:32:14.623 Test_AO_ABC (EURUSD,M1) Tutti i punteggi per C_AO_ABC: 0.46043003186219245

Risultati del test PSO (Particle Swarm Optimization)

2022.11.28 12:01:03.967 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:01:09.723 Test_AO_PSO (EURUSD,M1) 1 Skin; Func cicli 10000 risultato: 4.90276049713715
2022.11.28 12:01:09.723 Test_AO_PSO (EURUSD,M1) Punteggio: 0.99627
2022.11.28 12:01:17.064 Test_AO_PSO (EURUSD,M1) 20 Skin; Func cicli 10000 risultato: 2.3250668562024566
2022.11.28 12:01:17.064 Test_AO_PSO (EURUSD,M1) Punteggio: 0.38080
2022.11.28 12:01:52.880 Test_AO_PSO (EURUSD,M1) 500 Skin; Func cicli 10000 risultato: 0.943331687769892
2022.11.28 12:01:52.881 Test_AO_PSO (EURUSD,M1) Punteggio: 0.05089
2022.11.28 12:01:52.881 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:01:58.492 Test_AO_PSO (EURUSD,M1) 1 Forest; Func cicli 10000 risultato: 1.6577769478566602
2022.11.28 12:01:58.492 Test_AO_PSO (EURUSD,M1) Punteggio: 0.93772
2022.11.28 12:02:06.105 Test_AO_PSO (EURUSD,M1) 20 Forest; Func cicli 10000 risultato: 0.25704414127018393
2022.11.28 12:02:06.105 Test_AO_PSO (EURUSD,M1) Punteggio: 0.14540
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) 500 Forest; Func cicli 10000 risultato: 0.08584805450831333
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) Punteggio: 0.04856
2022.11.28 12:02:44.566 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:02:50.268 Test_AO_PSO (EURUSD,M1) 1 Megacity; Func cicli 10000 risultato: 12.0
2022.11.28 12:02:50.268 Test_AO_PSO (EURUSD,M1) Punteggio: 1.00000
2022.11.28 12:02:57.649 Test_AO_PSO (EURUSD,M1) 20 Megacity; Func cicli 10000 risultato: 1.1199999999999999
2022.11.28 12:02:57.649 Test_AO_PSO (EURUSD,M1) Punteggio: 0.09333
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.268
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) Punteggio: 0.02233
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) =============================
2022.11.28 12:03:34.895 Test_AO_PSO (EURUSD,M1) Tutti i punteggi per C_AO_PSO: 0.40836715689743186

Risultati del test RND (casuale):

2022.11.28 16:45:15.976 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:45:21.569 Test_AO_RND (EURUSD,M1) 1 Skin; Func cicli 10000 risultato: 4.915522750114194
2022.11.28 16:45:21.569 Test_AO_RND (EURUSD,M1) Punteggio: 0.99932
2022.11.28 16:45:28.607 Test_AO_RND (EURUSD,M1) 20 Skin; Func cicli 10000 risultato: 2.584546688199847
2022.11.28 16:45:28.607 Test_AO_RND (EURUSD,M1) Punteggio: 0.44276
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) 500 Skin; Func cicli 10000 risultato: 1.0161336237263792
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) Punteggio: 0.06827
2022.11.28 16:46:02.695 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:46:09.622 Test_AO_RND (EURUSD,M1) 1 Forest; Func cicli 10000 risultato: 1.4695680943894533
2022.11.28 16:46:09.622 Test_AO_RND (EURUSD,M1) Punteggio: 0.83126
2022.11.28 16:46:17.675 Test_AO_RND (EURUSD,M1) 20 Forest; Func cicli 10000 risultato: 0.20373533112604475
2022.11.28 16:46:17.675 Test_AO_RND (EURUSD,M1) Punteggio: 0.11524
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) 500 Forest; Func cicli 10000 risultato: 0.0538909816827325
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) Punteggio: 0.03048
2022.11.28 16:46:54.544 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:47:00.219 Test_AO_RND (EURUSD,M1) 1 Megacity; Func cicli 10000 risultato: 10.0
2022.11.28 16:47:00.219 Test_AO_RND (EURUSD,M1) Punteggio: 0.83333
2022.11.28 16:47:08.145 Test_AO_RND (EURUSD,M1) 20 Megacity; Func cicli 10000 risultato: 1,08
2022.11.28 16:47:08.145 Test_AO_RND (EURUSD,M1) Punteggio: 0.09000
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.28840000000000005
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) Punteggio: 0.02403
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) =============================
2022.11.28 16:47:49.875 Test_AO_RND (EURUSD,M1) Tutti i punteggi per C_AO_RND: 0.38163317904126015

Skin

GWO sulla funzione di test Skin

forest

GWO sulla funzione di test Forest

megacity

GWO sulla funzione di test Megacity

Risultati del test GWO.

2022.11.28 13:24:09.370 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:24:14.895 Test_AO_GWO (EURUSD,M1) 1 Skin; Func cicli 10000 risultato: 4.914175888065222
2022.11.28 13:24:14.895 Test_AO_GWO (EURUSD,M1) Punteggio: 0.99900
2022.11.28 13:24:22.175 Test_AO_GWO (EURUSD,M1) 20 Skin; Func cicli 10000 risultato: 2.7419092435309405
2022.11.28 13:24:22.175 Test_AO_GWO (EURUSD,M1) Punteggio: 0.48033
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) 500 Skin; Func cicli 10000 risultato: 1.5227848592798188
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) Punteggio: 0.18924
2022.11.28 13:25:01.381 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:25:06.924 Test_AO_GWO (EURUSD,M1) 1 Forest; Func cicli 10000 risultato: 1.4822580151819842
2022.11.28 13:25:06.924 Test_AO_GWO (EURUSD,M1) Punteggio: 0.83844
2022.11.28 13:25:14.551 Test_AO_GWO (EURUSD,M1) 20 Forest; Func cicli 10000 risultato: 0.15477395149266915
2022.11.28 13:25:14.551 Test_AO_GWO (EURUSD,M1) Punteggio: 0.08755
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) 500 Forest; Func cicli 10000 risultato: 0.04517298232457319
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) Punteggio: 0.02555
2022.11.28 13:25:56.900 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:26:02.305 Test_AO_GWO (EURUSD,M1) 1 Megacity; Func cicli 10000 risultato: 12.0
2022.11.28 13:26:02.305 Test_AO_GWO (EURUSD,M1) Punteggio: 1.00000
2022.11.28 13:26:09.475 Test_AO_GWO (EURUSD,M1) 20 Megacity; Func cicli 10000 risultato: 1,2
2022.11.28 13:26:09.475 Test_AO_GWO (EURUSD,M1) Punteggio: 0.10000
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.2624
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) Punteggio: 0.02187
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) =============================
2022.11.28 13:26:48.980 Test_AO_GWO (EURUSD,M1) Tutti i punteggi per C_AO_GWO: 0.41577484361261224

Il Gray Wolves Optimization Algorithm (GWO) è uno dei recenti algoritmi di ottimizzazione bioispirati, basato sulla simulazione della caccia di un branco di lupi grigi. In media, l'algoritmo si è dimostrato abbastanza efficiente su vari tipi di funzioni, sia in termini di accuratezza nel trovare un estremo sia in termini di velocità di convergenza. In alcuni test si è rivelato il migliore. I principali indicatori prestazionali dell'algoritmo di ottimizzazione "Gray Wolves" sono migliori di quelli dell'algoritmo di ottimizzazione sciame di particelle, ritenuto "convenzionale" nella classe degli algoritmi di ottimizzazione bioispirati.

Allo stesso tempo, la complessità computazionale dell'algoritmo di ottimizzazione Gray Wolves è paragonabile a quella dell'algoritmo di ottimizzazione sciame di particelle. Grazie ai numerosi vantaggi dell'algoritmo di ottimizzazione GWO, in breve tempo sono apparsi molti lavori sulla sua modifica da quando l'algoritmo è stato pubblicato. L'unico inconveniente dell'algoritmo è la scarsa precisione delle coordinate trovate della funzione sharp-maximum di Forest.

La scarsa accuratezza dell'estremo trovato si è manifestata in tutte le dimensioni della funzione di Forest, e i risultati sono i peggiori tra tutti i partecipanti alla tabella. L'algoritmo si è dimostrato efficiente sulla funzione regolare Skin, soprattutto nel caso di funzioni Skin di dimensioni maggiori. Il GWO è anche terzo nella classifica per aver raggiunto il 100% di successo nel massimo globale sulla funzione Megacity.

AO	Descrizione	Skin			Forest			Megacity (discreta)			Risultato finale
AO	Descrizione	2 parametri (1 F)	40 parametri (20 F)	1000 parametri (500 F)	2 parametri (1 F)	40 parametri (20 F)	1000 parametri (500 F)	2 parametri (1 F)	40 parametri (20 F)	1000 parametri (500 F)	Risultato finale
ACOm	ottimizzazione della colonia di formiche	0.98229	0.79108	0.12602	1.00000	0.62077	0.11521	0.38333	0.44000	0.02377	0.49805222
ABCm	colonia di api artificiale M	1.00000	0.63922	0.08076	0.99908	0.20112	0.03785	1.00000	0.16333	0.02823	0.46106556
ABC	colonia di api artificiale	0.99339	0.73381	0.11118	0.99934	0.21437	0.04215	0.85000	0.16833	0.03130	0.46043000
GWO	ottimizzatore lupo grigio	0.99900	0.48033	0.18924	0.83844	0.08755	0.02555	1.00000	0.10000	0.02187	0.41577556
PSO	ottimizzazione sciame di particelle	0.99627	0.38080	0.05089	0.93772	0.14540	0.04856	1.00000	0.09333	0.02233	0.40836667
RND	casuale	0.99932	0.44276	0.06827	0.83126	0.11524	0.03048	0.83333	0.09000	0.02403	0.38163222

Conclusioni:

Pro:
1. Alta velocità.
2. Alta convergenza per funzioni regolari con un gran numero di variabili.

Contro:
1. Non universale.
2. Rimanere bloccati negli estremi locali.
3. Bassa scalabilità su funzioni discrete e non differenziabili.

Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/11785

File allegati |

Scarica ZIP

l5_The_world_of_AO_oGWOv.zip (44.97 KB)

Avvertimento: Tutti i diritti su questi materiali sono riservati a MetaQuotes Ltd. La copia o la ristampa di questi materiali in tutto o in parte sono proibite.

Altri articoli di questo autore

Vai alla discussione

Algoritmi di ottimizzazione della popolazione: Algoritmo di Ottimizzazione del Cuculo (COA)

Il prossimo algoritmo che considererò è l'ottimizzazione della ricerca del cuculo utilizzando i voli di Levy. Si tratta di uno dei più recenti algoritmi di ottimizzazione e di un nuovo leader in classifica.

Impara come progettare un sistema di trading tramite VIDYA

Benvenuti in un nuovo articolo della nostra serie su come progettare un sistema di trading con gli indicatori tecnici più popolari. In questo articolo conosceremo un nuovo strumento tecnico e impareremo a progettare un sistema di trading tramite Variable Index Dynamic Average (VIDYA).

Impara come progettare un sistema di trading tramite DeMarker

Ecco un nuovo articolo nella nostra serie su come progettare un sistema di trading tramite gli indicatori tecnici più popolari. In questo articolo presenteremo come creare un sistema di trading tramite l'indicatore DeMarker.

Impara come progettare un sistema di trading tramite Bull’s Power

Benvenuti ad un nuovo articolo della nostra serie su come imparare a progettare un sistema di trading attraverso gli indicatori tecnici più popolari. In questo articolo impareremo a conoscere un nuovo indicatore tecnico e a progettare un sistema di trading in base ad esso, questo indicatore è il Bull's Power.