റെഗ്രഷൻ എന്ന അടിസ്ഥാന ക്ലാസിക് എംഎൽ സാങ്കേതികവിദ്യകളിൽ അവസാന പാഠമായ ഈ പാഠത്തിൽ, നാം ലോജിസ്റ്റിക് റെഗ്രഷൻ പരിശോധിക്കും. ബൈനറി വിഭാഗങ്ങൾ പ്രവചിക്കാൻ ഈ സാങ്കേതികവിദ്യ ഉപയോഗിക്കും. ഈ കാൻഡി ചോക്ലേറ്റ് ആണോ അല്ലയോ? ഈ രോഗം സംക്രമണശീലമാണോ അല്ലയോ? ഈ ഉപഭോക്താവ് ഈ ഉൽപ്പന്നം തിരഞ്ഞെടുക്കുമോ അല്ലയോ?
ഈ പാഠത്തിൽ നിങ്ങൾ പഠിക്കും:
- ഡാറ്റാ ദൃശ്യവത്കരണത്തിനുള്ള പുതിയ ലൈബ്രറി
- ലോജിസ്റ്റിക് റെഗ്രഷനുള്ള സാങ്കേതികവിദ്യകൾ
✅ ഈ Learn module വഴി ഈ തരത്തിലുള്ള റെഗ്രഷനിൽ പ്രവർത്തിക്കുന്നതിന്റെ അറിവ് കൂടുതൽ ആഴത്തിൽ നേടുക
പംപ്കിൻ ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിച്ചതിനാൽ, അതിൽ ഒരു ബൈനറി വിഭാഗം ഉണ്ടെന്ന് നമുക്ക് മനസ്സിലായി: Color.
ചില വേരിയബിളുകൾ നൽകിയാൽ, ഒരു പംപ്കിൻ ഏത് നിറത്തിൽ ഉണ്ടാകാൻ സാധ്യതയുള്ളതാണെന്ന് പ്രവചിക്കാൻ ഒരു ലോജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കാം (ഓറഞ്ച് 🎃 അല്ലെങ്കിൽ വെളുപ്പ് 👻).
റെഗ്രഷൻ പാഠങ്ങളുമായി ബന്ധപ്പെട്ട ഒരു ഗ്രൂപ്പിൽ ബൈനറി ക്ലാസിഫിക്കേഷൻ എന്തുകൊണ്ട് ചർച്ച ചെയ്യുന്നു? ഭാഷാശൈലിയുടെ സൗകര്യത്തിനായി മാത്രമാണ്, കാരണം ലോജിസ്റ്റിക് റെഗ്രഷൻ വാസ്തവത്തിൽ ഒരു ക്ലാസിഫിക്കേഷൻ രീതി ആണ്, എന്നാൽ ലീനിയർ അടിസ്ഥാനമാക്കിയുള്ളത്. അടുത്ത പാഠ ഗ്രൂപ്പിൽ ഡാറ്റ ക്ലാസിഫൈ ചെയ്യാനുള്ള മറ്റ് മാർഗങ്ങൾ പഠിക്കാം.
നമ്മുടെ ആവശ്യങ്ങൾക്ക്, ഇത് ഒരു ബൈനറിയായി പ്രകടിപ്പിക്കും: 'വെളുപ്പ്' അല്ലെങ്കിൽ 'വെളുപ്പ് അല്ല'. നമ്മുടെ ഡാറ്റാസെറ്റിൽ 'സ്ട്രൈപ്പഡ്' എന്ന ഒരു വിഭാഗവും ഉണ്ട്, പക്ഷേ അതിന്റെ ഉദാഹരണങ്ങൾ കുറവാണ്, അതിനാൽ അത് ഉപയോഗിക്കില്ല. നൾ മൂല്യങ്ങൾ നീക്കം ചെയ്താൽ അത് അപ്രാപ്യമാണ്.
🎃 രസകരമായ ഒരു വസ്തുത, വെളുപ്പ് പംപ്കിനുകളെ ചിലപ്പോൾ 'ഗോസ്റ്റ്' പംപ്കിനുകൾ എന്ന് വിളിക്കുന്നു. അവ കട്ടിയുള്ളവയല്ല, അതിനാൽ ഓറഞ്ച് പംപ്കിനുകളെപ്പോലെ ജനപ്രിയമല്ല, പക്ഷേ അവ കൂൾ ആയി കാണപ്പെടുന്നു! അതിനാൽ നാം ചോദ്യത്തെ 'ഗോസ്റ്റ്' അല്ലെങ്കിൽ 'ഗോസ്റ്റ് അല്ല' എന്നായി പുനർനിർവചിക്കാം. 👻
ലീനിയർ റെഗ്രഷനിൽ നിന്നുള്ള ലോജിസ്റ്റിക് റെഗ്രഷൻ ചില പ്രധാന വ്യത്യാസങ്ങളുണ്ട്.
🎥 ലോജിസ്റ്റിക് റെഗ്രഷന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.
ലോജിസ്റ്റിക് റെഗ്രഷൻ ലീനിയർ റെഗ്രഷനുപോലെ സവിശേഷതകൾ നൽകുന്നില്ല. മുൻപുള്ളത് ബൈനറി വിഭാഗത്തെക്കുറിച്ച് പ്രവചനം നൽകുന്നു ("വെളുപ്പ് അല്ലെങ്കിൽ വെളുപ്പ് അല്ല") എന്നാൽ പിന്നീടുള്ളത് തുടർച്ചയായ മൂല്യങ്ങൾ പ്രവചിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് ഒരു പംപ്കിന്റെ ഉത്ഭവവും വിളവെടുപ്പ് സമയവും നൽകിയാൽ, അതിന്റ വില എത്ര ഉയരും എന്നത്.
ഇൻഫോഗ്രാഫിക്: ദാസാനി മടിപള്ളി
മൾട്ടിനോമിയൽ, ഓർഡിനൽ തുടങ്ങിയ മറ്റ് തരത്തിലുള്ള ലോജിസ്റ്റിക് റെഗ്രഷനുകളും ഉണ്ട്:
- മൾട്ടിനോമിയൽ: ഒന്നിലധികം വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു - "ഓറഞ്ച്, വെളുപ്പ്, സ്ട്രൈപ്പഡ്".
- ഓർഡിനൽ: ക്രമീകരിച്ച വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു, ഉദാഹരണത്തിന് നമ്മുടെ പംപ്കിനുകൾ ചെറിയ, ചെറിയ, മധ്യ, വലിയ, എക്സ്എൽ, ഡബ്ല്യു എക്സ്എൽ എന്ന ക്രമത്തിൽ ക്രമീകരിച്ചിരിക്കുന്നതുപോലെ.
ലീനിയർ റെഗ്രഷൻ കൂടുതൽ ബന്ധമുള്ള വേരിയബിളുകളുമായി നല്ലതായിരുന്നു, എന്നാൽ ലോജിസ്റ്റിക് റെഗ്രഷൻ അതിന്റെ വിരുദ്ധമാണ് - വേരിയബിളുകൾ പൊരുത്തപ്പെടേണ്ടതില്ല. ഈ ഡാറ്റയ്ക്ക് ഇത് അനുയോജ്യമാണ്, കാരണം ഇതിൽ ബന്ധങ്ങൾ കുറവാണ്.
ലോജിസ്റ്റിക് റെഗ്രഷൻ കൂടുതൽ ഡാറ്റ ഉപയോഗിച്ചാൽ കൂടുതൽ കൃത്യമായ ഫലങ്ങൾ നൽകും; നമ്മുടെ ചെറിയ ഡാറ്റാസെറ്റ് ഈ ജോലി ചെയ്യാൻ അനുയോജ്യമല്ല, അതിനാൽ ഇത് മനസ്സിലാക്കുക.
🎥 ലീനിയർ റെഗ്രഷനായി ഡാറ്റ തയ്യാറാക്കലിന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
✅ ലോജിസ്റ്റിക് റെഗ്രഷനുമായി നല്ല അനുയോജ്യമായ ഡാറ്റാ തരം എന്തെല്ലാമാകാമെന്ന് ചിന്തിക്കുക
ആദ്യം, ഡാറ്റ കുറച്ച് ശുചീകരിക്കുക, നൾ മൂല്യങ്ങൾ ഒഴിവാക്കി ചില കോളങ്ങൾ മാത്രം തിരഞ്ഞെടുക്കുക:
-
താഴെ കൊടുത്ത കോഡ് ചേർക്കുക:
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color'] pumpkins = full_pumpkins.loc[:, columns_to_select] pumpkins.dropna(inplace=True)
നിങ്ങളുടെ പുതിയ ഡാറ്റാഫ്രെയിം ഒരു നോട്ടം എടുക്കാം:
pumpkins.info
ഇപ്പോൾ നിങ്ങൾ വീണ്ടും സ്റ്റാർട്ടർ നോട്ട്ബുക്ക് പംപ്കിൻ ഡാറ്റ ഉപയോഗിച്ച് ലോഡ് ചെയ്ത്, ചില വേരിയബിളുകൾ ഉൾപ്പെടുന്ന ഡാറ്റാസെറ്റ് സംരക്ഷിക്കാൻ ശുചീകരിച്ചു, അതിൽ Color ഉൾപ്പെടുന്നു. നമുക്ക് മറ്റൊരു ലൈബ്രറി ഉപയോഗിച്ച് നോട്ട്ബുക്കിൽ ഡാറ്റാഫ്രെയിം ദൃശ്യവത്കരിക്കാം: Seaborn, ഇത് Matplotlib-ന്റെ മേൽനോട്ടത്തിലാണ്, നാം മുമ്പ് ഉപയോഗിച്ചത്.
Seaborn നിങ്ങളുടെ ഡാറ്റ ദൃശ്യവത്കരിക്കാൻ ചില നല്ല മാർഗങ്ങൾ നൽകുന്നു. ഉദാഹരണത്തിന്, ഓരോ Varietyക്കും Colorക്കും ഉള്ള ഡാറ്റയുടെ വിതരണങ്ങൾ വർഗ്ഗീയ പ്ലോട്ടിൽ താരതമ്യം ചെയ്യാം.
-
catplotഫംഗ്ഷൻ ഉപയോഗിച്ച് ഇത്തരമൊരു പ്ലോട്ട് സൃഷ്ടിക്കുക, നമ്മുടെ പംപ്കിൻ ഡാറ്റpumpkinsഉപയോഗിച്ച്, ഓരോ പംപ്കിൻ വിഭാഗത്തിനും (ഓറഞ്ച് അല്ലെങ്കിൽ വെളുപ്പ്) നിറം നിശ്ചയിച്ച്:import seaborn as sns palette = { 'ORANGE': 'orange', 'WHITE': 'wheat', } sns.catplot( data=pumpkins, y="Variety", hue="Color", kind="count", palette=palette, )
ഡാറ്റ നിരീക്ഷിച്ച്, നിറം ഡാറ്റ
Variety-യുമായി എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന് കാണാം.✅ ഈ വർഗ്ഗീയ പ്ലോട്ട് നൽകിയാൽ, നിങ്ങൾക്ക് എന്തെല്ലാം രസകരമായ അന്വേഷണങ്ങൾ കാണാനാകും?
നമ്മുടെ പംപ്കിൻ ഡാറ്റാസെറ്റിലെ എല്ലാ കോളങ്ങളിലുമുള്ള മൂല്യങ്ങൾ സ്ട്രിംഗ് ആണ്. വർഗ്ഗീയ ഡാറ്റ മനുഷ്യർക്കു മനസ്സിലാക്കാൻ എളുപ്പമാണ്, പക്ഷേ യന്ത്രങ്ങൾക്ക് അല്ല. മെഷീൻ ലേണിംഗ് ആൽഗോരിതങ്ങൾ സംഖ്യകളുമായി നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്നു. അതിനാൽ എൻകോഡിംഗ് ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ് ഘട്ടത്തിൽ വളരെ പ്രധാനമാണ്, കാരണം ഇത് വർഗ്ഗീയ ഡാറ്റ സംഖ്യാത്മക ഡാറ്റയാക്കി മാറ്റാൻ സഹായിക്കുന്നു, വിവരങ്ങൾ നഷ്ടപ്പെടാതെ. നല്ല എൻകോഡിംഗ് നല്ല മോഡൽ നിർമ്മിക്കാൻ സഹായിക്കുന്നു.
ഫീച്ചർ എൻകോഡിംഗിന് രണ്ട് പ്രധാന എൻകോഡർ തരം ഉണ്ട്:
-
ഓർഡിനൽ എൻകോഡർ: ഓർഡിനൽ വേരിയബിളുകൾക്ക് അനുയോജ്യമാണ്, അവ ക്രമീകരിച്ച വർഗ്ഗീയ വേരിയബിളുകളാണ്, ഉദാഹരണത്തിന് നമ്മുടെ ഡാറ്റാസെറ്റിലെ
Item Sizeകോളം. ഓരോ വിഭാഗത്തിനും ഒരു സംഖ്യ നൽകുന്ന മാപ്പിംഗ് സൃഷ്ടിക്കുന്നു, അത് കോളത്തിലെ ക്രമം ആണ്.from sklearn.preprocessing import OrdinalEncoder item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']] ordinal_features = ['Item Size'] ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
-
വർഗ്ഗീയ എൻകോഡർ: നോമിനൽ വേരിയബിളുകൾക്ക് അനുയോജ്യമാണ്, അവ ക്രമീകരിക്കപ്പെട്ടിട്ടില്ലാത്ത വർഗ്ഗീയ വേരിയബിളുകളാണ്, നമ്മുടെ ഡാറ്റാസെറ്റിലെ
Item Sizeഒഴികെയുള്ള എല്ലാ ഫീച്ചറുകളും. ഇത് ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ് ആണ്, അതായത് ഓരോ വിഭാഗവും ഒരു ബൈനറി കോളമായി പ്രതിനിധീകരിക്കുന്നു: പംപ്കിൻ ആ വിഭാഗത്തിൽപ്പെട്ടാൽ എൻകോഡുചെയ്ത വേരിയബിൾ 1 ആകും, അല്ലെങ്കിൽ 0.from sklearn.preprocessing import OneHotEncoder categorical_features = ['City Name', 'Package', 'Variety', 'Origin'] categorical_encoder = OneHotEncoder(sparse_output=False)
പിന്നീട്, ColumnTransformer ഉപയോഗിച്ച് പല എൻകോഡറുകളും ഒരേ ഘട്ടത്തിൽ ചേർത്ത് അനുയോജ്യമായ കോളങ്ങളിൽ പ്രയോഗിക്കുന്നു.
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer(transformers=[
('ord', ordinal_encoder, ordinal_features),
('cat', categorical_encoder, categorical_features)
])
ct.set_output(transform='pandas')
encoded_features = ct.fit_transform(pumpkins)മറ്റുവശത്ത്, ലേബൽ എൻകോഡിംഗിന് scikit-learn-ന്റെ LabelEncoder ക്ലാസ് ഉപയോഗിക്കുന്നു, ഇത് ലേബലുകൾ 0 മുതൽ n_classes-1 (ഇവിടെ 0, 1) വരെയുള്ള മൂല്യങ്ങൾ മാത്രമാകാൻ സാധ്യമാക്കുന്ന ഒരു സഹായക ക്ലാസ്സാണ്.
from sklearn.preprocessing import LabelEncoder
label_encoder = LabelEncoder()
encoded_label = label_encoder.fit_transform(pumpkins['Color'])ഫീച്ചറുകളും ലേബലും എൻകോഡ് ചെയ്ത ശേഷം, അവ encoded_pumpkins എന്ന പുതിയ ഡാറ്റാഫ്രെയിമിൽ സംയോജിപ്പിക്കാം.
encoded_pumpkins = encoded_features.assign(Color=encoded_label)✅ Item Size കോളത്തിനായി ഓർഡിനൽ എൻകോഡർ ഉപയോഗിക്കുന്നതിന്റെ ഗുണങ്ങൾ എന്തെല്ലാമാണ്?
ഇപ്പോൾ നാം ഡാറ്റ പ്രീ-പ്രോസസ്സിംഗ് ചെയ്തു, ഫീച്ചറുകളും ലേബലും തമ്മിലുള്ള ബന്ധങ്ങൾ വിശകലനം ചെയ്ത് മോഡൽ എത്രത്തോളം ലേബൽ പ്രവചിക്കാൻ കഴിയും എന്ന് മനസ്സിലാക്കാം.
ഇത്തരത്തിലുള്ള വിശകലനത്തിന് ഏറ്റവും നല്ല മാർഗം ഡാറ്റ പ്ലോട്ട് ചെയ്യുകയാണ്. നാം വീണ്ടും Seaborn-ന്റെ catplot ഫംഗ്ഷൻ ഉപയോഗിച്ച് Item Size, Variety, Color തമ്മിലുള്ള ബന്ധങ്ങൾ വർഗ്ഗീയ പ്ലോട്ടിൽ കാണിക്കും. ഡാറ്റ മികച്ച രീതിയിൽ പ്ലോട്ട് ചെയ്യാൻ എൻകോഡ് ചെയ്ത Item Size കോളവും എൻകോഡ് ചെയ്യാത്ത Variety കോളവും ഉപയോഗിക്കും.
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
g = sns.catplot(
data=pumpkins,
x="Item Size", y="Color", row='Variety',
kind="box", orient="h",
sharex=False, margin_titles=True,
height=1.8, aspect=4, palette=palette,
)
g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
g.set_titles(row_template="{row_name}")
Color ഒരു ബൈനറി വിഭാഗമാണ (വെളുപ്പ് അല്ലെങ്കിൽ അല്ല), അതിനാൽ 'ഒരു പ്രത്യേക സമീപനം ദൃശ്യവത്കരണത്തിന്' ആവശ്യമാണ്. ഈ വിഭാഗത്തിന്റെ മറ്റ് വേരിയബിളുകളുമായുള്ള ബന്ധം കാണിക്കാൻ മറ്റ് മാർഗങ്ങളും ഉണ്ട്.
Seaborn പ്ലോട്ടുകൾ ഉപയോഗിച്ച് വേരിയബിളുകൾ പക്കൽ-പക്കൽ കാണിക്കാം.
-
മൂല്യങ്ങളുടെ വിതരണങ്ങൾ കാണിക്കാൻ 'സ്വാർം' പ്ലോട്ട് പരീക്ഷിക്കുക:
palette = { 0: 'orange', 1: 'wheat' } sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
ശ്രദ്ധിക്കുക: മുകളിൽ കൊടുത്ത കോഡ് ഒരു മുന്നറിയിപ്പ് ഉണ്ടാക്കാം, കാരണം Seaborn ഈ അളവിലുള്ള ഡാറ്റ പോയിന്റുകൾ സ്വാർം പ്ലോട്ടിൽ പ്രതിനിധീകരിക്കാൻ പരാജയപ്പെടും. ഒരു പരിഹാരമായി 'size' പാരാമീറ്റർ ഉപയോഗിച്ച് മാർക്കറിന്റെ വലിപ്പം കുറയ്ക്കാം. എന്നാൽ ഇത് പ്ലോട്ടിന്റെ വായനാസൗകര്യം ബാധിക്കും.
🧮 ഗണിതം കാണിക്കുക
ലോജിസ്റ്റിക് റെഗ്രഷൻ 'മാക്സിമം ലൈക്ലിഹുഡ്' ആശയത്തെ ആശ്രയിച്ചിരിക്കുന്നു, സിഗ്മോയ്ഡ് ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച്. ഒരു 'സിഗ്മോയ്ഡ് ഫംഗ്ഷൻ' പ്ലോട്ടിൽ 'S' ആകൃതിയിലാണ് കാണപ്പെടുന്നത്. ഒരു മൂല്യം എടുത്ത് അത് 0നും 1നും ഇടയിലുള്ള ഏതെങ്കിലും സ്ഥാനത്തേക്ക് മാപ്പ് ചെയ്യുന്നു. അതിന്റെ വളവ് 'ലോജിസ്റ്റിക് വളവ്' എന്നും വിളിക്കുന്നു. അതിന്റെ സൂത്രവാക്യം ഇപ്രകാരമാണ്:
ഇവിടെ സിഗ്മോയ്ഡിന്റെ മധ്യബിന്ദു x-ന്റെ 0 പോയിന്റിലാണ്, L വളവിന്റെ പരമാവധി മൂല്യം, k വളവിന്റെ കൂറ്റൻത്വം. ഫംഗ്ഷന്റെ ഫലം 0.5-ൽ കൂടുതലായാൽ, ആ ലേബലിന് ബൈനറി തിരഞ്ഞെടുപ്പിൽ '1' ക്ലാസ് നൽകും. അല്ലെങ്കിൽ '0' ആയി വർഗ്ഗീകരിക്കും.
ഈ ബൈനറി ക്ലാസിഫിക്കേഷൻ കണ്ടെത്താൻ മോഡൽ നിർമ്മിക്കുന്നത് Scikit-learn-ൽ അത്യന്തം ലളിതമാണ്.
🎥 ലീനിയർ റെഗ്രഷൻ മോഡൽ നിർമ്മാണത്തിന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
-
നിങ്ങളുടെ ക്ലാസിഫിക്കേഷൻ മോഡലിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന വേരിയബിളുകൾ തിരഞ്ഞെടുക്കുക, പരിശീലനവും പരിശോധനാ സെറ്റുകളും
train_test_split()വിളിച്ച് വിഭജിക്കുക:from sklearn.model_selection import train_test_split X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])] y = encoded_pumpkins['Color'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-
ഇപ്പോൾ നിങ്ങളുടെ മോഡൽ പരിശീലിപ്പിക്കാൻ, പരിശീലന ഡാറ്റ ഉപയോഗിച്ച്
fit()വിളിച്ച് ഫലം പ്രിന്റ് ചെയ്യുക:from sklearn.metrics import f1_score, classification_report from sklearn.linear_model import LogisticRegression model = LogisticRegression() model.fit(X_train, y_train) predictions = model.predict(X_test) print(classification_report(y_test, predictions)) print('Predicted labels: ', predictions) print('F1-score: ', f1_score(y_test, predictions))
നിങ്ങളുടെ മോഡലിന്റെ സ്കോർബോർഡ് നോക്കൂ. ഏകദേശം 1000 വരി ഡാറ്റ മാത്രമുള്ളതിനാൽ മോശമല്ല:
precision recall f1-score support 0 0.94 0.98 0.96 166 1 0.85 0.67 0.75 33 accuracy 0.92 199 macro avg 0.89 0.82 0.85 199 weighted avg 0.92 0.92 0.92 199 Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1] F1-score: 0.7457627118644068
മുകളിൽ കൊടുത്ത terms പ്രിന്റ് ചെയ്ത് സ്കോർബോർഡ് റിപ്പോർട്ട് ലഭിക്കാം, പക്ഷേ മോഡൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ കൺഫ്യൂഷൻ മാട്രിക്സ് ഉപയോഗിക്കുന്നത് സഹായിക്കും.
🎓 'കൺഫ്യൂഷൻ മാട്രിക്സ്' (അഥവാ 'എറർ മാട്രിക്സ്') നിങ്ങളുടെ മോഡലിന്റെ യഥാർത്ഥവും തെറ്റായ പോസിറ്റീവുകളും നെഗറ്റീവുകളും കാണിക്കുന്ന ഒരു പട്ടികയാണ്, പ്രവചനങ്ങളുടെ കൃത്യത അളക്കാൻ.
-
കൺഫ്യൂഷൻ മാട്രിക്സ് ഉപയോഗിക്കാൻ
confusion_matrix()വിളിക്കുക:from sklearn.metrics import confusion_matrix confusion_matrix(y_test, predictions)
നിങ്ങളുടെ മോഡലിന്റെ കൺഫ്യൂഷൻ മാട്രിക്സ് നോക്കൂ:
array([[162, 4], [ 11, 22]])
Scikit-learn-ൽ, കൺഫ്യൂഷൻ മാട്രിക്സിലെ വരികൾ (അക്ഷം 0) യഥാർത്ഥ ലേബലുകളാണ്, കോളങ്ങൾ (അക്ഷം 1) പ്രവചിച്ച ലേബലുകളാണ്.
| 0 | 1 | |
|---|---|---|
| 0 | TN | FP |
| 1 | FN | TP |
ഇവിടെ എന്താണ് സംഭവിക്കുന്നത്? നമുക്ക് മോഡലിന് പംപ്കിനുകളെ രണ്ട് ബൈനറി വിഭാഗങ്ങളായി, 'വെളുപ്പ്' എന്ന വിഭാഗവും 'വെളുപ്പ് അല്ല' എന്ന വിഭാഗവും വേർതിരിക്കാൻ ആവശ്യപ്പെട്ടതായി കരുതാം.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് അല്ല എന്ന് പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'വെളുപ്പ് അല്ല' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ട്രൂ നെഗറ്റീവ് ആണ്, മുകളിൽ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് ആണെന്ന് പ്രവചിച്ചാൽ, എന്നാൽ യഥാർത്ഥത്തിൽ 'വെളുപ്പ് അല്ല' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ഫാൾസ് പോസിറ്റീവ് ആണ്, മുകളിൽ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് അല്ല എന്ന് പ്രവചിച്ചാൽ, എന്നാൽ യഥാർത്ഥത്തിൽ 'വെളുപ്പ്' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ഫാൾസ് നെഗറ്റീവ് ആണ്, താഴെ ഇടത്തുള്ള സംഖ്യ കാണിക്കുന്നു.
- മോഡൽ ഒരു പംപ്കിൻ വെളുപ്പ് ആണെന്ന് പ്രവചിച്ചാൽ, അത് യഥാർത്ഥത്തിൽ 'വെളുപ്പ്' വിഭാഗത്തിൽപ്പെട്ടതാണ് എങ്കിൽ, അത് ഒരു ട്രൂ പോസിറ്റീവ് ആണ്, താഴെ വലത്തുള്ള സംഖ്യ കാണിക്കുന്നു. നിങ്ങൾക്ക് തോന്നിയതുപോലെ, സത്യം പോസിറ്റീവുകളും സത്യം നെഗറ്റീവുകളും കൂടുതലായിരിക്കണം, തെറ്റായ പോസിറ്റീവുകളും തെറ്റായ നെഗറ്റീവുകളും കുറവായിരിക്കണം, അതായത് മോഡൽ മികച്ച പ്രകടനം നടത്തുന്നു എന്നതാണ്.
കൺഫ്യൂഷൻ മാട്രിക്സ് പ്രിസിഷനും റിക്കോളും എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു? മുകളിൽ പ്രിന്റ് ചെയ്ത ക്ലാസിഫിക്കേഷൻ റിപ്പോർട്ട് പ്രിസിഷൻ (0.85)യും റിക്കോൾ (0.67)യും കാണിച്ചു.
Precision = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
Recall = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
✅ Q: കൺഫ്യൂഷൻ മാട്രിക്സിന്റെ പ്രകാരം മോഡൽ എങ്ങനെ പ്രവർത്തിച്ചു? A: മോശമല്ല; സത്യം നെഗറ്റീവുകളുടെ എണ്ണം നല്ലതാണെങ്കിലും ചില തെറ്റായ നെഗറ്റീവുകളും ഉണ്ട്.
TP/TN, FP/FN എന്നിവയുടെ കൺഫ്യൂഷൻ മാട്രിക്സ് മാപ്പിംഗിന്റെ സഹായത്തോടെ മുമ്പ് കണ്ട പദങ്ങൾ വീണ്ടും പരിശോധിക്കാം:
🎓 Precision: TP/(TP + FP) തിരികെ കിട്ടിയ ഉദാഹരണങ്ങളിൽ പ്രസക്തമായ ഉദാഹരണങ്ങളുടെ അനുപാതം (ഉദാ: ഏത് ലേബലുകൾ ശരിയായി ലേബൽ ചെയ്തിരിക്കുന്നു)
🎓 Recall: TP/(TP + FN) തിരികെ കിട്ടിയ പ്രസക്തമായ ഉദാഹരണങ്ങളുടെ അനുപാതം, ശരിയായി ലേബൽ ചെയ്തിട്ടുണ്ടോ എന്നത് നോക്കാതെ
🎓 f1-score: (2 * precision * recall)/(precision + recall) പ്രിസിഷനും റിക്കോളും തമ്മിലുള്ള ഭാരിത ശരാശരി, ഏറ്റവും നല്ലത് 1, ഏറ്റവും മോശം 0
🎓 Support: തിരികെ കിട്ടിയ ഓരോ ലേബലിന്റെയും സംഭവങ്ങളുടെ എണ്ണം
🎓 Accuracy: (TP + TN)/(TP + TN + FP + FN) ഒരു സാമ്പിളിനായി ശരിയായി പ്രവചിച്ച ലേബലുകളുടെ ശതമാനം
🎓 Macro Avg: ഓരോ ലേബലിനും ലേബൽ അസമത്വം പരിഗണിക്കാതെ ഗണ്യമായ ശരാശരി മെട്രിക്സ്
🎓 Weighted Avg: ഓരോ ലേബലിനും ലേബൽ അസമത്വം പരിഗണിച്ച് അവയുടെ സപ്പോർട്ട് (ഓരോ ലേബലിനും സത്യം ഉദാഹരണങ്ങളുടെ എണ്ണം) അനുസരിച്ച് ഭാരിത ശരാശരി
✅ നിങ്ങളുടെ മോഡൽ തെറ്റായ നെഗറ്റീവുകളുടെ എണ്ണം കുറയ്ക്കണമെന്ന് ആഗ്രഹിക്കുന്നുവെങ്കിൽ ഏത് മെട്രിക് ശ്രദ്ധിക്കണം എന്ന് നിങ്ങൾക്ക് തോന്നുന്നുണ്ടോ?
🎥 ROC വക്രങ്ങളുടെ ഒരു ചെറിയ വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക
'ROC' വക്രം കാണാൻ മറ്റൊരു ദൃശ്യവൽക്കരണം ചെയ്യാം:
from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
y_scores = model.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
fig = plt.figure(figsize=(6, 6))
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()Matplotlib ഉപയോഗിച്ച് മോഡലിന്റെ Receiving Operating Characteristic അല്ലെങ്കിൽ ROC വരച്ചിടുക. ROC വക്രങ്ങൾ സാധാരണയായി ക്ലാസിഫയറിന്റെ ഔട്ട്പുട്ട് സത്യം പോസിറ്റീവുകളും തെറ്റായ പോസിറ്റീവുകളും എന്ന കാഴ്ചപ്പാടിൽ കാണാൻ ഉപയോഗിക്കുന്നു. "ROC വക്രങ്ങളിൽ സാധാരണയായി Y അക്ഷത്തിൽ സത്യം പോസിറ്റീവ് നിരക്കും X അക്ഷത്തിൽ തെറ്റായ പോസിറ്റീവ് നിരക്കും കാണിക്കുന്നു." അതിനാൽ വക്രത്തിന്റെ കൂറ്റൻതയും മധ്യരേഖയും വക്രത്തിനിടയിലെ ഇടവും പ്രധാനമാണ്: നിങ്ങൾക്ക് വക്രം വേഗത്തിൽ മുകളിൽ കയറി രേഖയെ മറികടക്കുന്നത് വേണം. നമ്മുടെ കേസിൽ, തുടക്കത്തിൽ തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ട്, പിന്നീട് രേഖ ശരിയായി മുകളിൽ കയറി മറികടക്കുന്നു:
അവസാനമായി, Scikit-learn ന്റെ roc_auc_score API ഉപയോഗിച്ച് യഥാർത്ഥ 'Area Under the Curve' (AUC) കണക്കാക്കുക:
auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)ഫലം 0.9749908725812341 ആണ്. AUC 0 മുതൽ 1 വരെ മാറുന്നതുകൊണ്ട്, വലിയ സ്കോർ വേണം, കാരണം 100% ശരിയായ പ്രവചനമുള്ള മോഡലിന് AUC 1 ആയിരിക്കും; ഈ കേസിൽ മോഡൽ നന്നായിരിക്കുന്നു.
ഭാവിയിലെ ക്ലാസിഫിക്കേഷൻ പാഠങ്ങളിൽ, നിങ്ങളുടെ മോഡലിന്റെ സ്കോറുകൾ മെച്ചപ്പെടുത്താൻ എങ്ങനെ പുനരാവർത്തനം ചെയ്യാമെന്ന് പഠിക്കും. എന്നാൽ ഇപ്പോൾ, അഭിനന്ദനങ്ങൾ! നിങ്ങൾ ഈ റെഗ്രഷൻ പാഠങ്ങൾ പൂർത്തിയാക്കി!
ലോജിസ്റ്റിക് റെഗ്രഷൻ സംബന്ധിച്ച് പഠിക്കാനുള്ള കാര്യങ്ങൾ വളരെ കൂടുതലുണ്ട്! എന്നാൽ പഠിക്കാൻ ഏറ്റവും നല്ല മാർഗം പരീക്ഷണമാണ്. ഈ തരം വിശകലനത്തിന് അനുയോജ്യമായ ഒരു ഡാറ്റാസെറ്റ് കണ്ടെത്തി അതുമായി ഒരു മോഡൽ നിർമ്മിക്കുക. നിങ്ങൾ എന്ത് പഠിക്കുന്നു? ടിപ്പ്: രസകരമായ ഡാറ്റാസെറ്റുകൾക്കായി Kaggle പരീക്ഷിക്കുക.
ലോജിസ്റ്റിക് റെഗ്രഷന്റെ ചില പ്രായോഗിക ഉപയോഗങ്ങളെക്കുറിച്ച് പഠിക്കാൻ സ്റ്റാൻഫോർഡിന്റെ ഈ പേപ്പറിന്റെ ആദ്യ കുറച്ച് പേജുകൾ വായിക്കുക. ഇതുവരെ പഠിച്ചിട്ടുള്ള റെഗ്രഷൻ ടാസ്കുകളിൽ ഏത് ടാസ്കുകൾക്ക് ഏത് തരത്തിലുള്ള റെഗ്രഷൻ അനുയോജ്യമാണ് എന്ന് ചിന്തിക്കുക. ഏത് ഏറ്റവും നല്ലത്?
അസൂയാ:
ഈ രേഖ AI വിവർത്തന സേവനം Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.