{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "lesson_12-R.ipynb",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "ir",
   "display_name": "R"
  },
  "language_info": {
   "name": "R"
  },
  "coopTranslator": {
   "original_hash": "fab50046ca413a38939d579f8432274f",
   "translation_date": "2025-08-29T19:30:57+00:00",
   "source_file": "4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb",
   "language_code": "ne"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jsFutf_ygqSx"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HD54bEefgtNO"
   },
   "source": [
    "## खाना वर्गीकरणकर्ता २\n",
    "\n",
    "यस दोस्रो वर्गीकरण पाठमा, हामी `थप तरिकाहरू` द्वारा श्रेणीगत डाटालाई वर्गीकरण गर्ने तरिकाहरू अन्वेषण गर्नेछौं। साथै, एक वर्गीकरणकर्ता चयन गर्दा हुने प्रभावहरूको बारेमा पनि सिक्नेछौं।\n",
    "\n",
    "### [**पाठ अघि क्विज**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/23/)\n",
    "\n",
    "### **पूर्व-आवश्यकता**\n",
    "\n",
    "हामी मान्दछौं कि तपाईंले अघिल्लो पाठहरू पूरा गरिसक्नुभएको छ किनभने हामीले पहिले सिकेका केही अवधारणाहरूलाई अगाडि बढाउनेछौं।\n",
    "\n",
    "यस पाठको लागि, हामीलाई निम्न प्याकेजहरू आवश्यक पर्नेछ:\n",
    "\n",
    "-   `tidyverse`: [tidyverse](https://www.tidyverse.org/) [R प्याकेजहरूको संग्रह](https://www.tidyverse.org/packages) हो जसले डाटा विज्ञानलाई छिटो, सजिलो र रमाइलो बनाउँछ!\n",
    "\n",
    "-   `tidymodels`: [tidymodels](https://www.tidymodels.org/) फ्रेमवर्क [मोडलिङ र मेसिन लर्निङका लागि प्याकेजहरूको संग्रह](https://www.tidymodels.org/packages/) हो।\n",
    "\n",
    "-   `themis`: [themis प्याकेज](https://themis.tidymodels.org/) असन्तुलित डाटासँग व्यवहार गर्न अतिरिक्त रेसिपी चरणहरू प्रदान गर्दछ।\n",
    "\n",
    "तपाईंले यी प्याकेजहरू निम्न तरिकाले स्थापना गर्न सक्नुहुन्छ:\n",
    "\n",
    "`install.packages(c(\"tidyverse\", \"tidymodels\", \"kernlab\", \"themis\", \"ranger\", \"xgboost\", \"kknn\"))`\n",
    "\n",
    "वैकल्पिक रूपमा, तलको स्क्रिप्टले जाँच गर्दछ कि तपाईंले यस मोड्युल पूरा गर्न आवश्यक प्याकेजहरू स्थापना गर्नुभएको छ कि छैन, र यदि छैन भने, तिनीहरूलाई तपाईंको लागि स्थापना गर्दछ।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "vZ57IuUxgyQt"
   },
   "source": [
    "suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
    "\n",
    "pacman::p_load(tidyverse, tidymodels, themis, kernlab, ranger, xgboost, kknn)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z22M-pj4g07x"
   },
   "source": [
    "## **१. वर्गीकरण नक्सा**\n",
    "\n",
    "हाम्रो [अघिल्लो पाठ](https://github.com/microsoft/ML-For-Beginners/tree/main/4-Classification/2-Classifiers-1) मा, हामीले यो प्रश्नको उत्तर दिन प्रयास गर्यौं: धेरै मोडेलहरू बीच कसरी छनोट गर्ने? धेरै हदसम्म, यो डाटाको विशेषताहरू र हामीले समाधान गर्न चाहेको समस्याको प्रकार (जस्तै वर्गीकरण वा रिग्रेसन?) मा निर्भर गर्दछ।\n",
    "\n",
    "अघिल्लो पाठमा, हामीले माइक्रोसफ्टको चिट शीट प्रयोग गरेर डाटा वर्गीकरण गर्दा तपाईंले पाउन सक्ने विभिन्न विकल्पहरूको बारेमा सिक्यौं। पाइथनको मेसिन लर्निङ फ्रेमवर्क, Scikit-learn, ले यस्तै तर अझ विस्तृत चिट शीट प्रदान गर्दछ, जसले तपाईंको इस्टिमेटरहरू (वर्गीकरणकर्ताहरूको अर्को शब्द) चयन गर्न अझ सटीक मद्दत गर्न सक्छ:\n",
    "\n",
    "<p >\n",
    "   <img src=\"../../images/map.png\"\n",
    "   width=\"700\"/>\n",
    "   <figcaption></figcaption>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u1i3xRIVg7vG"
   },
   "source": [
    "> सुझाव: [यो अनलाइन नक्सा हेर्नुहोस्](https://scikit-learn.org/stable/tutorial/machine_learning_map/) र मार्गहरूमा क्लिक गरेर दस्तावेज पढ्नुहोस्।\n",
    ">\n",
    "> [Tidymodels सन्दर्भ साइट](https://www.tidymodels.org/find/parsnip/#models) ले विभिन्न प्रकारका मोडेलहरूको उत्कृष्ट दस्तावेज पनि प्रदान गर्दछ।\n",
    "\n",
    "### **योजना** 🗺️\n",
    "\n",
    "यो नक्सा तब धेरै उपयोगी हुन्छ जब तपाईंले आफ्नो डाटाको स्पष्ट समझ पाउनुभएको छ, किनकि तपाईं यसका मार्गहरूमा 'हिँडेर' निर्णयमा पुग्न सक्नुहुन्छ:\n",
    "\n",
    "-   हामीसँग \\>50 नमूनाहरू छन्\n",
    "\n",
    "-   हामीले एउटा श्रेणीको भविष्यवाणी गर्न चाहन्छौं\n",
    "\n",
    "-   हामीसँग लेबल गरिएको डाटा छ\n",
    "\n",
    "-   हामीसँग 100K भन्दा कम नमूनाहरू छन्\n",
    "\n",
    "-   ✨ हामीले Linear SVC चयन गर्न सक्छौं\n",
    "\n",
    "-   यदि यो काम गर्दैन भने, किनकि हामीसँग संख्यात्मक डाटा छ\n",
    "\n",
    "    -   हामी ✨ KNeighbors Classifier प्रयास गर्न सक्छौं\n",
    "\n",
    "        -   यदि यो काम गर्दैन भने, ✨ SVC र ✨ Ensemble Classifiers प्रयास गर्नुहोस्\n",
    "\n",
    "यो पछ्याउन धेरै उपयोगी मार्ग हो। अब, [tidymodels](https://www.tidymodels.org/) मोडेलिङ फ्रेमवर्क प्रयोग गरेर यसमा सिधै प्रवेश गरौं: राम्रो सांख्यिकीय अभ्यासलाई प्रोत्साहित गर्न विकसित गरिएको R प्याकेजहरूको एक सुसंगत र लचिलो संग्रह 😊।\n",
    "\n",
    "## २. डाटालाई विभाजन गर्नुहोस् र असन्तुलित डाटा सेटसँग व्यवहार गर्नुहोस्।\n",
    "\n",
    "हाम्रो अघिल्लो पाठहरूबाट, हामीले सिक्यौं कि हाम्रो खानाहरूमा सामान्य सामग्रीहरूको सेट थियो। साथै, खानाहरूको संख्यामा धेरै असमान वितरण थियो।\n",
    "\n",
    "हामी यी समस्याहरूलाई यसरी समाधान गर्नेछौं:\n",
    "\n",
    "-   `dplyr::select()` प्रयोग गरेर फरक खानाहरू बीच भ्रम सिर्जना गर्ने सबैभन्दा सामान्य सामग्रीहरू हटाउने।\n",
    "\n",
    "-   डाटालाई पूर्व-प्रक्रिया गर्न र मोडेलिङको लागि तयार पार्न `recipe` प्रयोग गर्ने, जसले `over-sampling` एल्गोरिदम लागू गर्दछ।\n",
    "\n",
    "हामीले माथिको कुरा अघिल्लो पाठमा पहिले नै हेरेका थियौं, त्यसैले यो सजिलो हुनेछ 🥳!\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "6tj_rN00hClA"
   },
   "source": [
    "# Load the core Tidyverse and Tidymodels packages\n",
    "library(tidyverse)\n",
    "library(tidymodels)\n",
    "\n",
    "# Load the original cuisines data\n",
    "df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/4-Classification/data/cuisines.csv\")\n",
    "\n",
    "# Drop id column, rice, garlic and ginger from our original data set\n",
    "df_select <- df %>% \n",
    "  select(-c(1, rice, garlic, ginger)) %>%\n",
    "  # Encode cuisine column as categorical\n",
    "  mutate(cuisine = factor(cuisine))\n",
    "\n",
    "\n",
    "# Create data split specification\n",
    "set.seed(2056)\n",
    "cuisines_split <- initial_split(data = df_select,\n",
    "                                strata = cuisine,\n",
    "                                prop = 0.7)\n",
    "\n",
    "# Extract the data in each split\n",
    "cuisines_train <- training(cuisines_split)\n",
    "cuisines_test <- testing(cuisines_split)\n",
    "\n",
    "# Display distribution of cuisines in the training set\n",
    "cuisines_train %>% \n",
    "  count(cuisine) %>% \n",
    "  arrange(desc(n))"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zFin5yw3hHb1"
   },
   "source": [
    "### असन्तुलित डाटासँग व्यवहार गर्ने\n",
    "\n",
    "असन्तुलित डाटाले प्रायः मोडेलको प्रदर्शनमा नकारात्मक प्रभाव पार्छ। धेरै मोडेलहरू तब राम्रो प्रदर्शन गर्छन् जब अवलोकनहरूको संख्या समान हुन्छ, र त्यसैले असन्तुलित डाटासँग संघर्ष गर्न सक्छन्।\n",
    "\n",
    "असन्तुलित डाटासेटहरूलाई व्यवस्थापन गर्ने दुई मुख्य तरिकाहरू छन्:\n",
    "\n",
    "-   अल्पसंख्यक वर्गमा अवलोकनहरू थप्ने: `ओभर-स्याम्पलिङ`, जस्तै SMOTE एल्गोरिदम प्रयोग गरेर, जसले यी केसहरूको नजिकका छिमेकीहरूको प्रयोग गरी अल्पसंख्यक वर्गका नयाँ उदाहरणहरू कृत्रिम रूपमा उत्पन्न गर्छ।\n",
    "\n",
    "-   बहुसंख्यक वर्गबाट अवलोकनहरू हटाउने: `अन्डर-स्याम्पलिङ`\n",
    "\n",
    "हाम्रो अघिल्लो पाठमा, हामीले `recipe` प्रयोग गरेर असन्तुलित डाटासेटहरूलाई कसरी व्यवस्थापन गर्ने भनेर देखाएका थियौं। `recipe` लाई एउटा खाका जस्तै सोच्न सकिन्छ, जसले डाटासेटलाई डाटा विश्लेषणको लागि तयार पार्न के कदमहरू लागू गर्नुपर्छ भनेर वर्णन गर्छ। हाम्रो केसमा, हामी हाम्रो `training set` का लागि हाम्रो खानाहरूको संख्यामा समान वितरण चाहन्छौं। अब यसमा लागौं।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "cRzTnHolhLWd"
   },
   "source": [
    "# Load themis package for dealing with imbalanced data\n",
    "library(themis)\n",
    "\n",
    "# Create a recipe for preprocessing training data\n",
    "cuisines_recipe <- recipe(cuisine ~ ., data = cuisines_train) %>%\n",
    "  step_smote(cuisine) \n",
    "\n",
    "# Print recipe\n",
    "cuisines_recipe"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KxOQ2ORhhO81"
   },
   "source": [
    "अब हामी मोडेलहरू प्रशिक्षण गर्न तयार छौं 👩‍💻👨‍💻!\n",
    "\n",
    "## ३. बहुविकल्पीय प्रतिगमन मोडेलहरू भन्दा पर\n",
    "\n",
    "हाम्रो अघिल्लो पाठमा, हामीले बहुविकल्पीय प्रतिगमन मोडेलहरूबारे अध्ययन गर्यौं। अब, वर्गीकरणका लागि केही थप लचिलो मोडेलहरू अन्वेषण गरौं।\n",
    "\n",
    "### सपोर्ट भेक्टर मेसिनहरू\n",
    "\n",
    "वर्गीकरणको सन्दर्भमा, `सपोर्ट भेक्टर मेसिनहरू` एक मेसिन लर्निङ प्रविधि हो जसले *हाइपरप्लेन* पत्ता लगाउन प्रयास गर्छ, जसले वर्गहरूलाई \"सबैभन्दा राम्रो\" तरिकाले छुट्याउँछ। अब, एउटा साधारण उदाहरण हेरौं:\n",
    "\n",
    "<p >\n",
    "   <img src=\"../../images/svm.png\"\n",
    "   width=\"300\"/>\n",
    "   <figcaption>https://commons.wikimedia.org/w/index.php?curid=22877598</figcaption>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C4Wsd0vZhXYu"
   },
   "source": [
    "H1~ कक्षाहरूलाई अलग गर्दैन। H2~ अलग गर्छ, तर केवल सानो मार्जिनसहित। H3~ तिनीहरूलाई अधिकतम मार्जिनसहित अलग गर्छ।\n",
    "\n",
    "#### रेखीय सपोर्ट भेक्टर क्लासिफायर\n",
    "\n",
    "सपोर्ट-भेक्टर क्लस्टरिङ (SVC) सपोर्ट-भेक्टर मेसिनहरूको ML प्रविधिहरूको परिवारको एक शाखा हो। SVC मा, हाइपरप्लेनलाई `प्रशिक्षणको अधिकांश` अवलोकनलाई सही रूपमा अलग गर्न चयन गरिन्छ, तर `केही अवलोकनलाई गलत वर्गीकरण गर्न` सकिन्छ। केही बिन्दुहरूलाई गलत पक्षमा राख्न अनुमति दिएर, SVM आउटलायर्सप्रति बढी मजबुत हुन्छ र नयाँ डाटामा राम्रो सामान्यीकरण प्रदान गर्छ। यस उल्लङ्घनलाई नियमन गर्ने प्यारामिटरलाई `cost` भनिन्छ जसको डिफल्ट मान 1 हुन्छ (हेर्नुहोस् `help(\"svm_poly\")`)।\n",
    "\n",
    "आउनुहोस्, `degree = 1` सेट गरेर बहुपद SVM मोडेलमा एक रेखीय SVC बनाउँ।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "vJpp6nuChlBz"
   },
   "source": [
    "# Make a linear SVC specification\n",
    "svc_linear_spec <- svm_poly(degree = 1) %>% \n",
    "  set_engine(\"kernlab\") %>% \n",
    "  set_mode(\"classification\")\n",
    "\n",
    "# Bundle specification and recipe into a worklow\n",
    "svc_linear_wf <- workflow() %>% \n",
    "  add_recipe(cuisines_recipe) %>% \n",
    "  add_model(svc_linear_spec)\n",
    "\n",
    "# Print out workflow\n",
    "svc_linear_wf"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rDs8cWNkhoqu"
   },
   "source": [
    "अब हामीले *workflow* मा पूर्वप्रक्रिया चरणहरू र मोडेल निर्दिष्टिकरण समेटिसकेपछि, हामीले linear SVC लाई प्रशिक्षण दिन र त्यसै क्रममा नतिजाहरू मूल्याङ्कन गर्न सक्छौं। प्रदर्शन मापनका लागि, आउनुहोस् एउटा मेट्रिक सेट बनाउँ, जसले `accuracy`, `sensitivity`, `Positive Predicted Value` र `F Measure` को मूल्याङ्कन गर्नेछ।\n",
    "\n",
    "> `augment()` ले दिइएको डाटामा भविष्यवाणीका लागि स्तम्भ(हरू) थप्नेछ।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "81wiqcwuhrnq"
   },
   "source": [
    "# Train a linear SVC model\n",
    "svc_linear_fit <- svc_linear_wf %>% \n",
    "  fit(data = cuisines_train)\n",
    "\n",
    "# Create a metric set\n",
    "eval_metrics <- metric_set(ppv, sens, accuracy, f_meas)\n",
    "\n",
    "\n",
    "# Make predictions and Evaluate model performance\n",
    "svc_linear_fit %>% \n",
    "  augment(new_data = cuisines_test) %>% \n",
    "  eval_metrics(truth = cuisine, estimate = .pred_class)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0UFQvHf-huo3"
   },
   "source": [
    "#### सपोर्ट भेक्टर मेसिन\n",
    "\n",
    "सपोर्ट भेक्टर मेसिन (SVM) सपोर्ट भेक्टर क्लासिफायरको विस्तार हो, जसले कक्षाहरू बीचको गैर-रेखीय सिमानालाई समायोजन गर्न सक्षम बनाउँछ। मुख्य रूपमा, SVMहरूले *कर्नेल ट्रिक* प्रयोग गरेर फिचर स्पेसलाई विस्तार गर्छन्, ताकि कक्षाहरू बीचको गैर-रेखीय सम्बन्धहरूलाई अनुकूल बनाउन सकियोस्। SVMहरूले प्रयोग गर्ने एक लोकप्रिय र अत्यन्त लचिलो कर्नेल फङ्सन *Radial basis function* हो। अब हेरौं, यसले हाम्रो डाटामा कस्तो प्रदर्शन गर्छ।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "-KX4S8mzhzmp"
   },
   "source": [
    "set.seed(2056)\n",
    "\n",
    "# Make an RBF SVM specification\n",
    "svm_rbf_spec <- svm_rbf() %>% \n",
    "  set_engine(\"kernlab\") %>% \n",
    "  set_mode(\"classification\")\n",
    "\n",
    "# Bundle specification and recipe into a worklow\n",
    "svm_rbf_wf <- workflow() %>% \n",
    "  add_recipe(cuisines_recipe) %>% \n",
    "  add_model(svm_rbf_spec)\n",
    "\n",
    "\n",
    "# Train an RBF model\n",
    "svm_rbf_fit <- svm_rbf_wf %>% \n",
    "  fit(data = cuisines_train)\n",
    "\n",
    "\n",
    "# Make predictions and Evaluate model performance\n",
    "svm_rbf_fit %>% \n",
    "  augment(new_data = cuisines_test) %>% \n",
    "  eval_metrics(truth = cuisine, estimate = .pred_class)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QBFSa7WSh4HQ"
   },
   "source": [
    "धेरै राम्रो 🤩!\n",
    "\n",
    "> ✅ कृपया हेर्नुहोस्:\n",
    ">\n",
    "> -   [*Support Vector Machines*](https://bradleyboehmke.github.io/HOML/svm.html), Hands-on Machine Learning with R\n",
    ">\n",
    "> -   [*Support Vector Machines*](https://www.statlearning.com/), An Introduction to Statistical Learning with Applications in R\n",
    ">\n",
    "> थप अध्ययनको लागि।\n",
    "\n",
    "### नजिकको छिमेकी वर्गीकरणकर्ता\n",
    "\n",
    "*K*-नजिकको छिमेकी (KNN) एउटा एल्गोरिदम हो जसमा प्रत्येक अवलोकनलाई अन्य अवलोकनहरूसँगको *समानता* को आधारमा भविष्यवाणी गरिन्छ।\n",
    "\n",
    "आउनुहोस्, यसलाई हाम्रो डाटामा फिट गरौं।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "k4BxxBcdh9Ka"
   },
   "source": [
    "# Make a KNN specification\n",
    "knn_spec <- nearest_neighbor() %>% \n",
    "  set_engine(\"kknn\") %>% \n",
    "  set_mode(\"classification\")\n",
    "\n",
    "# Bundle recipe and model specification into a workflow\n",
    "knn_wf <- workflow() %>% \n",
    "  add_recipe(cuisines_recipe) %>% \n",
    "  add_model(knn_spec)\n",
    "\n",
    "# Train a boosted tree model\n",
    "knn_wf_fit <- knn_wf %>% \n",
    "  fit(data = cuisines_train)\n",
    "\n",
    "\n",
    "# Make predictions and Evaluate model performance\n",
    "knn_wf_fit %>% \n",
    "  augment(new_data = cuisines_test) %>% \n",
    "  eval_metrics(truth = cuisine, estimate = .pred_class)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HaegQseriAcj"
   },
   "source": [
    "यो मोडेलले राम्रो प्रदर्शन गरिरहेको जस्तो देखिँदैन। सम्भवतः मोडेलका तर्कहरू परिवर्तन गर्दा (हेर्नुहोस् `help(\"nearest_neighbor\")`) मोडेलको प्रदर्शन सुधार हुन सक्छ। पक्का गर्नुहोस् कि यसलाई प्रयास गर्नुहोस्।\n",
    "\n",
    "> ✅ कृपया हेर्नुहोस्:\n",
    ">\n",
    "> -   [Hands-on Machine Learning with R](https://bradleyboehmke.github.io/HOML/)\n",
    ">\n",
    "> -   [An Introduction to Statistical Learning with Applications in R](https://www.statlearning.com/)\n",
    ">\n",
    "> *K*-Nearest Neighbors classifiers को बारेमा थप जान्न।\n",
    "\n",
    "### Ensemble classifiers\n",
    "\n",
    "Ensemble एल्गोरिदमहरूले धेरै आधारभूत अनुमानकर्ताहरूलाई संयोजन गरेर एउटा उत्तम मोडेल उत्पादन गर्छन्, जसले गर्दा:\n",
    "\n",
    "`bagging`: आधारभूत मोडेलहरूको संग्रहमा *औसत कार्य* लागू गर्ने\n",
    "\n",
    "`boosting`: एकअर्कामा निर्माण हुने मोडेलहरूको क्रम बनाउने जसले भविष्यवाणी प्रदर्शन सुधार गर्छ।\n",
    "\n",
    "हामी Random Forest मोडेलबाट सुरु गरौं, जसले निर्णयका रूखहरूको ठूलो संग्रह बनाउँछ र त्यसपछि राम्रो समग्र मोडेलका लागि औसत कार्य लागू गर्छ।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "49DPoVs6iK1M"
   },
   "source": [
    "# Make a random forest specification\n",
    "rf_spec <- rand_forest() %>% \n",
    "  set_engine(\"ranger\") %>% \n",
    "  set_mode(\"classification\")\n",
    "\n",
    "# Bundle recipe and model specification into a workflow\n",
    "rf_wf <- workflow() %>% \n",
    "  add_recipe(cuisines_recipe) %>% \n",
    "  add_model(rf_spec)\n",
    "\n",
    "# Train a random forest model\n",
    "rf_wf_fit <- rf_wf %>% \n",
    "  fit(data = cuisines_train)\n",
    "\n",
    "\n",
    "# Make predictions and Evaluate model performance\n",
    "rf_wf_fit %>% \n",
    "  augment(new_data = cuisines_test) %>% \n",
    "  eval_metrics(truth = cuisine, estimate = .pred_class)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RGVYwC_aiUWc"
   },
   "source": [
    "राम्रो काम 👏!\n",
    "\n",
    "आउनुहोस् Boosted Tree मोडेलसँग पनि प्रयोग गरौं।\n",
    "\n",
    "Boosted Tree ले एउटा ensemble विधि परिभाषित गर्दछ जसले क्रमिक निर्णय वृक्षहरूको श्रृंखला सिर्जना गर्दछ, जहाँ प्रत्येक वृक्षले अघिल्लो वृक्षहरूको नतिजामा निर्भर गर्दछ र क्रमिक रूपमा त्रुटि घटाउने प्रयास गर्दछ। यसले गलत वर्गीकृत वस्तुहरूको तौलमा ध्यान केन्द्रित गर्दछ र अर्को वर्गीकर्तालाई सुधार गर्नको लागि फिट समायोजन गर्दछ।\n",
    "\n",
    "यो मोडेल फिट गर्नका लागि विभिन्न तरिकाहरू छन् (हेर्नुहोस् `help(\"boost_tree\")`)। यस उदाहरणमा, हामी Boosted वृक्षहरूलाई `xgboost` इन्जिन मार्फत फिट गर्नेछौं।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Py1YWo-micWs"
   },
   "source": [
    "# Make a boosted tree specification\n",
    "boost_spec <- boost_tree(trees = 200) %>% \n",
    "  set_engine(\"xgboost\") %>% \n",
    "  set_mode(\"classification\")\n",
    "\n",
    "# Bundle recipe and model specification into a workflow\n",
    "boost_wf <- workflow() %>% \n",
    "  add_recipe(cuisines_recipe) %>% \n",
    "  add_model(boost_spec)\n",
    "\n",
    "# Train a boosted tree model\n",
    "boost_wf_fit <- boost_wf %>% \n",
    "  fit(data = cuisines_train)\n",
    "\n",
    "\n",
    "# Make predictions and Evaluate model performance\n",
    "boost_wf_fit %>% \n",
    "  augment(new_data = cuisines_test) %>% \n",
    "  eval_metrics(truth = cuisine, estimate = .pred_class)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zNQnbuejigZM"
   },
   "source": [
    "> ✅ कृपया हेर्नुहोस्:\n",
    ">\n",
    "> -   [Machine Learning for Social Scientists](https://cimentadaj.github.io/ml_socsci/tree-based-methods.html#random-forests)\n",
    ">\n",
    "> -   [Hands-on Machine Learning with R](https://bradleyboehmke.github.io/HOML/)\n",
    ">\n",
    "> -   [An Introduction to Statistical Learning with Applications in R](https://www.statlearning.com/)\n",
    ">\n",
    "> -   <https://algotech.netlify.app/blog/xgboost/> - AdaBoost मोडेलको अध्ययन गर्दछ, जुन xgboost को राम्रो विकल्प हो।\n",
    ">\n",
    "> Ensemble classifiers को बारेमा थप जान्न।\n",
    "\n",
    "## ४. थप - धेरै मोडेलहरूको तुलना\n",
    "\n",
    "हामीले यस प्रयोगशालामा धेरै मोडेलहरू फिट गरेका छौं 🙌। विभिन्न प्रिप्रोसेसर सेटहरू र/वा मोडेल स्पेसिफिकेसनहरूबाट धेरै वर्कफ्लोहरू सिर्जना गर्नु र त्यसपछि प्रदर्शन मेट्रिक्स एक-एक गरेर गणना गर्नु थकाइ लाग्दो वा झन्झटिलो हुन सक्छ।\n",
    "\n",
    "हेरौं, के हामी यसलाई समाधान गर्न सक्छौं कि प्रशिक्षण सेटमा वर्कफ्लोहरूको सूची फिट गर्ने र त्यसपछि परीक्षण सेटको आधारमा प्रदर्शन मेट्रिक्स फिर्ता गर्ने एउटा function सिर्जना गरेर। हामी [purrr](https://purrr.tidyverse.org/) प्याकेजबाट `map()` र `map_dfr()` प्रयोग गर्नेछौं, जसले सूचीका प्रत्येक तत्वमा function लागू गर्न मद्दत गर्दछ।\n",
    "\n",
    "> [`map()`](https://purrr.tidyverse.org/reference/map.html) functions ले धेरै for loops लाई प्रतिस्थापन गर्न अनुमति दिन्छ, जसले कोडलाई छोटो र पढ्न सजिलो बनाउँछ। [`map()`](https://purrr.tidyverse.org/reference/map.html) functions को बारेमा सिक्नको लागि सबैभन्दा राम्रो ठाउँ हो [iteration chapter](http://r4ds.had.co.nz/iteration.html) R for data science मा।\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Qzb7LyZnimd2"
   },
   "source": [
    "set.seed(2056)\n",
    "\n",
    "# Create a metric set\n",
    "eval_metrics <- metric_set(ppv, sens, accuracy, f_meas)\n",
    "\n",
    "# Define a function that returns performance metrics\n",
    "compare_models <- function(workflow_list, train_set, test_set){\n",
    "  \n",
    "  suppressWarnings(\n",
    "    # Fit each model to the train_set\n",
    "    map(workflow_list, fit, data = train_set) %>% \n",
    "    # Make predictions on the test set\n",
    "      map_dfr(augment, new_data = test_set, .id = \"model\") %>%\n",
    "    # Select desired columns\n",
    "      select(model, cuisine, .pred_class) %>% \n",
    "    # Evaluate model performance\n",
    "      group_by(model) %>% \n",
    "      eval_metrics(truth = cuisine, estimate = .pred_class) %>% \n",
    "      ungroup()\n",
    "  )\n",
    "  \n",
    "} # End of function"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fwa712sNisDA"
   },
   "source": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3i4VJOi2iu-a"
   },
   "source": [
    "# Make a list of workflows\n",
    "workflow_list <- list(\n",
    "  \"svc\" = svc_linear_wf,\n",
    "  \"svm\" = svm_rbf_wf,\n",
    "  \"knn\" = knn_wf,\n",
    "  \"random_forest\" = rf_wf,\n",
    "  \"xgboost\" = boost_wf)\n",
    "\n",
    "# Call the function\n",
    "set.seed(2056)\n",
    "perf_metrics <- compare_models(workflow_list = workflow_list, train_set = cuisines_train, test_set = cuisines_test)\n",
    "\n",
    "# Print out performance metrics\n",
    "perf_metrics %>% \n",
    "  group_by(.metric) %>% \n",
    "  arrange(desc(.estimate)) %>% \n",
    "  slice_head(n=7)\n",
    "\n",
    "# Compare accuracy\n",
    "perf_metrics %>% \n",
    "  filter(.metric == \"accuracy\") %>% \n",
    "  arrange(desc(.estimate))\n"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KuWK_lEli4nW"
   },
   "source": [
    "[**workflowset**](https://workflowsets.tidymodels.org/) प्याकेजले प्रयोगकर्ताहरूलाई धेरै मोडेलहरू सिर्जना गर्न र सजिलैसँग फिट गर्न अनुमति दिन्छ, तर यो मुख्य रूपमा `cross-validation` जस्ता पुन: नमूना प्रविधिहरूसँग काम गर्न डिजाइन गरिएको छ, जुन हामीले अझै कभर गर्न बाँकी छ।\n",
    "\n",
    "## **🚀चुनौती**\n",
    "\n",
    "यी प्रत्येक प्रविधिहरूमा धेरै संख्यामा प्यारामिटरहरू हुन्छन् जसलाई तपाईं परिमार्जन गर्न सक्नुहुन्छ, जस्तै SVM मा `cost`, KNN मा `neighbors`, र Random Forest मा `mtry` (र्यान्डम रूपमा चयन गरिएका भविष्यवाणीहरू)।\n",
    "\n",
    "प्रत्येक मोडेलको डिफल्ट प्यारामिटरहरूको अनुसन्धान गर्नुहोस् र यी प्यारामिटरहरू परिमार्जन गर्दा मोडेलको गुणस्तरमा के प्रभाव पर्छ भनेर सोच्नुहोस्।\n",
    "\n",
    "कुनै विशेष मोडेल र यसको प्यारामिटरहरूको बारेमा थप जान्नको लागि, प्रयोग गर्नुहोस्: `help(\"model\")` जस्तै `help(\"rand_forest\")`\n",
    "\n",
    "> व्यवहारमा, हामी सामान्यतया *सबैभन्दा राम्रो मानहरू* *अनुमान* गर्छौं, धेरै मोडेलहरूलाई `simulated data set` मा प्रशिक्षण गरेर र ती सबै मोडेलहरूले कत्तिको राम्रो प्रदर्शन गर्छन् भनेर मापन गरेर। यो प्रक्रिया **tuning** भनिन्छ।\n",
    "\n",
    "### [**पोस्ट-लेक्चर क्विज**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/24/)\n",
    "\n",
    "### **पुनरावलोकन र आत्म-अध्ययन**\n",
    "\n",
    "यी पाठहरूमा धेरै जटिल शब्दावली छ, त्यसैले [यो सूची](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) को उपयोगी शब्दावलीलाई एकपटक हेर्नुहोस्!\n",
    "\n",
    "#### धन्यवाद:\n",
    "\n",
    "[`Allison Horst`](https://twitter.com/allison_horst/) लाई R लाई अझ स्वागतयोग्य र आकर्षक बनाउने अद्भुत चित्रणहरू सिर्जना गरेकोमा। उनको [gallery](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM) मा थप चित्रणहरू फेला पार्नुहोस्।\n",
    "\n",
    "[Cassie Breviu](https://www.twitter.com/cassieview) र [Jen Looper](https://www.twitter.com/jenlooper) लाई यस मोड्युलको मूल Python संस्करण सिर्जना गरेकोमा ♥️\n",
    "\n",
    "सुखद अध्ययन,\n",
    "\n",
    "[Eric](https://twitter.com/ericntay), Gold Microsoft Learn Student Ambassador।\n",
    "\n",
    "<p >\n",
    "   <img src=\"../../images/r_learners_sm.jpeg\"\n",
    "   width=\"569\"/>\n",
    "   <figcaption>चित्रण @allison_horst द्वारा</figcaption>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**अस्वीकरण**:  \nयो दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) प्रयोग गरेर अनुवाद गरिएको छ। हामी शुद्धताको लागि प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छ। यसको मूल भाषा मा रहेको मूल दस्तावेज़लाई आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीको लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याको लागि हामी जिम्मेवार हुने छैनौं।\n"
   ]
  }
 ]
}