Creazione di criteri personalizzati di ottimizzazione degli Expert Advisor

Introduzione

Il client terminal MetaTrader 5 offre un'ampia gamma di opportunità per l'ottimizzazione dei parametri dell’Expert Advisor. Oltre ai criteri di ottimizzazione inclusi nel tester di strategia, gli sviluppatori hanno l'opportunità di creare i propri criteri. Questo porta a un numero quasi illimitato di possibilità di test e ottimizzazione degli Expert Advisor. L'articolo descrive i modi pratici per creare tali criteri, sia complessi che semplici.

1. La revisione delle caratteristiche dello Strategy Tester

Questo argomento è stato discusso molte volte, quindi farò solo un elenco di articoli con le loro brevi descrizioni. Ti consiglio di familiarizzare con i seguenti materiali prima di leggere questo articolo.

• "I Fondamenti dei Testing in MetaTrader 5". Parla in dettaglio tutti gli aspetti tecnici del test di un Expert Advisor: le modalità di generazione dei tick, il funzionamento con i prezzi aperti e le barre M1. Descrive l'uso degli indicatori durante i test, l'emulazione delle variabili ambientali e la gestione degli eventi standard. Inoltre, parla delle basi del test multivaluta.
• "Guida al Test all'Ottimizzazione degli Expert Advisor in MQL5". Discute le domande di test e ottimizzazione dei parametri di input di un Expert Advisor. Descrive il processo di adattamento dei parametri, l'interpretazione dei risultati dei test e la selezione dei parametri migliori.
• "Utilizzo della Funzione TesterWithdrawal() per il Modeling dei Prelievi di Profitto". Descrive l'utilizzo della funzione TesterWithdrawal per modellare i prelievi di denaro da un conto nello strategy tester. Inoltre, mostra come questa funzione influisca sull'algoritmo di calcolo dei drawdown azionari nello strategy tester.
  

E, naturalmente, all'inizio devi familiarizzare con la documentazione fornita con il client terminal.

2. I criteri di ottimizzazione incorporati nello Strategy Tester

Se guardi nella documentazione, troverai la seguente descrizione: Il criterio di ottimizzazione è un certo fattore il cui valore definisce la qualità di un set di parametri testati. Più alto è il valore del criterio di ottimizzazione, migliore è il risultato del test con l'insieme di parametri considerato.

Qui dobbiamo fare osservazione importante: un criterio di ottimizzazione può essere utilizzato solo nella modalità di ottimizzazione dell'algoritmo genetico. È chiaro che quando si esaminano tutte le possibili combinazioni di valori dei parametri, non può esserci alcun fattore per la scelta dei parametri ottimali di un Expert Advisor. L'altro aspetto è che possiamo salvare i risultati dei test e quindi elaborarli per trovare una combinazione ottimale di parametri.

Come scritto nella documentazione, lo strategy tester include i seguenti criteri di ottimizzazione da utilizzare con l'algoritmo genetico:

• Saldo massimo — il valore più elevato del saldo;
• Saldo + Fattore di profitto massimo - il valore più alto del prodotto del saldo e il fattore di profitto;
• Saldo + Massimo payoff previsto - il valore del prodotto del saldo e il payoff previsto;
• Saldo + Drawdown minimo - in questo caso vengono presi in considerazione il valore del saldo e il livello di drawdown: (100% - Drawdown)*Saldo;
• Saldo + fattore di recupero massimo - il prodotto del saldo e il fattore di recupero;
• Saldo + Indice di Sharpe massimo - il valore del prodotto di saldo e il Indice di Sharpe;
• Personalizzazione massima - Criterio personalizzato di ottimizzazione. Il criterio di ottimizzazione qui rappresenta il valore della funzione OnTester() nell’Expert Advisor. Questo parametro consente di utilizzare qualsiasi valore personalizzato per l'ottimizzazione dell'Expert Advisor.

È possibile selezionare un criterio di ottimizzazione nella scheda Impostazioni dello strategy tester come mostrato nella fig.1:

Fig.1. Scelta del criterio di ottimizzazione per l’Expert Advisor

Il criterio di personalizzazione massima, l'ultimo della lista, è il più interessante per noi e il suo utilizzo è oggetto di questo articolo.

3. Creazione di criteri di ottimizzazione personalizzati

La prima cosa da fare è dare all'utente la possibilità di una combinazione libera di parametri (non limitati a quelli mostrati in fig.1, ma personalizzati) che vengono calcolati dallo strategy tester dopo ogni esecuzione di un Expert Advisor.

Ad esempio, è interessante la seguente variante: Saldo massimo + Drawdown minimo + Numero di operazioni : più operazioni ci sono, più affidabile è il risultato. Oppure il seguente, Saldo massimo + Drawdown minimo + Fattore di profitto massimo. Naturalmente, ci sono molte altre combinazioni interessanti che non sono incluse nelle impostazioni dello strategy tester.

Chiamiamo queste combinazioni di criteri semplici criteri di ottimizzazione.

Ma quei criteri non sono sufficienti per fare una stima affidabile di un sistema di trading. Se guardiamo dal punto di vista del concetto di trading, ovvero realizzare un profitto con un rischio minimo, possiamo assumere il seguente criterio: possiamo ottimizzare i parametri per ottenere una curva di equilibrio più liscia con una deviazione minima dei risultati di operazioni separate dalla retta.

Chiamiamo questo criterio criterio di ottimizzazione per curva di equilibrio.

Il prossimo criterio di ottimizzazione che useremo è il coefficiente di sicurezza di un sistema di trading. Questo coefficiente è descritto nell'articolo "Be In-Phase". Caratterizza la corrispondenza di un sistema di trading al mercato; questo è ciò che dobbiamo scoprire durante l'ottimizzazione dei parametri. Chiamiamolo criterio di ottimizzazione per il coefficiente di sicurezza di un sistema di trading (CSTS).

Inoltre, diamo il consenso di combinare liberamente i criteri descritti.

4. La funzione OnTester()

Prima di scrivere le parti di codice, diamo un'occhiata all'organizzazione dell'utilizzo dei criteri personalizzati di ottimizzazione EA nello strategy tester.

La funzione predefinita OnTester() è destinata alla creazione di criteri di ottimizzazione personalizzati. Viene chiamato automaticamente alla fine di ogni passaggio di test di un Expert Advisor entro un intervallo di tempo specificato. Questa funzione viene chiamata subito prima della chiamata della funzione OnDeinit().

Ancora una volta, fai attenzione perché per utilizzare la funzione OnTester() devi abilitare la modalità di ottimizzazione dell'algoritmo di base genetica veloce come mostrato in fig.1.

Questa funzione ha il doppio formato del valore restituito, che viene utilizzato per l'ottimizzazione nello strategy tester.

Dai un'occhiata ancora una volta alla documentazione:

Nell'ottimizzazione genetica viene applicato l'ordinamento discendente ai risultati entro una generazione. Cioè, dal punto di vista del criterio di ottimizzazione, i risultati migliori sono quelli con valori maggiori. In tale ordinamento, i valori peggiori sono posizionati all'estremità e successivamente scartati e non partecipano alla formazione della prossima generazione.

Pertanto, quando si crea un criterio di ottimizzazione personalizzato, è necessario ottenere un valore integrale che verrà utilizzato per la stima del trading dell'Expert Advisor. Maggiore è il valore, migliore è il trading dell'Expert Advisor.

5. Scrivere un Expert Advisor sperimentale

Ora è il momento di creare un Expert Advisor che ottimizzeremo nello strategy tester. In questo caso, i requisiti principali sono essere semplici e veloci per non risparmiare molto tempo per la procedura di ottimizzazione di routine. Inoltre, è auspicabile che l'Expert Advisor non sia molto redditizio.

Prendiamo l'Expert Advisor descritto nell'articolo "Several Ways of Finding a Trend in MQL5" come sperimentale e miglioriamolo. In particolare, l'EA si basa sul "fan" di tre medie mobili. Il miglioramento consiste nell'eliminare l'utilizzo dell'indicatore per aumentare la velocità di funzionamento e spostare la parte di calcolo del codice all'interno dell'EA stesso. Ciò consente di aumentare significativamente la velocità dei test (quasi tre volte in un intervallo di due anni).

La parte dell'impostazione dei parametri di input è semplice:

input double Lots = 0.1; 
input int  MA1Period = 200; // period of the greatest moving average
input int  MA2Period = 50;  // period of the medium moving average
input int  MA3Period = 21;  // period of the smallest moving average

I periodi delle medie mobili sono ciò che ottimizzeremo.

La struttura e il funzionamento dell'Expert Advisor sono descritti in dettaglio nell'articolo sopra menzionato, quindi saltiamolo qui. L'innovazione principale è il gestore dell'evento di completamento di un altro test superato: la funzione OnTester(). Attualmente è vuoto e restituisce il controllo.

//---------------------------------------------------------------------
//  The handler of the event of completion of another test pass:
//---------------------------------------------------------------------
double OnTester()
{
  return(0.0);
}

Il file dell'EA, FanExpert.mq5, è allegato a questo articolo. Possiamo assicurarci che sia identico a FanTrendExpert.mq5 EA dal punto di vista delle operazioni eseguite. Il controllo dell'esistenza e della direzione di un segnale viene eseguito all'apertura di una nuova barra su un grafico.

Per ottenere il risultato del test calcolato alla fine di ogni passaggio, viene utilizzato il TesterStatistics(); restituisce il valore statistico richiesto calcolato a seguito del test. Può essere chiamato solo dalla funzione OnTester() e OnDeinit(), altrimenti il risultato è indefinito.

Ora aggiungiamo un criterio di ottimizzazione personalizzato. Supponiamo di dover trovare risultati ottimali sulla base di un valore massimo di fattore di recupero. Per farlo, abbiamo bisogno di conoscere i valori del prelievo massimo del saldo in denaro e l'utile lordo alla fine del test. Il fattore di recupero è calcolato come divisione dell'utile sul prelievo massimo.

È fatto solo come esempio, poiché il fattore di recupero è già incluso nell'elenco dei risultati statistici calcolati del test.

Per farlo, aggiungi questo semplice codice alla funzione OnTester():

//---------------------------------------------------------------------
//  The handler of the event of completion of another test pass:
//---------------------------------------------------------------------
double OnTester()
{
  double  profit = TesterStatistics(STAT_PROFIT);
  double  max_dd = TesterStatistics(STAT_BALANCE_DD);
  double  rec_factor = profit/max_dd;

  return(rec_factor);
}

Il controllo per lo zero divide è escluso dal codice per renderlo più semplice. Poiché il drawdown massimo può essere pari a zero, questo controllo deve essere effettuato in un vero Expert Advisor.

Ora, creiamo il criterio menzionato sopra: Saldo massimo + Drawdown minimo + Numero di operazioni - Saldo + Drawdown minimo + Numero di operazioni.

Per farlo, cambia la funzione OnTester() nel modo seguente:

double OnTester()
{
  double  param = 0.0;

//  Balance max + min Drawdown + Trades Number:
  double  balance = TesterStatistics(STAT_PROFIT);
  double  min_dd = TesterStatistics(STAT_BALANCE_DD);
  if(min_dd > 0.0)
  {
    min_dd = 1.0 / min_dd;
  }
  double  trades_number = TesterStatistics(STAT_TRADES);
  param = balance * min_dd * trades_number;

  return(param);
}

Qui prendiamo un valore opposto al drawdown supponendo che le altre condizioni siano uguali, perché minore è il drawdown, migliore è la situazione. Esegui l'ottimizzazione dell'EA FanExpert con il criterio di ottimizzazione creato dal parametro MA1Period utilizzando l'intervallo 2009.06.01 - 2011.06.03 e l'intervallo di tempo Н1. Imposta l'intervallo di valori della media mobile da 100 a 2000.

Al termine dell'ottimizzazione otterrai la seguente tabella di valori ordinati per i migliori parametri:

Fig. 2. I migliori risultati di ottimizzazione con il criterio Saldo massimo + Drawdown minimo + Numero di operazioni

I migliori parametri sono elencati qui (dalla colonna Risultato).

Ora, diamo un'occhiata ai parametri peggiori:

Fig. 3. I peggiori parametri di ottimizzazione secondo il criterio Saldo massimo + Drawdown minimo + Numero di operazioni

Confrontando due tabelle, puoi vedere che il drawdown e il profitto sono considerati insieme al numero di operazioni, ovvero il nostro criterio di ottimizzazione funziona. Inoltre, possiamo vedere il grafico di ottimizzazione (lineare):

Fig. 4. Il grafico di ottimizzazione per il criterio Saldo massimo + Drawdown minimo + Numero di operazioni

L'asse orizzontale visualizza il parametro ottimizzato e quello verticale mostra il criterio di ottimizzazione. Possiamo vedere il massimo netto del criterio impostato; si trova all'interno della gamma di periodi 980-1200.

Dovresti capire e ricordare che si tratta dell'ottimizzazione genetica dei parametri, non della ricerca completa. Ecco perché le tabelle riportate in fig.2 e fig.3 contengono i parametri più "vitali" che hanno superato la selezione naturale in diverse generazioni. Probabilmente, alcune varianti di successo sono state scartate.

La curva equilibrio/patrimonio netto per il periodo 1106 si presenta come segue:

Fig. 5. La curva equilibrio/patrimonio per il Periodo MA1 = 1106 periodo

6. Creazione di classi di criteri di ottimizzazione personalizzati

Quindi, abbiamo imparato come creare e utilizzare semplici criteri di ottimizzazione. Ora, facciamo una lezione per semplificare il loro utilizzo negli Expert Advisor. Uno dei requisiti principali per tale classe è la velocità di funzionamento oltre alla praticità d'uso. I calcoli dei criteri di ottimizzazione devono essere eseguiti rapidamente, altrimenti si attenderanno a lungo i risultati.

MetaTrader 5 consente di utilizzare la tecnologia di calcolo cloud per l'ottimizzazione. Si tratta di un enorme passo avanti, poiché l'elaborazione di un gran numero di parametri richiede una potenza di calcolo gigantesca. Quindi, per sviluppare la nostra classe utilizzeremo le soluzioni più semplici e veloci, anche se non molto eleganti dal punto di vista della programmazione.

Per lo sviluppo utilizzeremo le classi standard di organizzazione dei dati che vengono consegnate insieme al client terminal.

Prima di tutto, classifichiamo i tipi di risultati statistici calcolati dei test:

• Tipo float o intero con la diretta proporzionalità tra i valori del risultato del test e il criterio di ottimizzazione.

In altre parole, maggiore è il valore del risultato del test, migliore e maggiore è il valore del criterio di ottimizzazione. Un esempio lampante di tale risultato del test è il Profitto lordo alla fine del test STAT_PROFIT. Il valore ha il formato floating e può variare da infinito negativo (in realtà è limitato dal valore del deposito) a infinito positivo.

Un altro esempio del risultato di test di questo tipo è il Numero di operazioni STAT_TRADES. In genere, maggiore è il numero di operazioni, più affidabile è il risultato dell'ottimizzazione. Il valore ha il formato intero e può variare da zero a infinito positivo.

• Tipo float o intero con proporzionalità inversa tra i valori del risultato del test e il criterio di ottimizzazione.

In altre parole, minore è il valore del risultato del test, migliore e maggiore è il valore del criterio di ottimizzazione. Un esempio di tale risultato del test è il prelievo massimo del saldo in denaro STAT_BALANCE_DD, così come qualsiasi altro prelievo.

Per ottenere questo tipo di risultato di test, prenderemo un valore inverso per il calcolo del valore del criterio di ottimizzazione. Ovviamente, dobbiamo implementare il controllo per lo zero divide per evitare l'errore corrispondente.

La classe base per la creazione dei criteri personalizzati di ottimizzazione TCustomCriterion è molto semplice. Il suo scopo è la determinazione della funzionalità di base. Ecco come sembra:

class TCustomCriterion : public CObject
{
protected:
  int     criterion_level;        // type of criterion

public:
  int   GetCriterionLevel();
  virtual double  GetCriterion();  // get value of the result of optimization
};

Il metodo virtuale TCustomCriterion::GetCriterion deve essere sovrascritto nelle classi ereditate. Questo è il metodo principale che restituisce il valore del risultato integrale del test di un Expert Advisor alla fine di ogni test superato.

Il membro della classe TCustomCriterion::criterion_level memorizza il tipo di criterio personalizzato inerente a questa istanza di classe. Verrà utilizzato ulteriormente per differenziare gli oggetti in base ai loro tipi.

Ora possiamo ereditare da esso tutte le classi necessarie per l'ottimizzazione.

La classe TSimpleCriterion è destinata alla creazione di un criterio personalizzato "semplice" che corrisponde a un risultato statistico specificato del test. La sua determinazione appare come segue:

class TSimpleCriterion : public TCustomCriterion
{
protected:
  ENUM_STATISTICS  stat_param_type;

public:
  ENUM_STATISTICS  GetCriterionType();     // get type of optimized stat. parameter

public:
  virtual double   GetCriterion(); // receive optimization result value
  TSimpleCriterion(ENUM_STATISTICS _stat); // constructor
};

Qui usiamo un costruttore con parametri; è implementato come segue:

//---------------------------------------------------------------------
//  Constructor:
//---------------------------------------------------------------------
TSimpleCriterion::TSimpleCriterion(ENUM_STATISTICS _stat)
:
stat_param_type( _stat )
{
  criterion_level = 0;
}

Questa nuova funzionalità nel linguaggio MQL5 è comoda da usare durante la creazione di istanze di classe. Inoltre, abbiamo sovrascritto il metodo virtuale TSimpleCriterion::GetCriterion, il quale viene utilizzato per ottenere il risultato dell'ottimizzazione alla fine di ogni passaggio del test. La sua implementazione è semplice:

//---------------------------------------------------------------------
//  Get the result of optimization:
//---------------------------------------------------------------------
double  TSimpleCriterion::GetCriterion()
{
  return(TesterStatistics(stat_param_type));
}

Come vedi, restituisce solo il risultato statistico corrispondente del test.

Il tipo successivo del criterio di ottimizzazione personalizzato "semplice" viene creato utilizzando la classe TSimpleDivCriterion. È destinato a criteri con proporzionalità inversa tra i valori del risultato del test e il criterio di ottimizzazione.

Il metodo TSimpleDivCriterion::GetCriterion ha il seguente aspetto:

//---------------------------------------------------------------------
//  Get value of the optimization result:
//---------------------------------------------------------------------
double  TSimpleDivCriterion::GetCriterion()
{
  double  temp = TesterStatistics(stat_param_type);
  if(temp>0.0)
  {
    return(1.0/temp);
  }
  return(0.0);
}

Questo codice non richiede alcuna descrizione aggiuntiva.

Altri due tipi di criteri di ottimizzazione personalizzati "semplici" vengono creati utilizzando le classi TSimpleMinCriterion e TSimpleMaxCriterion. Sono destinati alla creazione di criteri con valori limitati di risultato statistico dei test rispettivamente dal basso e dall'alto.

Possono essere utili nel caso in cui sia necessario scartare valori volutamente errati dei parametri durante l'ottimizzazione. Ad esempio, puoi limitare il numero minimo di operazioni, il prelievo massimo, ecc.

La descrizione della classe TSimpleMinCriterion appare come segue:

class TSimpleMinCriterion : public TSimpleCriterion
{
  double  min_stat_param;

public:
  virtual double  GetCriterion();    // receive optimization result value
  TSimpleMinCriterion(ENUM_STATISTICS _stat, double _min);
};

Qui usiamo il costruttore con due parametri. Il parametro _min imposta il valore minimo di un risultato statistico del test. Se un altro test supera l'ottenimento di un valore inferiore a quello specificato, il risultato viene scartato.

L'implementazione del metodo TSimpleMinCriterion ::GetCriterion è la seguente:

//---------------------------------------------------------------------
//  Get value of the optimization result:
//---------------------------------------------------------------------
double  TSimpleMinCriterion::GetCriterion()
{
  double  temp = TesterStatistics(stat_param_type);
  if(temp<this.min_stat_param)
  {
    return(-1.0);
  }
  return(temp);
}

La classe TSimpleMaxCriterion è realizzata in modo simile e non richiede alcuna descrizione aggiuntiva. Le altre classi dei criteri personalizzati "semplici" sono realizzate in modo simile a quelle sopra descritte; si trovano nel file CustomOptimisation.mqh allegato a questo articolo. Lo stesso principio può essere utilizzato per sviluppare qualsiasi altra classe da utilizzare nell'ottimizzazione.

Prima di utilizzare le classi descritte sopra, creiamo una classe contenitore per un'operazione più conveniente con l'insieme di criteri. A tale scopo utilizziamo anche le classi standard per l'organizzazione dei dati. Poiché abbiamo bisogno di una semplice elaborazione conseguente dei criteri, la classe più adatta è CARrayObj. Consente di organizzare un array dinamico di oggetti ereditati dalla classe CObject.

La descrizione della classe contenitore TCustomCriterionArray è molto semplice:

class TCustomCriterionArray : public CArrayObj
{
public:
  virtual double  GetCriterion( );  // get value of the optimization result
};

Ha un solo metodo: TCustomCriterionArray::GetCriterion, che restituisce il valore del criterio di ottimizzazione alla fine di ogni passaggio del test. La sua attuazione è la seguente:

double  TCustomCriterionArray::GetCriterion()
{
  double  temp = 1.0;
  int     count = this.Total();
  if(count == 0)
  {
    return(0.0);
  }
  for(int i=0; i<count; i++)
  {
    temp *= ((TCustomCriterion*)(this.At(i))).GetCriterion();
    if(temp <= 0.0)
    {
      return(temp);
    }
  }

  return(temp);
}

Una cosa a cui dovresti prestare attenzione: se incontri un valore negativo durante l'elaborazione dei criteri, l'ulteriore passaggio del ciclo diventa inutile. Inoltre, elimina la situazione in cui si ottiene un valore positivo come risultato della moltiplicazione di due valori negativi.

7. Utilizzo di classi di criteri di ottimizzazione personalizzati

Quindi, abbiamo tutto per utilizzare i criteri personalizzati "semplici" durante l'ottimizzazione degli Expert Advisor. Analizziamo la sequenza di passaggi per migliorare l'EA FanExpert "sperimentale":

• Aggiungi il file include che contiene la descrizione delle classi dei criteri personalizzati:

#include <CustomOptimisation.mqh>

• Aggiungi il puntatore all'oggetto della classe contenitore per l'utilizzo di criteri personalizzati:

TCustomCriterionArray*  criterion_Ptr;

• Inizializza il puntatore all'oggetto della classe contenitore per l'utilizzo di criteri personalizzati:

  criterion_array = new TCustomCriterionArray();
  if(CheckPointer(criterion_array) == POINTER_INVALID)
  {
    return(-1);
  }

Viene eseguito nella funzione OnInit. In caso di creazione dell'oggetto non riuscita, restituire con un valore negativo. In questo caso, l'Expert Advisor interrompe il funzionamento.

• Aggiungi i criteri di ottimizzazione richiesti all'Expert Advisor:

  criterion_Ptr.Add(new TSimpleCriterion(STAT_PROFIT));
  criterion_Ptr.Add(new TSimpleDivCriterion(STAT_BALANCE_DD));
  criterion_Ptr.Add(new TSimpleMinCriterion(STAT_TRADES, 20.0));

In questo caso, abbiamo deciso di ottimizzare l'EA in base al profitto massimo, al drawdown minimo e al numero massimo di operazioni. Inoltre, scartiamo i set di parametri esterni dell'Expert Advisor che risultano in meno di venti operazioni.

• Aggiungi la chiamata corrispondente alla funzione OnTester:

  return(criterion_Ptr.GetCriterion());

• Nella funzione OnDeinit, aggiungi il codice per l'eliminazione dell'oggetto contenitore:

  if(CheckPointer(criterion_Ptr) == POINTER_DYNAMIC)
  {
    delete(criterion_Ptr);
  }

Questo è tutto per quanto riguarda l'ottimizzazione. Esegui l'ottimizzazione e assicurati che tutto funzioni come previsto. Per farlo, imposta i parametri nella scheda Impostazioni del tester di strategia come mostrato nella figura seguente:

Fig.6. Impostazioni dello strategy tester

Impostare l'intervallo di ottimizzazione dei parametri di input nella scheda parametri di input del tester di strategia come mostrato nella fig.7:

Fig.7. Parametri di input ottimizzati

Utilizzare gli agenti "cloud" per l'ottimizzazione. Per farlo, imposta i seguenti parametri nella scheda Agenti:

Fig.8. Parametri degli agenti di test

Ora fai clic sul pulsante Start (fig.6) e attendi il completamento dell'ottimizzazione. Quando si utilizza la tecnologia di calcolo "cloud", l'ottimizzazione viene eseguita abbastanza velocemente. Alla fine, otteniamo i seguenti risultati di ottimizzazione secondo i criteri specificati:

Fig.9. Risultati di ottimizzazione

Il nostro Expert Advisor "sperimentale" è stato ottimizzato con successo. Ci sono voluti 13 minuti per ottimizzare utilizzando gli agenti "cloud". L'EA per la verifica di questo criterio si trova nel file FanExpertSimple.mq5 allegato all'articolo.

8. Creazione di una classe di un criterio di ottimizzazione personalizzato sulla base dell'analisi della curva di equilibrio

La base per la creazione di questa classe è l'articolo "Controlling the Slope of Balance Curve During Work of an Expert Advisor". L'idea di questo criterio di ottimizzazione è di rendere la linea di equilibrio il più vicino possibile a una linea retta. Il grado di vicinanza a una linea retta sarà stimato dal valore della deviazione standard dei risultati di trading da essa. L'equazione di una linea retta verrà calcolata per la linea di regressione tracciata dai risultati delle operazioni nello strategy tester.

Per scartare le curve con saldo negativo risultante, impostare limiti aggiuntivi: il profitto risultante deve essere maggiore di un valore specificato e il numero di operazioni non deve essere inferiore a un valore specificato.

Pertanto, il nostro criterio di ottimizzazione sarà inversamente proporzionale al valore della deviazione standard dei risultati delle operazioni di trading dalla retta considerando i limiti del profitto risultante e il numero di operazioni.

Per implementare il criterio di ottimizzazione sulla base della curva di equilibrio abbiamo bisogno della classe TBalanceSlope dell'articolo citato sopra. Lo cambieremo: usa i costruttori con i parametri (per comodità) e aggiungi il calcolo della deviazione standard al calcolo della regressione lineare. Questo codice si trova nel file BalanceSlope.mqh allegato all'articolo.

La sequenza dei passaggi per l'aggiunta di questo criterio di ottimizzazione all'Expert Advisor è la stessa descritta sopra. Ora, i criteri di ottimizzazione sono i seguenti:

criterion_Ptr.Add(new TBalanceSlopeCriterion(Symbol( ), 10000.0));

Oltre al criterio della curva di equilibrio, possiamo aggiungere altri criteri da noi sviluppati. Ai lettori lascio la possibilità di sperimentare diversi set di parametri statistici di test.

Eseguiamo l'ottimizzazione in base ai criteri impostati. Per ottenere più operazioni, esegui l'ottimizzazione utilizzando l’intervallo di tempo H4, il periodo 2010.01.01 - 2011.01.01 e il simbolo EURUSD. Otterremo una serie di risultati:

Fig.10. Il risultato dell'ottimizzazione della curva di equilibrio

Ora, abbiamo bisogno di stimare la qualità dell'ottimizzazione. Penso che il criterio principale sia il lavoro dell'Expert Advisor al di fuori del periodo di ottimizzazione. Per verificarlo, eseguire un singolo test entro il periodo 2010.01.01-2011.06.14.

Confronta due risultati (che hanno quasi lo stesso profitto risultante) dall'insieme dei parametri ottimali: il miglior risultato con un risultato medio. I risultati al di fuori del periodo di ottimizzazione sono separati dalla linea rossa:

Fig.11. Il miglior risultato dell'ottimizzazione

In generale, il comportamento della curva non è peggiorato. La redditività è leggermente diminuita da 1,60 a 1,56.

Fig.12. Il risultato medio del test

L'Expert Advisor non è redditizio al di fuori del periodo di ottimizzazione. La redditività è diminuita significativamente da 2,17 a 1,75.

Si può quindi concludere che l'ipotesi di correlazione della curva di equilibrio con la durata di funzionamento dei parametri ottimizzati ha ragione di esistere. Certamente, non possiamo escludere la variante quando un risultato accettabile dell'utilizzo di questo criterio è irraggiungibile per un Expert Advisor. In questo caso, dobbiamo eseguire alcune analisi ed esperimenti aggiuntivi.

Probabilmente, per questo criterio dobbiamo utilizzare il periodo massimo possibile (ma ragionevole). L'Expert Advisor per la verifica di questo criterio è nel file FanExpertBalance.mq5 allegato all'articolo.

9. Creazione di una classe di un criterio di ottimizzazione personalizzato sulla base del coefficiente del sistema di scambio sicuro (CSTS)

Come descritto nell'articolo "Be in-Phase", il coefficiente del sistema di trading sicuro (CSTS) viene calcolato utilizzando la seguente formula:

CSTS = Avg.Win / Avg.Loss ((110% - %Win) / (%Win-10%) + 1)

dove:

• Avg.Win - il valore medio di un’operazione redditizia;
• Avg.Loss - il valore medio di un’operazione perdente;
• %Win - la percentuale di operazioni redditizie;

Se il valore CSTS è inferiore a 1, il sistema di negoziazione è nella zona di alto rischio di trading; valori ancora più piccoli indicano la zona di negoziazione non redditizia. Maggiore è il valore del CSTS, migliore è il sistema di trading adatto al mercato e redditizio.

Tutti i valori statistici richiesti per il calcolo del CSTS sono calcolati nel test di strategia dopo ogni superamento del test. Resta da creare la classe TTSSFCriterion ereditata da TCustomCriterion e implementare in essa il metodo GetCriterion(). L'implementazione di questo metodo nel codice è la seguente:

double  TTSSFCriterion::GetCriterion()
{
  double  avg_win = TesterStatistics(STAT_GROSS_PROFIT) / TesterStatistics(STAT_PROFIT_TRADES);
  double  avg_loss = -TesterStatistics(STAT_GROSS_LOSS) / TesterStatistics(STAT_LOSS_TRADES);
  double  win_perc = 100.0 * TesterStatistics(STAT_PROFIT_TRADES) / TesterStatistics(STAT_TRADES);

//  Calculated safe ratio for this percentage of profitable deals:
  double  teor = (110.0 - win_perc) / (win_perc - 10.0) + 1.0;

//  Calculate real ratio:
  double  real = avg_win / avg_loss;

//  CSTS:
  double  tssf = real / teor;

  return(tssf);
}

Suppongo che brevi periodi siano adatti a questo criterio di ottimizzazione. Tuttavia, per evitare l'adattamento, dobbiamo considerare meglio i risultati che sono nel mezzo dei risultati dell'ottimizzazione.

Diamo ai nostri lettori la possibilità di eseguire l'ottimizzazione da soli. L'Expert Advisor per la verifica di questo criterio si trova nel file FanExpertTSSF.mq5 allegato all'articolo.

Conclusione

Ad ogni modo, devi ammettere che una soluzione così semplice per l'implementazione della possibilità di creare criteri di ottimizzazione personalizzati (utilizzando un singolo tasso integrale) è quasi perfetta rispetto ad altre varianti. Consente di elevare a un livello superiore l'asticella dello sviluppo di sistemi di trading solidi. L'utilizzo della tecnologia "cloud" riduce significativamente la limitazione delle ottimizzazioni condotte.

Ulteriori modi di evoluzione possono essere collegati a criteri sostanziati, matematicamente e statisticamente descritti in diverse fonti di informazione. Lo strumento per farlo lo abbiamo.