लर्निंग कर्व्स ट्यूटोरियल: लर्निंग कर्व्स क्या हैं?

मशीन लर्निंग मॉडलों में त्रुटियों के दो प्रमुख कारण होते हैं:

• बायस उस मॉडल का वर्णन करता है जो लक्ष्य फ़ंक्शन को आसानी से निकटानुमित करने के लिए सरलीकृत मान्यताएँ बनाता है; उदाहरण के लिए, कोई मॉडल सीख ले कि दुनिया के हर 5'9 पुरुष का टॉप साइज मीडियम है — यह स्पष्ट रूप से पक्षपाती है।
• वैरिएंस मॉडल की भविष्यवाणी में बदलाव का वर्णन करता है; जब हम प्रशिक्षण के लिए उपयोग किए गए डेटा को बदलते हैं तो मॉडल की भविष्यवाणी कितनी बदलती है।

अधिक सटीक समाधान प्राप्त करने के लिए, हम अपने मॉडल में मौजूद बायस और वैरिएंस की मात्रा को कम करना चाहते हैं। यह सीधा-सादा कार्य नहीं है। बायस और वैरिएंस एक-दूसरे के विरुद्ध होते हैं — एक को घटाने से दूसरा बढ़ता है; इसे बायस-वैरिएंस ट्रेड-ऑफ कहा जाता है।

इस लेख में आप सीखेंगे:

• कैसे पहचानें कि कोई मॉडल उच्च बायस से ग्रस्त है या उच्च वैरिएंस से
• कैसे ऐसे किसी भी लक्षण से ग्रस्त मॉडल का निदान करें
• कैसे एक अच्छा-फिट मॉडल बनाएं

त्रुटि के लक्षणों का पता लगाने से पहले, आइए बायस-वैरिएंस ट्रेड-ऑफ को थोड़ी गहराई से समझते हैं।

बायस-वैरिएंस ट्रेड-ऑफ पर एक नज़र

सभी सुपरवाइज़्ड लर्निंग एल्गोरिदम एक ही लक्ष्य हासिल करने का प्रयास करते हैं: दिए गए इनपुट डेटा (X) के आधार पर लक्ष्य चर (y) के लिए मैपिंग फ़ंक्शन (f_hat) का अनुमान लगाना। जिस फ़ंक्शन का सन्निकटन करने का लक्ष्य कोई मशीन लर्निंग मॉडल रखता है, उसे हम लक्ष्य फ़ंक्शन कहते हैं।

लक्ष्य चर का सन्निकटन करने के लिए उपयोग किए गए इनपुट डेटा को बदलने से अक्सर अलग लक्ष्य फ़ंक्शन प्राप्त होता है, जो मॉडल की भविष्यवाणियों को प्रभावित कर सकता है। प्रशिक्षण डेटा के बदलने पर हमारा लक्ष्य फ़ंक्शन जितना बदलता है, उसे वैरिएंस कहते हैं। हम नहीं चाहते कि हमारे मॉडल में उच्च वैरिएंस हो, क्योंकि भले ही एल्गोरिदम प्रशिक्षण के दौरान बेदाग प्रदर्शन करे, वह अनदेखे उदाहरणों पर सामान्यीकरण करने में विफल रहता है।

ऊपर की छवि में, सन्निकटित लक्ष्य फ़ंक्शन हरी रेखा है और श्रेष्ठ फिट की रेखा काली है। देखें कि हरी रेखा के साथ मॉडल प्रशिक्षण डेटा को कितना अच्छी तरह सीखता है। यह पूरी कोशिश करता है कि सभी लाल और नीले अवलोकन अलग-अलग हो जाएं। यदि हम इस मॉडल को नए अवलोकनों पर प्रशिक्षित करें, तो यह पूरी तरह नया लक्ष्य फ़ंक्शन सीख लेगा और वही व्यवहार दोहराने की कोशिश करेगा।

एक परिदृश्य पर विचार करें जिसमें हम लक्ष्य फ़ंक्शन का सन्निकटन करने के लिए लिनियर रिग्रेशन जैसी रैखिक विधि का उपयोग करते हैं। रेखीय प्रतिगमन के बारे में पहली बात यह है कि यह इनपुट डेटा और लक्ष्य के बीच रैखिक संबंध मानता है। वास्तविक दुनिया की घटनाएँ कहीं अधिक जटिल होती हैं। कुछ लचीलेपन की कीमत पर, यह सरल मान्यता लक्ष्य फ़ंक्शन को सीखना बहुत तेज़ और समझना आसान बना देती है। हम इस प्रतिमान को बायस कहते हैं।

ऊपर की छवि में लाल रेखा सीखे गए लक्ष्य फ़ंक्शन का प्रतिनिधित्व करती है। कई अवलोकन मॉडल द्वारा भविष्यवाणी किए गए मानों से काफ़ी दूर गिरते हैं।

हम किसी मॉडल में लचीलापन बढ़ाकर बायस को कम कर सकते हैं, लेकिन इससे वैरिएंस आता है। दूसरी ओर, मॉडल को सरल बनाकर वैरिएंस कम किया जा सकता है, पर इससे बायस बढ़ता है। इस संबंध से बचने का कोई तरीका नहीं है। सर्वोत्तम विकल्प यह है कि ऐसा मॉडल चुनें और कॉन्फ़िगर करें जो बायस और वैरिएंस के बीच संतुलन स्थापित करे।

लक्ष्य फ़ंक्शन को प्रभावित करने वाले अज्ञात कारकों के कारण, मॉडल में हमेशा कुछ त्रुटि मौजूद रहेगी, जिसे अघटनीय त्रुटि कहा जाता है। इसे ऊपर की छवि में Total Error प्लॉट के सबसे निचले बिंदु के नीचे मौजूद त्रुटि की मात्रा से देखा जा सकता है। आदर्श मॉडल बनाने के लिए, हमें बायस और वैरिएंस के बीच ऐसा संतुलन खोजना होगा जिससे कुल त्रुटि न्यूनतम हो। इसे Optimum Model Complexity नामक बिंदीदार रेखा से दर्शाया गया है।

आइए लर्निंग कर्व्स का उपयोग करके बायस और वैरिएंस पर विस्तार से चर्चा करें।

लर्निंग कर्व की संरचना

लर्निंग कर्व ऐसे प्लॉट होते हैं जो प्रशिक्षण सेट का आकार बढ़ने के साथ मॉडल के प्रदर्शन को दिखाते हैं। एक और तरीका यह है कि किसी परिभाषित समयावधि में मॉडल के प्रदर्शन को दिखाया जाए। हम आमतौर पर उनका उपयोग उन एल्गोरिदम का निदान करने के लिए करते हैं जो डेटा से क्रमिक रूप से सीखते हैं। यह प्रशिक्षण और वैलिडेशन डेटासेट्स पर मॉडल का मूल्यांकन करके, फिर मापा गया प्रदर्शन प्लॉट करके काम करता है।

उदाहरण के लिए, मान लें हमने किसी मशीन लर्निंग एल्गोरिदम का उपयोग करके कुछ इनपुट और आउटपुट के बीच संबंध का मॉडल बनाया है। हम एक उदाहरण पर मॉडल को प्रशिक्षित करके और सौ उदाहरणों पर उसे वैलिडेट करके शुरू करते हैं। आपका क्या मानना है, क्या होगा? यदि आपने कहा कि मॉडल प्रशिक्षण डेटा को पूरी तरह सीख लेगा, तो आप सही हैं — कोई त्रुटि नहीं होगी।

एक इनपुट-आउटपुट संबंध का मॉडल बनाना कठिन नहीं है; बस उस संबंध को याद रखना होता है। कठिनाई तब आती है जब नए, अनदेखे उदाहरणों पर सटीक भविष्यवाणी करनी होती है। चूँकि हमारे मॉडल ने प्रशिक्षण डेटा को बहुत अच्छी तरह सीख लिया, यह पहले न देखे गए डेटा पर सामान्यीकरण करने में बुरी तरह विफल रहेगा। परिणामस्वरूप, मॉडल हमारा वैलिडेशन डेटा पर खराब प्रदर्शन करेगा। इसका अर्थ होगा कि प्रशिक्षण डेटा और वैलिडेशन डेटा पर मॉडल के प्रदर्शन के बीच बड़ा अंतर होगा। इस अंतर को हम जनरलाइज़ेशन एरर कहते हैं।

यदि हमारे एल्गोरिदम को वैलिडेशन डेटासेट पर बेहतर भविष्यवाणियाँ करने का कोई मौका देना है, तो हमें अधिक डेटा जोड़ने की आवश्यकता है। प्रशिक्षण डेटा में नए उदाहरण जोड़ने से अनिवार्य रूप से हमारे मॉडल का लक्ष्य फ़ंक्शन बदल जाएगा। जैसे-जैसे हम प्रशिक्षण डेटासेट बढ़ाते हैं, मॉडल कैसा प्रदर्शन करता है, इसे मॉनिटर और प्लॉट करके प्रशिक्षण और वैलिडेशन त्रुटि स्कोरों का विकास दिखाया जा सकता है।

इसका मतलब है कि ग्राफ दो अलग-अलग परिणाम दिखाएगा:

• ट्रेनिंग कर्व: प्रशिक्षण डेटा से निकाली गई कर्व; बताती है कि मॉडल कितना अच्छा सीख रहा है।
• वैलिडेशन कर्व: वैलिडेशन डेटा से निकाली गई कर्व; बताती है कि मॉडल अनदेखे उदाहरणों पर कितना अच्छा सामान्यीकरण कर रहा है।

ये कर्व्स हमें दिखाती हैं कि जैसे-जैसे डेटा बढ़ता है, मॉडल कैसा प्रदर्शन करता है; इसलिए इन्हें लर्निंग कर्व्स कहा जाता है।

नोट: यही प्रक्रिया समय के साथ हमारे मॉडल के सीखने के तरीके के बारे में भी बताने के लिए इस्तेमाल की जा सकती है। डेटा बढ़ने के साथ प्रदर्शन मॉनिटर करने के बजाय, हम समय के साथ मॉडल कितना सीखता है, यह मॉनिटर करते हैं। उदाहरण के लिए, आप कोई नई भाषा सीखने का निर्णय लेते हैं। 52 हफ्तों में आपका कितना सुधार हुआ, इसे संख्यात्मक स्कोर देकर आँका जा सकता है।

अब आपने लर्निंग कर्व की संरचना समझ ली है; आइए इसे किसी वास्तविक-जीवन डेटासेट पर लागू करके दृश्य समझ विकसित करें।

उपयोग मामला: रियल एस्टेट वैल्यूएशन का पूर्वानुमान

हम यह डेटासेट उपयोग करेंगे: रियल एस्टेट वैल्यूएशन का मार्केट हिस्टोरिकल डेटा सेट। यह डेटा Sindian Dist., New Taipei, Taiwan से एकत्र किया गया है और मार्केट के ऐतिहासिक डेटा से बना है।

हमारा कार्य निम्नलिखित फीचर्स के आधार पर रियल एस्टेट वैल्यूएशन की भविष्यवाणी करना है:

• X1 = लेन-देन की तारीख (उदा., 2013.250 = मार्च 2013, 2013.500 = जून 2013, आदि)
• X2 = मकान की आयु (इकाई: वर्ष)
• X3 = निकटतम MRT स्टेशन तक दूरी (इकाई: मीटर)
• X4 = पैदल दूरी के रहने के दायरे में कन्वीनिएंस स्टोर्स की संख्या (पूर्णांक)
• X5 = भौगोलिक निर्देशांक, अक्षांश (इकाई: डिग्री)
• X6 = भौगोलिक निर्देशांक, देशांतर (इकाई: डिग्री)

लक्ष्य चर परिभाषित है:

• Y = इकाई क्षेत्रफल का मकान मूल्य (10000 न्यू ताइवान डॉलर/पिंग, जहाँ पिंग एक स्थानीय इकाई है, 1 पिंग = 3.3 वर्ग मीटर)

हम जो लक्ष्य भविष्यवाणी कर रहे हैं वह सतत है, इसलिए समस्या के लिए रिग्रेशन तकनीकों की आवश्यकता होगी।

आइए डेटा पर एक नज़र डालकर शुरू करें:

import pandas as pd

data = pd.read_excel("/content/gdrive/MyDrive/real_estate_valuation_data.xlsx")
print(data.info())
data.head()

>>>>
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 414 entries, 0 to 413
Data columns (total 8 columns):
 #   Column                                  Non-Null Count  Dtype  
---  ------                                  --------------  -----  
 0   No                                      414 non-null    int64  
 1   X1 transaction date                     414 non-null    float64
 2   X2 house age                            414 non-null    float64
 3   X3 distance to the nearest MRT station  414 non-null    float64
 4   X4 number of convenience stores         414 non-null    int64  
 5   X5 latitude                             414 non-null    float64
 6   X6 longitude                            414 non-null    float64
 7   Y house price of unit area              414 non-null    float64
dtypes: float64(6), int64(2)
memory usage: 26.0 KB
None

No    X1 transaction date    X2 house age    X3 distance to the nearest MRT station    X4 number of convenience stores    X5 latitude    X6 longitude    Y house price of unit area
0    1    2012.916667    32.0    84.87882    10    24.98298    121.54024    37.9
1    2    2012.916667    19.5    306.59470    9    24.98034    121.53951    42.2
2    3    2013.583333    13.3    561.98450    5    24.98746    121.54391    47.3
3    4    2013.500000    13.3    561.98450    5    24.98746    121.54391    54.8
4    5    2012.833333    5.0    390.56840    5    24.97937    121.54245    43.1

यहाँ एक अतिरिक्त फीचर No नाम से है जिसका दस्तावेज़ में उल्लेख नहीं है। संभव है कि यह इंडेक्स को संदर्भित करता हो, लेकिन सरलता के लिए हम इसे हटा देंगे। साथ ही, फीचर नाम दस्तावेज़ में दिए गए नामों को प्रतिबिंबित नहीं करते, इसलिए हम इन्हें साफ़ करेंगे।

# rename the columns
renamed_columns = [col.split()[0] for col in data.columns]
renamed_columns_map = {data.columns[i]:renamed_columns[i] for i in range(len(data.columns))}

data.rename(renamed_columns_map, axis=1, inplace=True)

# remove No column
data.drop("No", axis=1, inplace=True)

print(data.head())

# separate features and target data
features, target = data.columns[:-1], data.columns[-1]

X = data[features]
y = data[target]

फ़ीचर्स और टार्गेट लेबल्स को अलग करने से पहले अंतिम डेटासेट इस प्रकार दिखता है:

        X1          X2          X3      X4      X5          X6        Y
0   2012.916667     32.0    84.87882    10  24.98298    121.54024   37.9
1   2012.916667     19.5    306.59470   9   24.98034    121.53951   42.2
2   2013.583333     13.3    561.98450   5   24.98746    121.54391   47.3
3   2013.500000     13.3    561.98450   5   24.98746    121.54391   54.8
4   2012.833333     5.0     390.56840   5   24.97937    121.54245   43.1

बायस, वैरिएंस और गुड-फिट समाधानों को प्रदर्शित करने के लिए, हम तीन मॉडल बनाएंगे: एक डिसीजन ट्री रिग्रेसर, रिग्रेशन के लिए सपोर्ट वेक्टर मशीन, और एक रैंडम फॉरेस्ट रिग्रेसर। मॉडल बनाने के बाद, हम प्रत्येक के लिए लर्निंग कर्व्स प्लॉट करेंगे और कुछ डायग्नोस्टिक तकनीकें साझा करेंगे।

लर्निंग कर्व्स का निदान

लर्निंग कर्व्स की व्याख्या उनके आकार का आकलन करके की जाती है। एक बार आकार और डायनेमिक्स समझ आने पर, हम उनका उपयोग किसी मशीन लर्निंग मॉडल के व्यवहार में समस्याओं का निदान करने के लिए कर सकते हैं।

Scikit-learn में learning_curve() फ़ंक्शन हमें प्रशिक्षण और वैलिडेशन स्कोर मॉनिटर करने में आसानी देता है, जो कि लर्निंग कर्व प्लॉट करने के लिए आवश्यक है।

learning_curve() फ़ंक्शन को दिए जाने वाले पैरामीटर इस प्रकार हैं:

• estimator: लक्ष्य फ़ंक्शन का सन्निकटन करने के लिए इस्तेमाल किया गया मॉडल
• X: इनपुट डेटा
• y: लक्ष्य
• cv: क्रॉस-वैलिडेशन विभाजन रणनीति
• scoring: मॉडल के प्रदर्शन का मूल्यांकन करने के लिए प्रयुक्त मीट्रिक
• train_sizes: वे प्रशिक्षण उदाहरणों की पूर्ण संख्याएँ जिनका उपयोग लर्निंग कर्व जनरेट करने में होगा; हम जो मान उपयोग कर रहे हैं, वे पूरी तरह यादृच्छिक हैं।

मॉडल 1: डिसीजन ट्री रिग्रेसर

उच्च वैरिएंस वाला मॉडल ओवरफिट कहलाता है। यह प्रशिक्षण डेटा और यादृच्छिक शोर को भी बहुत अच्छी तरह सीख लेता है, जिससे प्रशिक्षण डेटा पर अच्छा प्रदर्शन तो होता है, लेकिन अनदेखे उदाहरणों पर सामान्यीकरण विफल रहता है। ऐसा व्यवहार तब दिखता है जब प्रयुक्त एल्गोरिदम हल की जा रही समस्या के लिए बहुत अधिक लचीला हो, या मॉडल को बहुत लंबे समय तक प्रशिक्षित किया गया हो।

उदाहरण के लिए, डिसीजन ट्री रिग्रेसर एक नॉन-लिनियर मशीन लर्निंग एल्गोरिदम है। नॉन-लिनियर एल्गोरिदम आमतौर पर कम बायस और उच्च वैरिएंस रखते हैं। इसका अर्थ है कि डेटासेट में बदलाव लक्ष्य फ़ंक्शन में बड़े बदलाव कर सकते हैं।

आइए अपने डिसीजन ट्री रिग्रेसर से उच्च वैरिएंस का प्रदर्शन करें:

from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt

# overfitting
decision_tree = DecisionTreeRegressor()

train_sizes, train_scores, test_scores = learning_curve(
    estimator=decision_tree,
    X=X,
    y=y,
    cv=5,
    scoring="neg_root_mean_squared_error",
    train_sizes = [1, 75, 165, 270, 331]
)

train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)

plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")

plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")

plt.show()

मॉडल प्रशिक्षण के दौरान देखे गए उदाहरणों की भविष्यवाणी करते समय बहुत कम गलती करता है, लेकिन नए उदाहरणों पर जिनसे यह नहीं गुज़रा, बेहद खराब प्रदर्शन करता है। इसे आप प्रशिक्षण कर्व और वैलिडेशन कर्व के बीच बड़े जनरलाइज़ेशन एरर से देख सकते हैं। इस व्यवहार को सुधारने का एक समाधान यह हो सकता है कि प्रशिक्षण डेटासेट में और उदाहरण जोड़े जाएँ, जो बायस को परिचित करता है। एक और समाधान मॉडल में रेग्युलराइज़ेशन जोड़ना हो सकता है (जैसे, पेड़ को उसकी पूरी गहराई तक बढ़ने से रोकना)।

मॉडल 2: सपोर्ट वेक्टर मशीन

उच्च बायस वाला मॉडल अंडरफिट कहलाता है। यह प्रशिक्षण डेटा के बारे में सरलीकृत मान्यताएँ बनाता है, जिससे अंतर्निहित पैटर्न सीखना कठिन हो जाता है। परिणामस्वरूप प्रशिक्षण और वैलिडेशन दोनों डेटासेट्स पर उच्च त्रुटि मिलती है। ऐसा व्यवहार तब दिखता है जब प्रयुक्त मॉडल हल की जा रही समस्या के लिए बहुत सरल हो, या मॉडल को पर्याप्त समय तक प्रशिक्षित न किया गया हो।

उदाहरण के लिए, सपोर्ट वेक्टर मशीन एक रैखिक मशीन लर्निंग एल्गोरिदम है। रैखिक एल्गोरिदम आमतौर पर उच्च बायस और कम वैरिएंस रखते हैं। इसका मतलब है कि लक्ष्य फ़ंक्शन के रूप के बारे में अधिक मान्यताएँ बनाई जाती हैं। अपने मॉडल में अधिक बायस लाने के लिए, हमने अपने मॉडल में C पैरामीटर सेट करके रेग्युलराइज़ेशन जोड़ा है।

आइए अपनी सपोर्ट वेक्टर मशीन से उच्च बायस का प्रदर्शन करें:

from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler

# Underfitting
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

svm = SVR(C=0.25)

train_sizes, train_scores, test_scores = learning_curve(
    estimator=svm,
    X=X_scaled,
    y=y,
    cv=5,
    scoring="neg_root_mean_squared_error",
    train_sizes = [1, 75, 150, 270, 331]
)

train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)

plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")

plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")

plt.show()

जैसे-जैसे प्रशिक्षण डेटासेट का आकार बढ़ता है, प्रशिक्षण और वैलिडेशन कर्व का जनरलाइज़ेशन गैप अत्यंत छोटा हो जाता है। यह इंगित करता है कि मॉडल में और उदाहरण जोड़ने से इसका प्रदर्शन सुधरने वाला नहीं है। इस समस्या का समाधान अधिक फीचर्स बनाना या मॉडल को अधिक लचीला बनाना हो सकता है ताकि की जा रही मान्यताएँ कम हों।

मॉडल 3: रैंडम फॉरेस्ट रिग्रेसर

एक अच्छा-फिट मॉडल अंडरफिट और ओवरफिट मॉडल के बीच के धूसर क्षेत्र में आता है। यह मॉडल प्रशिक्षण डेटा पर ओवरफिट स्थिति जितना अच्छा न हो, लेकिन अनदेखे उदाहरणों का सामना करने पर कहीं कम त्रुटियाँ करेगा। यह व्यवहार तब देखा जा सकता है जब वैलिडेशन त्रुटि स्थिरता के बिंदु तक घटती है, जबकि प्रशिक्षण त्रुटि बढ़ती है, लेकिन केवल स्थिरता के बिंदु तक।

इसे प्रदर्शित करने के लिए हम रैंडम फॉरेस्ट का उपयोग करने जा रहे हैं, जो डिसीजन ट्रीज़ का एंसेंबल है। इसका अर्थ है कि मॉडल भी नॉन-लिनियर है, लेकिन कई विविध मॉडलों को बनाकर और उनकी भविष्यवाणियों को मिलाकर इसमें बायस जोड़ा जाता है।

हमने max_depth सेट करके अधिक रेग्युलराइज़ेशन भी जोड़ा है, जो प्रत्येक पेड़ की अधिकतम गहराई को नियंत्रित करता है, और इसे तीन पर रखा है।

आइए देखें, कोड में यह कैसा दिखता है:

from sklearn.ensemble import RandomForestRegressor

# better
random_forest = RandomForestRegressor(max_depth=3)

train_sizes, train_scores, test_scores = learning_curve(
    estimator=random_forest,
    X=X,
    y=y,
    cv=5,
    scoring="neg_root_mean_squared_error",
    train_sizes = [1, 75, 150, 270, 331]
)

train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)

plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")

plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")

plt.show()

अब आप देख सकते हैं कि हमने वैलिडेशन डेटा में त्रुटि घटा दी है। इसका मूल्य प्रशिक्षण डेटा पर प्रदर्शन में कमी के रूप में चुकाना पड़ा, लेकिन समग्र रूप से यह बेहतर मॉडल है।

जनरलाइज़ेशन एरर अब काफ़ी छोटा है, और त्रुटियों की संख्या कम है। साथ ही, 250 के प्रशिक्षण सेट आकार से आगे दोनों कर्व स्थिर हैं, जो संकेत देता है कि और उदाहरण जोड़ने से यह मॉडल बहुत अधिक नहीं सुधरेगा।

संक्षेप में, किसी मॉडल के व्यवहार का अवलोकन लर्निंग कर्व्स से किया जा सकता है। मशीन लर्निंग मॉडल बनाते समय आदर्श परिदृश्य त्रुटि को यथासंभव कम रखना है। उच्च त्रुटि के दो कारक बायस और वैरिएंस हैं, और इन दोनों के बीच संतुलन साधने से बेहतर प्रदर्शन करने वाला मॉडल प्राप्त होता है।