Algoritmi di ottimizzazione della popolazione: Ottimizzazione delle Piante Infestanti (Invasive Weed Optimization - IWO)

Contenuto

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

1. Introduzione

L'algoritmo meta-euristico delle piante infestanti è un algoritmo di ottimizzazione basato sulla popolazione che trova l'optimum generale della funzione ottimizzata simulando la compatibilità e la casualità di una colonia di infestanti.
L'algoritmo di ottimizzazione delle piante infestanti si riferisce agli algoritmi di popolazione ispirati alla natura e riflette il comportamento delle piante infestanti in un'area limitata nella lotta per la sopravvivenza per un periodo di tempo limitato.

Le piante infestanti sono erbe potenti che, con la loro crescita offensiva, costituiscono una seria minaccia per le colture. Sono molto resistenti e si adattano ai cambiamenti ambientali. Considerando le loro caratteristiche, abbiamo un potente algoritmo di ottimizzazione. Questo algoritmo cerca di imitare la robustezza, l'adattabilità e la casualità della comunità delle piante infestanti in natura.

Cosa rende le erbacce così speciali? Le erbacce tendono ad essere le prime a muoversi, diffondendosi ovunque attraverso una serie di meccanismi. Pertanto, raramente rientrano nella categoria delle specie in pericolo.
Di seguito sono riportate le brevi descrizioni di otto modi in cui le piante infestanti si adattano e sopravvivono in natura:

1. Genotipo universale. Gli studi hanno rivelato i cambiamenti evolutivi delle piante infestanti come risposta ai cambiamenti climatici.

2. Strategie del ciclo vitale, fertilità. Le piante infestanti presentano un'ampia gamma di strategie di ciclo vitale. Con il cambiamento dei sistemi di gestione della lavorazione del terreno, le erbacce che in precedenza non erano un problema importante in un determinato sistema di coltivazione diventano più resistenti. Ad esempio, i sistemi di lavorazione ridotta del terreno causano la comparsa di erbe infestanti perenni con diverse strategie di ciclo vitale. Inoltre, il cambiamento climatico sta iniziando a creare nuove nicchie per le specie o i genotipi di erbe infestanti i cui cicli vitali si adattano meglio alle condizioni mutevoli. In risposta all'aumento delle emissioni di anidride carbonica, le piante infestanti diventano più alte, più grandi e più forti, il che significa che possono produrre più semi e diffonderli più lontano dalle piante più alte grazie alle proprietà aerodinamiche. La loro fertilità è enorme. Ad esempio, il cardo di scrofa di mais produce fino a 19.000 semi.

3. Evoluzione rapida (germinazione, crescita senza pretese, competitività, sistema di riproduzione, produzione di semi e caratteristiche di distribuzione). La maggiore capacità di disperdere i semi, la concomitante dispersione e l'assenza di pretese nella crescita offrono opportunità di sopravvivenza. Le piante infestanti sono estremamente indifferenti alle condizioni del terreno e resistono con costanza alle forti oscillazioni di temperatura e umidità.

4. Epigenetica. Oltre alla rapida evoluzione, molte piante infestanti hanno la capacità di rispondere rapidamente ai cambiamenti dei fattori ambientali modificando l'espressione genica. In un ambiente in continuo mutamento, le piante devono essere flessibili per resistere a stress come le fluttuazioni di luce, temperatura, disponibilità di acqua e livelli di sale nel suolo. Per essere flessibili, le piante sono in grado di subire modifiche epigenetiche da sole.

5. Ibridazione. Le specie ibride di erbe infestanti spesso presentano un vigore ibrido, noto anche come eterosi. La progenie mostra una funzione biologica migliore rispetto a entrambe le specie parentali. In genere, un ibrido mostra una crescita più aggressiva con una maggiore capacità di diffondersi in nuovi territori e di competere all'interno dei territori invasi.

6. Resistenza e tolleranza agli erbicidi. Negli ultimi decenni si è registrato un forte aumento della resistenza agli erbicidi nella maggior parte delle piante infestanti.

7. Co-evoluzione delle erbe infestanti associate alle attività umane. Attraverso le pratiche di controllo delle erbe infestanti, come l'applicazione di erbicidi e il diserbo, le piante infestanti hanno sviluppato meccanismi di resistenza. Rispetto alle piante coltivate, subiscono meno danni esterni durante la lavorazione del terreno. Al contrario, questi danni sono spesso utili anche per la propagazione di erbe infestanti a propagazione vegetativa (per esempio, quelle che si propagano attraverso parti della radice o rizomi).

8. I cambiamenti climatici sempre più frequenti offrono alle piante infestanti l'opportunità di essere più vitali rispetto alle piante coltivate in "serra". Le erbacce causano gravi danni all'agricoltura. Essendo meno esigenti in termini di condizioni di coltivazione, superano le piante coltivate in termini di crescita e sviluppo. Assorbendo umidità, sostanze nutritive e luce solare, le erbe infestanti riducono drasticamente la resa, rendono difficile la raccolta e la trebbiatura dei campi e peggiorano la qualità del prodotto.

2. Descrizione dell'algoritmo

L'algoritmo delle piante infestanti si ispira al processo di crescita delle erbacce in natura. Questo metodo è stato introdotto da Mehrabian e Lucas nel 2006. Naturalmente le erbacce sono cresciute fortemente e questa forte crescita rappresenta una seria minaccia per le piante utili. Una caratteristica importante delle piante infestanti è la loro resistenza e l'elevata adattabilità in natura, che costituisce la base per l'ottimizzazione dell'algoritmo IWO. Questo algoritmo può essere utilizzato come base per approcci di ottimizzazione efficienti.

IWO è un algoritmo numerico stocastico continuo che imita il comportamento di colonizzazione delle erbe infestanti. In primo luogo, la popolazione iniziale dei semi viene distribuita in modo casuale sull'intero spazio di ricerca. Queste erbacce finalmente cresceranno e svolgeranno ulteriori fasi dell'algoritmo. L'algoritmo è composto da sette fasi, che possono essere rappresentate come pseudocodice:

1. Seminare in modo casuale
2. Calcolare FF
3. Seminare le erbacce
4. Calcolare FF
5. Unire l’erbaccia figlia con quella madre
6. Ordinare tutte le erbacce
7. Ripetere dal passaggio 3 finché non viene soddisfatta la condizione di arresto.

Il diagramma a blocchi rappresenta il funzionamento dell'algoritmo in una iterazione. IWO inizia il suo lavoro con il processo di inizializzazione del seme. I semi sono sparsi sul "campo" dello spazio di ricerca in modo casuale e uniforme. Dopodiché, supponiamo che i semi siano germogliati e abbiano formato piante adulte, che dovrebbero essere valutate dalla funzione di fitness.

Nella fase successiva, conoscendo il fitness di ogni pianta, possiamo permettere alle erbacce di propagarsi attraverso i semi, dove il numero di semi è proporzionale al fitness. Dopodiché, uniamo i semi germinati con le piante madri e li selezioniamo. In generale, l'algoritmo delle piante infestanti può essere considerato semplice da codificare, modificare e utilizzare insieme ad applicazioni di terze parti.

Fig. 1. Diagramma dell'algoritmo IWO

Passiamo ora a considerare le caratteristiche dell'algoritmo delle piante infestanti. Presenta molte delle capacità di sopravvivenza estrema delle erbacce. Una caratteristica distintiva di una colonia di erbacce, a differenza di algoritmi come quello genetico, quello delle api e altri, è la garanzia della semina da parte di tutte le piante della colonia, senza eccezioni. Questo fa sì che anche le piante peggio adattate lascino discendenti, poiché c'è sempre una probabilità non nulla che la peggiore possa essere la più vicina all'estremo globale.

Come ho già detto, ogni erbaccia produce semi all'interno di un intervallo compreso tra la quantità minima possibile e la quantità massima possibile (parametri esterni dell'algoritmo). Naturalmente, in queste condizioni, quando ogni pianta lascia almeno uno o più semi, ci saranno più piante figlie che piante madri - questa caratteristica è implementata in modo interessante nel codice che discuteremo di seguito. L'algoritmo in generale è presentato visivamente nella Figura 2. Le piante madri spargono i semi in proporzione alla loro fitness.

Quindi la pianta migliore al numero 1 ha seminato 6 semi, mentre la pianta al numero 6 ha seminato un solo seme (quello garantito). I semi germinati producono piante che vengono successivamente selezionate insieme alle madri. È un'imitazione della sopravvivenza. Dall'intero gruppo selezionato, vengono selezionate nuove piante madri e il ciclo di vita viene ripetuto all'iterazione successiva. L'algoritmo è caratterizzato da un meccanismo che risolve i problemi di "sovrappopolazione" e di realizzazione incompleta della capacità di semina.

Ad esempio, prendiamo il numero di semi, uno dei parametri dell'algoritmo è 50, e il numero di piante madri è 5, il numero minimo di semi è 1, mentre quello massimo è 6. In questo caso, 5 * 6 = 30, che è inferiore a 50. Come possiamo vedere da questo esempio, le possibilità di semina non sono pienamente realizzate. In questo caso, il diritto di mantenere un discendente passa al successivo nell'elenco fino a quando non viene raggiunto il numero massimo consentito di discendenti in tutte le piante madri. Quando si raggiunge la fine dell'elenco, il diritto va al primo dell'elenco e sarà consentito lasciare un discendente che superi il limite. 

Figura 2. Funzionamento dell'algoritmo IWO. Il numero di discendenti è proporzionale alla fitness del genitore.

La cosa successiva a cui prestare attenzione è la dispersione della semina. La dispersione della semina nell'algoritmo è una funzione lineare decrescente proporzionale al numero delle iterazioni. I parametri di dispersione esterna sono i limiti inferiore e superiore della dispersione del seme. Pertanto, con l'aumento delle iterazioni, il raggio di semina diminuisce e gli estremi trovati si affinano. Secondo le raccomandazioni degli autori dell'algoritmo, si dovrebbe applicare la distribuzione normale di semina, ma io ho semplificato i calcoli e ho applicato la funzione cubica. La funzione di dispersione del numero di iterazioni può essere vista nella Figura 3.

Fig. 3. La dipendenza della dispersione dal numero di iterazioni, dove 3 è il limite massimo e 2 quello minimo

Passiamo al codice IWO. Il codice è semplice e di rapida esecuzione.

L'unità più semplice (agente) dell'algoritmo è l'"erbaccia". Descriverà anche i semi dell'erba. Questo ci permetterà di utilizzare lo stesso tipo di dati per i successivi ordinamenti. La struttura consiste in un array di coordinate, una variabile per memorizzare il valore della funzione di fitness e un contatore per il numero di semi (discendenti). Questo contatore ci permetterà di controllare il numero minimo e massimo consentito di semi per ogni pianta.

//——————————————————————————————————————————————————————————————————————————————
struct S_Weed
{
  double c []; //coordinates
  double f;    //fitness
  int    s;    //number of seeds
};
//——————————————————————————————————————————————————————————————————————————————

Avremo bisogno di una struttura per implementare la funzione di probabilità di scegliere i genitori in proporzione alla loro fitness. In questo caso, si applica il principio della roulette, già visto nell'algoritmo della colonia di api. Le variabili "start" e "end" sono responsabili dell'inizio e della fine del campo di probabilità.

//——————————————————————————————————————————————————————————————————————————————
struct S_WeedFitness
{
  double start;
  double end;
};
//——————————————————————————————————————————————————————————————————————————————

Dichiariamo la classe dell'algoritmo delle piante infestanti. Al suo interno, dichiarare tutte le variabili necessarie - i confini e il passo dei parametri da ottimizzare, l'array che descrive le piante infestanti, così come l'array dei semi, l'array delle migliori coordinate globali e il miglior valore della funzione di fitness raggiunto dall'algoritmo. Abbiamo anche bisogno del flag "semina" della prima iterazione e delle variabili costanti dei parametri dell'algoritmo.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_IWO
{
  //============================================================================
  public: double rangeMax  []; //maximum search range
  public: double rangeMin  []; //manimum search range
  public: double rangeStep []; //step search
  public: S_Weed weeds     []; //weeds
  public: S_Weed weedsT    []; //temp weeds
  public: S_Weed seeds     []; //seeds
  public: double cB        []; //best coordinates
  public: double fB;           //fitness of the best coordinates

  public: void Init (const int    coordinatesP,      //Number of coordinates
                     const int    numberSeedsP,      //Number of seeds
                     const int    numberWeedsP,      //Number of weeds
                     const int    maxNumberSeedsP,   //Maximum number of seeds per weed
                     const int    minNumberSeedsP,   //Minimum number of seeds per weed
                     const double maxDispersionP,    //Maximum dispersion
                     const double minDispersionP,    //Minimum dispersion
                     const int    maxIterationP);    //Maximum iterations

  public: void Sowing      (int iter);
  public: void Germination ();

  //============================================================================
  private: void   Sorting        ();
  private: double SeInDiSp       (double In, double InMin, double InMax, double Step);
  private: double RNDfromCI      (double Min, double Max);
  private: double Scale          (double In, double InMIN, double InMAX, double OutMIN, double OutMAX,  bool Revers);

  private: double vec [];            //Vector
  private: int    ind [];
  private: double val [];
  private: S_WeedFitness wf [];      //Weed fitness
  private: bool   sowing;            //Sowing
  private: int    coordinates;       //Coordinates number
  private: int    numberSeeds;       //Number of seeds
  private: int    numberWeeds;       //Number of weeds
  private: int    totalNumWeeds;     //Total number of weeds
  private: int    maxNumberSeeds;    //Maximum number of seeds
  private: int    minNumberSeeds;    //Minimum number of seeds
  private: double maxDispersion;     //Maximum dispersion
  private: double minDispersion;     //Minimum dispersion
  private: int    maxIteration;      //Maximum iterations
};
//——————————————————————————————————————————————————————————————————————————————

Nel metodo aperto della funzione di inizializzazione, assegnare un valore alle variabili costanti, controllare che i parametri di ingresso dell'algoritmo siano validi, in modo che il prodotto delle piante madri per il valore minimo possibile di semi non ecceda il numero totale di semi. La somma delle piante madri e dei semi sarà necessaria per determinare l'array per eseguire l’ordinamento.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_IWO::Init (const int    coordinatesP,      //Number of coordinates
                     const int    numberSeedsP,      //Number of seeds
                     const int    numberWeedsP,      //Number of weeds
                     const int    maxNumberSeedsP,   //Maximum number of seeds per weed
                     const int    minNumberSeedsP,   //Minimum number of seeds per weed
                     const double maxDispersionP,    //Maximum dispersion
                     const double minDispersionP,    //Minimum dispersion
                     const int    maxIterationP)     //Maximum iterations
{
  MathSrand (GetTickCount ());
  sowing = false;
  fB     = -DBL_MAX;

  coordinates    = coordinatesP;
  numberSeeds    = numberSeedsP;
  numberWeeds    = numberWeedsP;
  maxNumberSeeds = maxNumberSeedsP;
  minNumberSeeds = minNumberSeedsP;
  maxDispersion  = maxDispersionP;
  minDispersion  = minDispersionP;
  maxIteration   = maxIterationP;


  if (minNumberSeeds < 1) minNumberSeeds = 1;
  if (numberWeeds * minNumberSeeds > numberSeeds) numberWeeds = numberSeeds / minNumberSeeds;
  else numberWeeds = numberWeedsP;

  totalNumWeeds  = numberWeeds + numberSeeds;

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

  ArrayResize (weeds,  totalNumWeeds);
  ArrayResize (weedsT, totalNumWeeds);
  ArrayResize (seeds,  numberSeeds);

  for (int i = 0; i < numberWeeds; i++)
  {
    ArrayResize (weeds  [i].c, coordinates);
    ArrayResize (weedsT [i].c, coordinates);
    weeds [i].f = -DBL_MAX;
    weeds [i].s = 0;
  }
  for (int i = 0; i < numberSeeds; i++)
  {
    ArrayResize (seeds [i].c, coordinates);
    seeds [i].s = 0;
  }

  ArrayResize (ind, totalNumWeeds);
  ArrayResize (val, totalNumWeeds);

  ArrayResize (wf, numberWeeds);
}
//——————————————————————————————————————————————————————————————————————————————

Il primo metodo pubblico chiamato ad ogni iterazione Sowing (), contiene la logica principale dell'algoritmo. Per facilitare la percezione, dividerò il metodo in diverse parti.

Quando l'algoritmo è alla prima iterazione, è necessario seminare in tutto lo spazio di ricerca. Di solito questo viene fatto in modo casuale e uniforme. Dopo aver generato numeri casuali nell'intervallo dei valori accettabili dei parametri ottimizzati, verificare che i valori ottenuti non vadano oltre l'intervallo e impostare la discrezionalità definita dai parametri dell'algoritmo. Qui assegneremo anche un vettore di distribuzione, che ci servirà quando semineremo più avanti nel codice. Inizializzare i valori di fitness dei semi al valore double minimo e azzerare il contatore dei semi (i semi diventeranno piante che utilizzeranno il contatore dei semi).

//the first sowing of seeds---------------------------------------------------
if (!sowing)
{
  fB = -DBL_MAX;

  for (int s = 0; s < numberSeeds; s++)
  {
    for (int c = 0; c < coordinates; c++)
    {
      seeds [s].c [c] = RNDfromCI (rangeMin [c], rangeMax [c]);
      seeds [s].c [c] = SeInDiSp (seeds [s].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);

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

    seeds [s].f = -DBL_MAX;
    seeds [s].s = 0;
  }

  sowing = true;
  return;
}

In questa sezione del codice, la dispersione viene calcolata in base all'iterazione corrente. Il numero minimo garantito di semi per ogni pianta madre, di cui ho parlato in precedenza, viene implementato qui. La garanzia del numero minimo di semi sarà fornita da due cicli, nel primo dei quali si selezioneranno le piante madri, mentre nel secondo si genereranno effettivamente nuovi semi, aumentando il contatore dei semi. Come si può notare, il senso della creazione di un nuovo discendente è quello di incrementare un numero casuale con la distribuzione di una funzione cubica con la dispersione precedentemente calcolata rispetto alla coordinata madre. Verificare che il valore ottenuto della nuova coordinata sia accettabile e assegnare la discrezionalità.

//guaranteed sowing of seeds by each weed-------------------------------------
int    pos = 0;
double r   = 0.0;
double dispersion = ((maxIteration - iter) / (double)maxIteration) * (maxDispersion - minDispersion) + minDispersion;

for (int w = 0; w < numberWeeds; w++)
{
  weeds [w].s = 0;

  for (int s = 0; s < minNumberSeeds; s++)
  {
    for (int c = 0; c < coordinates; c++)
    {
      r = RNDfromCI (-1.0, 1.0);
      r = r * r * r;

      seeds [pos].c [c] = weeds [w].c [c] + r * vec [c] * dispersion;
      seeds [pos].c [c] = SeInDiSp (seeds [pos].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    }

    pos++;
    weeds [w].s++;
  }
}

Con questo codice, forniremo campi di probabilità per ciascuna delle piante madri in proporzione alla fitness secondo il principio della roulette. Il codice sopra forniva un numero garantito di semi per ciascuna delle piante in un momento in cui il numero di semi qui aderisce a una legge casuale, per cui più l'erbaccia si adattata, più semi può lasciare e viceversa. Meno la pianta si adatta, meno semi produrrà.

//============================================================================
//sowing seeds in proportion to the fitness of weeds--------------------------

//the distribution of the probability field is proportional to the fitness of weeds
wf [0].start = weeds [0].f;
wf [0].end   = wf [0].start + (weeds [0].f - weeds [numberWeeds - 1].f);

for (int f = 1; f < numberWeeds; f++)
{
  if (f != numberWeeds - 1)
  {
    wf [f].start = wf [f - 1].end;
    wf [f].end   = wf [f].start + (weeds [f].f - weeds [numberWeeds - 1].f);
  }
  else
  {
    wf [f].start = wf [f - 1].end;
    wf [f].end   = wf [f].start + (weeds [f - 1].f - weeds [f].f) * 0.1;
  }
}

In base ai campi di probabilità ottenuti, selezioniamo la pianta madre che ha il diritto di lasciare un discendente. Se il contatore di semi ha raggiunto il valore massimo consentito, il diritto passa al successivo nella lista ordinata. Se si raggiunge la fine della lista, il diritto non passa al successivo, ma al primo dell'elenco. Poi si forma una pianta figlia secondo la regola descritta sopra con la dispersione calcolata.

bool seedingLimit = false;
int  weedsPos = 0;

for (int s = pos; s < numberSeeds; s++)
{
  r = RNDfromCI (wf [0].start, wf [numberWeeds - 1].end);

  for (int f = 0; f < numberWeeds; f++)
  {
    if (wf [f].start <= r && r < wf [f].end)
    {       
      weedsPos = f;
      break;
    }
  }

  if (weeds [weedsPos].s >= maxNumberSeeds)
  {
    seedingLimit = false;
    while (!seedingLimit)
    {
      weedsPos++;
      if (weedsPos >= numberWeeds)
      {
        weedsPos = 0;
        seedingLimit = true;
      }
      else
      {
        if (weeds [weedsPos].s < maxNumberSeeds)
        {
          seedingLimit = true;
        }
      }
    }
  }

  for (int c = 0; c < coordinates; c++)
  {
    r = RNDfromCI (-1.0, 1.0);
    r = r * r * r;

    seeds [s].c [c] = weeds [weedsPos].c [c] + r * vec [c] * dispersion;
    seeds [s].c [c] = SeInDiSp (seeds [s].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
  }

  seeds [s].s = 0;
  weeds [weedsPos].s++;
}

Il secondo metodo aperto è obbligatorio per l'esecuzione a ogni iterazione e viene richiesto dopo aver calcolato la funzione di fitness per ogni erba figlia. Prima di applicare l'ordinamento, posizionare i semi germinati nell'array comune con le piante madri alla fine dell'elenco, sostituendo così la generazione precedente, che potrebbe includere sia i discendenti che i genitori dell'iterazione precedente. In questo modo, distruggiamo le erbe infestanti poco adattate, come accade in natura. Successivamente, applicare l'ordinamento. La prima erbaccia risultante dell'elenco sarà degna di aggiornare la soluzione migliore raggiunta a livello globale, se è davvero migliore.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_IWO::Germination ()
{
  for (int s = 0; s < numberSeeds; s++)
  {
    weeds [numberWeeds + s] = seeds [s];
  }

  Sorting ();

  if (weeds [0].f > fB) fB = weeds [0].f;
}
//——————————————————————————————————————————————————————————————————————————————

3. Risultati del test

I risultati del banco di prova sono i seguenti:

2023.01.13 18:12:29.880 Test_AO_IWO (EURUSD,M1) C_AO_IWO:50;12;5;2;0.2;0.01
2023.01.13 18:12:29.880 Test_AO_GWO (EURUSD,M1) =============================
2023.01.13 18:12:32.251 Test_AO_IWO (EURUSD,M1) 5 Rastrigin's; Func cicli 10000 risultato: 79.71791976868334.
2023.01.13 18:12:32.251 Test_AO_GWO (EURUSD,M1) Punteggio: 0.98775.
2023.01.13 18:12:36.564 Test_AO_IWO (EURUSD,M1) 25 Rastrigin's; Func cicli 10000 risultato: 66.60305588198622.
2023.01.13 18:12:36.564 Test_AO_GWO (EURUSD,M1) Punteggio: 0.82525.
2023.01.13 18:13:14.024 Test_AO_IWO (EURUSD,M1) 500 Rastrigin's; Func cicli 10000 risultato: 45.4191288396659.
2023.01.13 18:13:14.024 Test_AO_GWO (EURUSD,M1) Punteggio: 0.56277.
2023.01.13 18:13:14.024 Test_AO_IWO (EURUSD,M1) =============================
2023.01.13 18:13:16.678 Test_AO_IWO (EURUSD,M1) 5 Forest; Func cicli 10000 risultato: 1.302934874807614.
2023.01.13 18:13:16.678 Test_AO_IWO (EURUSD,M1) Punteggio: 0.73701.
2023.01.13 18:13:22.113 Test_AO_IWO (EURUSD,M1) 25 Forest; Func cicli 10000 risultato: 0.5630336066477166.
2023.01.13 18:13:22.113 Test_AO_IWO (EURUSD,M1) Punteggio: 0.31848.
2023.01.13 18:14:05.092 Test_AO_IWO (EURUSD,M1) 500 Forest; Func cicli 10000 risultato: 0.11082098547471195.
2023.01.13 18:14:05.092 Test_AO_IWO (EURUSD,M1) Punteggio: 0.06269.
2023.01.13 18:14:05.092 Test_AO_IWO (EURUSD,M1) =============================
2023.01.13 18:14:09.102 Test_AO_IWO (EURUSD,M1) 5 Megacity; Func cicli 10000 risultato: 6.640000000000001.
2023.01.13 18:14:09.102 Test_AO_IWO (EURUSD,M1) Punteggio: 0.55333.
2023.01.13 18:14:15.191 Test_AO_IWO (EURUSD,M1) 25 Megacity; Func cicli 10000 risultato: 2.6.
2023.01.13 18:14:15.191 Test_AO_IWO (EURUSD,M1) Punteggio: 0.21667.
2023.01.13 18:14:55.886 Test_AO_IWO (EURUSD,M1) 500 Megacity; Func cicli 10000 risultato: 0.5668.
2023.01.13 18:14:55.886 Test_AO_IWO (EURUSD,M1) Punteggio: 0.04723.

Basta una rapida occhiata per notare gli elevati risultati dell'algoritmo sulle funzioni di test. Si nota una notevole preferenza per il lavoro sulle funzioni regolari, anche se finora nessuno degli algoritmi considerati ha mostrato una convergenza migliore sulle funzioni discrete rispetto a quelle regolari, il che si spiega con la complessità delle funzioni Forest e Megacity per tutti gli algoritmi senza eccezione. È possibile che alla fine si ottenga un algoritmo per i test che risolva le funzioni discrete meglio di quelle regolari.

  IWO sulla funzione di test Rastrigin

IWO sulla funzione di test Forest

IWO funzione di test Megacity

L'algoritmo delle piante invasive ha mostrato risultati impressionanti nella maggior parte dei test, in particolare sulla funzione regolare Rastrigin con 10 e 50 parametri. Le sue prestazioni si sono abbassate leggermente solo nel test con 1000 parametri, che in generale indica buone prestazioni su funzioni regolari. Questo mi permette di raccomandare l'algoritmo per funzioni regolari complesse e reti neurali. Sulle funzioni Forest, l'algoritmo ha mostrato buoni risultati nel primo test con 10 parametri, ma ha comunque mostrato risultati complessivamente nella media. Sulla funzione discreta Megacity, l'algoritmo delle piante invasive ha performato al di sopra della media, mostrando soprattutto un'eccellente scalabilità nel test con 1000 variabili, perdendo il primo posto solo rispetto all'algoritmo della lucciola, ma superandolo significativamente nei test con 10 e 50 parametri.

Sebbene l'algoritmo delle piante invasive abbia un numero piuttosto elevato di parametri, questo non deve essere considerato uno svantaggio, poiché i parametri sono molto intuitivi e possono essere facilmente configurati. Inoltre, la regolazione fine dell'algoritmo influisce generalmente solo sui risultati dei test di una funzione discreta, mentre i risultati su una funzione regolare rimangono buoni.

Nella visualizzazione delle funzioni di test, la capacità dell'algoritmo di isolare ed esplorare alcune parti dello spazio di ricerca è chiaramente visibile, proprio come accade nell'algoritmo delle api e in altri. Anche se diverse pubblicazioni affermano che l'algoritmo è incline a bloccarsi e presenta scarse capacità di ricerca. Nonostante l'algoritmo non abbia un riferimento all'estremo globale, così come i meccanismi per "saltare" fuori dalle trappole locali, IWO riesce in qualche modo a gestire il lavoro adeguatamente su funzioni complesse come Forest e Megacity. Quando si lavora su una funzione discreta, più sono i parametri ottimizzati, più stabili sono i risultati.

Poiché la dispersione del seme diminuisce linearmente ad ogni iterazione, l'affinamento dell'estremo aumenta ulteriormente verso la fine dell'ottimizzazione. A mio parere, questo non è del tutto ottimale, perché le capacità esplorative dell'algoritmo sono distribuite in modo non uniforme nel tempo, come possiamo notare dalla visualizzazione delle funzioni di test come rumore bianco costante. Inoltre, l'irregolarità della ricerca può essere giudicata dai grafici di convergenza nella parte destra della finestra del banco di prova. All'inizio dell'ottimizzazione si osserva una certa accelerazione della convergenza, tipica di quasi tutti gli algoritmi. Dopo un inizio deciso, la convergenza rallenta per la maggior parte dell'ottimizzazione. Possiamo notare una significativa accelerazione della convergenza solo verso la fine. La variazione dinamica della dispersione è motivo di ulteriori studi ed esperimenti dettagliati. Poichè possiamo notare che la convergenza potrebbe riprendere se il numero di iterazioni fosse maggiore. Tuttavia, esistono limitazioni ai test comparativi eseguiti in modo da mantenere l'obiettività e la validità pratica. 

Passiamo alla tabella di valutazione finale. La tabella mostra che IWO è attualmente leader. L'algoritmo ha mostrato i risultati migliori in due dei nove test, mentre negli altri i risultati sono molto migliori della media, quindi il risultato finale è di 100 punti. L'algoritmo della colonia di formiche modificato (ACOm) è il secondo. Rimane il migliore in 5 dei 9 test.

AO	Descrizione	Rastrigin			Finale Rastrigin	Forest			Finale Forest	Megacity (discreta)			Finale Megacity	Risultato finale
		10 parametri (5 F)	50 parametri (25 F)	1000 parametri (500 F)		10 parametri (5 F)	50 parametri (25 F)	1000 parametri (500 F)		10 parametri (5 F)	50 parametri (25 F)	1000 parametri (500 F)
IWO	Ottimizzazione delle piante infestanti	1.00000	1.00000	0.33519	2.33519	0.79937	0.46349	0.41071	1.67357	0.75912	0.44903	0.94088	2.14903	100.000
ACOm	Ottimizzazione della colonia di formiche M	0.36118	0.26810	0.17991	0.80919	1.00000	1.00000	1.00000	3.00000	1.00000	1.00000	0.10959	2.10959	95.996
COAm	Algoritmo di ottimizzazione a cucù M	0.96423	0.69756	0.28892	1.95071	0.64504	0.34034	0.21362	1.19900	0.67153	0.34273	0.45422	1.46848	74.204
FAm	Algoritmo della lucciola M	0.62430	0.50653	0.18102	1.31185	0.55408	0.42299	0.64360	1.62067	0.21167	0.28416	1.00000	1.49583	71.024
BA	Algoritmo del pipistrello	0.42290	0.95047	1.00000	2.37337	0.17768	0.17477	0.33595	0.68840	0.15329	0.07158	0.46287	0.68774	59.650
ABC	Colonia di api artificiali	0.81573	0.48767	0.22588	1.52928	0.58850	0.21455	0.17249	0.97554	0.47444	0.26681	0.35941	1.10066	57.237
FSS	Ricerca del banco di pesci	0.48850	0.37769	0.11006	0.97625	0.07806	0.05013	0.08423	0.21242	0.00000	0.01084	0.18998	0.20082	20.109
PSO	Ottimizzazione dello sciame di particelle	0.21339	0.12224	0.05966	0.39529	0.15345	0.10486	0.28099	0.53930	0.08028	0.02385	0.00000	0.10413	14.232
RND	Casuale	0.17559	0.14524	0.07011	0.39094	0.08623	0.04810	0.06094	0.19527	0.00000	0.00000	0.08904	0.08904	8.142
GWO	Ottimizzazione del lupo grigio	0.00000	0.00000	0.00000	0.00000	0.00000	0.00000	0.00000	0.00000	0.18977	0.04119	0.01802	0.24898	1.000

L'algoritmo delle piante invasive è ottimo per la ricerca globale. Questo algoritmo mostra buone prestazioni, sebbene non venga utilizzato il membro migliore della popolazione e non vi siano meccanismi di protezione contro il potenziale incollaggio negli estremi locali. Non c'è equilibrio tra ricerca e sfruttamento dell'algoritmo, ma questo non ha influito negativamente sulla precisione e sulla velocità dell'algoritmo. Questo algoritmo presenta anche altri svantaggi. Le prestazioni irregolari della ricerca nel corso dell'ottimizzazione suggeriscono che le prestazioni dell'IWO potrebbero essere potenzialmente più elevate se si potessero risolvere i problemi sopra esposti.

Istogramma dei risultati dei test dell'algoritmo in Figura 4

Fig. 4. Istogramma dei risultati finali degli algoritmi di test

Conclusioni sulle proprietà dell'Ottimizzazione delle Piante Infestanti (Invasive Weed Optimization - IWO):

Pro:
1. Alta velocità
2. L'algoritmo funziona bene con vari tipi di funzioni, sia regolari che discrete.
3. Buona scalabilità.

Contro:
1. Numerosi parametri (sebbene siano autoesplicativi).