R Random Forest Tutorial cu exemplu
Evelyn Clarke
Ce este Random Forest în R?
Pădurile aleatorii se bazează pe o idee simplă: „înțelepciunea mulțimii”. Agregarea rezultatelor mai multor predictori oferă o predicție mai bună decât cel mai bun predictor individual. Un grup de predictori se numește an ansamblu. Astfel, această tehnică se numește Învățare prin ansamblu.
În tutorialul anterior, ați învățat cum să utilizați Copacii de decizie pentru a face o predicție binară. Pentru a ne îmbunătăți tehnica, putem antrena un grup de Clasificatori de arbore de decizie, fiecare pe un subset aleatoriu diferit al garniturii. Pentru a face o predicție, obținem doar predicțiile tuturor arborilor indivizi, apoi prezicem clasa care obține cele mai multe voturi. Această tehnică se numește Pădurea întâmplătoare.
Pas 1) Importă datele
Pentru a vă asigura că aveți același set de date ca în tutorialul pentru copaci de decizie, testul trenului și setul de testare sunt stocate pe internet. Le puteți importa fără a face nicio modificare.
library(dplyr)
data_train <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/train.csv")
glimpse(data_train)
data_test <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/test.csv")
glimpse(data_test)
Pasul 2) Antrenează modelul
O modalitate de a evalua performanța unui model este de a-l antrena pe un număr de seturi de date mai mici și de a le evalua pe celălalt set de testare mai mic. Aceasta se numește Validare încrucișată F-fold caracteristică. R are o funcție de a împărți aleatoriu un număr de seturi de date de aproape aceeași dimensiune. De exemplu, dacă k=9, modelul este evaluat în cadrul celor nouă foldere și testat pe setul de testare rămas. Acest proces se repetă până când toate subseturile au fost evaluate. Această tehnică este utilizată pe scară largă pentru selecția modelului, mai ales atunci când modelul are parametri de reglat.
Acum că avem o modalitate de a ne evalua modelul, trebuie să ne dăm seama cum să alegem parametrii care au generalizat cel mai bine datele.
Pădurea aleatoare alege un subset aleatoriu de caracteristici și construiește mulți arbori de decizie. Modelul face o medie a tuturor predicțiilor arborilor de decizii.
Pădurea aleatoare are câțiva parametri care pot fi modificați pentru a îmbunătăți generalizarea predicției. Veți folosi funcția RandomForest() pentru a antrena modelul.
Sintaxa pentru Randon Forest este
RandomForest(formula, ntree=n, mtry=FALSE, maxnodes = NULL) Arguments: - Formula: Formula of the fitted model - ntree: number of trees in the forest - mtry: Number of candidates draw to feed the algorithm. By default, it is the square of the number of columns. - maxnodes: Set the maximum amount of terminal nodes in the forest - importance=TRUE: Whether independent variables importance in the random forest be assessed
notițe: Pădurea aleatoare poate fi antrenată pe mai mulți parametri. Vă puteți referi la vinietă pentru a vedea diferiții parametri.
Reglarea unui model este o muncă foarte obositoare. Există o mulțime de combinații posibile între parametri. Nu aveți neapărat timp să le încercați pe toate. O alternativă bună este să lăsați aparatul să găsească cea mai bună combinație pentru dvs. Există două metode disponibile:
- Căutare aleatorie
- Căutare grilă
Vom defini ambele metode, dar în timpul tutorialului, vom antrena modelul folosind căutarea pe grilă
Definiție de căutare în grilă
Metoda de căutare în grilă este simplă, modelul va fi evaluat peste toată combinația pe care o treceți în funcție, folosind validarea încrucișată.
De exemplu, doriți să încercați modelul cu 10, 20, 30 de arbori și fiecare arbore va fi testat pe un număr de metri egal cu 1, 2, 3, 4, 5. Apoi mașina va testa 15 modele diferite:
.mtry ntrees 1 1 10 2 2 10 3 3 10 4 4 10 5 5 10 6 1 20 7 2 20 8 3 20 9 4 20 10 5 20 11 1 30 12 2 30 13 3 30 14 4 30 15 5 30
Algoritmul va evalua:
RandomForest(formula, ntree=10, mtry=1) RandomForest(formula, ntree=10, mtry=2) RandomForest(formula, ntree=10, mtry=3) RandomForest(formula, ntree=20, mtry=2) ...
De fiecare dată, pădurea aleatoare experimentează cu o validare încrucișată. Un neajuns al căutării pe grilă este numărul de experimente. Poate deveni foarte ușor exploziv atunci când numărul de combinații este mare. Pentru a depăși această problemă, puteți utiliza căutarea aleatorie
Definiție de căutare aleatorie
Marea diferență dintre căutarea aleatorie și căutarea pe grilă este că căutarea aleatoare nu va evalua toată combinația de hiperparametri din spațiul de căutare. În schimb, va alege aleatoriu o combinație la fiecare iterație. Avantajul este că costul de calcul este mai mic.
Setați parametrul de control
Veți proceda după cum urmează pentru a construi și evalua modelul:
- Evaluați modelul cu setarea implicită
- Găsiți cel mai bun număr de mtry
- Găsiți cel mai bun număr de maxnodes
- Găsiți cel mai bun număr de arbori
- Evaluați modelul pe setul de date de testare
Înainte de a începe explorarea parametrilor, trebuie să instalați două biblioteci.
- caret: R bibliotecă de învățare automată. Daca ai instalați R cu r-esențial. Este deja în bibliotecă
- anaconda: conda install -cr r-caret
- e1071: R bibliotecă de învățare automată.
- anaconda: conda install -cr r-e1071
Le puteți importa împreună cu RandomForest
library(randomForest) library(caret) library(e1071)
Setare implicită
Validarea încrucișată K-fold este controlată de funcția trainControl().
trainControl(method = "cv", number = n, search ="grid") arguments - method = "cv": The method used to resample the dataset. - number = n: Number of folders to create - search = "grid": Use the search grid method. For randomized method, use "grid" Note: You can refer to the vignette to see the other arguments of the function.
Puteți încerca să rulați modelul cu parametrii impliciti și să vedeți scorul de precizie.
notițe: Veți folosi aceleași comenzi în timpul întregului tutorial.
# Define the control
trControl <- trainControl(method = "cv",
number = 10,
search = "grid")
Veți folosi biblioteca caret pentru a vă evalua modelul. Biblioteca are o funcție numită train() pentru a evalua aproape toate masina de învățare algoritm. Spune altfel, poți folosi această funcție pentru a antrena alți algoritmi.
Sintaxa de bază este:
train(formula, df, method = "rf", metric= "Accuracy", trControl = trainControl(), tuneGrid = NULL) argument - `formula`: Define the formula of the algorithm - `method`: Define which model to train. Note, at the end of the tutorial, there is a list of all the models that can be trained - `metric` = "Accuracy": Define how to select the optimal model - `trControl = trainControl()`: Define the control parameters - `tuneGrid = NULL`: Return a data frame with all the possible combination
Să încercăm să construim modelul cu valorile implicite.
set.seed(1234)
# Run the model
rf_default <- train(survived~.,
data = data_train,
method = "rf",
metric = "Accuracy",
trControl = trControl)
# Print the results
print(rf_default)
Explicarea codului
- trainControl(method=”cv”, number=10, search=”grid”): Evaluați modelul cu o căutare în grilă de 10 foldere
- train(…): Antrenează un model de pădure aleatoriu. Cel mai bun model este ales cu măsura de precizie.
ieșire:
## Random Forest ## ## 836 samples ## 7 predictor ## 2 classes: 'No', 'Yes' ## ## No pre-processing ## Resampling: Cross-Validated (10 fold) ## Summary of sample sizes: 753, 752, 753, 752, 752, 752, ... ## Resampling results across tuning parameters: ## ## mtry Accuracy Kappa ## 2 0.7919248 0.5536486 ## 6 0.7811245 0.5391611 ## 10 0.7572002 0.4939620 ## ## Accuracy was used to select the optimal model using the largest value. ## The final value used for the model was mtry = 2.
Algoritmul folosește 500 de arbori și a testat trei valori diferite ale mtry: 2, 6, 10.
Valoarea finală utilizată pentru model a fost mtry = 2 cu o precizie de 0.78. Să încercăm să obținem un scor mai mare.
Pasul 2) Căutați cel mai bun mtry
Puteți testa modelul cu valori de mtry de la 1 la 10
set.seed(1234)
tuneGrid <- expand.grid(.mtry = c(1: 10))
rf_mtry <- train(survived~.,
data = data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
ntree = 300)
print(rf_mtry)
Explicarea codului
- tuneGrid <- expand.grid(.mtry=c(3:10)): Construiți un vector cu valoare de la 3:10
Valoarea finală utilizată pentru model a fost mtry = 4.
ieșire:
## Random Forest ## ## 836 samples ## 7 predictor ## 2 classes: 'No', 'Yes' ## ## No pre-processing ## Resampling: Cross-Validated (10 fold) ## Summary of sample sizes: 753, 752, 753, 752, 752, 752, ... ## Resampling results across tuning parameters: ## ## mtry Accuracy Kappa ## 1 0.7572576 0.4647368 ## 2 0.7979346 0.5662364 ## 3 0.8075158 0.5884815 ## 4 0.8110729 0.5970664 ## 5 0.8074727 0.5900030 ## 6 0.8099111 0.5949342 ## 7 0.8050918 0.5866415 ## 8 0.8050918 0.5855399 ## 9 0.8050631 0.5855035 ## 10 0.7978916 0.5707336 ## ## Accuracy was used to select the optimal model using the largest value. ## The final value used for the model was mtry = 4.
Cea mai bună valoare a mtry este stocată în:
rf_mtry$bestTune$mtry
Îl puteți stoca și utiliza atunci când trebuie să reglați ceilalți parametri.
max(rf_mtry$results$Accuracy)
ieșire:
## [1] 0.8110729
best_mtry <- rf_mtry$bestTune$mtry best_mtry
ieșire:
## [1] 4
Pasul 3) Căutați cele mai bune maxnodes
Trebuie să creați o buclă pentru a evalua diferitele valori ale maxnodes. În următorul cod, veți:
- Creați o listă
- Creați o variabilă cu cea mai bună valoare a parametrului mtry; Obligatoriu
- Creați bucla
- Stocați valoarea curentă a lui maxnode
- Rezumați rezultatele
store_maxnode <- list()
tuneGrid <- expand.grid(.mtry = best_mtry)
for (maxnodes in c(5: 15)) {
set.seed(1234)
rf_maxnode <- train(survived~.,
data = data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
maxnodes = maxnodes,
ntree = 300)
current_iteration <- toString(maxnodes)
store_maxnode[[current_iteration]] <- rf_maxnode
}
results_mtry <- resamples(store_maxnode)
summary(results_mtry)
Explicația codului:
- store_maxnode <- list(): Rezultatele modelului vor fi stocate în această listă
- expand.grid(.mtry=best_mtry): Utilizați cea mai bună valoare pentru mtry
- for (maxnodes in c(15:25)) { … }: Calculați modelul cu valorile maxnodes începând de la 15 la 25.
- maxnodes=maxnodes: Pentru fiecare iterație, maxnodes este egal cu valoarea curentă a maxnodes. adică 15, 16, 17, …
- key <- toString(maxnodes): Stochează ca variabilă șir valoarea lui maxnode.
- store_maxnode[[key]] <- rf_maxnode: Salvați rezultatul modelului în listă.
- resamples(store_maxnode): Aranjați rezultatele modelului
- summary(results_mtry): Tipăriți rezumatul tuturor combinațiilor.
ieșire:
## ## Call: ## summary.resamples(object = results_mtry) ## ## Models: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ## Number of resamples: 10 ## ## Accuracy ## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's ## 5 0.6785714 0.7529762 0.7903758 0.7799771 0.8168388 0.8433735 0 ## 6 0.6904762 0.7648810 0.7784710 0.7811962 0.8125000 0.8313253 0 ## 7 0.6904762 0.7619048 0.7738095 0.7788009 0.8102410 0.8333333 0 ## 8 0.6904762 0.7627295 0.7844234 0.7847820 0.8184524 0.8433735 0 ## 9 0.7261905 0.7747418 0.8083764 0.7955250 0.8258749 0.8333333 0 ## 10 0.6904762 0.7837780 0.7904475 0.7895869 0.8214286 0.8433735 0 ## 11 0.7023810 0.7791523 0.8024240 0.7943775 0.8184524 0.8433735 0 ## 12 0.7380952 0.7910929 0.8144005 0.8051205 0.8288511 0.8452381 0 ## 13 0.7142857 0.8005952 0.8192771 0.8075158 0.8403614 0.8452381 0 ## 14 0.7380952 0.7941050 0.8203528 0.8098967 0.8403614 0.8452381 0 ## 15 0.7142857 0.8000215 0.8203528 0.8075301 0.8378873 0.8554217 0 ## ## Kappa ## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's ## 5 0.3297872 0.4640436 0.5459706 0.5270773 0.6068751 0.6717371 0 ## 6 0.3576471 0.4981484 0.5248805 0.5366310 0.6031287 0.6480921 0 ## 7 0.3576471 0.4927448 0.5192771 0.5297159 0.5996437 0.6508314 0 ## 8 0.3576471 0.4848320 0.5408159 0.5427127 0.6200253 0.6717371 0 ## 9 0.4236277 0.5074421 0.5859472 0.5601687 0.6228626 0.6480921 0 ## 10 0.3576471 0.5255698 0.5527057 0.5497490 0.6204819 0.6717371 0 ## 11 0.3794326 0.5235007 0.5783191 0.5600467 0.6126720 0.6717371 0 ## 12 0.4460432 0.5480930 0.5999072 0.5808134 0.6296780 0.6717371 0 ## 13 0.4014252 0.5725752 0.6087279 0.5875305 0.6576219 0.6678832 0 ## 14 0.4460432 0.5585005 0.6117973 0.5911995 0.6590982 0.6717371 0 ## 15 0.4014252 0.5689401 0.6117973 0.5867010 0.6507194 0.6955990 0
Ultima valoare a lui maxnode are cea mai mare precizie. Puteți încerca cu valori mai mari pentru a vedea dacă puteți obține un scor mai mare.
store_maxnode <- list()
tuneGrid <- expand.grid(.mtry = best_mtry)
for (maxnodes in c(20: 30)) {
set.seed(1234)
rf_maxnode <- train(survived~.,
data = data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
maxnodes = maxnodes,
ntree = 300)
key <- toString(maxnodes)
store_maxnode[[key]] <- rf_maxnode
}
results_node <- resamples(store_maxnode)
summary(results_node)
ieșire:
## ## Call: ## summary.resamples(object = results_node) ## ## Models: 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 ## Number of resamples: 10 ## ## Accuracy ## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's ## 20 0.7142857 0.7821644 0.8144005 0.8075301 0.8447719 0.8571429 0 ## 21 0.7142857 0.8000215 0.8144005 0.8075014 0.8403614 0.8571429 0 ## 22 0.7023810 0.7941050 0.8263769 0.8099254 0.8328313 0.8690476 0 ## 23 0.7023810 0.7941050 0.8263769 0.8111302 0.8447719 0.8571429 0 ## 24 0.7142857 0.7946429 0.8313253 0.8135112 0.8417599 0.8690476 0 ## 25 0.7142857 0.7916667 0.8313253 0.8099398 0.8408635 0.8690476 0 ## 26 0.7142857 0.7941050 0.8203528 0.8123207 0.8528758 0.8571429 0 ## 27 0.7023810 0.8060456 0.8313253 0.8135112 0.8333333 0.8690476 0 ## 28 0.7261905 0.7941050 0.8203528 0.8111015 0.8328313 0.8690476 0 ## 29 0.7142857 0.7910929 0.8313253 0.8087063 0.8333333 0.8571429 0 ## 30 0.6785714 0.7910929 0.8263769 0.8063253 0.8403614 0.8690476 0 ## ## Kappa ## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's ## 20 0.3956835 0.5316120 0.5961830 0.5854366 0.6661120 0.6955990 0 ## 21 0.3956835 0.5699332 0.5960343 0.5853247 0.6590982 0.6919315 0 ## 22 0.3735084 0.5560661 0.6221836 0.5914492 0.6422128 0.7189781 0 ## 23 0.3735084 0.5594228 0.6228827 0.5939786 0.6657372 0.6955990 0 ## 24 0.3956835 0.5600352 0.6337821 0.5992188 0.6604703 0.7189781 0 ## 25 0.3956835 0.5530760 0.6354875 0.5912239 0.6554912 0.7189781 0 ## 26 0.3956835 0.5589331 0.6136074 0.5969142 0.6822128 0.6955990 0 ## 27 0.3735084 0.5852459 0.6368425 0.5998148 0.6426088 0.7189781 0 ## 28 0.4290780 0.5589331 0.6154905 0.5946859 0.6356141 0.7189781 0 ## 29 0.4070588 0.5534173 0.6337821 0.5901173 0.6423101 0.6919315 0 ## 30 0.3297872 0.5534173 0.6202632 0.5843432 0.6590982 0.7189781 0
Cel mai mare scor de precizie se obține cu o valoare a maxnode egală cu 22.
Pasul 4) Căutați cele mai bune arbori
Acum că aveți cea mai bună valoare pentru mtry și maxnode, puteți regla numărul de arbori. Metoda este exact aceeași cu maxnode.
store_maxtrees <- list()
for (ntree in c(250, 300, 350, 400, 450, 500, 550, 600, 800, 1000, 2000)) {
set.seed(5678)
rf_maxtrees <- train(survived~.,
data = data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
maxnodes = 24,
ntree = ntree)
key <- toString(ntree)
store_maxtrees[[key]] <- rf_maxtrees
}
results_tree <- resamples(store_maxtrees)
summary(results_tree)
ieșire:
## ## Call: ## summary.resamples(object = results_tree) ## ## Models: 250, 300, 350, 400, 450, 500, 550, 600, 800, 1000, 2000 ## Number of resamples: 10 ## ## Accuracy ## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's ## 250 0.7380952 0.7976190 0.8083764 0.8087010 0.8292683 0.8674699 0 ## 300 0.7500000 0.7886905 0.8024240 0.8027199 0.8203397 0.8452381 0 ## 350 0.7500000 0.7886905 0.8024240 0.8027056 0.8277623 0.8452381 0 ## 400 0.7500000 0.7886905 0.8083764 0.8051009 0.8292683 0.8452381 0 ## 450 0.7500000 0.7886905 0.8024240 0.8039104 0.8292683 0.8452381 0 ## 500 0.7619048 0.7886905 0.8024240 0.8062914 0.8292683 0.8571429 0 ## 550 0.7619048 0.7886905 0.8083764 0.8099062 0.8323171 0.8571429 0 ## 600 0.7619048 0.7886905 0.8083764 0.8099205 0.8323171 0.8674699 0 ## 800 0.7619048 0.7976190 0.8083764 0.8110820 0.8292683 0.8674699 0 ## 1000 0.7619048 0.7976190 0.8121510 0.8086723 0.8303571 0.8452381 0 ## 2000 0.7619048 0.7886905 0.8121510 0.8086723 0.8333333 0.8452381 0 ## ## Kappa ## Min. 1st Qu. Median Mean 3rd Qu. Max. NA's ## 250 0.4061697 0.5667400 0.5836013 0.5856103 0.6335363 0.7196807 0 ## 300 0.4302326 0.5449376 0.5780349 0.5723307 0.6130767 0.6710843 0 ## 350 0.4302326 0.5449376 0.5780349 0.5723185 0.6291592 0.6710843 0 ## 400 0.4302326 0.5482030 0.5836013 0.5774782 0.6335363 0.6710843 0 ## 450 0.4302326 0.5449376 0.5780349 0.5750587 0.6335363 0.6710843 0 ## 500 0.4601542 0.5449376 0.5780349 0.5804340 0.6335363 0.6949153 0 ## 550 0.4601542 0.5482030 0.5857118 0.5884507 0.6396872 0.6949153 0 ## 600 0.4601542 0.5482030 0.5857118 0.5884374 0.6396872 0.7196807 0 ## 800 0.4601542 0.5667400 0.5836013 0.5910088 0.6335363 0.7196807 0 ## 1000 0.4601542 0.5667400 0.5961590 0.5857446 0.6343666 0.6678832 0 ## 2000 0.4601542 0.5482030 0.5961590 0.5862151 0.6440678 0.6656337 0
Ai modelul tău final. Puteți antrena pădurea aleatorie cu următorii parametri:
- ntree =800: vor fi dresați 800 de arbori
- mtry=4: sunt alese 4 caracteristici pentru fiecare iterație
- maxnodes = 24: Maxim 24 de noduri în nodurile terminale (frunze)
fit_rf <- train(survived~.,
data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
ntree = 800,
maxnodes = 24)
Pasul 5) Evaluați modelul
Caretul bibliotecii are o funcție de a face predicții.
predict(model, newdata= df) argument - `model`: Define the model evaluated before. - `newdata`: Define the dataset to make prediction
prediction <-predict(fit_rf, data_test)
Puteți utiliza predicția pentru a calcula matricea de confuzie și pentru a vedea scorul de precizie
confusionMatrix(prediction, data_test$survived)
ieșire:
## Confusion Matrix and Statistics ## ## Reference ## Prediction No Yes ## No 110 32 ## Yes 11 56 ## ## Accuracy : 0.7943 ## 95% CI : (0.733, 0.8469) ## No Information Rate : 0.5789 ## P-Value [Acc > NIR] : 3.959e-11 ## ## Kappa : 0.5638 ## Mcnemar's Test P-Value : 0.002289 ## ## Sensitivity : 0.9091 ## Specificity : 0.6364 ## Pos Pred Value : 0.7746 ## Neg Pred Value : 0.8358 ## Prevalence : 0.5789 ## Detection Rate : 0.5263 ## Detection Prevalence : 0.6794 ## Balanced Accuracy : 0.7727 ## ## 'Positive' Class : No ##
Aveți o precizie de 0.7943 la sută, care este mai mare decât valoarea implicită
Pasul 6) Vizualizați rezultatul
În cele din urmă, puteți analiza importanța caracteristicii cu funcția varImp(). Se pare că cele mai importante caracteristici sunt sexul și vârsta. Acest lucru nu este surprinzător, deoarece caracteristicile importante sunt probabil să apară mai aproape de rădăcina copacului, în timp ce caracteristicile mai puțin importante vor apărea adesea închise de frunze.
varImpPlot(fit_rf)
ieșire:
varImp(fit_rf) ## rf variable importance ## ## Importance ## sexmale 100.000 ## age 28.014 ## pclassMiddle 27.016 ## fare 21.557 ## pclassUpper 16.324 ## sibsp 11.246 ## parch 5.522 ## embarkedC 4.908 ## embarkedQ 1.420 ## embarkedS 0.000
Rezumat
Putem rezuma cum să antrenăm și să evaluăm o pădure aleatoare cu tabelul de mai jos:
| Bibliotecă | Obiectiv | Funcţie | Parametru |
|---|---|---|---|
| randomForest | Creați o pădure aleatorie | RandomForest() | formula, ntree=n, mtry=FALSE, maxnodes = NULL |
| semn de omisiune | Creați validarea încrucișată a folderului K | trainControl() | metoda = „cv”, număr = n, căutare = „grid” |
| semn de omisiune | Antrenează o pădure aleatorie | tren() | formula, df, metoda = „rf”, metric = „Acuratețe”, trControl = trainControl(), tuneGrid = NULL |
| semn de omisiune | Prevede din eșantion | prezice | model, newdata= df |
| semn de omisiune | Matricea de confuzie și statistici | confusionMatrix() | model, y test |
| semn de omisiune | importanță variabilă | cvarImp() | model |
Apendice
Lista modelelor utilizate în caret
names>(getModelInfo())
ieșire:
## [1] "ada" "AdaBag" "AdaBoost.M1" ## [4] "adaboost" "amdai" "ANFIS" ## [7] "avNNet" "awnb" "awtan" ## [10] "bag" "bagEarth" "bagEarthGCV" ## [13] "bagFDA" "bagFDAGCV" "bam" ## [16] "bartMachine" "bayesglm" "binda" ## [19] "blackboost" "blasso" "blassoAveraged" ## [22] "bridge" "brnn" "BstLm" ## [25] "bstSm" "bstTree" "C5.0" ## [28] "C5.0Cost" "C5.0Rules" "C5.0Tree" ## [31] "cforest" "chaid" "CSimca" ## [34] "ctree" "ctree2" "cubist" ## [37] "dda" "deepboost" "DENFIS" ## [40] "dnn" "dwdLinear" "dwdPoly" ## [43] "dwdRadial" "earth" "elm" ## [46] "enet" "evtree" "extraTrees" ## [49] "fda" "FH.GBML" "FIR.DM" ## [52] "foba" "FRBCS.CHI" "FRBCS.W" ## [55] "FS.HGD" "gam" "gamboost" ## [58] "gamLoess" "gamSpline" "gaussprLinear" ## [61] "gaussprPoly" "gaussprRadial" "gbm_h3o" ## [64] "gbm" "gcvEarth" "GFS.FR.MOGUL" ## [67] "GFS.GCCL" "GFS.LT.RS" "GFS.THRIFT" ## [70] "glm.nb" "glm" "glmboost" ## [73] "glmnet_h3o" "glmnet" "glmStepAIC" ## [76] "gpls" "hda" "hdda" ## [79] "hdrda" "HYFIS" "icr" ## [82] "J48" "JRip" "kernelpls" ## [85] "kknn" "knn" "krlsPoly" ## [88] "krlsRadial" "lars" "lars2" ## [91] "lasso" "lda" "lda2" ## [94] "leapBackward" "leapForward" "leapSeq" ## [97] "Linda" "lm" "lmStepAIC" ## [100] "LMT" "loclda" "logicBag" ## [103] "LogitBoost" "logreg" "lssvmLinear" ## [106] "lssvmPoly" "lssvmRadial" "lvq" ## [109] "M5" "M5Rules" "manb" ## [112] "mda" "Mlda" "mlp" ## [115] "mlpKerasDecay" "mlpKerasDecayCost" "mlpKerasDropout" ## [118] "mlpKerasDropoutCost" "mlpML" "mlpSGD" ## [121] "mlpWeightDecay" "mlpWeightDecayML" "monmlp" ## [124] "msaenet" "multinom" "mxnet" ## [127] "mxnetAdam" "naive_bayes" "nb" ## [130] "nbDiscrete" "nbSearch" "neuralnet" ## [133] "nnet" "nnls" "nodeHarvest" ## [136] "null" "OneR" "ordinalNet" ## [139] "ORFlog" "ORFpls" "ORFridge" ## [142] "ORFsvm" "ownn" "pam" ## [145] "parRF" "PART" "partDSA" ## [148] "pcaNNet" "pcr" "pda" ## [151] "pda2" "penalized" "PenalizedLDA" ## [154] "plr" "pls" "plsRglm" ## [157] "polr" "ppr" "PRIM" ## [160] "protoclass" "pythonKnnReg" "qda" ## [163] "QdaCov" "qrf" "qrnn" ## [166] "randomGLM" "ranger" "rbf" ## [169] "rbfDDA" "Rborist" "rda" ## [172] "regLogistic" "relaxo" "rf" ## [175] "rFerns" "RFlda" "rfRules" ## [178] "ridge" "rlda" "rlm" ## [181] "rmda" "rocc" "rotationForest" ## [184] "rotationForestCp" "rpart" "rpart1SE" ## [187] "rpart2" "rpartCost" "rpartScore" ## [190] "rqlasso" "rqnc" "RRF" ## [193] "RRFglobal" "rrlda" "RSimca" ## [196] "rvmLinear" "rvmPoly" "rvmRadial" ## [199] "SBC" "sda" "sdwd" ## [202] "simpls" "SLAVE" "slda" ## [205] "smda" "snn" "sparseLDA" ## [208] "spikeslab" "spls" "stepLDA" ## [211] "stepQDA" "superpc" "svmBoundrangeString"## [214] "svmExpoString" "svmLinear" "svmLinear2" ## [217] "svmLinear3" "svmLinearWeights" "svmLinearWeights2" ## [220] "svmPoly" "svmRadial" "svmRadialCost" ## [223] "svmRadialSigma" "svmRadialWeights" "svmSpectrumString" ## [226] "tan" "tanSearch" "treebag" ## [229] "vbmpRadial" "vglmAdjCat" "vglmContRatio" ## [232] "vglmCumulative" "widekernelpls" "WM" ## [235] "wsrf" "xgbLinear" "xgbTree" ## [238] "xyf"
