|
|
# Scikit-learn का उपयोग करके रिग्रेशन मॉडल बनाएं: चार तरीकों से रिग्रेशन
|
|
|
|
|
|
## शुरुआती नोट
|
|
|
|
|
|
जब हम एक **सांख्यिकीय मान** की भविष्यवाणी करना चाहते हैं (उदाहरण के लिए, घर की कीमत, तापमान, या बिक्री), तब लाइनियर रिग्रेशन का उपयोग किया जाता है। यह इनपुट फ़ीचर्स और आउटपुट के बीच संबंध का सर्वश्रेष्ठ प्रतिनिधित्व करने वाली एक सीधी रेखा खोजकर काम करता है।
|
|
|
|
|
|
इस पाठ में, हम अधिक उन्नत रिग्रेशन तकनीकों का पता लगाने से पहले अवधारणा को समझने पर ध्यान केंद्रित करते हैं।
|
|
|
|
|
|
> इन्फोग्राफिक द्वारा [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
|
|
## [प्री-लेक्चर क्विज़](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
> ### [यह पाठ R में उपलब्ध है!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
|
|
|
### परिचय
|
|
|
|
|
|
अब तक आपने रिग्रेशन क्या है इसका अन्वेषण किया है, जिसमें कद्दू की कीमतों के डेटासेट के साथ नमूना डेटा शामिल है, जिसे हम इस पाठ में प्रयोग करेंगे। आपने इसे Matplotlib का उपयोग करके भी विज़ुअलाइज़ किया है।
|
|
|
|
|
|
अब आप मशीन लर्निंग के लिए रिग्रेशन में गहराई से जाने के लिए तैयार हैं। जबकि विज़ुअलाइज़ेशन आपको डेटा को समझने में मदद करता है, मशीन लर्निंग की असली शक्ति _मॉडल प्रशिक्षण_ से आती है। मॉडल ऐतिहासिक डेटा पर प्रशिक्षित होते हैं ताकि वे डेटा निर्भरताओं को स्वचालित रूप से पकड़ सकें, और ये मॉडल नए डेटा के लिए परिणामों की भविष्यवाणी कर सकते हैं, जिसे मॉडल ने पहले नहीं देखा है।
|
|
|
|
|
|
इस पाठ में, आप दो प्रकार के रिग्रेशन सीखेंगे: _बुनियादी लाइनियर रिग्रेशन_ और _पॉलीनोमियल रिग्रेशन_, साथ ही इन तकनीकों के कुछ गणितीय पहलू। ये मॉडल हमें अलग-अलग इनपुट डेटा के आधार पर कद्दू की कीमतों की भविष्यवाणी करने की अनुमति देंगे।
|
|
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
|
|
|
|
|
|
> 🎥 ऊपर दी गई छवि पर क्लिक करें लाइनियर रिग्रेशन का संक्षिप्त वीडियो अवलोकन देखने के लिए।
|
|
|
|
|
|
> इस पाठ्यक्रम में, हम न्यूनतम गणितीय ज्ञान मानते हैं, और इसे अन्य क्षेत्रों से आने वाले छात्रों के लिए सुलभ बनाने का प्रयास करते हैं, इसलिए समझ में सहायता के लिए नोट्स, 🧮 कॉलआउट्स, आरेख, और अन्य शिक्षण उपकरण देखें।
|
|
|
|
|
|
### पूर्वापेक्षाएँ
|
|
|
|
|
|
अब तक आप उस कद्दू डेटा की संरचना से परिचित हो जाएंगे, जिसे हम देख रहे हैं। आप इसे इस पाठ के _notebook.ipynb_ फ़ाइल में प्रीलोडेड और पूर्व-साफ किया हुआ पाएंगे। फ़ाइल में, कद्दू की कीमत प्रति बशल नए डेटा फ़्रेम में प्रदर्शित की गई है। सुनिश्चित करें कि आप इन नोटबुक को Visual Studio Code में कर्नेल में चलाने में सक्षम हैं।
|
|
|
|
|
|
### तैयारी
|
|
|
|
|
|
स्मरण कराने के लिए, आप यह डेटा इस तरह की प्रश्न पूछने के लिए लोड कर रहे हैं:
|
|
|
|
|
|
- कद्दू खरीदने का सबसे अच्छा समय कब है?
|
|
|
- एक केस मिनिएचर कद्दुओं की क्या कीमत हो सकती है?
|
|
|
- क्या मुझे इन्हें आधे बशल टोकरी में खरीदना चाहिए या 1 1/9 बशल बॉक्स के अनुसार?
|
|
|
आइए इस डेटा में और खुदाई करते रहें।
|
|
|
|
|
|
पिछले पाठ में, आपने एक Pandas डेटा फ़्रेम बनाया और इसे मूल डेटा सेट के एक भाग से भरा, कीमत को बशल द्वारा मानकीकृत करते हुए। ऐसा करने से, हालांकि, आप केवल लगभग 400 डेटा पॉइंट और केवल पतझड़ के महीनों के लिए डेटा इकट्ठा कर पाए।
|
|
|
|
|
|
इस पाठ के साथ आने वाली नोटबुक में हमने जो डेटा प्रीलोड किया है, उस पर नज़र डालें। डेटा प्रीलोड किया गया है और प्रारंभिक स्कैटरप्लॉट चार्ट किया गया है जो महीनों के डेटा को दिखाता है। संभव है कि डेटा की प्रकृति के बारे में थोड़ा और विवरण प्राप्त किया जा सके, इसे और साफ करके।
|
|
|
|
|
|
## एक लाइनियर रिग्रेशन लाइन
|
|
|
|
|
|
जैसा कि आपने पाठ 1 में सीखा, एक लाइनियर रिग्रेशन व्यायाम का लक्ष्य यह है कि एक रेखा प्लाट की जा सके ताकि:
|
|
|
|
|
|
- **चर संबंध दिखाएं**। चर के बीच संबंध दिखाएं
|
|
|
- **भविष्यवाणियाँ करें**। यह सही पूर्वानुमान लगाएं कि कोई नया डेटा पॉइंट उस रेखा के संबंध में कहाँ आएगा।
|
|
|
|
|
|
यह सामान्य है कि **लीस्ट-स्क्वेयर रिग्रेशन** इस प्रकार की रेखा खींचे। "लीस्ट-स्क्वेयर" शब्द हमारे मॉडल में कुल त्रुटि को कम करने की प्रक्रिया को दर्शाता है। प्रत्येक डेटा पॉइंट के लिए, हम वास्तविक पॉइंट और हमारे रिग्रेशन लाइन के बीच ऊर्ध्वाधर दूरी (जिसे अवशिष्ट कहते हैं) मापते हैं।
|
|
|
|
|
|
हम इन दूरीयों को दो मुख्य कारणों से वर्ग करते हैं:
|
|
|
|
|
|
1. **आकार दिशा से अधिक महत्वपूर्ण:** हम -5 की त्रुटि को +5 की त्रुटि के समान मानना चाहते हैं। वर्गाकरण सभी मानों को सकारात्मक बना देता है।
|
|
|
|
|
|
2. **आउटलेयर्स को दंडित करना:** वर्गाकरण बड़ी त्रुटियों को अधिक महत्व देता है, जिससे रेखा उन बिंदुओं के करीब रहती है जो दूर हैं।
|
|
|
|
|
|
फिर हम इन सभी वर्गीकृत मानों को जोड़ते हैं। हमारा लक्ष्य उस विशेष रेखा को खोजना है जहाँ यह अंतिम योग न्यूनतम हो (संभवतः सबसे छोटे मान पर) — इसलिए इसे "लीस्ट-स्क्वेयर" कहा जाता है।
|
|
|
|
|
|
> **🧮 मुझे गणित दिखाओ**
|
|
|
>
|
|
|
> इस रेखा को, जिसे _लाइन ऑफ़ बेस्ट फिट_ कहा जाता है, [एक समीकरण](https://en.wikipedia.org/wiki/Simple_linear_regression) द्वारा व्यक्त किया जा सकता है:
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` 'व्याख्यात्मक चर' है। `Y` 'निर्भर चर' है। रेखा का ढलान `b` है और `a` y-अवरोध (y-intercept) है, जो 'X = 0' होने पर `Y` का मान दर्शाता है।
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> पहले, ढलान `b` की गणना करें। इन्फोग्राफिक द्वारा [Jen Looper](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> दूसरे शब्दों में, और हमारे कद्दू डेटा के मूल प्रश्न को ध्यान में रखते हुए: "महीने के अनुसार प्रति बशल कद्दू की कीमत की भविष्यवाणी करें", `X` कीमत को संदर्भित करता है और `Y` बिक्री के महीने को।
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> `Y` के मान की गणना करें। यदि आप लगभग $4 का भुगतान कर रहे हैं, तो वह अप्रैल होना चाहिए! इन्फोग्राफिक द्वारा [Jen Looper](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> जो गणित रेखा की गणना करता है, उसे ढलान दर्शानी चाहिए, जो अवरोध पर निर्भर भी होती है, अर्थात `X = 0` होने पर `Y` कहाँ होता है।
|
|
|
>
|
|
|
> आप इन मानों की गणना की विधि को [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) वेबसाइट पर देख सकते हैं। साथ ही [यह लीस्ट-स्क्वेयर्स कैलकुलेटर](https://www.mathsisfun.com/data/least-squares-calculator.html) देखें कि कैसे मान रेखा को प्रभावित करते हैं।
|
|
|
|
|
|
## सहसंबंध (Correlation)
|
|
|
|
|
|
एक और शब्द जिसे समझना आवश्यक है, वह है दिए गए X और Y चर के बीच का **सहसंबंध गुणांक**। स्कैटरप्लॉट का उपयोग करके, आप इसे जल्दी से देख सकते हैं। यदि पॉइंट्स एक साफ रेखा में फैलते हैं तो सहसंबंध अधिक होता है, परंतु यदि पॉइंट्स हर जगह फैल गए हैं, तो सहसंबंध कम होता है।
|
|
|
|
|
|
एक अच्छा लाइनियर रिग्रेशन मॉडल वह होगा जिसका सहसंबंध गुणांक उच्च (0 के बजाय 1 के करीब) होगा, और वह लाइन ऑफ़ रिग्रेशन के साथ लीस्ट-स्क्वेयर्स रिग्रेशन विधि का उपयोग करता हो।
|
|
|
|
|
|
✅ इस पाठ के साथ आने वाली नोटबुक चलाएं और महीने से कीमत स्कैटरप्लॉट को देखें। कद्दू बिक्री के लिए महीने और कीमत के डेटा का सहसंबंध आपके विज़ुअल विश्लेषण के अनुसार अधिक है या कम? क्या यदि आप `महीना` के बजाय अधिक सूक्ष्म माप का उपयोग करें, जैसे *साल का दिन* (यानी साल की शुरुआत से दिन की संख्या), तो क्या उस स्थिति में सहसंबंध बदल जाता है?
|
|
|
|
|
|
नीचे के कोड में, हम मान लेंगे कि हमने डेटा को साफ़ किया है, और एक डेटा फ्रेम `new_pumpkins` प्राप्त किया है, जो निम्नलिखित जैसा है:
|
|
|
|
|
|
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
|
|
|
---|-------|-----------|---------|------|---------|-----------|------------|-------
|
|
|
70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
|
|
|
71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
|
|
|
72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
|
|
|
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
|
|
|
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
|
|
|
|
|
|
> डेटा साफ़ करने के लिए कोड [`notebook.ipynb`](notebook.ipynb) में उपलब्ध है। हमने पिछले पाठ की तरह ही सफाई के चरण किए हैं, और `DayOfYear` कॉलम का मूल्य निम्नलिखित अभिव्यक्ति से निकाला है:
|
|
|
|
|
|
```python
|
|
|
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
|
|
|
```
|
|
|
|
|
|
अब जब आपको लाइनियर रिग्रेशन के पीछे का गणित समझ में आ गया है, तो आइए रिग्रेशन मॉडल बनाएं ताकि हम यह देख सकें कि कौन सा कद्दू पैकेज सबसे अच्छी कीमत देगा। कोई भी जो हॉलीडे कद्दू उद्घाटित करने के लिए कद्दू खरीद रहा है, यह जानकारी उनके पैच के कद्दू पैकेज की खरीद को अनुकूल बनाने में मदद कर सकती है।
|
|
|
|
|
|
## सहसंबंध की खोज
|
|
|
|
|
|
[](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
|
|
|
|
|
|
> 🎥 ऊपर दी गई छवि पर क्लिक करें सहसंबंध का संक्षिप्त वीडियो अवलोकन देखने के लिए।
|
|
|
|
|
|
पिछले पाठ से आपने शायद देखा होगा कि विभिन्न महीनों के लिए औसत कीमत कुछ इस प्रकार दिखती है:
|
|
|
|
|
|
<img alt="Average price by month" src="../../../../translated_images/hi/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
यह सुझाव देता है कि कुछ सहसंबंध होना चाहिए, और हम प्रयास कर सकते हैं कि लाइनियर रिग्रेशन मॉडल प्रशिक्षित करें जो `Month` और `Price` के बीच, या `DayOfYear` और `Price` के बीच संबंध की भविष्यवाणी करे। नीचे स्कैटर प्लॉट है जो बाद के संबंध को दिखाता है:
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/hi/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
|
|
|
|
|
|
आइए `corr` फ़ंक्शन का उपयोग करके देखें कि क्या सहसंबंध है:
|
|
|
|
|
|
```python
|
|
|
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
|
|
|
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
|
|
|
```
|
|
|
|
|
|
ऐसा लगता है कि सहसंबंध काफी छोटा है, `Month` के लिए -0.15 और `DayOfMonth` के लिए -0.17, लेकिन एक और महत्वपूर्ण संबंध हो सकता है। ऐसा लगता है कि अलग-अलग कद्दू की किस्मों के लिए कीमतों के अलग-अलग समूह हैं। इस हाइपोथीसिस को पुष्टि करने के लिए, आइए प्रत्येक कद्दू वर्ग को अलग रंग में प्लॉट करें। `scatter` प्लॉटिंग फ़ंक्शन को `ax` पैरामीटर पास करके हम सभी पॉइंट्स को एक ही ग्राफ पर प्लॉट कर सकते हैं:
|
|
|
|
|
|
```python
|
|
|
ax=None
|
|
|
colors = ['red','blue','green','yellow']
|
|
|
for i,var in enumerate(new_pumpkins['Variety'].unique()):
|
|
|
df = new_pumpkins[new_pumpkins['Variety']==var]
|
|
|
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
|
|
|
```
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/hi/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
|
|
|
|
|
|
हमारी जांच से पता चलता है कि किस्म का कुल कीमत पर वास्तविक बिक्री तिथि से अधिक प्रभाव होता है। हम इसे बार ग्राफ से देख सकते हैं:
|
|
|
|
|
|
```python
|
|
|
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
|
|
|
```
|
|
|
|
|
|
<img alt="Bar graph of price vs variety" src="../../../../translated_images/hi/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
अभी के लिए चलिए केवल एक कद्दू किस्म, 'pie type' पर ध्यान केंद्रित करें, और देखें कि तारीख का कीमत पर क्या प्रभाव है:
|
|
|
|
|
|
```python
|
|
|
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
|
|
|
pie_pumpkins.plot.scatter('DayOfYear','Price')
|
|
|
```
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/hi/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
|
|
|
|
|
|
यदि हम अब `Price` और `DayOfYear` के बीच सहसंबंध `corr` फ़ंक्शन से गणना करें, तो हमें लगभग `-0.27` मिलेगा - जिसका मतलब है कि एक पूर्वानुमान मॉडल प्रशिक्षण करना समझदारी है।
|
|
|
|
|
|
> लाइनियर रिग्रेशन मॉडल प्रशिक्षित करने से पहले, यह सुनिश्चित करना महत्वपूर्ण है कि हमारा डेटा साफ हो। लाइनियर रिग्रेशन खाली मानों के साथ अच्छा काम नहीं करता है, इसलिए सभी खाली कोशिकाओं को हटाना समझदारी है:
|
|
|
|
|
|
```python
|
|
|
pie_pumpkins.dropna(inplace=True)
|
|
|
pie_pumpkins.info()
|
|
|
```
|
|
|
|
|
|
एक अन्य तरीका यह होगा कि उन खाली मानों को संबंधित कॉलम के औसत मान से भर दिया जाए।
|
|
|
|
|
|
## सरल लाइनियर रिग्रेशन
|
|
|
|
|
|
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
|
|
|
|
|
|
> 🎥 ऊपर दी गई छवि पर क्लिक करें लाइनियर और पॉलीनोमियल रिग्रेशन का संक्षिप्त वीडियो अवलोकन देखने के लिए।
|
|
|
|
|
|
हम अपने लाइनियर रिग्रेशन मॉडल को प्रशिक्षित करने के लिए **Scikit-learn** पुस्तकालय का उपयोग करेंगे।
|
|
|
|
|
|
```python
|
|
|
from sklearn.linear_model import LinearRegression
|
|
|
from sklearn.metrics import mean_squared_error
|
|
|
from sklearn.model_selection import train_test_split
|
|
|
```
|
|
|
|
|
|
हम इनपुट मानों (फ़ीचर्स) और अपेक्षित आउटपुट (लेबल) को अलग-अलग numpy arrays में अलग करते हैं:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> ध्यान दें कि हमें इनपुट डेटा पर `reshape` करना पड़ा ताकि लाइनियर रिग्रेशन पैकेज इसे सही ढंग से समझ सके। लाइनियर रिग्रेशन 2D-array के रूप में इनपुट की अपेक्षा करता है, जहाँ array की प्रत्येक पंक्ति इनपुट फीचर्स का एक वेक्टर होता है। हमारे मामले में, चूंकि हमारे पास केवल एक इनपुट है, इसलिए हमें N×1 आकार की array चाहिए, जहाँ N डेटासेट का आकार है।
|
|
|
|
|
|
फिर, हमें डेटा को ट्रेन और टेस्ट डेटासेट में विभाजित करना होगा ताकि हम प्रशिक्षण के बाद हमारे मॉडल का मान्यकरण कर सकें:
|
|
|
|
|
|
```python
|
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
|
```
|
|
|
|
|
|
अंत में, वास्तविक लाइनियर रिग्रेशन मॉडल को प्रशिक्षित करना केवल दो पंक्तियों कोड में होता है। हम `LinearRegression` वस्तु परिभाषित करते हैं, और `fit` विधि का उपयोग करके इसे डेटा से फिट करते हैं:
|
|
|
|
|
|
```python
|
|
|
lin_reg = LinearRegression()
|
|
|
lin_reg.fit(X_train,y_train)
|
|
|
```
|
|
|
|
|
|
`LinearRegression` ऑब्जेक्ट `fit` करने के बाद रिग्रेशन के सभी गुणांक (coefficients) रखता है, जिन्हें `.coef_` प्रॉपर्टी का उपयोग करके एक्सेस किया जा सकता है। हमारे मामले में, केवल एक गुणांक है, जो लगभग `-0.017` के आसपास होना चाहिए। इसका मतलब है कि समय के साथ कीमतें थोड़ा गिरती लगती हैं, लेकिन बहुत अधिक नहीं, लगभग 2 सेंट प्रति दिन। हम रिग्रेशन के Y-अक्ष के साथ इंटरसेक्शन पॉइंट को भी `lin_reg.intercept_` का उपयोग कर सकते हैं - यह हमारे मामले में लगभग `21` होगा, जो साल की शुरुआत में कीमत को दर्शाता है।
|
|
|
|
|
|
अपने मॉडल की सटीकता देखने के लिए, हम टेस्ट डेटासेट पर कीमतों की भविष्यवाणी कर सकते हैं, और फिर देख सकते हैं कि हमारी भविष्यवाणियाँ अपेक्षित मानों के कितनी करीब हैं। यह रूट मीन स्क्वायर एरर (RMSE) मेट्रिक का उपयोग करके किया जा सकता है, जो कि अपेक्षित और भविष्यवाणी किए गए मानों के बीच सभी वर्गीकृत अंतर का माध्य का मूल है।
|
|
|
|
|
|
```python
|
|
|
pred = lin_reg.predict(X_test)
|
|
|
|
|
|
rmse = np.sqrt(mean_squared_error(y_test,pred))
|
|
|
print(f'RMSE: {rmse:3.3} ({rmse/np.mean(pred)*100:3.3}%)')
|
|
|
```
|
|
|
|
|
|
हमारी त्रुटि लगभग 2 पॉइंट के आसपास दिखती है, जो ~17% है। बहुत अच्छा नहीं। मॉडल क्वालिटी का एक और संकेतक **निर्धारण गुणांक (coefficient of determination)** है, जिसे इस प्रकार प्राप्त किया जा सकता है:
|
|
|
|
|
|
```python
|
|
|
score = lin_reg.score(X_train,y_train)
|
|
|
print('Model determination: ', score)
|
|
|
```
|
|
|
|
|
|
यदि मान 0 है, तो इसका मतलब है कि मॉडल इनपुट डेटा को ध्यान में नहीं लेता, और *सबसे खराब रैखिक पूर्वानुमानक* की तरह व्यवहार करता है, जो कि परिणाम का केवल औसत मान होता है। मान 1 का अर्थ है कि हम सभी अपेक्षित आउटपुट को पूरी तरह से सही भविष्यवाणी कर सकते हैं। हमारे मामले में, गुणांक लगभग 0.06 है, जो काफी कम है।
|
|
|
|
|
|
हम टेस्ट डेटा को रिग्रेशन लाइन के साथ प्लॉट भी कर सकते हैं ताकि यह बेहतर दिख सके कि हमारे मामले में रिग्रेशन कैसे काम करता है:
|
|
|
|
|
|
```python
|
|
|
plt.scatter(X_test,y_test)
|
|
|
plt.plot(X_test,pred)
|
|
|
```
|
|
|
|
|
|
<img alt="Linear regression" src="../../../../translated_images/hi/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## पॉलीनॉमियल रिग्रेशन
|
|
|
|
|
|
रैखिक रिग्रेशन का एक और प्रकार पॉलीनॉमियल रिग्रेशन है। जबकि कभी-कभी वेरिएबल्स के बीच एक रैखिक संबंध होता है - जैसे कि कद्दू जितना बड़ा होगा, कीमत उतनी ही अधिक होगी - कभी-कभी ये संबंध कोई समतल या सीधी रेखा नहीं हो सकते।
|
|
|
|
|
|
✅ यहाँ [कुछ और उदाहरण](https://online.stat.psu.edu/stat501/lesson/9/9.8) हैं जिनमें पॉलीनॉमियल रिग्रेशन का उपयोग हो सकता है।
|
|
|
|
|
|
दिनांक (Date) और कीमत (Price) के बीच संबंध पर एक बार फिर से नज़र डालें। क्या यह स्कैटरप्लॉट ऐसा लगता है कि इसे ज़रूरी तौर पर सीधी रेखा से विश्लेषित किया जाना चाहिए? क्या कीमतें उतार-चढ़ाव नहीं कर सकतीं? इस मामले में, आप पॉलीनॉमियल रिग्रेशन आज़मा सकते हैं।
|
|
|
|
|
|
✅ पॉलीनॉमियल गणितीय अभिव्यक्तियाँ होती हैं जिनमें एक या अधिक वेरिएबल और गुणांक हो सकते हैं।
|
|
|
|
|
|
पॉलीनॉमियल रिग्रेशन एक घुमावदार रेखा बनाता है जो गैर-रेखीय डेटा को बेहतर फिट करता है। हमारे मामले में, यदि हम इनपुट डेटा में वर्गीकृत `DayOfYear` वैरिएबल शामिल करें, तो हम अपने डेटा को परवलयाकार (parabolic) वक्र के साथ फिट कर पाएंगे, जिसका एक न्यूनतम बिंदु साल के भीतर कहीं होगा।
|
|
|
|
|
|
Scikit-learn में एक उपयोगी [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) शामिल है जो डेटा प्रोसेसिंग के विभिन्न चरणों को एक साथ जोड़ता है। एक **पाइपलाइन** **एस्टिमेटर्स** की श्रृंखला होती है। हमारे मामले में, हम एक पाइपलाइन बनाएंगे जो पहले मॉडल में पॉलीनॉमियल फीचर्स जोड़ता है, और फिर रिग्रेशन को प्रशिक्षित करता है:
|
|
|
|
|
|
```python
|
|
|
from sklearn.preprocessing import PolynomialFeatures
|
|
|
from sklearn.pipeline import make_pipeline
|
|
|
|
|
|
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
|
|
|
|
|
|
pipeline.fit(X_train,y_train)
|
|
|
```
|
|
|
|
|
|
`PolynomialFeatures(2)` का उपयोग करने का मतलब है कि हम इनपुट डेटा से सभी द्वित्वतीय (second-degree) पॉलीनॉमियल्स शामिल करेंगे। हमारे मामले में इसका मतलब केवल `DayOfYear`<sup>2</sup> होगा, लेकिन यदि दो इनपुट वेरिएबल X और Y हों, तो यह X<sup>2</sup>, XY और Y<sup>2</sup> जोड़ देगा। हम उच्च-डिग्री पॉलीनॉमियल भी उपयोग कर सकते हैं यदि चाहें।
|
|
|
|
|
|
पाइपलाइनों का उपयोग मूल `LinearRegression` ऑब्जेक्ट की तरह ही किया जा सकता है, अर्थात हम पाइपलाइन को `fit` कर सकते हैं, और फिर `predict` का उपयोग करके भविष्यवाणी के परिणाम प्राप्त कर सकते हैं। यहाँ ग्राफ है जो टेस्ट डेटा और अनुमानित वक्र दिखाता है:
|
|
|
|
|
|
<img alt="Polynomial regression" src="../../../../translated_images/hi/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
पॉलीनॉमियल रिग्रेशन का उपयोग करके, हम थोड़ा नीचे MSE और उच्च निर्धारण प्राप्त कर सकते हैं, लेकिन बहुत अधिक नहीं। हमें अन्य फीचर्स को भी ध्यान में रखना होगा!
|
|
|
|
|
|
> आप देख सकते हैं कि न्यूनतम कद्दू की कीमतें लगभग हैलोवीन के आसपास देखी जाती हैं। आप इसे कैसे समझाएंगे?
|
|
|
|
|
|
🎃 बधाई हो, आपने अभी एक ऐसा मॉडल बनाया है जो पैसे कद्दू की कीमत की भविष्यवाणी करने में मदद कर सकता है। आप शायद इसी प्रक्रिया को सभी कद्दू प्रकारों के लिए दोहरा सकते हैं, लेकिन यह मुश्किल होगा। आइए अब सीखते हैं कि मॉडल में कद्दू की किस्म (variety) को कैसे शामिल करें!
|
|
|
|
|
|
## श्रेणीबद्ध फीचर्स (Categorical Features)
|
|
|
|
|
|
आदर्श दुनिया में, हम चाहते हैं कि हम एक ही मॉडल का उपयोग करके विभिन्न कद्दू किस्मों की कीमतें भविष्यवाणी कर सकें। हालांकि, `Variety` कॉलम `Month` जैसे कॉलमों से थोड़ा अलग है, क्योंकि इसमें गैर-संख्यात्मक (non-numeric) मान होते हैं। ऐसे कॉलम को **श्रेणीबद्ध (categorical)** कहा जाता है।
|
|
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
|
|
|
|
|
|
> 🎥 ऊपर दिए गए इमेज पर क्लिक करें एक संक्षिप्त वीडियो अवलोकन के लिए जिसमें श्रेणीबद्ध फीचर्स के उपयोग को बताया गया है।
|
|
|
|
|
|
यहाँ आप देख सकते हैं कि औसत कीमत किस्म पर कैसे निर्भर करती है:
|
|
|
|
|
|
<img alt="Average price by variety" src="../../../../translated_images/hi/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
किस्म को ध्यान में लेने के लिए, हमें इसे पहले संख्यात्मक रूप में बदलना होगा, या **इन्कोड (encode)** करना होगा। इसे करने के कई तरीके हैं:
|
|
|
|
|
|
* सरल **न्यूमरिक इन्कोडिंग** विभिन्न किस्मों की एक तालिका बनाता है, और फिर किस्म के नाम को उस तालिका में एक अनुक्रमांक (index) से बदल देता है। यह रैखिक रिग्रेशन के लिए सबसे अच्छा विचार नहीं है, क्योंकि रिग्रेशन अनुक्रमांक के वास्तविक संख्यात्मक मान को लेता है और इसे कुछ गुणांक से गुणा कर परिणाम में जोड़ता है। हमारे मामले में, अनुक्रमांक नंबर और कीमत के बीच संबंध स्पष्ट रूप से गैर-रेखीय है, भले ही हम सुनिश्चित करें कि अनुक्रमांक किसी विशेष क्रम में हों।
|
|
|
* **वन-हॉट इन्कोडिंग (One-hot encoding)** `Variety` कॉलम को 4 अलग-अलग कॉलमों से प्रतिस्थापित कर देगा, प्रत्येक किस्म के लिए एक। हर कॉलम में `1` होगा यदि संबंधित पंक्ति उस किस्म की है, और अन्यथा `0` होगा। इसका मतलब है कि रैखिक रिग्रेशन में चार गुणांक होंगे, प्रत्येक कद्दू किस्म के लिए एक, जो उस विशेष किस्म के लिए "शुरुआती कीमत" (या बल्कि "अतिरिक्त कीमत") के लिए ज़िम्मेदार होंगे।
|
|
|
|
|
|
निचे का कोड दिखाता है कि हम किस तरह से वन-हॉट इन्कोडिंग कर सकते हैं:
|
|
|
|
|
|
```python
|
|
|
pd.get_dummies(new_pumpkins['Variety'])
|
|
|
```
|
|
|
|
|
|
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
|
|
|
----|-----------|-----------|--------------------------|----------
|
|
|
70 | 0 | 0 | 0 | 1
|
|
|
71 | 0 | 0 | 0 | 1
|
|
|
... | ... | ... | ... | ...
|
|
|
1738 | 0 | 1 | 0 | 0
|
|
|
1739 | 0 | 1 | 0 | 0
|
|
|
1740 | 0 | 1 | 0 | 0
|
|
|
1741 | 0 | 1 | 0 | 0
|
|
|
1742 | 0 | 1 | 0 | 0
|
|
|
|
|
|
वन-हॉट इन्कोडेड किस्म को इनपुट के रूप में लेकर जब हम रैखिक रिग्रेशन को ट्रेन करते हैं, तो हमें बस सही ढंग से `X` और `y` डेटा को इनिशियलाइज़ करना होता है:
|
|
|
|
|
|
```python
|
|
|
X = pd.get_dummies(new_pumpkins['Variety'])
|
|
|
y = new_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
बाकी कोड वही है जो हमने ऊपर Linear Regression को ट्रेन करने के लिए इस्तेमाल किया था। यदि आप इसे आज़माएंगे, तो आप देखेंगे कि मेर स्क्वायर्ड एरर लगभग समान है, लेकिन हमें निर्धारण गुणांक (~77%) काफी ज्यादा मिलता है। और भी अधिक सटीक भविष्यवाणियाँ करने के लिए, हम और भी श्रेणीबद्ध फीचर्स और संख्यात्मक फीचर्स, जैसे `Month` या `DayOfYear` को ध्यान में ले सकते हैं। एक बड़ा फीचर्स सेट पाने के लिए, हम `join` का उपयोग कर सकते हैं:
|
|
|
|
|
|
```python
|
|
|
X = pd.get_dummies(new_pumpkins['Variety']) \
|
|
|
.join(new_pumpkins['Month']) \
|
|
|
.join(pd.get_dummies(new_pumpkins['City'])) \
|
|
|
.join(pd.get_dummies(new_pumpkins['Package']))
|
|
|
y = new_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
यहाँ हम `City` और `Package` प्रकार को भी ध्यान में रखते हैं, जिससे हमें MSE 2.84 (10%) और निर्धारण 0.94 मिलता है!
|
|
|
|
|
|
## सब कुछ एक साथ जोड़ना
|
|
|
|
|
|
सबसे अच्छा मॉडल बनाने के लिए, हम ऊपर के उदाहरण से संयुक्त (वन-हॉट इन्कोडेड श्रेणीबद्ध + संख्यात्मक) डेटा को पॉलीनॉमियल रिग्रेशन के साथ उपयोग कर सकते हैं। आपकी सुविधा के लिए यहाँ पूरा कोड है:
|
|
|
|
|
|
```python
|
|
|
# प्रशिक्षण डेटा सेट करें
|
|
|
X = pd.get_dummies(new_pumpkins['Variety']) \
|
|
|
.join(new_pumpkins['Month']) \
|
|
|
.join(pd.get_dummies(new_pumpkins['City'])) \
|
|
|
.join(pd.get_dummies(new_pumpkins['Package']))
|
|
|
y = new_pumpkins['Price']
|
|
|
|
|
|
# ट्रेन-टेस्ट विभाजन करें
|
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
|
|
|
|
# पाइपलाइन सेटअप करें और प्रशिक्षित करें
|
|
|
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
|
|
|
pipeline.fit(X_train,y_train)
|
|
|
|
|
|
# टेस्ट डेटा के लिए परिणाम अनुमानित करें
|
|
|
pred = pipeline.predict(X_test)
|
|
|
|
|
|
# MSE और निर्धारण की गणना करें
|
|
|
mse = np.sqrt(mean_squared_error(y_test,pred))
|
|
|
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
|
|
|
|
|
|
score = pipeline.score(X_train,y_train)
|
|
|
print('Model determination: ', score)
|
|
|
```
|
|
|
|
|
|
इससे हमें सबसे अच्छा निर्धारण गुणांक लगभग 97% और MSE=2.23 (~8% भविष्यवाणी त्रुटि) मिलेगा।
|
|
|
|
|
|
| मॉडल | MSE | निर्धारण |
|
|
|
|-------|-----|-----------|
|
|
|
| `DayOfYear` रैखिक | 2.77 (17.2%) | 0.07 |
|
|
|
| `DayOfYear` पॉलीनॉमियल | 2.73 (17.0%) | 0.08 |
|
|
|
| `Variety` रैखिक | 5.24 (19.7%) | 0.77 |
|
|
|
| सभी फीचर्स रैखिक | 2.84 (10.5%) | 0.94 |
|
|
|
| सभी फीचर्स पॉलीनॉमियल | 2.23 (8.25%) | 0.97 |
|
|
|
|
|
|
🏆 बहुत बढ़िया! आपने एक पाठ में चार रिग्रेशन मॉडल बनाए, और मॉडल की गुणवत्ता को 97% तक सुधार दिया। रिग्रेशन के अंतिम खंड में, आप लॉजिस्टिक रिग्रेशन के बारे में सीखेंगे जो श्रेणियाँ निर्धारित करता है।
|
|
|
|
|
|
---
|
|
|
## 🚀चुनौती
|
|
|
|
|
|
इस नोटबुक में कई विभिन्न वेरिएबल्स को टेस्ट करें यह देखने के लिए कि सह-संबंध कैसे मॉडल की सटीकता से संबंधित है।
|
|
|
|
|
|
## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## समीक्षा और स्व-अध्ययन
|
|
|
|
|
|
इस पाठ में हमने Linear Regression के बारे में सीखा। रिग्रेशन के अन्य महत्वपूर्ण प्रकार भी हैं। Stepwise, Ridge, Lasso और Elasticnet तकनीकों के बारे में पढ़ें। एक अच्छा कोर्स सीखने के लिए है [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
|
|
|
|
|
|
## असाइनमेंट
|
|
|
|
|
|
[एक मॉडल बनाएं](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**अस्वीकरण**:
|
|
|
इस दस्तावेज़ का अनुवाद AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके किया गया है। जबकि हम सटीकता के लिए प्रयासरत हैं, कृपया ध्यान दें कि स्वचालित अनुवादों में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में दस्तावेज़ को ही अधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम जिम्मेदार नहीं हैं।
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
