Le funzionalità di ChatGPT di OpenAI nell'ambito dello sviluppo di MQL4 e MQL5

Contenuto

• Introduzione
• Prospettive di utilizzo di ChatGPT in MQL5
• Potenziali insidie associate a ChatGPT
• Opportunità di utilizzare ChatGPT per risolvere problemi matematici e sviluppare modelli matematici da utilizzare in un codice.
• Approccio corretto alla generazione del codice in MQL4 e MQL5
• Sviluppare un sistema di trading utilizzando ChatGPT
• Valutazione della funzionalità e analisi dei risultati
• Conclusione

Introduzione

Partiamo quindi dalle basi. Questa tecnologia è una delle varianti dell'intelligenza artificiale di OpenAI, progettata per aiutare le persone a risolvere vari compiti. Questo strumento si presenta come una normale chat di messaggistica. Tuttavia, all'altro capo c'è una cosiddetta intelligenza artificiale che risponde in forma di testo.

Naturalmente, il canale di comunicazione è limitato solo a un testo, ma è comunque sufficiente per risolvere vari problemi o imparare molte cose nuove. Questo canale di testo è adatto a risolvere problemi completamente diversi, come la programmazione, la matematica, la fisica, la chimica, per non parlare della pratica traduzione e di altre abilità.

Questo modello ci interessa solo in termini di sviluppo di sistemi di trading redditizi. Mi sono interessato a come utilizzare in modo ottimale e corretto questa tecnologia per uno sviluppo più rapido e semplice dei sistemi di trading. In definitiva, chi per primo inizia ad applicare correttamente una tecnologia per lo scopo per cui è stata concepita, riduce sia i costi di sviluppo che i costi di manodopera, con evidenti vantaggi competitivi.

Prospettive di utilizzo di ChatGPT in MQL5

Soffermiamoci più in dettaglio sulle prospettive tecnologiche. Dopo uno studio abbastanza approfondito sui miei stessi esempi, ho capito che questa tecnologia è solo il principio di qualcosa di veramente grande. Ma già ora posso evidenziare le seguenti caratteristiche:

• Generazione di qualsiasi codice MQL4 e MQL5
• Rifattorizzazione e ottimizzazione del codice di lavoro
• Pulire un codice
• Aggiunta di commenti ad un codice
• Correzione degli errori
• Implementazione di modelli matematici
• Successiva costruzione di codici basati sui modelli matematici
• Modernizzazione di tutti gli algoritmi e i modelli matematici conosciuti
• Accelerare il processo di sviluppo degli Expert Advisor (EA)
• Un'enorme quantità di informazioni

Questo elenco non è assolutamente definitivo e potete aggiungere qualcosa di vostro. Credo che quando le persone vengono a conoscenza di questo tipo di tecnologia, inizino a suddividersi in circa tre sottogruppi:

1. "Ora faremo un super algoritmo".
2. Coloro che sono diffidenti nei confronti dell'AI e ne mettono in dubbio l'utilità.
3. La macchina non può essere migliore dell'uomo. È solo un'altra pubblicità.

Ho iniziato a familiarizzare con questa tecnologia molto tempo fa e all'inizio appartenevo alla terza categoria. Nei primi due giorni in cui ho avuto a che fare con questa AI, sono passato bruscamente dalla terza alla prima categoria, dopodiché è iniziato un processo più interessante e piuttosto spiacevole di aggiustamento delle mie stesse convinzioni iniziali, che è più simile a un ritorno alla categoria "1,5", che è già una valutazione più realistica di questa tecnologia.
Questa tecnologia è utile, ma non quanto si potrebbe pensare inizialmente. A questo proposito, vale la pena rendere omaggio agli sviluppatori e agli addetti al marketing di questa tecnologia, anche solo per il fatto che crea un incredibile effetto "wow" dall'uso nei primi due giorni, che è sufficiente per una reazione a catena di autopromozione.

Per capirlo, è necessario fare molta pratica con questa AI. Personalmente, ho avuto un centinaio di dialoghi diversi con lui su vari argomenti. Posso dire di aver acquisito sufficiente pratica nell'uso di questa tecnologia per iniziare a utilizzarla per MQL5. Prima di passare alle applicazioni pratiche, è necessario che vi dica alcune informazioni molto importanti, per le quali dovremo guardare più a fondo, sotto il cofano di questa tecnologia.

Potenziali insidie associate a ChatGPT

Il cosiddetto effetto "wow" che proverete nei primi giorni di utilizzo di questa tecnologia è dovuto al fatto che si tratta principalmente di un modello testuale progettato per trasformare la vostra domanda in una risposta. Il motivo per cui vi piaceranno le sue risposte è che i creatori hanno insegnato a questo modello a mentire magnificamente. Sì, non sto scherzando! Mente così bene che vorrete crederci voi stessi e, anche dopo molti tentativi di smascherarla, il modello vi fornirà spesso qualcosa del genere:

• Mi dispiace! Sì, hai ragione. Ho commesso un piccolo errore. Ne terrò conto in futuro. (In realtà, non lo farà. Questa è solo una promessa vuota)
• Scusa il malinteso, ho commesso un errore. Ecco la versione corretta. (Contiene ancora più errori)
• Si potrebbe scoprire che il modello ha commesso un errore nei calcoli. (In realtà, il modello non ha fatto alcun calcolo, ha semplicemente trovato un numero approssimativo da qualche parte).
• È stato rilevato un errore in un codice. (Il modello si giustificherà ancora una volta e cercherà di ingannarvi)
• Il modello imita l'esecuzione di un compito e cerca di convincere l'utente che ha eseguito quanto richiesto. (In realtà, trova qualcosa di simile da qualche parte e lo fornisce all'utente. )
• Mi dispiace! Non sono stato in grado di aiutarti. (Questo accade quando il modello capisce che hai individuato le sue bugie o i suoi errori).
• Il modello aggiunge eccessive parole nella sua risposta per dare l'impressione di una risposta armoniosa e coerente. (Credo che questo sia in qualche modo collegato all'ottimizzazione dei costi delle risorse).

In breve, il modello cercherà di saltare il compito fornito in tutti i modi possibili, sfruttando l'imperfezione del vostro "prompt". In caso di errori, cercherà di giustificarsi in modo tale che non siate in grado di coglierlo sulla stessa cosa, e se capisce che lo avete inquadrato, cercherà di ammorbidire la vostra reazione negativa con alcune risposte e trucchi psicologici. In generale, ritengo che l'algoritmo sia stato studiato per ottenere un consumo ottimale di risorse con un livello accettabile di soddisfazione dell'utente. In altre parole, l'obiettivo in questo caso non è quello di fornire la soluzione di maggior qualità al problema, ma di fornire una soluzione che si consideri tale per ragioni completamente differenti. Si scopre che l'obiettivo è una reazione positiva da parte dell'utente e non è così importante se il compito viene risolto correttamente. È questo l'obiettivo che si prefigge. Dal punto di vista del marketing, ciò è corretto e, a questo proposito, l'AI può essere il più persuasiva possibile.

Considerando tutto questo, mi sono reso conto che per ridurre al minimo la sua libertà in questo aspetto, dovremmo prima di tutto accumulare esperienza nel comunicare con lei e trarre conclusioni su quale tipo di compiti non richiede l'uso di questa persuasività semplicemente perché sarà facile per lei soddisfare la nostra richiesta, dal momento che è più facile da soddisfare data la sua funzionalità ed è molto più facile dare una risposta diretta che permettere l'immaginazione. Perché non sarà efficiente in termini di costi delle risorse, in altre parole, semplicemente non sarà redditizio per lei ingannarvi, ma sarà molto più facile darvi una risposta vera.

Per iniziare a capire come porre tali domande, abbiamo bisogno di comprendere quanto segue:

1. La struttura e il tipo di "prompt" non sono così importanti, sono più importanti i dettagli e la qualità della domanda. (Il modello capisce tutto e non c'è bisogno di leggere guide su Internet su come comporre i prompt. Scrivete come volete, ma senza gergo).
2. Dividete le domande o le richieste complesse in paragrafi. (Semplificare e dividere le domande per ottenere risposte più precise, semplici e chiare).
3. Più la domanda è intelligente e puntuale, più la risposta è utile.
4. Non vi darà una super idea o un algoritmo. (Il modello non ha l'ampiezza del pensiero, della pianificazione e della creatività intellettuale. Ma all'inizio sembrerà che sia in grado di crearlo semplicemente perché, come ho detto, mente molto bene).
5. Dovremmo pensare all'uso di questa tecnologia solo nel contesto della velocizzazione del nostro lavoro e della riduzione dei costi di manodopera.
6. Ogni nuova richiesta deve essere il meno dipendente possibile dall'intero dialogo. (Il modello non è in grado di ricordare l'intero dialogo e spesso i vecchi messaggi non vengono presi in considerazione nelle risposte. Provatelo e capirete cosa intendo).
7. Più complessa è la domanda e più dettagli contiene, più alta è la probabilità di ottenere un'assurdità completa. (Questa è una spiegazione del secondo paragrafo).
8. Il modello non ha accesso a Internet e genera tutte le risposte solo in base alle sue conoscenze. (Se gli chiedete di ottenere un dato da Internet, vi fornirà i vecchi dati del suo database o modificherà la risposta in base al vostro contesto facendola passare per una nuova). Tenetelo a mente. Il modello lo farà semplicemente perché si rende conto che è inutile discutere con voi e che è meglio convincervi che ha fatto tutto lui).
9. ChatGPT 3.5 è stato addestrato fino al 2019. (Il che significa che non ha informazioni sugli eventi successivi al 2019 fino alla prossima sessione di addestramento sancita dagli sviluppatori).
10. ChatGPT 4.0 è stato addestrato fino al 2021. (È meglio perché mente poco e cerca di rispondere sempre correttamente. Se provate a fare domande e a fare confronti, vedrete che 3.5 mente palesemente).

In realtà, ci sono molti altri piccoli momenti spiacevoli che rovinano l'impressione di questa tecnologia. Tuttavia, non ne scriverei se questa tecnologia non fosse utile. Tutto questo si riduce al fatto che questa non è affatto un'intelligenza artificiale. Ma se rimaniamo pragmatici e pensiamo se tutto è così negativo e quali operazioni di routine possiamo eseguire più velocemente e meglio con l'aiuto di questa tecnologia, allora sono sicuro che non saremo troppo severi nel nostro giudizio. Dobbiamo solo pensare a come utilizzare tutto questo nello sviluppo di sistemi di trading.

Per concludere questa sezione, vorrei concentrare la vostra attenzione sul punto più importante e basilare che dovete sempre ricordare:

• Controllate sempre due volte le risposte di ChatGPT, in particolare i numeri, le equazioni e il codice generato.

Grazie alla mia conoscenza della matematica e della programmazione, mi è capitato di vedere molti esempi di errori e carenze e posso dire che sono piuttosto comuni. Sembrerebbe insignificante dal punto di vista del testo generato, ma quando si tratta di matematica o di codice, anche l'errore più insignificante rende inutile l'intera soluzione. Pertanto, controllate sempre due volte le risposte, correggete gli errori e richiamate l'attenzione del modello. A volte risponde correttamente per un po'. Questo paragrafo, tra l'altro, sarà estremamente utile durante lo sviluppo dei vostri EA.

Opportunità di utilizzare ChatGPT per risolvere problemi matematici e sviluppare modelli matematici da utilizzare in un codice.

Poiché questo modello è testuale, è facile intuire che se scriviamo le equazioni nel formato corretto, il modello le capirà e, inoltre, eseguirà trasformazioni matematiche e risolverà i problemi. Quando si sviluppano molti sistemi di trading, è necessario un aiuto per creare equazioni ed espressioni matematiche. È possibile risolvere alcuni possibili problemi matematici con la loro successiva implementazione in un codice. Esiste il seguente formato per la scrittura delle equazioni matematiche, che ChatGPT comprende e utilizza per fornire la risposta:

• LaTeX

Un esempio di utilizzo del formato Latex per la scrittura di equazioni:

Codice:

E &=& mc^2\\
m &=& \frac{m_0}{\sqrt{1-\frac{v^2}{c^2}}}

Incollate il tutto in un qualsiasi convertitore latex gratuito e otterrete una visualizzazione dei dati di tutte le espressioni conosciute:

Credo che ora sia chiaro come interpretare visivamente le risposte del modello in formato LaTeX. Soprattutto, non dimenticate di chiedere al modello di generare equazioni in questo formato se la risposta contiene espressioni matematiche. Esistono anche reti neurali in grado di convertire equazioni in immagini o altri formati nel formato che ci serve. Penso che troverete questi strumenti se ne avrete bisogno. Il mio compito è quello di dimostrarvi l'esistenza di questa possibilità.

Esistono bot di Telegram che combinano molte reti neurali, tra cui ChatGPT, e la funzione di conversione delle immagini in formato LaTeX. Se lo desiderate, potete trovarne uno nel mio profilo. Questo bot è stato realizzato da un mio amico e testato da me personalmente.

Potete chiedere a ChatGPT, per esempio, di risolvere una disequazione o un'equazione, sia numericamente che esplicitamente. Si può anche chiedere di risolvere sistemi di equazioni o disuguaglianze, nonché equazioni differenziali o integrali, o di eseguire qualsiasi trasformazione matematica richiesta. Tuttavia, come matematico, posso dire che non sempre lo fa in modo efficiente e razionale e a volte lascia il compito incompleto. È quindi necessario un doppio controllo.

Naturalmente, questa caratteristica può essere utile anche ai non matematici. In caso di uso prolungato, commetterete più errori e la vostra soluzione sarà piuttosto irrazionale e maldestra. Tuttavia, coprirete alcuni problemi matematici per il vostro codice, dato che il codice di solito utilizza solo metodi numerici, mentre la matematica applicata non è così complicata. Non c'è alcuna matematica differenziale.

Approccio corretto alla generazione del codice in MQL4 e MQL5

Qui le cose si fanno interessanti. Dato che le dimensioni dei codici di tutti i sistemi di trading di qualità sufficientemente elevata e più o meno decenti sono piuttosto grandi, vale la pena di pensare a come affrontare il processo di generazione di tali codici. In questo caso l'ostacolo principale è che la dimensione della risposta alla domanda è limitata a un certo numero di caratteri e, dopo numerosi tentativi di generare codici grandi e complessi, sono giunto alla conclusione che ogni codice in uscita deve essere abbastanza corto. Ciò significa che il codice deve essere visualizzato in parti. Come possiamo raggiungere questo obiettivo? La risposta è molto semplice - è necessario elaborare un piano per lo sviluppo di un EA, di un indicatore o di uno script.

Il piano deve essere redatto a condizione che ogni sottoelemento sia un sottocompito separato che può essere risolto in modo indipendente. A questo punto possiamo semplicemente risolvere ogni sottocompito in modo sequenziale e poi combinare tutto il codice insieme. Un altro vantaggio di questo approccio è che ogni sottocompito può essere finalizzato separatamente e, poiché ogni sottocompito è più semplice di tutti quelli combinati insieme, la finalizzazione viene eseguita più velocemente e in modo più comodo. Inoltre, eviteremo altri errori.

Come sviluppatore, è molto più comodo per me pensare autonomamente all'architettura principale del mio EA senza permettere all'intelligenza artificiale di interferire. Invece, lascio che implementi procedure separate nel mio EA. Che tutta la logica principale sia contenuta nelle procedure. Dovremo solo implementare un modello di codice approssimativo con funzioni vuote e poi chiedergli di implementare ogni funzione individualmente. Possiamo anche chiedergli di implementare prototipi di funzioni o altre strutture.

Un ulteriore e importante vantaggio è che potete chiedere al programma di preparare un piano per un EA o un altro codice, indicando i vostri requisiti, e poi semplicemente implementare il suo piano pezzo per pezzo. È bene avere un'idea approssimativa o precisa di come sarà l'algoritmo del vostro EA e di quali indicatori o altri approcci utilizzerà. Ma se non c'è un'idea del genere, potete prima parlargli e chiedergli di aiutarvi a scegliere una strategia di trading per il vostro EA. Vi offrirà alcune opzioni. Consideriamo questa linea di condotta come un esempio.

Riassumiamo ora quanto detto sopra e formiamo dei brevi sottopunti, che simboleggiano i possibili percorsi che seguiremo nella costruzione di un nuovo EA da zero. Per cominciare, ci sono diversi scenari possibili per iniziare:

1. Non abbiamo deciso l'architettura del futuro codice e non sappiamo da dove cominciare, e non sappiamo nemmeno quale approccio al trading scegliere.
2. Non abbiamo deciso l'architettura del codice futuro e non sappiamo da dove cominciare, ma conosciamo un'immagine approssimativa del codice di lavoro principale e di ciò che vogliamo dall'EA.
3. Abbiamo un'architettura già pronta che ci fa comodo, ma non sappiamo assolutamente quale approccio al trading scegliere.
4. Conosciamo l'architettura che vogliamo utilizzare e abbiamo anche un'idea chiara della futura logica di trading dell'EA.

Di norma, tutto si riduce a costruzioni simili. Tutti e quattro i punti possono essere applicati allo schema generale di costruzione di qualsiasi sistema di trading se si procede come segue:

• Se non conosciamo l'architettura (codice principale o struttura), dobbiamo prima di tutto implementarla e poi implementare tutto ciò che garantisce il funzionamento di questa struttura.

Questo può significare, ad esempio, che possiamo chiedere di implementare classi, variabili di input, campi e prototipi di metodi, interfacce, nonché la principale funzionalità di trading dell'EA, che utilizzerà le entità da noi descritte. Con una corretta gestione di ChatGPT, il codice può essere implementato in modo tale da occupare, ad esempio, non più del 5-10% del numero totale di caratteri. In questo caso, possiamo implementarlo rapidamente e poi passare all'implementazione delle procedure, che conterranno circa il 90% dell'intero codice. Queste procedure saranno implementate nello stesso semplice modo, perché ce ne saranno molte e risulteranno piuttosto piccole e facilmente eseguibili. Naturalmente, è molto più facile quando si dispone di un modello già pronto e non si deve implementare tutto questo, ma ciò richiede conoscenza ed esperienza.

Sviluppare un sistema di trading utilizzando ChatGPT

Credo di avervi fornito sufficienti informazioni teoriche. È il momento di applicarlo. Nel mio caso, utilizzo un modello già pronto su cui basare i miei EA. Ho descritto questo modello in uno degli articoli precedenti. La sua peculiarità è quella di fornire il trading parallelo di molti strumenti, attivati su un unico grafico. Presenta già tutte le funzionalità di trading necessarie e l'architettura principale. Costruirò un sistema di trading seguendo rigorosamente le raccomandazioni di ChatGPT. Implementerò io stesso la logica di trading principale dell'EA, così come la componente visiva, perché questo richiederà meno sforzi da parte mia.

Quando inizierete a interagire con ChatGPT, realizzerete che vi costerà di più cercare di fargli capire cosa deve fare e correggerete le sue risposte centinaia di volte quando implementerete alcune richieste e attività. Dopo un po' di tempo, inizierete semplicemente a capire quali domande vale la pena porre e quali no. Inizierete a impostare solo i compiti che in definitiva vi faranno risparmiare tempo invece di sprecarlo. C'è una linea piuttosto sottile qui, che dovete sentire voi stessi - non c'è altro modo. Tutto si impara con la pratica. Il mio approccio alla progettazione dell'EA si è formato completamente grazie a queste considerazioni.

Prima di tutto, ho chiesto di descrivere la base dell'EA - qual è il suo principio di funzionamento e quali metodi o indicatori deve utilizzare (ho permesso al modello di utilizzare qualsiasi informazione disponibile a sua discrezione). Allo stesso tempo, ho dichiarato di aver bisogno solo di condizioni logiche in forma leggibile, che posso implementare da solo nei seguenti quattro predicati:

1. Apertura di una posizione di acquisto.
2. Chiusura di una posizione di acquisto.
3. Apertura di una posizione di vendita.
4. Chiusura di una posizione di vendita.

Per implementare questi predicati, il modello mi ha proposto la seguente logica condizionale:

1. Il prezzo corrente ha chiuso al di sopra dell'EMA, la differenza tra il prezzo corrente e l'EMA è inferiore al rapporto * ATR e l'RSI è inferiore a 30.
2. Il prezzo corrente ha chiuso al di sotto della SMA, oppure il prezzo corrente ha chiuso al di sopra della banda superiore dell'indicatore Bollinger Bands.
3. Il prezzo attuale ha chiuso al di sotto dell'EMA, la differenza tra il prezzo attuale e l'EMA è inferiore al rapporto * ATR e l'RSI è superiore a 70.
4. Il prezzo corrente ha chiuso al di sopra della SMA, oppure il prezzo corrente è bloccato al di sotto della banda inferiore dell'indicatore Bollinger Bands.

Ovviamente, queste condizioni booleane restituiscono "true" in caso di successo e "falso" in caso di fallimento. Questi valori di segnale sono sufficienti per il trading con ordini di mercato. Vorrei richiamare la vostra attenzione sull'ovvia possibilità di modernizzare questa logica. A tal fine, si può procedere come segue:

• [K1] — zona del valore RSI inferiore
• [K2 = 100 - K1] — zona del valore RSI superiore

Queste espressioni possono essere utilizzate per espandere la flessibilità dell'algoritmo, con conseguente effetto positivo sull'efficienza dell'ottimizzazione EA:

1. Il prezzo corrente ha chiuso al di sopra dell'EMA, la differenza tra il prezzo corrente e l'EMA è inferiore al rapporto * ATR e l'RSI è inferiore a K1
2. Il prezzo corrente ha chiuso al di sotto della SMA o il prezzo corrente ha chiuso al di sopra della banda superiore dell'indicatore Bande di Bollinger
3. Il prezzo corrente ha chiuso al di sotto dell'EMA, la differenza tra il prezzo corrente e l'EMA è inferiore al rapporto * ATR e l'RSI è superiore a K2
4. il prezzo corrente ha chiuso al di sopra della SMA o il prezzo corrente ha chiuso al di sotto della banda inferiore dell'indicatore Bande di Bollinger

Ho fornito questo esempio perché non bisogna esitare a estendere il modello se è evidente che la soluzione in questione è solo un caso speciale di un algoritmo differente e più esteso. Anche se non si sa cosa può dare un'estensione di questo tipo, in questo modo si aumenta almeno la flessibilità dell'algoritmo e quindi la probabilità di una sua messa a punto più fine e, di conseguenza, di un possibile aumento della sua efficienza.

Considerando le condizioni necessarie che devono essere implementate, avremo bisogno di una delle due opzioni per implementare i seguenti indicatori:

1. SMA — media mobile standard (una linea)
2. EMA — media mobile esponenziale (una linea)
3. Bollinger Bands — Bande di Bollinger (un insieme di tre linee)
4. RSI — indice di forza relativa (una linea in una finestra separata)
5. ATR — average true range (una linea in una finestra separata)

Gli indicatori possono essere implementati utilizzando speciali funzioni predefinite di MQL5, ma non mi piace questo approccio, perché il codice implementato sarà più difficile da convertire nella versione MQL4. Inoltre, sarà più difficile per me integrarlo, ad esempio, nei miei progetti in altri linguaggi, cosa che faccio molto spesso. Da tempo ho l'abitudine di fare tutto nel modo più semplice possibile e pensando all'uso futuro. Credo che questa sia un'ottima abitudine.

Il secondo punto importante è che, di norma, tali indicatori si trascinano dietro calcoli e funzionalità inutili e ridondanti. Inoltre, è impossibile perfezionare tali indicatori, poiché le loro funzioni sono rigidamente impostate a livello di codice. Per apportare modifiche, sarà necessario creare in ogni caso una propria versione dell'indicatore. Credo sia ovvio che è meglio avere un'implementazione personalizzata all'interno di un EA o di uno script. Per implementare tali indicatori, ho escogitato il seguente trucco:

1. Creazione di array per la memorizzazione dei valori delle linee dell'indicatore (limitati alle ultime N barre).
2. Implementazione dello slittamento dei valori dell'array quando appare una nuova barra.
3. Implementazione della cancellazione dei valori degli indicatori nell’array in caso di errori o di una lunga disconnessione.
4. Implementazione del calcolo del valore dell'indicatore per l'ultima barra alla sua chiusura.

In questo approccio, i primi tre paragrafi creano blocchi di array e funzioni comuni che forniscono le azioni elencate. Vediamo come si presenta, usando il nostro compito come esempio. Cominciamo con il primo punto:

   double SMA1Values[]; // Array for storing SMA values
   double EMAValues[];  // Array for storing EMA values (exponential)
   double RSIValues[];  // Array for storing RSI values
   
   double BollingerBandsUpperValues[];  // Array for storing BollingerBands values, upper
   double BollingerBandsMiddleValues[]; // Array for storing BollingerBands values, middle
   double BollingerBandsLowerValues[];  // Array for storing BollingerBands values, lower
   
   double ATRValues[];// array for storing Average True Range values

Questi array sono inizializzati all'inizio dell'EA con i limiti di lunghezza indicati:

   //Prepare indicator arrays
   void PrepareArrays()
   {
      ArrayResize(SMA1Values, LastBars);
      ArrayResize(EMAValues, LastBars);
      ArrayResize(RSIValues, LastBars);
      ArrayResize(BollingerBandsUpperValues, LastBars);
      ArrayResize(BollingerBandsMiddleValues, LastBars);
      ArrayResize(BollingerBandsLowerValues, LastBars);
      ArrayResize(ATRValues, LastBars);
   }

A differenza degli indicatori convenzionali, per questa strategia non è necessario trascinare con sé tutti i valori precedenti. Questo è sicuramente un vantaggio. Mi piace questo paradigma di implementazione, perché garantisce la semplicità del codice e l'equivalenza sia dei valori di partenza dell'indicatore che di quelli ottenuti utilizzando i precedenti. Vediamo ora come si presenta lo slittamento di valore:

   //shift of indicator values
   void ShiftValues()
   {
      int shift = 1;
      for (int i = LastBars - 1; i >= shift; i--)
      {
         SMA1Values[i] = SMA1Values[i - shift];
         EMAValues[i] = EMAValues[i - shift];
         RSIValues[i] = RSIValues[i - shift];
         BollingerBandsUpperValues[i] = BollingerBandsUpperValues[i - shift];
         BollingerBandsMiddleValues[i] = BollingerBandsMiddleValues[i - shift];
         BollingerBandsLowerValues[i] = BollingerBandsLowerValues[i - shift];
         ATRValues[i] = ATRValues[i - shift];
      }
   }

Come potete vedere, tutto è estremamente semplice. Allo stesso modo lo applicheremo alla pulizia degli array:

   //reset all indicator arrays if connection fails [can also be used when initializing an EA]
   void EraseValues()
   {
      for (int i = 0; i < LastBars; i++)
      {
         SMA1Values[i] = -1.0;
         EMAValues[i] = -1.0;
         RSIValues[i] = -1.0;
         BollingerBandsUpperValues[i] = -1.0;
         BollingerBandsMiddleValues[i] = -1.0;
         BollingerBandsLowerValues[i] = -1.0;
         ATRValues[i] = -1.0;
      }
   }

Penso che sia abbastanza chiaro dove verrà utilizzata questa funzionalità. Passiamo ora all'implementazione degli indicatori stessi. Per fare ciò, ho chiesto a ChatGPT di implementare la funzione appropriata, che sarebbe stata adatta in base al mio paradigma di costruzione del codice. Ho iniziato con l'indicatore SMA:

   //1 Function that calculates the indicator value to bar "1"
   double calculateMA(int PeriodMA,int Shift=0)
   {
      int barIndex=Shift+1;//bar index SMA is calculated for (with a shift)
      int StartIndex=barIndex + PeriodMA-1;//starting bar index for calculating SMA
      if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating SMA (if not valid, then the value is -1)
      double sum = 0.0;

      for (int i = StartIndex; i >= barIndex; i--)
      {
         sum += Charts[chartindex].CloseI[i];
      }
      LastUpdateDateTime=TimeCurrent();
      return sum / PeriodMA;
   }

Come potete vedere, la funzione si è rivelata molto semplice e breve. Inizialmente, l'aspetto di questa funzione era un po' differente. Durante la prima generazione, ho riscontrato molti errori, ad esempio legati al fatto che non capiva la direzione della numerazione delle barre rispetto al tempo, e così via. Ma dopo alcune manipolazioni, ho risolto tutto questo e ho aggiunto il parametro Shift, che non era presente nell'implementazione originale. Dopo aver implementato alcuni miglioramenti visivi, ho chiesto di implementare il resto degli indicatori in modo simile. In seguito, gli errori nelle sue implementazioni sono diminuiti. Ho appena inviato le seguenti richieste per implementare una funzione simile per un altro indicatore, includendo esempi di implementazioni precedenti nel contesto della domanda. Questo ha permesso di risparmiare molto tempo. Vediamo ora le successive implementazioni di tutti gli indicatori rimanenti. Cominciamo con l'EMA:

   //2 Function that calculates the value of the exponential moving average to bar "1"
   double calculateEMA(int PeriodEMA,double Flatness=2.0,int Shift=0)
   {
      int barIndex = Shift+1; // bar index EMA is calculated for (with a shift)
      int StartIndex=barIndex + PeriodEMA-1;//index of the starting bar for calculating the first SMA, for starting the recurrent calculation of EMA
      if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating EMA (if not valid, then the value is -1)
   
      double sum = 0.0;
      double multiplier = Flatness / (PeriodEMA + 1); // Weight multiplier 
      double prevEMA;
   
      // Calculate the initial value for the EMA (the first value is considered as a normal SMA) 
      for (int i = StartIndex; i >= barIndex; i--)
      {
         sum += Charts[chartindex].CloseI[i];
      }
      prevEMA = sum / PeriodEMA;//this is the starting value for the bar (StartIndex-1)
   
      // Apply the EMA formula for the remaining values 
      for (int i = StartIndex; i >= barIndex; i--)
      {
         prevEMA = (Charts[chartindex].CloseI[i] - prevEMA) * multiplier + prevEMA;
      }
   
      LastUpdateDateTime = TimeCurrent();
      return prevEMA;
   }

A proposito, quando si ricercano le generazioni ChatGPT, bisogna rivolgersi a diverse risorse Internet per capire quale indicatore si basa su quale idea. Questo ci rende più competenti. Questo è particolarmente evidente con l'EMA. Se osserviamo attentamente il codice, noteremo che non differisce molto dall'implementazione più semplice della SMA e sembra piuttosto un'aggiunta alla solita media mobile. Non c'è alcun esponente, sebbene per qualche motivo è presente nel nome dell'indicatore. Il prossimo è l'indicatore RSI:

   //3 Function for calculating RSI to bar "1"
   double calculateRSI(int PeriodRSI,int Shift=0)
   {
       int barIndex = Shift+1; // bar index RSI is calculated for (with a shift)
       int StartIndex = barIndex + PeriodRSI - 1; // starting bar index for calculating RSI
       if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating RSI (if not valid, then the value is -1)
   
       double avgGain = 0.0;
       double avgLoss = 0.0;
       double change;
   
       // Calculate initial values for avgGain and avgLoss
       for (int i = StartIndex; i > barIndex; i--)
       {
           change = Charts[chartindex].CloseI[i]-Charts[chartindex].OpenI[i];
           if (change > 0)
           {
               avgGain += change;
           }
           else if (change < 0)
           {
               avgLoss -= change;
           }
       }
   
       avgGain /= PeriodRSI;
       avgLoss /= PeriodRSI;
   
       // RSI calculation
       double RS = 0.0;
       if (avgLoss != 0)
       {
           RS = avgGain / avgLoss;
       }
   
       double RSI = 100 - (100 / (1 + RS));
   
       LastUpdateDateTime = TimeCurrent();
       return RSI;
   }

Ora dobbiamo eseguire una procedura simile per l'indicatore Bollinger Bands. Questa procedura dovrebbe restituire i valori di tre linee, che possono essere inserite nella struttura preparata in via preliminare:

   //structure to return all three bollinger band lines
   struct BollingerBands 
   {
       double upper;
       double middle;
       double lower;
   };

Ora, avendo aggiunto questa struttura al contesto della domanda, possiamo chiedere di implementare la funzione, tenendo conto del fatto che deve restituire il tipo BollingerBands. Il modello è in grado di affrontare questo compito senza problemi:

   //4 Function for calculating the Bollinger Bands of the indicator 
   BollingerBands calculateBollingerBands(int PeriodBB, double DeviationBB,int Shift=0) 
   {
       int barIndex = Shift+1; // bar index Bollinger Bands is calculated for (with a shift)
       int StartIndex = barIndex + PeriodBB - 1; // index of the starting bar for calculating the first SMA, for starting the recurrent calculation of EMA
       BollingerBands rez;
       rez.lower=-1.0;
       rez.middle=-1.0;
       rez.upper=-1.0;
       if (StartIndex >= LastBars) return rez; // Check for the availability of the bars for calculating BB (if not valid, then the value is -1)
   
       double sum = 0.0;
       double prevBB;
       double sumSquares = 0.0;
   
       // Calculate the initial value for BB (the first value is considered as a normal SMA)
       for (int i = StartIndex; i >= barIndex; i--) {
           double closePrice = Charts[chartindex].CloseI[i];
           sum += closePrice;
       }
       prevBB = sum / PeriodBB; //this is the starting value for the bar (StartIndex-1)
   
       // Calculation of standard deviation
       for (int i = StartIndex; i >= barIndex; i--) {
           double closePrice = Charts[chartindex].CloseI[i];
           sumSquares += pow(closePrice - prevBB, 2);
       }
       double standardDeviation = sqrt(sumSquares / PeriodBB);
   
       // Calculate Bollinger Bands
       double upperBand = prevEMA + DeviationBB * standardDeviation;
       double lowerBand = prevEMA - DeviationBB * standardDeviation;
   
       rez.upper = upperBand;
       rez.middle = prevEMA;
       rez.lower = lowerBand;
   
       LastUpdateDateTime = TimeCurrent();
       return rez;
   }

Ora resta da implementare la versione della funzione per il calcolo dell'ATR:

   //5 Function for calculating Average True Range (Relative)
   double calculateRelativeATR(int PeriodATR,int Shift=0)
   {
       int barIndex = Shift+1; // bar index ATR is calculated for (with a shift)
       int StartIndex = barIndex + PeriodATR - 1; // starting bar index for calculating the first ATR
       if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating ATR and True Range (if not valid, then the value is -1)
   
       double sumPrice=0.0;
       double sumTrueRange = 0.0;
       double ATR;
   
       // Calculating True Range for bars and the sum of values for calculating the first ATR
       for (int i = StartIndex; i >= barIndex; i--)
       {
           sumPrice+=Charts[chartindex].HighI[i]+Charts[chartindex].LowI[i]+Charts[chartindex].CloseI[i]+Charts[chartindex].OpenI[i];//added by me 
           double high = Charts[chartindex].HighI[i];
           double low = Charts[chartindex].LowI[i];
           double trueRange = high - low;
           sumTrueRange += trueRange;
       }
   
       // ATR calculation
       //ATR = sumTrueRange / PeriodATR; - conventional calculation
       ATR = 100.0 * (sumTrueRange / PeriodATR)/(sumPrice/(PeriodATR*4.0));//calculation of relative ATR in %
   
       LastUpdateDateTime = TimeCurrent();
       return ATR;
   }

Prestate attenzione alla riga commentata alla fine. Ho modificato leggermente questo indicatore in modo che operi sui relativi valori. Ciò è necessario per evitare di dover impostare i propri pesi per ogni strumento di trading. Invece, ciò avverrà automaticamente in base al prezzo corrente. Ciò consentirà un'ottimizzazione più efficiente della multivaluta. Ci servirà per dimostrare che anche un algoritmo così semplice, se usato correttamente, può darci un piccolo ma sufficiente periodo di prova per il trading. In combinazione con altri metodi di efficienza, questa operazione può essere resa abbastanza accettabile, anche all’attuale livello consentito dall'EA.

Ho implementato io stesso i predicati. È stato molto semplice. Esaminiamone uno, diciamo il primo:

   //to open buy positions
   bool bBuy()
      {
      //determine if an open position is already present
      bool ord;
      ulong ticket;
      bool bOpened=false;
      for ( int i=0; i<PositionsTotal(); i++ )
         {
         ticket=PositionGetTicket(i);
         ord=PositionSelectByTicket(ticket);
         if ( ord && PositionGetInteger(POSITION_MAGIC) == MagicF)
            {
            bOpened=true;
            return false;
            }
         }
         
      if (!bOpened && EMAValues[1] > 0.0)//only if nothing is open and the indicator has been calculated 
         {
         //K - control ratio
         //RSIPercentBorder - control RSI
         double Val1=Charts[chartindex].CloseI[1]-EMAValues[1];
         double Val2=ATRValues[1]*(1.0/K);
         if (Val1 > 0 && Val1 < Val2 && RSIValues[1] < RSIPercentBorder) return true;         
         } 
      return false;
      }

Il predicato per l'apertura di una posizione di vendita è simile, con piccole eccezioni. Il predicato di chiusura è ancora più semplice:

   //to close a buy position
   bool bCloseBuy()
      {
      if (SMA1Values[1] > 0.0)
         {
         if (Charts[chartindex].CloseI[1] < SMA1Values[1] || Charts[chartindex].CloseI[1] > BollingerBandsUpperValues[1] )
            {
            return true;
            }
         }
      return false;   
      }

Tutto questo funzionerà in modo molto semplice:

   IndicatorDataRecalculate();//recalculate indicators

   if ( bCloseBuy() )
      {
         CloseBuyF();
      }
   if ( bCloseSell() )
      {
         CloseSellF();  
      }
   if ( bBuy() )
      {
         BuyF();
      }
   if ( bSell() )
      {
         SellF();
      } 

Penso che sia il più semplice possibile e che non ci sia bisogno di complicarlo ulteriormente. Tutto questo codice deve essere eseguito quando appare una nuova barra. Ho implementato la visualizzazione degli indicatori separatamente. L'unica cosa che non mi piace è che indicatori come ATR e RSI sono progettati per essere tracciati in una finestra separata. Ho realizzato la mia versione di rendering per loro in modo che siano anch'essi legati al prezzo, dato che non è possibile creare artificialmente una finestra separata e, francamente, non sono davvero necessari. Per ottenere questo risultato, ho creato un certo paradigma per disegnare le finestre degli indicatori.

1. Immettendo il valore del controllo Percentuale si creano tre corridoi da uno.
2. Determinando i valori massimi (Max) e minimi (Min) dell'indicatore per l'intero array di valori memorizzati.
3. Calcolo del delta del corridoio dato (Delta = Max - Min).
4. Calcolo del corridoio superiore dei valori aumentati (HighBorder = Max - Delta * Percent / 100).
5. Calcolo del corridoio inferiore dei valori aumentati (LowBorder = Min + Delta * Percent / 100).
6. Il corridoio centrale è già stato definito, poiché sono stati definiti sia il corridoio superiore che quello inferiore.

Se il valore corrente dell'indicatore si trova in uno dei corridoi, i suoi punti acquisiscono il colore appropriato corrispondente al corridoio. Tutto è semplice. In questo modo è possibile associare valori alle barre del grafico e, ad esempio, cambiare il loro colore di conseguenza, oppure creare oggetti collegati alle barre e con il colore corrispondente. Come molti avranno notato, mi sono ispirato all'indicatore RSI, perché questa particolare struttura viene solitamente utilizzata per il trading. Queste aree sono chiamate zone di ipercomprato e ipervenduto.

Ritengo che questo codice non sia così importante perché ha una relazione minima con l'implementazione del nostro compito, ma serve solo a correggere eventuali errori e miglioramenti. Se lo si desidera, è possibile implementare questo rendering utilizzando ChatGPT. Tuttavia, penso che valga la pena di mostrare come funziona questo rendering:

Qui tutto viene fatto nel modo più semplice possibile con il solo ausilio del tipo di oggetto Linea. Se, quando si crea una linea, i punti di inizio e fine della linea sono legati alla stessa ora e allo stesso prezzo, la linea diventa un punto. Regolando lo spessore della linea, si regola il peso del punto corrispondente. Questi sono solo alcuni trucchi di vita che uso da molto tempo.

Valutazione della funzionalità e analisi dei risultati

Sebbene ChatGPT ritenga che questo algoritmo sia ottimale, non sappiamo su cosa si basino queste decisioni. Un buon backtest o un trading reale possono servire a misurare l'efficienza. Spero che tutti comprendano che il trading reale deve essere preceduto da un'impostazione ottimale, che può essere eseguita utilizzando l'ottimizzatore di MetaTrader 5. Dato che questo terminale ha la possibilità di ottimizzare più valute e date le capacità del mio modello, che sfrutta appieno l'efficacia di questo strumento, possiamo tranquillamente ottimizzare l'EA per tutte le "28" coppie di valute. Forse non vale la pena di elencarli. Ma vale la pena sottolineare gli evidenti vantaggi di questo approccio:

1. Ricerca automatica di modelli multi valuta
2. I modelli multi valuta hanno un peso maggiore e si adattano ulteriormente ai cambiamenti del mercato
3. Si ottengono più operazioni, poiché ogni strumento di trading offre qualcosa di proprio.
4. Risparmio di tempo (non è necessario ottimizzare ogni strumento singolarmente)

Ci sono, ovviamente, degli aspetti negativi. In questo caso, la più importante è l'impossibilità di accordare finemente ogni strumento. Naturalmente, questo problema può essere risolto introducendo funzionalità aggiuntive, ma questo non è l'argomento di questo articolo. Ma non basta eseguire questa ottimizzazione, è anche importante selezionare correttamente i risultati dall'intera possibilità che offre. Ho scelto quello ottimale:

Come si può vedere, ho ottimizzato dal "2018" al "2023" utilizzando il timeframe "H4" e ho lasciato tutti i sei mesi del "2023" per il test d’avanzamento (forward test). Come possiamo vedere, nonostante la curva dei profitti tutt'altro che perfetta nella sezione di ottimizzazione, abbiamo ottenuto un paio di mesi in più di trading redditizio, e questo fatto significa che la strategia non è priva di significato e ha il potenziale per essere utilizzata con successo per il trading. Molti sistemi di trading ottimizzabili molto probabilmente non si avvicinerebbero nemmeno a questo risultato. A volte è possibile testare sistemi incredibilmente belli in termini di codice senza ottenere risultati simili.

Aggiungerei molto altro a questo algoritmo. Lo considero un parco giochi. Ma vale la pena di dire che non è affatto importante, ma il potenziale di espansione dell'EA risultante. Non è l'algoritmo proposto a giocare un ruolo importante, ma la vostra competenza e creatività. Dovrete possedere qualità importanti per integrarvi con successo nel processo di sviluppo di MQL5:

• Competenze di programmazione (obbligatorio)
• Competenze matematiche (auspicabili)
• Pensare a blocchi
• Capacità di semplificare i compiti e di suddividerli in fasi distinte
• Comprendere il fatto che ChatGPT è solo uno strumento, quindi non ha senso incolparlo per le cose che non funzionano (spetta a voi sistemare tutto ciò che non funziona).
• Corretta interpretazione dei risultati di trading ottenuti
• Realizzare che il modello commette comunque degli errori, ma questo non deve preoccupare (l'importante è aver ridotto il costo del lavoro di sviluppo).
• Sviluppare la struttura della propria applicazione (naturalmente non è necessario, si può usare il mio approccio).
• ChatGPT è il vostro compagno la cui forza dipende da voi. Quanto più pazienti, intelligenti e intraprendenti sarete, tanto più efficace sarà questo compagno.

Avete uno strumento che potete usare o meno, a vostra discrezione, ma posso sicuramente dire che questo strumento mi è stato molto utile per molti aspetti, compresa la programmazione.

Conclusione

In realtà, non è necessario aderire al mio modello di utilizzo di questo strumento. Ho provato molte cose e posso dire che le possibilità sono quasi illimitate. Naturalmente, prima di avere successo, dovrete sicuramente spendere una certa quantità di tempo e di sforzi, come me.

Ma vi consiglio comunque di provare questo strumento e di non risparmiare il vostro tempo. Se non altro, l'utilizzo di ChatGPT vi permetterà di acquisire il giusto atteggiamento nei confronti dell'intelligenza artificiale. È potenzialmente possibile integrare questa tecnologia in quasi tutte le catene di sviluppo. Sono certo che questo è solo l'inizio e che i cambiamenti sono dietro l'angolo. Vi consiglio di iniziare a familiarizzare con questo strumento il prima possibile e di cercare di applicarlo nei più svariati compiti.