\n",
" \n",
" ڈیزائن: داسانی مڈیپالی\n",
"\n",
"\n",
"#### تعارف\n",
"\n",
"اب تک آپ نے رجعت کے بارے میں جانا ہے، جس میں کدو کی قیمتوں کے ڈیٹا سیٹ سے نمونہ ڈیٹا استعمال کیا گیا ہے، جو ہم اس سبق میں استعمال کریں گے۔ آپ نے اسے `ggplot2` کے ذریعے بصری طور پر بھی دیکھا ہے۔💪\n",
"\n",
"اب آپ مشین لرننگ کے لیے رجعت کو مزید گہرائی سے سمجھنے کے لیے تیار ہیں۔ اس سبق میں، آپ دو قسم کی رجعت کے بارے میں مزید سیکھیں گے: *بنیادی لکیری رجعت* اور *کثیرالحدی رجعت*، اور ان تکنیکوں کے پیچھے موجود کچھ ریاضی کو بھی سمجھیں گے۔\n",
"\n",
"> اس نصاب میں، ہم ریاضی کے کم سے کم علم کو فرض کرتے ہیں اور اسے ان طلباء کے لیے قابل رسائی بنانے کی کوشش کرتے ہیں جو دیگر شعبوں سے آ رہے ہیں۔ لہذا نوٹس، 🧮 کال آؤٹس، خاکے، اور دیگر سیکھنے کے آلات پر نظر رکھیں جو سمجھنے میں مدد فراہم کریں۔\n",
"\n",
"#### تیاری\n",
"\n",
"یاد دہانی کے طور پر، آپ اس ڈیٹا کو اس لیے لوڈ کر رہے ہیں تاکہ اس سے سوالات پوچھ سکیں۔\n",
"\n",
"- کدو خریدنے کا بہترین وقت کب ہے؟\n",
"\n",
"- چھوٹے کدو کے ایک کیس کی قیمت کیا ہو سکتی ہے؟\n",
"\n",
"- کیا مجھے انہیں آدھے بوشل کی ٹوکریوں میں خریدنا چاہیے یا 1 1/9 بوشل کے ڈبے میں؟ آئیے اس ڈیٹا کو مزید کھنگالتے ہیں۔\n",
"\n",
"پچھلے سبق میں، آپ نے ایک `tibble` (ڈیٹا فریم کا جدید تصور) بنایا اور اسے اصل ڈیٹا سیٹ کے ایک حصے سے بھرا، قیمتوں کو بوشل کے حساب سے معیاری بنایا۔ لیکن ایسا کرنے سے، آپ صرف تقریباً 400 ڈیٹا پوائنٹس حاصل کر سکے اور وہ بھی صرف خزاں کے مہینوں کے لیے۔ شاید ہم ڈیٹا کو مزید صاف کر کے اس کی نوعیت کے بارے میں کچھ زیادہ تفصیل حاصل کر سکیں؟ دیکھتے ہیں... 🕵️♀️\n",
"\n",
"اس کام کے لیے، ہمیں درج ذیل پیکجز کی ضرورت ہوگی:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) ایک [R پیکجز کا مجموعہ](https://www.tidyverse.org/packages) ہے جو ڈیٹا سائنس کو تیز، آسان اور مزیدار بناتا ہے!\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) فریم ورک ایک [پیکجز کا مجموعہ](https://www.tidymodels.org/packages/) ہے جو ماڈلنگ اور مشین لرننگ کے لیے استعمال ہوتا ہے۔\n",
"\n",
"- `janitor`: [janitor پیکج](https://github.com/sfirke/janitor) گندے ڈیٹا کو جانچنے اور صاف کرنے کے لیے سادہ چھوٹے آلات فراہم کرتا ہے۔\n",
"\n",
"- `corrplot`: [corrplot پیکج](https://cran.r-project.org/web/packages/corrplot/vignettes/corrplot-intro.html) ایک بصری تحقیقی آلہ فراہم کرتا ہے جو متغیرات کے درمیان چھپے ہوئے نمونوں کو تلاش کرنے میں مدد دیتا ہے۔\n",
"\n",
"آپ انہیں اس طرح انسٹال کر سکتے ہیں:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"corrplot\"))`\n",
"\n",
"نیچے دیا گیا اسکرپٹ چیک کرتا ہے کہ آیا آپ کے پاس اس ماڈیول کو مکمل کرنے کے لیے مطلوبہ پیکجز موجود ہیں، اور اگر وہ غائب ہیں تو انہیں آپ کے لیے انسٹال کرتا ہے۔\n"
],
"metadata": {
"id": "WqQPS1OAsg3H"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"suppressWarnings(if (!require(\"pacman\")) install.packages(\"pacman\"))\n",
"\n",
"pacman::p_load(tidyverse, tidymodels, janitor, corrplot)"
],
"outputs": [],
"metadata": {
"id": "tA4C2WN3skCf",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "c06cd805-5534-4edc-f72b-d0d1dab96ac0"
}
},
{
"cell_type": "markdown",
"source": [
"ہم بعد میں ان شاندار پیکجز کو لوڈ کریں گے اور انہیں اپنے موجودہ R سیشن میں دستیاب کریں گے۔ (یہ صرف وضاحت کے لیے ہے، `pacman::p_load()` نے یہ کام پہلے ہی آپ کے لیے کر دیا ہے)\n",
"\n",
"## 1. ایک لکیری رجریشن لائن\n",
"\n",
"جیسا کہ آپ نے سبق نمبر 1 میں سیکھا، لکیری رجریشن کا مقصد یہ ہے کہ ہم ایک *لائن* *آف* *بیسٹ فٹ* کو اس طرح سے بنا سکیں:\n",
"\n",
"- **متغیرات کے تعلقات دکھائیں**۔ متغیرات کے درمیان تعلق کو ظاہر کریں۔\n",
"\n",
"- **پیش گوئیاں کریں**۔ یہ پیش گوئی کریں کہ نیا ڈیٹا پوائنٹ اس لائن کے تعلق میں کہاں گرے گا۔\n",
"\n",
"اس قسم کی لائن کھینچنے کے لیے ہم ایک شماریاتی تکنیک استعمال کرتے ہیں جسے **لیسٹ-اسکوائرز رجریشن** کہتے ہیں۔ `لیسٹ-اسکوائرز` کا مطلب یہ ہے کہ رجریشن لائن کے ارد گرد موجود تمام ڈیٹا پوائنٹس کو مربع کیا جاتا ہے اور پھر انہیں جمع کیا جاتا ہے۔ مثالی طور پر، یہ آخری مجموعہ جتنا چھوٹا ہو، اتنا ہی بہتر ہے، کیونکہ ہم غلطیوں کی کم تعداد چاہتے ہیں، یا `لیسٹ-اسکوائرز`۔ اس طرح، بہترین فٹ کی لائن وہ لائن ہے جو ہمیں مربع شدہ غلطیوں کے مجموعے کے لیے سب سے کم قدر دیتی ہے - اسی لیے اسے *لیسٹ اسکوائرز رجریشن* کہا جاتا ہے۔\n",
"\n",
"ہم ایسا اس لیے کرتے ہیں کیونکہ ہم ایک ایسی لائن کا ماڈل بنانا چاہتے ہیں جو ہمارے تمام ڈیٹا پوائنٹس سے کم سے کم مجموعی فاصلے پر ہو۔ ہم ان شرائط کو جمع کرنے سے پہلے مربع کرتے ہیں کیونکہ ہمیں اس کی شدت کی فکر ہے، نہ کہ اس کی سمت کی۔\n",
"\n",
"> **🧮 مجھے ریاضی دکھائیں**\n",
">\n",
"> اس لائن، جسے *بیسٹ فٹ کی لائن* کہا جاتا ہے، کو [ایک مساوات](https://en.wikipedia.org/wiki/Simple_linear_regression) کے ذریعے ظاہر کیا جا سکتا ہے:\n",
">\n",
"> Y = a + bX\n",
">\n",
"> `X` '`وضاحتی متغیر` یا `پیش گو`' ہے۔ `Y` '`انحصاری متغیر` یا `نتیجہ`' ہے۔ لائن کا ڈھلوان `b` ہے اور `a` y-انٹرسیپٹ ہے، جو اس وقت `Y` کی قدر کو ظاہر کرتا ہے جب `X = 0` ہو۔\n",
">\n",
"\n",
"> ![](../../../../../../2-Regression/3-Linear/solution/images/slope.png \"slope = $y/x$\")\n",
" Jen Looper کی طرف سے انفوگرافک\n",
">\n",
"> پہلے، ڈھلوان `b` کا حساب لگائیں۔\n",
">\n",
"> دوسرے الفاظ میں، اور ہمارے کدو کے ڈیٹا کے اصل سوال کا حوالہ دیتے ہوئے: \"ماہ کے لحاظ سے فی بوشل کدو کی قیمت کی پیش گوئی کریں\"، `X` قیمت کو ظاہر کرے گا اور `Y` فروخت کے مہینے کو ظاہر کرے گا۔\n",
">\n",
"> \n",
" Jen Looper کی طرف سے انفوگرافک\n",
"> \n",
"> `Y` کی قدر کا حساب لگائیں۔ اگر آپ تقریباً \\$4 ادا کر رہے ہیں، تو یہ ضرور اپریل ہوگا!\n",
">\n",
"> لائن کا حساب لگانے والی ریاضی کو لائن کی ڈھلوان ظاہر کرنی چاہیے، جو انٹرسیپٹ پر بھی منحصر ہے، یا جہاں `Y` واقع ہے جب `X = 0` ہو۔\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",
"ایک اچھا لکیری رجریشن ماڈل وہ ہوگا جس کا تعلق کا عددی ضابطہ زیادہ ہو (1 کے قریب ہو، 0 کے مقابلے میں) اور جو لیسٹ-اسکوائرز رجریشن طریقے کے ساتھ رجریشن لائن کا استعمال کرے۔\n"
],
"metadata": {
"id": "cdX5FRpvsoP5"
}
},
{
"cell_type": "markdown",
"source": [
"## **2. ڈیٹا کے ساتھ ایک رقص: ایک ڈیٹا فریم بنانا جو ماڈلنگ کے لیے استعمال ہوگا**\n",
"\n",
"
\n",
" \n",
" آرٹ ورک از @allison_horst\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": [
"کیا ہوگا اگر ہم کدو کے `price` کی پیش گوئی کرنا چاہیں، اس بنیاد پر کہ `city` یا `package` کالمز، جو کہ کریکٹر قسم کے ہیں؟ یا اس سے بھی زیادہ آسان، ہم کیسے `package` اور `price` کے درمیان تعلق (جو دونوں ان پٹ کے عددی ہونے کی ضرورت ہوتی ہے) تلاش کر سکتے ہیں؟ 🤷🤷\n",
"\n",
"مشین لرننگ ماڈلز عددی خصوصیات کے ساتھ بہتر کام کرتے ہیں بجائے کہ متنی قدروں کے، اس لیے عام طور پر آپ کو زمرہ وار خصوصیات کو عددی نمائندگی میں تبدیل کرنے کی ضرورت ہوتی ہے۔\n",
"\n",
"اس کا مطلب یہ ہے کہ ہمیں اپنے پیش گو عناصر کو اس طرح دوبارہ ترتیب دینا ہوگا کہ ماڈل ان کا مؤثر طریقے سے استعمال کر سکے، اس عمل کو `feature engineering` کہا جاتا ہے۔\n"
],
"metadata": {
"id": "7hsHoxsStyjJ"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. ماڈلنگ کے لیے ڈیٹا کی تیاری کے لیے ترکیبیں 👩🍳👨🍳\n",
"\n",
"ایسی سرگرمیاں جو پیش گوئی کرنے والی اقدار کو دوبارہ ترتیب دیتی ہیں تاکہ ماڈل کے لیے انہیں مؤثر طریقے سے استعمال کرنا آسان ہو، کو `فیچر انجینئرنگ` کہا جاتا ہے۔\n",
"\n",
"مختلف ماڈلز کی مختلف پری پروسیسنگ ضروریات ہوتی ہیں۔ مثال کے طور پر، لیسٹ اسکوائرز کو `کیٹیگوریکل ویریبلز` جیسے مہینہ، قسم، اور شہر کے نام کو `انکوڈنگ` کرنے کی ضرورت ہوتی ہے۔ اس میں صرف ایک کالم کو `کیٹیگوریکل ویلیوز` کے ساتھ `نومریک کالمز` میں تبدیل کرنا شامل ہوتا ہے جو اصل کالم کی جگہ لے لیتے ہیں۔\n",
"\n",
"مثال کے طور پر، فرض کریں کہ آپ کے ڈیٹا میں درج ذیل کیٹیگوریکل فیچر شامل ہے:\n",
"\n",
"| شہر |\n",
"|:-------:|\n",
"| ڈینور |\n",
"| نیروبی |\n",
"| ٹوکیو |\n",
"\n",
"آپ *آرڈینل انکوڈنگ* کا استعمال کر سکتے ہیں تاکہ ہر کیٹیگری کے لیے ایک منفرد عددی قدر کو تبدیل کیا جا سکے، جیسے:\n",
"\n",
"| شہر |\n",
"|:----:|\n",
"| 0 |\n",
"| 1 |\n",
"| 2 |\n",
"\n",
"اور یہی ہم اپنے ڈیٹا کے ساتھ کریں گے!\n",
"\n",
"اس سیکشن میں، ہم ایک اور شاندار Tidymodels پیکیج: [recipes](https://tidymodels.github.io/recipes/) کو دریافت کریں گے - جو آپ کے ڈیٹا کو ماڈل کی تربیت سے **پہلے** تیار کرنے میں مدد دینے کے لیے ڈیزائن کیا گیا ہے۔ بنیادی طور پر، ایک ترکیب ایک آبجیکٹ ہے جو یہ بیان کرتی ہے کہ ڈیٹا سیٹ پر ماڈلنگ کے لیے تیار کرنے کے لیے کون سے اقدامات لاگو کیے جائیں۔\n",
"\n",
"اب، آئیے ایک ترکیب بناتے ہیں جو ہمارے ڈیٹا کو ماڈلنگ کے لیے تیار کرے گی، اور پیش گوئی کرنے والے کالمز میں تمام مشاہدات کے لیے ایک منفرد عددی قدر کو تبدیل کرے گی:\n"
],
"metadata": {
"id": "AD5kQbcvt3Xl"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Specify a recipe\n",
"pumpkins_recipe <- recipe(price ~ ., data = new_pumpkins) %>% \n",
" step_integer(all_predictors(), zero_based = TRUE)\n",
"\n",
"\n",
"# Print out the recipe\n",
"pumpkins_recipe"
],
"outputs": [],
"metadata": {
"id": "BNaFKXfRt9TU"
}
},
{
"cell_type": "markdown",
"source": [
"زبردست! 👏 ہم نے ابھی اپنا پہلا نسخہ تیار کیا ہے جو ایک نتیجہ (قیمت) اور اس کے متعلقہ پیش گوئی کرنے والے عوامل کو بیان کرتا ہے، اور یہ کہ تمام پیش گوئی کرنے والے کالمز کو اعداد کی ایک سیٹ میں تبدیل کیا جانا چاہیے 🙌! آئیے اسے جلدی سے سمجھتے ہیں:\n",
"\n",
"- `recipe()` کو ایک فارمولے کے ساتھ کال کرنے سے نسخے کو متغیرات کے *کردار* بتائے جاتے ہیں، جس میں `new_pumpkins` ڈیٹا کو حوالہ کے طور پر استعمال کیا جاتا ہے۔ مثال کے طور پر، `price` کالم کو `outcome` کا کردار دیا گیا ہے جبکہ باقی کالمز کو `predictor` کا کردار دیا گیا ہے۔\n",
"\n",
"- `step_integer(all_predictors(), zero_based = TRUE)` یہ بتاتا ہے کہ تمام پیش گوئی کرنے والے عوامل کو اعداد کی ایک سیٹ میں تبدیل کیا جانا چاہیے، جس کی گنتی 0 سے شروع ہوتی ہے۔\n",
"\n",
"ہمیں یقین ہے کہ آپ کے ذہن میں یہ خیال آ رہا ہوگا: \"یہ تو بہت زبردست ہے!! لیکن اگر مجھے یہ تصدیق کرنی ہو کہ نسخے وہی کر رہے ہیں جو میں ان سے توقع کر رہا ہوں؟ 🤔\"\n",
"\n",
"یہ ایک شاندار خیال ہے! دیکھیں، جب آپ کا نسخہ تیار ہو جاتا ہے، تو آپ ان پیرامیٹرز کا اندازہ لگا سکتے ہیں جو اصل میں ڈیٹا کو پہلے سے پروسیس کرنے کے لیے درکار ہیں، اور پھر پروسیس شدہ ڈیٹا کو نکال سکتے ہیں۔ عام طور پر آپ کو یہ کرنے کی ضرورت نہیں ہوتی جب آپ Tidymodels استعمال کرتے ہیں (ہم ایک منٹ میں اس کا عام طریقہ دیکھیں گے -> `workflows`) لیکن یہ اس وقت کارآمد ہو سکتا ہے جب آپ یہ تصدیق کرنا چاہیں کہ نسخے وہی کر رہے ہیں جو آپ ان سے توقع کر رہے ہیں۔\n",
"\n",
"اس کے لیے، آپ کو دو مزید افعال کی ضرورت ہوگی: `prep()` اور `bake()` اور ہمیشہ کی طرح، ہمارے چھوٹے R دوست [`Allison Horst`](https://github.com/allisonhorst/stats-illustrations) کی مدد سے آپ کو یہ بہتر سمجھنے میں مدد ملے گی!\n",
"\n",
"
\n",
" \n",
" Artwork by @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): ایک تیار شدہ نسخہ لیتا ہے اور کسی بھی ڈیٹا سیٹ پر آپریشنز لاگو کرتا ہے۔\n",
"\n",
"یہ سب کہنے کے بعد، آئیے اپنے نسخے تیار کریں اور ان پر عمل کریں تاکہ واقعی تصدیق ہو جائے کہ اندرونی طور پر، پیش گوئی کرنے والے کالم پہلے انکوڈ کیے جائیں گے اس سے پہلے کہ ماڈل فٹ کیا جائے۔\n"
],
"metadata": {
"id": "Q1xtzebuuTCP"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Prep the recipe\n",
"pumpkins_prep <- prep(pumpkins_recipe)\n",
"\n",
"# Bake the recipe to extract a preprocessed new_pumpkins data\n",
"baked_pumpkins <- bake(pumpkins_prep, new_data = NULL)\n",
"\n",
"# Print out the baked data set\n",
"baked_pumpkins %>% \n",
" slice_head(n = 10)"
],
"outputs": [],
"metadata": {
"id": "FGBbJbP_uUUn"
}
},
{
"cell_type": "markdown",
"source": [
"واہ! 🥳 پروسیس شدہ ڈیٹا `baked_pumpkins` کے تمام پیش گوئی کرنے والے عناصر کو انکوڈ کیا گیا ہے، جس سے تصدیق ہوتی ہے کہ واقعی وہ پری پروسیسنگ مراحل جو ہماری ترکیب کے طور پر بیان کیے گئے ہیں، توقع کے مطابق کام کریں گے۔ یہ آپ کے لیے پڑھنا مشکل بنا دیتا ہے لیکن Tidymodels کے لیے بہت زیادہ سمجھنے کے قابل بناتا ہے! کچھ وقت نکالیں اور معلوم کریں کہ کون سا مشاہدہ متعلقہ عدد میں تبدیل کیا گیا ہے۔\n",
"\n",
"یہ ذکر کرنا بھی ضروری ہے کہ `baked_pumpkins` ایک ڈیٹا فریم ہے جس پر ہم حساب کتاب کر سکتے ہیں۔\n",
"\n",
"مثال کے طور پر، آئیے آپ کے ڈیٹا کے دو نکات کے درمیان ایک اچھا تعلق تلاش کرنے کی کوشش کریں تاکہ ممکنہ طور پر ایک اچھا پیش گوئی کرنے والا ماڈل بنایا جا سکے۔ ہم اس کے لیے فنکشن `cor()` استعمال کریں گے۔ فنکشن کے بارے میں مزید جاننے کے لیے `?cor()` ٹائپ کریں۔\n"
],
"metadata": {
"id": "1dvP0LBUueAW"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the correlation between the city_name and the price\n",
"cor(baked_pumpkins$city_name, baked_pumpkins$price)\n",
"\n",
"# Find the correlation between the package and the price\n",
"cor(baked_pumpkins$package, baked_pumpkins$price)\n"
],
"outputs": [],
"metadata": {
"id": "3bQzXCjFuiSV"
}
},
{
"cell_type": "markdown",
"source": [
"جیسا کہ پتہ چلتا ہے، شہر اور قیمت کے درمیان تعلق بہت کمزور ہے۔ البتہ، پیکج اور اس کی قیمت کے درمیان تعلق تھوڑا بہتر ہے۔ یہ بات سمجھ میں آتی ہے، ہے نا؟ عام طور پر، جتنا بڑا پروڈکٹ کا ڈبہ ہوگا، قیمت اتنی ہی زیادہ ہوگی۔\n",
"\n",
"جب ہم اس پر کام کر رہے ہیں، تو آئیے `corrplot` پیکج کا استعمال کرتے ہوئے تمام کالمز کا ایک تعلق میٹرکس بھی تصور کرنے کی کوشش کرتے ہیں۔\n"
],
"metadata": {
"id": "BToPWbgjuoZw"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load the corrplot package\n",
"library(corrplot)\n",
"\n",
"# Obtain correlation matrix\n",
"corr_mat <- cor(baked_pumpkins %>% \n",
" # Drop columns that are not really informative\n",
" select(-c(low_price, high_price)))\n",
"\n",
"# Make a correlation plot between the variables\n",
"corrplot(corr_mat, method = \"shade\", shade.col = NA, tl.col = \"black\", tl.srt = 45, addCoef.col = \"black\", cl.pos = \"n\", order = \"original\")"
],
"outputs": [],
"metadata": {
"id": "ZwAL3ksmutVR"
}
},
{
"cell_type": "markdown",
"source": [
"🤩🤩 بہت بہتر۔\n",
"\n",
"اب اس ڈیٹا سے پوچھنے کے لیے ایک اچھا سوال ہوگا: '`کسی دیے گئے کدو کے پیکج کی قیمت کیا ہو سکتی ہے؟`' آئیے اس پر کام شروع کرتے ہیں!\n",
"\n",
"> نوٹ: جب آپ **`bake()`** کرتے ہیں تیار کردہ ترکیب **`pumpkins_prep`** کے ساتھ **`new_data = NULL`**، تو آپ پروسیس شدہ (یعنی انکوڈ شدہ) تربیتی ڈیٹا نکالتے ہیں۔ اگر آپ کے پاس کوئی دوسرا ڈیٹا سیٹ ہو، مثلاً ایک ٹیسٹ سیٹ، اور آپ دیکھنا چاہتے ہوں کہ ترکیب اسے کیسے پہلے سے پروسیس کرے گی، تو آپ صرف **`pumpkins_prep`** کو **`new_data = test_set`** کے ساتھ bake کریں گے۔\n",
"\n",
"## 4. ایک لکیری ریگریشن ماڈل بنائیں\n",
"\n",
"
\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": [
"شاندار کام! اب جب کہ ہمارے پاس ایک نسخہ اور ماڈل کی وضاحت موجود ہے، ہمیں انہیں ایک ایسے آبجیکٹ میں اکٹھا کرنے کا طریقہ تلاش کرنا ہوگا جو پہلے ڈیٹا کو پہلے سے پروسیس کرے (پس منظر میں 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": [
"ماڈل کی تربیت کے دوران سیکھے گئے coefficients کو آؤٹ پٹ سے دیکھا جا سکتا ہے۔ یہ coefficients بہترین فٹ کی لائن کے coefficients کی نمائندگی کرتے ہیں جو اصل اور پیش گوئی شدہ متغیر کے درمیان مجموعی غلطی کو کم سے کم کرتے ہیں۔\n",
"\n",
"#### ٹیسٹ سیٹ کا استعمال کرتے ہوئے ماڈل کی کارکردگی کا جائزہ لیں\n",
"\n",
"اب وقت آ گیا ہے کہ ماڈل کی کارکردگی کو جانچیں 📏! ہم یہ کیسے کریں گے؟\n",
"\n",
"اب جب کہ ہم نے ماڈل کو تربیت دے دیا ہے، ہم اسے `parsnip::predict()` کا استعمال کرتے ہوئے test_set کے لیے پیش گوئیاں کرنے کے لیے استعمال کر سکتے ہیں۔ پھر ہم ان پیش گوئیوں کا موازنہ اصل لیبل کی قدروں سے کریں گے تاکہ یہ جان سکیں کہ ماڈل کتنا اچھا (یا برا!) کام کر رہا ہے۔\n",
"\n",
"آئیے پہلے ٹیسٹ سیٹ کے لیے پیش گوئیاں کرنے سے شروع کرتے ہیں اور پھر ان کالمز کو ٹیسٹ سیٹ کے ساتھ جوڑتے ہیں۔\n"
],
"metadata": {
"id": "_4QkGtBTwItF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Make predictions for the test set\n",
"predictions <- lm_wf_fit %>% \n",
" predict(new_data = pumpkins_test)\n",
"\n",
"\n",
"# Bind predictions to the test set\n",
"lm_results <- pumpkins_test %>% \n",
" select(c(package, price)) %>% \n",
" bind_cols(predictions)\n",
"\n",
"\n",
"# Print the first ten rows of the tibble\n",
"lm_results %>% \n",
" slice_head(n = 10)"
],
"outputs": [],
"metadata": {
"id": "UFZzTG0gwTs9"
}
},
{
"cell_type": "markdown",
"source": [
"آپ نے ابھی ایک ماڈل تربیت دیا ہے اور اس کا استعمال کرتے ہوئے پیش گوئیاں کی ہیں! 🔮 کیا یہ اچھا ہے؟ آئیے ماڈل کی کارکردگی کا جائزہ لیتے ہیں!\n",
"\n",
"Tidymodels میں، ہم یہ `yardstick::metrics()` کے ذریعے کرتے ہیں! لینیئر ریگریشن کے لیے، آئیے درج ذیل میٹرکس پر توجہ مرکوز کرتے ہیں:\n",
"\n",
"- `Root Mean Square Error (RMSE)`: [MSE](https://en.wikipedia.org/wiki/Mean_squared_error) کا مربع جذر۔ یہ ایک مطلق میٹرک فراہم کرتا ہے جو لیبل کے یونٹ میں ہوتا ہے (اس صورت میں، کدو کی قیمت)۔ جتنا چھوٹا یہ ویلیو ہوگا، ماڈل اتنا ہی بہتر ہوگا (سادہ الفاظ میں، یہ اوسط قیمت ظاہر کرتا ہے جس سے پیش گوئیاں غلط ہوتی ہیں!)\n",
"\n",
"- `Coefficient of Determination (عام طور پر R-squared یا R2 کے نام سے جانا جاتا ہے)`: ایک نسبتی میٹرک جس میں جتنا زیادہ ویلیو ہوگا، ماڈل کا فٹ اتنا ہی بہتر ہوگا۔ بنیادی طور پر، یہ میٹرک ظاہر کرتا ہے کہ ماڈل پیش گوئی شدہ اور اصل لیبل ویلیوز کے درمیان کتنی ویرینس کو سمجھنے کے قابل ہے۔\n"
],
"metadata": {
"id": "0A5MjzM7wW9M"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Evaluate performance of linear regression\n",
"metrics(data = lm_results,\n",
" truth = price,\n",
" estimate = .pred)"
],
"outputs": [],
"metadata": {
"id": "reJ0UIhQwcEH"
}
},
{
"cell_type": "markdown",
"source": [
"ماڈل کی کارکردگی ختم ہو گئی۔ آئیے دیکھتے ہیں کہ کیا ہم پیکیج اور قیمت کے ایک اسکیٹر پلاٹ کو بصری طور پر دیکھ کر بہتر اندازہ لگا سکتے ہیں، اور پھر پیش گوئیوں کا استعمال کرتے ہوئے بہترین فٹ کی ایک لائن شامل کریں۔\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",
"\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()` کا استعمال کرتے ہوئے 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",
"اس نوٹ بک میں مختلف متغیرات کو آزمائیں تاکہ یہ دیکھ سکیں کہ 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 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) کا شکریہ کہ انہوں نے شاندار illustrations بنائیں جو R کو زیادہ خوش آئند اور دلچسپ بناتی ہیں۔ مزید illustrations ان کے [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",
"