|
|
# 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 ഉപയോഗിച്ച് അത് ദൃശ്യീകരിക്കുകയും ചെയ്തിട്ടുണ്ട്.
|
|
|
|
|
|
ഇപ്പോൾ നിങ്ങൾ ML ൽ റെഗ്രഷനിൽ കൂടുതൽ ആഴമേറ്റാൻ തയ്യാറാണ്. ദൃശ്യീകരണം ഡാറ്റ പരിഗണിക്കാൻ സഹായിക്കുന്നുവെങ്കിലും, യാഥാർത്ഥ്യത്തിൽ യന്ത്രം പഠനത്തിന്റെ ശക്തി _മോഡലുകൾ പരിശീലിപ്പിക്കുന്നതിൽ_ നിന്നാണ്. മോഡലുകൾ ചരിത്ര ഡാറ്റയിൽ പരിശീലിപ്പിക്കപ്പെടുന്നു, ഡാറ്റാ ആശ്രിതത്വങ്ങൾ സ്വയം പടിയെടുക്കാൻ സഹായിക്കുന്നു, പുതിയ ഡാറ്റയ്ക്ക് ഫലങ്ങൾ മുൻകൂട്ടി പ്രവചിക്കാൻ കഴിയും, മോഡൽ മുമ്പ് കണ്ടിട്ടില്ലാത്തത് ആയിരിക്കാം.
|
|
|
|
|
|
ഈ പാഠത്തിൽ, നിങ്ങൾക്ക് രണ്ട് തരത്തിലുള്ള റെഗ്രഷനുകൾ കൂടുതൽ അറിയാം: _അടിസ്ഥാന ലീനിയർ റെഗ്രഷൻ_ এবং _Polynomial റെഗ്രഷൻ_, കൂടാതെ ഈ സാങ്കേതികവിദ്യകൾക്ക് അടിസ്ഥാനമായ ചില ഗണിതത്തെയും. ഈ മോഡലുകൾ നമ്മെ പമ്പ്കിൻ വിലകൾ വ്യത്യസ്ത ഇൻപുട്ട് ഡാറ്റ അനുസരിച്ച് പ്രവചിക്കാൻ അനുവദിക്കും.
|
|
|
|
|
|
[](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
|
|
|
|
|
|
> 🎥 ലീനിയർ റെഗ്രഷന്റെ സംക്ഷിപ്ത വീഡിയോവിവരത്തിന് മുകളിൽ കാണുന്ന ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
|
|
|
|
|
|
> ഈ കോഴ്സിൽ, ഗണിത ശാസ്ത്രം കുറഞ്ഞ പരിജ്ഞാനത്തോടെ വിദ്യാർത്ഥികൾക്ക് ലഭ്യമാക്കാനാണ് ശ്രമം, അതിനാൽ കുറിപ്പുകൾ, 🧮 കാൾഔട്ടുകൾ, ചിത്രരേഖകൾ, മറ്റും മനസ്സിലാക്കാൻ സഹായിക്കുന്ന ഉപകരണങ്ങൾ ശ്രദ്ധിക്കുക.
|
|
|
|
|
|
### മുൻഅടിസ്ഥാനങ്ങൾ
|
|
|
|
|
|
ഇപ്പോൾ വരെ നമുക്ക് പരിശോദിക്കുന്ന പമ്പ്കിൻ ഡാറ്റയുടെ ഘടനയെക്കുറിച്ച് പരിചിതരായിരിക്കണം. ഈ പാഠത്തിലെ _notebook.ipynb_ ഫയലിൽ ഇത് മുൻകൂട്ടി ലോഡ് ചെയ്ത് മുൻകൂട്ടി ശുദ്ധീകരിച്ചിട്ടുണ്ടു്. ഫയലിൽ, പമ്പ്കിൻ വില പുതിയ ഡാറ്റാ ഫ്രെയിമിൽ കേസ് വിലയായി കാണിക്കുന്നു. Visual Studio Code ൽ കണൽ ഉപയോഗിച്ച് ഈ നോട്ട് ബുക് ഓടിക്കാൻ കഴിവുണ്ടെന്ന് ഉറപ്പാക്കുക.
|
|
|
|
|
|
### ഒരുക്കം
|
|
|
|
|
|
ഓർമ്മപ്പെടുത്തലായി, ഈ ഡാറ്റ നിങ്ങളുടെ ചോദ്യങ്ങൾക്കായി ലോഡ് ചെയ്യുകയാണ്.
|
|
|
|
|
|
- പമ്പ്കിനുകൾ വാങ്ങാൻ ഏറ്റവും നല്ല സമയംഎന്താണ്?
|
|
|
- ഒരു ചെറിയ പമ്പ്കിൻ കേസിന് എത്ര വില പ്രതീക്ഷിക്കാം?
|
|
|
- പമ്പ്കിനുകൾ അർദ്ധ-ബഷൽ വാലറ്റിലോ അല്ലെങ്കിൽ 1 1/9 ബഷൽ ബോക്സിലോ വാങ്ങണോ?
|
|
|
|
|
|
ഈ ഡാറ്റയിൽ കൂടുതൽ ആഴത്തിൽ നോക്കാം.
|
|
|
|
|
|
മുമ്പത്തെ പാഠത്തിൽ നിങ്ങൾ പാണ്ടാസ് ഡാറ്റാ ഫ്രെയിം സൃഷ്ടിച്ച് അതിൽ മുഖ്യ ഡാറ്റാസെറ്റിന്റെ ഒരു ഭാഗം നൽകിയിരുന്നു, ബഷൽ അടിസ്ഥാനത്തിൽ വിലകൾ സാധാരണവത്കരിച്ചിരുന്നതായിരിന്നു്. എന്നാൽ അങ്ങനെ ചേർത്താൽ, ഏകദേശം 400 ഡാറ്റാപോയിന്റുകൾ മാത്രവും വീതം വീതമോഴി മാസങ്ങളോടെ മാത്രമായതായി കിട്ടി.
|
|
|
|
|
|
ഈ പാഠത്തിലെ സഹായി നോട്ട് ബുക്കിൽ മുൻകൂട്ടി ലോഡ് ചെയ്ത ഡാറ്റ നോക്കുക. ഡാറ്റ മുൻകൂട്ടി ലോഡ് ചെയ്തിട്ടുണ്ട്, തുടക്കം മാസത്തിലെ ഡാറ്റ കാണിക്കാൻ പ്രാഥമിക സ്കാറ്റർപ്ലോട്ട് വരച്ചിട്ടുണ്ട്. ഡാറ്റ കൂടുതൽ നന്നായി വ്യക്തമാക്കാൻ കൂടുതൽ ശുചീകരണം ചെയ്യാമോ എന്ന് നോക്കാം.
|
|
|
|
|
|
## ലീനിയർ റെഗ്രഷൻ രേഖ
|
|
|
|
|
|
പാഠം 1-ൽ നിങ്ങൾ പഠിച്ചതുപോലെ, ലീനിയർ റെഗ്രഷൻ അഭ്യാസത്തിന്റെ ലക്ഷ്യം ഒരു രേഖ വരയ്ക്കുകയാണ്:
|
|
|
|
|
|
- **മാറ്റികളുടെയും ബന്ധം കാണിക്കുക**. മാറ്റികളുടെ ബന്ധം കാണിക്കുക
|
|
|
- **പ്രവചനങ്ങൾ നടത്തുക**. ഒരു പുതിയ ഡാറ്റാപോയിന്റ് ആ രേഖയോട് എവിടെയായിരിക്കും എന്ന് കൃത്യമായി പ്രവചിക്കുക.
|
|
|
|
|
|
**ലീസ്റ്റ്-സ്ക്വയർസ് റെഗ്രഷൻ** ഉപയോഗിച്ച് ഇത്തരം രേഖ വരയ്ക്കുന്നത് സാധാരണമാണ്. "ലീസ്റ്റ്-സ്ക്വയർസ്" എന്നത് മോഡലിന്റെ മൊത്തം പിശകുകൾ കുറഞ്ഞുവരുത്താനുള്ള പ്രക്രിയ അർത്ഥമാക്കുന്നു. ഓരോ ഡാറ്റാപോയിന്റിന്റെയും യഥാർത്ഥ പോയിന്റും ഞങ്ങളുടെ റെഗ്രഷൻ രേഖയും തമ്മിലുള്ള ലംബനില വ്യത്യാസം (റസിഡ്വൽ എന്നറിയപ്പെടുന്നത്) നമുക്ക് അളക്കണം.
|
|
|
|
|
|
ഈ വ്യത്യാസങ്ങൾ സ്ക്വയർ ചെയ്യുന്നതിന് രണ്ട് പ്രധാന കാരണങ്ങളുണ്ട്:
|
|
|
|
|
|
1. **ദിശയിലേക്കു പോലും പ്രാധാന്യമില്ലാതെ വിസ്തൃതി**: -5 എന്ന പിശകും +5 എന്ന പിശകും ഒരുപോലെ കൈകാര്യം ചെയ്യാൻ. സ്ക്വയറിങ്ങ് എല്ലാ മൂല്യങ്ങളും പോസിറ്റീവായി മാറ്റുന്നു.
|
|
|
|
|
|
2. **ഓട്ട്ലയറുകളെ ശിക്ഷിക്കുക**: സ്ക്വയറിങ്ങ് വലിയ പിശകുകൾക്ക് കൂടുതലായ ഭാരമുള്ളതാക്കും, ഇത് രേഖയെ തോറും അകലെ ഉള്ള പോയിന്റുകളിലേക്കു നിന്നു് അടുത്ത് ഇരുപ്പാക്കും.
|
|
|
|
|
|
അങ്ങനെ, ഈ സ്ക്വയർ ചെയ്ത മൂല്യങ്ങൾ എല്ലാം കൂട്ടിച്ചേർക്കുന്നു. ഈ സംഖ്യ കുറഞ്ഞതായ രേഖ കണ്ടെത്തുക നമ്മുടെ ലക്ഷ്യം ആണ് (പരമാവധി കുറഞ്ഞ മൂല്യം) — അതുകൊണ്ട് പേര് "ലീസ്റ്റ്-സ്ക്വയർസ്" ആണ്.
|
|
|
|
|
|
> **🧮 കണക്കു കാണിക്കൂ**
|
|
|
>
|
|
|
> ഈ രേഖ, _സൗഹൃദ രേഖ_ എന്ന് വിളിയ്ക്കുന്ന രേഖ, [ഒരു സമവാക്യത്തിലൂടെ](https://en.wikipedia.org/wiki/Simple_linear_regression) അവതരിപ്പിക്കാം:
|
|
|
>
|
|
|
> ```
|
|
|
> Y = a + bX
|
|
|
> ```
|
|
|
>
|
|
|
> `X` 'വിവരണ മാറ്റി' ആണ്. `Y` 'പരിണാമ മാറ്റി' ആണ്. രേഖയുടെ സ്ലോപ്പ് `b` ആണ്, `a` യോ Y-അന്ത്യയിടപ്പ് ആണ്, അത് `X = 0` ആയപ്പോൾ Y യുടെ മൂല്യം സൂചിപ്പിക്കുന്നു.
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> ആദ്യം, സ്ലോപ്പ് `b` കണക്കാക്കുക. ഇന്ഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, നമ്മുടെ പമ്പ്കിനുകൾ ഡാറ്റയേക്കുറിച്ചുള്ള പ്രാഥമിക ചോദ്യത്തോട് ചേർത്ത്: "മാസം അനുസരിച്ച് ബഷൽ വില പ്രവചിക്കുക," `X` വില (Price) യെ സൂചിപ്പിക്കുന്നതായിരിക്കും, `Y`则销售月份（Month）。
|
|
|
>
|
|
|
>
|
|
|
>
|
|
|
> Y യുടെ മൂല്യം കണക്കാക്കുക. നിങ്ങൾ ഏകദേശം $4 ചെലവഴിക്കുന്നുവെങ്കിൽ, അത് ഏപ്രിൽ എന്നിരിക്കണം! ഇന്ഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper)
|
|
|
>
|
|
|
> രേഖയുടെ സ്ലോപ്പ്, അത് വരച്ചിരുന്നത് ഇന്നത്തെ ഒരു അന്ത്യയിൽ (intercept) ആശ്രയിച്ചിട്ടുള്ളതെന്നു് ഗണിതം കാണിക്കണം, അതായത് `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) സന്ദർശിച്ച് സംഖ്യകളുടെ മൂല്യങ്ങൾ രേഖയെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് യഥാർത്ഥത്തിൽ കാണാം.
|
|
|
|
|
|
## സഹസംബന്ധം
|
|
|
|
|
|
അറിവ് ആവശ്യമുള്ള മറ്റൊരു പദം **Correlation Coefficient** ആണ്, നൽകപ്പെട്ട `X` ഉം `Y` ഉം തമ്മിലുള്ള സഹസംബന്ധം സൂചിപ്പിക്കുന്നത്. സ്കാറ്റർപ്ലോട്ടിൽ ഇത് എളുപ്പത്തിൽ കാഴ്ചവെക്കാം. എത്രയും സമാന രേഖയിൽ മിക്ക ഡാറ്റാപോയിന്റുകളും പകലായി കാണിക്കുന്ന പ്ലോട്ട് സഹസംബന്ധം ഉയർന്നതാണെന്ന് സൂചിപ്പിക്കുന്നു. എന്നാൽ ഡാറ്റാപോയിന്റുകൾ പലയിടങ്ങളിലും പടർന്നുനിൽക്കുന്ന പ്ലോട്ട് താഴ്ന്ന സഹസംബന്ധം കാട്ടും.
|
|
|
|
|
|
നന്നായ ഒരു ലീനിയർ റെഗ്രഷൻ മോഡൽ `Least-Squares Regression` ഉപയോഗിക്കുന്നത് കൊണ്ട് രേഖയുടെ സഹായത്തോടെ ഉയർന്ന (നിങ്ങളുടെ 1-നടുത്ത് 0-നും ഇടയിൽ) Correlation Coefficient ഉള്ളത് ആകും.
|
|
|
|
|
|
✅ ഈ പാഠത്തോടൊപ്പം നൽകുന്ന നോട്ട് ബുക്ക് ഓടിച്ച് മാസവും വിലയും തമ്മിൽ ഉണ്ടാകുന്ന സ്കാറർപ്ലോട്ടുകൾ നോക്കുക. പമ്പ്കിൻ വിൽപ്പനയ്ക്ക് മാസവും വിലയുടെ ദൃശ്യമേഖലയിൽ высокого или низкого корреляции? അത് മാറ്റപ്പെടുമോ, നിങ്ങൾ കൂടുതൽ സൂക്ഷ്മമായ നിർവചനമായ *ആ വർഷത്തിലെ ദിവസം* (ആ വർഷം ആരംഭിച്ചിട്ട് എത്ര ദിവസം കഴിഞ്ഞുവോ) ഉപയോഗിച്ചാൽ?
|
|
|
|
|
|
ഇതോ, നിലവാരം ശുദ്ധീകരിച്ചും, `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/ml/barchart.a833ea9194346d76.webp" width="50%"/>
|
|
|
|
|
|
ഇതുവഴി ഒരു ചെറിയ സഹസംബന്ധം ഉണ്ടാകണമെന്നും, നാം ലീനിയർ റെഗ്രഷൻ മോഡൽ ട്രെയിന് ചെയ്ത് `Month`-ഉം `Price`-ഉം തമ്മിലുള്ള ബന്ധം പ്രവചിക്കാമെന്നും, അല്ലെങ്കിൽ `DayOfYear`-ഉം `Price`-ഉം തമ്മിലുള്ള ബന്ധം പ്രവചിക്കാമെന്നും തോന്നുന്നു. ഇത് കാണിക്കുന്ന സ്കാറ്റർപ്ലോട്ട് ഇവിടെ:
|
|
|
|
|
|
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
|
|
|
|
|
|
`corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് സഹസംബന്ധം പരിശോധിക്കാം:
|
|
|
|
|
|
```python
|
|
|
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
|
|
|
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
|
|
|
```
|
|
|
|
|
|
സഹസംബന്ധം കുറവായി തോന്നുന്നു, മാസമോട് -0.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/ml/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/ml/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/ml/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
|
|
|
|
|
|
`Price` യും `DayOfYear` യും തമ്മിലുള്ള `corr` ഉപയോഗിച്ച് സംഘം കണക്കാക്കിയാൽ, -0.27 വരും, അതായത് പ്രവചനാടിസ്ഥാനത്തിലുള്ള മോഡൽ പരിശീലിപ്പിക്കുന്നതു് യുക്തിയുള്ളതായി തോന്നുന്നു.
|
|
|
|
|
|
> ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നതിന് മുമ്പ്, ഡാറ്റ ശുദ്ധിയാക്കേണ്ടത് നിശ്ചിതമാണ്. നഷ്ടപ്പെട്ട മൂല്യങ്ങൾ ഉള്ള ഡാറ്റയുമായി ലീനിയർ റെഗ്രഷൻ നല്ല പ്രകടനം നൽകാനാകില്ല, അതിനാൽ ശൂന്യമായ എല്ലാ സെല്ലുകളും ഒഴിവാക്കുക ഇടക്കാലം നല്ലതാകും:
|
|
|
|
|
|
```python
|
|
|
pie_pumpkins.dropna(inplace=True)
|
|
|
pie_pumpkins.info()
|
|
|
```
|
|
|
|
|
|
അടുത്തൊരു മാർഗ്ഗം ശൂന്യമായ മൂല്യങ്ങൾ പ്രസക്തമായ കോളത്തിന്റെ ശരാശരി മൂല്യത്തിൽ പൂരിപ്പിക്കുന്നതാണ്.
|
|
|
|
|
|
## ലളിതമായ ലീനിയർ റെഗ്രഷൻ
|
|
|
|
|
|
[](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
|
|
|
|
|
|
> 🎥 ലീനിയർ, പൊളിനോമിയൽ റെഗ്രഷൻ സംബന്ധിച്ച ചുരുക്ക വീഡിയോക്ളിക്ക് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
|
|
|
|
|
|
നാം **Scikit-learn** ലൈബ്രറി ഉപയോഗിച്ച് ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കും.
|
|
|
|
|
|
```python
|
|
|
from sklearn.linear_model import LinearRegression
|
|
|
from sklearn.metrics import mean_squared_error
|
|
|
from sklearn.model_selection import train_test_split
|
|
|
```
|
|
|
|
|
|
ആദ്യമേ, ഇൻപുട്ട് മൂല്യങ്ങളായ ഫീച്ചറുകളും പ്രതീക്ഷിത ഔട്ട്പുട്ടായ ലേബലും വേർതിരിക്കാം numpy array ആയി:
|
|
|
|
|
|
```python
|
|
|
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
|
|
|
y = pie_pumpkins['Price']
|
|
|
```
|
|
|
|
|
|
> ലീനിയർ റെഗ്രഷനിൽ പാക്കേജ് ശരിയായി പ്രവർത്തിക്കാൻ ഇൻപുട്ട് ഡാറ്റ reshaping ചെയ്തതായാണ് ശ്രദ്ധിക്കുക. ലീനിയർ റെഗ്രഷൻ ഒരു 2D-അറേ മുഖ്യം കാണുന്നു, ഓരോ വരിയും ഫീച്ചറുകളുടെ വെക്ടർ ആണ്. ഇവിടെ മാത്രം ഒരു ഫീച്ചറുണ്ട്, അതിനാൽ N×1 ആകൃതിയിലുള്ള അറേ വേണം, ഇവിടെ N dataset വലിപ്പം.
|
|
|
|
|
|
ശേഷം, പരിശീലനത്തിനും പരിശോധനയ്ക്കുമായ ഡാറ്റ വേർതിരിക്കേണ്ടതാണ്, മോഡൽ പരിശീലിക്കുന്നതിന് ശേഷം മെച്ചം വിലയിരുത്താൻ.
|
|
|
|
|
|
```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` ആയിരിക്കും, വർഷത്തിന്റെ ആരംഭത്തിലെ വില സൂചിപ്പിക്കുന്നു.
|
|
|
|
|
|
ഞങ്ങളുടെ മോഡൽ എത്രത്തോളം കൃത്യമാണെന്ന് കാണാൻ, ടെസ്റ്റ് ഡേറ്റാസെറ്റിൽ വിലകൾ പ്രവചിച്ച്, പിന്നെ പ്രവചനങ്ങൾ പ്രതീക്ഷിച്ച മൂല്യങ്ങളോട് എത്ര അടുത്താണ് എന്ന് അളക്കാം. ഇത് തീരുവായും അനുകൂലമായ മൂല്യങ്ങളുടെയും പ്രവചന മൂല്യങ്ങളുടെയും ചതുരസമമായ വ്യത്യാസങ്ങളുടെ ശരാശരി മൂല്യത്തിന്റെ വേരായിരിക്കും (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%. വളരെച്ചങ്കമായില്ല. മോഡൽ ഗുണമേന്മയുടെ മറ്റൊരു സൂചനയാണ് **നിർണ്ണയ സഹഗം**, ഇത് ഇങ്ങനെ ലഭിക്കും:
|
|
|
|
|
|
```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/ml/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
|
|
|
|
|
|
## പോളിനോമിയൽ റഗ്രഷൻ
|
|
|
|
|
|
മറ്റൊരു തരം ലീനിയർ റഗ്രഷൻ പോളിനോമിയൽ റഗ്രഷനാണ്. ചിലപ്പോൾ വേരിയബിൾസ് തമ്മിൽ ലീനിയർ ബന്ധം ഉണ്ടായിരിക്കും - വോളിയം കൂടുതലുള്ള പംകിൻ വില ഉയർന്നിരിക്കും - എന്നാൽ ചിലപ്പോൾ ഈ ബന്ധം ഒരു സമതലോ നേരെയുള്ള വരിയോ ആയി പ്രദർശിപ്പിക്കാനാകില്ല.
|
|
|
|
|
|
✅ പോളിനോമിയൽ റഗ്രഷൻ ഉപയോഗിക്കാവുന്ന [കൂടുതൽ ഉദാഹരണങ്ങൾ](https://online.stat.psu.edu/stat501/lesson/9/9.8) ഇവയാണ്
|
|
|
|
|
|
Date ഒപ്പം Price നുള്ള ബന്ധം വീണ്ടും നോക്കാം. ഈ സ്കാറ്റർപ്ലോട്ട് ഒരിടത്തേക്ക് മാത്രം ഒതുക്കേണ്ടതുണ്ടോ? വിലകൾ മാറിയില്ലേ? ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ പോളിനോമിയൽ റഗ്രഷൻ ശ്രമിക്കാം.
|
|
|
|
|
|
✅ പോളിനോമിയലുകൾ ഒരോവയോ കൂടുതൽ വേരിയബിൾസും കോഫിഷ്യന്റ്സും അടങ്ങിയ ഗണിതീയ പ്രകടപഥങ്ങളാണ്
|
|
|
|
|
|
പോളിനോമിയൽ റഗ്രഷൻ nonlinear ഡാറ്റയ്ക്ക് മെച്ചമായ ഫിറ്റ് നൽകാൻ ഒരു വളഞ്ഞ വരി സൃഷ്ടിക്കുന്നു. നമ്മുടെ കേസിൽ, squared `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**യുടെ ശൃംഖല ആണ്. നമ്മുടെ കേസിൽ, ആദ്യം പോളിനോമിയൽ ഫീച്ചറുകൾ മodel ൽ ചേർക്കുകയും സായിപ്പും റഗ്രഷൻ പരിശീലിപ്പിക്കുകയും ചെയ്യുന്ന ഒരു പൈപ്പ്ലൈനുണ്ടാക്കും:
|
|
|
|
|
|
```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/ml/poly-results.ee587348f0f1f60b.webp" width="50%" />
|
|
|
|
|
|
പോളിനോമിയൽ റഗ്രഷൻ ഉപയോഗിച്ച് നാം കുറച്ചു കുറഞ്ഞ MSE ഉം ഉയർന്ന നിർണ്ണയവും നേടാം, പക്ഷേ വളരെ വ്യത്യാസമില്ല. മറ്റു ഫീച്ചറുകളും പരിഗണിക്കണം!
|
|
|
|
|
|
> നിങ്ങൾക്ക് കാണാം, പംകിൻ വിലകളുടെ ഏറ്റവും കുറഞ്ഞ സ്ഥിതിവിശേഷങ്ങൾ ഹാലോവีนിനടുത്താണ്. ഇതെങ്ങനെ വ്യാഖ്യാനിക്കാം?
|
|
|
|
|
|
🎃 അഭിനന്ദനങ്ങൾ, നിങ്ങൾ പൈ പംകിനുകളുടെ വില പ്രവചിക്കാൻ സഹായിക്കുന്ന ഒരു മോഡൽ സൃഷ്ടിച്ചു. നിക്ഷേപിച്ചുമാത്രം ബാക്കി പംകിൻ തരങ്ങൾക്കും ഇതുപോലെ ചെയ്യാവുന്നതാണ്, പക്ഷേ അത് ഉപയോഗിക്കാനുള്ള പ്രക്രിയ സമ്മർദ്ദകരമാണ്. ഇപ്പോൾ പഠിക്കാം പംകിൻ വകഭേദം ഞങ്ങളുടെ മോഡലിൽ എങ്ങനെ പരിഗണിക്കാം!
|
|
|
|
|
|
## വർഗ്ഗീകരണ ഫീച്ചറുകൾ
|
|
|
|
|
|
ആദർശ ലോകത്തിൽ, നാം ഒരേ മോഡൽ ഉപയോഗിച്ച് വ്യത്യസ്ത പംകിൻ വകഭേദങ്ങളുടെ വില പ്രവചിക്കാൻ ആഗ്രഹിക്കുന്നു. എന്നാൽ `Variety` കോളം `Month` പോലുള്ള കോളങ്ങളേക്കാൾ വ്യത്യസ്തമാണ്, കാരണം അതിൽ അക്കാത്മകമല്ലാത്ത മൂല്യങ്ങൾ ഉണ്ട്. ഇത്തരം കോളങ്ങൾ **categorical** എന്നു പറയുന്നു.
|
|
|
|
|
|
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
|
|
|
|
|
|
> 🎥 കോറ്ററായി വർഗ്ഗീകരണ ഫീച്ചറുകൾ ഉപയോഗിക്കുന്നതിന്റെ ചുരുക്ക വീഡിയോക്കായി ചിത്രത്തെ ക്ലിക്കുചെയ്യുക.
|
|
|
|
|
|
ഇവിടെ നിങ്ങൾക്ക് കാണാം പംകിൻ വകഭേദം അനുസരിച്ച് ശരാശരി വില:
|
|
|
|
|
|
<img alt="Average price by variety" src="../../../../translated_images/ml/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
|
|
|
|
|
|
വകഭേദം പരിഗണിക്കാൻ ആദ്യം അതിനെ അക്കാത്മക രൂപത്തിലാക്കണം, അതായത് **encode** ചെയ്യണം. ഇതിന് പല മാർഗ്ഗങ്ങളുണ്ട്:
|
|
|
|
|
|
* ലളിതമായ **നമ്പറികൽ എന്കോഡിംഗ്** വ്യത്യസ്ത വകഭേദങ്ങളുടെ പട്ടിക ഉണ്ടാക്കുകയും, ശേഷം അഡ്രസ്സിംഗ് പട്ടികയിൽ അവയുടെ നാമം സൂചിക കൊണ്ട് മാറ്റുകയും ചെയ്യുന്നു. ഇത് ലീനിയർ റഗ്രഷനിലേക്ക് മികച്ച ആശയമല്ല, കാരണം ലീനിയർ റഗ്രഷൻ സൂചികയുടെ അക്കാത്മക മൂല്യം എടുത്ത് കോഫിഷ്യന്റുമായി ഗുണിച്ച് ഫലത്തിൽ ചേർക്കുന്നു. ഞങ്ങളുടെ കേസിൽ, സൂചിക സംഖ്യയും വിലയും തമ്മിലുള്ള ബന്ധം സുതാര്യമായി 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 |
|
|
|
|
|
|
🏆 പ്രശംസകൾ! ഒരു പാഠത്തിൽ നാലു Regression മോഡലുകളും സൃഷ്ടിച്ചു, മോഡൽ ഗുണമേന്മ 97% വരെ മെച്ചപ്പെടുത്തിയിരിക്കുന്നു. അവസാന Regression ഭാഗത്ത് നിങ്ങൾക്ക് Logistic Regression ഉപയോഗിച്ച് വർഗ്ഗങ്ങൾ നിർണയിക്കുന്നതിനെ കുറിച്ച് പഠിക്കാം.
|
|
|
|
|
|
---
|
|
|
## 🚀ചിലവരികൾ
|
|
|
|
|
|
ഈ നോട്ട് ബുക്ക്-ൽ വ്യത്യസ്ത വേരിയബിൾസും പരീക്ഷിച്ച്, ടീമിനും മോഡൽ കൃത്യതയുമായി എങ്ങനെ ബന്ധമുണ്ടെന്ന് കണ്ടെത്തൂ.
|
|
|
|
|
|
## [പാഠാനന്തര പരീക്ഷ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## അവലോകനം & സ്വയം പഠനം
|
|
|
|
|
|
ഈ പാഠത്തിൽ നാം ലീനിയർ റഗ്രഷൻ പഠിച്ചു. മറ്റു പ്രധാനമായ 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 -->
|
|
|
**ഡിസ്ക്ലെയിമർ**:
|
|
|
ഈ ഡോക്യുമെന്റ് എ.ഐ. ഭാഷാന്തര സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നമുക്ക് വ്യക്തതയുടെ വേണ്ടി ശ്രമിക്കുന്നുണ്ടെങ്കിലും, സ്വയമേറ്റു ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ ഉണ്ടാകാനുള്ള സാധ്യതയുണ്ടെന്ന് ദയവായി ശ്രദ്ധിക്കുക. യഥാർത്ഥ ഭാഷയിലെ മൂല ഡോക്യുമെന്റാണ് അതിന്റെ അവകാശപ്രദമായ ഉറവിടമെന്ന് കരുതേണ്ടതാണ്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനത്തിന്റെ ശിപാർശ ചെയ്യുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതൊരു തെറ്റായ ധാരണകൾക്കും അഭ്യൂഹങ്ങൾക്കും ഞങ്ങൾ ഉത്തരവാദികളല്ല.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
