Scikit-learn-ൽ വൈദഗ്ദ്ധ്യം നേടാം: മോഡൽ തിരഞ്ഞെടുക്കുന്നതിനുള്ള ശക്തമായ ക്രോസ്-വാലിഡേഷൻ തന്ത്രങ്ങളെക്കുറിച്ചുള്ള ഒരു ആഗോള ഗൈഡ്

മെഷീൻ ലേണിംഗിന്റെ വിശാലവും ചലനാത്മകവുമായ ലോകത്ത്, പ്രവചന മോഡലുകൾ നിർമ്മിക്കുന്നത് യുദ്ധത്തിന്റെ പകുതി മാത്രമാണ്. അത്രതന്നെ നിർണായകമായ മറ്റേ പകുതി, ഈ മോഡലുകൾ കാണാത്ത ഡാറ്റയിൽ വിശ്വസനീയമായി പ്രവർത്തിക്കുമെന്ന് ഉറപ്പാക്കാൻ അവയെ കർശനമായി വിലയിരുത്തുക എന്നതാണ്. ശരിയായ മൂല്യനിർണ്ണയം കൂടാതെ, ഏറ്റവും സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ പോലും തെറ്റിദ്ധാരണാജനകമായ നിഗമനങ്ങളിലേക്കും ഒപ്റ്റിമൽ അല്ലാത്ത തീരുമാനങ്ങളിലേക്കും നയിച്ചേക്കാം. ഈ വെല്ലുവിളി സാർവത്രികമാണ്, ഇത് എല്ലാ വ്യവസായങ്ങളിലും ഭൂപ്രദേശങ്ങളിലുമുള്ള ഡാറ്റാ സയന്റിസ്റ്റുകളെയും മെഷീൻ ലേണിംഗ് എഞ്ചിനീയർമാരെയും ബാധിക്കുന്നു.

ഈ സമഗ്രമായ ഗൈഡ് ശക്തമായ മോഡൽ മൂല്യനിർണ്ണയത്തിനും തിരഞ്ഞെടുപ്പിനുമുള്ള ഏറ്റവും അടിസ്ഥാനപരവും ശക്തവുമായ സാങ്കേതികവിദ്യകളിലൊന്നായ ക്രോസ്-വാലിഡേഷനെക്കുറിച്ച് ആഴത്തിൽ പ്രതിപാദിക്കുന്നു. ഇത് പൈത്തണിന്റെ ജനപ്രിയ ലൈബ്രറിയായ Scikit-learn-ൽ എങ്ങനെ നടപ്പിലാക്കാമെന്നും വിശദീകരിക്കുന്നു. നിങ്ങൾ ലണ്ടനിലെ ഒരു പരിചയസമ്പന്നനായ പ്രൊഫഷണലോ, ബാംഗ്ലൂരിലെ വളർന്നുവരുന്ന ഒരു ഡാറ്റാ അനലിസ്റ്റോ, അല്ലെങ്കിൽ സാവോ പോളോയിലെ ഒരു മെഷീൻ ലേണിംഗ് ഗവേഷകനോ ആകട്ടെ, വിശ്വസനീയവും ഫലപ്രദവുമായ മെഷീൻ ലേണിംഗ് സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നതിന് ഈ തന്ത്രങ്ങൾ മനസ്സിലാക്കുകയും പ്രയോഗിക്കുകയും ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്.

നമ്മൾ വിവിധ ക്രോസ്-വാലിഡേഷൻ ടെക്നിക്കുകൾ പര്യവേക്ഷണം ചെയ്യുകയും, അവയുടെ സൂക്ഷ്മതകൾ മനസ്സിലാക്കുകയും, വ്യക്തവും പ്രവർത്തിപ്പിക്കാവുന്നതുമായ പൈത്തൺ കോഡ് ഉപയോഗിച്ച് അവയുടെ പ്രായോഗിക പ്രയോഗം പ്രദർശിപ്പിക്കുകയും ചെയ്യും. നിങ്ങളുടെ പ്രത്യേക ഡാറ്റാസെറ്റിനും മോഡലിംഗ് വെല്ലുവിളിക്കും അനുയോജ്യമായ തന്ത്രം തിരഞ്ഞെടുക്കുന്നതിനുള്ള അറിവ് നിങ്ങളെ സജ്ജരാക്കുക എന്നതാണ് ഞങ്ങളുടെ ലക്ഷ്യം. ഇത് നിങ്ങളുടെ മോഡലുകൾ നന്നായി സാമാന്യവൽക്കരിക്കുകയും സ്ഥിരമായ പ്രകടനം നൽകുകയും ചെയ്യുമെന്ന് ഉറപ്പാക്കുന്നു.

ഓവർഫിറ്റിംഗിന്റെയും അണ്ടർഫിറ്റിംഗിന്റെയും അപകടം: എന്തുകൊണ്ട് ശക്തമായ മൂല്യനിർണ്ണയം പ്രധാനമാകുന്നു

ക്രോസ്-വാലിഡേഷനിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, മെഷീൻ ലേണിംഗിന്റെ ഇരട്ട ശത്രുക്കളായ ഓവർഫിറ്റിംഗും അണ്ടർഫിറ്റിംഗും മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.

• ഓവർഫിറ്റിംഗ്: ഒരു മോഡൽ ട്രെയിനിംഗ് ഡാറ്റയെ വളരെ നന്നായി പഠിക്കുകയും, പുതിയതും കാണാത്തതുമായ ഡാറ്റയിലേക്ക് സാമാന്യവൽക്കരിക്കാത്ത നോയിസും പ്രത്യേക പാറ്റേണുകളും പിടിച്ചെടുക്കുകയും ചെയ്യുമ്പോൾ ഇത് സംഭവിക്കുന്നു. ഓവർഫിറ്റ് ചെയ്ത ഒരു മോഡൽ ട്രെയിനിംഗ് സെറ്റിൽ അസാധാരണമായി മികച്ച പ്രകടനം കാഴ്ചവെക്കുമെങ്കിലും ടെസ്റ്റ് ഡാറ്റയിൽ മോശം പ്രകടനം കാഴ്ചവെക്കും. ഒരു പ്രത്യേക പരീക്ഷയ്ക്കായി ഉത്തരങ്ങൾ മനഃപാഠമാക്കുകയും അതേ വിഷയത്തിലെ അല്പം വ്യത്യസ്തമായ ചോദ്യങ്ങളിൽ ബുദ്ധിമുട്ടുകയും ചെയ്യുന്ന ഒരു വിദ്യാർത്ഥിയെ സങ്കൽപ്പിക്കുക.
• അണ്ടർഫിറ്റിംഗ്: ഇതിന് വിപരീതമായി, ട്രെയിനിംഗ് ഡാറ്റയിലെ അടിസ്ഥാന പാറ്റേണുകൾ പിടിച്ചെടുക്കാൻ ഒരു മോഡൽ വളരെ ലളിതമാകുമ്പോൾ അണ്ടർഫിറ്റിംഗ് സംഭവിക്കുന്നു. ഇത് ട്രെയിനിംഗ്, ടെസ്റ്റ് ഡാറ്റകളിലെല്ലാം മോശം പ്രകടനം കാഴ്ചവെക്കുന്നു. അടിസ്ഥാന ആശയങ്ങൾ മനസ്സിലാക്കാത്തതിനാൽ ലളിതമായ ചോദ്യങ്ങൾക്ക് പോലും ഉത്തരം നൽകാൻ കഴിയാത്ത ഒരു വിദ്യാർത്ഥിയെപ്പോലെയാണിത്.

പരമ്പരാഗത മോഡൽ മൂല്യനിർണ്ണയത്തിൽ പലപ്പോഴും ഒരു ലളിതമായ ട്രെയിൻ/ടെസ്റ്റ് സ്പ്ലിറ്റ് ഉൾപ്പെടുന്നു. ഇത് ഒരു നല്ല തുടക്കമാണെങ്കിലും, ഒരൊറ്റ സ്പ്ലിറ്റ് പ്രശ്നകരമാകാം:

• പ്രകടനം നിർദ്ദിഷ്ട റാൻഡം സ്പ്ലിറ്റിനെ വളരെയധികം ആശ്രയിച്ചിരിക്കും. ഒരു "ഭാഗ്യമുള്ള" സ്പ്ലിറ്റ് ഒരു മോശം മോഡലിനെ മികച്ചതായി തോന്നിപ്പിക്കാം, തിരിച്ചും സംഭവിക്കാം.
• ഡാറ്റാസെറ്റ് ചെറുതാണെങ്കിൽ, ഒരൊറ്റ സ്പ്ലിറ്റ് എന്നാൽ പരിശീലനത്തിന് കുറച്ച് ഡാറ്റയോ അല്ലെങ്കിൽ പരിശോധനയ്ക്ക് കുറച്ച് ഡാറ്റയോ എന്നാണ് അർത്ഥമാക്കുന്നത്, ഇവ രണ്ടും വിശ്വസനീയമല്ലാത്ത പ്രകടന എസ്റ്റിമേറ്റുകളിലേക്ക് നയിച്ചേക്കാം.
• ഇത് മോഡലിന്റെ പ്രകടനത്തിലെ വ്യതിയാനത്തെക്കുറിച്ച് സ്ഥിരമായ ഒരു എസ്റ്റിമേറ്റ് നൽകുന്നില്ല.

മോഡൽ പ്രകടനം കണക്കാക്കുന്നതിനുള്ള കൂടുതൽ ശക്തവും സ്ഥിതിവിവരക്കണക്കനുസരിച്ച് ശരിയായതുമായ ഒരു രീതി വാഗ്ദാനം ചെയ്തുകൊണ്ട് ക്രോസ്-വാലിഡേഷൻ ഇവിടെ രക്ഷയ്‌ക്കെത്തുന്നു.

എന്താണ് ക്രോസ്-വാലിഡേഷൻ? അടിസ്ഥാന ആശയം

അടിസ്ഥാനപരമായി, ഒരു പരിമിതമായ ഡാറ്റാ സാമ്പിളിൽ മെഷീൻ ലേണിംഗ് മോഡലുകളെ വിലയിരുത്താൻ ഉപയോഗിക്കുന്ന ഒരു റീസാമ്പിളിംഗ് നടപടിക്രമമാണ് ക്രോസ്-വാലിഡേഷൻ. ഈ പ്രക്രിയയിൽ ഡാറ്റാസെറ്റിനെ പരസ്പരം പൂരകങ്ങളായ ഉപവിഭാഗങ്ങളായി വിഭജിക്കുകയും, ഒരു ഉപവിഭാഗത്തിൽ (ട്രെയിനിംഗ് സെറ്റ്) വിശകലനം നടത്തുകയും മറ്റേ ഉപവിഭാഗത്തിൽ (ടെസ്റ്റിംഗ് സെറ്റ്) വിശകലനം സാധൂകരിക്കുകയും ചെയ്യുന്നു. ഈ പ്രക്രിയ പലതവണ ആവർത്തിക്കുന്നു, ഉപവിഭാഗങ്ങളുടെ റോളുകൾ പരസ്പരം മാറ്റുകയും, തുടർന്ന് ഫലങ്ങൾ സംയോജിപ്പിച്ച് മോഡൽ പ്രകടനത്തിന്റെ കൂടുതൽ വിശ്വസനീയമായ ഒരു എസ്റ്റിമേറ്റ് ഉണ്ടാക്കുകയും ചെയ്യുന്നു.

ക്രോസ്-വാലിഡേഷന്റെ പ്രധാന നേട്ടങ്ങൾ ഇവയാണ്:

• കൂടുതൽ വിശ്വസനീയമായ പ്രകടന എസ്റ്റിമേറ്റുകൾ: ഒന്നിലധികം ട്രെയിൻ-ടെസ്റ്റ് സ്പ്ലിറ്റുകളിലെ ഫലങ്ങളുടെ ശരാശരി എടുക്കുന്നതിലൂടെ, ഇത് പ്രകടന എസ്റ്റിമേറ്റിന്റെ വേരിയൻസ് കുറയ്ക്കുകയും, മോഡൽ എങ്ങനെ സാമാന്യവൽക്കരിക്കുമെന്നതിന്റെ കൂടുതൽ സ്ഥിരതയുള്ളതും കൃത്യവുമായ അളവ് നൽകുകയും ചെയ്യുന്നു.
• ഡാറ്റയുടെ മികച്ച ഉപയോഗം: എല്ലാ ഡാറ്റാ പോയിന്റുകളും ഒടുവിൽ വിവിധ ഫോൾഡുകളിലായി പരിശീലനത്തിനും പരിശോധനയ്ക്കും ഉപയോഗിക്കപ്പെടുന്നു, ഇത് പരിമിതമായ ഡാറ്റാസെറ്റുകളെ കാര്യക്ഷമമായി ഉപയോഗിക്കാൻ സഹായിക്കുന്നു.
• ഓവർഫിറ്റിംഗ്/അണ്ടർഫിറ്റിംഗ് കണ്ടെത്തൽ: എല്ലാ ഫോൾഡുകളിലും സ്ഥിരമായി മോശം പ്രകടനം അണ്ടർഫിറ്റിംഗിനെ സൂചിപ്പിക്കാം, അതേസമയം മികച്ച പരിശീലന പ്രകടനവും എന്നാൽ ഫോൾഡുകളിലുടനീളം മോശം ടെസ്റ്റ് പ്രകടനവും ഓവർഫിറ്റിംഗിനെ ചൂണ്ടിക്കാണിക്കുന്നു.

Scikit-learn-ന്റെ ക്രോസ്-വാലിഡേഷൻ ടൂൾകിറ്റ്

പൈത്തണിലെ മെഷീൻ ലേണിംഗിന്റെ ഒരു അടിസ്ഥാന ലൈബ്രറിയായ Scikit-learn, അതിന്റെ model_selection മൊഡ്യൂളിനുള്ളിൽ വിവിധ ക്രോസ്-വാലിഡേഷൻ തന്ത്രങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള വിപുലമായ ടൂളുകൾ നൽകുന്നു. നമുക്ക് ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ഫംഗ്ഷനുകളിൽ നിന്ന് ആരംഭിക്കാം.

cross_val_score: മോഡൽ പ്രകടനത്തിന്റെ ഒരു ദ്രുത അവലോകനം

Scikit-learn-ൽ ക്രോസ്-വാലിഡേഷൻ നടത്താനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗമാണ് cross_val_score ഫംഗ്ഷൻ. ഇത് ക്രോസ്-വാലിഡേഷനിലൂടെ ഒരു സ്കോർ വിലയിരുത്തുന്നു, ഓരോ ഫോൾഡിനും ഒന്നെന്ന നിലയിൽ സ്കോറുകളുടെ ഒരു അറേ നൽകുന്നു.

പ്രധാന പാരാമീറ്ററുകൾ:

• estimator: മെഷീൻ ലേണിംഗ് മോഡൽ ഒബ്ജക്റ്റ് (ഉദാ: LogisticRegression()).
• X: ഫീച്ചറുകൾ (ട്രെയിനിംഗ് ഡാറ്റ).
• y: ടാർഗെറ്റ് വേരിയബിൾ.
• cv: ക്രോസ്-വാലിഡേഷൻ സ്പ്ലിറ്റിംഗ് തന്ത്രം നിർണ്ണയിക്കുന്നു. ഒരു പൂർണ്ണസംഖ്യ (ഫോൾഡുകളുടെ എണ്ണം), ഒരു സിവി സ്പ്ലിറ്റർ ഒബ്ജക്റ്റ് (ഉദാ: KFold()), അല്ലെങ്കിൽ ഒരു ഐറ്ററബിൾ ആകാം.
• scoring: ടെസ്റ്റ് സെറ്റിലെ പ്രവചനങ്ങൾ വിലയിരുത്തുന്നതിനുള്ള ഒരു സ്ട്രിംഗ് (ഉദാ: 'accuracy', 'f1', 'roc_auc') അല്ലെങ്കിൽ ഒരു കോളബിൾ.

            
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# Load a sample dataset
iris = load_iris()
X, y = iris.data, iris.target

# Initialize a model
model = LogisticRegression(max_iter=200)

# Perform 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

print(f"Cross-validation scores: {scores}")
print(f"Mean accuracy: {scores.mean():.4f}")
print(f"Standard deviation of accuracy: {scores.std():.4f}")

            

              
                Copy
              
            
          

ഈ ഔട്ട്പുട്ട് ഓരോ ഫോൾഡിനും ഒന്നെന്ന നിലയിൽ കൃത്യത സ്കോറുകളുടെ ഒരു അറേ നൽകുന്നു. ശരാശരിയും സ്റ്റാൻഡേർഡ് ഡീവിയേഷനും നിങ്ങൾക്ക് മോഡലിന്റെ പ്രകടനത്തിന്റെ ഒരു കേന്ദ്ര പ്രവണതയും വ്യതിയാനവും നൽകുന്നു.

cross_validate: കൂടുതൽ വിശദമായ മെട്രിക്കുകൾ

cross_val_score ഒരു മെട്രിക് മാത്രം നൽകുമ്പോൾ, cross_validate കൂടുതൽ വിശദമായ നിയന്ത്രണം നൽകുകയും ഓരോ ഫോൾഡിനുമുള്ള പരിശീലന സ്കോറുകൾ, ഫിറ്റ് ടൈംസ്, സ്കോർ ടൈംസ് എന്നിവയുൾപ്പെടെയുള്ള മെട്രിക്കുകളുടെ ഒരു ഡിക്ഷണറി നൽകുകയും ചെയ്യുന്നു. നിങ്ങൾക്ക് ഒന്നിലധികം മൂല്യനിർണ്ണയ മെട്രിക്കുകളോ പ്രകടന സമയങ്ങളോ ട്രാക്ക് ചെയ്യേണ്ടിവരുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

            
from sklearn.model_selection import cross_validate
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

iris = load_iris()
X, y = iris.data, iris.target

model = LogisticRegression(max_iter=200)

# Perform 5-fold cross-validation with multiple scoring metrics
scoring = ['accuracy', 'precision_macro', 'recall_macro', 'f1_macro']
results = cross_validate(model, X, y, cv=5, scoring=scoring, return_train_score=True)

print("Cross-validation results:")
for metric_name, values in results.items():
    print(f"  {metric_name}: {values}")
    print(f"  Mean {metric_name}: {values.mean():.4f}")
    print(f"  Std {metric_name}: {values.std():.4f}")

            

              
                Copy
              
            
          

ഓവർഫിറ്റിംഗ് കണ്ടെത്താൻ return_train_score=True എന്ന പാരാമീറ്റർ നിർണായകമാണ്: train_score എന്നത് test_score-നേക്കാൾ വളരെ കൂടുതലാണെങ്കിൽ, നിങ്ങളുടെ മോഡൽ ഓവർഫിറ്റിംഗ് ആകാൻ സാധ്യതയുണ്ട്.

Scikit-learn-ലെ പ്രധാന ക്രോസ്-വാലിഡേഷൻ തന്ത്രങ്ങൾ

Scikit-learn നിരവധി പ്രത്യേക ക്രോസ്-വാലിഡേഷൻ ഐറ്ററേറ്ററുകൾ വാഗ്ദാനം ചെയ്യുന്നു, ഓരോന്നും വ്യത്യസ്ത ഡാറ്റാ സവിശേഷതകൾക്കും മോഡലിംഗ് സാഹചര്യങ്ങൾക്കും അനുയോജ്യമാണ്. അർത്ഥവത്തായതും പക്ഷപാതരഹിതവുമായ പ്രകടന എസ്റ്റിമേറ്റുകൾ ലഭിക്കുന്നതിന് ശരിയായ തന്ത്രം തിരഞ്ഞെടുക്കുന്നത് നിർണായകമാണ്.

1. കെ-ഫോൾഡ് ക്രോസ്-വാലിഡേഷൻ

വിവരണം: കെ-ഫോൾഡ് ഏറ്റവും സാധാരണമായ ക്രോസ്-വാലിഡേഷൻ തന്ത്രമാണ്. ഡാറ്റാസെറ്റിനെ k തുല്യ വലുപ്പമുള്ള ഫോൾഡുകളായി വിഭജിക്കുന്നു. ഓരോ ആവർത്തനത്തിലും, ഒരു ഫോൾഡ് ടെസ്റ്റ് സെറ്റായും ശേഷിക്കുന്ന k-1 ഫോൾഡുകൾ ട്രെയിനിംഗ് സെറ്റായും ഉപയോഗിക്കുന്നു. ഈ പ്രക്രിയ k തവണ ആവർത്തിക്കുന്നു, ഓരോ ഫോൾഡും കൃത്യമായി ഒരു തവണ ടെസ്റ്റ് സെറ്റായി പ്രവർത്തിക്കുന്നു.

എപ്പോൾ ഉപയോഗിക്കണം: ഡാറ്റാ പോയിന്റുകൾ സ്വതന്ത്രവും സമാനമായി വിതരണം ചെയ്യപ്പെട്ടതുമായ (i.i.d.) നിരവധി സാധാരണ ക്ലാസിഫിക്കേഷൻ, റിഗ്രഷൻ ജോലികൾക്ക് അനുയോജ്യമായ ഒരു പൊതു-ഉദ്ദേശ്യ തിരഞ്ഞെടുപ്പാണിത്.

പരിഗണനകൾ:

• സാധാരണയായി, k 5 അല്ലെങ്കിൽ 10 ആയി സജ്ജീകരിക്കുന്നു. ഉയർന്ന k പക്ഷപാതം കുറഞ്ഞതും എന്നാൽ കമ്പ്യൂട്ടേഷണൽ ആയി ചെലവേറിയതുമായ എസ്റ്റിമേറ്റുകളിലേക്ക് നയിക്കുന്നു.
• അസന്തുലിതമായ ഡാറ്റാസെറ്റുകൾക്ക് ഇത് പ്രശ്‌നകരമാകാം, കാരണം ചില ഫോൾഡുകളിൽ ഒരു ന്യൂനപക്ഷ ക്ലാസിലെ സാമ്പിളുകൾ വളരെ കുറവോ ഇല്ലാതെയോ വരാം.

            
from sklearn.model_selection import KFold
import numpy as np

X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([0, 1, 0, 1, 0, 1])

kf = KFold(n_splits=3, shuffle=True, random_state=42)

print("K-Fold Cross-validation splits:")
for i, (train_index, test_index) in enumerate(kf.split(X)):
    print(f"  Fold {i+1}:")
    print(f"    TRAIN: {train_index}, TEST: {test_index}")
    print(f"    Train data X: {X[train_index]}, y: {y[train_index]}")
    print(f"    Test data X: {X[test_index]}, y: {y[test_index]}")

            

              
                Copy
              
            
          

വിഭജിക്കുന്നതിന് മുമ്പ് ഡാറ്റയെ ക്രമരഹിതമാക്കാൻ shuffle=True എന്ന പാരാമീറ്റർ പ്രധാനമാണ്, പ്രത്യേകിച്ചും നിങ്ങളുടെ ഡാറ്റയ്ക്ക് ഒരു സഹജമായ ക്രമമുണ്ടെങ്കിൽ. random_state ഷഫ്ളിംഗിന്റെ പുനരുൽപാദനക്ഷമത ഉറപ്പാക്കുന്നു.

2. സ്ട്രാറ്റിഫൈഡ് കെ-ഫോൾഡ് ക്രോസ്-വാലിഡേഷൻ

വിവരണം: ഇത് ക്ലാസിഫിക്കേഷൻ ജോലികൾക്കായി, പ്രത്യേകിച്ച് അസന്തുലിതമായ ഡാറ്റാസെറ്റുകൾക്കായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത കെ-ഫോൾഡിന്റെ ഒരു വകഭേദമാണ്. ഓരോ ഫോൾഡിലും ഓരോ ടാർഗെറ്റ് ക്ലാസിലെയും സാമ്പിളുകളുടെ ശതമാനം പൂർണ്ണമായ സെറ്റിലുള്ളതിന് ഏകദേശം തുല്യമാണെന്ന് ഇത് ഉറപ്പാക്കുന്നു. ഇത് ഫോൾഡുകൾ ന്യൂനപക്ഷ ക്ലാസ് സാമ്പിളുകൾ പൂർണ്ണമായും ഇല്ലാത്ത അവസ്ഥ ഒഴിവാക്കുന്നു, അത് മോശം മോഡൽ പരിശീലനത്തിനോ പരിശോധനയ്ക്കോ കാരണമായേക്കാം.

എപ്പോൾ ഉപയോഗിക്കണം: ക്ലാസിഫിക്കേഷൻ പ്രശ്നങ്ങൾക്ക് അത്യാവശ്യമാണ്, പ്രത്യേകിച്ചും മെഡിക്കൽ ഡയഗ്നോസ്റ്റിക്സ് (ഉദാഹരണത്തിന്, അപൂർവ രോഗ നിർണ്ണയം), തട്ടിപ്പ് കണ്ടെത്തൽ, അല്ലെങ്കിൽ അനോമലി കണ്ടെത്തൽ എന്നിവയിൽ സാധാരണമായ അസന്തുലിതമായ ക്ലാസ് വിതരണങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ.

            
from sklearn.model_selection import StratifiedKFold

X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [5,6], [7,8], [9,10], [11,12]])
y_imbalanced = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1]) # 60% class 0, 40% class 1

skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)

print("Stratified K-Fold Cross-validation splits:")
for i, (train_index, test_index) in enumerate(skf.split(X, y_imbalanced)):
    print(f"  Fold {i+1}:")
    print(f"    TRAIN: {train_index}, TEST: {test_index}")
    print(f"    Train y distribution: {np.bincount(y_imbalanced[train_index])}")
    print(f"    Test y distribution: {np.bincount(y_imbalanced[test_index])}")

            

              
                Copy
              
            
          

np.bincount എങ്ങനെയാണ് ഓരോ ഫോൾഡിലെയും പരിശീലന, ടെസ്റ്റിംഗ് സെറ്റുകൾ ക്ലാസുകളുടെ സമാനമായ അനുപാതം നിലനിർത്തുന്നതെന്ന് കാണിക്കുന്നത് ശ്രദ്ധിക്കുക (ഉദാഹരണത്തിന്, 60/40 സ്പ്ലിറ്റ് അല്ലെങ്കിൽ n_splits കണക്കിലെടുത്ത് സാധ്യമായത്ര അടുത്ത്).

3. ലീവ്-വൺ-ഔട്ട് ക്രോസ്-വാലിഡേഷൻ (LOOCV)

വിവരണം: LOOCV എന്നത് കെ-ഫോൾഡിന്റെ ഒരു തീവ്രമായ രൂപമാണ്, ഇവിടെ k എന്നത് സാമ്പിളുകളുടെ എണ്ണത്തിന് (n) തുല്യമാണ്. ഓരോ ഫോൾഡിനും, ഒരു സാമ്പിൾ ടെസ്റ്റ് സെറ്റായും ശേഷിക്കുന്ന n-1 സാമ്പിളുകൾ പരിശീലനത്തിനായും ഉപയോഗിക്കുന്നു. ഇതിനർത്ഥം മോഡൽ n തവണ പരിശീലിക്കുകയും വിലയിരുത്തുകയും ചെയ്യുന്നു എന്നാണ്.

എപ്പോൾ ഉപയോഗിക്കണം:

• ഓരോ ആവർത്തനത്തിലും പരിശീലന ഡാറ്റ പരമാവധിയാക്കേണ്ടത് നിർണായകമായ വളരെ ചെറിയ ഡാറ്റാസെറ്റുകൾക്ക് അനുയോജ്യം.
• മോഡൽ പ്രകടനത്തിന്റെ പക്ഷപാതരഹിതമായ ഒരു എസ്റ്റിമേറ്റ് നൽകുന്നു.

പരിഗണനകൾ:

• വലിയ ഡാറ്റാസെറ്റുകൾക്ക് ഇത് വളരെ കമ്പ്യൂട്ടേഷണൽ ആയി ചെലവേറിയതാണ്, കാരണം ഇതിന് മോഡലിനെ n തവണ പരിശീലിക്കേണ്ടതുണ്ട്.
• ടെസ്റ്റ് സെറ്റ് വളരെ ചെറുതായതിനാൽ ആവർത്തനങ്ങളിലുടനീളം പ്രകടന എസ്റ്റിമേറ്റുകളിൽ ഉയർന്ന വേരിയൻസ് ഉണ്ട്.

            
from sklearn.model_selection import LeaveOneOut

X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
y = np.array([0, 1, 0, 1])

loo = LeaveOneOut()

print("Leave-One-Out Cross-validation splits:")
for i, (train_index, test_index) in enumerate(loo.split(X)):
    print(f"  Iteration {i+1}: TRAIN: {train_index}, TEST: {test_index}")

            

              
                Copy
              
            
          

4. ഷഫിൾസ്പ്ലിറ്റും സ്ട്രാറ്റിഫൈഡ്ഷഫിൾസ്പ്ലിറ്റും

വിവരണം: ഓരോ സാമ്പിളും ടെസ്റ്റ് സെറ്റിൽ കൃത്യമായി ഒരു തവണ ദൃശ്യമാകുമെന്ന് ഉറപ്പുനൽകുന്ന കെ-ഫോൾഡിൽ നിന്ന് വ്യത്യസ്തമായി, ഷഫിൾസ്പ്ലിറ്റ് n_splits റാൻഡം ട്രെയിൻ/ടെസ്റ്റ് സ്പ്ലിറ്റുകൾ ഉണ്ടാക്കുന്നു. ഓരോ സ്പ്ലിറ്റിനും, ഡാറ്റയുടെ ഒരു അനുപാതം പരിശീലനത്തിനായി ക്രമരഹിതമായി തിരഞ്ഞെടുക്കുന്നു, മറ്റൊരു (ഡിസ്ജോയിന്റ്) അനുപാതം പരിശോധനയ്ക്കായി തിരഞ്ഞെടുക്കുന്നു. ഇത് ആവർത്തിച്ചുള്ള റാൻഡം സബ്സാമ്പിളിംഗിന് അനുവദിക്കുന്നു.

എപ്പോൾ ഉപയോഗിക്കണം:

• കെ-ഫോൾഡിലെ ഫോൾഡുകളുടെ എണ്ണം (k) പരിമിതമാണെങ്കിലും നിങ്ങൾക്ക് ഇപ്പോഴും ഒന്നിലധികം സ്വതന്ത്ര സ്പ്ലിറ്റുകൾ ആവശ്യമുള്ളപ്പോൾ.
• കെ-ഫോൾഡ് കമ്പ്യൂട്ടേഷണൽ ആയി തീവ്രമാകാൻ സാധ്യതയുള്ള വലിയ ഡാറ്റാസെറ്റുകൾക്ക്, അല്ലെങ്കിൽ ടെസ്റ്റ് സെറ്റ് വലുപ്പത്തിൽ 1/k എന്നതിനപ്പുറം കൂടുതൽ നിയന്ത്രണം ആവശ്യമുള്ളപ്പോൾ ഉപയോഗപ്രദമാണ്.
• StratifiedShuffleSplit അസന്തുലിതമായ ഡാറ്റയുള്ള ക്ലാസിഫിക്കേഷന് മുൻഗണന നൽകുന്ന തിരഞ്ഞെടുപ്പാണ്, കാരണം ഇത് ഓരോ സ്പ്ലിറ്റിലും ക്ലാസ് വിതരണം സംരക്ഷിക്കുന്നു.

പരിഗണനകൾ: എല്ലാ സാമ്പിളുകളും ടെസ്റ്റ് സെറ്റിലോ, ട്രെയിനിംഗ് സെറ്റിലോ, കുറഞ്ഞത് ഒരു സ്പ്ലിറ്റിലെങ്കിലും ഉണ്ടാകുമെന്ന് ഉറപ്പില്ല, എന്നിരുന്നാലും ധാരാളം സ്പ്ലിറ്റുകൾക്ക് ഇതിന് സാധ്യത കുറവാണ്.

            
from sklearn.model_selection import ShuffleSplit, StratifiedShuffleSplit

X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [5,6], [7,8], [9,10], [11,12]])
y = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) # Imbalanced data for StratifiedShuffleSplit

# ShuffleSplit example
ss = ShuffleSplit(n_splits=5, test_size=0.3, random_state=42)
print("ShuffleSplit Cross-validation splits:")
for i, (train_index, test_index) in enumerate(ss.split(X)):
    print(f"  Split {i+1}: TRAIN: {train_index}, TEST: {test_index}")

# StratifiedShuffleSplit example
sss = StratifiedShuffleSplit(n_splits=5, test_size=0.3, random_state=42)
print("\nStratifiedShuffleSplit Cross-validation splits (y distribution maintained):")
for i, (train_index, test_index) in enumerate(sss.split(X, y)):
    print(f"  Split {i+1}:")
    print(f"    TRAIN: {train_index}, TEST: {test_index}")
    print(f"    Train y distribution: {np.bincount(y[train_index])}")
    print(f"    Test y distribution: {np.bincount(y[test_index])}")

            

              
                Copy
              
            
          

5. ടൈം സീരീസ് ക്രോസ്-വാലിഡേഷൻ (TimeSeriesSplit)

വിവരണം: സാധാരണ ക്രോസ്-വാലിഡേഷൻ രീതികൾ ഡാറ്റാ പോയിന്റുകൾ സ്വതന്ത്രമാണെന്ന് അനുമാനിക്കുന്നു. എന്നിരുന്നാലും, ടൈം സീരീസ് ഡാറ്റയിൽ, നിരീക്ഷണങ്ങൾ ക്രമീകരിച്ചിരിക്കുന്നു, പലപ്പോഴും താൽക്കാലിക ആശ്രിതത്വങ്ങൾ പ്രകടിപ്പിക്കുന്നു. ടൈം സീരീസ് ഡാറ്റയെ ഷഫിൾ ചെയ്യുകയോ റാൻഡം ആയി വിഭജിക്കുകയോ ചെയ്യുന്നത് ഡാറ്റാ ലീക്കേജിലേക്ക് നയിക്കും, അവിടെ മോഡൽ ഭൂതകാലത്തെ പ്രവചിക്കാൻ ഭാവിയിലെ ഡാറ്റയിൽ പരിശീലിക്കുന്നു, ഇത് അമിതമായി ശുഭാപ്തിവിശ്വാസവും യാഥാർത്ഥ്യമല്ലാത്തതുമായ പ്രകടന എസ്റ്റിമേറ്റിലേക്ക് നയിക്കുന്നു.

ടെസ്റ്റ് സെറ്റ് എല്ലായ്പ്പോഴും ട്രെയിനിംഗ് സെറ്റിന് ശേഷം വരുന്ന ട്രെയിൻ/ടെസ്റ്റ് സ്പ്ലിറ്റുകൾ നൽകിക്കൊണ്ട് TimeSeriesSplit ഈ പ്രശ്നം പരിഹരിക്കുന്നു. ഡാറ്റയെ ഒരു ട്രെയിനിംഗ് സെറ്റായും തുടർന്നുള്ള ഒരു ടെസ്റ്റ് സെറ്റായും വിഭജിക്കുകയും, തുടർന്ന് ട്രെയിനിംഗ് സെറ്റിനെ ക്രമേണ വികസിപ്പിക്കുകയും ടെസ്റ്റ് സെറ്റിനെ സമയത്തിനനുസരിച്ച് മുന്നോട്ട് നീക്കുകയും ചെയ്തുകൊണ്ടാണ് ഇത് പ്രവർത്തിക്കുന്നത്.

എപ്പോൾ ഉപയോഗിക്കണം: ടൈം സീരീസ് ഫോർകാസ്റ്റിംഗിനോ അല്ലെങ്കിൽ നിരീക്ഷണങ്ങളുടെ താൽക്കാലിക ക്രമം സംരക്ഷിക്കേണ്ട ഏതെങ്കിലും സീക്വൻഷ്യൽ ഡാറ്റയ്‌ക്കോ വേണ്ടി മാത്രം.

പരിഗണനകൾ: ഓരോ സ്പ്ലിറ്റിലും ട്രെയിനിംഗ് സെറ്റുകൾ വലുതായിക്കൊണ്ടിരിക്കുന്നു, ഇത് പ്രകടനത്തിൽ വ്യത്യാസങ്ങൾ ഉണ്ടാക്കാൻ സാധ്യതയുണ്ട്, കൂടാതെ പ്രാരംഭ ട്രെയിനിംഗ് സെറ്റുകൾ വളരെ ചെറുതുമായിരിക്കാം.

            
from sklearn.model_selection import TimeSeriesSplit
import pandas as pd

# Simulate time series data
dates = pd.to_datetime(pd.date_range(start='2023-01-01', periods=100, freq='D'))
X_ts = np.arange(100).reshape(-1, 1)
y_ts = np.sin(np.arange(100) / 10) + np.random.randn(100) * 0.1 # Some time-dependent target

tscv = TimeSeriesSplit(n_splits=5)

print("Time Series Cross-validation splits:")
for i, (train_index, test_index) in enumerate(tscv.split(X_ts)):
    print(f"  Fold {i+1}:")
    print(f"    TRAIN indices: {train_index[0]} to {train_index[-1]}")
    print(f"    TEST indices: {test_index[0]} to {test_index[-1]}")
    # Verify that test_index always starts after train_index ends
    assert train_index[-1] < test_index[0]

            

              
                Copy
              
            
          

ഈ രീതി നിങ്ങളുടെ മോഡൽ എപ്പോഴും പരിശീലനം ലഭിച്ച ഡാറ്റയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഭാവിയിലെ ഡാറ്റയിൽ വിലയിരുത്തപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് സമയത്തെ ആശ്രയിച്ചുള്ള പ്രശ്നങ്ങൾക്കുള്ള യഥാർത്ഥ ലോക വിന്യാസ സാഹചര്യങ്ങളെ അനുകരിക്കുന്നു.

6. ഗ്രൂപ്പ് ക്രോസ്-വാലിഡേഷൻ (GroupKFold, LeaveOneGroupOut)

വിവരണം: ചില ഡാറ്റാസെറ്റുകളിൽ, സാമ്പിളുകൾ പൂർണ്ണമായും സ്വതന്ത്രമല്ല; അവ പ്രത്യേക ഗ്രൂപ്പുകളിൽപ്പെട്ടേക്കാം. ഉദാഹരണത്തിന്, ഒരേ രോഗിയുടെ ഒന്നിലധികം മെഡിക്കൽ അളവുകൾ, ഒരേ സെൻസറിൽ നിന്നുള്ള ഒന്നിലധികം നിരീക്ഷണങ്ങൾ, അല്ലെങ്കിൽ ഒരേ ഉപഭോക്താവിൽ നിന്നുള്ള ഒന്നിലധികം സാമ്പത്തിക ഇടപാടുകൾ. ഈ ഗ്രൂപ്പുകളെ ട്രെയിനിംഗ്, ടെസ്റ്റ് സെറ്റുകളിലായി വിഭജിച്ചാൽ, മോഡൽ ഗ്രൂപ്പ്-നിർദ്ദിഷ്ട പാറ്റേണുകൾ പഠിക്കുകയും പുതിയ, കാണാത്ത ഗ്രൂപ്പുകളിലേക്ക് സാമാന്യവൽക്കരിക്കുന്നതിൽ പരാജയപ്പെടുകയും ചെയ്യാം. ഇത് ഡാറ്റാ ലീക്കേജിന്റെ ഒരു രൂപമാണ്.

ഒരു ഗ്രൂപ്പിൽ നിന്നുള്ള എല്ലാ ഡാറ്റാ പോയിന്റുകളും ഒന്നുകിൽ പൂർണ്ണമായും ട്രെയിനിംഗ് സെറ്റിലോ അല്ലെങ്കിൽ പൂർണ്ണമായും ടെസ്റ്റ് സെറ്റിലോ ദൃശ്യമാകുന്നുവെന്നും, രണ്ടും ഒരുമിച്ചില്ലെന്നും ഗ്രൂപ്പ് ക്രോസ്-വാലിഡേഷൻ തന്ത്രങ്ങൾ ഉറപ്പാക്കുന്നു.

എപ്പോൾ ഉപയോഗിക്കണം: ഫോൾഡുകളായി വിഭജിച്ചാൽ പക്ഷപാതം ഉണ്ടാക്കാൻ സാധ്യതയുള്ള സഹജമായ ഗ്രൂപ്പുകൾ നിങ്ങളുടെ ഡാറ്റയിലുള്ളപ്പോഴെല്ലാം, ഉദാഹരണത്തിന് ദീർഘകാല പഠനങ്ങൾ, ഒന്നിലധികം ഉപകരണങ്ങളിൽ നിന്നുള്ള സെൻസർ ഡാറ്റ, അല്ലെങ്കിൽ ഉപഭോക്തൃ-നിർദ്ദിഷ്ട സ്വഭാവ മോഡലിംഗ്.

പരിഗണനകൾ: ഓരോ സാമ്പിളിന്റെയും ഗ്രൂപ്പ് ഐഡന്റിറ്റി വ്യക്തമാക്കുന്ന ഒരു 'groups' അറേ .split() രീതിയിലേക്ക് നൽകേണ്ടതുണ്ട്.

            
from sklearn.model_selection import GroupKFold

X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16]])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1])
# Two groups: samples 0-3 belong to Group A, samples 4-7 belong to Group B
groups = np.array(['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B'])

gkf = GroupKFold(n_splits=2) # We'll use 2 splits to clearly separate groups

print("Group K-Fold Cross-validation splits:")
for i, (train_index, test_index) in enumerate(gkf.split(X, y, groups)):
    print(f"  Fold {i+1}:")
    print(f"    TRAIN indices: {train_index}, GROUPS: {groups[train_index]}")
    print(f"    TEST indices: {test_index}, GROUPS: {groups[test_index]}")
    # Verify that no group appears in both train and test sets for a single fold
    assert len(set(groups[train_index]).intersection(set(groups[test_index]))) == 0

            

              
                Copy
              
            
          

മറ്റ് ഗ്രൂപ്പ്-അധിഷ്ഠിത തന്ത്രങ്ങളിൽ LeaveOneGroupOut (ഓരോ അദ്വിതീയ ഗ്രൂപ്പും ഒരു തവണ ടെസ്റ്റ് സെറ്റ് രൂപീകരിക്കുന്നു), LeavePGroupsOut (ടെസ്റ്റ് സെറ്റിനായി P ഗ്രൂപ്പുകളെ ഒഴിവാക്കുക) എന്നിവ ഉൾപ്പെടുന്നു.

ക്രോസ്-വാലിഡേഷനോടൊപ്പം നൂതന മോഡൽ തിരഞ്ഞെടുക്കൽ

ക്രോസ്-വാലിഡേഷൻ ഒരൊറ്റ മോഡലിനെ വിലയിരുത്താൻ മാത്രമല്ല; മികച്ച മോഡൽ തിരഞ്ഞെടുക്കുന്നതിനും അതിന്റെ ഹൈപ്പർപാരാമീറ്ററുകൾ ട്യൂൺ ചെയ്യുന്നതിനും ഇത് അവിഭാജ്യ ഘടകമാണ്.

GridSearchCV, RandomizedSearchCV എന്നിവ ഉപയോഗിച്ച് ഹൈപ്പർപാരാമീറ്റർ ട്യൂണിംഗ്

മെഷീൻ ലേണിംഗ് മോഡലുകൾക്ക് പലപ്പോഴും ഡാറ്റയിൽ നിന്ന് പഠിക്കാത്തതും എന്നാൽ പരിശീലനത്തിന് മുമ്പായി സജ്ജീകരിക്കേണ്ടതുമായ ഹൈപ്പർപാരാമീറ്ററുകൾ ഉണ്ട്. ഈ ഹൈപ്പർപാരാമീറ്ററുകളുടെ ഒപ്റ്റിമൽ മൂല്യങ്ങൾ സാധാരണയായി ഡാറ്റാസെറ്റിനെ ആശ്രയിച്ചിരിക്കും. Scikit-learn-ന്റെ GridSearchCV, RandomizedSearchCV എന്നിവ ഹൈപ്പർപാരാമീറ്ററുകളുടെ മികച്ച സംയോജനം വ്യവസ്ഥാപിതമായി കണ്ടെത്തുന്നതിന് ക്രോസ്-വാലിഡേഷൻ പ്രയോജനപ്പെടുത്തുന്നു.

• GridSearchCV: ഒരു നിശ്ചിത പാരാമീറ്റർ ഗ്രിഡിലൂടെ സമഗ്രമായി തിരയുന്നു, സാധ്യമായ എല്ലാ കോമ്പിനേഷനുകളും ക്രോസ്-വാലിഡേഷൻ ഉപയോഗിച്ച് വിലയിരുത്തുന്നു. ഗ്രിഡിനുള്ളിലെ മികച്ച കോമ്പിനേഷൻ കണ്ടെത്തുമെന്ന് ഇത് ഉറപ്പുനൽകുന്നു, എന്നാൽ വലിയ ഗ്രിഡുകൾക്ക് കമ്പ്യൂട്ടേഷണൽ ആയി ചെലവേറിയതാകാം.
• RandomizedSearchCV: നിർദ്ദിഷ്ട വിതരണങ്ങളിൽ നിന്ന് നിശ്ചിത എണ്ണം പാരാമീറ്റർ ക്രമീകരണങ്ങൾ സാമ്പിൾ ചെയ്യുന്നു. വലിയ സെർച്ച് സ്പേസുകൾക്ക് ഇത് GridSearchCV-നേക്കാൾ കാര്യക്ഷമമാണ്, കാരണം ഇത് എല്ലാ കോമ്പിനേഷനുകളും പരീക്ഷിക്കുന്നില്ല, പലപ്പോഴും കുറഞ്ഞ സമയത്തിനുള്ളിൽ ഒരു നല്ല പരിഹാരം കണ്ടെത്തുന്നു.

            
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_breast_cancer

# Load a sample dataset
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

# Define the model and parameter grid
model = SVC()
param_grid = {
    'C': [0.1, 1, 10],
    'kernel': ['linear', 'rbf']
}

# Perform GridSearchCV with 5-fold cross-validation
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid_search.fit(X, y)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best cross-validation accuracy: {grid_search.best_score_:.4f}")

            

              
                Copy
              
            
          

GridSearchCV, RandomizedSearchCV എന്നിവ രണ്ടും ഒരു cv പാരാമീറ്റർ സ്വീകരിക്കുന്നു, ഇത് നേരത്തെ ചർച്ച ചെയ്ത ഏതെങ്കിലും ക്രോസ്-വാലിഡേഷൻ ഐറ്ററേറ്ററുകൾ (ഉദാഹരണത്തിന്, അസന്തുലിതമായ ക്ലാസിഫിക്കേഷൻ ജോലികൾക്കായി StratifiedKFold) വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

നെസ്റ്റഡ് ക്രോസ്-വാലിഡേഷൻ: അമിതമായ ശുഭാപ്തിവിശ്വാസമുള്ള എസ്റ്റിമേറ്റുകൾ തടയുന്നു

ഹൈപ്പർപാരാമീറ്റർ ട്യൂണിംഗിനായി നിങ്ങൾ ക്രോസ്-വാലിഡേഷൻ ഉപയോഗിക്കുമ്പോൾ (ഉദാഹരണത്തിന്, GridSearchCV ഉപയോഗിച്ച്), തുടർന്ന് കണ്ടെത്തിയ മികച്ച പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ മോഡലിനെ ഒരു ബാഹ്യ ടെസ്റ്റ് സെറ്റിൽ വിലയിരുത്തുമ്പോൾ, നിങ്ങൾക്ക് ഇപ്പോഴും നിങ്ങളുടെ മോഡലിന്റെ പ്രകടനത്തെക്കുറിച്ച് അമിതമായി ശുഭാപ്തിവിശ്വാസമുള്ള ഒരു എസ്റ്റിമേറ്റ് ലഭിച്ചേക്കാം. ഇതിന് കാരണം ഹൈപ്പർപാരാമീറ്റർ തിരഞ്ഞെടുപ്പ് തന്നെ ഒരുതരം ഡാറ്റാ ലീക്കേജ് അവതരിപ്പിക്കുന്നു എന്നതാണ്: ഹൈപ്പർപാരാമീറ്ററുകൾ മുഴുവൻ പരിശീലന ഡാറ്റയെയും (ഇന്നർ ലൂപ്പിന്റെ വാലിഡേഷൻ ഫോൾഡുകൾ ഉൾപ്പെടെ) അടിസ്ഥാനമാക്കി ഒപ്റ്റിമൈസ് ചെയ്തു, ഇത് മോഡലിനെ ടെസ്റ്റ് സെറ്റിന്റെ സവിശേഷതകളെക്കുറിച്ച് ചെറുതായി "അറിവുള്ളതാക്കുന്നു".

നെസ്റ്റഡ് ക്രോസ്-വാലിഡേഷൻ ഇതിനെ അഭിസംബോധന ചെയ്യുന്ന കൂടുതൽ കർശനമായ ഒരു സമീപനമാണ്. ഇതിൽ ക്രോസ്-വാലിഡേഷന്റെ രണ്ട് പാളികൾ ഉൾപ്പെടുന്നു:

• ഔട്ടർ ലൂപ്പ്: പൊതുവായ മോഡൽ മൂല്യനിർണ്ണയത്തിനായി ഡാറ്റാസെറ്റിനെ K ഫോൾഡുകളായി വിഭജിക്കുന്നു.
• ഇന്നർ ലൂപ്പ്: ഔട്ടർ ലൂപ്പിന്റെ ഓരോ പരിശീലന ഫോൾഡിനും, മികച്ച ഹൈപ്പർപാരാമീറ്ററുകൾ കണ്ടെത്തുന്നതിന് ഇത് ക്രോസ്-വാലിഡേഷന്റെ മറ്റൊരു റൗണ്ട് (ഉദാഹരണത്തിന്, GridSearchCV ഉപയോഗിച്ച്) നടത്തുന്നു. തുടർന്ന് ഈ ഒപ്റ്റിമൽ ഹൈപ്പർപാരാമീറ്ററുകൾ ഉപയോഗിച്ച് മോഡലിനെ ഈ ഔട്ടർ പരിശീലന ഫോൾഡിൽ പരിശീലിപ്പിക്കുന്നു.
• മൂല്യനിർണ്ണയം: പരിശീലനം ലഭിച്ച മോഡൽ (മികച്ച ഇന്നർ-ലൂപ്പ് ഹൈപ്പർപാരാമീറ്ററുകളോടൊപ്പം) അനുബന്ധ ഔട്ടർ ടെസ്റ്റ് ഫോൾഡിൽ വിലയിരുത്തപ്പെടുന്നു.

ഈ രീതിയിൽ, ഓരോ ഔട്ടർ ഫോൾഡിനും ഹൈപ്പർപാരാമീറ്ററുകൾ സ്വതന്ത്രമായി ഒപ്റ്റിമൈസ് ചെയ്യപ്പെടുന്നു, ഇത് കാണാത്ത ഡാറ്റയിലെ മോഡലിന്റെ സാമാന്യവൽക്കരണ പ്രകടനത്തിന്റെ പക്ഷപാതരഹിതമായ ഒരു എസ്റ്റിമേറ്റ് നൽകുന്നു. കൂടുതൽ കമ്പ്യൂട്ടേഷണൽ ആയി തീവ്രമാണെങ്കിലും, ഹൈപ്പർപാരാമീറ്റർ ട്യൂണിംഗ് ഉൾപ്പെടുമ്പോൾ ശക്തമായ മോഡൽ തിരഞ്ഞെടുക്കുന്നതിനുള്ള ഗോൾഡ് സ്റ്റാൻഡേർഡ് ആണ് നെസ്റ്റഡ് ക്രോസ്-വാലിഡേഷൻ.

ആഗോള പ്രേക്ഷകർക്കുള്ള മികച്ച രീതികളും പരിഗണനകളും

ക്രോസ്-വാലിഡേഷൻ ഫലപ്രദമായി പ്രയോഗിക്കുന്നതിന് ചിന്താപൂർവ്വമായ പരിഗണന ആവശ്യമാണ്, പ്രത്യേകിച്ചും വിവിധ ആഗോള സന്ദർഭങ്ങളിൽ നിന്നുള്ള വൈവിധ്യമാർന്ന ഡാറ്റാസെറ്റുകളുമായി പ്രവർത്തിക്കുമ്പോൾ.

• ശരിയായ തന്ത്രം തിരഞ്ഞെടുക്കുക: നിങ്ങളുടെ ഡാറ്റയുടെ സഹജമായ ഗുണവിശേഷങ്ങൾ എപ്പോഴും പരിഗണിക്കുക. ഇത് സമയത്തെ ആശ്രയിച്ചുള്ളതാണോ? ഇതിന് ഗ്രൂപ്പ് ചെയ്ത നിരീക്ഷണങ്ങളുണ്ടോ? ക്ലാസ് ലേബലുകൾ അസന്തുലിതമാണോ? ഇത് ഒരുപക്ഷേ ഏറ്റവും നിർണായകമായ തീരുമാനമാണ്. തെറ്റായ തിരഞ്ഞെടുപ്പ് (ഉദാഹരണത്തിന്, ടൈം സീരീസിൽ കെ-ഫോൾഡ് ഉപയോഗിക്കുന്നത്) നിങ്ങളുടെ ഭൂമിശാസ്ത്രപരമായ സ്ഥാനമോ ഡാറ്റാസെറ്റിന്റെ ഉത്ഭവമോ പരിഗണിക്കാതെ തന്നെ അസാധുവായ ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം.
• ഡാറ്റാസെറ്റിന്റെ വലുപ്പവും കമ്പ്യൂട്ടേഷണൽ ചെലവും: വലിയ ഡാറ്റാസെറ്റുകൾക്ക് പലപ്പോഴും കുറഞ്ഞ ഫോൾഡുകൾ (ഉദാഹരണത്തിന്, 10-ഫോൾഡിനോ LOOCV-യ്‌ക്കോ പകരം 5-ഫോൾഡ്) അല്ലെങ്കിൽ കമ്പ്യൂട്ടേഷണൽ വിഭവങ്ങൾ കൈകാര്യം ചെയ്യാൻ ShuffleSplit പോലുള്ള രീതികൾ ആവശ്യമായി വരുന്നു. ഡിസ്ട്രിബ്യൂട്ടഡ് കമ്പ്യൂട്ടിംഗ് പ്ലാറ്റ്‌ഫോമുകളും ക്ലൗഡ് സേവനങ്ങളും (AWS, Azure, Google Cloud പോലുള്ളവ) ആഗോളതലത്തിൽ ലഭ്യമാണ്, കൂടാതെ തീവ്രമായ ക്രോസ്-വാലിഡേഷൻ ജോലികൾ കൈകാര്യം ചെയ്യാൻ സഹായിക്കാനും കഴിയും.
• പുനരുൽപാദനക്ഷമത: നിങ്ങളുടെ ക്രോസ്-വാലിഡേഷൻ സ്പ്ലിറ്ററുകളിൽ എപ്പോഴും random_state സജ്ജമാക്കുക (ഉദാഹരണത്തിന്, KFold(..., random_state=42)). ഇത് നിങ്ങളുടെ ഫലങ്ങൾ മറ്റുള്ളവർക്ക് പുനരുൽപ്പാദിപ്പിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു, ഇത് അന്താരാഷ്ട്ര ടീമുകളിലുടനീളം സുതാര്യതയും സഹകരണവും വളർത്തുന്നു.
• ഫലങ്ങൾ വ്യാഖ്യാനിക്കൽ: ശരാശരി സ്കോറിനപ്പുറം നോക്കുക. ക്രോസ്-വാലിഡേഷൻ സ്കോറുകളുടെ സ്റ്റാൻഡേർഡ് ഡീവിയേഷൻ നിങ്ങളുടെ മോഡലിന്റെ പ്രകടനത്തിലെ വ്യതിയാനത്തെ സൂചിപ്പിക്കുന്നു. ഉയർന്ന സ്റ്റാൻഡേർഡ് ഡീവിയേഷൻ നിങ്ങളുടെ മോഡലിന്റെ പ്രകടനം നിർദ്ദിഷ്ട ഡാറ്റാ സ്പ്ലിറ്റുകളോട് സെൻസിറ്റീവ് ആണെന്ന് സൂചിപ്പിക്കാം, ഇത് ഒരു ആശങ്കയായിരിക്കാം.
• വിഷയപരിജ്ഞാനമാണ് പ്രധാനം: ഡാറ്റയുടെ ഉത്ഭവവും സവിശേഷതകളും മനസ്സിലാക്കുന്നത് പരമപ്രധാനമാണ്. ഉദാഹരണത്തിന്, ഉപഭോക്തൃ ഡാറ്റ വിവിധ ഭൂമിശാസ്ത്രപരമായ പ്രദേശങ്ങളിൽ നിന്നുള്ളതാണെന്ന് അറിയുന്നത്, പ്രാദേശിക പാറ്റേണുകൾ ശക്തമാണെങ്കിൽ ഗ്രൂപ്പ് അധിഷ്ഠിത ക്രോസ്-വാലിഡേഷന്റെ ആവശ്യകതയെ സൂചിപ്പിക്കാം. ഡാറ്റാ ധാരണയിലുള്ള ആഗോള സഹകരണം ഇവിടെ പ്രധാനമാണ്.
• നൈതിക പരിഗണനകളും പക്ഷപാതവും: തികഞ്ഞ ക്രോസ്-വാലിഡേഷൻ ഉപയോഗിച്ചാലും, നിങ്ങളുടെ പ്രാരംഭ ഡാറ്റയിൽ പക്ഷപാതങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ (ഉദാഹരണത്തിന്, ചില ജനസംഖ്യാ ഗ്രൂപ്പുകളുടെയോ പ്രദേശങ്ങളുടെയോ പ്രാതിനിധ്യം കുറവാണെങ്കിൽ), നിങ്ങളുടെ മോഡൽ ആ പക്ഷപാതങ്ങൾ увековеചിപ്പിക്കാൻ സാധ്യതയുണ്ട്. ക്രോസ്-വാലിഡേഷൻ സാമാന്യവൽക്കരണം അളക്കാൻ സഹായിക്കുന്നു, പക്ഷേ സഹജമായ ഡാറ്റാ പക്ഷപാതങ്ങൾ പരിഹരിക്കുന്നില്ല. ഇവയെ അഭിസംബോധന ചെയ്യുന്നതിന് ശ്രദ്ധാപൂർവ്വമായ ഡാറ്റാ ശേഖരണവും പ്രീപ്രോസസ്സിംഗും ആവശ്യമാണ്, പലപ്പോഴും വൈവിധ്യമാർന്ന സാംസ്കാരിക, സാമൂഹിക കാഴ്ചപ്പാടുകളിൽ നിന്നുള്ള ഇൻപുട്ട് ഉപയോഗിച്ച്.
• സ്കേലബിലിറ്റി: വളരെ വലിയ ഡാറ്റാസെറ്റുകൾക്ക്, പൂർണ്ണമായ ക്രോസ്-വാലിഡേഷൻ അപ്രായോഗികമായേക്കാം. പ്രാരംഭ മോഡൽ വികസനത്തിനായി സബ്സാമ്പിളിംഗ് പോലുള്ള സാങ്കേതിക വിദ്യകൾ പരിഗണിക്കുക അല്ലെങ്കിൽ ക്രോസ്-വാലിഡേഷൻ കാര്യക്ഷമമായി സംയോജിപ്പിക്കുന്ന പ്രത്യേക ഡിസ്ട്രിബ്യൂട്ടഡ് മെഷീൻ ലേണിംഗ് ചട്ടക്കൂടുകൾ ഉപയോഗിക്കുക.

ഉപസംഹാരം

ക്രോസ്-വാലിഡേഷൻ ഒരു സാങ്കേതികവിദ്യ മാത്രമല്ല; വിശ്വസനീയവും ആശ്രയിക്കാവുന്നതുമായ മെഷീൻ ലേണിംഗ് മോഡലുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു അടിസ്ഥാന തത്വമാണിത്. Scikit-learn വിവിധ ക്രോസ്-വാലിഡേഷൻ തന്ത്രങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള വിപുലവും വഴക്കമുള്ളതുമായ ഒരു ടൂൾകിറ്റ് നൽകുന്നു, ഇത് ലോകമെമ്പാടുമുള്ള ഡാറ്റാ സയന്റിസ്റ്റുകളെ അവരുടെ മോഡലുകളെ കർശനമായി വിലയിരുത്താനും അറിവോടെയുള്ള തീരുമാനങ്ങൾ എടുക്കാനും പ്രാപ്തരാക്കുന്നു.

കെ-ഫോൾഡ്, സ്ട്രാറ്റിഫൈഡ് കെ-ഫോൾഡ്, ടൈം സീരീസ് സ്പ്ലിറ്റ്, ഗ്രൂപ്പ് കെഫോൾഡ് എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങളും ഹൈപ്പർപാരാമീറ്റർ ട്യൂണിംഗിലും ശക്തമായ മൂല്യനിർണ്ണയത്തിലും ഈ ടെക്നിക്കുകളുടെ നിർണായക പങ്കും മനസ്സിലാക്കുന്നതിലൂടെ, മോഡൽ തിരഞ്ഞെടുക്കലിന്റെ സങ്കീർണ്ണതകൾ നാവിഗേറ്റ് ചെയ്യാൻ നിങ്ങൾ കൂടുതൽ സജ്ജരാണ്. നിങ്ങളുടെ ക്രോസ്-വാലിഡേഷൻ തന്ത്രം എപ്പോഴും നിങ്ങളുടെ ഡാറ്റയുടെ അദ്വിതീയ സവിശേഷതകളുമായും നിങ്ങളുടെ മെഷീൻ ലേണിംഗ് പ്രോജക്റ്റിന്റെ നിർദ്ദിഷ്ട ലക്ഷ്യങ്ങളുമായും വിന്യസിക്കുക.

വെറും പ്രവചനത്തിനപ്പുറം, ഏത് ആഗോള പശ്ചാത്തലത്തിലും യഥാർത്ഥത്തിൽ സാമാന്യവൽക്കരിക്കാവുന്നതും ശക്തവും സ്വാധീനം ചെലുത്തുന്നതുമായ മോഡലുകൾ നിർമ്മിക്കുന്നതിലേക്ക് നീങ്ങാൻ ഈ തന്ത്രങ്ങൾ സ്വീകരിക്കുക. Scikit-learn ഉപയോഗിച്ച് മോഡൽ തിരഞ്ഞെടുക്കലിൽ വൈദഗ്ദ്ധ്യം നേടാനുള്ള നിങ്ങളുടെ യാത്ര ഇപ്പോൾ ആരംഭിച്ചിരിക്കുന്നു!