\n",
" \n",
" ఇన్ఫోగ్రాఫిక్ - దసాని మడిపల్లి\n",
"\n",
"\n",
"\n",
"\n",
"#### పరిచయం\n",
"\n",
"ఇప్పటివరకు మీరు పంప్కిన్ ధరల డేటాసెట్ నుండి సేకరించిన నమూనా డేటాతో రిగ్రెషన్ అంటే ఏమిటి అనేది అన్వేషించారు. మీరు దీన్ని `ggplot2` ఉపయోగించి విజువలైజ్ కూడా చేసారు.💪\n",
"\n",
"ఇప్పుడు మీరు ML కోసం రిగ్రెషన్ లో మరింత లోతుగా ప్రవేశించడానికి సిద్ధంగా ఉన్నారు. ఈ పాఠంలో, మీరు రెండు రకాల రిగ్రెషన్ గురించి మరింత తెలుసుకుంటారు: *మూలభూత లీనియర్ రిగ్రెషన్* మరియు *పోలినోమియల్ రిగ్రెషన్*, మరియు ఈ సాంకేతికతల వెనుక ఉన్న కొన్ని గణిత శాస్త్రం కూడా తెలుసుకుంటారు.\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",
"ఈ రకం రేఖను గీయడానికి, మేము **లీస్ట్-స్క్వేర్ రిగ్రెషన్** అనే గణాంక సాంకేతికతను ఉపయోగిస్తాము. `least-squares` అనే పదం అంటే రిగ్రెషన్ రేఖ చుట్టూ ఉన్న అన్ని డేటా పాయింట్లను స్క్వేర్ చేసి వాటిని జోడించడం. Ideally, ఆ తుది మొత్తం όσο తక్కువగా ఉంటే మంచిది, ఎందుకంటే మేము తక్కువ తప్పిదాల సంఖ్యను కోరుకుంటాము, లేదా `least-squares`. అందువల్ల, బెస్ట్ ఫిట్ రేఖ అనేది స్క్వేర్ చేసిన తప్పిదాల మొత్తం విలువను తక్కువగా ఇస్తుంది - అందుకే దీనిని *least squares regression* అంటారు.\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) వెబ్ సైట్లో చూడవచ్చు. అలాగే [ఈ Least-squares calculator](https://www.mathsisfun.com/data/least-squares-calculator.html) ను సందర్శించి సంఖ్యల విలువలు రేఖపై ఎలా ప్రభావం చూపిస్తాయో చూడండి.\n",
"\n",
"అంతగా భయంకరంగా లేదు కదా? 🤓\n",
"\n",
"#### సహసంబంధం\n",
"\n",
"మరొక పదం అర్థం చేసుకోవాలి అంటే, ఇచ్చిన X మరియు Y వేరియబుల్స్ మధ్య **సహసంబంధ గుణకం**. స్కాటర్ప్లాట్ ఉపయోగించి, మీరు ఈ గుణకాన్ని త్వరగా దృశ్యీకరించవచ్చు. డేటాపాయింట్లు ఒక సూటి రేఖలో చక్కగా పడి ఉంటే అధిక సహసంబంధం ఉంటుంది, కానీ X మరియు Y మధ్య ఎక్కడైనా చెలరేగిన డేటాపాయింట్లు ఉంటే తక్కువ సహసంబంధం ఉంటుంది.\n",
"\n",
"ఒక మంచి రేఖీయ రిగ్రెషన్ మోడల్ అనేది లీస్ట్-స్క్వేర్ రిగ్రెషన్ పద్ధతితో రిగ్రెషన్ రేఖతో ఉన్న అధిక (0 కంటే 1కి దగ్గరగా) సహసంబంధ గుణకం కలిగి ఉంటుంది.\n"
],
"metadata": {
"id": "cdX5FRpvsoP5"
}
},
{
"cell_type": "markdown",
"source": [
"## **2. డేటాతో నృత్యం: మోడలింగ్ కోసం ఉపయోగించే డేటా ఫ్రేమ్ సృష్టించడం**\n",
"\n",
"
\n",
" \n",
" @allison_horst చేత కళాకృతి\n",
"\n",
"\n",
"\n"
],
"metadata": {
"id": "WdUKXk7Bs8-V"
}
},
{
"cell_type": "markdown",
"source": [
"Load up required libraries and dataset. Convert the data to a data frame containing a subset of the data:\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` కాలమ్స్, ఇవి character టైపు ఉన్నవి, ఆధారంగా ఒక పంప్కిన్ యొక్క `price` ను అంచనా వేయాలనుకుంటే ఏమవుతుంది? లేదా మరింత సులభంగా, ఉదాహరణకు `package` మరియు `price` మధ్య (ఇరువురి ఇన్పుట్లు సంఖ్యాత్మకంగా ఉండాలని అవసరం ఉన్న) సంబంధాన్ని ఎలా కనుగొనగలం? 🤷🤷\n",
"\n",
"మిషన్ లెర్నింగ్ మోడల్స్ టెక్స్ట్ విలువల కంటే సంఖ్యాత్మక లక్షణాలతో ఉత్తమంగా పనిచేస్తాయి, కాబట్టి సాధారణంగా మీరు వర్గీకరణ లక్షణాలను సంఖ్యాత్మక ప్రాతినిధ్యాలలోకి మార్చాలి.\n",
"\n",
"దీని అర్థం ఏమిటంటే, మోడల్ సమర్థవంతంగా ఉపయోగించుకునేందుకు మన ప్రిడిక్టర్లను పునఃరూపకల్పన చేయడానికి ఒక మార్గాన్ని కనుగొనాలి, దీనిని `feature engineering` అని పిలుస్తారు.\n"
],
"metadata": {
"id": "7hsHoxsStyjJ"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. మోడలింగ్ కోసం డేటాను ప్రీప్రాసెసింగ్ చేయడం రిసిపీలతో 👩🍳👨🍳\n",
"\n",
"మోడల్ను సమర్థవంతంగా ఉపయోగించడానికి ప్రిడిక్టర్ విలువలను పునఃరూపకల్పన చేసే కార్యకలాపాలను `ఫీచర్ ఇంజనీరింగ్` అని పిలుస్తారు.\n",
"\n",
"వివిధ మోడల్స్కు వేర్వేరు ప్రీప్రాసెసింగ్ అవసరాలు ఉంటాయి. ఉదాహరణకు, లీస్ట్ స్క్వేర్లు `కేటగిరికల్ వేరియబుల్స్` ను ఎన్కోడ్ చేయడం అవసరం, ఉదాహరణకు నెల, రకం మరియు city_name. ఇది సాదారణంగా `కేటగిరికల్ విలువల`తో ఉన్న కాలమ్ను ఒకటి లేదా అంతకంటే ఎక్కువ `సంఖ్యాత్మక కాలమ్స్` గా మార్చడం, అవి అసలు కాలమ్ స్థానాన్ని తీసుకుంటాయి.\n",
"\n",
"ఉదాహరణకు, మీ డేటాలో క్రింది కేటగిరికల్ ఫీచర్ ఉంటుందని అనుకోండి:\n",
"\n",
"| city |\n",
"|:-------:|\n",
"| Denver |\n",
"| Nairobi |\n",
"| Tokyo |\n",
"\n",
"ప్రతి కేటగిరీకి ప్రత్యేకమైన పూర్తి సంఖ్య విలువను ప్రతిస్థాపించడానికి *ఆర్డినల్ ఎన్కోడింగ్* ను మీరు వర్తింపజేయవచ్చు, ఇలా:\n",
"\n",
"| city |\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`), కానీ రెసిపీలు మీరు ఆశిస్తున్న విధంగా పనిచేస్తున్నాయా అని నిర్ధారించుకోవడానికి sanity check చేయాలనుకుంటే ఇది ఉపయోగపడుతుంది.\n",
"\n",
"దానికి, మీరు రెండు మరిన్ని క్రియలు అవసరం: `prep()` మరియు `bake()` మరియు ఎప్పుడూ లాగా, మన చిన్న R స్నేహితులు [`Allison Horst`](https://github.com/allisonhorst/stats-illustrations) మీకు దీన్ని బాగా అర్థం చేసుకోవడంలో సహాయపడతారు!\n",
"\n",
"
\n",
" \n",
" Artwork by @allison_horst\n"
],
"metadata": {
"id": "KEiO0v7kuC9O"
}
},
{
"cell_type": "markdown",
"source": [
"[`prep()`](https://recipes.tidymodels.org/reference/prep.html): శిక్షణ సెట్ నుండి అవసరమైన పారామితులను అంచనా వేస్తుంది, ఇవి తర్వాత ఇతర డేటా సెట్లపై వర్తించవచ్చు. ఉదాహరణకు, ఒక నిర్దిష్ట predictor కాలమ్ కోసం, ఏ పరిశీలనకు integer 0 లేదా 1 లేదా 2 మొదలైనవి కేటాయించబడతాయి.\n",
"\n",
"[`bake()`](https://recipes.tidymodels.org/reference/bake.html): ఒక prepped రెసిపీ తీసుకుని ఆపరేషన్లను ఏదైనా డేటా సెట్పై వర్తింపజేస్తుంది.\n",
"\n",
"అంటే, మనం మన రెసిపీలను prep చేసి bake చేయాలి, తద్వారా నిజంగా అర్థమవుతుంది, predictor కాలమ్లు మొదట encode చేయబడతాయని, ఆ తర్వాత మోడల్ ఫిట్ అవుతుందని.\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",
"ఉదాహరణకు, మీ డేటా రెండు పాయింట్ల మధ్య మంచి సహసంబంధం (correlation) కనుగొనడానికి ప్రయత్నిద్దాం, తద్వారా మంచి ప్రిడిక్టివ్ మోడల్ నిర్మించవచ్చు. దీని కోసం మేము `cor()` ఫంక్షన్ను ఉపయోగిస్తాము. ఫంక్షన్ గురించి మరింత తెలుసుకోవడానికి `?cor()` టైప్ చేయండి.\n"
],
"metadata": {
"id": "1dvP0LBUueAW"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the correlation between the city_name and the price\n",
"cor(baked_pumpkins$city_name, baked_pumpkins$price)\n",
"\n",
"# Find the correlation between the package and the price\n",
"cor(baked_pumpkins$package, baked_pumpkins$price)\n"
],
"outputs": [],
"metadata": {
"id": "3bQzXCjFuiSV"
}
},
{
"cell_type": "markdown",
"source": [
"అవసరమైనంతవరకు, సిటీ మరియు ధర మధ్య బలహీన సంబంధం మాత్రమే ఉంది. అయితే ప్యాకేజీ మరియు దాని ధర మధ్య కొంత మెరుగైన సంబంధం ఉంది. అది అర్థం అవుతుంది కదా? సాధారణంగా, ఉత్పత్తి పెట్టె పెద్దదైతే, ధర ఎక్కువగా ఉంటుంది.\n",
"\n",
"మనం ఇదే సమయంలో, `corrplot` ప్యాకేజీ ఉపయోగించి అన్ని కాలమ్స్ యొక్క సంబంధ మ్యాట్రిక్స్ను కూడా విజువలైజ్ చేయడానికి ప్రయత్నిద్దాం.\n"
],
"metadata": {
"id": "BToPWbgjuoZw"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load the corrplot package\n",
"library(corrplot)\n",
"\n",
"# Obtain correlation matrix\n",
"corr_mat <- cor(baked_pumpkins %>% \n",
" # Drop columns that are not really informative\n",
" select(-c(low_price, high_price)))\n",
"\n",
"# Make a correlation plot between the variables\n",
"corrplot(corr_mat, method = \"shade\", shade.col = NA, tl.col = \"black\", tl.srt = 45, addCoef.col = \"black\", cl.pos = \"n\", order = \"original\")"
],
"outputs": [],
"metadata": {
"id": "ZwAL3ksmutVR"
}
},
{
"cell_type": "markdown",
"source": [
"🤩🤩 చాలా మెరుగైంది.\n",
"\n",
"ఇప్పుడు ఈ డేటా గురించి అడగవలసిన మంచి ప్రశ్న: '`నిర్దిష్టమైన పంప్కిన్ ప్యాకేజీకి నేను ఎంత ధర ఆశించవచ్చు?`' మనం దీని మీద నేరుగా దృష్టి సారిద్దాం!\n",
"\n",
"> గమనిక: మీరు **`bake()`** ద్వారా ప్రిపేర్ చేసిన రెసిపీ **`pumpkins_prep`** ను **`new_data = NULL`** తో ఉపయోగిస్తే, మీరు ప్రాసెస్ చేసిన (అంటే ఎన్కోడ్ చేసిన) శిక్షణ డేటాను పొందుతారు. ఉదాహరణకు, మీకు మరో డేటా సెట్ ఉంటే, ఉదాహరణకు టెస్ట్ సెట్, మరియు మీరు ఒక రెసిపీ దానిని ఎలా ప్రీ-ప్రాసెస్ చేస్తుందో చూడాలనుకుంటే, మీరు సాదారణంగా **`pumpkins_prep`** ను **`new_data = test_set`** తో బేక్ చేస్తారు.\n",
"\n",
"## 4. లీనియర్ రిగ్రెషన్ మోడల్ నిర్మించండి\n",
"\n",
"
\n",
" \n",
" ఇన్ఫోగ్రాఫిక్ - దసాని మడిపల్లి\n",
"\n",
"\n",
"\n"
],
"metadata": {
"id": "YqXjLuWavNxW"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు మనం ఒక రెసిపీని నిర్మించి, డేటా సరైన విధంగా ప్రీ-ప్రాసెస్ అవుతుందని నిజం చేసుకున్నాము, ఇప్పుడు మనం ఒక రిగ్రెషన్ మోడల్ను నిర్మిద్దాం ఈ ప్రశ్నకు సమాధానం చెప్పడానికి: `ఒక నిర్దిష్ట పంప్కిన్ ప్యాకేజీకి నేను ఎలాంటి ధర ఆశించవచ్చు?`\n",
"\n",
"#### శిక్షణ సెట్ ఉపయోగించి లీనియర్ రిగ్రెషన్ మోడల్ను శిక్షణ ఇవ్వండి\n",
"\n",
"మీకు ఇప్పటికే అర్థమై ఉండవచ్చు, *price* కాలమ్ `ఫలితం` వేరియబుల్ కాగా *package* కాలమ్ `పరిశీలన` వేరియబుల్.\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",
"\n",
"ఇప్పుడు మేము మోడల్ను శిక్షణ ఇచ్చినందున, `parsnip::predict()` ఉపయోగించి test_set కోసం అంచనాలు చేయవచ్చు. ఆపై ఈ అంచనాలను నిజమైన లేబుల్ విలువలతో పోల్చి మోడల్ ఎంత బాగా (లేదా బాగా కాకపోవచ్చు!) పని చేస్తుందో అంచనా వేయవచ్చు.\n",
"\n",
"ముందుగా test set కోసం అంచనాలు చేయడం ప్రారంభిద్దాం, ఆపై ఆ కాలమ్స్ను test set కు బైండ్ చేద్దాం.\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",
"
\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",
"> ✅ పాలినోమియల్స్ అనేవి ఒకటి లేదా ఎక్కువ వేరియబుల్స్ మరియు కోఎఫిషియెంట్లతో కూడిన గణితీయ వ్యక్తీకరణలు\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",
"ఈ నోట్బుక్లో వివిధ వేరియబుల్స్ను పరీక్షించి చూడండి, correlation మోడల్ ఖచ్చితత్వానికి ఎలా అనుగుణంగా ఉందో తెలుసుకోండి.\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 ఫ్రేమ్వర్క్ను ఎలా ఉపయోగించాలో మరింత తెలుసుకోవాలనుకుంటే, దయచేసి క్రింది వనరులను చూడండి:\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 ను మరింత ఆహ్లాదకరంగా మరియు ఆకర్షణీయంగా చేసే అద్భుతమైన చిత్రణలను సృష్టించినందుకు. ఆమె మరిన్ని చిత్రణలను ఆమె [గ్యాలరీ](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\n"
]
}
]
}
![](\"../../../../../../translated_images/te/linear-polynomial.5523c7cb6576ccab.webp\"\n",)
\n",
" ![](\"../../../../../../translated_images/te/janitor.e4a77dd3d3e6a32e.webp\"\n",)
\n",
" ![](\"../../../../../../translated_images/te/recipes.9ad10d8a4056bf89.webp\"\n",)
\n",
"