Datascience avec Python - Prétraitement des données - Part. 1

Cet article est la suite des articles sur la datascience avec Python, n'hésitez pas à aller voir les autres si jamais ce n'est pas encore fait afin de tout comprendre.

Aujourd'hui, nous allons voir comment traiter des données brutes afin de les rendre exploitables par un modèle de machine learning. C'est une étape essentielle à la résolution d'un problème de datascience.

Importation des données

Evidemment, avant toute manipulation sur les données, il faut les importer. Commençons par importer les librairies dont nous auront besoin. Les voici :

• Numpy : bibliothèque python pour le calcul scientifique, qui permet de travailler avec des tableaux multidimensionnels et de traiter de grandes quantités de données. Un tableau, qui est une grille de valeurs et est indexé par un tuple d'entiers non négatifs, est la principale structure de données de la bibliothèque Numpy.
• Pandas : package Python open source utilisé pour la manipulation de données, l'analyse et les tâches de machine learning.
• Matplotlib : package Pyton utilisé pour afficher des graphiques en deux dimensions.
• Scikit learn : Il s'agit d'une bibliothèque (écrite en grande partie en Python, basée sur NumPy, SciPy et Matplotlib) pour l'apprentissage automatique qui fournit des outils efficaces pour la modélisation machine learning et statistique, notamment la classification, la régression, le regroupement et la réduction de la dimensionnalité, etc...

import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn import datasets

Bien, maintenant on peut importer nos données. Si vous avez suivi la série, vous savez comment faire ceci avec Pandas.

dataset = pd.read_csv('data.csv')

Au niveau des données à utiliser, si vous avez vos propres données prenez celles-ci, sinon vous trouverez des exemples dans les ressources.

Gérer les valeurs manquantes

Certains des plus gros problèmes pouvant se poser à vous lors de la résolution d'un problème de machine learning, sont les données manquantes, aberrantes, corrompues, etc...

En effet, elles posent problème car elles affectent la précision. Pour les gérer, on peut s'en débarrasser, les moyenner, etc...

Pour s'en débarrasser, on utilise df.dropna comme vu dans les articles précédents. Pour les moyenner, on utilise quelque chose de nouveau, un Imputer.

imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(dataset)
dataset = imputer.transform(dataset)

On commence par créer un Imputer en lui passant en paramètres la forme de nos valeurs manquantes, et la stratégie à utiliser pour les remplacer. On le fait correspondre à notre dataset. On transforme notre dataset en utilisant l'Imputer qui remplace les valeurs manquantes. Cela nous renvoie un array Numpy.

Encodage de données

Pour comprendre cette partie, il faut comprendre la distinction entre des données quantitatvies et des données qualitatives. Si on vous demande votre âge, ou votre taille, ce sont des données quantitatives car vous pouvez les décrire avec des valeurs numériques. Si on vous demande par contre votre statut marital ou votre genre, ce sont des valeurs textuelles donc qualitatives.

En datascience, on évite de travailler directement avec des valeurs qualitatives. Il faut donc les encoder (de sorte que par exemple votre genre, soit "homme", soit "femme", soit égal à 0 ou 1). Pour cela, on utilise sklearn :

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X = LabelEncoder()
dataset[:, 0] = labelencoder_X.fit_transform(dataset[:, 0])
onehotencoder = OneHotEncoder()
dataset = onehotencoder.fit_transform(dataset).toarray()

On initialise un LabelEncoder qui permet d'encoder des valeurs textuelles. Ensuite, on choisit les valeurs qu'on souhaite encoder (dans l'exemple ce sera la 1ère colone) et on les "fit_transform" donc "fit" + "transform". Ensuite, il faut refaire pareil avec un OneHotEncoder, qui permet de convertir les valeurs en 0, 1, etc... comme évoqué plus haut.

Séparation en ensembles de test/apprentissage

Evidemment, il faut maintenant séparer nos données. Pour cela, on va utiliser train_test_split. Après avoir séparé nos features et nos variables, on peut utiliser cette fonction :

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3)

X_train sont les features d'entraînement, X_test celles pour le test, y_train les variables d'entraînement, et y_test celles de test. test_size est la taille de notre ensemble de test (ici 30% des valeurs).

Normalisation/Standardisation des données

Maintenant nous allons normaliser nos données. Cette étape esssentielle, car elle permet de ramener toutes les données au même poids. Par exemple, si nous normalisons nos donnés sur [0;1], cela signifie que toutes nos données auront une valeur comprise entre 0 et 1. Donc par exemple la taille d'un individu qui de base pouvait être entre 0cm et 250cm sera maintenant entre 0 et 1, tout comme le poids qui de base était entre 0 et 300kg. Bien sûr, la normalisation garde les proportions entre les données, par exemple pour la taille, 0.1 correspondra à 25cm tandis que 0.5 correspondra à 125cm.

Cela se fait simplement avec sklearn :

from sklearn.preprocessing import StandardScaler 
ss_X = StandardScaler() 
X_train = ss_X.fit_transform(X_train) 
X_test = ss_X.transform(X_test) 

Le mot de la fin

Bien, nous avons déjà pas mal avancé, mais il reste des choses à voir ! Pour cela, on se retrouve prochainement pour la suite de cette série !

Si jamais il y a quelque chose que vous n'avez pas compris, ou que vous souhaitez me faire un retour par rapport à l'article, n'hésitez pas à me contacter ou à laisser un commentaire.

On se retrouve prochainement pour la suite de votre apprentissage de la datascience !