|
|
<!--
|
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
|
{
|
|
|
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
|
|
|
"translation_date": "2025-12-19T13:48:41+00:00",
|
|
|
"source_file": "2-Regression/3-Linear/README.md",
|
|
|
"language_code": "ml"
|
|
|
}
|
|
|
-->
|
|
|
# Scikit-learn ഉപയോഗിച്ച് ഒരു റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: റെഗ്രഷൻ നാല് രീതികൾ
|
|
|
|
|
|
|
|
|
> ഇൻഫോഗ്രാഫിക് [ദസാനി മടിപള്ളി](https://twitter.com/dasani_decoded) tarafından
|
|
|
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
> ### [ഈ പാഠം R-ൽ ലഭ്യമാണ്!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
|
|
|
### പരിചയം
|
|
|
|
|
|
ഇതുവരെ നിങ്ങൾ റെഗ്രഷൻ എന്താണെന്ന് പംപ്കിൻ വില നിർണ്ണയ ഡാറ്റാസെറ്റിൽ നിന്നുള്ള സാമ്പിൾ ഡാറ്റ ഉപയോഗിച്ച് പരിശോധിച്ചിട്ടുണ്ട്, ഇത് ഈ പാഠത്തിൽ മുഴുവൻ ഉപയോഗിക്കും. നിങ്ങൾ Matplotlib ഉപയോഗിച്ച് അതിനെ ദൃശ്യവൽക്കരിക്കുകയും ചെയ്തു.
|
|
|
|
|
|
ഇപ്പോൾ നിങ്ങൾ ML-നുള്ള റെഗ്രഷനിൽ കൂടുതൽ ആഴത്തിൽ പ്രവേശിക്കാൻ തയ്യാറാണ്. ദൃശ്യവൽക്കരണം ഡാറ്റയെ മനസ്സിലാക്കാൻ സഹായിക്കുന്നതിനാൽ, യഥാർത്ഥ മെഷീൻ ലേണിങ്ങിന്റെ ശക്തി _മോഡലുകൾ പരിശീലിപ്പിക്കുന്നതിൽ_ ആണ്. മോഡലുകൾ ചരിത്ര ഡാറ്റയിൽ പരിശീലിപ്പിച്ച് ഡാറ്റ ആശ്രിതത്വങ്ങൾ സ്വയം പിടിച്ചെടുക്കുന്നു, കൂടാതെ മോഡൽ മുമ്പ് കാണാത്ത പുതിയ ഡാറ്റയ്ക്ക് ഫലം പ്രവചിക്കാൻ അനുവദിക്കുന്നു.
|
|
|
|
|
|
ഈ പാഠത്തിൽ, നിങ്ങൾ രണ്ട് തരത്തിലുള്ള റെഗ്രഷനുകൾക്കുറിച്ച് കൂടുതൽ പഠിക്കും: _അടിസ്ഥാന ലീനിയർ റെഗ്രഷൻ_യും _പോളിനോമിയൽ റെഗ്രഷൻ_യും, കൂടാതെ ഈ സാങ്കേതികവിദ്യകളുടെ പിന്നിലെ ചില ഗണിതശാസ്ത്രവും. ആ മോഡലുകൾ വിവിധ ഇൻപുട്ട് ഡാറ്റയുടെ അടിസ്ഥാനത്തിൽ പംപ്കിൻ വില പ്രവചിക്കാൻ സഹായിക്കും.
|
|
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
|
|
|
|
|
|
> 🎥 ലീനിയർ റെഗ്രഷന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
|
|
|
|
|
|
> ഈ പാഠ്യപദ്ധതിയിൽ, ഗണിതത്തിൽ കുറഞ്ഞ പരിജ്ഞാനം ഉള്ളവർക്കും മറ്റ് മേഖലകളിൽ നിന്നുള്ള വിദ്യാർത്ഥികൾക്കും ഇത് സുലഭമാക്കാൻ ശ്രമിക്കുന്നു, അതിനാൽ കുറിപ്പുകൾ, 🧮 വിളിപ്പുകൾ, ചിത്രങ്ങൾ, മറ്റ് പഠന ഉപകരണങ്ങൾ ശ്രദ്ധിക്കുക.
|
|
|
|
|
|
### മുൻപരിചയം
|
|
|
|
|
|
നിങ്ങൾ ഇപ്പോൾ പരിശോധിക്കുന്ന പംപ്കിൻ ഡാറ്റയുടെ ഘടനയിൽ പരിചിതനാകണം. ഈ പാഠത്തിലെ _notebook.ipynb_ ഫയലിൽ ഇത് മുൻകൂട്ടി ലോഡ് ചെയ്ത് ശുദ്ധീകരിച്ചിരിക്കുന്നു. ഫയലിൽ, പംപ്കിൻ വില ബുഷെൽപ്രതി പുതിയ ഡാറ്റാ ഫ്രെയിമിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു. Visual Studio Code-ൽ കർണലുകളിൽ ഈ നോട്ട്ബുക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.
|
|
|
|
|
|
### തയ്യാറെടുപ്പ്
|
|
|
|
|
|
ഓർമ്മപ്പെടുത്തലായി, നിങ്ങൾ ഈ ഡാറ്റ ലോഡ് ചെയ്യുന്നത് അതിൽ നിന്ന് ചോദ്യങ്ങൾ ചോദിക്കാൻ ആണ്.
|
|
|
|
|
|
- പംപ്കിനുകൾ വാങ്ങാൻ ഏറ്റവും നല്ല സമയം എപ്പോൾ?
|
|
|
- ഒരു കേസ് മിനിയേച്ചർ പംപ്കിനുകളുടെ വില എത്ര പ്രതീക്ഷിക്കാം?
|
|
|
- അവയെ അർദ്ധ ബുഷെൽ ബാസ്കറ്റുകളിൽ വാങ്ങണോ, 1 1/9 ബുഷെൽ ബോക്സിൽ വാങ്ങണോ?
|
|
|
നാം ഈ ഡാറ്റയിൽ കൂടുതൽ തിരയാം.
|
|
|
|
|
|
മുൻ പാഠത്തിൽ, നിങ്ങൾ ഒരു Pandas ഡാറ്റാ ഫ്രെയിം സൃഷ്ടിച്ച് അതിൽ യഥാർത്ഥ ഡാറ്റാസെറ്റിന്റെ ഭാഗം ഉൾപ്പെടുത്തി, വില ബുഷെൽപ്രതി സ്റ്റാൻഡേർഡൈസ് ചെയ്തു. എന്നാൽ, അങ്ങനെ ചെയ്തപ്പോൾ, ഏകദേശം 400 ഡാറ്റാപോയിന്റുകൾ മാത്രമേ ലഭിച്ചുള്ളൂ, അത് പോലും പകുതിമാസങ്ങളിൽ മാത്രം.
|
|
|
|
|
|
ഈ പാഠത്തിലെ അനുബന്ധ നോട്ട്ബുക്കിൽ മുൻകൂട്ടി ലോഡ് ചെയ്ത ഡാറ്റ നോക്കുക. ഡാറ്റ മുൻകൂട്ടി ലോഡ് ചെയ്തിട്ടുണ്ട്, ഒരു പ്രാഥമിക സ്കാറ്റർപ്ലോട്ട് മാസത്തെ ഡാറ്റ കാണിക്കാൻ വരച്ചിട്ടുണ്ട്. ഡാറ്റയുടെ സ്വഭാവത്തെ കുറിച്ച് കൂടുതൽ വിശദാംശങ്ങൾ ലഭിക്കാൻ കൂടുതൽ ശുദ്ധീകരണം നടത്താമോ എന്ന് നോക്കാം.
|
|
|
|
|
|
## ഒരു ലീനിയർ റെഗ്രഷൻ രേഖ
|
|
|
|
|
|
പാഠം 1-ൽ നിങ്ങൾ പഠിച്ച പോലെ, ഒരു ലീനിയർ റെഗ്രഷൻ അഭ്യാസത്തിന്റെ ലക്ഷ്യം ഒരു രേഖ വരയ്ക്കാനാകണം:
|
|
|
|
|
|
- **വേരിയബിൾ ബന്ധങ്ങൾ കാണിക്കുക**. വേരിയബിൾകളുടെ ബന്ധം കാണിക്കുക
|
|
|
- **പ്രവചനങ്ങൾ നടത്തുക**. ആ രേഖയുമായി ബന്ധപ്പെട്ട് പുതിയ ഡാറ്റാപോയിന്റ് എവിടെ വരും എന്ന് കൃത്യമായി പ്രവചിക്കുക.
|
|
|
|
|
|
**ലീസ്റ്റ്-സ്ക്വയർസ് റെഗ്രഷൻ** സാധാരണയായി ഇത്തരത്തിലുള്ള രേഖ വരയ്ക്കുന്നു. 'ലീസ്റ്റ്-സ്ക്വയർസ്' എന്ന പദം അർത്ഥമാക്കുന്നത്, റെഗ്രഷൻ രേഖ ചുറ്റിപ്പറ്റിയ എല്ലാ ഡാറ്റാപോയിന്റുകളും സ്ക്വയർ ചെയ്ത് കൂട്ടിച്ചേർക്കുന്നു എന്നതാണ്. ആകെ തുക όσο ചെറിയതായിരിക്കും, അത്ര നല്ലതാണ്, കാരണം ഞങ്ങൾ കുറവ് പിശകുകൾ (least-squares) ആഗ്രഹിക്കുന്നു.
|
|
|
|
|
|
ഞങ്ങൾ ഒരു രേഖ മോഡൽ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു, അത് എല്ലാ ഡാറ്റാപോയിന്റുകളുടെയും കൂറ്റൻ ദൂരം ഏറ്റവും കുറവായിരിക്കും. കൂടാതെ, ദിശയേക്കാൾ അതിന്റെ വലിപ്പം (മാഗ്നിറ്റ്യൂഡ്) പ്രധാനമാണെന്ന് കണക്കിലെടുത്ത് സ്ക്വയർ ചെയ്യുന്നു.
|
|
|
|
|
|
> **🧮 ഗണിതം കാണിക്കുക**
|
|
|
>
|
|
|
> ഈ രേഖ, _ബെസ്റ്റ് ഫിറ്റ് ലൈന_ എന്ന് വിളിക്കപ്പെടുന്നത്, [ഒരു സമവാക്യത്തിലൂടെ](https://en.wikipedia.org/wiki/Simple_linear_regression) പ്രകടിപ്പിക്കാം:
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` 'വ്യാഖ്യാന വേരിയബിൾ' ആണ്. `Y` 'അനുഭവ വേരിയബിൾ' ആണ്. രേഖയുടെ സ്ലോപ്പ് `b` ആണ്, `a` y-ഇന്റർസെപ്റ്റ് ആണ്, അതായത് `X = 0` ആയപ്പോൾ `Y` യുടെ മൂല്യം.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> ആദ്യം സ്ലോപ്പ് `b` കണക്കാക്കുക. ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
|
|
|
>
|
|
|
> മറ്റൊരു വാക്കിൽ, പംപ്കിൻ ഡാറ്റയുടെ യഥാർത്ഥ ചോദ്യത്തെ ആശ്രയിച്ച്: "മാസംപ്രതി പംപ്കിൻ വില പ്രവചിക്കുക", `X` വിലയെ സൂചിപ്പിക്കും, `Y` വിൽപ്പന മാസത്തെ സൂചിപ്പിക്കും.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> Y-യുടെ മൂല്യം കണക്കാക്കുക. നിങ്ങൾ ഏകദേശം $4 നൽകുകയാണെങ്കിൽ, അത് ഏപ്രിൽ ആയിരിക്കണം! ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
|
|
|
>
|
|
|
> രേഖയുടെ സ്ലോപ്പ് കണക്കാക്കുന്ന ഗണിതം, ഇന്റർസെപ്റ്റിനും ആശ്രയിച്ചിരിക്കുന്നു, അതായത് `X = 0` ആയപ്പോൾ `Y` എവിടെയാണ് എന്നതും.
|
|
|
>
|
|
|
> ഈ മൂല്യങ്ങൾ കണക്കാക്കുന്ന രീതി [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) വെബ്സൈറ്റിൽ കാണാം. കൂടാതെ [ഈ Least-squares കാൽക്കുലേറ്റർ](https://www.mathsisfun.com/data/least-squares-calculator.html) സന്ദർശിച്ച് സംഖ്യകളുടെ മൂല്യങ്ങൾ രേഖയെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് കാണാം.
|
|
|
|
|
|
## സഹസംബന്ധം
|
|
|
|
|
|
മറ്റൊരു പദം മനസ്സിലാക്കേണ്ടത് **സഹസംബന്ധ കോഫിഷ്യന്റ്** ആണ്, നൽകിയ X, Y വേരിയബിൾക്കിടയിലെ. സ്കാറ്റർപ്ലോട്ട് ഉപയോഗിച്ച് ഈ കോഫിഷ്യന്റ് എളുപ്പത്തിൽ ദൃശ്യവൽക്കരിക്കാം. ഡാറ്റാപോയിന്റുകൾ ഒരു സുതാര്യമായ രേഖയിൽ പടർന്നാൽ ഉയർന്ന സഹസംബന്ധം ഉണ്ട്, എന്നാൽ ഡാറ്റാപോയിന്റുകൾ 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`](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/barchart.a833ea9194346d76.ml.png" width="50%"/>
|
|
|
|
|
|
ഇത് ചില സഹസംബന്ധം ഉണ്ടാകുമെന്ന് സൂചിപ്പിക്കുന്നു, നാം ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിച്ച് `Month`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം പ്രവചിക്കാം, അല്ലെങ്കിൽ `DayOfYear`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം. താഴെ കാണുന്ന സ്കാറ്റർപ്ലോട്ട് രണ്ടാം ബന്ധം കാണിക്കുന്നു:
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/scatter-dayofyear.bc171c189c9fd553.ml.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="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/scatter-dayofyear-color.65790faefbb9d54f.ml.png" width="50%" />
|
|
|
|
|
|
നമ്മുടെ പരിശോധന പ്രകാരം, പംപ്കിൻ വർഗ്ഗം വിൽപ്പന തീയതിയേക്കാൾ വിലയിൽ കൂടുതൽ സ്വാധീനം ചെലുത്തുന്നു. ഇത് ഒരു ബാർ ഗ്രാഫിൽ കാണാം:
|
|
|
|
|
|
```python
|
|
|
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
|
|
|
```
|
|
|
|
|
|
<img alt="Bar graph of price vs variety" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb4.ml.png" 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/pie-pumpkins-scatter.d14f9804a53f927e.ml.png" 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` നിർബന്ധമായിരുന്നു. ലീനിയർ റെഗ്രഷൻ 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` മെത്തഡ് ഉപയോഗിച്ച് ഡാറ്റയിൽ ഫിറ്റ് ചെയ്യുന്നു:
|
|
|
|
|
|
```python
|
|
|
lin_reg = LinearRegression()
|
|
|
lin_reg.fit(X_train,y_train)
|
|
|
```
|
|
|
|
|
|
`fit` ചെയ്ത ശേഷം `LinearRegression` ഒബ്ജക്റ്റിൽ റെഗ്രഷന്റെ എല്ലാ കോഫിഷ്യന്റുകളും `.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% ആണ്. വളരെ നല്ലതല്ല. മോഡൽ ഗുണനിലവാരത്തിന്റെ മറ്റൊരു സൂചികയാണ് **നിർണ്ണയ ഘടകം** (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/linear-results.f7c3552c85b0ed1c.ml.png" width="50%" />
|
|
|
|
|
|
## പോളിനോമിയൽ റിഗ്രഷൻ
|
|
|
|
|
|
ലീനിയർ റിഗ്രഷന്റെ മറ്റൊരു തരം പോളിനോമിയൽ റിഗ്രഷനാണ്. ചിലപ്പോൾ വേരിയബിളുകൾക്കിടയിൽ ലീനിയർ ബന്ധമുണ്ടാകാം - വോളിയം കൂടുതലായ പംപ്കിൻ വില കൂടുതലായിരിക്കും - എന്നാൽ ചിലപ്പോൾ ഈ ബന്ധങ്ങൾ ഒരു സമതലമോ നേരിയ ലൈനോ ആയി ചിത്രീകരിക്കാൻ കഴിയില്ല.
|
|
|
|
|
|
✅ ഇവിടെ [കൂടുതൽ ഉദാഹരണങ്ങൾ](https://online.stat.psu.edu/stat501/lesson/9/9.8) ഉണ്ട്, പോളിനോമിയൽ റിഗ്രഷൻ ഉപയോഗിക്കാവുന്ന ഡാറ്റയുടെ.
|
|
|
|
|
|
തീയതി (Date)യും വിലയും (Price)യും തമ്മിലുള്ള ബന്ധം വീണ്ടും നോക്കൂ. ഈ സ്കാറ്റർപ്ലോട്ട് ഒരു നേരിയ ലൈനിലൂടെ വിശകലനം ചെയ്യേണ്ടതുണ്ടോ? വിലകൾ മാറാറില്ലേ? ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ പോളിനോമിയൽ റിഗ്രഷൻ പരീക്ഷിക്കാം.
|
|
|
|
|
|
✅ പോളിനോമിയലുകൾ ഒരു അല്ലെങ്കിൽ കൂടുതൽ വേരിയബിളുകളും കോഫിഷ്യന്റുകളും അടങ്ങിയ ഗണിതപരമായ പ്രകടനങ്ങളാണ്.
|
|
|
|
|
|
പോളിനോമിയൽ റിഗ്രഷൻ nonlinear ഡാറ്റയ്ക്ക് മികച്ച അനുയോജ്യമായ വളഞ്ഞ ലൈനുണ്ടാക്കുന്നു. നമ്മുടെ കേസിൽ, `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="Polynomial regression" src="../../../../translated_images/poly-results.ee587348f0f1f60b.ml.png" 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/price-by-variety.744a2f9925d9bcb4.ml.png" width="50%" />
|
|
|
|
|
|
വൈവിധ്യം പരിഗണിക്കാൻ, ആദ്യം അത് സംഖ്യാത്മക രൂപത്തിലേക്ക് മാറ്റണം, അല്ലെങ്കിൽ **എൻകോഡ്** ചെയ്യണം. ഇത് ചെയ്യാനുള്ള ചില മാർഗ്ഗങ്ങൾ:
|
|
|
|
|
|
* ലളിതമായ **സംഖ്യാത്മക എൻകോഡിംഗ്** വ്യത്യസ്ത വൈവിധ്യങ്ങളുടെ പട്ടിക സൃഷ്ടിച്ച്, ആ പട്ടികയിലെ ഇൻഡക്സ് ഉപയോഗിച്ച് വൈവിധ്യത്തിന്റെ പേര് മാറ്റും. ഇത് ലീനിയർ റിഗ്രഷനിൽ നല്ല ആശയമല്ല, കാരണം ലീനിയർ റിഗ്രഷൻ ഇൻഡക്സ് സംഖ്യയുടെ യഥാർത്ഥ മൂല്യം എടുത്ത് ഫലത്തിൽ കൂട്ടിച്ചേർക്കും, ചില കോഫിഷ്യന്റുകളാൽ ഗുണിച്ച്. നമ്മുടെ കേസിൽ, ഇൻഡക്സ് നമ്പറും വിലയും തമ്മിലുള്ള ബന്ധം വ്യക്തമായി nonlinear ആണ്, ഇൻഡക്സുകൾ പ്രത്യേക ക്രമത്തിൽ ക്രമീകരിച്ചാലും.
|
|
|
* **ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ്** `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` ലീനിയർ | 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 വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
