Nettoyage et préparation des données

Pourquoi nettoyer et préparer les données ? L'importance de la qualité des données

Les données du monde réel sont souvent incomplètes, incohérentes, bruitées, ou mal formatées. Avant de pouvoir analyser ou modéliser ces données, il est essentiel de les *nettoyer* et de les *préparer*.

Le nettoyage et la préparation des données (data cleaning and preprocessing) consistent à :

• Identifier et corriger les erreurs (valeurs manquantes, valeurs aberrantes, erreurs de type, etc.).
• Traiter les incohérences (par exemple, différentes représentations de la même information).
• Transformer les données dans un format adapté à l'analyse ou à la modélisation (par exemple, convertir des types de données, normaliser des valeurs, encoder des variables catégorielles).

La qualité des données est cruciale. Des données de mauvaise qualité peuvent conduire à :

• Des analyses erronées.
• Des modèles de machine learning peu performants ou biaisés.
• Des décisions incorrectes.

Le nettoyage et la préparation des données représentent souvent une part importante (voire la majorité) du temps passé sur un projet d'analyse de données ou de machine learning. On estime souvent que 80% du temps est passé sur cette étape.

Identifier les problèmes de qualité des données

Avant de nettoyer les données, il faut identifier les problèmes. Voici quelques types de problèmes courants :

• Valeurs manquantes : Des données absentes (représentées par `NaN`, `None`, ou des chaînes vides, par exemple).
• Doublons : Des enregistrements (lignes) identiques ou presque identiques.
• Erreurs de type : Des valeurs qui ne correspondent pas au type de données attendu (par exemple, une chaîne de caractères dans une colonne censée contenir des nombres).
• Valeurs aberrantes (outliers) : Des valeurs extrêmes qui s'écartent significativement des autres valeurs.
• Incohérences : Des valeurs qui se contredisent, ou qui ne respectent pas des règles logiques (par exemple, une date de naissance future).
• Format incorrect : Des données qui ne sont pas dans le format attendu (par exemple, des dates dans un format non standard).
• Unités incohérentes : Des valeurs qui utilisent des unités différentes (par exemple, des distances en mètres et en miles).
• Données bruitées : Des valeurs qui contiennent des erreurs de mesure ou des variations aléatoires.

Pour identifier ces problèmes, vous pouvez utiliser des techniques d'exploration de données (statistiques descriptives, visualisations) et votre connaissance du domaine.

Gérer les valeurs manquantes

Les valeurs manquantes sont un problème courant dans les jeux de données réels. Il existe plusieurs stratégies pour les gérer :

• Suppression : Supprimer les lignes ou les colonnes qui contiennent des valeurs manquantes. C'est la solution la plus simple, mais elle peut entraîner une perte d'information importante.
• Imputation : Remplacer les valeurs manquantes par des valeurs estimées (par exemple, la moyenne, la médiane, le mode, ou une valeur prédite par un modèle).
• Conserver comme catégorie : Dans certains cas, les valeurs manquantes peuvent avoir une signification en elles-mêmes. Vous pouvez les conserver comme une catégorie distincte.

Le choix de la stratégie dépend du contexte, de la quantité de valeurs manquantes, et de l'importance des données manquantes pour l'analyse.

En Python, avec Pandas, vous pouvez utiliser les fonctions suivantes :

• `df.isna()` ou `df.isnull()` : Détecte les valeurs manquantes (retourne un DataFrame de booléens). `df.isna().sum()` donne le nombre de valeurs manquantes par colonne.
• `df.dropna()` : Supprime les lignes ou les colonnes contenant des valeurs manquantes.
• `df.fillna(valeur)` : Remplace les valeurs manquantes par une valeur spécifique.
• `df.fillna(method='ffill')` : Remplit les valeurs manquantes en propageant la dernière valeur valide vers l'avant ("forward fill").
• `df.fillna(method='bfill')` : Remplit les valeurs manquantes en propageant la prochaine valeur valide vers l'arrière ("backward fill").
• `df.interpolate()` : Remplit les valeurs manquantes par interpolation.

Exemple :

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8], 'C': [9, 10, 11, 12]})
print(df)
#      A    B   C
# 0  1.0  5.0   9
# 1  2.0  NaN  10
# 2  NaN  NaN  11
# 3  4.0  8.0  12

print(df.isna())
#        A      B      C
# 0  False  False  False
# 1  False   True  False
# 2   True   True  False
# 3  False  False  False

print(df.isna().sum())
# A    1
# B    2
# C    0
# dtype: int64

# Supprimer les lignes avec des valeurs manquantes
df_sans_na = df.dropna()
print(df_sans_na)
#      A    B   C
# 0  1.0  5.0   9
# 3  4.0  8.0  12

# Remplacer les valeurs manquantes par 0
df_rempli = df.fillna(0)
print(df_rempli)
#      A    B   C
# 0  1.0  5.0   9
# 1  2.0  0.0  10
# 2  0.0  0.0  11
# 3  4.0  8.0  12

Gérer les doublons

Les doublons (lignes répétées) peuvent fausser les analyses et doivent être gérés.

Avec Pandas :

• `df.duplicated()` : Détecte les lignes dupliquées (retourne une Series de booléens).
• `df.drop_duplicates()` : Supprime les lignes dupliquées.

Exemple :

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 2, 3], 'B': [4, 5, 5, 6]})
print(df)
#    A  B
# 0  1  4
# 1  2  5
# 2  2  5
# 3  3  6

print(df.duplicated())
# 0    False
# 1    False
# 2     True
# 3    False
# dtype: bool

df_sans_doublons = df.drop_duplicates()
print(df_sans_doublons)
#    A  B
# 0  1  4
# 1  2  5
# 3  3  6

Gérer les erreurs de type

Assurez-vous que chaque colonne a le bon type de données. Par exemple, une colonne qui devrait contenir des nombres ne doit pas contenir de chaînes de caractères.

Utilisez les annotations de type et `mypy` pour détecter les erreurs de type potentielles.

Utilisez les fonctions de conversion de type (comme `int()`, `float()`, `str()`, `pd.to_datetime()`) pour convertir les données dans le type approprié.

Exemple (avec Pandas) :

import pandas as pd

df = pd.DataFrame({'age': ['25', '30', 'abc']})

# print(df['age'].sum())  # Lèverait une TypeError

# Convertir la colonne 'age' en entiers (en gérant les erreurs)
df['age'] = pd.to_numeric(df['age'], errors='coerce')  # 'coerce' remplace les erreurs par NaN
print(df.dtypes)
# age    float64 #car NaN est un float
# dtype: object

print(df) #Les valeurs non numériques sont remplacées par NaN.

print(df['age'].sum()) #Maintenant, on peut faire la somme.

Gérer les valeurs aberrantes (outliers)

Les valeurs aberrantes sont des valeurs extrêmes qui peuvent fausser les analyses statistiques et les modèles de machine learning. Il existe plusieurs techniques pour détecter et gérer les valeurs aberrantes :

• Visualisation : Utilisez des histogrammes, des boîtes à moustaches, ou des nuages de points pour identifier visuellement les valeurs aberrantes.
• Méthodes statistiques : Utilisez des seuils basés sur l'écart-type, l'intervalle interquartile, ou d'autres mesures statistiques.
• Techniques de machine learning : Utilisez des algorithmes de détection d'anomalies.

Une fois les valeurs aberrantes détectées, vous pouvez :

• Les supprimer (si vous êtes sûr que ce sont des erreurs).
• Les remplacer par une valeur plus plausible (par exemple, la moyenne, la médiane, ou une valeur prédite par un modèle).
• Les conserver, mais utiliser des méthodes d'analyse ou de modélisation robustes aux valeurs aberrantes.

Il n'y a pas de solution unique pour gérer les valeurs aberrantes. La meilleure approche dépend du contexte et de la nature des données.

Transformation des données

La préparation des données implique souvent de transformer les données pour les adapter à l'analyse ou à la modélisation. Voici quelques exemples de transformations courantes :

• Normalisation/Standardisation : Mettre à l'échelle les variables numériques pour qu'elles aient une plage de valeurs comparable (par exemple, entre 0 et 1, ou avec une moyenne de 0 et un écart-type de 1).
• Encodage des variables catégorielles : Convertir les variables catégorielles (texte) en variables numériques (par exemple, en utilisant le one-hot encoding ou le label encoding).
• Création de nouvelles variables : Combiner ou transformer des variables existantes pour créer de nouvelles variables plus pertinentes pour l'analyse.
• Agrégation de données : Regrouper les données par catégories et calculer des statistiques agrégées (somme, moyenne, etc.).

Pandas fournit de nombreuses fonctions pour effectuer ces transformations de manière efficace.

Exemple de code : nettoyage et préparation

Voici un exemple combinant plusieurs opérations de nettoyage et de préparation.

import pandas as pd
import numpy as np

# Créer un DataFrame avec des données problématiques
df = pd.DataFrame({
    'age': [25, 30, '35', 40, -5, 60, np.nan, 200],
    'sexe': ['M', 'F', 'M', 'F', 'M', 'F', 'F', 'M'],
    'salaire': [30000, 40000, 50000, None, 60000, 70000, 80000, 200000]
})

# 1. Convertir l'âge en numérique, en remplaçant les erreurs par NaN
df['age'] = pd.to_numeric(df['age'], errors='coerce')

# 2. Supprimer les lignes avec un âge manquant
df = df.dropna(subset=['age'])

# 3. Supprimer les valeurs aberrantes pour l'âge (âge < 0 ou âge > 120)
df = df[(df['age'] >= 0) & (df['age'] <= 120)]

# 4. Remplacer les valeurs manquantes de 'salaire' par la moyenne
df['salaire'] = df['salaire'].fillna(df['salaire'].mean())

# 5. Supprimer les outliers pour le salaire (on garde les salaires < 150000)
df = df[df['salaire']<150000]

# 6. Encoder la variable catégorielle 'sexe' (M=0, F=1)
df['sexe'] = df['sexe'].map({'M': 0, 'F': 1})


print(df)

Ce code effectue plusieurs opérations de nettoyage et de préparation, en utilisant les fonctions de Pandas. Il n'y a pas de solution unique, chaque étape est à adapter en fonction des données, et de ce que l'on veut en faire.