Si te gusta Skforecast , ayúdanos dándonos una estrella en GitHub! ⭐️
Modelar series temporales con tendencia utilizando modelos de árboles
Más sobre ciencia de datos: cienciadedatos.net
- Forecasting con Python y Scikit-learn
- Predicción (forecasting) de la demanda eléctrica con Python
- Predicción (forecasting) de visitas a página web con machine learning
- Forecasting series temporales con gradient boosting: Skforecast, XGBoost, LightGBM y CatBoost
- Predicción del precio de Bitcoin con Python
- Intervalos de predicción en modelos de forecasting
- Demanda intermitente con skforecast
Introducción¶
Los modelos basados en árboles, incluidos los árboles de decisión, random forests y gradient boosting machines (GBMs), son conocidos por su eficacia y su uso generalizado en multitud de aplicaciones de machine learning. Sin embargo, tienen limitaciones cuando se trata de extrapolar, es decir, hacer predicciones o estimaciones más allá del rango de los datos observado. Esta limitación resulta especialmente crítica cuando se trata de modelar series temporales que tienen tendencia. Debido a que estos modelos carecen de la capacidad para predecir valores más allá del rango observado durante el entrenamiento, sus valores pronosticados se desviarán de la tendencia subyacente.
Se han propuesto varias estrategias para hacer frente a este reto, y uno de los enfoques más comunes es el uso de la diferenciación. El proceso de diferenciación consiste en calcular las diferencias entre observaciones consecutivas de la serie temporal. En lugar de modelizar directamente los valores absolutos, la atención se centra en modelizar el ratio de cambio relativo. Una vez estimadas las predicciones, puede invertirse la transformación para obtener los valores en la escala original.
La librería skforecast, versión 0.10.0 o superior, introduce un nuevo argumento differentiation dentro de sus Forecasters para indicar que se debe aplicar un proceso de diferenciación antes de entrenar el modelo. Esto se consigue utilizando internamente una nueva clase llamada skforecast.preprocessing.TimeSeriesDifferentiator. Cabe destacar que todo el proceso de diferenciación se ha automatizado y sus efectos se invierten durante la fase de predicción. Esto garantiza que los valores predichos se encuentren en la misma escala que los datos originales.
Este documento muestra cómo la diferenciación permite modelizar series temporales con tendencia positiva utilizando modelos basados en árboles (random forest y gradient boosting xgboost).
Librerías¶
# Manipulación de datos
# ==============================================================================
import numpy as np
import pandas as pd
# Gráficos
# ==============================================================================
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-darkgrid')
# Modelado
# ==============================================================================
from xgboost import XGBRegressor
from sklearn.ensemble import RandomForestRegressor
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from skforecast.model_selection import backtesting_forecaster
from skforecast.preprocessing import TimeSeriesDifferentiator
from sklearn.metrics import mean_absolute_error
Datos¶
El conjunto de datos contiene el número de pasajeros mensuales de líneas aéreas internacionales, de 1949 a 1960.
# Descarga de datos
# ==============================================================================
url = (
'https://raw.githubusercontent.com/JoaquinAmatRodrigo/Estadistica-machine-learning-python/'
'master/data/AirPassengers.csv'
)
datos = pd.read_csv(url, sep=',')
# Preprocesado de datos
# ==============================================================================
datos['Date'] = pd.to_datetime(datos['Date'], format='%Y-%m')
datos = datos.set_index('Date')
datos = datos.asfreq('MS')
datos = datos['Passengers']
datos = datos.sort_index()
datos.head(4)
Se almacenan los mismos datos pero aplicando una diferenciación de orden 1 utilizando el TimeSeriesDifferentiator.
# Datos diferenciados
# ==============================================================================
diferenciator = TimeSeriesDifferentiator(order=1)
datos_diff = diferenciator.fit_transform(datos)
datos_diff = pd.Series(datos_diff, index=datos.index).dropna()
datos_diff.head(4)
# Partición de datos train-test
# ==============================================================================
end_train = '1955-12-01 23:59:59'
print(
f"Fechas entrenamiento : {datos.index.min()} --- {datos.loc[:end_train].index.max()} "
f"(n={len(datos.loc[:end_train])})")
print(
f"Fechas test : {datos.loc[end_train:].index.min()} --- {datos.index.max()} "
f"(n={len(datos.loc[end_train:])})")
# Plot
# ==============================================================================
fig, axs = plt.subplots(1, 2, figsize=(11, 2.5))
axs = axs.ravel()
datos.loc[:end_train].plot(ax=axs[0], label='train')
datos.loc[end_train:].plot(ax=axs[0], label='test')
axs[0].legend()
axs[0].set_title('Datos originales')
datos_diff.loc[:end_train].plot(ax=axs[1], label='train')
datos_diff.loc[end_train:].plot(ax=axs[1], label='test')
axs[1].legend()
axs[1].set_title('Datos diferenciados');
Forecasting con Random Forest y Gradient Boosting¶
Se crean dos forecasters, uno con un regresor RandomForestRegressor de scikit-learn y otro con XGBoost. Ambos se entrenan con datos de 1949-01-01 a 1956-01-01 y generan predicciones para los próximos 60 meses (5 años).
# Forecasting sin diferenciación (serie original)
# ==============================================================================
steps = len(datos.loc[end_train:])
# Forecasters
forecaster_rf = ForecasterAutoreg(
regressor = RandomForestRegressor(random_state=963),
lags = 12
)
forecaster_gb = ForecasterAutoreg(
regressor = XGBRegressor(random_state=963),
lags = 12
)
# Entrenamiento
forecaster_rf.fit(datos.loc[:end_train])
forecaster_gb.fit(datos.loc[:end_train])
# Predicción
predicciones_rf = forecaster_rf.predict(steps=steps)
predicciones_gb = forecaster_gb.predict(steps=steps)
# Error
error_rf = mean_absolute_error(datos.loc[end_train:], predicciones_rf)
error_gb = mean_absolute_error(datos.loc[end_train:], predicciones_gb)
print(f"Error (MAE) Random Forest: {error_rf:.2f}")
print(f"Error (MAE) Gradient Boosting: {error_gb:.2f}")
# Plot
fig, ax = plt.subplots(figsize=(7, 3), sharex=True, sharey=True)
datos.loc[:end_train].plot(ax=ax, label='train')
datos.loc[end_train:].plot(ax=ax, label='test')
predicciones_rf.plot(ax=ax, label='Random Forest')
predicciones_gb.plot(ax=ax, label='Gradient Boosting')
ax.set_title(f'Forecasting sin diferenciación')
ax.set_xlabel('')
ax.legend();
El gráfico muestra que ninguno de los modelos es capaz de seguir la tendencia en sus predicciones. Tras unos pocos pasos, las predicciones se vuelven casi constantes cerca del máximo observado en los datos de entrenamiento.
A continuación, se entrenan dos nuevos forecasters utilizando la misma configuración, pero con el argumento differentiation = 1. Esto activa el proceso interno de diferenciar (orden 1) las series temporales antes de entrenar el modelo, e invierte la diferenciación (también conocida como integración) para los valores predichos.
# Forecasting con diferenciación
# ==============================================================================
steps = len(datos.loc[end_train:])
# Forecasters
forecaster_rf = ForecasterAutoreg(
regressor = RandomForestRegressor(random_state=963),
lags = 12,
differentiation = 1
)
forecaster_gb = ForecasterAutoreg(
regressor = XGBRegressor(random_state=963),
lags = 12,
differentiation = 1
)
# Entramiento
forecaster_rf.fit(datos.loc[:end_train])
forecaster_gb.fit(datos.loc[:end_train])
# Predicción
predicciones_rf = forecaster_rf.predict(steps=steps)
predicciones_gb = forecaster_gb.predict(steps=steps)
# Error
error_rf = mean_absolute_error(datos.loc[end_train:], predicciones_rf)
error_gb = mean_absolute_error(datos.loc[end_train:], predicciones_gb)
print(f"Error (MAE) Random Forest: {error_rf:.2f}")
print(f"Error (MAE) Gradient Boosting: {error_gb:.2f}")
# Plot
fig, ax = plt.subplots(figsize=(7, 3), sharex=True, sharey=True)
datos.loc[:end_train].plot(ax=ax, label='train')
datos.loc[end_train:].plot(ax=ax, label='test')
predicciones_rf.plot(ax=ax, label='Random Forest')
predicciones_gb.plot(ax=ax, label='Gradient Boosting')
ax.set_title(f'Forecasting con diferenciación')
ax.set_xlabel('')
ax.legend();
Esta vez, ambos modelos son capaces de seguir la tendencia en sus predicciones.
Detalles de la diferenciación de series temporales¶
El ejemplo anterior muestra lo fácil que es introducir la diferenciación en el proceso de forecasting gracias a las funcionalidades disponibles en skforecast. Sin embargo, hay que aplicar varias transformaciones no triviales para conseguir una interacción fluida.
En los siguientes apartados, se presenta la clase TimeSeriesDifferentiator y se muestran sus principales ventajas.
La clase es capaz de diferenciaciar e integración (diferenciación inversa) cualquier serie temporal.
Explicación de por qué la gestión interna de la diferenciación tiene ventajas sobre el enfoque tradicional de pre-transformar toda la serie temporal antes de iniciar el entrenamiento del modelo.
Cómo gestionar la diferenciación cuando se aplica el Forecaster a nuevos datos que no siguen inmediatamente a los datos de entrenamiento).
TimeSeriesDifferentiator¶
TimeSeriesDifferentiator es un clase que sigue la API de sklearn de preprocesamiento. Esto significa que tiene el método fit, transform, fit_transform y inverse_transform.
# Diferenciación con TimeSeriesDifferentiator
# ==============================================================================
y = np.array([5, 8, 12, 10, 14, 17, 21, 19], dtype=float)
diferenciador = TimeSeriesDifferentiator()
diferenciador.fit(y)
y_diff = diferenciador.transform(y)
print(f"Serie original : {y}")
print(f"Serie diferenciada: {y_diff}")
La diferenciación puede revertirse (integración) con el método inverse_transform, recuperando así la serie original.
# Revertir transformación
# ==============================================================================
diferenciador.inverse_transform(y_diff)
⚠ Warning
El proceso de transformación inversainverse_transform es aplicable exclusivamente a las mismas series temporales que han sido previamente diferenciadas utilizando el mismo objeto TimeSeriesDifferentiator. Esta restricción surge de la necesidad de utilizar los n valores iniciales de la serie temporal (n igual al orden de diferenciación) para revertir efectivamente la diferenciación. Estos valores se capturan durante la invocación del método fit.
Note
Un método adicionalinverse_transform_next_window está disponible en la clase TimeSeriesDifferentiator. Este método está pensado para ser utilizado dentro de los Forecasters para invertir la diferenciación de los valores predichos. Si el regresor dentro del Forecaster está entrenado con una serie temporal diferenciada, entonces sus predicciones también lo estarán. El método inverse_transform_next_window permite devolver las predicciones a la escala original, suponiendo que siguen inmediatamente después de los últimos valores observados (last_window).
Diferenciación interna frente a preprocesamiento¶
Los Forecasters gestionan internamente el proceso de diferenciación, por lo que no es necesario preprocesar las series temporales ni postprocesar sus predicciones. Esto tiene varias ventajas, pero antes de entrar en ellas, se comparan los resultados de ambos enfoques.
# Diferenciación de la serie en el proprocesamiento
# ==============================================================================
diferenciador = TimeSeriesDifferentiator(order=1)
datos_diff = diferenciador.fit_transform(datos)
datos_diff = pd.Series(datos_diff, index=datos.index).dropna()
forecaster = ForecasterAutoreg(
regressor = RandomForestRegressor(random_state=963),
lags = 15
)
forecaster.fit(y=datos_diff.loc[:end_train])
predicciones_diff = forecaster.predict(steps=steps)
# Invertir diferenciación para obtener predicciones en la escala original
last_value_train = datos.loc[:end_train].iloc[[-1]]
predicciones_1 = pd.concat([last_value_train, predicciones_diff]).cumsum()[1:]
predicciones_1 = predicciones_1.asfreq('MS')
predicciones_1.name = 'pred'
predicciones_1.head(5)
# Serie temporal diferenciada internamente por el forecaster
# ==============================================================================
forecaster = ForecasterAutoreg(
regressor = RandomForestRegressor(random_state=963),
lags = 15,
differentiation = 1
)
forecaster.fit(y=datos.loc[:end_train])
predicciones_2 = forecaster.predict(steps=steps)
predicciones_2.head(5)
# Verificar que las predicciones son iguales
# ==============================================================================
pd.testing.assert_series_equal(predicciones_1, predicciones_2)
A continuación, los resultados del proceso de backtesting se someten a un análisis comparativo. Esta comparación es más compleja que la anterior, ya que el proceso de deshacer la diferenciación debe realizarse por separado para cada partición del backtesting.
# Backtesting con la serie temporal diferenciada en el preprocesamiento
# ==============================================================================
steps = 5
forecaster_1 = ForecasterAutoreg(
regressor = RandomForestRegressor(random_state=963),
lags = 15
)
_, predicciones_1 = backtesting_forecaster(
forecaster = forecaster_1,
y = datos_diff,
steps = steps,
metric = 'mean_squared_error',
initial_train_size = len(datos_diff.loc[:end_train]),
fixed_train_size = False,
gap = 0,
allow_incomplete_fold = True,
refit = True,
n_jobs = 'auto',
verbose = False,
show_progress = True
)
# Invertir diferenciación para obtener predicciones en la escala original. Las
# predicciones de cada partición deben revertirse individualmente. Un id se añade
# a cada predicción para identificar la partición a la que pertenece.
predicciones_1 = predicciones_1.rename(columns={'pred': 'pred_diff'})
folds = len(predicciones_1) / steps
folds = int(np.ceil(folds))
predicciones_1['backtesting_fold_id'] = np.repeat(range(folds), steps)[:len(predicciones_1)]
# Sumar el valor observado anteriormente (solo a la primera predicción de cada partición)
valores_anteriores = datos.shift(1).loc[predicciones_1.index].iloc[::steps]
valores_anteriores.name = 'valor_anterior'
predicciones_1 = predicciones_1.merge(
valores_anteriores,
left_index=True,
right_index=True,
how='left'
)
predicciones_1 = predicciones_1.fillna(0)
predicciones_1['suma_valores'] = (
predicciones_1['pred_diff'] + predicciones_1['valor_anterior']
)
# Revert differentiation using the cumulative sum by fold
predicciones_1['pred'] = (
predicciones_1
.groupby('backtesting_fold_id')
.apply(lambda x: x['suma_valores'].cumsum())
.to_numpy()
)
predicciones_1.head(5)
# Backtesting con la serie temporal diferenciada internamente por el forecaster
# ==============================================================================
forecaster_2 = ForecasterAutoreg(
regressor = RandomForestRegressor(random_state=963),
lags = 15,
differentiation=1
)
_, predicciones_2 = backtesting_forecaster(
forecaster = forecaster_2,
y = datos,
steps = steps,
metric = 'mean_squared_error',
initial_train_size = len(datos.loc[:end_train]),
fixed_train_size = False,
gap = 0,
allow_incomplete_fold = True,
refit = True,
n_jobs = 'auto',
verbose = False,
show_progress = True
)
predicciones_2.head(5)
# Validar que las predicciones son iguales
# ==============================================================================
pd.testing.assert_series_equal(predicciones_1['pred'], predicciones_2['pred'])
Como se ha demostrado, los valores son equivalentes cuando se diferencian las series temporales con un paso de preprocesamiento o cuando se permite que el Forecaster gestione la diferenciación internamente, ¿por qué la segunda alternativa es mejor?
Al gestionar el Forecaster internamente todas las transformaciones garantiza que se apliquen las mismas transformaciones cuando el modelo se ejecuta con nuevos datos.
Cuando el modelo se aplica a nuevos datos que no siguen inmediatamente a los datos de entrenamiento (por ejemplo, si un modelo no se vuelve a entrenar antes de cada fase de predicción), el Forecaster aumenta automáticamente el tamaño de la última ventana (last_window) necesaria para generar los predictores, además de aplicar la diferenciación a los datos entrantes e invertirla en las predicciones finales.
Estas transformaciones no son triviales y son muy propensas a errores, por lo que skforecast intenta evitar complicar en exceso la ya de por sí difícil tarea de predecir series temporales.
Información de sesión¶
import session_info
session_info.show(html=False)
¿Cómo citar este documento?
Modelar series temporales con tendencia utilizando modelos de árboles by Joaquín Amat Rodrigo and Javier Escobar Ortiz, available under a CC BY-NC-SA 4.0 at https://www.cienciadedatos.net/documentos/py49-modelar-tendencia-en-series-temporales-modelos-de-arboles.html 
¿Te ha gustado el artículo? Tu ayuda es importante
Mantener un sitio web tiene unos costes elevados, tu contribución me ayudará a seguir generando contenido divulgativo gratuito. ¡Muchísimas gracias! 😊
Este contenido, creado por Joaquín Amat Rodrigo y Javier Escobar Ortiz, tiene licencia Attribution-NonCommercial-ShareAlike 4.0 International.