R Academy · पाठ

निर्णय वृक्ष: एन्सेम्बल की नींव

rpart से निर्णय वृक्ष बनाएँ और उनका दृश्यांकन करें तथा बायस-वैरिएंस समझौते को समझें।

पाठ 1, कुल 4 में से13 चरण

निर्णय वृक्ष: एन्सेम्बल की नींव, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

निर्णय वृक्ष कैसे विभाजित होते हैं

निर्णय वृक्ष feature space को पुनरावर्ती रूप से आयताकार क्षेत्रों में विभाजित करता है। प्रत्येक node पर algorithm सभी features और सभी संभावित split points में खोज करता है, ताकि target variable को सबसे अच्छी तरह अलग करने वाला split मिल सके। इसका परिणाम if-else नियमों वाला वृक्ष होता है।

library(rpart)

# Fit a classification tree
tree <- rpart(
  Species ~ .,
  data   = iris,
  method = 'class'  # use 'anova' for regression
)

print(tree)

GINI बनाम Entropy विभाजन मानदंड

विभाजन मानदंड किसी node की impurity मापता है। Gini impurity यादृच्छिक रूप से चुने गए element को गलत वर्गीकृत करने की probability मापती है। Entropy (information gain) सूचना की अव्यवस्था में कमी मापती है। दोनों आम तौर पर समान वृक्ष देते हैं; Gini की गणना तेज़ होती है और यह rpart का डिफ़ॉल्ट है।

# Default: Gini impurity (parms = list(split = 'gini'))
tree_gini <- rpart(Species ~ ., data = iris, method = 'class')

# Using information gain (entropy)
tree_entropy <- rpart(
  Species ~ ., data = iris, method = 'class',
  parms = list(split = 'information')
)

cat('Gini root split:', tree_gini$frame$var[1])
cat('Entropy root split:', tree_entropy$frame$var[1])

printcp() — जटिलता सारणी

printcp(tree) जटिलता पैरामीटर (CP) सारणी प्रिंट करता है। प्रत्येक पंक्ति वृक्ष का आकार (विभाजनों की संख्या), प्रशिक्षण डेटा पर उसकी सापेक्ष त्रुटि और क्रॉस-वैलिडेशन त्रुटि (xerror) दिखाती है। CP सारणी का उपयोग इष्टतम छंटाई स्तर खोजने के लिए किया जाता है।

tree <- rpart(medv ~ ., data = MASS::Boston, method = 'anova',
              control = rpart.control(minsplit = 5, cp = 0.001))

printcp(tree)

# Identify the CP with minimum cross-validated error
best_cp <- tree$cptable[
  which.min(tree$cptable[, 'xerror']),
  'CP'
]
cat('Best CP:', best_cp)

prune() — वृक्ष को छोटा करना

prune(tree, cp) वृक्ष को cp द्वारा निर्दिष्ट जटिलता स्तर तक छोटा करता है। छंटाई उन शाखाओं को समेटकर अधिक-फिटिंग रोकती है जिनका पूर्वानुमान में बहुत कम योगदान होता है। मानक तरीका यह है: CV त्रुटि को न्यूनतम करने वाला CP खोजें, फिर छंटाई करें।

best_cp <- tree$cptable[
  which.min(tree$cptable[, 'xerror']), 'CP'
]

pruned_tree <- prune(tree, cp = best_cp)

cat('Original tree nodes:', nrow(tree$frame))
cat('Pruned tree nodes:', nrow(pruned_tree$frame))

rpart.plot() — वृक्ष का दृश्यांकन

rpart.plot(tree), जो rpart.plot पैकेज से आता है, निर्णय वृक्ष का साफ़ और रंगीन दृश्यांकन बनाता है। प्रत्येक आंतरिक नोड विभाजन नियम दिखाता है; प्रत्येक पत्ती अनुमानित वर्ग और प्रशिक्षण नमूनों का अनुपात दिखाती है।

library(rpart.plot)

tree <- rpart(Species ~ ., data = iris, method = 'class')
pruned <- prune(tree, cp = 0.02)

rpart.plot(
  pruned,
  type   = 4,     # split labels on branches
  extra  = 104,   # show class + probability
  fallen.leaves = TRUE
)

बायस-वैरिएंस संतुलन

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

रैंडम फ़ॉरेस्ट और बूस्टिंग जैसी समूह-विधियाँ इस संतुलन की समस्या को सीधे संबोधित करती हैं।

# Deep tree = low bias, high variance (overfits)
deep_tree <- rpart(medv ~ ., data = MASS::Boston,
                   control = rpart.control(minsplit = 2, cp = 0))

# Shallow tree = high bias, low variance (underfits)
shallow_tree <- rpart(medv ~ ., data = MASS::Boston,
                      control = rpart.control(maxdepth = 2))

cat('Deep nodes:', nrow(deep_tree$frame))
cat('Shallow nodes:', nrow(shallow_tree$frame))

निर्णय वृक्ष में अधिक-फिटिंग

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

set.seed(42)
train_idx <- sample(nrow(MASS::Boston), 400)
train_bos <- MASS::Boston[train_idx, ]
test_bos  <- MASS::Boston[-train_idx, ]

# Fully grown tree
full <- rpart(medv ~ ., data = train_bos,
              control = rpart.control(cp = 0, minsplit = 2))

train_pred <- predict(full, train_bos)
test_pred  <- predict(full, test_bos)

cat('Train RMSE:', sqrt(mean((train_pred - train_bos$medv)^2)))
cat('Test  RMSE:', sqrt(mean((test_pred  - test_bos$medv)^2)))

rpart से चर का महत्व

rpart प्रत्येक पूर्वानुमानक के लिए variable.importance दर्ज करता है: सभी विभाजनों में उस चर के कारण विभाजन मानदंड में हुआ कुल सुधार। इससे जल्दी पता चलता है कि मॉडल के निर्णयों को कौन-सी विशेषताएँ सबसे अधिक प्रभावित करती हैं।

tree <- rpart(medv ~ ., data = MASS::Boston, method = 'anova')

# Variable importance (sorted)
imp <- sort(tree$variable.importance, decreasing = TRUE)
print(imp)

# Quick barplot
barplot(imp, las = 2, main = 'Variable Importance',
        col = 'steelblue', cex.names = 0.8)

वृक्षों से समूह-विधियों तक

एक अकेला निर्णय वृक्ष अस्थिर होता है: डेटा का दोबारा नमूना लेने पर बहुत अलग वृक्ष बन सकते हैं। समूह-विधियाँ इस अस्थिरता का लाभ उठाती हैं:

  • बैगिंग / रैंडम फ़ॉरेस्ट: बूटस्ट्रैप नमूनों पर बने अनेक वृक्षों के पूर्वानुमानों का औसत निकालना।
  • बूस्टिंग: वृक्षों को क्रमशः बनाना, जहाँ प्रत्येक वृक्ष पिछले वृक्ष की त्रुटियों को सुधारता है।
  • दोनों वृक्षों की अभिव्यक्तिशील क्षमता बनाए रखते हुए वैरिएंस घटाते हैं।
# Demonstrating instability of a single tree
set.seed(1); t1 <- rpart(medv ~ ., data = MASS::Boston[sample(506, 400), ])
set.seed(2); t2 <- rpart(medv ~ ., data = MASS::Boston[sample(506, 400), ])

# Root split may differ between trees
cat('Tree 1 root split:', t1$frame$var[1])
cat('Tree 2 root split:', t2$frame$var[1])

rpart नियंत्रण पैरामीटर

rpart.control() यह नियंत्रित करता है कि वृक्ष कैसे बढ़ेगा। मुख्य पैरामीटर हैं: cp (जटिलता दंड), minsplit (विभाजन का प्रयास करने के लिए न्यूनतम प्रेक्षण), minbucket (पत्ती का न्यूनतम आकार) और maxdepth। वृक्ष-आधारित मॉडलों को ट्यून करने के लिए इन्हें समझना आवश्यक है।

ctrl <- rpart.control(
  cp        = 0.005,  # complexity penalty
  minsplit  = 20,     # min obs to try a split
  minbucket = 7,      # min obs in any leaf
  maxdepth  = 10      # max tree depth
)

tree <- rpart(medv ~ ., data = MASS::Boston,
              method = 'anova', control = ctrl)

printcp(tree)

वृक्ष के प्रदर्शन का मूल्यांकन

छंटाई के बाद अलग रखे गए परीक्षण समुच्चय पर वृक्ष का मूल्यांकन करें। प्रतिगमन के लिए RMSE और R-squared निकालें; वर्गीकरण के लिए सटीकता और भ्रम मैट्रिक्स निकालें। एकल वृक्ष से मिलने वाले लाभ को समझने के लिए इन मापों की तुलना मानक मॉडलों से करें।

pruned_tree <- prune(tree, cp = best_cp)

test_pred <- predict(pruned_tree, newdata = test_bos)

rmse <- sqrt(mean((test_pred - test_bos$medv)^2))
ss_res <- sum((test_pred - test_bos$medv)^2)
ss_tot <- sum((test_bos$medv - mean(test_bos$medv))^2)
r2 <- 1 - ss_res / ss_tot

cat('RMSE:', round(rmse, 3))
cat('R2:', round(r2, 3))

त्वरित जाँच

prune(tree, cp = best_cp) को कॉल करने के उद्देश्य का सबसे अच्छा वर्णन कौन-सा कथन करता है?

निर्णय वृक्षों का पुनरावलोकन

निर्णय वृक्ष — समूह-विधियों की नींव से मुख्य बातें:

  • वृक्ष विशेषता-स्थान को बार-बार विभाजित करते हैं; विभाजनों में Gini या entropy मानदंड का उपयोग होता है।
  • rpart(y ~ ., data, method) वृक्ष को फिट करता है; printcp() जटिलता सारणी दिखाता है।
  • न्यूनतम क्रॉस-वैलिडेशन त्रुटि वाला CP खोजें, फिर prune(tree, cp) चलाएँ।
  • rpart.plot() वृक्ष की संरचना का दृश्यांकन करता है।
  • गहरे वृक्ष अधिक-फिट होते हैं (कम बायस, अधिक वैरिएंस); उथले वृक्ष कम-फिट होते हैं।
  • tree$variable.importance पूर्वानुमानकों को उनके कुल विभाजन-सुधार के आधार पर क्रम देता है।
  • समूह-विधियाँ (रैंडम फ़ॉरेस्ट, बूस्टिंग) अकेले वृक्ष की अस्थिरता को दूर करती हैं।
# Standard rpart workflow
tree <- rpart(y ~ ., data = train, method = 'anova',
              control = rpart.control(cp = 0.001))

best_cp <- tree$cptable[which.min(tree$cptable[, 'xerror']), 'CP']
pruned  <- prune(tree, cp = best_cp)

test_pred <- predict(pruned, newdata = test)
rmse <- sqrt(mean((test_pred - test$y)^2))
cat('Pruned Tree RMSE:', rmse)
शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
43
पाठ
159

अक्सर पूछे जाने वाले प्रश्न

क्या “निर्णय वृक्ष: एन्सेम्बल की नींव” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “निर्णय वृक्ष: एन्सेम्बल की नींव” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“निर्णय वृक्ष: एन्सेम्बल की नींव” में मैं क्या सीखूँगा?

rpart से निर्णय वृक्ष बनाएँ और उनका दृश्यांकन करें तथा बायस-वैरिएंस समझौते को समझें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“निर्णय वृक्ष: एन्सेम्बल की नींव” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. निर्णय वृक्ष: एन्सेम्बल की नींव
  2. ranger से रैंडम फ़ॉरेस्ट
  3. xgboost से ग्रेडिएंट बूस्टिंग
  4. फीचर महत्त्व और मॉडल की व्याख्या
← R Academy पर वापस जाएँ