Big Data

Implémenter l'apprentissage automatique avec Caret dans R

introduction

L'un des plus grands défis auxquels les débutants en apprentissage automatique sont confrontés est de savoir quels algorithmes apprendre et sur quoi se concentrer.. Dans le cas de R, le problème est accentué par le fait que divers algorithmes auraient une syntaxe différente, différents paramètres à ajuster et différentes exigences sur le format des données. Cela pourrait être trop pour un débutant.

Ensuite, Comment pouvez-vous passer d'un débutant à un scientifique des données en créant des centaines de modèles et en les empilant ensemble? Il n'y a certainement pas de raccourci, mais ce que je vais vous dire aujourd'hui vous permettra d'appliquer des centaines de modèles d'apprentissage automatique sans avoir à:

mémoriser les différents noms de package pour chaque algorithme.
syntaxe d'application de chaque algorithme.
paramètres à ajuster pour chaque algorithme.

Tout cela a été possible grâce aux années d'efforts qui ont suivi CARET (Entraînement à la classification et à la régression) qui est peut-être le plus grand projet de R. Ce package à lui seul contient tout ce que vous devez savoir pour résoudre presque tous les problèmes d'apprentissage automatique supervisé.. Fournit une interface uniforme pour divers algorithmes d'apprentissage automatique et standardise d'autres tâches telles que le découpage des données, prétraitement, sélection de fonction, l'estimation de l'importance des variables, etc.

Pour une description détaillée des différentes fonctionnalités fournies par Caret, vous pouvez vous référer à cet article.

Aujourd'hui, nous allons travailler sur le Problème de prédiction de prêt III pour vous montrer la puissance du pack Caret.

PD Alors que caret simplifie définitivement le travail dans une certaine mesure, cela ne peut pas enlever le travail acharné et la pratique qu'il faut pour devenir un maître en apprentissage automatique.

Table des matières

Départ
Prétraitement avec Caret
Divisez les données avec Caret
Sélection de fonctionnalités avec Caret
Modèles d'entraînement avec Caret
Réglage des paramètres avec Caret
Estimation de l'importance des variables avec Caret
Faire des prédictions avec Caret

1. Départ

En peu de mots, Caret est essentiellement un conteneur pour plus de 200 algorithmes d'apprentissage automatique. En outre, fournit plusieurs fonctionnalités qui en font une solution complète pour tous les besoins de modélisation pour les problèmes d'apprentissage automatique supervisé.

Caret essaie de ne pas charger tous les packages dont il dépend au début. En échange, les charge uniquement lorsque des packages sont nécessaires. Mais cela suppose que vous avez déjà tous les algorithmes installés sur votre système.

Pour installer Caret sur votre système, utilisez la commande suivante. Avis: ça peut prendre du temps:

> install.packages("caret", dependencies = c("Depends", "Suggests"))

À présent, commençons à utiliser le package de collation dans Problème de prévision de prêt 3:

#Loading caret package library("caret") #Loading training data train<-read.csv("train_u6lujuX_CVtuZ9i.csv",stringsAsFactors = T) #Looking at the structure of caret package. str(train) #'data.frame':         614 obs. of  13 variables: #$ Loan_ID          : Factor w/ 614 levels "LP001002","LP001003",..: 1 2 3 4 5 6 7 8 9 #10 .. #$ Gender           : Factor w/ 3 levels "","Female","Male": 3 3 3 3 3 3 3 3 3 3 ... #$ Married          : Factor w/ 3 levels "","No","Yes": 2 3 3 3 2 3 3 3 3 3 ... #$ Dependents       : Factor w/ 5 levels "","0","1","2",..: 2 3 2 2 2 4 2 5 4 3 ... #$ Education        : Factor w/ 2 levels "Graduate","Not Graduate": 1 1 1 2 1 1 2 1 1 #1 ... #$ Self_Employed    : Factor w/ 3 levels "","No","Yes": 2 2 3 2 2 3 2 2 2 2 ... #$ ApplicantIncome  : int  5849 4583 3000 2583 6000 5417 2333 3036 4006 12841 #... #$ CoapplicantIncome: num  0 1508 0 2358 0 ... #$ LoanAmount       : int  NA 128 66 120 141 267 95 158 168 349 ... #$ Loan_Amount_Term : int  360 360 360 360 360 360 360 360 360 360 ... #$ Credit_History   : int  1 1 1 1 1 1 1 0 1 1 ... #$ Property_Area    : Factor w/ 3 levels "Rural","Semiurban",..: 3 1 3 3 3 3 3 2 3 2 #... #$ Loan_Status      : Factor w/ 2 levels "N","Y": 2 1 2 2 2 2 2 1 2 1 ...

Dans ce problème, nous devons prédire l'état du prêt d'une personne en fonction de son profil.

2. Prétraitement avec Caret

Nous devons prétraiter nos données avant de pouvoir les utiliser pour la modélisation. Vérifions si les données sont des valeurs manquantes:

sum(is.na(train)) #[1] 86

Ensuite, utilisons Caret pour imputer ces valeurs manquantes à l'aide de l'algorithme KNN. Nous allons prédire ces valeurs manquantes en fonction d'autres attributs pour cette ligne. En outre, nous allons mettre à l'échelle et centrer les données numériques en utilisant le prétraitement pratique () et Caret.

#Imputing missing values using KNN.Also centering and scaling numerical columns preProcValues <- preProcess(train, method = c("knnImpute","center","scale")) library('RANN') train_processed <- predict(preProcValues, train) sum(is.na(train_processed)) #[1] 0

Il est également très facile d'utiliser un codage à chaud dans Caret pour créer des variables muettes pour chaque niveau d'une variable catégorielle. Mais, premièrement, nous allons convertir la variable dépendante en numérique.

#Converting outcome variable to numeric train_processed$Loan_Status<-ifelse(train_processed$Loan_Status=='N',0,1) id<-train_processed$Loan_ID train_processed$Loan_ID<-NULL #Checking the structure of processed train file str(train_processed) #'data.frame':         614 obs. of  12 variables: #$ Gender           : Factor w/ 3 levels "","Female","Male": 3 3 3 3 3 3 3 3 3 3 ... #$ Married          : Factor w/ 3 levels "","No","Yes": 2 3 3 3 2 3 3 3 3 3 ... #$ Dependents       : Factor w/ 5 levels "","0","1","2",..: 2 3 2 2 2 4 2 5 4 3 ... #$ Education        : Factor w/ 2 levels "Graduate","Not Graduate": 1 1 1 2 1 1 2 1 1 #1 ... #$ Self_Employed    : Factor w/ 3 levels "","No","Yes": 2 2 3 2 2 3 2 2 2 2 ... #$ ApplicantIncome  : num  0.0729 -0.1343 -0.3934 -0.4617 0.0976 ... #$ CoapplicantIncome: num  -0.554 -0.0387 -0.554 0.2518 -0.554 ... #$ LoanAmount       : num  0.0162 -0.2151 -0.9395 -0.3086 -0.0632 ... #$ Loan_Amount_Term : num  0.276 0.276 0.276 0.276 0.276 ... #$ Credit_History   : num  0.432 0.432 0.432 0.432 0.432 ... #$ Property_Area    : Factor w/ 3 levels "Rural","Semiurban",..: 3 1 3 3 3 3 3 2 3 2 #... #$ Loan_Status      : num  1 0 1 1 1 1 1 0 1 0 ...

À présent, création de variables fictives à l'aide de l'encodage à chaud:

#Converting every categorical variable to numerical using dummy variables dmy <- dummyVars(" ~ .", data = train_processed,fullRank = T) train_transformed <- data.frame(predict(dmy, newdata = train_processed)) #Checking the structure of transformed train file str(train_transformed) #'data.frame':         614 obs. of  19 variables: #$ Gender.Female          : num  0 0 0 0 0 0 0 0 0 0 ... #$ Gender.Male            : num  1 1 1 1 1 1 1 1 1 1 ... #$ Married.No             : num  1 0 0 0 1 0 0 0 0 0 ... #$ Married.Yes            : num  0 1 1 1 0 1 1 1 1 1 ... #$ Dependents.0           : num  1 0 1 1 1 0 1 0 0 0 ... #$ Dependents.1           : num  0 1 0 0 0 0 0 0 0 1 ... #$ Dependents.2           : num  0 0 0 0 0 1 0 0 1 0 ... #$ Dependents.3.          : num  0 0 0 0 0 0 0 1 0 0 ... #$ Education.Not.Graduate : num  0 0 0 1 0 0 1 0 0 0 ... #$ Self_Employed.No       : num  1 1 0 1 1 0 1 1 1 1 ... #$ Self_Employed.Yes      : num  0 0 1 0 0 1 0 0 0 0 ... #$ ApplicantIncome        : num  0.0729 -0.1343 -0.3934 -0.4617 0.0976 ... #$ CoapplicantIncome      : num  -0.554 -0.0387 -0.554 0.2518 -0.554 ... #$ LoanAmount             : num  0.0162 -0.2151 -0.9395 -0.3086 -0.0632 ... #$ Loan_Amount_Term       : num  0.276 0.276 0.276 0.276 0.276 ... #$ Credit_History         : num  0.432 0.432 0.432 0.432 0.432 ... #$ Property_Area.Semiurban: num  0 0 0 0 0 0 0 1 0 1 ... #$ Property_Area.Urban    : num  1 0 1 1 1 1 1 0 1 0 ... #$ Loan_Status            : num  1 0 1 1 1 1 1 0 1 0 ... #Converting the dependent variable back to categorical train_transformed$Loan_Status<-as.factor(train_transformed$Loan_Status)

Ici, “rang complet = T” créera seulement (n-1) colonnes pour une colonne catégorielle avec n niveaux différents. Cela fonctionne particulièrement pour les prédicteurs catégoriques qui représentent le genre, marié, etc., où nous n'avons que deux niveaux: Masculin / Féminin, Oui / Non, etc. parce que 0 peut être utilisé pour représenter une classe tout en 1 représente l'autre classe dans la même colonne.

3. Diviser les données à l'aide du caret

Nous allons créer un ensemble de validation croisée à partir de l'ensemble d'apprentissage pour évaluer notre modèle. Il est important de s'appuyer davantage sur l'ensemble de validation croisée pour l'évaluation réelle de votre modèle, au contraire, vous pourriez finir par dépasser le classement public.

Nous utiliserons createDataPartition () diviser nos données d'entraînement en deux ensembles: 75% Oui 25%. Puisque notre variable de résultat est de nature catégorique, cette fonction garantira que la distribution des classes de variables de résultat est similaire dans les deux ensembles.

#Spliting training set into two parts based on outcome: 75% and 25% index <- createDataPartition(train_transformed$Loan_Status, p=0.75, list=FALSE) trainSet <- train_transformed[ index,] testSet <- train_transformed[-index,] #Checking the structure of trainSet str(trainSet) #'data.frame':         461 obs. of  19 variables: #$ Gender.Female          : num  0 0 0 0 0 0 0 0 0 0 ... #$ Gender.Male            : num  1 1 1 1 1 1 1 1 1 1 ... #$ Married.No             : num  1 0 0 0 1 0 0 0 0 0 ... #$ Married.Yes            : num  0 1 1 1 0 1 1 1 1 1 ... #$ Dependents.0           : num  1 0 1 1 1 0 1 0 0 0 ... #$ Dependents.1           : num  0 1 0 0 0 0 0 0 1 0 ... #$ Dependents.2           : num  0 0 0 0 0 1 0 0 0 1 ... #$ Dependents.3.          : num  0 0 0 0 0 0 0 1 0 0 ... #$ Education.Not.Graduate : num  0 0 0 1 0 0 1 0 0 0 ... #$ Self_Employed.No       : num  1 1 0 1 1 0 1 1 1 1 ... #$ Self_Employed.Yes      : num  0 0 1 0 0 1 0 0 0 0 ... #$ ApplicantIncome        : num  0.0729 -0.1343 -0.3934 -0.4617 0.0976 ... #$ CoapplicantIncome      : num  -0.554 -0.0387 -0.554 0.2518 -0.554 ... #$ LoanAmount             : num  0.0162 -0.2151 -0.9395 -0.3086 -0.0632 ... #$ Loan_Amount_Term       : num  0.276 0.276 0.276 0.276 0.276 ... #$ Credit_History         : num  0.432 0.432 0.432 0.432 0.432 ... #$ Property_Area.Semiurban: num  0 0 0 0 0 0 0 1 1 0 ... #$ Property_Area.Urban    : num  1 0 1 1 1 1 1 0 0 1 ... #$ Loan_Status            : Factor w/ 2 levels "0","1": 2 1 2 2 2 2 2 1 1 2 ...

4. Sélection de fonctionnalités avec Caret

La sélection des caractéristiques est une partie extrêmement cruciale de la modélisation. Comprendre l'importance de la sélection des rôles et les différentes techniques utilisées pour la sélection des rôles, Je vous recommande vivement de lire mon article précédent. Pour l'instant, nous utiliserons l'élimination des fonctionnalités récursives, qui est une méthode wrapper pour trouver le meilleur sous-ensemble de fonctionnalités à utiliser dans la modélisation.

#Sélection des fonctionnalités à l'aide de rfe dans le caret
control <- rfeControl(functions = rfFuncs,                    method = "repeatedcv",                    repeats = 3,                    verbose = FALSE) outcomeName<-'Loan_Status' predictors<-names(trainSet)[!names(trainSet) %in% outcomeName] Loan_Pred_Profile <- rfe(trainSet[,predictors], trainSet[,outcomeName],                       rfeControl = control) Loan_Pred_Profile #Recursive feature selection #Outer resampling method: Cross-Validated (10 fold, repeated 3 times) #Resampling performance over subset size: #  Variables Accuracy  Kappa AccuracySD KappaSD Selected #4   0.7737 0.4127    0.03707 0.09962         #8   0.7874 0.4317    0.03833 0.11168         #16   0.7903 0.4527    0.04159 0.11526         #18   0.7882 0.4431    0.03615 0.10812         #The top 5 variables (out of 16): #  Credit_History, LoanAmount, Loan_Amount_Term, ApplicantIncome, CoapplicantIncome #Taking only the top 5 predictors predictors<-c("Credit_History", "LoanAmount", "Loan_Amount_Term", "ApplicantIncome", "CoapplicantIncome")

5. Modèles d'entraînement avec Caret

C'est probablement la partie où Caret se démarque de tous les autres packages disponibles.. Offre la possibilité de mettre en œuvre plus de 200 algorithmes d'apprentissage automatique utilisant une syntaxe cohérente. Pour une liste de tous les algorithmes pris en charge par Caret, Vous pouvez utiliser:

noms(getModelInfo())
#[1] "ada"                 "AdaBag"              "AdaBoost.M1"         "adaboost"           #[5] "amdai"               "ANFIS"               "avNNet"              "awnb"               #[9] "awtan"               "bag"                 "bagEarth"            "bagEarthGCV"        #[13] "bagFDA"              "bagFDAGCV"           "bam"                 "bartMachine"        #[17] "bayesglm"            "bdk"                 "binda"               "blackboost"         #[21] "blasso"              "blassoAveraged"      "Boruta"              "bridge"              #…. #[205] "svmBoundrangeString" "svmExpoString"       "svmLinear"           "svmLinear2"         #[209] "svmLinear3"          "svmLinearWeights"    "svmLinearWeights2"   "svmPoly"            #[213] "svmRadial"           "svmRadialCost"       "svmRadialSigma"      "svmRadialWeights"   #[217] "svmSpectrumString"   "tan"                 "tanSearch"           "treebag"            #[221] "vbmpRadial"          "vglmAdjCat"          "vglmContRatio"       "vglmCumulative"     #[225] "widekernelpls"       "WM"                  "wsrf"                "xgbLinear"          #[229] "xgbTree"             "xyf"

Pour plus de détails sur n'importe quel modèle, vous pouvez consulter ici.

Nous pouvons simplement appliquer un grand nombre d'algorithmes avec une syntaxe similaire. Par exemple, appliquer GBM, forêt aléatoire, réseau de neurones et régression logistique:

model_gbm<-train(trainSet[,predictors],trainSet[,outcomeName],method='gbm') model_rf<-train(trainSet[,predictors],trainSet[,outcomeName],method='rf') model_nnet<-train(trainSet[,predictors],trainSet[,outcomeName],method='nnet') model_glm<-train(trainSet[,predictors],trainSet[,outcomeName],method='glm')

Vous pouvez continuer à régler les paramètres dans tous ces algorithmes à l'aide des techniques de réglage des paramètres.

6. Réglage des paramètres avec Caret

Il est extrêmement facile d'ajuster les paramètres à l'aide de Caret. Normalement, le paramétrage dans Caret se fait comme suit:

Presque chaque étape du processus d'ajustement peut être personnalisée. La technique de rééchantillonnage utilisée pour évaluer les performances du modèle à l'aide d'un jeu de paramètres dans Caret par défaut est le bootstrap, mais il fournit des alternatives pour utiliser k-fold, K-fold répété et validation croisée Leave-one-out (LOOCV) qui peut être spécifié en utilisant trainControl (). Dans cet exemple, nous utiliserons la validation croisée de 5 parties répétées 5 fois.

fitControl <- trainControl(   method = "repeatedcv",   number = 5,   repeats = 5)

Si l'espace de recherche des paramètres n'est pas défini, caret utilisera 3 des valeurs aléatoires de chaque paramètre réglable et utilisera les résultats de la validation croisée pour trouver le meilleur ensemble de paramètres pour cet algorithme. Au contraire, il y a deux autres façons d'ajuster les paramètres:

6.1.Utiliser tuneGrid

Pour trouver les paramètres d'un modèle qui peut être ajusté, vous pouvez utiliser

modelLookup(model="gbm") #model         parameter                   label forReg forClass probModel #1   gbm           n.trees   # Boosting Iterations   TRUE     TRUE      TRUE #2   gbm interaction.depth          Max Tree Depth   TRUE     TRUE      TRUE #3   gbm         shrinkage               Shrinkage   TRUE     TRUE      TRUE #4   gbm    n.minobsinnode Min. Terminal Node Size   TRUE     TRUE      TRUE #using grid search #Creating grid grid <- expand.grid(n.trees=c(10,20,50,100,500,1000),shrinkage=c(0.01,0.05,0.1,0.5),n.minobsinnode = c(3,5,10),interaction.depth=c(1,5,10)) # training the model model_gbm<-train(trainSet[,predictors],trainSet[,outcomeName],method='gbm',trControl=fitControl,tuneGrid=grid) # summarizing the model print(model_gbm) #Stochastic Gradient Boosting #461 samples #5 predictor #2 classes: '0', '1' #No pre-processing #Resampling: Cross-Validated (5 fold, repeated 5 times) #Summary of sample sizes: 368, 370, 369, 369, 368, 369, ... #Resampling results across tuning parameters: #  shrinkage  interaction.depth  n.minobsinnode  n.trees  Accuracy   Kappa    #0.01        1                  3                10     0.6876416  0.0000000 #0.01        1                  3                20     0.6876416  0.0000000 #0.01        1                  3                50     0.7982345  0.4423609 #0.01        1                  3               100     0.7952190  0.4364383 #0.01        1                  3               500     0.7904882  0.4342300 #0.01        1                  3              1000     0.7913627  0.4421230 #0.01        1                  5                10     0.6876416  0.0000000 #0.01        1                  5                20     0.6876416  0.0000000 #0.01        1                  5                50     0.7982345  0.4423609 #0.01        1                  5               100     0.7943635  0.4351912 #0.01        1                  5               500     0.7930783  0.4411348 #0.01        1                  5              1000     0.7913720  0.4417463 #0.01        1                 10                10     0.6876416  0.0000000 #0.01        1                 10                20     0.6876416  0.0000000 #0.01        1                 10                50     0.7982345  0.4423609 #0.01        1                 10               100     0.7943635  0.4351912 #0.01        1                 10               500     0.7939525  0.4426503 #0.01        1                 10              1000     0.7948362  0.4476742 #0.01        5                  3                10     0.6876416  0.0000000 #0.01        5                  3                20     0.6876416  0.0000000 #0.01        5                  3                50     0.7960556  0.4349571 #0.01        5                  3               100     0.7934987  0.4345481 #0.01        5                  3               500     0.7775055  0.4147204 #... #0.50        5                 10               100     0.7045617  0.2834696 #0.50        5                 10               500     0.6924480  0.2650477 #0.50        5                 10              1000     0.7115234  0.3050953 #0.50       10                  3                10     0.7389117  0.3681917 #0.50       10                  3                20     0.7228519  0.3317001 #0.50       10                  3                50     0.7180833  0.3159445 #0.50       10                  3               100     0.7172417  0.3189655 #0.50       10                  3               500     0.7058472  0.3098146 #0.50       10                  3              1000     0.7001852  0.2967784 #0.50       10                  5                10     0.7266895  0.3378430 #0.50       10                  5                20     0.7154746  0.3197905 #0.50       10                  5                50     0.7063535  0.2984819 #0.50       10                  5               100     0.7151012  0.3141440 #0.50       10                  5               500     0.7108516  0.3146822 #0.50       10                  5              1000     0.7147320  0.3225373 #0.50       10                 10                10     0.7314871  0.3327504 #0.50       10                 10                20     0.7150814  0.3081869 #0.50       10                 10                50     0.6993723  0.2815981 #0.50       10                 10               100     0.6977416  0.2719140 #0.50       10                 10               500     0.7037864  0.2854748 #0.50       10                 10              1000     0.6995610  0.2869718

La précision a été utilisée pour sélectionner le modèle optimal en utilisant la plus grande valeur.

Les valeurs finales utilisées pour le modèle étaient n. Arbres = 10, profondeur d'interaction = 1, contraction = 0.05 et n. Aminobsinnodo = 3

terrain(modèle_gbm)

Donc, pour toutes les combinaisons de paramètres que vous avez répertoriées dans expand.grid (), un modèle sera créé et testé en utilisant la validation croisée. L'ensemble de paramètres avec les meilleures performances de validation croisée sera utilisé pour créer le modèle final que vous obtiendrez au final.

6.2. Utilisation de tuneLength

Au lieu de spécifier les valeurs exactes pour chaque paramètre de réglage, nous pouvons simplement lui demander d'utiliser n'importe quel nombre de valeurs possibles pour chaque paramètre de réglage via tuneLength. Essayons un exemple en utilisant tuneLength = 10.

#using tune length model_gbm<-train(trainSet[,predictors],trainSet[,outcomeName],method='gbm',trControl=fitControl,tuneLength=10) print(model_gbm) #Stochastic Gradient Boosting #461 samples #5 predictor #2 classes: '0', '1' #No pre-processing #Resampling: Cross-Validated (5 fold, repeated 5 times) #Summary of sample sizes: 368, 369, 369, 370, 368, 369, ... #Resampling results across tuning parameters: #  interaction.depth  n.trees  Accuracy   Kappa    #1                  50      0.7978084  0.4541008 #1                 100      0.7978177  0.4566764 #1                 150      0.7934792  0.4472347 #1                 200      0.7904310  0.4424091 #1                 250      0.7869714  0.4342797 #1                 300      0.7830488  0.4262414 ... #10                 100      0.7575230  0.3860319 #10                 150      0.7479757  0.3719707 #10                 200      0.7397290  0.3566972 #10                 250      0.7397285  0.3561990 #10                 300      0.7362552  0.3513413 #10                 350      0.7340812  0.3453415 #10                 400      0.7336416  0.3453117 #10                 450      0.7306027  0.3415153 #10                 500      0.7253854  0.3295929

Le paramètre de réglage « retrait’ est resté constant à une valeur de 0,1

Le paramètre de réglage 'n.minobsinnode’ est resté constant à une valeur de 10

La précision a été utilisée pour sélectionner le modèle optimal en utilisant la plus grande valeur.

Les valeurs finales utilisées pour le modèle étaient n. Arbres = 50, profondeur d'interaction = 2, contraction = 0,1 et n. Aminobsinnodo = 10.

plot(model_gbm)

Ici, maintient les paramètres de contraction et n constants. Aminobsinnode en modifiant n. Les arbres et la profondeur de l'interaction sur 10 valeurs et utilise la meilleure combinaison pour former le modèle final.

7. Estimation de l'importance de la variable par entrelacement

Caret rend également les estimations d'importance des variables accessibles avec l'utilisation de varImp () pour tout modèle. Regardons l'importance de la variable pour les quatre modèles que nous avons créés:

#Checking variable importance for GBM #Variable Importance varImp(object=model_gbm) #gbm variable importance #Overall #Credit_History    100.000 #LoanAmount         16.633 #ApplicantIncome     7.104 #CoapplicantIncome   6.773 #Loan_Amount_Term    0.000 #Plotting Varianle importance for GBM plot(varImp(object=model_gbm),main="GBM - Variable Importance")

#Checking variable importance for RF varImp(object=model_rf) #rf variable importance #Overall #Credit_History     100.00 #ApplicantIncome     73.46 #LoanAmount          60.59 #CoapplicantIncome   40.43 #Loan_Amount_Term     0.00 #Plotting Varianle importance for Random Forest plot(varImp(object=model_rf),main="RF - Variable Importance")

#Checking variable importance for NNET varImp(object=model_nnet) #nnet variable importance #Overall #ApplicantIncome    100.00 #LoanAmount          82.87 #CoapplicantIncome   56.92 #Credit_History      41.11 #Loan_Amount_Term     0.00 #Plotting Variable importance for Neural Network plot(varImp(object=model_nnet),main="NNET - Variable Importance")

#Checking variable importance for GLM varImp(object=model_glm) #glm variable importance #Overall #Credit_History    100.000 #CoapplicantIncome  17.218 #Loan_Amount_Term   12.988 #LoanAmount          5.632 #ApplicantIncome     0.000 #Plotting Variable importance for GLM plot(varImp(object=model_glm),main="GLM - Variable Importance")

Clairement, les estimations d'importance variable provenant de différents modèles diffèrent et, donc, pourrait être utilisé pour obtenir une vue plus globale de l'importance de chaque prédicteur. Deux utilisations principales d'importance variable de divers modèles sont:

Les prédicteurs qui sont importants pour la plupart des modèles représentent des prédicteurs vraiment importants.
Dans l'ensemble, nous devrions utiliser des prédictions à partir de modèles qui ont une importance variable significativement différente, puisque vos prédictions devraient également être différentes. Même si, une chose dont vous devez vous assurer est qu'ils sont tous suffisamment précis.

8. Prédictions avec Caret

Pour prédire la variable dépendante pour l'ensemble de test, Caret ofrece prédire.train (). Vous devez spécifier le nom du modèle, données de test. Pour les problèmes de classement, Caret propose également une autre fonctionnalité appelée type qui peut être définie comme “prob” O “cru”. Type de para = « brut », les prédictions ne seront que les classes de résultats pour les données de test, tandis que pour type = "prob", donnera les probabilités d'occurrence de chaque observation dans plusieurs classes de la variable résultat.

Jetons un coup d'œil aux prédictions de notre modèle GBM:

#Predictions predictions<-predict.train(object=model_gbm,testSet[,predictors],type="raw") table(predictions) #predictions #0   1 #28 125

Caret fournit également une fonction confusionMatrix qui fournira la matrice de confusion ainsi que diverses autres métriques pour vos prédictions.. Voici l'analyse des performances de notre modèle GBM:

confusionMatrix(predictions,testSet[,outcomeName]) #Confusion Matrix and Statistics #Reference #Prediction   0   1 #0  25   3 #1  23 102 #Accuracy : 0.8301         #95% CI : (0.761, 0.8859) #No Information Rate : 0.6863         #P-Value [Acc > NIR] : 4.049e-05      #Kappa : 0.555          #Mcnemar's Test P-Value : 0.0001944      #Sensitivity : 0.5208         #Specificity : 0.9714         #Pos Pred Value : 0.8929 #Neg Pred Value : 0.8160         #Prevalence : 0.3137         #Detection Rate : 0.1634         #Detection Prevalence : 0.1830         #Balanced Accuracy : 0.7461         #'Positive' Class : 0

Ressources additionnelles

Remarques finales

Caret est l'un des packages les plus puissants et les plus utiles jamais créés dans R. Il a seulement la capacité de répondre à tous les besoins de modélisation prédictive, du prétraitement à l'interprétation. En outre, sa syntaxe est aussi très simple d'utilisation. Un R, Je vous encourage à utiliser Caret.

Caret est un package très complet et, au lieu de couvrir toutes les fonctionnalités qu'il offre, J'ai pensé que ce serait une meilleure idée de montrer une implémentation de bout en bout de Caret dans un véritable jeu de données hackathon J. J'ai essayé de couvrir autant de fonctions que possible dans Caret, mais Caret a tellement plus à offrir. Approfondir, Vous pouvez trouver les ressources énumérées ci-dessus très utiles. Plusieurs de ces ressources ont été écrites par Max Kuhn lui-même (le créateur du paquet caret).