Slumpmässig skog i R-handledning: Algoritm med exempel
Evelyn Clarke
⚡ Smart sammanfattning
Random Forest i R bygger hundratals beslutsträd på bootstrappade samplingar och medelvärdesbildar deras röster till en robust förutsägelse. Denna genomgång finjusterar mtry, maxnodes och ntree med caret och utvärderar den slutliga modellen på Titanics överlevnadsdata.
Vad är Random Forest i R?
Slumpmässiga skogar bygger på en enkel idé: "massans visdom". Aggregering av resultaten från flera prediktorer ger en bättre förutsägelse än den bästa individuella prediktorn. En grupp av prediktorer kallas en ensemble. Således kallas denna teknik Ensemble Learning.
I en tidigare handledning lärde du dig hur man använder beslutsträd att göra en binär förutsägelse. För att förbättra vår teknik kan vi träna en grupp av Klassificerare av beslutsträd, var och en på en annan slumpmässig delmängd av tåguppsättningen. För att göra en förutsägelse samlar du in förutsägelserna för alla individuella träd och returnerar den klass som får flest röster. Denna teknik kallas Slumpmässig skog.
Innan man skriver någon kod är det bra att se exakt hur skogen är sammansatt av de enskilda träden.
Hur fungerar slumpmässig skog i R?
Att förstå mekaniken gör det lättare att resonera kring varje inställningsparameter. En slumpmässig skog byggs i fyra steg.
- Bootstrap provtagning. Algoritmen ritar ett slumpmässigt urval av rader med byte från träningsmängden för varje träd. Ungefär en tredjedel av raderna utelämnas från varje urval; dessa är observationerna utanför påsen (OOB).
- Slumpmässigt val av funktioner. Vid varje delning beaktas endast en slumpmässig delmängd av prediktorer. Den delmängdens storlek är mtry parameter. Att begränsa valet är det som hindrar alla träd från att se likadana ut.
- Obeskuren trädtillväxt. Varje träd växer tills det stannarping regel som maxnoder or nodstorlekEnskilda träd tillåts medvetet överanpassa, eftersom deras fel är okorrelerade.
- Aggregering. För klassificering returnerar skogen klassen med flest röster; för regression returnerar den den genomsnittliga prediktionen. Detta medelvärdessteg är vad termen säckväv (bootstrap-aggregering) beskriver.
Radprovtagning plus kolumnprovtagning är hela tricket. Ett enda djupt träd har låg bias och mycket hög varians; att i genomsnitt använda hundratals av dem håller den låga biasen samtidigt som variansen sänks.
Fel vid tom påse. Eftersom varje observation exkluderas från ungefär en tredjedel av träden, kan R poängsätta varje rad med hjälp av endast de träd som aldrig såg den. Det resulterande OOB-felet är en fri, inbyggd valideringsuppskattning som skrivs ut av randomForest():
rf_oob <- randomForest(survived~., data = data_train, ntree = 800, mtry = 4) print(rf_oob) # reports the OOB estimate of error rate
OOB-felet är en bekväm snabbkontroll, men den här handledningen använder tiofaldig korsvalidering med cirkumflektor så att varje justeringsrutnät jämförs på identiska vikningar.
Slumpmässig skog kontra beslutsträd i R
En slumpmässig skog är en ensemble av samma beslutsträd behandlades i den föregående handledningen, så skillnaderna är värda att tydligt ange innan du väljer mellan dem.
| Kriterier | Beslutsträd | Slumpmässig skog |
|---|---|---|
| Structure | Ett träd | Hundratals träd kombinerade genom omröstning |
| Variation | Hög, mycket känslig för träningsprovet | Låg, medelvärdesberäkning eliminerar individuella fel |
| Risk för överanpassning | Hög om den inte beskärs | Låg även med obeskurna träd |
| tolkningsbarhet | Fullt läsbar som ett flödesschema | Endast variabel betydelse är läsbar |
| Utbildningskostnad | Mycket snabb | Proportionell mot trädet |
| Inbyggd validering | Ingen | Uppskattning av fel vid tomgångsfel |
| R-funktion | rpart() | slumpmässigForest() |
Välj ett enskilt träd när du måste förklara beslutsvägen för en icke-teknisk publik. Välj en skog när prediktiv noggrannhet är viktigare än ett läsbart diagram.
Fördelar och nackdelar med Random Forest
Att veta var algoritmen är stark och svag visar när det är värt att lägga ner den framtida finjusteringen.
Fördelar
- Noggrannhet utan beskärning: medelvärdesbildning av många okorrelerade träd ger starka resultat med väldigt lite manuell justering.
- Motståndskraftig mot överanpassning: Att lägga till fler träd ökar aldrig generaliseringsfelet, så ntree kan höjas säkert.
- Hanterar blandad data: Numeriska och faktorprediktorer fungerar sida vid sida, och skalning är onödig.
- Gratis validering och ranking: OOB-felet och varImp() medför ingen extra beräkningskostnad.
Nackdelar
- Ogenomskinliga förutsägelser: du kan inte tracen enda beslutsväg, vilket är viktigt i reglerade miljöer.
- Sakta i stora skogar: tränings- och prediktionstidsskala linjärt med antalet träd.
- Partiska viktighetspoäng: Kategoriska variabler med många nivåer kan se viktigare ut än de egentligen är.
- Svag extrapolering: För regression kan skogen aldrig förutsäga utanför det intervall som ses i träning.
När teorin och avvägningarna är avklarade bygger, finjusterar och utvärderar de kommande sex stegen en slumpmässig skog från ände till ände på Titanics överlevnadsdataset.
Steg 1) Importera data
För att se till att du har samma datauppsättning som i handledningen för beslutsträd, tågsetet och testsetet finns online. Du kan importera dem utan att göra några ändringar.
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)
Steg 2) Träna modellen
Ett sätt att utvärdera en modells prestanda är att träna den på ett antal olika mindre datamängder och utvärdera dem jämfört med den andra mindre testuppsättningen. Detta kallas k-faldig korsvalidering. R har en funktion som slumpmässigt delar upp data i k delmängder av nästan samma storlek. Till exempel, om k = 10, tränas modellen på nio veck och utvärderas på den återstående vecken. Denna process upprepas tills alla delmängder har utvärderats. Denna teknik används ofta för modellval, särskilt när modellen har parametrar att finjustera.
Nu när vi har ett sätt att utvärdera vår modell måste vi bestämma vilka parametrar som generaliseras bäst till osynliga data.
Random forest väljer en slumpmässig delmängd av funktioner och bygger många beslutsträd. Modellen gör ett genomsnitt av alla förutsägelser från beslutsträden.
Random forest har vissa parametrar som kan ändras för att förbättra generaliseringen av prediktionen. Du kommer att använda funktionen randomForest() för att träna modellen.
Syntaxen för randomForest() är:
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
Anmärkningar: Slumpmässig skog kan tränas på fler parametrar. Du kan hänvisa till karikatyrerna för att se de olika parametrarna.
Att finjustera en modell är ett mödosamt arbete. Det finns många möjliga parameterkombinationer. Du har inte nödvändigtvis tid att prova alla. Ett bra alternativ är att låta maskinen hitta den bästa kombinationen för dig. Det finns två metoder tillgängliga:
- Slumpmässig sökning
- Rutnätssökning
Båda metoderna definieras nedan, men den här handledningen tränar modellen med hjälp av rutnätssökning.
Grid Search definition
Rutnätssökningsmetoden är enkel, modellen kommer att utvärderas över alla kombinationer du passerar i funktionen, med hjälp av korsvalidering.
Till exempel, du vill prova modellen med 10, 20, 30 antal träd och varje träd kommer att testas över ett antal mtry lika med 1, 2, 3, 4, 5. Sedan kommer maskinen att testa 15 olika 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 kommer att utvärdera:
randomForest(formula, ntree=10, mtry=1) randomForest(formula, ntree=10, mtry=2) randomForest(formula, ntree=10, mtry=3) randomForest(formula, ntree=20, mtry=2) ...
Varje kombination utvärderas med korsvalidering. Nackdelen med rutnätssökning är antalet experiment: det växer explosionsartat när antalet kombinationer är högt. För att övervinna detta problem kan du använda slumpmässig sökning.
Slumpmässig sökning definition
Den stora skillnaden mellan slumpmässig sökning och rutnätssökning är att slumpmässig sökning inte utvärderar alla kombinationer av hyperparametrar i sökområdet. Istället väljer den slumpmässigt en kombination vid varje iteration. Fördelen är en mycket lägre beräkningskostnad.
Ställ in kontrollparametern
Du kommer att gå tillväga enligt följande för att konstruera och utvärdera modellen:
- Utvärdera modellen med standardinställningen
- Hitta det bästa antalet mtry
- Hitta det bästa antalet maxnoder
- Hitta det bästa antalet nträd
- Utvärdera modellen på testdatauppsättningen
Innan du börjar med parametrarnas utforskning måste du installera två bibliotek.
- caret: R maskininlärningsbibliotek. Om du har installera R med r-väsentligt. Den finns redan på biblioteket
- Anakonda: conda installera -cr r-caret
- e1071: R maskininlärningsbibliotek.
- Anakonda: conda installera -cr r-e1071
Du kan importera dem tillsammans med randomForest:
library(randomForest) library(caret) library(e1071)
Standardinställning
K-faldig korsvalidering styrs av 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 prova att köra modellen med standardparametrarna och se noggrannhetspoängen.
Anmärkningar: Du kommer att använda samma kontroller under hela handledningen.
# Define the control trControl <- trainControl(method = "cv", number = 10, search = "grid")
Du kommer att använda caret-biblioteket för att utvärdera din modell. Biblioteket har en funktion som kallas train() för att utvärdera nästan alla maskininlärning algoritm. Säg annorlunda, du kan använda den här funktionen för att träna andra algoritmer.
Den grundläggande syntaxen är:
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
Låt oss bygga modellen med standardvärdena.
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 Förklaring
- trainControl(metod="cv", nummer="10, sök="rutnät"): Utvärdera modellen med en rutnätssökning över 10 veck
- train(...): Träna en slumpmässig skogsmodell. Bästa modellen väljs med noggrannhetsmåttet.
Produktion:
## 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 använder 500 träd och testade tre olika värden på mtry: 2, 6, 10.
Det slutliga värdet som användes för modellen var mtry = 2, med en korsvaliderad noggrannhet på 0.792. Låt oss försöka få en högre poäng.
Sök efter den bästa mtry
Du kan testa modellen med värden på mtry från 1 till 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 Förklaring
- tuneGrid <- expand.grid(.mtry = c(1:10)): Konstruera en vektor med värden från 1 till 10
Produktion:
## 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.
Det bästa värdet för mtry är 4. Det lagras i:
rf_mtry$bestTune$mtry
Du kan lagra den och använda den när du behöver ställa in de andra parametrarna.
max(rf_mtry$results$Accuracy)
Produktion:
## [1] 0.8110729
best_mtry <- rf_mtry$bestTune$mtry best_mtry
Produktion:
## [1] 4
Steg 3) Sök efter de bästa maxnoderna
Du måste skapa en loop för att utvärdera de olika värdena för maxnoder. I följande kod kommer du:
- Skapa en lista
- Skapa en variabel med det bästa värdet av parametern mtry; Obligatorisk
- Skapa slingan
- Lagra det aktuella värdet för maxnode
- Sammanfatta resultaten
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 förklaring:
- store_maxnode <- list(): Resultaten av modellen kommer att lagras i denna lista
- expand.grid(.mtry=bästa_mtry): Använd det bästa värdet av mtry
- for (maxnodes in c(5:15)) { … }: Beräkna modellen med värden för maxnodes från 5 till 15.
- maxnodes = maxnodes: För varje iteration är maxnodes lika med det aktuella loopvärdet, dvs. 5, 6, 7, …
- current_iteration <- toString(maxnodes): Lagra värdet för maxnodes som en sträng.
- store_maxnode[[current_iteration]] <- rf_maxnode: Spara resultatet av modellen i listan.
- resamples(store_maxnode): Ordna resultaten av modellen
- summary(results_mtry): Skriv ut sammanfattningen av alla kombinationer.
Produktion:
## ## 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ögsta medelnoggrannheten i detta intervall (0.8099) tillhör maxnodes = 14, högst upp i det testade intervallet. Eftersom det bästa värdet ligger vid kanten av rutnätet bör du utöka sökningen uppåt.
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)
Produktion:
## ## 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ögsta medelnoggrannheten, 0.8135, erhålls med maxnodes = 24 (maxnodes = 27 är likvärdiga med medelvärdet men har en lägre tredjekvartil). Du kommer därför att använda maxnodes = 24 för de återstående stegen.
Steg 4) Sök efter de bästa träden
Nu när du har det bästa värdet av mtry och maxnode kan du ställa in antalet träd. Metoden är exakt densamma 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)
Produktion:
## ## 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 slutliga modell. Du kan träna den slumpmässiga skogen med följande parametrar:
- ntree = 800: 800 träd kommer att tränas
- mtry = 4: 4 kandidatfunktioner ritas vid varje delning
- maxnodes = 24: Varje träd är begränsat till 24 terminalnoder (löv)
fit_rf <- train(survived~., data_train, method = "rf", metric = "Accuracy", tuneGrid = tuneGrid, trControl = trControl, importance = TRUE, nodesize = 14, ntree = 800, maxnodes = 24)
Steg 5) Utvärdera modellen
Biblioteket har en funktion att göra förutsägelser.
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 använda förutsägelsen för att beräkna förvirringsmatrisen och se noggrannhetspoängen
confusionMatrix(prediction, data_test$survived)
Produktion:
## 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 noggrannhet på 0.7943, det vill säga 79.43 procent på det osedda testet, vilket är högre än standardkonfigurationen. Känsligheten är 0.9091 och specificiteten är 0.6364, så modellen känner igen icke-överlevande mycket mer tillförlitligt än överlevande.
Steg 6) Visualisera resultatet
Slutligen kan du titta på egenskapernas betydelse med funktionen varImp(). De viktigaste egenskaperna är kön och ålder. Det är inte förvånande eftersom de viktiga egenskaperna sannolikt förekommer närmare trädets rot, medan mindre viktiga egenskaper vanligtvis förekommer närmare bladen.
varImp(fit_rf)
Produktion:
## 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
Slumpmässig skog i R: Snabbfunktionsreferens
Tabellen nedan listar alla funktioner som används i de sex stegen, paketet som tillhandahåller den och de parametrar den förväntar sig.
| Bibliotek | Mål | Funktion | Parameter |
|---|---|---|---|
| randomForest | Skapa en slumpmässig skog | slumpmässigForest() | formel, ntree=n, mtry=FALSE, maxnodes = NULL |
| markör | Skapa k-faldig korsvalidering | trainControl() | metod = "cv", nummer = n, sök = "rutnät" |
| markör | Träna en Random Forest | tåg() | formel, df, metod = "rf", metrisk = "noggrannhet", trControl = trainControl(), tuneGrid = NULL |
| markör | Förutsäg ur provet | förutse | modell, newdata= df |
| markör | Förvirringsmatris och statistik | confusionMatrix() | modell, y test |
| markör | Variabel betydelse | varImp() | modell |
Bilaga: Modeller tillgängliga inom cirkumflätad markering
Funktionen train() kan anpassas till betydligt fler än slumpmässiga skogar. Kör kommandot nedan för att skriva ut alla modellidentifierare som stöds av cirkumflektorn, och skicka sedan vilken som helst av dem till metodargumentet.
names(getModelInfo())
Produktion:
## [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"
