आर रैंडम फ़ॉरेस्ट ट्यूटोरियल उदाहरण के साथ
एवलिन क्लार्क
आर में रैंडम फ़ॉरेस्ट क्या है?
रैंडम फ़ॉरेस्ट एक सरल विचार पर आधारित हैं: 'भीड़ की बुद्धि'। कई भविष्यवक्ताओं के परिणामों का योग सर्वश्रेष्ठ व्यक्तिगत भविष्यवक्ता की तुलना में बेहतर भविष्यवाणी देता है। भविष्यवक्ताओं के एक समूह को एक भविष्यवक्ता कहा जाता है एक साथ. इस प्रकार, इस तकनीक को कहा जाता है पहनावा सीखना.
पिछले ट्यूटोरियल में, आपने सीखा कि इसका उपयोग कैसे करें निर्णय के पेड़ बाइनरी भविष्यवाणी करने के लिए। अपनी तकनीक को बेहतर बनाने के लिए, हम एक समूह को प्रशिक्षित कर सकते हैं निर्णय वृक्ष वर्गीकरणकर्ता, प्रत्येक ट्रेन सेट के एक अलग यादृच्छिक उपसमूह पर। भविष्यवाणी करने के लिए, हम बस सभी व्यक्तिगत पेड़ों की भविष्यवाणियां प्राप्त करते हैं, फिर उस वर्ग की भविष्यवाणी करते हैं जिसे सबसे अधिक वोट मिलते हैं। इस तकनीक को कहा जाता है बेतरतीब जंगल.
चरण 1) डेटा आयात करें
यह सुनिश्चित करने के लिए कि आपके पास ट्यूटोरियल के समान ही डेटासेट है निर्णय के पेड़ट्रेन टेस्ट और टेस्ट सेट इंटरनेट पर संग्रहीत हैं। आप उन्हें बिना कोई बदलाव किए आयात कर सकते हैं।
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)
चरण 2) मॉडल को प्रशिक्षित करें
किसी मॉडल के प्रदर्शन का मूल्यांकन करने का एक तरीका यह है कि उसे कई अलग-अलग छोटे डेटासेट पर प्रशिक्षित किया जाए और अन्य छोटे परीक्षण सेट पर उनका मूल्यांकन किया जाए। इसे कहा जाता है एफ-फोल्ड क्रॉस-वैलिडेशन सुविधा. R लगभग समान आकार के डेटासेट की संख्या को यादृच्छिक रूप से विभाजित करने के लिए एक फ़ंक्शन है। उदाहरण के लिए, यदि k=9 है, तो मॉडल का मूल्यांकन नौ फ़ोल्डर पर किया जाता है और शेष परीक्षण सेट पर परीक्षण किया जाता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक कि सभी उपसमूहों का मूल्यांकन नहीं हो जाता। इस तकनीक का व्यापक रूप से मॉडल चयन के लिए उपयोग किया जाता है, खासकर जब मॉडल में ट्यून करने के लिए पैरामीटर होते हैं।
अब जबकि हमारे पास अपने मॉडल का मूल्यांकन करने का एक तरीका है, हमें यह पता लगाना होगा कि उन मापदंडों का चयन कैसे किया जाए जो डेटा को सर्वोत्तम रूप से सामान्यीकृत करते हैं।
रैंडम फ़ॉरेस्ट सुविधाओं का एक यादृच्छिक उपसमूह चुनता है और कई निर्णय वृक्ष बनाता है। मॉडल निर्णय वृक्षों की सभी भविष्यवाणियों का औसत निकालता है।
रैंडम फ़ॉरेस्ट में कुछ पैरामीटर होते हैं जिन्हें पूर्वानुमान के सामान्यीकरण को बेहतर बनाने के लिए बदला जा सकता है। मॉडल को प्रशिक्षित करने के लिए आप फ़ंक्शन RandomForest() का उपयोग करेंगे।
रैंडन फ़ॉरेस्ट का वाक्यविन्यास है
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
नोट: रैंडम फ़ॉरेस्ट को ज़्यादा पैरामीटर पर प्रशिक्षित किया जा सकता है। आप इसका संदर्भ ले सकते हैं शब्दचित्र विभिन्न मापदंडों को देखने के लिए.
मॉडल को ट्यून करना बहुत ही थकाऊ काम है। मापदंडों के बीच बहुत सारे संयोजन संभव हैं। जरूरी नहीं कि आपके पास उन सभी को आजमाने का समय हो। एक अच्छा विकल्प यह है कि मशीन को आपके लिए सबसे अच्छा संयोजन खोजने दें। इसके लिए दो तरीके उपलब्ध हैं:
- यादृच्छिक खोज
- ग्रिड खोज
हम दोनों विधियों को परिभाषित करेंगे लेकिन ट्यूटोरियल के दौरान, हम ग्रिड सर्च का उपयोग करके मॉडल को प्रशिक्षित करेंगे
ग्रिड खोज परिभाषा
ग्रिड खोज विधि सरल है, मॉडल का मूल्यांकन क्रॉस-वैलिडेशन का उपयोग करके, फ़ंक्शन में आपके द्वारा पास किए गए सभी संयोजनों पर किया जाएगा।
उदाहरण के लिए, आप 10, 20, 30 पेड़ों के साथ मॉडल का परीक्षण करना चाहते हैं और प्रत्येक पेड़ का परीक्षण 1, 2, 3, 4, 5 के बराबर मीटरी संख्या पर किया जाएगा। फिर मशीन 15 अलग-अलग मॉडलों का परीक्षण करेगी:
.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
एल्गोरिथ्म निम्नलिखित का मूल्यांकन करेगा:
RandomForest(formula, ntree=10, mtry=1) RandomForest(formula, ntree=10, mtry=2) RandomForest(formula, ntree=10, mtry=3) RandomForest(formula, ntree=20, mtry=2) ...
हर बार, रैंडम फ़ॉरेस्ट क्रॉस-वैलिडेशन के साथ प्रयोग करता है। ग्रिड सर्च की एक कमी प्रयोगों की संख्या है। जब संयोजन की संख्या अधिक होती है तो यह बहुत आसानी से विस्फोटक बन सकता है। इस समस्या को दूर करने के लिए, आप रैंडम सर्च का उपयोग कर सकते हैं
रैंडम खोज परिभाषा
रैंडम सर्च और ग्रिड सर्च के बीच बड़ा अंतर यह है कि रैंडम सर्च सर्चिंग स्पेस में हाइपरपैरामीटर के सभी संयोजनों का मूल्यांकन नहीं करेगा। इसके बजाय, यह हर पुनरावृत्ति पर यादृच्छिक रूप से संयोजन का चयन करेगा। इसका लाभ यह है कि यह कम्प्यूटेशनल लागत को कम करता है।
नियंत्रण पैरामीटर सेट करें
मॉडल का निर्माण और मूल्यांकन करने के लिए आप निम्नानुसार आगे बढ़ेंगे:
- डिफ़ॉल्ट सेटिंग के साथ मॉडल का मूल्यांकन करें
- mtry की सर्वोत्तम संख्या ज्ञात करें
- अधिकतम नोड्स की सर्वोत्तम संख्या ज्ञात करें
- ntrees की सर्वोत्तम संख्या ज्ञात करें
- परीक्षण डेटासेट पर मॉडल का मूल्यांकन करें
पैरामीटर अन्वेषण शुरू करने से पहले, आपको दो लाइब्रेरीज़ स्थापित करने की आवश्यकता है।
- कैरेट: आर मशीन लर्निंग लाइब्रेरी। अगर आपके पास है आर स्थापित करें यह पहले से ही लाइब्रेरी में मौजूद है
- एनाकोंडा: conda install -cr r-caret
- e1071: आर मशीन लर्निंग लाइब्रेरी.
- एनाकोंडा: conda इंस्टॉल -cr r-e1071
आप उन्हें RandomForest के साथ आयात कर सकते हैं
library(randomForest) library(caret) library(e1071)
डिफ़ॉल्ट सेटिंग
K-फ़ोल्ड क्रॉस वैलिडेशन को 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.
आप मॉडल को डिफ़ॉल्ट पैरामीटर के साथ चलाने का प्रयास कर सकते हैं और सटीकता स्कोर देख सकते हैं।
नोटआप पूरे ट्यूटोरियल के दौरान समान नियंत्रणों का उपयोग करेंगे।
# Define the control
trControl <- trainControl(method = "cv",
number = 10,
search = "grid")
आप अपने मॉडल का मूल्यांकन करने के लिए कैरेट लाइब्रेरी का उपयोग करेंगे। लाइब्रेरी में train() नामक एक फ़ंक्शन है जो लगभग सभी का मूल्यांकन करता है यंत्र अधिगम दूसरे शब्दों में, आप इस फ़ंक्शन का उपयोग अन्य एल्गोरिदम को प्रशिक्षित करने के लिए कर सकते हैं।
मूल वाक्यविन्यास है:
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
आइए डिफ़ॉल्ट मानों के साथ मॉडल बनाने का प्रयास करें।
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)
कोड स्पष्टीकरण
- trainControl(method=”cv”, number=10, search=”grid”): 10 फ़ोल्डर की ग्रिड खोज के साथ मॉडल का मूल्यांकन करें
- ट्रेन(…): रैंडम फ़ॉरेस्ट मॉडल को प्रशिक्षित करें। सटीकता माप के साथ सर्वश्रेष्ठ मॉडल चुना जाता है।
आउटपुट:
## 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.
एल्गोरिथ्म 500 वृक्षों का उपयोग करता है और mtry के तीन अलग-अलग मानों का परीक्षण करता है: 2, 6, 10.
मॉडल के लिए इस्तेमाल किया गया अंतिम मान mtry = 2 था जिसकी सटीकता 0.78 थी। आइए उच्च स्कोर प्राप्त करने का प्रयास करें।
चरण 2) सर्वोत्तम mtry खोजें
आप 1 से 10 तक mtry के मानों के साथ मॉडल का परीक्षण कर सकते हैं
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)
कोड स्पष्टीकरण
- tuneGrid <- expand.grid(.mtry=c(3:10)): 3:10 से मान वाले वेक्टर का निर्माण करें
मॉडल के लिए प्रयुक्त अंतिम मान mtry = 4 था।
आउटपुट:
## 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.
mtry का सर्वोत्तम मान इसमें संग्रहित किया जाता है:
rf_mtry$bestTune$mtry
आप इसे संग्रहीत कर सकते हैं और जब आपको अन्य पैरामीटरों को समायोजित करने की आवश्यकता हो तो इसका उपयोग कर सकते हैं।
max(rf_mtry$results$Accuracy)
आउटपुट:
## [1] 0.8110729
best_mtry <- rf_mtry$bestTune$mtry best_mtry
आउटपुट:
## [1] 4
चरण 3) सर्वोत्तम मैक्सनोड्स खोजें
आपको maxnodes के विभिन्न मानों का मूल्यांकन करने के लिए एक लूप बनाने की आवश्यकता है। निम्नलिखित कोड में, आप यह करेंगे:
- एक सूची बनाएं
- पैरामीटर mtry के सर्वोत्तम मान के साथ एक चर बनाएँ; अनिवार्य
- लूप बनाएं
- maxnode का वर्तमान मान संग्रहीत करें
- परिणामों को सारांशित करें
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)
कोड स्पष्टीकरण:
- store_maxnode <- list(): मॉडल के परिणाम इस सूची में संग्रहीत किए जाएंगे
- expand.grid(.mtry=best_mtry): mtry का सर्वोत्तम मान उपयोग करें
- for (maxnodes in c(15:25)) { … }: 15 से 25 तक maxnodes के मानों के साथ मॉडल की गणना करें।
- maxnodes=maxnodes: प्रत्येक पुनरावृत्ति के लिए, maxnodes maxnodes के वर्तमान मान के बराबर है। यानी 15, 16, 17, …
- key <- toString(maxnodes): maxnode का मान स्ट्रिंग वेरिएबल के रूप में संग्रहित करें।
- store_maxnode[[key]] <- rf_maxnode: मॉडल के परिणाम को सूची में सहेजें.
- resamples(store_maxnode): मॉडल के परिणामों को व्यवस्थित करें
- सारांश(results_mtry): सभी संयोजन का सारांश प्रिंट करें।
आउटपुट:
## ## 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
मैक्सनोड का अंतिम मान सबसे अधिक सटीकता वाला होता है। आप उच्च मानों के साथ प्रयास करके देख सकते हैं कि क्या आप उच्च स्कोर प्राप्त कर सकते हैं।
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)
आउटपुट:
## ## 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
उच्चतम सटीकता स्कोर maxnode के 22 के बराबर मान पर प्राप्त किया जाता है।
चरण 4) सर्वोत्तम ntrees खोजें
अब जब आपके पास mtry और maxnode का सबसे अच्छा मान है, तो आप पेड़ों की संख्या को ट्यून कर सकते हैं। यह विधि बिल्कुल 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)
आउटपुट:
## ## 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
आपके पास अपना अंतिम मॉडल है। आप रैंडम फ़ॉरेस्ट को निम्नलिखित पैरामीटर के साथ प्रशिक्षित कर सकते हैं:
- ntree =800: 800 पेड़ों को प्रशिक्षित किया जाएगा
- mtry=4: प्रत्येक पुनरावृत्ति के लिए 4 विशेषताएँ चुनी जाती हैं
- maxnodes = 24: टर्मिनल नोड्स (पत्तियों) में अधिकतम 24 नोड्स
fit_rf <- train(survived~.,
data_train,
method = "rf",
metric = "Accuracy",
tuneGrid = tuneGrid,
trControl = trControl,
importance = TRUE,
nodesize = 14,
ntree = 800,
maxnodes = 24)
चरण 5) मॉडल का मूल्यांकन करें
लाइब्रेरी कैरेट में पूर्वानुमान लगाने का कार्य होता है।
predict(model, newdata= df) argument - `model`: Define the model evaluated before. - `newdata`: Define the dataset to make prediction
prediction <-predict(fit_rf, data_test)
आप भ्रम मैट्रिक्स की गणना करने और सटीकता स्कोर देखने के लिए पूर्वानुमान का उपयोग कर सकते हैं
confusionMatrix(prediction, data_test$survived)
आउटपुट:
## 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 ##
आपकी सटीकता 0.7943 प्रतिशत है, जो डिफ़ॉल्ट मान से अधिक है
चरण 6) परिणाम की कल्पना करें
अंत में, आप varImp() फ़ंक्शन के साथ फ़ीचर के महत्व को देख सकते हैं। ऐसा लगता है कि सबसे महत्वपूर्ण विशेषताएँ लिंग और आयु हैं। यह आश्चर्यजनक नहीं है क्योंकि महत्वपूर्ण विशेषताएँ पेड़ की जड़ के करीब दिखाई देने की संभावना है, जबकि कम महत्वपूर्ण विशेषताएँ अक्सर पत्तियों के करीब दिखाई देंगी।
varImpPlot(fit_rf)
आउटपुट:
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
सारांश
हम नीचे दी गई तालिका के माध्यम से रैंडम फ़ॉरेस्ट को प्रशिक्षित करने और उसका मूल्यांकन करने का सारांश दे सकते हैं:
| पुस्तकालय | उद्देश्य | समारोह | प्राचल |
|---|---|---|---|
| यादृच्छिकवन | एक यादृच्छिक वन बनाएँ | रैंडमफ़ॉरेस्ट() | सूत्र, ntree=n, mtry=FALSE, maxnodes = NULL |
| कैरट | K फ़ोल्डर क्रॉस सत्यापन बनाएँ | ट्रेनकंट्रोल() | विधि = “cv”, संख्या = n, खोज = “ग्रिड” |
| कैरट | रैंडम फ़ॉरेस्ट को प्रशिक्षित करें | रेल गाडी() | सूत्र, df, विधि = “rf”, मीट्रिक = “सटीकता”, trControl = trainControl(), tuneGrid = NULL |
| कैरट | नमूने से बाहर का पूर्वानुमान लगाएं | भविष्यवाणी करना | मॉडल, नयाडाटा=df |
| कैरट | भ्रम मैट्रिक्स और सांख्यिकी | असमंजस का जाल() | मॉडल, वाई परीक्षण |
| कैरट | परिवर्तनशील महत्व | cvarImp() | आदर्श |
परिशिष्ट
कैरेट में प्रयुक्त मॉडल की सूची
names>(getModelInfo())
आउटपुट:
## [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"
