Le traitement des données manquantes est un aspect crucial de l’analyse des données et de la modélisation. Les ensembles de données incomplets peuvent poser des problèmes lors de l’analyse de données et donner lieu à des résultats biaisés ou inexacts. Pandas, une puissante bibliothèque Python pour la manipulation et l’analyse de données, fournit diverses fonctions pour traiter les données manquantes.
Dans ce tutoriel, nous allons explorer différentes techniques de traitement des données manquantes avec Pandas, notamment la suppression des valeurs manquantes, le remplissage des valeurs manquantes et l’interpolation des valeurs manquantes. Nous verrons également comment traiter les données manquantes dans les séries temporelles et les données catégorielles, ainsi que comment traiter les données manquantes pour les algorithmes de Machine Learning.
À la fin de ce tutoriel, tu auras une compréhension complète des meilleures pratiques de traitement des données manquantes avec Pandas, et tu seras équipé des compétences nécessaires pour préparer tes données en vue d’une analyse ou d’une modélisation efficaces.
Vérification des données manquantes
La première étape du traitement des données manquantes consiste à vérifier s’il existe des valeurs manquantes dans l’ensemble de données. Nous pouvons utiliser les fonctions isna() ou isnull() pour vérifier les données manquantes.
import pandas as pd
# Créer un échantillon de données (dataframe)
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, 12]})
# Vérification des données manquantes
print(df.isna())Le résultat sera le suivant :
A B C 0 False False False 1 False True False 2 True False False 3 False False False
Cela montre que la deuxième ligne de la colonne « B » et la troisième ligne de la colonne « A » ont des valeurs manquantes.
Abandon des données manquantes
Une façon de traiter les données manquantes consiste à supprimer les lignes ou les colonnes qui contiennent des valeurs manquantes. Pour ce faire, nous pouvons utiliser la fonction dropna().
# Supprimer les lignes contenant des données manquantes df = df.dropna() # Supprimer les colonnes avec des données manquantes df = df.dropna(axis=1)
Le DataFrame qui en résulte est présenté ci-dessous :
A B C 0 1.0 5.0 9 3 4.0 8.0 12
Remplissage des données manquantes
Une autre façon de traiter les données manquantes consiste à compléter les valeurs manquantes par une valeur quelconque. Pour ce faire, nous pouvons utiliser la fonction fillna().
# Créer un échantillon de données (dataframe)
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, 12]})
# Remplir/compléter les valeurs manquantes par une valeur constante
df = df.fillna(0)Le dataframe qui en résulte est présenté ci-dessous :
A B C 0 1.0 5.0 9 1 2.0 0.0 10 2 0.0 7.0 11 3 4.0 8.0 12
Dans l’exemple ci-dessus, les valeurs manquantes sont remplacées par 0.
# Créer un échantillon de données (dataframe)
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, 12]})
# Compléter les valeurs manquantes par la valeur moyenne de la colonne
df = df.fillna(df.mean())Le dataframe qui en résulte est présenté ci-dessous :
A B C 0 1.000000 5.000000 9 1 2.000000 6.666667 10 2 2.333333 7.000000 11 3 4.000000 8.000000 12
Dans l’exemple ci-dessus, les valeurs manquantes sont remplacées par la valeur moyenne de la colonne correspondante.
# Créer un échantillon de données (dataframe)
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, 12]})
# Compléter les valeurs manquantes par la valeur du mode de la colonne
df = df.fillna(df.mode().iloc[0]) Le dataframe qui en résulte est présenté ci-dessous :
A B C 0 1.0 5.0 9 1 2.0 5.0 10 2 1.0 7.0 11 3 4.0 8.0 12
Dans l’exemple ci-dessus, les valeurs manquantes sont remplacées par la valeur du mode de la colonne correspondante.
Interpolation des données manquantes
L’interpolation est une méthode permettant de combler les valeurs manquantes en les estimant sur la base des valeurs d’autres points de données. Nous pouvons utiliser la fonction interpolate() pour interpoler les valeurs manquantes.
# Créer un échantillon de données (dataframe)
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, 12]})
# Interpoler les valeurs manquantes à l'aide de l'interpolation linéaire
df = df.interpolate()Le dataframe qui en résulte est présenté ci-dessous :
A B C 0 1.0 5.0 9 1 2.0 6.0 10 2 3.0 7.0 11 3 4.0 8.0 12
Dans l’exemple ci-dessus, l’interpolation linéaire est utilisée pour interpoler les valeurs manquantes.
Remplissage en avant et en arrière
Le remplissage avant et arrière est une méthode permettant de compléter les valeurs manquantes par la dernière valeur connue. Pour ce faire, nous pouvons utiliser les fonctions ffill() et bfill().
# Créer un échantillon de données (dataframe)
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, 12]})# Remplissage des valeurs manquantes avec la valeur précédente df = df.ffill()
A B C 0 1.0 5.0 9 1 2.0 5.0 10 2 2.0 7.0 11 3 4.0 8.0 12
# Remplissage des valeurs manquantes avec la valeur suivante df = df.bfill()
A B C 0 1.0 5.0 9 1 2.0 7.0 10 2 4.0 7.0 11 3 4.0 8.0 12
Il s’agit de quelques-unes des façons de gérer les données manquantes avec pandas. Il est important de choisir la bonne méthode en fonction du type de données et de l’analyse que tu effectues.
Traitement des données manquantes dans les séries temporelles
Les données de séries temporelles sont un type particulier de données où chaque point de données est associé à un moment spécifique. Le traitement des données manquantes dans les séries temporelles nécessite une attention particulière car l’ordre des points de données est important.
Nous pouvons utiliser la fonction resample() de pandas pour ré-échantillonner les données à une fréquence différente et remplir les valeurs manquantes à l’aide de la fonction fillna().
import numpy as np
# Créer un échantillon de données de séries temporelles avec des valeurs manquantes
date_rng = pd.date_range(start='1/1/2022', end='1/10/2022', freq='D')
ts = pd.DataFrame(date_rng, columns=['date'])
ts['data'] = np.random.randint(0,100,size=(len(date_rng)))
ts = ts.set_index('date')
ts = ts.mask(np.random.random(ts.shape) < 0.1)
# Ré-échantillonner les données pour compléter les valeurs manquantes
ts_resampled = ts.resample('D').asfreq().fillna(method='ffill')Dans cet exemple, nous avons d’abord créé une série de données temporelles avec des valeurs manquantes. Nous avons ensuite ré-échantillonné les données pour compléter les valeurs manquantes à l’aide d’un remplissage par anticipation.
Pour en savoir plus sur les séries temporelles, je t’invite à consulter mon cours sur l’analyse et la prévision des séries temporelles.
Traitement des données manquantes dans les données catégorielles
Les données catégorielles sont un type de données dont les valeurs sont divisées en catégories ou en groupes. Le traitement des données manquantes dans les données catégorielles nécessite une attention particulière car les valeurs manquantes peuvent avoir une signification spéciale.
Nous pouvons utiliser la fonction fillna() avec le paramètre de méthode ffill ou bfill pour compléter les valeurs manquantes avec la dernière valeur connue. Nous pouvons également compléter les valeurs manquantes par une nouvelle catégorie ou une nouvelle étiquette.
Nous avons d’abord créé un dataframe contenant des données catégorielles.
# Créer un exemple de dataframe avec des données catégorielles
df = pd.DataFrame({'A': ['chat', 'chien', 'chat', None, 'chien', 'oiseau', 'chat']})Cela créera le dataframe suivant :
A 0 chat 1 chien 2 chat 3 None 4 chien 5 oiseau 6 chat
Nous pouvons compléter les valeurs manquantes à l’aide de la dernière valeur connue en procédant comme suit :
# Compléter les valeurs manquantes par la dernière valeur connue df = df.fillna(method='ffill')
Le dataframe mis à jour est présenté ci-dessous :
A 0 chat 1 chien 2 chat 3 chat 4 chien 5 oiseau 6 chat
Nous pouvons également compléter les valeurs manquantes par une nouvelle catégorie. Dans l’exemple suivant, une nouvelle catégorie « inconnu » est ajoutée aux données.
# Créer un exemple de dataframe avec des données catégorielles
df = pd.DataFrame({'A': ['chat', 'chien', 'chat', None, 'chien', 'oiseau', 'chat']})
# Compléter les valeurs manquantes avec une nouvelle catégorie
df = df.fillna('inconnu') Le dataframe mis à jour est présenté ci-dessous :
A 0 chat 1 chien 2 inconnu 3 chat 4 chien 5 oiseau 6 chat
Le traitement des données manquantes est une étape importante de l’analyse et de la modélisation des données. Pandas fournit une variété de fonctions pour gérer les données manquantes. Il est important de choisir la bonne méthode en fonction du type de données et de l’analyse que tu effectues.
Traitement des données manquantes pour les algorithmes de Machine Learning
Le traitement des données manquantes est une étape cruciale dans la préparation des données pour les algorithmes de Machine Learning. Dans de nombreux cas, les algorithmes de Machine Learning ne peuvent pas gérer les données manquantes, et nous devons donc les traiter avant d’introduire les données dans l’algorithme.
Nous pouvons utiliser la classe SimpleImputer du module sklearn.impute pour imputer les valeurs manquantes dans un ensemble de données. La classe SimpleImputer propose plusieurs stratégies pour imputer les valeurs manquantes, telles que la moyenne, la médiane et le mode.
from sklearn.impute import SimpleImputer
# Créer un échantillon de données avec des valeurs manquantes
df_ml = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8], 'C': [9, 10, 11, None]})
# Créer un objet SimpleImputer avec une stratégie de moyenne
imputer = SimpleImputer(strategy='mean')
# Imputer les valeurs manquantes
df_ml_imputed = imputer.fit_transform(df_ml)Dans cet exemple, nous avons d’abord créé un dataframe avec des valeurs manquantes. Nous avons ensuite créé un objet SimpleImputer avec strategy=’mean’ et l’avons utilisé pour imputer les valeurs manquantes.
Après avoir imputé les valeurs manquantes, nous pouvons utiliser les données obtenues pour entraîner des modèles de Machine Learning. Il est important de garder à l’esprit que l’imputation des valeurs manquantes peut introduire un biais dans les données, c’est pourquoi nous devons choisir la stratégie d’imputation avec soin en fonction du type de données et de l’analyse que nous effectuons.
Conclusion
Le traitement des données manquantes est une étape importante de l’analyse et de la modélisation des données. Pandas fournit une variété de fonctions pour traiter les données manquantes, telles que l’élimination des valeurs manquantes, le remplissage des valeurs manquantes avec une valeur constante et l’interpolation des valeurs manquantes. Nous avons également abordé la manière de traiter les données manquantes dans les séries temporelles et les données catégorielles, ainsi que la manière de traiter les données manquantes avec les algorithmes de Machine Learning. Il est important de choisir la bonne méthode en fonction du type de données et de l’analyse que tu effectues.
Si tu as aimé ce tutoriel, tu peux également lire ce tuto sur le nettoyage des données avec Python.
