Creazione di EA di reti neurali utilizzando MQL5 Wizard e Hlaiman EA Generator
348
0
Introduzione
Praticamente ogni trader conosce l'esistenza delle reti neurali. Ma per la maggior parte di loro il loro funzionamento rimane un mistero, con le uniche cose note che sono la capacità delle reti neurali di riconoscere i modelli, produrre la ricerca associativa di soluzioni e imparare. I trader di solito sanno che le reti neurali possono essere efficaci nel prevedere il comportamento del mercato e nel trading automatizzato. Molte fonti di informazione che si concentrano sull'applicazione delle reti neurali spesso parlano della loro difficoltà, sottolineando che si deve dedicare molto tempo e sforzi per imparare bene questo argomento per essere in grado di utilizzare le reti neurali.
Questo articolo mira a confutare questi argomenti e dimostrare che i metodi di automazione avanzati consentono ai trader di iniziare facilmente con le reti neurali ed evitare il lungo processo di apprendimento. Non c'è nulla di difficile nell’acquisire esperienza con le reti neurali. È certamente più facile dell'analisi tecnica.
Con questo in vista, descriveremo un metodo di generazione automatica di EA di rete neurale per MetaTrader 5 utilizzando il MQL5 Wizard e Hlaiman EA Generator.
La scelta degli strumenti per risolvere il compito a portata di mano è tutt'altro che casuale:
- MQL5 Wizard è un meccanismo efficiente (e il più veloce) di generazione automatica di codice MQL5 che consente di ridimensionare il codice generato utilizzando moduli aggiuntivi.
- Hlaiman EA Generator è un motore di rete neurale con un meccanismo flessibile di integrazione degli oggetti, programmabile direttamente nel codice MQL5 di un Expert Advisor.
L'abbreviazione "EA" è stata aggiunta intenzionalmente al nome dell'Expert Advisor poiché le proprietà umane associate al riconoscimento e all'apprendimento sono predominanti in una rete neurale EA a differenza di altri casi in cui l'uso di "EA" in un nome è spesso fuorviante e non riflette la vera natura delle cose.
Descrizione generale
A causa del motivo delineato nell'obiettivo dell'articolo, non troverete qui alcuna informazione teorica, classificazioni e struttura delle reti neurali o dati di ricerca relativi ai mercati finanziari. Tali informazioni sono disponibili in altre fonti. In questo articolo, ci limiteremo deliberatamente al concetto di rete neurale come una scatola nera in grado di pensare associativamente e prevedere le voci di mercato basate sul riconoscimento di modelli di prezzo grafici. Per lo stesso motivo, useremo la nozione più semplice del modello come una sequenza continua di barre in un grafico di strumenti di trading che precede un movimento di prezzo redditizio.
Qualche parola sugli strumenti di risoluzione dei problemi. A differenza Hlaiman, MQL5 Wizard è stato spesso oggetto di vari articoli e documentazione e non ha bisogno di presentazioni proprio come MetaTrader 5. Il progetto Hlaiman socialmente orientato è destinato allo sviluppo e alla promozione di software multiuso sotto forma di plug-in, tra EA Generator. Come accennato in precedenza, funzionalmente EA Generator rappresenta un motore di rete neurale con un meccanismo di integrazione.
Hlaiman EA Generator include <hlaim.exe> - una shell che rappresenta un'applicazione GUI di Windows con interfaccia multi-documento e plug-in sotto forma di librerie di componenti caricabili dinamicamente. Il sistema offre una vasta gamma di metodi di regolazione manuale e algoritmica e di controllo dei componenti che possono essere sia standard che caricabili come parte dei plug-in. Nel corso del funzionamento del sistema, è possibile creare gerarchie complesse di oggetti e avere un controllo flessibile sui loro metodi e proprietà, utilizzando Object Inspector e strumenti software di automazione, ad esempio script.
L'integrazione di Hlaiman EA Generator con MQL5 coinvolge l'interprete di script Object Pascal, mentre il codice sorgente viene passato tramite Named Pipes. Un percettrone multistrato (MLP) viene utilizzato come componente principale della rete neurale.
Hlaiman EA Generator è integrato con il wizard MQL5 utilizzando un modulo di libreria di segnali - SignalHNN.mqh. Una volta generato automaticamente, si può insegnare all'Expert Advisor a fare trading su qualsiasi numero di strumenti e intervalli di tempo. Nel terminale МetaТrader 5, le frecce che indicano i segnali possono essere disegnate manualmente nel grafico dei prezzi utilizzando gli oggetti grafici per le frecce o automaticamente utilizzando lo script TeachHNN.mq5 che allo stesso tempo avvia il processo di insegnamento dell'Expert Advisor.
Questo conclude la descrizione teorica. Passiamo ora alla parte pratica che è divisa in due sezioni: Principi operativi e Implementazione.
La seconda sezione è rivolta agli sviluppatori di software ed è fornita qui principalmente per rispetto a questo sito web. È quindi facoltativo, soprattutto per i trader che hanno poco o nessun interesse ad acquisire competenze di programmazione ma sono interessati a creare EA di reti neurali e valutarne l'efficienza o l'inutilità in termini di trading.
Principi di funzionamento
In MQL5.community, probabilmente non sarebbe necessario menzionare che è necessario il terminale MetaТrader 5 per procedere. Se non ce l'hai, scaricalo e installalo. Dovresti anche scaricare e installare una versione demo di Hlaiman EA Generator.
Avvia il terminale МetaТrader 5 e avvia MetaEditor. Apri la procedura guidata MQL5. Puoi farlo usando l'opzione "Nuovo" nella barra degli strumenti Standard o nel menu File, oltre a utilizzare il tasto di scelta rapida "Ctrl + N".
Nella finestra della procedura guidata MQL5, selezionare "Expert Advisor (genera)" e fare clic su "Avanti".
Fig. 1. Creazione di un Expert Advisor nel Wizard MQL5
Specificare la posizione e il nome dell'Expert Advisor, ad es. 'Experts\SampleHNN' e fai clic su 'Avanti'.
Fig. 2. Proprietà generali dell'Expert Advisor
Fai clic sul pulsante "Aggiungi". Vedrai la finestra di "Parametri del modulo di segnale" in cui devi selezionare "Segnali di modelli Hlaiman Neural Network EA generator" dall'elenco a discesa e fare clic su "OK".
Fig. 3. Selezione del modulo del segnale di trading del generatore EA Hlaiman Neural Network
In caso di implementazione molto semplice, è possibile fare clic su "Avanti" in tutti i passaggi rimanenti della procedura guidata MQL5. Se necessario, l'Expert Advisor può essere migliorato selezionando opzioni aggiuntive.
Al termine della generazione del codice, fai clic su "Compila" e chiudi la finestra di MetaEditor. L'Expert Advisor generato apparirà nel pannello Navigator del terminale MetaTrader 5 sotto 'Expert Advisors'.
Fig. 4. Il SampleHNN Expert Advisor
Prima di procedere all'insegnamento dell'Expert Advisor generato, dobbiamo aprire un grafico con il simbolo e l'intervallo di tempo richiesti nel terminale. Hlaiman EA Generator deve essere attiva e funzionante.
Fig. 5. Preparazione all'insegnamento della rete neurale
Per insegnare all'Expert Advisor, seleziona 'TeachHNN' sotto 'Scripts' nel pannello Navigator del terminale e attivalo per il grafico specificato.
Prima di eseguire lo script 'TeachHNN', è necessario assicurarsi che abbia tutte le impostazioni appropriate. L'oggetto ha i seguenti parametri:
- Nome del documento - nome dell'Expert Advisor per l'insegnamento;
- Strati neurali - numero di livelli di rete neurale;
- Neuroni medi - numero di neuroni;
- Epoche di insegnamento - numero di epoche di insegnamento;
- Barre del modello - numero di barre in un modello;
- Insegnare ad una rete? - avviare il processo di insegnamento della rete neurale (o semplicemente la generazione del segnale);
- SignalsCreate - per creare automaticamente immagini grafiche di segnali;
- SignalsBarPoints - soglia di generazione del segnale espressa in punti;
- SignalsBarsCount - numero di barre per il calcolo dei punti;
- SignalsStartTime, SignalsEndTime - ora di inizio e fine del periodo per la generazione del segnale;
- SignalsClear - per eliminare automaticamente le immagini del segnale al termine dell'insegnamento.
Fig. 6. Parametri dello script TeachHNN
Se tutto è pronto, fai clic su "OK" per avviare il processo di insegnamento dell'Expert Advisor. Questo avvierà la generazione automatica di modelli grafici per ciascuno dei segnali disponibili nel grafico.
Le informazioni pertinenti vengono visualizzate nella scheda "Esperti" del pannello "Toolbox" del terminale, mentre gli oggetti corrispondenti vengono visualizzati nella finestra Hlaiman EA Generator.
Al completamento della generazione del modello, inizia il processo di insegnamento. Viene visualizzato nella barra di avanzamento dell'insegnamento che appare sullo schermo.
Fig. 7. Pannello di avanzamento dell'insegnamento
Attendere il completamento del processo. Il processo di insegnamento può essere terminato prima che sia completato facendo clic con il pulsante destro del mouse sulla barra di avanzamento dell'insegnamento e selezionando l'opzione appropriata nel menu di scelta rapida.
Al termine del processo di insegnamento e dell'operazione di script, il messaggio pertinente verrà aggiunto al registro nella scheda "Esperti", ad es. "La rete neurale crea successo! Su 431 modelli indica che l'insegnamento dell'Expert Advisor è stato completato con successo utilizzando 431 segnali.
Questi messaggi mostrano quanti modelli sono stati coinvolti nel processo di insegnamento e scoprono il numero di tali modelli. Il COMPRA e IL VENDI, in particolare, sono determinati utilizzando i messaggi del seguente tipo: 'Segnale di vendita rilevato al modello #211'.
Fig. 8. I messaggi di script TeachHNN nel corso dell'insegnamento
I motivi per cui il processo di insegnamento dell'Expert Advisor può iniziare con un errore sono i seguenti:
- L'applicazione Hlaiman non era attiva e funzionante prima dell'avvio, come richiesto. In questo caso il messaggio di errore sarà il seguente "CSignalHNN::InitHNN: Errore! inizializzazione del server di pipe (possibile motivo: L'APPLICAZIONE HLAIMAN NON È IN ESECUZIONE!)".
- L'assenza di frecce che indicano i segnali nel grafico al momento della generazione automatica dei segnali disabilitata (la variabile SignalsCreate = false). In questo caso il messaggio di errore da visualizzare è il seguente: "OnStart: errore, freccia ordini non trovata!" Se la generazione automatica dei segnali è abilitata (la variabile SignalsCreate = true), un errore potrebbe essere causato dalla presenza di altri oggetti grafici nel grafico, poiché le marcature personalizzate non dovrebbero essere incasinate nel programma. Si raccomanda pertanto di aprire tutti i grafici separatamente ai fini della generazione automatica di segnali.
Una volta completato l'insegnamento dell'Expert Advisor, è possibile visualizzare i risultati pertinenti passando alla GUI Hlaiman e selezionando gli oggetti e i pannelli di visualizzazione appropriati.
Fig. 9. La scheda "Testo" dell'applicazione Hlaiman
Fig. 10. La scheda 'Grafico' dell'applicazione Hlaiman
Dopo aver insegnato con successo all'Expert Advisor almeno uno strumento di trading, possiamo procedere al test e/o all'ottimizzazione.
A tale scopo, selezionare il nome dell'Expert Advisor addestrato, il simbolo, l'intervallo di tempo, l'intervallo e altri parametri di test nello Strategy Tester. Impostare le variabili esterne, se necessario, ed eseguire il test.
Fig. 11. Impostazioni di SampleHNN Expert Advisor per il backtesting
Fig. 12. Le variabili esterne di SampleHNN Expert Advisor possono essere modificate
Di seguito è riportato un esempio del rapporto operativo di Expert Advisor nello Strategy Tester. L'Expert Advisor è stato insegnato utilizzando segnali generati automaticamente, con tutti i parametri esterni dello script didattico impostati per impostazione predefinita. Il periodo di insegnamento: 01.01.2010-01.07.2013, strumento: EURUSD H4.
Rapporto del tester di strategia
| Expert Advisor | EsempioHNN |
|---|---|
| Simbolo | EURUSD |
| Periodo | H4 (2010.01.01-2013.07.12) |
| Valuta | USD |
| Deposito iniziale | 10,000.00 |
| Leva finanziaria | 0,111111111 |
| Backtesting | |
| Qualità della storia: | 100% |
| Barre: | 5497 |
| Utile netto: | 9,159.58 |
| Profitto lordo | 29,735.97 |
| Perdita lorda | -20,576.39 |
| Fattore di profitto | 1.45 |
| Fattore di recupero | 12.81 |
| AHPR: | 1.0005 (0.05%) |
| GHPR: | 1.0005 (0.05%) |
| Totale operazioni: | 1417 |
| Totale Offerte: | 2246 |
| ticks++; | 60211228 |
| Saldo Drawdown Assoluto: | 0.00 |
| Bilancia Drawdown Maximal: | 679.98 (3.81%) |
| Saldo Drawdown Relativo: | 4.00% (715.08) |
| Profitto previsto | 6.46 |
| Indice di Sharpe | 0.16 |
| Correlazione LR: | 0.98 |
| LR Standard Error: | 595.06 |
| Short Trade | 703 (56.61%) |
| Operazioni di profitto (% del totale): | 793 (55.96%) |
| Il più grande commercio di profitto: | 53.00 |
| Profitto medio | 37.50 |
| Vincite massime consecutive | 9 (450.38) |
| Massime perdite consecutive | 450.38 (9) |
| Media vittorie consecutive: | 2 |
| Simboli | 1 |
| Equity Drawdown Absolute: | 6.60 |
| Equity Drawdown Maximal: | 715.08 (4.00%) |
| Equity Drawdown Relativo: | 4.00% (715.08) |
| Livello di margine | 6929.24% |
| Conto: | -1.24 (78.50%) |
| Risultato OnTester: | 0 |
| Long Trade | 714 (55.32%) |
| Operazioni di perdita (% del totale): | 624 (44.04%) |
| Il più grande commercio in perdita: | -53.30 |
| Perdita media commerciale: | -32.97 |
| Massime perdite consecutive | 9 (-234.00) |
| Massime perdite consecutive | -276.67 (7) |
| Massime perdite consecutive | 2 |
Fig. 13. Risultati del backtesting di SampleHNN Expert Advisor
Fig. 14. Le statistiche di ingresso nel mercato di SampleHNN Expert Advisor
Fig. 15. Correlazione tra profitto e MFE/MAE del SampleHNN Expert Advisor
Fig. 16. La posizione di SampleHNN Expert Advisor che detiene statistiche sul tempo
Implementazione
Il principale componente di implementazione mqL5 è la classe CSignalHNN descritta nel modulo di segnale SignalHNN.mqh. La classe è ereditata dalla classe base CExpertSignal e include tutti i campi dati e i metodi necessari per il funzionamento e l'integrazione di Hlaiman, nonché per lavorare con Expert Advisor generati utilizzando la procedura guidata MQL5.
Il modello di classe è il seguente:
//+------------------------------------------------------------------+ //| Class CSignalHNN. | //| Purpose: Class of generator of trade signals based on | //| the 'Hlaiman EA Generator Neural Net' indicator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalHNN :public CExpertSignal { protected: //--- variables int m_hnn; // handle of HNN connect string hnn_path; // MT5 Terminal data path string hnn_fil; // HNN file w neural net string hnn_nam; // Expert name string hnn_sym; // Symbol name string hnn_per; // Period name ENUM_TIMEFRAMES hnn_period; // Period timeframe int hnn_index; // Index ext multinet int hnn_bar; // index of last bar int hnn_in; // input layer int hnn_out; // output layer int hnn_layers; // layers count int hnn_neurons; // neurons count int hnn_epoch; // learn epoch double hnn_signal; // value of last signal double pattern[]; // values of the pattern bool hnn_norm; // normalize pattern public: CSignalHNN(void); // class constructor ~CSignalHNN(void); // class destructor //--- methods of setting adjustable parameters void PatternBarsCount(int value) { hnn_in = value; ArrayResize(pattern, value + 1); } void LayersCount(int value) { hnn_layers = value; } void NeuronsCount(int value) { hnn_neurons = value; } void EpochCount(int value) { hnn_epoch = value; } void Normalize(bool value) { hnn_norm = value; } //--- method of verification of settings virtual bool ValidationSettings(void); //--- method of creating the indicator and timeseries virtual bool InitIndicators(CIndicators *indicators); //--- methods of checking conditions of entering the market virtual double Direction(void); bool FillPattern(datetime tim = 0); // prepare pattern bool AddPattern(string name, int ptype); // add new pattern bool TeachHNN(void); // learn neural net bool SaveFileHNN(void); // neural net file double CalculateHNN(void); // calc neural signal //protected: //--- method of initialization of the Hlaiman Application bool InitHNN(bool openn); // Hlaiman App Init void FreeHNN(void) { // Hlaiman App Deinit if(m_hnn!=0 && m_hnn!=INVALID_HANDLE) { FileClose(m_hnn); m_hnn=0; } }; };
Dopo la creazione dell'istanza di classe utilizzando il costruttore, questo oggetto può funzionare in due modalità principali:
- Modalità di insegnamento: questa modalità è associata alla raccolta di modelli di mercato e all'insegnamento della rete neurale.
- Modalità indicatore: in questa modalità, il segnale della rete neurale viene calcolato utilizzando il modello corrente.
La modalità viene identificata quando si chiama la modalità di inizializzazione InitHNN utilizzando il parametro booleano openn. Il vero valore di questo parametro avvia la ricerca e l'apertura, nonché il caricamento e il funzionamento del file di dati della rete neurale insegnata nella modalità indicatore (2). Questa modalità è considerata la modalità operativa e viene utilizzata nell'Expert Advisor per il trading.
A differenza della modalità di insegnamento (1) che viene inizializzata quando si chiama il metodo InitHNN con openn = false, la modalità indicatore è preparatoria per l'Expert Advisor e viene utilizzata per il funzionamento dello script didattico.
Il metodo di inizializzazione viene implementato come segue:
//+------------------------------------------------------------------+ //| Initialize HNN | //+------------------------------------------------------------------+ bool CSignalHNN::InitHNN(bool openn) { //--- initialize Hlaiman Application int num=0; ulong res=0; if(m_symbol!=NULL) { hnn_sym=m_symbol.Name(); hnn_period=m_period; } else { hnn_sym=_Symbol; hnn_period=_Period; } hnn_per = string(PeriodSeconds(hnn_period) / 60); hnn_fil = hnn_nam + NAME_DELIM + hnn_sym + hnn_per + NAME_DELIM + string(hnn_index) + TYPE_NEURO; if(m_hnn== 0|| m_hnn == INVALID_HANDLE) m_hnn=FileOpen(HLAIMAN_PIPE,FILE_READ|FILE_WRITE|FILE_BIN); if(m_hnn!=0 && m_hnn!=INVALID_HANDLE) { string source,result=""; if(openn==true) { result=CON_OPENN+CON_TRUE; if(!FileIsExist(hnn_fil,FILE_READ)) { if(FileIsExist(hnn_fil,FILE_READ|FILE_COMMON)) hnn_fil=TerminalInfoString(TERMINAL_COMMONDATA_PATH)+PATH_FILES+hnn_fil; else { // hnn_fil = hnn_path + PATH_MQL5 + PATH_FILES + hnn_fil; hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } } else hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } else { result=CON_OPENN+CON_FALSE; hnn_fil=TerminalInfoString(TERMINAL_DATA_PATH)+PATH_MQL5+PATH_FILES+hnn_fil; } source="unit InitHNN; Interface "+result+" var libr, term, exp, sym: TObject;" " Implementation function main: integer;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');" " if (exp = nil) then exp := term.AddObject('TMT45Expert');\n\r" // Line #5 " if (exp <> nil) then" " begin" " if (exp.Name <> '"+hnn_nam+"') then exp.Name := '"+hnn_nam+"';\n\r" // Line #6 " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');" " if (sym = nil) then sym := exp.AddObject('TMT45Symbol');" " if (sym <> nil) then" " begin" " sym.Log.Add('"+hnn_sym+hnn_per+"');\n\r" " if (sym.Name <> '"+hnn_sym+hnn_per+"') then sym.Name := '"+hnn_sym+hnn_per+"';" " if (sym.Period <> "+hnn_per+") then sym.Period := "+hnn_per+";" " if (openn = true) then" " begin" // " sym.Log.Add('" + hnn_fil + "');" " if (sym.Open('"+hnn_fil+"')) then Result := sym.TeachInput;\n\r" // ret input Line #8 " end else" " begin" " sym.TeachInput := "+IntegerToString(hnn_in)+";" " sym.TeachOutput := "+IntegerToString(hnn_out)+";" " sym.TeachLayer := "+IntegerToString(hnn_layers)+";" " sym.TeachNeurons := "+IntegerToString(hnn_neurons)+";" " sym.TeachEpoch := "+IntegerToString(hnn_epoch)+";" " sym.FileName := '"+hnn_fil+"';" " Result := sym.TeachInput;\n\r" // ret input Line #9 " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(res<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); res=FileSize(m_hnn); num++; } if(res>0) { result=FileReadString(m_hnn,int(res/2)); res=StringToInteger(result); if(res<=RES_OK) printf(__FUNCTION__+": Error! Initialization data(possible reason: FILE NOT EXIST OR CORRUPTED "+hnn_fil); else { printf(__FUNCTION__+": Initialization successful! NEURAL PATTERN "+string(res)); ArrayResize(pattern,int(res+1)); return(true); } } else printf(__FUNCTION__+": Error! pipe server not responding(possible elimination: RESTART HLAIMAN APPLICATION)"); } else printf(__FUNCTION__+": Error! initializing pipe server (possible reason: HLAIMAN APPLICATION IS NOT RUNNING!)"); //--- ok return(false); }
Come si può vedere dal codice, il primo passaggio di inizializzazione copre un tentativo di aprire una named pipe per la connettività con l'applicazione Hlaiman. Se questo tentativo fallisce (ad esempio, quando <hlaim.exe> non è in esecuzione), l'uscita viene eseguita con uno stato negativo. Al secondo passaggio (al completamento con successo del primo passaggio e della modalità indicatore operativo), le cartelle locali e comuni del terminale vengono cercate per il nome del file richiesto con i dati della rete neurale. Il terzo passo riguarda la preparazione del codice in ObjectPascal (Delphi) per l'inizializzazione direttamente nell'applicazione Hlaiman.
Il testo del codice viene quindi spostato nella stringa di origine. Per comodità di formattazione, è suddiviso in sottostringhe utilizzando '\n\r' e contiene invocazioni delle proprietà e dei metodi dell'oggetto Hlaiman (vedere commenti). Come definito nel testo, l'ambiente basato su oggetti del plug-in MetaTrader 5 Hlaiman rappresenta l'architettura ad albero, con l'oggetto del plug-in che giace alla radice.
L'oggetto terminale МetaТrader 5 è al livello successivo seguito da Expert Advisor e oggetti simbolo. In caso di traduzione ed esecuzione riuscite del codice sorgente passato tramite la named pipe, il valore Result restituito conterrà il numero di elementi del vettore di input della rete neurale. Come suggerisce il codice, questo valore viene utilizzato per inizializzare la matrice di pattern e l'esecuzione del metodo viene completata con uno stato positivo.
Gli altri metodi chiave della classe CSignalHNN sono CalculateHNN, AddPattern e TeachHNN. Il primo restituisce il risultato del calcolo della rete neurale in modalità indicatore. Gli altri due metodi sono utilizzati nella modalità di insegnamento quando si raccolgono modelli e si avvia il processo di insegnamento della rete neurale, rispettivamente.
L'implementazione di questi metodi in <SignalHNN.mqh> è la seguente:
//+------------------------------------------------------------------+ //| Calculate HNN signal | //+------------------------------------------------------------------+ double CSignalHNN::CalculateHNN(void) { if(m_hnn==0 || m_hnn==INVALID_HANDLE) return(0.0); int num = 0; ulong siz = 0; double res=0.0; string source,result=""; if(FillPattern(0)==true) { result=CON_START; for(int i=1; i<(ArraySize(pattern)-1); i++) result= result+DoubleToString(pattern[i])+CON_ADD; result = result + DoubleToString(pattern[ArraySize(pattern) - 1]) + CON_END; source = "unit CalcHNN; Interface " + result + " var i: integer; libr, term, exp, sym, lst: TObject;" " Implementation function main: double;\n\r" // Line #1 " begin" " Result := 0.0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " lst := TStringList.Create;" " if (lst <> nil) then" " begin" " lst.Text := cons;" " if (lst.Count >= sym.NetInputs.Count) then" " begin" " for i := 0 to sym.NetInputs.Count - 1 do" " begin" " sym.NetInputs.Objects[i].NetValue := StrToFloat(lst[i]);\n\r" // Line #6 // " sym.Log.Add('Input ' + IntToStr(i) + ' = ' + lst[i]);" " end;" " sym.Computed := true;" " Result := sym.NetOutputs.Objects[0].NetValue;\n\r" // ret input Line #7 " end;" " lst.Free;" " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToDouble(result); } } //else Print("fill pattern error!"); return(res); } //+------------------------------------------------------------------+ //| AddPattern | //+------------------------------------------------------------------+ bool CSignalHNN::AddPattern(string name,int ptype) { int num=0; long res=0; ulong siz=0; string result,source,nam=name; if(m_hnn!=0 || m_hnn!=INVALID_HANDLE) { pattern[0]=ptype; result=CON_START; for(int i=0; i<(ArraySize(pattern)-1); i++) result= result+DoubleToString(pattern[i])+CON_ADD; result = result + DoubleToString(pattern[ArraySize(pattern) - 1]) + CON_END; source = "unit AddPatternHNN; Interface " + result + " Implementation function main: integer;" " var i: integer; out: double; onam: string;" " libr, term, exp, sym, ord, tck, lst: TObject;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " lst := TStringList.Create;" " if (lst <> nil) then" " begin" " lst.Text := cons;" " if (lst.Count >= (sym.TeachInput + sym.TeachOutput)) then" " begin" " out := StrToFloat(lst[0]);" " if(out >= 0) then onam := 'BUY-"+nam+"'" " else onam := 'SELL-"+nam+"';" " ord := sym.ObjectOfName(onam);" " if (ord = nil) then ord := sym.AddObject('TMT45Order');\n\r" // Line #6 " if (ord <> nil) then" " begin" " if (ord.Name <> onam) then ord.Name := onam;\n\r" // Line #7 " if (out >= 0) then ord.OrderType := 0 else ord.OrderType := 1;" " if (ord.NetOutput <> out) then ord.NetOutput := out;\n\r" // Line #8 " for i := 1 to sym.TeachInput do" " begin" " if(i <= ord.Count) then tck := ord.Items[i - 1] else" " tck := ord.AddObject('TMT45Tick');\n\r" // Line #10 " if (tck <> nil) then" " begin" " tck.x := i;" " tck.y := StrToFloat(lst[i]);\n\r" // Line #11 " end;" " end;" " end;" " Result := sym.Count;\n\r" // ret input Line #12 " end;" " lst.Free;" " end;" " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0 && (MQL5InfoInteger(MQL5_TESTER) || num<WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToInteger(result); } } return(res>0); } //+------------------------------------------------------------------+ //| TeachHNN | //+------------------------------------------------------------------+ bool CSignalHNN::TeachHNN(void) { int num=0; long res=0; ulong siz=0; string result,source; if(m_hnn!=0 || m_hnn!=INVALID_HANDLE) { source="unit TeachHNN; Interface const WAIT_TIM = 100; WAIT_CNT = 100;" " var i: integer; libr, term, exp, sym: TObject;" " Implementation function main: integer;\n\r" // Line #1 " begin" " Result := 0;" " libr := Open('mt45.dll');\n\r" // Line #2 " if (libr <> nil) then" " begin" " term := Open('"+hnn_path+"');\n\r" // Line #3 " if (term <> nil) then" " begin" " exp := term.ObjectOfName('"+hnn_nam+"');\n\r" // Line #4 " if (exp <> nil) then" " begin" " sym := exp.ObjectOfName('"+hnn_sym+hnn_per+"');\n\r" // Line #5 " if (sym <> nil) then" " begin" " if (sym.Teached) then sym.Teached := false;\n\r" // Line #6 " sym.Teached := true;\n\r" // Line #7 " Result := sym.Count;\n\r" // ret input Line #8 " end;" " end;" " end;" " end;" " end; end."; FileWriteString(m_hnn,source,StringLen(source)); FileFlush(m_hnn); while(siz<=0) {// && (MQL5InfoInteger(MQL5_TESTER) || num < WAIT_TIMES)) { Sleep(SLEEP_TIM); siz=FileSize(m_hnn); num++; } if(siz>0) { result=FileReadString(m_hnn,int(siz/2)); res=StringToInteger(result); } } return(res>0); }
Come si può vedere dal codice, il corpo del metodo è costituito principalmente dalle righe di origine, il cui testo è disposto in modo simile ai testi considerati sopra nella descrizione del metodo InitHNN. L'unica differenza è che la gerarchia basata su oggetti del plug-in ha altri due livelli per la rappresentazione del modello: ordine e tick. Inoltre, il codice contiene proprietà e metodi dell'oggetto aggiuntivi. Ad esempio, l'inizio del calcolo della rete neurale è contrassegnato dal flag Computed dell'oggetto "simbolo", mentre il flag Teached viene utilizzato quando si avvia il processo di insegnamento.
Il metodo CalculateHNN è anche diverso dagli altri metodi in quanto il tipo del valore "principale" restituito dalla funzione in questo caso è "double". Questo valore è l'uscita della rete neurale - il segnale, per cui il livello BUY si trova nell'intervallo 0..1 e il livello SELL è nell'intervallo 0..-1. Questo segnale viene utilizzato dall'Expert Advisor nel prendere decisioni relative all'apertura o alla chiusura di posizioni di trading ed è controllato dal metodo Direction. Questo metodo esegue il ricalcolo in caso di nuova barra e restituisce il suo valore espresso in percentuale.
//+------------------------------------------------------------------+ //| Check conditions for trading signals. | //+------------------------------------------------------------------+ double CSignalHNN::Direction(void) { if( m_hnn == 0 || m_hnn == INVALID_HANDLE) return(EMPTY_VALUE); //--- check new bar condition int cur_bar = Bars(hnn_sym, hnn_period); if (hnn_bar != cur_bar) { //--- condition OK hnn_signal = CalculateHNN() * 100; hnn_bar = cur_bar; } return(hnn_signal); }
Per impostare la soglia di risposta del segnale dell'Expert Advisor in relazione ai segnali per l'apertura e la chiusura di posizioni di trading, è possibile utilizzare le seguenti variabili esterne:
- input int Signal_ThresholdOpen =10; Valore di soglia del segnale da aprire [0...100]
- input int Signal_ThresholdClose=10; Valore di soglia del segnale da chiudere [0...100]
In pratica, i livelli del segnale dipendono dalla qualità e dall'intensità dell'insegnamento della rete neurale che, di norma, può essere valutata visivamente monitorando la dinamica di diminuzione dell'errore computazionale visualizzato nell'indicatore nel corso dell'insegnamento.
Conclusioni
Hlaiman EA Generator fornisce componenti e un ambiente trasparente controllato basato su oggetti per l'integrazione con MQL5, in cui:
- L'interfaccia MQL5 Wizard ottiene un tipo aggiuntivo basato sul riconoscimento di segnali e pattern, nonché la possibilità di generare EA di reti neurali.
- Oltre alla possibilità di generare rapidamente EA di reti neurali, puoi anche adattarli rapidamente al cambiamento del comportamento del mercato e insegnare loro ripetutamente su diversi strumenti di trading e intervalli di tempo.
- A causa del fatto che la procedura guidata MQL5 può abilitare più moduli di segnale, è possibile creare complessi EA di reti neurali multi-valuta e / o EA di reti neurali basate su indicatori composti. Possono anche essere combinati con vari filtri aggiuntivi, ad esempio filtri temporali.
- Infine, il modulo di rete neurale in sé può essere utilizzato come filtro aggiuntivo per aumentare l'efficienza di un Expert Advisor già pronto. Ciò è possibile grazie alla capacità di una rete neurale di essere insegnata utilizzando i grafici di visualizzazione dei risultati dei test dell'Expert Advisor originale.
L'uso dell'interprete di script che fa apparire il sistema informatico integrato non molto performante può essere considerato come uno degli svantaggi dell'implementazione fornita sopra. Prima di tutto, tuttavia, va notato che l'interpretazione del codice dello script, così come il funzionamento del plug-in Hlaiman è asincrono con EX5, cioè ci occupiamo della parallelizzazione delle attività. In secondo luogo, per aumentare la velocità dei calcoli dispendiosi in termini di tempo, ad esempio quando si tratta di reti neurali di grandi dimensioni, MetaTrader 5 e Hlaiman possono essere eseguiti su diversi computer collegati tramite pipe di rete denominate. Lanciando un terminale di trading su un computer separato, non solo guadagnerai in prestazioni, ma potresti anche aumentarne la sicurezza.
Se messi in prospettiva, possiamo esaminare lo sviluppo di Expert Advisor che possono auto-imparare nel corso del trading. A questo punto il modo più semplice per farlo è combinare il codice dell'Expert Advisor con il codice dello script didattico poiché entrambi utilizzano la stessa classe CSignalHNN che fornisce le funzionalità richieste. Questo materiale può diventare l'oggetto dell'articolo successivo o costituire la base di uno completamente nuovo, se sembra essere di interesse.
La versione demo di Hlaiman EA Generator può essere scaricata qui.
Allegati
- SignalHNN.mqh - modulo di segnale "MQL5\Include\Expert\Signal\".
- TeachHNN.mq5 - teaching script "MQL5\Scripts\".
- SampleHNN.mq5 - Expert Advisor basato sul modulo di segnale di trading 'Signals of patterns Hlaiman Neural Network EA generator' e generato utilizzando la procedura guidata MQL5.
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/706
Costruire un trader automatico di notizie
Un'altra classe OOP MQL5
MQL5 Wizard: Come insegnare a un EA ad aprire ordini pendenti a qualsiasi prezzo
Come installare e utilizzare OpenCL per i calcoli
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso