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:47:56+00:00",
|
|
"source_file": "2-Regression/3-Linear/solution/R/lesson_3-R.ipynb",
|
|
"language_code": "mr"
|
|
}
|
|
},
|
|
"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",
|
|
"जसे तुम्ही पहिल्या धड्यात शिकले, रेषीय प्रतिगमनाचा उद्देश म्हणजे *सर्वोत्तम तंदुरुस्तीची रेषा* काढणे:\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",
|
|
"> रेषा काढण्यासाठी गणित रेषेचा उतार दाखवले पाहिजे, जो अवरोधावर देखील अवलंबून असतो, किंवा `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": [
|
|
"## **२. डेटासोबतचा नृत्य: मॉडेलिंगसाठी वापरला जाणारा डेटा फ्रेम तयार करणे**\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": [
|
|
"खूपच स्वच्छ 🧹! आता, मागील धड्यातीलप्रमाणे `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` या वर्णात्मक प्रकाराच्या स्तंभांवर आधारित `pumpkin` च्या `price` ची भविष्यवाणी करायची असेल तर काय कराल? किंवा आणखी सोप्या पद्धतीने, जर आपल्याला `package` आणि `price` यांच्यातील संबंध शोधायचा असेल (ज्यासाठी दोन्ही इनपुट्स संख्यात्मक असणे आवश्यक आहे) तर काय कराल? 🤷🤷\n",
|
|
"\n",
|
|
"यंत्र शिक्षण मॉडेल्स संख्यात्मक वैशिष्ट्यांसोबत अधिक चांगले कार्य करतात, मजकूर मूल्यांऐवजी. त्यामुळे सामान्यतः श्रेणीबद्ध वैशिष्ट्यांना संख्यात्मक स्वरूपात रूपांतरित करणे आवश्यक असते.\n",
|
|
"\n",
|
|
"याचा अर्थ असा की आपल्याला आपल्या भविष्यवाणी करणाऱ्या घटकांना मॉडेलसाठी अधिक प्रभावीपणे वापरण्यास सोपे बनवण्यासाठी पुनर्रचना करावी लागेल, ज्याला `feature engineering` म्हणतात.\n"
|
|
],
|
|
"metadata": {
|
|
"id": "7hsHoxsStyjJ"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"## 3. मॉडेलसाठी डेटा पूर्वतयारी `recipes` च्या मदतीने 👩🍳👨🍳\n",
|
|
"\n",
|
|
"मॉडेलला प्रभावीपणे वापरण्यास सुलभ करण्यासाठी प्रेडिक्टर मूल्यांचे पुनर्रचना करणे म्हणजेच `फीचर इंजिनिअरिंग` असे म्हणतात.\n",
|
|
"\n",
|
|
"वेगवेगळ्या मॉडेल्सना वेगवेगळ्या प्रकारच्या पूर्वतयारीची आवश्यकता असते. उदाहरणार्थ, `least squares` ला `categorical variables` जसे की महिना, प्रकार, आणि शहराचे नाव `encode` करणे आवश्यक असते. याचा अर्थ असा की `categorical values` असलेल्या एका स्तंभाला `numeric columns` मध्ये रूपांतरित करणे, जे मूळ स्तंभाची जागा घेतील.\n",
|
|
"\n",
|
|
"उदाहरणार्थ, समजा तुमच्या डेटामध्ये खालीलप्रमाणे एक `categorical feature` आहे:\n",
|
|
"\n",
|
|
"| city |\n",
|
|
"|:-------:|\n",
|
|
"| Denver |\n",
|
|
"| Nairobi |\n",
|
|
"| Tokyo |\n",
|
|
"\n",
|
|
"तुम्ही *ordinal encoding* वापरून प्रत्येक श्रेणीसाठी एक अद्वितीय पूर्णांक मूल्य देऊ शकता, जसे:\n",
|
|
"\n",
|
|
"| city |\n",
|
|
"|:----:|\n",
|
|
"| 0 |\n",
|
|
"| 1 |\n",
|
|
"| 2 |\n",
|
|
"\n",
|
|
"आणि हेच आपण आपल्या डेटावर करणार आहोत!\n",
|
|
"\n",
|
|
"या विभागात, आपण `Tidymodels` च्या आणखी एका अप्रतिम पॅकेजचा अभ्यास करू: [recipes](https://tidymodels.github.io/recipes/) - जे तुमचा डेटा **मॉडेल प्रशिक्षणापूर्वी** पूर्वतयार करण्यासाठी डिझाइन केले गेले आहे. मुख्यतः, एक `recipe` म्हणजे एक ऑब्जेक्ट आहे जो डेटासेटवर कोणते टप्पे लागू करायचे आहेत हे परिभाषित करतो, जेणेकरून तो मॉडेलिंगसाठी तयार होईल.\n",
|
|
"\n",
|
|
"आता, आपण एक `recipe` तयार करूया, जी प्रेडिक्टर कॉलममधील सर्व निरीक्षणांसाठी एक अद्वितीय पूर्णांक बदलून आपला डेटा मॉडेलिंगसाठी तयार करेल:\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` डेटाचा संदर्भ वापरून व्हेरिएबल्सच्या *roles* रेसिपीला सांगितल्या जातात. उदाहरणार्थ, `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"
|
|
],
|
|
"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",
|
|
"> टीप: जेव्हा तुम्ही **`pumpkins_prep`** नावाच्या तयार केलेल्या रेसिपीला **`bake()`** करता आणि **`new_data = NULL`** सेट करता, तेव्हा तुम्हाला प्रक्रिया केलेले (उदा. एन्कोड केलेले) प्रशिक्षण डेटा मिळतो. उदाहरणार्थ, जर तुमच्याकडे दुसरा डेटा सेट असेल, जसे की चाचणी सेट, आणि तुम्हाला पाहायचे असेल की रेसिपी त्यावर कशी पूर्व-प्रक्रिया करेल, तर तुम्ही फक्त **`pumpkins_prep`** ला **`new_data = test_set`** सह बेक कराल.\n",
|
|
"\n",
|
|
"## ४. रेषीय प्रतिगमन मॉडेल तयार करा\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": [
|
|
"छान काम केलं! आता आपल्याकडे एक रेसिपी आणि एक मॉडेल स्पेसिफिकेशन आहे, त्यामुळे आता आपल्याला त्यांना एकत्र बांधून एक ऑब्जेक्ट तयार करायचा आहे, जो डेटा आधी प्रीप्रोसेस करेल (पार्श्वभूमीत 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",
|
|
"आता आपण मॉडेल प्रशिक्षित केले आहे, आपण `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",
|
|
"## ५. बहुपद प्रतिगमन मॉडेल तयार करा\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/linear-polynomial.png\"\n",
|
|
" width=\"800\"/>\n",
|
|
" <figcaption>दासानी मदीपल्ली यांनी तयार केलेले माहितीग्राफिक</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"<!--{width=\"800\"}-->\n"
|
|
],
|
|
"metadata": {
|
|
"id": "HOCqJXLTwtWI"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"कधी कधी आपल्या डेटामध्ये रेषीय संबंध नसतो, पण तरीही आपल्याला एखाद्या परिणामाचा अंदाज घ्यायचा असतो. अशा अधिक जटिल, रेषीय नसलेल्या संबंधांसाठी बहुपदीय प्रतिगमन (polynomial regression) आपल्याला मदत करू शकते.\n",
|
|
"\n",
|
|
"उदाहरणार्थ, आपल्या भोपळ्यांच्या डेटासेटमध्ये पॅकेज आणि किंमत यांच्यातील संबंध पाहा. कधी कधी चलांमध्ये रेषीय संबंध असतो - जसे की भोपळ्याचा आकार जसा मोठा तसा त्याची किंमत जास्त - पण कधी कधी हे संबंध सरळ रेषा किंवा पातळीवर मांडता येत नाहीत.\n",
|
|
"\n",
|
|
"> ✅ येथे [काही अधिक उदाहरणे](https://online.stat.psu.edu/stat501/lesson/9/9.8) दिली आहेत जिथे बहुपदीय प्रतिगमन उपयोगी ठरू शकते.\n",
|
|
">\n",
|
|
"> मागील प्लॉटमध्ये Variety आणि Price यांच्यातील संबंध पुन्हा एकदा पाहा. हा scatterplot सरळ रेषेने विश्लेषित केला जावा असे तुम्हाला वाटते का? कदाचित नाही. अशा परिस्थितीत, तुम्ही बहुपदीय प्रतिगमन वापरून पाहू शकता.\n",
|
|
">\n",
|
|
"> ✅ बहुपद (Polynomials) हे गणितीय समीकरणे आहेत ज्यामध्ये एक किंवा अधिक चल (variables) आणि गुणांक (coefficients) असू शकतात.\n",
|
|
"\n",
|
|
"#### प्रशिक्षण सेट वापरून बहुपदीय प्रतिगमन मॉडेल तयार करा\n",
|
|
"\n",
|
|
"बहुपदीय प्रतिगमन *वाकलेली रेषा* तयार करते जी रेषीय नसलेल्या डेटाला अधिक चांगल्या प्रकारे जुळवते.\n",
|
|
"\n",
|
|
"चला पाहूया की बहुपदीय मॉडेल अंदाज वर्तवण्यात अधिक चांगले कार्य करते का. आपण यापूर्वी केलेल्या प्रक्रियेप्रमाणेच काहीशी प्रक्रिया अनुसरण करू:\n",
|
|
"\n",
|
|
"- एक recipe तयार करा ज्यामध्ये आपल्या डेटावर मॉडेलिंगसाठी आवश्यक असलेल्या पूर्वप्रक्रिया पायऱ्या नमूद केल्या जातील, जसे की: predictors चे encoding करणे आणि *n* डिग्रीचे बहुपद तयार करणे.\n",
|
|
"\n",
|
|
"- मॉडेल स्पेसिफिकेशन तयार करा\n",
|
|
"\n",
|
|
"- recipe आणि मॉडेल स्पेसिफिकेशनला workflow मध्ये एकत्र करा\n",
|
|
"\n",
|
|
"- workflow फिट करून मॉडेल तयार करा\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": [
|
|
"`polynomial model` चा अंदाज योग्य वाटतो, दिलेल्या `price` आणि `package` च्या scatter plots पाहता! आणि, जर हा मागील मॉडेलपेक्षा चांगला मॉडेल असेल, तर त्याच डेटावरून पाहता, तुम्हाला या महागड्या भोपळ्यांसाठी बजेट तयार करावे लागेल!\n",
|
|
"\n",
|
|
"🏆 छान काम केले! तुम्ही एका धड्यात दोन regression मॉडेल्स तयार केले. Regression च्या अंतिम विभागात, तुम्ही logistic regression शिकाल ज्यामुळे श्रेणी निश्चित करता येतील.\n",
|
|
"\n",
|
|
"## **🚀चॅलेंज**\n",
|
|
"\n",
|
|
"या नोटबुकमध्ये विविध variables तपासा आणि correlation कसा मॉडेल accuracy शी संबंधित आहे ते पाहा.\n",
|
|
"\n",
|
|
"## [**Post-lecture quiz**](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",
|
|
"- Max Kuhn आणि Julia Silge, [*Tidy Modeling with R*](https://www.tmwr.org/)*.*\n",
|
|
"\n",
|
|
"###### **धन्यवाद:**\n",
|
|
"\n",
|
|
"[Allison Horst](https://twitter.com/allison_horst?lang=en) यांना R अधिक स्वागतार्ह आणि आकर्षक बनवणाऱ्या अप्रतिम चित्रे तयार केल्याबद्दल. तिच्या [gallery](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"
|
|
]
|
|
}
|
|
]
|
|
} |