Maîtriser l'art du nettoyage des données en Python – KDnuggets

Image par auteur
 

Le nettoyage des données est une partie essentielle de tout processus d’analyse de données. C'est l'étape où vous supprimez les erreurs, gérez les données manquantes et assurez-vous que vos données sont dans un format avec lequel vous pouvez travailler. Sans un ensemble de données bien nettoyé, toutes les analyses ultérieures peuvent être faussées ou incorrectes.

Cet article vous présente plusieurs techniques clés de nettoyage des données en Python, en utilisant des bibliothèques puissantes telles que pandas, numpy, seaborn et matplotlib.

Avant de plonger dans les mécanismes du nettoyage des données, comprenons son importance. Les données du monde réel sont souvent compliquées. Il peut contenir des entrées en double, des types de données incorrects ou incohérents, des valeurs manquantes, des fonctionnalités non pertinentes et des valeurs aberrantes. Tous ces facteurs peuvent conduire à des conclusions trompeuses lors de l’analyse des données. Cela fait du nettoyage des données un élément indispensable du cycle de vie de la science des données.

Nous aborderons les tâches de nettoyage de données suivantes.
 

Image par auteur

Avant de commencer, importons les bibliothèques nécessaires. Nous utiliserons des pandas pour la manipulation des données, et seaborn et matplotlib pour les visualisations.

Nous importerons également le module datetime Python pour manipuler les dates.

import pandas as pd
import seaborn as sns
import datetime as dt
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

Tout d’abord, nous devrons charger nos données. Dans cet exemple, nous allons charger un fichier CSV à l'aide de pandas. Nous ajoutons également l'argument délimiteur.

df = pd.read_csv('F:KDNuggetsKDN Mastering the Art of Data Cleaning in Pythonproperty.csv', delimiter= ';')

Ensuite, il est important d’inspecter les données pour comprendre leur structure, avec quel type de variables nous travaillons et s’il manque des valeurs. Puisque les données que nous avons importées ne sont pas énormes, examinons l’ensemble des données.

# Look at all the rows of the dataframe
display(df)

Voici à quoi ressemble l’ensemble de données.

Vous pouvez immédiatement voir qu'il manque des valeurs. De plus, les formats de date sont incohérents.

Jetons maintenant un œil au résumé DataFrame en utilisant la méthode info().

# Get a concise summary of the dataframe
print(df.info())

Voici la sortie du code.

Nous pouvons voir que seule la colonne square_feet n'a pas de valeurs NULL, nous devrons donc gérer cela d'une manière ou d'une autre. De plus, les colonnes Advertising_date et sale_date sont le type de données d'objet, même s'il doit s'agir d'une date.

L'emplacement de la colonne est complètement vide. En avons-nous besoin ?

Nous allons vous montrer comment gérer ces problèmes. Nous allons commencer par apprendre à supprimer les colonnes inutiles.

Il y a deux colonnes dans l'ensemble de données dont nous n'avons pas besoin dans notre analyse de données, nous allons donc les supprimer.

La première colonne est l'acheteur. Nous n’en avons pas besoin, car le nom de l’acheteur n’a pas d’impact sur l’analyse.

Nous utilisons la méthode drop() avec le nom de colonne spécifié. Nous définissons l'axe sur 1 pour spécifier que nous souhaitons supprimer une colonne. De plus, l'argument inplace est défini sur True afin que nous modifiions le DataFrame existant et ne créions pas un nouveau DataFrame sans la colonne supprimée.

df.drop('buyer', axis = 1, inplace = True)

La deuxième colonne que nous souhaitons supprimer est l'emplacement. Bien qu’il puisse être utile d’avoir ces informations, il s’agit d’une colonne complètement vide, alors supprimons-la.

Nous adoptons la même approche que pour la première colonne.

df.drop('location', axis = 1, inplace = True)

Bien entendu, vous pouvez supprimer ces deux colonnes simultanément.

df = df.drop(['buyer', 'location'], axis=1)

Les deux approches renvoient la trame de données suivante.

Des données en double peuvent apparaître dans votre ensemble de données pour diverses raisons et fausser votre analyse.

Détectons les doublons dans notre ensemble de données. Voici comment procéder.

Le code ci-dessous utilise la méthode dupliqué() pour considérer les doublons dans l’ensemble de données. Son paramètre par défaut est de considérer la première occurrence d'une valeur comme unique et les occurrences suivantes comme des doublons. Vous pouvez modifier ce comportement en utilisant le garder paramètre. Par exemple, df.duplicate(keep=False) marquerait tous les doublons comme True, y compris la première occurrence.

# Detecting duplicates
duplicates = df[df.duplicated()]
duplicates

Voici la sortie.

La ligne avec l'index 3 a été marquée comme doublon car la ligne 2 avec les mêmes valeurs est sa première occurrence.

Nous devons maintenant supprimer les doublons, ce que nous faisons avec le code suivant.

# Detecting duplicates
duplicates = df[df.duplicated()]
duplicates

Le drop_duplicates() La fonction prend en compte toutes les colonnes tout en identifiant les doublons. Si vous souhaitez considérer uniquement certaines colonnes, vous pouvez les transmettre sous forme de liste à cette fonction comme ceci : df.drop_duplicates(subset=['column1', 'column2']).

Comme vous pouvez le constater, la ligne en double a été supprimée. Cependant, l'indexation est restée la même, l'index 3 étant manquant. Nous allons ranger cela en réinitialisant les index.

df = df.reset_index(drop=True)

Cette tâche est effectuée en utilisant le réinitialiser_index() fonction. L'argument drop=True est utilisé pour supprimer l'index d'origine. Si vous n'incluez pas cet argument, l'ancien index sera ajouté en tant que nouvelle colonne dans votre DataFrame. En définissant drop=True, vous dites aux pandas d'oublier l'ancien index et de le réinitialiser à l'index entier par défaut.

Pour vous entraîner, essayez de supprimer les doublons de cet ensemble de données Microsoft.

Parfois, les types de données peuvent être mal définis. Par exemple, une colonne de date peut être interprétée comme des chaînes. Vous devez les convertir dans leurs types appropriés.

Dans notre ensemble de données, nous ferons cela pour les colonnes Advertising_date et sale_date, telles qu'elles sont affichées comme type de données d'objet. De plus, les dates sont formatées différemment selon les lignes. Nous devons le rendre cohérent, tout en le mettant à jour.

Le moyen le plus simple consiste à utiliser le à_datetime() méthode. Encore une fois, vous pouvez procéder ainsi colonne par colonne, comme indiqué ci-dessous.

Ce faisant, nous définissons l'argument dayfirst sur True car certaines dates commencent par le jour en premier.

# Converting advertisement_date column to datetime
df['advertisement_date'] = pd.to_datetime(df['advertisement_date'], dayfirst = True) # Converting sale_date column to datetime
df['sale_date'] = pd.to_datetime(df['sale_date'], dayfirst = True)

Vous pouvez également convertir les deux colonnes en même temps en utilisant le appliquer() méthode avec à_datetime().

# Converting advertisement_date and sale_date columns to datetime
df[['advertisement_date', 'sale_date']] = df[['advertisement_date', 'sale_date']].apply(pd.to_datetime, dayfirst = True)

Les deux approches vous donnent le même résultat.

Les dates sont désormais dans un format cohérent. Nous constatons que toutes les données n'ont pas été converties. Il y a une valeur NaT dans Advertising_date et deux dans sale_date. Cela signifie que la date est manquante.

Vérifions si les colonnes sont converties en dates en utilisant le Info() méthode.

# Get a concise summary of the dataframe
print(df.info())

Comme vous pouvez le constater, les deux colonnes ne sont pas au format datetime64[ns].

Maintenant, essayez de convertir les données de TEXT en NUMERIC dans ce Ensemble de données Airbnb.

Les ensembles de données du monde réel comportent souvent des valeurs manquantes. La gestion des données manquantes est vitale, car certains algorithmes ne peuvent pas gérer de telles valeurs.

Notre exemple comporte également des valeurs manquantes. Examinons donc les deux approches les plus courantes pour gérer les données manquantes.

Suppression de lignes avec des valeurs manquantes

Si le nombre de lignes avec des données manquantes est insignifiant par rapport au nombre total d'observations, vous pouvez envisager de supprimer ces lignes.

Dans notre exemple, la dernière ligne n'a aucune valeur à l'exception des pieds carrés et de la date de l'annonce. Nous ne pouvons pas utiliser de telles données, supprimons donc cette ligne.

Voici le code où l’on indique l’index de la ligne.

df = df.drop(8)

Le DataFrame ressemble maintenant à ceci.

La dernière ligne a été supprimée et notre DataFrame est désormais plus beau. Cependant, il reste encore quelques données manquantes que nous traiterons en utilisant une autre approche.

Imputation des valeurs manquantes

Si vous avez des données manquantes importantes, une meilleure stratégie que la suppression pourrait être l'imputation. Ce processus consiste à remplir les valeurs manquantes en fonction d'autres données. Pour les données numériques, les méthodes d'imputation courantes consistent à utiliser une mesure de tendance centrale (moyenne, médiane, mode).

Dans notre DataFrame déjà modifié, nous avons des valeurs NaT (Not a Time) dans les colonnes Advertising_date et sale_date. Nous imputerons ces valeurs manquantes en utilisant la signifier() méthode.

Le code utilise le remplirna() méthode pour trouver et remplir les valeurs nulles avec la valeur moyenne.

# Imputing values for numerical columns
df['advertisement_date'] = df['advertisement_date'].fillna(df['advertisement_date'].mean())
df['sale_date'] = df['sale_date'].fillna(df['sale_date'].mean())

Vous pouvez également faire la même chose sur une seule ligne de code. Nous utilisons le appliquer() pour appliquer la fonction définie à l'aide de lambda. Comme ci-dessus, cette fonction utilise le remplirna() et les signifier() méthodes pour remplir les valeurs manquantes.

# Imputing values for multiple numerical columns
df[['advertisement_date', 'sale_date']] = df[['advertisement_date', 'sale_date']].apply(lambda x: x.fillna(x.mean()))

Le résultat dans les deux cas ressemble à ceci.

Notre colonne sale_date contient désormais des heures dont nous n'avons pas besoin. Supprimons-les.

Nous utiliserons le strftime() méthode, qui convertit les dates en leur représentation sous forme de chaîne et dans un format spécifique.

df['sale_date'] = df['sale_date'].dt.strftime('%Y-%m-%d')

Les dates semblent désormais bien rangées.

Si vous avez besoin d'utiliser strftime() sur plusieurs colonnes, vous pouvez à nouveau utiliser lambda de la manière suivante.

df[['date1_formatted', 'date2_formatted']] = df[['date1', 'date2']].apply(lambda x: x.dt.strftime('%Y-%m-%d'))

Voyons maintenant comment imputer les valeurs catégorielles manquantes.

Les données catégorielles sont un type de données utilisé pour regrouper des informations présentant des caractéristiques similaires. Chacun de ces groupes est une catégorie. Les données catégorielles peuvent prendre des valeurs numériques (telles que « 1 » indiquant « homme » et « 2 » indiquant « femme »), mais ces nombres n'ont pas de signification mathématique. Vous ne pouvez pas les additionner, par exemple.

Les données catégorielles sont généralement divisées en deux catégories :

1. Données nominales: C'est à ce moment-là que les catégories sont uniquement étiquetées et ne peuvent pas être classées dans un ordre particulier. Les exemples incluent le sexe (homme, femme), le groupe sanguin (A, B, AB, O) ou la couleur (rouge, vert, bleu).

1. Données ordinales : C'est à ce moment-là que les catégories peuvent être ordonnées ou classées. Même si les intervalles entre les catégories ne sont pas équidistants, l’ordre des catégories a une signification. Les exemples incluent des échelles d'évaluation (évaluation de 1 à 5 d'un film), un niveau d'éducation (lycée, premier cycle, cycle supérieur) ou les stades du cancer (stade I, stade II, stade III).

Pour imputer les données catégorielles manquantes, le mode est généralement utilisé. Dans notre exemple, la colonne property_category contient des données catégorielles (nominales) et des données manquent sur deux lignes.

Remplaçons les valeurs manquantes par mode.

# For categorical columns
df['property_category'] = df['property_category'].fillna(df['property_category'].mode()[0])

Ce code utilise le remplirna() fonction pour remplacer toutes les valeurs NaN dans la colonne property_category. Il le remplace par mode.

De plus, la partie [0] est utilisée pour extraire la première valeur de cette série. S'il existe plusieurs modes, cela sélectionnera le premier. S'il n'y a qu'un seul mode, cela fonctionne toujours bien.

Voici la sortie.

Les données semblent désormais plutôt bonnes. Il ne reste plus qu’à voir s’il y a des valeurs aberrantes.

Vous pouvez vous entraîner à gérer les valeurs nulles à ce sujet Question de méta-entretien, où vous devrez remplacer les NULL par des zéros.

Les valeurs aberrantes sont des points de données dans un ensemble de données qui sont nettement différents des autres observations. Elles peuvent se situer exceptionnellement loin des autres valeurs de l’ensemble de données, se situant en dehors d’un modèle global. Ils sont considérés comme inhabituels car leurs valeurs sont soit nettement supérieures, soit inférieures par rapport au reste des données.

Des valeurs aberrantes peuvent survenir pour diverses raisons telles que :

• Erreurs de mesure ou de saisie
• Corruption de données
• De véritables anomalies statistiques

Les valeurs aberrantes peuvent avoir un impact significatif sur les résultats de votre analyse de données et de votre modélisation statistique. Ils peuvent conduire à une distribution asymétrique, à un biais ou invalider les hypothèses statistiques sous-jacentes, fausser l'ajustement estimé du modèle, réduire l'exactitude prédictive des modèles prédictifs et conduire à des conclusions incorrectes.

Certaines méthodes couramment utilisées pour détecter les valeurs aberrantes sont le score Z, l'IQR (intervalle interquartile), les diagrammes en boîte, les nuages ​​de points et les techniques de visualisation de données. Dans certains cas avancés, des méthodes d’apprentissage automatique sont également utilisées.

La visualisation des données peut aider à identifier les valeurs aberrantes. Le boxplot de Seaborn est pratique pour cela.

plt.figure(figsize=(10, 6))
sns.boxplot(data=df[['advertised_price', 'sale_price']])

Nous utilisons plt.figure() pour définir la largeur et la hauteur de la figure en pouces.

Ensuite, nous créons le boxplot pour les colonnes publiced_price et sale_price, qui ressemble à ceci.

L'intrigue peut être améliorée pour une utilisation plus facile en l'ajoutant au code ci-dessus.

plt.xlabel('Prices')
plt.ylabel('USD')
plt.ticklabel_format(style='plain', axis='y')
formatter = ticker.FuncFormatter(lambda x, p: format(x, ',.2f'))
plt.gca().yaxis.set_major_formatter(formatter)

Nous utilisons le code ci-dessus pour définir les étiquettes des deux axes. Nous remarquons également que les valeurs sur l’axe des y sont en notation scientifique, et nous ne pouvons pas l’utiliser pour les valeurs de prix. Nous changeons donc cela en style simple en utilisant la fonction plt.ticklabel_format().

Ensuite, nous créons le formateur qui affichera les valeurs sur l'axe des y avec des virgules comme mille séparateurs et des points décimaux. La dernière ligne de code l'applique à l'axe.

La sortie ressemble maintenant à ceci.

Maintenant, comment identifier et supprimer la valeur aberrante ?

L'un des moyens consiste à utiliser la méthode IQR.

IQR, ou Interquartile Range, est une méthode statistique utilisée pour mesurer la variabilité en divisant un ensemble de données en quartiles. Les quartiles divisent un ensemble de données classées en quatre parties égales, et les valeurs comprises dans la plage du premier quartile (25e centile) et du troisième quartile (75e centile) constituent la plage interquartile.

L'intervalle interquartile est utilisé pour identifier les valeurs aberrantes dans les données. Voici comment cela fonctionne:

1. Calculez d’abord le premier quartile (Q1), le troisième quartile (Q3), puis déterminez l’IQR. L’IQR est calculé comme suit : Q3 – Q1.
2. Toute valeur inférieure à Q1 – 1.5IQR ou supérieure à Q3 + 1.5IQR est considérée comme une valeur aberrante.

Sur notre boxplot, la boîte représente en fait l'IQR. La ligne à l’intérieur de la case est la médiane (ou deuxième quartile). Les « moustaches » du boxplot représentent la plage comprise entre 1.5*IQR entre le premier et le troisième trimestre.

Tous les points de données en dehors de ces moustaches peuvent être considérés comme des valeurs aberrantes. Dans notre cas, c’est la valeur de 12,000,000 XNUMX XNUMX $. Si vous regardez le diagramme en boîte, vous verrez à quel point cela est clairement représenté, ce qui montre pourquoi la visualisation des données est importante pour détecter les valeurs aberrantes.

Maintenant, supprimons les valeurs aberrantes en utilisant la méthode IQR dans le code Python. Tout d’abord, nous supprimerons les valeurs aberrantes de prix annoncées.

Q1 = df['advertised_price'].quantile(0.25)
Q3 = df['advertised_price'].quantile(0.75)
IQR = Q3 - Q1
df = df[~((df['advertised_price'] (Q1 - 1.5 * IQR)) |(df['advertised_price'] > (Q3 + 1.5 * IQR)))]

Nous calculons d'abord le premier quartile (ou le 25e percentile) à l'aide de la quantile() fonction. Nous faisons de même pour le troisième quartile ou le 75e percentile.

Ils montrent les valeurs en dessous desquelles se situent respectivement 25 % et 75 % des données.

Ensuite, nous calculons la différence entre les quartiles. Jusqu'à présent, tout consiste simplement à traduire les étapes IQR en code Python.

Dans une dernière étape, nous supprimons les valeurs aberrantes. En d’autres termes, toutes les données inférieures à Q1 – 1.5 * IQR ou supérieures à Q3 + 1.5 * IQR.

L'opérateur « ~ » annule la condition, nous nous retrouvons donc uniquement avec les données qui ne sont pas des valeurs aberrantes.

Ensuite, nous pouvons faire de même avec le prix de vente.

Q1 = df['sale_price'].quantile(0.25)
Q3 = df['sale_price'].quantile(0.75)
IQR = Q3 - Q1
df = df[~((df['sale_price'] (Q1 - 1.5 * IQR)) |(df['sale_price'] > (Q3 + 1.5 * IQR)))]

Bien sûr, vous pouvez le faire de manière plus succincte en utilisant le pour la boucle.

for column in ['advertised_price', 'sale_price']: Q1 = df[column].quantile(0.25) Q3 = df[column].quantile(0.75) IQR = Q3 - Q1 df = df[~((df[column] (Q1 - 1.5 * IQR)) |(df[column] > (Q3 + 1.5 * IQR)))]

La boucle parcourt les deux colonnes. Pour chaque colonne, il calcule l'IQR puis supprime les lignes du DataFrame.

Veuillez noter que cette opération est effectuée de manière séquentielle, d'abord pouradverted_price puis pour sale_price. Par conséquent, le DataFrame est modifié sur place pour chaque colonne et les lignes peuvent être supprimées en raison d'une valeur aberrante dans l'une ou l'autre colonne. Par conséquent, cette opération pourrait générer moins de lignes que si les valeurs aberrantes pouradverted_price et sale_price étaient supprimées indépendamment et que les résultats étaient ensuite combinés.

Dans notre exemple, le résultat sera le même dans les deux cas. Pour voir comment le diagramme en boîte a changé, nous devons le tracer à nouveau en utilisant le même code que précédemment.

plt.figure(figsize=(10, 6))
sns.boxplot(data=df[['advertised_price', 'sale_price']])
plt.xlabel('Prices')
plt.ylabel('USD')
plt.ticklabel_format(style='plain', axis='y')
formatter = ticker.FuncFormatter(lambda x, p: format(x, ',.2f'))
plt.gca().yaxis.set_major_formatter(formatter)

Voici la sortie.

Vous pouvez vous entraîner à calculer des centiles en Python en résolvant le problème Question d'entretien pour l'Assemblée générale.

Le nettoyage des données est une étape cruciale dans le processus d’analyse des données. Même si cela peut prendre du temps, il est essentiel de garantir l’exactitude de vos résultats.

Heureusement, le riche écosystème de bibliothèques de Python rend ce processus plus gérable. Nous avons appris à supprimer les lignes et colonnes inutiles, à reformater les données et à gérer les valeurs manquantes et les valeurs aberrantes. Ce sont les étapes habituelles qui doivent être effectuées sur la plupart des données. Cependant, vous devrez aussi parfois combiner deux colonnes en une seule, vérifier les données existantes, lui attribuer des étiquettesou débarrassez-vous des espaces blancs.

Tout cela constitue du nettoyage de données, car il vous permet de transformer des données désordonnées du monde réel en un ensemble de données bien structuré que vous pouvez analyser en toute confiance. Comparez simplement l’ensemble de données avec lequel nous avons commencé à celui avec lequel nous avons fini.

Si vous ne voyez pas la satisfaction de ce résultat et que les données propres ne vous excitent pas étrangement, que diable faites-vous en science des données !?
 

Nate Rosidi est data scientist et en stratégie produit. Il est également professeur adjoint enseignant l'analytique et fondateur de StrataScratch, une plate-forme aidant les data scientists à préparer leurs entretiens avec de vraies questions d'entretien posées par les meilleures entreprises. Connectez-vous avec lui sur Twitter : StrataScratch or LinkedIn.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://www.kdnuggets.com/mastering-the-art-of-data-cleaning-in-python?utm_source=rss&utm_medium=rss&utm_campaign=mastering-the-art-of-data-cleaning-in-python