Implementa l'apprendimento automatico con Caret in R

introduzione

Una delle maggiori sfide che i principianti del machine learning devono affrontare è quali algoritmi imparare e su cosa concentrarsi.. Nel caso di R, il problema è accentuato dal fatto che vari algoritmi avrebbero sintassi diversa, diferentes parametriIl "parametri" sono variabili o criteri che vengono utilizzati per definire, misurare o valutare un fenomeno o un sistema. In vari campi come la statistica, Informatica e Ricerca Scientifica, I parametri sono fondamentali per stabilire norme e standard che guidano l'analisi e l'interpretazione dei dati. La loro corretta selezione e gestione sono fondamentali per ottenere risultati accurati e pertinenti in qualsiasi studio o progetto.... para ajustar y diferentes requisitos en el formato de datos. Potrebbe essere troppo per un principiante.

Quindi, Come puoi trasformarti da principiante a scienziato dei dati costruendo centinaia di modelli e impilandoli insieme? Di certo non ci sono scorciatoie, ma quello che ti dirò oggi ti permetterà di applicare centinaia di modelli di machine learning senza doverlo fare:

• ricorda i diversi nomi dei pacchetti per ogni algoritmo.
• sintassi dell'applicazione di ogni algoritmo.
• parametri da regolare per ogni algoritmo.

Tutto questo è stato possibile grazie agli anni di sforzi che sono andati dietro CARET (FormazioneLa formazione è un processo sistematico volto a migliorare le competenze, conoscenze o abilità fisiche. Viene applicato in vari ambiti, come lo sport, Formazione e sviluppo professionale. Un programma di allenamento efficace include la pianificazione degli obiettivi, Pratica regolare e valutazione dei progressi. L'adattamento alle esigenze individuali e la motivazione sono fattori chiave per ottenere risultati di successo e sostenibili in qualsiasi disciplina.... Classificazione e regressione) che è forse il più grande progetto in R. Questo pacchetto da solo è tutto ciò che devi sapere per risolvere quasi tutti i problemi di apprendimento automatico supervisionato.. Fornisce un'interfaccia uniforme per vari algoritmi di apprendimento automatico e standardizza altre attività come lo slicing dei dati, pre-elaborazione, selezione della funzione, la estimación de importancia variabileIn statistica e matematica, un "variabile" è un simbolo che rappresenta un valore che può cambiare o variare. Esistono diversi tipi di variabili, e qualitativo, che descrivono caratteristiche non numeriche, e quantitativo, che rappresentano quantità numeriche. Le variabili sono fondamentali negli esperimenti e negli studi, poiché consentono l'analisi delle relazioni e dei modelli tra elementi diversi, facilitare la comprensione di fenomeni complessi...., eccetera.

Per una descrizione dettagliata delle varie funzionalità fornite da Caret, puoi fare riferimento a questo articolo.

Oggi lavoreremo sul Problema di previsione del prestito III per mostrarti la potenza del pacchetto Caret.

PD Mentre il cursore semplifica decisamente il lavoro in una certa misura, non può togliere il duro lavoro e la pratica necessari per diventare un maestro nell'apprendimento automatico.

Sommario

1. Di partenza
2. Pre-elaborazione con Caret
3. Dividi i dati con Caret
4. Selezione delle funzioni con Caret
5. Modelli di allenamento con Caret
6. Regolazione dei parametri con Caret
7. Stima di importanza variabile con Caret
8. Fai previsioni con Caret

1. Di partenza

In poche parole, Caret è essenzialmente un contenitore per più di 200 algoritmi di apprendimento automatico. Cosa c'è di più, fornisce diverse funzionalità che lo rendono una soluzione completa per tutte le esigenze di modellazione per problemi di apprendimento automatico supervisionato.

Caret cerca di non caricare tutti i pacchetti da cui dipende all'inizio. Anziché, li carica solo quando servono i pacchi. Ma presuppone che tu abbia già tutti gli algoritmi installati sul tuo sistema.

Per installare Caret sul tuo sistema, usa il seguente comando. Avviso: potrebbe volerci un po' di tempo:

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

Ora, iniziamo a utilizzare il pacchetto di confronto in Problema di previsione del prestito 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 ...

In questo problema, dobbiamo prevedere lo stato del prestito di una persona in base al suo profilo.

2. Pre-elaborazione con Caret

Dobbiamo preelaborare i nostri dati prima di poterli utilizzare per la modellazione. Controlliamo se i dati mancano di valori:

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

Prossimo, usiamo Caret per imputare questi valori mancanti usando l'algoritmo KNN. Prevediamo questi valori mancanti in base ad altri attributi per quella riga. Cosa c'è di più, scaleremo e centreremo i dati numerici utilizzando il comodo preprocesso () e 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

È anche molto facile usare una codifica a caldo in Caret per creare variabili fittizie per ogni livello di una variabile categoriale. Ma prima, convertiremo la variabile dipendente in numerica.

#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 ...

Ora, creazione di variabili fittizie usando la codifica a caldo:

#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)

Qui, “rango pieno = T” creerà solo (n-1) colonne per una colonna categoriale con n livelli diversi. Funziona soprattutto per i predittori categoriali che rappresentano il genere, sposato, eccetera., dove abbiamo solo due livelli: Maschile / Femminile, sì / No, eccetera. perché 0 può essere usato per rappresentare una classe while 1 rappresenta l'altra classe nella stessa colonna.

3. Dividi i dati usando il cursore

Creeremo un set di convalida incrociata dal set di addestramento per valutare il nostro modello. È importante fare più affidamento sul set di convalida incrociata per la valutazione effettiva del modello, altrimenti, potresti finire per sovraccaricare la classifica pubblica.

Useremo createDataPartition () per dividere i nostri dati di allenamento in due insiemi: 75% e 25%. Poiché la nostra variabile di risultato è di natura categorica, questa funzione assicurerà che la distribuzione delle classi delle variabili risultato sia simile in entrambi gli insiemi.

#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. Selezione delle funzioni con Caret

La selezione delle caratteristiche è una parte estremamente cruciale della modellazione. Comprendere l'importanza della selezione dei ruoli e le varie tecniche utilizzate per la selezione dei ruoli, Consiglio vivamente di leggere il mio articolo precedente. Per adesso, useremo l'eliminazione delle caratteristiche ricorsive, che è un metodo wrapper per trovare il miglior sottoinsieme di funzionalità da utilizzare nella modellazione.

#Selezione delle funzioni utilizzando rfe in 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. Modelli di allenamento con Caret

Questa è probabilmente la parte in cui Caret si distingue da ogni altro pacchetto disponibile.. Fornisce la capacità di implementare più di 200 algoritmi di apprendimento automatico che utilizzano una sintassi coerente. Per un elenco di tutti gli algoritmi supportati da Caret, Puoi usare:

nomi(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"

Per maggiori dettagli su qualsiasi modello, puoi consultare qui.

Possiamo semplicemente applicare un gran numero di algoritmi con una sintassi simile. Ad esempio, applicare GBM, foresta casuale, neuronale rossoLe reti neurali sono modelli computazionali ispirati al funzionamento del cervello umano. Usano strutture note come neuroni artificiali per elaborare e apprendere dai dati. Queste reti sono fondamentali nel campo dell'intelligenza artificiale, consentendo progressi significativi in attività come il riconoscimento delle immagini, Elaborazione del linguaggio naturale e previsione delle serie temporali, tra gli altri. La loro capacità di apprendere schemi complessi li rende strumenti potenti.. y regresión logística:

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')

Puoi continuare a regolare i parametri in tutti questi algoritmi utilizzando le tecniche di regolazione dei parametri.

6. Regolazione dei parametri con Caret

È estremamente facile regolare i parametri utilizzando Caret. Normalmente, l'impostazione dei parametri in Caret viene eseguita come segue:

Quasi ogni fase del processo di adattamento può essere personalizzata. La tecnica di ricampionamento utilizzata per valutare le prestazioni del modello utilizzando un parametro impostato in Caret per impostazione predefinita è bootstrap, ma fornisce alternative all'uso di k-fold, Convalida incrociata K-fold ripetuta e Leave-one-out (LOOCV) che può essere specificato usando trainControl (). In questo esempio, useremo la convalida incrociata di 5 parti ripetute 5 volte.

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

Se lo spazio di ricerca dei parametri non è definito, il cursore userà 3 valori casuali di ciascun parametro sintonizzabile e utilizzerà i risultati della convalida incrociata per trovare il miglior set di parametri per quell'algoritmo. Altrimenti, ci sono altri due modi per regolare i parametri:

6.1.Utilizzo di tuneGrid

Per trovare i parametri di un modello che può essere regolato, Puoi usare

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 precisione è stata utilizzata per selezionare il modello ottimale utilizzando il valore più grande.

I valori finali utilizzati per il modello erano n. alberi = 10, profondità di interazione = 1, contrazione = 0.05 e n. Aminobsinnodo = 3

complotto(model_gbm)

Perciò, per tutte le combinazioni di parametri che hai elencato in expand.grid (), un modello verrà creato e testato utilizzando la convalida incrociata. Il set di parametri con le migliori prestazioni di convalida incrociata verrà utilizzato per creare il modello finale che otterrai alla fine.

6.2. Usando tuneLength

Invece di specificare i valori esatti per ogni parametro di sintonizzazione, possiamo semplicemente chiedergli di utilizzare un numero qualsiasi di valori possibili per ciascun parametro di sintonizzazione tramite tuneLength. Proviamo un esempio usando 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

Il parametro di impostazione "restringimento"’ è rimasto costante ad un valore di 0,1

Il parametro di impostazione 'n.minobsinnode’ è rimasto costante ad un valore di 10

La precisione è stata utilizzata per selezionare il modello ottimale utilizzando il valore più grande.

I valori finali utilizzati per il modello erano n. alberi = 50, profondità di interazione = 2, contrazione = 0,1 e n. Aminobsinnodo = 10.

plot(model_gbm)

Qui, mantiene i parametri di contrazione e n costante. Aminobsinnode durante l'alterazione di n. Alberi e profondità di interazione su 10 valori e utilizza la migliore combinazione per addestrare il modello finale.

7. Stima dell'importanza della variabile mediante interlacciamento

Caret rende anche accessibili le stime di importanza delle variabili con l'uso di varImp () per qualsiasi modello. Diamo un'occhiata all'importanza della variabile per i quattro modelli che abbiamo creato:

#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")

Chiaramente, stime di varia importanza da diversi modelli differiscono e, così, potrebbe essere utilizzato per ottenere una visione più olistica dell'importanza di ciascun predittore. Due usi principali di varia importanza di vari modelli sono:

• I predittori che sono importanti per la maggior parte dei modelli rappresentano predittori davvero importanti.
• Su tutto, dovremmo usare previsioni da modelli che hanno un'importanza variabile significativamente diversa, poiché anche le tue previsioni dovrebbero essere diverse. Sebbene, una cosa che devi assicurarti è che siano tutti abbastanza precisi.

8. Pronostici con Caret

Per prevedere la variabile dipendente per il set di test, Caret ofrece forecast.train (). Devi specificare il nome del modello, dati di test. Per problemi di classificazione, Caret offre anche un'altra funzione chiamata tipo che può essere impostata come “probabilmente” oh “crudo”. Tipo Para = "grezzo", le previsioni saranno solo le classi di risultato per i dati del test, mentre per tipo = "prob", darà le probabilità di occorrenza di ciascuna osservazione in diverse classi della variabile risultato.

Diamo un'occhiata alle previsioni del nostro modello GBM:

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

Caret fornisce anche una funzione confusionMatrix che fornirà la matrice di confusione insieme a varie altre metriche per le tue previsioni.. Ecco l'analisi delle prestazioni del nostro modello 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

Risorse addizionali

Note finali

Caret è uno dei pacchetti più potenti e utili mai creati in R. Ha solo la capacità di soddisfare tutte le esigenze di modellazione predittiva dalla preelaborazione all'interpretazione. Cosa c'è di più, la sua sintassi è anche molto facile da usare. un R, Ti incoraggerò a usare Caret.

Caret è un pacchetto molto completo e, invece di coprire tutte le funzionalità che offre, Ho pensato che sarebbe stata un'idea migliore mostrare un'implementazione end-to-end di Caret in un vero set di dati J di hackathon. Ho cercato di coprire quante più funzioni possibile in Caret, ma Caret ha molto di più da offrire. Per approfondire, Potresti trovare le risorse sopra elencate molto utili. Molte di queste risorse sono state scritte dallo stesso Max Kuhn (il creatore del pacchetto caret).

Puoi mettere alla prova le tue abilità e conoscenze. Controllare Competizioni dal vivo e competi con i migliori data scientist di tutto il mondo nei commenti qui sotto.

Imparentato