Trading algoritmico e apprendimento automatico con Python

 
 Il commercio nel 21° secolo si è evoluto in modo esponenziale sin dal suo inizio. Sebbene, qualche decennio fa, fosse molto disorganizzato e lento a causa della funzionalità analogica. Nel frattempo, la moderna tecnologia informatica ha sviluppato sistemi di trading automatizzati più veloci, sostenibili e senza stress, orientando l'apprendimento automatico e l'intelligenza artificiale.

 Ogni volta che si parla di machine learning e intelligenza artificiale nel trading, spesso si è obbligati anche a includere il linguaggio di programmazione Python nella discussione. Con l'apprendimento automatico in Python, i sistemi di trading algoritmico hanno iniziato a offrire opportunità di trading algoritmico più veloci e prive di esseri umani.

 Di conseguenza, i robot di trading sono diventati uno strumento di trading standard moderno. Quindi, il trading algoritmico sta guadagnando popolarità grazie alla funzionalità di trading più veloce e priva di errori umani.

 Questo articolo tratterà gli approcci per avviare approcci di trading algoritmico con l'apprendimento automatico in Python.

L'apprendimento automatico facilita i trader più del tradizionale trading algoritmico. Ad esempio, gli algoritmi di apprendimento automatico possono trovare modelli valutando grandi volumi di dati, sebbene i metodi convenzionali possano elaborare meno quantità.

Allo stesso modo, i trader rilevano le tendenze di trading utilizzando l'apprendimento automatico e prendono decisioni mettendo alla prova l'algoritmo sui dati storici.
 Inoltre, lo sviluppo degli attuali sistemi cloud ha aperto la strada a una nuova era nell'informatica sofisticata. Allo stesso modo, chiunque può utilizzare il computing all'avanguardia per testare e utilizzare i propri algoritmi di apprendimento automatico utilizzando sistemi cloud distribuiti come MQL5 Cloud Network .

 Quindi, l'apprendimento automatico in Python è diventato ancora più popolare grazie alla disponibilità di tecnologie di backtesting. In particolare, la richiesta di una potenza di calcolo inferiore ha un impatto sull'evoluzione più rapida di Python.

Python, C++, Java, C# e R sono i cinque linguaggi di programmazione più comuni disponibili per i potenziali trader. Ma Python offre alcune caratteristiche eccellenti che lo rendono la prima scelta.

MetaTrader 5 è una piattaforma di trading di terze parti che offre pacchetti progettati per un'elaborazione e comunicazione dei dati adeguata e veloce direttamente dal terminale MetaTrader 5. I dati ricevuti possono essere ulteriormente utilizzati per calcoli statistici e apprendimento automatico. Ha anche una comunità online chiamata MQL5 Community per la comunicazione di trader e sviluppatori e gli sviluppatori possono vendere diverse soluzioni di trading e fare carriera.

1. Scarica l'ultima versione del linguaggio di programmazione Python. Inoltre, seleziona "Aggiungi Python 3.10.1 a PATH%" per eseguire gli script Python direttamente dalla riga di comando del PC.

2. Esegui la riga di comando ed esegui un comando per installare MetaTrader 5 con Python.

pip install MetaTrader5

3. Installa le librerie Python

pip install matplotlib

pip install pandas

4. Avviare questo codice script per testare l'integrazione.

 from datetime import datetime
 import matplotlib.pyplot as plt
 import pandas as pd
 from pandas.plotting import register_matplotlib_converters
 register_matplotlib_converters()
 import MetaTrader5 as mt5
 
 # connettiamoci a MetaTrader 5
 if not mt5.initialize():
  print("initialize() failed")
  mt5.shutdown()
 
 # stampiamo le info di connessione
 print(mt5.terminal_info())
 
 # stampiamo la MetaTrader 5 version
 print(mt5.version())
 
 # scarichiamo 1000 ticks da EURAUD
 euraud_ticks = mt5.copy_ticks_from("EURAUD", datetime(2020,1,28,13), 1000, mt5.COPY_TICKS_ALL)
 
 # scarichiamo ticks da AUDUSD da 2019.04.01 13:00 - 2019.04.02 13:00
 audusd_ticks = mt5.copy_ticks_range("AUDUSD", datetime(2020,1,27,13), datetime(2020,1,28,13), mt5.COPY_TICKS_ALL)
 
 # altri esempi
 eurusd_rates = mt5.copy_rates_from("EURUSD", mt5.TIMEFRAME_M1, datetime(2020,1,28,13), 1000)
 eurgbp_rates = mt5.copy_rates_from_pos("EURGBP", mt5.TIMEFRAME_M1, 0, 1000)
 eurcad_rates = mt5.copy_rates_range("EURCAD", mt5.TIMEFRAME_M1, datetime(2020,1,27,13), datetime(2020,1,28,13))
 
 # spengiamo MetaTrader 5
 mt5.shutdown()
 
 #DATI
 print('euraud_ticks(', len(euraud_ticks), ')')
 for val in euraud_ticks[:10]: print(val)
 print('audusd_ticks(', len(audusd_ticks), ')')
 for val in audusd_ticks[:10]: print(val)
 print('eurusd_rates(', len(eurusd_rates), ')')
 for val in eurusd_rates[:10]: print(val)
 print('eurgbp_rates(', len(eurgbp_rates), ')')
 for val in eurgbp_rates[:10]: print(val)
 print('eurcad_rates(', len(eurcad_rates), ')')
 for val in eurcad_rates[:10]: print(val)
 
 #GRAFICI
 # creiamo un DataFrame
 ticks_frame = pd.DataFrame(euraud_ticks)
 
 # convertiamo i secondi nel datetime format
 ticks_frame['time']=pd.to_datetime(ticks_frame['time'], unit='s')
 
 # grafico
 plt.plot(ticks_frame['time'], ticks_frame['ask'], 'r-', label='ask')
 plt.plot(ticks_frame['time'], ticks_frame['bid'], 'b-', label='bid')
 plt.legend(loc='upper left')
 plt.title('EURAUD ticks')
 plt.show()

L'idea del machine learning Python nel trading algoritmico è uno degli argomenti più estesi di questo tempo. Qui discuteremo brevemente alcuni dei metodi che puoi applicare all'apprendimento automatico di Python per la tua attività di trading algoritmico.
 Creazione e backtesting di una strategia di trading SMA (Simple Moving Average).

 La Simple Moving Average (SMA) è il prezzo medio per un determinato periodo di tempo. Funziona come un'indicazione tecnica ed è ampiamente utilizzato per creare strategie di trading. Di solito, vengono calcolati due SMA (Shorter e Longer) per costruire una strategia di trading.

 Costruiremo una semplice strategia di crossover per consentire al computer di eseguire un'operazione quando la SMA calcola per un breve periodo e incrocia al di sopra del periodo più lungo.

  Condizione dichiarata:

 SE SMA(BREVE PERIODO) > SMA(LUNGO PERIODO) => ACQUISTA
 SE SMA(LUNGO PERIODO) > SMA(BREVE PERIODO) => VENDI

 Utilizzeremo la libreria Python Panda per i frame di dati, Richieste di chiamate API, NumPy per gli array e Matplotlib per creare grafici.

 Estrai dati dal cloud

 Innanzitutto, è necessario estrarre i dati storici di Microsoft utilizzando l'API del cloud IEX. Puoi usare il cloud che desideri; può variare da utente a utente.

def get_historic_data(symbol):
  ticker = symbol
  iex_api_key = 'Tsk_30a2677082**********675d84baf94b'
  api_url = f'https://sandbox.iexapis.com/stable/stock/{ticker}/chart/max?token={iex_api_key}'
  df = requests.get(api_url).json()
  date = []
  open = []
  high = []
  low = []
  close = []
  for i in range(len(df)):
  date.append(df[i]['date'])
  open.append(df[i]['open'])
  high.append(df[i]['high'])
  low.append(df[i]['low'])
  close.append(df[i]['close'])
  date_df = pd.DataFrame(date).rename(columns = {0:'date'})
  open_df = pd.DataFrame(open).rename(columns = {0:'open'})
  high_df = pd.DataFrame(high).rename(columns = {0:'high'})
  low_df = pd.DataFrame(low).rename(columns = {0:'low'})
  close_df = pd.DataFrame(close).rename(columns = {0:'close'})
  frames = [date_df, open_df, high_df, low_df, close_df]
  df = pd.concat(frames, axis = 1, join = 'inner')
  return df
 
 
 msft = get_historic_data('MSFT')
 msft = msft.set_index('date')
 msft = msft[msft.index >= '2020-01-01']
 msft.index = pd.to_datetime(msft.index)
 msft.to_csv('msft.csv')
 msft = pd.read_csv('msft.csv').set_index('date')
 msft.index = pd.to_datetime(msft.index)

Ora calcoleremo due valori SMA, SMA 20 e SMA 50 e utilizzeremo questi due valori nel dataframe.

def sma(data, n):
  sma = data.rolling(window = n).mean()
  return pd.DataFrame(sma)
 n = [20, 50]
 for i in n:
  msft[f'sma_{i}' ] = sma(msft['close'], i)
 msft.tail()

Produzione

 
 
 Inoltre, se vuoi saperne di più sull'uso di Python e degli algoritmi di apprendimento automatico nel trading, in tal caso, dovresti esaminare questa implementazione di Perceptron multistrato e algoritmo di backpropagation in Python da una prospettiva diversa.

L'inaugurazione del trading algoritmico ha portato enormi cambiamenti nel settore finanziario. E ora, con la benedizione dell'intelligenza artificiale e dell'apprendimento automatico, ha aperto le porte a opportunità illimitate. Sebbene Python sia molto più semplice e pratico di altri linguaggi di programmazione, la maggior parte delle società commerciali e dei trader si concentra sulla propria attività utilizzando l'apprendimento automatico in Python.