Discussione sull’articolo "Sistemi di Trading Adattivi e loro utilizzo nel Client MetaTrader 5" - pagina 3

Nuovo commento
 
Quantum:

Cara Forexistence,

>>Caro

Hai risposto alla tua domanda :)

>> Si, forse in parte ho risposto io stesso alla mia domanda, e vorrei solo una conferma o opinioni diverse.

Hai ragione, ci sono due modi per modificare le condizioni di trading, da un lato possiamo aggiungere nuove condizioni alla strategia CStrategyMA (ma otterremo una nuova strategia, diversa da quella iniziale), l'altro modo è quello di creare una nuova classe (per esempio, CStrategyMA34) e aggiungere ulteriori condizioni di acquisto/vendita lì.

Naturalmente, è necessario includere il file con la nuova strategia e aggiungere queste nuove strategie alla funzione Expert_OnInit della classe CAdaptiveStrategy:

Il secondo modo è migliore: si possono aggiungere molte strategie e le loro varianti.

Non è necessario rimuovere le istanze della classe CStrategyMA (se ne avete), non guarderemo nelle loro sandbox e i loro risultati saranno negativi.

Il mercato ci aiuterà a determinare la migliore strategia nell'elenco delle strategie incluse in m_all_strategies.

>> Ok, ho capito il punto come immaginavo.

Ma la domanda, ora, è un'altra... Sto lavorando per "inputizzare" l'EA al fine di lavorare con le ottimizzazioni.

Quindi per esempio intendo pezzi di codice come questo:

for(int i=0; i<RSIcicle; i++)
     {
      CStrategyRSI *t_StrategyRSI;
      t_StrategyRSI=new CStrategyRSI;
      if(t_StrategyRSI==NULL)
        {
         delete m_all_strategies;
         Print("Error of creation of object of the CStrategyRSI type");
         return(-1);
        }

      

       ////////////////////////// PLEASE LOOK AT THIS FOLLOWING PIECE OF CODE ///////////////////////
   //impostare il periodo per ogni strategia
    int period=Trsi+Drsi*i;
    
    ENUM_TIMEFRAMES RSItempoframe=RSItempoframe_in; // SET TIMEFRAME (enum), INPUT, FOR STRATEGY 
    ENUM_APPLIED_PRICE RSIappprice=RSIappprice_in;  // SET APPPLIED PRICE (enum), INPUT, FOR STRATEGY
    
    int RSIvarA_root=RSIvarA_in;
    int RSIvarB_root=RSIvarB_in;
    
      // inizializzazione della strategia
      t_StrategyRSI.Initialization(period,true,RSItempoframe,RSIappprice,RSIvarA_root,RSIvarB_root);
      /////////////////////////////////////////////////////////////////////////////////////////////


      // impostare i dettagli della strategia
      t_StrategyRSI.SetStrategyInfo(_Symbol,"[RSI_"+IntegerToString(period)+"]",period,"Relative Strenght Index "+IntegerToString(period));
      
      if(t_StrategyRSISet_Stops_ ==true) {
      t_StrategyRSI.Set_Stops(tSMSSone,tSMSStwo); //3500,1000);
      }

dove (dichiarazioni) : 

//+------------------------------------------------------------------+
//|                                            CAdaptiveStrategy.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"

#include <Arrays\ArrayObj.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <CStrategyMA.mqh>
#include <CStrategyMAinv.mqh>
#include <CStrategyStoch.mqh>

#include <CStrategyRSI.mqh>   // AGGIUNTA DI UNA STRATEGIA

/*
......
*/

input int Trsi=0, Drsi=10, RSIcicle=10;

input ENUM_TIMEFRAMES RSItempoframe_in= PERIOD_CURRENT;
input ENUM_APPLIED_PRICE RSIappprice_in= PRICE_CLOSE;

input int RSIvarA_in=60, RSIvarB_in=40;




input int tSMSSone=3500, tSMSStwo=1000;


input bool t_StrategyRSISet_Stops_=false;

/*
...
*/

//+------------------------------------------------------------------+
//| Class CAdaptiveStrategy                                          |

/*
...
*/

e dove le variabili:

RSItempoframe, RSIappprice, RSIvarA_root, RSIvarB_root

lavorare in collaborazione con

//+------------------------------------------------------------------+
//|                                                  CStrategyMA.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#include <CSampleStrategy.mqh>

input int mval=0, mval1=1, mval2=2, mval3=3, mval4=4, mvalVar=0, mvalFix=0,

          mvalVar2=0, mvalFix2=0;
          

//+------------------------------------------------------------------+
//| Class CStrategyMA for implementation of virtual trading          |
//| by the moving average strategy                                   |
//+------------------------------------------------------------------+
class CStrategyRSI : public CSampleStrategy
  {
protected:
   int               m_handle;     // maniglia dell'indicatore della media mobile (iMA)
   int               m_period;     // periodo dell'indicatore della media mobile
   double            m_values[];   // array per memorizzare il valore dell'indicatore





   int               RSIvarA, RSIvarB; 
   
   ENUM_TIMEFRAMES   m_timeframe;
   ENUM_APPLIED_PRICE m_appprice;



   
public:
   // inizializzazione della strategia // Notifica degli input aggiunti


   int               Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
                                    ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);


   // deinizializzazione della strategia
   int               Deinitialization();
   // verifica delle condizioni di trading e apertura di posizioni virtuali
   bool              CheckTradeConditions();
  };
//+------------------------------------------------------------------+
//| Method of initialization of the strategy                         |
//+------------------------------------------------------------------+



int CStrategyRSI::Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
                                 ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root)


  {
   //set period for the RSI     (was //set period for the moving average)
   m_period=period;
      
   m_timeframe=RSItempoframe;
   m_appprice=RSIappprice;
   
   RSIvarA=RSIvarA_root;
   RSIvarB=RSIvarB_root;

/*
...
*/

/creare l'handle dell'indicatore 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

//+------------------------------------------------------------------+
//| checking the trade conditions and opening the virtual positions  |
//+------------------------------------------------------------------+
bool CStrategyRSI::CheckTradeConditions()
  {
   RecalcPositionProperties(m_position);
  // double p_close;

/*
...
*/
   
     if(CopyRates(_Symbol,m_timeframe,0,3,m_rates)<0)

{
      Alert("Error of copying history data - error:",GetLastError(),"!!");
      return(false);
     }
// Copia il prezzo di chiusura attuale della barra precedente (questa è la barra 1)
  // p_close=m_rates[1].close;  // close price of the previous bar          

   if(CopyBuffer(m_handle,0,0,3,m_values)<0)
     {
      Alert("Error of copying buffers of the Moving Average indicator - error number:",GetLastError());
      return(false);
     }

/*
...
*/

// Condizione di acquisto 1: RSI sale
   bool buy_condition_1=(m_values[mval]>m_values[mval1]) && (m_values[mval1]>m_values[mval2]);  // AVVISO di variabili intere nel [] dell'array

// Condizione di acquisto 2: il prezzo della chiusura precedente è superiore alla MA
 //  bool buy_condition_2=(p_close>m_values[1]);


     bool buy_condition_2=(m_values[mval+mvalVar+mvalFix]>RSIvarA);

/*
... ecc.
*/

La mia domanda è:

E' opportuno modificare il codice in modo da avere una variabile di input a livello di classfile della strategia (file di inclusione cioè CStrategyRSI.mqh), oppure con la corretta struttura/connessioni/alberi a livello di altre classi/inclusi (CAdaptiveStrategy.mqh)?

In altre parole, per influenzare il sistema centrale dell'idea di EA, con l'aggiunta di alcuni parametri di input per i test di ottimizzazione,

dovrei fare qualcosa del genere: (variabili di input in CAdaptiveStrategy.mqh)

/*
...
*/

class CStrategyRSI : public CSampleStrategy
  {
protected:
   int               m_handle;     // handle of the Moving Average (iMA) indicator
   int               m_period;     // period of the Moving Average indicator
   double            m_values[];   // array for storing the value of indicator
   int               RSIvarA, RSIvarB;
   
   ENUM_TIMEFRAMES   m_timeframe;
   ENUM_APPLIED_PRICE m_appprice;
   
public:
   // initialization of strategy
   int               Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
                                    ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);

/*
...
*/ 

//set period for the RSI     (was //set period for the moving average)
   m_period=period;
      
   m_timeframe=RSItempoframe;
   m_appprice=RSIappprice;
   
   RSIvarA=RSIvarA_root;
   RSIvarB=RSIvarB_root;

/*
...
*/

/creare l'handle dell'indicatore 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

oppure un'altra cosa del genere: (variabili di input in CSampleRSI.mqh)

/*
...
*/

input   int               RSIvarA_root, RSIvarB_root;
   
input  ENUM_TIMEFRAMES  RSItempoframe=PERIOD_M5;
input   ENUM_APPLIED_PRICE RSIappprice=PRICE_CLOSE;
   

class CStrategyRSI : public CSampleStrategy
  {
protected:
   int               m_handle;     // maniglia dell'indicatore della media mobile (iMA)
   int               m_period;     // periodo dell'indicatore della media mobile
   double            m_values[];   // array per memorizzare il valore dell'indicatore

  ENUM_TIMEFRAMES   m_timeframe;
  ENUM_APPLIED_PRICE m_appprice;

int               RSIvarA, RSIvarB;

public:
   // inizializzazione della strategia
   int               Initialization(int period,bool virtual_trade_flag);  // NOTARE IL CODICE ORIGINALE

/*
...
*/ 

//set period for the RSI     (was //set period for the moving average)
   m_period=period;
      
   m_timeframe=RSItempoframe;
   m_appprice=RSIappprice;
   
   RSIvarA=RSIvarA_root;
   RSIvarB=RSIvarB_root;

/*
...
*/

/creare l'handle dell'indicatore 
   
   m_handle=iRSI(_Symbol,m_timeframe,m_period,m_appprice);

/*
...
*/

In altre parole, le variabili di input dovrebbero essere usate nel file di inclusione della strategia, prima della dichiarazione della classe (esempio2, proprio questo qui sopra) o le variabili di input dovrebbero

derivare dal ciclo "for" della strategia CAdaptive e dovrebbero prendere in considerazione l'inizializzazione di tutte le classi e i parametri di input? (Intendo per questo primo esempio (appena sopra questo codice) :)

public:
// inizializzazione della strategia
int Initialization(int period,bool virtual_trade_flag,ENUM_TIMEFRAMES RSItempoframe,
ENUM_APPLIED_PRICE RSIappprice,int RSIvarA_root, int RSIvarB_root);

In che modo il nucleo del sistema sarà influenzato diversamente, se si utilizzano le variabili di input nel fileStrategyRSI.mqh o nel file CAdaptiveStrategy.mqh?

Suppongo che, se si tratta solo di testare, posso usare le variabili di input nel file CStrategyRSI.mqh, se invece voglio sia testare che influenzare il core dell'EA.

influenzare il sistema centrale dell'idea di EA (il sistema adattivo e il simulatore di trading, l'include del trader virtuale) dovrei dichiarare

variabili di input non nell'include della strategia, ma nel file dell'include adattivo, con tutte le connessioni e le chiamate appropriate

di input/output dell'inizializzazione e della dichiarazione di classi/funzioni?

Giusto?

Spero che tu abbia capito il mio punto di vista.

Tnkx

 
forexistence:

....Ma la domanda, ora, è un'altra... Sto lavorando per "immettere" l'EA al fine di lavorare con le ottimizzazioni....

Se vuoi trovare i migliori parametri della strategia usando l'opzione di ottimizzazione nello Strategy Tester, è meglio riscrivere l'EA con qualche strategia particolare e giocarci.

Il concetto di EA adattivo e la sua struttura non consentono di ottimizzare i suoi parametri direttamente nello Strategy Tester, perché non c'è nessuna strategia e nessun parametro particolare da ottimizzare.

Quando utilizziamo l'EA adattivo nel trading o lo testiamo nello Strategy Tester, abbiamo un sistema di trading come un insieme di segnali provenienti da diverse strategie. In altre parole, il Tester non può accedere alle sandbox virtuali che abbiamo creato e non ne sa nulla.

Se si desidera utilizzare i parametri di input per configurare i parametri delle strategie di trading da utilizzare, è meglio utilizzare i file, che consentono di configurare i parametri e l'elenco delle strategie di trading.

 
Quantum:

Se si desidera trovare i parametri migliori della strategia utilizzando l'opzione di ottimizzazione nel Tester di strategia, è meglio riscrivere l'EA con una particolare strategia e giocare con essa.

>> Ok, ho capito il punto. Non sarà un compito facile...

Il concetto di EA adattivo e la sua struttura non permettono di ottimizzare i suoi parametri direttamente nello Strategy Tester, perché non c'è nessuna strategia e nessun parametro particolare da ottimizzare.

>> Sì. L'EA è idealizzato per lavorare conparametri ancora ottimizzati per le strategie. Quello che ho capito è che utilizza strategie diverse in base a come/quale il mercato risponde (o viceversa da un altro punto di vista...).

Quando utilizziamo l'EA adattivo nel trading o lo testiamo nello Strategy Tester, abbiamo un sistema di trading come un insieme di segnali provenienti dalle diverse strategie. In altre parole, il Tester non può accedere alle sandbox virtuali che abbiamo creato e non ne sa nulla.

>> Ho capito questo concetto, ma non completamente.

Capisco che non ha senso far interagire il tester con le sandbox virtuali, non ha senso logico per il trading.

Il mio unico obiettivo era quello di far modificare l'EA, per poterlo usare con un addon: l'obiettivo di usare questo EA anche per ottimizzare i parametri, senza riscrivere un altro EA, o riscrivere tutte le strategie, o testare ogni strategia singolarmente. La mia idea era solo di "comodità" per la possibilità di ottimizzare i parametri, all'interno dello stesso EA, ma questa ottimizzazione non è destinata a lavorare con il commercio virtuale / sistema adattivo. Si tratta solo di avere la possibilità di ottimizzare i parametri delle strategie, utilizzando la stessa finestra di input dell'EA, e non di scrivere un altro EA per ogni strategia, ottenere i parametri ottimizzati e inserirli come valori fissi nel sistema di strategia adattiva. Spero che abbiate capito il mio punto di vista.

Se si desidera utilizzare i parametri di input per configurare i parametri delle strategie di trading da utilizzare, è meglio utilizzare i file, che consentono di configurare i parametri e l'elenco delle strategie di trading.

>> Di quali file stai parlando? ( Se vuoi usare i parametri di input per configurare i parametri delle strategie di trading da usare, è meglio usare i file ).

Stai parlando di usare CStrategyXXX.mqh o del fatto di scrivere un altro EA individuale per ogni strategia, ottimizzarlo e copiare i parametri come valori fissi in CStrategyXXX.mqh?

 

Are you talking about to use CStrategyXXX.mqh or the fact to write another individual EA for each strategy, optimize it, and copy the parameters as fixed values in CStrategyXXX.mqh?

Intendo dire che il contenitore della strategia può essere riempito secondo alcune impostazioni dell'EA adattivo.

Ad esempio, in Adaptive_Expert.Expert_OnInit() può essere caricato un file con le impostazioni dell'EA adattivo:

MA;3
MA;15
MA;25
Stoch;3;12;20
Stoch;3;15;30

Strategy1;Param1;Param2;
Strategy2;Param1;Param2;

Analizzando ogni riga, riconosce la strategia da includere e la aggiunge con i parametri corrispondenti specificati. È uno dei modi per configurare l'EA adattivo senza compilazioni. Per semplicità, non l'ho considerato nell'articolo.

Capisco che non ha senso far interagire il tester con sandbox virtuali, non ha senso logico il trading.

Il mio unico obiettivo era quello di far modificare l'EA, per poterlo utilizzare con un addon: l'obiettivo di utilizzare questo EA anche per ottimizzare i parametri, senza dover riscrivere un altro EA, o riscrivere tutte le strategie, o testare ogni strategia singolarmente. La mia idea era solo di "comodità" per la possibilità di ottimizzare i parametri, all'interno dello stesso EA, ma questa ottimizzazione non è destinata a lavorare con il commercio virtuale / sistema adattivo. Si tratta solo di avere la possibilità di ottimizzare i parametri delle strategie, utilizzando la stessa finestra di input dell'EA, e non di scrivere un altro EA per ogni strategia, ottenere i parametri ottimizzati e inserirli come valori fissi nel sistema di strategia adattiva. Spero che abbiate capito il mio punto di vista.

Esiste un modo per esaminare le sandbox. Lo si può fare indirettamente utilizzando lo Strategy Tester.

Supponiamo di voler riprodurre i risultati presentati nella figura 2 dell'articolo.

Abbiamo bisogno della versione di debug dell'EA adattivo adaptive-systems-mql5-sources-debug-en.zip (riporta le sandbox). Successivamente, compiliamo e apriamo Adaptive_Expert_Sample in Strategy Tester, selezioniamo EURUSD H1 dal 01.01.2010 al 20.08.2010 e avviamo il test. Le sandbox e i risultati della strategia adattiva saranno salvati in tester\files\equity_res.txt In questo modo è molto facile riprodurre tutte le figure.

L'analisi delle azioni/bilanci del trading virtuale vi permetterà di semplificare l'ottimizzazione.

 

Ciao a tutti,

Grazie per questo ottimo articolo, ora sto lavorando solo su un EA adattivo.

Tuttavia, non sono sicuro di dove inserire una funzione di trailing stop in questo tipo di EA.

Penso che tale funzione possa essere aggiunta nella parte CAdaptiveStrategy.mqh.

Qualcuno di voi potrebbe aiutarmi? Forse avete già sviluppato una funzione del genere?

Grazie mille in anticipo!

Cordiali saluti,

Patrick

 
Qualcuno ha una versione di Adaptive Trading che funzioni con gli esperti basati sulla classe OO Expert?
 
L'MQL5 ci offre enormi opportunità, che non molti della comunità del trading sono ancora in grado di apprezzare e ancor meno di utilizzare.
 
Grazie per l'ottimo articolo, ho pensato a come implementare un sistema adattivo, questo è un approccio che ho ideato ma che non ho ancora avuto il tempo di elaborare. Avete preso in considerazione l'utilizzo di una delle funzioni di backtesting integrate in combinazione con i dati live?
 

Non riesco a riprodurre i risultati riportati nell'articolo.

Ho scaricato i file sorgente, li ho compilati e li ho eseguiti sullo stesso timeframe (EURUSD H1, 04/01/2010 - 20/08/2010) e ho ottenuto un risultato diverso.

Ho usato i file di debug e ho controllato i risultati del trading virtuale ... i grafici delle azioni virtuali sono identici, ma le operazioni reali non corrispondono.

Senza un file di log delle operazioni reali è difficile capire perché le mie operazioni non corrispondono a quelle dell'articolo.

Qualche idea sul perché non corrispondano?

 
L'articolo è molto bello, ma la distrazione è dovuta al fatto che le persone cercano di riprodurre i risultati, invece di sfruttare e integrare le possibilità funzionali proposte. Ora la probabilità di creare un EA di trading automatico e semi-automatico completamente funzionale e redditizio è realizzata. Testare gli indicatori su larga scala, compilare i risultati ed estrarre i dati statistici degli indicatori in aggiunta alle statistiche conformazionali di tali dati e consentire all'EA di scegliere la migliore strategia di trading da implementare. L'analisi fondamentale e tecnica non è mai stata combinata in un EA fino ad ora con l'ausilio del linguaggio MQL5. Guardando al futuro, vedo la realizzazione di EA in tutti i mercati che si uniscono per prevedere le fluttuazioni del mercato.
1234
Nuovo commento