Data-Science-For-Beginners/translations/fr/2-Working-With-Data/08-data-preparation

Travailler avec les données : Préparation des données

Préparation des données - Sketchnote par @nitya

Quiz avant le cours

Selon sa source, les données brutes peuvent contenir des incohérences qui poseront des défis lors de l'analyse et de la modélisation. En d'autres termes, ces données peuvent être qualifiées de "sales" et nécessiteront un nettoyage. Cette leçon se concentre sur les techniques de nettoyage et de transformation des données pour gérer les problèmes de données manquantes, inexactes ou incomplètes. Les sujets abordés dans cette leçon utiliseront Python et la bibliothèque Pandas et seront démontrés dans le notebook de ce répertoire.

L'importance de nettoyer les données

• Facilité d'utilisation et de réutilisation : Lorsque les données sont correctement organisées et normalisées, il est plus facile de les rechercher, de les utiliser et de les partager avec d'autres.

• Cohérence : La science des données nécessite souvent de travailler avec plusieurs ensembles de données, où des ensembles provenant de différentes sources doivent être combinés. S'assurer que chaque ensemble de données individuel respecte une standardisation commune garantit que les données restent utiles lorsqu'elles sont fusionnées en un seul ensemble.

• Précision des modèles : Des données nettoyées améliorent la précision des modèles qui en dépendent.

Objectifs et stratégies courants de nettoyage

• Explorer un ensemble de données : L'exploration des données, qui est abordée dans une leçon ultérieure, peut vous aider à identifier les données nécessitant un nettoyage. Observer visuellement les valeurs d'un ensemble de données peut donner une idée de ce à quoi s'attendre pour le reste ou révéler des problèmes à résoudre. L'exploration peut inclure des requêtes de base, des visualisations et des échantillonnages.

• Formatage : Selon la source, les données peuvent présenter des incohérences dans leur présentation. Cela peut poser des problèmes pour les recherches et la représentation des valeurs, où elles sont visibles dans l'ensemble de données mais mal représentées dans les visualisations ou les résultats de requêtes. Les problèmes courants de formatage incluent la gestion des espaces blancs, des dates et des types de données. La résolution de ces problèmes dépend souvent des utilisateurs des données. Par exemple, les normes sur la présentation des dates et des nombres peuvent varier selon les pays.

• Doublons : Les données ayant plusieurs occurrences peuvent produire des résultats inexacts et doivent généralement être supprimées. Cela peut se produire fréquemment lors de la fusion de plusieurs ensembles de données. Cependant, il existe des cas où les doublons contiennent des informations supplémentaires et doivent être conservés.

• Données manquantes : Les données manquantes peuvent entraîner des résultats inexacts, faibles ou biaisés. Parfois, elles peuvent être résolues par un "rechargement" des données, en remplissant les valeurs manquantes par des calculs et du code comme Python, ou simplement en supprimant la valeur et les données correspondantes. Les raisons des données manquantes sont nombreuses, et les actions pour les résoudre dépendent souvent de la manière et des raisons pour lesquelles elles ont disparu.

Explorer les informations d'un DataFrame

Objectif d'apprentissage : À la fin de cette sous-section, vous devriez être à l'aise pour trouver des informations générales sur les données stockées dans des DataFrames pandas.

Une fois vos données chargées dans pandas, elles seront probablement dans un DataFrame (voir la leçon précédente pour un aperçu détaillé). Cependant, si votre DataFrame contient 60 000 lignes et 400 colonnes, par où commencer pour comprendre ce que vous avez ? Heureusement, pandas propose des outils pratiques pour examiner rapidement les informations générales d'un DataFrame, ainsi que les premières et dernières lignes.

Pour explorer cette fonctionnalité, nous allons importer la bibliothèque Python scikit-learn et utiliser un ensemble de données emblématique : l'ensemble de données Iris.

import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()
iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])

	longueur sépale (cm)	largeur sépale (cm)	longueur pétale (cm)	largeur pétale (cm)
0	5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5.0	3.6	1.4	0.2

• DataFrame.info : Pour commencer, la méthode info() est utilisée pour afficher un résumé du contenu présent dans un DataFrame. Jetons un œil à cet ensemble de données pour voir ce que nous avons :

iris_df.info()

RangeIndex: 150 entries, 0 to 149
Data columns (total 4 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   sepal length (cm)  150 non-null    float64
 1   sepal width (cm)   150 non-null    float64
 2   petal length (cm)  150 non-null    float64
 3   petal width (cm)   150 non-null    float64
dtypes: float64(4)
memory usage: 4.8 KB

D'après cela, nous savons que l'ensemble de données Iris contient 150 entrées dans quatre colonnes sans valeurs nulles. Toutes les données sont stockées sous forme de nombres à virgule flottante 64 bits.

• DataFrame.head() : Ensuite, pour vérifier le contenu réel du DataFrame, nous utilisons la méthode head(). Voyons à quoi ressemblent les premières lignes de notre iris_df :

iris_df.head()

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
0                5.1               3.5                1.4               0.2
1                4.9               3.0                1.4               0.2
2                4.7               3.2                1.3               0.2
3                4.6               3.1                1.5               0.2
4                5.0               3.6                1.4               0.2

• DataFrame.tail() : Inversement, pour vérifier les dernières lignes du DataFrame, nous utilisons la méthode tail() :

iris_df.tail()

     sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
145                6.7               3.0                5.2               2.3
146                6.3               2.5                5.0               1.9
147                6.5               3.0                5.2               2.0
148                6.2               3.4                5.4               2.3
149                5.9               3.0                5.1               1.8

À retenir : Rien qu'en regardant les métadonnées ou les premières et dernières valeurs d'un DataFrame, vous pouvez avoir une idée immédiate de la taille, de la forme et du contenu des données avec lesquelles vous travaillez.

Gérer les données manquantes

Objectif d'apprentissage : À la fin de cette sous-section, vous devriez savoir comment remplacer ou supprimer les valeurs nulles dans les DataFrames.

La plupart du temps, les ensembles de données que vous souhaitez utiliser (ou devez utiliser) contiennent des valeurs manquantes. La manière dont les données manquantes sont gérées comporte des compromis subtils qui peuvent affecter votre analyse finale et les résultats réels.

Pandas gère les valeurs manquantes de deux manières. La première, que vous avez déjà vue dans les sections précédentes, est NaN, ou Not a Number. Il s'agit en fait d'une valeur spéciale faisant partie de la spécification IEEE pour les nombres à virgule flottante, utilisée uniquement pour indiquer des valeurs flottantes manquantes.

Pour les valeurs manquantes autres que les flottants, pandas utilise l'objet Python None. Bien qu'il puisse sembler déroutant de rencontrer deux types de valeurs indiquant essentiellement la même chose, il existe des raisons programmatiques valables pour ce choix de conception. En pratique, cela permet à pandas de proposer un bon compromis pour la grande majorité des cas. Cependant, None et NaN comportent des restrictions dont vous devez être conscient quant à leur utilisation.

Découvrez-en plus sur NaN et None dans le notebook !

• Détecter les valeurs nulles : Dans pandas, les méthodes isnull() et notnull() sont vos principales méthodes pour détecter les données nulles. Les deux renvoient des masques booléens sur vos données. Nous utiliserons numpy pour les valeurs NaN :

import numpy as np

example1 = pd.Series([0, np.nan, '', None])
example1.isnull()

0    False
1     True
2    False
3     True
dtype: bool

Regardez attentivement la sortie. Quelque chose vous surprend-il ? Bien que 0 soit un nul arithmétique, il reste néanmoins un entier valide et pandas le traite comme tel. '' est un peu plus subtil. Bien que nous l'ayons utilisé dans la Section 1 pour représenter une chaîne vide, il reste néanmoins un objet chaîne et non une représentation de null pour pandas.

Voyons maintenant comment utiliser ces méthodes de manière plus pratique. Vous pouvez utiliser des masques booléens directement comme index de Series ou DataFrame, ce qui peut être utile pour travailler avec des valeurs manquantes (ou présentes) isolées.

À retenir : Les méthodes isnull() et notnull() produisent des résultats similaires dans les DataFrames : elles montrent les résultats et l'index de ces résultats, ce qui vous sera d'une grande aide pour manipuler vos données.

• Supprimer les valeurs nulles : Au-delà de l'identification des valeurs manquantes, pandas propose un moyen pratique de supprimer les valeurs nulles des Series et DataFrames. (En particulier pour les grands ensembles de données, il est souvent plus judicieux de simplement supprimer les valeurs manquantes [NA] de votre analyse que de les traiter autrement.) Pour voir cela en action, revenons à example1 :

example1 = example1.dropna()
example1

0    0
2     
dtype: object

Notez que cela devrait ressembler à votre sortie de example3[example3.notnull()]. La différence ici est que, plutôt que d'indexer uniquement sur les valeurs masquées, dropna a supprimé ces valeurs manquantes de la Series example1.

Les DataFrames ayant deux dimensions, ils offrent plus d'options pour supprimer des données.

example2 = pd.DataFrame([[1,      np.nan, 7], 
                         [2,      5,      8], 
                         [np.nan, 6,      9]])
example2

	0	1	2
0	1.0	NaN	7
1	2.0	5.0	8
2	NaN	6.0	9

(Remarquez que pandas a converti deux des colonnes en flottants pour accueillir les NaN.)

Vous ne pouvez pas supprimer une seule valeur d'un DataFrame, vous devez donc supprimer des lignes ou des colonnes entières. Selon ce que vous faites, vous pourriez vouloir faire l'un ou l'autre, et pandas vous offre des options pour les deux. En science des données, les colonnes représentent généralement des variables et les lignes des observations, vous êtes donc plus susceptible de supprimer des lignes de données ; le paramètre par défaut de dropna() est de supprimer toutes les lignes contenant des valeurs nulles :

example2.dropna()

	0	1	2
1	2.0	5.0	8

Si nécessaire, vous pouvez supprimer les valeurs NA des colonnes. Utilisez axis=1 pour ce faire :

example2.dropna(axis='columns')

	2
0	7
1	8
2	9

Notez que cela peut supprimer beaucoup de données que vous pourriez vouloir conserver, en particulier dans les petits ensembles de données. Que faire si vous souhaitez uniquement supprimer les lignes ou colonnes contenant plusieurs ou même toutes les valeurs nulles ? Vous pouvez spécifier ces paramètres dans dropna avec les paramètres how et thresh.

Par défaut, how='any' (si vous souhaitez vérifier par vous-même ou voir quels autres paramètres la méthode propose, exécutez example4.dropna? dans une cellule de code). Vous pourriez alternativement spécifier how='all' pour ne supprimer que les lignes ou colonnes contenant uniquement des valeurs nulles. Étendons notre exemple de DataFrame pour voir cela en action.

example2[3] = np.nan
example2

	0	1	2	3
0	1.0	NaN	7	NaN
1	2.0	5.0	8	NaN
2	NaN	6.0	9	NaN

Le paramètre thresh vous donne un contrôle plus précis : vous définissez le nombre de valeurs non nulles qu'une ligne ou une colonne doit avoir pour être conservée :

example2.dropna(axis='rows', thresh=3)

	0	1	2	3
1	2.0	5.0	8	NaN

Ici, la première et la dernière ligne ont été supprimées, car elles contiennent seulement deux valeurs non nulles.

• Remplir les valeurs nulles : Selon votre ensemble de données, il peut parfois être plus logique de remplir les valeurs nulles avec des valeurs valides plutôt que de les supprimer. Vous pourriez utiliser isnull pour le faire sur place, mais cela peut être laborieux, en particulier si vous avez beaucoup de valeurs à remplir. Comme cette tâche est courante en science des données, pandas propose fillna, qui renvoie une copie de la Series ou du DataFrame avec les valeurs manquantes remplacées par celles de votre choix. Créons une autre Series d'exemple pour voir comment cela fonctionne en pratique.

example3 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))
example3

a    1.0
b    NaN
c    2.0
d    NaN
e    3.0
dtype: float64

Vous pouvez remplir toutes les entrées nulles avec une seule valeur, comme 0 :

example3.fillna(0)

a    1.0
b    0.0
c    2.0
d    0.0
e    3.0
dtype: float64

Vous pouvez remplir vers l'avant les valeurs nulles, c'est-à-dire utiliser la dernière valeur valide pour remplir une valeur nulle :

example3.fillna(method='ffill')

a    1.0
b    1.0
c    2.0
d    2.0
e    3.0
dtype: float64

Vous pouvez également remplir vers l'arrière pour propager la prochaine valeur valide en arrière afin de remplir une valeur nulle :

example3.fillna(method='bfill')

a    1.0
b    2.0
c    2.0
d    3.0
e    3.0
dtype: float64

Comme vous pouvez le deviner, cela fonctionne de la même manière avec les DataFrames, mais vous pouvez également spécifier un axis le long duquel remplir les valeurs nulles. En reprenant example2 utilisé précédemment :

example2.fillna(method='ffill', axis=1)

	0	1	2	3
0	1.0	1.0	7.0	7.0
1	2.0	5.0	8.0	8.0
2	NaN	6.0	9.0	9.0

Remarquez que lorsqu'une valeur précédente n'est pas disponible pour le remplissage vers l'avant, la valeur nulle reste.

À retenir : Il existe plusieurs façons de gérer les valeurs manquantes dans vos ensembles de données. La stratégie spécifique que vous utilisez (les supprimer, les remplacer, ou même la manière dont vous les remplacez) doit être dictée par les particularités de ces données. Vous développerez une meilleure intuition pour traiter les valeurs manquantes à mesure que vous manipulerez et interagirez avec des ensembles de données.

Suppression des données dupliquées

Objectif d'apprentissage : À la fin de cette sous-section, vous devriez être à l'aise pour identifier et supprimer les valeurs dupliquées dans des DataFrames.

En plus des données manquantes, vous rencontrerez souvent des données dupliquées dans des ensembles de données réels. Heureusement, pandas offre un moyen simple de détecter et de supprimer les entrées dupliquées.

• Identifier les doublons : duplicated : Vous pouvez facilement repérer les valeurs dupliquées en utilisant la méthode duplicated de pandas, qui renvoie un masque booléen indiquant si une entrée dans un DataFrame est un doublon d'une entrée précédente. Créons un autre exemple de DataFrame pour voir cela en action.

example4 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],
                         'numbers': [1, 2, 1, 3, 3]})
example4

	lettres	nombres
0	A	1
1	B	2
2	A	1
3	B	3
4	B	3

example4.duplicated()

0    False
1    False
2     True
3    False
4     True
dtype: bool

• Supprimer les doublons : drop_duplicates : retourne simplement une copie des données pour lesquelles toutes les valeurs duplicated sont False :

example4.drop_duplicates()

	letters	numbers
0	A	1
1	B	2
3	B	3

Les méthodes duplicated et drop_duplicates considèrent par défaut toutes les colonnes, mais vous pouvez spécifier qu'elles examinent uniquement un sous-ensemble de colonnes dans votre DataFrame :

example4.drop_duplicates(['letters'])

letters	numbers
0	A	1
1	B	2

À retenir : Supprimer les données dupliquées est une étape essentielle dans presque tous les projets de science des données. Les données dupliquées peuvent modifier les résultats de vos analyses et vous donner des résultats inexacts !

🚀 Défi

Tous les matériaux abordés sont disponibles sous forme de Jupyter Notebook. De plus, des exercices sont présents après chaque section, essayez-les !

Quiz après le cours

Révision et auto-apprentissage

Il existe de nombreuses façons de découvrir et d'aborder la préparation de vos données pour l'analyse et la modélisation, et le nettoyage des données est une étape importante qui nécessite une expérience pratique. Essayez ces défis sur Kaggle pour explorer des techniques que cette leçon n'a pas couvertes.

• Défi de nettoyage des données : Analyse des dates

• Défi de nettoyage des données : Mise à l'échelle et normalisation des données

Devoir

Évaluation des données d'un formulaire

Avertissement :
Ce document a été traduit à l'aide du service de traduction automatique Co-op Translator. Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.