R Academy · पाठ

rsample से पुनर्नमूनाकरण और क्रॉस-वैलिडेशन

k-fold CV, बूटस्ट्रैप और नेस्टेड पुनर्नमूनाकरण से मॉडलों का मूल्यांकन करें।

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

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

Resample क्यों करें?

एकल training/test विभाजन मॉडल के प्रदर्शन का शोरयुक्त अनुमान देता है — test सेट में कौन-से observations पहुँचे, इस पर आप भाग्यशाली या दुर्भाग्यशाली हो सकते हैं। Resampling इस प्रक्रिया को कई बार दोहराता है, ताकि आपका मॉडल नए डेटा पर कितना सामान्यीकृत होता है, इसका स्थिर और विश्वसनीय अनुमान मिल सके।

library(rsample)

# Single split — performance estimate depends heavily
# on which 20% ended up as test data
split <- initial_split(mtcars, prop = 0.8)
train <- training(split)
test  <- testing(split)

cat('Train:', nrow(train), '| Test:', nrow(test))

initial_split()

initial_split(data, prop, strata) डेटा को training और test सेटों में एकल यादृच्छिक विभाजन में बाँटता है। किसी कॉलम के आधार पर स्तरीकरण करने के लिए strata का उपयोग करें, जैसे outcome variable, ताकि दोनों भागों में वर्गों का संतुलन बना रहे।

library(rsample)

# Stratified split by outcome variable
split <- initial_split(ames, prop = 0.8, strata = Sale_Price)

train <- training(split)
test  <- testing(split)

cat('Train rows:', nrow(train))
cat('Test rows:', nrow(test))

vfold_cv() — K-Fold क्रॉस-वैलिडेशन

vfold_cv(data, v = 10) 10 folds बनाता है। डेटा को 10 बराबर भागों में बाँटा जाता है; 9 का उपयोग training के लिए और 1 का validation के लिए होता है, फिर सभी folds पर यह क्रम बदलता रहता है। इससे प्रदर्शन के 10 अनुमान मिलते हैं, जिनका औसत लेकर स्थिर मीट्रिक प्राप्त की जाती है।

folds <- vfold_cv(housing_train, v = 10, strata = price)

# Each fold is a split object
print(folds)

# Inspect one fold
fold_1 <- folds$splits[[1]]
train_1 <- analysis(fold_1)
val_1   <- assessment(fold_1)
cat('Fold 1 — Train:', nrow(train_1), '| Val:', nrow(val_1))

fit_resamples()

fit_resamples(workflow, resamples, metrics) प्रत्येक training fold पर आपके वर्कफ़्लो को प्रशिक्षित करता है और validation fold पर उसका मूल्यांकन करके अनुरोधित metrics एकत्र करता है। यह परिणामों का एक tibble लौटाता है, जिसका सारांश आप collect_metrics() से बनाते हैं।

library(tune)

folds <- vfold_cv(housing_train, v = 10)

res <- fit_resamples(
  wf,       # your workflow
  folds,
  metrics = metric_set(rmse, rsq)
)

# Average metric across all 10 folds
collect_metrics(res)

collect_metrics()

collect_metrics(resample_result) सभी folds में मॉडल के प्रदर्शन का सारांश देने वाला सुव्यवस्थित tibble लौटाता है। mean कॉलम औसत मीट्रिक और std_err मानक त्रुटि दर्शाता है, जिससे अनुमान में विचरण का आभास मिलता है।

metrics_df <- collect_metrics(res)
print(metrics_df)

#   .metric .estimator   mean  n std_err .config
#   rmse    standard    24500  10   1200  Preprocessor1_Model1
#   rsq     standard    0.882  10  0.012  Preprocessor1_Model1

# Pull a single metric
collect_metrics(res) |>
  dplyr::filter(.metric == 'rmse') |>
  dplyr::pull(mean)

bootstraps() — बूटस्ट्रैप Resampling

bootstraps(data, times = 25) बूटस्ट्रैप नमूने बनाता है: प्रत्येक नमूना मूल dataset के बराबर आकार का, पुनर्स्थापन सहित लिया गया यादृच्छिक चयन होता है। जो observations चयनित नहीं होते, वे out-of-bag (OOB) assessment सेट बनाते हैं। K-fold की तुलना में bootstraps में विचरण अधिक होता है, लेकिन वे छोटे datasets के साथ अच्छी तरह काम करते हैं।

boot_samples <- bootstraps(housing_train, times = 25, strata = price)

print(boot_samples)

# Average proportion of unique rows in each bootstrap
mean(sapply(boot_samples$splits, function(s) {
  nrow(analysis(s)) / nrow(housing_train)
}))

मोंटे कार्लो क्रॉस-वैलिडेशन

mc_cv(data, prop, times) times यादृच्छिक विभाजन बनाता है, जिनमें प्रत्येक में डेटा का prop भाग training के लिए उपयोग होता है। K-fold के विपरीत, एक ही observation validation सेट में कई बार आ सकता है। जब आपको K-fold से मिलने वाले iterations से अधिक resampling iterations चाहिए हों, तब यह उपयोगी है।

mc_splits <- mc_cv(housing_train, prop = 0.8, times = 20)

res_mc <- fit_resamples(
  wf,
  mc_splits,
  metrics = metric_set(rmse, rsq)
)

collect_metrics(res_mc)

tune_grid() — हाइपरपैरामीटर खोज

जब आपके वर्कफ़्लो में tune() placeholders हों, तो हाइपरपैरामीटर मानों के grid में खोज करने के लिए tune_grid(wf, resamples, grid) का उपयोग करें। प्रत्येक combination का सभी folds पर मूल्यांकन किया जाता है और select_best() से सर्वोत्तम configuration चुना जाता है।

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

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

grid <- grid_regular(mtry(range = c(2, 10)), trees(range = c(100, 500)), levels = 3)

tune_res <- tune_grid(wf_tune, resamples = folds, grid = grid)
collect_metrics(tune_res) |> head()

select_best() और finalize_workflow()

Tuning के बाद select_best(tune_res, metric) सर्वोत्तम औसत मीट्रिक वाला हाइपरपैरामीटर combination चुनता है। finalize_workflow(wf, best_params) उन मानों को tune() के स्थान पर रखकर नया वर्कफ़्लो बनाता है।

best_params <- select_best(tune_res, metric = 'rmse')
print(best_params)

# Substitute best values into the workflow
final_wf <- finalize_workflow(wf_tune, best_params)

# Fit on all training data, evaluate on test
final_fit <- last_fit(final_wf, split)
collect_metrics(final_fit)

नेस्टेड क्रॉस-वैलिडेशन

जब आप हाइपरपैरामीटर भी tune कर रहे हों और वास्तव में निष्पक्ष मूल्यांकन चाहिए हो, तो नेस्टेड क्रॉस-वैलिडेशन का उपयोग करें: प्रदर्शन के अनुमान के लिए बाहरी loop और tuning के लिए आंतरिक loop। rsample में एक बाहरी vfold_cv बनाकर प्रत्येक बाहरी fold के भीतर आंतरिक folds का उपयोग करके tune करें।

# Outer folds for unbiased evaluation
outer_folds <- vfold_cv(housing_train, v = 5)

# For each outer fold, tune on the inner training data
res_nested <- tune_grid(
  wf_tune,
  resamples = outer_folds,
  grid = 10,  # 10 random configurations
  metrics = metric_set(rmse)
)

collect_metrics(res_nested)

Resampling रणनीतियों की तुलना

प्रत्येक resampling रणनीति के अपने लाभ और सीमाएँ हैं। चुनाव अपने dataset के आकार और उपलब्ध computational budget के आधार पर करें:

k-fold (v=10): कम bias, मध्यम variance। अधिकांश समस्याओं के लिए डिफ़ॉल्ट विकल्प।
Bootstrap: बहुत छोटे डेटा के साथ काम करता है; k-fold की तुलना में variance अधिक होता है।
Monte Carlo CV: अधिक लचीला; समय-सीमित tuning के लिए अच्छा।
Repeated k-fold: कम variance; जब आप अधिक computation का खर्च उठा सकें तब उपयोग करें।

# Repeated k-fold: 5-fold repeated 3 times = 15 models fitted
repeated_folds <- vfold_cv(housing_train, v = 5, repeats = 3)

res_rep <- fit_resamples(
  wf,
  repeated_folds,
  metrics = metric_set(rmse, rsq)
)

collect_metrics(res_rep)

त्वरित जाँच

fit_resamples() के परिणाम पर लागू करने पर collect_metrics() क्या लौटाता है?

इंटरैक्टिव पाठ में इसका उत्तर दें

Resampling का पुनरावलोकन

rsample के साथ Resampling और क्रॉस-वैलिडेशन से मुख्य बातें:

initial_split(data, prop, strata) स्तरीकृत training/test विभाजन बनाता है।
vfold_cv(data, v = 10) k-fold क्रॉस-वैलिडेशन folds बनाता है।
bootstraps(data, times) छोटे datasets के लिए बूटस्ट्रैप नमूने बनाता है।
fit_resamples(wf, folds, metrics) सभी folds पर वर्कफ़्लो का मूल्यांकन करता है।
collect_metrics() mean और standard error के साथ परिणामों का सारांश देता है।
tune_grid() हाइपरपैरामीटर खोजता है; select_best() विजेता चुनता है।
finalize_workflow() + last_fit() tuning से deployment तक की pipeline पूरी करते हैं।

# Full rsample pipeline
split  <- initial_split(data, prop = 0.8, strata = y)
train  <- training(split)
folds  <- vfold_cv(train, v = 10)

res    <- fit_resamples(wf, folds, metrics = metric_set(rmse, rsq))
collect_metrics(res)

# After tuning
best   <- select_best(tune_res, metric = 'rmse')
fin_wf <- finalize_workflow(wf_tune, best)
last_fit(fin_wf, split) |> collect_metrics()

शुरुआत निःशुल्क

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

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

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

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

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

क्या “rsample से पुनर्नमूनाकरण और क्रॉस-वैलिडेशन” पाठ निःशुल्क है?

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

“rsample से पुनर्नमूनाकरण और क्रॉस-वैलिडेशन” में मैं क्या सीखूँगा?

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

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

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

“rsample से पुनर्नमूनाकरण और क्रॉस-वैलिडेशन” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

recipes से फीचर इंजीनियरिंग
parsnip से मॉडल विनिर्देश
वर्कफ़्लो: रेसिपी और मॉडल का संयोजन
rsample से पुनर्नमूनाकरण और क्रॉस-वैलिडेशन

← R Academy पर वापस जाएँ