स्किट-लर्नमध्ये प्राविण्य: मॉडेल निवडीसाठी मजबूत क्रॉस-व्हॅलिडेशन पद्धतींसाठी एक जागतिक मार्गदर्शक

मशीन लर्निंगच्या विशाल आणि गतिमान क्षेत्रात, प्रेडिक्टिव्ह मॉडेल्स तयार करणे हे केवळ अर्धे युद्ध आहे. दुसरे, तितकेच महत्त्वाचे अर्धे युद्ध म्हणजे या मॉडेल्सचे कठोरपणे मूल्यांकन करणे, जेणेकरून ते न पाहिलेल्या डेटावर विश्वसनीयपणे कामगिरी करतील याची खात्री करता येईल. योग्य मूल्यांकनाशिवाय, सर्वात अत्याधुनिक अल्गोरिदम देखील दिशाभूल करणारे निष्कर्ष आणि अयोग्य निर्णयांना कारणीभूत ठरू शकतात. हे आव्हान सार्वत्रिक आहे, जे सर्व उद्योग आणि भौगोलिक क्षेत्रांतील डेटा सायंटिस्ट आणि मशीन लर्निंग इंजिनिअर्सना प्रभावित करते.

हे सर्वसमावेशक मार्गदर्शक मॉडेलच्या मजबूत मूल्यांकनासाठी आणि निवडीसाठी सर्वात मूलभूत आणि शक्तिशाली तंत्रांपैकी एक असलेल्या क्रॉस-व्हॅलिडेशनचा सखोल अभ्यास करते, जसे की ते Python च्या लोकप्रिय स्किट-लर्न लायब्ररीमध्ये लागू केले आहे. तुम्ही लंडनमधील एक अनुभवी व्यावसायिक असाल, बंगळूरमधील एक उदयोन्मुख डेटा विश्लेषक असाल, किंवा साओ पाउलोमधील मशीन लर्निंग संशोधक असाल, या पद्धती समजून घेणे आणि लागू करणे विश्वासार्ह आणि प्रभावी मशीन लर्निंग सिस्टम्स तयार करण्यासाठी अत्यंत महत्त्वाचे आहे.

आम्ही विविध क्रॉस-व्हॅलिडेशन तंत्रांचा शोध घेऊ, त्यांच्या बारकाव्या समजून घेऊ आणि स्पष्ट, कार्यान्वित करण्यायोग्य Python कोड वापरून त्यांचे व्यावहारिक उपयोजन दाखवू. आमचे ध्येय तुम्हाला तुमच्या विशिष्ट डेटासेट आणि मॉडेलिंग आव्हानासाठी सर्वोत्तम पद्धत निवडण्याचे ज्ञान देणे आहे, जेणेकरून तुमचे मॉडेल्स चांगल्या प्रकारे सामान्यीकरण (generalize) करतील आणि सातत्यपूर्ण कामगिरी देतील.

ओव्हरफिटिंग आणि अंडरफिटिंगचे धोके: मजबूत मूल्यांकन का महत्त्वाचे आहे

क्रॉस-व्हॅलिडेशनमध्ये जाण्यापूर्वी, मशीन लर्निंगचे दोन मुख्य शत्रू समजून घेणे आवश्यक आहे: ओव्हरफिटिंग आणि अंडरफिटिंग.

• ओव्हरफिटिंग (Overfitting): हे तेव्हा घडते जेव्हा मॉडेल ट्रेनिंग डेटा खूप चांगल्या प्रकारे शिकते, त्यातला नॉईज (noise) आणि विशिष्ट नमुने पकडते जे नवीन, न पाहिलेल्या डेटावर सामान्यीकरण करत नाहीत. एक ओव्हरफिट मॉडेल ट्रेनिंग सेटवर अपवादात्मकपणे चांगली कामगिरी करेल परंतु टेस्ट डेटावर खराब कामगिरी करेल. कल्पना करा की एक विद्यार्थी जो एका विशिष्ट परीक्षेसाठी उत्तरे पाठ करतो, पण त्याच विषयावरील थोड्या वेगळ्या प्रश्नांना सामोरे जाताना संघर्ष करतो.
• अंडरफिटिंग (Underfitting): याउलट, अंडरफिटिंग तेव्हा होते जेव्हा मॉडेल ट्रेनिंग डेटामधील मूळ नमुने पकडण्यासाठी खूप सोपे असते. ते ट्रेनिंग आणि टेस्ट दोन्ही डेटावर खराब कामगिरी करते. हे त्या विद्यार्थ्यासारखे आहे ज्याने मूलभूत संकल्पनाच समजून घेतल्या नाहीत आणि त्यामुळे सोप्या प्रश्नांची उत्तरेही देऊ शकत नाही.

पारंपारिक मॉडेल मूल्यांकनामध्ये अनेकदा साधा ट्रेन/टेस्ट स्प्लिट वापरला जातो. जरी ही एक चांगली सुरुवात असली तरी, एकच स्प्लिट समस्याग्रस्त असू शकते:

• कामगिरी विशिष्ट यादृच्छिक (random) स्प्लिटवर अवलंबून असू शकते. एका "भाग्यवान" स्प्लिटमुळे एक खराब मॉडेल चांगले दिसू शकते, आणि याउलट.
• जर डेटासेट लहान असेल, तर एकाच स्प्लिटचा अर्थ ट्रेनिंगसाठी कमी डेटा किंवा टेस्टिंगसाठी कमी डेटा असतो, ज्यामुळे दोन्ही बाबतीत कमी विश्वसनीय कामगिरीचे अंदाज येऊ शकतात.
• हे मॉडेलच्या कामगिरीतील विविधतेचा स्थिर अंदाज देत नाही.

येथेच क्रॉस-व्हॅलिडेशन मदतीला येते, जे मॉडेलच्या कामगिरीचा अंदाज घेण्यासाठी अधिक मजबूत आणि सांख्यिकीयदृष्ट्या योग्य पद्धत देते.

क्रॉस-व्हॅलिडेशन म्हणजे काय? मूलभूत कल्पना

मूळतः, क्रॉस-व्हॅलिडेशन ही एक रीसॅम्पलिंग प्रक्रिया आहे जी मर्यादित डेटा नमुन्यावर मशीन लर्निंग मॉडेल्सचे मूल्यांकन करण्यासाठी वापरली जाते. या प्रक्रियेमध्ये डेटासेटला पूरक उपसंचांमध्ये (subsets) विभाजित करणे, एका उपसंचावर (ट्रेनिंग सेट) विश्लेषण करणे आणि दुसऱ्या उपसंचावर (टेस्टिंग सेट) विश्लेषणाची वैधता तपासणे यांचा समावेश असतो. ही प्रक्रिया अनेक वेळा पुनरावृत्त केली जाते, उपसंचांच्या भूमिका बदलल्या जातात, आणि नंतर मॉडेलच्या कामगिरीचा अधिक विश्वसनीय अंदाज मिळवण्यासाठी परिणाम एकत्र केले जातात.

क्रॉस-व्हॅलिडेशनचे मुख्य फायदे खालीलप्रमाणे आहेत:

• अधिक विश्वसनीय कामगिरीचे अंदाज: अनेक ट्रेन-टेस्ट स्प्लिट्सवरील निकालांची सरासरी काढून, ते कामगिरीच्या अंदाजातील फरक (variance) कमी करते, ज्यामुळे मॉडेल कसे सामान्यीकरण करेल याचे अधिक स्थिर आणि अचूक मोजमाप मिळते.
• डेटाचा उत्तम वापर: सर्व डेटा पॉइंट्स अखेरीस वेगवेगळ्या फोल्ड्समध्ये ट्रेनिंग आणि टेस्टिंग दोन्हीसाठी वापरले जातात, ज्यामुळे मर्यादित डेटासेटचा कार्यक्षम वापर होतो.
• ओव्हरफिटिंग/अंडरफिटिंग ओळखणे: सर्व फोल्ड्समध्ये सातत्याने खराब कामगिरी अंडरफिटिंग दर्शवू शकते, तर उत्कृष्ट ट्रेनिंग कामगिरी परंतु फोल्ड्समध्ये खराब टेस्ट कामगिरी ओव्हरफिटिंगकडे निर्देश करते.

स्किट-लर्नचे क्रॉस-व्हॅलिडेशन टूलकिट

स्किट-लर्न, Python मधील मशीन लर्निंगसाठी एक आधारभूत लायब्ररी, तिच्या model_selection मॉड्यूलमध्ये विविध क्रॉस-व्हॅलिडेशन पद्धती लागू करण्यासाठी साधनांचा एक समृद्ध संच प्रदान करते. चला सर्वात सामान्यपणे वापरल्या जाणाऱ्या फंक्शन्सपासून सुरुवात करूया.

cross_val_score: मॉडेल कामगिरीचा एक जलद आढावा

cross_val_score फंक्शन हे स्किट-लर्नमध्ये क्रॉस-व्हॅलिडेशन करण्याचा कदाचित सर्वात सोपा मार्ग आहे. हे क्रॉस-व्हॅलिडेशनद्वारे एका स्कोअरचे मूल्यांकन करते, आणि स्कोअरची एक ॲरे (array) परत करते, प्रत्येक फोल्डसाठी एक.

मुख्य पॅरामीटर्स:

• estimator: मशीन लर्निंग मॉडेल ऑब्जेक्ट (उदा. LogisticRegression()).
• X: फीचर्स (ट्रेनिंग डेटा).
• y: टार्गेट व्हेरिएबल.
• cv: क्रॉस-व्हॅलिडेशन स्प्लिटिंगची पद्धत ठरवते. ही एक पूर्णांक संख्या (फोल्ड्सची संख्या), एक CV स्प्लिटर ऑब्जेक्ट (उदा. KFold()), किंवा एक इटरेबल (iterable) असू शकते.
• scoring: टेस्ट सेटवरील प्रेडिक्शन्सचे मूल्यांकन करण्यासाठी एक स्ट्रिंग (उदा. 'accuracy', 'f1', 'roc_auc') किंवा एक कॉलेबल (callable).

            
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
              
            
          

हे आउटपुट प्रत्येक फोल्डसाठी ॲक्युरसी स्कोअरची एक ॲरे देते. सरासरी (mean) आणि मानक विचलन (standard deviation) तुम्हाला मॉडेलच्या कामगिरीची केंद्रीय प्रवृत्ती आणि परिवर्तनशीलता देतात.

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 पेक्षा खूप जास्त असेल, तर तुमचे मॉडेल ओव्हरफिट होण्याची शक्यता आहे.

स्किट-लर्नमधील प्रमुख क्रॉस-व्हॅलिडेशन पद्धती

स्किट-लर्न अनेक विशेष क्रॉस-व्हॅलिडेशन इटरेटर्स ऑफर करते, प्रत्येक वेगवेगळ्या डेटा वैशिष्ट्यांसाठी आणि मॉडेलिंग परिस्थितींसाठी उपयुक्त आहे. योग्य पद्धत निवडणे अर्थपूर्ण आणि निःपक्षपाती कामगिरीचे अंदाज मिळवण्यासाठी महत्त्वपूर्ण आहे.

१. के-फोल्ड क्रॉस-व्हॅलिडेशन (K-Fold Cross-Validation)

वर्णन: के-फोल्ड ही सर्वात सामान्य क्रॉस-व्हॅलिडेशन पद्धत आहे. डेटासेटला k समान आकाराच्या फोल्ड्समध्ये विभागले जाते. प्रत्येक पुनरावृत्तीमध्ये, एक फोल्ड टेस्ट सेट म्हणून वापरला जातो आणि उर्वरित k-1 फोल्ड्स ट्रेनिंग सेट म्हणून वापरले जातात. ही प्रक्रिया k वेळा पुनरावृत्त केली जाते, प्रत्येक फोल्ड एकदाच टेस्ट सेट म्हणून काम करतो.

कधी वापरावे: अनेक मानक वर्गीकरण (classification) आणि रिग्रेशन (regression) कार्यांसाठी हा एक सामान्य-उद्देशीय पर्याय आहे, जिथे डेटा पॉइंट्स स्वतंत्र आणि समान वितरीत (independent and identically distributed - i.i.d.) असतात.

विचारात घेण्यासारख्या गोष्टी:

• सामान्यतः, k चे मूल्य ५ किंवा १० ठेवले जाते. जास्त 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 शफलिंगची पुनरुत्पादकता सुनिश्चित करते.

२. स्ट्रॅटिफाइड के-फोल्ड क्रॉस-व्हॅलिडेशन (Stratified K-Fold Cross-Validation)

वर्णन: हे के-फोल्डचे एक प्रकार आहे जे विशेषतः वर्गीकरण कार्यांसाठी डिझाइन केलेले आहे, विशेषतः असंतुलित डेटासेटसह. हे सुनिश्चित करते की प्रत्येक फोल्डमध्ये प्रत्येक टार्गेट वर्गाच्या नमुन्यांची टक्केवारी संपूर्ण सेटप्रमाणेच असेल. हे फोल्ड्सना अल्पसंख्याक वर्गाच्या नमुन्यांपासून पूर्णपणे वंचित राहण्यापासून प्रतिबंधित करते, ज्यामुळे खराब मॉडेल ट्रेनिंग किंवा टेस्टिंग होऊ शकते.

कधी वापरावे: वर्गीकरण समस्यांसाठी आवश्यक, विशेषतः जेव्हा असंतुलित वर्ग वितरणांशी व्यवहार करता, जे वैद्यकीय निदान (उदा. दुर्मिळ रोगांचे निदान), फसवणूक ओळखणे किंवा विसंगती ओळखणे यासारख्या क्षेत्रात सामान्य आहे.

            
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 कसे दर्शवते की प्रत्येक फोल्डमधील ट्रेनिंग आणि टेस्टिंग दोन्ही सेट्स वर्गांचे समान प्रमाण राखतात (उदा. ६०/४० विभाजन किंवा n_splits दिल्यास शक्य तितके जवळचे).

३. लीव्ह-वन-आउट क्रॉस-व्हॅलिडेशन (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
              
            
          

४. शफलस्प्लिट आणि स्ट्रॅटिफाइडशफलस्प्लिट (ShuffleSplit and StratifiedShuffleSplit)

वर्णन: के-फोल्डच्या विपरीत, जे प्रत्येक नमुना टेस्ट सेटमध्ये एकदाच दिसेल याची हमी देते, शफलस्प्लिट n_splits यादृच्छिक ट्रेन/टेस्ट स्प्लिट्स काढते. प्रत्येक स्प्लिटसाठी, डेटाचा एक भाग यादृच्छिकपणे ट्रेनिंगसाठी निवडला जातो, आणि दुसरा (स्वतंत्र) भाग टेस्टिंगसाठी. हे वारंवार यादृच्छिक उपनमुने घेण्यास (subsampling) परवानगी देते.

कधी वापरावे:

• जेव्हा के-फोल्डमधील फोल्ड्सची संख्या (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
              
            
          

५. टाइम सिरीज क्रॉस-व्हॅलिडेशन (TimeSeriesSplit)

वर्णन: मानक क्रॉस-व्हॅलिडेशन पद्धती असे गृहीत धरतात की डेटा पॉइंट्स स्वतंत्र आहेत. तथापि, टाइम सिरीज डेटामध्ये, निरीक्षणे क्रमित असतात आणि अनेकदा कालबद्ध अवलंबित्व (temporal dependencies) दर्शवतात. टाइम सिरीज डेटाला शफल करणे किंवा यादृच्छिकपणे विभाजित केल्याने डेटा लीकेज होईल, जिथे मॉडेल भूतकाळातील डेटाचा अंदाज लावण्यासाठी भविष्यातील डेटावर प्रशिक्षण घेईल, ज्यामुळे अति-आशावादी आणि अवास्तव कामगिरीचा अंदाज येईल.

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
              
            
          

ही पद्धत सुनिश्चित करते की तुमचे मॉडेल नेहमी भविष्यातील डेटावर मूल्यांकित केले जाते ज्यावर ते प्रशिक्षित केले गेले होते, वेळेवर अवलंबून असलेल्या समस्यांसाठी वास्तविक-जगातील उपयोजन परिस्थितीचे अनुकरण करते.

६. ग्रुप क्रॉस-व्हॅलिडेशन (GroupKFold, LeaveOneGroupOut)

वर्णन: काही डेटासेटमध्ये, नमुने पूर्णपणे स्वतंत्र नसतात; ते विशिष्ट गटांचे असू शकतात. उदाहरणार्थ, एकाच रुग्णाकडून अनेक वैद्यकीय मोजमाप, एकाच सेन्सरकडून अनेक निरीक्षणे, किंवा एकाच ग्राहकाकडून अनेक आर्थिक व्यवहार. जर हे गट ट्रेनिंग आणि टेस्ट सेट्समध्ये विभागले गेले, तर मॉडेल गट-विशिष्ट नमुने शिकू शकते आणि नवीन, न पाहिलेल्या गटांवर सामान्यीकरण करण्यात अयशस्वी होऊ शकते. हा डेटा लीकेजचा एक प्रकार आहे.

ग्रुप क्रॉस-व्हॅलिडेशन पद्धती सुनिश्चित करतात की एकाच गटातील सर्व डेटा पॉइंट्स एकतर पूर्णपणे ट्रेनिंग सेटमध्ये किंवा पूर्णपणे टेस्ट सेटमध्ये दिसतात, दोन्हीमध्ये कधीच नाहीत.

कधी वापरावे: जेव्हा तुमच्या डेटामध्ये अंतर्निहित गट असतात जे फोल्ड्समध्ये विभागल्यास पक्षपात आणू शकतात, जसे की लॉंगिट्युडिनल स्टडीज, अनेक उपकरणांवरील सेन्सर डेटा, किंवा ग्राहक-विशिष्ट वर्तणूक मॉडेलिंग.

विचारात घेण्यासारख्या गोष्टी: .split() पद्धतीला एक 'groups' ॲरे पास करणे आवश्यक आहे, जे प्रत्येक नमुन्यासाठी गटाची ओळख निर्दिष्ट करते.

            
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 सह हायपरपॅरामीटर ट्यूनिंग

मशीन लर्निंग मॉडेल्समध्ये अनेकदा हायपरपॅरामीटर्स असतात जे डेटामधून शिकले जात नाहीत परंतु ट्रेनिंगपूर्वी सेट केले पाहिजेत. या हायपरपॅरामीटर्सची सर्वोत्तम मूल्ये सहसा डेटासेट-अवलंबित असतात. स्किट-लर्नचे 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 सह), आणि नंतर सापडलेले सर्वोत्तम पॅरामीटर्स वापरून तुमच्या मॉडेलचे बाह्य टेस्ट सेटवर मूल्यांकन करता, तेव्हा तुम्हाला तरीही तुमच्या मॉडेलच्या कामगिरीचा अति-आशावादी अंदाज मिळू शकतो. याचे कारण असे आहे की हायपरपॅरामीटर निवड स्वतःच डेटा लीकेजचा एक प्रकार आहे: हायपरपॅरामीटर्स संपूर्ण ट्रेनिंग डेटावर (आतील लूपच्या व्हॅलिडेशन फोल्ड्ससह) ऑप्टिमाइझ केले गेले, ज्यामुळे मॉडेल टेस्ट सेटच्या वैशिष्ट्यांबद्दल थोडेसे "जागरूक" होते.

नेस्टेड क्रॉस-व्हॅलिडेशन ही एक अधिक कठोर पद्धत आहे जी यावर उपाय करते. यात क्रॉस-व्हॅलिडेशनचे दोन स्तर असतात:

• बाह्य लूप (Outer Loop): सामान्य मॉडेल मूल्यांकनासाठी डेटासेटला K फोल्ड्समध्ये विभाजित करते.
• आतील लूप (Inner Loop): बाह्य लूपच्या प्रत्येक ट्रेनिंग फोल्डसाठी, ते सर्वोत्तम हायपरपॅरामीटर्स शोधण्यासाठी क्रॉस-व्हॅलिडेशनचा दुसरा फेरी (उदा., GridSearchCV वापरून) करते. मॉडेल नंतर या बाह्य ट्रेनिंग फोल्डवर या सर्वोत्तम हायपरपॅरामीटर्सचा वापर करून प्रशिक्षित केले जाते.
• मूल्यांकन: प्रशिक्षित मॉडेल (सर्वोत्तम आतील-लूप हायपरपॅरामीटर्ससह) नंतर संबंधित बाह्य टेस्ट फोल्डवर मूल्यांकित केले जाते.

या प्रकारे, हायपरपॅरामीटर्स प्रत्येक बाह्य फोल्डसाठी स्वतंत्रपणे ऑप्टिमाइझ केले जातात, ज्यामुळे न पाहिलेल्या डेटावर मॉडेलच्या सामान्यीकरण कामगिरीचा खरोखरच निःपक्षपाती अंदाज मिळतो. जरी हे अधिक संगणकीयदृष्ट्या गहन असले तरी, हायपरपॅरामीटर ट्यूनिंग समाविष्ट असताना मजबूत मॉडेल निवडीसाठी नेस्टेड क्रॉस-व्हॅलिडेशन हे सुवर्ण मानक आहे.

जागतिक प्रेक्षकांसाठी सर्वोत्तम पद्धती आणि विचार

क्रॉस-व्हॅलिडेशन प्रभावीपणे लागू करण्यासाठी विचारपूर्वक विचार करणे आवश्यक आहे, विशेषतः विविध जागतिक संदर्भांतील विविध डेटासेटसह काम करताना.

• योग्य पद्धत निवडा: तुमच्या डेटाच्या अंतर्निहित गुणधर्मांचा नेहमी विचार करा. तो वेळेवर अवलंबून आहे का? त्यात गटबद्ध निरीक्षणे आहेत का? वर्ग लेबल्स असंतुलित आहेत का? हा कदाचित सर्वात महत्त्वाचा निर्णय आहे. चुकीची निवड (उदा. टाइम सिरीजवर के-फोल्ड) अवैध परिणामांना कारणीभूत ठरू शकते, तुमचे भौगोलिक स्थान किंवा डेटासेटचे मूळ काहीही असो.
• डेटासेटचा आकार आणि संगणकीय खर्च: मोठ्या डेटासेटसाठी अनेकदा कमी फोल्ड्स (उदा. १०-फोल्ड किंवा LOOCV ऐवजी ५-फोल्ड) किंवा संगणकीय संसाधने व्यवस्थापित करण्यासाठी ShuffleSplit सारख्या पद्धतींची आवश्यकता असते. वितरित संगणकीय प्लॅटफॉर्म आणि क्लाउड सेवा (जसे की AWS, Azure, Google Cloud) जागतिक स्तरावर उपलब्ध आहेत आणि गहन क्रॉस-व्हॅलिडेशन कार्यांना हाताळण्यास मदत करू शकतात.
• पुनरुत्पादकता (Reproducibility): तुमच्या क्रॉस-व्हॅलिडेशन स्प्लिटर्समध्ये नेहमी random_state सेट करा (उदा. KFold(..., random_state=42)). हे सुनिश्चित करते की तुमचे परिणाम इतरांद्वारे पुनरुत्पादित केले जाऊ शकतात, ज्यामुळे आंतरराष्ट्रीय संघांमध्ये पारदर्शकता आणि सहकार्य वाढते.
• निकालांचा अर्थ लावणे: केवळ सरासरी स्कोअरच्या पलीकडे पहा. क्रॉस-व्हॅलिडेशन स्कोअरचे मानक विचलन तुमच्या मॉडेलच्या कामगिरीतील परिवर्तनशीलता दर्शवते. उच्च मानक विचलन सूचित करू शकते की तुमच्या मॉडेलची कामगिरी विशिष्ट डेटा स्प्लिट्ससाठी संवेदनशील आहे, जी एक चिंतेची बाब असू शकते.
• डोमेन ज्ञान राजा आहे: डेटाचे मूळ आणि वैशिष्ट्ये समजून घेणे अत्यंत महत्त्वाचे आहे. उदाहरणार्थ, ग्राहक डेटा वेगवेगळ्या भौगोलिक प्रदेशांमधून येतो हे जाणून घेतल्यास, जर प्रादेशिक नमुने मजबूत असतील तर गट-आधारित क्रॉस-व्हॅलिडेशनची आवश्यकता दर्शवू शकते. डेटा समजून घेण्यासाठी जागतिक सहकार्य येथे महत्त्वाचे आहे.
• नैतिक विचार आणि पक्षपात: परिपूर्ण क्रॉस-व्हॅलिडेशनसह देखील, जर तुमच्या सुरुवातीच्या डेटामध्ये पक्षपात असेल (उदा. काही लोकसंख्याशास्त्रीय गट किंवा प्रदेशांचे कमी प्रतिनिधित्व), तर तुमचे मॉडेल त्या पक्षपातांना कायम ठेवण्याची शक्यता आहे. क्रॉस-व्हॅलिडेशन सामान्यीकरण मोजण्यात मदत करते परंतु अंतर्निहित डेटा पक्षपात दूर करत नाही. यावर उपाय करण्यासाठी काळजीपूर्वक डेटा संकलन आणि प्रीप्रोसेसिंगची आवश्यकता असते, अनेकदा विविध सांस्कृतिक आणि सामाजिक दृष्टिकोनांमधून इनपुटसह.
• स्केलेबिलिटी: अत्यंत मोठ्या डेटासेटसाठी, पूर्ण क्रॉस-व्हॅलिडेशन अव्यवहार्य असू शकते. सुरुवातीच्या मॉडेल विकासासाठी उपनमुने घेण्याचे तंत्र किंवा क्रॉस-व्हॅलिडेशन कार्यक्षमतेने एकत्रित करणाऱ्या विशेष वितरित मशीन लर्निंग फ्रेमवर्कचा वापर करण्याचा विचार करा.

निष्कर्ष

क्रॉस-व्हॅलिडेशन हे फक्त एक तंत्र नाही; ते विश्वसनीय आणि विश्वासार्ह मशीन लर्निंग मॉडेल्स तयार करण्यासाठी एक मूलभूत तत्त्व आहे. स्किट-लर्न विविध क्रॉस-व्हॅलिडेशन पद्धती लागू करण्यासाठी एक विस्तृत आणि लवचिक टूलकिट प्रदान करते, ज्यामुळे जगभरातील डेटा सायंटिस्ट त्यांच्या मॉडेल्सचे कठोरपणे मूल्यांकन करू शकतात आणि माहितीपूर्ण निर्णय घेऊ शकतात.

के-फोल्ड, स्ट्रॅटिफाइड के-फोल्ड, टाइम सिरीज स्प्लिट, ग्रुपकेफोल्ड यांच्यातील फरक समजून घेऊन आणि हायपरपॅरामीटर ट्यूनिंग आणि मजबूत मूल्यांकनामध्ये या तंत्रांची महत्त्वपूर्ण भूमिका जाणून घेऊन, तुम्ही मॉडेल निवडीच्या गुंतागुंतीला सामोरे जाण्यासाठी अधिक सुसज्ज आहात. तुमची क्रॉस-व्हॅलिडेशन पद्धत नेहमी तुमच्या डेटाच्या अद्वितीय वैशिष्ट्यांशी आणि तुमच्या मशीन लर्निंग प्रकल्पाच्या विशिष्ट ध्येयांशी जुळवा.

केवळ अंदाजाच्या पलीकडे जाऊन खऱ्या अर्थाने सामान्यीकरण करण्यायोग्य, मजबूत आणि कोणत्याही जागतिक संदर्भात प्रभावी मॉडेल्स तयार करण्यासाठी या पद्धतींचा स्वीकार करा. स्किट-लर्नसह मॉडेल निवडीमध्ये प्राविण्य मिळवण्याचा तुमचा प्रवास नुकताच सुरू झाला आहे!