Come creare un modello ARIMA in Python per le previsioni di Trading

Fra le tecniche di previsione una di quelle piu’ conosciute è quella dell’analisi delle serie temporali. All’interno di esse prenderemo il modello ARIMA.

ARIMA presuppone che i dati da processare abbiano la caratteristica di Stazionarietà. E’ un modello previsionale che si basa sul concetto di regressione, un metodo di approssimazione relativamente intuitive e di facile interpretazione. ARIMA permette inoltre di avere una misura dell’errore previsionale, elemento essenziale per una trattazione di tipo quantitativo.

Per la trattazione dell’argomento si farà uso del software di programmazione Python in ambiente Jupiter Notebook.

Prima di iniziare a leggere questo articolo su come creare un modello ARIMA in Python per le previsioni di Trading ti consigliamo di leggere questo articolo di introduzione :

Machine Learning per il trading

Come creare un modello ARIMA in Python per le previsioni di Trading

Trading basato su Serie Temporali (Time Series)

Alla base delle Serie Temporali c'è il concetto per cui, sotto certe condizioni (Stazionarietà) il futuro comportamento di un certo fenomeno é funzione del comportamento che ne ha caratterizzato il passato. L'analisi delle serie temporali è usata per determinare un buon modello che può essere usato per prevedere le metriche del business come le vendite, il fatturato, e ...... come vedremo del mercato azionario. La stazionarietà è piuttosto intuitiva ed è una proprietà invariante che significa che le caratteristiche statistiche della serie temporale non cambiano nel tempo. In parole povere, una serie temporale è stazionaria se il suo comportamento non cambia nel tempo. Una tendenza o un ciclo non sono stazionari.

Così il compito di previsione diventa, in sostanza, un'attenta analisi del passato più un presupposto che gli stessi modelli e relazioni si manterranno nel futuro. La stazionarietà di una serie e determinate dall'osservazione grafica e nei casi in cui essa risulti non immediate possiamo utilizzare delle tecniche per testarne questa caratteristica (Dickey-Fuller test). Quando le nostre Serie Temporali non sono stazionarie possiamo comunque operare delle trasformazioni sulla stessa serie di dati in modo da renderli stazionari (guardare la trasformata di Fourier per gli intenditori).

La programmazione di un sistema previsionale in Python per le previsioni di Trading

Ricordiamo I passi per la programmazione di un codice Machine Learning:

1. Importazione dati

2. Elaborazione e organizzazione dati

3. Definizione del modello da utilizzare

4. Addestramento del modello

5. Valutazione dell'affidabilità del modello

6. Previsione

Utilizzando Python, durante il processo avremmo bisogno di importare le librerie necessarie per le operazioni matematiche, la manipolazione struttura dei dati, la visualizzazione grafica e a seconda del modello che vogliamo implementare le librerie per gli algoritmi di regressione, di reti neurali, NLP etc… Le librerie piu'diffuse e adatte al nostro scopo possono essere importate digitando le seguenti istruzioni :

#importiamo le librerie

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt 
from plotly.graph_objs 
import graph_objs 
%matplotlib inline 
from matplotlib.pylab import rcParams

rcParams['figure.figsize'] = 10,6 

Ora passiamo all'importazione dei dati su cui vogliamo fare le nostre previsioni. Per questo ho scelto di analizzare I valori di chiusura giornalieri del Volatility Index.

Il Volatility Index è più comunemente conosciuto con il suo simbolo di ticker ed è spesso indicato semplicemente come "il VIX".

È stato creato dal Chicago Board Options Exchange (CBOE) ed è mantenuto da Cboe Global Markets.

Il Cboe Volatility Index (VIX) è un indice in tempo reale che rappresenta le aspettative del mercato per la forza relativa delle variazioni di prezzo a breve termine dell'indice S&P 500 (SPX).

La scelta di prevedere l'andamento del VIX è dettata dal fatto che il VIX rispetto alle azioni o agli indici azionari non ha una tendenza specifica ma ha, nella sua natura intrinseca di non stabilità, un comportamento più stazionario. L'importazione dei dati può essere fatta scaricando un'altra libreria che permette l'estrapolazione dei dati dal sito web yahoo finance e richiamare l'istruzione per poterli importare nel nostro ambiente di programmazione.

Assegneremo la serie di dati ad una variabile che chiameremo “data”

pip install yfinance 

data = yf.download(tickers='^VIX', period='1y', interval='1d') 

A questo punto potremmo avere la visualizzazione dei dati in forma tabellare o in forma grafica (F1 e F2)

Figura 1 ottenuta dalla funzione di plotting del codice python e rappresenta andamento grafico giornaliero a un anno del VIX

Figura 2 ottenuta dalla funzione di print del codice python rappresenta il data set giornaliero a un anno del VIX.

Dopo alcune semplici operazioni sul set di dati a disposizioni in modo da avere solamente solo la Colonna “Date” e “Close” con cui l'algoritmo ARIMA può lavorare.

Come creare un modello ARIMA in Python per le previsioni di Trading

ARIMA, abbreviazione di 'Auto Regressive Integrated Moving Average' è in realtà una classe di modelli che elabora previsioni di una data serie temporale sulla base dei suoi valori passati. Qualsiasi serie temporale a carattere "Stazionario" può essere processata con modelli ARIMA.

Un modello ARIMA è caratterizzato da 3 termini: p, d, q dove:

1. p è l'ordine del termine AR

2. q è l'ordine del termine MA

3. d è il numero di differenziazioni necessarie per rendere stazionaria la serie temporale.

Salteremo ulteriori approfondimenti sull' ARIMA per evitare di riportare una lunga trattazione ma invitiamo gli interessati ad approfondire l'argomento per una migliore consapevolezza.

Per Implementare ARIMA ancora abbiamo bisogno di librerie specifiche per le sue operazione che andiamo a richiamare con le seguenti linee di codice:

#Importiamo le librerie necessarie

from statsmodels.tsa.stattools import acf, pacf 
from statsmodels.tsa.arima_model import ARIMA
 
# Media Mobile a 12 Giorni
rolling_mean = timeseries.rolling(window=12).mean() 

# Derovazione standard
rolling_std = timeseries.rolling(window=12).std() 

# Creiamo il nostro grafico con la Timeserie, la Media e la Derivazione
orig = plt.plot(timeseries, color='blue', label='Original') 
mean = plt.plot(rolling_mean, color='red', label='Rolling Mean') 
std = plt.plot(rolling_std, color='black', label='Rolling Std') 

#aggiunfiamo delle info al grafico
plt.legend(loc='best') 
plt.title('Rolling Mean & Standard Deviation') 

#Mostriamo il grafico
plt.show()

A questo punto implementiamo poche righe di codice che ci permetteranno di visualizzare l'andamento della media mobile a 12 giorni del VIX e l'andamento della sua deviazione standard (F3).

Figura 3 ottenuta dalla funzione di plotting del codice python rappresenta l'andamento della media mobile e della deviazione standard a 12 giorni

Con il seguente blocco otteniamo I grafici ACF (Autocorrelation Function) e PCF (Partial Autocorrelation Function) (F4).

def plot_acf_dcf():
    # ACF and PACF 
    plots lag_acf = acf(dataset_log_first_order_diff, nlags=20) 
    lag_pacf = pacf(dataset_log_first_order_diff, nlags=20, method=’ols’)

    # Plot ACF
    plt.subplot(121)
    plt.plot(lag_acf)
    plt.axhline(y=0, linestyle=’–‘, color=’gray’) 
    plt.axhline(y=-1.96/np.sqrt(len(dataset_log_first_ order_diff)), linestyle=’–‘, color=’gray’) 
    plt.axhline(y=1.96/np.sqrt(len(dataset_log_first_ order_diff)), linestyle=’–‘, color=’gray’) 
    plt.title(‘ACF’)

    # Plot PACF
    plt.subplot(122)
    plt.plot(lag_pacf)
    plt.axhline(y=0, linestyle=’–‘, color=’gray’) 
    plt.axhline(y=-1.96/np.sqrt(len(dataset_log_first_ order_diff)),linestyle=’–‘, color=’gray’)
    plt.axhline(y=1.96/np.sqrt(len(dataset_log_first_ order_diff)), linestyle=’–‘, color=’gray’) plt.title(‘PACF’)
    plt.tight_layout() 
    plt.show()

Figura 4 rappresenta l'andamento e l'andamento dell'Autocorrelation Function e della Partiam Autocorrelation Function

Questa informazione ci da un indicazione della correlazione di ogni riga di dato (Colonna “Date” e Colonna “Close”) con le righe precedenti. I valori ACF e PCF che incrociano il livello 0 del grafico determinano rispettivamente I parametri p e q, necessari al modello ARIMA.

A questo punto lanciamo l'algoritmo ARIMA facendo eseguire il codice con p=1, q=1 e d=1

def model_ARIMA(indexed_data_log_scale, dataset_log_first_order_diff):  
	#ARIMA Model with p,d,q=1  
	model = ARIMA(indexed_data_log_scale, order=(1, 1, 1))  
	results_ARIMA = model.fit(disp=-1)  
	plt.plot(dataset_log_first_order_diff)  
	plt.plot(results_ARIMA.fittedvalues, color='red')  
	plt.title('RSS: %.4f'% 										sum((results_ARIMA.fittedvaluesdataset_log_first_order_diff['Close'])**2))  
	plt.show()  
	return results_ARIMA

All'interno di queste righe di codice è possibile notare la citazione del parametro , RSS (Residual Sum of Squares)che misura l'errore della previsione. Come abbiamo già affermato, parte integrante di una previsione quantitative eè la misurazione del suo errore. Con l'utilizzo del Dickey-Fuller test verifichiamo il carattere stazionario della serie temporale del VIX.

Il Dickey-Fuller test è disponibile nella libreria che importiamo così:

from statsmodels.tsa.stattools import adfuller

Lanciamo adesso la computazione con il blocco :

print ('Result of Dickey=Fuller Test') 
dftest = adfuller(timeseries['Close'], autolag='AIC') 
dfoutput = pd.Series(dftest[0:4], index=['Test Statistic', 'p-value', '#Lags Used', '#Observations Used']) 
for key, value in dftest[4].items():  
	dfoutput['Critical Value (%s)'%key] = value 
print (dfoutput)

che darà l'output in F5.

Figura 5 ottenuta dalla funzione di print del codice python rappresenta l'analisi di stazionarietà con Dickey Fuller test

Avendo constatato il P Value essere <0,05 non abbiamo la necessità di trasformare la serie di dati per migliorarne la stazionarietà e siamo pronti a lanciare il codice che ci permette di avere la previsione dei prossimi 30 giorni (da notare il parametron 395 = 365 + 30) che vogliamo.

results_ARIMA = model_ARIMA(indexed_data_log_scale,dataset_log_first_order_diff) 
results_ARIMA.plot_predict(1,395) 
plt.show()

Figura 6 rappresenta l'andamento e la previsione dell'andamento del VIX nei 30 giorni successivi (fino al 29.12.2021) alla data in cui la previsione viene fatta (29.11.2021)

in F6 abbiamo l'output grafico della previsione mentre il valore numerico del VIX per ogni giorno di previsione ci viene restituito dalle seguenti istruzioni :

futureforecast2 = results_ARIMA.forecast(steps=30) 
new= np.exp(futureforecast2[0]) 
print (new)

che vediamo in F7.

Figura 7 rappresenta la serie vettoriale dei valori del VIX previsti per i 30 giorni successive (fino al 29.12.2021) alla data in cui la previsione viene fatta (29.11.2021)

Conslusioni su come creare un modello ARIMA in Python per le previsioni di Trading

Con quanto illustrato non si pretende di dare al lettore uno strumento a support delle sue decisioni di investimento. L'utilizzo di questi strumenti per trading reale richiede una molto più profonda conoscenza dell'argomento.

Ci limitiamo in questo breve articolo ad illustrare un punto di partenza per approcciare l'intelligenza artificiale e l'applicazione di tecniche di machine learning.

Per chi fosse interessato ad ottenere il codice completo e strutturato per un plug and play in ambiente Jupiter Notebook, richiedetelo pure all'autore all'indirizzo email nicola.matarese73@gmail.com

Nei prossimi articoli illustreremo altri algoritmi previsionali che confronteremo di volta in volta con I precedenti.

---

Nicola Matarese classe 1973, ha conseguito una laurea magistrale in ingegneria meccanica ed ha ricoperto ruoli manageriali all’interno di realtà industriali in ambito aerospazio e difesa.

E’ appassionato di trading e opera sui mercati dal 2001. Da qualche anno lavora a sistemi di trading supportati da teorie sui Big Data e Intelligenza Artificiale.

Collegati o manda un messaggio a Nicola Matarese su LINKEDIN

---