Tutoriel Python: prétraitement des données numériques

Table des matières

Introduction

Le prétraitement des données est une technique d’exploitation de données brutes qui consiste à transformer ces dernières en un format compréhensible. Sachant que les données du monde réel sont dans la plupart des cas incomplètes, incohérentes ou dépourvues de certaines tendances, le prétraitement de celles-ci est une méthode certaine pour résoudre ces problèmes ainsi que de nombreuses erreurs susceptibles d’exister dans ces données.

Des données incomplètes c’est à dire qu’elles manquent de valeurs d’attributs, d’attributs intéressants ou ne contiennent que des données agrégées. Ainsi, avoir des données bruyantes est équivalent à dire que ces données contiennent des erreurs ou des valeurs aberrantes. Enfin, les données incohérentes sont des données contenant des divergences dans les codes ou les noms.

Le prétraitement des données pour l’apprentissage automatique consiste à suivre les étapes suivantes :

Étape 1 : Importation des bibliothèques ;
Étape 2 : Importation de la dataset en question ;
Étape 3 : Vérification des valeurs manquantes ;
Étape 4 : Vérification des valeurs catégorielles ;
Étape 5 : Fractionnement de l’ensemble de données ;
Étape 6 : Mise à l’échelle des caractéristiques.

1. Importation des bibliothèques

Les bibliothèques fondamentales dont on aura besoin sont les suivantes :

Code :

import numpy as np
import pandas as pd

Résultat de l’exécution :

NumPy (Numerical Python) est la première bibliothèque à connaitre si vous utilisez Python pour des domaines qui touchent aux mathématiques. Elle est une extension fondamentale de Python qui permet de faire du calcul scientifique en Python. Cette bibliothèque contient :

L’objet de type tableau à N dimension ;
Des fonctions sophistiquées ;
Des outils pour l’intégration du code C/C++ et Fortran ;
Des utilités d’algèbre linéaire, de transformée de Fourier et de nombres aléatoires.

Pandas est une bibliothèque open source, sous licence BSD, de Python qui permet la manipulation et l’analyse des données à travers des DataFrames qui correspondent à des matrices d’individus qui représentent des observations (lignes) et de variables qui sont des attributs décrivant les individus (colonnes). À partir de ces DataFrames, on peut facilement tracer des graphes à l’aide de la bibliothèque matplotlib.

2. Importation de la dataset

En utilisant la bibliothèque Pandas, on importe la dataset qui est dans l’exemple ci-après sous format CSV. Il n’est pas toujours le cas que ça soit sous ce format, il se peut que l’ensemble de données soit un fichier html, Excel ou Xlsx.

Remarque :

L’utilisation des fichiers de type CSV est dû à leur faible poids.

Exemple 1 :

Nous importons en DataFrame l’ensemble de données « food-consumption » qui est une dataset relative à la consommation de certains produits alimentaires dans les pays européens et scandinaves, les chiffres représentent le pourcentage de la population qui consomme ce type d’aliment.

Et on affiche les cinq premiers enregistrements de cette dataset en utilisant la fonction head(), afin de vérifier rapidement si l’objet contient le bon type de donnée.

Code :

df = pd.read_csv ('C:/Users/LENOVO/Desktop/coursGratuit/food-consumption.csv')
df.head()

Résultat de l’exécution :

3. Vérification des valeurs manquantes

Les valeurs manquantes en statistique sont relatives au cas lorsqu’une variable donnée n’a pas d’observations pour un certain individu. Lors de l’analyse statistique, les valeurs manquantes ne peuvent pas être ignorées. Cependant, si ces données ne sont pas traitées correctement, le chercheur peut tirer des conclusions inexactes sur les données.

Exemple 2 :

Nous affichons ci-dessous le nombre de valeurs manquantes pour chaque colonne de l’ensemble de données.

Code :

df.isnull().sum()

Résultat de l’exécution

Nous nous intéresserons lors de ce tutoriel à deux méthodes jugées les plus importantes pour résoudre le problème des valeurs manquantes :

La première méthode consiste à : soit supprimer une ligne particulière contenant une valeur manquante pour une caractéristique donnée, soit supprimer toute une colonne si elle comporte plus de 75% de valeurs manquantes. Cette méthode est recommandée lorsqu’il y a suffisamment d’échantillons dans la dataset. Il faut s’assurer que la suppression de données n’impactera pas les résultats finaux.
La deuxième méthode s’applique aux éléments contenant les données numériques où les valeurs manquantes peuvent être remplacées par la moyenne, la médiane ou le mode de l’élément en question. Cette méthode donne un meilleur résultat comparant à la première méthode parce qu’il s’agit d’une approximation statistique qui peut ajouter de la variance à l’ensemble de données. On peut aussi approximer avec l’écart des valeurs voisines si les données sont linéaires.

Exemple 3 :

Méthode 1 :

On retourne les dimensions du dataframe df à l’aide de l’attribut de pandas shape.

Code :

df.shape

Résultat de l’exécution :

À l’aide de la fonction dropna(), on supprime toutes les valeurs manquantes de notre ensemble de données. Ensuite, en faisant appel aux deux fonctions isnull() et sum(), on retourne la somme des valeurs manquantes pour chaque colonne et qui est 0 partout !

Finalement, on affiche la dimension de la dataframe qui est différente de la première, car on vient de supprimer les valeurs manquantes de chaque colonne.

Code :

#méthode 1
df.dropna( inplace = True)
df.isnull().sum()

Résultat de l’exécution :

Méthode 2 :

Dans ce qui suit, on calcule la moyenne de la colonne « Biscuits », on affiche cette colonne pour comparer ses valeurs après avoir modifié la valeur manquante par la moyenne des valeurs de la colonne « Biscuits ».

Code :

#méthode 2
df['Biscuits'].mean()
print( df['Biscuits'])
df['Biscuits'].replace( np.NaN, df ['Biscuits'].mean())

Résultat de l’exécution :

Jusqu’à présent, nous avons vu comment traiter des données numériques, l’étape suivante se focalisera sur les données catégorielles.

4. Vérification des valeurs catégorielles

Les modèles d’apprentissage automatique se basent sur des équations mathématiques, alors intuitivement la présence de données catégorielles entrainera un problème car on ne peut garder que des nombres dans les équations. Alorsn ces données catégorielles doivent être codées en données numériques.

Exemple 4 :

Prenons la dataset « iris », le type de l’iris est une donnée catégorielle :

Code :

import numpy as np
import pandas as pd
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/iris_dataset.csv')
df.head()

Résultat de l’exécution :

Pour convertir les données de la colonne « flower » en données numériques, on peut faire appel à la classe LabelEncoder() de la bibliothèque preprocessing.

Après avoir créé une instance de cette classe, on l’ajuste à l’aide de fit_transform() à la colonne « flower » pour qu’elle revoie celle-ci sous format encodée.

Code :

y = df.iloc[ : , 4: ].values
print(y)
from sklearn.preprocessing import LabelEncoder
Label_encoder = LabelEncoder()
y = Label_encoder.fit_transform(y)
print(y)

Résultat de l’exécution :

Maintenant que les données catégorielles sont encodées, un problème se présente : puisque 0

Alors, pour éviter cela, nous utiliserons les Dummies Variables qui sont des variables qui prennent la valeur 0 pour indiquer l’absence d’un effet catégorique pouvant modifier le résultat et 1 pour sa présence.

Exemple 5 :

Nous continuons avec l’exemple de la dataset « iris ». Alors dans ce cas au lieu d’avoir une colonne, nous allons avoir trois.

Méthode 1 :

Pour créer les dummies variables nous ferons appel à la classe OneHotEncoder de la bibliothèque preprocessing.

Code :

from sklearn.preprocessing import OneHotEncoder
Onehotencoder = OneHotEncoder( categories = 'auto')
y = Onehotencoder.fit_transform(y)

Résultat de l’exécution :

Méthode 2 :

Cette deuxième méthode de création des dummies variables consiste à faire appel à la fonction get_dummies() de la bibliothèque Pandas.

Code :

dummy = pd.get_dummies (df ['flower'])
dummy

Résultat de l’exécution :

Maintenant, il ne reste plus qu’à concaténer les deux tableaux et de supprimer la colonne « flower »:

Code :

df = pd.concat( [df, dummy ], axis = 1)
df.drop( ['flower'], axis = 1)

Résultat de l’exécution :

5. Fractionnement de l’ensemble de données

Pour tous les modèles d’apprentissage automatique, qu’ils soient supervisés ou non supervisés, nous allons fractionner l’ensemble de données en deux :

Un ensemble de données d’entrainement : Training.
Un ensemble de données de test.

En général, on divise l’ensemble de données en un rapport 75/25% ou 80/20%, qui signifie que 75% des données sont des données de training et 25% pour les tests. Toutefois, ces répartitions peuvent varier en fonction de la forme et de la taille de la dataset.

Exemple 6 :

On utilise la fonction train_test_split pour fractionner l’ensemble des données en données de train et de test qui sont par défaut à 75/25 %.

Code :

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 0)

Résultat de l’exécution :

6. Mise à l’échelle des caractéristiques

La mise à l’échelle ou la standardisation des caractéristiques est la méthode qui permet de limiter la différence de fourchette des variables pour qu’elles puissent être comparées sur des bases communes.

Exemple 7 :

Voici l’exemple d’un dataset, les variables « Salaire » et « Age » n’ont pas la même échelle ce qui engendrera des problèmes dans les modèles d’apprentissage automatique.

Code :

import numpy as np
import pandas as pd
df = pd.read_excel ('C:/Users/LENOVO/Desktop/coursGratuit/achat.xlsx')
df.head()

Résultat de l’exécution :

Si on prend deux valeurs de ces deux colonnes et on utilise la distance euclidienne, la colonne Salaire sera dominée par celle-ci.

Remarque :

Dans certains cas, les modèles d’apprentissage automatique ne sont pas basés sur la distance euclidienne, mais la mise à l’échelle des caractéristiques permettra à l’algorithme de converger plus rapidement. C’est le cas du modèle d’arbre de décision.

Dans le code suivant, on fait appel à la classe StandardScaler qui permet de standardiser les variables. On crée une instance de celle-ci puis on l’entraine sur notre ensemble de données grâce à la méthodefit_transform().

Résultat : toutes les valeurs sont à la même échelle.

Code :

x = df[['Age', 'Salaire']]
from sklearn.preprocessing import StandardScaler
mise_a_echelle = StandardScaler()
x = mise_a_echelle.fit_transform(x)
print(x)

Résultat de l’exécution :

Le code suivant permet de transformer le tableau contenant les valeurs standardisées des deux variables Salaire et Age en un dataframe, pour ensuite le concaténer avec les données de la dataset. Puis on supprime les deux anciennes colonnes en question.

Code :

dfx = pd.DataFrame(data = x, columns = ['Age2', 'Salaire2'])
df = pd.concat( [df, dfx ], axis = 1)
df = df.drop( ['Age', 'Salaire'], axis = 1)
print(df)

Résultat de l’exécution :

7. Exercices

7.1. Exercice 1

Appliquez les différentes étapes du prétraitement à la dataset suivante :

8. Solution des exercices

8.1. Exercice 1

Cet exercice est une application directe des étapes vues précédemment dans ce tutoriel.

Code :

import numpy as np
import pandas as pd
#import des données
df = pd.read_csv ('C:/Users/LENOVO/Desktop/coursGratuit/pokemon.csv')
#affichage des 5 premiers enregistrements
df.head ()

Résultat de l’exécution :

On affiche les informations relatives à la dataset en utilisant la fonction suivante :

Code :

df.info ()

Résultat de l’exécution :

Pour savoir la somme des valeurs manquantes on procède ainsi :

Code :

df.isnull ().sum ()

Résultat de l’exécution :

Encodage de la colonne Type_1 en dummies variables.

Code :

Df ['Type_1'].unique ()
dummy = pd.get_dummies ( df ['Type_1'])
dummy

Résultat de l’exécution :

Finalement, on standardise les valeurs des colonnes suivantes : Total, HP, Attack, Defense, Height_m, Weight_kg.

Code :

x = df[['Total', 'HP', 'Attack', 'Defense', 'Height_m', 'Weight_kg']]
from sklearn.preprocessing import StandardScaler
mise_a_echelle = StandardScaler ()
x = mise_a_echelle.fit_transform(x)
print(x)

Résultat de l’exécution :

Conclusion

Lors de ce tutoriel, nous avons prêté attention à la préparation des données avant l’application des modèles d’apprentissage automatique. C’est une étape très importante, car elle permet d’éliminer plusieurs problèmes et c’est lors de laquelle qu’une grande partie de la véracité des résultats est établie.

Article publié le 26 Novembre 2020par Imane BENHMIDOU