Machine Learning

Présentation

Le prétraitement des données est un processus de préparation des données brutes et de leur adaptation à un modèle d'apprentissage automatique. C'est la première étape cruciale lors de la création d'un modèle d'apprentissage automatique.

Lors de la création d'un projet d'apprentissage automatique, nous ne rencontrons pas toujours des données propres et formatées. Et lors de toute opération avec des données, il est obligatoire de les nettoyer et de les mettre en forme.

Une donnée de la vrais vie contient généralement des bruits, des valeurs manquantes et peut-être dans un format inutilisable. Le prétraitement des données est une tâche requise pour nettoyer les données et les adapter à un modèle d'apprentissage automatique, ce qui augmente également la précision et l'efficacité d'un modèle d'apprentissage automatique.


Récupérer l'ensemble de données

Pour créer un modèle d'apprentissage automatique, la première chose dont nous avons besoin est un ensemble de données, car un modèle d'apprentissage automatique fonctionne entièrement sur les données.
L'ensemble de données peut être de différents formats selon les objectifs, par exemple, si nous voulons créer un modèle d'apprentissage automatique à des fins commerciales, l'ensemble de données sera différent avec celui requis pour un patient atteint de la Covid 19.


Importer les bibliothèques

Afin d'effectuer le prétraitement des données à l'aide de Python, nous devons importer certaines bibliothèques prédéfinies. Ces bibliothèques sont utilisées pour effectuer certaines tâches spécifiques. Il existe trois bibliothèques spécifiques que nous utiliserons pour le prétraitement des données, à savoir :

Numpy : la bibliothèque Numpy est utilisée pour inclure tout type d'opération mathématique. C'est le package fondamental pour le calcul scientifique en Python. Il prend également en charge l'ajout de grands tableaux et matrices multidimensionnels.

Matplotlib : la deuxième bibliothèque est matplotlib, qui est une bibliothèque de graphiques Python 2D, et avec cette bibliothèque, nous devons importer une sous-bibliothèque pyplot.

Pandas : la dernière bibliothèque est la bibliothèque Pandas, qui est l'une des bibliothèques Python les plus connues et utilisée pour importer et gérer les ensembles de données.


Créer un notebook avec Visual Studio Code

Voir mon billet :
Comment créer un environnement de Machine Learning ?
https://www.developpez.net/forums/bl...hine-learning/

Voici le début du code dans la 1ère cellule du notebook :

# -*- coding: utf-8 -*-
"""
@author: Rhona
"""
# Prétraitement des données

# Importer les bibliothèques
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd


Créer le jeu de données

Copier les données ci-dessous dans un fichier Data.csv dans le même répertoire que votre notebook :

Country,Age,Salary,Purchased
France,44,72000,No
Spain,27,48000,Yes
Germany,30,54000,No
Spain,38,61000,No
Germany,40,,Yes
France,35,58000,Yes
Spain,,52000,No
France,48,79000,Yes
Germany,50,83000,No
France,37,67000,Yes


Créer un DataSet Panda à partir d'un CSV

Utiliser la fonction read_csv() de la bibliothèque pandas, pour effectuer diverses opérations sur un fichier csv (ou bien à partir d'une URL) :

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


Extraction des variables dépendantes et indépendantes

En apprentissage automatique, il est important de distinguer la matrice des caractéristiques (variables indépendantes) et les variables dépendantes de l'ensemble de données. Dans notre ensemble de données, il y a trois variables indépendantes qui sont le pays (Country(, l'âge (Age) et le salaire (Salary), et une qui est une variable dépendante nommée "a acheté" (Purchased).

Pour extraire une variable indépendante, nous utiliserons la méthode iloc[ ] de la librairie Pandas. Il est utilisé pour extraire les lignes et les colonnes requises de l'ensemble de données.

X = dataset.iloc[:, :-1].values
print(X)

Le premier deux-points est utilisé pour prendre toutes les lignes et le deuxième deux-points est pour toutes les colonnes. Ici, nous avons utilisé :-1, car nous ne voulons pas prendre la dernière colonne car elle contient la variable dépendante. Donc, en faisant cela, nous obtiendrons la matrice des fonctionnalités.

Résultat :

[['France' 44.0 72000.0]
['Spain' 27.0 48000.0]
['Germany' 30.0 54000.0]
['Spain' 38.0 61000.0]
['Germany' 40.0 nan]
['France' 35.0 58000.0]
['Spain' nan 52000.0]
['France' 48.0 79000.0]
['Germany' 50.0 83000.0]
['France' 37.0 67000.0]]

Remarque : pour la ligne en rouge, l'age n'est pas renseigné, ce qui fausse l'apprentissage. Dans ce qui suit, on remplacera la valeur manquante par la moyenne de la colonne.

Pour extraire les variables dépendantes, encore une fois, nous utiliserons la méthode Pandas .iloc[].

y = dataset.iloc[:, 3].values
print(y)

Ici, nous avons pris toutes les lignes avec la dernière colonne uniquement. Cela donnera le tableau des variables dépendantes.

Résultat :

['No' 'Yes' 'No' 'No' 'Yes' 'Yes' 'No' 'Yes' 'No' 'Yes']


Traitement des données manquantes

La prochaine étape du prétraitement des données consiste à gérer les données manquantes dans les ensembles de données. Si notre ensemble de données contient des données manquantes, cela peut créer un problème pour notre modèle d'apprentissage automatique.

Il existe principalement deux façons de gérer les données manquantes, à savoir :

1. En supprimant la ligne particulière : cette méthode est utilisée pour traiter couramment les valeurs nulles. De cette façon, nous supprimons simplement la ligne ou la colonne spécifique qui se compose de valeurs nulles. Mais cette méthode n'est pas aussi efficace et la suppression de données peut entraîner une perte d'informations qui ne donnera pas une sortie précise.
2. En calculant la moyenne : de cette manière, nous calculerons la moyenne de cette colonne ou ligne qui contient une valeur manquante et la placerons à la place de la valeur manquante. Cette stratégie est utile pour les fonctionnalités qui ont des données numériques telles que l'âge, le salaire, l'année, etc. Ici, nous utiliserons cette approche.

Pour gérer les valeurs manquantes, nous utiliserons la bibliothèque scikit-learn, qui contient diverses bibliothèques pour créer des modèles d'apprentissage automatique. Ici, nous utiliserons la classe SimpleImputer de la bibliothèque sklearn.impute. Ci-dessous le code.

# Pour traiter les données manquantes
from sklearn.impute import SimpleImputer

# Créer l'objet de la classe Imputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')

# Adapter l'objet imputer aux données X (Matrice de la caractéristique X)
imputer = imputer.fit(X[:, 1:3])

# Remplacer les données manquantes de la colonne par la moyenne
X[:, 1:3] = imputer.transform(X[:, 1:3])
print(X)

Résultat :

[['France' 44.0 72000.0]
['Spain' 27.0 48000.0]
['Germany' 30.0 54000.0]
['Spain' 38.0 61000.0]
['Germany' 40.0 63777.77777777778]
['France' 35.0 58000.0]
['Spain' 38.77777777777778 52000.0]
['France' 48.0 79000.0]
['Germany' 50.0 83000.0] ['France' 37.0 67000.0]]

La valeur manquante "nan" a été remplacée par la moyenne de la colonne 38.77...


Codage des données catégorielles

Les données catégorielles sont des données qui représentent certaines catégories telles que, dans notre ensemble de données ; il existe deux variables de catégorie, Pays et Acheté.

Étant donné que le modèle d'apprentissage automatique fonctionne entièrement sur les mathématiques et les nombres, mais si notre ensemble de données avait une variable catégorielle non numérique, cela pourrait créer des problèmes lors de la construction du modèle. Il est donc nécessaire d'encoder ces variables catégorielles en nombres.

Dans un premier temps, nous allons convertir les variables pays en données catégorielles. Donc, pour ce faire, nous utiliserons la classe LabelEncoder() de la bibliothèque sklearn.preprocessing.

# Encodage des données catégorielles
# Création de variables factices à l'aide de la classe LabelEncoder
from sklearn.preprocessing import LabelEncoder

# Création de l'objet de la classe LabelEncoder
labelencoder_X = LabelEncoder()

# adapter l'objet labelencoder_X à la colonne Pays de la matrice X
X[:, 0] = labelencoder_X.fit_transform(X[:, 0])
print(X)



Résultat :
[[0 44.0 72000.0] [2 27.0 48000.0] [1 30.0 54000.0] [2 38.0 61000.0]
... [2 38.77777777777778 52000.0] [0 48.0 79000.0] [1 50.0 83000.0] [0 37.0 67000.0]]


Dans le code ci-dessus, nous avons importé la classe LabelEncoder de la bibliothèque sklearn. Cette classe a codé avec succès les variables en chiffres.
Mais dans notre cas, il y a trois variables de pays, et comme nous pouvons le voir dans la sortie ci-dessus, ces variables sont codées en 0, 1 et 2.
Par ces valeurs, le modèle d'apprentissage automatique peut supposer qu'il existe une certaine corrélation entre ces variables qui produiront la mauvaise sortie. Donc, pour supprimer ce problème, nous utiliserons un encodage factice.


Encodage factice

Les variables factices sont les variables qui ont les valeurs 0 ou 1. La valeur 1 donne la présence de cette variable dans une colonne particulière, et les variables restantes deviennent 0. Avec l'encodage factice, nous aurons un nombre de colonnes égal au nombre de catégories.
Dans notre ensemble de données, nous avons 3 catégories, il produira donc trois colonnes ayant des valeurs 0 et 1. Nous utiliserons la classe OneHotEncoder et ColumnTransformer.

# Créer les variables factices
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# Créer l'objet de la classe ColumnTransformer
ct = ColumnTransformer([("Country", OneHotEncoder(), [0])], remainder = 'passthrough')

# Adapter l'objet onehotencoder à la première colonne - Pays de la matrice X
X = ct.fit_transform(X)
print(X)

Résultat :

[[1.0 0.0 0.0 44.0 72000.0]
[0.0 0.0 1.0 27.0 48000.0]
[0.0 1.0 0.0 30.0 54000.0]
[0.0 0.0 1.0 38.0 61000.0]
[0.0 1.0 0.0 40.0 63777.77777777778]
[1.0 0.0 0.0 35.0 58000.0]
[0.0 0.0 1.0 38.77777777777778 52000.0]
[1.0 0.0 0.0 48.0 79000.0]
[0.0 1.0 0.0 50.0 83000.0]
[1.0 0.0 0.0 37.0 67000.0]]

Comme nous pouvons le voir dans la sortie ci-dessus, toutes les variables sont codées en nombres 0 et 1 et divisées en trois colonnes.


Pour la variable "Acheté" (Purchased)

# Créer l'objet de la classe LabelEncoder
labelencoder_y = LabelEncoder()

# adapter l'objet labelencoder_y à la colonne "Purchased", nous obtiendrons un vecteur encodé
y = labelencoder_y.fit_transform(y)

Pour la deuxième variable catégorielle, nous n'utiliserons que l'objet labelencoder de la classe LableEncoder. Ici nous n'utilisons pas la classe OneHotEncoder car la variable achetée n'a que deux catégories oui ou non, et qui sont automatiquement encodées en 0 et 1.


Fractionnement de l'ensemble de données en un ensemble d'apprentissage et en ensemble de test

Dans le prétraitement des données d'apprentissage automatique, nous divisons notre ensemble de données en un ensemble d'apprentissage et un ensemble de test. C'est l'une des étapes cruciales du prétraitement des données car, ce faisant, nous pouvons améliorer les performances de notre modèle d'apprentissage automatique.

Supposons que nous ayons entraîné notre modèle d'apprentissage automatique par un ensemble de données et que nous le testions par un ensemble de données complètement différent, cela créera des difficultés pour notre modèle de d'interpêter les corrélations entre les modèles.
Nous essayons donc toujours de créer un modèle d'apprentissage automatique qui fonctionne bien avec l'ensemble d'apprentissage et également avec l'ensemble de données de test.

• Ensemble d'entraînement (X_train, y_train) : un sous-ensemble d'ensemble de données pour entraîner le modèle d'apprentissage automatique, et nous connaissons déjà la sortie.
• Ensemble de test (X_test, y_test) : un sous-ensemble d'ensemble de données pour tester le modèle d'apprentissage automatique et, en utilisant l'ensemble de test, le modèle prédit la sortie.

Pour diviser l'ensemble de données, nous utiliserons les lignes de code ci-dessous :

#Diviser le dataset en un ensemble d'apprentissage et un autre de test
from sklearn.model_selection import train_test_split

#Prendre 20 % pour les tests
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

Dans le code ci-dessus, la première ligne est utilisée pour diviser les tableaux de l'ensemble de données en sous-ensembles de train et de test aléatoires.
Dans la deuxième ligne, nous avons utilisé quatre variables pour notre sortie qui sont

• X_train : fonctionnalités pour les données d'entraînement
• X_test : fonctionnalités pour tester les données
• y_train : variables dépendantes pour les données d'entraînement
• y_test : variable indépendante pour tester les données

Dans la fonction train_test_split(), nous avons passé quatre paramètres dans lesquels les deux premiers sont pour les tableaux de données, et test_size est pour spécifier la taille de l'ensemble de test, ici 20 % du jeu de données.
Le dernier paramètre random_state est utilisé pour initialiser un générateur aléatoire afin que vous obteniez toujours le même résultat, et la valeur la plus utilisée pour cela est 0.


Mise à l'échelle des fonctionnalités

La mise à l'échelle des fonctionnalités est la dernière étape du prétraitement des données dans l'apprentissage automatique. C'est une technique pour normaliser les variables indépendantes de l'ensemble de données dans une plage spécifique. Dans la mise à l'échelle des fonctionnalités, nous plaçons nos variables dans la même plage et dans la même échelle afin qu'aucune variable ne domine une autre.

Comme nous pouvons le voir, les valeurs des colonnes âge et salaire ne sont pas sur la même échelle. Un modèle d'apprentissage automatique est basé sur la distance euclidienne, et si nous ne mettons pas à l'échelle la variable, cela causera un problème dans notre modèle d'apprentissage automatique.

Ici, nous utiliserons la méthode de standardisation pour notre jeu de données.

Pour la mise à l'échelle des fonctionnalités, nous importerons la classe StandardScaler de la bibliothèque sklearn.preprocessing :

from sklearn.preprocessing import StandardScaler

Maintenant, nous allons créer l'objet de la classe StandardScaler pour les variables indépendantes ou les fonctionnalités.
Ensuite, nous ajusterons et transformerons l'ensemble de données d'entraînement.

sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)

Pour l'ensemble de données de test, nous appliquerons directement la fonction transform() au lieu de fit_transform() car cela est déjà fait dans l'ensemble d'apprentissage.

X_test = sc_X.transform(X_test)

Résultat pour X_train

[[-1. 2.64575131 -0.77459667 0.26306757 0.12381479]
[ 1. -0.37796447 -0.77459667 -0.25350148 0.46175632]
[-1. -0.37796447 1.29099445 -1.97539832 -1.53093341]
[-1. -0.37796447 1.29099445 0.05261351 -1.11141978]
[ 1. -0.37796447 -0.77459667 1.64058505 1.7202972 ]
[-1. -0.37796447 1.29099445 -0.0813118 -0.16751412]
[ 1. -0.37796447 -0.77459667 0.95182631 0.98614835]
[ 1. -0.37796447 -0.77459667 -0.59788085 -0.48214934]]

Résultat pour X_test :

[[-1. 2.64575131 -0.77459667 -1.45882927 -0.90166297]
[-1. 2.64575131 -0.77459667 1.98496442 2.13981082]]

Comme nous pouvons le voir dans les résultats ci-dessus, toutes les variables sont mises à l'échelle entre les valeurs -1 à 1.

Remarque : Ici, nous n'avons pas mis à l'échelle la variable dépendante car il n'y a que deux valeurs 0 et 1. Mais si ces variables ont une plus grande plage de valeurs, nous devrons également les mettre à l'échelle.

Rhona Maxwel
https://www.urbanisation-si.com/
@rhona_helena

"La question est de savoir si l’acte de penser finira par s’intégrer dans l’engrenage du traitement de l’information" Martin Heidegger