आर में निर्णय वृक्ष: उदाहरण के साथ वर्गीकरण वृक्ष

निर्णय वृक्ष क्या हैं?

निर्णय के पेड़ बहुमुखी मशीन लर्निंग एल्गोरिदम हैं जो वर्गीकरण और प्रतिगमन दोनों कार्य कर सकते हैं। वे बहुत शक्तिशाली एल्गोरिदम हैं, जो जटिल डेटासेट को फ़िट करने में सक्षम हैं। इसके अलावा, निर्णय वृक्ष यादृच्छिक वनों के मूलभूत घटक हैं, जो आज उपलब्ध सबसे शक्तिशाली मशीन लर्निंग एल्गोरिदम में से हैं।

आर में निर्णय वृक्ष का प्रशिक्षण और दृश्यांकन

आर उदाहरण में अपना पहला निर्णय वृक्ष बनाने के लिए, हम इस निर्णय वृक्ष ट्यूटोरियल में निम्नानुसार आगे बढ़ेंगे:

  • चरण 1: डेटा आयात करें
  • चरण 2: डेटासेट साफ़ करें
  • चरण 3: ट्रेन/टेस्ट सेट बनाएं
  • चरण 4: मॉडल बनाएं
  • चरण 5: पूर्वानुमान लगाएं
  • चरण 6: प्रदर्शन मापें
  • चरण 7: हाइपर-पैरामीटर्स को ट्यून करें

चरण 1) डेटा आयात करें

यदि आप टाइटैनिक के भाग्य के बारे में जानने को उत्सुक हैं, तो आप यह वीडियो देख सकते हैं यूट्यूबइस डेटासेट का उद्देश्य यह अनुमान लगाना है कि हिमखंड से टकराने के बाद किन लोगों के बचने की संभावना अधिक है। डेटासेट में 13 चर और 1309 अवलोकन शामिल हैं। डेटासेट को चर X के अनुसार क्रमबद्ध किया गया है।

set.seed(678)
path <- 'https://raw.githubusercontent.com/guru99-edu/R-Programming/master/titanic_data.csv'
titanic <-read.csv(path)
head(titanic)

आउटपुट:

##   X pclass survived                                            name    sex
## 1 1      1        1                   Allen, Miss. Elisabeth Walton female
## 2 2      1        1                  Allison, Master. Hudson Trevor   male
## 3 3      1        0                    Allison, Miss. Helen Loraine female
## 4 4      1        0            Allison, Mr. Hudson Joshua Creighton   male
## 5 5      1        0 Allison, Mrs. Hudson J C (Bessie Waldo Daniels) female
## 6 6      1        1                             Anderson, Mr. Harry   male
##       age sibsp parch ticket     fare   cabin embarked
## 1 29.0000     0     0  24160 211.3375      B5        S
## 2  0.9167     1     2 113781 151.5500 C22 C26        S
## 3  2.0000     1     2 113781 151.5500 C22 C26        S
## 4 30.0000     1     2 113781 151.5500 C22 C26        S
## 5 25.0000     1     2 113781 151.5500 C22 C26        S
## 6 48.0000     0     0  19952  26.5500     E12        S
##                         home.dest
## 1                    St Louis, MO
## 2 Montreal, PQ / Chesterville, ON
## 3 Montreal, PQ / Chesterville, ON
## 4 Montreal, PQ / Chesterville, ON
## 5 Montreal, PQ / Chesterville, ON
## 6                    New York, NY
tail(titanic)

आउटपुट:

##         X pclass survived                      name    sex  age sibsp
## 1304 1304      3        0     Yousseff, Mr. Gerious   male   NA     0
## 1305 1305      3        0      Zabour, Miss. Hileni female 14.5     1
## 1306 1306      3        0     Zabour, Miss. Thamine female   NA     1
## 1307 1307      3        0 Zakarian, Mr. Mapriededer   male 26.5     0
## 1308 1308      3        0       Zakarian, Mr. Ortin   male 27.0     0
## 1309 1309      3        0        Zimmerman, Mr. Leo   male 29.0     0
##      parch ticket    fare cabin embarked home.dest
## 1304     0   2627 14.4583              C          
## 1305     0   2665 14.4542              C          
## 1306     0   2665 14.4542              C          
## 1307     0   2656  7.2250              C          
## 1308     0   2670  7.2250              C          
## 1309     0 315082  7.8750              S

हेड और टेल आउटपुट से, आप देख सकते हैं कि डेटा शफल नहीं हुआ है। यह एक बड़ी समस्या है! जब आप अपने डेटा को ट्रेन सेट और टेस्ट सेट के बीच विभाजित करेंगे, तो आप चयन करेंगे केवल कक्षा 1 और 2 के यात्री (कक्षा 3 का कोई भी यात्री शीर्ष 80 प्रतिशत अवलोकनों में नहीं है), जिसका अर्थ है कि एल्गोरिथ्म कक्षा 3 के यात्री की विशेषताओं को कभी नहीं देख पाएगा। यह गलती खराब भविष्यवाणी को जन्म देगी।

इस समस्या को दूर करने के लिए, आप फ़ंक्शन sample() का उपयोग कर सकते हैं।

shuffle_index <- sample(1:nrow(titanic))
head(shuffle_index)

निर्णय वृक्ष आर कोड स्पष्टीकरण

  • नमूना(1:nrow(titanic)): 1 से 1309 तक (अर्थात पंक्तियों की अधिकतम संख्या) सूचकांक की एक यादृच्छिक सूची उत्पन्न करें।

आउटपुट:

## [1]  288  874 1078  633  887  992

आप टाइटैनिक डेटासेट को शफ़ल करने के लिए इस इंडेक्स का उपयोग करेंगे।

titanic <- titanic[shuffle_index, ]
head(titanic)

आउटपुट:

##         X pclass survived
## 288   288      1        0
## 874   874      3        0
## 1078 1078      3        1
## 633   633      3        0
## 887   887      3        1
## 992   992      3        1
##                                                           name    sex age
## 288                                      Sutton, Mr. Frederick   male  61
## 874                   Humblen, Mr. Adolf Mathias Nicolai Olsen   male  42
## 1078                                 O'Driscoll, Miss. Bridget female  NA
## 633  Andersson, Mrs. Anders Johan (Alfrida Konstantia Brogren) female  39
## 887                                        Jermyn, Miss. Annie female  NA
## 992                                           Mamee, Mr. Hanna   male  NA
##      sibsp parch ticket    fare cabin embarked           home.dest## 288      0     0  36963 32.3208   D50        S     Haddenfield, NJ
## 874      0     0 348121  7.6500 F G63        S                    
## 1078     0     0  14311  7.7500              Q                    
## 633      1     5 347082 31.2750              S Sweden Winnipeg, MN
## 887      0     0  14313  7.7500              Q                    
## 992      0     0   2677  7.2292              C	

चरण 2) डेटासेट साफ़ करें

डेटा की संरचना से पता चलता है कि कुछ चरों में NA है। डेटा को इस प्रकार साफ किया जाना चाहिए

  • होम.डेस्ट, केबिन, नाम, एक्स और टिकट चर हटाएं
  • pclass और saved के लिए कारक चर बनाएँ
  • एनए को छोड़ो
library(dplyr)
# Drop variables
clean_titanic <- titanic % > %
select(-c(home.dest, cabin, name, X, ticket)) % > % 
#Convert to factor level
	mutate(pclass = factor(pclass, levels = c(1, 2, 3), labels = c('Upper', 'Middle', 'Lower')),
	survived = factor(survived, levels = c(0, 1), labels = c('No', 'Yes'))) % > %
na.omit()
glimpse(clean_titanic)

कोड स्पष्टीकरण

  • select(-c(home.dest, cabin, name, X, ticket)): अनावश्यक चर हटाएं
  • pclass = फ़ैक्टर(pclass, लेवल = c(1,2,3), लेबल= c('ऊपरी', 'मध्यम', 'निचला')): वेरिएबल pclass में लेबल जोड़ें। 1 ऊपरी हो जाता है, 2 मध्य हो जाता है और 3 निचला हो जाता है
  • फ़ैक्टर(survived, लेवल = c(0,1), लेबल = c('नहीं', 'हां')): जीवित चर में लेबल जोड़ें। 1 नहीं बन जाता है और 2 हाँ बन जाता है
  • na.omit(): NA अवलोकनों को हटाएँ

आउटपुट:

## Observations: 1,045
## Variables: 8
## $ pclass   <fctr> Upper, Lower, Lower, Upper, Middle, Upper, Middle, U...
## $ survived <fctr> No, No, No, Yes, No, Yes, Yes, No, No, No, No, No, Y...
## $ sex      <fctr> male, male, female, female, male, male, female, male...
## $ age      <dbl> 61.0, 42.0, 39.0, 49.0, 29.0, 37.0, 20.0, 54.0, 2.0, ...
## $ sibsp    <int> 0, 0, 1, 0, 0, 1, 0, 0, 4, 0, 0, 1, 1, 0, 0, 0, 1, 1,...
## $ parch    <int> 0, 0, 5, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 2, 0, 4, 0,...
## $ fare     <dbl> 32.3208, 7.6500, 31.2750, 25.9292, 10.5000, 52.5542, ...
## $ embarked <fctr> S, S, S, S, S, S, S, S, S, C, S, S, S, Q, C, S, S, C...		

चरण 3) ट्रेन/टेस्ट सेट बनाएं

अपने मॉडल को प्रशिक्षित करने से पहले, आपको दो चरण करने होंगे:

  • ट्रेन और टेस्ट सेट बनाएँ: आप मॉडल को ट्रेन सेट पर प्रशिक्षित करते हैं और टेस्ट सेट (अर्थात अदृश्य डेटा) पर पूर्वानुमान का परीक्षण करते हैं
  • कंसोल से rpart.plot स्थापित करें

आम तौर पर डेटा को 80/20 में विभाजित किया जाता है, 80 प्रतिशत डेटा मॉडल को प्रशिक्षित करने के लिए और 20 प्रतिशत पूर्वानुमान लगाने के लिए उपयोग किया जाता है। आपको दो अलग-अलग डेटा फ़्रेम बनाने की आवश्यकता है। जब तक आप अपना मॉडल बनाना समाप्त नहीं कर लेते, तब तक आप टेस्ट सेट को छूना नहीं चाहेंगे। आप create_train_test() नाम का एक फ़ंक्शन बना सकते हैं जो तीन तर्क लेता है।

create_train_test(df, size = 0.8, train = TRUE)
arguments:
-df: Dataset used to train the model.
-size: Size of the split. By default, 0.8. Numerical value
-train: If set to `TRUE`, the function creates the train set, otherwise the test set. Default value sets to `TRUE`. Boolean value.You need to add a Boolean parameter because R does not allow to return two data frames simultaneously.
create_train_test <- function(data, size = 0.8, train = TRUE) {
    n_row = nrow(data)
    total_row = size * n_row
    train_sample < - 1: total_row
    if (train == TRUE) {
        return (data[train_sample, ])
    } else {
        return (data[-train_sample, ])
    }
}

कोड स्पष्टीकरण

  • फ़ंक्शन(डेटा, आकार=0.8, ट्रेन = सत्य): फ़ंक्शन में तर्क जोड़ें
  • n_row = nrow(data): डेटासेट में पंक्तियों की संख्या गिनें
  • total_row = size*n_row: ट्रेन सेट बनाने के लिए nवीं पंक्ति लौटाएँ
  • train_sample <- 1:total_row: पहली पंक्ति से nवीं पंक्तियों तक का चयन करें
  • यदि (ट्रेन == सत्य) { } अन्यथा { }: यदि शर्त सत्य पर सेट होती है, तो ट्रेन सेट लौटाएं, अन्यथा परीक्षण सेट लौटाएं।

आप अपने फ़ंक्शन का परीक्षण और आयाम की जांच कर सकते हैं।

data_train <- create_train_test(clean_titanic, 0.8, train = TRUE)
data_test <- create_train_test(clean_titanic, 0.8, train = FALSE)
dim(data_train)

आउटपुट:

## [1] 836   8
dim(data_test)

आउटपुट:

## [1] 209   8

ट्रेन डेटासेट में 1046 पंक्तियाँ हैं जबकि परीक्षण डेटासेट में 262 पंक्तियाँ हैं।

यादृच्छिकीकरण प्रक्रिया सही है या नहीं, इसकी पुष्टि करने के लिए आप prop.table() और table() संयुक्त फ़ंक्शन का उपयोग करते हैं।

prop.table(table(data_train$survived))

आउटपुट:

##
##        No       Yes 
## 0.5944976 0.4055024
prop.table(table(data_test$survived))

आउटपुट:

## 
##        No       Yes 
## 0.5789474 0.4210526

दोनों डेटासेट में जीवित बचे लोगों की संख्या समान है, लगभग 40 प्रतिशत।

rpart.plot स्थापित करें

rpart.plot conda लाइब्रेरी से उपलब्ध नहीं है। आप इसे कंसोल से इंस्टॉल कर सकते हैं:

install.packages("rpart.plot")

चरण 4) मॉडल बनाएं

आप मॉडल बनाने के लिए तैयार हैं। Rpart निर्णय वृक्ष फ़ंक्शन के लिए सिंटैक्स है:

rpart(formula, data=, method='')
arguments:			
- formula: The function to predict
- data: Specifies the data frame- method: 			
- "class" for a classification tree 			
- "anova" for a regression tree	

आप क्लास विधि का उपयोग करते हैं क्योंकि आप एक क्लास की भविष्यवाणी करते हैं।

library(rpart)
library(rpart.plot)
fit <- rpart(survived~., data = data_train, method = 'class')
rpart.plot(fit, extra = 106

कोड स्पष्टीकरण

  • rpart(): मॉडल को फिट करने के लिए फ़ंक्शन। तर्क हैं:
    • बच गया ~.: निर्णय वृक्षों का सूत्र
    • डेटा = डेटा_ट्रेन: डेटासेट
    • विधि = 'क्लास': बाइनरी मॉडल फिट करें
  • rpart.plot(fit, extra= 106): ट्री प्लॉट करें। अतिरिक्त विशेषताएँ 101nd क्लास की संभावना प्रदर्शित करने के लिए 2 पर सेट की गई हैं (बाइनरी प्रतिक्रियाओं के लिए उपयोगी)। आप इसका संदर्भ ले सकते हैं शब्दचित्र अन्य विकल्पों के बारे में अधिक जानकारी के लिए.

आउटपुट:

आर में निर्णय वृक्षों का एक मॉडल बनाएं

आप मूल नोड (गहराई 0 से 3, ग्राफ के शीर्ष) से ​​शुरू करते हैं:

  1. सबसे ऊपर, यह दुर्घटना में जीवित बचे यात्रियों की समग्र संभावना को दर्शाता है। यह दुर्घटना में जीवित बचे यात्रियों का अनुपात दर्शाता है। 41 प्रतिशत यात्री बच गए।
  2. यह नोड पूछता है कि यात्री का लिंग पुरुष है या नहीं। यदि हाँ, तो आप रूट के बाएं चाइल्ड नोड (गहराई 2) पर जाएँ। 63 प्रतिशत पुरुष हैं और बचने की संभावना 21 प्रतिशत है।
  3. दूसरे नोड में आप पूछते हैं कि क्या पुरुष यात्री की उम्र 3.5 साल से अधिक है। अगर हाँ, तो बचने की संभावना 19 प्रतिशत है।
  4. आप यह समझने के लिए इसी तरह आगे बढ़ते रहें कि कौन सी विशेषताएं जीवित रहने की संभावना को प्रभावित करती हैं।

ध्यान दें कि, निर्णय वृक्षों की कई खूबियों में से एक यह है कि उन्हें बहुत कम डेटा तैयारी की आवश्यकता होती है। विशेष रूप से, उन्हें फीचर स्केलिंग या सेंटरिंग की आवश्यकता नहीं होती है।

डिफ़ॉल्ट रूप से, rpart() फ़ंक्शन का उपयोग करता है गिनी नोट को विभाजित करने के लिए अशुद्धता माप। गिनी गुणांक जितना अधिक होगा, नोड के भीतर उतने ही अधिक विभिन्न उदाहरण होंगे।

चरण 5) पूर्वानुमान लगाएं

आप अपने परीक्षण डेटासेट का पूर्वानुमान लगा सकते हैं। पूर्वानुमान लगाने के लिए, आप predict() फ़ंक्शन का उपयोग कर सकते हैं। R निर्णय वृक्ष के लिए पूर्वानुमान का मूल सिंटैक्स है:

predict(fitted_model, df, type = 'class')
arguments:
- fitted_model: This is the object stored after model estimation. 
- df: Data frame used to make the prediction
- type: Type of prediction			
    - 'class': for classification			
    - 'prob': to compute the probability of each class			
    - 'vector': Predict the mean response at the node level	

आप टेस्ट सेट से यह अनुमान लगाना चाहते हैं कि टक्कर के बाद कौन से यात्री बचने की अधिक संभावना रखते हैं। इसका मतलब है कि आपको उन 209 यात्रियों में से पता चल जाएगा कि कौन बच पाएगा या नहीं।

predict_unseen <-predict(fit, data_test, type = 'class')

कोड स्पष्टीकरण

  • भविष्यवाणी (फिट, डेटा_टेस्ट, प्रकार = 'क्लास'): परीक्षण सेट की कक्षा (0/1) की भविष्यवाणी करें

जो यात्री विमान में सवार नहीं हो सके, उनका तथा जो विमान में सवार हो गये, उनका परीक्षण किया गया।

table_mat <- table(data_test$survived, predict_unseen)
table_mat

कोड स्पष्टीकरण

  • तालिका (डेटा_टेस्ट $ सर्वाइव्ड, प्रेडिक्ट_अनसीन): एक तालिका बनाएं जिसमें यह गणना की जाए कि कितने यात्रियों को जीवित के रूप में वर्गीकृत किया गया है और कितने की मृत्यु हो गई है, इसकी तुलना R में सही निर्णय वृक्ष वर्गीकरण से की जा सकती है।

आउटपुट:

##      predict_unseen
##        No Yes
##   No  106  15
##   Yes  30  58

मॉडल ने 106 मृत यात्रियों की सही भविष्यवाणी की, लेकिन 15 जीवित बचे लोगों को मृत घोषित कर दिया। इसी तरह, मॉडल ने 30 यात्रियों को जीवित बचे लोगों के रूप में गलत वर्गीकृत किया, जबकि वे मृत निकले।

चरण 6) प्रदर्शन मापें

आप वर्गीकरण कार्य के लिए सटीकता माप की गणना कर सकते हैं असमंजस का जाल:

RSI असमंजस का जाल वर्गीकरण प्रदर्शन का मूल्यांकन करने के लिए एक बेहतर विकल्प है। सामान्य विचार यह है कि सत्य उदाहरणों को गलत के रूप में वर्गीकृत किए जाने की संख्या की गणना की जाए।

आर में निर्णय वृक्षों के प्रदर्शन को मापें

भ्रम मैट्रिक्स में प्रत्येक पंक्ति एक वास्तविक लक्ष्य को दर्शाती है, जबकि प्रत्येक स्तंभ एक पूर्वानुमानित लक्ष्य को दर्शाता है। इस मैट्रिक्स की पहली पंक्ति मृत यात्रियों (गलत श्रेणी) पर विचार करती है: 106 को सही ढंग से मृत के रूप में वर्गीकृत किया गया था (सच्चा नकारात्मक), जबकि शेष को ग़लत तरीके से उत्तरजीवी के रूप में वर्गीकृत किया गया था (सकारात्मक झूठी) दूसरी पंक्ति में जीवित बचे लोगों को शामिल किया गया है, सकारात्मक वर्ग में 58 लोग थे (सच्चा सकारात्मक), जबकि सच्चा नकारात्मक 30 था।

आप गणना कर सकते हैं सटीकता परीक्षण भ्रम मैट्रिक्स से:

आर में निर्णय वृक्षों के प्रदर्शन को मापें

यह मैट्रिक्स के योग पर सच्चे सकारात्मक और सच्चे नकारात्मक का अनुपात है। R के साथ, आप निम्न प्रकार से कोड कर सकते हैं:

accuracy_Test <- sum(diag(table_mat)) / sum(table_mat)

कोड स्पष्टीकरण

  • sum(diag(table_mat)): विकर्ण का योग
  • sum(table_mat): मैट्रिक्स का योग.

आप परीक्षण सेट की सटीकता प्रिंट कर सकते हैं:

print(paste('Accuracy for test', accuracy_Test))

आउटपुट:

## [1] "Accuracy for test 0.784688995215311"

टेस्ट सेट के लिए आपका स्कोर 78 प्रतिशत है। आप प्रशिक्षण डेटासेट के साथ भी यही अभ्यास दोहरा सकते हैं।

चरण 7) हाइपर-पैरामीटर्स को ट्यून करें

R में निर्णय वृक्ष में विभिन्न पैरामीटर होते हैं जो फिट के पहलुओं को नियंत्रित करते हैं। rpart निर्णय वृक्ष लाइब्रेरी में, आप rpart.control() फ़ंक्शन का उपयोग करके पैरामीटर को नियंत्रित कर सकते हैं। निम्नलिखित कोड में, आप उन पैरामीटर को पेश करते हैं जिन्हें आप ट्यून करेंगे। आप इसका संदर्भ ले सकते हैं शब्दचित्र अन्य मापदंडों के लिए.

rpart.control(minsplit = 20, minbucket = round(minsplit/3), maxdepth = 30)
Arguments:
-minsplit: Set the minimum number of observations in the node before the algorithm perform a split
-minbucket:  Set the minimum number of observations in the final note i.e. the leaf
-maxdepth: Set the maximum depth of any node of the final tree. The root node is treated a depth 0

हम निम्नानुसार आगे बढ़ेंगे:

  • सटीकता लौटाने के लिए फ़ंक्शन का निर्माण करें
  • अधिकतम गहराई को ट्यून करें
  • नोड को विभाजित करने से पहले न्यूनतम सैंपल संख्या निर्धारित करें
  • एक लीफ नोड में न्यूनतम सैंपल की संख्या निर्धारित करें

आप सटीकता प्रदर्शित करने के लिए एक फ़ंक्शन लिख सकते हैं। आप बस पहले इस्तेमाल किए गए कोड को लपेट सकते हैं:

  1. भविष्यवाणी: भविष्यवाणी_अनदेखी <- भविष्यवाणी(फिट, डेटा_परीक्षण, प्रकार = 'क्लास')
  2. तालिका बनाएं: table_mat <- table(data_test$survived, predict_unseen)
  3. सटीकता की गणना करें: precision_Test <- sum(diag(table_mat))/sum(table_mat)
accuracy_tune <- function(fit) {
    predict_unseen <- predict(fit, data_test, type = 'class')
    table_mat <- table(data_test$survived, predict_unseen)
    accuracy_Test <- sum(diag(table_mat)) / sum(table_mat)
    accuracy_Test
}

आप पैरामीटर्स को ट्यून करने की कोशिश कर सकते हैं और देख सकते हैं कि क्या आप डिफ़ॉल्ट मान पर मॉडल को बेहतर बना सकते हैं। याद रखें, आपको 0.78 से ज़्यादा सटीकता प्राप्त करने की ज़रूरत है

control <- rpart.control(minsplit = 4,
    minbucket = round(5 / 3),
    maxdepth = 3,
    cp = 0)
tune_fit <- rpart(survived~., data = data_train, method = 'class', control = control)
accuracy_tune(tune_fit)

आउटपुट:

## [1] 0.7990431

निम्नलिखित पैरामीटर के साथ:

minsplit = 4
minbucket= round(5/3)
maxdepth = 3cp=0

आपको पिछले मॉडल की तुलना में बेहतर प्रदर्शन मिलता है। बधाई हो!

सारांश

हम निर्णय वृक्ष एल्गोरिथ्म को प्रशिक्षित करने के लिए कार्यों को संक्षेप में प्रस्तुत कर सकते हैं R

पुस्तकालय उद्देश्य समारोह वर्ग पैरामीटर्स विवरण
आरपार्ट आर में वर्गीकरण वृक्ष को प्रशिक्षित करें आरपार्ट() कक्षा सूत्र, डीएफ, विधि
आरपार्ट ट्रेन रिग्रेशन ट्री आरपार्ट() एनोवा सूत्र, डीएफ, विधि
आरपार्ट पेड़ों की रूपरेखा बनाइये आरपार्ट.प्लॉट() फिटेड मॉडल
आधार भविष्यवाणी करना अनुमान है () कक्षा फिटेड मॉडल, प्रकार
आधार भविष्यवाणी करना अनुमान है () समस्या फिटेड मॉडल, प्रकार
आधार भविष्यवाणी करना अनुमान है () वेक्टर फिटेड मॉडल, प्रकार
आरपार्ट नियंत्रण के मानकों आरपार्ट.कंट्रोल() मिनस्प्लिट एल्गोरिथ्म द्वारा विभाजन निष्पादित करने से पहले नोड में प्रेक्षणों की न्यूनतम संख्या निर्धारित करें
मिनबकेट अंतिम नोट यानी पत्ते में अवलोकनों की न्यूनतम संख्या निर्धारित करें
अधिकतम गहराई अंतिम वृक्ष के किसी भी नोड की अधिकतम गहराई निर्धारित करें। रूट नोड को गहराई 0 माना जाता है
आरपार्ट नियंत्रण पैरामीटर के साथ मॉडल को प्रशिक्षित करें आरपार्ट() सूत्र, डीएफ, विधि, नियंत्रण

नोट: मॉडल को प्रशिक्षण डेटा पर प्रशिक्षित करें और एक अदृश्य डेटासेट, अर्थात परीक्षण सेट पर प्रदर्शन का परीक्षण करें।