msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2d9b2ea197'
${ noResults }
ML-For-Beginners/translations/ml/4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb

655 lines
43 KiB
Raw Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{
"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-12-19T17:12:00+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb",
"language_code": "ml"
}
},
"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": [
"ഇപ്പോൾ, നമുക്ക് പ്രവർത്തനം ആരംഭിക്കാം!\n",
"\n",
"## **1. ഒരു വർഗ്ഗീകരണ മാപ്പ്**\n",
"\n",
"നമ്മുടെ [മുൻപത്തെ പാഠത്തിൽ](https://github.com/microsoft/ML-For-Beginners/tree/main/4-Classification/2-Classifiers-1), നാം ചോദ്യം പരിഹരിക്കാൻ ശ്രമിച്ചു: പല മോഡലുകൾക്കിടയിൽ എങ്ങനെ തിരഞ്ഞെടുക്കാം? വലിയ തോതിൽ, ഇത് ഡാറ്റയുടെ സവിശേഷതകളിലും നാം പരിഹരിക്കാൻ ആഗ്രഹിക്കുന്ന പ്രശ്നത്തിന്റെ തരം (ഉദാഹരണത്തിന്, വർഗ്ഗീകരണമോ റിഗ്രഷനോ?) ആശ്രയിച്ചിരിക്കുന്നു.\n",
"\n",
"മുൻപ്, മൈക്രോസോഫ്റ്റിന്റെ ചീറ്റ് ഷീറ്റ് ഉപയോഗിച്ച് ഡാറ്റ വർഗ്ഗീകരിക്കുമ്പോൾ നിങ്ങൾക്കുള്ള വിവിധ ഓപ്ഷനുകൾക്കുറിച്ച് നാം പഠിച്ചു. പൈത്തൺ മെഷീൻ ലേണിംഗ് ഫ്രെയിംവർക്ക്, സ്കൈകിറ്റ്-ലേൺ, സമാനമായെങ്കിലും കൂടുതൽ സൂക്ഷ്മമായ ഒരു ചീറ്റ് ഷീറ്റ് നൽകുന്നു, ഇത് നിങ്ങളുടെ എസ്റ്റിമേറ്ററുകൾ (വർഗ്ഗീകരണങ്ങളുടെ മറ്റൊരു പദം) കൂടുതൽ നിശ്ചയിക്കാൻ സഹായിക്കും:\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/ml/map.e963a6a51349425a.webp\"\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",
"- ✨ ഞങ്ങൾ ഒരു ലീനിയർ SVC തിരഞ്ഞെടുക്കാം\n",
"\n",
"- അത് പ്രവർത്തിക്കാത്ത പക്ഷം, ഞങ്ങൾക്ക് സംഖ്യാത്മക ഡാറ്റ ഉണ്ടാകുന്നതിനാൽ\n",
"\n",
" - ✨ KNeighbors ക്ലാസിഫയർ പരീക്ഷിക്കാം\n",
"\n",
" - അത് പ്രവർത്തിക്കാത്ത പക്ഷം, ✨ SVCയും ✨ എൻസംബിൾ ക്ലാസിഫയറുകളും പരീക്ഷിക്കുക\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",
"- ന്യൂനപക്ഷ ക്ലാസിലേക്ക് നിരീക്ഷണങ്ങൾ ചേർക്കൽ: `ഓവർ-സാമ്പ്ലിംഗ്` ഉദാഹരണത്തിന് 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",
"## 3. മൾട്ടിനോമിയൽ റെഗ്രഷൻ മോഡലുകൾക്കപ്പുറം\n",
"\n",
"മുൻപത്തെ പാഠത്തിൽ, നാം മൾട്ടിനോമിയൽ റെഗ്രഷൻ മോഡലുകൾ പരിശോധിച്ചു. ക്ലാസിഫിക്കേഷനിനായി കൂടുതൽ ലവചികമായ ചില മോഡലുകൾ പരിശോധിക്കാം.\n",
"\n",
"### സപ്പോർട്ട് വെക്ടർ മെഷീനുകൾ.\n",
"\n",
"ക്ലാസിഫിക്കേഷൻ സന്ധർഭത്തിൽ, `സപ്പോർട്ട് വെക്ടർ മെഷീനുകൾ` എന്നത് ഒരു മെഷീൻ ലേണിംഗ് സാങ്കേതിക വിദ്യയാണ്, ഇത് ക്ലാസുകൾ \"മികച്ച\" വിധത്തിൽ വേർതിരിക്കുന്ന ഒരു *ഹൈപ്പർപ്ലെയിൻ* കണ്ടെത്താൻ ശ്രമിക്കുന്നു. ഒരു ലളിതമായ ഉദാഹരണം നോക്കാം:\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/ml/svm.621ae7b516d678e0.webp\"\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",
"പോളിനോമിയൽ SVM മോഡലിൽ `degree = 1` സജ്ജമാക്കി ഒരു ലീനിയർ 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": [
"#### Support Vector Machine\n",
"\n",
"സപ്പോർട്ട് വെക്ടർ മെഷീൻ (SVM) ക്ലാസുകൾക്കിടയിലെ നോൺ-ലീനിയർ ബൗണ്ടറി സ്വീകരിക്കാൻ സപ്പോർട്ട് വെക്ടർ ക്ലാസിഫയറിന്റെ വിപുലീകരണമാണ്. സാരാംശത്തിൽ, SVMകൾ ക്ലാസുകൾക്കിടയിലെ നോൺലീനിയർ ബന്ധങ്ങൾക്കായി ഫീച്ചർ സ്പേസ് വലുതാക്കാൻ *kernel trick* ഉപയോഗിക്കുന്നു. SVMകൾ ഉപയോഗിക്കുന്ന ഒരു പ്രശസ്തവും അത്യന്തം ലവചികവുമായ kernel ഫംഗ്ഷൻ ആണ് *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), R ഉപയോഗിച്ച് ഹാൻഡ്‌സ്-ഓൺ മെഷീൻ ലേണിംഗ്\n",
">\n",
"> - [*Support Vector Machines*](https://www.statlearning.com/), 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": [
"ഈ മോഡൽ അത്ര നല്ല പ്രകടനം കാഴ്ചവയ്ക്കുന്നില്ലെന്ന് തോന്നുന്നു. മോഡലിന്റെ arguments മാറ്റുന്നത് (കാണുക `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 ക്ലാസിഫയർസിനെക്കുറിച്ച് കൂടുതൽ അറിയാൻ.\n",
"\n",
"### എൻസംബിൾ ക്ലാസിഫയർസ്\n",
"\n",
"എൻസംബിൾ ആൽഗോരിതങ്ങൾ പല ബേസ് എസ്റ്റിമേറ്ററുകളെ സംയോജിപ്പിച്ച് ഒരു മികച്ച മോഡൽ സൃഷ്ടിക്കുന്നതിലൂടെ പ്രവർത്തിക്കുന്നു, അതായത്:\n",
"\n",
"`bagging`: ബേസ് മോഡലുകളുടെ ഒരു ശേഖരത്തിൽ *ഔസത ഫംഗ്ഷൻ* പ്രയോഗിക്കുന്നത്\n",
"\n",
"`boosting`: പരസ്പരം ആശ്രയിച്ച് പ്രവർത്തിക്കുന്ന മോഡലുകളുടെ ഒരു ശ്രേണി നിർമ്മിച്ച് പ്രവചന പ്രകടനം മെച്ചപ്പെടുത്തുന്നത്.\n",
"\n",
"നമുക്ക് ആദ്യം ഒരു റാൻഡം ഫോറസ്റ്റ് മോഡൽ പരീക്ഷിക്കാം, ഇത് വലിയൊരു ഡിസിഷൻ ട്രീകളുടെ ശേഖരം നിർമ്മിച്ച് അവയ്ക്ക് ഒരു ഔസത ഫംഗ്ഷൻ പ്രയോഗിച്ച് മികച്ച മൊത്തം മോഡൽ സൃഷ്ടിക്കുന്നു.\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 ഒരു എൻസംബിൾ രീതിയാണ്, ഇത് പരമ്പരാഗതമായ തീരുമാനമരങ്ങൾ സൃഷ്ടിക്കുന്നു, ഓരോ മരവും മുമ്പത്തെ മരങ്ങളുടെ ഫലങ്ങളിൽ ആശ്രയിച്ചിരിക്കുന്നു, പിഴവ് ക്രമാതീതമായി കുറയ്ക്കാൻ ശ്രമിക്കുന്നു. തെറ്റായി വർഗ്ഗീകരിച്ച വസ്തുക്കളുടെ ഭാരം ശ്രദ്ധിച്ച് അടുത്ത ക്ലാസിഫയറിന്റെ ഫിറ്റ് ശരിയാക്കുന്നു.\n",
"\n",
"ഈ മോഡൽ ഫിറ്റ് ചെയ്യാനുള്ള വിവിധ മാർഗ്ഗങ്ങൾ ഉണ്ട് (`help(\"boost_tree\")` കാണുക). ഈ ഉദാഹരണത്തിൽ, നാം `xgboost` എഞ്ചിൻ വഴി Boosted trees ഫിറ്റ് ചെയ്യും.\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",
"> - [സാമൂഹ്യ ശാസ്ത്രജ്ഞർക്കുള്ള മെഷീൻ ലേണിംഗ്](https://cimentadaj.github.io/ml_socsci/tree-based-methods.html#random-forests)\n",
">\n",
"> - [R ഉപയോഗിച്ച് ഹാൻഡ്‌സ്-ഓൺ മെഷീൻ ലേണിംഗ്](https://bradleyboehmke.github.io/HOML/)\n",
">\n",
"> - [R-ൽ അപ്ലിക്കേഷനുകളോടുകൂടിയ സ്റ്റാറ്റിസ്റ്റിക്കൽ ലേണിംഗിലേക്ക് ഒരു പരിചയം](https://www.statlearning.com/)\n",
">\n",
"> - <https://algotech.netlify.app/blog/xgboost/> - xgboost-ന് നല്ല ഒരു പകരം ആയ AdaBoost മോഡൽ പരിശോധിക്കുന്നു.\n",
">\n",
"> എൺസംബിൾ ക്ലാസിഫയർസിനെക്കുറിച്ച് കൂടുതൽ അറിയാൻ.\n",
"\n",
"## 4. അധികം - പല മോഡലുകളും താരതമ്യം ചെയ്യൽ\n",
"\n",
"ഈ ലാബിൽ നാം വളരെ മോഡലുകൾ ഫിറ്റ് ചെയ്തിട്ടുണ്ട് 🙌. വ്യത്യസ്ത സെറ്റുകളുടെ പ്രീപ്രോസസറുകളും/അഥവാ മോഡൽ സ്പെസിഫിക്കേഷനുകളും ഉപയോഗിച്ച് നിരവധി വർക്ക്‌ഫ്ലോകൾ സൃഷ്ടിച്ച് ഓരോന്നിന്റെയും പ്രകടന മെട്രിക്കുകൾ ഒറ്റത്തവണ കണക്കാക്കുന്നത് ക്ഷീണകരമോ ബുദ്ധിമുട്ടുള്ളതോ ആകാം.\n",
"\n",
"ട്രെയിനിംഗ് സെറ്റിൽ വർക്ക്‌ഫ്ലോകളുടെ ഒരു ലിസ്റ്റ് ഫിറ്റ് ചെയ്ത് ടെസ്റ്റ് സെറ്റിന്റെ അടിസ്ഥാനത്തിൽ പ്രകടന മെട്രിക്കുകൾ തിരികെ നൽകുന്ന ഒരു ഫംഗ്ഷൻ സൃഷ്ടിച്ച് ഇത് പരിഹരിക്കാമോ എന്ന് നോക്കാം. ലിസ്റ്റിലെ ഓരോ ഘടകത്തിലും ഫംഗ്ഷനുകൾ പ്രയോഗിക്കാൻ [purrr](https://purrr.tidyverse.org/) പാക്കേജിൽ നിന്നുള്ള `map()` ഉം `map_dfr()` ഉം ഉപയോഗിക്കാം.\n",
"\n",
"> [`map()`](https://purrr.tidyverse.org/reference/map.html) ഫംഗ്ഷനുകൾ കോഡ് കൂടുതൽ സംക്ഷിപ്തവും വായിക്കാൻ എളുപ്പവുമാക്കുന്ന നിരവധി for ലൂപ്പുകൾ മാറ്റാൻ അനുവദിക്കുന്നു. [`map()`](https://purrr.tidyverse.org/reference/map.html) ഫംഗ്ഷനുകൾക്കുറിച്ച് പഠിക്കാൻ ഏറ്റവും നല്ല സ്ഥലം R for data science-ലെ [iteration chapter](http://r4ds.had.co.nz/iteration.html) ആണ്.\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": [
"നമുക്ക് നമ്മുടെ ഫംഗ്ഷൻ വിളിച്ച് മോഡലുകൾക്കിടയിലെ കൃത്യത താരതമ്യം ചെയ്യാം.\n"
]
},
{
"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": [
"\n",
"[**workflowset**](https://workflowsets.tidymodels.org/) പാക്കേജ് ഉപയോക്താക്കൾക്ക് വലിയ തോതിൽ മോഡലുകൾ സൃഷ്ടിക്കുകയും എളുപ്പത്തിൽ ഫിറ്റ് ചെയ്യുകയും ചെയ്യാൻ അനുവദിക്കുന്നു, പക്ഷേ ഇത് പ്രധാനമായും `cross-validation` പോലുള്ള റിസാമ്പ്ലിംഗ് സാങ്കേതികവിദ്യകളുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തതാണ്, ഇത് നാം ഇതുവരെ പഠിച്ചിട്ടില്ല.\n",
"\n",
"## **🚀ചലഞ്ച്**\n",
"\n",
"ഈ സാങ്കേതികവിദ്യകളിൽ ഓരോതിലും നിങ്ങൾ ക്രമീകരിക്കാവുന്ന നിരവധി പാരാമീറ്ററുകൾ ഉണ്ട്, ഉദാഹരണത്തിന് SVM-കളിലെ `cost`, KNN-യിലെ `neighbors`, Random Forest-യിലെ `mtry` (Randomly Selected Predictors).\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)യും ഈ മോഡ്യൂളിന്റെ ഒറിജിനൽ പൈതൺ പതിപ്പ് സൃഷ്ടിച്ചതിന് ♥️\n",
"\n",
"സന്തോഷകരമായ പഠനം,\n",
"\n",
"[Eric](https://twitter.com/ericntay), ഗോൾഡ് മൈക്രോസോഫ്റ്റ് ലേൺ സ്റ്റുഡന്റ് അംബാസഡർ.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/ml/r_learners_sm.f9199f76f1e2e493.webp\"\n",
" width=\"569\"/>\n",
" <figcaption>@allison_horst എന്നവരുടെ കലാസൃഷ്ടി</figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**അസൂയാപത്രം**: \nഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ പ്രാമാണികമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
]
}
]
}
Reference in new issue View Git Blame Copy Permalink