msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2d9b2ea197'
${ noResults }
ML-For-Beginners/translations/kn/2-Regression/2-Data/solution/R/lesson_2-R.ipynb

673 lines
40 KiB
Raw Blame History

{
"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",
"<p >\n",
" <img src=\"../../../../../../translated_images/kn/unruly_data.0eedc7ced92d2d91.webp\"\n",
" width=\"700\"/>\n",
" <figcaption>ಕಲಾಕೃತಿ @allison_horst ಅವರಿಂದ</figcaption>\n"
],
"metadata": {
"id": "Pg5aexcOPqAZ"
}
},
{
"cell_type": "markdown",
"source": [
"## 1. ಕಂಬಳಿಯ ಡೇಟಾವನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಟಿಡಿವರ್ಸ್ ಅನ್ನು ಕರೆಸಿಕೊಳ್ಳುವುದು\n",
"\n",
"ನಾವು ಈ ಪಾಠವನ್ನು ಕತ್ತರಿಸಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ಕೆಳಗಿನ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಅಗತ್ಯವಿದೆ:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) ಒಂದು [R ಪ್ಯಾಕೇಜುಗಳ ಸಂಗ್ರಹ](https://www.tidyverse.org/packages) ಆಗಿದ್ದು, ಡೇಟಾ ವಿಜ್ಞಾನವನ್ನು ವೇಗವಾಗಿ, ಸುಲಭವಾಗಿ ಮತ್ತು ಹೆಚ್ಚು ಮನರಂಜನೀಯವಾಗಿ ಮಾಡುತ್ತದೆ!\n",
"\n",
"ನೀವು ಅವುಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬಹುದು:\n",
"\n",
"`install.packages(c(\"tidyverse\"))`\n",
"\n",
"ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಘಟಕವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜುಗಳಿದ್ದಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಕೆಲವು ಇಲ್ಲದಿದ್ದರೆ ಅವುಗಳನ್ನು ನಿಮ್ಮಿಗಾಗಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುತ್ತದೆ.\n"
],
"metadata": {
"id": "dc5WhyVdXAjR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
"pacman::p_load(tidyverse)"
],
"outputs": [],
"metadata": {
"id": "GqPYUZgfXOBt"
}
},
{
"cell_type": "markdown",
"source": [
"ಈಗ, ಕೆಲವು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಈ ಪಾಠಕ್ಕಾಗಿ ನೀಡಲಾದ [ಡೇಟಾ](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) ಅನ್ನು ಲೋಡ್ ಮಾಡೋಣ!\n"
],
"metadata": {
"id": "kvjDTPDSXRr2"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load the core Tidyverse packages\n",
"library(tidyverse)\n",
"\n",
"# Import the pumpkins data\n",
"pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\")\n",
"\n",
"\n",
"# Get a glimpse and dimensions of the data\n",
"glimpse(pumpkins)\n",
"\n",
"\n",
"# Print the first 50 rows of the data set\n",
"pumpkins %>% \n",
" slice_head(n =50)"
],
"outputs": [],
"metadata": {
"id": "VMri-t2zXqgD"
}
},
{
"cell_type": "markdown",
"source": [
"ತಕ್ಷಣದ `glimpse()` ತೋರಿಸುತ್ತದೆ ಎಂದು ಖಾಲಿ ಸ್ಥಳಗಳಿವೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ಗಳು (`chr`) ಮತ್ತು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾ (`dbl`) ಮಿಶ್ರಣವಿದೆ. `Date` ಪ್ರಕಾರವು ಕ್ಯಾರಕ್ಟರ್ ಆಗಿದ್ದು, `Package` ಎಂಬ ವಿಚಿತ್ರ ಕಾಲಮ್ ಕೂಡ ಇದೆ, ಅಲ್ಲಿ ಡೇಟಾ `sacks`, `bins` ಮತ್ತು ಇತರ ಮೌಲ್ಯಗಳ ಮಿಶ್ರಣವಾಗಿದೆ. ವಾಸ್ತವದಲ್ಲಿ, ಡೇಟಾ ಸ್ವಲ್ಪ ಗೊಂದಲವಾಗಿದೆ 😤.\n",
"\n",
"ವಾಸ್ತವದಲ್ಲಿ, ಬಾಕ್ಸ್‌ನಿಂದಲೇ ML ಮಾದರಿಯನ್ನು ರಚಿಸಲು ಸಂಪೂರ್ಣವಾಗಿ ಸಿದ್ಧವಾಗಿರುವ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಪಡೆಯುವುದು ಸಾಮಾನ್ಯವಲ್ಲ. ಆದರೆ ಚಿಂತೆ ಮಾಡಬೇಡಿ, ಈ ಪಾಠದಲ್ಲಿ ನೀವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ R ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ ಕಚ್ಚಾ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಹೇಗೆ ಸಿದ್ಧಪಡಿಸಬೇಕೆಂದು ಕಲಿಯುತ್ತೀರಿ 🧑‍🔧. ನೀವು ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ವಿವಿಧ ತಂತ್ರಗಳನ್ನು ಸಹ ಕಲಿಯುತ್ತೀರಿ.📈📊\n",
"<br>\n",
"\n",
"> ಪುನಃಸ್ಮರಣೆ: ಪೈಪ್ ಆಪರೇಟರ್ (`%>%`) ಲಾಜಿಕಲ್ ಕ್ರಮದಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಒಂದು ವಸ್ತುವನ್ನು ಮುಂದಕ್ಕೆ ಫಂಕ್ಷನ್ ಅಥವಾ ಕರೆ ಅಭಿವ್ಯಕ್ತಿಗೆ ಹಂಚಿಕೊಡುತ್ತದೆ. ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಪೈಪ್ ಆಪರೇಟರ್ ಅನ್ನು \"ಮತ್ತು ನಂತರ\" ಎಂದು ಹೇಳುವುದಾಗಿ ಭಾವಿಸಬಹುದು.\n"
],
"metadata": {
"id": "REWcIv9yX29v"
}
},
{
"cell_type": "markdown",
"source": [
"## 2. ಕಾಣೆಯಾದ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸಿ\n",
"\n",
"ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಎದುರಿಸಬೇಕಾದ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಅಪೂರ್ಣ ಅಥವಾ ಕಾಣೆಯಾದ ಡೇಟಾ. R ಕಾಣೆಯಾದ ಅಥವಾ ಅಜ್ಞಾತ ಮೌಲ್ಯಗಳನ್ನು ವಿಶೇಷ ಸೆಂಟಿನೆಲ್ ಮೌಲ್ಯದಿಂದ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ: `NA` (ಲಭ್ಯವಿಲ್ಲ).\n",
"\n",
"ಆದ್ದರಿಂದ ಡೇಟಾ ಫ್ರೇಮ್‌ನಲ್ಲಿ ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳಿವೆ ಎಂದು ನಾವು ಹೇಗೆ ತಿಳಿಯಬಹುದು?\n",
"<br>\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",
"<p >\n",
" <img src=\"../../../../../../translated_images/kn/dplyr_wrangling.f5f99c64fd4580f1.webp\"\n",
" width=\"569\"/>\n",
" <figcaption>@allison_horst ಅವರ ಕಲಾಕೃತಿ</figcaption>\n",
"\n",
"\n",
"<!--![Artwork by \\@allison_horst](../../../../../../translated_images/kn/dplyr_wrangling.f5f99c64fd4580f1.webp)<br/>Artwork by \\@allison_horst-->\n"
],
"metadata": {
"id": "o4jLY5-VZO2C"
}
},
{
"cell_type": "markdown",
"source": [
"[`dplyr`](https://dplyr.tidyverse.org/), ಟಿಡಿವರ್ಸ್‌ನ ಒಂದು ಪ್ಯಾಕೇಜ್, ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ನ ವ್ಯಾಕರಣವಾಗಿದೆ ಇದು ನಿಮಗೆ ಸಾಮಾನ್ಯ ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡುವ ಸತತ ಕ್ರಿಯಾಪದಗಳ ಸಮೂಹವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು dplyr ನ ಕೆಲವು ಕ್ರಿಯಾಪದಗಳನ್ನು ಅನ್ವೇಷಿಸುವೆವು! \n",
"<br>\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",
"<br>\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",
"<br>\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",
"<br>\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",
"<br>\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",
"<br>\n"
],
"metadata": {
"id": "y8TJ0Za_bn5Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 4. ggplot2 ಬಳಸಿ ಡೇಟಾ ದೃಶ್ಯೀಕರಣ\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/kn/data-visualization.54e56dded7c1a804.webp\"\n",
" width=\"600\"/>\n",
" <figcaption>ಡಾಸನಿ ಮಡಿಪಳ್ಳಿ ಅವರ ಇನ್ಫೋಗ್ರಾಫಿಕ್</figcaption>\n",
"\n",
"\n",
"<!--![ಡಾಸನಿ ಮಡಿಪಳ್ಳಿ ಅವರ ಇನ್ಫೋಗ್ರಾಫಿಕ್](../../../../../../translated_images/kn/data-visualization.54e56dded7c1a804.webp){width=\"600\"}-->\n",
"\n",
"ಇದೀಗ ಒಂದು *ಜ್ಞಾನವಂತ* ಮಾತು ಇದೆ:\n",
"\n",
"> \"ಸರಳ ಗ್ರಾಫ್ ಡೇಟಾ ವಿಶ್ಲೇಷಕನ ಮನಸ್ಸಿಗೆ ಯಾವುದೇ ಇತರೆ ಸಾಧನಕ್ಕಿಂತ ಹೆಚ್ಚು ಮಾಹಿತಿ ತಂದಿದೆ.\" --- ಜಾನ್ ಟುಕಿ\n",
"\n",
"ಡೇಟಾ ವಿಜ್ಞಾನಿಯ ಪಾತ್ರದ ಒಂದು ಭಾಗವೆಂದರೆ ಅವರು ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಡೇಟಾದ ಗುಣಮಟ್ಟ ಮತ್ತು ಸ್ವಭಾವವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು. ಇದಕ್ಕಾಗಿ, ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ಆಸಕ್ತಿದಾಯಕ ದೃಶ್ಯೀಕರಣಗಳನ್ನು, ಅಥವಾ ಪ್ಲಾಟ್‌ಗಳು, ಗ್ರಾಫ್‌ಗಳು ಮತ್ತು ಚಾರ್ಟ್‌ಗಳನ್ನು ರಚಿಸುತ್ತಾರೆ, ಡೇಟಾದ ವಿಭಿನ್ನ ಅಂಶಗಳನ್ನು ತೋರಿಸುತ್ತಾರೆ. ಈ ರೀತಿಯಲ್ಲಿ, ಅವರು ದೃಶ್ಯವಾಗಿ ಸಂಬಂಧಗಳು ಮತ್ತು ಗ್ಯಾಪ್‌ಗಳನ್ನು ತೋರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಅವುಗಳನ್ನು ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಕಂಡುಹಿಡಿಯುವುದು ಕಷ್ಟ.\n",
"\n",
"ದೃಶ್ಯೀಕರಣಗಳು ಡೇಟಾಗೆ ಅತ್ಯಂತ ಸೂಕ್ತವಾದ ಯಂತ್ರ ಅಧ್ಯಯನ ತಂತ್ರವನ್ನು ನಿರ್ಧರಿಸಲು ಸಹ ಸಹಾಯ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಸ್ಕ್ಯಾಟರ್‌ಪ್ಲಾಟ್ ಒಂದು ರೇಖೆಯನ್ನು ಅನುಸರಿಸುತ್ತಿರುವಂತೆ ಕಾಣಿಸಿದರೆ, ಅದು ಡೇಟಾ ಲೀನಿಯರ್ ರಿಗ್ರೆಷನ್ ಅಭ್ಯಾಸಕ್ಕೆ ಉತ್ತಮ ಅಭ್ಯರ್ಥಿ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.\n",
"\n",
"R ಗ್ರಾಫ್‌ಗಳನ್ನು ರಚಿಸಲು ಹಲವಾರು ವ್ಯವಸ್ಥೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದರೆ [`ggplot2`](https://ggplot2.tidyverse.org/index.html) ಅತ್ಯಂತ ಸುಂದರ ಮತ್ತು ಬಹುಮುಖವಾಗಿದೆ. `ggplot2` ನಿಮಗೆ **ಸ್ವತಂತ್ರ ಘಟಕಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ** ಗ್ರಾಫ್‌ಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.\n",
"\n",
"ನಾವು Price ಮತ್ತು Month ಕಾಲಮ್‌ಗಳಿಗಾಗಿ ಸರಳ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್‌ನಿಂದ ಪ್ರಾರಂಭಿಸೋಣ.\n",
"\n",
"ಹೀಗಾಗಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು [`ggplot()`](https://ggplot2.tidyverse.org/reference/ggplot.html) ನಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಡೇಟಾಸೆಟ್ ಮತ್ತು ಅಲಂಕಾರಿಕ ನಕ್ಷೆ (aesthetic mapping) ( [`aes()`](https://ggplot2.tidyverse.org/reference/aes.html) ಬಳಸಿ) ಒದಗಿಸಿ ನಂತರ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್‌ಗಳಿಗೆ [`geom_point()`](https://ggplot2.tidyverse.org/reference/geom_point.html) ಹೋಲುವ ಲೇಯರ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ.\n"
],
"metadata": {
"id": "mYSH6-EtbvNa"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Set a theme for the plots\n",
"theme_set(theme_light())\n",
"\n",
"# Create a scatter plot\n",
"p <- ggplot(data = new_pumpkins, aes(x = Price, y = Month))\n",
"p + geom_point()"
],
"outputs": [],
"metadata": {
"id": "g2YjnGeOcLo4"
}
},
{
"cell_type": "markdown",
"source": [
"ಇದು ಉಪಯುಕ್ತವಾದ ಪ್ಲಾಟ್ ಆಗಿದೆಯೇ 🤷? ಇದರಲ್ಲಿ ನಿಮಗೆ ಏನಾದರೂ ಆಶ್ಚರ್ಯಕರವಾಗಿದೆಯೇ?\n",
"\n",
"ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಲ್ಲ ಏಕೆಂದರೆ ಇದು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ನೀಡಲಾದ ತಿಂಗಳಲ್ಲಿ ಬಿಂದುಗಳ ವಿಸ್ತಾರವಾಗಿ ಪ್ರದರ್ಶಿಸುವುದೇ ಆಗಿದೆ.\n",
"<br>\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<!-- 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"
]
}
]
}
Reference in new issue View Git Blame Copy Permalink