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.
1084 lines
68 KiB
1084 lines
68 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-08-29T18:52:43+00:00",
|
|
"source_file": "2-Regression/3-Linear/solution/R/lesson_3-R.ipynb",
|
|
"language_code": "pa"
|
|
}
|
|
},
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [],
|
|
"metadata": {
|
|
"id": "EgQw8osnsUV-"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## ਕਦੂ ਦੀ ਕੀਮਤ ਲਈ ਲੀਨੀਅਰ ਅਤੇ ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ - ਪਾਠ 3\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>ਦਸਾਨੀ ਮਦਿਪੱਲੀ ਦੁਆਰਾ ਇਨਫੋਗ੍ਰਾਫਿਕ</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"#### ਪਰਿਚਯ\n",
|
|
"\n",
|
|
"ਅਜੇ ਤੱਕ ਤੁਸੀਂ ਰਿਗ੍ਰੈਸ਼ਨ ਕੀ ਹੈ ਇਸ ਬਾਰੇ ਪੜ੍ਹਾਈ ਕੀਤੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਕਦੂ ਦੀ ਕੀਮਤ ਦੇ ਡਾਟਾਸੈਟ ਤੋਂ ਇਕੱਠੇ ਕੀਤੇ ਨਮੂਨਾ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ, ਜੋ ਅਸੀਂ ਇਸ ਪਾਠ ਵਿੱਚ ਵਰਤਾਂਗੇ। ਤੁਸੀਂ ਇਸਨੂੰ `ggplot2` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਿਜੁਅਲਾਈਜ਼ ਵੀ ਕੀਤਾ ਹੈ।💪\n",
|
|
"\n",
|
|
"ਹੁਣ ਤੁਸੀਂ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਲਈ ਰਿਗ੍ਰੈਸ਼ਨ ਵਿੱਚ ਹੋਰ ਡੂੰਘਾਈ ਵਿੱਚ ਜਾਣ ਲਈ ਤਿਆਰ ਹੋ। ਇਸ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਦੋ ਪ੍ਰਕਾਰਾਂ ਬਾਰੇ ਹੋਰ ਜਾਣੋਗੇ: *ਮੂਲ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ* ਅਤੇ *ਪੋਲੀਨੋਮਿਅਲ ਰਿਗ੍ਰੈਸ਼ਨ*, ਨਾਲ ਹੀ ਇਨ੍ਹਾਂ ਤਕਨੀਕਾਂ ਦੇ ਕੁਝ ਗਣਿਤ ਬਾਰੇ।\n",
|
|
"\n",
|
|
"> ਇਸ ਪਾਠਕ੍ਰਮ ਵਿੱਚ, ਅਸੀਂ ਗਣਿਤ ਦਾ ਘੱਟ ਜ਼ਿਆਦਾ ਗਿਆਨ ਮੰਨਦੇ ਹਾਂ ਅਤੇ ਵਿਦਿਆਰਥੀਆਂ ਲਈ, ਜੋ ਹੋਰ ਖੇਤਰਾਂ ਤੋਂ ਆਉਂਦੇ ਹਨ, ਇਸਨੂੰ ਸੌਖਾ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ। ਇਸ ਲਈ ਨੋਟਸ, 🧮 ਕਾਲਆਉਟਸ, ਡਾਇਗ੍ਰਾਮ ਅਤੇ ਹੋਰ ਸਿੱਖਣ ਦੇ ਸਾਧਨਾਂ 'ਤੇ ਧਿਆਨ ਦਿਓ ਜੋ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ।\n",
|
|
"\n",
|
|
"#### ਤਿਆਰੀ\n",
|
|
"\n",
|
|
"ਯਾਦ ਦਿਵਾਉਣ ਲਈ, ਤੁਸੀਂ ਇਸ ਡਾਟਾ ਨੂੰ ਲੋਡ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਜੋ ਇਸ 'ਤੇ ਸਵਾਲ ਪੁੱਛ ਸਕੋ।\n",
|
|
"\n",
|
|
"- ਕਦੂ ਖਰੀਦਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਸਮਾਂ ਕਦੋਂ ਹੈ?\n",
|
|
"\n",
|
|
"- ਮਿਨੀਏਚਰ ਕਦੂ ਦੇ ਕੇਸ ਦੀ ਕੀਮਤ ਕੀ ਹੋ ਸਕਦੀ ਹੈ?\n",
|
|
"\n",
|
|
"- ਕੀ ਮੈਂ ਇਹਨਾਂ ਨੂੰ ਅੱਧੇ ਬਾਸਕਟ ਵਿੱਚ ਖਰੀਦਣਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ 1 1/9 ਬਾਸਕਟ ਬਾਕਸ ਵਿੱਚ? ਆਓ ਇਸ ਡਾਟਾ ਵਿੱਚ ਹੋਰ ਖੋਜ ਕਰੀਏ।\n",
|
|
"\n",
|
|
"ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ `tibble` (ਡਾਟਾ ਫਰੇਮ ਦਾ ਆਧੁਨਿਕ ਰੂਪ) ਬਣਾਇਆ ਸੀ ਅਤੇ ਇਸਨੂੰ ਮੂਲ ਡਾਟਾਸੈਟ ਦੇ ਹਿੱਸੇ ਨਾਲ ਭਰਿਆ ਸੀ, ਬਾਸਕਟ ਦੁਆਰਾ ਕੀਮਤ ਨੂੰ ਸਟੈਂਡਰਡ ਕਰਕੇ। ਇਸਨੂੰ ਕਰਨ ਨਾਲ, ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਸਿਰਫ 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",
|
|
"ਇਸ ਕਿਸਮ ਦੀ ਲਾਈਨ ਖਿੱਚਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਅੰਕਗਣਿਤ ਤਕਨੀਕ ਵਰਤਦੇ ਹਾਂ ਜਿਸਨੂੰ **ਲੀਸਟ-ਸਕਵੇਅਰਜ਼ ਰਿਗ੍ਰੈਸ਼ਨ** ਕਿਹਾ ਜਾਂਦਾ ਹੈ। `ਲੀਸਟ-ਸਕਵੇਅਰਜ਼` ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਰਿਗ੍ਰੈਸ਼ਨ ਲਾਈਨ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਾਰੇ ਡਾਟਾ ਪੌਇੰਟਸ ਨੂੰ ਸਕਵੇਅਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਆਦਰਸ਼ ਤੌਰ 'ਤੇ, ਉਹ ਅੰਤਿਮ ਜੋੜ ਜਿੰਨਾ ਛੋਟਾ ਹੋਵੇ, ਉਨਾ ਹੀ ਵਧੀਆ ਹੈ, ਕਿਉਂਕਿ ਅਸੀਂ ਗਲਤੀਆਂ ਦੀ ਘੱਟ ਗਿਣਤੀ ਚਾਹੁੰਦੇ ਹਾਂ, ਜਾਂ `ਲੀਸਟ-ਸਕਵੇਅਰਜ਼`। ਇਸ ਤਰ੍ਹਾਂ, ਸਰਵੋਤਮ ਫਿੱਟ ਲਾਈਨ ਉਹ ਲਾਈਨ ਹੈ ਜੋ ਸਾਡੇ ਲਈ ਸਕਵੇਅਰ ਗਲਤੀਆਂ ਦੇ ਜੋੜ ਦਾ ਸਭ ਤੋਂ ਘੱਟ ਮੁੱਲ ਦਿੰਦੀ ਹੈ - ਇਸੇ ਲਈ ਇਸਨੂੰ *ਲੀਸਟ ਸਕਵੇਅਰਜ਼ ਰਿਗ੍ਰੈਸ਼ਨ* ਕਿਹਾ ਜਾਂਦਾ ਹੈ।\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",
|
|
"> ਲਾਈਨ ਦੀ ਗਣਨਾ ਕਰਨ ਵਾਲਾ ਗਣਿਤ ਲਾਈਨ ਦੀ ਢਲਾਨ ਨੂੰ ਦਰਸਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਇੰਟਰਸੈਪਟ 'ਤੇ ਵੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜਾਂ ਜਿੱਥੇ `Y` ਸਥਿਤ ਹੈ ਜਦੋਂ `X = 0`।\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=\"../../images/janitor.jpg\"\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": [
|
|
"🤔 ਅਸੀਂ ਹੋਰ ਚੰਗਾ ਕਰ ਸਕਦੇ ਹਾਂ। ਆਓ ਇਨ੍ਹਾਂ ਕਾਲਮ ਨਾਮਾਂ ਨੂੰ `friendR` ਬਣਾਈਏ ਜਿਨ੍ਹਾਂ ਨੂੰ [snake_case](https://en.wikipedia.org/wiki/Snake_case) ਰੀਤੀ ਵਿੱਚ `janitor::clean_names` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਦਲਿਆ ਜਾ ਸਕੇ। ਇਸ ਫੰਕਸ਼ਨ ਬਾਰੇ ਹੋਰ ਜਾਣਨ ਲਈ: `?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": [
|
|
"ਕੀ ਅਸੀਂ ਕਦੋਂ ਵੀ ਸੋਚਿਆ ਹੈ ਕਿ ਜੇ ਅਸੀਂ `price` ਦੀ ਭਵਿੱਖਵਾਣੀ ਕਰਨੀ ਹੋਵੇ ਜੋ ਕਿ `city` ਜਾਂ `package` ਕਾਲਮਾਂ 'ਤੇ ਆਧਾਰਿਤ ਹੈ, ਜੋ ਕਿ ਕਿਰਦਾਰ ਪ੍ਰਕਾਰ ਦੇ ਹਨ? ਜਾਂ ਹੋਰ ਸੌਖੇ ਤਰੀਕੇ ਨਾਲ, ਅਸੀਂ ਕਿਵੇਂ `package` ਅਤੇ `price` ਦੇ ਵਿਚਕਾਰ ਸਬੰਧ ਲੱਭ ਸਕਦੇ ਹਾਂ (ਜਿਸ ਲਈ ਦੋਵੇਂ ਇਨਪੁਟਸ ਦਾ ਸੰਖਿਆਤਮਕ ਹੋਣਾ ਜ਼ਰੂਰੀ ਹੈ)? 🤷🤷\n",
|
|
"\n",
|
|
"ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਸੰਖਿਆਤਮਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਸਭ ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦੇ ਹਨ ਬਜਾਏ ਟੈਕਸਟ ਮੁੱਲਾਂ ਦੇ, ਇਸ ਲਈ ਆਮ ਤੌਰ 'ਤੇ ਤੁਹਾਨੂੰ ਸ਼੍ਰੇਣੀਬੱਧ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੰਖਿਆਤਮਕ ਰੂਪਾਂ ਵਿੱਚ ਬਦਲਣਾ ਪੈਂਦਾ ਹੈ।\n",
|
|
"\n",
|
|
"ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਾਨੂੰ ਆਪਣੇ ਪੇਸ਼ਕਰਤਾਵਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦੁਬਾਰਾ ਫਾਰਮੈਟ ਕਰਨ ਦਾ ਤਰੀਕਾ ਲੱਭਣਾ ਪਵੇਗਾ ਜੋ ਮਾਡਲ ਲਈ ਉਪਯੋਗ ਹੋ ਸਕੇ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ `feature engineering` ਕਿਹਾ ਜਾਂਦਾ ਹੈ।\n"
|
|
],
|
|
"metadata": {
|
|
"id": "7hsHoxsStyjJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 3. ਮਾਡਲਿੰਗ ਲਈ ਡਾਟਾ ਦੀ ਪੂਰਵ-ਪ੍ਰਕਿਰਿਆ ਰਸੋਈਆਂ ਨਾਲ 👩🍳👨🍳\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=\"../../images/recipes.png\"\n",
|
|
" width=\"550\"/>\n",
|
|
" <figcaption>ਕਲਾ @allison_horst ਦੁਆਰਾ</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"550\"}-->\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",
|
|
"> Note: ਜਦੋਂ ਤੁਸੀਂ **`bake()`** ਕਰਦੇ ਹੋ ਤਿਆਰ ਕੀਤੀ ਰਸੋਈ **`pumpkins_prep`** ਨਾਲ **`new_data = NULL`**, ਤਾਂ ਤੁਸੀਂ ਪ੍ਰੋਸੈਸ ਕੀਤੇ (i.e. encoded) ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਹੋਰ ਡਾਟਾ ਸੈੱਟ ਹੈ, ਉਦਾਹਰਨ ਵਜੋਂ ਇੱਕ ਟੈਸਟ ਸੈੱਟ, ਅਤੇ ਤੁਸੀਂ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇੱਕ ਰਸੋਈ ਇਸ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕਰੇਗੀ, ਤਾਂ ਤੁਸੀਂ ਸਿਰਫ **`pumpkins_prep`** ਨੂੰ **`new_data = test_set`** ਨਾਲ bake ਕਰਦੇ ਹੋ।\n",
|
|
"\n",
|
|
"## 4. ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਓ\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>ਦਸਾਨੀ ਮਦਿਪੱਲੀ ਦੁਆਰਾ ਇਨਫੋਗ੍ਰਾਫਿਕ</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"800\"}-->\n"
|
|
],
|
|
"metadata": {
|
|
"id": "YqXjLuWavNxW"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਰਿਸੀਪੀ ਤਿਆਰ ਕਰ ਲਈ ਹੈ ਅਤੇ ਇਹ ਪੁਸ਼ਟੀ ਕਰ ਲਈ ਹੈ ਕਿ ਡਾਟਾ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਹੋਵੇਗਾ, ਆਓ ਹੁਣ ਇੱਕ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਬਣਾਈਏ ਤਾਂ ਜੋ ਇਸ ਸਵਾਲ ਦਾ ਜਵਾਬ ਮਿਲ ਸਕੇ: `ਮੈਂ ਇੱਕ ਦਿੱਤੇ ਗਏ ਕੱਦੂ ਦੇ ਪੈਕੇਜ ਦੀ ਕੀਮਤ ਕਿੰਨੀ ਉਮੀਦ ਕਰ ਸਕਦਾ ਹਾਂ?`\n",
|
|
"\n",
|
|
"#### ਟ੍ਰੇਨਿੰਗ ਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਲੀਨੀਅਰ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਟ੍ਰੇਨ ਕਰੋ\n",
|
|
"\n",
|
|
"ਜਿਵੇਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਪਹਿਲਾਂ ਹੀ ਸਮਝ ਗਏ ਹੋਵੋਗੇ, ਕਾਲਮ *price* `outcome` ਵੈਰੀਏਬਲ ਹੈ ਜਦਕਿ *package* ਕਾਲਮ `predictor` ਵੈਰੀਏਬਲ ਹੈ।\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": [
|
|
"ਸ਼ਾਬਾਸ਼! ਹੁਣ ਸਾਡੇ ਕੋਲ ਇੱਕ ਰੈਸਿਪੀ ਅਤੇ ਮਾਡਲ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ, ਸਾਨੂੰ ਇਹਨਾਂ ਨੂੰ ਇੱਕ ਆਬਜੈਕਟ ਵਿੱਚ ਇਕੱਠਾ ਕਰਨ ਦਾ ਤਰੀਕਾ ਲੱਭਣਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਡਾਟਾ ਨੂੰ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕਰੇਗਾ (ਪਿੱਛੇ ਪ੍ਰੈਪ + ਬੇਕ), ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕੀਤੇ ਡਾਟਾ 'ਤੇ ਮਾਡਲ ਨੂੰ ਫਿੱਟ ਕਰੇਗਾ ਅਤੇ ਸੰਭਾਵਿਤ ਪੋਸਟ-ਪ੍ਰੋਸੈਸਿੰਗ ਗਤੀਵਿਧੀਆਂ ਦੀ ਵੀ ਆਗਿਆ ਦੇਵੇਗਾ। ਇਹ ਤੁਹਾਡੇ ਮਨ ਦੀ ਸ਼ਾਂਤੀ ਲਈ ਕਿਵੇਂ ਹੈ!🤩\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",
|
|
"ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰ ਲਿਆ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ `parsnip::predict()` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਸੈੱਟ ਲਈ ਅਨੁਮਾਨ ਲਗਾਉਣ ਲਈ ਵਰਤ ਸਕਦੇ ਹਾਂ। ਫਿਰ ਅਸੀਂ ਇਹ ਅਨੁਮਾਨ ਅਸਲ ਲੇਬਲ ਮੁੱਲਾਂ ਨਾਲ ਤੁਲਨਾ ਕਰ ਸਕਦੇ ਹਾਂ ਤਾਂ ਜੋ ਇਹ ਅੰਕਣ ਕਰ ਸਕੀਏ ਕਿ ਮਾਡਲ ਕਿੰਨਾ ਵਧੀਆ (ਜਾਂ ਨਹੀਂ!) ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।\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": [
|
|
"ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਘਟ ਗਈ। ਆਓ ਵੇਖੀਏ ਕਿ ਕੀ ਅਸੀਂ ਪੈਕੇਜ ਅਤੇ ਕੀਮਤ ਦੇ ਸਕੈਟਰ ਪਲਾਟ ਨੂੰ ਦਿਖਾ ਕੇ ਬਿਹਤਰ ਸੰਕੇਤ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ, ਫਿਰ ਕੀਤੇ ਗਏ ਅਨੁਮਾਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਬਿਹਤਰ ਫਿੱਟ ਲਾਈਨ ਨੂੰ ਓਵਰਲੇ ਕਰੀਏ।\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=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>ਦਸਾਨੀ ਮਦੀਪੱਲੀ ਦੁਆਰਾ ਇਨਫੋਗ੍ਰਾਫਿਕ</figcaption>\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()` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ।\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": [
|
|
"`polynomial model` ਦੀ ਪੇਸ਼ਗੋਈ ਮਕੂਲ ਲੱਗਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ `price` ਅਤੇ `package` ਦੇ scatter plots ਨੂੰ ਦੇਖ ਕੇ ਸਮਝ ਆਉਂਦੀ ਹੈ! ਅਤੇ, ਜੇ ਇਹ ਪਿਛਲੇ ਮਾਡਲ ਨਾਲੋਂ ਵਧੀਆ ਮਾਡਲ ਹੈ, ਤਾਂ ਇਸੇ ਡਾਟਾ ਨੂੰ ਦੇਖਦੇ ਹੋਏ ਤੁਹਾਨੂੰ ਇਹ ਮਹਿੰਗੇ ਕੱਦੂਆਂ ਲਈ ਬਜਟ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ!\n",
|
|
"\n",
|
|
"🏆 ਸ਼ਾਬਾਸ਼! ਤੁਸੀਂ ਇੱਕ ਪਾਠ ਵਿੱਚ ਦੋ regression ਮਾਡਲ ਬਣਾਏ। Regression ਦੇ ਅੰਤਿਮ ਭਾਗ ਵਿੱਚ, ਤੁਸੀਂ logistic regression ਬਾਰੇ ਸਿੱਖੋਗੇ ਜੋ ਸ਼੍ਰੇਣੀਆਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।\n",
|
|
"\n",
|
|
"## **🚀ਚੁਣੌਤੀ**\n",
|
|
"\n",
|
|
"ਇਸ ਨੋਟਬੁੱਕ ਵਿੱਚ ਕਈ ਵੱਖ-ਵੱਖ variables ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ correlation ਅਤੇ ਮਾਡਲ ਦੀ accuracy ਦੇ ਸੰਬੰਧ ਨੂੰ ਸਮਝਿਆ ਜਾ ਸਕੇ।\n",
|
|
"\n",
|
|
"## [**ਪਾਠ ਬਾਅਦ ਕਵਿਜ਼**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/14/)\n",
|
|
"\n",
|
|
"## **ਸਮੀਖਿਆ ਅਤੇ ਸਵੈ ਅਧਿਐਨ**\n",
|
|
"\n",
|
|
"ਇਸ ਪਾਠ ਵਿੱਚ ਅਸੀਂ Linear Regression ਬਾਰੇ ਸਿੱਖਿਆ। Regression ਦੇ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਕਾਰ ਵੀ ਹਨ। Stepwise, Ridge, Lasso ਅਤੇ Elasticnet ਤਕਨੀਕਾਂ ਬਾਰੇ ਪੜ੍ਹੋ। ਇਸ ਬਾਰੇ ਹੋਰ ਸਿੱਖਣ ਲਈ ਇੱਕ ਵਧੀਆ ਕੋਰਸ [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ਹੈ।\n",
|
|
"\n",
|
|
"ਜੇ ਤੁਸੀਂ ਸ਼ਾਨਦਾਰ Tidymodels framework ਨੂੰ ਵਰਤਣ ਬਾਰੇ ਹੋਰ ਸਿੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਹੇਠਾਂ ਦਿੱਤੇ ਸਾਧਨਾਂ ਨੂੰ ਦੇਖੋ:\n",
|
|
"\n",
|
|
"- Tidymodels ਵੈਬਸਾਈਟ: [Tidymodels ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ](https://www.tidymodels.org/start/)\n",
|
|
"\n",
|
|
"- ਮੈਕਸ ਕੁਹਨ ਅਤੇ ਜੂਲੀਆ ਸਿਲਗੇ, [*Tidy Modeling with 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\n**ਅਸਵੀਕਤੀ**: \nਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚੀਤਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।\n"
|
|
]
|
|
}
|
|
]
|
|
} |