{ "nbformat": 4, "nbformat_minor": 2, "metadata": { "colab": { "name": "lesson_2-R.ipynb", "provenance": [], "collapsed_sections": [], "toc_visible": true }, "kernelspec": { "name": "ir", "display_name": "R" }, "language_info": { "name": "R" }, "coopTranslator": { "original_hash": "f3c335f9940cfd76528b3ef918b9b342", "translation_date": "2025-12-19T16:36:33+00:00", "source_file": "2-Regression/2-Data/solution/R/lesson_2-R.ipynb", "language_code": "kn" } }, "cells": [ { "cell_type": "markdown", "source": [ "# ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ: ಡೇಟಾವನ್ನು ಸಿದ್ಧಪಡಿಸಿ ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ\n", "\n", "## **ಕುಂಬಳಕಾಯಿ ಗಾಗಿ ರೇಖೀಯ ರಿಗ್ರೆಶನ್ - ಪಾಠ 2**\n", "#### ಪರಿಚಯ\n", "\n", "ನೀವು ಈಗ Tidymodels ಮತ್ತು Tidyverse ಬಳಸಿ ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿ ನಿರ್ಮಾಣವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅಗತ್ಯವಿರುವ ಸಾಧನಗಳೊಂದಿಗೆ ಸಜ್ಜಾಗಿದ್ದೀರಿ, ನೀವು ನಿಮ್ಮ ಡೇಟಾದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ. ನೀವು ಡೇಟಾ ಜೊತೆ ಕೆಲಸಮಾಡಿ ML ಪರಿಹಾರಗಳನ್ನು ಅನ್ವಯಿಸುವಾಗ, ನಿಮ್ಮ ಡೇಟಾಸೆಟ್ನ ಸಾಧ್ಯತೆಗಳನ್ನು ಸರಿಯಾಗಿ ಅನ್ಲಾಕ್ ಮಾಡಲು ಸರಿಯಾದ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳುವುದು ಬಹಳ ಮುಖ್ಯ.\n", "\n", "ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಕಲಿಯುವಿರಿ:\n", "\n", "- ನಿಮ್ಮ ಮಾದರಿ ನಿರ್ಮಾಣಕ್ಕಾಗಿ ಡೇಟಾವನ್ನು ಹೇಗೆ ಸಿದ್ಧಪಡಿಸುವುದು.\n", "\n", "- ಡೇಟಾ ದೃಶ್ಯೀಕರಣಕ್ಕಾಗಿ `ggplot2` ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು.\n", "\n", "ನೀವು ಉತ್ತರಿಸಬೇಕಾದ ಪ್ರಶ್ನೆ ಯಾವ ರೀತಿಯ ML ಆಲ್ಗಾರಿದಮ್ಗಳನ್ನು ನೀವು ಬಳಸಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತದೆ. ಮತ್ತು ನೀವು ಪಡೆಯುವ ಉತ್ತರದ ಗುಣಮಟ್ಟವು ನಿಮ್ಮ ಡೇಟಾದ ಸ್ವಭಾವದ ಮೇಲೆ ಬಹಳ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ.\n", "\n", "ಪ್ರಾಯೋಗಿಕ ವ್ಯಾಯಾಮದ ಮೂಲಕ ಇದನ್ನು ನೋಡೋಣ.\n", "\n", "\n", "
\n",
"
\n",
"
\n",
"\n",
"> ಪುನಃಸ್ಮರಣೆ: ಪೈಪ್ ಆಪರೇಟರ್ (`%>%`) ಲಾಜಿಕಲ್ ಕ್ರಮದಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಒಂದು ವಸ್ತುವನ್ನು ಮುಂದಕ್ಕೆ ಫಂಕ್ಷನ್ ಅಥವಾ ಕರೆ ಅಭಿವ್ಯಕ್ತಿಗೆ ಹಂಚಿಕೊಡುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್ನಲ್ಲಿ ಪೈಪ್ ಆಪರೇಟರ್ ಅನ್ನು \"ಮತ್ತು ನಂತರ\" ಎಂದು ಹೇಳುವುದಾಗಿ ಭಾವಿಸಬಹುದು.\n"
],
"metadata": {
"id": "REWcIv9yX29v"
}
},
{
"cell_type": "markdown",
"source": [
"## 2. ಕಾಣೆಯಾದ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸಿ\n",
"\n",
"ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಎದುರಿಸಬೇಕಾದ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಅಪೂರ್ಣ ಅಥವಾ ಕಾಣೆಯಾದ ಡೇಟಾ. R ಕಾಣೆಯಾದ ಅಥವಾ ಅಜ್ಞಾತ ಮೌಲ್ಯಗಳನ್ನು ವಿಶೇಷ ಸೆಂಟಿನೆಲ್ ಮೌಲ್ಯದಿಂದ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ: `NA` (ಲಭ್ಯವಿಲ್ಲ).\n",
"\n",
"ಆದ್ದರಿಂದ ಡೇಟಾ ಫ್ರೇಮ್ನಲ್ಲಿ ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳಿವೆ ಎಂದು ನಾವು ಹೇಗೆ ತಿಳಿಯಬಹುದು?\n",
"
\n",
"- ಒಂದು ಸರಳ ವಿಧಾನವೆಂದರೆ ಮೂಲ R ಫಂಕ್ಷನ್ `anyNA` ಅನ್ನು ಬಳಸುವುದು, ಇದು ತಾರ್ಕಿಕ ವಸ್ತುಗಳು `TRUE` ಅಥವಾ `FALSE` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.\n"
],
"metadata": {
"id": "Zxfb3AM5YbUe"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" anyNA()"
],
"outputs": [],
"metadata": {
"id": "G--DQutAYltj"
}
},
{
"cell_type": "markdown",
"source": [
"ಚೆನ್ನಾಗಿದೆ, ಕೆಲವು ಡೇಟಾ ಕಾಣೆಯಾಗಿರುವಂತೆ ತೋರುತ್ತದೆ! ಅದು ಪ್ರಾರಂಭಿಸಲು ಒಳ್ಳೆಯ ಸ್ಥಳವಾಗಿದೆ.\n",
"\n",
"- ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ `is.na()` ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸುವುದು, ಇದು ಯಾವ ವೈಯಕ್ತಿಕ ಕಾಲಮ್ ಅಂಶಗಳು ಕಾಣೆಯಾಗಿವೆ ಎಂದು ಲಾಜಿಕಲ್ `TRUE` ಮೂಲಕ ಸೂಚಿಸುತ್ತದೆ.\n"
],
"metadata": {
"id": "mU-7-SB6YokF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" is.na() %>% \n",
" head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "W-DxDOR4YxSW"
}
},
{
"cell_type": "markdown",
"source": [
"ಸರಿ, ಕೆಲಸ ಮುಗಿಸಿದೆ ಆದರೆ ಇಂತಹ ದೊಡ್ಡ ಡೇಟಾ ಫ್ರೇಮ್ನೊಂದಿಗೆ, ಎಲ್ಲಾ ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್ಗಳನ್ನು ವೈಯಕ್ತಿಕವಾಗಿ ಪರಿಶೀಲಿಸುವುದು ಅಸಾಧ್ಯ ಮತ್ತು ಅಪ್ರಾಯೋಗಿಕವಾಗಿರುತ್ತದೆ😴.\n",
"\n",
"- ಇನ್ನೊಂದು ಹೆಚ್ಚು ಅರ್ಥಪೂರ್ಣ ವಿಧಾನವೆಂದರೆ ಪ್ರತಿ ಕಾಲಮ್ಗೆ ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳ ಮೊತ್ತವನ್ನು ಲೆಕ್ಕಹಾಕುವುದು:\n"
],
"metadata": {
"id": "xUWxipKYY0o7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" is.na() %>% \n",
" colSums()"
],
"outputs": [],
"metadata": {
"id": "ZRBWV6P9ZArL"
}
},
{
"cell_type": "markdown",
"source": [
"ಇನ್ನಷ್ಟು ಉತ್ತಮವಾಗಿದೆ! ಕೆಲವು ಡೇಟಾ ಕಾಣೆಯಾಗಿವೆ, ಆದರೆ ಬಹುಶಃ ಅದು ಈ ಕಾರ್ಯಕ್ಕೆ ಪ್ರಭಾವ ಬೀರುವುದಿಲ್ಲ. ಮುಂದಿನ ವಿಶ್ಲೇಷಣೆ ಏನು ತರುತ್ತದೆ ನೋಡೋಣ.\n",
"\n",
"> ಅದ್ಭುತ ಪ್ಯಾಕೇಜುಗಳು ಮತ್ತು ಫಂಕ್ಷನ್ಗಳ ಜೊತೆಗೆ, R ಗೆ ಅತ್ಯುತ್ತಮ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಇದೆ. ಉದಾಹರಣೆಗೆ, ಫಂಕ್ಷನ್ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ `help(colSums)` ಅಥವಾ `?colSums` ಅನ್ನು ಬಳಸಿ.\n"
],
"metadata": {
"id": "9gv-crB6ZD1Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. Dplyr: ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ನ ವ್ಯಾಕರಣ\n",
"\n",
"\n",
"
\n",
"
\n",
"
\n"
],
"metadata": {
"id": "i5o33MQBZWWw"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::select()\n",
"\n",
"`select()` ಎಂಬುದು `dplyr` ಪ್ಯಾಕೇಜ್ನ ಒಂದು ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಇದು ನೀವು ಉಳಿಸಿಕೊಳ್ಳಬೇಕಾದ ಅಥವಾ ಹೊರತುಪಡಿಸಬೇಕಾದ ಕಾಲಮ್ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.\n",
"\n",
"ನಿಮ್ಮ ಡೇಟಾ ಫ್ರೇಮ್ ಅನ್ನು ಸುಲಭವಾಗಿ ಕೆಲಸ ಮಾಡಲು, ಅದರ ಕೆಲವು ಕಾಲಮ್ಗಳನ್ನು `select()` ಬಳಸಿ ಬಿಟ್ಟಿಹಾಕಿ, ನೀವು ಬೇಕಾದ ಕಾಲಮ್ಗಳನ್ನು ಮಾತ್ರ ಉಳಿಸಿ.\n",
"\n",
"ಉದಾಹರಣೆಗೆ, ಈ ವ್ಯಾಯಾಮದಲ್ಲಿ, ನಮ್ಮ ವಿಶ್ಲೇಷಣೆ `Package`, `Low Price`, `High Price` ಮತ್ತು `Date` ಕಾಲಮ್ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಕಾಲಮ್ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡೋಣ.\n"
],
"metadata": {
"id": "x3VGMAGBZiUr"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Select desired columns\n",
"pumpkins <- pumpkins %>% \n",
" select(Package, `Low Price`, `High Price`, Date)\n",
"\n",
"\n",
"# Print data set\n",
"pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "F_FgxQnVZnM0"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::mutate()\n",
"\n",
"`mutate()` ಎಂಬುದು `dplyr` ಪ್ಯಾಕೇಜಿನ ಒಂದು ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಇದರಿಂದ ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಾಲಮ್ಗಳನ್ನು ಉಳಿಸಿಕೊಂಡು ಹೊಸ ಕಾಲಮ್ಗಳನ್ನು ರಚಿಸಬಹುದು ಅಥವಾ ಬದಲಾಯಿಸಬಹುದು.\n",
"\n",
"mutate ನ ಸಾಮಾನ್ಯ ರಚನೆ ಹೀಗಿದೆ:\n",
"\n",
"`data %>% mutate(new_column_name = what_it_contains)`\n",
"\n",
"`Date` ಕಾಲಮ್ ಬಳಸಿ ಕೆಳಗಿನ ಕಾರ್ಯಗಳನ್ನು ಮಾಡಿ `mutate` ಅನ್ನು ಪ್ರಯೋಗಿಸೋಣ:\n",
"\n",
"1. ದಿನಾಂಕಗಳನ್ನು (ಈಗಾಗಲೇ character ಪ್ರಕಾರದಲ್ಲಿರುವ) ತಿಂಗಳ ಫಾರ್ಮ್ಯಾಟ್ಗೆ ಪರಿವರ್ತಿಸಿ (ಇವು US ದಿನಾಂಕಗಳು, ಆದ್ದರಿಂದ ಫಾರ್ಮ್ಯಾಟ್ `MM/DD/YYYY` ಆಗಿದೆ).\n",
"\n",
"2. ದಿನಾಂಕಗಳಿಂದ ತಿಂಗಳನ್ನೊಂದು ಹೊಸ ಕಾಲಮ್ಗೆ ತೆಗೆದುಹಾಕಿ.\n",
"\n",
"R ನಲ್ಲಿ, [lubridate](https://lubridate.tidyverse.org/) ಪ್ಯಾಕೇಜ್ Date-time ಡೇಟಾ ಜೊತೆ ಕೆಲಸ ಮಾಡಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, `dplyr::mutate()`, `lubridate::mdy()`, `lubridate::month()` ಗಳನ್ನು ಬಳಸಿ ಮೇಲಿನ ಗುರಿಗಳನ್ನು ಹೇಗೆ ಸಾಧಿಸಬಹುದು ನೋಡೋಣ. ಮುಂದಿನ ಕಾರ್ಯಗಳಲ್ಲಿ Date ಕಾಲಮ್ ಬೇಕಾಗುವುದಿಲ್ಲದರಿಂದ ಅದನ್ನು ತೆಗೆದುಹಾಕಬಹುದು.\n"
],
"metadata": {
"id": "2KKo0Ed9Z1VB"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load lubridate\n",
"library(lubridate)\n",
"\n",
"pumpkins <- pumpkins %>% \n",
" # Convert the Date column to a date object\n",
" mutate(Date = mdy(Date)) %>% \n",
" # Extract month from Date\n",
" mutate(Month = month(Date)) %>% \n",
" # Drop Date column\n",
" select(-Date)\n",
"\n",
"# View the first few rows\n",
"pumpkins %>% \n",
" slice_head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "5joszIVSZ6xe"
}
},
{
"cell_type": "markdown",
"source": [
"ವಾಹ್! 🤩\n",
"\n",
"ಮುಂದೆ, ನಾವು ಹೊಸ ಕಾಲಮ್ `Price` ಅನ್ನು ರಚಿಸೋಣ, ಇದು ಒಂದು ಕಂಬಳದ ಸರಾಸರಿ ಬೆಲೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈಗ, ಹೊಸ Price ಕಾಲಮ್ ಅನ್ನು ತುಂಬಲು `Low Price` ಮತ್ತು `High Price` ಕಾಲಮ್ಗಳ ಸರಾಸರಿ ತೆಗೆದುಕೊಳ್ಳೋಣ.\n",
"
\n"
],
"metadata": {
"id": "nIgLjNMCZ-6Y"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create a new column Price\n",
"pumpkins <- pumpkins %>% \n",
" mutate(Price = (`Low Price` + `High Price`)/2)\n",
"\n",
"# View the first few rows of the data\n",
"pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "Zo0BsqqtaJw2"
}
},
{
"cell_type": "markdown",
"source": [
"ಹೌದು!💪\n",
"\n",
"\"ಆದರೆ ಕಾಯಿರಿ!\", ನೀವು `View(pumpkins)` ಮೂಲಕ ಸಂಪೂರ್ಣ ಡೇಟಾ ಸೆಟ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡಿದ ನಂತರ ಹೇಳುತ್ತೀರಿ, \"ಇಲ್ಲಿ ಏನೋ ವಿಚಿತ್ರವಿದೆ!\"🤔\n",
"\n",
"ನೀವು `Package` ಕಾಲಮ್ ಅನ್ನು ನೋಡಿದರೆ, ಕಂಬಳಿಗಳು ವಿವಿಧ ವಿನ್ಯಾಸಗಳಲ್ಲಿ ಮಾರಾಟವಾಗುತ್ತಿವೆ. ಕೆಲವು `1 1/9 ಬಷೆಲ್` ಅಳತೆಯಲ್ಲಿ ಮಾರಾಟವಾಗುತ್ತವೆ, ಕೆಲವು `1/2 ಬಷೆಲ್` ಅಳತೆಯಲ್ಲಿ, ಕೆಲವು ಪ್ರತಿ ಕಂಬಳಿಗೆ, ಕೆಲವು ಪ್ರತಿ ಪೌಂಡ್ಗೆ, ಮತ್ತು ಕೆಲವು ಬೃಹತ್ ಬಾಕ್ಸ್ಗಳಲ್ಲಿ ವಿವಿಧ ಅಗಲಗಳೊಂದಿಗೆ.\n",
"\n",
"ನಾವು ಇದನ್ನು ಪರಿಶೀಲಿಸೋಣ:\n"
],
"metadata": {
"id": "p77WZr-9aQAR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Verify the distinct observations in Package column\n",
"pumpkins %>% \n",
" distinct(Package)"
],
"outputs": [],
"metadata": {
"id": "XISGfh0IaUy6"
}
},
{
"cell_type": "markdown",
"source": [
"ಅದ್ಭುತ!👏\n",
"\n",
"ಕುಂಬಳಕಾಯಿ ತೂಕವನ್ನು ಸತತವಾಗಿ ಅಳೆಯುವುದು ಬಹಳ ಕಷ್ಟವಾಗುತ್ತದೆ ಎಂದು ತೋರುತ್ತದೆ, ಆದ್ದರಿಂದ `Package` ಕಾಲಮ್ನಲ್ಲಿ *bushel* ಎಂಬ ಸ್ಟ್ರಿಂಗ್ ಇರುವ ಕುಂಬಳಕಾಯಿಗಳನ್ನು ಮಾತ್ರ ಆಯ್ಕೆಮಾಡಿ ಫಿಲ್ಟರ್ ಮಾಡೋಣ ಮತ್ತು ಇದನ್ನು ಹೊಸ ಡೇಟಾ ಫ್ರೇಮ್ `new_pumpkins` ನಲ್ಲಿ ಇಡೋಣ.\n",
"
\n"
],
"metadata": {
"id": "7sMjiVujaZxY"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::filter() ಮತ್ತು stringr::str_detect()\n",
"\n",
"[`dplyr::filter()`](https://dplyr.tidyverse.org/reference/filter.html): ನಿಮ್ಮ ಶರತ್ತುಗಳನ್ನು ಪೂರೈಸುವ **ಸಾಲುಗಳು** ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ಡೇಟಾದ ಉಪಸಮೂಹವನ್ನು ರಚಿಸುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, `Package` ಕಾಲಮ್ನಲ್ಲಿ *bushel* ಎಂಬ ಸ್ಟ್ರಿಂಗ್ ಇರುವ ಕಂಬಳಿಗಳು.\n",
"\n",
"[stringr::str_detect()](https://stringr.tidyverse.org/reference/str_detect.html): ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಮಾದರಿಯಿರುವಿಕೆ ಅಥವಾ ಇಲ್ಲದಿರುವಿಕೆಯನ್ನು ಪತ್ತೆಹಚ್ಚುತ್ತದೆ.\n",
"\n",
"[`stringr`](https://github.com/tidyverse/stringr) ಪ್ಯಾಕೇಜ್ ಸಾಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಸರಳ ಫಂಕ್ಷನ್ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.\n"
],
"metadata": {
"id": "L8Qfcs92ageF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Retain only pumpkins with \"bushel\"\n",
"new_pumpkins <- pumpkins %>% \n",
" filter(str_detect(Package, \"bushel\"))\n",
"\n",
"# Get the dimensions of the new data\n",
"dim(new_pumpkins)\n",
"\n",
"# View a few rows of the new data\n",
"new_pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "hy_SGYREampd"
}
},
{
"cell_type": "markdown",
"source": [
"ನೀವು ನೋಡಬಹುದು ನಾವು ಬಸ್ಸೆಲ್ ಮೂಲಕ ಕಂಬಳಿಗಳನ್ನು ಹೊಂದಿರುವ ಸುಮಾರು 415 ಸಾಲುಗಳ ಡೇಟಾವನ್ನು ಸೀಮಿತಗೊಳಿಸಿದ್ದೇವೆ.🤩\n",
"
\n"
],
"metadata": {
"id": "VrDwF031avlR"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::case_when()\n",
"\n",
"**ಆದರೆ ಕಾಯಿರಿ! ಇನ್ನೊಂದು ಕೆಲಸ ಮಾಡಬೇಕಿದೆ**\n",
"\n",
"ನೀವು ಗಮನಿಸಿದ್ದೀರಾ, ಬಷೆಲ್ ಪ್ರಮಾಣವು ಪ್ರತಿ ಸಾಲಿಗೆ ಬದಲಾಗುತ್ತದೆ? ನೀವು ಬೆಲೆಯನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸಬೇಕಾಗಿದೆ, ಹೀಗಾಗಿ ನೀವು ಬೆಲೆಯನ್ನು ಪ್ರತಿ ಬಷೆಲ್ಗೆ ತೋರಿಸಬೇಕು, 1 1/9 ಅಥವಾ 1/2 ಬಷೆಲ್ಗೆ ಅಲ್ಲ. ಅದನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸಲು ಕೆಲವು ಗಣಿತ ಮಾಡಬೇಕಾಗಿದೆ.\n",
"\n",
"ನಾವು ಕೆಲವು ಶರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ಬೆಲೆ ಕಾಲಮ್ ಅನ್ನು *ಮ್ಯೂಟೇಟ್* ಮಾಡಲು [`case_when()`](https://dplyr.tidyverse.org/reference/case_when.html) ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. `case_when` ನಿಮಗೆ ಹಲವಾರು `if_else()` ಹೇಳಿಕೆಗಳನ್ನು ವೆಕ್ಟರೈಸ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.\n"
],
"metadata": {
"id": "mLpw2jH4a0tx"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Convert the price if the Package contains fractional bushel values\n",
"new_pumpkins <- new_pumpkins %>% \n",
" mutate(Price = case_when(\n",
" str_detect(Package, \"1 1/9\") ~ Price/(1 + 1/9),\n",
" str_detect(Package, \"1/2\") ~ Price/(1/2),\n",
" TRUE ~ Price))\n",
"\n",
"# View the first few rows of the data\n",
"new_pumpkins %>% \n",
" slice_head(n = 30)"
],
"outputs": [],
"metadata": {
"id": "P68kLVQmbM6I"
}
},
{
"cell_type": "markdown",
"source": [
"ಈಗ, ನಾವು ಅವರ ಬಷೆಲ್ ಅಳತೆಯ ಆಧಾರದ ಮೇಲೆ ಪ್ರತಿ ಘಟಕದ ಬೆಲೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಬಹುದು. ಈ ಎಲ್ಲಾ ಕಂಬಳಕಾಯಿ ಬಷೆಲ್ ಅಧ್ಯಯನವು, ಆದಾಗ್ಯೂ, ನಿಮ್ಮ ಡೇಟಾದ ಸ್ವಭಾವವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಎಷ್ಟು `ಮುಖ್ಯ` ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ!\n",
"\n",
"> ✅ [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308) ಪ್ರಕಾರ, ಬಷೆಲ್ನ ತೂಕವು ಉತ್ಪನ್ನದ ಪ್ರಕಾರ ಅವಲಂಬಿತವಾಗಿದ್ದು, ಇದು ಪ್ರಮಾಣದ ಅಳತೆ. \"ಉದಾಹರಣೆಗೆ, ಟೊಮೇಟೋಗಳ ಒಂದು ಬಷೆಲ್ 56 ಪೌಂಡು ತೂಕವಾಗಿರಬೇಕು... ಎಲೆಗಳು ಮತ್ತು ಹಸಿರುಗಳು ಕಡಿಮೆ ತೂಕದೊಂದಿಗೆ ಹೆಚ್ಚು ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ, ಆದ್ದರಿಂದ ಸ್ಪಿನಾಚ್ನ ಒಂದು ಬಷೆಲ್ ಕೇವಲ 20 ಪೌಂಡು ತೂಕದಿರುತ್ತದೆ.\" ಇದು ಎಲ್ಲವೂ ತುಂಬಾ ಸಂಕೀರ್ಣವಾಗಿದೆ! ಬಷೆಲ್-ನಿಂದ ಪೌಂಡಿಗೆ ಪರಿವರ್ತನೆ ಮಾಡುವುದನ್ನು ಬಿಟ್ಟು, ಬಷೆಲ್ ಪ್ರಕಾರ ಬೆಲೆಯನ್ನು ನಿಗದಿಪಡಿಸೋಣ. ಈ ಎಲ್ಲಾ ಕಂಬಳಕಾಯಿ ಬಷೆಲ್ ಅಧ್ಯಯನವು, ಆದಾಗ್ಯೂ, ನಿಮ್ಮ ಡೇಟಾದ ಸ್ವಭಾವವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಎಷ್ಟು ಮುಖ್ಯ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ!\n",
">\n",
"> ✅ ನೀವು ಗಮನಿಸಿದ್ದೀರಾ, ಅರ್ಧ ಬಷೆಲ್ ಪ್ರಕಾರ ಮಾರಾಟವಾಗುವ ಕಂಬಳಕಾಯಿಗಳು ತುಂಬಾ ದುಬಾರಿ? ನೀವು ಏಕೆ ಎಂದು ಕಂಡುಹಿಡಿಯಬಹುದೇ? ಸೂಚನೆ: ಸಣ್ಣ ಕಂಬಳಕಾಯಿಗಳು ದೊಡ್ಡದಿಗಿಂತ ಬಹಳ ಹೆಚ್ಚು ಬೆಲೆಯಿರುತ್ತವೆ, ಬಹುಶಃ ಏಕೆಂದರೆ ಒಂದು ದೊಡ್ಡ ಹೊಳೆಯುವ ಪೈ ಕಂಬಳಕಾಯಿಯಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾದ ಉಪಯೋಗಿಸದ ಜಾಗದ ಕಾರಣದಿಂದ, ಬಷೆಲ್ ಪ್ರತಿ ಹೆಚ್ಚು ಸಂಖ್ಯೆಯ ಸಣ್ಣ ಕಂಬಳಕಾಯಿಗಳು ಇರುತ್ತವೆ.\n",
"
\n"
],
"metadata": {
"id": "pS2GNPagbSdb"
}
},
{
"cell_type": "markdown",
"source": [
"ಇದೀಗ ಕೊನೆಗೆ, ಸಾಹಸಕ್ಕಾಗಿ 💁♀️, ನಾವು ತಿಂಗಳು ಕಾಲಮ್ ಅನ್ನು ಮೊದಲ ಸ್ಥಾನಕ್ಕೆ `Package` ಕಾಲಮ್ `ಮುಂಬರುವ` ಮಾಡೋಣ.\n",
"\n",
"ಕಾಲಮ್ ಸ್ಥಾನಗಳನ್ನು ಬದಲಾಯಿಸಲು `dplyr::relocate()` ಬಳಸಲಾಗುತ್ತದೆ.\n"
],
"metadata": {
"id": "qql1SowfbdnP"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create a new data frame new_pumpkins\n",
"new_pumpkins <- new_pumpkins %>% \n",
" relocate(Month, .before = Package)\n",
"\n",
"new_pumpkins %>% \n",
" slice_head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "JJ1x6kw8bixF"
}
},
{
"cell_type": "markdown",
"source": [
"ಚೆನ್ನಾಗಿದೆ!👌 ಈಗ ನಿಮಗೆ ಹೊಸ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾಗುವ ಸ್ವಚ್ಛ, ಸುವ್ಯವಸ್ಥಿತ ಡೇಟಾಸೆಟ್ ಇದೆ! \n",
"
\n"
],
"metadata": {
"id": "y8TJ0Za_bn5Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 4. ggplot2 ಬಳಸಿ ಡೇಟಾ ದೃಶ್ಯೀಕರಣ\n",
"\n",
"
\n",
"
\n",
"
\n"
],
"metadata": {
"id": "Ml7SDCLQcPvE"
}
},
{
"cell_type": "markdown",
"source": [
"### **ನಾವು ಇದನ್ನು ಉಪಯುಕ್ತವಾಗಿಸಲು ಹೇಗೆ ಮಾಡಬಹುದು?**\n",
"\n",
"ಚಾರ್ಟ್ಗಳು ಉಪಯುಕ್ತ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸಲು, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾವನ್ನು ಯಾವುದೋ ರೀತಿಯಲ್ಲಿ ಗುಂಪು ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಪ್ರತಿ ತಿಂಗಳಿಗಾಗಿ ಕಂಬಳಿಗಳ ಸರಾಸರಿ ಬೆಲೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ನಮ್ಮ ಡೇಟಾದ ಅಡಿಯಲ್ಲಿ ಇರುವ ಮಾದರಿಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ. ಇದು ನಮಗೆ ಇನ್ನೊಂದು **dplyr** ಫ್ಲೈಬೈಗೆ ದಾರಿ ಮಾಡಿಕೊಡುತ್ತದೆ:\n",
"\n",
"#### `dplyr::group_by() %>% summarize()`\n",
"\n",
"R ನಲ್ಲಿ ಗುಂಪು ಮಾಡಿದ ಸಂಗ್ರಹಣೆಯನ್ನು ಸುಲಭವಾಗಿ ಲೆಕ್ಕಹಾಕಬಹುದು\n",
"\n",
"`dplyr::group_by() %>% summarize()`\n",
"\n",
"- `dplyr::group_by()` ವಿಶ್ಲೇಷಣೆಯ ಘಟಕವನ್ನು ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ನಿಂದ ಪ್ರತಿ ತಿಂಗಳುಗಳಂತಹ ವೈಯಕ್ತಿಕ ಗುಂಪುಗಳಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.\n",
"\n",
"- `dplyr::summarize()` ನೀವು ಸೂಚಿಸಿದ ಪ್ರತಿಯೊಂದು ಗುಂಪು ಚರ ಮತ್ತು ಪ್ರತಿಯೊಂದು ಸಾರಾಂಶ ಅಂಕಿಅಂಶಗಳಿಗಾಗಿ ಒಂದು ಕಾಲಮ್ ಹೊಂದಿರುವ ಹೊಸ ಡೇಟಾ ಫ್ರೇಮ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.\n",
"\n",
"ಉದಾಹರಣೆಗೆ, ನಾವು `dplyr::group_by() %>% summarize()` ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಂಬಳಿಗಳನ್ನು **ತಿಂಗಳು** ಕಾಲಮ್ ಆಧಾರಿತ ಗುಂಪುಗಳಾಗಿ ಗುಂಪು ಮಾಡಿ, ನಂತರ ಪ್ರತಿ ತಿಂಗಳಿಗೂ **ಸರಾಸರಿ ಬೆಲೆ** ಕಂಡುಹಿಡಿಯಬಹುದು.\n"
],
"metadata": {
"id": "jMakvJZIcVkh"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the average price of pumpkins per month\r\n",
"new_pumpkins %>%\r\n",
" group_by(Month) %>% \r\n",
" summarise(mean_price = mean(Price))"
],
"outputs": [],
"metadata": {
"id": "6kVSUa2Bcilf"
}
},
{
"cell_type": "markdown",
"source": [
"ಸಂಕ್ಷಿಪ್ತ!✨\n",
"\n",
"ತಿಂಗಳುಗಳಂತಹ ವರ್ಗೀಕೃತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಾರ್ ಪ್ಲಾಟ್ 📊 ಬಳಸಿ ಉತ್ತಮವಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಬಾರ್ ಚಾರ್ಟ್ಗಳಿಗೆ ಹೊಣೆಗಾರಿರುವ ಲೇಯರ್ಗಳು `geom_bar()` ಮತ್ತು `geom_col()` ಆಗಿವೆ. ಇನ್ನಷ್ಟು ತಿಳಿಯಲು `?geom_bar` ಅನ್ನು ನೋಡಿ.\n",
"\n",
"ಒಂದು ತಯಾರಿಸೋಣ!\n"
],
"metadata": {
"id": "Kds48GUBcj3W"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the average price of pumpkins per month then plot a bar chart\r\n",
"new_pumpkins %>%\r\n",
" group_by(Month) %>% \r\n",
" summarise(mean_price = mean(Price)) %>% \r\n",
" ggplot(aes(x = Month, y = mean_price)) +\r\n",
" geom_col(fill = \"midnightblue\", alpha = 0.7) +\r\n",
" ylab(\"Pumpkin Price\")"
],
"outputs": [],
"metadata": {
"id": "VNbU1S3BcrxO"
}
},
{
"cell_type": "markdown",
"source": [
"🤩🤩ಇದು ಇನ್ನಷ್ಟು ಉಪಯುಕ್ತ ಡೇಟಾ ದೃಶ್ಯೀಕರಣವಾಗಿದೆ! ಇದು ಸಪ್ಟೆಂಬರ್ ಮತ್ತು ಅಕ್ಟೋಬರ್ ತಿಂಗಳಲ್ಲಿ ಕಂಬಳಿಗಳ ಗರಿಷ್ಠ ಬೆಲೆ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ಸೂಚಿಸುತ್ತಿದೆ ಎಂದು ತೋರುತ್ತದೆ. ಇದು ನಿಮ್ಮ ನಿರೀಕ್ಷೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ? ಏಕೆ ಅಥವಾ ಏಕೆ ಅಲ್ಲ?\n",
"\n",
"ಎರಡನೇ ಪಾಠವನ್ನು ಮುಗಿಸಿದ ನಿಮಗೆ ಅಭಿನಂದನೆಗಳು 👏! ನೀವು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಮಾದರಿ ನಿರ್ಮಾಣಕ್ಕೆ ಸಿದ್ಧಪಡಿಸಿದಿರಿ, ನಂತರ ದೃಶ್ಯೀಕರಣಗಳನ್ನು ಬಳಸಿ ಇನ್ನಷ್ಟು ಒಳನೋಟಗಳನ್ನು ಅನಾವರಣಗೊಳಿಸಿದಿರಿ!\n"
],
"metadata": {
"id": "zDm0VOzzcuzR"
}
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n\n\n**ಅಸ್ವೀಕರಣ**: \nಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n\n"
]
}
]
}