Random Forest i R-vejledning: Algoritme med eksempel
Evelyn Clarke
⚡ Smart opsummering
Random Forest i R bygger hundredvis af beslutningstræer på bootstrappede prøver og gennemsnittet af deres stemmer til én robust forudsigelse. Denne gennemgang finjusterer mtry, maxnodes og ntree med caret og evaluerer den endelige model på Titanic-overlevelsesdataene.
Hvad er Random Forest i R?
Tilfældige skove er baseret på en simpel idé: 'mængdens visdom'. Aggregering af resultaterne af flere prædiktorer giver en bedre forudsigelse end den bedste individuelle prædiktor. En gruppe af prædiktorer kaldes en ensemble. Således kaldes denne teknik Ensemble læring.
I en tidligere vejledning lærte du, hvordan man bruger beslutning træer at lave en binær forudsigelse. For at forbedre vores teknik kan vi træne en gruppe af Decision Tree klassifikatorer, hver på en forskellig tilfældig delmængde af togsættet. For at lave en forudsigelse indsamler du forudsigelserne for alle de individuelle træer og returnerer den klasse, der får flest stemmer. Denne teknik kaldes Tilfældig Skov.
Før man skriver kode, er det en god idé at se præcis, hvordan skoven er sammensat af de enkelte træer.
Hvordan fungerer en tilfældig skov i R?
Forståelse af mekanikken gør det lettere at ræsonnere om hver tuningparameter. En tilfældig skov opbygges i fire faser.
- Bootstrap prøveudtagning. Algoritmen tegner en tilfældig stikprøve af rækker med udskiftning fra træningssættet for hvert træ. Omtrent en tredjedel af rækkerne er udeladt af hver stikprøve; disse er observationerne uden for posen (OOB).
- Tilfældig funktionsudvælgelse. Ved hver opdeling tages kun en tilfældig delmængde af prædiktorer i betragtning. Denne delmængdestørrelse er mtry parameter. Begrænsning af valget er det, der forhindrer alle træerne i at ligne hinanden.
- Ubeskåret trævækst. Hvert træ vokser, indtil det stopperping regel som f.eks. maxnoder or nodestørrelseIndividuelle træer får bevidst lov til at overfitte, fordi deres fejl er ukorrelerede.
- Aggregering. Ved klassificering returnerer skoven klassen med flest stemmer; ved regression returnerer den den gennemsnitlige forudsigelse. Dette gennemsnitstrin er, hvad termen sække (bootstrap-aggregering) beskriver.
Rækkesampling plus kolonnesampling er hele tricket. Et enkelt dybt træ har lav bias og meget høj varians; at bruge hundredvis af dem i gennemsnit holder den lave bias, samtidig med at variansen reduceres.
Fejl ved udpakning. Fordi hver observation er udelukket fra omkring en tredjedel af træerne, kan R score hver række ved kun at bruge de træer, der aldrig har set den. Den resulterende OOB-fejl er et gratis, indbygget valideringsestimat, der udskrives af randomForest():
rf_oob <- randomForest(survived~., data = data_train, ntree = 800, mtry = 4) print(rf_oob) # reports the OOB estimate of error rate
OOB-fejlen er en praktisk hurtig kontrol, men denne vejledning bruger tifold krydsvalidering via cirkumfleks, så hvert tuninggitter sammenlignes på identiske foldninger.
Tilfældig skov vs. beslutningstræ i R
En tilfældig skov er et ensemble af det samme beslutning træer dækket i den forrige vejledning, så forskellene er værd at nævne tydeligt, før du vælger mellem dem.
| Kriterier | Beslutningstræ | Tilfældig Skov |
|---|---|---|
| Struktur | Et træ | Hundredvis af træer kombineret ved afstemning |
| varians | Høj, meget følsom over for træningsprøven | Lav, gennemsnittet eliminerer individuelle fejl |
| Risiko for overtilpasning | Høj medmindre beskæret | Lav selv med ubeskårne træer |
| Fortolkningsmulighed | Fuldt læsbar som et flowdiagram | Kun variabel vigtighed er læsbar |
| Udgifter til uddannelse | Meget hurtig | Proportionelt med ntree |
| Indbygget validering | Ingen | Estimat af fejl ved udløbsdato |
| R funktion | rpart() | tilfældigSkov() |
Vælg et enkelt træ, når du skal forklare beslutningsvejen til et ikke-teknisk publikum. Vælg en skov, når prædiktiv nøjagtighed er vigtigere end et læsbart diagram.
Fordele og ulemper ved Random Forest
At vide, hvor algoritmen er stærk og svag, fortæller dig, hvornår den forudgående justeringsindsats er værd at bruge.
Fordele
- Præcision uden beskæring: Midling af mange ukorrelerede træer giver stærke resultater med meget lidt manuel justering.
- Modstandsdygtig over for overmontering: Tilføjelse af flere træer øger aldrig generaliseringsfejlen, så ntree kan hæves sikkert.
- Håndterer blandede data: Numeriske og faktorprædiktorer fungerer side om side, og skalering er unødvendig.
- Gratis validering og rangering: OOB-fejlen og varImp() kommer uden ekstra beregningsomkostninger.
Ulemper
- Uigennemsigtige forudsigelser: du kan ikke tracén enkelt beslutningsvej, hvilket er vigtigt i regulerede miljøer.
- Langsomt i store skove: trænings- og forudsigelsestidsskala lineært med antallet af træer.
- Forudindtagede vigtighedsscorer: Kategoriske variabler med mange niveauer kan se vigtigere ud, end de i virkeligheden er.
- Svag ekstrapolering: For regression kan skoven aldrig forudsige uden for det interval, der ses i træning.
Når teorien og afvejningerne er afklaret, opbygger, finjusterer og evaluerer de næste seks trin en tilfældig skov ende til anden på Titanic-overlevelsesdatasættet.
Trin 1) Importer dataene
For at sikre dig, at du har det samme datasæt som i vejledningen til beslutning træer, togsættet og testsættet hostes online. Du kan importere dem uden at foretage nogen ændringer.
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)
Trin 2) Træn modellen
En måde at evaluere en models ydeevne på er at træne den på en række forskellige mindre datasæt og evaluere dem i forhold til de andre mindre testsæt. Dette kaldes k-fold krydsvalidering. R har en funktion, der tilfældigt opdeler dataene i k delmængder af næsten samme størrelse. Hvis k f.eks. = 10, trænes modellen på ni foldninger og evalueres på den resterende foldning. Denne proces gentages, indtil alle delmængder er blevet evalueret. Denne teknik bruges i vid udstrækning til modeludvælgelse, især når modellen har parametre, der skal justeres.
Nu hvor vi har en måde at evaluere vores model på, skal vi beslutte, hvilke parametre der bedst generaliserer til usete data.
Tilfældig skov vælger en tilfældig delmængde af funktioner og bygger mange beslutningstræer. Modellen udligner alle forudsigelserne fra beslutningstræerne.
Random forest har nogle parametre, der kan ændres for at forbedre generaliseringen af forudsigelsen. Du skal bruge funktionen randomForest() til at træne modellen.
Syntaksen for randomForest() er:
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
Bemærk: Tilfældig skov kan trænes på flere parametre. Du kan henvise til tegnefilm for at se de forskellige parametre.
Det er et kedeligt arbejde at finjustere en model. Der er mange mulige parameterkombinationer. Du har ikke nødvendigvis tid til at prøve dem alle. Et godt alternativ er at lade maskinen finde den bedste kombination for dig. Der er to metoder tilgængelige:
- Tilfældig søgning
- Netsøgning
Begge metoder er defineret nedenfor, men denne vejledning træner modellen ved hjælp af gittersøgning.
Grid Search definition
Gittersøgningsmetoden er enkel, modellen vil blive evalueret over al den kombination, du passerer i funktionen, ved hjælp af krydsvalidering.
For eksempel vil du prøve modellen med 10, 20, 30 antal træer, og hvert træ vil blive testet over et antal mtry svarende til 1, 2, 3, 4, 5. Derefter vil maskinen teste 15 forskellige modeller:
.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
Algoritmen vil evaluere:
randomForest(formula, ntree=10, mtry=1) randomForest(formula, ntree=10, mtry=2) randomForest(formula, ntree=10, mtry=3) randomForest(formula, ntree=20, mtry=2) ...
Hver kombination evalueres med krydsvalidering. Manglen ved gridsøgning er antallet af eksperimenter: det vokser eksplosivt, når antallet af kombinationer er højt. For at overvinde dette problem kan du bruge tilfældig søgning.
Definition af tilfældig søgning
Den store forskel mellem tilfældig søgning og gittersøgning er, at tilfældig søgning ikke evaluerer alle kombinationer af hyperparametre i søgeområdet. I stedet vælger den tilfældigt en kombination ved hver iteration. Fordelen er en meget lavere beregningsomkostning.
Indstil kontrolparameteren
Du vil fortsætte som følger for at konstruere og evaluere modellen:
- Evaluer modellen med standardindstillingen
- Find det bedste antal mtry
- Find det bedste antal maxnodes
- Find det bedste antal ntræer
- Evaluer modellen på testdatasættet
Før du begynder med udforskningen af parametrene, skal du installere to biblioteker.
- caret: R maskinlæringsbibliotek. Hvis du har installer R med r-essentiel. Den ligger allerede på biblioteket
- Anaconda: conda install -cr r-caret
- e1071: R maskinlæringsbibliotek.
- Anaconda: conda install -cr r-e1071
Du kan importere dem sammen med randomForest:
library(randomForest) library(caret) library(e1071)
Standardindstilling
K-fold krydsvalidering styres af trainControl()-funktionen
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.
Du kan prøve at køre modellen med standardparametrene og se nøjagtighedsscore.
Bemærk: Du vil bruge de samme kontroller under hele selvstudiet.
# Define the control trControl <- trainControl(method = "cv", number = 10, search = "grid")
Du vil bruge caret-biblioteket til at evaluere din model. Biblioteket har en funktion kaldet train() til at evaluere næsten alle machine learning algoritme. Sig anderledes, du kan bruge denne funktion til at træne andre algoritmer.
Den grundlæggende syntaks er:
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
Lad os bygge modellen med standardværdierne.
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 Forklaring
- trainControl(method="cv", number="10, search="grid"): Evaluer modellen med en gridsøgning over 10 folder
- tog(...): Træn en tilfældig skovmodel. Bedste model vælges med nøjagtighedsmålet.
Output:
## 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.
Algoritmen bruger 500 træer og testede tre forskellige værdier af mtry: 2, 6, 10.
Den endelige værdi, der blev brugt til modellen, var mtry = 2, med en krydsvalideret nøjagtighed på 0.792. Lad os prøve at få en højere score.
Søg efter den bedste mtry
Du kan teste modellen med værdier på mtry fra 1 til 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 Forklaring
- tuneGrid <- expand.grid(.mtry = c(1:10)): Konstruer en vektor med værdier fra 1 til 10
Output:
## 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.
Den bedste værdi for mtry er 4. Den er gemt i:
rf_mtry$bestTune$mtry
Du kan gemme det og bruge det, når du skal indstille de andre parametre.
max(rf_mtry$results$Accuracy)
Output:
## [1] 0.8110729
best_mtry <- rf_mtry$bestTune$mtry best_mtry
Output:
## [1] 4
Trin 3) Søg efter de bedste maxnodes
Du skal oprette en løkke for at evaluere de forskellige værdier af maxnodes. I følgende kode vil du:
- Opret en liste
- Opret en variabel med den bedste værdi af parameteren mtry; Obligatorisk
- Opret løkken
- Gem den aktuelle værdi af maxnode
- Opsummer resultaterne
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 forklaring:
- store_maxnode <- list(): Resultaterne af modellen vil blive gemt på denne liste
- expand.grid(.mtry=best_mtry): Brug den bedste værdi af mtry
- for (maxnodes in c(5:15)) { … }: Beregn modellen med værdier af maxnodes fra 5 til 15.
- maxnodes = maxnodes: For hver iteration er maxnodes lig med den aktuelle loopværdi, dvs. 5, 6, 7, …
- current_iteration <- toString(maxnodes): Gem værdien af maxnodes som en streng.
- store_maxnode[[current_iteration]] <- rf_maxnode: Gem resultatet af modellen i listen.
- resamples(store_maxnode): Arranger resultaterne af modellen
- summary(results_mtry): Udskriv oversigten over alle kombinationerne.
Output:
## ## 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
Den højeste gennemsnitlige nøjagtighed i dette interval (0.8099) tilhører maxnodes = 14, øverst i det testede interval. Da den bedste værdi ligger i kanten af gitteret, bør du udvide søgningen opad.
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)
Output:
## ## 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
Den højeste gennemsnitlige nøjagtighed, 0.8135, opnås med maxnodes = 24 (maxnodes = 27 stemmer overens med gennemsnittet, men har en lavere tredje kvartil). Du vil derfor bruge maxnodes = 24 til de resterende trin.
Trin 4) Søg efter de bedste træer
Nu hvor du har den bedste værdi af mtry og maxnode, kan du justere antallet af træer. Metoden er nøjagtig den samme som 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)
Output:
## ## 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
Du har din endelige model. Du kan træne den tilfældige skov med følgende parametre:
- ntree = 800: 800 træer vil blive trænet
- mtry = 4: 4 kandidatfunktioner tegnes ved hver opdeling
- maxnodes = 24: Hvert træ er begrænset til 24 terminalnoder (blade)
fit_rf <- train(survived~., data_train, method = "rf", metric = "Accuracy", tuneGrid = tuneGrid, trControl = trControl, importance = TRUE, nodesize = 14, ntree = 800, maxnodes = 24)
Trin 5) Evaluer modellen
Biblioteket har en funktion til at forudsige.
predict(model, newdata= df)
argument
- `model`: Define the model evaluated before.
- `newdata`: Define the dataset to make prediction
prediction <-predict(fit_rf, data_test)
Du kan bruge forudsigelsen til at beregne forvirringsmatricen og se nøjagtighedsscore
confusionMatrix(prediction, data_test$survived)
Output:
## 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 ##
Modellen når en nøjagtighed på 0.7943, det vil sige 79.43 procent på det usete testsæt, hvilket er højere end standardkonfigurationen. Følsomheden er 0.9091, og specificiteten er 0.6364, så modellen genkender ikke-overlevende langt mere pålideligt end overlevende.
Trin 6) Visualiser resultatet
Til sidst kan du se på vigtigheden af funktionerne med funktionen varImp(). De vigtigste funktioner er køn og alder. Det er ikke overraskende, da de vigtige funktioner sandsynligvis vises tættere på træets rod, mens mindre vigtige funktioner normalt vises tættere på bladene.
varImp(fit_rf)
Output:
## 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
Tilfældig skov i R: Hurtig funktionsreference
Tabellen nedenfor viser alle funktioner, der bruges på tværs af de seks trin, den pakke, der leverer den, og de parametre, den forventer.
| Bibliotek | Objektiv | Funktion | Parameter |
|---|---|---|---|
| randomForest | Opret en tilfældig skov | tilfældigSkov() | formel, ntree=n, mtry=FALSE, maxnodes = NULL |
| indskudsmærke | Opret k-fold krydsvalidering | trainControl() | metode = "cv", tal = n, søg = "gitter" |
| indskudsmærke | Træn en tilfældig skov | tog() | formel, df, metode = "rf", metrisk = "Nøjagtighed", trControl = trainControl(), tuneGrid = NULL |
| indskudsmærke | Forudsig ud af prøven | forudsige | model, newdata= df |
| indskudsmærke | Forvirringsmatrix og statistik | confusionMatrix() | model, y test |
| indskudsmærke | Variabel betydning | varImp() | model |
Bilag: Modeller tilgængelige i markeret markering
Funktionen train() kan passe til langt mere end tilfældige skove. Kør kommandoen nedenfor for at udskrive alle modelidentifikatorer, som cirkumfleks understøtter, og send derefter en af dem til metodeargumentet.
names(getModelInfo())
Output:
## [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"
