ML-For-Beginners/translations/bg/4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb

{
 "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-09-04T08:34:11+00:00",
   "source_file": "4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb",
   "language_code": "bg"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jsFutf_ygqSx"
   },
   "source": [
    "# Създайте модел за класификация: Вкусни азиатски и индийски ястия\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HD54bEefgtNO"
   },
   "source": [
    "## Класификатори за кухня 2\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": [
    "## **1. Карта за класификация**\n",
    "\n",
    "В нашия [предишен урок](https://github.com/microsoft/ML-For-Beginners/tree/main/4-Classification/2-Classifiers-1) се опитахме да отговорим на въпроса: как да изберем между множество модели? До голяма степен това зависи от характеристиките на данните и типа проблем, който искаме да решим (например класификация или регресия).\n",
    "\n",
    "По-рано научихме за различните опции, които имате при класифициране на данни, използвайки помощния лист на Microsoft. Машинно обучителната рамка на Python, 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",
    "## 2. Разделяне на данните и справяне с небалансиран набор от данни.\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",
    "-   добавяне на наблюдения към малцинствения клас: `Over-sampling`, например чрез използване на алгоритъма SMOTE, който синтетично генерира нови примери за малцинствения клас, използвайки най-близките съседи на тези случаи.\n",
    "\n",
    "-   премахване на наблюдения от мнозинствения клас: `Under-sampling`\n",
    "\n",
    "В предишния ни урок демонстрирахме как да се справим с небалансирани набори от данни, използвайки `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",
    "## 3. Отвъд моделите за мултиномиална регресия\n",
    "\n",
    "В предишния урок разгледахме модели за мултиномиална регресия. Нека изследваме някои по-гъвкави модели за класификация.\n",
    "\n",
    "### Поддържащи векторни машини (Support Vector Machines)\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) е част от семейството на машинно обучение с опорни вектори. При SVC хиперплоскостта се избира така, че да разделя `повечето` от тренировъчните наблюдения правилно, но `може да класифицира погрешно` някои наблюдения. Като се позволи на някои точки да бъдат от грешната страна, SVM става по-устойчив към аномалии и следователно по-добре обобщава нови данни. Параметърът, който регулира това нарушение, се нарича `cost` и има стойност по подразбиране 1 (вижте `help(\"svm_poly\")`).\n",
    "\n",
    "Нека създадем линеен SVC, като зададем `degree = 1` в полиномиален SVM модел.\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*, можем да продължим с обучението на линейния 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, е *функцията с радиална база*. Нека видим как ще се представи върху нашите данни.\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*-най-близки съседи.\n",
    "\n",
    "### Ансамблови класификатори\n",
    "\n",
    "Ансамбловите алгоритми работят, като комбинират множество базови оценители, за да създадат оптимален модел, като използват:\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",
    "Нека също така да експериментираме с модел на Усилено Дърво.\n",
    "\n",
    "Усиленото Дърво определя ансамблов метод, който създава серия от последователни дървета за вземане на решения, като всяко дърво зависи от резултатите на предишните дървета в опит да намали грешката постепенно. То се фокусира върху теглата на неправилно класифицираните елементи и коригира модела за следващия класификатор, за да поправи грешките.\n",
    "\n",
    "Има различни начини за настройка на този модел (вижте `help(\"boost_tree\")`). В този пример ще настроим Усилени дървета чрез енджина `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",
    "> за да научите повече за ансамбловите класификатори.\n",
    "\n",
    "## 4. Допълнително - сравнение на множество модели\n",
    "\n",
    "В тази лаборатория сме създали доста модели 🙌. Може да стане досадно или обременително да създаваме множество работни потоци от различни набори от предварителни обработки и/или спецификации на модели и след това да изчисляваме метриките за производителност една по една.\n",
    "\n",
    "Нека видим дали можем да решим този проблем, като създадем функция, която прилага списък от работни потоци върху обучаващия набор и след това връща метриките за производителност, базирани на тестовия набор. Ще използваме `map()` и `map_dfr()` от пакета [purrr](https://purrr.tidyverse.org/), за да приложим функции към всеки елемент от списъка.\n",
    "\n",
    "> [`map()`](https://purrr.tidyverse.org/reference/map.html) функциите ви позволяват да замените много цикли for с код, който е по-кратък и по-лесен за четене. Най-доброто място за учене за [`map()`](https://purrr.tidyverse.org/reference/map.html) функциите е [главата за итерации](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/) позволява на потребителите да създават и лесно да прилагат голям брой модели, но е основно предназначен за работа с техники за повторно извадково тестване като `кръстосана проверка`, подход, който все още не сме разгледали.\n",
    "\n",
    "## **🚀Предизвикателство**\n",
    "\n",
    "Всяка от тези техники има голям брой параметри, които можете да настройвате, например `cost` в SVMs, `neighbors` в KNN, `mtry` (Случайно избрани предиктори) в Random Forest.\n",
    "\n",
    "Проучете стандартните параметри на всяка от тях и помислете какво би означавало настройването на тези параметри за качеството на модела.\n",
    "\n",
    "За да научите повече за конкретен модел и неговите параметри, използвайте: `help(\"model\")`, например `help(\"rand_forest\")`.\n",
    "\n",
    "> На практика обикновено *оценяваме* *най-добрите стойности* за тези параметри, като обучаваме много модели върху `симулиран набор от данни` и измерваме колко добре се представят всички тези модели. Този процес се нарича **настройване**.\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 по-приветлив и ангажиращ. Намерете повече илюстрации в нейния [галерия](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), Златен студентски посланик на Microsoft Learn.\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"
   ]
  }
 ]
}