Tutorial ScikitLearn: Validación y evaluación de modelos en series temporales

Técnicas de validación cruzada específicas para series temporales

En el análisis de series temporales, la validación cruzada tradicional no es adecuada debido a la dependencia temporal inherente en los datos. Aplicar métodos como K-Fold o ShuffleSplit rompería el orden cronológico, lo que podría introducir fugas de información y llevar a estimaciones poco realistas del rendimiento del modelo.

Para abordar este desafío, Scikit-Learn proporciona el método TimeSeriesSplit, una técnica de validación cruzada diseñada específicamente para series temporales. Este método divide los datos respetando la secuencia temporal, asegurando que los conjuntos de entrenamiento siempre precedan en el tiempo a los conjuntos de prueba.

A continuación se muestra un ejemplo de cómo utilizar TimeSeriesSplit:

from sklearn.model_selection import TimeSeriesSplit
import numpy as np

# Datos de ejemplo
X = np.arange(10).reshape(-1, 1)
y = np.arange(10)

# Definir TimeSeriesSplit con 5 divisiones
tscv = TimeSeriesSplit(n_splits=5)

# Iterar sobre las particiones
for fold, (train_index, test_index) in enumerate(tscv.split(X)):
    print(f"Fold {fold + 1}")
    print(f"Entrenamiento: índice {train_index}")
    print(f"Prueba: índice {test_index}\n")

Este código generará particiones donde cada conjunto de prueba es posterior al conjunto de entrenamiento, manteniendo la integridad temporal:

Fold 1
Entrenamiento: índice [0 1 2 3 4]
Prueba: índice [5]

Fold 2
Entrenamiento: índice [0 1 2 3 4 5]
Prueba: índice [6]

Fold 3
Entrenamiento: índice [0 1 2 3 4 5 6]
Prueba: índice [7]

Fold 4
Entrenamiento: índice [0 1 2 3 4 5 6 7]
Prueba: índice [8]

Fold 5
Entrenamiento: índice [0 1 2 3 4 5 6 7 8]
Prueba: índice [9]

Es posible personalizar el tamaño de los conjuntos de entrenamiento y prueba utilizando los parámetros max_train_size y test_size:

# Definir TimeSeriesSplit con tamaño máximo de entrenamiento y tamaño de prueba específico
tscv = TimeSeriesSplit(n_splits=3, max_train_size=5, test_size=2)

for fold, (train_index, test_index) in enumerate(tscv.split(X)):
    print(f"Fold {fold + 1}")
    print(f"Entrenamiento: índice {train_index}")
    print(f"Prueba: índice {test_index}\n")

De esta manera, se controla la proporción de datos en cada partición, lo que puede ser útil cuando se trabaja con series temporales muy largas o cuando se quiere simular un escenario de pronóstico específico.

Otra técnica relevante es el uso de la ventana deslizante (rolling window), donde se actualiza el conjunto de entrenamiento incorporando nuevos datos a medida que avanza el tiempo. Esto es especialmente útil en casos donde la serie temporal puede cambiar su comportamiento a lo largo del tiempo.

Ejemplo de implementación de ventana deslizante:

window_size = 5
n_samples = len(X)

for start in range(n_samples - window_size):
    end = start + window_size
    X_train, X_test = X[start:end], X[end:end+1]
    y_train, y_test = y[start:end], y[end:end+1]
    # Entrenar y evaluar el modelo

Esta técnica permite mantener un conjunto de entrenamiento de tamaño constante y evaluar el modelo en puntos sucesivos, lo que ayuda a capturar cambios en la dinámica temporal de los datos.

Al aplicar estas técnicas de validación cruzada específicas, se mejora la estimación del rendimiento real del modelo y se garantiza que las evaluaciones reflejen de manera más precisa su capacidad para generalizar a datos futuros.

División de datos de entrenamiento y prueba en series temporales

En el análisis de series temporales, la correcta división de los datos en conjuntos de entrenamiento y prueba es fundamental para obtener modelos fiables y evitar el sobreajuste. A diferencia de los datos no temporales, las series temporales tienen una dependencia intrínseca en el tiempo, lo que significa que los valores futuros están condicionados por los valores pasados. Por esta razón, es esencial mantener el orden cronológico al realizar la partición de los datos.

Una práctica común es dividir los datos utilizando un punto de corte temporal, donde los datos anteriores a cierta fecha se utilizan para entrenar el modelo y los posteriores para evaluarlo. De esta manera, se simula un escenario real de pronóstico, donde el modelo se entrena con información conocida y se prueba con datos futuros desconocidos.

Por ejemplo, supongamos que tenemos una serie temporal de ventas diarias desde el 1 de enero de 2020 hasta el 31 de diciembre de 2022. Podemos elegir el 31 de diciembre de 2021 como punto de corte:

import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
import matplotlib.pyplot as plt

# Cargar datos de ventas
data = pd.read_csv('ventas_diarias.csv', parse_dates=['fecha'])
data.set_index('fecha', inplace=True)

# Características y objetivo
X = data.drop('ventas', axis=1)
y = data['ventas']

# Convertir variables categóricas a variables dummy
X = pd.get_dummies(X, columns=['dia_semana'], drop_first=True)

# Punto de corte temporal
# Para tener conjuntos de entrenamiento y prueba, puedes elegir una fecha adecuada
# Por ejemplo, entrenar con los primeros 160 días y probar con los últimos 40 días
cutoff_date = '2021-06-09'  # Ajusta según necesites

# Dividir en conjuntos de entrenamiento y prueba
X_train = X.loc[:cutoff_date].values
y_train = y.loc[:cutoff_date].values
X_test = X.loc[cutoff_date:].values
y_test = y.loc[cutoff_date:].values

# Entrenar modelo
model = RandomForestRegressor(random_state=42)
model.fit(X_train, y_train)

# Predecir y evaluar
y_pred = model.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
print(f'Error medio absoluto (MAE): {mae:.2f}')

Este enfoque garantiza que el modelo solo utilice información del pasado para predecir el futuro, respetando la secuencia temporal y evitando fugas de información.

Es importante destacar que la elección del punto de corte debe reflejar el objetivo del análisis y considerar posibles cambios en la estacionalidad o patrones a lo largo del tiempo. En algunos casos, puede ser útil utilizar múltiples puntos de corte para evaluar la robustez del modelo.

Además, es recomendable analizar la distribución de los datos antes y después del punto de corte para asegurarse de que ambos conjuntos sean representativos. Si hay cambios significativos en la serie temporal, como tendencias o ciclos económicos, el rendimiento del modelo podría variar.

Otra técnica útil es el backtesting, que consiste en iterar el proceso de entrenamiento y prueba en diferentes intervalos temporales. Esto permite evaluar cómo se comporta el modelo en diferentes periodos y detectar posibles inestabilidades.

Ejemplo de implementación de backtesting:

from sklearn.metrics import mean_squared_error
import numpy as np

# Definir parámetros de backtesting
initial_train_size = int(len(X) * 0.6)
horizon = 30  # Horizonte de predicción en días
n_trials = int((len(X) - initial_train_size) / horizon)

errors = []

for i in range(n_trials):
    # Definir índices de entrenamiento y prueba
    train_start = 0
    train_end = initial_train_size + i * horizon
    test_start = train_end
    test_end = test_start + horizon
    
    # Extraer conjuntos de entrenamiento y prueba
    X_train = X.iloc[train_start:train_end]
    y_train = y.iloc[train_start:train_end]
    X_test = X.iloc[test_start:test_end]
    y_test = y.iloc[test_start:test_end]
    
    # Entrenar y predecir
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    
    # Evaluar y almacenar error
    mse = mean_squared_error(y_test, y_pred)
    errors.append(mse)

# Error promedio del backtesting
mean_error = np.mean(errors)
print(f'Error cuadrático medio promedio: {mean_error:.2f}')

Este código realiza múltiples entrenamientos y evaluaciones avanzando el conjunto de prueba en ventanas móviles, lo que proporciona una evaluación más completa del rendimiento del modelo a lo largo del tiempo.

Al dividir los datos de esta manera, se evitan problemas comunes como la dependencia temporal y se garantiza que el modelo tenga una capacidad real de generalización. Es esencial también asegurar que todas las transformaciones y preprocesamientos aplicados al conjunto de entrenamiento se apliquen de manera consistente al conjunto de prueba, evitando introducir sesgos en el proceso.

Por último, es crucial documentar y justificar la estrategia de división de datos utilizada, ya que esto aporta transparencia al análisis y facilita la replicabilidad del estudio por parte de otros profesionales.

Métricas de evaluación para modelos de pronóstico (MAE, MSE, RMSE)

La evaluación de modelos de pronóstico es esencial para determinar su capacidad de generar predicciones precisas. Las métricas como MAE, MSE y RMSE permiten cuantificar el error entre los valores reales y las predicciones del modelo, proporcionando una medida objetiva de su desempeño.

El Error Absoluto Medio (MAE, por sus siglas en inglés) es la media de las diferencias absolutas entre los valores predichos y los observados. Se calcula utilizando la siguiente fórmula:

$$
\text{MAE} = \frac{1}{n} \sum_{i=1}^{n} | y_i - \hat{y}_i |
$$

Donde $( y_i )$ son los valores reales y $( \hat{y}_i )$ las predicciones del modelo. El MAE es una métrica intuitiva que expresa el error promedio en las mismas unidades que la variable objetivo, facilitando su interpretación.

El Error Cuadrático Medio (MSE) es la media de los cuadrados de las diferencias entre los valores predichos y los observados:

$$
\text{MSE} = \frac{1}{n} \sum_{i=1}^{n} ( y_i - \hat{y}_i )^2
$$

La naturaleza cuadrática del MSE penaliza más severamente los errores grandes, lo que puede ser útil si se desea enfatizar la importancia de las desviaciones significativas en las predicciones.

La Raíz del Error Cuadrático Medio (RMSE) es la raíz cuadrada del MSE:

$$
\text{RMSE} = \sqrt{ \text{MSE} } = \sqrt{ \frac{1}{n} \sum_{i=1}^{n} ( y_i - \hat{y}_i )^2 }
$$

El RMSE tiene la ventaja de estar en las mismas unidades que la variable objetivo, al igual que el MAE, pero conservando las propiedades del MSE respecto a penalizar errores grandes.

Para ilustrar cómo calcular estas métricas utilizando Scikit-Learn, consideremos un ejemplo práctico. Supongamos que tenemos un conjunto de datos de una serie temporal y queremos entrenar un modelo de bosque aleatorio para realizar pronósticos.

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, root_mean_squared_error
from sklearn.model_selection import TimeSeriesSplit

# Cargar datos
data = pd.read_csv('serie_temporal.csv', parse_dates=['fecha'])
data.set_index('fecha', inplace=True)

# Variables predictoras y objetivo
X = data.drop('valor', axis=1)
y = data['valor']

# Dividir datos utilizando TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
mae_scores = []
rmse_scores = []

for train_index, test_index in tscv.split(X):
    X_train, X_test = X.iloc[train_index], X.iloc[test_index]
    y_train, y_test = y.iloc[train_index], y.iloc[test_index]
    
    # Entrenar el modelo
    model = RandomForestRegressor()
    model.fit(X_train, y_train)
    
    # Realizar predicciones
    y_pred = model.predict(X_test)
    
    # Calcular MAE
    mae = mean_absolute_error(y_test, y_pred)
    mae_scores.append(mae)
    
    # Calcular RMSE
    rmse = root_mean_squared_error(y_test, y_pred)
    rmse_scores.append(rmse)

# Resultados promedio
print(f'Error Absoluto Medio promedio: {np.mean(mae_scores):.2f}')
print(f'Raíz del Error Cuadrático Medio promedio: {np.mean(rmse_scores):.2f}')

En este ejemplo, utilizamos TimeSeriesSplit para respetar la secuencia temporal durante la validación. Calculamos el MAE y el RMSE en cada partición, almacenando los resultados para obtener un promedio final que refleje el rendimiento general del modelo.

Es importante destacar que, para calcular el RMSE utilizando Scikit-Learn, se puede establecer el parámetro squared=False en la función mean_squared_error. Esto devuelve directamente la raíz cuadrada del MSE, simplificando el proceso.

La elección entre MAE, MSE y RMSE depende del contexto y de cómo se desea interpretar el error. El MAE es más robusto frente a valores atípicos, ya que no los penaliza de manera exagerada. Por otro lado, el MSE y el RMSE amplifican los errores grandes debido al cuadrado, lo que puede ser conveniente si se quiere dar más peso a las desviaciones significativas.

Al comparar modelos, es recomendable analizar varias métricas para obtener una visión más completa de su desempeño. Además, es fundamental considerar las características específicas de la serie temporal y el impacto que pueden tener los errores en la aplicación práctica del modelo de pronóstico.

Mediante el uso de estas métricas de evaluación, es posible realizar un diagnóstico preciso y mejorar iterativamente el modelo, ajustando hiperparámetros o probando diferentes enfoques de modelado para optimizar las predicciones.

Análisis de residuos y diagnóstico de modelos

El análisis de residuos es una herramienta fundamental para evaluar la adecuación de los modelos de series temporales. Los residuos representan la diferencia entre los valores observados y las predicciones del modelo:

El análisis detallado de los residuos permite identificar patrones no capturados, autocorrelaciones e indicadores de posibles mejoras en el modelo.

Un supuesto clave en el modelado es que los residuos deben ser independientes, seguir una distribución aproximadamente normal y tener una media cercana a cero. Esto significa que:

1. Los residuos no deben mostrar patrones temporales: Su distribución debería ser aleatoria en el tiempo.
2. La media de los residuos debe ser cercana a cero: Esto indica que el modelo no tiene un sesgo sistemático hacia la subestimación o sobreestimación.

Es importante notar que la media cero no implica que todos los residuos sean exactamente cero; esto solo ocurriría si el modelo ajustara perfectamente cada punto de datos, lo cual no es deseable ni realista, ya que implicaría sobreajuste.

A continuación, se presentan varias herramientas para analizar residuos:

Gráfico de residuos en función del tiempo

Visualizar los residuos a lo largo del tiempo ayuda a detectar patrones temporales no capturados por el modelo. Lo ideal es que los residuos se distribuyan aleatoriamente alrededor de cero:

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
import matplotlib.pyplot as plt
from statsmodels.graphics.tsaplots import plot_acf
from sklearn.model_selection import TimeSeriesSplit

# Cargar datos de la serie temporal
data = pd.read_csv('serie_temporal.csv', parse_dates=['fecha'])
data.set_index('fecha', inplace=True)

# Variables predictoras y objetivo
X = data.drop('valor', axis=1)
y = data['valor']

# Dividir los datos respetando la secuencia temporal
tscv = TimeSeriesSplit(n_splits=5)
train_index, test_index = list(tscv.split(X))[-1]
X_train, X_test = X.iloc[train_index], X.iloc[test_index]
y_train, y_test = y.iloc[train_index], y.iloc[test_index]

# Entrenar el modelo
model = RandomForestRegressor()
model.fit(X_train, y_train)

# Realizar predicciones
y_pred = model.predict(X_test)

# Calcular residuos
residuos = y_test - y_pred

# Gráfico de residuos en función del tiempo
plt.figure(figsize=(12, 6))
plt.plot(y_test.index, residuos, marker='o', linestyle='-', label='Residuos')
plt.hlines(0, y_test.index.min(), y_test.index.max(), colors='r', linestyles='dashed')
plt.title('Residuos del modelo en función del tiempo')
plt.xlabel('Fecha')
plt.ylabel('Residuo')
plt.legend()
plt.show()

Si los residuos tienen una media cercana a cero y no muestran tendencias claras, es una buena señal de que el modelo ha capturado adecuadamente los patrones temporales. Sin embargo, no es esperado que todos los residuos sean exactamente cero, ya que eso indicaría que el modelo está sobreajustando los datos de entrenamiento.

Gráfico de autocorrelación de los residuos

El estudio de la autocorrelación permite identificar dependencia temporal en los residuos. Si los residuos están autocorrelacionados, significa que el modelo no ha capturado toda la estructura de los datos:

from statsmodels.graphics.tsaplots import plot_acf

plot_acf(residuos, lags=30)
plt.title('Función de Autocorrelación de los Residuos')
plt.show()

Si el gráfico muestra barras significativas fuera del intervalo de confianza, podría ser necesario ajustar el modelo o incluir más información.

Prueba de Ljung-Box

La prueba de Ljung-Box evalúa estadísticamente la independencia de los residuos:

from statsmodels.stats.diagnostic import acorr_ljungbox
lb_test = acorr_ljungbox(residuos, lags=[10], return_df=True)
print(lb_test)

Un p-valor bajo (por ejemplo, menor a 0.05) indica que los residuos tienen autocorrelación significativa, sugiriendo que el modelo puede mejorarse.

Verificación de la normalidad de los residuos

Es importante verificar si los residuos siguen una distribución normal. Esto puede evaluarse mediante un histograma y un gráfico Q-Q (cuantil-cuantil):

import scipy.stats as stats

# Histograma de los residuos
plt.figure(figsize=(8, 6))
plt.hist(residuos, bins=20, edgecolor='k')
plt.title('Histograma de los Residuos')
plt.xlabel('Residuo')
plt.ylabel('Frecuencia')
plt.show()

# Gráfico Q-Q
plt.figure(figsize=(8, 6))
stats.probplot(residuos, dist="norm", plot=plt)
plt.title('Gráfico Q-Q de los Residuos')
plt.show()

Un histograma simétrico y un gráfico Q-Q alineado con la diagonal indican que los residuos se aproximan a la normalidad.

Detección de heterocedasticidad

La heterocedasticidad ocurre cuando la varianza de los residuos no es constante a lo largo de las predicciones. Esto se puede analizar graficando los residuos contra las predicciones:

# Gráfico de residuos vs predicciones
plt.figure(figsize=(8, 6))
plt.scatter(y_pred, residuos, edgecolors='k', alpha=0.7)
plt.hlines(0, y_pred.min(), y_pred.max(), colors='r', linestyles='dashed')
plt.title('Residuos vs Predicciones')
plt.xlabel('Predicciones')
plt.ylabel('Residuos')
plt.show()

Si se observa un patrón claro, como un abanico o una forma no aleatoria, esto indica heterocedasticidad. En ese caso, podría ser necesario transformar la variable objetivo o ajustar el modelo.

Acciones si los residuos no cumplen los supuestos

Si los residuos muestran problemas como autocorrelación, heterocedasticidad o falta de normalidad, se pueden considerar las siguientes estrategias:

1. Incorporar términos adicionales: Agregar variables explicativas o transformar las existentes.
2. Cambiar el modelo: Probar algoritmos como ARIMA o redes neuronales recurrentes para capturar patrones complejos.
3. Transformar la variable objetivo: Aplicar logaritmos o diferencias para estabilizar la varianza.

En resumen, el análisis de residuos es una herramienta crucial para diagnosticar la calidad del modelo y guiar ajustes que mejoren su capacidad predictiva.

Prevención del sobreajuste en modelos temporales

El sobreajuste es un problema común en el modelado de series temporales, donde el modelo se ajusta demasiado a los datos históricos y pierde capacidad de generalización a datos futuros. Prevenir el sobreajuste es crucial para desarrollar modelos robustos y fiables en predicciones a largo plazo.

Una técnica fundamental para evitar el sobreajuste es controlar la complejidad del modelo. Modelos demasiado complejos pueden capturar el "ruido" de los datos en lugar de los patrones subyacentes. Por ejemplo, al utilizar un árbol de decisión como DecisionTreeRegressor, es recomendable limitar la profundidad máxima del árbol:

from sklearn.tree import DecisionTreeRegressor

# Crear un modelo de árbol de decisión con profundidad máxima de 5
model = DecisionTreeRegressor(max_depth=5, random_state=42)

Al restringir max_depth, se evita que el árbol se vuelva demasiado específico, lo que ayuda a mejorar su capacidad de generalización.

Otra estrategia efectiva es aplicar regularización en modelos lineales. Los modelos como Ridge y Lasso añaden un término de penalización a la función de coste, lo que reduce la magnitud de los coeficientes y previene el sobreajuste:

from sklearn.linear_model import Ridge

# Crear un modelo de Ridge Regression con alpha=1.0
model = Ridge(alpha=1.0)

El parámetro alpha controla la fuerza de la penalización; valores más altos aumentan la regularización, reduciendo la complejidad del modelo.

La selección de características es otro aspecto clave. Incluir demasiadas variables independientes, especialmente si están altamente correlacionadas, puede conducir al sobreajuste. Es importante seleccionar solo las características más relevantes y eliminar redundancias. Una forma de hacerlo es utilizando técnicas de selección de características basadas en modelos:

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestRegressor

# Modelo base para la selección de características
base_model = RandomForestRegressor(n_estimators=100, random_state=42)

# Selector de características
selector = SelectFromModel(base_model)

# Ajustar el selector y transformar las características
X_reduced = selector.fit_transform(X_train, y_train)

Este proceso ayuda a identificar y utilizar únicamente las características que contribuyen significativamente al rendimiento del modelo.

Además, es esencial realizar una tuning adecuada de los hiperparámetros. Utilizar herramientas como GridSearchCV o RandomizedSearchCV junto con TimeSeriesSplit permite encontrar la combinación óptima de parámetros evitando el sobreajuste:

from sklearn.model_selection import GridSearchCV, TimeSeriesSplit

# Definir el espacio de hiperparámetros
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, None],
    'min_samples_leaf': [1, 2, 4]
}

# Configurar el validador temporal
tscv = TimeSeriesSplit(n_splits=5)

# Configurar la búsqueda en cuadrícula
grid_search = GridSearchCV(
    estimator=RandomForestRegressor(random_state=42),
    param_grid=param_grid,
    cv=tscv,
    scoring='neg_mean_absolute_error',
    n_jobs=-1
)

# Ejecutar la búsqueda
grid_search.fit(X_train, y_train)

# Mejor estimador encontrado
best_model = grid_search.best_estimator_

Este enfoque garantiza que la evaluación de cada combinación de hiperparámetros respete la secuencia temporal, reduciendo el riesgo de fugas de información y sobreajuste.

La implementación de early stopping es especialmente útil en algoritmos que iteran durante el entrenamiento, como los bosques aleatorios o los modelos de gradient boosting. El early stopping detiene el entrenamiento cuando el rendimiento en un conjunto de validación deja de mejorar, evitando sobreajustar a los datos de entrenamiento:

from sklearn.ensemble import GradientBoostingRegressor

# Crear un modelo con early stopping
model = GradientBoostingRegressor(
    n_estimators=1000,
    validation_fraction=0.1,
    n_iter_no_change=10,
    random_state=42
)

# Entrenar el modelo
model.fit(X_train, y_train)

En este ejemplo, el modelo reserva el 10% de los datos de entrenamiento para validación interna y detiene el entrenamiento si no hay mejora en el error durante 10 iteraciones consecutivas.

Otra práctica recomendada es utilizar modelos ensamble que combinan múltiples algoritmos para mejorar la capacidad de generalización y reducir la varianza. Sin embargo, es importante no incrementar excesivamente el número de estimadores, ya que puede llevar a modelos innecesariamente complejos:

from sklearn.ensemble import BaggingRegressor

# Modelo de bagging con 50 estimadores
model = BaggingRegressor(
    estimator=DecisionTreeRegressor(max_depth=5),
    n_estimators=50,
    random_state=42
)

El bagging ayuda a reducir el sobreajuste al promediar los resultados de múltiples modelos ajustados en subconjuntos diferentes de los datos.

Finalmente, es crucial mantener una actualización continua del modelo con nuevos datos. Las series temporales pueden cambiar su comportamiento a lo largo del tiempo debido a cambios estructurales o eventos externos. Retrainar el modelo periódicamente con datos recientes ayuda a mantener su relevancia y capacidad predictiva.