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.
Trading algoritmico e apprendimento automatico
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.
Perché utilizzare l'apprendimento automatico nel trading algoritmico?
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.
Perché Python per il trading algoritmico?
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.
Il codice Python è facile da leggere e capire. Meno codifica rispetto ad altri linguaggi grazie alle librerie complete. Quindi, meno codifica, più trading.
È un linguaggio interpretato che esegue le istruzioni di codice, costruendo un debug completo. Inoltre, l'esecuzione di un singolo errore velocizza l'intero processo di costruzione.
Python ha un'incredibile potenza di calcolo per sovvenzionare il tuo portafoglio e la tua scalabilità. Inoltre, correggere un nuovo modulo in Python e renderlo esteso è più semplice di qualsiasi altro linguaggio.
Ha un'ampia libreria di supporto composta dalle attività del linguaggio di programmazione più popolari al loro interno in un metodo semplicistico.
Come integrare Python con il modulo di trading MetaTrader 5?
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.
Vediamo come integrare Python e MetaTrader 5:
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 MetaTrader53. Installa le librerie Python
pip install matplotlibpip install pandas4. 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()Usa il trading algoritmico con l'apprendimento automatico in Python
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)Calcolo SMA
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.
Conclusione trading, Machine Learning e Python
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.
.png)
