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.
1086 lines
72 KiB
1086 lines
72 KiB
{
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2,
|
|
"metadata": {
|
|
"colab": {
|
|
"name": "lesson_3-R.ipynb",
|
|
"provenance": [],
|
|
"collapsed_sections": [],
|
|
"toc_visible": true
|
|
},
|
|
"kernelspec": {
|
|
"name": "ir",
|
|
"display_name": "R"
|
|
},
|
|
"language_info": {
|
|
"name": "R"
|
|
},
|
|
"coopTranslator": {
|
|
"original_hash": "5015d65d61ba75a223bfc56c273aa174",
|
|
"translation_date": "2025-12-19T16:27:41+00:00",
|
|
"source_file": "2-Regression/3-Linear/solution/R/lesson_3-R.ipynb",
|
|
"language_code": "kn"
|
|
}
|
|
},
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ: ರೇಖೀಯ ಮತ್ತು ಬಹುಪದ ರೆಗ್ರೆಶನ್ ಮಾದರಿಗಳು\n"
|
|
],
|
|
"metadata": {
|
|
"id": "EgQw8osnsUV-"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## ಲೀನಿಯರ್ ಮತ್ತು ಪೋಲಿನೋಮಿಯಲ್ ರಿಗ್ರೆಶನ್ ಫಾರ್ ಪಂಪ್ಕಿನ್ ಪ್ರೈಸಿಂಗ್ - ಪಾಠ 3\n",
|
|
"<p >\n",
|
|
" <img src=\"../../../../../../translated_images/kn/linear-polynomial.5523c7cb6576ccab.webp\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>ಡಾಸಾನಿ ಮಡಿಪಳ್ಳಿ ಅವರ ಇನ್ಫೋಗ್ರಾಫಿಕ್</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"800\"}-->\n",
|
|
"\n",
|
|
"#### ಪರಿಚಯ\n",
|
|
"\n",
|
|
"ಈವರೆಗೆ ನೀವು ರಿಗ್ರೆಶನ್ ಎಂದರೇನು ಎಂಬುದನ್ನು ಪಂಪ್ಕಿನ್ ಪ್ರೈಸಿಂಗ್ ಡೇಟಾಸೆಟ್ನಿಂದ ಸಂಗ್ರಹಿಸಿದ ಮಾದರಿ ಡೇಟಾ ಮೂಲಕ ಅನ್ವೇಷಣೆ ಮಾಡಿದ್ದೀರಿ, ಇದನ್ನು ನಾವು ಈ ಪಾಠದಲ್ಲಿ ಬಳಸಲಿದ್ದೇವೆ. ನೀವು ಇದನ್ನು `ggplot2` ಬಳಸಿ ದೃಶ್ಯೀಕರಿಸಿದ್ದೀರಿ.💪\n",
|
|
"\n",
|
|
"ಈಗ ನೀವು ಎಂಎಲ್ ರಿಗ್ರೆಶನ್ನಲ್ಲಿ ಇನ್ನಷ್ಟು ಆಳವಾಗಿ ಹೋಗಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ. ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಎರಡು ವಿಧದ ರಿಗ್ರೆಶನ್ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ತಿಳಿಯಲಿದ್ದೀರಿ: *ಮೂಲಭೂತ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್* ಮತ್ತು *ಪೋಲಿನೋಮಿಯಲ್ ರಿಗ್ರೆಶನ್*, ಜೊತೆಗೆ ಈ ತಂತ್ರಜ್ಞಾನಗಳ ಹಿಂದೆ ಇರುವ ಕೆಲವು ಗಣಿತ.\n",
|
|
"\n",
|
|
"> ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ, ನಾವು ಗಣಿತದ ಕನಿಷ್ಠ ಜ್ಞಾನವನ್ನು ಊಹಿಸುತ್ತೇವೆ ಮತ್ತು ಇತರ ಕ್ಷೇತ್ರಗಳಿಂದ ಬರುವ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಇದನ್ನು ಸುಲಭಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಟಿಪ್ಪಣಿಗಳು, 🧮 ಕರೆಗಳು, ಚಿತ್ರಗಳು ಮತ್ತು ಇತರ ಕಲಿಕಾ ಸಾಧನಗಳನ್ನು ಗಮನಿಸಿ.\n",
|
|
"\n",
|
|
"#### ತಯಾರಿ\n",
|
|
"\n",
|
|
"ಒಂದು ಸ್ಮರಣಿಕೆಗಾಗಿ, ನೀವು ಈ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುತ್ತಿದ್ದೀರಿ ಇದರಿಂದ ಅದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು.\n",
|
|
"\n",
|
|
"- ಪಂಪ್ಕಿನ್ಗಳನ್ನು ಖರೀದಿಸಲು ಅತ್ಯುತ್ತಮ ಸಮಯ ಯಾವುದು?\n",
|
|
"\n",
|
|
"- ಒಂದು ಕೇಸ್ ಮಿನಿಯೇಚರ್ ಪಂಪ್ಕಿನ್ಗಳ ಬೆಲೆ ಎಷ್ಟು ನಿರೀಕ್ಷಿಸಬಹುದು?\n",
|
|
"\n",
|
|
"- ಅವುಗಳನ್ನು ಅರ್ಧ-ಬುಷೆಲ್ ಬಾಸ್ಕೆಟ್ಗಳಲ್ಲಿ ಖರೀದಿಸಬೇಕೇ ಅಥವಾ 1 1/9 ಬುಷೆಲ್ ಬಾಕ್ಸ್ ಮೂಲಕವೇ? ನಾವು ಈ ಡೇಟಾದ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಳಹದಿಯನ್ನು ಪರಿಶೀಲಿಸೋಣ.\n",
|
|
"\n",
|
|
"ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಒಂದು `ಟಿಬಲ್` (ಡೇಟಾ ಫ್ರೇಮ್ನ ಆಧುನಿಕ ಮರುಕಲ್ಪನೆ) ರಚಿಸಿ ಮೂಲ ಡೇಟಾಸೆಟ್ನ ಭಾಗವನ್ನು ತುಂಬಿದ್ದೀರಿ, ಬೆಲೆಯನ್ನು ಬುಷೆಲ್ ಪ್ರಕಾರ ಮಾನಕೀಕರಿಸಿದ್ದೀರಿ. ಆದರೂ, ನೀವು ಸುಮಾರು 400 ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಬಹುದಾಗಿತ್ತು ಮತ್ತು ಅದು ಕೇವಲ ಶರದೃತು ತಿಂಗಳುಗಳಿಗೆ ಮಾತ್ರ. ಡೇಟಾದ ಸ್ವಭಾವದ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ವಿವರಗಳನ್ನು ಪಡೆಯಲು ಅದನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಮೂಲಕ ನೋಡೋಣವೇ? ನೋಡೋಣ... 🕵️♀️\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",
|
|
"- `corrplot`: [corrplot ಪ್ಯಾಕೇಜ್](https://cran.r-project.org/web/packages/corrplot/vignettes/corrplot-intro.html) ಸಹಾಯದಿಂದ ಸಹಸಂಬಂಧ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಮೇಲೆ ದೃಶ್ಯಾತ್ಮಕ ಅನ್ವೇಷಣಾ ಸಾಧನವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಚರಗಳ ಪುನರ್ಕ್ರಮಣೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಚರಗಳ ನಡುವೆ ಮರೆಮಾಚಿದ ಮಾದರಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ನೀವು ಅವುಗಳನ್ನು ಇನ್ಸ್ಟಾಲ್ ಮಾಡಬಹುದು:\n",
|
|
"\n",
|
|
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"corrplot\"))`\n",
|
|
"\n",
|
|
"ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಘಟಕವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜ್ಗಳಿದ್ದರೆ ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅವು ಇಲ್ಲದಿದ್ದರೆ ನಿಮ್ಮಿಗಾಗಿ ಇನ್ಸ್ಟಾಲ್ ಮಾಡುತ್ತದೆ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "WqQPS1OAsg3H"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"suppressWarnings(if (!require(\"pacman\")) install.packages(\"pacman\"))\n",
|
|
"\n",
|
|
"pacman::p_load(tidyverse, tidymodels, janitor, corrplot)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "tA4C2WN3skCf",
|
|
"colab": {
|
|
"base_uri": "https://localhost:8080/"
|
|
},
|
|
"outputId": "c06cd805-5534-4edc-f72b-d0d1dab96ac0"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ನಾವು ನಂತರ ಈ ಅದ್ಭುತ ಪ್ಯಾಕೇಜ್ಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ ನಮ್ಮ ಪ್ರಸ್ತುತ R ಸೆಷನ್ನಲ್ಲಿ ಲಭ್ಯವಿರಿಸುವೆವು. (ಇದು ಕೇವಲ ಉದಾಹರಣೆಗೆ, `pacman::p_load()` ಈಗಾಗಲೇ ಅದನ್ನು ನಿಮ್ಮಿಗಾಗಿ ಮಾಡಿದೆ)\n",
|
|
"\n",
|
|
"## 1. ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ರೇಖೆ\n",
|
|
"\n",
|
|
"ನೀವು ಪಾಠ 1 ರಲ್ಲಿ ಕಲಿತಂತೆ, ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ವ್ಯಾಯಾಮದ ಗುರಿ ಎಂದರೆ *ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯ* *ರೇಖೆಯನ್ನು* ಚಿತ್ರಿಸಲು ಸಾಧ್ಯವಾಗುವುದು:\n",
|
|
"\n",
|
|
"- **ಚರಗಳ ಸಂಬಂಧಗಳನ್ನು ತೋರಿಸುವುದು**. ಚರಗಳ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ತೋರಿಸುವುದು\n",
|
|
"\n",
|
|
"- **ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು**. ಹೊಸ ಡೇಟಾ ಪಾಯಿಂಟ್ ಆ ರೇಖೆಯ ಸಂಬಂಧದಲ್ಲಿ ಎಲ್ಲಿ ಬಿದ್ದೀತು ಎಂಬುದರ ಬಗ್ಗೆ ನಿಖರ ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು.\n",
|
|
"\n",
|
|
"ಈ ರೀತಿಯ ರೇಖೆಯನ್ನು ಚಿತ್ರಿಸಲು, ನಾವು **ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್ ರಿಗ್ರೆಷನ್** ಎಂಬ ಸಂಖ್ಯಾಶಾಸ್ತ್ರೀಯ ತಂತ್ರವನ್ನು ಬಳಸುತ್ತೇವೆ. `least-squares` ಎಂಬ ಪದವು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳುವುದು, ರಿಗ್ರೆಷನ್ ರೇಖೆಯ ಸುತ್ತಲೂ ಇರುವ ಎಲ್ಲಾ ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳನ್ನು ವರ್ಗಮೂಲ ಮಾಡಿ ನಂತರ ಸೇರಿಸುವುದು. ಆದರ್ಶವಾಗಿ, ಅಂತಿಮ ಮೊತ್ತ ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಇರಬೇಕು, ಏಕೆಂದರೆ ನಾವು ತಪ್ಪುಗಳ ಸಂಖ್ಯೆ ಕಡಿಮೆ ಇರಬೇಕೆಂದು ಬಯಸುತ್ತೇವೆ, ಅಂದರೆ `least-squares`. ಆದ್ದರಿಂದ, ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆ ಎಂದರೆ ವರ್ಗಮೂಲ ತಪ್ಪುಗಳ ಮೊತ್ತಕ್ಕೆ ಅತ್ಯಂತ ಕಡಿಮೆ ಮೌಲ್ಯ ನೀಡುವ ರೇಖೆ - ಆದ್ದರಿಂದ ಇದರ ಹೆಸರು *ಲೀಸ್ಟ್ ಸ್ಕ್ವೇರ್ಸ್ ರಿಗ್ರೆಷನ್*.\n",
|
|
"\n",
|
|
"ನಾವು ಈ ರೇಖೆಯನ್ನು ಮಾಡುವುದು ಏಕೆಂದರೆ ನಾವು ನಮ್ಮ ಎಲ್ಲಾ ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳಿಂದ ಕನಿಷ್ಠ ಒಟ್ಟು ದೂರವಿರುವ ರೇಖೆಯನ್ನು ಮಾದರಿಯಾಗಿಸಬೇಕೆಂದು ಬಯಸುತ್ತೇವೆ. ನಾವು ಮೊದಲು ವರ್ಗಮೂಲಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಏಕೆಂದರೆ ನಾವು ಅದರ ದಿಕ್ಕಿನ ಬದಲು ಅದರ ಪ್ರಮಾಣದ ಬಗ್ಗೆ ಚಿಂತಿಸುತ್ತೇವೆ.\n",
|
|
"\n",
|
|
"> **🧮 ಗಣಿತವನ್ನು ತೋರಿಸಿ**\n",
|
|
">\n",
|
|
"> ಈ ರೇಖೆಯನ್ನು, *ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆ* ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, [ಒಂದು ಸಮೀಕರಣದಿಂದ](https://en.wikipedia.org/wiki/Simple_linear_regression) ವ್ಯಕ್ತಪಡಿಸಬಹುದು:\n",
|
|
">\n",
|
|
"> Y = a + bX\n",
|
|
">\n",
|
|
"> `X` ಎಂದರೆ '`ವಿವರಣೆ ಚರ` ಅಥವಾ `ಭವಿಷ್ಯವಾಣಿ ಚರ`'. `Y` ಎಂದರೆ '`ಆಧಾರಿತ ಚರ` ಅಥವಾ `ಫಲಿತಾಂಶ`'. ರೇಖೆಯ ತಿರುವು `b` ಆಗಿದ್ದು, `a` ಯು y-ಅಂತರವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು `X = 0` ಆಗಿರುವಾಗ `Y` ಯ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.\n",
|
|
">\n",
|
|
"\n",
|
|
"> ![](../../../../../../2-Regression/3-Linear/solution/images/slope.png \"slope = $y/x$\")\n",
|
|
" ಜೆನ್ ಲೂಪರ್ ರಚಿಸಿದ ಇನ್ಫೋಗ್ರಾಫಿಕ್\n",
|
|
">\n",
|
|
"> ಮೊದಲು, ತಿರುವು `b` ಅನ್ನು ಲೆಕ್ಕಹಾಕಿ.\n",
|
|
">\n",
|
|
"> ಬೇರೆ ಪದಗಳಲ್ಲಿ, ನಮ್ಮ ಕಂಬಳಿಯ ಮೂಲ ಪ್ರಶ್ನೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ: \"ತಿಂಗಳ ಪ್ರಕಾರ ಕಂಬಳಿಯ ಬೆಲೆಯನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡು\", `X` ಬೆಲೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು `Y` ಮಾರಾಟದ ತಿಂಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ.\n",
|
|
">\n",
|
|
"> \n",
|
|
" ಜೆನ್ ಲೂಪರ್ ರಚಿಸಿದ ಇನ್ಫೋಗ್ರಾಫಿಕ್\n",
|
|
"> \n",
|
|
"> Y ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಹಾಕಿ. ನೀವು ಸುಮಾರು \\$4 ಪಾವತಿಸುತ್ತಿದ್ದರೆ, ಅದು ಏಪ್ರಿಲ್ ಆಗಿರಬೇಕು!\n",
|
|
">\n",
|
|
"> ರೇಖೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವ ಗಣಿತವು ರೇಖೆಯ ತಿರುವನ್ನು ತೋರಿಸಬೇಕು, ಇದು ಅಂತರದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದು, ಅಂದರೆ `X = 0` ಆಗಿರುವಾಗ `Y` ಎಲ್ಲಿ ಇರುತ್ತದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ.\n",
|
|
">\n",
|
|
"> ಈ ಮೌಲ್ಯಗಳನ್ನು ಲೆಕ್ಕಹಾಕುವ ವಿಧಾನವನ್ನು ನೀವು [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ನೋಡಬಹುದು. ಜೊತೆಗೆ [ಈ ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್ ಕ್ಯಾಲ್ಕ್ಯುಲೇಟರ್](https://www.mathsisfun.com/data/least-squares-calculator.html) ಗೆ ಭೇಟಿ ನೀಡಿ ಸಂಖ್ಯೆಗಳ ಮೌಲ್ಯಗಳು ರೇಖೆಯನ್ನು ಹೇಗೆ ಪ್ರಭಾವಿಸುತ್ತವೆ ಎಂದು ನೋಡಿ.\n",
|
|
"\n",
|
|
"ಅಷ್ಟು ಭಯಂಕರವಲ್ಲ, ಅಲ್ಲವೇ? 🤓\n",
|
|
"\n",
|
|
"#### ಸಹಸಂಬಂಧ\n",
|
|
"\n",
|
|
"ಮತ್ತೊಂದು ಪದವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಿದೆ ಅದು ನೀಡಲಾದ X ಮತ್ತು Y ಚರಗಳ ನಡುವಿನ **ಸಹಸಂಬಂಧ ಗುಣಾಂಕ**. ಸ್ಕ್ಯಾಟರ್ಪ್ಲಾಟ್ ಬಳಸಿ, ನೀವು ಈ ಗುಣಾಂಕವನ್ನು ತ್ವರಿತವಾಗಿ ದೃಶ್ಯೀಕರಿಸಬಹುದು. ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳು ಸರಿಯಾದ ರೇಖೆಯಲ್ಲಿ ಸೆರೆಯಾದ ಪ್ಲಾಟ್ಗೆ ಹೆಚ್ಚಿನ ಸಹಸಂಬಂಧವಿರುತ್ತದೆ, ಆದರೆ X ಮತ್ತು Y ನಡುವೆ ಎಲ್ಲೆಡೆ ಸೆರೆಯಾದ ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳ ಪ್ಲಾಟ್ಗೆ ಕಡಿಮೆ ಸಹಸಂಬಂಧವಿರುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ಒಂದು ಉತ್ತಮ ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ಮಾದರಿ ಎಂದರೆ ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್ ರಿಗ್ರೆಷನ್ ವಿಧಾನವನ್ನು ಬಳಸಿ ರಿಗ್ರೆಷನ್ ರೇಖೆಯೊಂದಿಗೆ 1 ಗೆ ಹತ್ತಿರ (0 ಕಿಂತ ಹೆಚ್ಚು) ಇರುವ ಹೆಚ್ಚಿನ ಸಹಸಂಬಂಧ ಗುಣಾಂಕ ಹೊಂದಿರುವ ಮಾದರಿ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "cdX5FRpvsoP5"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## **2. ಡೇಟಾ ಜೊತೆಗೆ ನೃತ್ಯ: ಮಾದರಿಗಾಗಿ ಬಳಸಲಾಗುವ ಡೇಟಾ ಫ್ರೇಮ್ ರಚನೆ**\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../../../../../translated_images/kn/janitor.e4a77dd3d3e6a32e.webp\"\n",
|
|
" width=\"700\"/>\n",
|
|
" <figcaption>@allison_horst ಅವರ ಕಲಾಕೃತಿ</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"700\"}-->\n"
|
|
],
|
|
"metadata": {
|
|
"id": "WdUKXk7Bs8-V"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಅಗತ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು ಮತ್ತು ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿ. ಡೇಟಾವನ್ನು ಡೇಟಾ ಫ್ರೇಮ್ಗೆ ಪರಿವರ್ತಿಸಿ, ಇದರಲ್ಲಿ ಡೇಟಾದ ಉಪಸಮೂಹವಿದೆ:\n",
|
|
"\n",
|
|
"- ಬಸ್ಸೆಲ್ ಪ್ರಕಾರ ಬೆಲೆ ನಿಗದಿಪಡಿಸಿದ ಕಂಬಳಿಗಳನ್ನು ಮಾತ್ರ ಪಡೆಯಿರಿ\n",
|
|
"\n",
|
|
"- ದಿನಾಂಕವನ್ನು ತಿಂಗಳಾಗಿ ಪರಿವರ್ತಿಸಿ\n",
|
|
"\n",
|
|
"- ಬೆಲೆಯನ್ನು ಹೈ ಮತ್ತು ಲೋ ಬೆಲೆಗಳ ಸರಾಸರಿ ಆಗಿ ಲೆಕ್ಕಿಸಿ\n",
|
|
"\n",
|
|
"- ಬೆಲೆಯನ್ನು ಬಸ್ಸೆಲ್ ಪ್ರಮಾಣದ ಪ್ರಕಾರ ಪ್ರತಿಬಿಂಬಿಸುವಂತೆ ಪರಿವರ್ತಿಸಿ\n",
|
|
"\n",
|
|
"> ನಾವು ಈ ಹಂತಗಳನ್ನು [ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/2-Data/solution/lesson_2-R.ipynb) ಆವರಿಸಿಕೊಂಡಿದ್ದೇವೆ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "fMCtu2G2s-p8"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Load the core Tidyverse packages\n",
|
|
"library(tidyverse)\n",
|
|
"library(lubridate)\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 = 5)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "ryMVZEEPtERn"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಶುದ್ಧ ಸಾಹಸದ ಮನೋಭಾವದಲ್ಲಿ, ಕಳಪೆ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಸರಳ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುವ [`janitor package`](../../../../../../2-Regression/3-Linear/solution/R/github.com/sfirke/janitor) ಅನ್ನು ಅನ್ವೇಷಿಸೋಣ. ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಡೇಟಾದ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ನೋಡೋಣ:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "xcNxM70EtJjb"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Return column names\n",
|
|
"pumpkins %>% \n",
|
|
" names()"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "5XtpaIigtPfW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"🤔 ನಾವು ಇನ್ನೂ ಉತ್ತಮ ಮಾಡಬಹುದು. ಈ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು `janitor::clean_names` ಬಳಸಿ [snake_case](https://en.wikipedia.org/wiki/Snake_case) ಸಂಪ್ರದಾಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ `friendR` ಆಗಿಸೋಣ. ಈ ಫಂಕ್ಷನ್ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿಯಲು: `?clean_names`\n"
|
|
],
|
|
"metadata": {
|
|
"id": "IbIqrMINtSHe"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Clean names to the snake_case convention\n",
|
|
"pumpkins <- pumpkins %>% \n",
|
|
" clean_names(case = \"snake\")\n",
|
|
"\n",
|
|
"# Return column names\n",
|
|
"pumpkins %>% \n",
|
|
" names()"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "a2uYvclYtWvX"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಬಹಳ tidyR 🧹! ಈಗ, ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಇದ್ದಂತೆ `dplyr` ಬಳಸಿ ಡೇಟಾದೊಂದಿಗೆ ನೃತ್ಯ ಮಾಡೋಣ! 💃\n"
|
|
],
|
|
"metadata": {
|
|
"id": "HfhnuzDDtaDd"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Select desired columns\n",
|
|
"pumpkins <- pumpkins %>% \n",
|
|
" select(variety, city_name, package, low_price, high_price, date)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Extract the month from the dates to a new column\n",
|
|
"pumpkins <- pumpkins %>%\n",
|
|
" mutate(date = mdy(date),\n",
|
|
" month = month(date)) %>% \n",
|
|
" select(-date)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Create a new column for average Price\n",
|
|
"pumpkins <- pumpkins %>% \n",
|
|
" mutate(price = (low_price + high_price)/2)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Retain only pumpkins with the string \"bushel\"\n",
|
|
"new_pumpkins <- pumpkins %>% \n",
|
|
" filter(str_detect(string = package, pattern = \"bushel\"))\n",
|
|
"\n",
|
|
"\n",
|
|
"# Normalize the pricing so that you show the pricing per bushel, not per 1 1/9 or 1/2 bushel\n",
|
|
"new_pumpkins <- new_pumpkins %>% \n",
|
|
" mutate(price = case_when(\n",
|
|
" str_detect(package, \"1 1/9\") ~ price/(1.1),\n",
|
|
" str_detect(package, \"1/2\") ~ price*2,\n",
|
|
" TRUE ~ price))\n",
|
|
"\n",
|
|
"# Relocate column positions\n",
|
|
"new_pumpkins <- new_pumpkins %>% \n",
|
|
" relocate(month, .before = variety)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Display the first 5 rows\n",
|
|
"new_pumpkins %>% \n",
|
|
" slice_head(n = 5)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "X0wU3gQvtd9f"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಚೆನ್ನಾಗಿದೆ!👌 ಈಗ ನಿಮಗೆ ಹೊಸ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾಗುವ ಸ್ವಚ್ಛ, ಸುವ್ಯವಸ್ಥಿತ ಡೇಟಾ ಸೆಟ್ ಇದೆ!\n",
|
|
"\n",
|
|
"ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್ ಬೇಕೆ?\n"
|
|
],
|
|
"metadata": {
|
|
"id": "UpaIwaxqth82"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Set theme\n",
|
|
"theme_set(theme_light())\n",
|
|
"\n",
|
|
"# Make a scatter plot of month and price\n",
|
|
"new_pumpkins %>% \n",
|
|
" ggplot(mapping = aes(x = month, y = price)) +\n",
|
|
" geom_point(size = 1.6)\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "DXgU-j37tl5K"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಒಂದು ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್ ನಮಗೆ ಆಗಸ್ಟ್ನಿಂದ ಡಿಸೆಂಬರ್ ವರೆಗೆ ಮಾತ್ರ ತಿಂಗಳ ಡೇಟಾ ಇದೆ ಎಂದು ನೆನಪಿಸುತ್ತದೆ. ರೇಖೀಯ ರೀತಿಯಲ್ಲಿ ನಿರ್ಣಯಗಳನ್ನು ಬಿಡಿಸಲು ನಾವು ಬಹುಶಃ ಹೆಚ್ಚು ಡೇಟಾವನ್ನು ಬೇಕಾಗಬಹುದು.\n",
|
|
"\n",
|
|
"ನಮ್ಮ ಮಾದರೀಕರಣ ಡೇಟಾವನ್ನು ಮತ್ತೆ ನೋಡೋಣ:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "Ve64wVbwtobI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Display first 5 rows\n",
|
|
"new_pumpkins %>% \n",
|
|
" slice_head(n = 5)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "HFQX2ng1tuSJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ನಾವು `city` ಅಥವಾ `package` ಕಾಲಮ್ಗಳ ಆಧಾರದ ಮೇಲೆ ಕಂಬಳಿಯ `price` ಅನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಯಸಿದರೆ ಏನು ಆಗುತ್ತದೆ, ಅವುಗಳ ಪ್ರಕಾರವು character ಆಗಿದೆ? ಅಥವಾ ಇನ್ನಷ್ಟು ಸರಳವಾಗಿ, ಉದಾಹರಣೆಗೆ `package` ಮತ್ತು `price` ನಡುವಿನ ಸಹಸಂಬಂಧವನ್ನು (ಇದು ಎರಡೂ ಇನ್ಪುಟ್ಗಳು ಸಂಖ್ಯಾತ್ಮಕವಾಗಿರಬೇಕು) ಹೇಗೆ ಕಂಡುಹಿಡಿಯಬಹುದು? 🤷🤷\n",
|
|
"\n",
|
|
"ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳು ಪಠ್ಯ ಮೌಲ್ಯಗಳಿಗಿಂತ ಸಂಖ್ಯಾತ್ಮಕ ಲಕ್ಷಣಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯವಾಗಿ ವರ್ಗೀಕೃತ ಲಕ್ಷಣಗಳನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ಪ್ರತಿನಿಧಿಗಳಾಗಿ ಪರಿವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ಇದರಿಂದ, ನಾವು ನಮ್ಮ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾದರಿಯು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಸುಲಭವಾಗುವಂತೆ ಮರುರೂಪಗೊಳಿಸುವ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಾಗುತ್ತದೆ, ಇದನ್ನು `feature engineering` ಎಂದು ಕರೆಯುತ್ತಾರೆ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "7hsHoxsStyjJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 3. ಮಾದರಿಗಾಗಿ ಡೇಟಾವನ್ನು ಪೂರ್ವಸಿದ್ಧಗೊಳಿಸುವುದು recipes 👩🍳👨🍳 ಬಳಸಿ\n",
|
|
"\n",
|
|
"ಮಾದರಿಯು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಸುಲಭವಾಗುವಂತೆ ಭವಿಷ್ಯವಾಣಿ ಮೌಲ್ಯಗಳನ್ನು ಮರುರೂಪಗೊಳಿಸುವ ಚಟುವಟಿಕೆಗಳನ್ನು `ವೈಶಿಷ್ಟ್ಯ ಎಂಜಿನಿಯರಿಂಗ್` ಎಂದು ಕರೆಯಲಾಗಿದೆ.\n",
|
|
"\n",
|
|
"ವಿವಿಧ ಮಾದರಿಗಳಿಗೆ ವಿಭಿನ್ನ ಪೂರ್ವಸಿದ್ಧತೆ ಅಗತ್ಯವಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಲೀಸ್ಟ್ ಸ್ಕ್ವೇರ್ಗಳು `ಮಾಸ, ವೈವಿಧ್ಯ ಮತ್ತು ನಗರ_ಹೆಸರು` ಮುಂತಾದ `ವರ್ಗೀಕೃತ ಚರಗಳನ್ನು ಎನ್ಕೋಡ್ ಮಾಡುವುದು` ಅಗತ್ಯವಿದೆ. ಇದು ಸರಳವಾಗಿ `ವರ್ಗೀಕೃತ ಮೌಲ್ಯಗಳ` ಕಾಲಮ್ ಅನ್ನು ಮೂಲದ ಬದಲಿಗೆ ಒಂದು ಅಥವಾ ಹೆಚ್ಚು `ಸಂಖ್ಯಾತ್ಮಕ ಕಾಲಮ್ಗಳಾಗಿ` `ಅನುವಾದಿಸುವುದನ್ನು` ಒಳಗೊಂಡಿದೆ.\n",
|
|
"\n",
|
|
"ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಡೇಟಾದಲ್ಲಿ ಕೆಳಗಿನ ವರ್ಗೀಕೃತ ವೈಶಿಷ್ಟ್ಯವಿದೆ ಎಂದು فرضಿಸಿ:\n",
|
|
"\n",
|
|
"| ನಗರ |\n",
|
|
"|:-------:|\n",
|
|
"| ಡೆನ್ವರ್ |\n",
|
|
"| ನೈರೋಬಿ |\n",
|
|
"| ಟೋಕಿಯೋ |\n",
|
|
"\n",
|
|
"ನೀವು ಪ್ರತಿ ವರ್ಗಕ್ಕೆ ವಿಶಿಷ್ಟ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು *ಕ್ರಮಾಂಕ ಎನ್ಕೋಡಿಂಗ್* ಅನ್ನು ಅನ್ವಯಿಸಬಹುದು, ಹೀಗೆ:\n",
|
|
"\n",
|
|
"| ನಗರ |\n",
|
|
"|:----:|\n",
|
|
"| 0 |\n",
|
|
"| 1 |\n",
|
|
"| 2 |\n",
|
|
"\n",
|
|
"ಮತ್ತು ಅದೇನೂ ನಾವು ನಮ್ಮ ಡೇಟಾದ ಮೇಲೆ ಮಾಡಲಿದ್ದೇವೆ!\n",
|
|
"\n",
|
|
"ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಇನ್ನೊಂದು ಅದ್ಭುತ Tidymodels ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಅನ್ವೇಷಿಸುವೆವು: [recipes](https://tidymodels.github.io/recipes/) - ಇದು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿಗೆ ಒಳಪಡಿಸುವ **ಮುಂಬರುವ** ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಪೂರ್ವಸಿದ್ಧಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಮೂಲತಃ, ಒಂದು ರೆಸಿಪಿ ಎಂದರೆ ಮಾದರಿಗಾಗಿ ಸಿದ್ಧಪಡಿಸಲು ಡೇಟಾ ಸೆಟ್ಗೆ ಯಾವ ಹಂತಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕು ಎಂದು ನಿರ್ಧರಿಸುವ ವಸ್ತು.\n",
|
|
"\n",
|
|
"ಈಗ, ಭವಿಷ್ಯವಾಣಿ ಕಾಲಮ್ಗಳಲ್ಲಿನ ಎಲ್ಲಾ ವೀಕ್ಷಣೆಗಳಿಗೆ ವಿಶಿಷ್ಟ ಪೂರ್ಣಾಂಕವನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ನಮ್ಮ ಡೇಟಾವನ್ನು ಮಾದರಿಗಾಗಿ ಸಿದ್ಧಪಡಿಸುವ ರೆಸಿಪಿಯನ್ನು ರಚಿಸೋಣ:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "AD5kQbcvt3Xl"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Specify a recipe\n",
|
|
"pumpkins_recipe <- recipe(price ~ ., data = new_pumpkins) %>% \n",
|
|
" step_integer(all_predictors(), zero_based = TRUE)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print out the recipe\n",
|
|
"pumpkins_recipe"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "BNaFKXfRt9TU"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಅದ್ಭುತ! 👏 ನಾವು ಮೊದಲ ರೆಸಿಪಿಯನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದು ಒಂದು ಫಲಿತಾಂಶವನ್ನು (ಬೆಲೆ) ಮತ್ತು ಅದರ ಸಂಬಂಧಿತ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಭವಿಷ್ಯವಾಣಿ ಕಾಲಮ್ಗಳನ್ನು ಪೂರ್ಣಾಂಕಗಳ ಸೆಟ್ ಆಗಿ ಎನ್ಕೋಡ್ ಮಾಡಬೇಕು 🙌! ಬನ್ನಿ ಅದನ್ನು ತ್ವರಿತವಾಗಿ ವಿಭಜಿಸೋಣ:\n",
|
|
"\n",
|
|
"- `recipe()` ಗೆ ಫಾರ್ಮುಲಾ ಸಹಿತ ಕರೆ ಮಾಡುವುದರಿಂದ, `new_pumpkins` ಡೇಟಾವನ್ನು ಉಲ್ಲೇಖವಾಗಿ ಬಳಸಿಕೊಂಡು, ಚರಗಳ *ಪಾತ್ರಗಳನ್ನು* ರೆಸಿಪಿಗೆ ತಿಳಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, `price` ಕಾಲಮ್ಗೆ `outcome` ಪಾತ್ರವನ್ನು ನೀಡಲಾಗಿದೆ, ಉಳಿದ ಕಾಲಮ್ಗಳಿಗೆ `predictor` ಪಾತ್ರವನ್ನು ನೀಡಲಾಗಿದೆ.\n",
|
|
"\n",
|
|
"- `step_integer(all_predictors(), zero_based = TRUE)` ಎಲ್ಲಾ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಸಂಖ್ಯೆಗಳ ಸೆಟ್ ಆಗಿ ಪರಿವರ್ತಿಸಲು ಸೂಚಿಸುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ನೀವು ಈ ರೀತಿಯ ವಿಚಾರಗಳನ್ನು ಹೊಂದಿರಬಹುದು: \"ಇದು ತುಂಬಾ ಕುಲ್!! ಆದರೆ ನಾನು ರೆಸಿಪಿಗಳು ನಿಜವಾಗಿಯೂ ನಾನು ನಿರೀಕ್ಷಿಸುವಂತೆ ಕೆಲಸ ಮಾಡುತ್ತವೆಯೇ ಎಂದು ದೃಢೀಕರಿಸಬೇಕಾದರೆ? 🤔\"\n",
|
|
"\n",
|
|
"ಅದು ಅದ್ಭುತವಾದ ವಿಚಾರ! ನೀವು ನೋಡುತ್ತೀರಿ, ನಿಮ್ಮ ರೆಸಿಪಿ ವ್ಯಾಖ್ಯಾನವಾದ ನಂತರ, ನೀವು ಡೇಟಾವನ್ನು ಪೂರ್ವಸಿದ್ಧಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ಪರಿಮಾಣಗಳನ್ನು ಅಂದಾಜಿಸಬಹುದು ಮತ್ತು ನಂತರ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯಬಹುದು. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ Tidymodels ಬಳಸುವಾಗ ಇದನ್ನು ಮಾಡಬೇಕಾಗಿಲ್ಲ (ನಾವು ಸ್ವಲ್ಪ ಸಮಯದಲ್ಲಿ ಸಾಮಾನ್ಯ ಸಂಪ್ರದಾಯವನ್ನು ನೋಡುತ್ತೇವೆ -> `workflows`), ಆದರೆ ನೀವು ರೆಸಿಪಿಗಳು ನೀವು ನಿರೀಕ್ಷಿಸುವಂತೆ ಕೆಲಸ ಮಾಡುತ್ತವೆಯೇ ಎಂದು ದೃಢೀಕರಿಸಲು ಕೆಲವು ರೀತಿಯ ಮಾನಸಿಕ ಪರಿಶೀಲನೆ ಮಾಡಲು ಬಯಸಿದಾಗ ಇದು ಸಹಾಯಕವಾಗಬಹುದು.\n",
|
|
"\n",
|
|
"ಅದರಿಗಾಗಿ, ನಿಮಗೆ ಇನ್ನೂ ಎರಡು ಕ್ರಿಯಾಪದಗಳು ಬೇಕಾಗಿವೆ: `prep()` ಮತ್ತು `bake()` ಮತ್ತು ಯಾವಾಗಲೂ ಹಾಗೆಯೇ, ನಮ್ಮ ಸಣ್ಣ R ಸ್ನೇಹಿತರು [`Allison Horst`](https://github.com/allisonhorst/stats-illustrations) ಅವರಿಂದ ನಿಮಗೆ ಇದನ್ನು ಉತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತಾರೆ!\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../../../../../translated_images/kn/recipes.9ad10d8a4056bf89.webp\"\n",
|
|
" width=\"550\"/>\n",
|
|
" <figcaption>@allison_horst ಅವರ ಕಲಾಕೃತಿ</figcaption>\n"
|
|
],
|
|
"metadata": {
|
|
"id": "KEiO0v7kuC9O"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"[`prep()`](https://recipes.tidymodels.org/reference/prep.html): ತರಬೇತಿ ಸೆಟ್ನಿಂದ ಅಗತ್ಯವಾದ ಪರಿಮಾಣಗಳನ್ನು ಅಂದಾಜು ಮಾಡುತ್ತದೆ, ಅವುಗಳನ್ನು ನಂತರ ಇತರ ಡೇಟಾ ಸೆಟ್ಗಳಿಗೆ ಅನ್ವಯಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀಡಲಾದ ಭವಿಷ್ಯವಾಣಿ ಕಾಲಮ್ಗೆ, ಯಾವ ವೀಕ್ಷಣೆಗೆ ಪೂರ್ಣಾಂಕ 0 ಅಥವಾ 1 ಅಥವಾ 2 ಇತ್ಯಾದಿ ನಿಯೋಜಿಸಲಾಗುತ್ತದೆ.\n",
|
|
"\n",
|
|
"[`bake()`](https://recipes.tidymodels.org/reference/bake.html): ಪೂರ್ವಸಿದ್ಧವಾದ ರೆಸಿಪಿಯನ್ನು ತೆಗೆದು ಯಾವುದೇ ಡೇಟಾ ಸೆಟ್ಗೆ ಆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ಅಂದರೆ, ನಾವು ನಮ್ಮ ರೆಸಿಪಿಗಳನ್ನು ಪೂರ್ವಸಿದ್ಧಗೊಳಿಸಿ ಮತ್ತು ಬೇಕ್ ಮಾಡಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳೋಣ, ಅಂದರೆ ಒಳಗೆ, ಭವಿಷ್ಯವಾಣಿ ಕಾಲಮ್ಗಳನ್ನು ಮೊದಲು ಎನ್ಕೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ ನಂತರ ಮಾದರಿಯನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತದೆ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "Q1xtzebuuTCP"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Prep the recipe\n",
|
|
"pumpkins_prep <- prep(pumpkins_recipe)\n",
|
|
"\n",
|
|
"# Bake the recipe to extract a preprocessed new_pumpkins data\n",
|
|
"baked_pumpkins <- bake(pumpkins_prep, new_data = NULL)\n",
|
|
"\n",
|
|
"# Print out the baked data set\n",
|
|
"baked_pumpkins %>% \n",
|
|
" slice_head(n = 10)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "FGBbJbP_uUUn"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ವಾಹ್!🥳 ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ಡೇಟಾ `baked_pumpkins` ನಲ್ಲಿ ಅದರ ಎಲ್ಲಾ ಪೂರ್ವಕಾಲಿಕಗಳು ಎನ್ಕೋಡ್ ಆಗಿವೆ ಎಂದು ದೃಢೀಕರಿಸುತ್ತದೆ, ಇದು ನಿಜವಾಗಿಯೂ ನಮ್ಮ ರೆಸಿಪಿ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಪೂರ್ವಪ್ರಕ್ರಿಯೆ ಹಂತಗಳು ನಿರೀಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಇದರಿಂದ ಓದಲು ಸ್ವಲ್ಪ ಕಷ್ಟವಾಗಬಹುದು ಆದರೆ Tidymodels ಗೆ ಬಹಳ ಹೆಚ್ಚು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗುತ್ತದೆ! ಯಾವ ವೀಕ್ಷಣೆಯನ್ನು ಸಂಬಂಧಿತ ಪೂರ್ಣಾಂಕಕ್ಕೆ ನಕ್ಷೆ ಮಾಡಲಾಗಿದೆ ಎಂದು ಕಂಡುಹಿಡಿಯಲು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಿ.\n",
|
|
"\n",
|
|
"ಇದು ಕೂಡ ಹೇಳಬೇಕಾದದ್ದು, `baked_pumpkins` ಒಂದು ಡೇಟಾ ಫ್ರೇಮ್ ಆಗಿದ್ದು, ಅದರಲ್ಲಿ ನಾವು ಗಣನೆಗಳನ್ನು ನಡೆಸಬಹುದು.\n",
|
|
"\n",
|
|
"ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಡೇಟಾದ ಎರಡು ಬಿಂದುಗಳ ನಡುವೆ ಉತ್ತಮ ಸಂಬಂಧವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರಯತ್ನಿಸೋಣ, ಇದರಿಂದ ಉತ್ತಮ ಭವಿಷ್ಯವಾಣಿ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾಗಬಹುದು. ಇದಕ್ಕಾಗಿ ನಾವು `cor()` ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಫಂಕ್ಷನ್ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ `?cor()` ಟೈಪ್ ಮಾಡಿ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "1dvP0LBUueAW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Find the correlation between the city_name and the price\n",
|
|
"cor(baked_pumpkins$city_name, baked_pumpkins$price)\n",
|
|
"\n",
|
|
"# Find the correlation between the package and the price\n",
|
|
"cor(baked_pumpkins$package, baked_pumpkins$price)\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "3bQzXCjFuiSV"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಹಾಗಿದ್ದರೆ, ನಗರ ಮತ್ತು ಬೆಲೆಯ ನಡುವೆ ಕೇವಲ ದುರ್ಬಲ ಸಂಬಂಧವಿದೆ. ಆದರೆ ಪ್ಯಾಕೇಜ್ ಮತ್ತು ಅದರ ಬೆಲೆಯ ನಡುವೆ ಸ್ವಲ್ಪ ಉತ್ತಮ ಸಂಬಂಧವಿದೆ. ಅದು ಅರ್ಥವಾಗುತ್ತದೆ, ಅಲ್ಲವೇ? ಸಾಮಾನ್ಯವಾಗಿ, ಉತ್ಪನ್ನದ ಬಾಕ್ಸ್ ದೊಡ್ಡದಾಗಿದ್ದರೆ, ಬೆಲೆ ಹೆಚ್ಚು ಇರುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ನಾವು ಇದರಲ್ಲಿ ಇದ್ದಾಗ, `corrplot` ಪ್ಯಾಕೇಜ್ ಬಳಸಿ ಎಲ್ಲಾ ಕಾಲಮ್ಗಳ ಸಂಬಂಧ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "BToPWbgjuoZw"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Load the corrplot package\n",
|
|
"library(corrplot)\n",
|
|
"\n",
|
|
"# Obtain correlation matrix\n",
|
|
"corr_mat <- cor(baked_pumpkins %>% \n",
|
|
" # Drop columns that are not really informative\n",
|
|
" select(-c(low_price, high_price)))\n",
|
|
"\n",
|
|
"# Make a correlation plot between the variables\n",
|
|
"corrplot(corr_mat, method = \"shade\", shade.col = NA, tl.col = \"black\", tl.srt = 45, addCoef.col = \"black\", cl.pos = \"n\", order = \"original\")"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "ZwAL3ksmutVR"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"🤩🤩 ಬಹಳ ಉತ್ತಮ.\n",
|
|
"\n",
|
|
"ಈ ಡೇಟಾದ ಬಗ್ಗೆ ಈಗ ಕೇಳಬೇಕಾದ ಒಳ್ಳೆಯ ಪ್ರಶ್ನೆ ಏನೆಂದರೆ: '`ನನಗೆ ನೀಡಲಾದ ಪಂಪ್ಕಿನ್ ಪ್ಯಾಕೇಜ್ನ ಬೆಲೆ ಎಷ್ಟು ನಿರೀಕ್ಷಿಸಬಹುದು?`' ಬನ್ನಿ, ಅದಕ್ಕೆ ನೇರವಾಗಿ ಹೋಗೋಣ!\n",
|
|
"\n",
|
|
"> ಟಿಪ್ಪಣಿ: ನೀವು **`bake()`** ಮೂಲಕ ಪೂರ್ವಸಿದ್ಧ ರೆಸಿಪಿ **`pumpkins_prep`** ಅನ್ನು **`new_data = NULL`** ಜೊತೆ ಬಳಸಿದಾಗ, ನೀವು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ (ಅಂದರೆ ಎನ್ಕೋಡ್ ಮಾಡಿದ) ತರಬೇತಿ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯುತ್ತೀರಿ. ಉದಾಹರಣೆಗೆ, ನಿಮಗೆ ಇನ್ನೊಂದು ಡೇಟಾ ಸೆಟ್ ಇದ್ದರೆ, ಪರೀಕ್ಷಾ ಸೆಟ್ ಎಂದುಕೊಳ್ಳಿ, ಮತ್ತು ನೀವು ರೆಸಿಪಿ ಅದನ್ನು ಹೇಗೆ ಪೂರ್ವಸಿದ್ಧಗೊಳಿಸುವುದನ್ನು ನೋಡಲು ಬಯಸಿದರೆ, ನೀವು ಸರಳವಾಗಿ **`pumpkins_prep`** ಅನ್ನು **`new_data = test_set`** ಜೊತೆ bake ಮಾಡುತ್ತೀರಿ.\n",
|
|
"\n",
|
|
"## 4. ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../../../../../translated_images/kn/linear-polynomial.5523c7cb6576ccab.webp\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>ಡಾಸಾನಿ ಮಡಿಪಳ್ಳಿ ಅವರ ಇನ್ಫೋಗ್ರಾಫಿಕ್</figcaption>\n"
|
|
],
|
|
"metadata": {
|
|
"id": "YqXjLuWavNxW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಈಗ ನಾವು ಒಂದು ರೆಸಿಪಿ ರಚಿಸಿದ್ದೇವೆ, ಮತ್ತು ಡೇಟಾ ಸರಿಯಾಗಿ ಪೂರ್ವಪ್ರಕ್ರಿಯೆಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಂಡಿದ್ದೇವೆ, ಈಗ ನಾವು ಒಂದು ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸೋಣ ಮತ್ತು ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸೋಣ: `ನನಗೆ ನೀಡಲಾದ ಕಂಬಳಿಯ ಪ್ಯಾಕೇಜಿನ ಬೆಲೆ ಎಷ್ಟು ಇರಬಹುದು?`\n",
|
|
"\n",
|
|
"#### ತರಬೇತಿ ಸೆಟ್ ಬಳಸಿ ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ತರಬೇತಿಗೊಳಿಸಿ\n",
|
|
"\n",
|
|
"ನೀವು ಈಗಾಗಲೇ ಅರ್ಥಮಾಡಿಕೊಂಡಿರಬಹುದು, *ಬೆಲೆ* ಕಾಲಮ್ `ಫಲಿತಾಂಶ` ಚರವಾಗಿದ್ದು, *ಪ್ಯಾಕೇಜ್* ಕಾಲಮ್ `ಭವಿಷ್ಯವಾಣಿ` ಚರವಾಗಿದೆ.\n",
|
|
"\n",
|
|
"ಇದನ್ನು ಮಾಡಲು, ಮೊದಲು ಡೇಟಾವನ್ನು 80% ತರಬೇತಿಗೆ ಮತ್ತು 20% ಪರೀಕ್ಷಾ ಸೆಟ್ಗೆ ವಿಭಜಿಸೋಣ, ನಂತರ ಭವಿಷ್ಯವಾಣಿ ಕಾಲಮ್ ಅನ್ನು ಪೂರ್ಣಾಂಕಗಳ ಸರಣಿಯಾಗಿ ಎನ್ಕೋಡ್ ಮಾಡುವ ರೆಸಿಪಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ, ನಂತರ ಮಾದರಿ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ನಿರ್ಮಿಸೋಣ. ನಾವು ಈಗಾಗಲೇ ಡೇಟಾ ಪೂರ್ವಪ್ರಕ್ರಿಯೆಗೊಳ್ಳುತ್ತದೆ ಎಂದು ತಿಳಿದಿರುವುದರಿಂದ ನಮ್ಮ ರೆಸಿಪಿಯನ್ನು ಪ್ರೆಪ್ ಮತ್ತು ಬೇಕ್ ಮಾಡುವುದಿಲ್ಲ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "Pq0bSzCevW-h"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"set.seed(2056)\n",
|
|
"# Split the data into training and test sets\n",
|
|
"pumpkins_split <- new_pumpkins %>% \n",
|
|
" initial_split(prop = 0.8)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Extract training and test data\n",
|
|
"pumpkins_train <- training(pumpkins_split)\n",
|
|
"pumpkins_test <- testing(pumpkins_split)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Create a recipe for preprocessing the data\n",
|
|
"lm_pumpkins_recipe <- recipe(price ~ package, data = pumpkins_train) %>% \n",
|
|
" step_integer(all_predictors(), zero_based = TRUE)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Create a linear model specification\n",
|
|
"lm_spec <- linear_reg() %>% \n",
|
|
" set_engine(\"lm\") %>% \n",
|
|
" set_mode(\"regression\")"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "CyoEh_wuvcLv"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಚೆನ್ನಾಗಿದೆ! ಈಗ ನಮಗೆ ಒಂದು ರೆಸಿಪಿ ಮತ್ತು ಒಂದು ಮಾದರಿ ವಿವರಣೆ ಇದ್ದು, ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಒಂದು ವಸ್ತುವಾಗಿ ಬಂಡಲ್ ಮಾಡುವ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಾಗಿದೆ, ಅದು ಮೊದಲು ಡೇಟಾವನ್ನು ಪೂರ್ವಸಿದ್ಧತೆ ಮಾಡುತ್ತದೆ (ಹಿಂದಿನ ದೃಶ್ಯದಲ್ಲಿ prep+bake), ಪೂರ್ವಸಿದ್ಧತೆ ಮಾಡಿದ ಡೇಟಾದ ಮೇಲೆ ಮಾದರಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಸಾಧ್ಯವಾದ ನಂತರದ ಪ್ರಕ್ರಿಯೆಗಳಿಗೂ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ನಿಮ್ಮ ಮನಸ್ಸಿಗೆ ಇದು ಹೇಗಿದೆ!🤩\n",
|
|
"\n",
|
|
"Tidymodels ನಲ್ಲಿ, ಈ ಅನುಕೂಲಕರ ವಸ್ತುವನ್ನು [`workflow`](https://workflows.tidymodels.org/) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಇದು ನಿಮ್ಮ ಮಾದರಿ ಘಟಕಗಳನ್ನು ಅನುಕೂಲಕರವಾಗಿ ಹಿಡಿದಿಡುತ್ತದೆ! Python ನಲ್ಲಿ ಇದನ್ನು *pipelines* ಎಂದು ಕರೆಯುತ್ತೇವೆ.\n",
|
|
"\n",
|
|
"ಹೀಗಾಗಿ ಎಲ್ಲವನ್ನೂ workflow ಗೆ ಬಂಡಲ್ ಮಾಡೋಣ!📦\n"
|
|
],
|
|
"metadata": {
|
|
"id": "G3zF_3DqviFJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Hold modelling components in a workflow\n",
|
|
"lm_wf <- workflow() %>% \n",
|
|
" add_recipe(lm_pumpkins_recipe) %>% \n",
|
|
" add_model(lm_spec)\n",
|
|
"\n",
|
|
"# Print out the workflow\n",
|
|
"lm_wf"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "T3olroU3v-WX"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"👌 ಜೊತೆಗೆ, ಒಂದು ವರ್ಕ್ಫ್ಲೋವನ್ನು ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸುವಂತೆ ಅಥವಾ ಹೊಂದಿಸುವಂತೆ ಮಾಡಬಹುದು.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "zd1A5tgOwEPX"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Train the model\n",
|
|
"lm_wf_fit <- lm_wf %>% \n",
|
|
" fit(data = pumpkins_train)\n",
|
|
"\n",
|
|
"# Print the model coefficients learned \n",
|
|
"lm_wf_fit"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "NhJagFumwFHf"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಮಾದರಿ ಔಟ್ಪುಟ್ನಿಂದ, ನಾವು ತರಬೇತಿ ಸಮಯದಲ್ಲಿ ಕಲಿತ ಸಹಗುಣಾಂಕಗಳನ್ನು ನೋಡಬಹುದು. ಅವುಗಳು ನಿಜವಾದ ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲಾದ ಚರಗಳ ನಡುವೆ ಒಟ್ಟು ತಪ್ಪು ಕಡಿಮೆ ಆಗುವ ಅತ್ಯುತ್ತಮ ಸರಳರೇಖೆಯ ಸಹಗುಣಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.\n",
|
|
"\n",
|
|
"\n",
|
|
"#### ಪರೀಕ್ಷಾ ಸೆಟ್ ಬಳಸಿ ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ\n",
|
|
"\n",
|
|
"ಮಾದರಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಿತು ಎಂದು ನೋಡಲು ಸಮಯವಾಗಿದೆ 📏! ನಾವು ಇದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೇವೆ?\n",
|
|
"\n",
|
|
"ಈಗ ನಾವು ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಿದ್ದರಿಂದ, `parsnip::predict()` ಬಳಸಿ test_set ಗೆ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡಬಹುದು. ನಂತರ ನಾವು ಈ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ನಿಜವಾದ ಲೇಬಲ್ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಹೋಲಿಸಿ ಮಾದರಿ ಎಷ್ಟು ಚೆನ್ನಾಗಿ (ಅಥವಾ ಇಲ್ಲ!) ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡಬಹುದು.\n",
|
|
"\n",
|
|
"ಮೊದಲು ಪರೀಕ್ಷಾ ಸೆಟ್ಗೆ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡೋಣ ಮತ್ತು ನಂತರ ಆ ಕಾಲಮ್ಗಳನ್ನು ಪರೀಕ್ಷಾ ಸೆಟ್ಗೆ ಜೋಡಿಸೋಣ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "_4QkGtBTwItF"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make predictions for the test set\n",
|
|
"predictions <- lm_wf_fit %>% \n",
|
|
" predict(new_data = pumpkins_test)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Bind predictions to the test set\n",
|
|
"lm_results <- pumpkins_test %>% \n",
|
|
" select(c(package, price)) %>% \n",
|
|
" bind_cols(predictions)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print the first ten rows of the tibble\n",
|
|
"lm_results %>% \n",
|
|
" slice_head(n = 10)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "UFZzTG0gwTs9"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಹೌದು, ನೀವು ಇತ್ತೀಚೆಗೆ ಒಂದು ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಂಡು ಅದನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಳಸಿದ್ದೀರಿ!🔮 ಇದು ಎಷ್ಟು ಉತ್ತಮವಾಗಿದೆ ಎಂದು ನೋಡೋಣ, ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡೋಣ!\n",
|
|
"\n",
|
|
"Tidymodels ನಲ್ಲಿ, ನಾವು ಇದನ್ನು `yardstick::metrics()` ಬಳಸಿ ಮಾಡುತ್ತೇವೆ! ರೇಖೀಯ ರಿಗ್ರೆಶನ್ಗಾಗಿ, ಕೆಳಗಿನ ಮೆಟ್ರಿಕ್ಸ್ಗಳ ಮೇಲೆ ಗಮನಹರಿಸೋಣ:\n",
|
|
"\n",
|
|
"- `Root Mean Square Error (RMSE)`: [MSE](https://en.wikipedia.org/wiki/Mean_squared_error) ಯ ಚದರ ಮೂಲ. ಇದು ಲೇಬಲ್ನ (ಈ ಪ್ರಕರಣದಲ್ಲಿ, ಕಂಬಳಿಯ ಬೆಲೆ) ಅದೇ ಘಟಕದಲ್ಲಿ ಪರಮಾಣು ಮೆಟ್ರಿಕ್ ಅನ್ನು ನೀಡುತ್ತದೆ. ಮೌಲ್ಯವು ಕಡಿಮೆ ಇದ್ದರೆ, ಮಾದರಿ ಉತ್ತಮವಾಗಿದೆ (ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಇದು ಭವಿಷ್ಯವಾಣಿಗಳು ತಪ್ಪಾಗಿರುವ ಸರಾಸರಿ ಬೆಲೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ!)\n",
|
|
"\n",
|
|
"- `Coefficient of Determination (ಸಾಮಾನ್ಯವಾಗಿ R-squared ಅಥವಾ R2 ಎಂದು ಕರೆಯಲ್ಪಡುವುದು)`: ಇದು ಸಾಪೇಕ್ಷ ಮೆಟ್ರಿಕ್ ಆಗಿದ್ದು, ಮೌಲ್ಯವು ಹೆಚ್ಚು ಇದ್ದರೆ, ಮಾದರಿಯ ಹೊಂದಾಣಿಕೆ ಉತ್ತಮವಾಗಿದೆ. ಮೂಲತಃ, ಈ ಮೆಟ್ರಿಕ್ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿದ ಮತ್ತು ನಿಜವಾದ ಲೇಬಲ್ ಮೌಲ್ಯಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾದರಿ ಎಷ್ಟು ವಿವರಿಸಬಹುದು ಎಂಬುದನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "0A5MjzM7wW9M"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Evaluate performance of linear regression\n",
|
|
"metrics(data = lm_results,\n",
|
|
" truth = price,\n",
|
|
" estimate = .pred)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "reJ0UIhQwcEH"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಮಾಡೆಲ್ ಕಾರ್ಯಕ್ಷಮತೆ ಇಲ್ಲಿಗೆ ಹೋಗುತ್ತದೆ. ಪ್ಯಾಕೇಜ್ ಮತ್ತು ಬೆಲೆಯ scatter ಪ್ಲಾಟ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸುವ ಮೂಲಕ ನಾವು ಉತ್ತಮ ಸೂಚನೆಯನ್ನು ಪಡೆಯಬಹುದೇ ಎಂದು ನೋಡೋಣ, ನಂತರ ಮಾಡಲಾದ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆಯನ್ನು ಓವರ್ಲೆ ಮಾಡೋಣ.\n",
|
|
"\n",
|
|
"ಇದಕ್ಕೆ ಅರ್ಥ, ನಾವು ಪ್ಯಾಕೇಜ್ ಕಾಲಮ್ ಅನ್ನು ಎನ್ಕೋಡ್ ಮಾಡಲು ಟೆಸ್ಟ್ ಸೆಟ್ ಅನ್ನು ತಯಾರಿಸಿ ಬೇಕ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ನಂತರ ಇದನ್ನು ನಮ್ಮ ಮಾಡೆಲ್ ಮಾಡಿದ ಭವಿಷ್ಯವಾಣಿಗಳೊಂದಿಗೆ ಬಾಂಧಿಸಬೇಕು.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "fdgjzjkBwfWt"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Encode package column\n",
|
|
"package_encode <- lm_pumpkins_recipe %>% \n",
|
|
" prep() %>% \n",
|
|
" bake(new_data = pumpkins_test) %>% \n",
|
|
" select(package)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Bind encoded package column to the results\n",
|
|
"lm_results <- lm_results %>% \n",
|
|
" bind_cols(package_encode %>% \n",
|
|
" rename(package_integer = package)) %>% \n",
|
|
" relocate(package_integer, .after = package)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print new results data frame\n",
|
|
"lm_results %>% \n",
|
|
" slice_head(n = 5)\n",
|
|
"\n",
|
|
"\n",
|
|
"# Make a scatter plot\n",
|
|
"lm_results %>% \n",
|
|
" ggplot(mapping = aes(x = package_integer, y = price)) +\n",
|
|
" geom_point(size = 1.6) +\n",
|
|
" # Overlay a line of best fit\n",
|
|
" geom_line(aes(y = .pred), color = \"orange\", size = 1.2) +\n",
|
|
" xlab(\"package\")\n",
|
|
" \n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "R0nw719lwkHE"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಅದ್ಭುತ! ನೀವು ನೋಡಬಹುದು, ಲೀನಿಯರ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿ ಪ್ಯಾಕೇಜ್ ಮತ್ತು ಅದರ ಸಂಬಂಧಿತ ಬೆಲೆಯ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಚೆನ್ನಾಗಿ ಸಾಮಾನ್ಯಗೊಳಿಸುವುದಿಲ್ಲ.\n",
|
|
"\n",
|
|
"🎃 ಅಭಿನಂದನೆಗಳು, ನೀವು ಕೆಲವು ಬಗೆಯ ಕಂಬಳಿಗಳ ಬೆಲೆಯನ್ನು ಊಹಿಸಲು ಸಹಾಯ ಮಾಡುವ ಮಾದರಿಯನ್ನು ಸೃಷ್ಟಿಸಿದ್ದೀರಿ. ನಿಮ್ಮ ಹಬ್ಬದ ಕಂಬಳಿ ತೋಟ ಸುಂದರವಾಗಿರುತ್ತದೆ. ಆದರೆ ನೀವು ಬಹುಶಃ ಉತ್ತಮ ಮಾದರಿಯನ್ನು ರಚಿಸಬಹುದು!\n",
|
|
"\n",
|
|
"## 5. ಬಹುಪದ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../../../../../translated_images/kn/linear-polynomial.5523c7cb6576ccab.webp\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>ದಾಸನಿ ಮಡಿಪಳ್ಳಿ ಅವರ ಇನ್ಫೋಗ್ರಾಫಿಕ್</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"800\"}-->\n"
|
|
],
|
|
"metadata": {
|
|
"id": "HOCqJXLTwtWI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಕೆಲವೊಮ್ಮೆ ನಮ್ಮ ಡೇಟಾದಲ್ಲಿ ರೇಖೀಯ ಸಂಬಂಧವಿರದಿರಬಹುದು, ಆದರೆ ನಾವು ಇನ್ನೂ ಫಲಿತಾಂಶವನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಬಹುಪದೀಯ ರಿಗ್ರೆಶನ್ ನಮಗೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ರೇಖೀಯವಲ್ಲದ ಸಂಬಂಧಗಳಿಗೆ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಸಹಾಯ ಮಾಡಬಹುದು.\n",
|
|
"\n",
|
|
"ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಕಂಬಳಿಗಳ ಡೇಟಾ ಸೆಟ್ನ ಪ್ಯಾಕೇಜ್ ಮತ್ತು ಬೆಲೆಯ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. ಕೆಲವೊಮ್ಮೆ ಚರಗಳ ನಡುವೆ ರೇಖೀಯ ಸಂಬಂಧವಿರುತ್ತದೆ - ಕಂಬಳಿಯ ವಾಲ್ಯೂಮ್ ದೊಡ್ಡದಾದಂತೆ ಬೆಲೆ ಹೆಚ್ಚಾಗುತ್ತದೆ - ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಈ ಸಂಬಂಧಗಳನ್ನು ಸಮತಲ ಅಥವಾ ಸರಳ ರೇಖೆಯಾಗಿ ಚಿತ್ರಿಸಲಾಗುವುದಿಲ್ಲ.\n",
|
|
"\n",
|
|
"> ✅ ಇಲ್ಲಿ [ಇನ್ನಷ್ಟು ಉದಾಹರಣೆಗಳು](https://online.stat.psu.edu/stat501/lesson/9/9.8) ಇವೆ, ಬಹುಪದೀಯ ರಿಗ್ರೆಶನ್ ಬಳಸಬಹುದಾದ ಡೇಟಾಗಳಿಗೆ\n",
|
|
">\n",
|
|
"> ಹಿಂದಿನ ಪ್ಲಾಟ್ನಲ್ಲಿ ವೈವಿಧ್ಯದಿಂದ ಬೆಲೆಯ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಮತ್ತೊಮ್ಮೆ ನೋಡಿ. ಈ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್ ಅನ್ನು ಅವಶ್ಯಕವಾಗಿ ಸರಳ ರೇಖೆಯಿಂದ ವಿಶ್ಲೇಷಿಸಬೇಕೆಂದು ತೋರುತ್ತದೆಯೇ? ಬಹುಶಃ ಅಲ್ಲ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಬಹುಪದೀಯ ರಿಗ್ರೆಶನ್ ಪ್ರಯತ್ನಿಸಬಹುದು.\n",
|
|
">\n",
|
|
"> ✅ ಬಹುಪದೀಯಗಳು ಗಣಿತೀಯ ಅಭಿವ್ಯಕ್ತಿಗಳು, ಅವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಚರಗಳು ಮತ್ತು ಗುಣಾಂಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು\n",
|
|
"\n",
|
|
"#### ತರಬೇತಿ ಸೆಟ್ ಬಳಸಿ ಬಹುಪದೀಯ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಿ\n",
|
|
"\n",
|
|
"ಬಹುಪದೀಯ ರಿಗ್ರೆಶನ್ *ವಕ್ರ ರೇಖೆ* ರಚಿಸಿ ರೇಖೀಯವಲ್ಲದ ಡೇಟಾಗೆ ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ.\n",
|
|
"\n",
|
|
"ಬಹುಪದೀಯ ಮಾದರಿ ಭವಿಷ್ಯವಾಣಿಯಲ್ಲಿ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ತೋರಿಸುವುದೇ ಎಂದು ನೋಡೋಣ. ನಾವು ಹಿಂದಿನಂತೆ ಸ್ವಲ್ಪ ಸಮಾನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅನುಸರಿಸುವೆವು:\n",
|
|
"\n",
|
|
"- ನಮ್ಮ ಡೇಟಾವನ್ನು ಮಾದರಿಗಾಗಿ ಸಿದ್ಧಪಡಿಸಲು ಮಾಡಬೇಕಾದ ಪೂರ್ವಪ್ರಕ್ರಿಯೆಗಳ ಹಂತಗಳನ್ನು ಸೂಚಿಸುವ ರೆಸಿಪಿ ರಚಿಸಿ, ಅಂದರೆ: ಭವಿಷ್ಯವಾಣಿಕಾರರನ್ನು ಎನ್ಕೋಡ್ ಮಾಡುವುದು ಮತ್ತು ಡಿಗ್ರಿ *n* ರ ಬಹುಪದೀಯಗಳನ್ನು ಲೆಕ್ಕಹಾಕುವುದು\n",
|
|
"\n",
|
|
"- ಮಾದರಿ ನಿರ್ದಿಷ್ಟೀಕರಣವನ್ನು ನಿರ್ಮಿಸಿ\n",
|
|
"\n",
|
|
"- ರೆಸಿಪಿ ಮತ್ತು ಮಾದರಿ ನಿರ್ದಿಷ್ಟೀಕರಣವನ್ನು ವರ್ಕ್ಫ್ಲೋದಲ್ಲಿ ಸಂಯೋಜಿಸಿ\n",
|
|
"\n",
|
|
"- ವರ್ಕ್ಫ್ಲೋವನ್ನು ಹೊಂದಿಸಿ ಮಾದರಿಯನ್ನು ರಚಿಸಿ\n",
|
|
"\n",
|
|
"- ಪರೀಕ್ಷಾ ಡೇಟಾದ ಮೇಲೆ ಮಾದರಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ\n",
|
|
"\n",
|
|
"ನೇರವಾಗಿ ಪ್ರಾರಂಭಿಸೋಣ!\n"
|
|
],
|
|
"metadata": {
|
|
"id": "VcEIpRV9wzYr"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Specify a recipe\r\n",
|
|
"poly_pumpkins_recipe <-\r\n",
|
|
" recipe(price ~ package, data = pumpkins_train) %>%\r\n",
|
|
" step_integer(all_predictors(), zero_based = TRUE) %>% \r\n",
|
|
" step_poly(all_predictors(), degree = 4)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Create a model specification\r\n",
|
|
"poly_spec <- linear_reg() %>% \r\n",
|
|
" set_engine(\"lm\") %>% \r\n",
|
|
" set_mode(\"regression\")\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Bundle recipe and model spec into a workflow\r\n",
|
|
"poly_wf <- workflow() %>% \r\n",
|
|
" add_recipe(poly_pumpkins_recipe) %>% \r\n",
|
|
" add_model(poly_spec)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Create a model\r\n",
|
|
"poly_wf_fit <- poly_wf %>% \r\n",
|
|
" fit(data = pumpkins_train)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Print learned model coefficients\r\n",
|
|
"poly_wf_fit\r\n",
|
|
"\r\n",
|
|
" "
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "63n_YyRXw3CC"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"#### ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ\n",
|
|
"\n",
|
|
"👏👏ನೀವು ಒಂದು ಬಹುಪದ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ, ಬನ್ನಿ ಪರೀಕ್ಷಾ ಸೆಟ್ ಮೇಲೆ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮಾಡೋಣ!\n"
|
|
],
|
|
"metadata": {
|
|
"id": "-LHZtztSxDP0"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make price predictions on test data\r\n",
|
|
"poly_results <- poly_wf_fit %>% predict(new_data = pumpkins_test) %>% \r\n",
|
|
" bind_cols(pumpkins_test %>% select(c(package, price))) %>% \r\n",
|
|
" relocate(.pred, .after = last_col())\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Print the results\r\n",
|
|
"poly_results %>% \r\n",
|
|
" slice_head(n = 10)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "YUFpQ_dKxJGx"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ವು-ಹೂ, ನಾವು `yardstick::metrics()` ಬಳಸಿ ಮಾದರಿಯು test_set ಮೇಲೆ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಿತು ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡೋಣ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "qxdyj86bxNGZ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"metrics(data = poly_results, truth = price, estimate = .pred)"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "8AW5ltkBxXDm"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"🤩🤩 ಬಹಳ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆ.\n",
|
|
"\n",
|
|
"`rmse` ಸುಮಾರು 7 ರಿಂದ ಸುಮಾರು 3 ಕ್ಕೆ ಇಳಿದಿದೆ, ಇದು ನಿಜವಾದ ಬೆಲೆ ಮತ್ತು ಊಹಿಸಲಾದ ಬೆಲೆಯ ನಡುವೆ ಕಡಿಮೆ ದೋಷವಿರುವ ಸೂಚನೆ. ನೀವು ಇದನ್ನು *ಸಡಿಲವಾಗಿ* ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು ಎಂದರೆ ಸರಾಸರಿಯಾಗಿ, ತಪ್ಪು ಊಹೆಗಳು ಸುಮಾರು \\$3 ದಿಂದ ತಪ್ಪಾಗಿವೆ. `rsq` ಸುಮಾರು 0.4 ರಿಂದ 0.8 ಕ್ಕೆ ಏರಿದೆ.\n",
|
|
"\n",
|
|
"ಈ ಎಲ್ಲಾ ಅಳತೆಗಳು ಬಹುಪದ ಮಾದರಿ ರೇಖೀಯ ಮಾದರಿಗಿಂತ ಬಹಳ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಸೂಚಿಸುತ್ತವೆ. ಚೆನ್ನಾಗಿದೆ!\n",
|
|
"\n",
|
|
"ನಾವು ಇದನ್ನು ದೃಶ್ಯೀಕರಿಸಬಹುದೇ ನೋಡೋಣ!\n"
|
|
],
|
|
"metadata": {
|
|
"id": "6gLHNZDwxYaS"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Bind encoded package column to the results\r\n",
|
|
"poly_results <- poly_results %>% \r\n",
|
|
" bind_cols(package_encode %>% \r\n",
|
|
" rename(package_integer = package)) %>% \r\n",
|
|
" relocate(package_integer, .after = package)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Print new results data frame\r\n",
|
|
"poly_results %>% \r\n",
|
|
" slice_head(n = 5)\r\n",
|
|
"\r\n",
|
|
"\r\n",
|
|
"# Make a scatter plot\r\n",
|
|
"poly_results %>% \r\n",
|
|
" ggplot(mapping = aes(x = package_integer, y = price)) +\r\n",
|
|
" geom_point(size = 1.6) +\r\n",
|
|
" # Overlay a line of best fit\r\n",
|
|
" geom_line(aes(y = .pred), color = \"midnightblue\", size = 1.2) +\r\n",
|
|
" xlab(\"package\")\r\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "A83U16frxdF1"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ನೀವು ನಿಮ್ಮ ಡೇಟಾಗೆ ಉತ್ತಮವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುವ ವಕ್ರ ರೇಖೆಯನ್ನು ನೋಡಬಹುದು! 🤩\n",
|
|
"\n",
|
|
"ನೀವು ಇದನ್ನು ಇನ್ನಷ್ಟು ಸ್ಮೂತ್ ಆಗಿಸಲು `geom_smooth` ಗೆ ಪೋಲಿನೋಮಿಯಲ್ ಸೂತ್ರವನ್ನು ಹೀಗೆ ಪಾಸ್ ಮಾಡಬಹುದು:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "4U-7aHOVxlGU"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make a scatter plot\r\n",
|
|
"poly_results %>% \r\n",
|
|
" ggplot(mapping = aes(x = package_integer, y = price)) +\r\n",
|
|
" geom_point(size = 1.6) +\r\n",
|
|
" # Overlay a line of best fit\r\n",
|
|
" geom_smooth(method = lm, formula = y ~ poly(x, degree = 4), color = \"midnightblue\", size = 1.2, se = FALSE) +\r\n",
|
|
" xlab(\"package\")"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "5vzNT0Uexm-w"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ಮೃದುವಾದ ವಕ್ರರೇಖೆಯಂತೆ!🤩\n",
|
|
"\n",
|
|
"ಹೊಸ ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವ ವಿಧಾನ ಇಲ್ಲಿದೆ:\n"
|
|
],
|
|
"metadata": {
|
|
"id": "v9u-wwyLxq4G"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"source": [
|
|
"# Make a hypothetical data frame\r\n",
|
|
"hypo_tibble <- tibble(package = \"bushel baskets\")\r\n",
|
|
"\r\n",
|
|
"# Make predictions using linear model\r\n",
|
|
"lm_pred <- lm_wf_fit %>% predict(new_data = hypo_tibble)\r\n",
|
|
"\r\n",
|
|
"# Make predictions using polynomial model\r\n",
|
|
"poly_pred <- poly_wf_fit %>% predict(new_data = hypo_tibble)\r\n",
|
|
"\r\n",
|
|
"# Return predictions in a list\r\n",
|
|
"list(\"linear model prediction\" = lm_pred, \r\n",
|
|
" \"polynomial model prediction\" = poly_pred)\r\n"
|
|
],
|
|
"outputs": [],
|
|
"metadata": {
|
|
"id": "jRPSyfQGxuQv"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"`ಪಾಲಿನೋಮಿಯಲ್ ಮಾದರಿ` ಭವಿಷ್ಯವಾಣಿ ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ, `ಬೆಲೆ` ಮತ್ತು `ಪ್ಯಾಕೇಜ್`ಗಳ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್ಗಳನ್ನು ಗಮನಿಸಿದರೆ! ಮತ್ತು, ಇದು ಹಿಂದಿನ ಮಾದರಿಗಿಂತ ಉತ್ತಮ ಮಾದರಿ ಆಗಿದ್ದರೆ, ಅದೇ ಡೇಟಾವನ್ನು ನೋಡಿದಾಗ, ನೀವು ಈ ಹೆಚ್ಚು ದುಬಾರಿ ಕಂಬಳಿಗಳನ್ನು ಬಜೆಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ!\n",
|
|
"\n",
|
|
"🏆 ಚೆನ್ನಾಗಿದೆ! ನೀವು ಒಂದು ಪಾಠದಲ್ಲಿ ಎರಡು ರಿಗ್ರೆಷನ್ ಮಾದರಿಗಳನ್ನು ರಚಿಸಿದ್ದೀರಿ. ರಿಗ್ರೆಷನ್ನ ಅಂತಿಮ ವಿಭಾಗದಲ್ಲಿ, ವರ್ಗಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಷನ್ ಬಗ್ಗೆ ತಿಳಿಯುತ್ತೀರಿ.\n",
|
|
"\n",
|
|
"## **🚀ಸವಾಲು**\n",
|
|
"\n",
|
|
"ಈ ನೋಟ್ಬುಕ್ನಲ್ಲಿ ವಿವಿಧ ಚರಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ, ಸಹಸಂಬಂಧವು ಮಾದರಿ ನಿಖರತೆಗೆ ಹೇಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ನೋಡಿ.\n",
|
|
"\n",
|
|
"## [**ಪಾಠೋತ್ತರ ಕ್ವಿಜ್**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/14/)\n",
|
|
"\n",
|
|
"## **ಪುನರ್ ಪರಿಶೀಲನೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ**\n",
|
|
"\n",
|
|
"ಈ ಪಾಠದಲ್ಲಿ ನಾವು ಲೀನಿಯರ್ ರಿಗ್ರೆಷನ್ ಬಗ್ಗೆ ಕಲಿತೆವು. ಇನ್ನೂ ಕೆಲವು ಪ್ರಮುಖ ರಿಗ್ರೆಷನ್ ಪ್ರಕಾರಗಳಿವೆ. ಸ್ಟೆಪ್ವೈಸ್, ರಿಡ್ಜ್, ಲಾಸ್ಸೋ ಮತ್ತು ಎಲಾಸ್ಟಿಕ್ನೆಟ್ ತಂತ್ರಗಳನ್ನು ಓದಿ ತಿಳಿಯಿರಿ. ಹೆಚ್ಚಿನ ಅಧ್ಯಯನಕ್ಕೆ ಉತ್ತಮ ಕೋರ್ಸ್ [ಸ್ಟ್ಯಾನ್ಫರ್ಡ್ ಸ್ಟಾಟಿಸ್ಟಿಕಲ್ ಲರ್ನಿಂಗ್ ಕೋರ್ಸ್](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ಆಗಿದೆ.\n",
|
|
"\n",
|
|
"ಅದ್ಭುತ ಟಿಡಿಮೋಡಲ್ಸ್ ಫ್ರೇಮ್ವರ್ಕ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಇನ್ನಷ್ಟು ತಿಳಿಯಲು, ದಯವಿಟ್ಟು ಕೆಳಗಿನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪರಿಶೀಲಿಸಿ:\n",
|
|
"\n",
|
|
"- ಟಿಡಿಮೋಡಲ್ಸ್ ವೆಬ್ಸೈಟ್: [ಟಿಡಿಮೋಡಲ್ಸ್ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ](https://www.tidymodels.org/start/)\n",
|
|
"\n",
|
|
"- ಮ್ಯಾಕ್ಸ್ ಕುಹ್ನ್ ಮತ್ತು ಜೂಲಿಯಾ ಸಿಲ್ಜ್, [*R ನೊಂದಿಗೆ ಟಿಡಿ ಮಾದರೀಕರಣ*](https://www.tmwr.org/)*.*\n",
|
|
"\n",
|
|
"###### **ಧನ್ಯವಾದಗಳು:**\n",
|
|
"\n",
|
|
"[ಅಲಿಸನ್ ಹೋರ್ಸ್ಟ್](https://twitter.com/allison_horst?lang=en) ಅವರಿಗೆ, R ಅನ್ನು ಹೆಚ್ಚು ಆತಿಥ್ಯಪೂರ್ಣ ಮತ್ತು ಆಕರ್ಷಕವಾಗಿಸುವ ಅದ್ಭುತ ಚಿತ್ರಣಗಳನ್ನು ಸೃಷ್ಟಿಸಿದಕ್ಕಾಗಿ. ಅವರ ಇನ್ನಷ್ಟು ಚಿತ್ರಣಗಳನ್ನು ಅವರ [ಗ್ಯಾಲರಿ](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM) ನಲ್ಲಿ ಕಂಡುಹಿಡಿಯಿರಿ.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "8zOLOWqMxzk5"
|
|
}
|
|
},
|
|
{
|
|
"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"
|
|
]
|
|
}
|
|
]
|
|
} |