आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते
शिक्षार्थी याद किए हुए मॉडल का मूल्यांकन करके डेटा रिसाव प्रदर्शित करेंगे और देखेंगे कि ईमानदार प्रदर्शन अनुमान के लिए अलग रखा गया परीक्षण डेटा क्यों आवश्यक है।
आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
Evaluation का जाल
मॉडल को प्रशिक्षित करने के बाद सबसे आकर्षक काम यह लगता है कि उसी डेटा पर उसका test किया जाए जिसका उपयोग training में किया गया था। मॉडल का score बहुत ऊँचा—कभी-कभी 100% accuracy—आ सकता है और यह सफलता जैसा महसूस होता है। लेकिन ऐसा नहीं है। यह मशीन लर्निंग की सबसे मूलभूत गलतियों में से एक है और वास्तविक दुनिया के प्रदर्शन का पूर्वानुमान लगाने के लिए पूरी तरह बेकार परिणाम देता है।
यह समझना कि यह क्यों विफल होता है, महज़ तकनीकी बारीकी नहीं है—यह मशीन लर्निंग के पूरे उद्देश्य के बारे में आपकी सोच बदल देता है। लक्ष्य training data पर अच्छा प्रदर्शन करना कभी नहीं होता। लक्ष्य हमेशा नए, पहले न देखे गए डेटा पर सामान्यीकरण करना होता है।
कंठस्थ करना बनाम सामान्यीकरण
उस विद्यार्थी के बीच अंतर पर विचार कीजिए जो परीक्षा-तैयारी की पुस्तक में दिए हर उत्तर को कंठस्थ कर लेता है और उस विद्यार्थी के बीच जो वास्तव में विषय को समझता है। पहला विद्यार्थी हर अभ्यास-प्रश्न में पूरे अंक प्राप्त करता है, लेकिन वास्तविक परीक्षा में प्रश्नों की भाषा थोड़ी अलग होने पर विफल हो जाता है। दूसरा विद्यार्थी अभ्यास-प्रश्नों में पूरे अंक न भी पाए, फिर भी नए प्रश्नों को आत्मविश्वास से हल कर लेता है।
जो ML मॉडल training examples को 'कंठस्थ' कर लेता है (एक बहुत अधिक overfitted मॉडल), वह पहले विद्यार्थी की तरह ही व्यवहार करता है। वह training accuracy में पूर्ण परिणाम प्राप्त करता है, लेकिन नए inputs पर विफल हो जाता है। जब evaluation के दौरान ऐसा होता है, तो इस घटना को data leakage कहा जाता है—आपने उत्तरों को test में 'लीक' कर दिया है।
एक प्रदर्शन: कंठस्थ करना सक्रिय रूप में
आइए इसे अनुभवजन्य रूप से सिद्ध करें। असीमित गहराई वाला decision tree हर training example को पूरी तरह कंठस्थ कर लेगा और 100% training accuracy प्राप्त करेगा। लेकिन उसकी test accuracy बहुत कम होगी, क्योंकि उसने वास्तविक अंतर्निहित pattern के बजाय noise सीखा है।
यह प्रयोग समस्या को ठोस और मापने योग्य बनाता है: training accuracy प्रदर्शन के अनुमान के रूप में अर्थहीन है—यह बुद्धिमत्ता नहीं, स्मृति को मापती है।
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Unlimited depth: memorises training data
model = DecisionTreeClassifier() # no max_depth limit
model.fit(X_train, y_train)
train_acc = model.score(X_train, y_train)
test_acc = model.score(X_test, y_test)
print(f'Training accuracy: {train_acc:.3f}') # 1.000 -- perfect memorisation
print(f'Test accuracy: {test_acc:.3f}') # much lower
print(f'Overfit gap: {train_acc - test_acc:.3f}')Training Accuracy में आशावादी पक्षपात क्यों होता है
मॉडल के parameters को विशेष रूप से training set पर error को न्यूनतम करने के लिए optimize किया गया था। इसका अर्थ है कि किसी भी उचित रूप से जटिल मॉडल के लिए training error, वास्तविक generalisation error से कम होना सुनिश्चित है। training error और test error के बीच के अंतर को training error का optimism कहा जाता है।
Training examples की तुलना में मॉडल में जितने अधिक parameters होंगे, optimism उतना ही गंभीर होगा। लाखों parameters वाला neural network केवल 1,000 training examples के साथ आसानी से 0% training error प्राप्त कर सकता है, जबकि उसकी वास्तविक error rate 50% हो सकती है। Training error generalisation का विश्वसनीय अनुमान नहीं है—बिल्कुल नहीं।
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np
X, y = make_classification(n_samples=500, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
# KNN with k=1: memorises perfectly (always finds the exact training point)
knn1 = KNeighborsClassifier(n_neighbors=1)
knn1.fit(X_train, y_train)
print(f'k=1 Training accuracy: {knn1.score(X_train, y_train):.3f}') # 1.000
print(f'k=1 Test accuracy: {knn1.score(X_test, y_test):.3f}') # lower
# k=10: generalisers better
knn10 = KNeighborsClassifier(n_neighbors=10)
knn10.fit(X_train, y_train)
print(f'k=10 Test accuracy: {knn10.score(X_test, y_test):.3f}')अलग रखा गया Test Set: समाधान
समाधान सरल है, लेकिन इसे कठोरता से लागू करना आवश्यक है: मॉडलिंग शुरू होने से पहले अपने डेटा का एक हिस्सा अलग रख दीजिए और उसे training या मॉडल को प्रभावित करने वाले किसी भी निर्णय के लिए कभी उपयोग न करें।
यह अलग रखा गया test set generalisation performance का आपका ईमानदार अनुमान है। क्योंकि मॉडल ने इसे कभी नहीं देखा है, इसलिए इस set पर उसका प्रदर्शन भविष्य के डेटा पर उसके प्रदर्शन का उपलब्ध सर्वोत्तम अनुमान है। Test set एक बार उपयोग किया जाने वाला मापन साधन है—अपने मॉडल को बेहतर बनाने के लिए इसे कई बार उपयोग करने से यह अमान्य हो जाता है।
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
# CORRECT workflow: split BEFORE any analysis
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.20, # 20% held out for final evaluation only
random_state=42, # reproducible split
stratify=y # maintain class ratio in both splits
)
print(f'Training set: {X_train.shape[0]} examples')
print(f'Test set: {X_test.shape[0]} examples')
print(f'Train class balance: {y_train.mean():.3f}')
print(f'Test class balance: {y_test.mean():.3f}')Data Leakage: सूक्ष्म रूप
अंतिम मूल्यांकन के लिए परीक्षण डेटा का उपयोग करना डेटा लीक होने का सबसे स्पष्ट रूप है। इसके कुछ अधिक सूक्ष्म रूप भी हैं, जो उतने ही विनाशकारी हो सकते हैं:
- पूर्व-प्रसंस्करण लीक: विभाजन से पहले पूरे डेटासेट पर स्केलर को fit करना और फिर प्रशिक्षण तथा परीक्षण डेटा को स्केल करना — स्केलर परीक्षण डेटा के आँकड़ों को 'देख' चुका होता है।
- फ़ीचर लीक: ऐसा फ़ीचर शामिल करना, जो लक्ष्य चर से निकाला गया हो (जैसे, 'निदान की पुष्टि' का संकेतक, जिसे केवल तब सेट किया जाता है जब रोगी वास्तव में बीमार हो)।
- समय-संबंधी लीक: पिछली घटनाओं का अनुमान लगाने के लिए भविष्य के डेटा का उपयोग करना (जैसे, पहली तिमाही के परिणामों का अनुमान लगाते समय तीसरी तिमाही की बिक्री का डेटा शामिल करना)।
from sklearn.preprocessing import StandardScaler
import numpy as np
# WRONG: fit scaler on full dataset before splitting
X = np.random.randn(1000, 5)
scaler_wrong = StandardScaler()
X_scaled_all = scaler_wrong.fit_transform(X) # leakage! scaler saw test data
# Correct: split first, then fit scaler ONLY on training data
from sklearn.model_selection import train_test_split
X_train, X_test = train_test_split(X, test_size=0.2)
scaler_correct = StandardScaler()
X_train_s = scaler_correct.fit_transform(X_train) # fit on train only
X_test_s = scaler_correct.transform(X_test) # apply to test
print('Correct preprocessing: scaler fitted on training data only.')तीन-तरफ़ा विभाजन: प्रशिक्षण, सत्यापन और परीक्षण
जब आप निर्णय लेने के लिए परीक्षण सेट का उपयोग करते हैं — जैसे दो मॉडलों में से किसी एक को चुनना या कोई सीमा निर्धारित करना — तो वह सामान्यीकरण का निष्पक्ष अनुमान नहीं रह जाता। परीक्षण सेट को अपरिवर्तित रखने के लिए एक सत्यापन सेट शामिल करें:
- प्रशिक्षण सेट: मॉडल के पैरामीटरों पर fit करें।
- सत्यापन सेट: हाइपरपैरामीटर समायोजित करें, मॉडल चुनें और सीमाएँ बदलें।
- परीक्षण सेट: अंतिम, एक बार किया जाने वाला मूल्यांकन। इसे केवल अंत में, एक ही बार उपयोग करें।
एक सामान्य विभाजन 70% प्रशिक्षण / 15% सत्यापन / 15% परीक्षण होता है। प्रशिक्षण सेट पर सत्यापन खंडों को बारी-बारी से उपयोग करके क्रॉस-वैलिडेशन अधिक दक्ष विकल्प प्रदान करता है।
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
# First split off test set (15%)
X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.15, random_state=42)
# Then split remaining into train and validation
X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.176, random_state=42)
# 0.176 of 85% ≈ 15% of the original
print(f'Train: {X_train.shape[0]}')
print(f'Val: {X_val.shape[0]}')
print(f'Test: {X_test.shape[0]}')परीक्षण सेट के दूषित होने से परिणामों का बढ़ जाना
मान लीजिए कि आप 10 अलग-अलग मॉडल प्रशिक्षित करते हैं, हर एक का परीक्षण सेट पर मूल्यांकन करते हैं और सबसे अधिक परीक्षण सटीकता वाले मॉडल को चुनते हैं। इस प्रक्रिया से परीक्षण सेट दूषित हो गया है — आपने मॉडल संबंधी निर्णय लेने के लिए परीक्षण प्रदर्शन का उपयोग किया है। चुना गया मॉडल परीक्षण सेट के लिए अनुकूलित है और अब इसकी बताई गई सटीकता वास्तविकता से अधिक आशावादी है।
इसी कारण Kaggle जैसी प्रतियोगिताओं में सार्वजनिक लीडरबोर्ड (सत्यापन सेट) और निजी लीडरबोर्ड (सच्चा परीक्षण सेट, जो केवल अंत में दिखाया जाता है) होता है। बहुत-सी प्रस्तुतियाँ करके सार्वजनिक लीडरबोर्ड पर अति-अनुकूलित होने वाली टीमें अक्सर निजी लीडरबोर्ड पर खराब प्रदर्शन करती हैं।
from sklearn.datasets import make_classification
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
import numpy as np
X, y = make_classification(n_samples=500, random_state=99)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Contamination: picking best max_depth based on test set
best_acc, best_depth = 0, 1
for depth in range(1, 20):
model = DecisionTreeClassifier(max_depth=depth)
model.fit(X_train, y_train)
acc = model.score(X_test, y_test)
if acc > best_acc:
best_acc, best_depth = acc, depth
print(f'Best depth selected by test: {best_depth}, acc: {best_acc:.3f}')
print('This accuracy is now overly optimistic!')पुनरुत्पादकता: random_state पैरामीटर
train_test_split में random_state पैरामीटर यह नियंत्रित करता है कि कौन-से उदाहरण किस विभाजन में जाएँ। इसके बिना, हर बार अलग विभाजन बनता है, जिससे परिणामों को दोहराना और तुलना करना कठिन हो जाता है।
आप जो भी कोड दूसरों के साथ साझा करें या बाद में दोहराना चाहें, उसमें हमेशा random_state को किसी निश्चित पूर्णांक पर सेट करें। कोई भी पूर्णांक चलेगा — आम तौर पर 42, 0 या 1 का उपयोग किया जाता है — बशर्ते आप इस्तेमाल किए गए मान का दस्तावेज़ रखें। पूर्णांक का विशिष्ट मान महत्वपूर्ण नहीं है; निरंतरता महत्वपूर्ण है।
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
# Without random_state: different results every run
X_train1, X_test1, _, _ = train_test_split(X, y) # no seed
X_train2, X_test2, _, _ = train_test_split(X, y) # no seed
print('Different splits without seed:', not (X_train1 == X_train2).all())
# With random_state: same result every run
X_train3, X_test3, _, _ = train_test_split(X, y, random_state=42)
X_train4, X_test4, _, _ = train_test_split(X, y, random_state=42)
print('Same splits with seed:', (X_train3 == X_train4).all())मशीन लर्निंग मूल्यांकन का स्वर्णिम नियम
इस पूरे पाठ में बताए गए हर सिद्धांत को समेटने वाला एक नियम है: मॉडल के विकास के दौरान लिए गए किसी भी निर्णय को परीक्षण सेट कभी प्रभावित नहीं करना चाहिए। इसका अर्थ है:
- परीक्षण डेटा पर किया गया कोई पूर्व-प्रसंस्करण नहीं।
- परीक्षण प्रदर्शन के आधार पर कोई मॉडल चयन नहीं।
- परीक्षण प्रदर्शन पर समायोजित की गई कोई सीमा नहीं।
- परीक्षण त्रुटियाँ देखने के बाद बनाया गया कोई फ़ीचर नहीं।
- परीक्षण सेट का उपयोग केवल अंत में, अंतिम प्रदर्शन बताने के लिए, एक ही बार किया जाए।
इस नियम का पालन करने से यह सुनिश्चित होता है कि आपका बताया गया प्रदर्शन इस बात का ईमानदार अनुमान है कि भविष्य के डेटा पर उत्पादन परिवेश में मॉडल कैसा व्यवहार करेगा।
त्वरित जाँच
इस पाठ में दिए गए Python के साथ मशीन लर्निंग संबंधी अवधारणाओं की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: प्रशिक्षण सटीकता हमेशा आशावादी रूप से पक्षपाती होती है, क्योंकि मॉडल के पैरामीटर उसी डेटा पर अनुकूलित किए गए थे, ऐसा अलग रखा गया परीक्षण सेट, जो प्रशिक्षण के किसी भी निर्णय को प्रभावित नहीं करता, सामान्यीकरण का ईमानदार अनुमान देता है, और डेटा लीक — जिसमें पूर्व-प्रसंस्करण लीक तथा परीक्षण सेट का दूषित होना शामिल है — प्रदर्शन के भ्रामक रूप से अधिक अनुमान उत्पन्न करता है। आगे हम scikit-learn के train_test_split फ़ंक्शन का गहराई से अध्ययन करेंगे, जिसमें परीक्षण आकार के अनुपात, यादृच्छिक बीज और असंतुलित वर्गीकरण समस्याओं के लिए स्तरीकरण शामिल हैं।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते” पाठ निःशुल्क है?
हाँ—“आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते” में मैं क्या सीखूँगा?
शिक्षार्थी याद किए हुए मॉडल का मूल्यांकन करके डेटा रिसाव प्रदर्शित करेंगे और देखेंगे कि ईमानदार प्रदर्शन अनुमान के लिए अलग रखा गया परीक्षण डेटा क्यों आवश्यक है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- आप प्रशिक्षण डेटा पर मूल्यांकन क्यों नहीं कर सकते
- train_test_split: अनुपात, बीज और स्तरीकरण
- पक्षपात-विचरण संतुलन: कम-फिटिंग बनाम अधिक-फिटिंग
- आधारभूत मॉडल: DummyClassifier को हमेशा हराइए