ML-For-Beginners/translations/kn/2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ - ಪಾಠ 4\n",
    "\n",
    "![ಲಾಜಿಸ್ಟಿಕ್ ವಿರುದ್ಧ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ ಇನ್ಫೋಗ್ರಾಫಿಕ್](../../../../../../translated_images/kn/linear-vs-logistic.ba180bf95e7ee667.webp)\n",
    "\n",
    "#### **[ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)**\n",
    "\n",
    "#### ಪರಿಚಯ\n",
    "\n",
    "ರಿಗ್ರೆಶನ್ ಕುರಿತು ಈ ಅಂತಿಮ ಪಾಠದಲ್ಲಿ, ಮೂಲ *ಕ್ಲಾಸಿಕ್* ಎಂಎಲ್ ತಂತ್ರಜ್ಞಾನಗಳಲ್ಲಿ ಒಂದಾದ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಅನ್ನು ನೋಡೋಣ. ನೀವು ಈ ತಂತ್ರಜ್ಞಾನವನ್ನು ದ್ವಿಪದ ವರ್ಗಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಮಾದರಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಬಳಸುತ್ತೀರಿ. ಈ ಕ್ಯಾಂಡಿ ಚಾಕೊಲೇಟ್ ಆಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ? ಈ ರೋಗ ಸಂಕ್ರಾಮಕವೇ ಅಥವಾ ಇಲ್ಲವೇ? ಈ ಗ್ರಾಹಕ ಈ ಉತ್ಪನ್ನವನ್ನು ಆರಿಸುವನೋ ಅಥವಾ ಇಲ್ಲವೇ?\n",
    "\n",
    "ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಕಲಿಯುವಿರಿ:\n",
    "\n",
    "- ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ತಂತ್ರಗಳು\n",
    "\n",
    "✅ ಈ ರೀತಿಯ ರಿಗ್ರೆಶನ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರ ಬಗ್ಗೆ ನಿಮ್ಮ ಅರ್ಥವನ್ನು ಗಾಢಗೊಳಿಸಿ ಈ [ಕಲಿಕೆ ಘಟಕದಲ್ಲಿ](https://learn.microsoft.com/training/modules/introduction-classification-models/?WT.mc_id=academic-77952-leestott)\n",
    "\n",
    "## ಪೂರ್ವಾಪೇಕ್ಷಿತ\n",
    "\n",
    "ಪಂಪ್ಕಿನ್ ಡೇಟಾ ಜೊತೆ ಕೆಲಸ ಮಾಡಿದ ನಂತರ, ನಾವು ಈಗ ಅದರಲ್ಲಿ ಒಂದು ದ್ವಿಪದ ವರ್ಗವಿದೆ ಎಂದು ತಿಳಿದುಕೊಂಡಿದ್ದೇವೆ: `ಬಣ್ಣ`.\n",
    "\n",
    "ನಾವು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸೋಣ, ಕೆಲವು ಚರಗಳನ್ನು ನೀಡಿದಾಗ, *ಒಂದು ಪಂಪ್ಕಿನ್ ಯಾವ ಬಣ್ಣದಾಗಿರಬಹುದು* ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು (ಕಿತ್ತಳೆ 🎃 ಅಥವಾ ಬಿಳಿ 👻).\n",
    "\n",
    "> ರಿಗ್ರೆಶನ್ ಕುರಿತು ಪಾಠ ಗುಂಪಿನಲ್ಲಿ ದ್ವಿಪದ ವರ್ಗೀಕರಣದ ಬಗ್ಗೆ ನಾವು ಏಕೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ? ಭಾಷಾಶೈಲಿಯ ಅನುಕೂಲಕ್ಕಾಗಿ ಮಾತ್ರ, ಏಕೆಂದರೆ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ [ನಿಜವಾಗಿಯೂ ವರ್ಗೀಕರಣ ವಿಧಾನವಾಗಿದೆ](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), ಆದರೂ ಲೀನಿಯರ್ ಆಧಾರಿತದಾಗಿದೆ. ಮುಂದಿನ ಪಾಠ ಗುಂಪಿನಲ್ಲಿ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವ ಇತರ ವಿಧಾನಗಳನ್ನು ತಿಳಿಯಿರಿ.\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",
    "- `janitor`: [janitor ಪ್ಯಾಕೇಜ್](https://github.com/sfirke/janitor) ಕಳಪೆ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಸರಳ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.\n",
    "\n",
    "- `ggbeeswarm`: [ggbeeswarm ಪ್ಯಾಕೇಜ್](https://github.com/eclarke/ggbeeswarm) ggplot2 ಬಳಸಿ ಬೀಸ್ವಾರ್ಮ್ ಶೈಲಿಯ ಪ್ಲಾಟ್‌ಗಳನ್ನು ರಚಿಸುವ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.\n",
    "\n",
    "ನೀವು ಅವುಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬಹುದು:\n",
    "\n",
    "`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"ggbeeswarm\"))`\n",
    "\n",
    "ಬದಲಿ, ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಘಟಕವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಬೇಕಾದ ಪ್ಯಾಕೇಜುಗಳಿದ್ದಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ಅವು ಇಲ್ಲದಿದ್ದರೆ ನಿಮ್ಮಿಗಾಗಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುತ್ತದೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
    "\n",
    "pacman::p_load(tidyverse, tidymodels, janitor, ggbeeswarm)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **ಪ್ರಶ್ನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ**\n",
    "\n",
    "ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗೆ, ನಾವು ಇದನ್ನು ದ್ವಿಮೂಲ್ಯವಾಗಿ ವ್ಯಕ್ತಪಡಿಸುವೆವು: 'ಬಿಳಿ' ಅಥವಾ 'ಬಿಳಿಯಲ್ಲದ'. ನಮ್ಮ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ 'ಪಟ್ಟೆ' ಎಂಬ ವರ್ಗವೂ ಇದೆ ಆದರೆ ಅದರ ಕೆಲವು ಉದಾಹರಣೆಗಳಿವೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಡೇಟಾಸೆಟ್‌ನಿಂದ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದ ನಂತರ ಅದು ಅಳಿದುಹೋಗುತ್ತದೆ.\n",
    "\n",
    "> 🎃 ಮನರಂಜನೆಯ ಸಂಗತಿ, ನಾವು ಕೆಲವೊಮ್ಮೆ ಬಿಳಿ ಕಂಬಳಿಗಳನ್ನು 'ಭೂತ' ಕಂಬಳಿಗಳು ಎಂದು ಕರೆಯುತ್ತೇವೆ. ಅವುಗಳನ್ನು ಕತ್ತರಿಸುವುದು ಸುಲಭವಲ್ಲ, ಆದ್ದರಿಂದ ಅವು ಕಿತ್ತಳೆ ಬಣ್ಣದ ಕಂಬಳಿಗಳಂತೆ ಜನಪ್ರಿಯವಾಗಿಲ್ಲ ಆದರೆ ಅವು ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತವೆ! ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಪ್ರಶ್ನೆಯನ್ನು 'ಭೂತ' ಅಥವಾ 'ಭೂತವಲ್ಲ' ಎಂದು ಮರುರೂಪಿಸಬಹುದು. 👻\n",
    "\n",
    "## **ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಬಗ್ಗೆ**\n",
    "\n",
    "ನೀವು ಹಿಂದಿನ ಅಧ್ಯಯನದಲ್ಲಿ ಕಲಿತ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್‌ನಿಂದ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಕೆಲವು ಪ್ರಮುಖ ರೀತಿಗಳಲ್ಲಿ ಭಿನ್ನವಾಗಿದೆ.\n",
    "\n",
    "#### **ದ್ವಿಮೂಲ್ಯ ವರ್ಗೀಕರಣ**\n",
    "\n",
    "ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್‌ನಂತೆ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ. ಮೊದಲದು `ದ್ವಿಮೂಲ್ಯ ವರ್ಗ` (\"ಕಿತ್ತಳೆ ಅಥವಾ ಕಿತ್ತಳೆಯಲ್ಲ\") ಬಗ್ಗೆ ಭವಿಷ್ಯವಾಣಿ ನೀಡುತ್ತದೆ, ಆದರೆ ನಂತರದದು `ನಿರಂತರ ಮೌಲ್ಯಗಳನ್ನು` ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಸಾಧ್ಯ, ಉದಾಹರಣೆಗೆ ಕಂಬಳಿಯ ಮೂಲ ಮತ್ತು ಹಾರ್ವೆಸ್ಟ್ ಸಮಯವನ್ನು ನೀಡಿದಾಗ, *ಅದರ ಬೆಲೆ ಎಷ್ಟು ಏರಲಿದೆ* ಎಂದು.\n",
    "\n",
    "![Infographic by Dasani Madipalli](../../../../../../translated_images/kn/pumpkin-classifier.562771f104ad5436.webp)\n",
    "\n",
    "### ಇತರೆ ವರ್ಗೀಕರಣಗಳು\n",
    "\n",
    "ಮಲ್ಟಿನೋಮಿಯಲ್ ಮತ್ತು ಆರ್ಡಿನಲ್ ಸೇರಿದಂತೆ ಇತರೆ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಪ್ರಕಾರಗಳಿವೆ:\n",
    "\n",
    "- **ಮಲ್ಟಿನೋಮಿಯಲ್**, ಇದು ಒಂದುಕ್ಕಿಂತ ಹೆಚ್ಚು ವರ್ಗಗಳನ್ನು ಹೊಂದಿರುವುದು - \"ಕಿತ್ತಳೆ, ಬಿಳಿ ಮತ್ತು ಪಟ್ಟೆ\".\n",
    "\n",
    "- **ಆರ್ಡಿನಲ್**, ಇದು ಕ್ರಮಬದ್ಧ ವರ್ಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ನಮ್ಮ ಫಲಿತಾಂಶಗಳನ್ನು ತಾರ್ಕಿಕವಾಗಿ ಕ್ರಮಬದ್ಧಗೊಳಿಸಲು ಉಪಯುಕ್ತ, ಉದಾಹರಣೆಗೆ ನಮ್ಮ ಕಂಬಳಿಗಳು ಸಣ್ಣ, ಸ್ಮಾಲ್, ಮಧ್ಯಮ, ದೊಡ್ಡ, ಎಕ್ಸ್ಎಲ್, ಎಕ್ಸ್ಎಕ್ಸ್ಎಲ್ ಎಂಬ ನಿರ್ದಿಷ್ಟ ಗಾತ್ರಗಳ ಮೂಲಕ ಕ್ರಮಬದ್ಧವಾಗಿವೆ.\n",
    "\n",
    "![Multinomial vs ordinal regression](../../../../../../translated_images/kn/multinomial-vs-ordinal.36701b4850e37d86.webp)\n",
    "\n",
    "#### **ಚರಗಳು ಹೊಂದಾಣಿಕೆ ಹೊಂದಿರಬೇಕಾಗಿಲ್ಲ**\n",
    "\n",
    "ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ ಹೆಚ್ಚು ಹೊಂದಾಣಿಕೆಯ ಚರಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ನೆನಪಿಡಿ? ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಅದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿದೆ - ಚರಗಳು ಹೊಂದಾಣಿಕೆ ಹೊಂದಿರಬೇಕಾಗಿಲ್ಲ. ಇದು ಸ್ವಲ್ಪ ದುರ್ಬಲ ಹೊಂದಾಣಿಕೆಗಳಿರುವ ಈ ಡೇಟಾಗೆ ಸೂಕ್ತವಾಗಿದೆ.\n",
    "\n",
    "#### **ನೀವು ಹೆಚ್ಚಿನ ಸ್ವಚ್ಛ ಡೇಟಾವನ್ನು ಬೇಕಾಗುತ್ತದೆ**\n",
    "\n",
    "ನೀವು ಹೆಚ್ಚು ಡೇಟಾವನ್ನು ಬಳಸಿದರೆ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಹೆಚ್ಚು ನಿಖರ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತದೆ; ನಮ್ಮ ಸಣ್ಣ ಡೇಟಾಸೆಟ್ ಈ ಕಾರ್ಯಕ್ಕೆ ಸೂಕ್ತವಲ್ಲ, ಆದ್ದರಿಂದ ಅದನ್ನು ಗಮನದಲ್ಲಿಡಿ.\n",
    "\n",
    "✅ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್‌ಗೆ ಸೂಕ್ತವಾಗುವ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಬಗ್ಗೆ ಯೋಚಿಸಿ\n",
    "\n",
    "## ಅಭ್ಯಾಸ - ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ\n",
    "\n",
    "ಮೊದಲು, ಡೇಟಾವನ್ನು ಸ್ವಲ್ಪ ಸ್ವಚ್ಛಗೊಳಿಸಿ, ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ಕೆಲವು ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ಆಯ್ಕೆಮಾಡಿ:\n",
    "\n",
    "1. ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಿ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Load the core tidyverse packages\n",
    "library(tidyverse)\n",
    "\n",
    "# Import the data and clean column names\n",
    "pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\") %>% \n",
    "  clean_names()\n",
    "\n",
    "# Select desired columns\n",
    "pumpkins_select <- pumpkins %>% \n",
    "  select(c(city_name, package, variety, origin, item_size, color)) \n",
    "\n",
    "# Drop rows containing missing values and encode color as factor (category)\n",
    "pumpkins_select <- pumpkins_select %>% \n",
    "  drop_na() %>% \n",
    "  mutate(color = factor(color))\n",
    "\n",
    "# View the first few rows\n",
    "pumpkins_select %>% \n",
    "  slice_head(n = 5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ನೀವು ಯಾವಾಗಲೂ ನಿಮ್ಮ ಹೊಸ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಕೆಳಗಿನಂತೆ [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) ಫಂಕ್ಷನ್ ಬಳಸಿ ಒಂದು ನೋಟವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "pumpkins_select %>% \n",
    "  glimpse()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ನಾವು ನಿಜವಾಗಿಯೂ ಬೈನರಿ ವರ್ಗೀಕರಣ ಸಮಸ್ಯೆಯನ್ನು ಮಾಡುತ್ತಿರುವುದನ್ನು ದೃಢೀಕರಿಸೋಣ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Subset distinct observations in outcome column\n",
    "pumpkins_select %>% \n",
    "  distinct(color)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ದೃಶ್ಯೀಕರಣ - ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್\n",
    "ಈಗಾಗಲೇ ನೀವು ಪುನಃ ಪಂಪ್ಕಿನ್ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಿ ಸ್ವಚ್ಛಗೊಳಿಸಿದ್ದೀರಿ, ಇದರಿಂದ ಕೆಲವು ಚರಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಡೇಟಾಸೆಟ್ ಉಳಿಯುತ್ತದೆ, ಅದರಲ್ಲಿ ಬಣ್ಣವೂ ಸೇರಿದೆ. ggplot ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸೋಣ.\n",
    "\n",
    "ggplot ಲೈಬ್ರರಿ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಕೆಲವು ಚೆನ್ನಾದ ವಿಧಾನಗಳನ್ನು ನೀಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್‌ನಲ್ಲಿ ಪ್ರತಿ Variety ಮತ್ತು ಬಣ್ಣದ ಡೇಟಾ ವಿತರಣೆಗಳನ್ನು ಹೋಲಿಸಬಹುದು.\n",
    "\n",
    "1. geombar ಫಂಕ್ಷನ್ ಬಳಸಿ, ನಮ್ಮ ಪಂಪ್ಕಿನ್ ಡೇಟಾವನ್ನು ಉಪಯೋಗಿಸಿ, ಮತ್ತು ಪ್ರತಿ ಪಂಪ್ಕಿನ್ ವರ್ಗಕ್ಕೆ (ಕಿತ್ತಳೆ ಅಥವಾ ಬಿಳಿ) ಬಣ್ಣ ನಕ್ಷೆಗಳನ್ನು ಸೂಚಿಸಿ, ಇಂತಹ ಪ್ಲಾಟ್ ಅನ್ನು ರಚಿಸಿ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "python"
    }
   },
   "outputs": [],
   "source": [
    "# Specify colors for each value of the hue variable\n",
    "palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
    "\n",
    "# Create the bar plot\n",
    "ggplot(pumpkins_select, aes(y = variety, fill = color)) +\n",
    "  geom_bar(position = \"dodge\") +\n",
    "  scale_fill_manual(values = palette) +\n",
    "  labs(y = \"Variety\", fill = \"Color\") +\n",
    "  theme_minimal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಡೇಟಾವನ್ನು ಗಮನಿಸುವ ಮೂಲಕ, ನೀವು ಬಣ್ಣದ ಡೇಟಾ ವೈವಿಧ್ಯಕ್ಕೆ ಹೇಗೆ ಸಂಬಂಧಿಸಿದೆ ಎಂದು ನೋಡಬಹುದು.\n",
    "\n",
    "✅ ಈ ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್ ನೀಡಿರುವಾಗ, ನೀವು ಯಾವಂತಹ ಆಸಕ್ತಿದಾಯಕ ಅನ್ವೇಷಣೆಗಳನ್ನು ಕಲ್ಪಿಸಬಹುದು?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ಡೇಟಾ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆ: ವೈಶಿಷ್ಟ್ಯ ಎನ್‌ಕೋಡಿಂಗ್\n",
    "\n",
    "ನಮ್ಮ ಕಂಬಳಿಯ ಡೇಟಾಸೆಟ್‌ನ ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳಿವೆ. ವರ್ಗೀಕೃತ ಡೇಟಾ ಮಾನವರಿಗೆ ಸುಲಭವಾಗಿದ್ದರೂ ಯಂತ್ರಗಳಿಗೆ ಅಲ್ಲ. ಯಂತ್ರ ಕಲಿಕೆ ಆಲ್ಗಾರಿದಮ್‌ಗಳು ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ. ಅದಕ್ಕಾಗಿ ಎನ್‌ಕೋಡಿಂಗ್ ಡೇಟಾ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆ ಹಂತದಲ್ಲಿ ಅತ್ಯಂತ ಪ್ರಮುಖ ಹಂತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ವರ್ಗೀಕೃತ ಡೇಟಾವನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾಗಾಗಿ ಪರಿವರ್ತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಯಾವುದೇ ಮಾಹಿತಿಯನ್ನು ಕಳೆದುಕೊಳ್ಳದೆ. ಉತ್ತಮ ಎನ್‌ಕೋಡಿಂಗ್ ಉತ್ತಮ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.\n",
    "\n",
    "ವೈಶಿಷ್ಟ್ಯ ಎನ್‌ಕೋಡಿಂಗ್‌ಗೆ ಎರಡು ಪ್ರಮುಖ ಎನ್‌ಕೋಡರ್‌ಗಳಿವೆ:\n",
    "\n",
    "1. ಆರ್ಡಿನಲ್ ಎನ್‌ಕೋಡರ್: ಇದು ಆರ್ಡಿನಲ್ ಚರಗಳಿಗಾಗಿ ಸೂಕ್ತವಾಗಿದೆ, ಅವು ವರ್ಗೀಕೃತ ಚರಗಳು ಆಗಿದ್ದು, ಅವುಗಳ ಡೇಟಾ ತಾರ್ಕಿಕ ಕ್ರಮವನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ನಮ್ಮ ಡೇಟಾಸೆಟ್‌ನ `item_size` ಕಾಲಮ್. ಇದು ಪ್ರತಿ ವರ್ಗವನ್ನು ಒಂದು ಸಂಖ್ಯೆಯಿಂದ ಪ್ರತಿನಿಧಿಸುವ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು ಕಾಲಮ್‌ನಲ್ಲಿನ ವರ್ಗದ ಕ್ರಮವಾಗಿದೆ.\n",
    "\n",
    "2. ವರ್ಗೀಕೃತ ಎನ್‌ಕೋಡರ್: ಇದು ನಾಮಮಾತ್ರ ಚರಗಳಿಗಾಗಿ ಸೂಕ್ತವಾಗಿದೆ, ಅವು ವರ್ಗೀಕೃತ ಚರಗಳು ಆಗಿದ್ದು, ಅವುಗಳ ಡೇಟಾ ತಾರ್ಕಿಕ ಕ್ರಮವನ್ನು ಅನುಸರಿಸುವುದಿಲ್ಲ, ಉದಾಹರಣೆಗೆ ನಮ್ಮ ಡೇಟಾಸೆಟ್‌ನ `item_size` ಹೊರತುಪಡಿಸಿದ ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳು. ಇದು ಒನ್-ಹಾಟ್ ಎನ್‌ಕೋಡಿಂಗ್ ಆಗಿದ್ದು, ಪ್ರತಿ ವರ್ಗವನ್ನು ಒಂದು ಬೈನರಿ ಕಾಲಮ್ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ: ಎನ್‌ಕೋಡಿಂಗ್ ಮಾಡಿದ ಚರವು 1 ಆಗಿರುತ್ತದೆ, ಅಂದರೆ ಕಂಬಳಿಯು ಆ ವೈವಿಧ್ಯಕ್ಕೆ ಸೇರಿದ್ದರೆ ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ 0.\n",
    "\n",
    "ಟೈಡಿಮೋಡಲ್ಸ್ ಇನ್ನೊಂದು ಚೆನ್ನಾದ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ: [recipes](https://recipes.tidymodels.org/) - ಡೇಟಾ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಪ್ಯಾಕೇಜ್. ನಾವು ಒಂದು `recipe` ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವೆವು, ಅದು ಎಲ್ಲಾ ಭವಿಷ್ಯವಾಣಿ ಕಾಲಮ್‌ಗಳನ್ನು ಪೂರ್ಣಾಂಕಗಳ ಸರಣಿಯಾಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡಬೇಕು ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಅದನ್ನು `prep` ಮೂಲಕ ಅಗತ್ಯವಿರುವ ಪ್ರಮಾಣಗಳು ಮತ್ತು ಅಂಕಿಅಂಶಗಳನ್ನು ಅಂದಾಜಿಸುತ್ತದೆ ಮತ್ತು ಕೊನೆಗೆ `bake` ಮೂಲಕ ಹೊಸ ಡೇಟಾಗೆ ಗಣನೆಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.\n",
    "\n",
    "> ಸಾಮಾನ್ಯವಾಗಿ, recipes ಅನ್ನು ಮಾದರೀಕರಣಕ್ಕಾಗಿ ಪೂರ್ವಪ್ರಕ್ರಿಯೆಕಾರಿಯಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅದು ಡೇಟಾ ಸೆಟ್‌ಗೆ ಯಾವ ಹಂತಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕು ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ, ಅದನ್ನು ಮಾದರೀಕರಣಕ್ಕೆ ಸಿದ್ಧಗೊಳಿಸಲು. ಆ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು `workflow()` ಅನ್ನು ಕೈಯಿಂದ prep ಮತ್ತು bake ಬಳಸಿ recipe ಅಂದಾಜಿಸುವುದರ ಬದಲು **ತೀವ್ರವಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ**. ನಾವು ಇದನ್ನು ಕ್ಷಣದಲ್ಲೇ ನೋಡುತ್ತೇವೆ.\n",
    ">\n",
    "> ಆದರೆ ಈಗ, ನಾವು recipes + prep + bake ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ, ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಗೆ ಸಿದ್ಧಗೊಳಿಸಲು ಯಾವ ಹಂತಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕು ಎಂದು ಸೂಚಿಸಲು ಮತ್ತು ನಂತರ ಅನ್ವಯಿಸಿದ ಹಂತಗಳೊಂದಿಗೆ ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆ ಮಾಡಿದ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯಲು.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Preprocess and extract data to allow some data analysis\n",
    "baked_pumpkins <- recipe(color ~ ., data = pumpkins_select) %>%\n",
    "  # Define ordering for item_size column\n",
    "  step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
    "  # Convert factors to numbers using the order defined above (Ordinal encoding)\n",
    "  step_integer(item_size, zero_based = F) %>%\n",
    "  # Encode all other predictors using one hot encoding\n",
    "  step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE) %>%\n",
    "  prep(data = pumpkin_select) %>%\n",
    "  bake(new_data = NULL)\n",
    "\n",
    "# Display the first few rows of preprocessed data\n",
    "baked_pumpkins %>% \n",
    "  slice_head(n = 5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "✅ ಐಟಂ ಗಾತ್ರ ಕಾಲಮ್‌ಗೆ ಆರ್ಡಿನಲ್ ಎನ್‌ಕೋಡರ್ ಬಳಸುವುದರಿಂದ ಏನು ಲಾಭಗಳಿವೆ?\n",
    "\n",
    "### ಚರಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ\n",
    "\n",
    "ನಾವು ಈಗಾಗಲೇ ನಮ್ಮ ಡೇಟಾವನ್ನು ಪೂರ್ವ-ಪ್ರಕ್ರಿಯೆ ಮಾಡಿರುವುದರಿಂದ, ನಾವು ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಲೇಬಲ್ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡಿದಾಗ ಮಾದರಿ ಲೇಬಲ್ ಅನ್ನು ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು ಎಂಬುದರ ಬಗ್ಗೆ ಒಂದು ಕಲ್ಪನೆ ಪಡೆಯಬಹುದು. ಈ ರೀತಿಯ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮಾಡಲು ಅತ್ಯುತ್ತಮ ವಿಧಾನ ಡೇಟಾವನ್ನು ಪ್ಲಾಟ್ ಮಾಡುವುದು.  \n",
    "ನಾವು ಮತ್ತೆ ggplot ನ geom_boxplot_ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಐಟಂ ಗಾತ್ರ, ವೈವಿಧ್ಯ ಮತ್ತು ಬಣ್ಣಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ವರ್ಗೀಕೃತ ಪ್ಲಾಟ್‌ನಲ್ಲಿ ದೃಶ್ಯೀಕರಿಸಲು. ಡೇಟಾವನ್ನು ಉತ್ತಮವಾಗಿ ಪ್ಲಾಟ್ ಮಾಡಲು ನಾವು ಎನ್‌ಕೋಡ್ ಮಾಡಲಾದ ಐಟಂ ಗಾತ್ರ ಕಾಲಮ್ ಮತ್ತು ಎನ್‌ಕೋಡ್ ಮಾಡದ ವೈವಿಧ್ಯ ಕಾಲಮ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Define the color palette\n",
    "palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
    "\n",
    "# We need the encoded Item Size column to use it as the x-axis values in the plot\n",
    "pumpkins_select_plot<-pumpkins_select\n",
    "pumpkins_select_plot$item_size <- baked_pumpkins$item_size\n",
    "\n",
    "# Create the grouped box plot\n",
    "ggplot(pumpkins_select_plot, aes(x = `item_size`, y = color, fill = color)) +\n",
    "  geom_boxplot() +\n",
    "  facet_grid(variety ~ ., scales = \"free_x\") +\n",
    "  scale_fill_manual(values = palette) +\n",
    "  labs(x = \"Item Size\", y = \"\") +\n",
    "  theme_minimal() +\n",
    "  theme(strip.text = element_text(size = 12)) +\n",
    "  theme(axis.text.x = element_text(size = 10)) +\n",
    "  theme(axis.title.x = element_text(size = 12)) +\n",
    "  theme(axis.title.y = element_blank()) +\n",
    "  theme(legend.position = \"bottom\") +\n",
    "  guides(fill = guide_legend(title = \"Color\")) +\n",
    "  theme(panel.spacing = unit(0.5, \"lines\"))+\n",
    "  theme(strip.text.y = element_text(size = 4, hjust = 0)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ಸ್ವಾರ್ಮ್ ಪ್ಲಾಟ್ ಬಳಸಿ\n",
    "\n",
    "ಬಣ್ಣವು ದ್ವಿಮೂಲ ವರ್ಗ (ಬಿಳಿ ಅಥವಾ ಅಲ್ಲ) ಆಗಿರುವುದರಿಂದ, ಅದನ್ನು ದೃಶ್ಯೀಕರಣಕ್ಕೆ 'ವಿಶೇಷ ವಿಧಾನ' ಬೇಕಾಗುತ್ತದೆ.\n",
    "\n",
    "ಐಟಂ_ಗಾತ್ರದ ಸಂಬಂಧದಲ್ಲಿ ಬಣ್ಣದ ವಿತರಣೆ ತೋರಿಸಲು `ಸ್ವಾರ್ಮ್ ಪ್ಲಾಟ್` ಪ್ರಯತ್ನಿಸಿ.\n",
    "\n",
    "ನಾವು [ggbeeswarm ಪ್ಯಾಕೇಜ್](https://github.com/eclarke/ggbeeswarm) ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ggplot2 ಬಳಸಿ ಬೀಸ್ವಾರ್ಮ್ ಶೈಲಿಯ ಪ್ಲಾಟ್‌ಗಳನ್ನು ರಚಿಸುವ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಬೀಸ್ವಾರ್ಮ್ ಪ್ಲಾಟ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಒಟ್ಟಿಗೆ ಮಿಲಿತವಾಗುವ ಬಿಂದುಗಳನ್ನು ಪರಸ್ಪರ ಪಕ್ಕದಲ್ಲಿ ಬಿದ್ದಂತೆ ಚಿತ್ರಿಸುವ ವಿಧಾನವಾಗಿದೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Create beeswarm plots of color and item_size\n",
    "baked_pumpkins %>% \n",
    "  mutate(color = factor(color)) %>% \n",
    "  ggplot(mapping = aes(x = color, y = item_size, color = color)) +\n",
    "  geom_quasirandom() +\n",
    "  scale_color_brewer(palette = \"Dark2\", direction = -1) +\n",
    "  theme(legend.position = \"none\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಈಗ ನಾವು ಬಣ್ಣದ ದ್ವಿಪದ ವರ್ಗಗಳ ಮತ್ತು ದೊಡ್ಡ ಗಾತ್ರಗಳ ಗುಂಪಿನ ನಡುವಿನ ಸಂಬಂಧದ ಬಗ್ಗೆ ಒಂದು ಕಲ್ಪನೆ ಹೊಂದಿದ್ದೇವೆ, ಬರುವುದಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಅನ್ನು ಅನ್ವೇಷಿಸಿ ನೀಡಲಾದ ಕಂಬಳಿಯ ಸಾಧ್ಯತೆಯ ಬಣ್ಣವನ್ನು ನಿರ್ಧರಿಸೋಣ.\n",
    "\n",
    "## ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ\n",
    "\n",
    "ನೀವು ನಿಮ್ಮ ವರ್ಗೀಕರಣ ಮಾದರಿಯಲ್ಲಿ ಬಳಸಲು ಬಯಸುವ ಚರಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಡೇಟಾವನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿ. [rsample](https://rsample.tidymodels.org/), Tidymodels ನಲ್ಲಿ ಒಂದು ಪ್ಯಾಕೇಜ್, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಡೇಟಾ ವಿಭಜನೆ ಮತ್ತು ಮರುನಮೂನೆಗಾಗಿ ಮೂಲಸೌಕರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Split data into 80% for training and 20% for testing\n",
    "set.seed(2056)\n",
    "pumpkins_split <- pumpkins_select %>% \n",
    "  initial_split(prop = 0.8)\n",
    "\n",
    "# Extract the data in each split\n",
    "pumpkins_train <- training(pumpkins_split)\n",
    "pumpkins_test <- testing(pumpkins_split)\n",
    "\n",
    "# Print out the first 5 rows of the training set\n",
    "pumpkins_train %>% \n",
    "  slice_head(n = 5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🙌 ನಾವು ಈಗ ತರಬೇತಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ತರಬೇತಿ ಲೇಬಲ್ (ಬಣ್ಣ) ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ ಮಾದರಿಯನ್ನು ತರಬೇತಿಗೆ ಸಿದ್ಧರಾಗಿದ್ದೇವೆ.\n",
    "\n",
    "ನಮ್ಮ ಡೇಟಾವನ್ನು ಮಾದರಿಗಾಗಿ ಸಿದ್ಧಗೊಳಿಸಲು ಮಾಡಬೇಕಾದ ಪೂರ್ವಪ್ರಕ್ರಿಯೆ ಹಂತಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಒಂದು ರೆಸಿಪಿಯನ್ನು ರಚಿಸುವುದರಿಂದ ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಅಂದರೆ: ವರ್ಗೀಕೃತ ಚರಗಳನ್ನು ಪೂರ್ಣಾಂಕಗಳ ಸರಣಿಯಾಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡುವುದು. `baked_pumpkins` ನಂತೆ, ನಾವು `pumpkins_recipe` ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಆದರೆ ಅದನ್ನು `prep` ಮತ್ತು `bake` ಮಾಡುತ್ತಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ವರ್ಕ್‌ಫ್ಲೋದಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ, ನೀವು ಕೆಲವು ಹಂತಗಳಲ್ಲಿ ಅದನ್ನು ನೋಡುತ್ತೀರಿ.\n",
    "\n",
    "Tidymodels ನಲ್ಲಿ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಹಲವಾರು ವಿಧಾನಗಳಿವೆ. `?logistic_reg()` ಅನ್ನು ನೋಡಿ. ಈಗಾಗಲೇ, ನಾವು ಡೀಫಾಲ್ಟ್ `stats::glm()` ಎಂಜಿನ್ ಮೂಲಕ ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Create a recipe that specifies preprocessing steps for modelling\n",
    "pumpkins_recipe <- recipe(color ~ ., data = pumpkins_train) %>% \n",
    "  step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
    "  step_integer(item_size, zero_based = F) %>%  \n",
    "  step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE)\n",
    "\n",
    "# Create a logistic model specification\n",
    "log_reg <- logistic_reg() %>% \n",
    "  set_engine(\"glm\") %>% \n",
    "  set_mode(\"classification\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಈಗ ನಮಗೆ ಒಂದು ರೆಸಿಪಿ ಮತ್ತು ಒಂದು ಮಾದರಿ ನಿರ್ದಿಷ್ಟತೆ ಇದ್ದು, ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಒಂದು ವಸ್ತುವಾಗಿ ಪ್ಯಾಕೇಜ್ ಮಾಡುವ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಾಗಿದೆ, ಅದು ಮೊದಲು ಡೇಟಾವನ್ನು ಪೂರ್ವಸಿದ್ಧತೆ ಮಾಡುತ್ತದೆ (ಹಿನ್ನೆಲೆದಲ್ಲಿ prep+bake), ಪೂರ್ವಸಿದ್ಧತೆ ಮಾಡಲಾದ ಡೇಟಾದ ಮೇಲೆ ಮಾದರಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಸಾಧ್ಯವಾದ ನಂತರದ ಪ್ರಕ್ರಿಯೆಗಳಿಗೂ ಅವಕಾಶ ನೀಡುತ್ತದೆ.\n",
    "\n",
    "Tidymodels ನಲ್ಲಿ, ಈ ಅನುಕೂಲಕರ ವಸ್ತುವನ್ನು [`workflow`](https://workflows.tidymodels.org/) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಇದು ನಿಮ್ಮ ಮಾದರಿ ಘಟಕಗಳನ್ನು ಅನುಕೂಲಕರವಾಗಿ ಹಿಡಿದಿಡುತ್ತದೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Bundle modelling components in a workflow\n",
    "log_reg_wf <- workflow() %>% \n",
    "  add_recipe(pumpkins_recipe) %>% \n",
    "  add_model(log_reg)\n",
    "\n",
    "# Print out the workflow\n",
    "log_reg_wf\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಒಂದು ವರ್ಕ್‌ಫ್ಲೋವನ್ನು *ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ* ನಂತರ, ಮಾದರಿಯನ್ನು [`fit()`](https://tidymodels.github.io/parsnip/reference/fit.html) ಫಂಕ್ಷನ್ ಬಳಸಿ `ಪ್ರಶಿಕ್ಷಣ` ಮಾಡಬಹುದು. ವರ್ಕ್‌ಫ್ಲೋವು ತರಬೇತಿಗೆ ಮುನ್ನ ರೆಸಿಪಿ ಅಂದಾಜು ಮಾಡುತ್ತದೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಪೂರ್ವಸಿದ್ಧಗೊಳಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಕೈಯಿಂದ prep ಮತ್ತು bake ಬಳಸಿ ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Train the model\n",
    "wf_fit <- log_reg_wf %>% \n",
    "  fit(data = pumpkins_train)\n",
    "\n",
    "# Print the trained workflow\n",
    "wf_fit\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಮಾದರಿ ಮುದ್ರಣವು ತರಬೇತಿ ಸಮಯದಲ್ಲಿ ಕಲಿತ ಸಹಗುಣಾಂಕಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.\n",
    "\n",
    "ಈಗ ನಾವು ತರಬೇತಿ ಡೇಟಾವನ್ನು ಬಳಸಿ ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಿದ್ದೇವೆ, ನಾವು [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html) ಅನ್ನು ಬಳಸಿ ಪರೀಕ್ಷಾ ಡೇಟಾದ ಮೇಲೆ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು. ನಮ್ಮ ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗೆ ಲೇಬಲ್ಗಳನ್ನು ಮತ್ತು ಪ್ರತಿ ಲೇಬಲ್ಗಾಗಿ ಸಾಧ್ಯತೆಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಮಾದರಿಯನ್ನು ಬಳಸುವುದರಿಂದ ಪ್ರಾರಂಭಿಸೋಣ. ಸಾಧ್ಯತೆ 0.5 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಇದ್ದಾಗ, predict ವರ್ಗ `WHITE` ಆಗಿರುತ್ತದೆ ಇಲ್ಲದಿದ್ದರೆ `ORANGE`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Make predictions for color and corresponding probabilities\n",
    "results <- pumpkins_test %>% select(color) %>% \n",
    "  bind_cols(wf_fit %>% \n",
    "              predict(new_data = pumpkins_test)) %>%\n",
    "  bind_cols(wf_fit %>%\n",
    "              predict(new_data = pumpkins_test, type = \"prob\"))\n",
    "\n",
    "# Compare predictions\n",
    "results %>% \n",
    "  slice_head(n = 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಬಹಳ ಚೆನ್ನಾಗಿದೆ! ಇದು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ.\n",
    "\n",
    "### ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಮೂಲಕ ಉತ್ತಮ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ\n",
    "\n",
    "ಪ್ರತಿ ಭವಿಷ್ಯವಾಣಿ ಮತ್ತು ಅದರ ಸಂಬಂಧಿಸಿದ \"ಭೂಮಿಯ ಸತ್ಯ\" ನಿಜವಾದ ಮೌಲ್ಯವನ್ನು ಹೋಲಿಸುವುದು ಮಾದರಿ ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡುತ್ತಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಬಹಳ ಪರಿಣಾಮಕಾರಿಯಾದ ವಿಧಾನವಲ್ಲ. ಭಾಗ್ಯವಶಾತ್, Tidymodels ನಲ್ಲಿ ಇನ್ನಷ್ಟು ತಂತ್ರಗಳು ಇವೆ: [`yardstick`](https://yardstick.tidymodels.org/) - ಕಾರ್ಯಕ್ಷಮತೆ ಮೌಲ್ಯಮಾಪನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಗಳ ಪರಿಣಾಮಕಾರಿತ್ವವನ್ನು ಅಳೆಯಲು ಬಳಸುವ ಪ್ಯಾಕೇಜ್.\n",
    "\n",
    "ವರ್ಗೀಕರಣ ಸಮಸ್ಯೆಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಒಂದು ಕಾರ್ಯಕ್ಷಮತೆ ಮೌಲ್ಯಮಾಪನವು [`confusion matrix`](https://wikipedia.org/wiki/Confusion_matrix). ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಒಂದು ವರ್ಗೀಕರಣ ಮಾದರಿ ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಪ್ರತಿ ವರ್ಗದಲ್ಲಿ ಎಷ್ಟು ಉದಾಹರಣೆಗಳನ್ನು ಮಾದರಿ ಸರಿಯಾಗಿ ವರ್ಗೀಕರಿಸಿದೆ ಎಂಬುದನ್ನು ಟ್ಯಾಬುಲೇಟು ಮಾಡುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಇದು ನಿಮಗೆ ಎಷ್ಟು ಕಿತ್ತಳೆ ಕಂಬಳಿಗಳನ್ನು ಕಿತ್ತಳೆ ಎಂದು ವರ್ಗೀಕರಿಸಲಾಗಿದೆ ಮತ್ತು ಎಷ್ಟು ಬಿಳಿ ಕಂಬಳಿಗಳನ್ನು ಬಿಳಿ ಎಂದು ವರ್ಗೀಕರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ; ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ನಿಮಗೆ ಎಷ್ಟು **ತಪ್ಪು** ವರ್ಗಗಳಲ್ಲಿ ವರ್ಗೀಕರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನೂ ತೋರಿಸುತ್ತದೆ.\n",
    "\n",
    "yardstick ನಿಂದ [**`conf_mat()`**](https://tidymodels.github.io/yardstick/reference/conf_mat.html) ಫಂಕ್ಷನ್ ಈ ಗಮನಿಸಿದ ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ವರ್ಗಗಳ ಕ್ರಾಸ್-ಟ್ಯಾಬ್ಯುಲೇಶನ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತದೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Confusion matrix for prediction results\n",
    "conf_mat(data = results, truth = color, estimate = .pred_class)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ನಾವು ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ. ನಮ್ಮ ಮಾದರಿಯನ್ನು ಎರಡು ದ್ವಿಮೂಲ್ಯ ವರ್ಗಗಳಾದ `white` ಮತ್ತು `not-white` ವರ್ಗಗಳ ನಡುವೆ ಕಂಬಳಿಗಳನ್ನು ವರ್ಗೀಕರಿಸಲು ಕೇಳಲಾಗಿದೆ\n",
    "\n",
    "-   ನಿಮ್ಮ ಮಾದರಿ ಒಂದು ಕಂಬಳಿಯನ್ನು white ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ವಾಸ್ತವದಲ್ಲಿ 'white' ವರ್ಗಕ್ಕೆ ಸೇರಿದ್ದರೆ, ಅದನ್ನು ನಾವು `true positive` ಎಂದು ಕರೆಯುತ್ತೇವೆ, ಇದು ಮೇಲಿನ ಎಡಭಾಗದ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.\n",
    "\n",
    "-   ನಿಮ್ಮ ಮಾದರಿ ಒಂದು ಕಂಬಳಿಯನ್ನು not white ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ವಾಸ್ತವದಲ್ಲಿ 'white' ವರ್ಗಕ್ಕೆ ಸೇರಿದ್ದರೆ, ಅದನ್ನು ನಾವು `false negative` ಎಂದು ಕರೆಯುತ್ತೇವೆ, ಇದು ಕೆಳಗಿನ ಎಡಭಾಗದ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.\n",
    "\n",
    "-   ನಿಮ್ಮ ಮಾದರಿ ಒಂದು ಕಂಬಳಿಯನ್ನು white ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ವಾಸ್ತವದಲ್ಲಿ 'not-white' ವರ್ಗಕ್ಕೆ ಸೇರಿದ್ದರೆ, ಅದನ್ನು ನಾವು `false positive` ಎಂದು ಕರೆಯುತ್ತೇವೆ, ಇದು ಮೇಲಿನ ಬಲಭಾಗದ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.\n",
    "\n",
    "-   ನಿಮ್ಮ ಮಾದರಿ ಒಂದು ಕಂಬಳಿಯನ್ನು not white ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದರೆ ಮತ್ತು ಅದು ವಾಸ್ತವದಲ್ಲಿ 'not-white' ವರ್ಗಕ್ಕೆ ಸೇರಿದ್ದರೆ, ಅದನ್ನು ನಾವು `true negative` ಎಂದು ಕರೆಯುತ್ತೇವೆ, ಇದು ಕೆಳಗಿನ ಬಲಭಾಗದ ಸಂಖ್ಯೆಯಿಂದ ತೋರಿಸಲಾಗಿದೆ.\n",
    "\n",
    "| Truth |\n",
    "|:-----:|\n",
    "\n",
    "\n",
    "|               |        |       |\n",
    "|---------------|--------|-------|\n",
    "| **Predicted** | WHITE | ORANGE |\n",
    "| WHITE        | TP     | FP    |\n",
    "| ORANGE         | FN     | TN    |\n",
    "\n",
    "ನೀವು ಊಹಿಸಿದ್ದಂತೆ, ಹೆಚ್ಚು true positives ಮತ್ತು true negatives ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರುವುದು ಮತ್ತು ಕಡಿಮೆ false positives ಮತ್ತು false negatives ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರುವುದು ಇಷ್ಟಕರ, ಇದು ಮಾದರಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.\n",
    "\n",
    "ಗೊಂದಲ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಉಪಯುಕ್ತವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಇತರ ಮೆಟ್ರಿಕ್ಸ್ ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಅವುಗಳು ವರ್ಗೀಕರಣ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಕೆಲವು ಮೆಟ್ರಿಕ್ಸ್ ಗಳನ್ನು ನೋಡೋಣ:\n",
    "\n",
    "🎓 Precision: `TP/(TP + FP)` ಇದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಧನಾತ್ಮಕಗಳಲ್ಲಿನ ನಿಜವಾದ ಧನಾತ್ಮಕಗಳ ಅನುಪಾತವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಇದನ್ನು [positive predictive value](https://en.wikipedia.org/wiki/Positive_predictive_value \"Positive predictive value\") ಎಂದೂ ಕರೆಯುತ್ತಾರೆ\n",
    "\n",
    "🎓 Recall: `TP/(TP + FN)` ಇದು ನಿಜವಾಗಿಯೂ ಧನಾತ್ಮಕವಾಗಿದ್ದ ಮಾದರಿಗಳ ಸಂಖ್ಯೆಯಲ್ಲಿನ ಧನಾತ್ಮಕ ಫಲಿತಾಂಶಗಳ ಅನುಪಾತವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಇದನ್ನು `sensitivity` ಎಂದೂ ಕರೆಯುತ್ತಾರೆ.\n",
    "\n",
    "🎓 Specificity: `TN/(TN + FP)` ಇದು ನಿಜವಾಗಿಯೂ ನಕಾರಾತ್ಮಕವಾಗಿದ್ದ ಮಾದರಿಗಳ ಸಂಖ್ಯೆಯಲ್ಲಿನ ನಕಾರಾತ್ಮಕ ಫಲಿತಾಂಶಗಳ ಅನುಪಾತವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.\n",
    "\n",
    "🎓 Accuracy: `TP + TN/(TP + TN + FP + FN)` ಮಾದರಿಯು ನಿಖರವಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಲೇಬಲ್ ಗಳ ಶೇಕಡಾವಾರು.\n",
    "\n",
    "🎓 F Measure: precision ಮತ್ತು recall ನ ತೂಕಿತ ಸರಾಸರಿ, ಉತ್ತಮವಾದುದು 1 ಮತ್ತು ಕೆಟ್ಟದಾದುದು 0.\n",
    "\n",
    "ಈ ಮೆಟ್ರಿಕ್ಸ್ ಗಳನ್ನು ಲೆಕ್ಕಹಾಕೋಣ!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Combine metric functions and calculate them all at once\n",
    "eval_metrics <- metric_set(ppv, recall, spec, f_meas, accuracy)\n",
    "eval_metrics(data = results, truth = color, estimate = .pred_class)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ಈ ಮಾದರಿಯ ROC ವಕ್ರವನ್ನು ದೃಶ್ಯೀಕರಿಸಿ\n",
    "\n",
    "ಹೆಸರಾಗಿರುವ [`ROC ವಕ್ರ`](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) ಅನ್ನು ನೋಡಲು ಇನ್ನೊಂದು ದೃಶ್ಯೀಕರಣ ಮಾಡೋಣ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Make a roc_curve\n",
    "results %>% \n",
    "  roc_curve(color, .pred_ORANGE) %>% \n",
    "  autoplot()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ROC ವಕ್ರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ವರ್ಗೀಕರಿಸುವ ಯಂತ್ರದ ನಿಜವಾದ ಮತ್ತು ತಪ್ಪು ಧನಾತ್ಮಕಗಳ ದೃಷ್ಟಿಕೋನದಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡಲು ಬಳಸಲಾಗುತ್ತವೆ. ROC ವಕ್ರಗಳು ಸಾಮಾನ್ಯವಾಗಿ Y ಅಕ್ಷದಲ್ಲಿ `ನಿಜವಾದ ಧನಾತ್ಮಕ ದರ`/ಸಂವೇದನಶೀಲತೆ ಮತ್ತು X ಅಕ್ಷದಲ್ಲಿ `ತಪ್ಪು ಧನಾತ್ಮಕ ದರ`/1-ವಿಶಿಷ್ಟತೆ ಹೊಂದಿರುತ್ತವೆ. ಆದ್ದರಿಂದ, ವಕ್ರದ ತೀವ್ರತೆ ಮತ್ತು ಮಧ್ಯರೇಖೆ ಮತ್ತು ವಕ್ರದ ನಡುವೆ ಇರುವ ಸ್ಥಳವು ಮಹತ್ವಪೂರ್ಣ: ನೀವು ವಕ್ರವು ತ್ವರಿತವಾಗಿ ಮೇಲಕ್ಕೆ ಹೋಗಿ ರೇಖೆಯನ್ನು ದಾಟುವಂತೆ ಬಯಸುತ್ತೀರಿ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಪ್ರಾರಂಭದಲ್ಲಿ ತಪ್ಪು ಧನಾತ್ಮಕಗಳಿವೆ, ನಂತರ ರೇಖೆ ಸರಿಯಾಗಿ ಮೇಲಕ್ಕೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ದಾಟುತ್ತದೆ.\n",
    "\n",
    "ಕೊನೆಗೆ, ನಿಜವಾದ ವಕ್ರದ ಕೆಳಗಿನ ಪ್ರದೇಶವನ್ನು ಲೆಕ್ಕಿಸಲು `yardstick::roc_auc()` ಅನ್ನು ಬಳಸೋಣ. AUC ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಒಂದು ವಿಧಾನವೆಂದರೆ, ಮಾದರಿ ಯಾದೃಚ್ಛಿಕ ಧನಾತ್ಮಕ ಉದಾಹರಣೆಯನ್ನು ಯಾದೃಚ್ಛಿಕ ನಕಾರಾತ್ಮಕ ಉದಾಹರಣೆಯಿಗಿಂತ ಹೆಚ್ಚು ಶ್ರೇಣೀಕರಿಸುವ ಸಾಧ್ಯತೆ ಎಂದು.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Calculate area under curve\n",
    "results %>% \n",
    "  roc_auc(color, .pred_ORANGE)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ಫಲಿತಾಂಶವು ಸುತ್ತಲೂ `0.975` ಇದೆ. AUC 0 ರಿಂದ 1 ರವರೆಗೆ ವ್ಯಾಪಿಸುತ್ತಿರುವುದರಿಂದ, ನೀವು ದೊಡ್ಡ ಸ್ಕೋರ್ ಅನ್ನು ಬಯಸುತ್ತೀರಿ, ಏಕೆಂದರೆ 100% ಸರಿಯಾದ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡುವ ಮಾದರಿಯು 1 ರ AUC ಹೊಂದಿರುತ್ತದೆ; ಈ ಪ್ರಕರಣದಲ್ಲಿ, ಮಾದರಿ *ಚೆನ್ನಾಗಿದೆ*.\n",
    "\n",
    "ಭವಿಷ್ಯದಲ್ಲಿ ವರ್ಗೀಕರಣಗಳ ಪಾಠಗಳಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ಮಾದರಿಯ ಸ್ಕೋರ್‌ಗಳನ್ನು ಸುಧಾರಿಸುವುದನ್ನು ಕಲಿಯುತ್ತೀರಿ (ಈ ಪ್ರಕರಣದಲ್ಲಿ ಅಸಮತೋಲನ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವಂತಹ).\n",
    "\n",
    "## 🚀ಸವಾಲು\n",
    "\n",
    "ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಬಗ್ಗೆ ಇನ್ನೂ ಬಹಳವಿದೆ ಅನ್ವೇಷಿಸಲು! ಆದರೆ ಕಲಿಯಲು ಉತ್ತಮ ಮಾರ್ಗವು ಪ್ರಯೋಗ ಮಾಡುವುದು. ಈ ರೀತಿಯ ವಿಶ್ಲೇಷಣೆಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಹುಡುಕಿ ಮತ್ತು ಅದರಿಂದ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ. ನೀವು ಏನು ಕಲಿತೀರಿ? ಸೂಚನೆ: ಆಸಕ್ತಿದಾಯಕ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ.\n",
    "\n",
    "## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ\n",
    "\n",
    "ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್‌ನ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಗಳ ಕುರಿತು [ಸ್ಟ್ಯಾನ್‌ಫರ್ಡ್‌ನ ಈ ಪೇಪರ್](https://web.stanford.edu/~jurafsky/slp3/5.pdf) ನ ಮೊದಲ ಕೆಲವು ಪುಟಗಳನ್ನು ಓದಿ. ನಾವು ಈವರೆಗೆ ಅಧ್ಯಯನ ಮಾಡಿದ ರಿಗ್ರೆಶನ್ ಕಾರ್ಯಗಳ ಒಂದರ ಅಥವಾ ಇನ್ನೊಂದರಿಗಾಗಿ ಉತ್ತಮವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುವ ಕಾರ್ಯಗಳ ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಯಾವುದು ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**:  \nಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": "",
  "kernelspec": {
   "display_name": "R",
   "langauge": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.4.1"
  },
  "coopTranslator": {
   "original_hash": "feaf125f481a89c468fa115bf2aed580",
   "translation_date": "2025-12-19T16:47:45+00:00",
   "source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
   "language_code": "kn"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}