Añade características de calendario y de retardo

Unos 26 minutos de lectura, con 2 ejemplos en 8 secciones.

Edición 2026.11.11 Ejemplos verificados el 20 de nov de 2026 41 de 41 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.11. Lee el original

Al terminar este capítulo, podrás convertir el historial horario de un cliente en una tabla de características, añadir retardos y características de calendario y de días festivos que un pronóstico de un día de antelación puede usar, medir qué aporta cada característica sobre las mismas ventanas y detectar un retardo que lee el día que se pronostica.

Los modelos estadísticos del Capítulo 4 solo ven una serie. Conocen su nivel y su ritmo diario, y nada más: no saben que el 25 de diciembre de 2014 fue festivo nacional, que un lunes es distinto de un domingo ni que la demanda varía según la estación. El Capítulo 1 mostró lo que eso cuesta. Su línea base estacional ingenua tuvo su peor día el 26 de diciembre, el día después de Navidad, porque copió hacia adelante las lecturas del festivo. Un modelo de gradient boosting puede incorporar hechos de este tipo como columnas, y como el proveedor compra antes de que empiece el día, solo pueden entrar en su pronóstico las columnas conocidas en el momento de corte. Este capítulo añade columnas de calendario y de festivos para el subconjunto de ocho clientes y comprueba cada una antes de darla por válida. La marca de festivo no corrige el fallo del 26 de diciembre, porque el 26 de diciembre no es festivo. La característica que sí lo corregiría, una marca de día posterior a un festivo, también se conoce de antemano, pero este capítulo no la construye, y sus cortes estándar no puntúan un festivo.

Convierte el historial en características

Último cambio en la edición 2026.11.11

La tabla va primero, porque cada característica de este capítulo es una columna de ella. Una tabla de características tiene una fila por cada hora que el modelo debe predecir. Cada fila de una tabla de características contiene el valor a predecir, que el libro llama el objetivo, y las características: las lecturas y los datos que el modelo puede usar para la hora de esa fila. Un modelo de gradient boosting aprende una correspondencia de las columnas al objetivo, una fila a la vez, así que la tabla es todo lo que el modelo puede saber.

Las características de una fila deben ser conocidas en el corte de la ventana que la pronostica, porque el pronóstico se hace ahí. El objetivo es la lectura en esa hora. El modelo necesita dos tipos de filas. Las filas de entrenamiento son las horas del historial anteriores al corte, cada una con sus propias características y su propia lectura como objetivo. Las filas de pronóstico son las 24 horas posteriores al corte, con características pero sin objetivo. El modelo se ajusta con el primer tipo y predice el segundo.

Tomemos el corte a las 00:00 del 30 de diciembre de 2014. Sus filas de pronóstico son las 24 horas del 30 de diciembre, de 00:00 a 23:00, y cada una tiene un objetivo en blanco. Sus filas de entrenamiento retroceden ocho semanas, hasta el 4 de noviembre de 2014, una fila por cliente y hora, con la lectura como objetivo. Tomemos la fila del 15 de diciembre a las 18:00: su objetivo es la lectura en esa hora, y sus características son lecturas de horas anteriores, como la lectura de 24 horas antes. Ninguna fila es un total diario.

La tabla de entrenamiento de cada ventana se construye a partir de las 1,344 horas de historial anteriores a su corte, ocho semanas, para cada cliente en SUBSET8. Los ocho clientes se apilan en una sola tabla, y la misma construcción se repite para cada ventana de decisión y para los tres cortes estándar, del 29 al 31 de diciembre de 2014. La primera semana de historial no tiene una lectura una semana antes, así que sale de la tabla: 1,344 horas menos 168 horas dejan 1,176 filas por cliente en cada ventana. Se ajusta un modelo por ventana, solo con el historial de esa ventana, de modo que ninguna fila de entrenamiento proviene de los días que se pronostican.

Para el conjunto solo de rezagos, las columnas son los dos rezagos y el objetivo y; la hora del día llega con las demás columnas de calendario más adelante en el capítulo, y la columna de festivos después de ellas. MLForecast en mlforecast 1.1.0 toma la serie y produce las filas de entrenamiento en fit y las filas de pronóstico en predict. Dos de sus valores por defecto importan aquí. Una fila de entrenamiento cuyas características faltan se descarta (dropna=True, en mlforecast/core.py), y las primeras horas de cada historial se descartan porque no tienen una lectura una semana antes. Nada en la biblioteca impide que una característica lea la hora que predice. La regla que lo impide es la que tú escribes y compruebas.

Regla práctica: Construye cada fila de características como si el corte fuera la última lectura que tienes. Una característica para una hora de pronóstico debe poder calcularse a partir de lecturas del corte o anteriores a él de su ventana. Antes de cualquier prueba de desplazamiento, pregunta si la característica se conoce en el corte. Luego compruébala con la prueba de desplazamiento del capítulo 3, y no entrenes con una tabla que no hayas comprobado.

Añade retardos que el pronóstico pueda ver

Último cambio en la edición 2026.11.5

Los retardos son las primeras columnas que se añaden a esa tabla: lecturas anteriores del mismo cliente. El retardo de k horas para la hora t es la lectura en t menos k. Los retardos son la forma más económica de darle a un modelo el ritmo de una serie: un retardo de 24 es la lectura de la misma hora de ayer, y un retardo de 168 es la lectura de la misma hora hace una semana. El modelo aprende cuánta confianza darle a cada uno. El retardo de 168 también retrocede una semana completa, que es el mismo día de la semana, así que recoge el patrón semanal sin necesidad de una columna de día de la semana.

Si un retardo es conocido depende del horizonte. Un pronóstico hecho a las 00:00 cubre las 24 horas posteriores al corte. Numera las horas de ese día de 0 a 23, contadas desde el corte. Un retardo de k lee la hora j menos k, así que para la hora objetivo j lee una lectura anterior al corte solo cuando j menos k es negativo. Eso debe cumplirse para cada j de 0 a 23, lo que significa que k debe ser 24 o más. Un retardo de 1 es conocido para la primera hora, porque lee la última lectura antes del corte. Para las otras 23 horas lee una lectura que el pronóstico no tiene.

La tabla siguiente muestra los tres tipos de hora objetivo en ese pronóstico de un día de antelación, para un corte a las 00:00. La hora 0 es la primera hora después del corte, y la hora 23 es la última.

Hora objetivo Retardo 1 lee Retardo 1 conocido en el corte Retardo 24 lee Retardo 24 conocido en el corte
00:00 (hora 0) 23:00 del día anterior sí 00:00 del día anterior sí
01:00 (hora 1) 00:00 del día del pronóstico no 01:00 del día anterior sí
23:00 (hora 23) 22:00 del día del pronóstico no 23:00 del día anterior sí

Los dos retardos del proveedor, 24 y 168, son conocidos a cada hora del pronóstico de un día de antelación, así que el modelo nunca necesita una lectura que todavía no existe. lgbm-feature-sets pasa estos dos retardos a MLForecast, y la biblioteca hace el resto.

La regla del reloj del Capítulo 3 también afecta a los retardos: la hora del hueco del 30 de marzo de 2014 se pone como faltante, de modo que cualquier variable que la lea también falta. En el historial de un corte del 1 de abril de 2014, lgbm-feature-sets encuentra 1 hora enmascarada, y 1 fila tiene un retardo que la lee: la fila 24 horas después del hueco. Antes de ajustar el modelo de cada ventana, sus horas enmascaradas se rellenan como el Capítulo 3 las rellena, a partir del propio historial de esa ventana, y el relleno no lee nada posterior al corte. Una vez rellenada, la hora es una lectura, así que la fila que la lee conserva su valor, y LightGBM nunca recibe un valor faltante de un retardo. La regla es una decisión declarada, no un óptimo medido. El recuento impreso junto a ella es lo que el lector debe comprobar.

Regla práctica: Usa solo retardos al menos tan largos como el horizonte. Con un horizonte de 24 horas eso significa 24 horas o más, y este libro usa 24 y 168. Un retardo más corto necesita una razón, y un modelo que lo use debe superar la prueba de desplazamiento antes de que alguien confíe en su puntuación. Mantén la regla del reloj en los retardos, cuenta las filas cuyos retardos leen una hora enmascarada, y cuenta las horas rellenadas a partir del historial.

Añadir características de calendario y de festivos

Último cambio en la edición 2026.11.11

Los retardos se construyen a partir de las lecturas. Las características de calendario, a diferencia de los retardos, son hechos sobre la propia hora objetivo: su hora del día, su día de la semana y su mes. Se conocen de antemano, porque el reloj los indica antes de que exista ninguna lectura. No necesitan ningún retardo ni ninguna regla de corte. Su valor en una hora objetivo no puede depender de ninguna lectura, así que la prueba de desplazamiento no tiene nada que detectar.

La demanda del proveedor sigue al día. La hora del día repite lo que ya aportan los retardos: el ritmo diario. El día de la semana añade lo que ellos no aportan. Le dice al modelo que el sábado y el domingo difieren de los días laborables. El mes es la tercera columna, y con este historial es una columna débil. Ocho semanas de historial abarcan dos o tres meses naturales, así que month solo puede distinguir unas pocas semanas del historial respecto al resto, y con los cortes estándar todas las horas de previsión caen en diciembre. El libro usa tres características de fecha de mlforecast, nombradas según su atributo: hour, dayofweek y month. La columna del día de la semana ya contiene el fin de semana, así que el libro no añade un indicador de fin de semana por separado. En pandas, dayofweek cuenta el lunes como 0 y el domingo como 6, de modo que el sábado y el domingo son los dos valores que un árbol debe separar del resto. Un árbol puede dividir por ahí en un solo paso, por eso el día de la semana es barato de probar.

Un día festivo público no sigue al día de la semana. Un modelo con solo características de día de la semana lee el 25 de diciembre de 2014 como un jueves cualquiera, y lee un festivo en domingo como un domingo cualquiera. La característica de festivo responde a esto. Es una función de la marca de tiempo, is_holiday en el módulo compartido examples/lib/features.py, que devuelve 1 en un festivo nacional portugués y 0 en otro caso. mlforecast acepta una función así como característica de fecha y nombra su columna según la función. Los festivos proceden del paquete holidays 0.110.dev20261118063242, con licencia MIT, a través de holidays.country_holidays("PT", years=[2013, 2014]). Para los dos años de los datos, el paquete enumera 18 fechas. El libro no incluye esa lista. Cada ejecución la construye a partir del calendario del paquete.

Los cortes estándar son del 29 al 31 de diciembre de 2014, y ninguna de sus 72 horas por cliente es festivo. El 25 de diciembre de la semana reservada está fuera de ellos, así que el efecto de la característica sobre ese día no se evalúa en este capítulo. En los cortes estándar, solo llega a las puntuaciones a través del historial de entrenamiento, que contiene los festivos del 8 y del 25 de diciembre de 2014.

La lista de festivos es un hecho conocido de antemano, como el día de la semana. Procede de un calendario publicado y no de las lecturas, así que no puede filtrar una lectura del día objetivo. Las características de calendario responden a la pregunta de la regla práctica en cada hora objetivo, por construcción, y un retardo solo pasa la prueba cuando es al menos tan largo como el horizonte.

Regla práctica: Añade las características de calendario que requiera el ritmo de tu caso, y conserva cada una solo si ayuda en las mismas ventanas, como mide la siguiente sección. Para los festivos, usa un calendario que cubra todos los años de tus datos y todos los años que vayas a predecir, e imprime cuántos festivos contiene para esos años. Un recuento de cero para un año de previsión significa que la lista no tiene ese año, no que ese año no tuviera festivos.

Elige sobre las ventanas de decisión

Último cambio en la edición 2026.11.11

Las ventanas de decisión son las ventanas sobre las que se elige el conjunto de características, nunca los cortes estándar, que son las ventanas que el libro reporta. Hay dos tipos. El primero son cuatro cortes ordinarios, 25 de noviembre, 26 de noviembre, 2 de diciembre y 3 de diciembre de 2014. El segundo son siete cortes de festivo: los festivos nacionales portugueses de 2014 anteriores al 25 de diciembre cuyo historial de ocho semanas está completo, 18 de abril, 20 de abril, 25 de abril, 1 de mayo, 10 de junio, 15 de agosto y 8 de diciembre. Las ventanas ordinarias no contienen ningún festivo, así que una característica de festivo nunca ganaría en ellas, y las ventanas de festivo son donde sí puede ganar. La elección usa, por tanto, todas las ventanas de decisión, porque uno de los conjuntos contiene una característica de festivo. Los cortes estándar se puntúan después de la elección y se imprimen junto a ella. No eligen nada.

La marca de festivo actúa de dos maneras. En las ventanas de decisión está activa en las horas puntuadas, así que puede cambiar una predicción. En los cortes estándar ningún festivo cae en una hora puntuada, de modo que la marca solo cambia esas puntuaciones a través del entrenamiento.

Regla práctica: Elige una característica sobre ventanas que sean anteriores a la semana reservada y que correspondan al tipo de día para el que sirve la característica: una característica de festivo necesita ventanas de festivo. Los cortes estándar se informan junto a la elección y nunca se usan para hacerla.

Esta parte aún no está traducida, así que está en inglés.

Measure what each feature adds

Último cambio en la edición 2026.11.11

A feature is worth keeping when it lowers the error on windows the model did not train on. To measure one, hold everything else fixed: the same windows, the same history, the same settings. Three feature sets are fitted, one at a time. The first has lags only. The second adds the calendar features. The third adds the holiday feature to them. Each set is fitted once per window, with one model for all eight clients of SUBSET8, and each is compared with seasonal naive on the same windows.

Each set gets two scores. The pooled MAE is the MAE over every client-hour in the windows, the single number for the whole supplier. The mean per-client MASE is MASE for each client, averaged over the eight clients. MASE divides each client's error by a scale: the mean absolute error that seasonal naive makes in sample on that client's own readings. The book uses one scale function everywhere, scoring.book_scale. The scale reads every reading before the first scored window of the set, Apr 18, 2014 at 00:00, with clock-change hours masked, so it does not depend on the windows scored and cannot leak. One client needs care. MT_115 starts reading on Jan 14, 2014, and the zeros before its first reading are left out of its scale, because it is counted from its first reading. Chapter 4 teaches that rule for late starters.

lgbm-feature-sets.py Python 3.13.16 · holidays 0.110.dev20261118063242 · lightgbm 4.7.0 · mlforecast 1.1.0 · numpy 2.5.5 · pandas 2.3.3 · statsforecast 2.1.1 · utilsforecast 0.2.17 Superado
"""Compare three feature sets for the global LightGBM forecast of SUBSET8 on the decision windows (B-5, B-9, B-10): fourordinary cutoffs and seven 2014 holidays before Dec 25, each fitted scaled and unscaled. The mean MASE lines carry thechoice; the standard-cutoff lines are reported beside it and choose nothing."""import pandas as pdfrom lib.backtest import history_beforefrom lib.electricity import loadfrom lib.features import CALENDAR, PT_HOLIDAYS, is_holiday, rows_reading_missing, score_feature_setsfrom lib.panel import DECISION_CUTOFFS, HOLIDAY_DECISION_CUTOFFSfrom lib.quirks import mask_clock_changesfrom lib.settings import EVAL_CUTOFFS, LEAD, SUBSET8, showLAGS = [24, 168]  # both at least the 24-hour horizon, so each is known at every forecast hour# CALENDAR is hour, dayofweek and month, as mlforecast date features; the holiday set adds is_holiday to themFEATURE_SETS = {"lags_only": [], "with_calendar": CALENDAR, "with_holidays": CALENDAR + [is_holiday]}MODELS = ["SeasonalNaive", *FEATURE_SETS, *[f"unscaled_{name}" for name in FEATURE_SETS]]DECISION = sorted([*DECISION_CUTOFFS, *HOLIDAY_DECISION_CUTOFFS])  # the decision windows; standard cutoffs are not hereraw = load(SUBSET8)# DECISION[0] is the first decision window, Apr 18, 2014: the MASE scale reads only the readings before itforecasts, scored, per_client = score_feature_sets(raw, DECISION, LAGS, FEATURE_SETS, DECISION[0])show("clients", forecasts["unique_id"].nunique())show("decision windows", len(DECISION))show("scored hours", len(scored))show("Portuguese holidays in 2013 and 2014", len(PT_HOLIDAYS))show("holiday hours in the decision windows", int(is_holiday(scored["ds"]).sum()))for model in MODELS:    show(f"MAE {model.replace('unscaled_', 'unscaled ')}", (scored["y"] - scored[model]).abs().mean())for model in MODELS:    show(f"mean MASE {model.replace('unscaled_', 'unscaled ')}", per_client[model].mean(), digits=3)for model in MODELS:    # the prose does not quote this client, so this line is for reference only    show(f"MASE MT_268 {model.replace('unscaled_', 'unscaled ')}", per_client.loc["MT_268", model], digits=3)# The standard cutoffs, reported beside the choice above. Nothing is chosen from them.# The scale here reads the readings before the first standard cutoff, Dec 29, 2014._, _, standard = score_feature_sets(raw, EVAL_CUTOFFS, LAGS, FEATURE_SETS, EVAL_CUTOFFS[0])for model in MODELS:    show(f"standard cutoffs, mean MASE {model.replace('unscaled_', 'unscaled ')}", standard[model].mean(), digits=3)# Clock-change check: the history of a 1 April 2014 cutoff holds the 30 March gap, which the feature rules must reach.march = history_before(mask_clock_changes(load([LEAD])), pd.Timestamp("2014-04-01"))  # the Chapter 3 mask, then the cutshow("masked hours in the history", int(march["y"].isna().sum()))# a row counts when either lag, 24 or 168, reads a masked hourshow("rows whose lag reads a masked hour", rows_reading_missing(march.set_index("ds")["y"], LAGS))
Salidapython lgbm-feature-sets.py
clients: 8
decision windows: 11
scored hours: 2112
Portuguese holidays in 2013 and 2014: 18
holiday hours in the decision windows: 1344
MAE SeasonalNaive: 305.21
MAE lags_only: 280.57
MAE with_calendar: 270.57
MAE with_holidays: 267.40
MAE unscaled lags_only: 304.03
MAE unscaled with_calendar: 271.63
MAE unscaled with_holidays: 280.75
mean MASE SeasonalNaive: 0.934
mean MASE lags_only: 0.886
mean MASE with_calendar: 0.894
mean MASE with_holidays: 0.893
mean MASE unscaled lags_only: 1.115
mean MASE unscaled with_calendar: 1.119
mean MASE unscaled with_holidays: 1.139
MASE MT_268 SeasonalNaive: 0.840
MASE MT_268 lags_only: 0.797
MASE MT_268 with_calendar: 0.758
MASE MT_268 with_holidays: 0.789
MASE MT_268 unscaled lags_only: 0.855
MASE MT_268 unscaled with_calendar: 0.871
MASE MT_268 unscaled with_holidays: 0.936
standard cutoffs, mean MASE SeasonalNaive: 1.162
standard cutoffs, mean MASE lags_only: 1.057
standard cutoffs, mean MASE with_calendar: 1.165
standard cutoffs, mean MASE with_holidays: 1.134
standard cutoffs, mean MASE unscaled lags_only: 1.357
standard cutoffs, mean MASE unscaled with_calendar: 1.494
standard cutoffs, mean MASE unscaled with_holidays: 1.486
masked hours in the history: 1
rows whose lag reads a masked hour: 1

Seasonal naive is the bar here. Its MAE, pooled over 2112 scored hours (eight clients in 11 windows of 24 hours each), is 305.21 kWh.

Without scaling, the lags-only model trails seasonal naive on the per-client view. Its mean per-client MASE is 1.115, worse than seasonal naive's 0.934. The clients differ a great deal in size, so the largest clients' readings are many times the smallest's. A global model fits one loss over every client's rows, and here that loss is squared error in kWh, so the largest clients' errors set the splits and the small clients carry little weight. We think the cause is the loss, not the range of any one client. The scaled runs below remove the difference, which supports that reading. It is a judgement from these numbers, not a proof.

The scaled runs standardise each client's target with mlforecast's LocalStandardScaler (mlforecast/target_transforms.py), which subtracts the client's mean and divides by its standard deviation. Both come from the window's history before the cutoff, fitted inside fit, and predict only inverts them. No reading after the cutoff sets them, so the scaling passes the same test as the features. make_forecaster takes scaled=True by default, and Chapter 6 reuses that default.

Scaled, the comparison changes, and lags alone beat seasonal naive on the per-client view: a mean MASE of 0.886, against 0.934. Its pooled MAE is 280.57 kWh.

The calendar set does not beat lags alone. It still beats seasonal naive: its mean MASE is 0.894, and its pooled MAE is 270.57 kWh.

The holiday flag, added to the calendar set, narrows the gap without closing it: the mean is 0.893, and the pooled MAE is 267.40 kWh.

Chapter 4 set AutoETS and ARIMA as the bar a gradient-boosting model must beat. On the standard cutoffs, lags alone also come in under that bar: 1.057 against ARIMA's 1.09, on the same clients, cutoffs and scale.

By the working rule, only the lags stay, and the per-client view decides it, because it is the view that matters to a client's forecast. The calendar set's mean MASE is above lags alone's, so it is not kept. The pooled view points the other way here: the calendar set's pooled MAE is below lags alone's, and the holiday set's is lower still. The chapter reports both, as the rule asks, and does not tune the model to make them agree.

The rule keeps a feature only when it lowers the error of the set it extends. The holiday flag lowers the calendar set's mean by a hair, too little to count as a gain, and the set that holds it is still above lags alone. The flag is on for 1344 client-hours, a full day on each holiday window, for every client, so it had its chance, and it does not earn a place. The book therefore hands Chapter 6 the lags-only set. That result comes from 11 windows, which is a small test.

Working rule: Keep a feature set only when it lowers the mean per-client MASE against the set it extends, on the same windows. Report the pooled MAE beside it. Do not tune the model to make a disagreement between the two views go away.

Esta parte aún no está traducida, así que está en inglés.

Catch a lag that leaks the future

Último cambio en la edición 2026.11.11

The measurements above assume that each feature is known at its cutoff. A leak is a feature that uses a reading the forecast cannot have at its cutoff. In the book's view, a leak is a likely reason a backtest looks better than the model will be, and it can be built by accident. One pattern builds the feature table once from the whole series, so each target hour carries its lag, and then scores the table's forecast rows as if they were out of sample. Nothing fails. The score is too good, and nothing in it says so.

The library adds a second trap of its own. MLForecast predicts recursively by default. In recursive prediction, for a 24-hour horizon, MLForecast forecasts one hour, writes that forecast back as the reading for the next hour, and repeats (_predict_recursive in mlforecast/core.py). A lag of 1 therefore reads a forecast for every hour after the first, while training read actual readings for that lag. Calling that mismatch a leak is the book's judgement. It is one more reason to choose lags of 24 or more. With lags of 24 and 168, every step of the 24 reads actual readings, so the recursion never feeds this model its own forecasts. With max_horizon set, the library trains one model per horizon instead, and predicts with them in _predict_multi. The rule does not change with it: a feature must still be known at the cutoff of the window it forecasts.

The shift test from Chapter 3 carries over with one change: compare the lag at the target hours after the cutoff, not at the history rows. Compute the lag for each target hour twice: once from the history cut at the cutoff, and once from the whole series. Count the hours where the two differ. A lag of 24 agrees on every target hour, because each of the 24 hours reads a reading before the cutoff. A lag of 1 agrees only on the first hour.

Which do you expect to have the lower error, the model with a lag of 1 or the one without it? Both are fitted on the same training rows with the same settings, for each of the three standard cutoffs. The honest model uses lags 24 and 168. The leaky model adds a lag of 1, read from the whole series for the target hours, which is what the table built once would do.

lag-leak-check.py Python 3.13.16 · holidays 0.110.dev20261118063242 · lightgbm 4.7.0 · mlforecast 1.1.0 · numpy 2.5.5 · pandas 2.3.3 · statsforecast 2.1.1 · utilsforecast 0.2.17 Superado
"""Shows which lag leaks: a lag of 1 reads the hour before each target hour, which a 24-hour forecast does not have at itscutoff. The rows-differing lines are the shift test, and the two MAE lines show how much the leak flatters the score."""import numpy as npimport pandas as pdfrom lib.electricity import loadfrom lib.features import fit_window_mae, lag_valuesfrom lib.settings import EVAL_CUTOFFS, HORIZON, LEAD, showy = load([LEAD]).set_index("ds")["y"].asfreq("h")  # asfreq gives every hour a row, so a missing hour is NaN, not skippedHONEST, LEAKY = [24, 168], [1, 24, 168]  # HONEST lags are both at least the horizon; LEAKY adds lag 1CUTOFFS = pd.to_datetime(EVAL_CUTOFFS)def shift_test(lag):    """Target hours where the lag differs between the history cut at each cutoff and the whole series, and how many."""    compared = differing = 0    for c in CUTOFFS:        targets = pd.date_range(c, periods=HORIZON, freq="h")  # the 24 hours each forecast must predict        honest = lag_values(y[y.index < c], lag, targets)  # readings before the cutoff only, as the forecast has them        whole = lag_values(y, lag, targets)  # the same lag read from the whole series, as a table built once would read it        same = (honest == whole) | (np.isnan(honest) & np.isnan(whole))  # NaN never equals NaN, so the second term counts two missing readings as the same        compared += len(targets)        differing += int((~same).sum())    return compared, differingshow("cutoffs", len(CUTOFFS))show("rows compared", shift_test(1)[0])  # the first value is the hours compared, the same for every lagfor lag in (1, 24, 168):    show(f"rows differing for lag {lag}", shift_test(lag)[1])show("MAE honest, lags 24 and 168", fit_window_mae(y, HONEST, CUTOFFS, leaky=False))  # the table holds the lags and the hour of day; leaky=False reads the target lags from the cut historyshow("MAE leaky, lags 1, 24 and 168", fit_window_mae(y, LEAKY, CUTOFFS, leaky=True))  # leaky=True reads the whole series
Salidapython lag-leak-check.py
cutoffs: 3
rows compared: 72
rows differing for lag 1: 69
rows differing for lag 24: 0
rows differing for lag 168: 0
MAE honest, lags 24 and 168: 5.36
MAE leaky, lags 1, 24 and 168: 2.87

Only the lag of 1 fails the shift test. Of the 72 target hours compared, 69 read a different value from the cut history than from the whole series: every hour of each window but the first. The lags of 24 and 168 differ on 0 and 0 rows. The lag of 1 agrees only on the first hour of each window, because that hour reads the last reading before the cutoff, which the forecast does have.

The leaky model looks almost twice as good: its MAE is 2.87 kWh, against 5.36 kWh for the honest model. The gap is the leak. Its lag of 1 reads the hour before the target, which for most target hours is an hour of the forecast window itself. The honest model never sees that hour, so its error is the one that production will show.

Working rule: Run the shift test on every lag and every window feature before a model trains on it, and treat any differing row as a leak until you have shown otherwise. When an error falls sharply after you add a feature, check that feature first, before you credit it.

Qué sale mal en producción

Último cambio en la edición 2026.11.5

Una lista de festivos que se detiene al final de los datos asigna cero a todos los festivos posteriores. La marca queda entonces desactivada durante todos los días del año de pronóstico, y el modelo pronostica los festivos como si fueran días ordinarios. El primer festivo aparece como un error grande en el panel de control. El recuento de festivos que imprime el ejemplo es la comprobación: una lista para un año nuevo que imprime cero festivos no incluye ese año. Una versión posterior de holidays también puede cambiar su calendario, así que fija la versión, como hace el libro, y vuelve a ejecutar el recuento después de cualquier actualización.

Un rezago más corto que el horizonte, arrastrado de un modelo horario usado para un pronóstico del día siguiente, obtiene buenos resultados en la prueba retrospectiva, porque la prueba se construyó con la serie completa. En producción, las horas posteriores leen los propios pronósticos del modelo. Compara el error en vivo del pronóstico del día siguiente por hora con el error de la prueba retrospectiva por hora. Un modelo sin esta fuga debería mostrar aproximadamente el error que mostró la prueba retrospectiva en cada hora. Un error que crece con la hora del horizonte, más allá de eso, es señal de retroalimentación de los propios pronósticos del modelo.

La regla del reloj todavía puede fallar en la canalización. Las horas enmascaradas dejan algunas variables de pronóstico sin valor, y una canalización puede descartar esas filas, o rellenar esas horas, sin avisarlo. Imprime las horas enmascaradas y las filas que afectan cada vez que cambie el historial.

Una puntuación agregada puede ocultar el cliente típico. En lgbm-feature-sets, el MAE agregado del modelo sin escalar que usa solo rezagos, 304.03 kWh, es inferior al de la referencia estacional ingenua, 305.21 kWh, pero su MASE medio por cliente es 1.115, frente a 0.934. El proveedor compra energía para cada cliente, así que la cifra por cliente es la que decide el pronóstico de un cliente. Un proveedor que informe solo el MAE agregado venderá el pronóstico equivocado a los clientes que la cifra agregada oculta. Informa el MASE por cliente junto a la cifra agregada, y revisa primero el peor cliente.

Los resultados también pueden depender de la máquina. La referencia de parámetros de LightGBM indica que deterministic da resultados estables para los mismos datos y los mismos parámetros en el tipo de dispositivo CPU, y advierte que los resultados pueden diferir con otras versiones de LightGBM, con binarios compilados por otros compiladores, o en otros sistemas. El libro establece deterministic, histogramas por filas, un hilo y una semilla fija, con LightGBM 4.7.0. Esos ajustes hacen que la salida sea repetible en una misma máquina con un mismo número de hilos: la salida fue idéntica en tres ejecuciones en la máquina de la grabación. No garantizan la concordancia entre máquinas, y el libro no lo ha probado. Las puntuaciones se citan redondeadas, y el redondeo no hace que dos máquinas coincidan. Si una máquina de publicación imprime valores distintos, la salida registrada necesita una nueva grabación, y el texto necesita la misma verificación.

Regla práctica: Vuelve a comprobar el recuento de festivos para cada año de pronóstico, las horas enmascaradas y las filas que alcanzan, y la longitud de los rezagos cada vez que cambien los datos o una biblioteca. Ejecuta la prueba de desplazamiento en cada rezago, y lee el MASE por cliente junto al MAE agregado. Una comprobación que cambia es motivo para detenerse y leer la causa antes de publicar el siguiente pronóstico.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.5

Las decisiones que siguen son las que un lector tendría que tomar de otra manera para cambiar los resultados. Cada una es decisión del libro y queda abierta a revisión cuando una edición posterior mida otra cosa.

  • El modelo heredado usa solo los retardos 24 y 168. El retardo 1 aparece únicamente en la comprobación de fuga, nunca en un pronóstico.
  • El conjunto de variables de calendario es hour, dayofweek y month. Se mide y no se conserva: en la vista por cliente es peor que usar solo retardos. No hay un indicador separado de fin de semana, porque el día de la semana ya lo recoge.
  • El indicador de festivos se mide solo encima del conjunto de calendario, en todas las ventanas de decisión. No se conserva, porque el conjunto que lo incluye sigue siendo peor que usar solo retardos. El capítulo 6 usa el conjunto con solo retardos.
  • Los festivos vienen del paquete holidays para Portugal, para los dos años de los datos. La función is_holiday está en examples/lib/features.py.
  • El objetivo de cada cliente se escala por defecto, con make_forecaster(scaled=True). El escalador se ajusta solo con el historial de cada ventana. La ejecución sin escalar se imprime una vez, para mostrar el fallo que corrige el escalado.
  • Las horas enmascaradas por el cambio de hora de cada ventana se rellenan con el historial de esa ventana antes del ajuste, de modo que no se descarta ninguna fila por ellas y LightGBM nunca recibe un valor ausente.
  • La configuración de LightGBM es LGBM_PARAMS en examples/lib/features.py: determinista, histogramas por filas, un solo hilo y semilla 0. Está ahí, no en settings.py, que este capítulo deja sin cambios.
  • La escala de MASE es scoring.book_scale. Empieza en la primera lectura de cada cliente y usa las lecturas anteriores a la primera ventana de decisión, el 18 de abril de 2014.
  • En las ventanas de decisión, el modelo con solo retardos supera a la referencia estacional ingenua en el MASE medio por cliente. El capítulo no ajusta el modelo para cambiar ese resultado.
  • Los conjuntos de variables se eligen en las ventanas de decisión, no en los cortes estándar ni en la semana reservada. Las ventanas de festivos terminan el 8 de diciembre, así que el efecto del festivo del 25 de diciembre no se mide en este capítulo. Tampoco se mide aquí si las variables de calendario aportan con un historial más largo.
  • La comprobación de fuga usa MT_014, un solo cliente, porque la fuga es una propiedad del retardo y no de la mezcla de clientes, así que su objetivo no se escala. Los conjuntos de variables usan SUBSET8.
  • El capítulo 6 reutiliza make_forecaster, mlforecast_windows, fit_window_mae, lag_table y is_holiday de examples/lib/features.py. make_forecaster escala por defecto.
  • La lección es un orden de pruebas: la prueba de desplazamiento se ejecuta antes de cualquier puntuación, y el MASE por cliente decide qué variables se quedan.

Este capítulo, en esta edición

Edición 2026.11.11Ejemplos verificados el 20 de nov de 2026Superan la prueba 2 de 2 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.11.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 5 de 10: Añade características de calendario y de retardo

  1. Convierte el historial en características
  2. Añade retardos que el pronóstico pueda ver
  3. Añadir características de calendario y de festivos
  4. Elige sobre las ventanas de decisión
  5. Measure what each feature adds
  6. Catch a lag that leaks the future
  7. Qué sale mal en producción
  8. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos