Stationnarité et stabilité

Machine Learning pour les données chronologiques en Python

Chris Holdgraf

Fellow, Berkeley Institute for Data Science

Stationnarité

Une série chronologique stationnaire ne change pas ses propriétés statistiques dans le temps
P. ex. moyenne, écart type, tendances
La plupart des séries sont en partie non stationnaires

Stabilité du modèle

Des données non stationnaires ajoutent de la variabilité au modèle
Les propriétés statistiques trouvées peuvent changer avec les données
Nous serons aussi moins certains des bonnes valeurs des paramètres
Comment quantifier cela ?

Validation croisée pour quantifier la stabilité des paramètres

Une approche : utiliser la validation croisée
Calculer les paramètres du modèle à chaque itération
Évaluer la stabilité des paramètres sur tous les volets de VC

Bootstraper la moyenne

Le bootstrap est une méthode courante pour évaluer la variabilité
Bootstrap :
1. Prendre un échantillon aléatoire avec remise
2. Calculer la moyenne de l'échantillon
3. Répéter de nombreuses fois (des milliers)
4. Calculer les percentiles du résultat (souvent 2,5 et 97,5)

Le résultat est un intervalle de confiance de 95 % pour la moyenne de chaque coefficient.

Bootstraper la moyenne

from sklearn.utils import resample

# cv_coefficients has shape (n_cv_folds, n_coefficients)
n_boots = 100
bootstrap_means = np.zeros(n_boots, n_coefficients)
for ii in range(n_boots):
    # Generate random indices for our data with replacement, 
    # then take the sample mean
    random_sample = resample(cv_coefficients)
    bootstrap_means[ii] = random_sample.mean(axis=0)

# Compute the percentiles of choice for the bootstrapped means
percentiles = np.percentile(bootstrap_means, (2.5, 97.5), axis=0)

Tracer les coefficients bootstrapés

fig, ax = plt.subplots()
ax.scatter(many_shifts.columns, percentiles[0], marker='_', s=200)
ax.scatter(many_shifts.columns, percentiles[1], marker='_', s=200)

Évaluer la stabilité de la performance du modèle

Avec TimeSeriesSplit, on peut tracer le score du modèle dans le temps
Utile pour repérer des périodes qui nuisent au score
Utile aussi pour détecter des signaux non stationnaires

Performance du modèle dans le temps

def my_corrcoef(est, X, y):
    """Return the correlation coefficient 
    between model predictions and a validation set."""
    return np.corrcoef(y, est.predict(X))[1, 0]

# Grab the date of the first index of each validation set
first_indices = [data.index[tt[0]] for tr, tt in cv.split(X, y)]

# Calculate the CV scores and convert to a Pandas Series
cv_scores = cross_val_score(model, X, y, cv=cv, scoring=my_corrcoef)
cv_scores = pd.Series(cv_scores, index=first_indices)

Visualiser les scores comme une série chronologique

fig, axs = plt.subplots(2, 1, figsize=(10, 5), sharex=True)

# Calculate a rolling mean of scores over time
cv_scores_mean = cv_scores.rolling(10, min_periods=1).mean()
cv_scores.plot(ax=axs[0])
axs[0].set(title='Validation scores (correlation)', ylim=[0, 1])

# Plot the raw data
data.plot(ax=axs[1])
axs[1].set(title='Validation data')

Visualiser les scores du modèle

Fenêtres fixes avec validation croisée en série temporelle

# Only keep the last 100 datapoints in the training data
window = 100

# Initialize the CV with this window size
cv = TimeSeriesSplit(n_splits=10, max_train_size=window)

Signaux non stationnaires

Passons à la pratique !

Machine Learning pour les données chronologiques en Python