TP Fouille de données (Data Mining) et Apprentissage Machine

DataMining et Apprentissage Machine ISAEG – 2020 Master Pro. DATA SCIENCE
Enseignant : KHMILI Boubaker 1
TP Combiné : TP 2 et 3
 Importation et Exploration des données (TP 2)
 Modélisation prédictive en utilisant l’apprentissage machine : Régression
linéaire, Arbre de décision et Forêt d'arbres décisionnels (TP 3)
1. Package utile à installer pour ce TP
Sur environ 7800 packages répertoriés sur CRAN, les packages les plus couramment utilisés
dans la modélisation prédictive sont :
Pour l’importation de données : R propose une large gamme de packages pour l'importation
de données disponibles dans tous les formats tels que .txt, .csv, .json, .sql etc. Pour importer
rapidement de gros fichiers de données, il est conseillé d'installer et d'utiliser data.table, readr,
RMySQL, sqldf, jsonlite.
Pour la visualisation des données : R a également intégré des commandes de traçage. Ils sont
bons pour créer des graphiques simples. Mais, devient complexe quand il s'agit de créer des
graphiques avancés. Par conséquent, vous devez installer ggplot2.
Pour la manipulation des données : R possède une collection de packages pour la
manipulation des données. Ces packages vous permettent d'effectuer rapidement des calculs de
base et avancés. Ces packages sont dplyr, plyr, tidyr, lubridate, stringr.
Pour la modélisation / Apprentissage machine : Pour la modélisation, le package caret dans
R est puissant pour répondre à tous les besoins de création de modèle d'apprentissage machine.
Cependant, vous pouvez installer des algorithmes de packages tels que randomForest, rpart,
gbm, etc.
2. Objectif de ce TP et Dataset (Base de données) utilisé
Le Dataset pour ce TP sera les données de vente de l’année 2013 de BigMart pour 1559 produits
dans 10 magasins dans différentes villes.

L'objectif est de construire un modèle prédictif et de connaître les ventes de chaque produit
dans un magasin particulier.
En utilisant ce modèle, BigMart tentera de comprendre les propriétés des produits et des
magasins qui jouent un rôle clé dans l'augmentation des ventes.
L'apprentissage machine comporte généralement deux phases. La première est dite «
d'apprentissage » ou « d'entraînement ». La seconde phase correspond à la mise en production
: le modèle étant déterminé, de nouvelles données peuvent alors être soumises afin d'obtenir le
résultat correspondant à la tâche souhaitée.
Pour ce TP, les variables (observations) d’entrainement (phase I) sont composées de 8523
observations ayant chacune 12 attributs. Les observations de test (phase II) sont composées de
5681 lignes et 11 colonnes.
3. Etape 1 : Importation des données dans R
Variables de prédiction
Variablederéponse

L'exploration des données est une étape cruciale du modèle prédictif. Vous ne pouvez pas créer
de modèles efficaces et pratiques à moins d'apprendre à explorer les données du début à la fin.
Cette étape constitue une base concrète pour la manipulation des données Comprenons-le dans
R.
Suivez-ces étapes pour importer et explorer les données d’entrainement et de test :
Il est conseillé que vous conservez les fichiers « train » et « test » dans votre répertoire de travail
directement pour éviter les problèmes de répertoire inutiles. Une fois le répertoire défini, nous
pouvons facilement importer les fichiers .csv à l'aide des commandes ci-dessous.
#Chargement des Datasets
train <- read.csv("Train.csv")
test <- read.csv("Test.csv")
Si tout s’est bien déroulé, les « datas » suivant seront ajoutés à votre espace de travail :
4. Etape 2 : Exploration (rapide) des données
Vérifierons les dimensions dans l'ensemble de données :
> dim(train)
> dim(test)
Vérifions les variables et leurs types en « train » :
> str(train)
Vérifions si des données ont des valeurs manquantes :
> table(is.na(train))

D’après la commande « table(is.na(train)) », nous avons 1463 valeurs manquantes. Vérifions
les variables dans lesquelles ces valeurs manquent. Il est important de rechercher et de localiser
ces valeurs manquantes. De nombreux scientifiques des données ont conseillé à plusieurs
reprises de porter une attention particulière à la valeur manquante dans les étapes d'exploration
des données :
> colSums(is.na(train))
Par conséquent, nous voyons que la colonne Item_Weight a 1463 valeurs manquantes.
Obtenons plus d'inférences à partir de ces données :
> summary(train)
Interpréter les résultats.
5. Etape 3 (optionnel) : Représentation graphique des données
La compréhension des variables est mieux visuellement que concrètement.
À l'aide de graphiques, nous pouvons analyser les données de 2 façons : analyse univariée et
analyse bivariée.
L'analyse univariée est effectuée avec une variable. L'analyse bivariée se fait avec deux
variables. L'analyse univariée est facile à faire. Par conséquent, on sautera cette partie dans ce
TP. Je vous recommande de l'essayer de votre côté.
Essayons maintenant de faire une analyse bivariée et de découvrir des informations cachées.
Pour la visualisation, on utilisera le package ggplot2. Ces graphiques nous aideraient à
comprendre la distribution et la fréquence des variables dans l'ensemble de données.
> ggplot(train, aes(x= Item_Visibility, y = Item_Outlet_Sales)) + geom_point(size =
2.5, color="navy") + xlab("Item Visibility") + ylab("Item Outlet Sales") +
ggtitle("Item Visibility vs Item Outlet Sales")

On constate que la majorité des ventes a été réalisée à partir de produits ayant une visibilité
inférieure à 0,2. Cela suggère qu’item_visibility <2 doit être un facteur important dans la
détermination des ventes.
Trouvons quelques graphiques plus intéressants et explorons ces informations cachées.
> ggplot(train, aes(Outlet_Identifier, Item_Outlet_Sales)) + geom_bar(stat =
"identity", color = "purple") +theme(axis.text.x = element_text(angle = 70, vjust =
0.5, color = "black")) + ggtitle("Points de vente vs ventes totales") + theme_bw()

Ici, nous en déduisons que le point de vente OUT027 a contribué à la majorité des ventes, suivi
de OUT35. OUT10 et OUT19 ont probablement le moins de fréquentation, contribuant ainsi
aux ventes de points de vente le moins.
> ggplot(train, aes(Item_Type, Item_Outlet_Sales)) + geom_bar( stat = "identity")
+theme(axis.text.x = element_text(angle = 70, vjust = 0.5, color = "navy")) +
xlab("Type d’article ") + ylab("Vente en magasin ")+ggtitle("Type d'article vs ventes
")
À partir de ce graphique, nous pouvons déduire que les fruits et légumes contribuent au plus
grand nombre de ventes en magasin, suivis des grignotines et des produits ménagers.
6. Etape 5 : Correction des données manquantes
Maintenant, nous avons une idée des variables et de leur importance sur la variable de réponse.
Revenons maintenant à notre point de départ : Valeurs manquantes. Nous allons maintenant
imputer les valeurs manquantes.
Nous avons vu que la variable Item_Weight avait des valeurs manquantes. Item_Weight est une
variable continue. Par conséquent, dans ce cas, nous pouvons imputer les valeurs manquantes
avec la moyenne / médiane d’item_weight. Ce sont les méthodes les plus couramment utilisées
pour imputer la valeur manquante.

Commençons par combiner les ensembles de données : Train et Test. Cela nous fera gagner du
temps car nous n'avons pas besoin d'écrire des codes distincts pour le « train » et « Test ». Pour
combiner les deux trames de données, il faut s'assurer qu'elles ont des colonnes égales, ce qui
n'est pas le cas.
> test$Item_Outlet_Sales <- 1
> combi <- rbind(train, test)
Imputez la valeur manquante par la médiane. On utilise la médiane car elle est connue pour être
très résistante aux valeurs aberrantes ( une observation qui est « distante » des autres
observations ).
> combi$Item_Weight[is.na(combi$Item_Weight)] <- median(combi$Item_Weight, na.rm =
TRUE)
> table(is.na(combi$Item_Weight))
Nous avons vu aussi que la visibilité des articles a également une valeur nulle, ce qui est
pratiquement impossible. Par conséquent, nous la considérerons comme une valeur manquante
et effectuerons à nouveau l'imputation en utilisant la médiane.
combi$Item_Visibility <- ifelse(combi$Item_Visibility == 0,
median(combi$Item_Visibility), combi$Item_Visibility)
Il est important d'apprendre à traiter séparément les variables quantitatives continues et
qualitatives dans un ensemble de données. En d'autres termes, elles nécessitent une attention
particulière. Dans cet ensemble de données, nous n'avons que 3 variables continues et le reste
est de nature catégorique.
> levels(combi$Outlet_Size)[1] <- "Other"
> library(plyr)
> combi$Item_Fat_Content <- revalue(combi$Item_Fat_Content,
c("LF" = "Low Fat", "reg" = "Regular"))
> combi$Item_Fat_Content <- revalue(combi$Item_Fat_Content, c("low fat" = "Low
Fat"))
> table(combi$Item_Fat_Content)
7. Etape 6 : Modélisation prédictive à l'aide du Machine Learning
Essayons de créer notre modèle de régression complet pour notre problème :

#Charger les données
> train <- read.csv("train_Big.csv")
> test <- read.csv("test_Big.csv")
# créer une nouvelle variable dans le fichier de test
> test$Item_Outlet_Sales <- 1
# combiner les données de train et de test
> combi <- rbind(train, test)
# imputer la valeur manquante dans Item_Weight
> combi$Item_Weight[is.na(combi$Item_Weight)] <- median(combi$Item_Weight, na.rm =
TRUE)
# imputer 0 dans item_visibility
> combi$Item_Visibility <- ifelse(combi$Item_Visibility == 0,
median(combi$Item_Visibility), combi$Item_Visibility)
# renommer le niveau dans Outlet_Size
> levels(combi$Outlet_Size)[1] <- "Other"
# renommer les niveaux de Item_Fat_Content
> library(plyr)
> combi$Item_Fat_Content <- revalue(combi$Item_Fat_Content,c("LF" = "Low Fat",
"reg" = "Regular"))
> combi$Item_Fat_Content <- revalue(combi$Item_Fat_Content, c("low fat" = "Low
Fat"))
# créer une nouvelle colonne 2013 - Année
> combi$Year <- 2013 - combi$Outlet_Establishment_Year
# supprimer les variables non requises dans la modélisation
> library(dplyr)
> combi <- select(combi, -c(Item_Identifier, Outlet_Identifier,
Outlet_Establishment_Year))
# diviser l'ensemble de données
> new_train <- combi[1:nrow(train),]
> new_test <- combi[-(1:nrow(train)),]
# régression linéaire
> linear_model <- lm(Item_Outlet_Sales ~ ., data = new_train)
# recapitulation
> summary(linear_model)
Le R² ajusté mesure la qualité de l'ajustement d'un modèle de régression. Plus le R² est élevé,
meilleur est le modèle. Nous avons R² = 0,5621 ce qui nous permet de conclure que notre
modèle est bon.
Question : est-il possible de l’améliorer ?

Examinons le graphique de régression pour découvrir d'autres façons d'améliorer ce modèle.
> par(mfrow=c(2,2))
> plot(linear_model)
Vous pouvez zoomer ces graphiques dans R Studio de votre côté. Tous ces complots ont une
histoire différente à raconter. Mais l'histoire la plus importante est représentée par le
graphique Residuals vs Fitted.
Les valeurs résiduelles sont la différence entre les valeurs de résultat réelles et prévues. Les
valeurs ajustées sont les valeurs prédites. Si vous voyez attentivement, vous le découvrirez
sous la forme d'un graphique en forme d'entonnoir (de droite à gauche). La forme de ce
graphique suggère que notre modèle souffre d'hétéroscédasticité (variance inégale en termes
d'erreur). S'il y avait une variance constante, aucun schéma ne serait visible sur ce graphique.
Une pratique courante pour lutter contre l'hétéroscédasticité consiste à prendre le log de la
variable de réponse. Faisons-le et vérifions si nous pouvons encore nous améliorer :
> linear_model <- lm(log(Item_Outlet_Sales) ~ ., data = new_train)
> summary(linear_model)
Nous avons un modèle amélioré avec R² = 0,72.

Question : Dresser le graphique de régression. Comparer-le à son ancien.
Ce modèle peut être encore amélioré.
Pour l'instant, vérifions notre RMSE (Root Mean Square Error) afin de pouvoir le comparer
avec les algorithmes qui suivent.
> install.packages("Metrics")
> library(Metrics)
> rmse(new_train$Item_Outlet_Sales, exp(linear_model$fitted.values))
[1] 1140.004
Travail à faire : Faites améliorer encore ce modèle amélioré.
Passons à l'algorithme d'arbre de décision.
Dans R, l'algorithme d'arbre de décision peut être implémenté à l'aide du package rpart. De
plus, nous utiliserons le package caret pour effectuer la validation croisée. La validation croisée
est une technique pour construire des modèles robustes qui ne sont pas sujets au surajustement.
Le surajustement d'un modèle se produit lorsque vous tentez d'estimer trop de paramètres à
partir d'un échantillon de taille trop faible.

Dans R, l'arbre de décision utilise un paramètre de complexité (cp). Il mesure le compromis
entre la complexité du modèle et la précision sur l'ensemble d'apprentissage. Un cp plus petit
conduira à un arbre plus grand, qui pourrait sur-adapter le modèle. Inversement, une grande
valeur de cp pourrait sous-estimer le modèle. Le sous-ajustement se produit lorsque le modèle
ne saisit pas correctement les tendances sous-jacentes.
Découvrons la valeur optimale de cp pour notre modèle avec une validation croisée 5 fois.
# chargement des bibliothèques requises
> library(rpart)
> library(e1071)
> library(rpart.plot)
> library(caret)
# définition des paramètres de contrôle de l'arborescence
> fitControl <- trainControl(method = "cv", number = 5)
> cartGrid <- expand.grid(.cp=(1:50)*0.01)
# arbre de décision
> tree_model <- train(Item_Outlet_Sales ~ ., data = new_train, method = "rpart",
trControl = fitControl, tuneGrid = cartGrid)
> print(tree_model)
Le modèle avec cp = 0,01 a le moins RMSE. Construisons maintenant un arbre de décision
avec 0,01 comme paramètre de complexité.
> main_tree <- rpart(Item_Outlet_Sales ~ ., data = new_train, control =
rpart.control(cp=0.01))
> prp(main_tree)

Si vous avez bien compris les bases, vous comprendrez maintenant que cet algorithme a
marqué Item_MRP comme variable la plus importante (étant le nœud racine). Vérifions le
RMSE de ce modèle et voyons si c'est mieux que la régression :
> pre_score <- predict(main_tree, type = "vector")
> rmse(new_train$Item_Outlet_Sales, pre_score)
Comme vous pouvez le voir, notre RMSE s'est encore amélioré de 1141.023 à 1102,77 avec un
arbre de décision.
Travail à faire : Pour améliorer encore ce score, affiner les paramètres pour une plus
grande précision.
Passons maintenant à l’algorithme suivant.
La forêt d'arbres décisionnels est un algorithme puissant qui prend en charge de manière
systémique les valeurs manquantes, les valeurs aberrantes et autres non-linéarités dans
l'ensemble de données. C’est simplement une collection d’arbres de classification, d’où le nom
de « forêt ».
Dans R, l'algorithme de forêt aléatoire peut être implémenté à l'aide du package randomForest.
Pour ce problème, nous allons nous concentrer sur deux paramètres de forêt aléatoire. mtry et
ntree. ntree est le nombre d'arbres à cultiver dans la forêt. mtry est le nombre de variables prises
à chaque nœud pour construire un arbre. Et nous ferons une validation croisée 5 fois.
# charger la bibliothèque randomForest
> library(randomForest)
# définir les paramètres de réglage
> control <- trainControl(method = "cv", number = 5)
# modèle de forêt aléatoire
> rf_model <- train(Item_Outlet_Sales ~ ., data = new_train, method =
"parRF", trControl = control, prox = TRUE, allowParallel = TRUE)
# vérifier les paramètres optimaux
> print(rf_model)
On a utilisé la méthode = "parRF" (forêt aléatoire parallèle). Il s'agit d'une implémentation
parallèle de forêt aléatoire. Ce package fait que votre machine locale prend moins de temps

dans le calcul de forêt aléatoire. Alternativement, vous pouvez également utiliser method = “rf”
comme une fonction de forêt aléatoire standard.
Nous avons maintenant la valeur optimale de mtry = 15. Utilisons 1000 arbres pour le calcul.
#random forest model
> forest_model <- randomForest(Item_Outlet_Sales ~ ., data = new_train, mtry = 15,
ntree = 1000)
> print(forest_model)
> varImpPlot(forest_model)

TP Fouille de données (Data Mining) et Apprentissage Machine

Contenu connexe

Similaire à TP Fouille de données (Data Mining) et Apprentissage Machine

TP Fouille de données (Data Mining) et Apprentissage Machine