{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਉਣਾ - ਪਾਠ 4\n",
    "\n",
    "![ਲੌਜਿਸਟਿਕ ਅਤੇ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਇਨਫੋਗ੍ਰਾਫਿਕ](../../../../../../translated_images/linear-vs-logistic.ba180bf95e7ee66721ba10ebf2dac2666acbd64a88b003c83928712433a13c7d.pa.png)\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",
    "ਕਦੂ ਦੇ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਹੁਣ ਇਸ ਨਾਲ ਕਾਫ਼ੀ ਜਾਣੂ ਹੋ ਗਏ ਹਾਂ ਕਿ ਇੱਕ ਬਾਈਨਰੀ ਸ਼੍ਰੇਣੀ ਹੈ ਜਿਸ ਨਾਲ ਅਸੀਂ ਕੰਮ ਕਰ ਸਕਦੇ ਹਾਂ: `Color`।\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 ਦੀ ਵਰਤੋਂ ਕਰਕੇ beeswarm-ਸ਼ੈਲੀ ਦੇ ਪਲਾਟ ਬਣਾਉਣ ਦੇ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।\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",
    "ਸਾਡੇ ਮਕਸਦ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ ਦੋ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਾਂਗੇ: 'ਚਿੱਟਾ' ਜਾਂ 'ਚਿੱਟਾ ਨਹੀਂ'। ਸਾਡੇ ਡੇਟਾਸੈਟ ਵਿੱਚ 'ਧਾਰੀਦਾਰ' ਸ਼੍ਰੇਣੀ ਵੀ ਹੈ, ਪਰ ਇਸ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਘੱਟ ਹਨ, ਇਸ ਲਈ ਅਸੀਂ ਇਸਨੂੰ ਵਰਤਾਂਗੇ ਨਹੀਂ। ਜਦੋਂ ਅਸੀਂ ਡੇਟਾਸੈਟ ਵਿੱਚੋਂ null ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਸ਼੍ਰੇਣੀ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ।\n",
    "\n",
    "> 🎃 ਮਜ਼ੇਦਾਰ ਗੱਲ, ਅਸੀਂ ਕਈ ਵਾਰ ਚਿੱਟੇ ਕੱਦੂਆਂ ਨੂੰ 'ਭੂਤ' ਕੱਦੂ ਕਹਿੰਦੇ ਹਾਂ। ਇਹ ਕੱਟਣ ਵਿੱਚ ਆਸਾਨ ਨਹੀਂ ਹੁੰਦੇ, ਇਸ ਲਈ ਇਹ ਸੰਤਰੀ ਕੱਦੂਆਂ ਜਿੰਨੇ ਲੋਕਪ੍ਰਿਯ ਨਹੀਂ ਹਨ, ਪਰ ਇਹ ਦੇਖਣ ਵਿੱਚ ਕਾਫ਼ੀ ਵਧੀਆ ਹੁੰਦੇ ਹਨ! ਇਸ ਲਈ ਅਸੀਂ ਆਪਣੇ ਸਵਾਲ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਵੀ ਦੁਬਾਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ: 'ਭੂਤ' ਜਾਂ 'ਭੂਤ ਨਹੀਂ'। 👻\n",
    "\n",
    "## **ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਬਾਰੇ**\n",
    "\n",
    "ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਕੁਝ ਮਹੱਤਵਪੂਰਨ ਤਰੀਕਿਆਂ ਵਿੱਚ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਤੋਂ ਵੱਖਰਾ ਹੈ, ਜਿਸ ਬਾਰੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਸਿੱਖਿਆ ਸੀ।\n",
    "\n",
    "#### **ਦੋਹਰੀ ਵਰਗੀਕਰਨ (ਬਾਈਨਰੀ ਕਲਾਸੀਫਿਕੇਸ਼ਨ)**\n",
    "\n",
    "ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਵਾਲੀਆਂ ਹੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਹੀਂ ਦਿੰਦਾ। ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਇੱਕ `ਬਾਈਨਰੀ ਸ਼੍ਰੇਣੀ` ('ਸੰਤਰੀ ਜਾਂ ਸੰਤਰੀ ਨਹੀਂ') ਬਾਰੇ ਅਨੁਮਾਨ ਦਿੰਦਾ ਹੈ, ਜਦਕਿ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ `ਲਗਾਤਾਰ ਮੁੱਲਾਂ` ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦੇ ਯੋਗ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਕੱਦੂ ਦੇ ਮੂਲ ਅਤੇ ਕੱਟਣ ਦੇ ਸਮੇਂ ਦੇ ਆਧਾਰ 'ਇਸ ਦੀ ਕੀਮਤ ਕਿੰਨੀ ਵਧੇਗੀ'।\n",
    "\n",
    "![ਦਸਾਨੀ ਮਦੀਪੱਲੀ ਦੁਆਰਾ ਇਨਫੋਗ੍ਰਾਫਿਕ](../../../../../../translated_images/pumpkin-classifier.562771f104ad5436b87d1c67bca02a42a17841133556559325c0a0e348e5b774.pa.png)\n",
    "\n",
    "### ਹੋਰ ਵਰਗੀਕਰਨ\n",
    "\n",
    "ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਹੋਰ ਕਿਸਮਾਂ ਵੀ ਹਨ, ਜਿਵੇਂ ਕਿ ਮਲਟੀਨੋਮਿਅਲ ਅਤੇ ਆਰਡਿਨਲ:\n",
    "\n",
    "- **ਮਲਟੀਨੋਮਿਅਲ**, ਜਿਸ ਵਿੱਚ ਇੱਕ ਤੋਂ ਵੱਧ ਸ਼੍ਰੇਣੀਆਂ ਹੁੰਦੀਆਂ ਹਨ - \"ਸੰਤਰੀ, ਚਿੱਟਾ, ਅਤੇ ਧਾਰੀਦਾਰ\"।\n",
    "\n",
    "- **ਆਰਡਿਨਲ**, ਜਿਸ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਸ਼੍ਰੇਣੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਜੋ ਸਾਡੇ ਨਤੀਜਿਆਂ ਨੂੰ ਤਰਤੀਬਵਾਰ ਲਗਾਉਣ ਲਈ ਲਾਭਦਾਇਕ ਹੁੰਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਸਾਡੇ ਕੱਦੂ, ਜੋ ਇੱਕ ਨਿਰਧਾਰਤ ਗਿਣਤੀ ਦੇ ਆਕਾਰਾਂ (ਮਿਨੀ, ਛੋਟਾ, ਦਰਮਿਆਨਾ, ਵੱਡਾ, ਬਹੁਤ ਵੱਡਾ, ਆਦਿ) ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕੀਤੇ ਗਏ ਹਨ।\n",
    "\n",
    "![ਮਲਟੀਨੋਮਿਅਲ ਵਸ ਆਰਡਿਨਲ ਰਿਗ੍ਰੈਸ਼ਨ](../../../../../../translated_images/multinomial-vs-ordinal.36701b4850e37d86c9dd49f7bef93a2f94dbdb8fe03443eb68f0542f97f28f29.pa.png)\n",
    "\n",
    "#### **ਵੈਰੀਏਬਲਜ਼ ਦਾ ਆਪਸ ਵਿੱਚ ਸੰਬੰਧ ਹੋਣਾ ਜ਼ਰੂਰੀ ਨਹੀਂ**\n",
    "\n",
    "ਤੁਹਾਨੂੰ ਯਾਦ ਹੈ ਕਿ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਜਦੋਂ ਵੈਰੀਏਬਲਜ਼ ਜ਼ਿਆਦਾ ਸੰਬੰਧਿਤ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ? ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਇਸਦਾ ਉਲਟ ਹੈ - ਵੈਰੀਏਬਲਜ਼ ਦਾ ਆਪਸ ਵਿੱਚ ਸੰਬੰਧ ਹੋਣਾ ਜ਼ਰੂਰੀ ਨਹੀਂ। ਇਹ ਇਸ ਡੇਟਾ ਲਈ ਠੀਕ ਹੈ, ਜਿਸ ਵਿੱਚ ਸੰਬੰਧ ਕਾਫ਼ੀ ਕਮਜ਼ੋਰ ਹਨ।\n",
    "\n",
    "#### **ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਫ਼ ਡੇਟਾ ਚਾਹੀਦਾ ਹੈ**\n",
    "\n",
    "ਜੇ ਤੁਸੀਂ ਵੱਧ ਡੇਟਾ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਹੋਰ ਸਹੀ ਨਤੀਜੇ ਦੇਵੇਗਾ; ਸਾਡਾ ਛੋਟਾ ਡੇਟਾਸੈਟ ਇਸ ਕੰਮ ਲਈ ਉਪਯੁਕਤ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇਸ ਗੱਲ ਨੂੰ ਯਾਦ ਰੱਖੋ।\n",
    "\n",
    "✅ ਉਹ ਡੇਟਾ ਕਿਸਮਾਂ ਬਾਰੇ ਸੋਚੋ ਜੋ ਲੌਜਿਸਟਿਕ ਰਿਗ੍ਰੈਸ਼ਨ ਲਈ ਵਧੀਆ ਹੋ ਸਕਦੀਆਂ ਹਨ।\n",
    "\n",
    "## ਕਸਰਤ - ਡੇਟਾ ਸਾਫ਼ ਕਰੋ\n",
    "\n",
    "ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਡੇਟਾ ਨੂੰ ਥੋੜ੍ਹਾ ਸਾਫ਼ ਕਰੋ, null ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਓ ਅਤੇ ਸਿਰਫ ਕੁਝ ਕਾਲਮ ਚੁਣੋ:\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",
    "ਹੁਣ ਤੱਕ ਤੁਸੀਂ ਕਦੂ ਦੇ ਡਾਟਾ ਨੂੰ ਮੁੜ ਲੋਡ ਕਰ ਲਿਆ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਾਫ਼ ਕਰ ਲਿਆ ਹੈ ਤਾਂ ਜੋ ਕੁਝ ਵੈਰੀਏਬਲਾਂ ਸਮੇਤ Color ਵਾਲਾ ਡਾਟਾਸੈਟ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾ ਸਕੇ। ਆਓ ggplot ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੋਟਬੁੱਕ ਵਿੱਚ ਡਾਟਾਫਰੇਮ ਨੂੰ ਵਿਜੁਅਲਾਈਜ਼ ਕਰੀਏ।\n",
    "\n",
    "ggplot ਲਾਇਬ੍ਰੇਰੀ ਤੁਹਾਡੇ ਡਾਟਾ ਨੂੰ ਵਿਜੁਅਲਾਈਜ਼ ਕਰਨ ਦੇ ਕੁਝ ਵਧੀਆ ਤਰੀਕੇ ਪੇਸ਼ ਕਰਦੀ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ਤੁਸੀਂ ਇੱਕ ਸ਼੍ਰੇਣੀਬੱਧ ਪਲਾਟ ਵਿੱਚ ਹਰ Variety ਅਤੇ Color ਲਈ ਡਾਟਾ ਦੇ ਵੰਡ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕਦੇ ਹੋ।\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 ਦੇ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ ਜੇਕਰ ਕੱਦੂ ਉਸ Variety ਨਾਲ ਸਬੰਧਿਤ ਹੈ ਅਤੇ 0 ਹੋਰਥਾਂ।\n",
    "\n",
    "**Tidymodels** ਇੱਕ ਹੋਰ ਵਧੀਆ ਪੈਕੇਜ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: [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",
    "ਕਿਉਂਕਿ ਰੰਗ ਇੱਕ ਦਵਾਈਵ ਸ਼੍ਰੇਣੀ ਹੈ (ਚਿੱਟਾ ਜਾਂ ਨਹੀਂ), ਇਸਨੂੰ ਵਿਜੁਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ 'ਇੱਕ [ਖਾਸ ਪਹੁੰਚ](https://github.com/rstudio/cheatsheets/blob/main/data-visualization.pdf)' ਦੀ ਲੋੜ ਹੈ।\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": [
    "ਹੁਣ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਇੱਕ ਰੈਸਿਪੀ ਅਤੇ ਮਾਡਲ ਨਿਰਧਾਰਣ ਹੈ, ਸਾਨੂੰ ਇਹਨਾਂ ਨੂੰ ਇੱਕ ਆਬਜੈਕਟ ਵਿੱਚ ਇਕੱਠੇ ਕਰਨ ਦਾ ਤਰੀਕਾ ਲੱਭਣਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਡਾਟਾ ਨੂੰ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕਰੇਗਾ (ਪਿੱਛੇ ਪ੍ਰੈਪ + ਬੇਕ), ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕੀਤੇ ਡਾਟਾ 'ਤੇ ਮਾਡਲ ਨੂੰ ਫਿੱਟ ਕਰੇਗਾ ਅਤੇ ਸੰਭਾਵਿਤ ਪੋਸਟ-ਪ੍ਰੋਸੈਸਿੰਗ ਗਤੀਵਿਧੀਆਂ ਦੀ ਵੀ ਆਗਿਆ ਦੇਵੇਗਾ।\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) ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ `trained` ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਵਰਕਫਲੋ ਇੱਕ ਰਿਸੇਪੀ ਦਾ ਅਨੁਮਾਨ ਲਗਾਏਗਾ ਅਤੇ ਟ੍ਰੇਨਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਡਾਟਾ ਨੂੰ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕਰੇਗਾ, ਇਸ ਲਈ ਸਾਨੂੰ ਹੱਥੋਂ ਤਿਆਰ ਕਰਨ ਅਤੇ ਬੇਕ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੋਵੇਗੀ।\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 ਤੋਂ ਵੱਧ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਅਨੁਮਾਨਿਤ ਵਰਗ `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",
    "[`conf_mat()`](https://tidymodels.github.io/yardstick/reference/conf_mat.html) ਫੰਕਸ਼ਨ, ਜੋ yardstick ਤੋਂ ਹੈ, ਅਨੁਮਾਨਿਤ ਅਤੇ ਅਵਲੋਕਿਤ ਵਰਗਾਂ ਦੀ ਇਸ ਕ੍ਰਾਸ-ਟੈਬੂਲੇਸ਼ਨ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।\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",
    "| ਸੱਚ |\n",
    "|:-----:|\n",
    "\n",
    "|               |        |       |\n",
    "|---------------|--------|-------|\n",
    "| **ਪੇਸ਼ ਕੀਤੇ** | WHITE | ORANGE |\n",
    "| WHITE        | TP     | FP    |\n",
    "| ORANGE         | FN     | TN    |\n",
    "\n",
    "ਜਿਵੇਂ ਤੁਸੀਂ ਅੰਦਾਜ਼ਾ ਲਗਾਇਆ ਹੋਵੇਗਾ, ਇਹ ਵਧੀਆ ਹੈ ਕਿ `true positives` ਅਤੇ `true negatives` ਦੀ ਗਿਣਤੀ ਵਧੇਰੇ ਹੋਵੇ ਅਤੇ `false positives` ਅਤੇ `false negatives` ਦੀ ਗਿਣਤੀ ਘੱਟ ਹੋਵੇ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮਾਡਲ ਚੰਗਾ ਕੰਮ ਕਰਦਾ ਹੈ।\n",
    "\n",
    "ਕਨਫਿਊਜ਼ਨ ਮੈਟ੍ਰਿਕਸ ਮਦਦਗਾਰ ਹੈ ਕਿਉਂਕਿ ਇਹ ਹੋਰ ਮੈਟ੍ਰਿਕਸਾਂ ਨੂੰ ਜਨਮ ਦਿੰਦਾ ਹੈ ਜੋ ਸਾਨੂੰ ਕਲਾਸੀਫਿਕੇਸ਼ਨ ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਬਿਹਤਰ ਤਰੀਕੇ ਨਾਲ ਮਾਪਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ। ਆਓ ਕੁਝ ਮੈਟ੍ਰਿਕਸਾਂ ਨੂੰ ਸਮਝੀਏ:\n",
    "\n",
    "🎓 ਪ੍ਰਿਸੀਜ਼ਨ: `TP/(TP + FP)` ਜੋ ਪੇਸ਼ ਕੀਤੇ ਪਾਜ਼ਿਟਿਵਜ਼ ਵਿੱਚੋਂ ਅਸਲ ਪਾਜ਼ਿਟਿਵਜ਼ ਦਾ ਅਨੁਪਾਤ ਹੈ। ਇਸਨੂੰ [positive predictive value](https://en.wikipedia.org/wiki/Positive_predictive_value \"Positive predictive value\") ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।\n",
    "\n",
    "🎓 ਰੀਕਾਲ: `TP/(TP + FN)` ਜੋ ਅਸਲ ਪਾਜ਼ਿਟਿਵ ਨਮੂਨਿਆਂ ਵਿੱਚੋਂ ਪਾਜ਼ਿਟਿਵ ਨਤੀਜਿਆਂ ਦਾ ਅਨੁਪਾਤ ਹੈ। ਇਸਨੂੰ `sensitivity` ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।\n",
    "\n",
    "🎓 ਸਪੈਸਿਫਿਕਿਟੀ: `TN/(TN + FP)` ਜੋ ਅਸਲ ਨੈਗਟਿਵ ਨਮੂਨਿਆਂ ਵਿੱਚੋਂ ਨੈਗਟਿਵ ਨਤੀਜਿਆਂ ਦਾ ਅਨੁਪਾਤ ਹੈ।\n",
    "\n",
    "🎓 ਐਕ੍ਯੂਰੇਸੀ: `TP + TN/(TP + TN + FP + FN)` ਨਮੂਨੇ ਲਈ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਪੇਸ਼ ਕੀਤੇ ਲੇਬਲਾਂ ਦਾ ਪ੍ਰਤੀਸ਼ਤ।\n",
    "\n",
    "🎓 F ਮੀਜ਼ਰ: ਪ੍ਰਿਸੀਜ਼ਨ ਅਤੇ ਰੀਕਾਲ ਦਾ ਵਜ਼ਨੀ ਔਸਤ, ਜਿਸਦਾ ਸਭ ਤੋਂ ਵਧੀਆ 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 ਅਕਸ 'ਤੇ `True Positive Rate`/Sensitivity ਅਤੇ X ਅਕਸ 'ਤੇ `False Positive Rate`/1-Specificity ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ। ਇਸ ਤਰ੍ਹਾਂ, ਕਰਵ ਦੀ ਢਲਾਨ ਅਤੇ ਮਿਡਪੋਇੰਟ ਲਾਈਨ ਅਤੇ ਕਰਵ ਦੇ ਵਿਚਕਾਰ ਦੀ ਜਗ੍ਹਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀ ਹੈ: ਤੁਸੀਂ ਇੱਕ ਕਰਵ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਜਲਦੀ ਲਾਈਨ ਦੇ ਉੱਪਰ ਚੜ੍ਹੇ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਸ਼ੁਰੂ ਵਿੱਚ ਕੁਝ ਗਲਤ ਪਾਜ਼ਿਟਿਵ ਹਨ, ਅਤੇ ਫਿਰ ਲਾਈਨ ਠੀਕ ਢੰਗ ਨਾਲ ਉੱਪਰ ਚੜ੍ਹਦੀ ਹੈ।\n",
    "\n",
    "ਅੰਤ ਵਿੱਚ, ਆਓ `yardstick::roc_auc()` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹਕੀਕਤੀ Area Under the Curve ਦੀ ਗਣਨਾ ਕਰੀਏ। 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% ਸਹੀ ਪੇਸ਼ਗੂਈ ਕਰਦਾ ਹੈ ਤਾਂ ਉਸਦਾ AUC 1 ਹੋਵੇਗਾ; ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਮਾਡਲ *ਕਾਫ਼ੀ ਵਧੀਆ* ਹੈ।\n",
    "\n",
    "ਭਵਿੱਖ ਦੇ ਪਾਠਾਂ ਵਿੱਚ, ਜਿੱਥੇ ਕਲਾਸੀਫਿਕੇਸ਼ਨ ਬਾਰੇ ਸਿੱਖਿਆ ਜਾਵੇਗੀ, ਤੁਸੀਂ ਆਪਣੇ ਮਾਡਲ ਦੇ ਸਕੋਰਾਂ ਨੂੰ ਸੁਧਾਰਨ ਦੇ ਤਰੀਕੇ ਸਿੱਖੋਗੇ (ਜਿਵੇਂ ਕਿ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਅਸਮਤਲ ਡਾਟਾ ਨਾਲ ਨਿਪਟਣਾ)।\n",
    "\n",
    "## 🚀ਚੁਣੌਤੀ\n",
    "\n",
    "ਲੌਜਿਸਟਿਕ ਰਿਗਰੈਸ਼ਨ ਬਾਰੇ ਬਹੁਤ ਕੁਝ ਸਿੱਖਣ ਲਈ ਹੈ! ਪਰ ਸਿੱਖਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਅਨੁਭਵ ਕਰਨਾ ਹੈ। ਇੱਕ dataset ਲੱਭੋ ਜੋ ਇਸ ਕਿਸਮ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਉਚਿਤ ਹੋਵੇ ਅਤੇ ਇਸ ਨਾਲ ਇੱਕ ਮਾਡਲ ਬਣਾਓ। ਤੁਸੀਂ ਕੀ ਸਿੱਖਦੇ ਹੋ? ਸੁਝਾਅ: ਦਿਲਚਸਪ datasets ਲਈ [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ।\n",
    "\n",
    "## ਸਮੀਖਿਆ ਅਤੇ ਖੁਦ ਅਧਿਐਨ\n",
    "\n",
    "[Stanford ਤੋਂ ਇਸ ਪੇਪਰ](https://web.stanford.edu/~jurafsky/slp3/5.pdf) ਦੇ ਪਹਿਲੇ ਕੁਹਿ ਪੰਨੇ ਪੜ੍ਹੋ, ਜੋ ਲੌਜਿਸਟਿਕ ਰਿਗਰੈਸ਼ਨ ਦੇ ਕੁਝ ਵਿਆਵਹਾਰਿਕ ਉਪਯੋਗਾਂ ਬਾਰੇ ਹੈ। ਉਹ ਕੰਮਾਂ ਬਾਰੇ ਸੋਚੋ ਜੋ ਅਜੇ ਤੱਕ ਸਿੱਖੇ ਗਏ ਰਿਗਰੈਸ਼ਨ ਦੇ ਕਿਸਮਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਲਈ ਵਧੀਆ ਹੋ ਸਕਦੇ ਹਨ। ਕਿਹੜਾ ਤਰੀਕਾ ਸਭ ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰੇਗਾ?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**ਅਸਵੀਕਰਤੀ**:  \nਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀ ਹੋਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਣੀਕਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼, ਜੋ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਹੈ, ਨੂੰ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।\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-08-29T18:58:56+00:00",
   "source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
   "language_code": "pa"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}