{
 "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-29T15:29:37+00:00",
   "source_file": "4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb",
   "language_code": "tl"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jsFutf_ygqSx"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HD54bEefgtNO"
   },
   "source": [
    "## Mga Classifier ng Lutuin 2\n",
    "\n",
    "Sa ikalawang aralin ng klasipikasyon, tatalakayin natin ang `mas maraming paraan` upang iklasipika ang categorical na data. Matutunan din natin ang mga epekto ng pagpili ng isang classifier kumpara sa iba.\n",
    "\n",
    "### [**Pre-lecture quiz**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/23/)\n",
    "\n",
    "### **Paunang Kaalaman**\n",
    "\n",
    "Inaakala namin na natapos mo na ang mga naunang aralin dahil magpapatuloy tayo sa ilang mga konsepto na natutunan natin dati.\n",
    "\n",
    "Para sa araling ito, kakailanganin natin ang mga sumusunod na package:\n",
    "\n",
    "-   `tidyverse`: Ang [tidyverse](https://www.tidyverse.org/) ay isang [koleksyon ng mga R package](https://www.tidyverse.org/packages) na idinisenyo upang gawing mas mabilis, mas madali, at mas masaya ang data science!\n",
    "\n",
    "-   `tidymodels`: Ang [tidymodels](https://www.tidymodels.org/) framework ay isang [koleksyon ng mga package](https://www.tidymodels.org/packages/) para sa pagmomodelo at machine learning.\n",
    "\n",
    "-   `themis`: Ang [themis package](https://themis.tidymodels.org/) ay nagbibigay ng Extra Recipes Steps para sa pag-aayos ng hindi balanseng data.\n",
    "\n",
    "Maaari mong i-install ang mga ito gamit ang:\n",
    "\n",
    "`install.packages(c(\"tidyverse\", \"tidymodels\", \"kernlab\", \"themis\", \"ranger\", \"xgboost\", \"kknn\"))`\n",
    "\n",
    "Bilang alternatibo, ang script sa ibaba ay nagche-check kung mayroon ka ng mga kinakailangang package upang makumpleto ang module na ito at ini-install ang mga ito para sa iyo kung sakaling wala pa.\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": [
    "## **1. Isang Mapa ng Klasipikasyon**\n",
    "\n",
    "Sa ating [nakaraang aralin](https://github.com/microsoft/ML-For-Beginners/tree/main/4-Classification/2-Classifiers-1), sinubukan nating sagutin ang tanong: paano tayo pipili sa pagitan ng iba't ibang modelo? Sa malaking bahagi, nakadepende ito sa mga katangian ng datos at sa uri ng problemang nais nating lutasin (halimbawa, klasipikasyon o regresyon?).\n",
    "\n",
    "Noong nakaraan, natutunan natin ang iba't ibang opsyon na mayroon ka kapag nagka-klasipika ng datos gamit ang cheat sheet ng Microsoft. Ang Machine Learning framework ng Python, Scikit-learn, ay nag-aalok ng katulad ngunit mas detalyadong cheat sheet na makakatulong pa upang mas paliitin ang pagpipilian mo ng mga estimator (isa pang termino para sa mga classifier):\n",
    "\n",
    "<p >\n",
    "   <img src=\"../../images/map.png\"\n",
    "   width=\"700\"/>\n",
    "   <figcaption></figcaption>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u1i3xRIVg7vG"
   },
   "source": [
    "> Tip: [bisitahin ang online na mapa](https://scikit-learn.org/stable/tutorial/machine_learning_map/) at mag-click sa mga landas upang mabasa ang dokumentasyon.\n",
    ">\n",
    "> Ang [Tidymodels reference site](https://www.tidymodels.org/find/parsnip/#models) ay nagbibigay din ng mahusay na dokumentasyon tungkol sa iba't ibang uri ng modelo.\n",
    "\n",
    "### **Ang plano** 🗺️\n",
    "\n",
    "Ang mapa na ito ay napaka-kapaki-pakinabang kapag malinaw na ang iyong pagkaunawa sa data, dahil maaari kang 'maglakad' sa mga landas nito patungo sa isang desisyon:\n",
    "\n",
    "-   Mayroon tayong \\>50 na sample\n",
    "\n",
    "-   Gusto nating magpredikta ng isang kategorya\n",
    "\n",
    "-   Mayroon tayong labeled na data\n",
    "\n",
    "-   Mayroon tayong mas kaunti sa 100K na sample\n",
    "\n",
    "-   ✨ Maaari tayong pumili ng Linear SVC\n",
    "\n",
    "-   Kung hindi ito gumana, dahil numeric ang ating data\n",
    "\n",
    "    -   Maaari nating subukan ang ✨ KNeighbors Classifier\n",
    "\n",
    "        -   Kung hindi ito gumana, subukan ang ✨ SVC at ✨ Ensemble Classifiers\n",
    "\n",
    "Napaka-kapaki-pakinabang ng landas na ito upang sundan. Ngayon, simulan na natin gamit ang [tidymodels](https://www.tidymodels.org/) modelling framework: isang pare-pareho at flexible na koleksyon ng mga R packages na ginawa upang hikayatin ang mahusay na estadistikal na praktis 😊.\n",
    "\n",
    "## 2. Hatiin ang data at harapin ang hindi balanseng data set.\n",
    "\n",
    "Mula sa ating mga nakaraang aralin, natutunan natin na mayroong hanay ng mga karaniwang sangkap sa iba't ibang lutuin. Gayundin, may hindi pantay na distribusyon sa bilang ng mga lutuin.\n",
    "\n",
    "Aayusin natin ito sa pamamagitan ng:\n",
    "\n",
    "-   Pag-drop ng mga pinakakaraniwang sangkap na nagdudulot ng kalituhan sa pagitan ng magkakaibang lutuin, gamit ang `dplyr::select()`.\n",
    "\n",
    "-   Paggamit ng isang `recipe` na nagpoproseso ng data upang ihanda ito para sa pagmomodelo sa pamamagitan ng pag-aaplay ng isang `over-sampling` algorithm.\n",
    "\n",
    "Tinalakay na natin ang mga ito sa nakaraang aralin kaya dapat madali na ito 🥳!\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": [
    "### Paano Harapin ang Hindi Balanseng Datos\n",
    "\n",
    "Ang hindi balanseng datos ay madalas na may negatibong epekto sa performance ng modelo. Maraming modelo ang mas mahusay kapag pantay ang bilang ng mga obserbasyon, kaya't nahihirapan ang mga ito kapag hindi balansado ang datos.\n",
    "\n",
    "May dalawang pangunahing paraan upang harapin ang hindi balanseng datos:\n",
    "\n",
    "-   magdagdag ng mga obserbasyon sa minority class: `Over-sampling` halimbawa, gamit ang SMOTE algorithm na synthetically gumagawa ng mga bagong halimbawa ng minority class gamit ang mga pinakamalapit na kapitbahay ng mga kasong ito.\n",
    "\n",
    "-   magtanggal ng mga obserbasyon mula sa majority class: `Under-sampling`\n",
    "\n",
    "Sa nakaraang aralin, ipinakita namin kung paano harapin ang hindi balanseng datos gamit ang isang `recipe`. Ang recipe ay maituturing na isang plano na naglalarawan kung anong mga hakbang ang dapat gawin sa isang datos upang maihanda ito para sa pagsusuri. Sa ating kaso, nais nating magkaroon ng pantay na distribusyon ng bilang ng ating mga lutuin para sa ating `training set`. Sige, simulan na natin.\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": [
    "Ngayon, handa na tayong mag-train ng mga modelo 👩‍💻👨‍💻!\n",
    "\n",
    "## 3. Higit pa sa multinomial regression models\n",
    "\n",
    "Sa nakaraang aralin, tinalakay natin ang multinomial regression models. Tuklasin natin ang mas flexible na mga modelo para sa classification.\n",
    "\n",
    "### Support Vector Machines\n",
    "\n",
    "Sa konteksto ng classification, ang `Support Vector Machines` ay isang machine learning technique na naglalayong makahanap ng isang *hyperplane* na \"pinakamahusay\" na naghihiwalay sa mga klase. Tingnan natin ang isang simpleng halimbawa:\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~ hindi naghihiwalay ng mga klase. H2~ naghihiwalay, ngunit may maliit na margin lamang. H3~ naghihiwalay ng mga klase gamit ang pinakamalaking margin.\n",
    "\n",
    "#### Linear Support Vector Classifier\n",
    "\n",
    "Ang Support-Vector clustering (SVC) ay bahagi ng pamilya ng Support-Vector machines na mga teknik sa ML. Sa SVC, ang hyperplane ay pinipili upang tama na maihiwalay ang `karamihan` sa mga obserbasyon sa training, ngunit `maaaring magkamali` sa ilang obserbasyon. Sa pamamagitan ng pagpayag na ang ilang puntos ay nasa maling panig, nagiging mas matatag ang SVM laban sa mga outlier kaya mas mahusay ang generalization sa bagong data. Ang parameter na nagre-regulate sa paglabag na ito ay tinatawag na `cost` na may default na halaga na 1 (tingnan ang `help(\"svm_poly\")`).\n",
    "\n",
    "Gumawa tayo ng linear SVC sa pamamagitan ng pag-set ng `degree = 1` sa isang polynomial SVM model.\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": [
    "Ngayon na naitala na natin ang mga hakbang sa preprocessing at ang detalye ng modelo sa isang *workflow*, maaari na tayong magpatuloy sa pagsasanay ng linear SVC at suriin ang mga resulta habang ginagawa ito. Para sa mga performance metrics, gumawa tayo ng isang metric set na magsusuri ng: `accuracy`, `sensitivity`, `Positive Predicted Value`, at `F Measure`.\n",
    "\n",
    "> Ang `augment()` ay magdaragdag ng column(s) para sa mga prediksyon sa ibinigay na data.\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": [
    "#### Support Vector Machine\n",
    "\n",
    "Ang support vector machine (SVM) ay isang pagpapalawig ng support vector classifier upang makapagbigay-daan sa isang hindi linyar na hangganan sa pagitan ng mga klase. Sa esensya, ginagamit ng SVM ang *kernel trick* upang palakihin ang feature space at makaangkop sa mga hindi linyar na relasyon sa pagitan ng mga klase. Isa sa mga tanyag at napaka-flexible na kernel function na ginagamit ng SVM ay ang *Radial basis function.* Tingnan natin kung paano ito magpapakita ng resulta sa ating datos.\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": [
    "Mas maganda 🤩!\n",
    "\n",
    "> ✅ Pakitingnan:\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",
    "> para sa karagdagang pagbabasa.\n",
    "\n",
    "### Mga classifier ng Nearest Neighbor\n",
    "\n",
    "Ang *K*-nearest neighbor (KNN) ay isang algorithm kung saan ang bawat obserbasyon ay hinuhulaan batay sa *pagkakapareho* nito sa ibang mga obserbasyon.\n",
    "\n",
    "Subukan nating mag-fit ng isa sa ating data.\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": [
    "Mukhang hindi masyadong mahusay ang performance ng modelong ito. Marahil ang pagbabago sa mga argumento ng modelo (tingnan ang `help(\"nearest_neighbor\")`) ay makakatulong upang mapabuti ang performance ng modelo. Siguraduhing subukan ito.\n",
    "\n",
    "> ✅ Mangyaring tingnan:\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",
    "> upang matuto nang higit pa tungkol sa mga *K*-Nearest Neighbors classifiers.\n",
    "\n",
    "### Ensemble classifiers\n",
    "\n",
    "Ang mga ensemble algorithm ay gumagana sa pamamagitan ng pagsasama-sama ng maraming base estimators upang makabuo ng isang optimal na modelo sa pamamagitan ng:\n",
    "\n",
    "`bagging`: paglalapat ng isang *averaging function* sa isang koleksyon ng mga base models\n",
    "\n",
    "`boosting`: pagbuo ng sunod-sunod na mga modelo na nagtatayo sa isa't isa upang mapabuti ang predictive performance.\n",
    "\n",
    "Simulan natin sa pamamagitan ng pagsubok sa isang Random Forest model, na bumubuo ng malaking koleksyon ng mga decision tree at pagkatapos ay nag-aaplay ng isang averaging function para makabuo ng mas mahusay na kabuuang modelo.\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": [
    "Magaling na trabaho 👏!\n",
    "\n",
    "Subukan din nating gumamit ng Boosted Tree model.\n",
    "\n",
    "Ang Boosted Tree ay isang ensemble method na lumilikha ng serye ng sunud-sunod na decision trees kung saan ang bawat puno ay nakadepende sa resulta ng mga naunang puno sa layuning unti-unting bawasan ang error. Nakatuon ito sa mga timbang ng mga maling na-classify na item at ina-adjust ang fit para sa susunod na classifier upang maitama.\n",
    "\n",
    "May iba't ibang paraan upang i-fit ang modelong ito (tingnan ang `help(\"boost_tree\")`). Sa halimbawang ito, i-fi-fit natin ang Boosted trees gamit ang `xgboost` engine.\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": [
    "> ✅ Pakitingnan:\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/> - Tinalakay ang modelong AdaBoost na isang magandang alternatibo sa xgboost.\n",
    ">\n",
    "> upang matuto pa tungkol sa Ensemble classifiers.\n",
    "\n",
    "## 4. Extra - paghahambing ng maraming modelo\n",
    "\n",
    "Nakagawa tayo ng medyo maraming modelo sa lab na ito 🙌. Maaari itong maging nakakapagod o mahirap kung kailangang gumawa ng maraming workflows mula sa iba't ibang set ng preprocessors at/o model specifications at pagkatapos ay isa-isang kalkulahin ang performance metrics.\n",
    "\n",
    "Tingnan natin kung paano natin ito masosolusyunan sa pamamagitan ng paggawa ng isang function na magfi-fit ng listahan ng workflows sa training set at pagkatapos ay magbabalik ng performance metrics base sa test set. Gagamitin natin ang `map()` at `map_dfr()` mula sa [purrr](https://purrr.tidyverse.org/) package upang mag-apply ng mga function sa bawat elemento ng listahan.\n",
    "\n",
    "> Ang mga [`map()`](https://purrr.tidyverse.org/reference/map.html) na function ay nagbibigay-daan sa iyo na palitan ang maraming for loops ng code na mas maikli at mas madaling basahin. Ang pinakamagandang lugar upang matutunan ang tungkol sa [`map()`](https://purrr.tidyverse.org/reference/map.html) na mga function ay ang [iteration chapter](http://r4ds.had.co.nz/iteration.html) sa 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/) na package ay nagbibigay-daan sa mga user na lumikha at madaling mag-fit ng maraming modelo, ngunit ito ay pangunahing idinisenyo upang gumana gamit ang mga resampling techniques tulad ng `cross-validation`, isang pamamaraan na hindi pa natin natatalakay.\n",
    "\n",
    "## **🚀Hamunin**\n",
    "\n",
    "Ang bawat isa sa mga teknik na ito ay may maraming mga parameter na maaari mong i-adjust, tulad ng `cost` sa SVMs, `neighbors` sa KNN, `mtry` (Randomly Selected Predictors) sa Random Forest.\n",
    "\n",
    "Magsaliksik tungkol sa default parameters ng bawat isa at pag-isipan kung ano ang magiging epekto ng pag-aadjust ng mga parameter na ito sa kalidad ng modelo.\n",
    "\n",
    "Upang malaman ang higit pa tungkol sa isang partikular na modelo at ang mga parameter nito, gamitin ang: `help(\"model\")` halimbawa `help(\"rand_forest\")`\n",
    "\n",
    "> Sa praktika, karaniwan nating *ina-estima* ang *pinakamainam na mga halaga* para dito sa pamamagitan ng pagte-train ng maraming modelo sa isang `simulated data set` at sinusukat kung gaano kahusay ang performance ng mga modelong ito. Ang prosesong ito ay tinatawag na **tuning**.\n",
    "\n",
    "### [**Post-lecture quiz**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/24/)\n",
    "\n",
    "### **Review at Pag-aaral sa Sarili**\n",
    "\n",
    "Maraming jargon sa mga araling ito, kaya maglaan ng oras upang balikan ang [listahang ito](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ng mga kapaki-pakinabang na termino!\n",
    "\n",
    "#### PASASALAMAT SA:\n",
    "\n",
    "[`Allison Horst`](https://twitter.com/allison_horst/) para sa paggawa ng mga kamangha-manghang ilustrasyon na ginagawang mas welcoming at engaging ang R. Hanapin ang iba pang ilustrasyon sa kanyang [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) at [Jen Looper](https://www.twitter.com/jenlooper) para sa paggawa ng orihinal na bersyong Python ng module na ito ♥️\n",
    "\n",
    "Masayang Pag-aaral,\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>Artwork ni @allison_horst</figcaption>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**Paunawa**:  \nAng dokumentong ito ay isinalin gamit ang AI translation service na [Co-op Translator](https://github.com/Azure/co-op-translator). Bagama't sinisikap naming maging tumpak, pakitandaan na ang mga awtomatikong pagsasalin ay maaaring maglaman ng mga pagkakamali o hindi pagkakatugma. Ang orihinal na dokumento sa kanyang katutubong wika ang dapat ituring na opisyal na sanggunian. Para sa mahalagang impormasyon, inirerekomenda ang propesyonal na pagsasalin ng tao. Hindi kami mananagot sa anumang hindi pagkakaunawaan o maling interpretasyon na dulot ng paggamit ng pagsasaling ito.\n"
   ]
  }
 ]
}