Ottimizzazione nel tester di strategia - pagina 7

[Renat Fatkhullin]

In breve:

• La sufficienza ragionevole consiste nell'inserirsi in un campo di ricerca di 2 alla potenza di 64
• Un comportamento ragionevole è quello di pre-stimare il campo di ricerca invece di tirare fuori tutte le variabili da cercare al massimo

Rashid, è improbabile che qualcuno osi fare un'enumerazione diretta. Un ottimizzatore genetico 2^64 controllerà facilmente, ma questo non significa che dobbiamo esporre regioni di ricerca illimitate. Dopo tutto, dobbiamo generare geni per queste regioni e poi manipolarli.

[Sergey Chalyshev]

Rosh:

Ok, facciamo i conti. Lasciamo che un passaggio nel tester richieda 1 secondo, poi dividiamo il numero di passaggi 2^64-1 per 60 e otteniamo il tempo di ottimizzazione in minuti: 18 446 744 073 709 551 615/60.

Poi, dividete questo tempo per 8 (8 core sul computer) e ottenete il tempo di ottimizzazione con questo numero di passaggi su un computer a 8 core. Quanto ci vorrà in ore o giorni?

Non contate, non sto parlando di una semplice enumerazione. Lasciate che sia l'algoritmo genetico stesso a determinare di quanti ne ha bisogno.

Se lo si paragona al cervello umano, secondo gli scienziati il cervello contiene circa 10^10 neuroni e ognuno ha circa 10^4 connessioni sinaptiche.

Questo è ciò a cui tutti aspiriamo, creando programmi sempre più avanzati.

Per cosa è stato fatto il cloud computing? Grazie a questo, gli utenti non sono limitati a un solo computer, per cui grazie mille.

[Sergey Chalyshev]

Renat:

Per farla breve:

• La sufficienza ragionevole consiste nell'inserirsi in un campo di ricerca di 2 alla potenza di 64
• Un comportamento ragionevole è quello di pre-stimare il campo di ricerca invece di tirare fuori tutte le variabili da cercare al massimo

Rashid, è improbabile che qualcuno si azzardi a fare un superamento diretto. Un ottimizzatore genetico 2^64 controllerà facilmente, ma questo non significa che devi esporre domini di ricerca illimitati. Dopo tutto, dobbiamo generare geni per queste regioni e poi manipolarli.

Quello che è 2 su 64 è un problema inverosimile.

In un algoritmo genetico non è necessario mantenere i risultati peggiori?

Cosa vi impedisce di torcere tutte le variabili al massimo?

Non riesco a capire quale sia la connessione tra i geni e 2^64?

[ddd06]

Tuttavia, può essere utile per cercare attraverso un sacco di variabili (ad esempio, Rete Neurale) e questa limitazione non è buona.

Quindi spero nella libertà dai vincoli))

[Andrey Dik]

Il tester di strategie sembra usare GA con codifica binaria dei cromosomi.

Ecco una citazione:

"Tuttavia, la rappresentazione binaria dei cromosomi comporta alcune difficoltà quando si cerca in spazi continui di grande dimensionalità, e quando è richiesta un'alta precisione si usa una tecnica speciale basata sul fatto che l'intero intervallo di valori ammissibili di una caratteristica [ai,bi] è diviso in sezioni con la precisione richiesta. Laprecisione richiesta p è definita dall'espressione:

dove N è il numero di bit per codificare una stringa di bit.

Questa formula mostra che p dipende fortemente da N, cioè la precisione di rappresentazione è determinata dal numero di bit usati per codificare un cromosoma. Pertanto, all'aumentare di N, lo spazio di ricerca si espande e diventa enorme. Un esempio di libro ben noto: lasciamo che 100 variabili che variano nell'intervallo [-500; 500] richiedano di trovare un estremo entro sei cifre decimali. In questo caso, usando GA con codifica binaria, la lunghezza della stringa sarebbe di 3000 elementi e lo spazio di ricerca sarebbe di circa¹⁰¹⁰⁰⁰ cromosomi".

Pertanto, anche una rete neurale di dimensioni relativamente piccole nell'ottimizzatore standard, quando è limitata a 64 parametri da ottimizzare, non può essere addestrata. C'è un altro svantaggio - è molto dispendioso in termini di tempo riempire manualmente i parametri delle variabili ottimizzabili se ce ne sono molte. Ecco perché ho già suggerito che si possono specificare gli array con parametri ottimizzabili programmaticamente.

Ma c'è una buona notizia. Tutto ciò che manca nel tester e nel terminale può essere implementato con i mezzi nativi di MQL5. Più tardi posterò i risultati di alcuni test di ottimizzazione utilizzando il tester e il codice del programma.

[Andrey Dik]

Tuttavia, non ho mai aspettato i risultati dal tester sul compito di prova (voglio dire, aspettare è pigro).

Ma chiunque può fare i test da solo. Per questo potete prendere il primo esempio dall'articolo. Non dimenticate di impostare la modalità di ottimizzazione - ricerca dei massimi (per essere in grado di confrontare con l'ottimizzatore standard dove sono disponibili solo i massimi).

Scriviamo un semplice Expert Advisor che è ancora più semplice di una rapa verde e non fa altro che calcolare la funzione di test dell'utente:

//+------------------------------------------------------------------+
//|                                                  Test expert.mq5 |
//|                                      Copyright 2010, JQS aka Joo |
//|                              https://www.mql5.com/ru/users/joo |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, JQS aka Joo"
#property link      "https://www.mql5.com/ru/users/joo"
#property version   "1.00"
//--- input parameters
input double   x1=0.0;
input double   x2=0.0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

  }
//+------------------------------------------------------------------+

double OnTester()
  {
   return
   (
    pow(cos((double)(2*x1*x1))-0.11 e1,0.2 e1)+
    pow(sin(0.5 e0 *(double) x1)-0.12 e1,0.2 e1) -
    pow(cos((double)(2*x2*x2))-0.11 e1,0.2 e1)+
    pow(sin(0.5 e0 *(double) x2)-0.12 e1,0.2 e1)
    );
  }
//+------------------------------------------------------------------+

Le impostazioni nella finestra del tester sono le seguenti:

Nella scheda "Input parameters", fate come segue:

E vai.

Le conclusioni approssimative sono le seguenti:

1) L'ottimizzatore nel tester è 10-100 volte più lento (ha funzionato per me, anche se l'ottimizzazione nel tester è stata eseguita su due core del processore, mentre l'ottimizzazione software è stata eseguita su un core). Molto probabilmente, una differenza così mostruosa è dovuta al fatto che il tester deve scrivere registri, visualizzare informazioni sullo schermo, ecc, oltre ai calcoli diretti di FF, cioè ha una "frenata forzata" rispetto all'ottimizzazione del software.

2) È impossibile utilizzare più di 64 parametri ottimizzabili nel tester (e in Wizard per creare Expert Advisors è limitato a 60 parametri), quindi è impossibile addestrare reti neurali di qualsiasi dimensione significativa.

Si tratta di scrivere da soli i sostituti dei test (MQL5 lo permette, è un'ottima "canna da pesca" ma non un "pesce"), o aspettare che l'algoritmo genetico binario del tester sia sostituito da un algoritmo continuo e la limitazione del numero di parametri ottimizzati venga rimossa. Il secondo non è costruttivo, quindi rimane il primo. :)

Conclusione globale: imparare MQL5.

PS Una buona soluzione sarebbe quella di permettere di disabilitare l'output delle informazioni di ottimizzazione (log, grafico di ottimizzazione) e, ancora meglio, di personalizzare i dettagli dell'output per aumentare le prestazioni del tester.

[Mr.FreeMan]

joo, c'è di più, oltre a scrivere un tester e un ottimizzatore per questi calcoli non piccoli è necessario fare un distributore di calcolo, che coinvolgerebbe tutti i core del processore ed eventualmente collegare agenti remoti (se si fanno calcoli collettivi). In primo luogo la sua velocità non può essere paragonata a quella del tester standard - tutto verrà eseguito molto più lentamente, e in secondo luogo per scrivere tutto questo è necessario spendere un sacco di tempo e centinaia di kilobyte di codice, e tutto a causa di cosa, esattamente?

[Mykola Demko]

Mr.FreeMan:
joo, c'è di più, oltre a scrivere un tester e un ottimizzatore per questi calcoli non piccoli è necessario fare un distributore di calcolo, che coinvolgerebbe tutti i core del processore ed eventualmente collegare agenti remoti (se si fanno calcoli collettivi). In primo luogo non è paragonabile al tester standard - tutto sarà molto più lento, e in secondo luogo per scrivere tutto questo è necessario spendere un sacco di tempo e centinaia di kilobyte di codice, e qual è la ragione?

GA di joo è già più veloce di quello standard, e facendo il porting del codice a CPP con studio 10 (adattato per i processori multi-core) la velocità è ancora 6 volte più veloce.

[Andrey Dik]

Mr.FreeMan:
joo, c'è di più; oltre a scrivere un tester e un ottimizzatore per calcoli così piccoli devi anche fare un distributore per i calcoli che coinvolgerebbero tutti i core del processore ed eventualmente collegare agenti remoti (se vuoi tenere calcoli collettivi). In primo luogo la sua velocità non può essere paragonata a quella del tester standard - tutto verrà eseguito molto più lentamente, e in secondo luogo per scrivere tutto questo è necessario spendere un sacco di tempo e centinaia di kilobyte di codice, e tutto a causa di cosa, esattamente?

Sul rosso Urain ha risposto.

Per quanto riguarda il verde, si tratta di soldi, ovviamente. Il tempo è denaro. Di solito sono un principiante lento, ma un pilota veloce (mi ci è voluto più di un anno per sviluppare e debuggare il GA), e ora continuo a ricevere messaggi di ringraziamento nella mia casella di posta elettronica dopo la pubblicazione dell'articolo. :)

Non sto criticando il tester interno. Sto solo focalizzando l'attenzione degli sviluppatori su ciò a cui bisogna prestare particolare attenzione. Dopo tutto, non importa quanto sia buono l'ottimizzatore (l'ottimizzatore, non il tester), se è terribilmente lento, tutti i suoi vantaggi svaniscono.

[Andrey Dik]

Proprio ora mi è venuto in mente un pensiero audace. Anche se, in effetti, perché non dovrebbe?

Sarò onorato di usare il mio UGA in MetaTrader 5 optimizer di MetaQuotes Software Corp. Sarà assolutamente gratuito, anche se non rifiuterò dei bonus, ovviamente.

UGA è semplice ed efficiente. Molto flessibile nelle impostazioni. È possibile inserire tre modelli di impostazioni nel tester - "Rough", "Medium" e "Fine", e anche visualizzare separatamente le impostazioni di Evans con un'indicazione "Se non sai esattamente per cosa ti serve, non cambiare nulla in queste impostazioni". Poi sarà possibile condurre l'ottimizzazione con il grado desiderato di ricerca dei dettagli - da un'approssimazione molto rapida alla ricerca finale esatta delle impostazioni ottimali di TC. Al momento, l'ottimizzatore integrato non permette di essere configurato in alcun modo.