R Academy · पाठ

ranger से रैंडम फ़ॉरेस्ट

रैंडम फ़ॉरेस्ट मॉडल प्रशिक्षित करें, mtry और ntrees का समायोजन करें तथा OOB त्रुटि का आकलन करें।

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

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

रैंडम फ़ॉरेस्ट क्या है?

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

library(ranger)

# Minimal random forest: 500 trees, auto mtry
rf <- ranger(
  medv ~ .,
  data      = MASS::Boston,
  num.trees = 500
)

print(rf)

mtry पैरामीटर

mtry प्रत्येक विभाजन पर यादृच्छिक रूप से विचार की जाने वाली विशेषताओं की संख्या है। कुल विशेषताओं से कम विशेषताओं का उपयोग करने पर वृक्षों के बीच सहसंबंध घटता है और वैरिएंस कम होता है। सामान्य नियम के अनुसार वर्गीकरण में mtry = sqrt(p) और प्रतिगमन में mtry = p/3 लिया जाता है, जहाँ p पूर्वानुमानकों की संख्या है।

p <- ncol(MASS::Boston) - 1  # number of predictors

rf_class <- ranger(
  Species ~ ., data = iris,
  num.trees = 500,
  mtry      = floor(sqrt(4))  # sqrt(p) for classification
)

rf_reg <- ranger(
  medv ~ ., data = MASS::Boston,
  num.trees = 500,
  mtry      = floor(p / 3)    # p/3 for regression
)

cat('Classification OOB Error:', rf_class$prediction.error)
cat('Regression OOB RMSE:', sqrt(rf_reg$prediction.error))

OOB त्रुटि — निःशुल्क सत्यापन

क्योंकि प्रत्येक वृक्ष को बूटस्ट्रैप नमूने पर प्रशिक्षित किया जाता है, लगभग एक-तिहाई प्रेक्षण बाहर रह जाते हैं (आउट-ऑफ-बैग, OOB)। ये OOB नमूने प्रत्येक वृक्ष के लिए अंतर्निहित सत्यापन समुच्चय की तरह काम करते हैं। कुल OOB त्रुटि परीक्षण त्रुटि का लगभग निष्पक्ष अनुमान देती है—अलग सत्यापन समुच्चय की आवश्यकता नहीं होती।

rf <- ranger(
  medv ~ ., data = MASS::Boston,
  num.trees = 500,
  mtry      = 4
)

# OOB MSE
cat('OOB MSE:', rf$prediction.error)

# OOB RMSE
cat('OOB RMSE:', sqrt(rf$prediction.error))

# For classification: OOB error rate
rf_cl <- ranger(Species ~ ., data = iris)
cat('OOB Error Rate:', rf_cl$prediction.error)

चर का महत्व

importance = 'impurity' सेट करने पर सभी वृक्षों में प्रत्येक विशेषता के लिए नोड अशुद्धता (Gini या MSE) में हुई कुल कमी दर्ज होती है। importance = 'permutation' सेट करने पर प्रत्येक विशेषता को यादृच्छिक रूप से बदलने के बाद सटीकता में आई कमी मापी जाती है—यह अधिक विश्वसनीय, लेकिन धीमा होता है।

rf_imp <- ranger(
  medv ~ ., data = MASS::Boston,
  num.trees  = 500,
  importance = 'impurity'
)

# Sorted importance scores
imp <- sort(rf_imp$variable.importance, decreasing = TRUE)
print(imp)

# Quick plot
barplot(imp, las = 2, col = 'steelblue',
        main = 'Random Forest Variable Importance')

ranger से पूर्वानुमान

पूर्वानुमान बनाने के लिए predict(rf, data = test) का उपयोग करें। परिणाम एक सूची होता है; पूर्वानुमानों तक $predictions से पहुँचें। वर्गीकरण में, डिफ़ॉल्ट रूप से पूर्वानुमान factor स्तरों के रूप में होते हैं।

set.seed(1)
idx   <- sample(nrow(MASS::Boston), 400)
train <- MASS::Boston[idx, ]
test  <- MASS::Boston[-idx, ]

rf <- ranger(medv ~ ., data = train, num.trees = 500)

pred <- predict(rf, data = test)
test_rmse <- sqrt(mean((pred$predictions - test$medv)^2))
cat('Test RMSE:', round(test_rmse, 3))

भ्रम मैट्रिक्स की अवधारणा

वर्गीकरण में, एक भ्रम मैट्रिक्स वास्तविक और अनुमानित वर्गों की क्रॉस-टैबुलेशन करता है। इससे प्राप्त मुख्य मापों में सटीकता, परिशुद्धता (TP / (TP + FP)), रिकॉल (TP / (TP + FN)) और F1 स्कोर शामिल हैं। ranger सीधे OOB भ्रम मैट्रिक्स उपलब्ध कराता है।

rf_cl <- ranger(
  Species ~ ., data = iris,
  num.trees = 500,
  mtry      = 2
)

# OOB confusion matrix
print(rf_cl$confusion.matrix)

# OOB error rate
cat('OOB Error Rate:', rf_cl$prediction.error)

# Manual accuracy on OOB predictions
# (1 - error rate)
cat('OOB Accuracy:', 1 - rf_cl$prediction.error)

mtry और num.trees को ट्यून करना

अधिक वृक्ष हमेशा वैरिएंस घटाते हैं (लगभग 300–500 वृक्षों के बाद लाभ धीरे-धीरे कम होने तक)। mtry पैरामीटर का एक उपयुक्त मान होता है। एक सरल ट्यूनिंग लूप mtry मानों के एक ग्रिड पर OOB त्रुटि का मूल्यांकन करके क्रॉस-वैलिडेशन के बिना इष्टतम मान खोजता है।

mtry_vals <- c(2, 4, 6, 8, 10)
oob_errors <- sapply(mtry_vals, function(m) {
  rf <- ranger(
    medv ~ ., data = MASS::Boston,
    num.trees = 300, mtry = m
  )
  rf$prediction.error
})

best_mtry <- mtry_vals[which.min(oob_errors)]
cat('Best mtry:', best_mtry)
plot(mtry_vals, sqrt(oob_errors), type = 'b',
     xlab = 'mtry', ylab = 'OOB RMSE')

वर्गीकरण के लिए ranger

वर्गीकरण के लिए कठोर लेबलों के बजाय वर्ग-प्रायिकता पूर्वानुमान प्राप्त करने हेतु probability = TRUE सेट करें। ROC वक्र की गणना और कैलिब्रेट की गई प्रायिकता के अनुमान के लिए यह आवश्यक है, तथा यह yardstick मापों द्वारा अपेक्षित आउटपुट प्रारूप से मेल खाता है।

# Ensure the target is a factor
iris$Species <- as.factor(iris$Species)

rf_prob <- ranger(
  Species ~ ., data = iris,
  num.trees   = 300,
  probability = TRUE  # output class probabilities
)

# Predictions are a matrix of probabilities
pred_prob <- predict(rf_prob, data = iris[1:5, ])
print(pred_prob$predictions)

ranger में समानांतर प्रसंस्करण

ranger को गति और समानांतर प्रसंस्करण के लिए बनाया गया है। सभी उपलब्ध CPU कोर का उपयोग करने के लिए num.threads सेट करें। इससे पुराने randomForest पैकेज की तुलना में, विशेषकर अनेक वृक्षों वाले बड़े डेटासेट पर, गति में बहुत अधिक वृद्धि हो सकती है।

# Use all available cores
rf_fast <- ranger(
  medv ~ ., data = MASS::Boston,
  num.trees  = 1000,
  mtry       = 4,
  num.threads = parallel::detectCores()
)

cat('Trees:', rf_fast$num.trees)
cat('Threads used:', rf_fast$num.threads)
cat('OOB RMSE:', sqrt(rf_fast$prediction.error))

tidymodels के माध्यम से ranger

आप tidymodels इंटरफ़ेस के माध्यम से ranger का उपयोग कर सकते हैं। यह एकसमान वाक्य-विन्यास देता है और कार्यप्रवाह, क्रॉस-वैलिडेशन तथा ट्यूनिंग के साथ एकीकृत होता है। इंजन के रूप में 'ranger' निर्दिष्ट करें और इंजन-विशिष्ट तर्क set_engine() के साथ दें।

library(parsnip)
library(workflows)

rf_spec <- rand_forest(
  mtry  = tune(),
  trees = 500,
  min_n = tune()
) |>
  set_engine('ranger', importance = 'impurity') |>
  set_mode('regression')

wf <- workflow() |>
  add_recipe(rec) |>
  add_model(rf_spec)

print(wf)

ranger आउटपुट की व्याख्या

प्रिंट किया गया ranger मॉडल यह दिखाता है: वृक्षों की संख्या, लक्ष्य चर, उपयोग की गई विशेषताओं की संख्या, OOB पूर्वानुमान त्रुटि और R-squared (प्रतिगमन के लिए)। त्वरित उचितता-जाँच के रूप में हमेशा OOB त्रुटि देखें—यदि बड़े डेटासेट पर यह अत्यंत कम हो, तो डेटा लीकेज की आशंका करें।

rf <- ranger(
  medv ~ ., data = MASS::Boston,
  num.trees  = 500, mtry = 4,
  importance = 'impurity'
)

# Key output fields
cat('OOB MSE:      ', rf$prediction.error, '\n')
cat('OOB RMSE:     ', sqrt(rf$prediction.error), '\n')
cat('R-squared:    ', rf$r.squared, '\n')
cat('Num trees:    ', rf$num.trees, '\n')
cat('Num features: ', rf$num.independent.variables, '\n')

त्वरित जाँच

ranger से बनाए गए रैंडम फ़ॉरेस्ट में OOB (आउट-ऑफ-बैग) त्रुटि का अनुमान किस चीज़ का लगाती है?

रैंडम फ़ॉरेस्ट का पुनरावलोकन

ranger वाले रैंडम फ़ॉरेस्ट से मुख्य बातें:

  • रैंडम फ़ॉरेस्ट बूटस्ट्रैप नमूनों पर बनाए गए अनेक वृक्षों को प्रत्येक विभाजन पर विशेषताओं के यादृच्छिक चयन के साथ जोड़ता है।
  • mtry: वर्गीकरण के लिए sqrt(p), प्रतिगमन के लिए p/3; इस पैरामीटर को ट्यून करें।
  • OOB त्रुटि निःशुल्क और लगभग निष्पक्ष सत्यापन अनुमान देती है।
  • importance = 'impurity' या 'permutation' चर के महत्व के अंक देता है।
  • वर्गीकरण में वर्ग-प्रायिकता आउटपुट के लिए probability = TRUE सेट करें।
  • ranger अत्यधिक समानांतरित है; बड़े डेटासेट के लिए num.threads का उपयोग करें।
  • rand_forest() |> set_engine('ranger') के माध्यम से tidymodels के साथ एकीकृत करें।
rf <- ranger(
  medv ~ ., data = MASS::Boston,
  num.trees  = 500,
  mtry       = 4,
  importance = 'impurity',
  num.threads = parallel::detectCores()
)

cat('OOB RMSE:', sqrt(rf$prediction.error))
cat('R2:', rf$r.squared)

print(sort(rf$variable.importance, decreasing = TRUE))
शुरुआत निःशुल्क

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

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

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

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

क्या “ranger से रैंडम फ़ॉरेस्ट” पाठ निःशुल्क है?

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

“ranger से रैंडम फ़ॉरेस्ट” में मैं क्या सीखूँगा?

रैंडम फ़ॉरेस्ट मॉडल प्रशिक्षित करें, mtry और ntrees का समायोजन करें तथा OOB त्रुटि का आकलन करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

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

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

“ranger से रैंडम फ़ॉरेस्ट” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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