You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
374 lines
51 KiB
374 lines
51 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
|
|
"translation_date": "2025-10-11T11:44:57+00:00",
|
|
"source_file": "2-Regression/3-Linear/README.md",
|
|
"language_code": "ta"
|
|
}
|
|
-->
|
|
# 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)
|
|
### அறிமுகம்
|
|
|
|
இ bisher நீங்கள் ரிக்ரஷன் என்ன என்பதை கற்றுக்கொண்டீர்கள், மற்றும் இந்த பாடத்தில் பயன்படுத்தப்படும் கம்பளி விலை தரவுத்தொகுப்பிலிருந்து எடுத்த மாதிரி தரவுடன் அதை ஆராய்ந்தீர்கள். மேலும், அதை Matplotlib பயன்படுத்தி காட்சிப்படுத்தியுள்ளீர்கள்.
|
|
|
|
இப்போது நீங்கள் எம்.எல். ரிக்ரஷனை மேலும் ஆழமாக ஆராய தயாராக உள்ளீர்கள். காட்சிப்படுத்தல் தரவின் அர்த்தத்தை புரிந்துகொள்ள உதவுகிறது, ஆனால் இயந்திர கற்றலின் உண்மையான சக்தி _மாடல்களை பயிற்சி செய்வதில்_ உள்ளது. மாடல்கள் வரலாற்று தரவின் அடிப்படையில் பயிற்சி பெறுகின்றன, தரவின் சார்புகளை தானாகவே பிடிக்கின்றன, மேலும் மாடல் முன்பே பார்த்திராத புதிய தரவுக்கான முடிவுகளை கணிக்க அனுமதிக்கின்றன.
|
|
|
|
இந்த பாடத்தில், நீங்கள் இரண்டு வகையான ரிக்ரஷனைப் பற்றி மேலும் கற்றுக்கொள்வீர்கள்: _அடிப்படை நேரியல் ரிக்ரஷன்_ மற்றும் _பாலினோமியல் ரிக்ரஷன்_, மற்றும் இந்த நுட்பங்களின் அடிப்படையில் உள்ள சில கணிதங்களை. இந்த மாடல்கள் வெவ்வேறு உள்ளீட்டு தரவுகளின் அடிப்படையில் கம்பளி விலைகளை கணிக்க உதவும்.
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "தொடக்க நிலை எம்.எல். - நேரியல் ரிக்ரஷனைப் புரிந்துகொள்வது")
|
|
|
|
> 🎥 மேலே உள்ள படத்தை கிளிக் செய்து நேரியல் ரிக்ரஷனின் சுருக்கமான வீடியோ கண்ணோட்டத்தைப் பாருங்கள்.
|
|
|
|
> இந்த பாடத்திட்டத்தின் முழுவதும், கணிதத்தில் குறைந்த அறிவை நாம் கருதுகிறோம், மற்றும் பிற துறைகளிலிருந்து வரும் மாணவர்களுக்கு அதை அணுகக்கூடியதாக மாற்ற முயற்சிக்கிறோம். குறிப்புகள், 🧮 அழைப்புகள், வரைபடங்கள் மற்றும் புரிதலுக்கு உதவும் பிற கற்றல் கருவிகளை கவனிக்கவும்.
|
|
|
|
### முன்-தயாரிப்பு
|
|
|
|
இப்போது நீங்கள் கம்பளி தரவின் அமைப்புடன் பரிச்சயமாக இருக்க வேண்டும். இந்த பாடத்தின் _notebook.ipynb_ கோப்பில் இது முன்பே ஏற்றப்பட்டு சுத்தம் செய்யப்பட்டு கிடைக்கிறது. இந்த கோப்பில், கம்பளி விலை ஒரு புதிய தரவுப் பிரேமில் புஷெல் ஒன்றுக்கு காட்டப்படுகிறது. Visual Studio Code-இல் கர்னல்களில் இந்த நோட்புக்குகளை இயக்க முடியும் என்பதை உறுதிப்படுத்தவும்.
|
|
|
|
### தயாரிப்பு
|
|
|
|
நினைவூட்டலுக்காக, நீங்கள் இந்த தரவுகளை ஏற்றுவதன் மூலம் அதில் கேள்விகளை கேட்க முடியும்.
|
|
|
|
- கம்பளிகளை வாங்க சிறந்த நேரம் எது?
|
|
- சிறிய கம்பளிகளின் ஒரு கேஸின் விலையை நான் எதிர்பார்க்க முடியுமா?
|
|
- நான் அவற்றை அரை புஷெல் கூளங்களில் வாங்க வேண்டுமா அல்லது 1 1/9 புஷெல் பெட்டியில் வாங்க வேண்டுமா?
|
|
இந்த தரவுகளை மேலும் ஆராய்வோம்.
|
|
|
|
முந்தைய பாடத்தில், நீங்கள் ஒரு Pandas தரவுப் பிரேமை உருவாக்கி, அசல் தரவுத்தொகுப்பின் ஒரு பகுதியை அதில் நிரப்பி, புஷெல் மூலம் விலையை நிலைப்படுத்தினீர்கள். ஆனால், அதைச் செய்வதன் மூலம், நீங்கள் சுமார் 400 தரவுப் புள்ளிகளை மட்டுமே சேகரிக்க முடிந்தது, மேலும் அவை விழுந்து காலங்களில் மட்டுமே இருந்தன.
|
|
|
|
இந்த பாடத்துடன் இணைக்கப்பட்ட நோட்புக்கில் முன்பே ஏற்றப்பட்ட தரவைக் கவனிக்கவும். தரவுகள் முன்பே ஏற்றப்பட்டு, ஆரம்ப ஸ்காட்டர்ப்ளாட் மாத்திரம் வரைபடமாக்கப்பட்டுள்ளது. மாதத் தரவைக் காட்டுகிறது. தரவின் இயல்பைப் பற்றி மேலும் விவரங்களைப் பெற சுத்தம் செய்ய முயற்சிக்கலாம்.
|
|
|
|
## ஒரு நேரியல் ரிக்ரஷன் கோடு
|
|
|
|
Lesson 1-இல் நீங்கள் கற்றுக்கொண்டது போல, ஒரு நேரியல் ரிக்ரஷன் பயிற்சியின் நோக்கம் ஒரு கோட்டை வரைபடமாக்குவதில் உள்ளது:
|
|
|
|
- **மாறிலி உறவுகளை காட்டுதல்**. மாறிலிகளுக்கிடையேயான உறவுகளை காட்டுதல்
|
|
- **கணிப்புகளைச் செய்யுதல்**. புதிய தரவுப் புள்ளி அந்த கோட்டுடன் தொடர்புடைய இடத்தில் எங்கு இருக்கும் என்பதை துல்லியமாக கணிக்குதல்.
|
|
|
|
இது **குறைந்த-சதுர ரிக்ரஷன்** மூலம் இந்த வகையான கோட்டை வரைபடமாக்குவது வழக்கமாகும். 'குறைந்த-சதுரங்கள்' என்ற சொல், ரிக்ரஷன் கோட்டின் சுற்றியுள்ள அனைத்து தரவுப் புள்ளிகளும் சதுரமாக்கப்பட்டு பின்னர் சேர்க்கப்படுகின்றன என்பதை குறிக்கிறது. இறுதியில், அந்த மொத்த தொகை மிகச் சிறியதாக இருக்க வேண்டும், ஏனெனில் நாம் குறைந்த பிழைகள், அல்லது `குறைந்த-சதுரங்கள்` வேண்டும்.
|
|
|
|
நாம் தரவுப் புள்ளிகளின் மொத்த தூரம் குறைவாக இருக்க வேண்டும் என்பதற்காக இதைச் செய்கிறோம். மேலும், அதன் திசையை விட அதன் அளவைக் கவனிக்கிறோம் என்பதற்காக நிபந்தனைகளை சதுரமாக்கி பின்னர் சேர்க்கிறோம்.
|
|
|
|
> **🧮 கணிதத்தை காட்டுங்கள்**
|
|
>
|
|
> இந்த கோடு, _சிறந்த பொருத்தம் கொண்ட கோடு_ [ஒரு சமன்பாட்டால்](https://en.wikipedia.org/wiki/Simple_linear_regression) வெளிப்படுத்தப்படலாம்:
|
|
>
|
|
> ```
|
|
> Y = a + bX
|
|
> ```
|
|
>
|
|
> `X` என்பது 'விளக்க மாறிலி'. `Y` என்பது 'சார்ந்த மாறிலி'. கோட்டின் சாய்வு `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) க்கு சென்று எண்களின் மதிப்புகள் கோட்டில் எப்படி பாதிக்கின்றன என்பதைப் பாருங்கள்.
|
|
|
|
## தொடர்பு
|
|
|
|
மற்றொரு முக்கியமான சொல் **தொடர்பு குணகம்** என்பது கொடுக்கப்பட்ட X மற்றும் Y மாறிலிகளுக்கிடையே. ஒரு ஸ்காட்டர்ப்ளாட்டைப் பயன்படுத்தி, நீங்கள் இந்த குணகத்தை விரைவாக காட்சிப்படுத்தலாம். தரவுப் புள்ளிகள் ஒழுங்காக ஒரு கோட்டில் சிதறியுள்ள ஒரு வரைபடம் அதிக தொடர்பு கொண்டதாக இருக்கும், ஆனால் X மற்றும் Y இடையே தரவுப் புள்ளிகள் எங்கும் சிதறியுள்ள ஒரு வரைபடம் குறைந்த தொடர்பு கொண்டதாக இருக்கும்.
|
|
|
|
ஒரு நல்ல நேரியல் ரிக்ரஷன் மாடல், **குறைந்த-சதுர ரிக்ரஷன்** முறையைப் பயன்படுத்தி ஒரு ரிக்ரஷன் கோட்டுடன் 1 க்கு அருகிலுள்ள (0 க்கு அருகிலல்ல) தொடர்பு குணகத்தை கொண்டிருக்கும்.
|
|
|
|
✅ இந்த பாடத்துடன் இணைக்கப்பட்ட நோட்புக்கை இயக்கி, மாதத்திற்கும் விலைக்கும் இடையேயான ஸ்காட்டர்ப்ளாட்டைப் பாருங்கள். கம்பளி விற்பனைக்கு மாதத்திற்கும் விலைக்கும் இடையேயான தரவுகள், உங்கள் கண்ணோட்டத்தின் அடிப்படையில் ஸ்காட்டர்ப்ளாட்டில் அதிக அல்லது குறைந்த தொடர்பு கொண்டதாக தோன்றுகிறதா? `மாதம்` என்பதற்குப் பதிலாக *ஆண்டின் நாள்* (அதாவது ஆண்டின் தொடக்கத்திலிருந்து நாட்களின் எண்ணிக்கை) போன்ற நுண்ணறிவு அளவீட்டை நீங்கள் பயன்படுத்தினால் அது மாறுமா?
|
|
|
|
கீழே உள்ள குறியீட்டில், தரவுகளை சுத்தம் செய்துவிட்டு, `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 "தொடக்க நிலை எம்.எல். - தொடர்பு தேடுதல்: நேரியல் ரிக்ரஷனுக்கான முக்கியம்")
|
|
|
|
> 🎥 மேலே உள்ள படத்தை கிளிக் செய்து தொடர்பின் சுருக்கமான வீடியோ கண்ணோட்டத்தைப் பாருங்கள்.
|
|
|
|
முந்தைய பாடத்தில் நீங்கள் பார்த்திருப்பீர்கள், வெவ்வேறு மாதங்களுக்கான சராசரி விலை இவ்வாறு தோன்றுகிறது:
|
|
|
|
<img alt="மாதத்திற்கான சராசரி விலை" src="../../../../translated_images/barchart.a833ea9194346d769c77a3a870f7d8aee51574cd1138ca902e5500830a41cbce.ta.png" width="50%"/>
|
|
|
|
இது தொடர்பு இருக்க வேண்டும் என்று பரிந்துரைக்கிறது, மேலும் `Month` மற்றும் `Price` அல்லது `DayOfYear` மற்றும் `Price` இடையேயான உறவுகளை கணிக்க ஒரு நேரியல் ரிக்ரஷன் மாடலை பயிற்சி செய்ய முயற்சிக்கலாம். இதோ பின்வரும் உறவைக் காட்டும் ஸ்காட்டர்ப்ளாட்:
|
|
|
|
<img alt="Day of Year-க்கு எதிராக விலை ஸ்காட்டர்ப்ளாட்" src="../../../../translated_images/scatter-dayofyear.bc171c189c9fd553fe93030180b9c00ed123148a577640e4d7481c4c01811972.ta.png" 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/scatter-dayofyear-color.65790faefbb9d54fb8f6223c566c445b9fac58a1c15f41f8641c3842af9d548b.ta.png" width="50%" />
|
|
|
|
எங்கள் விசாரணை, விற்பனை தேதியை விட வகை மொத்த விலைக்கு அதிக தாக்கத்தை ஏற்படுத்துகிறது என்பதை பரிந்துரைக்கிறது. இதை ஒரு பட்டை வரைபடத்தில் காணலாம்:
|
|
|
|
```python
|
|
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
|
|
```
|
|
|
|
<img alt="வகைக்கு எதிராக விலை பட்டை வரைபடம்" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb43a9a8c69469ce2520c9524fabfa270b1b2422cc2450d6d11.ta.png" width="50%" />
|
|
|
|
இப்போது 'pie type' என்ற ஒரு கம்பளி வகையை மட்டும் கவனித்து, தேதியின் விலைக்கு என்ன தாக்கம் உள்ளது என்பதைப் பார்ப்போம்:
|
|
|
|
```python
|
|
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
|
|
pie_pumpkins.plot.scatter('DayOfYear','Price')
|
|
```
|
|
<img alt="Day of Year-க்கு எதிராக விலை ஸ்காட்டர்ப்ளாட்" src="../../../../translated_images/pie-pumpkins-scatter.d14f9804a53f927e7fe39aa072486f4ed1bdd7f31c8bb08f476855f4b02350c3.ta.png" width="50%" />
|
|
|
|
இப்போது `corr` செயல்பாட்டைப் பயன்படுத்தி `Price` மற்றும் `DayOfYear` இடையேயான தொடர்பை கணக்கிடினால், `-0.27` போன்ற ஒன்றைப் பெறுவோம் - இது ஒரு கணிப்பீட்டு மாடலை பயிற்சி செய்வது பொருத்தமாக உள்ளது என்று பொருள்.
|
|
|
|
> ஒரு நேரியல் ரிக்ரஷன் மாடலை பயிற்சி செய்வதற்கு முன், எங்கள் தரவுகள் சுத்தமாக உள்ளன என்பதை உறுதிப்படுத்துவது முக்கியம். நேரியல் ரிக்ரஷன் வெற்றிட மதிப்புகளுடன் நன்றாக வேலை செய்யாது, எனவே அனைத்து காலியான செல்களை அகற்றுவது பொருத்தமாக இருக்கும்:
|
|
|
|
```python
|
|
pie_pumpkins.dropna(inplace=True)
|
|
pie_pumpkins.info()
|
|
```
|
|
|
|
மற்றொரு அணுகுமுறை, காலியான மதிப்புகளை தொடர்புடைய பத்தியில் இருந்து சராசரி மதிப்புகளால் நிரப்புவது.
|
|
|
|
## எளிய நேரியல் ரிக்ரஷன்
|
|
|
|
[](https://youtu.be/e4c_UP2fSjg "தொடக்க நிலை எம்.எல். - Scikit-learn பயன்படுத்தி நேரியல் மற்றும் பாலினோமியல் ரிக்ரஷன்")
|
|
|
|
> 🎥 மேலே உள்ள படத்தை கிளிக் செய்து 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']
|
|
```
|
|
|
|
> கவனிக்கவும், Linear Regression தொகுப்பு அதை சரியாக புரிந்துகொள்ள `reshape` செய்ய வேண்டியிருந்தது. Linear Regression ஒரு 2D-வரிசையை உள்ளீடாக எதிர்பார்க்கிறது, அங்கு வரிசையின் ஒவ்வொரு வரிசையும் உள்ளீட்டு அம்சங்களின் ஒரு வெக்டருக்கு இணையாக இருக்கும். எங்கள் வழக்கில், ஏனெனில் எங்களுக்கு ஒரு உள்ளீடு மட்டுமே உள்ளது - N×1 வடிவத்துடன் ஒரு வரிசை தேவை, N தரவுத்தொகுப்பின் அளவு.
|
|
|
|
பின்னர், தரவுகளை பயிற்சி மற்றும் சோதனை தரவுத்தொகுப்புகளாகப் பிரிக்க வேண்டும், பயிற்சிக்குப் பிறகு எங்கள் மாடலை சரிபார்க்க முடியும்:
|
|
|
|
```python
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
```
|
|
|
|
இறுதியாக, உண்மையான நேரியல் ரிக்ரஷன் மாடலை பயிற்சி செய்வது இரண்டு வரிகளின் குறியீட்டில் மட்டுமே ஆகிறது. `LinearRegression` பொருளை வரையறுத்து, `fit` முறைமையைப் பயன்படுத்தி அதை எங்கள் தரவுகளுக்கு பொருத்துகிற
|
|
மாதிரி எவ்வளவு துல்லியமாக உள்ளது என்பதைப் பார்க்க, நாம் சோதனை தரவுத்தொகுப்பில் விலைகளை கணிக்கலாம், பின்னர் எங்கள் கணிப்புகள் எதிர்பார்க்கப்படும் மதிப்புகளுக்கு எவ்வளவு அருகில் உள்ளன என்பதை அளவிடலாம். இதைச் செய்ய **மீன் ஸ்கொயர் எரர் (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="நேரியல் ரெக்ரஷன்" src="../../../../translated_images/linear-results.f7c3552c85b0ed1ce2808276c870656733f6878c8fd37ec220812ee77686c3ef.ta.png" width="50%" />
|
|
|
|
## பாலினோமியல் ரெக்ரஷன்
|
|
|
|
நேரியல் ரெக்ரஷனின் மற்றொரு வகை பாலினோமியல் ரெக்ரஷன் ஆகும். சில நேரங்களில் மாறிகள் இடையே நேரியல் உறவு இருக்கும் - கும்மியளவு அதிகமாக இருந்தால், விலை அதிகமாக இருக்கும் - ஆனால் சில நேரங்களில் இந்த உறவுகளை ஒரு தளம் அல்லது நேர்கோட்டாக வரைந்து காட்ட முடியாது.
|
|
|
|
✅ [இங்கே](https://online.stat.psu.edu/stat501/lesson/9/9.8) பாலினோமியல் ரெக்ரஷன் பயன்படுத்தக்கூடிய தரவின் சில உதாரணங்கள் உள்ளன.
|
|
|
|
Date மற்றும் Price இடையேயான உறவை மீண்டும் பாருங்கள். இந்த சிதறல் வரைபடம் நேர்கோட்டால் பகுப்பாய்வு செய்யப்பட வேண்டும் என்று தோன்றுகிறதா? விலைகள் மாறக்கூடாது? இந்த நிலைமையில், நீங்கள் பாலினோமியல் ரெக்ரஷனை முயற்சிக்கலாம்.
|
|
|
|
✅ பாலினோமியல்கள் ஒரு அல்லது அதற்கு மேற்பட்ட மாறிகள் மற்றும் குணகங்கள் கொண்ட கணிதப் பிரகடனங்கள் ஆகும்.
|
|
|
|
பாலினோமியல் ரெக்ரஷன் நேரியல் தரவுக்கு பொருத்தமாக ஒரு வளைந்த கோட்டை உருவாக்குகிறது. எங்கள் நிலைமையில், `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** களின் சங்கிலி ஆகும். எங்கள் நிலைமையில், முதலில் பாலினோமியல் அம்சங்களை மாதிரியில் சேர்த்து, பின்னர் ரெக்ரஷனை பயிற்சி செய்யும் ஒரு 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> ஐச் சேர்க்கும். மேலும், நாம் விரும்பினால் அதிக நிலை பாலினோமியல்களையும் பயன்படுத்தலாம்.
|
|
|
|
Pipeline ஐ `LinearRegression` பொருளைப் போலவே பயன்படுத்தலாம், அதாவது, pipeline ஐ `fit` செய்து, பின்னர் `predict` ஐப் பயன்படுத்தி கணிப்பு முடிவுகளைப் பெறலாம். சோதனை தரவுகள் மற்றும் அணுகுமுறை வளைவை காட்டும் வரைபடம் இங்கே உள்ளது:
|
|
|
|
<img alt="பாலினோமியல் ரெக்ரஷன்" src="../../../../translated_images/poly-results.ee587348f0f1f60bd16c471321b0b2f2457d0eaa99d99ec0ced4affc900fa96c.ta.png" width="50%" />
|
|
|
|
பாலினோமியல் ரெக்ரஷனைப் பயன்படுத்தி, நாம் சற்று குறைந்த MSE மற்றும் அதிக தீர்மானத்தைப் பெற முடியும், ஆனால் குறிப்பிடத்தக்க அளவில் அல்ல. மற்ற அம்சங்களைப் பின்பற்ற வேண்டும்!
|
|
|
|
> நீங்கள் பார்க்கலாம், கும்மி விலைகள் குறைந்தபட்சமாக ஹாலோவீன் அருகே காணப்படுகின்றன. இதை நீங்கள் எப்படி விளக்குவீர்கள்?
|
|
|
|
🎃 வாழ்த்துகள், நீங்கள் பை கும்மிகளின் விலையை கணிக்க உதவும் ஒரு மாதிரியை உருவாக்கியுள்ளீர்கள். நீங்கள் இதே செயல்முறையை அனைத்து கும்மி வகைகளுக்கும் மீண்டும் செய்யலாம், ஆனால் அது சிரமமாக இருக்கும். இப்போது, எங்கள் மாதிரியில் கும்மி வகையை கணக்கில் எடுப்பது எப்படி என்பதைப் பார்ப்போம்!
|
|
|
|
## வகை அம்சங்கள்
|
|
|
|
சிறந்த உலகில், ஒரே மாதிரியைப் பயன்படுத்தி வெவ்வேறு கும்மி வகைகளுக்கான விலைகளை கணிக்க முடியும். ஆனால், `Variety` பத்தி `Month` போன்ற பத்திகளிலிருந்து சற்று வேறுபட்டது, ஏனெனில் இது எண்ணியல் அல்லாத மதிப்புகளை கொண்டுள்ளது. இவ்வகை பத்திகள் **categorical** என்று அழைக்கப்படுகின்றன.
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "தொடக்கநிலை ML - Categorical Feature Predictions with Linear Regression")
|
|
|
|
> 🎥 மேலே உள்ள படத்தை கிளிக் செய்து வகை அம்சங்களைப் பயன்படுத்துவதற்கான சுருக்கமான வீடியோவைப் பாருங்கள்.
|
|
|
|
இங்கே நீங்கள் வகை அடிப்படையில் சராசரி விலை எப்படி மாறுகிறது என்பதைப் பார்க்கலாம்:
|
|
|
|
<img alt="வகை அடிப்படையில் சராசரி விலை" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb43a9a8c69469ce2520c9524fabfa270b1b2422cc2450d6d11.ta.png" width="50%" />
|
|
|
|
வகையை கணக்கில் எடுக்க, முதலில் அதை எண்ணியல் வடிவத்திற்கு மாற்ற வேண்டும், அல்லது **encode** செய்ய வேண்டும். இதைச் செய்ய பல வழிகள் உள்ளன:
|
|
|
|
* எளிய **numeric encoding** ஒரு வகை பட்டியலை உருவாக்கி, பின்னர் வகை பெயரை அந்த பட்டியலில் உள்ள ஒரு குறியீட்டால் மாற்றும். இது நேரியல் ரெக்ரஷனுக்கு சிறந்த யோசனை அல்ல, ஏனெனில் நேரியல் ரெக்ரஷன் குறியீட்டின் உண்மையான எண்ணியல் மதிப்பை எடுத்துக் கொண்டு, அதை ஒரு குணகத்தால் பெருக்கி முடிவில் சேர்க்கும். எங்கள் நிலைமையில், குறியீட்டு எண் மற்றும் விலை இடையேயான உறவு தெளிவாகவே நேரியல் அல்ல, எங்கள் குறியீடுகள் ஒரு குறிப்பிட்ட முறையில் வரிசைப்படுத்தப்பட்டாலும் கூட.
|
|
* **One-hot encoding** `Variety` பத்தியை 4 வெவ்வேறு பத்திகளால் மாற்றும், ஒவ்வொரு வகைக்கும் ஒரு பத்தி. ஒவ்வொரு பத்தியும், அந்த வரிசை ஒரு குறிப்பிட்ட வகையைச் சேர்ந்தது என்றால் `1` ஐ கொண்டிருக்கும், இல்லையெனில் `0` ஐ கொண்டிருக்கும். இது, கும்மி வகைக்கு ஒவ்வொன்றுக்கும், அந்த குறிப்பிட்ட வகைக்கு "தொடக்க விலை" (அல்லது "கூடுதல் விலை")க்கு பொறுப்பான, நேரியல் ரெக்ரஷனில் நான்கு குணகங்களை உருவாக்கும்.
|
|
|
|
வகையை 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
|
|
|
|
One-hot encode செய்யப்பட்ட வகையை உள்ளீடாகக் கொண்டு நேரியல் ரெக்ரஷனைப் பயிற்சி செய்ய, `X` மற்றும் `y` தரவுகளை சரியாக initialize செய்ய வேண்டும்:
|
|
|
|
```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 ஐ வழங்குகிறது!
|
|
|
|
## அனைத்தையும் ஒன்றாக இணைத்தல்
|
|
|
|
சிறந்த மாதிரியை உருவாக்க, மேலே உள்ள உதாரணத்திலிருந்து (one-hot encode செய்யப்பட்ட வகை + எண்ணியல்) தரவுகளை Polynomial Regression உடன் இணைத்து பயன்படுத்தலாம். உங்கள் வசதிக்காக முழு கோடு இங்கே உள்ளது:
|
|
|
|
```python
|
|
# set up training data
|
|
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']
|
|
|
|
# make train-test split
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
|
|
# setup and train the pipeline
|
|
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
|
|
pipeline.fit(X_train,y_train)
|
|
|
|
# predict results for test data
|
|
pred = pipeline.predict(X_test)
|
|
|
|
# calculate MSE and determination
|
|
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)
|
|
```
|
|
|
|
இது எங்களுக்கு MSE=2.23 (~8% prediction error) மற்றும் தீர்மானக் குணகம் 97% அளவுக்கு தர வேண்டும்.
|
|
|
|
| மாதிரி | 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 |
|
|
| All features Linear | 2.84 (10.5%) | 0.94 |
|
|
| All features Polynomial | 2.23 (8.25%) | 0.97 |
|
|
|
|
🏆 வாழ்த்துகள்! நீங்கள் ஒரு பாடத்தில் நான்கு ரெக்ரஷன் மாதிரிகளை உருவாக்கி, மாதிரி தரத்தை 97% வரை மேம்படுத்தியுள்ளீர்கள். ரெக்ரஷன் பற்றிய இறுதி பகுதியில், வகைகளைத் தீர்மானிக்க **Logistic Regression** பற்றி நீங்கள் கற்றுக்கொள்வீர்கள்.
|
|
|
|
---
|
|
## 🚀சவால்
|
|
|
|
இந்த நோட்புக்கில் பல்வேறு மாறிகளைச் சோதித்து, தொடர்பு மாதிரி துல்லியத்துடன் எப்படி பொருந்துகிறது என்பதைப் பாருங்கள்.
|
|
|
|
## [பாடத்திற்குப் பிந்தைய வினாடி வினா](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](https://github.com/Azure/co-op-translator) என்ற AI மொழிபெயர்ப்பு சேவையை பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்திற்காக முயற்சிக்கிறோம், ஆனால் தானியங்கி மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறுகள் இருக்கக்கூடும் என்பதை கவனத்தில் கொள்ளவும். அதன் சொந்த மொழியில் உள்ள மூல ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்களுக்கும் அல்லது தவறான விளக்கங்களுக்கும் நாங்கள் பொறுப்பல்ல. |