caret

C'est un package qui permet d'appeler de nombreuses méthodes de machine learning en offrant une interface unifiée et qui comporte des fonctions utilitaires diverses. Appeler la fonction getModelInfo() pour avoir les informations grâce auxquelles caret sait utiliser les différentes librairies.

createDataPartition : permet de séparer un dataset en training et test :

• myList <- createDataPartition(fr$y, p = 0.75) : renvoie une liste avec myList$Resample1 qui est la liste des indices pour le training
• myMatrix <- createDataPartition(fr$y, p = 0.75, list = FALSE) : renvoie une matrice à une colonne. On peut alors faire :
  • frTrain <- fr[myMatrix, ]
  • frTest <- fr[- myMatrix, ]
• myList <- createDataPartition(fr$y, p = 0.75, times = 3) : crée 3 partitions différentes, myList$Resample1, myList$Resample2, myList$Resample2 (avec list = FALSE), renvoie une matrice à 3 colonnes)

createFolds : partitionne les données en plusieurs folds :

• myList <- createFolds(fr$y, k = 10) : renvoie une liste de 10 éléments donc chacun sont les indices pour le fold (en partionnant équitablement selon les valeurs prises par fr$y).

createResample : crée des échantillons de bootstrap (avec répétitions possibles).

preProcess : fonction pour préprocesser les features :

• prepP <- preProcess(fr[, which(colnames(fr) != "y")], method = c("center", "scale")) : pré-processe les variables de façon à ce qu'elles soient centrées et réduites (i.e. moyenne 0 et écart-type 1). En fait, les données ne sont pas affectées et l'appel renvoie simplement un objet de la classe preProcess qui contient de quoi calculer le pre-processing !
• predict(prepP, fr[, which(colnames(fr) != "y")]) : permet d'appliquer effectivement le pré-processing aux variables (les variables de training ou de test). L'objet prepP permet de garder la mémoire de la transformation identique à appliquer aux échantillons de training et de test.
• preProcess(fr[, which(colnames(fr) != "y")], method = "pca", thresh = 0.90) : pré-processe les variables par PCA de façon à conserver les n dimensions les plus significatives formant 90% de la variabilité.
• preProcess(fr[, which(colnames(fr) != "y")], method = "pca", pcaComp = 5) : pré-processe les variables par PCA de façon à conserver les 5 dimensions les plus significatives.
• preProcess(fr[, which(colnames(fr) != "y")], method = "BoxCox") : applique une transformation pour transformer des données en données ayant une distribution quasi-normale.
• preProcess(fr[, which(colnames(fr) != "y")], method = "knnImpute", k = 10) : permet de remplacer les valeurs manquantes par des valeurs calculées à partir des 10 individus les plus proches (k nearest neighbour)

train : fonction pour faire l'apprentissage :

• train ne se contente pas simplement d'appeler la fonction d'apprentissage de la librairie correspondant à la méthode, elle optimise aussi les paramètres.
• model <- train(y ~ ., data = frTrain, method = "glm") : effectue l'apprentissage en utilisant la méthode glm sur le dataset frTrain. L'objet renvoyé est de la classe train.
• model <- train(y ~ ., data = frTrain, method = "rpart") : effectue l'apprentissage en utilisant la méthode rpart (arbres de décision). Utiliser "rf" pour les random forest.
• model$finalModel : c'est le modèle obtenu, dont la classe dépend de la méthode indiquée.
• pour avoir les noms des modèles disponibles : names(getModelInfo()). getModelInfo contient pour chaque méthode toutes les infos comme le nom de la librairie (qui doit être installée pour l'utiliser !).
• model <- train(y ~ ., data = frTrain, method = "glm", metric = "Kappa") : indique quelle métrique est choisie pour trouver le meilleur modèle : RMSE (défaut) ou Rsquared pour les regressions (Rsquared mesure l'accord linéaire entre la prédiction et la variable à prédire), Accuracy (défaut) ou Kappa pour les classifications.
• tuneLength : permet d'indiquer combien de valeur de chaque paramètre de la méthode d'apprentissage il faut tester (défaut = 3)
• le preprocessing peut se faire directement à l'appel de train : model <- train(y ~ ., data = fr, preProcess = c("center", "scale")) : permet de faire la normalisation des features au moment du training.

predict appliqué sur un objet train (fonction predict.train) : fonction pour faire la prédiction à partir du résultat de l'apprentissage :

• pred <- predict(model, newdata = frTest) : fait la prédiction en utilisant le modèle renvoyé par train et renvoie un vecteur de prédictions. Si dans le modèle, on avait indiqué un pré-processing (avec preProcess), ce même pré-processing est appliqué de la même façon au test.
• avec certaines méthodes de prédiction, on peut avoir des probabilités d'appartenance à chaque classe plutôt que simplement une classe : pred <- predict(model, newdata = frTest, type = "prob") : renvoie un data frame avec une colonne par classe et des probabilités.

featurePlot : permet de tracer la variable à predire en fonction de chacune des features sur un panel de graphes :

• featurePlot(fr[, which(colnames(fr) != "y")], fr$y) : trace autant de graphes que de features avec y en fonction de chaque feature. Si la variable prédite est de type numérique, c'est un scatter plot, si c'est un facteur, c'est un strip plot.
• featurePlot(fr[, which(colnames(fr) != "y")], fr$y, plot = "box") : imprime un boxplot pour une variable prédite de type factor.

cut2 du package Hmisc : permet de convertir facilement une variable numérique en facteur correspondant à des intervalles de valeurs :

• cut2(x, cuts = seq(0, 100, 10)) : binifie les données en séparant les données car les séparations données par cuts (premier intervalle fini à la première valeur si il y a des valeurs plus petites, sinon il commence à la première valeur, et idem pour la dernière valeur). Renvoie des intervalles comme valeurs.
• cut2(x, g = 5) : binifie les données de façon à avoir 5 groupes.
• cut2(x, m = 10) : binifie les données de façon à avoir environ 10 données par groupe.
• cut2(x, levels.mean = TRUE) : binifie les données en renvoyant au lieu des intervalles la moyenne des valeurs dans le bin (mais c'est toujours un facteur).

nearZeroVar : identifie les variables qui ne sont presque par variables et qu'on l'on peut donc éliminer pour la prédiction :

• nearZeroVar(fr[, which(colnames(fr) != "y")]) : renvoie les index des colonnes très peu variables.

confusionMatrix : permet de créer une matrice de confusion (effectifs croisés de chaque couple de valeurs) ainsi que les statistiques associées à partir du facteur prédit et du facteur réel :

• cm <- confusionMatrix(yPredicted, yReal) : renvoie un objet de la classe confusionMatrix avec notamment les champs :
  • cm$table : le tableau de confusion
  • cm$overall : un vecteur de valeurs avec notamment les noms : Accuracy, Kappa, AccuracyLower, AccuracyUpper
  • cm$byClass : une matrice avec une ligne par classe et notamment les colonnes Sensitivity, Specificity, Pos Pred Value, Neg Pred Value.