ലീനിയർ റഗ്രഷൻ ഉപയോഗിക്കുന്നത് നമ്മൾ ഒരു സംഖ്യാമാന മൂല്യം (ഉദാഹരണത്തിന്, വീട് വില, താപനില, അല്ലെങ്കിൽ വിൽപ്പന) പ്രവചിക്കണമെന്ന് ആഗ്രഹിക്കുന്നപ്പോഴാണ്.
ഇത് ഇൻപുട്ട് ഫീച്ചറുകളും ഔട്ട്പുട്ട് തമ്മിലുള്ള ബന്ധത്തെ മികച്ച വിധത്തിൽ പ്രതിനിധാനം ചെയ്യുന്ന ഒരു നേരിയ റേഖ കണ്ടെത്തി പ്രവർത്തിക്കുന്നു.
ഈ പാഠത്തിൽ, കൂടുതൽ പുരോഗമന റഗ്രഷൻ സാങ്കേതികവിദ്യകൾ ഏറെയുള്ളതിന് മുമ്പ് ആശയം മനസിലാക്കുന്നതിൽ ശ്രദ്ധ നൽകുന്നു.
ഇൻഫോഗ്രാഫിക്: ദാസാനി മാടിപള്ളി
ഇത്ര വരെ നിങ്ങൾ റഗ്രഷൻ എന്താണെന്ന് പംപ്കിൻ വില dataset ൽ നിന്നുള്ള സാമ്പിൾ ഡാറ്റ ഉപയോഗിച്ച് അന്വേഷിച്ച് കഴിഞ്ഞു. Matplotlib ഉപയോഗിച്ച് അതിനെ ദൃശ്യമാക്കിയിട്ടുണ്ട്.
ഇപ്പോഴിതുവരെ നിങ്ങൾ മെഷീൻ ലേണിംഗിനായി റഗ്രഷനിൽ കൂടുതൽ ആഴത്തിൽ പ്രവേശിക്കാനുള്ള ഒരുക്കത്തിലാണ്. ദൃശ്യമാക്കൽ ഡാറ്റ മനസ്സിലാക്കാനുള്ള ഒരു മാർഗമാണ്, പക്ഷേ യഥാർത്ഥ മെഷീൻ ലേണിംഗ് ശക്തി മോഡലുകൾ പരിശീലിപ്പിക്കുന്നതിൽ ആണ്. മോഡലുകൾ പഴയ ഡാറ്റയിൽ പരിശീലിപ്പിച്ച് സ്വയം ഡാറ്റയുടെ ആശ്രിതത്വങ്ങൾ സുഖാത്മകമായി പിടിച്ച് പൂട്ടുന്നു, പുതിയ ഡാറ്റയ്ക്ക് ഫലങ്ങൾ പ്രവചിക്കാൻ അനുമതിയുണ്ട്, മോഡൽ മുമ്പ് കണ്ടിട്ടില്ലാത്തതുകൊണ്ട്.
ഈ പാഠത്തിൽ, നിങ്ങൾ റഗ്രഷന്റെ രണ്ട് തരങ്ങളുടെ പറ്റി കൂടുതൽ പഠിക്കും: അടിഭാഗം ലീനിയർ റഗ്രഷൻ ഒപ്പം പോളിനോമിയൽ റഗ്രഷൻ, ഈ സാങ്കേതികവിദ്യകൾ പിന്തുണയ്ക്കുന്ന ചില ഗണിതവും. ഈ മോഡലുകൾ വഴി വ്യത്യസ്ത ഇൻപുട്ട് ഡാറ്റ അടിസ്ഥാനമാക്കി പംപ്കിൻ വിലകൾ പ്രവചിക്കാം.
🎥 ലീനിയർ റഗ്രഷന്റെ സംക്ഷിപ്ത വീഡിയോ അവലോകം കാണാൻ മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
ഈ പാഠ ക്രമത്തിൽ, ഗണിതത്തിന്റെ അടിസ്ഥാന അറിയിപ്പ് ഉപരിതല രീതിയിൽ കരുതുന്നു, മറ്റ് മേഖലയിലെ വിദ്യാർത്ഥികൾക്ക് പാഠം എളുപ്പത്തിൽ പകർന്നു നൽകാനായി കുറിപ്പുകളും, 🧮 ഗണിത ചൂണ്ടിക്കാണലുകളും, ചിത്രീകരണങ്ങളും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.
നിങ്ങൾ ഇപ്പോൾ പരിശോദിക്കുന്ന പംപ്കിൻ ഡാറ്റയുടെ ഘടനയെ പരിചിതമാണ്. ഈ പാഠത്തിന്റെ notebook.ipynb ഫയലിൽ ഇത് മുൻകൂട്ടി ലോഡ് ചെയ്തും ശുദ്ധീകരിച്ചും ലഭ്യമാണ്. ഈ ഫയലിൽ പൊതു ബുശെലിനുള്ള പംപ്കിൻ വില പുതിയ ഡാറ്റാഫ്രെയിമിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു. Visual Studio Code എന്ന കോഡിംഗ് പരിസ്ഥിതിയിൽ നിങ്ങൾക്ക് ഈ നോട്ട്ബുക്കുകൾ റൺ ചെയ്യാൻ കഴിയണമെന്ന് ഉറപ്പാക്കുക.
ഓർമപ്പെടുത്തലായി, നിങ്ങൾ ഈ ഡാറ്റ ലോഡ് ചെയ്യുന്നത് അതിൽ നിന്നുള്ള ചോദ്യങ്ങൾ ചോദിക്കാൻ ആണ്.
- പംപ്കിനുകൾ വാങ്ങാൻ ഏറ്റവും അനുയോജ്യമായ സമയമ是哪ა?
- മിനിയേച്ചർ പംപ്കിനുകളുടെ ഒരു കേസ് വേണ്ടി എത്ര വില പ്രതീക്ഷിക്കാമെന്നു?
- അതെ, അവ പകുതി-ബുശെൽ ബാസ್ಕೆറ്റുകളിൽ വാങ്ങണോ എനിക്ക്, 1 1/9 ബുശെൽ ബോക്സിൽ വാങ്ങണോ?
നാം ഈ ഡാറ്റയിൽ കൂടുതൽ അവലോകനം തുടരാം.
മുമ്പത്തെ പാഠത്തിൽ, നിങ്ങൾ Pandas ഡാറ്റാഫ്രെയിം സൃഷ്ടിച്ച് ഭാഗികം യഥാർത്ഥ dataset യിൽ നിന്നുള്ള ഡാറ്റ ഉപയോഗിച്ച് പുഴക്കമില്ലാതെ വില ബുശെൽ അനുപാതത്തിൽ സ്റ്റാന്ററ്ഡൈസ് ചെയ്തു. അതിലൂടെ, ഏകദേശം 400 ഡാറ്റാപോയിന്റുകൾ മാത്രം ശേഖരിക്കാനായി സാധ്യമായി, തേനി മാസങ്ങൾക്കായി മാത്രം.
ഈ പാഠത്തിനുള്ളൊപ്പം നൽകിയ നോട്ട്ബുക്കിൽ മുൻകൂട്ടി ലോഡ് ചെയ്ത ഡാറ്റയും, പ്രതിമാസം ചിത്രീകരിക്കുന്ന സ്കാറ്റർ പ്ലോട്ടും കാണുക. കൂടുതൽ വിശദാംശങ്ങൾ ലഭിക്കാനായി ഡാറ്റ കൂടുതൽ ശുദ്ധീകരിച്ച് പരിശോധിക്കാം.
Lesson 1ൽ പഠിച്ചത് പോലെ, ലീനിയർ റഗ്രഷൻ ജനറായി പ്ലോട്ട് ചെയ്യാൻ ഒരു ലൈനാണ് തയ്യാർ ചെയ്യുക:
- വലിയ നിരീക്ഷണങ്ങൾ കാണിക്കുക. മാറ്റ চলനങ്ങളുടേയും അന്തസുടേയും ബന്ധം വ്യക്തമാക്കുക
- പ്രവചനങ്ങൾ നടത്തുക. ആ ലൈനോട് ബന്ധം പുലർത്തുന്ന സ്ഥിതിയിൽ പുതിയ ഡേറ്റാ പോയിന്റ് എവിടെയുണ്ടാകുമെന്ന് ശരിയായി പ്രവചിക്കുക
Least-Squares Regression പ്രകാരമാണ് ഇത്തരം ലൈനുകൾ വരയ്ക്കുന്നത് സാധാരണ. "Least-Squares" എന്ന പദം മോഡലിലെ മൊത്തം പിശകുകൾ കുറഞ്ഞതാക്കുന്നതിനുള്ള പ്രക്രിയയെ സൂചിപ്പിക്കുന്നു. ഓരോ ഡാറ്റാ പോയിൻറിനും, യഥാർത്ഥ പോയിന്റും റഗ്രഷൻ ലൈനും തമ്മിലുള്ളൻ നിലത്തുള്ള ദൂരം (residual) അളക്കുന്നു.
ഈ ദൂരങ്ങൾ സ്ക്വയർ ചെയ്യുന്ന രണ്ട് പ്രധാന കാരണങ്ങൾ:
-
ദിശക്ക് മുകളിലായിരുത്തുക: -5 പിശകും +5 പിശകും സമാനമായി പരിഗണിക്കണമെന്ന് ആഗ്രഹിക്കുന്നു. സ്ക്വയർ ചെയ്താൽ എല്ലാ മൂല്യങ്ങളും പോസിറ്റീവായി മാറുന്നു.
-
അപവാദങ്ങളോട് കരുതലോടെ ഉണ്ടായിരിക്കുക: വലിയ പിശകുകൾക്ക് കൂടുതൽ ഭാരമാണ് സ്ക്വയർ ചെയ്തപ്പോൾ ലഭിക്കുക, അതിനാൽ അകലെയുള്ള പോയിന്റുകളെ líne അടുത്തുനിർത്താൻ ഉദ്ദേശിക്കുന്നു.
അങ്ങനെ ഈ സ്ക്വയർ ചെയ്ത മൂല്യങ്ങളെല്ലാം കൂടി കൂട്ടുന്നു. ഏറ്റവും കുറഞ്ഞ മൊത്തം പൂജ്യം നൽകുന്ന പ്രത്യേക ലൈനാണ് കണ്ടെത്തുന്നത്, അതുകൊണ്ടുതന്നെ "Least-Squares" എന്ന് പേര്.
🧮 ഗണിതം കാണിക്കൂ
ഈ ലൈനിനെ ഉത്തമമായ അനുയോജ്യമായ ലൈന എന്ന് കൂടി പറയുന്നു, ഇതിനെ സൂത്രവാക്യം വഴി പ്രകടിപ്പിക്കാം:
Y = a + bX
Xഎന്നത് 'വ്യാഖ്യാനചിഹ്നം' (explanatory variable) ആണ്.Yഎന്നത് 'ആശ്രിത ചര' (dependent variable) ആണ്. ലൈന്റെ സ്ലോപ്പ്bആണ്,aഎന്നത് y-ഇന്റർസെപ്റ്റ് ആണ്, അതായത്X = 0ആയപ്പോൾYയുടെ മൂല്യം.
ആദ്യം സ്ലോപ്പ്
bകണക്കാക്കുക. ഇൻഫോഗ്രാഫിക്: ജെൻ ലൂപ്പർമറ്റൊരു ഭാഷയിൽ പറഞ്ഞാൽ, നമ്മുടെ പംപ്കിൻ ഡാറ്റയുടെ അടിസ്ഥാന ചോദ്യത്തിന്: "മാസം അനുസരിച്ച് ബുശെലിന് പംപ്കിന്റെ വില പ്രവചിക്കുക",
Xവിലയെ സൂചിപ്പിക്കും,Yവിൽപ്പനയുള്ള മാസം.
Y വാല്യൂ കണക്കാക്കുക. നിങ്ങൾക്ക് $4 ന് ചുറ്റും നൽകുന്നുവെങ്കിൽ അത് ഏപ്രിലായിരിക്കണം! ഇൻഫോഗ്രാഫിക്: ജെൻ ലൂപ്പർ
ലൈൻ കണക്കാക്കുന്ന ഗണിതം തന്നെ സ്ലോപ്പ് മത്സ്യവും y-ഇന്റർസെപ്റ്റ് സൂചിപ്പിക്കുന്നതു്, ഇപ്പോൾ
X = 0ആണെങ്കിൽYഎവിടെയാണെന്ന്.ഈ മൂല്യങ്ങൾ കണക്കാക്കുന്ന രീതി നിങ്ങൾ Math is Fun വെബ്സൈറ്റിൽ കാണാം. കൂടാതെ Least-squares കാൽക്കുലേറ്റർ സന്ദർശിച്ച് എങ്ങനെ മൂല്യങ്ങൾ ലൈനിനെ സ്വാധീനിക്കുന്നു എന്ന് കാണാം.
ഒരു മത്സ്യ മനസ്സിലാക്കാനുള്ള മറ്റൊരു പദമാണ് Correlation Coefficient രണ്ട് 변수 X, Y നുള്ളത്.
സ്കാറ്റർപ്ലോട്ടിലൂടെ ഈ കോഫീഷ്യന്റ് ഉടനെ ദൃശ്യമായാക്കാം. ഒരു ലൈൻ പോലെ നന്നായി കൃത്യമായ പോയിന്റുകൾ ഉള്ള പ്ലോട്ട് ഉയർന്ന കോറിലേഷൻ കാണിക്കും, പക്ഷേ X, Y തമ്മിൽ പായൽപോയ എല്ലായിടത്തും പൊടിപോയ പോയിന്റുകൾ ഉള്ള പ്ലോട്ട് താഴ്ന്ന കോറിലേഷൻ കാണിക്കും.
ഒരു മികച്ച ലീനിയർ റഗ്രഷൻ മോഡൽ ഉയർന്ന (0 നുള്ളിൽ 1-ന് അടുത്തുള്ള) Correlation Coefficient ഉം ഒരേ റഗ്രഷൻ ലൈനും Least-Squares regression ഉപയോഗിച്ചുള്ളതും ആയിരിക്കും.
✅ ഈ പാഠം കൂടെ നൽകിയ നോട്ട്ബുക്ക് റൺ ചെയ്ത്, മാസംനും വിലയും ഉള്ള സ്കാറ്റർപ്ലോട്ടിനെ കാണുക. പംപ്കിൻ വിൽപ്പനയുടെ മാസം വിലക്കിടയിലുള്ള ഡാറ്റ ഉയർന്ന കോറിലേഷൻ കാണിക്കുന്നുണ്ടോ എങ്കിൽ താഴ്ന്നതാണോ എന്നറിയാമോ? ആ കോർലേഷൻ മാസം പകരം വർഷത്തിലെ ദിവസം (ആരംഭം മുതൽ ദിവസങ്ങളുടെ സംഖ്യ) ആയി finer measure ആയി എടുത്താൽ മാറ്റം ഉണ്ടാകുമോ?
താഴെയുള്ള കോഡിൽ നമുക്ക് ഡാറ്റ ശുദ്ധീകരിച്ചിരിക്കുന്നുവെന്ന് കരുതാം, ഈ പദ്സ്യൂപം ഡാറ്റാഫ്രെയിം ഞങ്ങൾ ലഭിച്ചു, 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ല് ലഭ്യമാണ്. കഴിഞ്ഞ പാഠത്തിലെ പോലെ തന്നെ ഡാറ്റ ശുദ്ധീകരണ നടപടികൾ ചെയ്തിരിക്കുന്നു, കൂടാതെ താഴെപറയുന്ന ഘടകം ഉപയോഗിച്ചുംDayOfYearകോളം കണക്കാക്കി:
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)ഇപ്പോൾ ലീനിയർ റഗ്രഷന്റെ പിന്നിലുള്ള ഗണിതം മനസ്സിലാക്കി, നാം ഒരു Regression മോഡൽ സൃഷ്ടിക്കാം, ഏത് പംപ്കിൻ പാക്കേജ് ഏറ്റവും നല്ല വില നൽകുമെന്ന് പ്രവചിക്കാൻ സഹായിക്കും. ഒരു ഉത്സവത്തിനായി പംപ്കിൻ വാങ്ങുന്നവർക്കു ഇത് അവരുടെ വാങ്ങേണ്ട പംപ്കിൻ പാക്കേജുകൾ പരമാവധി ഉപയോഗപ്പെടുത്താൻ സഹായിക്കും.
🎥 കോറിലേഷൻ പറ്റി ചെറിയ വീഡിയോ അവലോകം കാണാൻ മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
മുമ്പത്തെ പാഠത്തിൽ, വേറിട്ട മാസങ്ങളിലെ ശരാശരി വില ഇങ്ങനെ കാണിച്ചിട്ടുണ്ട്:
ഇത് ഏതാനും കോറിലേഷൻ ഉണ്ടായിരിക്കാമെന്നു സൂചിപ്പിക്കുന്നു, നാം പാഠം റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിച്ച് Month-നും Price-നും ഇടയിലുള്ള ബന്ധം പ്രവചിക്കാം, അല്ലെങ്കിൽ DayOfYear-നും Price-നും ഇടയിലുള്ള ബന്ധം. താഴെയുള്ള സ്കാറ്റർ പ്ലോട്ട് ഇരട്ട ബന്ധം കാണിക്കുന്നു:
corr ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഇതെന്ത് കോറലേഷൻ ആണെന്ന് നോക്കാം:
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))Monthൽ -0.15, DayOfMonthൽ -0.17 എന്ന് വളരെ ഇളം കോറിലേഷൻ പോലെയാണ് കാണുന്നത്, എന്നാൽ മറ്റൊരു പ്രധാന ബന്ധം ഉണ്ടായിരിക്കും എങ്കിൽ. വില വ്യത്യാസപ്പെടുന്ന പല വർണ്ണങ്ങൾ ഉള്ള പരമ്പരകളാണെന്നു കാണാം. ഈ ആശയം സ്ഥിരീകരിക്കാൻ, ഓരോ പംപ്കിൻ വർഗ്ഗത്തെയും വേറിട്ട നിറത്തിൽ ചിത്രീകരിക്കാം. ax പാരാമീറ്റർ scatter ഫംഗ്ഷനിലേക്ക് കൊടുക്കുമ്പോൾ എല്ലാ പോയിന്റുകളും ഒരേ ഗ്രാഫിൽ വരയ്ക്കാം.
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)
നമ്മുടെ പരിശോധനാ വിവരമനുസരിച്ചു, വർഗ്ഗം വിലയിൽ തികച്ചും ഫലപ്രദമാണ്, ഉയർന്ന വിലയുടെ മറ്റു വകുപ്പുകളേക്കാൾ മാസത്തിൻ്റെ സ്വാധീനം കുറവാണ് എന്ന് കാണാം. ഇത് ഒരു ബാർ ഗ്രാഫിലും വ്യക്തമാക്കാം:
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
നാം ഒരു പ്രത്യേക പംപ്കിൻ വർഗ്ഗം മാത്രമേ ഇപ്പോൾ ശ്രദ്ധിക്കൂ, 'പൈ തരം' (pie type), കാണാം ദിവസത്തിന്റെ വിലയിൽ എന്ത് സ്വാധീനം ഉണ്ട്:
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price') 
ഇപ്പോൾ Price-നും DayOfYear-നും corr ഫംഗ്ഷൻ ഉപയോഗിച്ച് കോറലേഷനെ കണക്കാക്കി നോക്കിയാൽ -0.27 പോലെയാകും, അതായത് പ്രവചന മോഡൽ പരിശീലിപ്പിക്കുന്നത് അർത്ഥവത്താണ്.
ലീനിയർ റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നതിന് മുമ്പ്, ഡാറ്റ ശുദ്ധമാണെന്ന് സ്ഥിരീകരിക്കുക വളരെ പ്രധാനമാണ്. ലീനിയർ റഗ്രഷൻ പതിവായി നഷ്ടപ്പെട്ട മൂല്യങ്ങളുള്ള ഡാറ്റയിൽ മോശമായി പ്രവർത്തിക്കുന്നു, അതിനാൽ ശൂന്യമായ സെല്ലുകൾ നീക്കംചെയ്യേണ്ടതാണ്:
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()മറ്റ് സമീപനം, ആ ശൂന്യ മൂല്യങ്ങളെ ആ കോളത്തിലെ ശരാശരി മൂല്യത്തോടെ പകരം നല്കുക തന്നെയാണ്.
🎥 ലീനിയർ, പോളിനോമിയൽ റഗ്രഷൻ സംക്ഷിപ്ത വീഡിയോ കാണാൻ മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
ലീനിയർ റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കാൻ നമ്മൾ Scikit-learn ലൈബ്രറി ഉപയോഗിക്കും.
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_splitനാം ആദ്യം ഇൻപുട്ട് മൂല്യങ്ങൾ (ഫീച്ചറുകൾ) അതേ സമയം പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ട് (ലേബൽ) numpy അരേയിലായി വേർതിരിക്കുന്നു:
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']ഇൻപുട്ട് ഡാറ്റ പാക്കേജ് ശരിയായി മനസ്സിലാക്കാൻ
reshapeനടത്തേണ്ടതുണ്ടെന്ന് ശ്രദ്ധിക്കുക. ലീനിയർ റഗ്രഷൻ 2D അരേ കണ്ടു കേൾക്കാൻ ആഗ്രഹിക്കുന്നു, ഓരോ റോ ഡാറ്റാ സജ്ജീവങ്ങളുള്ള ഫീച്ചറുകളുടെ വെക്റ്ററാണ്. ഇന്നത്തെ അവസരത്തിൽ, നമ്മുടെ ഇൻപുട്ട് ഒറ്റ ഫീച്ചറിനെയാണ്, അതിനാൽ N×1 രൂപത്തിലുള്ള അരേയുണ്ടു, N dataset വലിപ്പം.
അതിനുശേഷം ഡാറ്റ പരിശീലനത്തിനും പരിശോധനയ്ക്കുമായി train-test സെറ്റുകളായി വേർതിരിക്കും:
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)അവസാനത്തിൽ, യഥാർത്ഥ ലീനിയർ റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നത് രണ്ട് കോഡ് വരികളിൽ മാത്രമേ എടുക്കൂ. LinearRegression ഒബ്ജക്ട് നിർവ്വചിച്ച്, fit മെതഡിലൂടെ ഡാറ്റയിൽ ഇതിനെ നിന്നും ഫിറ്റ് ചെയ്യുക:
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)LinearRegression ഓബ്രക്റ്റ് fit-ചെയ്തതിന് ശേഷം റെഗ്രഷന്റെ എല്ലാ കോഫിഷ്യന്റുകളും അടങ്ങിയിരിക്കും, അവ .coef_ പ്രോപ്പർട്ടി വഴി ആക്സസ് ചെയ്യാവുന്നതാണ്. നമ്മുടെ കേസിൽ ഒരു കോഫിഷ്യന്റ് മാത്രമേ ഉണ്ടാകൂ, അത് ഏകദേശം -0.017 ആയിരിക്കണം. ഇത് അതായത് വിലകൾ സമയത്തിന് അനുബന്ധിച്ച് കുറച്ചുകുറച്ച് കുറഞ്ഞേക്കാം, പക്ഷെ അത്രയും കൂടുതലല്ല, ദിവസം ഏകദേശം 2 സെന്റുകൾക്കു ചുറ്റും. Y-അക്സിസുമായുള്ള റെഗ്രഷന്റെ ഇന്റേഴ്സെക്ഷൻ പോയിന്റ് lin_reg.intercept_ ഉപയോഗിച്ച് ആക്സസ് ചെയ്യാമെന്നാണ്, ഇത് നമ്മുടെ കേസിൽ ഏകദേശം 21 ആയിരിക്കും, വർഷത്തിന്റെ തുടക്കത്തിലെ വില സൂചിപ്പിക്കുന്നു.
നമ്മുടെ മോഡൽ എത്രത്തോളം ആക്വറേറ്റ് ആണെന്ന് കാണാൻ, ടെസ്റ്റ് ഡാറ്റാസെറ്റിൽ വിലകൾ പ്രവചിച്ച്, പ്രതീക്ഷിച്ച മൂല്യങ്ങളോട് നമ്മുടെ പ്രവചനങ്ങൾ എത്രത്തോളം അടുത്താണ് എന്ന് അളക്കാം. ഇത് ഗണിക്കുവാൻ മീൻ സ്ക്വയർ എറർ (MSE) മെട്രിക് ഉപയോഗിക്കാം, ഇത് പ്രതീക്ഷിച്ചയും പ്രവചിച്ചതും തമ്മിലുള്ള എല്ലാ സ്ക്വയർ ചെയ്ത വ്യത്യാസങ്ങളുടെ ശരാശരിയാണ്.
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), ഇത് ഇങ്ങനെ ലഭിക്കും:
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)മൂല്യം 0 ആണെങ്കിൽ, അത് മോഡൽ ഇൻപുട്ട് ഡാറ്റ കണക്കിലെടുത്ത് പ്രവൃത്തി ചെയ്യാത്തതാണെന്ന് വ്യക്തമാക്കുന്നു, അതായത് ഏറ്റവും മോശം ലീനിയർ പ്രവചകൻ പോലെ പ്രവർത്തിക്കുന്നു, ഇത് ഫലം കണക്കാക്കുന്ന ശരാശരിയാണ്. മൂല്യം 1 ആണെങ്കിൽ, എല്ലാ പ്രതീക്ഷിച്ച ഔട്ട്പുട്ടുകളും പൂർണ്ണമായും കൃത്യമായി പ്രവചിക്കാം എന്നർത്ഥം. നമ്മുടെ കേസിൽ, കോഫിഷ്യന്റ് ഏകദേശം 0.06 ആയിട്ടാണ്, ഇത് വളരെ കുറഞ്ഞതാണെന്ന് 의미ം.
റെഗ്രഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നന്നായി കാണാൻ ടെസ്റ്റ് ഡാറ്റയും റെഗ്രഷൻ വരും ചേർന്ന് പ്ലോട്ട് ചെയ്യാം:
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
ലീനിയർ റെഗ്രഷന്റെ മറ്റൊരു തരമാണ് പൊളിനോമിയൽ റെഗ്രഷൻ. ചിലസമയം വേരിയബിളുകൾ തമ്മിൽ ലീനിയർ ബന്ധം കാണാം - വോള്യത്തിൽ വലിയ ഗ്രാമ്മാതുള്ള പംപ്കിൻ കൂടുതൽ വിലവീഴും - എന്നാൽ ചിലപ്പോൾ ഈ ബന്ധങ്ങൾ സുതാര്യമായ വിമർശനയും അല്ലെങ്കിൽ നേരെയുള്ള রেখയായി കാഴ്ചവയ്ക്കാനാകാത്തതാണ്.
✅ ഇവിടെയാണ് ഇനി ചില ഉദാഹരണങ്ങൾ പൊളിനോമിയൽ റെഗ്രഷൻ ഉപയോഗിക്കാൻ കഴിയുന്നഡാറ്റ.
തിയതി Dateയും വില Priceയും തമ്മിലുള്ള ബന്ധം വീണ്ടും നോക്കുക. ഈ സ്കാറ്റർപ്ലോട്ട് ഒരു സരളരേഖ ഉപയോഗിച്ച് അവലോകനം ചെയ്തിരിക്കണമെന്നു തോന്നുമോ? വിലകൾ ചലിക്കുന്നില്ലേ? ഇത്തരം അവസരങ്ങളിൽ, പൊളിനോമിയൽ റെഗ്രഷൻ ശ്രമിക്കാം.
✅ പൊളിനോമിയൽ ആണെങ്കിൽ, അത് ഒരോ വൈറബിളുകളുടെയും കോഫിഷ്യന്റുകളുടെയും കൂട്ടമായ ഗണിതം പ്രകടനമാണ്.
പൊളിനോമിയൽ റെഗ്രഷൻ, നെളിനിയർ ഡാറ്റയ്ക്ക് മികച്ച രൂപത്തിൽ ചട്ടം പിടിക്കാൻ വളഞ്ഞ വര വരയ്ക്കുന്നു. നമ്മുടെ കേസിൽ, സ്ക്വയർ ചെയ്ത DayOfYear വേരിയബിള് ഇൻപ്പുട്ടിൽ ചേർത്താൽ, വർഷത്തിനുള്ളിൽ ഒരു നിശ്ചിത പോയിന്റിൽ കുറഞ്ഞത് ഉള്ള പാരബോളിക് വളവ് ഫിറ്റ് ചെയ്യാൻ കഴിയും.
Scikit-learn ഒരു ഉപകാരപ്രദമായ പൈപ്പ്ലൈൻ API ഉൾപ്പെടുത്തി, ഇത് ഡാറ്റ പ്രോസസിങ്ങിന്റെ വിവിധ ഘട്ടങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു. ഒരു പൈപ്പ്ലൈൻ എന്ന് പറയുന്നു എസ്റ്റിമേറ്ററുകളുടെ ഒരു ശൃംഖല. നമ്മുടെ കേസ്, ആദ്യം മോഡലിൽ പൊളിനോമിയൽ ഫീച്ചറുകൾ ചേർക്കുകയും പിന്നെ റെഗ്രഷൻ പരിശീലിപ്പിക്കുകയും ചെയ്യുന്ന പൈപ്പ്ലൈൻ സൃഷ്ടിക്കും:
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) ഉപയോഗിക്കുന്നത് ഇൻപുട്ട് ഡാറ്റയിലെ എല്ലാ രണ്ടാം-നിര പൊളിനോമിയൽ ഉൾപ്പെടുത്തുമെന്ന് അർത്ഥം. നമ്മുടെ കേസിൽ DayOfYear2 മാത്രമായിരിക്കും, എന്നാൽ രണ്ട് ഇൻപുട്ട് വേരിയബിൾസ് X, Y ഉണ്ടെങ്കിൽ, ഇത് X2, XY, Y2 എന്നിവ ചേർക്കും. ഉയർന്ന ഡിഗ്രി പൊളിനോമിയലുകൾ വേണമെങ്കിൽ അവ ഉപയോഗിക്കാം.
പൈപ്പ്ലൈൻ LinearRegression ഓബ്രക്റ്റ് പോലെ തന്നെ ഉപയോഗിക്കാം, അതായത് പൈപ്പ് ലൈൻ fit ചെയ്ത്, തുടർന്ന് predict എന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് പ്രവചന ഫലങ്ങൾ കിട്ടിക്കും. ഇവിടെ ടെസ്റ്റ് ഡാറ്റയും ആനുകൂല്യവർഗ്ഗം വളവും കാണിക്കുന്ന ഗ്രാഫ്:
പൊളിനോമിയൽ റെഗ്രഷൻ ഉപയോഗിച്ച് ചെറിയ കുറവ് MSEയും കൂടുതൽ ദേറ്റർമിനേഷൻ കിട്ടാമെന്ന് കാണാം, പക്ഷെ സാരമായ മാറ്റം ഇല്ല. കൂടുതൽ ഫീച്ചറുകൾ പരിഗണിക്കേണ്ടതാണ്!
ഹാലോവീന് ചുറ്റുമുള്ള സമയത്ത് പംപ്കിൻ വിലകൾ ഏറ്റവും താഴെയാണ് എന്ന് നിങ്ങൾ കാണും. നിങ്ങൾക്ക് ഇതെങ്ങനെ വിശദീകരിക്കാമെന്ന് തോന്നുന്നു?
🎃 അഭിനന്ദനങ്ങൾ, നിങ്ങൾ പൈ പംപ്കിൻ വില പ്രവചിക്കുന്ന ഒരു മോഡൽ സൃഷ്ടിച്ചു. നിങ്ങൾക്ക് സൂക്ഷ്മമായി എല്ലാം കായ്ക്കാം, എന്നാൽ അതൊരു കാരണം വൈകിയാകും. ഇനി പംപ്കിൻ വകഭേദം (variety) മോഡലിൽ ഉൾപ്പെടുത്തുന്നത് പഠിക്കാം!
സർവോപരി സ്ഥിതിയിൽ, ഒരേ മോഡലിൽ ഉപയോഗിച്ച് പംപ്കിൻ വകഭേദങ്ങൾക്കായുള്ള വില പ്രവചിക്കാൻ ആഗ്രഹിക്കും. പക്ഷെ Variety കോളം ഒരു പ്രത്യേകമാണ്, ലളിതവസ്തുക്കളായ Month പോലുള്ള കോളുകളേക്കാൾ വ്യത്യസ്തമാണ്, കാരണം ഇത് സംഖ്യാമല്ലാത്ത മൂല്യങ്ങൾ അടങ്ങിയതാണ്. ഇത്തരം കോളംഗൾ വിഭാഗീയ (categorical) എന്ന് പറയുന്നു.
🎥 ഉപയോഗിക്കാനുമുള്ള ലഘുവായ വീഡിയോ അവലോകനത്തിന് മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
ഇവിടെ നിങ്ങൾക്ക് പക്ഷവിധിവഴി ശരാശരി വില എങ്ങനെ വ്യത്യസ്തമാണ് എന്ന് കാണാം:
വകഭേദം പരിഗണിക്കാൻ, ആദ്യം അത് സംഖ്യാമായ രൂപത്തിൽ മാറ്റണം, അല്ലെങ്കിൽ എൻകോഡ് ചെയ്യണമെന്ന്. ഇതിന് കൂടുതലായ മാർഗ്ഗങ്ങൾ ഉണ്ട്:
- ലളിതമായ സംഖ്യാനി ഏന്കോടിംഗ് (numeric encoding) വിവിധ വകഭേദങ്ങളുടെ പട്ടിക സൃഷ്ടിച്ച്, ആ പട്ടികയിൽ ഉള്ള ഇനങ്ങളുടെ സൂചിക നൽകിയിട്ട് ഭാരതമാറ്റം നടത്തും. ഇത് ലീനിയർ റെഗ്രഷനിൽ നല്ല ഐഡിയയല്ല, കാരണം ലീനിയർ റെഗ്രഷൻ ഇൻഡക്സിന്റെ സംഖ്യാത്മക മൂല്യം കണക്കാക്കുന്നു, അത് അക്ക ഫലത്തിൽ ഒരു കോഫിഷ്യന്റ് ഉപയോഗിച്ച് കൂട്ടിച്ചേർക്കുന്നു. നമ്മുടെ കേസിൽ ഇൻഡക്സ് നമ്പറും വിലയും തമ്മിലുള്ള ബന്ധം ലീനിയർ അല്ലാത്തതായതിനാൽ ഇത് സാധ്യതയില്ല.
- ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ് (One-hot encoding)
Varietyകോളം 4 വ്യത്യസ്ത കോളങ്ങളായി മാറ്റും, ഓരോ വകഭേദത്തിനും പ്രത്യേകം ഒരു കോളം. ഓരോ കോളവും 1 അല്ലെങ്കിൽ 0 മൂല്യങ്ങളുള്ളതായി വരും, 1 ആണെങ്കിൽ ആ വരി ആ വിഭാഗത്തിൽപ്പെടുന്നു എന്നർത്ഥം. ഇത് ലീനിയർ റെഗ്രഷനിൽ ഓരോ പംപ്കിൻ വകഭേദത്തിനും 4 കോഫിഷ്യന്റുകൾ ഉണ്ടാകുമെന്ന് സൂചിപ്പിക്കുന്നു, ഓരോ വകഭേദത്തിനും പ്രത്യേക "ആരംഭ വില" (കൂടാതെ "കൂടുതൽ വില") പേരിൽ.
ഓന്ന്-ഹോട്ട് എൻകോഡിംഗ് Variety-യുമായി എങ്ങനെ ചെയ്യാമെന്നു കാണിക്കുന്നു ഈ കോഡ്:
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 |
ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ് ഉപയോഗിച്ച് Variety ഇൻപുട്ടായി Linear Regression പരിശീലിപ്പിക്കാൻ, Xയും yയും ശരിയായി ഇൻഷ്യലൈസ് ചെയ്യണം:
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']മറ്റ് കോഡ് അതെതാണ്, മുമ്പ് ലീനിയർ റെഗ്രഷൻ പരിശീലിപ്പിക്കാൻ ഉപയോഗിച്ചത് പോലെ. നിങ്ങൾ പരീക്ഷിക്കുമ്പോൾ, MSE ഏകദേശം അതേ ഉണ്ടാകുമെന്ന് കാണും പകരം തന്നെ ദേറ്റർമിനേഷൻ കോഫിഷ്യന്റ് വളരെ ഉയർന്നീിരിക്കും (~77%). കൂടുതൽ കൃത്യമായ പ്രവചനങ്ങൾക്ക്, മറ്റു വിഭാഗീയ ഫീച്ചറുകളും കൂടാതെ സങ്ക്യാ ഫീച്ചറുകളും (ഉദാ: Month അല്ലെങ്കിൽ DayOfYear) പരിഗണിക്കാം. മുഴുവൻ ഫീച്ചറുകളും ഒരു വൻ അറായിയാക്കാൻ join ഉപയോഗിക്കാം:
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 ഉം നൽകുന്നു!
ശ്രേഷ്ഠ മോഡൽ ഉണ്ടാക്കാൻ, ഒരു കൂട്ടിച്ചേർന്ന (ഒന്ന്-ഹോട്ട് എൻകോഡഡ് വിഭാഗീയ + സഖ്യാ) ഡാറ്റയും പൊളിനോമിയൽ റെഗ്രഷനും ചേർത്ത് ഉപയോഗിക്കാം. നിങ്ങളുടെ സൗകര്യത്തിന് പൂർണ്ണ കോഡ് ഇവിടെ:
# പരിശീലന ഡാറ്റ സജ്ജമാക്കുക
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% വരെ ഉയർത്തി. റെഗ്രഷനിലെ അവസാന അധ്യായത്തിൽ നിങ്ങൾ ലജിസ്റ്റിക് റെഗ്രഷൻ കുറിച്ച് പഠിക്കും, വിഭാഗങ്ങൾ നിർണയിക്കാൻ.
ഈ നോട്ട്ബുക്കിൽ പല വ്യത്യസ്ത വേരിയബിളുകളെ പരീക്ഷിച്ച് കോറിയലേഷൻ മോഡൽ ആകുറേറ്റിന് എങ്ങനെ ബാധിക്കുന്നു എന്ന് നോക്കുക.
ഈ പാഠത്തിൽ നാം ലീനിയർ റെഗ്രഷൻ പഠിച്ചു. മറ്റ് പ്രധാന റെഗ്രഷൻ തരം들도 ഉണ്ട്. Stepwise, Ridge, Lasso, Elasticnet ടെക്നിക്കുകൾ വായിക്കുക. കൂടുതൽ പഠിക്കാനുള്ള നല്ല കോഴ്സ് Stanford Statistical Learning course ആണ്.
പരിചിതക്കുറിപ്പ്:
ഈ രേഖ AI പരിഭാഷാ സേവനമായ Co-op Translator ഉപയോഗിച്ച് പരിഭാഷ ചെയ്തതാണ്. ഞങ്ങൾ സർവസാധാരണത്വത്തിനായി ശ്രമിച്ചുവെങ്കിലും, യന്ത്രപരിഭാഷയിൽ പിശകുകളോ അസംഘടിതത്വങ്ങളോ ഉണ്ടായേക്കാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. യഥാര്ത്ഥ രേഖയുടെ മാതൃഭാഷയിലെ ഫയൽ പ്രാമാണികമായ ആദ്യസ്രോതസ്സായി കണക്കാക്കേണ്ടതാണ്. സുപ്രധാന വിവരങ്ങൾക്കായി, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ നിർദ്ദേശിക്കുന്നു. ഈ പരിഭാഷ ഉപയോഗിക്കുന്നതിൽ നിന്നു കാണാവുന്ന തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾക്ക് ഉത്തരവാദിത്വമില്ല.