Automatisation des processus de nettoyage des données avec Pandas

Peu de projets de science des données sont exemptés de la nécessité de nettoyer les données. Le nettoyage des données englobe les étapes initiales de préparation des données. Son objectif spécifique est que seules les informations pertinentes et utiles sous-jacentes aux données soient conservées, que ce soit pour leur analyse ultérieure, pour les utiliser comme entrées dans un modèle d'IA ou d'apprentissage automatique, etc. Unifier ou convertir des types de données, traiter les valeurs manquantes, éliminer les valeurs bruyantes provenant de mesures erronées et supprimer les doublons sont quelques exemples de processus typiques de l'étape de nettoyage des données.

Comme vous pourriez le penser, plus les données sont complexes, plus le nettoyage des données peut devenir complexe, fastidieux et long, en particulier lors de sa mise en œuvre manuelle.

Cet article approfondit les fonctionnalités offertes par la bibliothèque Pandas pour automatiser le processus de nettoyage des données. C'est parti !

Nettoyer les données avec Pandas : fonctions communes

Automatiser les processus de nettoyage des données avec pandas revient à systématiser l'application combinée et séquentielle de plusieurs fonctions de nettoyage des données pour encapsuler la séquence d'actions dans un seul pipeline de nettoyage des données. Avant de faire cela, présentons quelques fonctions pandas généralement utilisées pour diverses étapes de nettoyage des données. Dans la suite, nous supposons un exemple de variable python df qui contient un ensemble de données encapsulé dans un objet pandas DataFrame.

• Remplir les valeurs manquantes : pandas fournit des méthodes pour traiter automatiquement les valeurs manquantes dans un ensemble de données, que ce soit en remplaçant les valeurs manquantes par une valeur « par défaut » à l'aide de df.fillna() ou en supprimant toutes les lignes ou colonnes contenant des valeurs manquantes via la méthode df.dropna().
• Suppression des instances en double : la suppression automatique des entrées (lignes) en double dans un ensemble de données ne pourrait pas être plus simple grâce à la méthode df.drop_duplicates(), qui permet la suppression des instances supplémentaires lorsque soit une valeur d'attribut spécifique, soit les valeurs d'instance entières sont dupliquées dans une autre entrée.
• Manipulation des chaînes : certaines fonctions pandas sont utiles pour uniformiser le format des attributs de chaîne. Par exemple, s'il existe un mélange de valeurs minuscules, majuscules et majuscules pour un attribut 'column' et que nous voulons qu'elles soient toutes en minuscules, le df['column'].str La méthode .lower() fait le travail. Pour supprimer les espaces de début et de fin introduits accidentellement, essayez la méthode df['column'].str.strip().
• Manipulation de la date et de l'heure : le pd.to_datetime(df['column']) convertit les colonnes de chaîne contenant des informations date-heure, par ex. au format jj/mm/aaaa, dans des objets datetime Python, facilitant ainsi leur manipulation ultérieure.
• Renommer les colonnes : automatiser le processus de renommage des colonnes peut être particulièrement utile lorsqu'il existe plusieurs ensembles de données séparés par ville, région, projet, etc., et que nous souhaitons ajouter des préfixes ou des suffixes à tout ou partie de leurs colonnes pour faciliter leur identification. La méthode df.rename(columns={old_name: new_name}) rend cela possible.

Rassembler le tout : pipeline de nettoyage automatisé des données

Il est temps de regrouper les exemples de méthodes ci-dessus dans un pipeline réutilisable qui permet d'automatiser davantage le processus de nettoyage des données au fil du temps. Considérons un petit ensemble de données de transactions personnelles avec trois colonnes : nom de la personne (nom), date d'achat (date) et montant dépensé (valeur) :

Cet ensemble de données a été stocké dans un DataFrame pandas, df.

Pour créer un pipeline de nettoyage de données simple mais encapsulé, nous créons une classe personnalisée appelée DataCleaner, avec une série de méthodes personnalisées pour chacune des étapes de nettoyage de données décrites ci-dessus, comme suit :

class DataCleaner:
def __init__(self):
    pass

def fill_missing_values(self, df):
    return df.fillna(method='ffill').fillna(method='bfill')

Remarque : les valeurs des arguments ffill et bfill dans la méthode « fillna » sont deux exemples de stratégies pour gérer les valeurs manquantes. En particulier, ffill applique un « remplissage direct » qui impute les valeurs manquantes à partir de la valeur de la ligne précédente. Un « remplissage en arrière » est ensuite appliqué avec bfill pour remplir toutes les valeurs manquantes restantes en utilisant la valeur de l'instance suivante, garantissant ainsi qu'aucune valeur manquante ne sera laissée.

def drop_missing_values(self, df):
    return df.dropna()

def remove_duplicates(self, df):
    return df.drop_duplicates()

def clean_strings(self, df, column):
    df[column] = df[column].str.strip().str.lower()
    return df

def convert_to_datetime(self, df, column):
    df[column] = pd.to_datetime(df[column])
    return df

def rename_columns(self, df, columns_dict):
    return df.rename(columns=columns_dict)

Vient ensuite la méthode « centrale » de cette classe, qui regroupe toutes les étapes de nettoyage en un seul pipeline. N'oubliez pas que, comme dans tout processus de manipulation de données, l'ordre compte : c'est à vous de déterminer l'ordre le plus logique pour appliquer les différentes étapes pour obtenir ce que vous recherchez dans vos données, en fonction du problème spécifique abordé.

def clean_data(self, df):
    df = self.fill_missing_values(df)
    df = self.drop_missing_values(df)
    df = self.remove_duplicates(df)
    df = self.clean_strings(df, 'name')
    df = self.convert_to_datetime(df, 'date')
    df = self.rename_columns(df, {'name': 'full_name'})
    return df

Enfin, nous utilisons la classe nouvellement créée pour appliquer l'ensemble du processus de nettoyage d'un seul coup et afficher le résultat.

cleaner = DataCleaner()
cleaned_df = cleaner.clean_data(df)
print("\nCleaned DataFrame:")
print(cleaned_df)

Et c'est tout ! Nous avons une version beaucoup plus agréable et uniforme de nos données originales après y avoir appliqué quelques retouches.

Ce pipeline encapsulé est conçu pour faciliter et simplifier considérablement le processus global de nettoyage des données sur tous les nouveaux lots de données que vous obtenez à partir de maintenant.