Prediciendo el precio del Dolar Blue con ARIMA

En este notebook vamos a predecir el valor del dólar en el mercado informal, utilizando como datos los valores de años anteriores.

In [1]:
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
D:\Users\Daniel\Anaconda3\lib\site-packages\statsmodels\compat\pandas.py:56: FutureWarning: The pandas.core.datetools module is deprecated and will be removed in a future version. Please use the pandas.tseries module instead.
  from pandas.core import datetools

Dataset

El dataset tiene registrado el valor del dólar en el mercado informal (dolar blue) de cada día del año desde 2011.

In [2]:
deida = pd.read_csv('USD_ARS-informal-market.csv')
deida.Value = pd.to_numeric(deida.Value)
deida.head()
Out[2]:
Date Value
0 3-01-2011 4.11
1 4-01-2011 4.12
2 5-01-2011 4.14
3 6-01-2011 4.14
4 7-01-2011 4.12

Se convierte la data al formato de serie temporal.

In [3]:
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)
Out[3]:
[<matplotlib.lines.Line2D at 0xc927a90>]

Resampleando la data en la serie temporal

La variación diaria es muy grande, así que se resamplea para tener la data por semana.

In [4]:
ts_week = ts.resample('W').mean()
plt.plot(ts_week.index.to_pydatetime(), ts_week.values)
Out[4]:
[<matplotlib.lines.Line2D at 0xc9a27f0>]

Comprobando que la serie temporal es estacionaria.

¿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:

In [5]:
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)
In [6]:
test_stationarity(ts_week)
Resultados de Test de Dickey-Fuller:
Estadística del test         0.066983
P-valor                      0.963733
#Lags                       15.000000
Número de observaciones    363.000000
Valor Crítico (1%)          -3.448494
Valor Crítico (5%)          -2.869535
Valor Crítico (10%)         -2.571029
dtype: float64

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.

Estacionarizando la serie temporal

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.

Aplicando una transformación logarítmica no lineal (re-escalando la serie temporal)

In [7]:
ts_week_log = np.log(ts_week)
In [8]:
test_stationarity(ts_week_log)
Resultados de Test de Dickey-Fuller:
Estadística del test        -1.538721
P-valor                      0.514277
#Lags                       15.000000
Número de observaciones    363.000000
Valor Crítico (1%)          -3.448494
Valor Crítico (5%)          -2.869535
Valor Crítico (10%)         -2.571029
dtype: float64

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)

Quitando tendencias y estacionalidad con descomposición

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.

In [9]:
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.

Quitando tendencias y estacionalidad con diferenciación

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.

In [10]:
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)
Out[10]:
[<matplotlib.lines.Line2D at 0xe7a7550>]
In [11]:
ts_week_log_diff.dropna(inplace=True)
test_stationarity(ts_week_log_diff)
Resultados de Test de Dickey-Fuller:
Estadística del test      -5.978886e+00
P-valor                    1.858909e-07
#Lags                      1.400000e+01
Número de observaciones    3.630000e+02
Valor Crítico (1%)        -3.448494e+00
Valor Crítico (5%)        -2.869535e+00
Valor Crítico (10%)       -2.571029e+00
dtype: float64

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.

Encontrando parámetros óptimos y construyendo el modelo ARIMA

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).

Ploteando la función de autocorrelación (ACF) y la función de autocorrelación parcial (PACF)

In [12]:
#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):

In [13]:
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))
Out[13]:
<matplotlib.text.Text at 0xf0c3ef0>

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.

In [14]:
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))
Out[14]:
<matplotlib.text.Text at 0xea142e8>

Midiendo la varianza entre la data y los valores predichos por el modelo

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).

In [15]:
print(results_ARIMA.summary())
# plot residual errors
residuals = DataFrame(results_ARIMA.resid)
residuals.plot(kind='kde')
print(residuals.describe())
                             ARIMA Model Results                              
==============================================================================
Dep. Variable:                D.Value   No. Observations:                  378
Model:                 ARIMA(2, 1, 1)   Log Likelihood                 972.357
Method:                       css-mle   S.D. of innovations              0.018
Date:                Thu, 17 May 2018   AIC                          -1934.714
Time:                        22:06:24   BIC                          -1915.040
Sample:                    01-16-2011   HQIC                         -1926.906
                         - 04-08-2018                                         
=================================================================================
                    coef    std err          z      P>|z|      [0.025      0.975]
---------------------------------------------------------------------------------
const             0.0043      0.001      3.381      0.001       0.002       0.007
ar.L1.D.Value     0.0950      0.179      0.532      0.595      -0.255       0.445
ar.L2.D.Value    -0.0766      0.083     -0.920      0.358      -0.240       0.087
ma.L1.D.Value     0.3060      0.174      1.762      0.079      -0.034       0.646
                                    Roots                                    
=============================================================================
                 Real           Imaginary           Modulus         Frequency
-----------------------------------------------------------------------------
AR.1            0.6200           -3.5593j            3.6129           -0.2226
AR.2            0.6200           +3.5593j            3.6129            0.2226
MA.1           -3.2679           +0.0000j            3.2679            0.5000
-----------------------------------------------------------------------------
                0
count  378.000000
mean     0.000002
std      0.018495
min     -0.104526
25%     -0.007766
50%     -0.000731
75%      0.008331
max      0.069493

Esto confirma un buen resultado del modelo. La simetría nos indica que no hay ningún sesgo en el modelo.

Escalar las predicciones

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.

In [16]:
predictions_ARIMA_diff = pd.Series(results_ARIMA.fittedvalues, copy=True)
print (predictions_ARIMA_diff.head())
Date
2011-01-16    0.004272
2011-01-23    0.003174
2011-01-30    0.004692
2011-02-06    0.002466
2011-02-13    0.001500
Freq: W-SUN, dtype: float64
In [17]:
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)
In [18]:
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)))
Out[18]:
<matplotlib.text.Text at 0xd542320>

La RMSE es suficientemente cercana a 0: podemos esperar que el modelo se desempeñe razonablemente bien.

Haciendo predicciones en la serie temporal

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.

In [19]:
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)
Valores predichos vs Valores Esperados


Predicción=17.964369, Esperado=18.007500
Predicción=18.105389, Esperado=18.102000
Predicción=18.173672, Esperado=18.064000
Predicción=18.092970, Esperado=17.957500
Predicción=17.981310, Esperado=18.072000
Predicción=18.192816, Esperado=18.107500
Predicción=18.148719, Esperado=18.066000
Predicción=18.106816, Esperado=17.965000
Predicción=17.986796, Esperado=17.972000
Predicción=18.047687, Esperado=18.130000
Predicción=18.242773, Esperado=19.125000
Predicción=19.574189, Esperado=19.350000
Predicción=19.302818, Esperado=19.478000
Predicción=19.607841, Esperado=19.632000
Predicción=19.726033, Esperado=19.930000
Predicción=20.093538, Esperado=19.974000
Predicción=20.002575, Esperado=19.964000
Predicción=20.031469, Esperado=20.038000
Predicción=20.131728, Esperado=20.134000
Predicción=20.222472, Esperado=20.320000
Predicción=20.445793, Esperado=20.466000
Predicción=20.557873, Esperado=20.768000
Predicción=20.938634, Esperado=20.942000
Predicción=21.025173, Esperado=20.800000
Predicción=20.792341, Esperado=20.760000


Error medio cuadrático de las predicciones
MSE: 0.000124

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.

In [20]:
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.

Sumario

  • Cargar y visualizar la serie temporal
  • Comprobar la estacionaridad.
  • Aplicar transformaciones para obtener un comportamiento estacionario.
  • Encontrar los valores óptimos para los parámetros del modelo ARIMA
  • Usar el modelo para hacer predicciones.

Data obtenida de https://docs.google.com/spreadsheets/d/1VfAUEuoNHkR7HG_KHgA5ZT-3nwdl1zOtT_VvvgfJx5g/export?format=csv&id=1VfAUEuoNHkR7HG_KHgA5ZT-3nwdl1zOtT_VvvgfJx5g&gid=0