En este notebook vamos a predecir el valor del dólar en el mercado informal, utilizando como datos los valores de años anteriores.
import requests
import pandas as pd
import numpy as np
from pandas import DataFrame
from io import StringIO
import time, json
from datetime import date
import statsmodels
from statsmodels.tsa.stattools import adfuller, acf, pacf
from statsmodels.tsa.arima_model import ARIMA
from statsmodels.tsa.seasonal import seasonal_decompose
from sklearn.metrics import mean_squared_error
import matplotlib.pylab as plt
%matplotlib inline
from matplotlib.pylab import rcParams
rcParams['figure.figsize'] = 12, 6
El dataset tiene registrado el valor del dólar en el mercado informal (dolar blue) de cada día del año desde 2011.
deida = pd.read_csv('USD_ARS-informal-market.csv')
deida.Value = pd.to_numeric(deida.Value)
deida.head()
Se convierte la data al formato de serie temporal.
deida['Date'] = pd.to_datetime(deida['Date'], format = '%d-%m-%Y')
indexed_df = deida.set_index('Date')
ts = indexed_df['Value']
plt.plot(ts.index.to_pydatetime(), ts.values)
La variación diaria es muy grande, así que se resamplea para tener la data por semana.
ts_week = ts.resample('W').mean()
plt.plot(ts_week.index.to_pydatetime(), ts_week.values)
¿Por qué es importante?
En una serie de tiempo estacionaria, las propiedades estadísticas deben ser constantes en el tiempo y la autocovarianza debe ser dependiente del tiempo. Normalmente, cuando se corre una regresión normal, uno espera que las observaciones sean independientes entre sí. Sin embargo, en una serie temporal uno tiene certeza que las observaciones dependen del tiempo. Para poder usar técnicas de regresión en variables dependientes del tiempo la data debe ser estacionaria. Las técnicas que aplican a variables independientes aleatorias también aplican a variables aleatorias estacionarias.
Hay dos formas de comprobar si una serie de tiempo es estacionaria. La primera es plotear la varianza móvil y observar si se mantiene constante en el tiempo; aunque siempre es posible hacer inferencias visuales. La otra forma es usar el test de Dickey-Fuller, un test estadístico cuya hipótesis nula es que la serie temporal es no-estacionaria, si el test da como resultado que la estadística del test es significativamente menor que el valor crítico preestablecido, podemos rechazar la hipótesis nula en favor de tomar la serie temporal como estacionaria.
A continuación, se calcula la varianza móvil, se plotean los resultados y se aplica el test de Dickey-Fuller en la serie temporal:
def test_stationarity(timeseries):
#Estadísticos móviles
rolmean = timeseries.rolling(window=52,center=False).mean()
rolstd = timeseries.rolling(window=52,center=False).std()
#Plot:
orig = plt.plot(timeseries.index.to_pydatetime(), timeseries.values, color='blue',label='Original')
mean = plt.plot(rolmean.index.to_pydatetime(), rolmean.values, color='red', label='Media móvil')
std = plt.plot(rolstd.index.to_pydatetime(), rolstd.values, color='black', label = 'Desvío móvil')
plt.legend(loc='best')
plt.title('Media y desvío estandard móviles')
plt.show(block=False)
#Test de Dickey-Fuller :
print ('Resultados de Test de Dickey-Fuller:')
dftest = adfuller(timeseries, autolag='AIC')
dfoutput = pd.Series(dftest[0:4], index=['Estadística del test','P-valor','#Lags','Número de observaciones'])
for key,value in dftest[4].items():
dfoutput['Valor Crítico (%s)'%key] = value
print (dfoutput)
test_stationarity(ts_week)
Se puede ver que la estadística del test es mayor que el valor crítico del 5% y el p-valor es más grande que 0.05, la media móvil no es constante en el tiempo y la hipótesis nula del test Dickey-Fuller no se puede rechazar. Esto muestra que la serie de tiempo semanal no es estacionaria.
Antes de que poder aplicar el modelo ARIMA para predicciones, es necesario transformar esta serie de tiempo en una serie de tiempo estacionaria.
Si la serie de tiempo revela una tendencia o estacionalidad (no confundir estacional con estacionario), es una indicación de que es no-estacionaria. Para estacionarizar la serie temporal se calculan la tendencia y estacionalidad y se remueven estos factores del modelo. Se pueden aplicar diferentes transformaciones para estacionarizar la data como se verá a continuación.
ts_week_log = np.log(ts_week)
test_stationarity(ts_week_log)
El resultado del test de Dickey-Fuller confirma que la serie temporal es todavía no estacionaria. (Estadística del test > 5% , P-valor> 0.05)
Los resultados de la descomposición muestran una tendencia y un efecto estacional con un ciclo de aproximadamente 12 meses para las semanas más recientes del dataset.
decomposition = seasonal_decompose(ts_week)
trend = decomposition.trend
seasonal = decomposition.seasonal
residual = decomposition.resid
ts_week_log_select = ts_week_log[-80:]
plt.subplot(411)
plt.plot(ts_week_log_select.index.to_pydatetime(), ts_week_log_select.values, label='Original')
plt.legend(loc='best')
plt.subplot(412)
plt.plot(ts_week_log_select.index.to_pydatetime(), trend[-80:].values, label='Tendencia')
plt.legend(loc='best')
plt.subplot(413)
plt.plot(ts_week_log_select.index.to_pydatetime(), seasonal[-80:].values,label='Estacionalidad')
plt.legend(loc='best')
plt.subplot(414)
plt.plot(ts_week_log_select.index.to_pydatetime(), residual[-80:].values, label='Residuos')
plt.legend(loc='best')
plt.tight_layout()
Ahora que las tendencias y la estacionalidad están identificadas se hace posible modelar los residuos. Sin embargo, como los patrones de tendencia y la información de la estacionalidad extraídos de la serie temporal que están ploteados después de la descomposición todavía no son consistentes y no se pueden escalar de vuelta a los valores originales, todavía no se puede usar este enfoque para crear predicciones confiables.
La diferenciación (differencing) es uno de los métodos más comunes para tratar tanto la tendencia como la estacionalidad. En diferenciación de primer orden, se calculan las "diferencias" entre observaciones consecutivas en la serie temporal. Esto suele mejorar la estacionalidad en la serie de tiempo. En el código esto se confirma realizando el test de Dickey-Fuller.
ts_week_log_diff = ts_week_log - ts_week_log.shift()
plt.plot(ts_week_log_diff.index.to_pydatetime(), ts_week_log_diff.values)
ts_week_log_diff.dropna(inplace=True)
test_stationarity(ts_week_log_diff)
Los resultados muestran que la estadística del test es significativamente menor que el valor crítico de 1%. Esto significa que la serie temporal es estacionaria con 99% de confianza. Ahora se pueden aplicar modelos estadísticos como ARIMA sobre esta serie de tiempo estacionaria.
Para aplicar ARIMA a la serie temporal es necesario encontrar los valores óptimos para los tres parámetros siguientes (p,d,q):
(p) El número de términos autoregresivos (AR): Los términos AR son simplemente desfases de la variable dependiente (el tipo de cambio en este dataset). Entonces, p=2 significa que los predictores de x(t) son x(t-1) y x(t-2).
(q) El número de términos de media móvil (MA) : Los términos MA son errores desfasados de predicción en la ecuación predictiva. Por ejemplo, con q=2 los predictores de x(t) son e(t-1) y e(t-2) donde e(i) es la diferencia entre la media móvil en el instante iésimo y el valor verdadero.
El número de diferencias (d): Estos son los números de diferencias no estacionales. En nuestro caso, d=1ya que estamos usando una serie de tiempo diferenciada en el primer orden.
Hay dos maneras de determinar el número de términos AR y MA. La primera es usar la función arma_order_select_ic de Python. La segunda utiliza los gráficos de la función de autocorrelación (ACF) y la función de autocorrelacion parcial (PACF).
#ACF and PACF plots
lag_acf = acf(ts_week_log_diff, nlags=10)
lag_pacf = pacf(ts_week_log_diff, nlags=10, 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(ts_week_log_diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(ts_week_log_diff)),linestyle='--',color='gray')
plt.title('Autocorrelation Function')
#Plot PACF:
plt.subplot(122)
plt.plot(lag_pacf)
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y=-1.96/np.sqrt(len(ts_week_log_diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(ts_week_log_diff)),linestyle='--',color='gray')
plt.title('Partial Autocorrelation Function')
plt.tight_layout()
En este gráfico, los valores 'p' y 'q' pueden ser determinados como sigue:
p: El valor donde la curva PACF corta el 0 por primera vez. (p=2)
q: El valor donde la curva ACF cruza el intervalo de confianza superior por primera vez. (q=2, q=1 tambien podría funcionar)
Esto significa que los valores óptimos para el modelo ARIMA(p,d,q) son (2,1,2).
Si los valores sugeridos por los gráficos de ACF y PACF difieren de los valores obtenidos por la función arma_order_select_ic, se deben probar valores para los términos p y q y usar los resultados del modelo ajustados para obtener sus valores AIC y proceder con con el modelo que tenga un menor valor de AIC.
La siguiente línea de código ajusta la data usando el modelo ARIMA con valores (2,1,2):
model = ARIMA(ts_week_log, order=(2, 1, 2))
results_ARIMA = model.fit(disp=-1)
plt.plot(ts_week_log_diff.index.to_pydatetime(), ts_week_log_diff.values)
plt.plot(ts_week_log_diff.index.to_pydatetime(), results_ARIMA.fittedvalues, color='red')
plt.title('RSS: %.4f'% sum((results_ARIMA.fittedvalues-ts_week_log_diff)**2))
Es posible que un término AR y un término MA cancelen sus efectos mutuamente en este tipo de modelo. Se repite el modelo con un término MA menos.
model = ARIMA(ts_week_log, order=(2, 1, 1))
results_ARIMA = model.fit(disp=-1)
plt.plot(ts_week_log_diff.index.to_pydatetime(), ts_week_log_diff.values)
plt.plot(ts_week_log_diff.index.to_pydatetime(), results_ARIMA.fittedvalues, color='red')
plt.title('RSS: %.4f'% sum((results_ARIMA.fittedvalues-ts_week_log_diff)**2))
Se puede medir si los resultados del modelo se ajustan a la data subyacente mediante la métrica de la suma de residuos cuadrados (RSS). Un valor bajo de RSS sugiere que el modelo se ajusta a la data.
Otro enfoque para validar si el modelo ARIMA es apropiado consiste en realizar análisis de residuos.
A continuación, se imprimen los parámetros del modelo ARIMA y se grafican los residuos. Un gráfico de densidades de los valores de error residual indica una distribución normal centrada en cero. Además, los residuos no violan el supuesto de ubicación constante y escala, ya que la mayor parte de los valores se encuentra en el rango (-1,1).
print(results_ARIMA.summary())
# plot residual errors
residuals = DataFrame(results_ARIMA.resid)
residuals.plot(kind='kde')
print(residuals.describe())
Esto confirma un buen resultado del modelo. La simetría nos indica que no hay ningún sesgo en el modelo.
En esta instancia el modelo se desempeña correctamente, así que se pueden escalar las predicciones del modelo de vuelta a su escala original. Para esto se remueve la diferenciación de primer orden y se toma el exponente para restaurar las predicciones a su escala original.
Valores más cercanos a cero de la raíz media cuadrada del error (RMSE), indican que las predicciones del modelo son más cercanas a los valores verdaderos.
predictions_ARIMA_diff = pd.Series(results_ARIMA.fittedvalues, copy=True)
print (predictions_ARIMA_diff.head())
predictions_ARIMA_diff_cumsum = predictions_ARIMA_diff.cumsum()
predictions_ARIMA_log = pd.Series(ts_week_log.iloc[0], index=ts_week_log.index)
predictions_ARIMA_log = predictions_ARIMA_log.add(predictions_ARIMA_diff_cumsum,fill_value=0)
predictions_ARIMA = np.exp(predictions_ARIMA_log)
plt.plot(ts_week.index.to_pydatetime(), ts_week.values)
plt.plot(ts_week.index.to_pydatetime(), predictions_ARIMA.values)
plt.title('RMSE: %.4f'% np.sqrt(sum((predictions_ARIMA-ts_week)**2)/len(ts_week)))
La RMSE es suficientemente cercana a 0: podemos esperar que el modelo se desempeñe razonablemente bien.
Lo que se ha logrado hasta este punto es una predicción dentro de la muestra usando ARIMA, al entrenar el modelo en la toda la data de la serie temporal. Lo siguiente es separar el dataset en dos conjuntos, uno de training y otro de test. Se usará el dataset de training para entrenar el modelo ARIMA y realizar una predicción fuera de la muestra. Luego se compararán los resultados de las predicciones fuera de la muestra con los valores del conjunto de test.
Se usará la función "forecast" para realizar una predicción móvil de un paso con ARIMA. Una predicción móvil es requerida dada la dependencia en las observaciones durante la diferenciación y el modelo AR. Se re-creará el modelo ARIMA después de que cada nueva predicción sea recibida. Manualmente se mantendrá registro de todas las observaciones en una lista llamada history, la cual tiene una semilla en la data de training y para la cual nuevas predicciones son incorporadas en cada iteración.
size = int(len(ts_week_log) - 25)
train, test = ts_week_log[0:size], ts_week_log[size:len(ts_week_log)]
history = [x for x in train]
predictions = list()
print('Valores predichos vs Valores Esperados')
print('\n')
for t in range(len(test)):
model = ARIMA(history, order=(2,1,1))
model_fit = model.fit(disp=0)
output = model_fit.forecast()
yhat = output[0]
predictions.append(float(yhat))
obs = test[t]
history.append(obs)
print('Predicción=%f, Esperado=%f' % (np.exp(yhat), np.exp(obs)))
error = mean_squared_error(test, predictions)
print('\n')
print('Error medio cuadrático de las predicciones')
print('MSE: %.6f' % error)
predictions_series = pd.Series(predictions, index = test.index)
Se ha validado el modelo mediante comparar sus predicciones fuera de la muestra con los valores verdaderos del dataset de prueba calculando el error medio cuadrado. A continuación, se plotean las predicciones del modelo contra los valores observados.
fig, ax = plt.subplots()
ax.set(title='Tipo de Cambio, ARS - USD', xlabel='Fecha', ylabel='ARS - USD')
ax.plot(ts_week[-50:], 'o', label='observaciones')
ax.plot(np.exp(predictions_series), 'g', label='predicciones')
legend = ax.legend(loc='upper left')
legend.get_frame().set_facecolor('w')
Se puede notar que las predicciones están en la escala correcta y reproducen la tendencia de la serie de tiempo original.