|
|
# 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ல் கற்றுக்கொண்டபடி, நேரியல் ரிகிரெஷனின் நோக்கம் ஒரு கோட்டை வரைபடமாக பதிவது:
|
|
|
|
|
|
- **மாறிலிகள் இடையிலான உறவை காட்டுவது**: மாறிலிகள் இடையிலான உறவை காட்ட
|
|
|
- **பயனுள்ள கணிப்புகளை செய்வது**: புதிய தரவுப் புள்ளி அந்த கோட்டுக்கு எங்கு தாக்கும் என்பதில் சரியான கணிப்புகளை செய்வது.
|
|
|
|
|
|
**குறைந்த-சதுரங்கள் ரிகிரெஷன்** (Least-Squares Regression) இந்த வித கோட்டை வரைவதில் பொதுவாகப் பயன்படுத்தப்படுகிறது. "குறைந்த-சதுரங்கள்" என்றால் மாதிரியில் மும்முரணத்தைக் குறைக்க முயற்சிப்பது. ஒவ்வொரு தரவுபுள்ளிக்கும் உண்மையான புள்ளி மற்றும் ரிகிரெஷன் கோட்டுக்கு இடையே நின்ற சரியான பார்க்கப்பட்ட தொலைவு (residual) மதிப்பை அளக்கின்றோம்.
|
|
|
|
|
|
இந்த தொலைவுகளை நாம் சதுரமாக்குகிறோம் இரண்டு முக்கிய காரணங்களுக்காக:
|
|
|
|
|
|
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` கணக்கிடவும். தகவல்நூல்: [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) மூலம் எண்கள் கோட்டுக்கு எப்படி சென்று சேர்வதைப் பார்க்கலாம்.
|
|
|
|
|
|
## தொடர்பு_coef
|
|
|
|
|
|
மற்றொரு புரிதல் முக்கியமானது என்பது கொடுக்கப்பட்ட X மற்றும் Y மாறிலிகளுக்கிடையேயான **தொடர்பு கூட்டி (Correlation Coefficient)**. ஸ்காட்டர்பிளாட்டைப் பயன்படுத்தி இம்மதிப்பை விரைவாக காணலாம். தரவுப் புள்ளிகள் நன்கு ஒரே கோட்டிலோ அண்டையில் இருந்தால் அதில் அதிக தொடர்பு இருக்கும், ஆனால் புள்ளிகள் எங்கு வேண்டுமானாலும் சாய்ந்து இருந்தால் குறைந்த தொடர்பு இருப்பதாகக் கணிக்கலாம்.
|
|
|
|
|
|
நல்ல நேரியல் ரிகிரெஷன் மாதிரி என்பது குறைந்த-சதுரங்கள் முறையைப் பயன்படுத்தி, 1க்கு அண்மையில் (0க்கு அருகில் இல்லாமல்) ஒரு அதிக தொடர்பு கூற்றைக் கொண்டதே ஆகும்.
|
|
|
|
|
|
✅ இந்த பாடத்துடனான நோட்புக் இயக்கி, மாதத்தையும் விலையையும் காட்டும் ஸ்காட்டர்பிளாட்டைப் பாருங்கள். பம்ப்கின் விற்பனைக்கான மாதத்திற்கும் விலை இடையேயான தொடர்பு அதிகமா அல்லது குறைவா தெரிகிறதா? *மாதம்* எனினும், *ஆண்டின் நாள்* போன்ற சிதறலான அளவீடைக் பயன்படுத்தினால் அது மாறுமா?
|
|
|
|
|
|
பின்வரும் குறியீட்டில், தரவு சுத்தமாக்பட்டதும் `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="மாதப்படி சராசரி விலை" src="../../../../translated_images/ta/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
இதிலிருந்து தொடர்பு இருக்க வேண்டும் என்று தோன்றுகிறது; ஆகவே `Month` மற்றும் `Price` இடையேயான அல்லது `DayOfYear` மற்றும் `Price` இடையேயான உறவை கணிக்க நேரியல் ரிகிரெஷன் மாதிரியை பயிற்றுவிக்கலாம். கீழுள்ள ஸ்காட்டர் பிளாட் அதனைக் காட்டுகிறது:
|
|
|
|
|
|
<img alt="Day of Year மற்றும் Price இடையேயான ஸ்காட்டர் பிளாட்" src="../../../../translated_images/ta/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="Day of Year மற்றும் விலை இடையேயான நிற வேறுபாடு உள்ள ஸ்காட்டர் பிளாட்" src="../../../../translated_images/ta/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
|
|
|
|
|
|
நமது ஆராய்ச்சி கொண்டு வகையானது விற்பனைக் காலத்தைவிட அதிக தாக்கம் உண்டு என தெரிகிறது. இது ஒரு பட்டி வரைபடத்தில் தெளிவாகக் காணப்படுகிறது:
|
|
|
|
|
|
```python
|
|
|
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
|
|
|
```
|
|
|
|
|
|
<img alt="விலை மற்றும் வகை இடையேயான பட்டி வரைபடம்" src="../../../../translated_images/ta/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="Day of Year மற்றும் விலை இடையேயான பை வகை பம்ப்கின் ஸ்காட்டர் பிளாட்" src="../../../../translated_images/ta/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 வரிசைகளாக பிரிக்கப்பட்டு நிர்மாணிக்கப்படுகிறன:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> புகுபதிகை: உள்ளீட்டுப் தரவுகளுக்கு `reshape` செய்ய வேண்டியதாயிருக்கிறது, ஆகையால் Linear Regression தொகுப்பிற்கு அதை சரியாக புரிந்துகொள்ளும் வகையில் செய்ய வேண்டும். Linear Regression 2D வரிசையைப் பெறும், அதில் ஒவ்வொரு வரிசையும் உள்ளீட்டு அம்சங்கள் வெக்டாரை குறிக்கும். நமது நிலை ஒரு உள்ளீடு மட்டுமே இருக்கிறதால், N×1 வடிவமைப்புடைய வரிசை தேவையானது.
|
|
|
|
|
|
பிறகு தரவை பயிற்சி மற்றும் சோதனை தொகுப்பாக பிரிக்க வேண்டும் மாதிரியை பயிற்றிய பிறகு பரிசோதிக்க:
|
|
|
|
|
|
```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` செய்த பின் அனைத்து ரெக்ரெஷன் கூற்றுக்கள் உள்ளன, அவற்றை `.coef_` சொத்தைக் கொண்டு அணுக முடியும். எங்கள் வழக்கில், ஒரு கூற்று மட்டுமே உள்ளது, அது சுமார் `-0.017` இருக்கும். இது விலை குறுகுவதாக தோன்றுகிறது, ஆனால் அதிகமாக இல்லை, தினத்திற்கு சுமார் 2 சென்ட். நாமே ரெக்ரெஷன் வரி Y-அச்சை எங்கே தாண்டுகிறது என்பதையும் `lin_reg.intercept_` மூலம் அணுகலாம் - எங்கள் வழக்கில் இது சுமார் `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/ta/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## Polynomial Regression
|
|
|
|
|
|
மற்றொரு வகை நேரியல் ரெக்ரெஷன் என்பது பல்லியோமியல் ரெக்ரெஷன். சில நேரத்தில் மாறிலிகள் இடையே நேரியல் உறவுகள் இருக்கும் - அளவில் பெரிய பப்பாளி, விலை அதிகமாகும் - ஆனால் சில நேரங்களில் இந்த உறவுகளை சமத்தளமாக அல்லது நேரடியான கோடாக படம் பிடிக்க முடியாது.
|
|
|
|
|
|
✅ இங்கு [மற்ற சில எடுத்துக்காட்டுகள்](https://online.stat.psu.edu/stat501/lesson/9/9.8) உள்ளன, இவை பல்லியோமியல் ரெக்ரெஷன் பயன்படுத்த முடியும்
|
|
|
|
|
|
தேதி மற்றும் விலை இடையேயான உறவை மீண்டும் பாருங்கள். இந்த சித்திரப்பதிவு நேரடியான கோடு கொண்டு நிரூபிக்க வேண்டியதா என தோன்றுமா? விலைகள் மாறக்கூடும். இந்த வழியில், நீங்கள் பல்லியோமியல் ரெக்ரெஷன் முயற்சி செய்யலாம்.
|
|
|
|
|
|
✅ பல்லியோமிகள் என்பது ஒன்று அல்லது அதற்கு மேற்பட்ட மாறிகள் மற்றும் கூற்றுக்களைக் கொண்ட கணிதமான வெளிப்பாடுகள் ஆகும்
|
|
|
|
|
|
பல்லியோமியல் ரெக்ரெஷன் சாராத தரவுகளை நல்ல முறையில் பொருந்துவதற்காக வளைந்த கோட்டை உருவாக்குகிறது. எங்கள் வழக்கில், நாமே `DayOfYear` என்ற மாறியை சதுரமாகச் சேர்த்தால், ஆண்டு முழுவதும் ஒரு குறைந்த மதிப்பு கொண்ட பாரபாலிக் வளைவு தரவுக்கு பொருந்தும்.
|
|
|
|
|
|
Scikit-learn முழுமையான [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) வழங்குகிறது, இது தரவுகளை ஒருங்கிணைக்க உதவுகிறது. **pipeline** என்பது பல **உருத்திகள்** கொண்ட நிரம்பாகும். எங்கள் வழக்கில், முதலில் பல்லியோமியல் அம்சங்களை சேர்த்து, பின்னர் ரெக்ரெஷன் பயிற்சி பெறும் 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)` பயன்படுத்துதல் நம் உள்ளீடு தரவில் இருந்து இரண்டாம் நிலை பல்லியோமியல்களைச் சேர் என குறிக்கிறது. எங்கள் வழக்கில் இது `DayOfYear`<sup>2</sup> மட்டும் வேண்டியிருக்கும், ஆனால் இரண்டு மாறிகள் X மற்றும் Y இருந்தால், X<sup>2</sup>, XY மற்றும் Y<sup>2</sup> அம்சங்கள் சேர்க்கப்படும். நாம் அதிக நிலை பல்லியோமியல்களையும் பயன்படுத்தலாம்.
|
|
|
|
|
|
pipelines அசல் `LinearRegression` பொருள் போலவே பயன்படுத்தலாம், அதாவது நாமே பணியிடும் வகையில் `fit` செய்து பின்னர் `predict` பயன்படுத்த முடியும. கீழே சோதனை தரவு மற்றும் அண்மிப்புக் கோட்டை காணப்படுகின்றன:
|
|
|
|
|
|
<img alt="Polynomial regression" src="../../../../translated_images/ta/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
பல்லியோமியல் ரெக்ரெஷன் பயன்படுத்தி, எங்கள் MSE சற்று குறையும் மற்றும் தீர்மானம் அதிகரிக்கும், ஆனால் மிகவும் குறிப்பிடத்தக்க மாற்றமில்லை. மற்ற அம்சங்களையும் நாம் கருத்தில் கொள்ள வேண்டும்!
|
|
|
|
|
|
> குறைந்தபட்ச பப்பாளி விலைகள் ஹாலோவீன் காலத்தில் காட்சியளிக்கப்படுகின்றன. இதை எப்படி விளக்கலாம்?
|
|
|
|
|
|
🎃 வாழ்த்துகள், நீங்கள் பை பப்பாளி விலையை கணிக்க உதவும் மாதிரியை உருவாக்கியுள்ளீர்கள். எல்லா பப்பாளி வகைகளுக்கும் அதே செயல்முறையை மீண்டும் செய்வதற்கும் முடியும், ஆனால் அது கடினம் தான். இப்போது பப்பாளி வகைகளை எங்கள் மாதிரியில் எவ்வாறு சேர்க்குவது என்பதை கற்கலாம்!
|
|
|
|
|
|
## வழக்குக் குறிப்புகள்
|
|
|
|
|
|
சரியான உலகில், ஒரே மாதிரியைப் பயன்படுத்தி பல பப்பாளி வகைகளின் விலைகளை கணிக்க விரும்புகிறோம். ஆனால், `Variety` என்ற நெடுவரிசை, `Month` போன்ற நெடுவரிசைகளுக்கு மாறாக, எண்கள் இல்லாத மதிப்புகளை கொண்டுள்ளது. இவ்வாறான நெடுவரிசைகள் **வகைப்படுத்தப்பட்ட** என்று கூறப்படுகின்றன.
|
|
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
|
|
|
|
|
|
> 🎥 மேலே உள்ள படத்தில் வகைப்படுத்தப்பட்ட அம்சங்களை பயன்படுத்தும் குறுகிய வீடியோ தொகுப்பு உள்ளது.
|
|
|
|
|
|
இங்கே வகைப்படுத்தப்பட்ட விலை எவ்வாறு இருக்கிறது என்று பார்க்கலாம்:
|
|
|
|
|
|
<img alt="Average price by variety" src="../../../../translated_images/ta/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
வகைப்படுத்தத்தை கருத்தில் கொள்ளும் முன்பு, முதலில் அதனை எண்களாக மாற்ற வேண்டும் அல்லது **என்கோடு** செய்ய வேண்டும். இதற்கான பல வழிகள் உள்ளன:
|
|
|
|
|
|
* எளிய **எண்கோடிங்** என்பது வகைகளின் பட்டியலை உருவாக்கி அதில் இருந்து பெயர் பதிலாக பட்டியலில் இருக்குமிட குறியீட்டை பயன்படுத்துவது. இது நேரியல் ரெக்ரெஷனுக்கு சிறந்தது அல்ல, ஏனெனில் நேரியல் ரெக்ரெஷன் அந்த எண் மதிப்பைக் கொண்டு தீர்வை கூற்றுக்குறிப்பாக்கும். எங்கள் வழக்கில், இந்த எண்ணைக் குறியீட்டும் விலையும் நேரியல் அல்ல என்று தெளிவாக உண்டு.
|
|
|
* **ஒன்-ஹாட் என்கோடிங்** என்பது `Variety` நெடுவரிசை 4 வேறு நெடுவரிசைகளாக மாற்றப்படும், ஒவ்வொரு வகைக்குமான ஒன்று. ஒவ்வொரு நெடுவரிசையும் அந்த வரி அந்த வகைக்குள் இருந்தால் `1`இல், இல்லையெனில் `0`இல் இருக்கும். இது நமது நேரியல் ரெக்ரெஷனில் 4 கூற்றுக்களை உருவாக்கும், ஒவ்வொரு வகைக்கும் தனித்தனியான ஆரம்ப விலை (அல்லது கூடுதல் விலை) உடையதாக இருக்கும்.
|
|
|
|
|
|
கீழிற்க்காணும் குறியீடு வகையை ஒன்-ஹாட் என்கோட் செய்வதை காட்டுகிறது:
|
|
|
|
|
|
```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
|
|
|
|
|
|
ஒன்-ஹாட் இந்த வகையை உள்ளீடாகக் கொண்டு நேரியல் ரெக்ரெஷன் பயிற்சி பெறும் விதம்:
|
|
|
|
|
|
```python
|
|
|
X = pd.get_dummies(new_pumpkins['Variety'])
|
|
|
y = new_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
மீதமுள்ள குறியீடு மேலே நாம் பயன்படுத்திய `LinearRegression` பயிற்சிக்கான அதே மாதிரி. முயற்சித்தால், சராசரி சதுர தவறு அதே மாதிரியாகும், ஆனால் தீர்மானக் கூற்றின் மதிப்பு மிகவும் அதிகமாக (~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% ஆக மேம்பட்டது. கடைசி பகுதியில், வகைகளை வகைப்படுத்த பயன்படுத்தப்படும் லாஜிஸ்டிக் ரெக்ரெஷன் பற்றி கற்பீர்கள்.
|
|
|
|
|
|
---
|
|
|
## 🚀சவால்
|
|
|
|
|
|
இந்த நோட்புக்கில் பல்வேறு மாறிலிகளை சோதிக்க, ஒற்றுமை எவ்வாறு மாதிரி துல்லியத்துடன் பொருந்துகிறது என்பதைப் பாருங்கள்.
|
|
|
|
|
|
## [பாடத்திற்கு பின் கேள்விக்குப்பத்திரிக்கை](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## மீளாய்வு & சுயகல்வி
|
|
|
|
|
|
இந்த பாடத்தில் நாம் நேரியல் ரெக்ரெஷன் கற்றோம். இன்னும் முக்கியமான ரெக்ரெஷன் வகைகள் உண்டு. 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 மொழி மொழிபெயர்ப்பு சேவை [கோ-ஒப் மொழிபெயர்ப்பு](https://github.com/Azure/co-op-translator) பயன்படுத்தி மொழிபெயர்த்துள்ளது. நாங்கள் துல்லியத்தை உறுதிப்படுத்த முயற்சித்தாலும், தானாகத் தயாரிக்கப்படும் மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறுகள் இருக்க வாய்ப்பு இருக்கலாம். ஒவ்வொரு காலத்திய மொழியில் உள்ள அசல் ஆவணம் அதிகாரப்பூர்வ மூலமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பை பரிந்துரைக்கிறோம். இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதனால் ஏற்படும் தவறான புரிதல்கள் அல்லது தவறான விளக்கங்களுக்கு நாங்கள் பொறுப்புப்படுத்தப்படமாட்டோம்.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
