Nettoyer et améliorer vos données

Machine Learning pour les données chronologiques en Python

Chris Holdgraf

Fellow, Berkeley Institute for Data Science

Les données sont brouillonnes

Les données réelles sont souvent brouillonnes
Les deux problèmes les plus courants : données manquantes et valeurs aberrantes
Causes fréquentes : erreur humaine, capteur défectueux, panne de base de données, etc.
Visualiser vos données brutes aide à repérer ces problèmes

À quoi ressemblent des données brouillonnes

Interpolation : utiliser le temps pour combler les données manquantes

Une façon courante de traiter les données manquantes est d'interpoler les valeurs absentes
Avec des séries temporelles, vous pouvez utiliser le temps pour guider l'interpolation.
Ici, l'interpolation consiste à utiliser les valeurs connues de part et d'autre d'un vide pour estimer ce qui manque.

Interpolation avec Pandas

# Indiquer par un booléen où les valeurs sont manquantes
missing = prices.isna()

# Interpoler linéairement dans les fenêtres manquantes
prices_interp = prices.interpolate('linear')

# Tracer les données interpolées en rouge et celles avec valeurs manquantes en noir
ax = prices_interp.plot(c='r')
prices.plot(c='k', ax=ax, lw=2)

Visualiser les données interpolées

Transformer avec une fenêtre glissante

Autre usage des fenêtres glissantes : transformer les données
Nous l'avons déjà fait pour lisser la série
On peut aussi s'en servir pour des transformations plus complexes

Transformer pour standardiser la variance

Une transformation fréquente standardise la moyenne et la variance dans le temps (plusieurs méthodes possibles).
Ici, on convertit l'ensemble pour que chaque point soit le % de variation sur une fenêtre précédente.
Cela rend les instants plus comparables si les valeurs absolues varient beaucoup

Transformer en pourcentage de variation avec Pandas

def percent_change(values):
    """Calcule le % de variation entre la dernière valeur 
    et la moyenne des valeurs précédentes"""
    # Séparer la dernière valeur et toutes les précédentes
    previous_values = values[:-1]
    last_value = values[-1]

    # Calculer l'écart en % entre la dernière valeur 
    # et la moyenne des valeurs antérieures
    percent_change = (last_value - np.mean(previous_values)) \
    / np.mean(previous_values)
    return percent_change

Application à nos données

# Tracer les données brutes
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
ax = prices.plot(ax=axs[0])

# Calculer le % de variation et tracer
ax = prices.rolling(window=20).aggregate(percent_change).plot(ax=axs[1])
ax.legend_.set_visible(False)

Repérer les valeurs aberrantes

Les valeurs aberrantes sont des points très différents statistiquement du reste.
Elles peuvent nuire au pouvoir prédictif du modèle, l'éloignant de sa « vraie » valeur
Une solution : retirer ou remplacer ces valeurs par quelque chose de plus représentatif

Soyez très prudent : il est souvent difficile de distinguer une valeur vraiment extrême d'une aberration.

Tracer un seuil sur nos données

fig, axs = plt.subplots(1, 2, figsize=(10, 5))
for data, ax in zip([prices, prices_perc_change], axs):
    # Calculer la moyenne et l'écart type
    this_mean = data.mean()
    this_std = data.std()

    # Tracer les données et un seuil à 3 écarts types 
    # autour de la moyenne
    data.plot(ax=ax)
    ax.axhline(this_mean + this_std * 3, ls='--', c='r')
    ax.axhline(this_mean - this_std * 3, ls='--', c='r')

Visualiser les seuils d'aberration

Remplacer les valeurs aberrantes à l'aide du seuil

# Centrer les données pour que la moyenne soit 0
prices_outlier_centered = prices_outlier_perc - prices_outlier_perc.mean()

# Calculer l'écart type
std = prices_outlier_perc.std()

# Utiliser la valeur absolue de chaque point 
# pour repérer plus facilement les aberrations
outliers = np.abs(prices_outlier_centered) > (std * 3)

# Remplacer les aberrations par la médiane
# Utiliser np.nanmedian car il peut y avoir des NaN près des aberrations
prices_outlier_fixed = prices_outlier_centered.copy()
prices_outlier_fixed[outliers] = np.nanmedian(prices_outlier_fixed)

Visualiser les résultats

fig, axs = plt.subplots(1, 2, figsize=(10, 5))
prices_outlier_centered.plot(ax=axs[0])
prices_outlier_fixed.plot(ax=axs[1])

Passons à la pratique !

Machine Learning pour les données chronologiques en Python