Más sobre forecasting en: cienciadedatos.net
- Forecasting series temporales con machine learning
- Modelos ARIMA y SARIMAX
- Forecasting series temporales con gradient boosting: XGBoost, LightGBM y CatBoost
- Global Forecasting: Multi-series forecasting
- Forecasting de la demanda eléctrica con machine learning
- Forecasting con deep learning
- Forecasting con modelos fundacionales
- Forecasting de visitas a página web con machine learning
- Forecasting del precio de Bitcoin
- Forecasting probabilístico
- Forecasting de demanda intermitente
- Reducir el impacto del Covid en modelos de forecasting
- Modelar series temporales con tendencia utilizando modelos de árboles
Introducción¶
El forecasting de demanda intermitente es un método estadístico utilizado para predecir la demanda de productos que tienen patrones de venta esporádicos o irregulares. Este tipo de productos se caracteriza por periodos de gran demanda seguidos de periodos de escasa o nula demanda. El forecasting de demanda intermitente se utiliza en las industrias manufacturera, minorista y sanitaria para gestionar los niveles de inventario, optimizar los programas de producción y reducir las roturas de stock y los costes por exceso de inventario.
La demanda intermitente regular se refiere a patrones de demanda predecibles con intervalos conocidos entre periodos de demanda. Este tipo de demanda intermitente se produce con cierta regularidad, como un producto que tiene una demanda estacional o un producto que se pide todos los meses en una fecha determinada. Tradicionalmente, la demanda intermitente se predice con métodos estadísticos como el método de Croston, que modela por separado el tamaño de las demandas distintas de cero y los intervalos entre ellas. Sin embargo, estos métodos no tienen en cuenta variables exógenas que pueden aportar información valiosa sobre cuándo se producirá la demanda, por ejemplo, un calendario conocido de horarios de apertura. Por esta razón, el forecasting basado en modelos de machine learning puede ser una alternativa interesante, ya que permite incorporar estas variables y mejorar la precisión.
Por otro lado, la demanda intermitente irregular se refiere a patrones de demanda impredecibles, sin intervalos conocidos entre periodos de demanda. Este tipo de demanda intermitente es aleatoria e imprevisible, como un producto que se pide solo unas pocas veces al año y en cantidades variables. Predecir la demanda intermitente irregular es un reto porque no hay un patrón predecible en la demanda. Los métodos de forecasting tradicionales pueden no funcionar eficazmente en estas situaciones y puede ser necesario recurrir a métodos alternativos, como el bootstrapping o la simulación.
En resumen, la demanda intermitente regular tiene un patrón predecible, mientras que la demanda intermitente irregular no lo tiene. Predecir la demanda intermitente regular es más fácil que predecir la irregular debido a la previsibilidad del patrón de demanda.
Este documento muestra cómo se puede utilizar la librería de Python skforecast para predecir escenarios de demanda intermitente regular. La estrategia combina una métrica personalizada, de modo que el modelo se evalúa y optimiza únicamente en los periodos de interés, con variables que informan al modelo de los periodos en los que no hay demanda y de la posición de cada observación dentro del día y de la semana.
✎ Nota
En el ejemplo utilizado en este documento, los ceros son estructurales: la tienda está cerrada por la noche y los fines de semana, por lo que los periodos sin demanda siguen un horario conocido de antemano. Esto es distinto de la demanda intermitente irregular, en la que los ceros aparecen de forma aleatoria y la principal dificultad es predecir cuándo se producirá la demanda.
Librerías¶
# Tratamiento de datos
# ==============================================================================
import pandas as pd
# Gráficos
# ==============================================================================
import plotly.graph_objects as go
import plotly.express as px
import plotly.io as pio
import plotly.offline as poff
pio.templates.default = 'seaborn'
poff.init_notebook_mode(connected=True)
# Modelado y forecasting
# ==============================================================================
import skforecast
from lightgbm import LGBMRegressor
from sklearn.metrics import mean_absolute_error
from skforecast.recursive import ForecasterRecursive
from skforecast.preprocessing import CalendarFeatures
from skforecast.model_selection import TimeSeriesFold
from skforecast.model_selection import grid_search_forecaster
from skforecast.model_selection import backtesting_forecaster
# Configuración de warnings
# ==============================================================================
import warnings
warnings.filterwarnings('once')
color = '\033[1m\033[38;5;208m'
print(f'{color}Versión skforecast: {skforecast.__version__}')
Versión skforecast: 0.27.0
Datos¶
Los datos utilizados en este ejemplo representan el número de usuarios que visitaron una tienda cada hora. La tienda abre de lunes a viernes, de 7:00 a 21:00, por lo que el último registro horario con visitantes de cada día es el de las 20:00. Fuera del horario de apertura, el número de usuarios es siempre cero. Por lo tanto, cualquier predicción fuera de este periodo no es útil y puede ignorarse o fijarse en 0.
La serie tiene frecuencia horaria y abarca desde el 2011-01-01 hasta el 2012-12-31 (17.544 observaciones). En torno al 58% de las observaciones son cero, y todas ellas corresponden a horas en las que la tienda está cerrada.
# Descarga de datos
# ======================================================================================
url = ('https://raw.githubusercontent.com/JoaquinAmatRodrigo/Estadistica-machine'
'-learning-python/master/data/intermittent_demand.csv')
datos = pd.read_csv(url, sep=',')
datos['date_time'] = pd.to_datetime(datos['date_time'], format='%Y-%m-%d %H:%M:%S')
datos = datos.set_index('date_time')
datos = datos.sort_index()
datos = datos.asfreq('h')
datos.head(3)
| users | |
|---|---|
| date_time | |
| 2011-01-01 00:00:00 | 0.0 |
| 2011-01-01 01:00:00 | 0.0 |
| 2011-01-01 02:00:00 | 0.0 |
Los datos se dividen en tres particiones que respetan el orden temporal de las observaciones: un conjunto de entrenamiento, utilizado para ajustar el modelo; un conjunto de validación, utilizado para seleccionar los lags y los hiperparámetros; y un conjunto de test, reservado para estimar el rendimiento del modelo final con datos que no se han utilizado en ninguna etapa anterior. En series temporales, la división debe ser siempre cronológica. Una división aleatoria permitiría al modelo aprender de observaciones posteriores a las que se le pide predecir, lo que conduce a resultados demasiado optimistas.
# División train-validación-test
# ======================================================================================
fin_train = '2012-03-31 23:59:00'
fin_validacion = '2012-08-31 23:59:00'
datos_train = datos.loc[: fin_train, :]
datos_val = datos.loc[fin_train:fin_validacion, :]
datos_test = datos.loc[fin_validacion:, :]
print(
f'Fechas train : {datos_train.index.min()} --- {datos_train.index.max()} '
f'(n={len(datos_train)})'
)
print(
f'Fechas validación : {datos_val.index.min()} --- {datos_val.index.max()} '
f'(n={len(datos_val)})'
)
print(
f'Fechas test : {datos_test.index.min()} --- {datos_test.index.max()} '
f'(n={len(datos_test)})'
)
Fechas train : 2011-01-01 00:00:00 --- 2012-03-31 23:00:00 (n=10944) Fechas validación : 2012-04-01 00:00:00 --- 2012-08-31 23:00:00 (n=3672) Fechas test : 2012-09-01 00:00:00 --- 2012-12-31 23:00:00 (n=2928)
# Gráfico de la serie temporal
# ======================================================================================
fig = go.Figure()
trace1 = go.Scatter(
x=datos_train.index, y=datos_train['users'], name='train', mode='lines'
)
trace2 = go.Scatter(
x=datos_val.index, y=datos_val['users'], name='validación', mode='lines'
)
trace3 = go.Scatter(
x=datos_test.index, y=datos_test['users'], name='test', mode='lines'
)
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.add_trace(trace3)
fig.update_layout(
title='Serie temporal de usuarios',
xaxis_title='Fecha',
yaxis_title='Usuarios',
width = 750,
height = 350,
margin=dict(l=20, r=20, t=35, b=20),
legend=dict(orientation='h', yanchor='top', y=1.1, xanchor='left', x=0.001)
)
fig.show()
# Boxplot para la estacionalidad semanal
# ==============================================================================
datos['dia_semana'] = datos.index.day_of_week + 1
fig = px.box(
datos,
x='dia_semana',
y='users',
labels={'dia_semana': 'Día de la semana (1 = lunes)', 'users': 'Usuarios'},
title = 'Distribución de usuarios por día de la semana',
width=600,
height=300
)
medianas = datos.groupby('dia_semana')['users'].median()
fig.add_trace(
go.Scatter(
x=medianas.index,
y=medianas.values,
mode='lines+markers',
line=dict(color='blue', dash='dash'),
showlegend=False
)
)
fig.update_layout(margin=dict(l=20, r=20, t=35, b=20))
fig.show()
# Boxplot para la estacionalidad diaria
# ==============================================================================
datos['hora_dia'] = datos.index.hour
fig = px.box(
datos,
x='hora_dia',
y='users',
labels={'hora_dia': 'Hora del día', 'users': 'Usuarios'},
title = 'Distribución de usuarios por hora del día',
width=600,
height=300
)
medianas = datos.groupby('hora_dia')['users'].median()
fig.add_trace(
go.Scatter(
x=medianas.index,
y=medianas.values,
mode='lines+markers',
line=dict(color='blue', dash='dash'),
showlegend=False
)
)
fig.update_layout(margin=dict(l=20, r=20, t=35, b=20))
fig.show()
Los gráficos muestran las dos características que definen esta serie:
La tienda está cerrada los sábados y domingos (días 6 y 7) y, en los días laborables, antes de las 7:00 y a partir de las 21:00. En todos estos periodos, el número de usuarios es exactamente cero.
Durante el horario de apertura, la demanda sigue un marcado patrón diario con dos picos, uno en torno a las 8:00 y otro en torno a las 17:00-18:00.
Un modelo que solo utiliza los lags de la serie no dispone de información explícita sobre el horario de apertura, por lo que tiene que inferirlo a partir de los valores más recientes.
Métrica personalizada para evaluar el modelo¶
Para evaluar adecuadamente el rendimiento del modelo, es crucial definir una métrica que refleje fielmente el escenario de negocio en el que se utilizará. En este caso, el rendimiento del modelo debe optimizarse para las horas en las que la tienda está abierta: días laborables de 7:00 a 21:00, es decir, los registros horarios de las 7:00 a las 20:00.
Afortunadamente, skforecast ofrece la flexibilidad de utilizar funciones personalizadas como métricas para backtesting y optimización de hiperparámetros. Una métrica personalizada es una función que recibe los argumentos y_true e y_pred y devuelve un único valor.
def metrica_personalizada(y_true, y_pred):
"""
Calcular el error absoluto medio utilizando solo los valores predichos para
el horario de apertura de la tienda: de lunes a viernes, de 7:00 a 20:59.
"""
dia_semana = y_true.index.day_of_week
hora_dia = y_true.index.hour
mascara = dia_semana.isin([0, 1, 2, 3, 4]) & (hora_dia >= 7) & (hora_dia <= 20)
metrica = mean_absolute_error(y_true[mascara], y_pred[mascara])
return metrica
⚠ Advertencia
Si las horas de cierre se incluyeran en la métrica, más de la mitad de las observaciones evaluadas serían ceros triviales de predecir, ya que las predicciones de esas horas simplemente se fijan en 0. El error resultante quedaría diluido y parecería mucho mejor que el error que realmente experimenta el negocio durante el horario de apertura. Además, backtesting_forecaster calcula la métrica con las predicciones tal y como las devuelve el modelo, antes de cualquier posprocesado, lo que es otra razón para restringir la métrica al horario de apertura.
Forecasting¶
Se entrena un primer modelo utilizando como predictores únicamente los valores pasados de la serie. Se crea un ForecasterRecursive con un regresor LightGBM y los últimos 24 lags, es decir, el número de usuarios en cada una de las 24 horas anteriores.
El modelo se evalúa mediante backtesting con la función backtesting_forecaster. La estrategia de validación se define con un TimeSeriesFold: el modelo se entrena una única vez con los datos de entrenamiento y validación (initial_train_size) y después se utiliza para predecir el periodo de test en folds consecutivos de 36 horas (steps = 36), sin reentrenarlo. Esto simula un escenario en el que, cada 36 horas, se genera la predicción de las siguientes 36 horas con los datos disponibles hasta ese momento. Dado que el conjunto de test tiene 2.928 horas, el proceso se repite en 82 folds.
# Crear forecaster
# ==============================================================================
forecaster = ForecasterRecursive(
estimator = LGBMRegressor(
learning_rate = 0.1,
max_depth = 5,
n_estimators = 500,
random_state = 123,
verbose = -1
),
lags = 24
)
forecaster
ForecasterRecursive
General Information
- Estimator: LGBMRegressor
- Lags: [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
- Window features: None
- Calendar features: None
- Window size: 24
- Series name: None
- Exogenous included: False
- Categorical features: auto
- Weight function included: False
- Differentiation order: None
- Drop NaN from series: False
- Creation date: 2026-11-11 21:44:35
- Last fit date: None
- Skforecast version: 0.27.0
- Python version: 3.13.18
- Forecaster id: None
Exogenous Variables
None
Data Transformations
- Transformer for y: None
- Transformer for exog: None
Training Information
- Training range: Not fitted
- Training index type: Not fitted
- Training index frequency: Not fitted
Estimator Parameters
-
{'boosting_type': 'gbdt', 'class_weight': None, 'colsample_bytree': 1.0, 'importance_type': 'split', 'learning_rate': 0.1, 'max_depth': 5, 'min_child_samples': 20, 'min_child_weight': 0.001, 'min_split_gain': 0.0, 'n_estimators': 500, 'n_jobs': None, 'num_leaves': 31, 'objective': None, 'random_state': 123, 'reg_alpha': 0.0, 'reg_lambda': 0.0, 'subsample': 1.0, 'subsample_for_bin': 200000, 'subsample_freq': 0, 'verbose': -1}
Fit Kwargs
-
{}
# Backtesting en el periodo de test
# ==============================================================================
cv = TimeSeriesFold(steps = 36, initial_train_size = len(datos.loc[:fin_validacion]))
metrica_lags, predicciones = backtesting_forecaster(
forecaster = forecaster,
y = datos['users'],
cv = cv,
metric = metrica_personalizada
)
metrica_lags
| metrica_personalizada | n_evaluated | |
|---|---|---|
| 0 | 198.521846 | 2928 |
# Fijar a cero las predicciones de las horas de cierre
# ==============================================================================
hora = predicciones.index.hour
dia_semana = predicciones.index.day_of_week
horas_cierre = (hora < 7) | (hora > 20)
dias_cierre = dia_semana.isin([5, 6])
tienda_cerrada = (horas_cierre) | (dias_cierre)
predicciones.loc[tienda_cerrada, 'pred'] = 0
# Gráfico de predicciones vs valores reales
# ======================================================================================
fig = go.Figure()
trace1 = go.Scatter(
x=datos_test.index, y=datos_test['users'], name='test', mode='lines'
)
trace2 = go.Scatter(
x=predicciones.index, y=predicciones['pred'], name='predicción', mode='lines'
)
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.update_layout(
title='Valores reales vs predicciones en el periodo de test',
xaxis_title='Fecha',
yaxis_title='Usuarios',
width = 750,
height = 350,
margin=dict(l=20, r=20, t=35, b=20),
legend=dict(orientation='h', yanchor='top', y=1.1, xanchor='left', x=0.001)
)
fig.show()
Al analizar las predicciones, queda claro que el modelo no reproduce con precisión el patrón de demanda del horario de apertura: los valores predichos quedan muy por debajo de los reales. Para entender mejor dónde falla el modelo, se analizan los residuos por día de la semana y hora del día.
# Distribución de los residuos por día de la semana y hora del día
# ==============================================================================
residuos = (predicciones['pred'] - datos_test['users']).to_frame('residuos')
residuos['dia_semana'] = residuos.index.day_of_week + 1
residuos['hora_dia'] = residuos.index.hour
fig = px.box(
residuos,
x='dia_semana',
y='residuos',
labels={'dia_semana': 'Día de la semana (1 = lunes)', 'residuos': 'Residuos'},
title = 'Distribución de los residuos por día de la semana',
width=600,
height=300
)
fig.update_layout(margin=dict(l=20, r=20, t=35, b=20))
fig.show()
fig = px.box(
residuos,
x='hora_dia',
y='residuos',
labels={'hora_dia': 'Hora del día', 'residuos': 'Residuos'},
title = 'Distribución de los residuos por hora del día',
width=600,
height=300
)
fig.update_layout(margin=dict(l=20, r=20, t=35, b=20))
fig.show()
Los residuos se calculan como la predicción menos el valor real, por lo que los valores negativos indican que el modelo subestima el número de usuarios. Los residuos de las horas en las que la tienda está cerrada son exactamente cero porque esas predicciones se fijaron en 0. Destacan dos patrones:
El modelo subestima la demanda todos los días laborables, y la mayor subestimación se produce los lunes, el día posterior a los dos días de cierre. Cuando se predice el lunes, los lags más recientes corresponden al fin de semana, cuando el número de usuarios es cero.
Por hora del día, los mayores errores se concentran en los dos picos de demanda: el pico de la mañana, poco después de la apertura de la tienda (8:00), y el pico de la tarde (17:00-18:00).
Informar al modelo cuando la tienda está cerrada¶
Las variables exógenas pueden utilizarse en un modelo de forecasting para proporcionar información adicional y mejorar la capacidad del modelo para detectar patrones. Este enfoque ofrece la ventaja de incorporar factores externos que podrían influir en la precisión de las predicciones, lo que conduce a un modelo más fiable y preciso. El argumento exog facilita enormemente la integración de variables exógenas en el forecaster. En este caso, se crea una variable binaria tienda_cerrada que indica las horas en las que la tienda está cerrada.
✎ Nota
Las variables exógenas deben conocerse para todo el horizonte de predicción en el momento en que se realiza la predicción. La variable tienda_cerrada se obtiene exclusivamente a partir del calendario (día de la semana y hora del día), por lo que sus valores futuros se conocen de antemano y su uso no introduce data leakage.
# Crear variable exógena
# ==============================================================================
hora = datos.index.hour
dia_semana = datos.index.day_of_week
horas_cierre = (hora < 7) | (hora > 20)
dias_cierre = dia_semana.isin([5, 6])
tienda_cerrada = (horas_cierre) | (dias_cierre)
datos['tienda_cerrada'] = tienda_cerrada.astype(int)
# Actualizar las particiones para que incluyan la nueva variable
datos_train = datos.loc[: fin_train, :]
datos_val = datos.loc[fin_train:fin_validacion, :]
datos_test = datos.loc[fin_validacion:, :]
# Backtesting en el periodo de test
# ==============================================================================
metrica_exog, predicciones = backtesting_forecaster(
forecaster = forecaster,
y = datos['users'],
exog = datos['tienda_cerrada'],
cv = cv,
metric = metrica_personalizada
)
metrica_exog
| metrica_personalizada | n_evaluated | |
|---|---|---|
| 0 | 107.744754 | 2928 |
# Fijar a cero las predicciones de las horas de cierre
# ==============================================================================
tienda_cerrada = datos.loc[predicciones.index, 'tienda_cerrada'] == 1
predicciones.loc[tienda_cerrada, 'pred'] = 0
# Gráfico de predicciones vs valores reales
# ======================================================================================
fig = go.Figure()
trace1 = go.Scatter(
x=datos_test.index, y=datos_test['users'], name='test', mode='lines'
)
trace2 = go.Scatter(
x=predicciones.index, y=predicciones['pred'], name='predicción', mode='lines'
)
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.update_layout(
title='Valores reales vs predicciones en el periodo de test',
xaxis_title='Fecha',
yaxis_title='Usuarios',
width = 750,
height = 350,
margin=dict(l=20, r=20, t=35, b=20),
legend=dict(orientation='h', yanchor='top', y=1.1, xanchor='left', x=0.001)
)
fig.show()
La incorporación de la variable exógena al modelo produce una mejora significativa en la precisión de las predicciones: el error absoluto medio durante el horario de apertura se reduce casi a la mitad. Esto pone de manifiesto la importancia de utilizar factores externos para mejorar el rendimiento del modelo de forecasting.
Variables de calendario y lag semanal¶
El análisis de residuos del primer modelo mostró que los mayores errores se producen en horas concretas del día (los dos picos de demanda) y en un día concreto de la semana (el lunes). La variable tienda_cerrada indica al modelo cuándo está cerrada la tienda, pero no en qué punto del día o de la semana se encuentra cada observación. Se añaden al modelo dos fuentes de información adicionales:
Variables de calendario: el día de la semana y la hora del día, extraídos del índice de la serie con
CalendarFeatures. Conencoding = 'cyclical', cada variable se transforma en un par seno-coseno, de modo que el modelo sabe que, por ejemplo, la hora 23 y la hora 0 son consecutivas. El transformador se pasa al forecaster con el argumentocalendar_features, y las variables se crean automáticamente durante el entrenamiento y la predicción. Para más detalles, véase variables de calendario.Lag semanal: el lag 168, es decir, el número de usuarios a la misma hora del mismo día de la semana anterior. Con solo los últimos 24 lags, cuando la tienda abre un lunes, todos los lags corresponden al fin de semana.
Al igual que tienda_cerrada, las variables de calendario solo dependen de la fecha, por lo que sus valores futuros se conocen de antemano.
# Crear forecaster con variables de calendario y lag semanal
# ==============================================================================
transformer_calendario = CalendarFeatures(
features = ['day_of_week', 'hour'],
encoding = 'cyclical',
keep_original_columns = False
)
# Lags 1 a 24 y lag 168 (misma hora de la semana anterior)
forecaster = ForecasterRecursive(
estimator = LGBMRegressor(
learning_rate = 0.1,
max_depth = 5,
n_estimators = 500,
random_state = 123,
verbose = -1
),
lags = list(range(1, 25)) + [168],
calendar_features = transformer_calendario
)
# Backtesting en el periodo de test
# ==============================================================================
metrica_calendario, predicciones = backtesting_forecaster(
forecaster = forecaster,
y = datos['users'],
exog = datos['tienda_cerrada'],
cv = cv,
metric = metrica_personalizada
)
metrica_calendario
| metrica_personalizada | n_evaluated | |
|---|---|---|
| 0 | 87.129526 | 2928 |
# Fijar a cero las predicciones de las horas de cierre
# ==============================================================================
tienda_cerrada = datos.loc[predicciones.index, 'tienda_cerrada'] == 1
predicciones.loc[tienda_cerrada, 'pred'] = 0
# Gráfico de predicciones vs valores reales
# ======================================================================================
fig = go.Figure()
trace1 = go.Scatter(
x=datos_test.index, y=datos_test['users'], name='test', mode='lines'
)
trace2 = go.Scatter(
x=predicciones.index, y=predicciones['pred'], name='predicción', mode='lines'
)
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.update_layout(
title='Valores reales vs predicciones en el periodo de test',
xaxis_title='Fecha',
yaxis_title='Usuarios',
width = 750,
height = 350,
margin=dict(l=20, r=20, t=35, b=20),
legend=dict(orientation='h', yanchor='top', y=1.1, xanchor='left', x=0.001)
)
fig.show()
Con las variables de calendario y el lag semanal, el error en el conjunto de test se reduce de nuevo, casi una quinta parte respecto al modelo anterior.
Optimización de hiperparámetros¶
La optimización de hiperparámetros es un aspecto crítico en el desarrollo de modelos de machine learning precisos y eficaces. Los hiperparámetros son valores que no pueden aprenderse a partir de los datos y que el usuario debe establecer antes de entrenar el modelo. Estos hiperparámetros pueden tener un impacto significativo en el rendimiento del modelo, y un ajuste cuidadoso puede mejorar su precisión y su capacidad de generalización a nuevos datos. En el caso de los modelos de forecasting, los lags incluidos en el modelo pueden considerarse un hiperparámetro adicional.
La optimización de hiperparámetros consiste en probar sistemáticamente distintos valores o combinaciones de hiperparámetros (incluidos los lags) para encontrar la configuración que ofrezca los mejores resultados. La librería skforecast ofrece varias estrategias de optimización de hiperparámetros, como la búsqueda en cuadrícula (grid search), la búsqueda aleatoria y la búsqueda bayesiana, para identificar la combinación de lags e hiperparámetros que consigue el mejor rendimiento predictivo.
En este ejemplo, se realiza una búsqueda en cuadrícula con grid_search_forecaster. Cada combinación de lags e hiperparámetros se evalúa mediante backtesting en el conjunto de validación con la misma métrica personalizada, de modo que el conjunto de test no se utiliza en ningún momento durante el proceso de optimización. Por defecto (return_best = True), una vez finalizada la búsqueda, el forecaster se reentrena con la mejor configuración encontrada. La búsqueda parte del último modelo: se mantienen las variables de calendario y todos los conjuntos de lags candidatos incluyen el lag semanal.
# Búsqueda en cuadrícula de hiperparámetros y lags
# ==============================================================================
forecaster = ForecasterRecursive(
estimator = LGBMRegressor(
learning_rate = 0.1,
max_depth = 5,
n_estimators = 500,
random_state = 123,
verbose = -1
),
lags = 24, # Se reemplaza en la búsqueda
calendar_features = transformer_calendario
)
# Lags: todos los candidatos incluyen el lag semanal
lags_grid = {
'lags 1-24 + 168': list(range(1, 25)) + [168],
'lags 1-48 + 168': list(range(1, 49)) + [168],
'lags 1-72 + 168': list(range(1, 73)) + [168]
}
# Hiperparámetros
param_grid = {
'n_estimators': [50, 100, 500],
'max_depth': [5, 10, 15],
'learning_rate': [0.01, 0.1],
}
# Folds
cv_busqueda = TimeSeriesFold(
steps = 36,
initial_train_size = len(datos.loc[:fin_train])
)
resultados_grid = grid_search_forecaster(
forecaster = forecaster,
y = datos.loc[:fin_validacion, 'users'],
exog = datos.loc[:fin_validacion, 'tienda_cerrada'],
cv = cv_busqueda,
param_grid = param_grid,
lags_grid = lags_grid,
metric = metrica_personalizada
)
# Resultados de la búsqueda
# ==============================================================================
columnas = [
'lags_label', 'learning_rate', 'max_depth', 'n_estimators', 'metrica_personalizada'
]
resultados_grid[columnas].head(4)
| lags_label | learning_rate | max_depth | n_estimators | metrica_personalizada | |
|---|---|---|---|---|---|
| 0 | lags 1-72 + 168 | 0.1 | 10.0 | 100.0 | 78.803211 |
| 1 | lags 1-72 + 168 | 0.1 | 15.0 | 100.0 | 80.656150 |
| 2 | lags 1-72 + 168 | 0.1 | 5.0 | 100.0 | 80.832176 |
| 3 | lags 1-48 + 168 | 0.1 | 5.0 | 100.0 | 81.133973 |
# Backtesting en el periodo de test
# ==============================================================================
metrica_tuning, predicciones = backtesting_forecaster(
forecaster = forecaster,
y = datos['users'],
exog = datos['tienda_cerrada'],
cv = cv,
metric = metrica_personalizada
)
metrica_tuning
| metrica_personalizada | n_evaluated | |
|---|---|---|
| 0 | 83.167124 | 2928 |
# Fijar a cero las predicciones de las horas de cierre
# ==============================================================================
tienda_cerrada = datos.loc[predicciones.index, 'tienda_cerrada'] == 1
predicciones.loc[tienda_cerrada, 'pred'] = 0
# Gráfico de predicciones vs valores reales
# ======================================================================================
fig = go.Figure()
trace1 = go.Scatter(
x=datos_test.index, y=datos_test['users'], name='test', mode='lines'
)
trace2 = go.Scatter(
x=predicciones.index, y=predicciones['pred'], name='predicción', mode='lines'
)
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.update_layout(
title='Valores reales vs predicciones en el periodo de test',
xaxis_title='Fecha',
yaxis_title='Usuarios',
width = 750,
height = 350,
margin=dict(l=20, r=20, t=35, b=20),
legend=dict(orientation='h', yanchor='top', y=1.1, xanchor='left', x=0.001)
)
fig.show()
La primera fila de la tabla de resultados muestra la configuración seleccionada por la búsqueda en cuadrícula. Con ella, el error en el conjunto de test vuelve a disminuir. Además, el error en el conjunto de test es similar al obtenido en el conjunto de validación durante la búsqueda, lo que indica que la configuración seleccionada generaliza bien a nuevos datos.
Resumen de resultados¶
# Resumen de los resultados en el conjunto de test
# ==============================================================================
resultados = pd.concat([metrica_lags, metrica_exog, metrica_calendario, metrica_tuning])
# Cada modelo añade nuevos elementos al anterior
resultados.index = [
'Solo lags',
'+ tienda_cerrada',
'+ variables de calendario y lag semanal',
'+ optimización de lags e hiperparámetros'
]
resultados = resultados.rename(
columns={'metrica_personalizada': 'MAE horario de apertura'}
)
resultados['Reducción vs modelo anterior (%)'] = (
-100 * resultados['MAE horario de apertura'].pct_change()
)
resultados.round(1)
| MAE horario de apertura | n_evaluated | Reducción vs modelo anterior (%) | |
|---|---|---|---|
| Solo lags | 198.5 | 2928 | NaN |
| + tienda_cerrada | 107.7 | 2928 | 45.7 |
| + variables de calendario y lag semanal | 87.1 | 2928 | 19.1 |
| + optimización de lags e hiperparámetros | 83.2 | 2928 | 4.5 |
Cada paso reduce el error respecto al modelo anterior. La mayor mejora procede de informar al modelo de cuándo está cerrada la tienda, y el error del modelo final es inferior a la mitad del error del modelo inicial.
✎ Nota
En este documento, las horas en las que la tienda está cerrada siguen formando parte de los datos de entrenamiento. Una alternativa es excluirlas del entrenamiento del modelo asignándoles un peso de cero, o reducir su influencia con un peso menor, mediante el argumento weight_func del forecaster. Para más detalles, véase Weighted time series forecasting.
Información de sesión¶
import session_info
session_info.show(html=False)
----- lightgbm 4.7.0 pandas 2.3.3 plotly 7.1.0 session_info v1.0.1 skforecast 0.27.0 sklearn 1.9.1 ----- IPython 9.17.1 jupyter_client 8.10.0 jupyter_core 5.9.1 ----- Python 3.13.18 | packaged by conda-forge | (main, Oct 26 2026, 11:30:40) [MSC v.1944 64 bit (AMD64)] Windows-11-10.0.26200-SP0 ----- Session information updated at 2026-11-11 21:45
Instrucciones para citar¶
¿Cómo citar este documento?
Si utilizas este documento o alguna parte de él, te agradecemos que lo cites. ¡Muchas gracias!
Forecasting demanda intermitente con skforecast por Joaquín Amat Rodrigo y Javier Escobar Ortiz, disponible bajo una licencia Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0 DEED) en https://www.cienciadedatos.net/documentos/py48-forecasting-demanda-intermitente.html
¿Cómo citar skforecast?
Si utilizas skforecast, te agradeceríamos mucho que lo cites. ¡Muchas gracias!
Zenodo:
Amat Rodrigo, Joaquin, & Escobar Ortiz, Javier. (2026). skforecast (v0.27.0). Zenodo. https://doi.org/10.5281/zenodo.8382787
APA:
Amat Rodrigo, J., & Escobar Ortiz, J. (2026). skforecast (Version 0.27.0) [Computer software]. https://doi.org/10.5281/zenodo.8382787
BibTeX:
@software{skforecast, author = {Amat Rodrigo, Joaquin and Escobar Ortiz, Javier}, title = {skforecast}, version = {0.27.0}, month = {11}, year = {2026}, license = {BSD-3-Clause}, url = {https://skforecast.org/}, doi = {10.5281/zenodo.8382787} }
¿Te ha gustado el artículo? Tu ayuda es importante
Tu contribución me ayudará a seguir generando contenido divulgativo gratuito. ¡Muchísimas gracias! 😊
Este documento creado por Joaquín Amat Rodrigo y Javier Escobar Ortiz tiene licencia Attribution-NonCommercial-ShareAlike 4.0 International.
Se permite:
-
Compartir: copiar y redistribuir el material en cualquier medio o formato.
-
Adaptar: remezclar, transformar y crear a partir del material.
Bajo los siguientes términos:
-
Atribución: Debes otorgar el crédito adecuado, proporcionar un enlace a la licencia e indicar si se realizaron cambios. Puedes hacerlo de cualquier manera razonable, pero no de una forma que sugiera que el licenciante te respalda o respalda tu uso.
-
No-Comercial: No puedes utilizar el material para fines comerciales.
-
Compartir-Igual: Si remezclas, transformas o creas a partir del material, debes distribuir tus contribuciones bajo la misma licencia que el original.
