Cours
Nettoyer des données en Python
4 h
160.4K
Peu importe la sophistication de nos analyses ou algorithmes prédictifs, la qualité des résultats dépend de la qualité des données en entrée. Autrement dit : garbage in, garbage out.
Comme les données sont à la base de tous ces processus, il est crucial d'y consacrer le temps nécessaire pour les préparer correctement.
Le nettoyage des données est une étape fondatrice du cycle de vie de la data science, et son rôle est déterminant pour dégager des insights fiables et répondre avec justesse aux questions posées. Dans le monde réel, les données sont rarement propres ; on ne peut donc pas faire l'impasse sur cette étape.
Dans cet article, nous aborderons des notions clés comme la gestion des valeurs manquantes, des doublons et des valeurs aberrantes. Pour des consignes plus complètes, suivez notre cours Cleaning Data in Python ou Cleaning Data in R.
Quelles sont les causes des données non propres ?
En bref, le nettoyage (ou assainissement) des données est un processus nécessaire pour préparer une analyse. Il peut consister à détecter et supprimer des doublons, à écarter des enregistrements incomplets, ou à corriger des valeurs inexactes.
Les données sales sont un problème ancien, amplifié par l'explosion des volumes au cours de la dernière décennie. Rien qu'en 2020, plus de 64 zettabytes de données ont été générés dans le monde, soit 6,4 billions de gigaoctets. Même si moins de 2 % de ces données sont conservées, cela ne fait qu'aggraver le problème récurrent des « données sales ». Avant de nettoyer, il faut comprendre d'où vient la saleté. Les sources fréquentes incluent :
- Des erreurs humaines lors de la saisie, de l'enregistrement ou du codage
- Un capteur défectueux, comme c'est parfois le cas dans l'internet des objets (IoT)
- Une corruption due à une panne matérielle ou logicielle
Identifier la cause racine des problèmes pose les bases pour définir des critères de qualité des données et classifier les différents soucis d'un jeu de données.
Pourquoi le nettoyage des données est-il si important ?
Le nettoyage contribue à établir une méthode réutilisable pour assainir les données d'une organisation. Comme indiqué plus haut : garbage in, garbage out. Si on le néglige, on s'expose à des analyses erronées et coûteuses en temps, en argent et en ressources.
Qu'est-ce que la qualité des données ?
La qualité des données est la mesure, qualitative et/ou quantitative, de l'adéquation des données à l'usage visé. Ces mesures servent de référentiel pratique pour évaluer si les données fournies conviennent à nos objectifs. Voyez-les comme des tests métriques que nos données doivent réussir pour être jugées aptes à la data science.
Critères de qualité des données
- Exactitude : L'information est-elle fidèle en tous points ? En data, nous cherchons à approximer le réel ; l'exactitude indique dans quelle mesure ces approximations sont justes.
- Pertinence : Cette information sert-elle directement notre objectif final ?
- Coherence : La source est-elle vérifiée et l'information fiable ? Par exemple, un client de 15 ans indiqué comme marié.
- Exhaustivité : Les données sont-elles suffisamment complètes pour l'objectif visé ? Problème fréquent lié aux valeurs manquantes ; une piste consiste à enquêter sur la source.
- Uniformité : Si une colonne de ventes contient des montants dans différentes devises, il faut les convertir dans une devise unique. L'uniformité garantit l'usage des mêmes unités de mesure dans tous les systèmes.
Nettoyage vs transformation des données
Il faut distinguer nettoyage et transformation. La transformation vise à extraire davantage d'insights en changeant le format brut en un autre format. Exemples :
- Encodage : conversion de variables catégorielles en valeurs binaires exploitables par les algorithmes. L'exemple montre à quoi ressemblerait une colonne de genre encodée : l'information est identique, le format change.
- Regroupement en classes (binning) : aussi appelé bucketing, il réduit l'effet de petites observations en groupant des valeurs continues en intervalles (catégories).
- Normalisation / mise à l'échelle : technique classique en machine learning pour ramener des variables à des plages comparables.
La plupart des transformations modifient la représentation d'origine. Les données restent les mêmes, mais le format devient mieux adapté au machine learning ou à un autre usage.
Comment procéder au nettoyage des données
Pour garantir une donnée de qualité, définissez un workflow de nettoyage. Il recense toutes les étapes nécessaires :
- Exploration des données
- Nettoyage des données
- Vérification des données
- Reporting du nettoyage Certaines étapes seront également illustrées en Python
Exploration des données
Il s'agit de comprendre en profondeur les variables du jeu de données, via des visualisations et des agrégations pour mettre au jour les problèmes sous-jacents. Pour une exploration efficace :
Contexte des données
Avant de nettoyer, il faut comprendre le contexte : sources, conditions et modalités de collecte. Ce cadre éclaire ce qui est acceptable en nettoyage (et en analyse) et oriente l'interprétation.
Une fois le contexte clarifié, on peut explorer les données.
Analyse exploratoire
L'analyse exploratoire des données consiste à mener des investigations initiales pour découvrir des motifs, détecter des anomalies, tester des hypothèses et vérifier des hypothèses grâce à des statistiques descriptives et des graphiques. Aucune découverte sans exploration. Sans exploration, il est difficile de repérer les différents problèmes.
Par exemple, nous disposons d'un jeu de données accessible ici. Les fichiers Rolling Sales du Department of Finance listent les biens vendus au cours des douze derniers mois à New York pour les classes fiscales 1, 2 et 4. Nous allons télécharger et lire les données du Bronx.
#pandas
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
#read excel file
df = pd.read_excel("rollingsales_bronx.xls")
#preview data
df.head()
Problèmes notables dans ce DataFrame :
- colonnes sans nom
- valeurs manquantes dans les trois premières lignes
Or, en examinant le fichier Excel, on constate que le tableau commence à la 4e ligne. Relisons donc le fichier en indiquant les lignes à ignorer et la ligne d'en-tête :
#we read the data in again but skill 3 rows this time
df = pd.read_excel("rollingsales_bronx.xls", skiprows = 4, header = [0])
df.head()
L'affichage change radicalement. Nous aurions pu nettoyer le premier import, mais l'exploration nous a fait gagner un temps précieux en ajustant simplement les paramètres de lecture.
L'exploration, c'est entrer sur une scène de crime en observateur ; le nettoyage, c'est mener l'enquête pour résoudre l'affaire.
Nettoyage des données
Exploration et nettoyage vont souvent de pair. Une fois les problèmes identifiés (visuels, agrégats, statistiques), il faut les corriger. On supprime, corrige ou impute.
Enregistrements incohérents
Exemple typique : un formulaire où les individus renseignent leur genre : « M », « m », « Male », « MALE » ; ou encore « aples » vs « apples » vs « APPLES ». On les détecte via un diagramme de fréquences ou la liste des valeurs distinctes. Opérations courantes :
- Convertir les chaînes en minuscules ou en casse propre
- Supprimer les espaces superflus
- Renommer les colonnes
Exemple Python : avec le jeu de données importé plus haut, notez l'incohérence des noms de colonnes :
Ce n'est pas dramatique, mais il est préférable d'uniformiser l'accès aux colonnes. Par exemple, EASE-MENT comporte un tiret (-) là où les autres ont des espaces.
Assurer la cohérence fait partie du nettoyage. Procédons en deux étapes :
- Remplacer les espaces par des underscores
- Passer en casse titre
# Extract columns
cols = df.columns
# Create empty list for new column names
new_cols = []
# Iterate over each column name to fix issues
for column in cols:
# Convert column name to title case
proper_cols = column.title()
# Replace spaces and hyphens with underscores
proper_cols_hyphen = proper_cols.replace(" ", "_")
clean_col = proper_cols_hyphen.replace("-", "_")
# Append the cleaned column name to the list
new_cols.append(clean_col)
# Display the transformed column names
new_cols
# Replace existing columns in the dataframe with the cleaned list
df.columns = new_cols
# Preview the updated dataframe
df.head()
Types de données et conversions
Le type de données détermine sa représentation et les opérations possibles. Affichons les types de chaque colonne du DataFrame du Bronx.
#data types
df.dtypes
NB : Nous pouvons maintenant appeler facilement les colonnes avec la notation point (df.Year_Built).
Tous les types semblent corrects sauf Year_Built, qui devrait être catégorielle. Sans impact majeur, mais lors des agrégations, Year_Built pourrait être incluse à tort.
#Fix Year_Built column
df.Year_Built = df.Year_Built.astype("str")
#Check
df.dtypes
Valeurs manquantes
Il arrive que certaines observations (lignes) comportent des valeurs manquantes, voire des colonnes entières vides. Que faire ? Ignorer le problème revient à laisser fuir un toit sous la pluie.
Les valeurs manquantes sont représentées différemment selon les outils : NULL, chaînes vides, NaN, NA, #NA, etc. Le contexte est clé pour comprendre pourquoi elles manquent. Deux approches principales :
- Suppression
- Imputation
Avant de décider, examinez les motifs d'absence par colonne, via des techniques visuelles et descriptives.
#extract the column names
cols = df.columns
#plot a heatmap of missing values with seaborn
plt.figure(figsize = (10,5))
sns.heatmap(df[cols].isnull())
Le graphique montre visuellement :
- Toutes les valeurs de Ease_ment et presque toutes celles de Apartment_Number manquent
- Des valeurs manquantes disséminées dans Units et Square_Feet Pour des jeux de données très volumineux, ce graphique n'est pas idéal. On peut également mesurer l'ampleur des manques par rapport à la taille du jeu.
#Get the percentage of missing values in each column
missing_pct = round(df.isnull().sum()/len(df) * 100, 1)
print(missing_pct)
Nous allons supprimer les colonnes Ease_Ment et Apartment_Number puis remplacer les valeurs manquantes des autres colonnes.
#columns with more than 30% missing values
drop_cols = missing_pct[missing_pct > 30].index
#We can drop these columns with greater than 30 percent missing values
df_new = df.drop(columns = drop_cols)
#Extract columns with mising values between 1 and 30%
replace_cols = missing_pct[(missing_pct > 0) & (missing_pct < 30)].index
#Iterate to replace missing values
for col in replace_cols:
#if column is year built we replace with median otherwise the mean
if col == "Year_Built":
df_new.fillna(df_new[col].median(), inplace = True)
else:
mean_value = df_new[col].mean()
df_new.fillna(mean_value, inplace = True)
df_new.isnull().sum() #preview for missing values
Il existe bien sûr d'autres stratégies, présentées dans ce cours Datacamp sur Dealing with Missing Values in Python. Les besoins varient selon les jeux, types et structures de données ; il n'y a pas de procédure unique. Le schéma ci-dessous illustre différents scénarios pour choisir entre suppression et imputation.
Doublons
Il faut garantir une source unique de vérité pour chaque observation. Il arrive d'avoir plusieurs enregistrements pour un même client (double soumission de formulaire, erreur de saisie, etc.). Quelles qu'en soient les causes, il faut construire une version unique et complète de la vérité afin que :
- Temps et budget ne soient pas gaspillés à cibler deux fois le même client
- Une version fiable et exhaustive serve de base à des décisions business solides
Valeurs aberrantes
Les valeurs aberrantes sont des points extrêmes, très bas ou très hauts, qui ne suivent pas le motif général, par exemple :
- Un client âgé de 200 ans
- Une mesure de 40 °C en Antarctique
Identifier les valeurs aberrantes On peut les détecter par :
-
Tri du jeu de données : en triant, on repère facilement des extrêmités, mais cette méthode atteint vite ses limites sur de grands volumes.
-
Visualisation : boxplots, histogrammes, nuages de points facilitent la détection.
-
Scores z : méthode statistique qui quantifie le caractère inhabituel d'une valeur (en nombre d'écarts types par rapport à la moyenne), sous hypothèse de normalité.
Traitement des valeurs aberrantes Deux approches principales :
- Supprimer : retirer les valeurs situées au-delà d'un certain percentile bas/haut. Cas typiques :
- Donnée manifestement erronée (un client actif de 200 ans doit être supprimé).
-
Si l'impact sur les résultats est nul et que la proportion est faible, on peut écarter ces points.
-
Remplacer : substituer ces valeurs extrêmes par la moyenne, la médiane ou la mode. Si les valeurs aberrantes sont nombreuses, la suppression n'est pas viable. Remarque : la moyenne est sensible aux extrêmes ; préférez la médiane ou la mode.
Vérification des données
Une fois le nettoyage effectué, réévaluez la qualité via l'exploration. Il s'agit de valider l'exhaustivité et la justesse du processus, et de vérifier la cohérence avec le contexte.
Reporting et automatisation du nettoyage
Le reporting documente l'état de santé des données après nettoyage, ainsi que les étapes suivies. Il sert de guide pour des besoins similaires (reproductibilité) et facilite l'automatisation.
L'automatisation rend le nettoyage reproductible. Une grande partie du processus repose sur des scripts réutilisables, adaptables avec quelques ajustements au besoin.
Conclusion
Nous avons passé en revue en profondeur le nettoyage des données et les composantes à considérer pour réussir vos projets. C'est une phase chronophage à laquelle les professionnels consacrent jusqu'à 60 % d'un projet de data science. Elle conditionne à elle seule l'issue du projet. Des données différentes ont des besoins différents ; adaptez votre approche à votre cas d'usage.
Ressources :
- Les images liées à la transformation des données proviennent d'un classeur Excel disponible ici
- Le notebook Python est disponible sur DataCamp workspace