R Tutorial sulla foresta casuale con esempio
Evelyn Clarke
Cos'è la foresta casuale in R?
Le foreste casuali si basano su un'idea semplice: "la saggezza della folla". L'aggregazione dei risultati di più predittori fornisce una previsione migliore rispetto al miglior predittore individuale. Un gruppo di predittori è chiamato an insieme. Quindi, questa tecnica viene chiamata Ensemble Learning.
Nel tutorial precedente, hai imparato come utilizzare Alberi decisionali per fare una previsione binaria. Per migliorare la nostra tecnica, possiamo allenare un gruppo di Classificatori dell'albero decisionale, ciascuno su un diverso sottoinsieme casuale del convoglio. Per fare una previsione, dobbiamo semplicemente ottenere le previsioni di tutti i singoli alberi, quindi prevedere la classe che ottiene il maggior numero di voti. Questa tecnica si chiama Foresta casuale.
Passo 1) Importa i dati
Per assicurarti di avere lo stesso set di dati del tutorial per alberi decisionali, il test del treno e il set di test vengono archiviati su Internet. Puoi importarli senza apportare alcuna modifica.
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)
Passaggio 2) Addestrare il modello
Un modo per valutare le prestazioni di un modello è addestrarlo su una serie di set di dati diversi più piccoli e valutarli rispetto all'altro set di test più piccolo. Questo è chiamato il Convalida incrociata F-fold caratteristica. R ha una funzione per dividere in modo casuale un numero di set di dati quasi della stessa dimensione. Ad esempio, se k=9, il modello viene valutato sulla cartella nove e testato sul set di test rimanente. Questo processo viene ripetuto finché tutti i sottoinsiemi non sono stati valutati. Questa tecnica è ampiamente utilizzata per la selezione del modello, soprattutto quando il modello ha parametri da ottimizzare.
Ora che abbiamo un modo per valutare il nostro modello, dobbiamo capire come scegliere i parametri che generalizzano meglio i dati.
La foresta casuale sceglie un sottoinsieme casuale di funzionalità e costruisce molti alberi decisionali. Il modello calcola la media di tutte le previsioni degli alberi decisionali.
La foresta casuale ha alcuni parametri che possono essere modificati per migliorare la generalizzazione della previsione. Utilizzerai la funzione RandomForest() per addestrare il modello.
La sintassi per Randon Forest è
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
Note:: La foresta casuale può essere addestrata su più parametri. Puoi fare riferimento a vignette per vedere i diversi parametri.
Mettere a punto un modello è un lavoro molto noioso. Ci sono molte combinazioni possibili tra i parametri. Non hai necessariamente il tempo di provarli tutti. Una buona alternativa è lasciare che sia la macchina a trovare la combinazione migliore per te. Sono disponibili due metodi:
- Ricerca casuale
- Grid Search
Definiremo entrambi i metodi ma durante il tutorial addestreremo il modello utilizzando la ricerca nella griglia
Definizione della ricerca in griglia
Il metodo di ricerca della griglia è semplice, il modello verrà valutato su tutte le combinazioni passate nella funzione, utilizzando la convalida incrociata.
Ad esempio, vuoi provare il modello con 10, 20, 30 numeri di alberi e ogni albero verrà testato su un numero di metri pari a 1, 2, 3, 4, 5. Quindi la macchina testerà 15 modelli diversi:
.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
L’algoritmo valuterà:
RandomForest(formula, ntree=10, mtry=1) RandomForest(formula, ntree=10, mtry=2) RandomForest(formula, ntree=10, mtry=3) RandomForest(formula, ntree=20, mtry=2) ...
Ogni volta, la foresta casuale sperimenta una convalida incrociata. Uno svantaggio della ricerca sulla griglia è il numero di sperimentazioni. Può diventare molto facilmente esplosivo quando il numero di combinazioni è elevato. Per superare questo problema, puoi utilizzare la ricerca casuale
Definizione di ricerca casuale
La grande differenza tra la ricerca casuale e la ricerca in griglia è che la ricerca casuale non valuterà tutte le combinazioni di iperparametri nello spazio di ricerca. Invece, sceglierà casualmente la combinazione a ogni iterazione. Il vantaggio è che riduce il costo computazionale.
Impostare il parametro di controllo
Si procederà come segue per costruire e valutare il modello:
- Valutare il modello con l'impostazione predefinita
- Trova il miglior numero di metri
- Trova il miglior numero di maxnodi
- Trova il miglior numero di nalberi
- Valutare il modello sul set di dati di test
Prima di iniziare con l'esplorazione dei parametri, è necessario installare due librerie.
- accento circonflesso: libreria di machine learning R. Se hai installa r con r-essenziale. È già in biblioteca
- Anaconda: conda install -cr r-caret
- e1071: libreria di apprendimento automatico R.
- Anaconda: conda install -cr r-e1071
Puoi importarli insieme a RandomForest
library(randomForest) library(caret) library(e1071)
Impostazione predefinita
La convalida incrociata K-fold è controllata dalla funzione 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.
Puoi provare a eseguire il modello con i parametri predefiniti e vedere il punteggio di precisione.
Note:: utilizzerai gli stessi controlli durante tutto il tutorial.
# Define the control
trControl <- trainControl(method = "cv",
number = 10,
search = "grid")
Utilizzerai la libreria di punti circonferenza per valutare il tuo modello. La libreria ha una funzione chiamata train() per valutare quasi tutti machine learning algoritmo. In altre parole, puoi utilizzare questa funzione per addestrare altri algoritmi.
La sintassi di base è:
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
Proviamo a creare il modello con i valori predefiniti.
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)
Spiegazione del codice
- trainControl(method="cv", number=10, search="grid"): Valuta il modello con una ricerca a griglia di 10 cartelle
- train(…): addestra un modello di foresta casuale. Il modello migliore viene scelto con la misura di accuratezza.
Produzione:
## 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.
L'algoritmo utilizza 500 alberi e testa tre diversi valori di mtry: 2, 6, 10.
Il valore finale utilizzato per il modello era mtry = 2 con una precisione di 0.78. Proviamo a ottenere un punteggio più alto.
Passaggio 2) Cerca il miglior mtry
Puoi testare il modello con valori di mtry da 1 a 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)
Spiegazione del codice
- tuneGrid <- espanso.grid(.mtry=c(3:10)): costruisce un vettore con valore da 3:10
Il valore finale utilizzato per il modello era mtry = 4.
Produzione:
## 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.
Il miglior valore di mtry è memorizzato in:
rf_mtry$bestTune$mtry
Puoi memorizzarlo e usarlo quando hai bisogno di regolare gli altri parametri.
max(rf_mtry$results$Accuracy)
Produzione:
## [1] 0.8110729
best_mtry <- rf_mtry$bestTune$mtry best_mtry
Produzione:
## [1] 4
Passaggio 3) Cerca i migliori maxnode
Devi creare un ciclo per valutare i diversi valori di maxnodes. Nel seguente codice, dovrai:
- Creare un elenco
- Crea una variabile con il miglior valore del parametro mtry; Obbligatorio
- Crea il ciclo
- Memorizza il valore corrente di maxnode
- Riassumi i risultati
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)
Spiegazione del codice:
- store_maxnode <- list(): i risultati del modello verranno archiviati in questo elenco
- expand.grid(.mtry=best_mtry): utilizza il miglior valore di mtry
- for (maxnodes in c(15:25)) { … }: calcola il modello con valori di maxnodes a partire da 15 a 25.
- maxnodes=maxnodes: per ogni iterazione, maxnodes è uguale al valore corrente di maxnodes. cioè 15, 16, 17, …
- key <- toString(maxnodes): memorizza come variabile stringa il valore di maxnode.
- store_maxnode[[key]] <- rf_maxnode: salva il risultato del modello nell'elenco.
- resamples(store_maxnode): organizza i risultati del modello
- summary(results_mtry): stampa il riepilogo di tutte le combinazioni.
Produzione:
## ## 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
L'ultimo valore di maxnode ha la massima precisione. Puoi provare con valori più alti per vedere se riesci a ottenere un punteggio più alto.
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)
Produzione:
## ## 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
Il punteggio di accuratezza più alto si ottiene con un valore di maxnode pari a 22.
Passaggio 4) Cerca gli alberi migliori
Ora che hai il miglior valore di mtry e maxnode, puoi ottimizzare il numero di alberi. Il metodo è esattamente lo stesso di 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)
Produzione:
## ## 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
Hai il tuo modello finale. Puoi addestrare la foresta casuale con i seguenti parametri:
- ntree=800: verranno formati 800 alberi
- mtry=4: vengono scelte 4 funzionalità per ogni iterazione
- maxnodes = 24: massimo 24 nodi nei nodi terminali (foglie)
fit_rf <- train(survived~.,
data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
ntree = 800,
maxnodes = 24)
Passaggio 5) Valutare il modello
Il cursore della libreria ha una funzione per fare previsioni.
predict(model, newdata= df) argument - `model`: Define the model evaluated before. - `newdata`: Define the dataset to make prediction
prediction <-predict(fit_rf, data_test)
È possibile utilizzare la previsione per calcolare la matrice di confusione e visualizzare il punteggio di precisione
confusionMatrix(prediction, data_test$survived)
Produzione:
## 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 ##
Hai una precisione dello 0.7943%, che è superiore al valore predefinito
Passaggio 6) Visualizza il risultato
Infine, puoi esaminare l'importanza delle funzionalità con la funzione varImp(). Sembra che le caratteristiche più importanti siano il sesso e l'età. Ciò non sorprende perché è probabile che le caratteristiche importanti appaiano più vicine alla radice dell'albero, mentre le caratteristiche meno importanti appariranno spesso vicino alle foglie.
varImpPlot(fit_rf)
Produzione:
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
Sommario
Possiamo riassumere come addestrare e valutare una foresta casuale con la tabella seguente:
| Biblioteca | Obiettivo | Funzione | Parametro |
|---|---|---|---|
| randomForest | Crea una foresta casuale | Foresta Casuale() | formula, ntree=n, mtry=FALSE, maxnodes = NULL |
| segno di omissione | Crea convalida incrociata della cartella K | trainControl() | metodo = “cv”, numero = n, ricerca =”griglia” |
| segno di omissione | Addestra una foresta casuale | treno() | formula, df, metodo = “rf”, metric= “Precisione”, trControl = trainControl(), tuneGrid = NULL |
| segno di omissione | Prevedere fuori campione | predire | modello, nuovi dati=df |
| segno di omissione | Matrice di confusione e statistica | confusioneMatrice() | modello, e test |
| segno di omissione | importanza variabile | cvarImp() | modello |
Appendice
Elenco dei modelli utilizzati nel cursore
names>(getModelInfo())
Produzione:
## [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"
