Analisi delle serie temporali modelli ARIMA in Python

ARIMA time series analysis models in Python

L’analisi delle serie temporali è ampiamente utilizzata per la previsione e la predizione dei punti futuri in una serie temporale. I modelli AutoRegressive Integrated Moving Average (ARIMA) sono ampiamente utilizzati per la previsione delle serie temporali e sono considerati uno degli approcci più popolari. In questo tutorial, impareremo come costruire e valutare i modelli ARIMA per la previsione delle serie temporali in Python.

Cos’è un modello ARIMA?

Il modello ARIMA è un modello statistico utilizzato per analizzare e prevedere i dati delle serie temporali. L’approccio ARIMA si adatta esplicitamente alle strutture standard presenti nelle serie temporali, fornendo un metodo semplice ma efficace per effettuare previsioni accurate delle serie temporali.

• Incontra MetaGPT il framework di intelligenza artificiale open-source che trasforma i GPT in ingegneri, architetti e manager.
• 15+ Strumenti di Intelligenza Artificiale per Sviluppatori (agosto 2023)
• Crisi presso Stability AI – I principali protagonisti si dimettono in mezzo alle controversie del CEO!

ARIMA sta per AutoRegressive Integrated Moving Average. Combina tre aspetti chiave:

• Autoregressione (AR): un modello che utilizza la correlazione tra l’osservazione corrente e le osservazioni ritardate. Il numero di osservazioni ritardate è chiamato ordine di ritardo o p.
• Integrated (I): l’utilizzo della differenziazione delle osservazioni grezze per rendere la serie temporale stazionaria. Il numero di operazioni di differenziazione è indicato come d.
• Moving Average (MA): un modello che tiene conto della relazione tra l’osservazione corrente e gli errori residui di un modello di media mobile applicato alle osservazioni passate. La dimensione della finestra media mobile è l’ordine o q.

Il modello ARIMA è definito con la notazione ARIMA(p,d,q) in cui p, d e q sono sostituiti con valori interi per specificare il modello esatto utilizzato.

Presupposti chiave quando si adotta un modello ARIMA:

• La serie temporale è stata generata da un processo ARIMA sottostante.
• I parametri p, d, q devono essere specificati correttamente in base alle osservazioni grezze.
• I dati della serie temporale devono essere resi stazionari mediante la differenziazione prima di adattare il modello ARIMA.
• I residui dovrebbero essere non correlati e distribuiti normalmente se il modello si adatta bene.

In sintesi, il modello ARIMA fornisce un approccio strutturato e configurabile per la modellazione dei dati delle serie temporali per scopi come la previsione. Ora vedremo come adattare i modelli ARIMA in Python.

Esempio di codice Python

In questo tutorial, utilizzeremo i dati delle azioni Netflix da Kaggle per prevedere il prezzo delle azioni Netflix utilizzando il modello ARIMA.

Caricamento dati

Caricheremo il nostro dataset dei prezzi delle azioni con la colonna “Data” come indice.

import pandas as pd


net_df = pd.read_csv("Netflix_stock_history.csv", index_col="Date", parse_dates=True)
net_df.head(3)

Visualizzazione dei dati

Possiamo utilizzare la funzione ‘plot’ di pandas per visualizzare le variazioni del prezzo delle azioni e del volume nel tempo. È evidente che i prezzi delle azioni stanno aumentando in modo esponenziale.

net_df[["Close","Volume"]].plot(subplots=True, layout=(2,1));

Modello ARIMA con previsione progressiva

Il nostro dataset è stato diviso in set di addestramento e test, e abbiamo proceduto ad addestrare un modello ARIMA. La prima previsione è stata quindi effettuata.

Ottenevamo un risultato insoddisfacente con il modello ARIMA generico, in quanto produceva una linea piatta. Pertanto, abbiamo deciso di provare un metodo di previsione progressiva.

Nota: L’esempio di codice è una versione modificata del notebook di BOGDAN IVANYUK.

from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_squared_error, mean_absolute_error
import math


train_data, test_data = net_df[0:int(len(net_df)*0.9)], net_df[int(len(net_df)*0.9):]


train_arima = train_data['Open']
test_arima = test_data['Open']


history = [x for x in train_arima]
y = test_arima
# effettua la prima previsione
predictions = list()
model = ARIMA(history, order=(1,1,0))
model_fit = model.fit()
yhat = model_fit.forecast()[0]
predictions.append(yhat)
history.append(y[0])

 

Quando si lavora con dati di serie temporali, è spesso necessario effettuare una previsione in movimento a causa della dipendenza dalle osservazioni precedenti. Un modo per farlo è ricreare il modello dopo ogni nuova osservazione ricevuta.

Per tenere traccia di tutte le osservazioni, possiamo mantenere manualmente una lista chiamata history, che inizialmente contiene i dati di addestramento e a cui vengono aggiunte nuove osservazioni ad ogni iterazione. Questo approccio può aiutarci a ottenere un modello di previsione accurato.

# previsioni in movimento
for i in range(1, len(y)):
    # previsione
    modello = ARIMA(history, order=(1,1,0))
    modello_fit = modello.fit()
    yhat = modello_fit.forecast()[0]
    # inverti la previsione trasformata
    predictions.append(yhat)
    # osservazione
    obs = y[i]
    history.append(obs)

 

Valutazione del modello 

 

Il nostro modello di previsione in movimento ARIMA ha mostrato un miglioramento del 100% rispetto all’implementazione semplice, fornendo risultati impressionanti.

# rapporto delle prestazioni
mse = mean_squared_error(y, predictions)
print('MSE: '+str(mse))
mae = mean_absolute_error(y, predictions)
print('MAE: '+str(mae))
rmse = math.sqrt(mean_squared_error(y, predictions))
print('RMSE: '+str(rmse))

 

MSE: 116.89611817706545
MAE: 7.690948135967959
RMSE: 10.811850821069696

 

Visualizziamo e confrontiamo i risultati effettivi con quelli previsti. È evidente che il nostro modello ha effettuato previsioni estremamente accurate.

import matplotlib.pyplot as plt
plt.figure(figsize=(16,8))
plt.plot(net_df.index[-600:], net_df['Open'].tail(600), color='green', label = 'Train Stock Price')
plt.plot(test_data.index, y, color = 'red', label = 'Real Stock Price')
plt.plot(test_data.index, predictions, color = 'blue', label = 'Predicted Stock Price')
plt.title('Netflix Stock Price Prediction')
plt.xlabel('Time')
plt.ylabel('Netflix Stock Price')
plt.legend()
plt.grid(True)
plt.savefig('arima_model.pdf')
plt.show()

 

 

Conclusione

 

In questo breve tutorial, abbiamo fornito una panoramica dei modelli ARIMA e di come implementarli in Python per la previsione delle serie temporali. L’approccio ARIMA fornisce un modo flessibile e strutturato per modellare i dati di serie temporali che si basa sulle osservazioni precedenti e sugli errori di previsione passati. Se sei interessato a un’analisi approfondita del modello ARIMA e dell’analisi delle serie temporali, ti consiglio di dare un’occhiata a Stock Market Forecasting Using Time Series Analysis.     Abid Ali Awan (@1abidaliawan) è un professionista certificato in data science che ama costruire modelli di machine learning. Attualmente, si sta concentrando sulla creazione di contenuti e sulla scrittura di blog tecnici su tecnologie di machine learning e data science. Abid ha conseguito una laurea magistrale in gestione della tecnologia e una laurea triennale in ingegneria delle telecomunicazioni. La sua visione è quella di costruire un prodotto AI utilizzando una rete neurale a grafo per gli studenti che lottano con disturbi mentali.