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
• Modelos de forecasting globales: modelado de múltiples series temporales con machine learning
• Forecasting de la demanda eléctrica con machine learning
• Forecasting con deep learning
• 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

Modelos de forecasting globales¶

En los modelos de series individuales (Local Forecasting Model), una única serie temporal se modela como una combinación lineal o no lineal de sus valores pasados y, opcionalmente, variables exógenas. Aunque este método proporciona una comprensión exhaustiva de cada serie, su escalabilidad puede verse comprometida cuando se dispone de un gran número de series.

Los modelos globales multiserie (Global Forecasting Model) consisten en un único modelo que tiene en cuenta varias series temporales de forma simultánea. Intentan captar los patrones comunes que rigen las series, mitigando así el ruido potencial que pueda introducir cada serie. Este enfoque requiere un único modelo independientemente del número de series, es fácil de mantener y puede conseguir mayor generalización, aunque potencialmente a costa de sacrificar cierta resolución individual. Se pueden distinguir dos estrategias de modelos de previsión global: Múltiples series temporales independientes y Múltiples series temporales dependientes.

Ventajas de los modelos multiseries

• Es más fácil mantener y controlar un solo modelo que varios.

• Dado que todas las series temporales se combinan durante el entrenamiento, cuando las series sean cortas (pocos datos) el modelo tendrá una mayor capacidad de aprendizaje al disponer de más observaciones.

• Al combinar múltiples series temporales, el modelo puede aprender patrones más generalizables.

Desventajas de los modelos multiseries

• Si las series no siguen la misma dinámica interna, el modelo puede aprender un patrón que no represente a ninguna de ellas.

• Las series pueden enmascararse unas a otras, por lo que el modelo puede no predecirlas todas con el mismo rendimiento.

• Es más exigente desde el punto de vista computacional (tiempo y recursos) entrenar y realizar backtesting de un modelo grande que de varios pequeños.

Múltiples series temporales independientes

En este escenario, cada serie temporal es independiente de las demás o, dicho de otro modo, los valores pasados de una serie no se utilizan como predictores de las otras series. ¿Por qué es útil entonces modelar todo junto? Aunque las series no dependen unas de otras, pueden seguir el mismo patrón intrínseco en cuanto a sus valores pasados y futuros. Por ejemplo, en una misma tienda, las ventas de los productos A y B pueden no estar relacionadas, pero siguen la misma dinámica, la de la tienda.

Para predecir los siguientes n steps, se sigue una estrategia recursiva, recursive multi-step forecasting.

Múltiples series temporales dependientes

Todas las series se modelan teniendo en cuenta que cada serie temporal depende no sólo de sus valores pasados, sino también de los valores pasados de las demás series. Se espera que el modelo no sólo aprenda la información de cada serie por separado, sino que también las relacione. Por ejemplo, las mediciones realizadas por todos los sensores (caudal, temperatura, presión...) instalados en una máquina industrial como un compresor. Series temporales multivariantes user guide.

Series con la misma longitud¶

En este primer ejemplo, se utilizan múltiples series temporales de la misma longitud. El objetivo es comparar los resultados de un modelo global con los de un modelo individual para cada serie al predecir los próximos 7 días de ventas para 50 productos diferentes en una tienda, utilizando los 5 años de historial disponible. Los datos se han obtenido del Store Item Demand Forecasting Challenge. Este conjunto de datos contiene 913,000 transacciones de ventas desde el 01/01/2013 hasta el 31/12/2017 para 50 productos (SKU) en 10 tiendas.

Librerías¶

# Manipulación de datos
# ==============================================================================
import numpy as np
import pandas as pd

# Gráficos
# ==============================================================================
import matplotlib.pyplot as plt
from skforecast.plot import set_dark_theme
from tqdm.notebook import tqdm

# Modelado y Forecasting
# ==============================================================================
import sklearn
import skforecast
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.preprocessing import StandardScaler
from skforecast.recursive import ForecasterRecursive, ForecasterRecursiveMultiSeries
from skforecast.model_selection import (
    TimeSeriesFold,
    OneStepAheadFold,
    backtesting_forecaster,
    bayesian_search_forecaster,
    backtesting_forecaster_multiseries,
    bayesian_search_forecaster_multiseries
)
from skforecast.preprocessing import (
    RollingFeatures,
    reshape_series_long_to_dict,
    reshape_exog_long_to_dict
)
from skforecast.exceptions import OneStepAheadValidationWarning

# Warnings
# ==============================================================================
import warnings
warnings.filterwarnings('once')

color = '\033[1m\033[38;5;208m'
print(f'{color}Versión skforecast: {skforecast.__version__}')
print(f'{color}Versión scikit-learn: {sklearn.__version__}')
print(f'{color}Versión pandas: {pd.__version__}')
print(f'{color}Versión numpy: {np.__version__}')

Versión skforecast: 0.27.0
Versión scikit-learn: 1.9.1
Versión pandas: 2.3.3
Versión numpy: 2.5.4

Datos¶

# Lectura de datos
# ======================================================================================
data = pd.read_csv('./train_stores_kaggle.csv')
display(data.head())
print(f'Shape: {data.shape}')

Shape: (913000, 4)

# Preparación datos
# ======================================================================================
selected_store = 2  # Seleccionar una tienda
# Se seleccionan todos los items, modificar `selected_items` para usar un subconjunto
selected_items = data.item.unique()
data = data[
    (data['store'] == selected_store) & (data['item'].isin(selected_items))
].copy()
data['date'] = pd.to_datetime(data['date'], format='%Y-%m-%d')
data = pd.pivot_table(
           data    = data,
           values  = 'sales',
           index   = 'date',
           columns = 'item'
       )
data.columns.name = None
data.columns = [f'item_{col}' for col in data.columns]
data = data.asfreq('1D')
data.head(4)

El dataset se divide en 3 particiones: una para el entrenamiento, otra para la validación y otra para test.

# Separación datos train-validation-test
# ======================================================================================
end_train = '2016-05-31 23:59:00'
end_val = '2017-05-31 23:59:00'
data_train = data.loc[:end_train, :].copy()
data_val   = data.loc[end_train:end_val, :].copy()
data_test  = data.loc[end_val:, :].copy()
print(
    f'Fechas train      : {data_train.index.min()} --- '
    f'{data_train.index.max()}  (n={len(data_train)})'
)
print(
    f'Fechas validación : {data_val.index.min()} --- '
    f'{data_val.index.max()}  (n={len(data_val)})'
)
print(
    f'Fechas test       : {data_test.index.min()} --- '
    f'{data_test.index.max()}  (n={len(data_test)})'
)

Fechas train      : 2013-01-01 00:00:00 --- 2016-05-31 00:00:00  (n=1247)
Fechas validación : 2016-06-01 00:00:00 --- 2017-05-31 00:00:00  (n=365)
Fechas test       : 2017-06-01 00:00:00 --- 2017-12-31 00:00:00  (n=214)

Se representan cuatro de las series para comprender sus tendencias y patrones. Se recomienda al lector que grafique más de ellas para comprenderlas en profundidad.

# Gráfico series temporales
# ======================================================================================
set_dark_theme()
fig, axs = plt.subplots(4, 1, figsize=(7, 5), sharex=True)
data.iloc[:, :4].plot(
    legend    = True,
    subplots  = True,
    title     = f'Ventas de la tienda {selected_store}',
    ax        = axs,
    linewidth = 1
)
for ax in axs:
    ax.axvline(pd.to_datetime(end_train), color='white', linestyle='--', linewidth=1.5)
    ax.axvline(pd.to_datetime(end_val), color='white', linestyle='--', linewidth=1.5)
fig.tight_layout()
plt.show()

Forecasting individual para cada item¶

Se entrena un modelo Gradient Boosting Machine (GBM) para cada producto, utilizando las ventas de los últimos 14 días, así como las ventas promedio, máxima y mínima de los últimos 7 días (RollingFeatures) como predictores. El rendimiento del modelo para los siguientes 7 días se evalúa mediante backtesting utilizando el Error Absoluto Medio (MAE) como métrica de evaluación. Las particiones se definen con TimeSeriesFold y la evaluación se realiza con backtesting_forecaster. Finalmente, se compara el rendimiento de estos modelos individuales con el de un modelo global entrenado con todas las series.

# Entrenar y realizar backtesting de un modelo para cada item
# ======================================================================================
items = []
mae_values = []
cv = TimeSeriesFold(
        steps              = 7,
        initial_train_size = len(data_train) + len(data_val),
        refit              = False,
     )

for item in tqdm(data.columns):
    # Definir el forecaster
    window_features = RollingFeatures(stats=['mean', 'min', 'max'], window_sizes=7)
    forecaster = ForecasterRecursive(
                     estimator       = HistGradientBoostingRegressor(random_state=8523),
                     lags            = 14,
                     window_features = window_features
                 )
    # Backtesting forecaster
    metric, _ = backtesting_forecaster(
                        forecaster    = forecaster,
                        y             = data[item],
                        cv            = cv,
                        metric        = 'mean_absolute_error',
                        show_progress = False
                    )
    items.append(item)
    mae_values.append(metric.at[0, 'mean_absolute_error'])

# Resultados
uni_series_mae = pd.Series(
                     data  = mae_values,
                     index = items,
                     name  = 'uni_series_mae'
                 )
uni_series_mae.head()

item_1     6.004406
item_2    10.104921
item_3     8.678198
item_4     5.528955
item_5     5.096925
Name: uni_series_mae, dtype: float64

Modelo global¶

Se entrena un modelo global (ForecasterRecursiveMultiSeries) con las mismas características que los modelos individuales. Su rendimiento se evalúa con el mismo proceso de backtesting, esta vez con backtesting_forecaster_multiseries, y se compara con el de los modelos individuales. Dado que las series se pasan como un DataFrame, skforecast muestra un InputTypeWarning indicando que un diccionario de pandas.Series es un formato de entrada más eficiente; este formato se describe en la sección Series de diferente longitud y distintas variables exógenas.

# Entrenamiento y backtesting con un único modelo para todos los items
# ======================================================================================
# Definir el forecaster
estimator = HistGradientBoostingRegressor(random_state=8523)
window_features = RollingFeatures(stats=['mean', 'min', 'max'], window_sizes=7)
forecaster_ms = ForecasterRecursiveMultiSeries(
                    estimator          = estimator,
                    lags               = 14,
                    encoding           = 'ordinal',
                    transformer_series = StandardScaler(),
                    window_features    = window_features,
                )
# Backtesting forecaster para todos los items
cv = TimeSeriesFold(
            steps              = 7,
            initial_train_size = len(data_train) + len(data_val),
            refit              = False,
         )
multi_series_mae, predictions_ms = backtesting_forecaster_multiseries(
                                       forecaster            = forecaster_ms,
                                       series                = data,
                                       cv                    = cv,
                                       metric                = 'mean_absolute_error',
                                       add_aggregated_metric = False,
                                   )
# Resultados
display(multi_series_mae.head(3))
print('')
display(predictions_ms.head(3))

╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮
│ Passing a DataFrame (either wide or long format) as `series` requires additional     │
│ internal transformations, which can increase computational time. It is recommended   │
│ to use a dictionary of pandas Series instead. For more details, see:                 │
│ https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. │
│ html#input-data                                                                      │
│                                                                                      │
│ Category : skforecast.exceptions.InputTypeWarning                                    │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:4425                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                │
╰──────────────────────────────────────────────────────────────────────────────────────╯

Comparación¶

# Diferencia de la métrica de backtesting para cada item
# ======================================================================================
multi_series_mae = (
    multi_series_mae.set_index('levels')['mean_absolute_error']
    .rename('multi_series_mae')
)
results = pd.concat((uni_series_mae, multi_series_mae), axis=1)
results['improvement'] = results['uni_series_mae'] - results['multi_series_mae']
results['improvement_(%)'] = (
    100 * results['improvement'] / results['uni_series_mae']
)
results = results.round(2)
results.style.bar(subset=['improvement_(%)'], align='mid', color=['#d65f5f', '#5fba7d'])

# Mejora media de todos los items
# ======================================================================================
results[['improvement', 'improvement_(%)']].agg(['mean', 'min', 'max'])

# Número de series con mejora positiva y negativa
# ======================================================================================
pd.Series(
    np.where(results['improvement_(%)'] < 0, 'negative', 'positive')
).value_counts()

positive    49
negative     1
Name: count, dtype: int64

El modelo global logra una mejora media de aproximadamente el 7.5% en comparación con el uso de un modelo individual para cada serie. Para 49 de las 50 series, el error de predicción evaluado mediante backtesting es menor cuando se utiliza el modelo global, y en la restante es solo un 1.4% mayor. Este caso de uso demuestra que un modelo multiserie puede tener ventajas sobre varios modelos individuales a la hora de predecir series temporales que siguen una dinámica similar. Además de las mejoras potenciales en la predicción, también es importante tener en cuenta el beneficio de tener un único modelo que mantener.

Series de diferente longitud y distintas variables exógenas¶

En escenarios en los que se tienen que modelar múltiples series, es habitual que las series tengan longitudes distintas debido a diferencias en los momentos de inicio del registro de los datos. Para hacer frente a este escenario, la clase ForecasterRecursiveMultiSeries permite modelizar simultáneamente series temporales de distintas longitudes y con distintas variables exógenas. En estos casos, los datos deben estructurarse en una de las siguientes formas:

• En un diccionario de pandas.Series: las claves del diccionario son los nombres de las series y los valores son las propias series. Todas las series deben ser del tipo pandas.Series, tener un índice DatetimeIndex y la misma frecuencia.

• En un pandas.DataFrame con MultiIndex: el primer nivel del índice contiene el nombre de la serie y el segundo nivel es el índice temporal. El segundo nivel debe ser un DatetimeIndex y todas las series deben tener la misma frecuencia.

Cuando se utilizan variables exógenas diferentes para cada serie o cuando las variables exógenas son las mismas pero tienen valores diferentes para cada serie, deben utilizarse alguna de las siguientes opciones:

• En un diccionario: Las claves del diccionario son los nombres de las series y los valores son las propias variables exógenas. Todas las variables exógenas deben ser de tipo pandas.DataFrame o pandas.Series.

• En un pandas.DataFrame con MultiIndex: el primer nivel del índice debe contener el nombre de la serie y el segundo nivel es el índice temporal. Todas las variables exógenas deben ser del tipo pandas.DataFrame o pandas.Series.

Si los datos no siguen estas estructuras, skforecast proporciona dos funciones para transformar los datos: reshape_series_long_to_dict y reshape_exog_long_to_dict.

Datos¶

Los datos de este ejemplo son cinco series temporales diarias de demostración (id_1000 a id_1004) de distinta longitud, junto con variables exógenas de calendario (día de la semana) y meteorológicas (temperatura del aire y velocidad del viento). Los datos están almacenados en "formato largo" en un único DataFrame. La columna series_id identifica la serie a la que pertenece cada observación. La columna timestamp contiene la fecha de la observación, y la columna value contiene el valor de la serie en esa fecha. Cada serie temporal tiene una longitud diferente.

Las variables exógenas se almacenan en un DataFrame separado, también en "formato largo". La columna series_id identifica la serie a la que pertenece cada observación. La columna timestamp contiene la fecha de la observación, y las columnas restantes contienen los valores de las variables exógenas en esa fecha.

# Lectura series con diferentes longitudes y variables exógenas
# ==============================================================================
series = pd.read_csv(
    'https://raw.githubusercontent.com/skforecast/skforecast-datasets/main/data/demo_multi_series.csv'
)
exog = pd.read_csv(
    'https://raw.githubusercontent.com/skforecast/skforecast-datasets/main/data/demo_multi_series_exog.csv'
)
series['timestamp'] = pd.to_datetime(series['timestamp'])
exog['timestamp'] = pd.to_datetime(exog['timestamp'])
display(series.head())
display(exog.head())

Cuando las series tienen longitudes diferentes, se recomienda transformar los datos en un diccionario (también se admite un DataFrame en formato largo con MultiIndex). Las claves del diccionario son los nombres de las series y los valores son las propias series. Para ello, se utiliza la función reshape_series_long_to_dict, que toma el DataFrame en "formato largo" y devuelve un diccionario de series.

Del mismo modo, cuando las variables exógenas son diferentes (valores o variables) para cada serie, se recomienda almacenarlas en un diccionario. Las claves del diccionario son los nombres de las series y los valores son las propias variables exógenas. Se utiliza la función reshape_exog_long_to_dict, que toma el DataFrame en "formato largo" y devuelve un diccionario de variables exógenas.

# Transformar series y exog a diccionarios
# ==============================================================================
series_dict = reshape_series_long_to_dict(
                data      = series,
                series_id = 'series_id',
                index     = 'timestamp',
                values    = 'value',
                freq      = 'D'
              )

exog_dict = reshape_exog_long_to_dict(
                data      = exog,
                series_id = 'series_id',
                index     = 'timestamp',
                freq      = 'D'
            )

╭──────────────────────────────── MissingValuesWarning ────────────────────────────────╮
│ Series 'id_1003' is incomplete. NaNs have been introduced after setting the          │
│ frequency.                                                                           │
│                                                                                      │
│ Category : skforecast.exceptions.MissingValuesWarning                                │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\pre │
│ processing\_preprocessing.py:592                                                     │
│ Suppress : warnings.simplefilter('ignore', category=MissingValuesWarning)            │
╰──────────────────────────────────────────────────────────────────────────────────────╯

El MissingValuesWarning indica que la serie 'id_1003' tiene huecos: las fechas que faltan se rellenan con NaN al establecer la frecuencia diaria (73 valores en el conjunto de entrenamiento y 73 en el de test, ver la descripción de cada serie más abajo). Las filas cuyo valor objetivo es NaN siempre se eliminan de las matrices de entrenamiento. El argumento dropna_from_series controla el resto: con True, también se elimina toda fila con al menos un NaN entre los predictores; con False (el valor utilizado en este ejemplo), esas filas se mantienen. En este ejemplo es relevante porque a las series 'id_1000' y 'id_1003' les faltan algunas variables exógenas, por lo que todas sus filas tienen al menos un NaN y se descartarían con True. Mantenerlas es posible porque HistGradientBoostingRegressor admite valores faltantes.

Algunas variables exógenas se omiten en las series 'id_1000' y 'id_1003' para ilustrar que se pueden utilizar diferentes variables exógenas para cada serie.

# Eliminar algunas variables exógenas de las series 'id_1000' y 'id_1003'
# ==============================================================================
exog_dict['id_1000'] = exog_dict['id_1000'].drop(
    columns=['air_temperature', 'wind_speed']
)
exog_dict['id_1003'] = exog_dict['id_1003'].drop(columns=['cos_day_of_week'])

# Particiones de entrenamiento y test
# ==============================================================================
end_train = '2016-07-31 23:59:00'
series_dict_train = {k: v.loc[:end_train] for k, v in series_dict.items()}
exog_dict_train   = {k: v.loc[:end_train] for k, v in exog_dict.items()}
series_dict_test  = {k: v.loc[end_train:] for k, v in series_dict.items()}
exog_dict_test    = {k: v.loc[end_train:] for k, v in exog_dict.items()}

# Gráfico series
# ==============================================================================
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
fig, axs = plt.subplots(5, 1, figsize=(8, 4), sharex=True)
for i, s in enumerate(series_dict.values()):
    axs[i].plot(s, label=s.name, color=colors[i])
    axs[i].legend(loc='upper right', fontsize=8)
    axs[i].tick_params(axis='both', labelsize=8)
    axs[i].axvline(
        pd.to_datetime(end_train), color='white', linestyle='--', linewidth=1
    )
fig.tight_layout()
plt.show()

# Descripción de cada serie
# ==============================================================================
for k in series_dict.keys():
    print(f'{k}:')
    try:
        print(
            f'\tTrain: len={len(series_dict_train[k])}, {series_dict_train[k].index[0]}'
            f' --- {series_dict_train[k].index[-1]} '
            f' (missing={series_dict_train[k].isnull().sum()})'
        )
    except IndexError:
        print('\tTrain: len=0')
    try:
        print(
            f'\tTest : len={len(series_dict_test[k])}, {series_dict_test[k].index[0]}'
            f' --- {series_dict_test[k].index[-1]} '
            f' (missing={series_dict_test[k].isnull().sum()})'
        )
    except IndexError:
        print('\tTest : len=0')

id_1000:
	Train: len=213, 2016-01-01 00:00:00 --- 2016-07-31 00:00:00  (missing=0)
	Test : len=153, 2016-08-01 00:00:00 --- 2016-12-31 00:00:00  (missing=0)
id_1001:
	Train: len=30, 2016-07-02 00:00:00 --- 2016-07-31 00:00:00  (missing=0)
	Test : len=153, 2016-08-01 00:00:00 --- 2016-12-31 00:00:00  (missing=0)
id_1002:
	Train: len=183, 2016-01-01 00:00:00 --- 2016-07-01 00:00:00  (missing=0)
	Test : len=0
id_1003:
	Train: len=213, 2016-01-01 00:00:00 --- 2016-07-31 00:00:00  (missing=73)
	Test : len=153, 2016-08-01 00:00:00 --- 2016-12-31 00:00:00  (missing=73)
id_1004:
	Train: len=91, 2016-05-02 00:00:00 --- 2016-07-31 00:00:00  (missing=0)
	Test : len=31, 2016-08-01 00:00:00 --- 2016-08-31 00:00:00  (missing=0)

# Variables exógenas de cada serie
# ==============================================================================
for k in series_dict.keys():
    print(f'{k}:')
    print(f'\t{exog_dict[k].columns.to_list()}')

id_1000:
	['sin_day_of_week', 'cos_day_of_week']
id_1001:
	['sin_day_of_week', 'cos_day_of_week', 'air_temperature', 'wind_speed']
id_1002:
	['sin_day_of_week', 'cos_day_of_week', 'air_temperature', 'wind_speed']
id_1003:
	['sin_day_of_week', 'air_temperature', 'wind_speed']
id_1004:
	['sin_day_of_week', 'cos_day_of_week', 'air_temperature', 'wind_speed']

Modelo global¶

# Fit forecaster
# ==============================================================================
estimator = HistGradientBoostingRegressor(random_state=123, max_depth=5)
window_features = RollingFeatures(stats=['mean', 'min', 'max'], window_sizes=7)
forecaster = ForecasterRecursiveMultiSeries(
                estimator          = estimator,
                lags               = 14,
                window_features    = window_features,
                encoding           = 'ordinal',
                dropna_from_series = False
            )

forecaster.fit(series=series_dict_train, exog=exog_dict_train, suppress_warnings=True)
forecaster

Sólo se pueden predecir juntas las series cuya última ventana de datos (last_window) termine en el mismo índice fecha-hora. Si levels = None, se excluyen de la predicción las series que no alcanzan el índice máximo. En este ejemplo, la serie 'id_1002' se excluye.

# Predict
# ==============================================================================
predicciones = forecaster.predict(steps=7, exog=exog_dict_test, suppress_warnings=True)
predicciones

Backtesting¶

Cuando las series tienen longitudes diferentes, una serie sólo se predice en las particiones (folds) en las que su última ventana está disponible. La serie 'id_1002' termina antes del periodo de test, por lo que no tiene predicciones y su métrica es NaN. La serie 'id_1004' termina el 2016-08-31, a mitad de un fold, por lo que sus predicciones continúan hasta el final de ese fold. Las fechas sin valores observados (incluidos los huecos de 'id_1003') se ignoran al calcular la métrica.

# Backtesting
# ==============================================================================
cv = TimeSeriesFold(
        steps              = 7,
        initial_train_size = end_train,
        refit              = False,
     )

metrics_levels, backtest_predictions = backtesting_forecaster_multiseries(
    forecaster            = forecaster,
    series                = series_dict,
    exog                  = exog_dict,
    cv                    = cv,
    metric                = 'mean_absolute_error',
    add_aggregated_metric = False,
    verbose               = True,
    suppress_warnings     = True
)

display(metrics_levels)
display(backtest_predictions)

Information of folds
--------------------
Number of observations used for initial training: 213
Number of observations used for backtesting: 153
    Number of folds: 22
    Number skipped folds: 0 
    Number of steps per fold: 7
    Number of steps to exclude between last observed data (last window) and predictions (gap): 0
    Last fold only includes 6 observations.

Fold: 0
    Training:   2016-01-01 00:00:00 -- 2016-07-31 00:00:00  (n=213)
    Validation: 2016-08-01 00:00:00 -- 2016-08-07 00:00:00  (n=7)
Fold: 1
    Training:   No training in this fold
    Validation: 2016-08-08 00:00:00 -- 2016-08-14 00:00:00  (n=7)
Fold: 2
    Training:   No training in this fold
    Validation: 2016-08-15 00:00:00 -- 2016-08-21 00:00:00  (n=7)
Fold: 3
    Training:   No training in this fold
    Validation: 2016-08-22 00:00:00 -- 2016-08-28 00:00:00  (n=7)
Fold: 4
    Training:   No training in this fold
    Validation: 2016-08-29 00:00:00 -- 2016-09-04 00:00:00  (n=7)
Fold: 5
    Training:   No training in this fold
    Validation: 2016-09-05 00:00:00 -- 2016-09-11 00:00:00  (n=7)
Fold: 6
    Training:   No training in this fold
    Validation: 2016-09-12 00:00:00 -- 2016-09-18 00:00:00  (n=7)
Fold: 7
    Training:   No training in this fold
    Validation: 2016-09-19 00:00:00 -- 2016-09-25 00:00:00  (n=7)
Fold: 8
    Training:   No training in this fold
    Validation: 2016-09-26 00:00:00 -- 2016-10-02 00:00:00  (n=7)
Fold: 9
    Training:   No training in this fold
    Validation: 2016-10-03 00:00:00 -- 2016-10-09 00:00:00  (n=7)
Fold: 10
    Training:   No training in this fold
    Validation: 2016-10-10 00:00:00 -- 2016-10-16 00:00:00  (n=7)
Fold: 11
    Training:   No training in this fold
    Validation: 2016-10-17 00:00:00 -- 2016-10-23 00:00:00  (n=7)
Fold: 12
    Training:   No training in this fold
    Validation: 2016-10-24 00:00:00 -- 2016-10-30 00:00:00  (n=7)
Fold: 13
    Training:   No training in this fold
    Validation: 2016-10-31 00:00:00 -- 2016-11-06 00:00:00  (n=7)
Fold: 14
    Training:   No training in this fold
    Validation: 2016-11-07 00:00:00 -- 2016-11-13 00:00:00  (n=7)
Fold: 15
    Training:   No training in this fold
    Validation: 2016-11-14 00:00:00 -- 2016-11-20 00:00:00  (n=7)
Fold: 16
    Training:   No training in this fold
    Validation: 2016-11-21 00:00:00 -- 2016-11-27 00:00:00  (n=7)
Fold: 17
    Training:   No training in this fold
    Validation: 2016-11-28 00:00:00 -- 2016-12-04 00:00:00  (n=7)
Fold: 18
    Training:   No training in this fold
    Validation: 2016-12-05 00:00:00 -- 2016-12-11 00:00:00  (n=7)
Fold: 19
    Training:   No training in this fold
    Validation: 2016-12-12 00:00:00 -- 2016-12-18 00:00:00  (n=7)
Fold: 20
    Training:   No training in this fold
    Validation: 2016-12-19 00:00:00 -- 2016-12-25 00:00:00  (n=7)
Fold: 21
    Training:   No training in this fold
    Validation: 2016-12-26 00:00:00 -- 2016-12-31 00:00:00  (n=6)

# Gráfico predicciones backtesting
# ==============================================================================
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
fig, axs = plt.subplots(5, 1, figsize=(8, 4), sharex=True)
for i, s in enumerate(series_dict.keys()):
    axs[i].plot(series_dict[s], label=series_dict[s].name, color=colors[i])
    axs[i].axvline(
        pd.to_datetime(end_train), color='white', linestyle='--', linewidth=1
    )
    axs[i].plot(
        backtest_predictions.loc[backtest_predictions['level'] == s, 'pred'],
        label='prediction',
        color='white',
    )
    axs[i].legend(loc='upper left', fontsize=8)
    axs[i].tick_params(axis='both', labelsize=8)
fig.tight_layout()
plt.show()

Al permitir la modelización de series temporales de diferentes longitudes y con diferentes variables exógenas, la clase ForecasterRecursiveMultiSeries proporciona una herramienta flexible y potente para utilizar toda la información disponible para entrenar los modelos.

Optimización de hiperparámetros y lags¶

En el primer ejemplo de este documento, la comparación entre forecaster se ha realizado sin optimizar los hiperparámetros de los estimadores. Para una comparación justa, se utiliza una estrategia de búsqueda bayesiana (Bayesian search, bayesian_search_forecaster y bayesian_search_forecaster_multiseries) con el fin de seleccionar la mejor configuración para cada forecaster. Véase más información en hyperparameter tuning and lags selection.

# Búsqueda de hiperparámetros y backtesting de un modelo para cada item
# ==============================================================================
items = []
mae_values = []

def search_space(trial):
    search_space = {
        'lags'          : trial.suggest_categorical('lags', [7, 14]),
        'max_iter'      : trial.suggest_int('max_iter', 100, 500),
        'max_depth'     : trial.suggest_categorical('max_depth', [None, 5, 6, 7, 8, 9, 10]),
        'learning_rate' : trial.suggest_float('learning_rate', 0.01, 0.1, log=True)
    }

    return search_space

cv_search = OneStepAheadFold(initial_train_size=len(data_train))
cv_backtesting = TimeSeriesFold(
                    steps              = 7,
                    initial_train_size = len(data_train) + len(data_val),
                    refit              = False,
                 )
warnings.simplefilter('ignore', category=OneStepAheadValidationWarning)

for item in tqdm(data.columns):

    window_features = RollingFeatures(stats=['mean', 'min', 'max'], window_sizes=7)
    forecaster = ForecasterRecursive(
                    estimator       = HistGradientBoostingRegressor(random_state=123),
                    lags            = 14,
                    window_features = window_features
                )

    # return_best=True (por defecto): tras la búsqueda, el forecaster se configura y
    # reentrena con la mejor configuración encontrada
    bayesian_search_forecaster(
        forecaster    = forecaster,
        y             = data.loc[:end_val, item],
        cv            = cv_search,
        search_space  = search_space,
        n_trials      = 10,
        metric        = 'mean_absolute_error',
        show_progress = False
    )
    metric, _ = backtesting_forecaster(
                        forecaster    = forecaster,
                        y             = data[item],
                        cv            = cv_backtesting,
                        metric        = 'mean_absolute_error',
                        show_progress = False
                    )

    items.append(item)
    mae_values.append(metric.at[0, 'mean_absolute_error'])

uni_series_mae = pd.Series(
                    data  = mae_values,
                    index = items,
                    name  = 'uni_series_mae'
                )

# Búsqueda de hiperparámetros y backtesting de un modelo global para todos los items
# ==============================================================================
# search_space, cv_search, cv_backtesting y window_features son los mismos que
# en la búsqueda de los modelos individuales
estimator = HistGradientBoostingRegressor(random_state=123)
forecaster_ms = ForecasterRecursiveMultiSeries(
                    estimator          = estimator,
                    lags               = 14,
                    window_features    = window_features,
                    transformer_series = StandardScaler(),
                    encoding           = 'ordinal'
                )

# return_best=True (por defecto): tras la búsqueda, el forecaster se configura y
# reentrena con la mejor configuración encontrada
bayesian_search_forecaster_multiseries(
    forecaster    = forecaster_ms,
    series        = data.loc[:end_val, :],
    cv            = cv_search,
    search_space  = search_space,
    n_trials      = 20,
    metric        = 'mean_absolute_error',
    show_progress = False
)

multi_series_mae, _ = backtesting_forecaster_multiseries(
                                       forecaster            = forecaster_ms,
                                       series                = data,
                                       cv                    = cv_backtesting,
                                       metric                = 'mean_absolute_error',
                                       add_aggregated_metric = False,
                                   )

╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮
│ Passing a DataFrame (either wide or long format) as `series` requires additional     │
│ internal transformations, which can increase computational time. It is recommended   │
│ to use a dictionary of pandas Series instead. For more details, see:                 │
│ https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. │
│ html#input-data                                                                      │
│                                                                                      │
│ Category : skforecast.exceptions.InputTypeWarning                                    │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:4425                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                │
╰──────────────────────────────────────────────────────────────────────────────────────╯

╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮
│ Passing a DataFrame (either wide or long format) as `series` requires additional     │
│ internal transformations, which can increase computational time. It is recommended   │
│ to use a dictionary of pandas Series instead. For more details, see:                 │
│ https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. │
│ html#input-data                                                                      │
│                                                                                      │
│ Category : skforecast.exceptions.InputTypeWarning                                    │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:4425                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                │
╰──────────────────────────────────────────────────────────────────────────────────────╯

# Diferencia de la métrica de backtesting para cada item
# ==============================================================================
multi_series_mae = (
    multi_series_mae.set_index('levels')['mean_absolute_error']
    .rename('multi_series_mae')
)
results = pd.concat((uni_series_mae, multi_series_mae), axis=1)
results['improvement'] = results['uni_series_mae'] - results['multi_series_mae']
results['improvement_(%)'] = (
    100 * results['improvement'] / results['uni_series_mae']
)
results = results.round(2)

# Mejora media de todos los items
# ==============================================================================
results[['improvement', 'improvement_(%)']].agg(['mean', 'min', 'max'])

# Número de series con mejora positiva y negativa
# ==============================================================================
pd.Series(
    np.where(results['improvement_(%)'] < 0, 'negative', 'positive')
).value_counts()

positive    48
negative     2
Name: count, dtype: int64

Tras optimizar los lags e hiperparámetros de ambas aproximaciones, la mejora media del modelo multiserie se reduce del 7.5% al 5.2%. Aun así, el modelo multiserie sigue proporcionando mejores resultados para 48 de los 50 items, y en los otros dos la diferencia es despreciable.

Selección de predictores¶

La selección de predictores es el proceso de seleccionar un subconjunto de predictores relevantes (variables) para su uso en la construcción del modelo. Las técnicas de selección de predictores se utilizan por varias razones: para simplificar los modelos y hacerlos más fáciles de interpretar, para reducir el tiempo de entrenamiento, para evitar los problemas de dimensionalidad, para mejorar la generalización reduciendo el sobreajuste (formalmente, la reducción de la varianza), entre otros.

Skforecast es compatible con los métodos de selección implementados en scikit-learn. Existen varios métodos de selección de características, pero los más comunes son:

• Recursive feature elimination (RFE)

• Sequential Feature Selection (SFS)

• Feature selection based on threshold (SelectFromModel)

Consulte la guía de usuario de selección de predictores para ver ejemplos de cómo aplicar estos métodos a los forecasters de skforecast con las funciones select_features y select_features_multiseries.

Pesos en forecasting multiseries¶

Los pesos se utilizan para controlar la influencia que tiene cada observación en el entrenamiento del modelo. ForecasterRecursiveMultiSeries acepta dos tipos de pesos:

• series_weights controla la importancia relativa de cada serie. Si una serie tiene el doble de peso que las demás, las observaciones de esa serie influyen el doble en el entrenamiento. Cuanto mayor sea el peso de una serie en relación con las demás, más se centrará el modelo en intentar aprender esa serie.

• weight_func controla la importancia relativa de cada observación en función del índice. Por ejemplo, una función que asigna un peso menor a ciertas fechas.

Si se indican los dos tipos de pesos, estos se multiplican para crear los pesos finales como se muestra en la figura. El sample_weight resultante no puede contener valores negativos.

Más información sobre weights in multi-series forecasting y weighted time series forecasting con skforecast.

En este ejemplo, item_1 tiene una mayor importancia relativa entre series (pesa 3 veces más que el resto de series), y las observaciones entre '2013-12-01' y '2014-01-31' se consideran no representativas y se les aplica un peso de 0. Como solo item_1 está incluida en series_weights, skforecast lanza un IgnoredArgumentWarning para informar de que el resto de series reciben un peso de 1; es el comportamiento esperado.

# Pesos en forecasting multiseries
# ======================================================================================
# Pesos de cada serie
series_weights = {'item_1': 3.0}  # Las series ausentes en el dict tienen peso 1

# Pesos de cada observación (por índice)
def custom_weights(index):
    """
    Devuelve 0 si el índice está entre '2013-12-01' y '2014-01-31', 1 en caso contrario.
    """
    weights = np.where(
                  (index >= '2013-12-01') & (index <= '2014-01-31'),
                   0,
                   1
              )

    return weights

forecaster = ForecasterRecursiveMultiSeries(
                 estimator          = HistGradientBoostingRegressor(random_state=123),
                 lags               = 14,
                 transformer_series = StandardScaler(),
                 weight_func        = custom_weights,
                 series_weights     = series_weights
             )

forecaster.fit(series=data)
forecaster.predict(steps=7).head(3)

╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮
│ Passing a DataFrame (either wide or long format) as `series` requires additional     │
│ internal transformations, which can increase computational time. It is recommended   │
│ to use a dictionary of pandas Series instead. For more details, see:                 │
│ https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. │
│ html#input-data                                                                      │
│                                                                                      │
│ Category : skforecast.exceptions.InputTypeWarning                                    │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:4425                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                │
╰──────────────────────────────────────────────────────────────────────────────────────╯

╭─────────────────────────────── IgnoredArgumentWarning ───────────────────────────────╮
│ {'item_40', 'item_9', 'item_5', 'item_28', 'item_29', 'item_31', 'item_22',          │
│ 'item_13', 'item_19', 'item_20', 'item_45', 'item_47', 'item_41', 'item_48',         │
│ 'item_15', 'item_6', 'item_10', 'item_27', 'item_32', 'item_17', 'item_42',          │
│ 'item_33', 'item_39', 'item_14', 'item_43', 'item_26', 'item_18', 'item_44',         │
│ 'item_35', 'item_49', 'item_2', 'item_46', 'item_11', 'item_37', 'item_16',          │
│ 'item_24', 'item_30', 'item_34', 'item_21', 'item_36', 'item_7', 'item_8',           │
│ 'item_38', 'item_23', 'item_50', 'item_12', 'item_3', 'item_25', 'item_4'} not       │
│ present in `series_weights`. A weight of 1 is given to all their samples.            │
│                                                                                      │
│ Category : skforecast.exceptions.IgnoredArgumentWarning                              │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\rec │
│ ursive\_forecaster_recursive_multiseries.py:2227                                     │
│ Suppress : warnings.simplefilter('ignore', category=IgnoredArgumentWarning)          │
╰──────────────────────────────────────────────────────────────────────────────────────╯

Predecir nuevas series (series desconocidas)¶

ForecasterRecursiveMultiSeries permite predecir series desconocidas (series no vistas durante el proceso de entrenamiento). Pueden darse dos escenarios:

• Existen datos históricos para la nueva serie: El usuario debe proporcionar un DataFrame con los datos históricos necesarios para crear los predictores (lags y rolling) utilizados durante el proceso de predicción. Este DataFrame debe contener una columna por cada serie que se desee predecir. Es posible incluir tanto series vistas durante el entrenamiento como series nuevas (no vistas).

• No existen datos históricos para la nueva serie: Este escenario es similar, pero la last_window para las nuevas series está compuesta completamente por valores NaN. Este enfoque solo es posible cuando se utilizan estimadores que soportan valores faltantes, ya que todos los lags serán NaN.

En ambos casos, las variables exógenas pueden estar disponibles o no. Si no están disponibles, se establecerán automáticamente como NaN. Como las nuevas series no se han visto durante el entrenamiento, su identificador tampoco puede codificarse: también se establece como NaN, y skforecast lanza un UnknownLevelWarning para informar de ello. Por tanto, el estimador debe admitir valores faltantes (HistGradientBoostingRegressor los admite).

# Predecir nuevas series con datos históricos disponibles
# ==============================================================================
# Crear un dataframe con las últimas 14 observaciones de la nueva serie
last_window_new = pd.DataFrame(
    {
        'series_new_1': [25.0, 31.0, 28.0, 35.0, 41.0, 38.0, 26.0,
                         27.0, 33.0, 29.0, 36.0, 43.0, 40.0, 28.0],
        'series_new_2': [65.0, 78.0, 72.0, 83.0, 95.0, 91.0, 68.0,
                         67.0, 80.0, 74.0, 86.0, 98.0, 92.0, 70.0]
    },
    index=pd.date_range(end=data.index[-1], periods=14, freq='D'),
)

forecaster.predict(steps=5, last_window=last_window_new)

╭──────────────────────────────── UnknownLevelWarning ─────────────────────────────────╮
│ `levels` {'series_new_2', 'series_new_1'} were not included in training. Unknown     │
│ levels are encoded as NaN, which may cause the prediction to fail if the estimator   │
│ does not accept NaN values.                                                          │
│                                                                                      │
│ Category : skforecast.exceptions.UnknownLevelWarning                                 │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:1502                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=UnknownLevelWarning)             │
╰──────────────────────────────────────────────────────────────────────────────────────╯

# Predecir nuevas series sin datos históricos disponibles
# ==============================================================================
# Crear un dataframe con la última ventana de la nueva serie con valores NaN
last_window_new = pd.DataFrame(
    {
        'series_new_1': np.nan,
        'series_new_2': np.nan
    },
    index=pd.date_range(end=data.index[-1], periods=14, freq='D'),
)

forecaster.predict(steps=5, last_window=last_window_new)

╭──────────────────────────────── UnknownLevelWarning ─────────────────────────────────╮
│ `levels` {'series_new_2', 'series_new_1'} were not included in training. Unknown     │
│ levels are encoded as NaN, which may cause the prediction to fail if the estimator   │
│ does not accept NaN values.                                                          │
│                                                                                      │
│ Category : skforecast.exceptions.UnknownLevelWarning                                 │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:1502                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=UnknownLevelWarning)             │
╰──────────────────────────────────────────────────────────────────────────────────────╯

╭──────────────────────────────── MissingValuesWarning ────────────────────────────────╮
│ `last_window` has missing values. Most of machine learning models do not allow       │
│ missing values. Prediction method may either raise an error or return NaN            │
│ predictions.                                                                         │
│                                                                                      │
│ Category : skforecast.exceptions.MissingValuesWarning                                │
│ Location :                                                                           │
│ C:\Users\Joaquin\miniconda3\envs\skforecast_27_py13\Lib\site-packages\skforecast\uti │
│ ls\utils.py:1602                                                                     │
│ Suppress : warnings.simplefilter('ignore', category=MissingValuesWarning)            │
╰──────────────────────────────────────────────────────────────────────────────────────╯

Conclusiones¶

Este documento ha mostrado cómo los modelos de forecasting globales pueden utilizarse para modelar múltiples series temporales con skforecast:

• Un único modelo global entrenado con las 50 series de ventas superó a los modelos individuales en 49 de las 50 series, con una mejora media de aproximadamente el 7.5% (5.2% tras optimizar los hiperparámetros de ambas aproximaciones, cuando es mejor en 48 de las 50 series). Esto confirma que un modelo multiserie puede tener ventajas sobre varios modelos individuales al predecir series temporales que siguen dinámicas similares.

• ForecasterRecursiveMultiSeries puede combinar series de diferente longitud, con valores faltantes y con distintas variables exógenas para cada serie.

• La influencia de cada serie y de cada observación en el modelo puede controlarse con series_weights y weight_func.

• Una vez entrenado, un modelo global puede predecir series no vistas durante el entrenamiento, siempre que se disponga de su historia reciente o el estimador admita valores faltantes.

Más allá de las posibles mejoras en la capacidad predictiva, también es importante tener en cuenta la ventaja de tener un único modelo que mantener.

Información de sesión¶

import session_info
session_info.show(html=False)

-----
matplotlib          3.11.2
numpy               2.5.4
pandas              2.3.3
session_info        v1.0.1
skforecast          0.27.0
sklearn             1.9.1
tqdm                4.70.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:37

Instrucciones para citar¶

¿Cómo citar este documento?

Si utilizas este documento o alguna parte de él, te agradecemos que lo cites. ¡Muchas gracias!

Modelos de forecasting globales: modelado de múltiples series temporales con machine learning por Joaquín Amat Rodrigo and Javier Escobar Ortiz, disponible con licencia Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0 DEED) en https://www.cienciadedatos.net/documentos/py44-multi-series-forecasting-skforecast-español.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.