Costruzione e convalida di algoritmi semplici per il trading di azioni utilizzando Python

Creazione e test di algoritmi semplici per il trading di azioni con Python

Introduzione

Il trading algoritmico è una strategia di trading ampiamente adottata che ha rivoluzionato il modo in cui le persone scambiano azioni. Sempre più persone stanno guadagnando soldi investendo in azioni e automatizzando le loro strategie di trading. Questo tutorial ti insegnerà come costruire algoritmi di trading azionario utilizzando indicatori tecnici primitivi come MACD, SMA, EMA, ecc. e selezionare le migliori strategie in base alle loro prestazioni/rendimenti effettivi, utilizzando completamente Python.

Obiettivi di apprendimento

• Capire cosa è il trading algoritmico.
• Costruire algoritmi di trading azionario semplici in Python, utilizzando indicatori tecnici per generare segnali di acquisto e vendita.
• Imparare a implementare strategie di trading e automatizzarle in Python.
• Imparare a confrontare e selezionare la miglior strategia di trading in base ai loro rendimenti medi.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Avvertenza – Questo non sono consigli finanziari e tutto il lavoro svolto in questo progetto è solo a scopo educativo.

Cos’è il trading algoritmico?

Il trading algoritmico è un metodo di trading di asset finanziari che utilizza programmi informatici automatizzati per eseguire ordini basati su regole e strategie predefinite. Coinvolge l’utilizzo di diverse strategie di trading, tra cui arbitraggio statistico, trend following e mean reversion, per citarne alcune.

• Riconoscimento e Generazione di Composizioni di Oggetti-Stato nell’Apprendimento Automatico Utilizzando Taglia e Apprendi
• DALL·E 3 è qui con l’integrazione di ChatGPT
• Sbloccare generazioni affidabili attraverso una catena di verifica un enorme progresso nell’ingegneria immediata

Ci sono molti tipi diversi di trading algoritmico. Uno di essi è il trading ad alta frequenza, che prevede l’esecuzione di operazioni ad alta velocità con quasi nessuna latenza per sfruttare piccoli movimenti dei prezzi. Un altro è il trading basato sulle notizie, che prevede operazioni basate su notizie e altri eventi di mercato.

In questo articolo, utilizzeremo Python per fare trading azionario basato su indicatori tecnici e rilevamento dei pattern delle candele.

Come utilizzare algoritmi Python per l’analisi del trading azionario?

Possiamo analizzare il mercato azionario, individuare le tendenze, sviluppare strategie di trading e impostare segnali per automatizzare il trading azionario, tutto utilizzando Python! Il processo di trading algoritmico con Python prevede alcuni passaggi come la selezione del database, l’installazione di determinate librerie e l’estrazione dei dati storici. Approfondiremo ora ciascuno di questi passaggi e impareremo a costruire algoritmi di trading azionario semplici.

Selezione del dataset

Esistono migliaia di azioni quotate pubblicamente e possiamo considerare qualsiasi insieme di azioni per costruire l’algoritmo. Tuttavia, è sempre una buona opzione considerare tipi simili di azioni poiché i loro fondamentali e le loro indicatori tecnici saranno comparabili.

In questo articolo, prenderemo in considerazione le azioni del Nifty 50. L’indice Nifty 50 è composto da 50 delle principali aziende in India scelte in base a vari fattori come capitalizzazione di mercato, liquidità, rappresentanza del settore e performance finanziaria. L’indice è anche ampiamente utilizzato come benchmark per misurare le performance del mercato azionario indiano e, di conseguenza, vi è una minor quantità di rischio coinvolta nell’investire in queste aziende rispetto all’investimento in società small-cap o mid-cap. Considererò WIPRO per effettuare l’analisi in questo articolo. L’approccio di analisi discusso in questo articolo può essere effettuato su qualsiasi insieme di azioni simili richiamando le funzioni per ogni azione in un ciclo for.

Installazione delle librerie necessarie

Utilizzeremo le librerie predefinite come pandas, numpy, matplotlib insieme a yfinance e pandas_ta. La libreria yfinance verrà utilizzata per estrarre i prezzi storici delle azioni. La libreria pandas_ta verrà utilizzata per implementare l’indicatore SMA e MACD e costruire l’algoritmo di trading. Questi moduli possono essere installati direttamente utilizzando pip come qualsiasi altra libreria Python. Importiamo i moduli dopo averli installati.

!pip install yfinance!pip install pandas-ta

import yfinance as yfimport pandas as pdimport pandas_ta as taimport numpy as npfrom datetime import datetime as dtimport matplotlib.pyplot as pltfrom datetime import timedelta as deltaimport numpy as npimport osimport seaborn as sb

Ora che abbiamo installato ed importato tutte le librerie necessarie, mettiamoci all’opera e iniziamo a costruire le strategie.

Estrazione dei prezzi storici delle azioni utilizzando yfinance

Utilizzeremo la funzione “download()” del modulo yfinance per estrarre il prezzo storico di un’azione, che accetta l’ID dell’azione, la data di inizio e la data di fine. Per semplicità, prenderemo come data di inizio “2000-01-01” e come data di fine la data corrente. Scriviamo una semplice funzione che estrae i prezzi storici delle azioni e li restituisce come un dataframe per ulteriori elaborazioni, salvandoli anche come file CSV sul nostro disco.

def get_stock_info(stock, save_to_disk=False):    start_date = '2000-01-01'    end_date = (dt.now() + delta(1)).strftime('%Y-%m-%d')    df = yf.download(f"{stock}.NS", period='1d', start=start_date, end=end_date, progress=False)    if(save_to_disk == True):        path = './csv'        try: os.mkdir(path)        except OSError as error: pass        df.to_csv(f'{path}/{stock}.csv')    return dfdf = get_stock_info('WIPRO', save_to_disk = True)

Creazione di Algoritmi di Trading Azionario Utilizzando Indicatori Tecnici

Ci sono numerosi indicatori disponibili per il trading azionario, ma utilizzeremo due tra i più semplici e popolari, ovvero SMA e MACD. SMA sta per Media Mobile Semplice, mentre MACD sta per Divergenza Convergenza della Media Mobile. Nel caso non siate familiari con questi termini, potete saperne di più in questo articolo. In breve, cercheremo di individuare i segnali di incrocio tra SMA e MACD e di trovare la migliore combinazione tra i due per massimizzare i rendimenti.

Per l’incrocio della SMA, prenderemo in considerazione le medie mobili a 10 giorni, 30 giorni, 50 giorni e 200 giorni. Per l’incrocio del MACD, prenderemo in considerazione le medie mobili esponenziali a 12 giorni, 26 giorni e 9 giorni. Calcoliamo questi valori utilizzando la libreria pandas_ta.

Per calcolare la SMA, utilizzeremo la funzione “sma()” passando il prezzo di chiusura adeguato del titolo insieme al numero di giorni. Per calcolare il MACD, utilizzeremo la funzione “macd()” passando il prezzo di chiusura adeguato del titolo e impostando i parametri di fast, slow e signal rispettivamente a 12, 26 e 9. I valori di SMA e MACD non hanno molto senso come tali. Quindi, codifichiamoli per capire se ci sono incroci.

Nel caso della SMA, prenderemo in considerazione 3 condizioni:

• La SMA a 10 giorni deve essere superiore alla SMA a 30 giorni.
• La SMA a 10 giorni e la SMA a 30 giorni devono essere superiori alla SMA a 50 giorni.
• La SMA a 10 giorni, la SMA a 30 giorni e la SMA a 50 giorni devono essere superiori alla SMA a 200 giorni.

Nel caso del MACD, avremo 2 condizioni:

• Il MACD deve essere superiore al segnale MACD.
• Il MACD deve essere superiore a 0.

Il codice Python riportato di seguito crea una funzione per implementare le condizioni sopra menzionate.

def add_signal_indicators(df):    df['SMA_10'] = ta.sma(df['Adj Close'],length=10)    df['SMA_30'] = ta.sma(df['Adj Close'],length=30)    df['SMA_50'] = ta.sma(df['Adj Close'],length=50)    df['SMA_200'] = ta.sma(df['Adj Close'],length=200)        macd = ta.macd(df['Adj Close'], fast=12, slow=26, signal=9)    df['MACD'] = macd['MACD_12_26_9']    df['MACD_signal'] = macd['MACDs_12_26_9']    df['MACD_hist'] = macd['MACDh_12_26_9']        df['10_cross_30'] = np.where(df['SMA_10'] > df['SMA_30'], 1, 0)        df['MACD_Signal_MACD'] = np.where(df['MACD_signal'] < df['MACD'], 1, 0)        df['MACD_lim'] = np.where(df['MACD']>0, 1, 0)        df['abv_50'] = np.where((df['SMA_30']>df['SMA_50'])            &(df['SMA_10']>df['SMA_50']), 1, 0)        df['abv_200'] = np.where((df['SMA_30']>df['SMA_200'])            &(df['SMA_10']>df['SMA_200'])&(df['SMA_50']>df['SMA_200']), 1, 0)        return dfdf =  add_signal_indicators(df)

Ora che abbiamo aggiunto tutti i segnali ai nostri dati, è il momento di calcolare i rendimenti. I rendimenti saranno l’aspetto più importante per selezionare la migliore strategia di trading tra tutte. Calcoleremo i rendimenti a 5 giorni e a 10 giorni delle azioni. Etichetteremo anche i rendimenti come 0 e 1 con 0 che indica rendimenti negativi e 1 che indica rendimenti positivi. Andiamo avanti e creiamo la funzione che implementa la stessa cosa.

def calcola_rendimenti(df):    df['5D_rendimenti'] = (df['Adj Close'].shift(-5)-df['Adj Close'])/df['Close']*100    df['10D_rendimenti'] = (df['Adj Close'].shift(-10)-df['Adj Close'])/df['Close']*100    df['5D_positivi'] = np.where(df['5D_rendimenti']>0, 1, 0)    df['10D_positivi'] = np.where(df['10D_rendimenti']>0, 1, 0)        return df.dropna()df = calcola_rendimenti(df)    

Comprensione delle Prestazioni dei Segnali

Possiamo prendere tutte le condizioni menzionate in precedenza e eseguire una semplice aggregazione per calcolare la media e la mediana dei rendimenti che possiamo aspettarci durante il trading basato su questi segnali. Possiamo anche estrarre i rendimenti minimi e massimi che ciascun segnale ha generato in passato. Questo non solo ci darà una comprensione approssimativa di quanto buoni siano i segnali, ma anche un’idea di quanto rendimento ci si può aspettare durante il trading utilizzando questi segnali. Scriviamo un codice semplice per fare lo stesso utilizzando Python.

def ottieni_eda_e_deepdive(df):    eda = df.dropna().groupby(['10_cross_30', 'MACD_Signal_MACD',     'MACD_lim', 'abv_50', 'abv_200'])[['5D_rendimenti', '10D_rendimenti']]\    .agg(['count', 'mean','median', 'min', 'max'])        deepdive = df.dropna().groupby(['10_cross_30', 'MACD_Signal_MACD',     'MACD_lim', 'abv_50', 'abv_200','5D_positivi', '10D_positivi'])[['5D_rendimenti', '10D_rendimenti']]\    .agg(['count', 'mean','median', 'min', 'max'])    return eda, deepdive        eda, deepdive = ottieni_eda_e_deepdive(df)

Visualizziamo il grafico dei boxplot per le prime 10 combinazioni di segnali ordinati in base ai rendimenti a 5 e 10 giorni.

x = df.copy()def _fun(x):    codice = ''    for i in x.keys(): codice += str(x[i])    return codicex['segno'] = x[['10_cross_30', 'MACD_Signal_MACD', 'MACD_lim', 'abv_50', 'abv_200',                     '5D_positivi', '10D_positivi']].apply(_fun, axis=1)x = x.dropna()lim = x.groupby(['10_cross_30', 'MACD_Signal_MACD', 'MACD_lim', 'abv_50', 'abv_200', '5D_positivi', '10D_positivi'])['5D_rendimenti'].agg(['mean']).reset_index()lim = lim.sort_values(by='mean', ascending=False).head(10)x = x.merge(lim, on=['10_cross_30', 'MACD_Signal_MACD', 'MACD_lim', 'abv_50', 'abv_200', '5D_positivi', '10D_positivi'], how='inner')

ax = sb.boxplot(x='segno', y='5D_rendimenti', data=x)ax.set_xticklabels(ax.get_xticklabels(), rotation=45)plt.show()

ax = sb.boxplot(x='segno', y='10D_rendimenti', data=x)ax.set_xticklabels(ax.get_xticklabels(), rotation=45)plt.show()

Prendere solo i rendimenti a 5 e 10 giorni per selezionare i migliori segnali non è l’approccio migliore perché non sapremo mai quante volte il segnale ha fornito rendimenti positivi rispetto a quelli negativi. Questo approccio potrebbe essere preso in considerazione durante la selezione delle migliori strategie, che potrebbero migliorare potenzialmente le prestazioni delle strategie. Non userò questo approccio per mantenere questo articolo semplice e adatto ai principianti.

Conclusione

Il concetto di trading algoritmico può essere estremamente allettante per molti in quanto può essere molto redditizio, ma allo stesso tempo tende ad essere un compito estremamente complesso e tedioso per costruire algoritmi di trading azionario da zero. È molto importante comprendere il fatto che tutti gli algoritmi possono fallire, il che potrebbe potenzialmente portare a enormi perdite finanziarie quando vengono implementati in un ambiente di trading dal vivo. Lo scopo di questo articolo era quello di esplorare come si possono costruire e convalidare algoritmi di trading semplici utilizzando Python. Per procedere ulteriormente in questo progetto, potresti prendere in considerazione altri indicatori tecnici e modelli di candele e usarli in modo interscambiabile per costruire algoritmi e strategie più complessi.

Punto chiave

• In questo articolo, abbiamo imparato ad estrarre i prezzi storici delle azioni utilizzando yfinance.
• Abbiamo imparato a calcolare i valori MACD e SMA basati sul prezzo delle azioni e a creare algoritmi Python per creare segnali/strategie utilizzando questi valori.
• Abbiamo anche imparato a calcolare e visualizzare i rendimenti a 5 e 10 giorni delle strategie sulle azioni.

Nota: Questo non è un consiglio finanziario, e tutto il lavoro svolto in questo progetto è solo a scopo educativo. Questo è tutto per questo articolo. Spero che abbiate apprezzato la lettura di questo articolo e abbiate imparato qualcosa di nuovo. Grazie per la lettura e buono studio!

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell’autore.