\n",
" \n",
" डासानी मडिपल्लीद्वारा इन्फोग्राफिक\n",
"\n",
"\n",
"#### परिचय\n",
"\n",
"अहिलेसम्म तपाईंले कद्दूको मूल्य निर्धारण डेटासेटबाट सङ्कलित नमूना डाटाको साथ प्रतिगमन के हो भनेर अन्वेषण गर्नुभएको छ, जुन हामीले यस पाठभरि प्रयोग गर्नेछौं। तपाईंले यसलाई `ggplot2` प्रयोग गरेर दृश्यात्मक पनि गर्नुभएको छ।💪\n",
"\n",
"अब तपाईं एमएलका लागि प्रतिगमनमा गहिरो रूपमा जान तयार हुनुहुन्छ। यस पाठमा, तपाईं दुई प्रकारका प्रतिगमनबारे थप जान्नुहुनेछ: *आधारभूत रेखीय प्रतिगमन* र *बहुपदीय प्रतिगमन*, साथै यी प्रविधिहरूको आधारभूत गणितबारे पनि।\n",
"\n",
"> यस पाठ्यक्रमभरि, हामी न्यूनतम गणितीय ज्ञानलाई मान्यता दिन्छौं, र अन्य क्षेत्रबाट आएका विद्यार्थीहरूका लागि यसलाई पहुँचयोग्य बनाउन खोज्छौं। त्यसैले नोटहरू, 🧮 गणितीय संकेतहरू, रेखाचित्रहरू, र अन्य सिकाइ उपकरणहरूलाई बुझ्न मद्दतका लागि ध्यान दिनुहोस्।\n",
"\n",
"#### तयारी\n",
"\n",
"स्मरण गराउनका लागि, तपाईंले यस डाटालाई लोड गर्दै हुनुहुन्छ ताकि यसबाट प्रश्नहरू सोध्न सक्नुहोस्।\n",
"\n",
"- कद्दू किन्ने उत्तम समय कहिले हो?\n",
"\n",
"- साना कद्दूहरूको केसको मूल्य कति अपेक्षा गर्न सकिन्छ?\n",
"\n",
"- मैले तिनीहरूलाई आधा-बुशल टोकरीमा किन्ने कि १ १/९ बुशल बक्समा किन्ने? यस डाटामा अझै गहिरो रूपमा खन्ने प्रयास गरौं।\n",
"\n",
"अघिल्लो पाठमा, तपाईंले `tibble` (डाटा फ्रेमको आधुनिक पुनःकल्पना) सिर्जना गर्नुभएको थियो र मूल डेटासेटको भागसँग यसलाई भरिएको थियो, बुशलद्वारा मूल्यलाई मानकीकरण गर्दै। तर, त्यसो गर्दा, तपाईंले केवल लगभग ४०० डाटा बिन्दुहरू सङ्कलन गर्न सक्नुभयो र केवल शरद ऋतु महिनाहरूका लागि। सायद हामी डाटाको प्रकृतिबारे अझै धेरै विवरण प्राप्त गर्न यसलाई सफा गरेर गर्न सक्छौं? हेर्नेछौं... 🕵️♀️\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",
"## १. रेखीय प्रतिगमन रेखा\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",
"एक राम्रो रेखीय प्रतिगमन मोडेल भनेको यस्तो मोडेल हो जसले सर्वोत्तम वर्ग प्रतिगमन विधि प्रयोग गरेर रेखासँग उच्च (१ नजिक, ० भन्दा टाढा) सम्बन्ध गुणांक राख्छ।\n"
],
"metadata": {
"id": "cdX5FRpvsoP5"
}
},
{
"cell_type": "markdown",
"source": [
"## **२. डाटासँगको नृत्य: मोडेलिङका लागि प्रयोग गरिने डेटा फ्रेम तयार गर्दै**\n",
"\n",
"
\n",
" \n",
" @allison_horst द्वारा सिर्जित कला\n",
"\n",
"\n",
"\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": [
"यदि हामीले `city` वा `package` जस्ता क्यारेक्टर प्रकारका स्तम्भहरूको आधारमा कद्दूको `price` भविष्यवाणी गर्न चाह्यौं भने के गर्ने? वा अझ सरल रूपमा, यदि हामीले `package` र `price` बीचको सम्बन्ध (जसका लागि दुवै इनपुटहरू संख्यात्मक हुन आवश्यक छ) पत्ता लगाउन चाह्यौं भने के गर्ने? 🤷🤷\n",
"\n",
"मेसिन लर्निङ मोडेलहरू पाठ मानहरूभन्दा संख्यात्मक विशेषताहरूमा राम्रोसँग काम गर्छन्, त्यसैले सामान्यतया तपाईँले श्रेणीगत विशेषताहरूलाई संख्यात्मक प्रतिनिधित्वमा रूपान्तरण गर्न आवश्यक पर्छ।\n",
"\n",
"यसको अर्थ, हामीले हाम्रो भविष्यवक्ताहरूलाई मोडेलले प्रभावकारी रूपमा प्रयोग गर्न सजिलो बनाउन पुनःस्वरूप दिनको लागि कुनै तरिका खोज्नुपर्छ, जसलाई `feature engineering` भनिन्छ।\n"
],
"metadata": {
"id": "7hsHoxsStyjJ"
}
},
{
"cell_type": "markdown",
"source": [
"## ३. मोडेलिङका लागि डेटा पूर्वप्रक्रिया गर्न recipes प्रयोग गर्दै 👩🍳👨🍳\n",
"\n",
"पूर्वानुमान गर्ने मानहरूलाई पुनःस्वरूप दिनु, जसले मोडेललाई प्रभावकारी रूपमा प्रयोग गर्न सजिलो बनाउँछ, `फिचर इन्जिनियरिङ` भनिन्छ।\n",
"\n",
"विभिन्न मोडेलहरूलाई विभिन्न प्रकारका पूर्वप्रक्रियाहरू आवश्यक पर्छ। उदाहरणका लागि, least squares लाई `श्रेणीगत भेरिएबलहरूको इन्कोडिङ` जस्तै महिना, प्रकार, र city_name आवश्यक पर्छ। यसको मतलब `श्रेणीगत मानहरू` भएको स्तम्भलाई `संख्यात्मक स्तम्भहरू` मा रूपान्तरण गर्नु हो, जसले मूल स्तम्भलाई प्रतिस्थापन गर्छ।\n",
"\n",
"उदाहरणका लागि, मानौं तपाईंको डेटामा निम्न श्रेणीगत फिचर समावेश छ:\n",
"\n",
"| city |\n",
"|:-------:|\n",
"| Denver |\n",
"| Nairobi |\n",
"| Tokyo |\n",
"\n",
"तपाईं *ordinal encoding* प्रयोग गरेर प्रत्येक श्रेणीको लागि एक अद्वितीय पूर्णांक मान प्रतिस्थापन गर्न सक्नुहुन्छ, यसरी:\n",
"\n",
"| city |\n",
"|:----:|\n",
"| 0 |\n",
"| १ |\n",
"| २ |\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` डाटालाई सन्दर्भको रूपमा प्रयोग गरेर भेरिएबलहरूको *भूमिका* निर्धारण गर्छ। उदाहरणका लागि, `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",
"
\n",
" \n",
" @allison_horst द्वारा कलाकृति\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): तयार गरिएको recipe लाई लिन्छ र कुनै पनि डाटा सेटमा ती कार्यहरू लागू गर्छ।\n",
"\n",
"त्यसैले, हाम्रा recipe हरू तयार (prep) र लागू (bake) गरौं ताकि यो पक्का गर्न सकियोस् कि भित्री प्रक्रियामा, भविष्यवक्ता स्तम्भहरूलाई पहिले एन्कोड गरिनेछ र त्यसपछि मोडेल फिट गरिनेछ।\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` का सबै भविष्यवक्ता (predictors) को एन्कोडिङ गरिएको छ, जसले पुष्टि गर्दछ कि हाम्रो परिभाषित preprocessing चरणहरू हाम्रो recipe अनुसार अपेक्षित रूपमा काम गर्नेछन्। यो तपाईंको लागि पढ्न अलि गाह्रो हुन सक्छ, तर Tidymodels का लागि यो धेरै बुझ्न सजिलो हुन्छ! केहि समय निकालेर पत्ता लगाउनुहोस् कि कुन observation लाई कुन integer मा म्याप गरिएको छ।\n",
"\n",
"यो पनि उल्लेखनीय छ कि `baked_pumpkins` एउटा data frame हो जसमा हामी गणना गर्न सक्छौं।\n",
"\n",
"उदाहरणका लागि, तपाईंको डेटा भित्रका दुई बिन्दुहरू बीच राम्रो सम्बन्ध (correlation) पत्ता लगाएर सम्भावित रूपमा राम्रो predictive model निर्माण गर्न प्रयास गरौं। यसका लागि हामी `cor()` function प्रयोग गर्नेछौं। यस function को बारेमा थप जान्न `?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`** को साथ बेक गर्नु मात्र पर्नेछ।\n",
"\n",
"## ४. रेखीय प्रतिगमन मोडेल निर्माण गर्नुहोस्\n",
"\n",
"
\n",
" \n",
" डासानी मडिपल्लीद्वारा इन्फोग्राफिक\n",
"\n",
"\n",
"\n"
],
"metadata": {
"id": "YqXjLuWavNxW"
}
},
{
"cell_type": "markdown",
"source": [
"अब हामीले एउटा रेसिपी तयार गरिसकेका छौं, र वास्तवमा पुष्टि गरिसकेका छौं कि डाटा उपयुक्त रूपमा पूर्व-प्रक्रिया गरिनेछ, अब हामी एउटा रिग्रेसन मोडेल निर्माण गर्नेछौं जसले यो प्रश्नको उत्तर दिनेछ: `दिइएको कद्दू प्याकेजको मूल्य कति अपेक्षा गर्न सकिन्छ?`\n",
"\n",
"#### प्रशिक्षण सेट प्रयोग गरेर एउटा लीनियर रिग्रेसन मोडेल प्रशिक्षण गर्नुहोस्\n",
"\n",
"जसरी तपाईंले पहिले नै अनुमान गर्नुभएको हुन सक्छ, *price* स्तम्भ `outcome` भेरिएबल हो भने *package* स्तम्भ `predictor` भेरिएबल हो।\n",
"\n",
"यसलाई गर्नका लागि, हामीले पहिलोमा डाटालाई यसरी विभाजन गर्नेछौं कि ८०% प्रशिक्षण सेटमा जानेछ र २०% परीक्षण सेटमा जानेछ, त्यसपछि एउटा रेसिपी परिभाषित गर्नेछौं जसले predictor स्तम्भलाई पूर्णांकहरूको सेटमा एन्कोड गर्नेछ, त्यसपछि मोडेल स्पेसिफिकेसन निर्माण गर्नेछौं। हामी हाम्रो रेसिपीलाई prep र bake गर्नेछैनौं किनकि हामीलाई पहिले नै थाहा छ कि यसले डाटालाई अपेक्षित रूपमा पूर्व-प्रक्रिया गर्नेछ।\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",
"
\n",
" \n",
" डसानी मडिपल्लीद्वारा इन्फोग्राफिक\n",
"\n",
"\n",
"\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",
"> ✅ बहुपद (Polynomials) गणितीय अभिव्यक्तिहरू हुन्, जसमा एक वा बढी चर र गुणांकहरू समावेश हुन सक्छन्।\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": [
"Woo-hoo, आउनुहोस् `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` लगभग ७ बाट घटेर लगभग ३ मा पुगेको छ, जसले वास्तविक मूल्य र अनुमानित मूल्य बीचको त्रुटि कम भएको संकेत गर्दछ। तपाईं यसलाई *ढिलो* रूपमा व्याख्या गर्न सक्नुहुन्छ कि औसतमा, गलत अनुमानहरू लगभग \\$३ ले गलत छन्। `rsq` लगभग ०.४ बाट बढेर ०.८ मा पुगेको छ।\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 हेर्दा अर्थपूर्ण देखिन्छ! र, यदि यो अघिल्लो मोडलभन्दा राम्रो छ भने, उही डेटा हेर्दा, तपाईंले यी महँगो pumpkins को लागि बजेट बनाउन आवश्यक छ!\n",
"\n",
"🏆 राम्रो काम! तपाईंले एक पाठमा दुई regression models बनाउनु भयो। Regression को अन्तिम खण्डमा, तपाईंले logistic regression सिक्नुहुनेछ जसले categories निर्धारण गर्न मद्दत गर्दछ।\n",
"\n",
"## **🚀चुनौती**\n",
"\n",
"यस notebook मा विभिन्न variables परीक्षण गर्नुहोस् र correlation कसरी model accuracy संग सम्बन्धित छ हेर्नुहोस्।\n",
"\n",
"## [**पाठपछिको क्विज**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/14/)\n",
"\n",
"## **पुनरावलोकन र आत्म-अध्ययन**\n",
"\n",
"यस पाठमा हामीले Linear Regression को बारेमा सिक्यौं। Regression का अन्य महत्वपूर्ण प्रकारहरू पनि छन्। Stepwise, Ridge, Lasso र Elasticnet techniques को बारेमा पढ्नुहोस्। थप जान्नको लागि राम्रो कोर्स [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"
]
}
]
}
![](\"../../images/linear-polynomial.png\"\n",)
\n",
" ![](\"../../images/janitor.jpg\"\n",)
\n",
" ![](\"../../images/recipes.png\"\n",)
\n",
"