|
|
# स्कायट-लर्न वापरून रिग्रेशन मॉडेल तयार करा: रिग्रेशन चार प्रकारे
|
|
|
|
|
|
## सुरुवातीसाठी टीप
|
|
|
|
|
|
रेखीय रिग्रेशन तेव्हा वापरले जाते जेव्हा आपल्याला **संख्यात्मक मूल्य** (उदाहरणार्थ, घरांची किंमत, तापमान, किंवा विक्री) भाकित करायचे असते.
|
|
|
हे इनपुट वैशिष्ट्ये आणि आउटपुटमधील संबंध सर्वोत्तम रीतीने दर्शविणारी सरळ रेषा शोधून कार्य करते.
|
|
|
|
|
|
या धड्यात, आम्ही पूर्वीच्या अधिक प्रगत रिग्रेशन तंत्रांचा अभ्यास करण्याआधी संकल्पना समजण्यावर भर देतो.
|
|
|
|
|
|
> इन्फोग्राफिक द्वारे [दसनी मडिपल्ली](https://twitter.com/dasani_decoded)
|
|
|
## [पूर्व-पाठ क्विझ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
> ### [हा धडा R मध्ये उपलब्ध आहे!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
|
|
|
### परिचय
|
|
|
|
|
|
तुम्ही आतापर्यंत रिग्रेशन म्हणजे काय हे कद्दू किमतींच्या डेटासेटवरून पाहिले आहे ज्याचा उपयोग संपूर्ण धड्यात होणार आहे. तुम्ही ते मॅटप्लॉटलिब वापरून दृष्यरूपात देखील पाहिले आहे.
|
|
|
|
|
|
आता तुम्ही ML साठी रिग्रेशनमध्ये खोलवर जाण्यास तयार आहात. चित्ररूपण तुम्हाला डेटाचे अर्थ लावण्यास मदत करते, परंतु मशीन लर्निंगची खरी सामर्थ्य म्हणजे _मॉडेल प्रशिक्षित करणे_. मॉडेल्स ऐतिहासिक डेटावर प्रशिक्षित केले जातात जेणेकरून डेटा संबंधितता आपोआप पकडता येते, आणि ते नवीन डेटासाठी पूर्वनिर्धारित परिणाम भाकित करू शकतात, ज्याचा मॉडेलने परवानगी घेतलेली माहिती नाही.
|
|
|
|
|
|
या धड्यात, तुम्ही दोन प्रकारच्या रिग्रेशनबद्दल अधिक जाणून घेणार आहात: _मूलभूत रेखीय रिग्रेशन_ आणि _बहुपद रिग्रेशन_, तसेच या तंत्रज्ञानामागील काही गणित. हे मॉडेल्स आम्हाला विविध इनपुट डेटानुसार कद्दूच्या किंमती भाकित करण्याची परवानगी देतील.
|
|
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
|
|
|
|
|
|
> 🎥 वरील चित्रावर क्लिक करा रेखीय रिग्रेशनच्या थोडक्यात व्हिडिओसाठी.
|
|
|
|
|
|
> या अभ्यासक्रमादरम्यान, आम्ही गणिताची कमीतकमी माहिती धरतो आणि इतर क्षेत्रांतील विद्यार्थ्यांसाठी हा विषय सुलभ करण्याचा प्रयत्न करतो, त्यामुळे समज वाढविण्यासाठी टीपा, 🧮 गणितीय कॉलआउट्स, आकृत्या आणि इतर अध्ययन साधने पाहा.
|
|
|
|
|
|
### पूर्वतयारी
|
|
|
|
|
|
आता तुम्हाला कद्दू डेटाच्या रचनेची ओळख झाली पाहिजे ज्याचे आपण अभ्यास करीत आहोत. ती या धड्याच्या _notebook.ipynb_ फाइलमध्ये आधीच लोड केलेली आणि स्वच्छ केलेली आहे. त्या फाईलमध्ये कद्दूची किंमत बसलावर एक नवीन डेटाफ्रेममध्ये दाखवली गेली आहे. ही नोटबुक विज्युअल स्टुडिओ कोडमध्ये कर्नल्समध्ये चालवता यावी याची खात्री करा.
|
|
|
|
|
|
### तयारी
|
|
|
|
|
|
स्मरणपत्र म्हणून, तुम्ही हा डेटा हे प्रश्न विचारण्यासाठी लोड करत आहात.
|
|
|
|
|
|
- कधी कद्दू विकत घेण्याची उत्तम वेळ आहे?
|
|
|
- एका केज लहान कद्दूचा कसा अंदाजित किंमत येईल?
|
|
|
- मला हाफ-बुशेल बास्केट्समध्ये खरेदी करायला हवे की 1 1/9 बुशेल बॉक्समध्ये?
|
|
|
चला या डेटामध्ये अधिक खोलवर जाऊया.
|
|
|
|
|
|
मागच्या धड्यात तुम्ही पँडास डेटा फ्रेम तयार केला आणि मूळ डेटासेटचा एक भाग भरा, किंमती बुशेल प्रमाणे प्रमाणित केल्या. पण त्यामुळे तुम्हाला अंदाजे 400 डेटापॉईंट्स, केवळ शरद ऋतू महिन्यांसाठी मिळाले.
|
|
|
|
|
|
या धड्याच्या संबंधित नोटबुकमध्ये आधीच लोड केलेला डेटा पहा. डेटा आधीच लोड केलेला आहे आणि सुरुवातीचा स्कॅटरप्लॉट महिन्यांचे डेटा दाखवतो. कदाचित आपण डेटाची स्वच्छता करून अधिक सखोल माहिती मिळवू शकतो.
|
|
|
|
|
|
## रेखीय रिग्रेशन रेषा
|
|
|
|
|
|
धडा 1 मध्ये आपण शिकल्याप्रमाणे, रेखीय रिग्रेशनचा उद्देश असा आहे की:
|
|
|
|
|
|
- **चलांचे संबंध दाखवा**. चलांमधील संबंध दाखवा.
|
|
|
- **भाकित करा**. या रेषेच्या अनुरूप नवीन डेटापॉईंट कुठे येईल ते अचूक भाकित करा.
|
|
|
|
|
|
**लिस्ट-स्क्वेअर रिग्रेशन** मध्ये अशा प्रकारची रेषा काढणे सामान्य आहे. "लिस्ट-स्क्वेअर" म्हणजे आपल्या मॉडेलचा एकूण त्रुटी कमी करण्याचा प्रक्रियेला म्हणतात. प्रत्येक datapoint साठी आपण त्याच्या प्रत्यक्ष बिंदू आणि रिग्रेशन रेषा यामधील उभ्या अंतराचा (called residuals) मोजमाप करतो.
|
|
|
|
|
|
या अंतरांचे वर्ग काढण्याची दोन मुख्य कारणे आहेत:
|
|
|
|
|
|
1. **परिमाणावर भर, दिशा नोंदपण ठेवण्यास नकार:** -5 या त्रुटीस +5 सारखेच मानायचे आहे. वर्ग काढल्याने सर्व मूल्ये धनात्मक होतात.
|
|
|
|
|
|
2. **आउटलायर्सना जबरदस्त गणना:** वर्गाने मोठ्या त्रुटींना अधिक वजन दिले जाते, जेणेकरून रेषा दूरच्या बिंदूंच्या जवळ राहते.
|
|
|
|
|
|
नंतर आपण सर्व वर्गबद्ध मूल्ये जमा करतो. आपला उद्देश असा रेषा शोधणे आहे जिथे ही अंतिम बेरीज कमी होईल (सर्वांत लहान मूल्य)—त्यामुळे हे नाव "लिस्ट-स्क्वेअर" आहे.
|
|
|
|
|
|
> **🧮 मला गणित दाखवा**
|
|
|
>
|
|
|
> या रेषेला _हे सबसे योग्य रेषा_ म्हणतात, जे [एका समीकरणाने](https://en.wikipedia.org/wiki/Simple_linear_regression) दर्शविले जाते:
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` हा 'स्पष्टीकरणात्मक चल' आहे. `Y` हा 'आश्रित चल' आहे. रेषेचा उतार `b` आहे आणि `a` हा y-अवरोधक आहे, जो `X = 0` असताना `Y` ची किंमत दर्शवितो.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> प्रथम, उतार `b` काढा. इन्फोग्राफिक द्वारे [जेन लूपर](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> दुसऱ्या शब्दांत, आपल्या कद्दू डेटाच्या मूळ प्रश्नासंबंधात: "महिन्यानुसार कद्दूच्या किंमतीची भाकीत करा", `X` ची किंमत असेल आणि `Y` विक्रीचा महिना असेल.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> `Y` ची किंमत काढा. जर तुम्ही सुमारे $4 देत असाल, तर नक्की एप्रिल असावा! इन्फोग्राफिक द्वारे [जेन लूपर](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) भेट देऊन संख्या कशी रेषेवर परिणाम करतात ते बघा.
|
|
|
|
|
|
## सहसंबंध
|
|
|
|
|
|
अजून एक शब्द समजून घेणे आवश्यक आहे: दिलेल्या `X` आणि `Y` चलांमधील **सहसंबंध गुणांक**. स्कॅटरप्लॉट वापरून तुम्ही जलदपणे हा गुणांक पाहू शकता. जर डेटा बिंदू एका नीटसर रेषेत विखुरलेले असतील तर उच्च सहसंबंध असतो, परंतु जर डेटा बिंदू सर्वत्र विखुरलेले असतील तर सहसंबंध कमी असतो.
|
|
|
|
|
|
योग्य रिग्रेशन मॉडेल असेल ज्याचा सहसंबंध गुणांक (0 पेक्षा जवळजवळ 1) लिस्ट-स्क्वेअर रिग्रेशन पद्धतीने रेषा सह असतो.
|
|
|
|
|
|
✅ या धड्याशी संबंधित नोटबुक चालवा आणि महिन्यांवरून किमतींचा स्कॅटरप्लॉट पहा. कद्दू विक्रीसाठी महिना व किमतींचा संबंध तुमच्या दृश्य समजुतीनुसार उच्च किंवा कमी सहसंबंध दर्शवितो का? जर तुम्ही `Month` ऐवजी *वर्षातील दिवस* (उदा. वर्षाच्या सुरुवातीपासून किती दिवस झाले) वापरला तर सहसंबंध बदलतो का?
|
|
|
|
|
|
खालील कोडमध्ये, समजा आपण डेटा स्वच्छ केला आहे, आणणि `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` मध्ये उपलब्ध आहे. आपण मागील धड्यासारखेच स्वच्छ करण्याचे चरण पार पाडले आहेत आणि खालील अभिव्यक्तीने `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/mr/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
हे सूचित करते की किमान काही सहसंबंध असावा, आणि आपण रेखीय रिग्रेशनच्या मदतीने `Month` व `Price` किंवा `DayOfYear` व `Price` मध्ये संबंध भाकित करण्याचा प्रयत्न करू शकतो. खालील स्कॅटरप्लॉट `DayOfYear` व `Price` मधील संबंध दाखवते:
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/mr/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
|
|
|
|
|
|
`corr` फंक्शन वापरून बघूया:
|
|
|
|
|
|
```python
|
|
|
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
|
|
|
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
|
|
|
```
|
|
|
|
|
|
सहसंबंध 0 पेक्षा कमी आणि फार लहान वाटत आहे, `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/mr/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/mr/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
सध्या फक्त एका कद्दू प्रकारावर, 'पाय टाईप', लक्ष केंद्रित करूया, आणि पाहूया की विक्री तारखेचा किम्मतीवर काय परिणाम आहे:
|
|
|
|
|
|
```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/mr/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 array मध्ये विभागतो:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> लक्षात घ्या की इनपुट डेटावर आम्हाला `reshape` करावे लागले कारण Linear Regression पॅकेजला ते योग्यरित्या समजावे लागते. Linear Regression ला 2D-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)
|
|
|
```
|
|
|
|
|
|
शेवटी, Lineal Regression मॉडेलचे प्रशिक्षण फक्त दोन ओळींमध्ये होते. आम्ही `LinearRegression` ऑब्जेक्ट तयार करतो, आणि `fit` पद्धतीने आमच्या डेटावर ते बसवतो:
|
|
|
|
|
|
```python
|
|
|
lin_reg = LinearRegression()
|
|
|
lin_reg.fit(X_train,y_train)
|
|
|
```
|
|
|
|
|
|
`LinearRegression` ऑब्जेक्ट `fit` केल्यानंतर सर्व रेग्रेशनचे गुणांक समाविष्ट करतो, जे `.coef_` प्रॉपर्टीने प्रवेश केले जाऊ शकतात. आपल्या बाबतीत, फक्त एकच गुणांक आहे, जो सुमारे `-0.017` असावा. याचा अर्थ किंमती काळाप्रमाणे थोड्या प्रमाणात कमी होतात, पण फार नाही, दररोज सुमारे 2 सेंट. आपण `lin_reg.intercept_` वापरून रेग्रेशनचा Y-अक्षाशी छेदन बिंदू देखील प्राप्त करू शकतो - आपल्या बाबतीत हा सुमारे `21` असेल, जो वर्षाच्या सुरुवातीच्या किमतीचा दर्शवितो.
|
|
|
|
|
|
आपल्या मॉडेलची अचूकता पाहण्यासाठी, आपण चाचणी डेटासेटवरील किंमतींची भाकित करू शकतो, आणि नंतर आपल्या भाकिते अपेक्षित किमतींपेक्षा किती जवळ आहेत हे मोजू शकतो. हे सर्व अपेक्षित आणि भाकित मूल्ये यांच्यातील चौकटांत फरकांचे सरासरी (MSE) मेट्रिक वापरून करू शकतो.
|
|
|
|
|
|
```python
|
|
|
pred = lin_reg.predict(X_test)
|
|
|
|
|
|
mse = np.sqrt(mean_squared_error(y_test,pred))
|
|
|
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
|
|
|
```
|
|
|
|
|
|
आपला त्रुटी सुमारे 2 पॉइंट्स असून सुमारे ~17% आहे. फार चांगले नाही. मॉडेल क्वालिटीचा आणखी एक निर्देशांक म्हणजे **निर्धारण गुणांक**, जो अशी प्राप्त केला जाऊ शकतो:
|
|
|
|
|
|
```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/mr/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## बहुपदी रेग्रेशन
|
|
|
|
|
|
रेषीय रेग्रेशनचा दुसरा प्रकार आहे बहुपदी रेग्रेशन. कधी कधी व्हेरीएबल्समध्ये रेषीय संबंध असतो - जितका भोपळा खंडफळाने मोठा तितकी किंमत जास्त - पण कधी कधी हे संबंध समतल किंवा सरळ रेषा म्हणून दर्शवू शकत नाहीत.
|
|
|
|
|
|
✅ येथे [अधिक काही उदाहरणे](https://online.stat.psu.edu/stat501/lesson/9/9.8) आहेत ज्यासाठी बहुपदी रेग्रेशन वापरले जाऊ शकते
|
|
|
|
|
|
दिनांक आणि किंमत यांच्यातील संबंध पुन्हा एकदा पाहा. हा स्कॅटरप्लॉट आवश्यकतेनुसार नेहमी सरळ रेषेत विश्लेषित व्हायला हवा का? किंमती कधी बदलत नाहीत का? अशा केसमध्ये आपण बहुपदी रेग्रेशन वापरून पाहू शकतो.
|
|
|
|
|
|
✅ बहुपदी गणितीय अभिव्यक्ती आहेत ज्यात एक किंवा अधिक चल आणि गुणांक असू शकतात
|
|
|
|
|
|
बहुपदी रेग्रेशन वक्र रेषा तयार करते ज्यामुळे नॉन-रेषीय डेटा चांगल्या प्रकारे फिट होतो. आपल्या बाबतीत, जर आपण `DayOfYear` चा वर्गमूल इनपुटमध्ये समाविष्ट केला तर आपला डेटा एक पराबॉलिक वक्राद्वारे फिट करू शकतो, ज्याची किमान किंमत वर्षातील एका विशिष्ट बिंदूवर असेल.
|
|
|
|
|
|
स्किट-लर्नमध्ये डेटा प्रोसेसिंगच्या विविध टप्प्यांना एकत्रित करण्यासाठी उपयुक्त [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) आहे. एक **pipeline** म्हणजे **estimators** ची साखळी आहे. आपल्या बाबतीत, आपण असा pipeline तयार करू जे प्रथम polynomial features जोडेल आणि नंतर रेग्रेशन ट्रेन करेल:
|
|
|
|
|
|
```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)` वापरून म्हणजे इनपुट डेटामधून सर्व दुसऱ्या क्रमांकाचे बहुपदी जोडले जातील. आपल्या बाबतीत याचा अर्थ फक्त `DayOfYear`<sup>2</sup> असेल, पण दोन इनपुट व्हेरीएबल्स X आणि Y असल्यास, हे X<sup>2</sup>, XY आणि Y<sup>2</sup> जोडेल. आपण इच्छित असल्यास अधिक उच्च क्रमांकाचे बहुपदी देखील वापरू शकतो.
|
|
|
|
|
|
Pipelines मूळ `LinearRegression` ऑब्जेक्टसारखे वापरू शकतो, म्हणजे आपण pipeline ला `fit` करू शकतो आणि नंतर `predict` वापरून भाकित प्राप्त करू शकतो. खाली ग्राफमध्ये चाचणी डेटा आणि अंदाजे वक्र दाखवला आहे:
|
|
|
|
|
|
<img alt="Polynomial regression" src="../../../../translated_images/mr/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
बहुपदी रेग्रेशन वापरून आपल्याला थोडा कमी MSE आणि अधिक निर्धारण गुणांक मिळू शकतो, पण फारसे नाही. आपल्याला इतर वैशिष्ट्ये देखील विचारात घ्यावी लागतील!
|
|
|
|
|
|
> आपण पाहू शकता की किमान भोपळ्याच्या किंमती हॅलोवीनच्या सुमारास दिसतात. तुम्ही हे कसे समजावून सांगू शकता?
|
|
|
|
|
|
🎃 अभिनंदन, तुम्ही अशी मॉडेल तयार केली आहे जी पाय भोपळ्याच्या किंमती भाकित करण्यात मदत करू शकते. तुम्ही हेच प्रोसिजर सर्व भोपळ्यांच्या प्रकारांसाठी पुनरावृत्ती करू शकता, पण ते फारच वेळखाऊ होईल. चला आता शिकूया की आपल्या मॉडेलमध्ये भोपळ्याचा प्रकार कसा विचारात घ्यावा!
|
|
|
|
|
|
## श्रेणीगत वैशिष्ट्ये
|
|
|
|
|
|
आदर्श जगात, आपल्याला वेगवेगळ्या भोपळा प्रकारांसाठी किंमती सारखे मॉडेल वापरून भाकित करायचे आहे. तथापि, `Variety` स्तंभ `Month` सारख्या स्तंभांपेक्षा वेगळा आहे, कारण त्यात संख्या नसलेली (गैर-सांख्यिक) मूल्ये असतात. अशा स्तंभांना **categorical** म्हणतात.
|
|
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
|
|
|
|
|
|
> 🎥 वरील प्रतिमा क्लिक करा, जेथे श्रेणीगत वैशिष्ट्य वापरण्याचे संक्षिप्त व्हिडिओ अवलोकन आहे.
|
|
|
|
|
|
येथे तुम्ही पाहू शकता की सरासरी किंमत प्रकारावर कशी अवलंबून असते:
|
|
|
|
|
|
<img alt="Average price by variety" src="../../../../translated_images/mr/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
प्रकार विचारात घेण्यासाठी, आपल्याला प्रथम त्याला संख्यात्मक स्वरूपात रूपांतरित करणे आवश्यक आहे, किंवा **encode** करणे आवश्यक आहे. आपण हे करण्याचे काही मार्ग आहेत:
|
|
|
|
|
|
* सोप्या **संख्यात्मक एनकोडिंग** मध्ये वेगवेगळ्या प्रकारांची यादी तयार केली जाते आणि नंतर त्या यादीतील क्रमांकाने प्रकाराचे नाव बदलले जाते. रेषीय रेग्रेशनसाठी हे चांगले नाही, कारण रेषीय रेग्रेशन त्या क्रमांकाचे वास्तविक अंकात्मक मूल्य घेते आणि त्याला गुणांशी जमा करते. आपल्या बाबतीत, मूल्य आणि किंमत यांच्यातील संबंध स्पष्टपणे नॉन-रेखीय आहे, जरी सूचकांची विशिष्ट क्रमशः वितरण केली द्या.
|
|
|
* **One-hot एनकोडिंग** मध्ये `Variety` कॉलम ४ वेगळ्या कॉलमने बदलले जाते, प्रत्येक प्रकारासाठी एक कॉलम. प्रत्येक कॉलममध्ये `1` असेल जर संबंधित ओळ दिलेल्या प्रकाराची असेल, नाहीतर `0`. याचा अर्थ रेषीय रेग्रेशनमध्ये पुढील चार गुणांक असतील, प्रत्येक भोपळा प्रकारासाठी, जे त्या प्रकाराच्या "सुरुवातीच्या किंमतीसाठी" जबाबदार आहेत (किंवा "अतिरिक्त किंमत" म्हणावे).
|
|
|
|
|
|
खालील कोडमध्ये आपण variety कसा one-hot encode करू शकतो हे दाखवले आहे:
|
|
|
|
|
|
```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
|
|
|
|
|
|
वन-हॉट एनकोडेड variety वापरून रेषीय रेग्रेशन ट्रेन करण्यासाठी, आपल्याला फक्त `X` आणि `y` डेटा योग्यरित्या प्रारंभ करावा लागेल:
|
|
|
|
|
|
```python
|
|
|
X = pd.get_dummies(new_pumpkins['Variety'])
|
|
|
y = new_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
उर्वरित कोड तेच आहे जे आपण वर रेषीय रेग्रेशनसाठी वापरले होते. आपण प्रयत्न केले तर पाहाल की MSE सुमारे तसंच आहे, पण निर्धारण गुणांक खूप जास्त (~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 मिळते!
|
|
|
|
|
|
## सर्व एकत्र करणे
|
|
|
|
|
|
सर्वात चांगले मॉडेल तयार करण्यासाठी, आपण वरील उदाहरणातील एकत्रित (वन-हॉट एनकोडेड श्रेणीगत + संख्यात्मक) डेटा Polynomial Regression सह वापरू शकतो. आपल्यासाठी पूर्ण कोड खाली दिला आहे:
|
|
|
|
|
|
```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` Linear | 2.77 (17.2%) | 0.07 |
|
|
|
| `DayOfYear` Polynomial | 2.73 (17.0%) | 0.08 |
|
|
|
| `Variety` Linear | 5.24 (19.7%) | 0.77 |
|
|
|
| सर्व वैशिष्ट्ये Linear | 2.84 (10.5%) | 0.94 |
|
|
|
| सर्व वैशिष्ट्ये Polynomial | 2.23 (8.25%) | 0.97 |
|
|
|
|
|
|
🏆 छान काम! तुम्ही एका धड्यात चार रेग्रेशन मॉडेल तयार केली, आणि मॉडेल क्वालिटी 97% पर्यंत सुधारली. अंतिम विभागात, आपण Logistic Regression बद्दल शिकाल ज्याद्वारे वर्ग निश्चित केले जातात.
|
|
|
|
|
|
---
|
|
|
## 🚀आव्हान
|
|
|
|
|
|
या नोटबुकमध्ये विविध व्हेरीएबल्ससह प्रयत्न करा आणि correlation आणि मॉडेल अचूकतेत कसा संबंध आहे हे तपासा.
|
|
|
|
|
|
## [धड्यांनंतरचा क्विझ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## पुनरावलोकन आणि स्वाध्याय
|
|
|
|
|
|
या धड्यात आपण Linear Regression बद्दल शिकले. इतरही महत्त्वाचे 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 --> |
