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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistilise regressioonimudeli loomine - Õppetund 4\n",
    "\n",
    "![Logistilise vs. lineaarse regressiooni infograafik](../../../../../../translated_images/et/linear-vs-logistic.ba180bf95e7ee667.webp)\n",
    "\n",
    "#### **[Loengu-eelne viktoriin](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)**\n",
    "\n",
    "#### Sissejuhatus\n",
    "\n",
    "Selles viimases õppetunnis regressioonist, mis on üks põhilisi *klassikalisi* masinõppe tehnikaid, vaatame logistilist regressiooni. Seda tehnikat kasutatakse mustrite avastamiseks, et ennustada binaarseid kategooriaid. Kas see komm on šokolaad või mitte? Kas see haigus on nakkav või mitte? Kas see klient valib selle toote või mitte?\n",
    "\n",
    "Selles õppetunnis õpid:\n",
    "\n",
    "-   Logistilise regressiooni tehnikaid\n",
    "\n",
    "✅ Süvenda oma arusaamist selle regressioonitüübi kasutamisest selles [õppemoodulis](https://learn.microsoft.com/training/modules/introduction-classification-models/?WT.mc_id=academic-77952-leestott)\n",
    "\n",
    "## Eeldused\n",
    "\n",
    "Olles töötanud kõrvitsate andmetega, oleme nüüd piisavalt tuttavad, et mõista, et seal on üks binaarne kategooria, millega saame töötada: `Color`.\n",
    "\n",
    "Loome logistilise regressioonimudeli, et ennustada, arvestades mõningaid muutujaid, *mis värvi antud kõrvits tõenäoliselt on* (oranž 🎃 või valge 👻).\n",
    "\n",
    "> Miks räägime binaarsest klassifikatsioonist õppetunnis, mis käsitleb regressiooni? Ainult keelelise mugavuse huvides, kuna logistiline regressioon on [tegelikult klassifikatsioonimeetod](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), kuigi lineaarne. Õpi teisi viise andmete klassifitseerimiseks järgmises õppetundide grupis.\n",
    "\n",
    "Selle õppetunni jaoks vajame järgmisi pakette:\n",
    "\n",
    "-   `tidyverse`: [tidyverse](https://www.tidyverse.org/) on [R-pakettide kogum](https://www.tidyverse.org/packages), mis on loodud andmeteaduse kiiremaks, lihtsamaks ja lõbusamaks muutmiseks!\n",
    "\n",
    "-   `tidymodels`: [tidymodels](https://www.tidymodels.org/) raamistik on [pakettide kogum](https://www.tidymodels.org/packages/) modelleerimiseks ja masinõppeks.\n",
    "\n",
    "-   `janitor`: [janitor-pakett](https://github.com/sfirke/janitor) pakub lihtsaid tööriistu määrdunud andmete uurimiseks ja puhastamiseks.\n",
    "\n",
    "-   `ggbeeswarm`: [ggbeeswarm-pakett](https://github.com/eclarke/ggbeeswarm) pakub meetodeid mesilassülem-stiilis graafikute loomiseks, kasutades ggplot2.\n",
    "\n",
    "Sa saad need installida järgmiselt:\n",
    "\n",
    "`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"ggbeeswarm\"))`\n",
    "\n",
    "Alternatiivselt kontrollib allolev skript, kas sul on vajalikud paketid selle mooduli läbimiseks, ja installib need sinu jaoks, kui need puuduvad.\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": [
    "## **Määra küsimus**\n",
    "\n",
    "Meie eesmärkidel väljendame seda binaarselt: 'Valge' või 'Mitte valge'. Meie andmestikus on ka 'triibuline' kategooria, kuid selle esinemisi on vähe, seega me seda ei kasuta. See kaob niikuinii, kui eemaldame andmestikust tühjad väärtused.\n",
    "\n",
    "> 🎃 Lõbus fakt: mõnikord kutsume valgeid kõrvitsaid 'kummituskõrvitsateks'. Neid pole eriti lihtne nikerdada, mistõttu pole need nii populaarsed kui oranžid, kuid need näevad lahedad välja! Seega võiksime oma küsimuse ümber sõnastada ka nii: 'Kummitus' või 'Mitte kummitus'. 👻\n",
    "\n",
    "## **Logistilise regressiooni kohta**\n",
    "\n",
    "Logistiline regressioon erineb lineaarregressioonist, mida sa varem õppisid, mitmel olulisel viisil.\n",
    "\n",
    "#### **Binaarne klassifikatsioon**\n",
    "\n",
    "Logistiline regressioon ei paku samu võimalusi kui lineaarregressioon. Esimene annab ennustuse `binaarse kategooria` kohta (\"oranž või mitte oranž\"), samas kui viimane suudab ennustada `jätkuvaid väärtusi`, näiteks arvestades kõrvitsa päritolu ja koristusaega, *kui palju selle hind tõuseb*.\n",
    "\n",
    "![Infograafik autorilt Dasani Madipalli](../../../../../../translated_images/et/pumpkin-classifier.562771f104ad5436.webp)\n",
    "\n",
    "### Muud klassifikatsioonid\n",
    "\n",
    "On ka teisi logistilise regressiooni tüüpe, sealhulgas multinomiaalne ja ordinaalne:\n",
    "\n",
    "- **Multinomiaalne**, mis hõlmab rohkem kui ühte kategooriat - \"Oranž, Valge ja Triibuline\".\n",
    "\n",
    "- **Ordinaalne**, mis hõlmab järjestatud kategooriaid, kasulik, kui tahame tulemusi loogiliselt järjestada, näiteks meie kõrvitsad, mis on järjestatud kindla arvu suuruste järgi (mini, väike, keskmine, suur, väga suur, hiiglaslik).\n",
    "\n",
    "![Multinomiaalne vs ordinaalne regressioon](../../../../../../translated_images/et/multinomial-vs-ordinal.36701b4850e37d86.webp)\n",
    "\n",
    "#### **Muutujad EI PEA korreleeruma**\n",
    "\n",
    "Kas mäletad, kuidas lineaarregressioon töötas paremini, kui muutujad olid rohkem korreleeritud? Logistilise regressiooni puhul on vastupidi - muutujad ei pea olema joondatud. See sobib nende andmete jaoks, millel on üsna nõrgad korrelatsioonid.\n",
    "\n",
    "#### **Vaja on palju puhast andmestikku**\n",
    "\n",
    "Logistiline regressioon annab täpsemaid tulemusi, kui kasutad rohkem andmeid; meie väike andmestik pole selle ülesande jaoks optimaalne, seega pea seda meeles.\n",
    "\n",
    "✅ Mõtle, millised andmetüübid sobiksid hästi logistilisele regressioonile\n",
    "\n",
    "## Harjutus - andmete korrastamine\n",
    "\n",
    "Kõigepealt puhasta andmed veidi, eemaldades tühjad väärtused ja valides ainult mõned veerud:\n",
    "\n",
    "1. Lisa järgmine kood:\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": [
    "Saate alati oma uuele andmeraamile pilgu heita, kasutades funktsiooni [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) järgmiselt:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "pumpkins_select %>% \n",
    "  glimpse()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kinnitame, et tegeleme tõepoolest binaarse klassifikatsiooni probleemiga:\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": [
    "### Visualiseerimine - kategooriline graafik\n",
    "Praeguseks olete kõrvitsate andmed uuesti laaditud ja puhastanud, et säilitada andmestik, mis sisaldab mõningaid muutujaid, sealhulgas Värv. Visualiseerime andmestikku märkmikus, kasutades ggplot teeki.\n",
    "\n",
    "Ggplot teek pakub häid viise andmete visualiseerimiseks. Näiteks saate võrrelda andmete jaotusi iga Sordi ja Värvi jaoks kategoorilises graafikus.\n",
    "\n",
    "1. Looge selline graafik, kasutades geombar funktsiooni, meie kõrvitsate andmete põhjal, ja määrake värvikaardistus iga kõrvitsakategooria jaoks (oranž või valge):\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": [
    "Andmeid jälgides näete, kuidas värviandmed on seotud sordiga.\n",
    "\n",
    "✅ Selle kategoorilise graafiku põhjal, milliseid huvitavaid uurimissuundi võite ette kujutada?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Andmete eeltöötlus: tunnuste kodeerimine\n",
    "\n",
    "Meie kõrvitsate andmestik sisaldab stringiväärtusi kõigis veergudes. Kategooriliste andmetega töötamine on inimestele intuitiivne, kuid masinatele mitte. Masinõppe algoritmid töötavad hästi numbritega. Seetõttu on kodeerimine andmete eeltöötluse faasis väga oluline samm, kuna see võimaldab meil muuta kategoorilised andmed numbrilisteks, kaotamata seejuures mingit teavet. Hea kodeerimine aitab luua hea mudeli.\n",
    "\n",
    "Tunnuste kodeerimiseks on kaks peamist kodeerijatüüpi:\n",
    "\n",
    "1. Järjestuskodeerija: see sobib hästi järjestuslikele muutujatele, mis on kategoorilised muutujad, kus andmed järgivad loogilist järjestust, nagu näiteks `item_size` veerg meie andmestikus. See loob kaardistuse, kus iga kategooria esitatakse numbriga, mis vastab kategooria järjestusele veerus.\n",
    "\n",
    "2. Kategooriakodeerija: see sobib hästi nimelistele muutujatele, mis on kategoorilised muutujad, kus andmed ei järgi loogilist järjestust, nagu kõik tunnused peale `item_size` meie andmestikus. See on ühekuumkodeerimine (one-hot encoding), mis tähendab, et iga kategooria esitatakse binaarse veeruga: kodeeritud muutuja väärtus on 1, kui kõrvits kuulub vastavasse sordirühma, ja 0, kui mitte.\n",
    "\n",
    "Tidymodels pakub veel üht kasulikku paketti: [recipes](https://recipes.tidymodels.org/) – paketti andmete eeltöötluseks. Me määratleme `recipe`, mis täpsustab, et kõik ennustajate veerud tuleks kodeerida täisarvudeks, `prep`-ime selle, et hinnata vajalikke koguseid ja statistikat mis tahes toimingute jaoks, ning lõpuks `bake`-ime, et rakendada arvutused uutele andmetele.\n",
    "\n",
    "> Tavaliselt kasutatakse recipes-paketti mudeli eeltöötluseks, kus see määratleb, millised sammud tuleks andmestikule rakendada, et see oleks mudeldamiseks valmis. Sel juhul on **väga soovitatav**, et kasutaksite `workflow()`-i, selle asemel et käsitsi hinnata retsepti prep ja bake abil. Näeme seda kõike peagi.\n",
    ">\n",
    "> Kuid praegu kasutame recipes + prep + bake, et täpsustada, millised sammud tuleks andmestikule rakendada, et see oleks valmis andmeanalüüsiks, ja seejärel ekstraheerime eeltöödeldud andmed koos rakendatud sammudega.\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": [
    "✅ Millised on ordinal encoderi kasutamise eelised Item Size veeru puhul?\n",
    "\n",
    "### Analüüsi muutujate vahelisi seoseid\n",
    "\n",
    "Nüüd, kui oleme oma andmed eeltöötlenud, saame analüüsida tunnuste ja märgise vahelisi seoseid, et mõista, kui hästi mudel suudab tunnuste põhjal märgist ennustada. Parim viis sellise analüüsi tegemiseks on andmete visualiseerimine. \n",
    "Kasutame taas ggplot geom_boxplot_ funktsiooni, et kuvada seoseid Item Size, Variety ja Color vahel kategoorilises graafikus. Andmete paremaks visualiseerimiseks kasutame kodeeritud Item Size veergu ja kodeerimata Variety veergu.\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": [
    "#### Kasuta hajuvusdiagrammi\n",
    "\n",
    "Kuna värv on binaarne kategooria (valge või mitte), vajab see 'visualiseerimiseks [spetsiaalset lähenemist](https://github.com/rstudio/cheatsheets/blob/main/data-visualization.pdf)'.\n",
    "\n",
    "Proovi `hajuvusdiagrammi`, et näidata värvi jaotust vastavalt item_size'ile.\n",
    "\n",
    "Kasutame [ggbeeswarm paketti](https://github.com/eclarke/ggbeeswarm), mis pakub meetodeid mesilassülem-stiilis diagrammide loomiseks ggplot2 abil. Mesilassülemdiagrammid on viis punktide kuvamiseks, mis muidu kattuksid, nii et need paigutatakse üksteise kõrvale.\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üüd, kui meil on aimu värvi binaarsete kategooriate ja suurema suuruste grupi vahelisest seosest, uurime logistilist regressiooni, et määrata kindlaks tõenäoline kõrvitsa värv.\n",
    "\n",
    "## Loo oma mudel\n",
    "\n",
    "Vali muutujad, mida soovid oma klassifitseerimismudelis kasutada, ja jaga andmed treening- ja testkomplektideks. [rsample](https://rsample.tidymodels.org/), Tidymodelsi pakett, pakub tõhusat andmete jagamise ja taasvalimi võtmise infrastruktuuri:\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": [
    "🙌 Oleme nüüd valmis mudelit treenima, sobitades treeningandmed treeningmärgisega (värv).\n",
    "\n",
    "Alustame retsepti loomisega, mis määrab kindlaks andmete eeltöötluse sammud, et need modelleerimiseks ette valmistada, näiteks: kategooriliste muutujate kodeerimine täisarvudeks. Täpselt nagu `baked_pumpkins`, loome `pumpkins_recipe`, kuid ei kasuta `prep` ega `bake`, kuna see lisatakse töövoogu, mida näete mõne sammu pärast.\n",
    "\n",
    "Tidymodelsis on mitmeid viise logistilise regressioonimudeli määramiseks. Vaadake `?logistic_reg()`. Praegu määrame logistilise regressioonimudeli vaikimisi `stats::glm()` mootoriga.\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üüd, kui meil on retsept ja mudeli spetsifikatsioon, peame leidma viisi, kuidas need kokku koondada objektiks, mis esmalt eeltöötleb andmed (taustal prep+bake), sobitab mudeli eeltöödeldud andmetele ja võimaldab ka võimalikke järelprotsessimise tegevusi.\n",
    "\n",
    "Tidymodelsis nimetatakse seda mugavat objekti [`workflow`](https://workflows.tidymodels.org/), mis hoiab mugavalt sinu modelleerimise komponente.\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": [
    "Pärast seda, kui töövoog on *määratletud*, saab mudelit `treenida` kasutades funktsiooni [`fit()`](https://tidymodels.github.io/parsnip/reference/fit.html). Töövoog hindab retsepti ja eeltöötleb andmed enne treenimist, nii et me ei pea seda käsitsi tegema, kasutades prep ja 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": [
    "Mudeli väljund näitab treeningu käigus õpitud koefitsiente.\n",
    "\n",
    "Nüüd, kui oleme mudeli treeningandmete abil treeninud, saame teha prognoose testandmete põhjal, kasutades [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html). Alustame mudeli kasutamisest, et ennustada meie testkomplekti silte ja iga sildi tõenäosusi. Kui tõenäosus on suurem kui 0,5, on ennustatav klass `WHITE`, vastasel juhul `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": [
    "Väga tore! See annab rohkem ülevaadet, kuidas logistiline regressioon töötab.\n",
    "\n",
    "### Parem arusaamine segadusmaatriksi kaudu\n",
    "\n",
    "Iga ennustuse võrdlemine vastava \"tõelise\" tegeliku väärtusega ei ole eriti tõhus viis, et määrata, kui hästi mudel ennustab. Õnneks on Tidymodelsil veel mõned nipid varuks: [`yardstick`](https://yardstick.tidymodels.org/) - pakett, mida kasutatakse mudelite tõhususe mõõtmiseks jõudlusmõõdikute abil.\n",
    "\n",
    "Üks klassifitseerimisprobleemidega seotud jõudlusmõõdik on [`segadusmaatriks`](https://wikipedia.org/wiki/Confusion_matrix). Segadusmaatriks kirjeldab, kui hästi klassifitseerimismudel toimib. Segadusmaatriks koostab tabeli, mis näitab, kui palju näiteid igas klassis mudel õigesti klassifitseeris. Meie puhul näitab see, kui palju oranže kõrvitsaid klassifitseeriti oranžiks ja kui palju valgeid kõrvitsaid klassifitseeriti valgeks; segadusmaatriks näitab ka, kui palju klassifitseeriti **valedesse** kategooriatesse.\n",
    "\n",
    "Yardsticki [**`conf_mat()`**](https://tidymodels.github.io/yardstick/reference/conf_mat.html) funktsioon arvutab selle vaatluste ja ennustatud klasside risttabeli.\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": [
    "Tõlgime segadusmaatriksi. Meie mudelil palutakse klassifitseerida kõrvitsad kahe binaarse kategooria vahel: kategooria `valge` ja kategooria `mitte-valge`.\n",
    "\n",
    "- Kui teie mudel ennustab kõrvitsa valgeks ja see kuulub tegelikult kategooriasse 'valge', nimetame seda `tõeliseks positiivseks`, mida näitab ülemine vasakpoolne number.\n",
    "\n",
    "- Kui teie mudel ennustab kõrvitsa mitte-valgeks ja see kuulub tegelikult kategooriasse 'valge', nimetame seda `valeks negatiivseks`, mida näitab alumine vasakpoolne number.\n",
    "\n",
    "- Kui teie mudel ennustab kõrvitsa valgeks ja see kuulub tegelikult kategooriasse 'mitte-valge', nimetame seda `valeks positiivseks`, mida näitab ülemine parempoolne number.\n",
    "\n",
    "- Kui teie mudel ennustab kõrvitsa mitte-valgeks ja see kuulub tegelikult kategooriasse 'mitte-valge', nimetame seda `tõeliseks negatiivseks`, mida näitab alumine parempoolne number.\n",
    "\n",
    "| Tõde |\n",
    "|:-----:|\n",
    "\n",
    "|               |        |       |\n",
    "|---------------|--------|-------|\n",
    "| **Ennustatud** | VALGE | ORANŽ |\n",
    "| VALGE         | TP     | FP    |\n",
    "| ORANŽ         | FN     | TN    |\n",
    "\n",
    "Nagu võite arvata, on eelistatav, et tõeliste positiivsete ja tõeliste negatiivsete arv oleks suurem ning valede positiivsete ja valede negatiivsete arv väiksem, mis viitab sellele, et mudel toimib paremini.\n",
    "\n",
    "Segadusmaatriks on kasulik, kuna see annab aluse teistele mõõdikutele, mis aitavad meil paremini hinnata klassifikatsioonimudeli jõudlust. Vaatame mõningaid neist:\n",
    "\n",
    "🎓 Täpsus: `TP/(TP + FP)` määratletud kui ennustatud positiivsete osakaal, mis on tegelikult positiivsed. Tuntud ka kui [positiivne ennustusväärtus](https://en.wikipedia.org/wiki/Positive_predictive_value \"Positive predictive value\").\n",
    "\n",
    "🎓 Tundlikkus: `TP/(TP + FN)` määratletud kui positiivsete tulemuste osakaal tegelikult positiivsete näidiste arvust. Tuntud ka kui `sensitiivsus`.\n",
    "\n",
    "🎓 Spetsiifilisus: `TN/(TN + FP)` määratletud kui negatiivsete tulemuste osakaal tegelikult negatiivsete näidiste arvust.\n",
    "\n",
    "🎓 Täpsus: `TP + TN/(TP + TN + FP + FN)` Etikettide ennustamise täpsuse protsent näidise kohta.\n",
    "\n",
    "🎓 F-mõõdik: Täpsuse ja tundlikkuse kaalutud keskmine, kus parim väärtus on 1 ja halvim 0.\n",
    "\n",
    "Arvutame need mõõdikud!\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": [
    "## Visualiseeri selle mudeli ROC kõver\n",
    "\n",
    "Teeme veel ühe visualiseerimise, et näha niinimetatud [`ROC kõver`](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 kõveraid kasutatakse sageli klassifikaatori väljundi analüüsimiseks, võrreldes tõelisi positiivseid ja valepositiivseid tulemusi. ROC kõveratel on tavaliselt Y-teljel `True Positive Rate`/tundlikkus ja X-teljel `False Positive Rate`/1-spetsiifilisus. Seega on kõvera järskus ja vahe keskjoone ning kõvera vahel olulised: soovitav on kõver, mis kiiresti tõuseb ja liigub üle joone. Meie puhul on alguses valepositiivseid tulemusi, kuid seejärel kõver tõuseb ja liigub korralikult üle.\n",
    "\n",
    "Lõpuks kasutame `yardstick::roc_auc()`, et arvutada kõvera alune pindala (Area Under the Curve). Üks viis AUC-i tõlgendamiseks on vaadelda seda kui tõenäosust, et mudel järjestab juhusliku positiivse näite kõrgemale kui juhusliku negatiivse näite.\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": [
    "Tulemus on umbes `0.975`. Kuna AUC jääb vahemikku 0 kuni 1, siis soovite saada kõrget skoori, sest mudel, mis teeb 100% täpseid ennustusi, saavutab AUC väärtuse 1; antud juhul on mudel *üsna hea*.\n",
    "\n",
    "Tulevastes klassifikatsiooni tundides õpite, kuidas oma mudeli skoori parandada (näiteks tasakaalustamata andmetega tegelemine selles olukorras).\n",
    "\n",
    "## 🚀Väljakutse\n",
    "\n",
    "Logistilise regressiooni kohta on palju rohkem avastada! Kuid parim viis õppimiseks on katsetamine. Leidke andmestik, mis sobib selliseks analüüsiks, ja looge selle põhjal mudel. Mida te õpite? vihje: proovige [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets), et leida huvitavaid andmestikke.\n",
    "\n",
    "## Ülevaade ja iseseisev õppimine\n",
    "\n",
    "Lugege [Stanfordi artikli](https://web.stanford.edu/~jurafsky/slp3/5.pdf) esimesi lehekülgi, kus käsitletakse logistilise regressiooni praktilisi kasutusviise. Mõelge ülesannetele, mis sobivad paremini ühe või teise regressiooni tüübi jaoks, mida oleme siiani uurinud. Mis toimiks kõige paremini?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n---\n\n**Lahtiütlus**:  \nSee dokument on tõlgitud AI tõlketeenuse [Co-op Translator](https://github.com/Azure/co-op-translator) abil. Kuigi püüame tagada täpsust, palume arvestada, et automaatsed tõlked võivad sisaldada vigu või ebatäpsusi. Algne dokument selle algses keeles tuleks pidada autoriteetseks allikaks. Olulise teabe puhul soovitame kasutada professionaalset inimtõlget. Me ei vastuta selle tõlke kasutamisest tulenevate arusaamatuste või valesti tõlgenduste eest.\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-10-11T12:18:03+00:00",
   "source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
   "language_code": "et"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}