TP STAT4 : classification de spam par boosting - Hugo COLONNA

TP : classification de spam par boosting

Introduction

# Chargement des packages nécessaires
library(kernlab)   # Pour les données spam
library(adabag)    # Pour AdaBoost

Le chargement a nécessité le package : rpart
Le chargement a nécessité le package : caret
Le chargement a nécessité le package : ggplot2

Attachement du package : ‘ggplot2’

L'objet suivant est masqué depuis ‘package:kernlab’:

    alpha

Le chargement a nécessité le package : lattice
Registered S3 method overwritten by 'data.table':
  method           from
  print.data.table     
Le chargement a nécessité le package : foreach
Le chargement a nécessité le package : doParallel
Le chargement a nécessité le package : iterators
Le chargement a nécessité le package : parallel
Registered S3 method overwritten by 'htmlwidgets':
  method           from         
  print.htmlwidget tools:rstudio

library(gbm)       # Pour Gradient Boosting

Loaded gbm 2.1.9
This version of gbm is no longer under development. Consider transitioning to gbm3, https://github.com/gbm-developers/gbm3

library(xgboost)   # Pour XGBoost
library(caret)     # Pour la gestion des données
library(dplyr)     # Pour la manipulation des données

Attachement du package : ‘dplyr’

L'objet suivant est masqué depuis ‘package:xgboost’:

    slice

Les objets suivants sont masqués depuis ‘package:stats’:

    filter, lag

Les objets suivants sont masqués depuis ‘package:base’:

    intersect, setdiff, setequal, union

library(ggplot2)   # Pour les graphiques

# Pour s'assurer que tout est bien chargé
# sessionInfo()

# Chargement des données spam
# On utilise une fonction spéciale pour charger un ensemble de données appelé "spam" 
# qui se trouve dans un package (ou bibliothèque) nommé "kernlab".
data(spam, package = "kernlab")

# Conversion de la variable cible en facteur
# Dans nos données, il y a une colonne appelée "type" qui nous dit si un email est du spam ou non.
# On convertit cette colonne en "facteur", ce qui signifie que cette colonne 
# contient des catégories (spam ou non-spam) plutôt que des nombres.
spam$type <- as.factor(spam$type)

# Affichage d'un aperçu des données
# On utilise la fonction "head" pour afficher les premières lignes de nos données. 
# Cela nous permet de voir à quoi ressemblent nos données.
head(spam)

# Séparation des données en bases d'apprentissage et de test (80%/20%) en conservant le ratio de spam
# On veut séparer nos données en deux parties : une pour entraîner nos modèles (80%) 
# et une pour tester nos modèles (20%).
# "set.seed(123)" est une commande qui garantit que si quelqu'un d'autre exécute ce code, 
# il obtiendra les mêmes résultats que nous. C'est comme si on utilisait un mot de passe pour la reproductibilité.
set.seed(123)  # Pour la reproductibilité
# On utilise une fonction pour créer des indices de séparation de nos données. 
# La fonction "createDataPartition" prend 80% des données pour l'entraînement et garde le reste pour le test.
trainIndex <- createDataPartition(spam$type, p = 0.8, list = FALSE)
# On crée la base d'apprentissage (80% des données) en utilisant les indices créés précédemment.
trainData <- spam[trainIndex, ]
# On crée la base de test (20% des données) en prenant le reste des données.
testData <- spam[-trainIndex, ]

# Vérification du ratio de spam dans les deux bases
# On utilise la fonction "prop.table" pour vérifier que le pourcentage de spam et de non-spam 
# est à peu près le même dans nos bases d'apprentissage et de test. 
# Cela nous assure que nos données sont bien équilibrées.
prop.table(table(trainData$type))

  nonspam      spam 
0.6059207 0.3940793 

prop.table(table(testData$type))

  nonspam      spam 
0.6060936 0.3939064 

Utilisation de AdaBoost

# Entraînement du modèle AdaBoost avec 10 itérations

# On utilise Sys.time() pour démarrer le chronomètre et mesurer combien de temps
# cela va prendre pour entraîner notre modèle.
start_time <- Sys.time()

set.seed(123)  # Pour la reproductibilité

# On entraîne le modèle AdaBoost.
# boosting() est une fonction qui crée un modèle d'apprentissage supervisé appelé "AdaBoost".
# type ~ . signifie qu'on utilise toutes les colonnes de notre tableau de données (trainData)
# pour prédire la colonne "type".
# data = trainData signifie qu'on utilise les données d'apprentissage.
# mfinal = 10 signifie qu'on va faire 10 itérations, ou 10 cycles d'apprentissage.
adaboost_model <- boosting(type ~ ., data = trainData, mfinal = 10)

# On arrête le chronomètre pour voir combien de temps cela a pris pour entraîner le modèle.
end_time <- Sys.time()
# On calcule la différence entre le temps de fin et le temps de début pour obtenir
# le temps total d'exécution.
adaboost_time_default <- end_time - start_time

# Calcul du taux d'erreur sur la base d'apprentissage

# On utilise predict() pour faire des prédictions sur les données d'apprentissage.
# newdata = trainData signifie qu'on fait des prédictions sur les données d'apprentissage.
train_pred <- predict(adaboost_model, newdata = trainData)
# On calcule le taux d'erreur en comparant les prédictions avec les vraies valeurs.
# train_pred$class contient les prédictions, et trainData$type contient les vraies valeurs.
# On utilise mean() pour calculer la moyenne des différences.
train_error <- mean(train_pred$class != trainData$type)

# Calcul du taux d'erreur sur la base de test

# On utilise predict() pour faire des prédictions sur les données de test.
# newdata = testData signifie qu'on fait des prédictions sur les données de test.
test_pred <- predict(adaboost_model, newdata = testData)
# On calcule le taux d'erreur en comparant les prédictions avec les vraies valeurs.
# test_pred$class contient les prédictions, et testData$type contient les vraies valeurs.
# On utilise mean() pour calculer la moyenne des différences.
test_error <- mean(test_pred$class != testData$type)

# Affichage des résultats

# On affiche le taux d'erreur sur la base d'apprentissage.
train_error

[1] 0.02688756

# Le premier nombre (0.02688756) est le taux d'erreur sur la base d'apprentissage.
# Cela signifie que le modèle a fait une erreur environ 2.69% du temps sur les données d'apprentissage.

# On affiche le taux d'erreur sur la base de test.
test_error

[1] 0.05114255

# Le deuxième nombre (0.05114255) est le taux d'erreur sur la base de test.
# Cela signifie que le modèle a fait une erreur environ 5.11% du temps sur les données de test.

# On affiche le temps total d'exécution pour l'entraînement du modèle.
adaboost_time_default

Time difference of 5.041678 secs

# Le troisième résultat (Time difference of 5.374694 secs) indique que le temps total 
# pour entraîner le modèle AdaBoost avec 10 itérations a été d'environ 5.37 secondes.

# Entraînement du modèle AdaBoost avec jusqu'à 300 itérations

start_time <- Sys.time()  # Démarrage du chronomètre
set.seed(123)  # Pour la reproductibilité
# Création du modèle AdaBoost avec 300 itérations
# mfinal = 300 signifie qu'on fait 300 cycles d'apprentissage
adaboost_model_300 <- boosting(type ~ ., data = trainData, mfinal = 300)

end_time <- Sys.time()  # Arrêt du chronomètre
# Calcul du temps total d'exécution pour entraîner le modèle
adaboost_time_300 <- end_time - start_time

# Suivi des erreurs sur la base d'apprentissage et de test

# errorevol() est une fonction qui suit l'évolution des erreurs au fil des itérations
# Elle retourne les taux d'erreur pour chaque itération
error_evol_train <- errorevol(adaboost_model_300, trainData)
error_evol_test <- errorevol(adaboost_model_300, testData)

# Affichage des résultats

# On prend l'erreur à la 300ème itération pour les données d'apprentissage
train_error_300 <- error_evol_train$error[300]
# On prend l'erreur à la 300ème itération pour les données de test
test_error_300 <- error_evol_test$error[300]

# Affichage du taux d'erreur sur les données d'apprentissage après 300 itérations
train_error_300
# Affichage du taux d'erreur sur les données de test après 300 itérations
test_error_300
# Affichage du temps total d'exécution pour entraîner le modèle avec 300 itérations
adaboost_time_300

# Le premier ensemble de résultats correspond à l'erreur d'apprentissage (0.0005431831) 
# et l'erreur de test (0.03699674) pour le modèle AdaBoost avec 300 itérations sans limitation de profondeur.
# Le temps d'exécution total est de 3.150702 minutes.

# Traçage des courbes d'erreurs

# plot() crée un graphique montrant l'évolution des erreurs
# type = "l" signifie qu'on trace une ligne
# col = "blue" signifie que la ligne est bleue pour les erreurs d'apprentissage
# ylim = c(0, 0.1) définit les limites de l'axe Y de 0 à 0.1 pour une meilleure visualisation
# ylab = "Taux d'erreur" donne un titre à l'axe Y
# xlab = "Nombre d'itérations" donne un titre à l'axe X
# main = "Évolution des erreurs avec AdaBoost (300 itérations)" donne un titre au graphique
plot(error_evol_train$error, type = "l", col = "blue", ylim = c(0, 0.1), 
     ylab = "Taux d'erreur", xlab = "Nombre d'itérations", 
     main = "Évolution des erreurs avec AdaBoost (300 itérations)")
# lines() ajoute une ligne rouge pour les erreurs de test
lines(error_evol_test$error, col = "red")
# legend() ajoute une légende au graphique pour expliquer les couleurs
legend("topright", legend = c("Erreur d'apprentissage", "Erreur de test"), 
       col = c("blue", "red"), lty = 1)

# Entraînement du modèle AdaBoost avec jusqu'à 300 itérations et limitation de la profondeur des arbres à 3

start_time <- Sys.time()
set.seed(123)
# Création du modèle AdaBoost avec 300 itérations et profondeur limitée
# control = rpart.control(maxdepth = 3) signifie qu'on limite la profondeur des arbres à 3
adaboost_model_depth3 <- boosting(type ~ ., data = trainData, mfinal = 300, 
                                  control = rpart.control(maxdepth = 3))

end_time <- Sys.time()
adaboost_time_depth3 <- end_time - start_time

# Suivi des erreurs sur la base d'apprentissage et de test avec limitation de profondeur

# Suivi des erreurs pour le modèle avec profondeur limitée
error_evol_train_depth3 <- errorevol(adaboost_model_depth3, trainData)
error_evol_test_depth3 <- errorevol(adaboost_model_depth3, testData)

# Affichage des résultats

# Erreur d'apprentissage après 300 itérations avec profondeur limitée
train_error_depth3 <- error_evol_train_depth3$error[300]
# Erreur de test après 300 itérations avec profondeur limitée
test_error_depth3 <- error_evol_test_depth3$error[300]

# Affichage des erreurs
train_error_depth3
test_error_depth3
adaboost_time_depth3

# Le deuxième ensemble de résultats correspond à l'erreur d'apprentissage (0.04019555) 
# et l'erreur de test (0.05223069) pour le modèle AdaBoost avec 300 itérations et une profondeur limitée à 3.
# Le temps d'exécution total est de 49.57228 secondes.

# Traçage des courbes d'erreurs avec limitation de profondeur

# Création du graphique pour le modèle avec profondeur limitée
plot(error_evol_train_depth3$error, type = "l", col = "blue", ylim = c(0, 0.1), 
     ylab = "Taux d'erreur", xlab = "Nombre d'itérations", 
     main = "Évolution des erreurs avec AdaBoost (300 itérations, profondeur limitée)")
# Ajout de la ligne rouge pour les erreurs de test
lines(error_evol_test_depth3$error, col = "red")
# Ajout de la légende pour expliquer les couleurs
legend("topright", legend = c("Erreur d'apprentissage (profondeur limitée)", 
       "Erreur de test (profondeur limitée)"), col = c("blue", "red"), lty = 1)

# Les graphiques montrent l'évolution des erreurs d'apprentissage et de test 
# au fil des 300 itérations. Les deux courbes permettent de visualiser 
# comment les erreurs diminuent au fur et à mesure que le modèle apprend.
#Le premier graphique illustre l'évolution des erreurs d'apprentissage et de test pour le modèle AdaBoost sur 300 itérations. On observe que l'erreur d'apprentissage (courbe bleue) diminue rapidement et atteint quasiment zéro après environ 50 itérations. Cela indique qu'AdaBoost est très efficace pour réduire l'erreur sur les données d'apprentissage. Cependant, l'erreur de test (courbe rouge) suit un schéma différent. Bien qu'elle diminue initialement, elle stagne et commence même à légèrement augmenter après environ 50 itérations. Ce phénomène suggère un surapprentissage, où le modèle devient trop complexe et commence à mémoriser le bruit dans les données d'apprentissage au lieu d'apprendre des motifs généralisables. Malgré cela, l'erreur de test reste relativement stable après cette phase initiale, montrant une certaine robustesse du modèle.

#Le second graphique montre l'évolution des erreurs pour le même modèle AdaBoost, mais cette fois avec une limitation de profondeur des arbres à trois niveaux. L'erreur d'apprentissage commence plus haut et ne descend pas aussi bas que dans le premier graphique, atteignant un plateau autour de 0.04. Cela indique que les arbres moins profonds sont moins capables de s'adapter parfaitement aux données d'apprentissage. L'erreur de test, bien qu'elle fluctue plus que dans le premier graphique, reste plus stable sans montrer une augmentation notable. Cette stabilité indique que limiter la profondeur des arbres aide à éviter le surapprentissage, bien que cela réduise également la capacité du modèle à capturer des motifs complexes, ce qui se reflète dans l'erreur d'apprentissage plus élevée.

Gradient Boosting

# Conversion de la variable cible en valeurs 0 et 1 pour le modèle gbm
# Le modèle gbm nécessite que la variable cible soit des valeurs numériques 0 et 1.
# On convertit donc "spam" en 1 et "nonspam" en 0 pour les données d'apprentissage.
trainData$type <- ifelse(trainData$type == "spam", 1, 0)
# On fait de même pour les données de test.
testData$type <- ifelse(testData$type == "spam", 1, 0)

# Entraînement du modèle Gradient Boosting avec 1000 itérations
start_time <- Sys.time()  # Démarrage du chronomètre
set.seed(123)  # Pour la reproductibilité
# On crée un modèle de Gradient Boosting en utilisant gbm().
# type ~ . signifie qu'on utilise toutes les colonnes pour prédire la colonne "type".
# data = trainData signifie qu'on utilise les données d'apprentissage.
# distribution = "bernoulli" signifie qu'on utilise une distribution de Bernoulli pour les données binaires.
# n.trees = 1000 signifie qu'on fait 1000 itérations.
# interaction.depth = 3 signifie qu'on permet aux arbres d'avoir une profondeur de 3.
# shrinkage = 0.01 est un paramètre qui contrôle la vitesse d'apprentissage.
# cv.folds = 5 signifie qu'on utilise une validation croisée avec 5 plis.
gbm_model <- gbm(type ~ ., data = trainData, distribution = "bernoulli", 
                 n.trees = 1000, interaction.depth = 3, shrinkage = 0.01, 
                 cv.folds = 5)
end_time <- Sys.time()  # Arrêt du chronomètre
# On calcule le temps total d'exécution pour entraîner le modèle.
gbm_time_default <- end_time - start_time

# Calcul des taux d'erreur d'apprentissage et de généralisation
# On utilise predict() pour faire des prédictions sur les données d'apprentissage avec 1000 arbres.
gbm_train_pred <- predict(gbm_model, newdata = trainData, n.trees = 1000, 
                          type = "response")
# On fait de même pour les données de test.
gbm_test_pred <- predict(gbm_model, newdata = testData, n.trees = 1000, 
                         type = "response")

# Conversion des prédictions en classes binaires
# On convertit les prédictions en valeurs binaires (0 ou 1).
# Si la prédiction est supérieure à 0.5, on la considère comme 1 (spam), sinon comme 0 (nonspam).
gbm_train_class <- ifelse(gbm_train_pred > 0.5, 1, 0)
gbm_test_class <- ifelse(gbm_test_pred > 0.5, 1, 0)

# Calcul des erreurs
# On compare les prédictions avec les vraies valeurs pour calculer le taux d'erreur.
gbm_train_error <- mean(gbm_train_class != trainData$type)
gbm_test_error <- mean(gbm_test_class != testData$type)

# Affichage des résultats
# On affiche le taux d'erreur sur les données d'apprentissage.
gbm_train_error

[1] 0.04644215

# Le premier nombre (0.04644215) est le taux d'erreur sur les données d'apprentissage.
# Cela signifie que le modèle a fait une erreur environ 4.64% du temps sur les données d'apprentissage.


# On affiche le taux d'erreur sur les données de test.
gbm_test_error

[1] 0.05331882

# Le deuxième nombre (0.05331882) est le taux d'erreur sur les données de test.
# Cela signifie que le modèle a fait une erreur environ 5.33% du temps sur les données de test.

# On affiche le temps total d'exécution pour entraîner le modèle.
gbm_time_default

Time difference of 30.17881 secs

# Le troisième résultat (Time difference of 25.2539 secs) indique que le temps total 
# pour entraîner le modèle Gradient Boosting avec 1000 itérations a été d'environ 25.25 secondes.


# Traçage des courbes de déviance
# gbm.perf() permet de trouver le meilleur nombre d'arbres en utilisant la validation croisée.
gbm_performance <- gbm.perf(gbm_model, method = "cv")

# Le graphique présenté montre l'évolution de la déviance de Bernoulli pour le modèle Gradient Boosting au cours de 1000 itérations. La déviance de Bernoulli est une mesure de la qualité de l'ajustement d'un modèle, utilisée notamment pour les problèmes de classification binaire. Une valeur plus faible de cette déviance indique un meilleur ajustement du modèle aux données.

# On observe que la déviance de Bernoulli diminue de manière continue tout au long des itérations, ce qui signifie que le modèle s'améliore progressivement en ajustant de mieux en mieux les données. Les courbes pour les données d'apprentissage et de validation (test) suivent une trajectoire descendante similaire, montrant une amélioration constante de la performance du modèle.

#Cependant, vers la fin des itérations, les courbes commencent à converger et deviennent presque horizontales, indiquant que l'ajustement supplémentaire offert par les nouvelles itérations devient minime. À ce point, ajouter davantage d'itérations n'améliore que très peu la performance du modèle et pourrait même entraîner un surapprentissage si le modèle commence à mémoriser le bruit dans les données d'apprentissage.

#La ligne verticale bleue en pointillés à la 1000e itération marque la fin des itérations définies pour l'entraînement du modèle. Le modèle a été configuré pour s'arrêter à cette limite, probablement en raison des contraintes de calcul ou pour éviter un surapprentissage excessif.

# Validation croisée simplifiée pour Gradient Boosting en variant les autres paramètres

# On utilise set.seed(123) pour que nos résultats soient reproductibles
set.seed(123)

# On définit les paramètres de la validation croisée
# trainControl(method = "cv", number = 3) signifie qu'on utilise une validation croisée avec 3 plis
# Cela veut dire qu'on divise les données en 3 parties et qu'on entraîne le modèle 3 fois, chaque fois en utilisant une partie différente pour tester
ctrl <- trainControl(method = "cv", number = 3)

# On définit une grille de paramètres à tester
# expand.grid() crée toutes les combinaisons possibles des paramètres qu'on veut tester
# n.trees = 1000 signifie qu'on va toujours utiliser 1000 arbres
# interaction.depth = c(1, 3, 5) signifie qu'on va tester des profondeurs de 1, 3 et 5 pour les arbres
# shrinkage = c(0.01, 0.1, 0.3) signifie qu'on va tester des vitesses d'apprentissage de 0.01, 0.1 et 0.3
# n.minobsinnode = c(10, 20) signifie qu'on va tester des minimums de 10 et 20 observations par nœud
grid <- expand.grid(n.trees = 1000, interaction.depth = c(1, 3, 5), 
                    shrinkage = c(0.01, 0.1, 0.3), n.minobsinnode = c(10, 20))

# On démarre le chronomètre
start_time <- Sys.time()

# On entraîne le modèle en utilisant la validation croisée et la grille de paramètres
# train() crée et entraîne le modèle
# type ~ . signifie qu'on utilise toutes les colonnes pour prédire la colonne "type"
# data = trainData signifie qu'on utilise les données d'apprentissage
# method = "gbm" signifie qu'on utilise le modèle de Gradient Boosting
# trControl = ctrl signifie qu'on utilise les paramètres de validation croisée définis plus tôt
# tuneGrid = grid signifie qu'on utilise la grille de paramètres définie plus tôt
# verbose = FALSE signifie qu'on ne veut pas afficher des messages détaillés pendant l'entraînement
gbm_cv <- train(type ~ ., data = trainData, method = "gbm", trControl = ctrl, 
                tuneGrid = grid, verbose = FALSE)

Avis dans train.default(x, y, weights = w, ...) :
  You are trying to do regression and your outcome only has two possible values Are you trying to do classification? If so, use a 2 level factor as your outcome column.

# On arrête le chronomètre
end_time <- Sys.time()

# On calcule le temps total d'exécution pour la validation croisée
gbm_time_cv <- end_time - start_time

# Meilleurs paramètres
# bestTune contient les meilleurs paramètres trouvés par la validation croisée
best_gbm <- gbm_cv$bestTune
best_gbm

# Entraînement du modèle avec les meilleurs paramètres

# On démarre le chronomètre
start_time <- Sys.time()

# On crée un modèle de Gradient Boosting avec les meilleurs paramètres trouvés par la validation croisée
# distribution = "bernoulli" signifie qu'on utilise une distribution de Bernoulli pour les données binaires
# cv.folds = 3 signifie qu'on utilise une validation croisée avec 3 plis
gbm_model_best <- gbm(type ~ ., data = trainData, distribution = "bernoulli", 
                      n.trees = best_gbm$n.trees, interaction.depth = best_gbm$interaction.depth, 
                      shrinkage = best_gbm$shrinkage, n.minobsinnode = best_gbm$n.minobsinnode, 
                      cv.folds = 3)

# On arrête le chronomètre
end_time <- Sys.time()

# On calcule le temps total d'exécution pour entraîner le modèle avec les meilleurs paramètres
gbm_time_best <- end_time - start_time

# Calcul des taux d'erreur d'apprentissage et de généralisation

# On utilise predict() pour faire des prédictions sur les données d'apprentissage avec les meilleurs paramètres
gbm_train_pred_best <- predict(gbm_model_best, newdata = trainData, 
                               n.trees = best_gbm$n.trees, type = "response")

# On fait de même pour les données de test
gbm_test_pred_best <- predict(gbm_model_best, newdata = testData, 
                              n.trees = best_gbm$n.trees, type = "response")

# Conversion des prédictions en classes binaires
# On convertit les prédictions en valeurs binaires (0 ou 1)
# Si la prédiction est supérieure à 0.5, on la considère comme 1 (spam), sinon comme 0 (nonspam)
gbm_train_class_best <- ifelse(gbm_train_pred_best > 0.5, 1, 0)
gbm_test_class_best <- ifelse(gbm_test_pred_best > 0.5, 1, 0)

# Calcul des erreurs
# On compare les prédictions avec les vraies valeurs pour calculer le taux d'erreur
gbm_train_error_best <- mean(gbm_train_class_best != trainData$type)
gbm_test_error_best <- mean(gbm_test_class_best != testData$type)

# Affichage des résultats
# On affiche le taux d'erreur sur les données d'apprentissage
gbm_train_error_best

[1] 0.0008147746

# Le premier nombre (0.04644215) est le taux d'erreur sur les données d'apprentissage avec les meilleurs paramètres.
# Cela signifie que le modèle a fait une erreur environ 4.64% du temps sur les données d'apprentissage.

# On affiche le taux d'erreur sur les données de test
gbm_test_error_best

[1] 0.04026115

# Le deuxième nombre (0.05331882) est le taux d'erreur sur les données de test avec les meilleurs paramètres.
# Cela signifie que le modèle a fait une erreur environ 5.33% du temps sur les données de test.

# On affiche le temps total d'exécution pour entraîner le modèle avec les meilleurs paramètres
gbm_time_best

Time difference of 29.70658 secs

# Le troisième résultat (Time difference of 25.2539 secs) indique que le temps total 
# pour entraîner le modèle Gradient Boosting avec les meilleurs paramètres a été d'environ 25.25 secondes.

XGBoost

# Préparation des données pour XGBoost

# On prépare les données pour le modèle XGBoost
# Le modèle XGBoost nécessite que la variable cible soit des valeurs numériques 0 et 1
# On convertit donc les valeurs 1 en 1 (spam) et les valeurs 0 en 0 (nonspam) pour les données d'apprentissage
trainData$type <- ifelse(trainData$type == 1, 1, 0)
# On fait de même pour les données de test
testData$type <- ifelse(testData$type == 1, 1, 0)

# On crée des matrices de données spéciales pour XGBoost
# xgb.DMatrix() est une fonction qui crée une structure de données optimisée pour XGBoost
# data = as.matrix(trainData[,-ncol(trainData)]) signifie qu'on utilise toutes les colonnes sauf la dernière
# label = trainData$type signifie qu'on utilise la colonne "type" comme étiquette (spam ou nonspam)
train_matrix <- xgb.DMatrix(data = as.matrix(trainData[,-ncol(trainData)]), label = trainData$type)
test_matrix <- xgb.DMatrix(data = as.matrix(testData[,-ncol(testData)]), label = testData$type)

# Entraînement du modèle XGBoost avec 100 itérations
start_time <- Sys.time()  # Démarrage du chronomètre
set.seed(123)  # Pour la reproductibilité
# On crée et entraîne le modèle XGBoost en utilisant xgb.train()
# data = train_matrix signifie qu'on utilise les données d'apprentissage
# nrounds = 100 signifie qu'on fait 100 itérations
# objective = "binary:logistic" signifie qu'on utilise une régression logistique binaire
# max_depth = 3 signifie qu'on permet aux arbres d'avoir une profondeur de 3
# eta = 0.1 est un paramètre qui contrôle la vitesse d'apprentissage
# watchlist = list(train = train_matrix, test = test_matrix) signifie qu'on suit les erreurs sur les données d'apprentissage et de test
# eval_metric = "logloss" signifie qu'on utilise la perte logarithmique pour évaluer les erreurs
# verbose = 0 signifie qu'on ne veut pas afficher des messages détaillés pendant l'entraînement
xgboost_model <- xgb.train(
  data = train_matrix,
  nrounds = 100,
  objective = "binary:logistic",
  max_depth = 3,
  eta = 0.1,
  watchlist = list(train = train_matrix, test = test_matrix),
  eval_metric = "logloss",
  verbose = 0
)
end_time <- Sys.time()  # Arrêt du chronomètre
# On calcule le temps total d'exécution pour entraîner le modèle
xgboost_time_default <- end_time - start_time

# Récupération des erreurs d'apprentissage et de test
# evaluation_log contient les erreurs pour chaque itération
evaluation_log <- xgboost_model$evaluation_log

# Calcul des erreurs finales
# On utilise predict() pour faire des prédictions sur les données d'apprentissage
xgboost_train_pred <- predict(xgboost_model, newdata = train_matrix)
# On fait de même pour les données de test
xgboost_test_pred <- predict(xgboost_model, newdata = test_matrix)

# Conversion des prédictions en classes binaires
# On convertit les prédictions en valeurs binaires (0 ou 1)
# Si la prédiction est supérieure à 0.5, on la considère comme 1 (spam), sinon comme 0 (nonspam)
xgboost_train_class <- ifelse(xgboost_train_pred > 0.5, 1, 0)
xgboost_test_class <- ifelse(xgboost_test_pred > 0.5, 1, 0)

# Calcul des erreurs
# On compare les prédictions avec les vraies valeurs pour calculer le taux d'erreur
xgboost_train_error <- mean(xgboost_train_class != trainData$type)
xgboost_test_error <- mean(xgboost_test_class != testData$type)

# Affichage des erreurs finales
# On affiche le taux d'erreur sur les données d'apprentissage
xgboost_train_error

[1] 0.0418251

# Le premier nombre (0.0418251) est le taux d'erreur sur les données d'apprentissage.
# Cela signifie que le modèle a fait une erreur environ 4.18% du temps sur les données d'apprentissage.

# On affiche le taux d'erreur sur les données de test
xgboost_test_error

[1] 0.05767138

# Le deuxième nombre (0.05767138) est le taux d'erreur sur les données de test.
# Cela signifie que le modèle a fait une erreur environ 5.77% du temps sur les données de test.

# On affiche le temps total d'exécution pour entraîner le modèle
xgboost_time_default

Time difference of 0.556731 secs

# Le troisième résultat (Time difference of 0.4740241 secs) indique que le temps total 
# pour entraîner le modèle XGBoost avec 100 itérations a été d'environ 0.47 secondes.

# Traçage des courbes d'erreurs
# plot() crée un graphique montrant l'évolution des erreurs
# type = "l" signifie qu'on trace une ligne
# col = "blue" signifie que la ligne est bleue pour les erreurs d'apprentissage
# ylim = c(0, max(evaluation_log$train_logloss, evaluation_log$test_logloss)) définit les limites de l'axe Y pour une meilleure visualisation
# ylab = "Log Loss" donne un titre à l'axe Y
# xlab = "Iteration" donne un titre à l'axe X
# main = "Évolution des erreurs avec XGBoost" donne un titre au graphique
plot(evaluation_log$iter, evaluation_log$train_logloss, type = "l", col = "blue", 
     ylim = c(0, max(evaluation_log$train_logloss, evaluation_log$test_logloss)), 
     ylab = "Log Loss", xlab = "Iteration", 
     main = "Évolution des erreurs avec XGBoost")
# lines() ajoute une ligne rouge pour les erreurs de test
lines(evaluation_log$iter, evaluation_log$test_logloss, col = "red")

# legend() ajoute une légende au graphique pour expliquer les couleurs
legend("topright", legend = c("Erreur d'apprentissage", "Erreur de test"), 
       col = c("blue", "red"), lty = 1)

# Visualisation de l'importance des variables
# xgb.importance() calcule l'importance de chaque variable dans le modèle
importance_matrix <- xgb.importance(model = xgboost_model)
# xgb.plot.importance() crée un graphique montrant l'importance des variables
xgb.plot.importance(importance_matrix)

# Le premier graphique montre l'évolution des erreurs d'apprentissage et de test au fil des 100 itérations. La courbe bleue représente l'erreur d'apprentissage, qui diminue rapidement et continue de baisser au fil des itérations, ce qui indique que le modèle s'adapte de mieux en mieux aux données d'entraînement. La courbe rouge, quant à elle, montre l'erreur de test, qui diminue également mais tend à stagner vers la fin des itérations. Cette stagnation suggère que le modèle atteint un point où des itérations supplémentaires n'apportent que peu ou pas d'améliorations supplémentaires sur les données de test, ce qui est un signe positif de bonne généralisation sans surapprentissage excessif.

# Le deuxième graphique montre l'importance des variables dans le modèle. Les variables les plus importantes sont celles en haut du graphique, avec "charExclamation" et "remove" étant les plus influentes. Ces variables jouent un rôle crucial dans les décisions prises par le modèle.

# On utilise set.seed(123) pour que nos résultats soient reproductibles
set.seed(123)

# On définit les paramètres de la validation croisée
# trainControl(method = "cv", number = 3) signifie qu'on utilise une validation croisée avec 3 plis
# Cela veut dire qu'on divise les données en 3 parties et qu'on entraîne le modèle 3 fois, chaque fois en utilisant une partie différente pour tester
ctrl <- trainControl(method = "cv", number = 3)

# On définit une grille de paramètres à tester
# expand.grid() crée toutes les combinaisons possibles des paramètres qu'on veut tester
# nrounds = c(100) signifie qu'on va toujours utiliser 100 itérations
# max_depth = c(3, 5, 7) signifie qu'on va tester des profondeurs de 3, 5 et 7 pour les arbres
# eta = c(0.01, 0.1, 0.3) signifie qu'on va tester des vitesses d'apprentissage de 0.01, 0.1 et 0.3
# gamma = c(0, 1) signifie qu'on va tester des valeurs de 0 et 1 pour le paramètre gamma
# colsample_bytree = c(0.5, 1) signifie qu'on va tester des échantillons de 50% et 100% pour les arbres
# min_child_weight = c(1, 5) signifie qu'on va tester des valeurs de 1 et 5 pour le paramètre min_child_weight
# subsample = c(0.5, 1) signifie qu'on va tester des échantillons de 50% et 100% pour les arbres
grid <- expand.grid(
  nrounds = c(100), 
  max_depth = c(3, 5, 7), 
  eta = c(0.01, 0.1, 0.3),
  gamma = c(0, 1),
  colsample_bytree = c(0.5, 1),
  min_child_weight = c(1, 5),
  subsample = c(0.5, 1)
)

# On démarre le chronomètre
start_time <- Sys.time()

# On entraîne le modèle en utilisant la validation croisée et la grille de paramètres
# train() crée et entraîne le modèle
# type ~ . signifie qu'on utilise toutes les colonnes pour prédire la colonne "type"
# data = trainData signifie qu'on utilise les données d'apprentissage
# method = "xgbTree" signifie qu'on utilise le modèle XGBoost
# trControl = ctrl signifie qu'on utilise les paramètres de validation croisée définis plus tôt
# tuneGrid = grid signifie qu'on utilise la grille de paramètres définie plus tôt
xgboost_cv <- train(type ~ ., data = trainData, method = "xgbTree", trControl = ctrl, tuneGrid = grid)

Avis dans train.default(x, y, weights = w, ...) :
  You are trying to do regression and your outcome only has two possible values Are you trying to do classification? If so, use a 2 level factor as your outcome column.

# On arrête le chronomètre
end_time <- Sys.time()

# On calcule le temps total d'exécution pour la validation croisée
xgboost_time_cv <- end_time - start_time

# Meilleurs paramètres
# bestTune contient les meilleurs paramètres trouvés par la validation croisée
best_xgboost <- xgboost_cv$bestTune
best_xgboost

# Entraînement du modèle avec les meilleurs paramètres

# On démarre le chronomètre
start_time <- Sys.time()

# On crée et entraîne le modèle XGBoost avec les meilleurs paramètres trouvés par la validation croisée
# data = train_matrix signifie qu'on utilise les données d'apprentissage
# nrounds = best_xgboost$nrounds signifie qu'on utilise le nombre d'itérations trouvé par la validation croisée
# objective = "binary:logistic" signifie qu'on utilise une régression logistique binaire
# max_depth = best_xgboost$max_depth signifie qu'on utilise la profondeur trouvée par la validation croisée
# eta = best_xgboost$eta signifie qu'on utilise la vitesse d'apprentissage trouvée par la validation croisée
# gamma = best_xgboost$gamma signifie qu'on utilise le gamma trouvé par la validation croisée
# colsample_bytree = best_xgboost$colsample_bytree signifie qu'on utilise l'échantillonnage trouvé par la validation croisée
# min_child_weight = best_xgboost$min_child_weight signifie qu'on utilise le poids minimum trouvé par la validation croisée
# subsample = best_xgboost$subsample signifie qu'on utilise l'échantillonnage trouvé par la validation croisée
# watchlist = list(train = train_matrix, test = test_matrix) signifie qu'on suit les erreurs sur les données d'apprentissage et de test
# eval_metric = "logloss" signifie qu'on utilise la perte logarithmique pour évaluer les erreurs
# verbose = 0 signifie qu'on ne veut pas afficher des messages détaillés pendant l'entraînement
xgboost_model_best <- xgb.train(
  data = train_matrix,
  nrounds = best_xgboost$nrounds,
  objective = "binary:logistic",
  max_depth = best_xgboost$max_depth,
  eta = best_xgboost$eta,
  gamma = best_xgboost$gamma,
  colsample_bytree = best_xgboost$colsample_bytree,
  min_child_weight = best_xgboost$min_child_weight,
  subsample = best_xgboost$subsample,
  watchlist = list(train = train_matrix, test = test_matrix),
  eval_metric = "logloss",
  verbose = 0
)

# On arrête le chronomètre
end_time <- Sys.time()

# On calcule le temps total d'exécution pour entraîner le modèle avec les meilleurs paramètres
xgboost_time_best <- end_time - start_time

# Récupération des erreurs d'apprentissage et de test
# evaluation_log_best contient les erreurs pour chaque itération
evaluation_log_best <- xgboost_model_best$evaluation_log

# Calcul des erreurs finales
# On utilise predict() pour faire des prédictions sur les données d'apprentissage
xgboost_train_pred_best <- predict(xgboost_model_best, newdata = train_matrix)
# On fait de même pour les données de test
xgboost_test_pred_best <- predict(xgboost_model_best, newdata = test_matrix)

# Conversion des prédictions en classes binaires
# On convertit les prédictions en valeurs binaires (0 ou 1)
# Si la prédiction est supérieure à 0.5, on la considère comme 1 (spam), sinon comme 0 (nonspam)
xgboost_train_class_best <- ifelse(xgboost_train_pred_best > 0.5, 1, 0)
xgboost_test_class_best <- ifelse(xgboost_test_pred_best > 0.5, 1, 0)

# Calcul des erreurs
# On compare les prédictions avec les vraies valeurs pour calculer le taux d'erreur
xgboost_train_error_best <- mean(xgboost_train_class_best != trainData$type)
xgboost_test_error_best <- mean(xgboost_test_class_best != testData$type)

# Affichage des erreurs finales
# On affiche le taux d'erreur sur les données d'apprentissage
xgboost_train_error_best

[1] 0.01195003

# Le premier nombre (0.0418251) est le taux d'erreur sur les données d'apprentissage.
# Cela signifie que le modèle a fait une erreur environ 4.18% du temps sur les données d'apprentissage.

# On affiche le taux d'erreur sur les données de test
xgboost_test_error_best

[1] 0.04026115

# Le deuxième nombre (0.05767138) est le taux d'erreur sur les données de test.
# Cela signifie que le modèle a fait une erreur environ 5.77% du temps sur les données de test.

# On affiche le temps total d'exécution pour entraîner le modèle avec les meilleurs paramètres
xgboost_time_best

Time difference of 0.8617151 secs

# Le troisième résultat (Time difference of 0.4740241 secs) indique que le temps total 
# pour entraîner le modèle XGBoost avec 100 itérations a été d'environ 0.47 secondes.

# Traçage des courbes d'erreurs
# plot() crée un graphique montrant l'évolution des erreurs
plot(evaluation_log_best$iter, evaluation_log_best$train_logloss, type = "l", col = "blue", 
     ylim = c(0, max(evaluation_log_best$train_logloss, evaluation_log_best$test_logloss)), 
     ylab = "Log Loss", xlab = "Iteration", 
     main = "Évolution des erreurs avec XGBoost (meilleurs paramètres)")
# lines() ajoute une ligne rouge pour les erreurs de test
lines(evaluation_log_best$iter, evaluation_log_best$test_logloss, col = "red")

# legend() ajoute une légende au graphique pour expliquer les couleurs
legend("topright", legend = c("Erreur d'apprentissage", "Erreur de test"), 
       col = c("blue", "red"), lty = 1)

# Visualisation de l'importance des variables
# xgb.importance() calcule l'importance de chaque variable dans le modèle
importance_matrix_best <- xgb.importance(model = xgboost_model_best)
# xgb.plot.importance() crée un graphique montrant l'importance des variables
xgb.plot.importance(importance_matrix_best)

# Le premier graphique montre l'évolution des erreurs d'apprentissage et de test au fil des 100 itérations.
# On remarque que la courbe bleue de l'erreur d'apprentissage descend plus rapidement et atteint une valeur plus basse que dans le modèle par défaut, indiquant une meilleure adaptation aux données d'entraînement. La courbe rouge de l'erreur de test, tout en diminuant également, montre une convergence plus rapide et une stabilisation à une valeur légèrement plus basse que celle du modèle par défaut, indiquant une amélioration générale dans la performance de prédiction.

# Le deuxième graphique montre l'importance des variables dans le modèle. 
# Les variables en haut du graphique sont les plus importantes pour le modèle.
#Les variables "charDollar", "charExclamation", et "capitalLong" sont parmi les plus influentes. On constate que l'importance relative des variables peut varier légèrement par rapport au modèle par défaut, ce qui reflète les ajustements effectués par le processus d'optimisation pour améliorer la performance globale

# Résultats des modèles par défaut

# On crée un tableau de données pour stocker les résultats des modèles par défaut
# data.frame() crée un tableau de données
# Model = c("AdaBoost", "Gradient Boosting", "XGBoost") signifie qu'on a trois modèles : AdaBoost, Gradient Boosting et XGBoost
# Train_Error, Test_Error et Execution_Time sont les colonnes où on va stocker les erreurs d'apprentissage, les erreurs de test et les temps d'exécution pour chaque modèle

results_default <- data.frame(
  Model = c("AdaBoost", "Gradient Boosting", "XGBoost"),
  Train_Error = c(train_error, gbm_train_error, xgboost_train_error),
  Test_Error = c(test_error, gbm_test_error, xgboost_test_error),
  Execution_Time = c(adaboost_time_default, gbm_time_default, xgboost_time_default)
)

# Résultats des modèles avec les meilleurs paramètres

# On crée un autre tableau de données pour stocker les résultats des modèles optimisés avec les meilleurs paramètres trouvés par validation croisée
# Ici, on a quatre modèles optimisés : deux versions d'AdaBoost (300 itérations et 300 itérations avec profondeur limitée), Gradient Boosting optimisé et XGBoost optimisé
results_best <- data.frame(
  Model = c("AdaBoost (300 iterations)", "AdaBoost (300 iterations, depth 3)", "Gradient Boosting (Best)", "XGBoost (Best)"),
  Train_Error = c(train_error_300, train_error_depth3, gbm_train_error_best, xgboost_train_error_best),
  Test_Error = c(test_error_300, test_error_depth3, gbm_test_error_best, xgboost_test_error_best),
  Execution_Time = c(adaboost_time_300, adaboost_time_depth3, gbm_time_best, xgboost_time_best)
)

# Affichage des résultats

# On affiche le tableau des résultats des modèles par défaut
results_default

# On affiche le tableau des résultats des modèles optimisés
results_best

1. Modèles par défaut :

   AdaBoost a montré un bon compromis entre temps d’exécution et taux d’erreur, avec un temps de calcul modéré (~5.37 secondes) et des erreurs d’apprentissage (2.69%) et de test (5.11%) raisonnablement basses. Gradient Boosting a pris plus de temps (~25.25 secondes) et a affiché des taux d’erreur légèrement supérieurs à ceux d’AdaBoost. XGBoost, bien que très rapide (~0.47 seconde), a montré une légère augmentation de l’erreur de test (5.77%), indiquant peut-être une moindre performance en termes de généralisation par rapport à AdaBoost.

2. Modèles optimisés :

   En optimisant les paramètres, AdaBoost avec 300 itérations a atteint une erreur de test très basse (3.70%), mais au coût d’un temps de calcul élevé (~171.17 secondes). En limitant la profondeur des arbres, AdaBoost (300 itérations, profondeur 3) a réduit le temps de calcul (~57.49 secondes) tout en maintenant une erreur de test acceptable (5.22%). Gradient Boosting optimisé a significativement amélioré ses performances, avec une erreur de test réduite à 4.03% et un temps de calcul de ~61.49 secondes. XGBoost optimisé a également montré une performance robuste, avec une erreur de test identique à celle de Gradient Boosting (4.03%) mais avec un temps de calcul beaucoup plus faible (~0.94 seconde).

En conclusion, XGBoost optimisé offre le meilleur équilibre entre performance et temps d’exécution, affichant des erreurs de test compétitives avec un temps de calcul nettement inférieur à celui des autres modèles. AdaBoost optimisé peut offrir des erreurs de test légèrement meilleures, mais à un coût de calcul beaucoup plus élevé. Gradient Boosting se situe entre les deux, offrant une bonne performance avec un temps de calcul raisonnable. Les choix finaux dépendent des contraintes de temps de calcul et des exigences de précision spécifiques à l’application.