|
|
# Scikit-learn वापरून रिग्रेशन मॉडेल तयार करा: रिग्रेशन चार पद्धती
|
|
|
|
|
|
## नवशिक्यांसाठी नोट
|
|
|
|
|
|
लिनीअर रिग्रेशनचा वापर आपण जेव्हा **संख्यात्मक मूल्य** (उदाहरणार्थ, घराची किंमत, तापमान, किंवा विक्री) भाकीत करू इच्छितो तेव्हा केला जातो.
|
|
|
हे इनपुट वैशिष्ट्ये आणि आउटपुट यामधील संबंध सर्वोत्तम दर्शविणारी सरळ रेषा शोधून काम करते.
|
|
|
|
|
|
या धड्यात, आम्ही अधिक प्रगत रिग्रेशन तंत्रे शिकण्यापूर्वी संकल्पना समजून घेण्यावर लक्ष केंद्रित करू.
|
|
|
|
|
|
> इन्फोग्राफिक [दासानी मदीपाली](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_ फाईलमध्ये प्रीलोड आणि प्री-क्लीन केलेला सापडेल. फाईलमध्ये भोपळ्याची किंमत प्रत्येक बुशेलसाठी नवीन डेटा फ्रेममध्ये दाखवली आहे. हे notebook Visual Studio Code मधील कर्नलमध्ये चालवू शकता याची खात्री करा.
|
|
|
|
|
|
### तयारी
|
|
|
|
|
|
स्मरणार्थ, आपण हा डेटा लोड करता जेणेकरून त्याबाबत प्रश्न विचारता येतील.
|
|
|
|
|
|
- भोपळा खरेदीसाठी सर्वोत्तम वेळ कधी आहे?
|
|
|
- लहान भोपळ्यांच्या केसची किंमत काय अपेक्षित करू शकतो?
|
|
|
- मी त्यांना अर्धा बुशेल टोपल्या मध्ये खरेदी करावे का की 1 1/9 बुशेल बॉक्सने?
|
|
|
चला या डेटामध्ये अधिक खोलवर पाहू.
|
|
|
|
|
|
यापूर्वीच्या धड्यात आपण Pandas डेटा फ्रेम तयार केला होता आणि मूळ डेटासेटचा भाग वापरून किंमती बुशेलनुसार प्रमाणित केला. मात्र, त्यामुळे केवळ सुमारे ४०० डेटापॉइंट्स मिळाले आणि तेही फक्त शरद ऋतूतील महिनेकरिता.
|
|
|
|
|
|
या धड्याच्या संलग्न नोटबुकमध्ये प्रीलोड केलेला डेटा पहा. डेटा प्रीलोड केला आहे आणि प्रारंभिक स्कॅटरप्लॉट तयार केला आहे जे महिना डेटाचा दाखला देतो. कदाचित आपण डेटा अजून स्वच्छ करुन त्याची निसर्ग अधिक जाणून घेऊ शकू.
|
|
|
|
|
|
## एक लिनीअर रिग्रेशन रेषा
|
|
|
|
|
|
आपण धडा 1 मध्ये शिकलो तसे, लिनीअर रिग्रेशनचा उद्दिष्ट रेषा अशी काढणे आहे जी:
|
|
|
|
|
|
- **चल संबंध दाखवते**. चलांच्या संबंध दर्शविणे
|
|
|
- **भाकीत करणे**. नवीन डेटापॉइंट एखाद्या विशिष्ट ठिकाणी येईल का ते अचूक भाकीत करणे.
|
|
|
|
|
|
हे सहसा **लीस्ट-स्क्वेअर्स रिग्रेशन** वापरून केले जाते. "लीस्ट-स्क्वेअर्स" शब्द म्हणजे आपल्या मॉडेलमधील एकूण त्रुटी कमी करते असे तंत्र. प्रत्येक डेटा पॉइंटसाठी आपण खऱ्या पॉइंट आणि रिग्रेशन लाइनमधील उभी अंतर (रेजिड्युअल) मोजतो.
|
|
|
|
|
|
आपण या अंतराला दोन मुख्य कारणांसाठी वर्गाकार करतो:
|
|
|
|
|
|
1. **परिमाणाकडे अधिक महत्त्व**: -5 वजा 5 या त्रुटींना समान समजण्यासाठी वर्गाकार सर्व मूल्ये सकारात्मक करतो.
|
|
|
|
|
|
2. **आउटलायरला दंड देणे**: वर्गाकार मोठ्या त्रुटींना अधिक वजन देतो, त्यामुळे रेषा दूर असलेल्या पॉइंट्सजवळ राहायला भाग पाडतो.
|
|
|
|
|
|
आम्ही नंतर या सर्व वर्गाकार मूल्यांची बेरीज करतो. आमचा उद्देश असा आहे की ही अंतिम बेरीज कमीत कमी (सर्वात लहान शक्य मूल्य) होईल—म्हणून त्याला "लीस्ट-स्क्वेअर्स" म्हणतात.
|
|
|
|
|
|
> **🧮 मला गणित दाखवा**
|
|
|
>
|
|
|
> ही रेषा, ज्याला _सर्वोत्तम बसणारी रेषा_ म्हणतात, [एका समीकरणाने](https://en.wikipedia.org/wiki/Simple_linear_regression) व्यक्त केली जाऊ शकते:
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` हा 'स्पष्टीकरणात्मक चल' (explanatory variable) आहे. `Y` हा 'आश्रित चल' (dependent variable). रेषेचा उतार `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) या संकेतस्थळावर या मूल्यांच्या गणनेची पद्धत पाहू शकता. तसेच [Least-squares calculator](https://www.mathsisfun.com/data/least-squares-calculator.html) येथे जाऊन संख्यांचे मूल्य रेषेवर कसे परिणाम करतात ते पाहू शकता.
|
|
|
|
|
|
## सहसंबंध
|
|
|
|
|
|
आणखी एक समजण्याचे टर्म म्हणजे दिलेल्या X आणि Y चलांमधील **सहसंबंध गुणांक**. स्कॅटरप्लॉट वापरून आपण हा गुणांक पटकन देखील पाहू शकता. जर पॉइंट्स एक नीटसर रेषेत विखुरलेले असतील तर त्यात उच्च सहसंबंध आहे, परंतु सर्वत्र विखुरलेल्या पॉइंट्ससह रेषेत कमी सहसंबंध आहे.
|
|
|
|
|
|
एक चांगला लिनीअर रिग्रेशन मॉडेल तो असेल ज्यात लीस्ट-स्क्वेअर्स रिग्रेशन पद्धतीने रेषेचा सहसंबंध गुणांक जास्त (0 पेक्षा 1 च्या जवळ) असेल.
|
|
|
|
|
|
✅ या धड्याला संलग्न notebook चालवा आणि महिना ते किंमत टेबल पाहा. भोपळा विक्रीसाठी महिना ते किंमत डेटा आपल्या दृश्यात्मक मुल्यांकनानुसार उच्च की कमी सहसंबंध दाखवतो? जर आपण `महिना` ऐवजी अधिक सूक्ष्म मोजमाप वापरले, उदा. *वर्षातील दिवस* (वर्षाच्या सुरुवातीपासून वादलेले दिवस) तर ते बदलते का?
|
|
|
|
|
|
खालील कोडमध्ये, आपण गृहित धरू की आम्ही डेटा स्वच्छ केला आहे आणि `new_pumpkins` नावाचा डेटा फ्रेम तयार केला आहे, जो खालीलप्रमाणे दिसू शकतो:
|
|
|
|
|
|
ID | महिना | वर्षातील दिवस | विविधता | शहर | पाकेट | कमी किंमत | जास्त किंमत | किंमत
|
|
|
---|-------|--------------|----------|-------|---------|------------|-------------|--------
|
|
|
70 | 9 | 267 | पाई प्रकार | बाल्टिमोर | 1 1/9 बुशेल कार्टन्स | 15.0 | 15.0 | 13.636364
|
|
|
71 | 9 | 267 | पाई प्रकार | बाल्टिमोर | 1 1/9 बुशेल कार्टन्स | 18.0 | 18.0 | 16.363636
|
|
|
72 | 10 | 274 | पाई प्रकार | बाल्टिमोर | 1 1/9 बुशेल कार्टन्स | 18.0 | 18.0 | 16.363636
|
|
|
73 | 10 | 274 | पाई प्रकार | बाल्टिमोर | 1 1/9 बुशेल कार्टन्स | 17.0 | 17.0 | 15.454545
|
|
|
74 | 10 | 281 | पाई प्रकार | बाल्टिमोर | 1 1/9 बुशेल कार्टन्स | 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/mr/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
हे सूचित करते की काही सहसंबंध असावा, आणि आपण `Month` आणि `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']))
|
|
|
```
|
|
|
|
|
|
अशी दिसते की सहसंबंध फारसा मोठा नाही, `Month` साठी -0.15 आणि `DayOfYear` साठी -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 arrays मध्ये विभाजित करून सुरुवात करतो:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> लक्षात घ्या की Linear Regression पॅकेज योग्यरित्या समजावून घेण्यासाठी आम्हाला इनपुट डेटावर `reshape` करावी लागली. लिनीअर रिग्रेशन 2D-array इनपुट म्हणून अपेक्षित असतो, ज्यामध्ये प्रत्येक ओळ इनपुट वैशिष्ट्यांच्या व्हेक्टरसाठी असते. आमच्या बाबतीत, फक्त एक इनपुट असल्यामुळे, N×1 आकाराचा arrary हवा आहे, जिथे 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)
|
|
|
```
|
|
|
|
|
|
`fit` केल्यानंतरचा `LinearRegression` ऑब्जेक्टमध्ये रिग्रेशनचे सर्व गुणांक असतात, जे `.coef_` प्रॉपर्टी वापरून पाहता येतात. आपल्या प्रकरणात, फक्त एक गुणांक आहे, जो सुमारे `-0.017` असावा. याचा अर्थ किंमती वेळेनुसार थोड्या प्रमाणात कमी होतात, पण फार नाही, दररोज सुमारे 2 सेंट्स. आपण रिग्रेशनचा Y-ऍक्सिसशी छेद बिंदू `lin_reg.intercept_` वापरून पाहू शकतो - आमच्या प्रकरणात तो सुमारे `21` असेल, जे वर्षाच्या सुरुवातीच्या किंमतींना दर्शवते.
|
|
|
|
|
|
आपल्या मॉडेलची अचूकता पाहण्यासाठी, आपण टेस्ट डेटासेटवर किंमतींचा अंदाज लावू शकतो, आणि नंतर आपल्या अंदाजित किंमती अपेक्षित किंमतींशी किती जवळ आहेत हे मोजू शकतो. हे root mean square error (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/mr/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## बहुपदीय रिग्रेशन
|
|
|
|
|
|
रेषीय फलनाचा आणखी एक प्रकार म्हणजे बहुपदीय रिग्रेशन (Polynomial Regression). कधी कधी चलांच्या दरम्यान रेषीय संबंध असतो - जसे की भोपळ्याचा आयतन जितका मोठा, तितकी किंमत जास्त - पण कधी या संबंधांना प्लेन किंवा सरळ रेषेत प्रदर्शित करता येत नाही.
|
|
|
|
|
|
✅ येथे [अजून काही उदाहरणे](https://online.stat.psu.edu/stat501/lesson/9/9.8) आहेत, ज्यात बहुपदीय रिग्रेशन वापरता येऊ शकतो
|
|
|
|
|
|
“तारीख” आणि “किंमत” यांच्यामधील संबंध पुन्हा पाहा. हा scatterplot असा दिसतो का की तो नेहमीच सरळ रेषेने विश्लेषित केला पाहिजे? किंमती बदलू शकतात का? या परिस्थितीत, आपण बहुपदीय रिग्रेशन वापरू शकतो.
|
|
|
|
|
|
✅ बहुपदी हे गणितीय अभिव्यक्ती आहेत ज्यात एक किंवा अधिक चल आणि गुणांक असू शकतात
|
|
|
|
|
|
बहुपदीय रिग्रेशन गैररेषीय डेटाला चांगल्या प्रकारे बसवण्यासाठी वक्र रेषा तयार करतो. आपल्या प्रकरणात, जर आपण इनपुट डेटामध्ये ‘DayOfYear’ या चलाचा वर्ग महत्त्वाचा समाविष्ट केला, तर आपल्याला आपला डेटा पॅराबोलिक वक्रासह बसवता येईल, ज्याचा किमान बिंदू वर्षाच्या एका विशिष्ट ठिकाणी असेल.
|
|
|
|
|
|
Scikit-learn मध्ये डेटा प्रक्रिया एकत्र करण्यासाठी उपयुक्त [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) उपलब्ध आहे. **pipeline** म्हणजे **estimators** चा साखळ. आपल्या प्रकरणात, आपण एक पाइपलाइन तयार करू ज्यात आधी बहुपदीय गुणधर्म जोडले जातील आणि नंतर रिग्रेशन प्रशिक्षित केला जाईल:
|
|
|
|
|
|
```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> जोडेल. आपण हवे असल्यास उच्च दर्जाचे बहुपदी देखील वापरू शकतो.
|
|
|
|
|
|
पाइपलाइनचा वापर `LinearRegression` ऑब्जेक्टसारखा केला जाऊ शकतो, म्हणजे आपण पाइपलाइनला `fit` करू शकतो आणि नंतर `predict` वापरून अंदाज मिळवू शकतो. खाली ग्राफिक दाखविते की टेस्ट डेटा आणि सुमारे जवळचे वक्र कसे दिसते:
|
|
|
|
|
|
<img alt="Polynomial regression" src="../../../../translated_images/mr/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
बहुपदीय रिग्रेशन वापरून आपल्याला थोडे कमी MSE आणि जास्त निर्धारण मिळू शकते, पण महत्त्वपूर्ण फरक नाही. आपल्याला अन्य गुणधर्म देखील लक्षात घ्यावे लागतील!
|
|
|
|
|
|
> आपण पाहू शकता की, भोपळ्यांच्या किमती Halloween च्या सुमारास जवळजवळ किमान असतात. आपण हे कसे समजावता?
|
|
|
|
|
|
🎃 अभिनंदन, आपण असा मॉडेल बनवला आहे ज्याचा वापर पाय भोपळ्यांच्या किंमती भाकीत करण्यासाठी होऊ शकतो. आपण कदाचित सारखा प्रक्रिया सर्व भोपळ्यांच्या प्रकारांसाठी करू शकता, पण ते वेळखाऊ होईल. आता आपण आपल्या मॉडेलमध्ये भोपळ्याचा प्रकार कसा समाविष्ट करायचा ते शिकू!
|
|
|
|
|
|
## वर्गवारी गुणधर्म (Categorical Features)
|
|
|
|
|
|
आदर्श जगात आपल्याला वेगवेगळ्या भोपळ्यांच्या प्रकारांसाठी किंमती भाकीत करायच्या असतात, तोही समान मॉडेल वापरून. पण `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%" />
|
|
|
|
|
|
प्रकार विचारात घेण्यासाठी, आपल्याला प्रथम त्याला अंकात्मक स्वरूपात रूपांतरित करणे किंवा **कोडिंग** करणे आवश्यक आहे. असे करण्याचे काही मार्ग आहेत:
|
|
|
|
|
|
* सोप्या **न्यूमेरिक एनकोडिंग** मध्ये वेगवेगळ्या प्रकारांसाठी एक तक्ता तयार केला जातो, आणि नंतर त्या तक्त्यातील इंडेक्सनी नाम बदला जातो. पण रेषीय रिग्रेशनसाठी हा चांगला विचार नाही, कारण रेषीय रिग्रेशन इंडेक्समधील अंकात्मक मूल्य घेतो आणि त्याला गुणांकाने गुणून निकालात जोडतो. आमच्या प्रकरणात इंडेक्स नंबर आणि किंमतीत गैररेषीय संबंध स्पष्ट आहे, अगदी आपण इंडेक्स विशिष्ट क्रमाने ठेवला तरीही.
|
|
|
* **वन-हॉट एनकोडिंग** मध्ये `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']
|
|
|
```
|
|
|
|
|
|
उर्वरित कोड अगदी अगोदर वापरलेले रेषीय रिग्रेशनसारखेच आहे. जर आपण हे वापरले तर आपल्याला रविवारी चतुर्थांश त्रुटी सुमारे अगदी समान मिळेल, पण निर्धारण गुणांक खूप जास्त (~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` 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 बद्दल शिकाल ज्याचा उपयोग वर्ग ठरविण्यासाठी होतो.
|
|
|
|
|
|
---
|
|
|
## 🚀आव्हान
|
|
|
|
|
|
हा नोटबुक वापरून विविध चल तपासून पहा, आणि तपासा की सहसंबंध मॉडेलच्या अचूकतेशी कसा संबंधित आहे.
|
|
|
|
|
|
## [पोस्ट-लेक्चर क्विझ](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 --> |
