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 :
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:
Importazione dati
Elaborazione e organizzazione dati
Definizione del modello da utilizzare
Addestramento del modello
Valutazione dell'affidabilità del modello
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)
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:
p è l'ordine del termine AR
q è l'ordine del termine MA
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).
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()
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.
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()
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.
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.
Comments