{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## లాజిస్టిక్ రిగ్రెషన్ మోడల్ నిర్మాణం - పాఠం 4\n",
    "\n",
    "![లాజిస్టిక్ vs. లీనియర్ రిగ్రెషన్ ఇన్ఫోగ్రాఫిక్](../../../../../../translated_images/te/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",
    "✅ ఈ రకమైన రిగ్రెషన్‌తో పని చేయడంపై మీ అవగాహనను ఈ [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",
    "![Infographic by Dasani Madipalli](../../../../../../translated_images/te/pumpkin-classifier.562771f104ad5436.webp)\n",
    "\n",
    "### ఇతర వర్గీకరణలు\n",
    "\n",
    "మల్టినోమియల్ మరియు ఆర్డినల్ సహా ఇతర రకాల లాజిస్టిక్ రిగ్రెషన్ ఉన్నాయి:\n",
    "\n",
    "- **మల్టినోమియల్**, ఇది ఒక కంటే ఎక్కువ వర్గాలు కలిగి ఉంటుంది - \"ఆరెంజ్, తెల్ల, మరియు పట్టుదల\".\n",
    "\n",
    "- **ఆర్డినల్**, ఇది క్రమబద్ధమైన వర్గాలను కలిగి ఉంటుంది, మన ఫలితాలను తార్కికంగా క్రమబద్ధీకరించాలనుకుంటే ఉపయోగపడుతుంది, ఉదాహరణకు మన పండ్లు పరిమాణాల పరిమిత సంఖ్య (మినీ, చిన్న, మధ్య, పెద్ద, ఎక్స్ ఎల్, ఎక్స్ ఎక్స్ ఎల్) ద్వారా క్రమబద్ధీకరించబడ్డాయి.\n",
    "\n",
    "![Multinomial vs ordinal regression](../../../../../../translated_images/te/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 మరియు 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 అవుతుంది ఆ పంప్కిన్ ఆ వేరియటీకి చెందితే, లేకపోతే 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",
    "రంగు మరియు item_size సంబంధిత పంపిణీని చూపించడానికి `swarm plot` ప్రయత్నించండి.\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) ఫంక్షన్ ఉపయోగించి `శిక్షణ` ఇవ్వవచ్చు. వర్క్‌ఫ్లో ఒక రెసిపీని అంచనా వేస్తుంది మరియు శిక్షణకు ముందు డేటాను ప్రీప్రాసెస్ చేస్తుంది, కాబట్టి మనం 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 కంటే ఎక్కువగా ఉన్నప్పుడు, అంచనా తరగతి `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 అక్షంపై `True Positive Rate`/సెన్సిటివిటీ మరియు X అక్షంపై `False Positive Rate`/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% సరిగ్గా అంచనా వేయగల మోడల్‌కు 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:39:14+00:00",
   "source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
   "language_code": "te"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}