Accéder au contenu principal

Prétraitement des données : Un guide complet avec des exemples en Python

Apprenez les techniques de préparation des données brutes pour l'analyse ou l'apprentissage automatique avec des exemples en Python !
Actualisé 16 janv. 2025  · 24 min de lecture

La qualité de vos données a un impact direct sur la précision de votre analyse et la performance de votre modèle. Pourquoi ? Parce que les données brutes contiennent souvent des incohérences, des erreurs et des informations non pertinentes qui peuvent fausser les résultats et conduire à des conclusions erronées. Le prétraitement des données est un moyen d'atténuer ce problème. Il s'agit du processus de transformation des données brutes en un format propre et structuré. 

Dans cet article de blog, j'aborderai les sujets suivants : 

  • Qu'est-ce que le prétraitement des données ? 
  • Étapes du prétraitement des données
  • Techniques de prétraitement des données avec exemples
  • Outils de prétraitement des données
  • Meilleures pratiques pour le prétraitement des données

Allons-y !

Qu'est-ce que le prétraitement des données ?

Le prétraitement des données est un aspect essentiel de la préparation des données. Il s'agit de tout traitement appliqué aux données brutes afin de les préparer à des tâches d'analyse ou de traitement ultérieures. 

Traditionnellement, le prétraitement des données est une étape préliminaire essentielle de l'analyse des données. Toutefois, plus récemment, ces techniques ont été adaptées pour former des modèles d'apprentissage automatique et d'intelligence artificielle et en tirer des conclusions

Ainsi, le prétraitement des données peut être défini comme le processus de conversion des données brutes dans un format qui peut être traité de manière plus efficace et plus précise dans des tâches telles que : 

  • Analyse des données
  • Apprentissage automatique 
  • Science des données
  • AI

Devenez ingénieur en données

Développez vos compétences en Python pour devenir un ingénieur de données professionnel.
Commencez gratuitement

Étapes du prétraitement des données

Le prétraitement des données comporte plusieurs étapes, chacune répondant à des défis spécifiques liés à la qualité, à la structure et à la pertinence des données. 

Examinons ces étapes clés, qui se déroulent généralement dans l'ordre suivant : 

Étape 1 : Nettoyage des données

Le nettoyage des données consiste à identifier et à corriger les erreurs ou les incohérences dans les données afin de s'assurer qu'elles sont exactes et complètes. L'objectif est de résoudre les problèmes qui peuvent fausser l'analyse ou les performances du modèle.

Par exemple : 

  • Traitement des valeurs manquantes : Utiliser des stratégies telles que l'imputation moyenne/mode, la suppression ou les modèles prédictifs pour compléter ou supprimer les données manquantes.
  • Suppression des doublons : Élimination des enregistrements en double afin de garantir que chaque entrée est unique et pertinente.
  • Correction des formats incohérents : Normaliser les formats (par exemple, les formats de date, les chaînes de caractères) pour maintenir la cohérence.

Voici ce que cela donne en Python :

# Creating a manual dataset
data = pd.DataFrame({
    'name': ['John', 'Jane', 'Jack', 'John', None],
    'age': [28, 34, None, 28, 22],
    'purchase_amount': [100.5, None, 85.3, 100.5, 50.0],
    'date_of_purchase': ['2023/12/01', '2023/12/02', '2023/12/01', '2023/12/01', '2023/12/03']
	})

# Handling missing values using mean imputation for 'age' and 'purchase_amount'
imputer = SimpleImputer(strategy='mean')
data[['age', 'purchase_amount']] = imputer.fit_transform(data[['age', 'purchase_amount']])

# Removing duplicate rows
data = data.drop_duplicates()

# Correcting inconsistent date formats
data['date_of_purchase'] = pd.to_datetime(data['date_of_purchase'], errors='coerce')

print(data)

Image montrant un tableau représentant la sortie d'un script Python

Sortie du code ci-dessus 

Étape 2 : Intégration des données

L'intégration des données consiste à combiner des données provenant de sources multiples pour créer un ensemble de données unifié. Cela est souvent nécessaire lorsque les données sont collectées à partir de différents systèmes sources.

Parmi les techniques utilisées pour l'intégration des données, on peut citer 

  • Correspondance des schémas : Alignement des champs et des structures de données provenant de différentes sources afin d'en assurer la cohérence.
  • Déduplication des données : Identification et suppression des doublons dans plusieurs ensembles de données.

Par exemple, supposons que nous ayons des données sur les clients provenant de plusieurs bases de données. Voici comment nous pourrions les fusionner en une seule vue : 

# Creating two manual datasets
data1 = pd.DataFrame({
    'customer_id': [1, 2, 3],
    'name': ['John', 'Jane', 'Jack'],
    'age': [28, 34, 29]
})

data2 = pd.DataFrame({
    'customer_id': [1, 3, 4],
    'purchase_amount': [100.5, 85.3, 45.0],
    'purchase_date': ['2023-12-01', '2023-12-02', '2023-12-03']
})

# Merging datasets on a common key 'customer_id'
merged_data = pd.merge(data1, data2, on='customer_id', how='inner')

print(merged_data)

Image montrant un tableau représentant la sortie d'un script Python

Sortie du code ci-dessus

Étape 3 : Transformation des données

La transformation des données permet de convertir les données dans des formats adaptés à l'analyse, à l'apprentissage automatique ou à l'exploitation minière. 

Par exemple :

  • Mise à l'échelle et normalisation : L'ajustement des valeurs numériques à une échelle commune est souvent nécessaire pour les algorithmes qui s'appuient sur des mesures de distance.
  • Encodage de variables catégorielles : Conversion de données catégorielles en valeurs numériques à l'aide de techniques d'encodage à un point ou d'encodage d'étiquettes.
  • Ingénierie et extraction de caractéristiques : Créer de nouvelles fonctionnalités ou sélectionner des fonctionnalités importantes pour améliorer les performances du modèle.

Voici ce que cela donne en Python, en utilisant scikit-learn : 

from sklearn.preprocessing import StandardScaler, OneHotEncoder

# Creating a manual dataset
data = pd.DataFrame({
    'category': ['A', 'B', 'A', 'C', 'B'],
    'numeric_column': [10, 15, 10, 20, 15]
	})

# Scaling numeric data
scaler = StandardScaler()
data['scaled_numeric_column'] = scaler.fit_transform(data[['numeric_column']])

# Encoding categorical variables using one-hot encoding
encoder = OneHotEncoder(sparse_output=False)
encoded_data = pd.DataFrame(encoder.fit_transform(data[['category']]),
                            columns=encoder.get_feature_names_out(['category']))

# Concatenating the encoded data with the original dataset
data = pd.concat([data, encoded_data], axis=1)

print(data)

Image montrant un tableau représentant la sortie d'un script Python

Sortie du code ci-dessus

Étape 4 : Réduction des données

La réduction des données permet de simplifier l'ensemble des données en réduisant le nombre de caractéristiques ou d'enregistrements tout en préservant les informations essentielles. Cela permet d'accélérer l'analyse et la formation des modèles sans sacrifier la précision.

Les techniques de réduction des données comprennent 

  • Sélection des caractéristiques : Choisir les caractéristiques les plus importantes contribuant à la performance de l'analyse ou du modèle.
  • Analyse en composantes principales (ACP) : Unetechnique de réduction de la dimensionnalité qui transforme les données en un espace de dimension inférieure.
  • Méthodes d'échantillonnage : La réduction de la taille de l'ensemble de données par la sélection d'échantillons représentatifs est utile pour traiter de grands ensembles de données.

Et voici comment nous mettons en œuvre la réduction de la dimensionnalité en Python :

from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest, chi2

# Creating a manual dataset
data = pd.DataFrame({
    'feature1': [10, 20, 30, 40, 50],
    'feature2': [1, 2, 3, 4, 5],
    'feature3': [100, 200, 300, 400, 500],
    'target': [0, 1, 0, 1, 0]
	})

# Feature selection using SelectKBest
selector = SelectKBest(chi2, k=2)
selected_features = selector.fit_transform(data[['feature1', 'feature2', 'feature3']], data['target'])

# Printing selected features
print("Selected features (SelectKBest):")
print(selected_features)

# Dimensionality reduction using PCA
pca = PCA(n_components=2)
pca_data = pca.fit_transform(data[['feature1', 'feature2', 'feature3']])

# Printing PCA results
print("PCA reduced data:")
print(pca_data)

Image montrant le résultat de l'exécution d'un script scikit-learn

Sortie du code ci-dessus 

Techniques courantes de prétraitement des données avec exemples

Nous avons établi que le prétraitement des données brutes est essentiel pour s'assurer qu'elles sont bien adaptées à l'analyse ou aux modèles d'apprentissage automatique. Nous avons également abordé les étapes du processus. 

Dans cette section, nous allons explorer différentes techniques pour traiter les problèmes courants lors de la phase de prétraitement. En outre, nous explorerons l'augmentation des données, une technique utile pour créer des données synthétiques dans des contextes spécifiques tels que des ensembles de données d'images ou de textes.

Traitement des données manquantes

Les données manquantes peuvent avoir un impact négatif sur les performances d'un modèle ou d'une analyse d'apprentissage automatique. Il existe plusieurs stratégies pour traiter efficacement les valeurs manquantes :

  • Imputation : Cette technique consiste à compléter les valeurs manquantes par une estimation calculée, telle que la moyenne, la médiane ou le mode des données disponibles. Les méthodes avancées comprennent la modélisation prédictive, où les valeurs manquantes sont prédites sur la base des relations entre les données.
# Note: This is dummy code and not expected to run on its own
from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy='mean')  # Replace 'mean' with 'median' or 'most_frequent' if needed
data['column_with_missing'] = imputer.fit_transform(data[['column_with_missing']])
  • Suppression : La suppression des lignes ou des colonnes comportant des valeurs manquantes est une solution simple. Il convient toutefois de l'utiliser avec prudence, car il peut entraîner la perte de données précieuses, en particulier si de nombreuses entrées sont manquantes.
data.dropna(inplace=True)  # Removes rows with any missing values
  • Modélisation des valeurs manquantes : Dans les cas où le modèle de données manquantes est plus complexe, les modèles d'apprentissage automatique peuvent prédire les valeurs manquantes sur la base du reste de l'ensemble de données. Cela permet d'améliorer la précision en intégrant les relations entre les différentes variables.

Détection et suppression des valeurs aberrantes

Les valeurs aberrantes sont des valeurs extrêmes qui s'écartent de manière significative du reste des données et qui, comme les valeurs manquantes, peuvent fausser l'analyse et les performances du modèle. Différentes techniques peuvent être utilisées pour détecter et traiter les valeurs aberrantes :

  • Méthode du score Z : Cette approche mesure le nombre d'écarts types d'un point de données par rapport à la moyenne. Les points de données dépassant un certain seuil (par exemple, ± 3 écarts types) peuvent être considérés comme des valeurs aberrantes.
# Note: this is dummy code. 
# It won’t work unless a data with a column named “column” is imported

from scipy import stats 
z_scores = stats.zscore(data['column']) outliers = abs(z_scores) > 3 # Identifying outliers
  • Intervalle interquartile (IQR): L'IQR est l'intervalle entre le premier quartile (Q1) et le troisième quartile (Q3). Les valeurs supérieures à 1,5 fois l'IQR au-dessus de Q3 ou au-dessous de Q1 sont considérées comme aberrantes.
Q1 = data['column'].quantile(0.25)
Q3 = data['column'].quantile(0.75)
IQR = Q3 - Q1
outliers = (data['column'] < (Q1 - 1.5 * IQR)) | (data['column'] > (Q3 + 1.5 * IQR))
  • Techniques visuelles : Les méthodes de visualisation telles que les diagrammes en boîte, les diagrammes de dispersion ou les histogrammes peuvent aider à détecter les valeurs aberrantes dans un ensemble de données. Une fois identifiées, les valeurs aberrantes peuvent être supprimées ou transformées, en fonction de leur influence sur l'analyse.

Encodage des données

Lorsque l'on travaille avec des données catégorielles, l'encodage est nécessaire pour convertir les catégories en représentations numériques que les algorithmes d'apprentissage automatique peuvent traiter. Les techniques d'encodage les plus courantes sont les suivantes :

from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder(sparse_output=False)
encoded_data = encoder.fit_transform(data[['categorical_column']])
  • Codage des étiquettes : Le codage des étiquettes attribue une valeur numérique unique à chaque catégorie. Toutefois, cette méthode peut introduire une relation ordinale involontaire entre les catégories si elles n'ont pas d'ordre naturel.
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
data['encoded_column'] = le.fit_transform(data['categorical_column'])
  • Codage ordinal : Le codage ordinal est utilisé lorsque les variables catégorielles ont un ordre inhérent, comme faible, moyen et élevé. Chaque catégorie est associée à une valeur entière correspondant à son classement.
from sklearn.preprocessing import OrdinalEncoder
oe = OrdinalEncoder(categories=[['low', 'medium', 'high']])
data['ordinal_column'] = oe.fit_transform(data[['ordinal_column']])

Mise à l'échelle et normalisation des données

La mise à l'échelle et la normalisation garantissent que les caractéristiques numériques sont sur une échelle similaire, ce qui est particulièrement important pour les algorithmes qui reposent sur des mesures de distance (par exemple, k-voisins les plus proches, SVM).

  • Échelle minimale-maximale : Cette technique permet d'échelonner les données sur une plage spécifiée, généralement de 0 à 1. Elle est utile lorsque toutes les caractéristiques doivent avoir la même échelle.
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
data[['scaled_column']] = scaler.fit_transform(data[['numeric_column']])
  • Normalisation (normalisation du score Z) : Cette méthode met les données à l'échelle de sorte que la moyenne devienne 0 et l'écart type 1, ce qui permet aux modèles d'être plus performants avec des caractéristiques normalement distribuées.
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
data[['standardized_column']] = scaler.fit_transform(data[['numeric_column']])

Augmentation des données

L'augmentation des données est une technique permettant d'accroître artificiellement la taille d'un ensemble de données en créant de nouveaux exemples synthétiques. Ceci est particulièrement utile pour les ensembles de données d'images ou de textes dans les modèles d'apprentissage profond, où de grandes quantités de données sont nécessaires pour une performance robuste du modèle.

  • Augmentation de l'image : Des techniques telles que la rotation, le retournement, la mise à l'échelle ou l'ajout de bruit aux images permettent de créer des variations qui améliorent la généralisation du modèle.
from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest')

augmented_images = datagen.flow_from_directory('image_directory', target_size=(150, 150))
  • Augmentation du texte : Pour les données textuelles, les méthodes d'augmentation comprennent le remplacement des synonymes, l'insertion aléatoire et la rétro-traduction, qui consiste à traduire une phrase dans une autre langue, puis à la retraduire dans la langue d'origine, en introduisant des variations.
import nlpaug.augmenter.word as naw
# install nlpaug here: https://github.com/makcedward/nlpaug 

aug = naw.SynonymAug(aug_src='wordnet')
augmented_text = aug.augment("This is a sample text for augmentation.")

Outils de prétraitement des données

Bien que vous puissiez mettre en œuvre le traitement des données à l'aide d'un code Python pur, des outils puissants ont été développés pour gérer diverses tâches et rendre le processus global plus efficace. Voici quelques exemples : 

Bibliothèques Python

Il existe pas mal de bibliothèques spécialisées dans le prétraitement des données en Python. Voici trois des plus populaires : 

  • Pandas : La bibliothèque la plus utilisée de Python pour la manipulation et le nettoyage des données. Il fournit des structures de données flexibles, principalement DataFrame et Series, qui vous permettent de manipuler efficacement des données structurées. Pandas prend en charge des opérations telles que le traitement des données manquantes, la fusion des ensembles de données, le filtrage des données et le remodelage.
import pandas as pd

# Load a sample dataset
data = pd.DataFrame({
    'name': ['John', 'Jane', 'Jack'],
    'age': [28, 31, 34]
})

print(data)

Image montrant un tableau comme résultat de l'exécution d'un script Python

Sortie du code ci-dessus 

  • NumPy : Une bibliothèque fondamentale pour les calculs numériques. Il prend en charges les grands tableaux multidimensionnels et les matrices, ainsi que les fonctions mathématiques permettant d'opérer sur ces tableaux. NumPy est souvent la base de nombreuses bibliothèques de traitement de données de niveau supérieur, telles que Pandas.
import numpy as np

# Create an array and perform element-wise operations
array = np.array([1, 2, 3, 4])
squared_array = np.square(array)

print(squared_array)

Sortie du code ci-dessus

  • Scikit-learn : Largement utilisé pour les tâches d'apprentissage automatique, il offre également de nombreux utilitaires de prétraitement, tels que la mise à l'échelle, l'encodage et la transformation des données. Son module de prétraitement contient des outils pour le traitement des données catégorielles, la mise à l'échelle des données numériques, l'extraction de caractéristiques, etc.
from sklearn.preprocessing import StandardScaler 

# Standardize data 
data = [[10, 2], [15, 5], [20, 3]] 
scaler = StandardScaler() 
scaled_data = scaler.fit_transform(data)
print(scaled_data)

Image montrant un tableau comme résultat de l'exécution d'un script Python

Sortie du code ci-dessus

Plateformes cloud

Les systèmes sur site peuvent ne pas être en mesure de traiter efficacement des ensembles de données volumineux. Dans de telles situations, les plateformes cloud offrent des solutions évolutives et efficaces qui vous permettent de traiter de grandes quantités de données à travers des systèmes distribués. 

Voici quelques outils de plateforme cloud à prendre en compte : 

  • Colle AWS : Un service ETL entièrement géré par AmazonWeb Services. Il découvre et organise automatiquement les données et les prépare pour l'analyse. Glue prend en charge le catalogage des données et peut se connecter à des services AWS tels que S3 et Redshift.
  • Azure Data Factory : Un service d'intégration de données basé sur le cloud de Microsoft. Il permet de créer des pipelines ETL et ELT pour les données à grande échelle. Azure Data Factory permet aux utilisateurs de déplacer des données entre différents services, de les prétraiter à l'aide de transformations et d'orchestrer des flux de travail à l'aide d'une interface visuelle.

Outils d'automatisation

L'automatisation des étapes répétitives du prétraitement des données permet de gagner du temps et de réduire les erreurs, en particulier lorsqu'il s'agit de modèles d'apprentissage automatique et de grands ensembles de données. Voici quelques outils qui proposent des pipelines de prétraitement intégrés : 

  • Plateformes AutoML: AutoML est l'abréviation de Automated Machine Learning (apprentissage automatique de la machine). En d'autres termes, ces plateformes automatisent plusieurs étapes du flux de travail de l'apprentissage automatique. Les plateformes telles queke Google's AutoML, Microsoft's Azure AutoML, et H2O.ai's AutoML fournissent des pipelines automatisés qui gèrent des tâches telles que la sélection des caractéristiques, la transformation des données et la sélection des modèles avec une intervention minimale de l'utilisateur.
  • Pipelines de prétraitement dans scikit-learn : Scikit-learn fournites la classe Pipeline, qui permet de streamline et d'automatiser les étapes de prétraitement. Il vous permet d'enchaîner plusieurs opérations de prétraitement en un seul flux de travail exécutable, garantissant ainsi une application cohérente des tâches de prétraitement :
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer

# Example Pipeline combining different preprocessing tasks
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder())
])

preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_transformer, ['age']),
    ('cat', categorical_transformer, ['category'])
])

preprocessed_data = preprocessor.fit_transform(data)

Bonnes pratiques pour le prétraitement des données

Il est essentiel de suivre les meilleures pratiques pour maximiser l'efficacité de vos efforts de prétraitement. Cela dit, voici quelques pratiques que je vous encourage à envisager : 

Comprendre les données

Avant de vous lancer dans le prétraitement, il est important de bien comprendre l'ensemble de données. Effectuez une analyse exploratoire des données afin d'identifier la structure des données en question. Ce que vous voulez comprendre en particulier, c'est ce qui suit : 

  • Caractéristiques principales 
  • Anomalies potentielles
  • Les relations 

Si vous ne comprenez pas d'abord les caractéristiques de l'ensemble de données, il est fort probable que vous appliquiez des méthodes de prétraitement incorrectes, ce qui faussera les données. 

Automatiser les étapes répétitives

Le prétraitement implique souvent des tâches répétitives. L'automatisation de ces tâches par la création de pipelines garantit la cohérence et l'efficacité et réduit les risques d'erreurs manuelles. Pour rationaliser les flux de travail, tirez parti des pipelines dans des outils comme scikit-learn ou des plateformes basées sur le cloud.

Étapes du prétraitement des documents

Une documentation claire permet d'atteindre deux objectifs :

  • Reproductibilité
  • Comprendre (pour vous-même à une date ultérieure ou pour d'autres membres de votre équipe).

Chaque décision, transformation ou étape de filtrage doit être enregistrée, y compris son raisonnement. Cela améliorera considérablement la collaboration entre les membres de l'équipe et vous aidera à reprendre les projets là où vous les avez laissés. 

Améliorations itératives

Le prétraitement des données n'est pas une tâche ponctuelle - il doit s'agir d'un processus itératif. Au fur et à mesure que les modèles évoluent et fournissent un retour d'information sur leurs performances, utilisez ces informations pour revoir et affiner les étapes de prétraitement, car elles peuvent conduire à de meilleurs résultats. Par exemple, l'ingénierie des caractéristiques peut révéler de nouvelles caractéristiques utiles, ou le traitement des valeurs aberrantes peut améliorer la précision du modèle - utilisez ce retour d'information pour mettre à jour vos étapes de prétraitement. 

Conclusion

Le prétraitement des données joue un rôle essentiel dans la réussite de tout projet de données. Un prétraitement adéquat garantit que les données brutes sont transformées en un format propre et structuré, ce qui permet aux modèles et aux analyses de produire des informations plus précises et plus significatives. 

Dans cet article, j'ai présenté plusieurs techniques permettant de mettre en œuvre le prétraitement des données. Cependant, la chose la plus importante à noter est que ce processus n'est pas un effort ponctuel mais un processus itératif ! L'affinement continu permet d'améliorer les performances du modèle et de prendre de meilleures décisions. Un ensemble de données bien préparé constitue la base de toute initiative réussie en matière d'IA des données.

Pour poursuivre votre apprentissage, je vous recommande de consulter les excellentes ressources suivantes :

Devenez un scientifique ML

Améliorez vos connaissances en Python pour devenir un scientifique spécialisé dans l'apprentissage automatique.

Kurtis Pykes 's photo
Author
Kurtis Pykes
LinkedIn
Sujets

Apprenez-en plus sur l'ingénierie des données avec ces cours !

Certification disponible

cours

Introduction à l'ingénierie des données

4 hr
115.8K
Découvrez le monde de l'ingénierie des données dans ce cours de courte durée, couvrant des outils et des sujets tels que l'ETL et le cloud computing.
Afficher les détailsRight Arrow
Commencer le cours
Voir plusRight Arrow