Tutorial Random Forest în R: Algoritm cu exemplu
Evelyn Clarke
⚡ Rezumat inteligent
Random Forest în R construiește sute de arbori de decizie pe eșantioane bootstrappate și calculează media voturilor acestora într-o singură predicție robustă. Această demonstrație ghidează mtry, maxnodes și ntree cu caret și evaluează modelul final pe baza datelor de supraviețuire a Titanicului.
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.
Într-un tutorial anterior, ați învățat cum să utilizați copaci 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 o submulțime aleatorie diferită a setului de trenuri. Pentru a face o predicție, colectați predicțiile tuturor arborilor individuali și returnați clasa care primește cele mai multe voturi. Această tehnică se numește Pădurea întâmplătoare.
Înainte de a scrie orice cod, este util să vedem exact cum este asamblată pădurea din acei copaci individuali.
Cum funcționează Random Forest în R?
Înțelegerea mecanicii face ca fiecare parametru de reglare să fie mai ușor de raționat. O pădure aleatorie este construită în patru etape.
- Bootstrap prelevarea de probe. Algoritmul extrage un eșantion aleatoriu de rânduri cu înlocuire din setul de antrenament pentru fiecare arbore. Aproximativ o treime din rânduri sunt omise din fiecare eșantion; acestea sunt observațiile out-of-bag (OOB).
- Selecție aleatorie a caracteristicilor. La fiecare divizare, se ia în considerare doar un subset aleatoriu de predictori. Dimensiunea acelui subset este mtry parametru. Restricționarea alegerii este ceea ce împiedică toți copacii să arate la fel.
- Creșterea copacilor netăiați. Fiecare copac crește până se opreșteping regulă precum maxnodes or dimensiunea noduluiArborii individuali sunt lăsați în mod deliberat să se supraadapteze, deoarece erorile lor nu sunt corelate.
- Agregare. Pentru clasificare, pădurea returnează clasa cu cele mai multe voturi; pentru regresie, returnează predicția medie. Acest pas de mediere este ceea ce termenul insacuire (agregare bootstrap) descrie.
Eșantionarea pe rânduri plus eșantionarea pe coloane este întregul truc. Un singur arbore adânc are o abatere de la normal scăzută și o varianță foarte mare; media a sutelor de arbori menține abaterea de la normal scăzută, reducând în același timp varianța.
Eroare „out of bag” (în afara pungii). Deoarece fiecare observație este exclusă din aproximativ o treime dintre arbori, R poate evalua fiecare rând folosind doar arborii care nu au văzut-o niciodată. Eroarea OOB rezultată este o estimare de validare gratuită, încorporată, afișată de randomForest():
rf_oob <- randomForest(survived~., data = data_train, ntree = 800, mtry = 4) print(rf_oob) # reports the OOB estimate of error rate
Eroarea OOB este o verificare rapidă și convenabilă, dar acest tutorial folosește validarea încrucișată de zece ori prin caret, astfel încât fiecare grilă de reglare este comparată pe pliuri identice.
Pădure aleatorie vs. arbore de decizie în R
O pădure aleatorie este un ansamblu de aceleași elemente copaci de decizie acoperite în tutorialul anterior, așa că diferențele merită menționate clar înainte de a alege între ele.
| Criterii | Arborele de Decizii | Pădurea întâmplătoare |
|---|---|---|
| Structure | Un copac | Sute de copaci combinați prin vot |
| variație | Ridicat, foarte sensibil la eșantionul de antrenament | Scăzut, media anulează erorile individuale |
| Riscul de supraadaptare | Ridicat, cu excepția cazului în care este tăiat | Scăzut chiar și cu copaci netăiați |
| interpretabilitate | Complet lizibil ca diagramă logică | Doar importanța variabilelor este lizibilă |
| Costul instruirii | Foarte rapid | Proporțional cu ntree |
| Validare încorporată | Nici unul | Estimarea erorii out-of-bag |
| Funcția R | rpart() | randomForest() |
Alegeți un singur arbore atunci când trebuie să explicați calea decizională unui public non-tehnic. Alegeți o pădure ori de câte ori acuratețea predictivă contează mai mult decât o diagramă lizibilă.
Avantajele și dezavantajele pădurii aleatorii
Cunoașterea punctelor forte și a punctelor slabe ale algoritmului îți spune când merită efortul de optimizare care urmează.
Avantaje
- Precizie fără tăiere: medierea mai multor arbori necorelați oferă rezultate puternice cu foarte puține reglaje manuale.
- Rezistent la suprasolicitare: Adăugarea mai multor arbori nu crește niciodată eroarea de generalizare, deci ntree poate fi generat în siguranță.
- Gestionează date mixte: Predictorii numerici și factoriali funcționează împreună, iar scalarea este inutilă.
- Validare și clasificare gratuite: Eroarea OOB și varImp() nu au costuri de calcul suplimentare.
Dezavantaje
- Predicții opace: nu poți traco singură cale decizională, ceea ce contează în mediile reglementate.
- Lent în pădurile mari: scara de timp de antrenament și predicție liniar cu numărul de copaci.
- Scoruri de importanță distorsionate: Variabilele categorice cu mai multe niveluri pot părea mai importante decât sunt în realitate.
- Extrapolare slabă: pentru regresie, pădurea nu poate niciodată prezice în afara intervalului observat în antrenament.
Odată stabilite teoria și compromisurile, următorii șase pași construiesc, ajustează și evaluează o pădure aleatorie de la un capăt la altul pe setul de date privind supraviețuirea Titanicului.
Pasul 1) Importați datele
Pentru a vă asigura că aveți același set de date ca în tutorialul pentru copaci de decizie, setul de trenuri și setul de testare sunt găzduite online. 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 mai multe seturi de date diferite, mai mici, și de a le evalua pe baza celuilalt set de testare mai mic. Aceasta se numește k-fold de validare încrucișată. R are o funcție care împarte aleatoriu datele în k subseturi de aproape aceeași dimensiune. De exemplu, dacă k = 10, modelul este antrenat pe nouă pliuri și evaluat pe pliul 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, în special atunci când modelul are parametri de reglat.
Acum, că avem o modalitate de a evalua modelul nostru, trebuie să decidem care parametri se generalizează cel mai bine pentru date nevăzute.
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 aleatorie are anumiți parametri care pot fi modificați pentru a îmbunătăți generalizarea predicției. Veți utiliza funcția randomForest() pentru a antrena modelul.
Sintaxa pentru randomForest() 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 candidate variables drawn at each split. By default, it is the square root of the number of predictors for classification. - maxnodes: Set the maximum number of terminal nodes each tree can have - 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ă plictisitoare. Există multe combinații posibile de parametri. Nu aveți neapărat timp să le încercați pe toate. O alternativă bună este să lăsați mașina să găsească cea mai bună combinație pentru dvs. Există două metode disponibile:
- Căutare aleatorie
- Căutare grilă
Ambele metode sunt definite mai jos, dar acest tutorial antrenează modelul folosind căutarea în 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) ...
Fiecare combinație este evaluată prin validare încrucișată. Dezavantajul căutării în grilă este numărul de experimente: acesta crește 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 în grilă este că, în cazul căutării aleatorii, nu se vor evalua toate combinațiile de hiperparametri din spațiul de căutare. În schimb, se vor alege aleatoriu combinațiile la fiecare iterație. Avantajul constă într-un cost de calcul mult 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 poț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 folds to create - search = "grid": Use the grid search method. For the randomized method, use "random" 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ă 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)
Code Explicație
- trainControl(method=”cv”, number=10, search=”grid”): Evaluează modelul cu o căutare în grilă pe 10 pliuri
- 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 validată încrucișat de 0.792. Să încercăm să obținem un scor mai mare.
Caută cele mai bune 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)
Code Explicație
- tuneGrid <- expand.grid(.mtry = c(1:10)): Construiește un vector cu valori de la 1 la 10
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 lui mtry este 4. Aceasta 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)
Code explicaţie:
- 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(5:15)) { … }: Calculați modelul cu valori ale maxnodelor de la 5 la 15.
- maxnodes = maxnodes: Pentru fiecare iterație, maxnodes este egal cu valoarea curentă a buclei, adică 5, 6, 7, ...
- current_iteration <- toString(maxnodes): Stochează valoarea lui maxnodes ca șir de caractere.
- store_maxnode[[current_iteration]] <- rf_maxnode: Salvează 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
Cea mai mare precizie medie în acest interval (0.8099) aparține maxnodes = 14, în partea superioară a intervalului testat. Deoarece cea mai bună valoare se află la marginea grilei, ar trebui să extindeți căutarea în sus.
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
Cea mai mare precizie medie, 0.8135, se obține cu maxnodes = 24 (maxnodes = 27 se leagă de medie, dar are o a treia cuartilă inferioară). Prin urmare, veți utiliza maxnodes = 24 pentru pașii rămași.
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: 800 de arbori vor fi antrenați
- mtry = 4: 4 caracteristici candidate sunt desenate la fiecare divizare
- maxnodes = 24: Fiecare arbore este limitat la 24 de noduri 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 ##
Modelul atinge o precizie de 0.7943, adică 79.43% pe setul de teste nevăzute, ceea ce este mai mare decât configurația implicită. Sensibilitatea este de 0.9091, iar specificitatea este de 0.6364, astfel încât modelul recunoaște persoanele care nu supraviețuiesc mult mai fiabil decât cele care supraviețuiesc.
Pasul 6) Vizualizați rezultatul
În cele din urmă, puteți analiza importanța caracteristicilor cu funcția varImp(). Cele mai importante caracteristici sunt sexul și vârsta. Acest lucru nu este surprinzător, deoarece caracteristicile importante sunt susceptibile de a apărea mai aproape de rădăcina arborelui, în timp ce caracteristicile mai puțin importante apar de obicei mai aproape de frunze.
varImp(fit_rf)
ieșire:
## 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
Pădure aleatorie în R: Referință rapidă a funcțiilor
Tabelul de mai jos listează fiecare funcție utilizată în cei șase pași, pachetul care o furnizează și parametrii pe care îi așteaptă.
| 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 validare încrucișată k-fold | 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ă | varImp() | model |
Anexă: Modele disponibile în semnul caret
Funcția train() poate include mult mai multe tipuri de păduri decât păduri aleatorii. Rulați comanda de mai jos pentru a afișa fiecare identificator de model suportat de caret, apoi transmiteți oricare dintre acestea argumentului metodei.
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"
