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.
678 lines
53 KiB
678 lines
53 KiB
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## ലോജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക - പാഠം 4\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"#### **[പ്രീ-ലെക്ചർ ക്വിസ്](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)**\n",
|
|
"\n",
|
|
"#### പരിചയം\n",
|
|
"\n",
|
|
"റെഗ്രഷൻ എന്ന അടിസ്ഥാന *ക്ലാസിക്* എംഎൽ സാങ്കേതികവിദ്യകളിൽ ഒന്ന് ആയ ലോജിസ്റ്റിക് റെഗ്രഷനെക്കുറിച്ച് ഈ അവസാന പാഠത്തിൽ നാം നോക്കാം. ബൈനറി വിഭാഗങ്ങൾ പ്രവചിക്കാൻ ഈ സാങ്കേതികവിദ്യ ഉപയോഗിക്കും. ഈ കാൻഡി ചോക്ലേറ്റ് ആണോ അല്ലയോ? ഈ രോഗം സംക്രമണശീലമാണോ അല്ലയോ? ഈ ഉപഭോക്താവ് ഈ ഉൽപ്പന്നം തിരഞ്ഞെടുക്കുമോ അല്ലയോ?\n",
|
|
"\n",
|
|
"ഈ പാഠത്തിൽ നിങ്ങൾ പഠിക്കാനിരിക്കുന്നതെന്തെന്നാൽ:\n",
|
|
"\n",
|
|
"- ലോജിസ്റ്റിക് റെഗ്രഷനുള്ള സാങ്കേതികവിദ്യകൾ\n",
|
|
"\n",
|
|
"✅ ഈ തരത്തിലുള്ള റെഗ്രഷനുമായി പ്രവർത്തിക്കുന്നതിൽ നിങ്ങളുടെ മനസ്സിലാക്കൽ കൂടുതൽ ആഴപ്പെടുത്തുക ഈ [Learn module](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 ഉപയോഗിച്ച് ബീസ്വാർം-സ്റ്റൈൽ പ്ലോട്ടുകൾ സൃഷ്ടിക്കാൻ മാർഗങ്ങൾ നൽകുന്നു.\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",
|
|
"\n",
|
|
"\n",
|
|
"### മറ്റ് ക്ലാസിഫിക്കേഷനുകൾ\n",
|
|
"\n",
|
|
"മൾട്ടിനോമിയൽ, ഓർഡിനൽ എന്നിവ ഉൾപ്പെടെ മറ്റ് തരത്തിലുള്ള ലോജിസ്റ്റിക് റെഗ്രഷനുകളും ഉണ്ട്:\n",
|
|
"\n",
|
|
"- **മൾട്ടിനോമിയൽ**, ഇതിൽ ഒന്നിലധികം വിഭാഗങ്ങൾ ഉണ്ടാകാം - \"ഓറഞ്ച്, വെളുത്ത, സ്ട്രൈപ്പഡ്\".\n",
|
|
"\n",
|
|
"- **ഓർഡിനൽ**, ഇത് ക്രമീകരിച്ച വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു, ഉദാഹരണത്തിന് നമുക്ക് ഫലം ലജിക്കൽ ആയി ക്രമീകരിക്കേണ്ടതുണ്ടെങ്കിൽ, നമ്മുടെ പംപ്കിനുകൾ ചെറിയ, ചെറിയ, മധ്യ, വലിയ, എക്സ് എൽ, ഡബിൾ എക്സ് എൽ എന്നിങ്ങനെ ക്രമീകരിച്ചിരിക്കുന്നതുപോലെ.\n",
|
|
"\n",
|
|
"\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": [
|
|
"### Visualization - categorical plot\n",
|
|
"ഇപ്പോൾ നിങ്ങൾ പംപ്കിൻ ഡാറ്റ വീണ്ടും ലോഡ് ചെയ്ത് ചില വേരിയബിളുകൾ ഉൾപ്പെടുന്ന ഒരു ഡാറ്റാസെറ്റ് സംരക്ഷിക്കാൻ ക്ലീൻ ചെയ്തിട്ടുണ്ട്, അതിൽ Color ഉൾപ്പെടുന്നു. നോട്ട്ബുക്കിൽ ggplot ലൈബ്രറി ഉപയോഗിച്ച് ഡാറ്റാഫ്രെയിം ദൃശ്യവൽക്കരിക്കാം.\n",
|
|
"\n",
|
|
"ggplot ലൈബ്രറി നിങ്ങളുടെ ഡാറ്റ ദൃശ്യവൽക്കരിക്കാൻ ചില നല്ല മാർഗങ്ങൾ നൽകുന്നു. ഉദാഹരണത്തിന്, ഓരോ Variety, Color എന്നിവയുടെ ഡാറ്റയുടെ വിതരണങ്ങൾ categorical plot-ൽ താരതമ്യം ചെയ്യാം.\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": [
|
|
"✅ Item Size കോളത്തിനായി ഓർഡിനൽ എൻകോഡർ ഉപയോഗിക്കുന്നതിന്റെ ഗുണങ്ങൾ എന്തെല്ലാം?\n",
|
|
"\n",
|
|
"### വ്യത്യസ്ത വേരിയബിളുകൾ തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്യുക\n",
|
|
"\n",
|
|
"ഇപ്പോൾ നാം നമ്മുടെ ഡാറ്റ പ്രീ-പ്രോസസ് ചെയ്തതിനുശേഷം, ഫീച്ചറുകളും ലേബലും തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്ത്, ഫീച്ചറുകൾ നൽകിയാൽ മോഡൽ ലേബൽ എത്രത്തോളം നന്നായി പ്രവചിക്കാനാകും എന്ന് മനസിലാക്കാം. ഈ തരത്തിലുള്ള വിശകലനം നടത്താനുള്ള ഏറ്റവും നല്ല മാർഗം ഡാറ്റ പ്ലോട്ട് ചെയ്യുകയാണ്. \n",
|
|
"Item Size, Variety, Color എന്നിവ തമ്മിലുള്ള ബന്ധങ്ങൾ കാറ്റഗോറിയൽ പ്ലോട്ടിൽ കാണിക്കാൻ നാം വീണ്ടും ggplot-ന്റെ geom_boxplot_ ഫംഗ്ഷൻ ഉപയോഗിക്കും. ഡാറ്റയെ കൂടുതൽ നല്ല രീതിയിൽ പ്ലോട്ട് ചെയ്യാൻ, എൻകോഡുചെയ്ത Item Size കോളവും എൻകോഡുചെയ്യാത്ത Variety കോളവും ഉപയോഗിക്കും.\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",
|
|
"Color ഒരു ബൈനറി വിഭാഗമാണെന്നതിനാൽ (White അല്ലെങ്കിൽ Not), visualization-ന് 'a [specialized approach](https://github.com/rstudio/cheatsheets/blob/main/data-visualization.pdf)' ആവശ്യമുണ്ട്.\n",
|
|
"\n",
|
|
"item_size-നോട് ബന്ധപ്പെട്ട് color-ന്റെ വിതരണത്തെ കാണിക്കാൻ `swarm plot` പരീക്ഷിക്കുക.\n",
|
|
"\n",
|
|
"നാം [ggbeeswarm package](https://github.com/eclarke/ggbeeswarm) ഉപയോഗിക്കും, ഇത് ggplot2 ഉപയോഗിച്ച് beeswarm-ശൈലിയിൽ പ്ലോട്ടുകൾ സൃഷ്ടിക്കാൻ മാർഗങ്ങൾ നൽകുന്നു. Beeswarm പ്ലോട്ടുകൾ സാധാരണയായി ഒതുക്കിയിരിക്കും പോയിന്റുകൾ പരസ്പരം അടുത്ത് വീഴാതെ പക്കൽ വീഴാൻ ഉപയോഗിക്കുന്ന ഒരു രീതിയാണ്.\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",
|
|
"നിങ്ങൾ നിങ്ങളുടെ വർഗ്ഗീകരണ മോഡലിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ചാരങ്ങൾ തിരഞ്ഞെടുക്കുകയും ഡാറ്റ പരിശീലനവും പരിശോധനാ സെറ്റുകളായി വിഭജിക്കുകയും ചെയ്യുക. Tidymodels-ൽ ഉള്ള ഒരു പാക്കേജ് ആയ [rsample](https://rsample.tidymodels.org/) കാര്യക്ഷമമായ ഡാറ്റ വിഭജനം, റീസാമ്പ്ലിംഗ് എന്നിവയ്ക്ക് അടിസ്ഥാന സൗകര്യം നൽകുന്നു:\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) ഫംഗ്ഷൻ ഉപയോഗിച്ച് `പരിശീലിപ്പിക്കപ്പെടാം`. പരിശീലനത്തിന് മുമ്പ് വർക്ക്ഫ്ലോ ഒരു റെസിപ്പി അളക്കുകയും ഡാറ്റ പ്രീപ്രോസസ് ചെയ്യുകയും ചെയ്യും, അതിനാൽ 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": [
|
|
"Translation for chunk 1 of 'lesson_4-R.ipynb' skipped due to timeout.\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' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `true positive` (സത്യം പോസിറ്റീവ്) എന്ന് വിളിക്കുന്നു, മുകളിൽ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
|
|
"\n",
|
|
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയല്ലാത്തതായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'white' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `false negative` (തെറ്റായ നെഗറ്റീവ്) എന്ന് വിളിക്കുന്നു, താഴെ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
|
|
"\n",
|
|
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'not-white' വിഭാഗത്തിൽപ്പെട്ടതാണെങ്കിൽ, അത് `false positive` (തെറ്റായ പോസിറ്റീവ്) എന്ന് വിളിക്കുന്നു, മുകളിൽ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു.\n",
|
|
"\n",
|
|
"- നിങ്ങളുടെ മോഡൽ ഒരു പംപ്കിൻ വെള്ളയല്ലാത്തതായി പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ '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",
|
|
"നിങ്ങൾക്ക് തോന്നിയതുപോലെ, സത്യം പോസിറ്റീവുകളും സത്യം നെഗറ്റീവുകളും കൂടുതലായിരിക്കണം, തെറ്റായ പോസിറ്റീവുകളും തെറ്റായ നെഗറ്റീവുകളും കുറവായിരിക്കണം, ഇത് മോഡൽ മികച്ച പ്രകടനം നടത്തുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.\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 curve`](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`/സെൻസിറ്റിവിറ്റി, X അക്ഷത്തിൽ `False Positive Rate`/1-സ്പെസിഫിസിറ്റി കാണിക്കുന്നു. അതിനാൽ, വക്രത്തിന്റെ കൂറ്റൻതയും മധ്യരേഖയും വക്രത്തിനിടയിലെ ഇടവും പ്രധാനമാണ്: നിങ്ങൾക്ക് വക്രം വേഗത്തിൽ മുകളിൽ കയറി രേഖയെ മറികടക്കുന്നത് വേണം. നമ്മുടെ കേസിൽ, തുടക്കത്തിൽ തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ടാകുന്നു, പിന്നീട് രേഖ ശരിയായി മുകളിൽ കയറി മറികടക്കുന്നു.\n",
|
|
"\n",
|
|
"അവസാനമായി, യഥാർത്ഥ Area Under the Curve കണക്കാക്കാൻ `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% ശരിയായ പ്രവചനങ്ങൾ ചെയ്യുന്ന മോഡലിന് AUC 1 ആയിരിക്കും; ഈ സാഹചര്യത്തിൽ, മോഡൽ *ചെറുതല്ലാത്തത്* ആണ്.\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ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് കരുതേണ്ടതാണ്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.\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:46:02+00:00",
|
|
"source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
|
|
"language_code": "ml"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 1
|
|
} |