PricingLoginStart free
Machine Learning Academy · पाठ

k चुनना: एल्बो विधि और सत्यापन वक्र

शिक्षार्थी k को 1 से 30 तक बदलकर देखेंगे, सत्यापन सटीकता का आलेख बनाएँगे और पक्षपात तथा विचरण के संतुलन वाला सर्वोत्तम बिंदु पहचानेंगे।

पाठ 2, कुल 4 में से13 चरण

k चुनना: एल्बो विधि और सत्यापन वक्र, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

k चुनना क्यों महत्वपूर्ण है

K का मान KNN का सबसे महत्वपूर्ण हाइपरपैरामीटर है। बहुत छोटा k (जैसे, k=1) मॉडल को शोर के प्रति अत्यधिक संवेदनशील बना देता है: प्रत्येक प्रशिक्षण बिंदु अपना अलग भविष्यवाणी क्षेत्र बना लेता है, जिससे मॉडल पैटर्न सीखने के बजाय शोर को याद करने लगता है। बहुत बड़ा k निर्णय सीमा को अत्यधिक चिकना कर देता है और वास्तव में अलग-अलग वर्गों को मिला सकता है। सही k ढूँढना bias-variance की समस्या है: छोटा k = कम bias, अधिक variance; बड़ा k = अधिक bias, कम variance। Elbow विधि और validation curves अनुभवजन्य रूप से सर्वोत्तम k पहचानने में मदद करते हैं।

# k=1: memorises training set perfectly
# Training accuracy = 100%, test accuracy low (overfitting)

# k=N (all neighbors): always predicts majority class
# Training accuracy = majority fraction (underfitting)

# Optimal k: somewhere in between
# Maximises test/validation accuracy

from sklearn.neighbors import KNeighborsClassifier
print('k=1  overfits (memorises noise)')
print('k=N  underfits (ignores all variation)')
print('Best k: maximises cross-validated accuracy')

k मानों की जाँच: मूल लूप

सबसे सरल तरीका है कि k मानों की एक सीमा के लिए KNN को प्रशिक्षित करें, प्रत्येक का मूल्यांकन validation सेट पर करें और सबसे अधिक validation accuracy वाले k को चुनें। Scikit-learn इसे सरल बनाता है: 1 से किसी अधिकतम मान तक k पर लूप चलाएँ और प्रत्येक मॉडल को fit करके उसका score निकालें। हमेशा अलग रखे गए validation सेट पर मूल्यांकन करें या cross-validation का उपयोग करें — training सेट पर मूल्यांकन करने से हमेशा k=1 चुना जाएगा (क्योंकि k=1 होने पर KNN प्रशिक्षण बिंदुओं को याद करके 100% accuracy से उनका अनुमान लगाता है)।

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_tr = scaler.fit_transform(X_train)
X_v  = scaler.transform(X_val)

val_scores = []
for k in range(1, 31):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_tr, y_train)
    val_scores.append(knn.score(X_v, y_val))

best_k = val_scores.index(max(val_scores)) + 1
print('Best k:', best_k, 'with accuracy:', max(val_scores).round(3))

Validation Curve का आलेख बनाना

k के सापेक्ष validation accuracy का दृश्यांकन दो महत्वपूर्ण पैटर्न दिखाता है। कम k पर curve अधिक variance के कारण शोरयुक्त होती है (मॉडल अलग-अलग प्रशिक्षण बिंदुओं पर प्रतिक्रिया करता है)। जैसे-जैसे k बढ़ता है, accuracy आमतौर पर एक शिखर तक सुधरती है, फिर धीरे-धीरे घटती है क्योंकि मॉडल बहुत अधिक चिकना हो जाता है। सर्वोत्तम k validation curve के शिखर पर होता है। एक ही validation विभाजन में यह आकृति हमेशा स्पष्ट नहीं होती, इसलिए cross-validation कई विभाजनों का औसत लेकर अधिक विश्वसनीय अनुमान देता है।

import matplotlib.pyplot as plt
import numpy as np

k_values = range(1, 31)
# val_scores computed from previous sweep
plt.figure(figsize=(10, 5))
plt.plot(k_values, val_scores, marker='o', label='Validation accuracy')
plt.axvline(x=best_k, color='r', linestyle='--', label=f'Best k={best_k}')
plt.xlabel('k (Number of Neighbors)')
plt.ylabel('Validation Accuracy')
plt.title('KNN Validation Curve')
plt.legend()
plt.grid(True)
plt.show()

प्रत्येक k के लिए Cross-Validated Accuracy

एक ही validation विभाजन पक्षपाती हो सकता है, क्योंकि यह इस बात पर निर्भर करता है कि कौन-से नमूने validation सेट में पहुँचे। Cross-validation k विभाजनों का औसत निकालता है, जिससे अधिक स्थिर अनुमान मिलता है। प्रत्येक k मान के लिए Scikit-learn के cross_val_score को call किया जा सकता है। औसत accuracy प्रवृत्ति दिखाती है और folds में standard deviation विश्वसनीयता दर्शाता है। सबसे अधिक mean cross-validated accuracy वाले k को चुनें; यदि कई k मानों के परिणाम पास-पास हों, तो अधिक चिकनी और अधिक सामान्यीकृत भविष्यवाणियों के लिए बड़ा k चुनें।

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
import numpy as np

X, y = load_iris(return_X_y=True)

cv_means, cv_stds = [], []
for k in range(1, 31):
    pipe = Pipeline([('sc', StandardScaler()),
                     ('knn', KNeighborsClassifier(n_neighbors=k))])
    scores = cross_val_score(pipe, X, y, cv=10)
    cv_means.append(scores.mean())
    cv_stds.append(scores.std())

best_k_cv = np.argmax(cv_means) + 1
print('Best k by CV:', best_k_cv, 'mean accuracy:', max(cv_means).round(3))

Elbow विधि की अवधारणा

Elbow विधि उस उपयुक्त बिंदु को खोजने की एक दृश्य तकनीक है जहाँ accuracy में सुधार बहुत कम हो जाता है। validation accuracy (या error) का k के सापेक्ष आलेख बनाएँ; curve आमतौर पर छोटे k पर तेज़ सुधार दिखाती है और फिर समतल होने लगती है। Elbow — अर्थात वह बिंदु जहाँ curve तेज़ से समतल दिशा में मुड़ती है — अक्सर सर्वोत्तम k होता है। इसका तर्क घटते लाभ का है: इस बिंदु के बाद और पड़ोसी जोड़ने से accuracy में सार्थक सुधार नहीं होता, लेकिन bias बढ़ता है। Elbow हमेशा स्पष्ट नहीं होता, इसलिए अंतिम चयन के लिए CV जैसी मात्रात्मक विधियों को प्राथमिकता दी जाती है।

import matplotlib.pyplot as plt
import numpy as np

k_range = range(1, 31)
error_rates = [1 - acc for acc in cv_means]  # Convert accuracy to error

plt.figure(figsize=(10, 5))
plt.plot(list(k_range), error_rates, marker='o')
plt.xlabel('k')
plt.ylabel('Cross-Validated Error Rate')
plt.title('Elbow Method for Optimal k')
plt.grid(True)

# Mark the elbow visually
plt.axvline(x=best_k_cv, color='r', linestyle='--', label=f'Elbow at k={best_k_cv}')
plt.legend()
plt.show()

scikit-learn से validation_curve का उपयोग

Scikit-learn सुविधा के लिए validation_curve() उपलब्ध कराता है। यह हाइपरपैरामीटर मानों की सीमा पर जाँच करता है और प्रत्येक मान के लिए training तथा validation scores लौटाता है। यह मैन्युअल लूप से अधिक साफ़ तरीका है, क्योंकि यह आंतरिक रूप से cross-validation संभालता है। param_name तर्क pipeline के पैरामीटरों के लिए double-underscore संकेत-पद्धति का उपयोग करता है (जैसे, knn__n_neighbors)। training और validation curves को साथ में आलेखित करने से पता चलता है कि कम प्रदर्शन underfitting (दोनों कम), overfitting (train अधिक, val कम) या अच्छे generalisation (दोनों अधिक) के कारण है।

from sklearn.model_selection import validation_curve
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
import numpy as np

pipe = Pipeline([('sc', StandardScaler()), ('knn', KNeighborsClassifier())])

train_scores, val_scores = validation_curve(
    pipe, X, y,
    param_name='knn__n_neighbors',
    param_range=range(1, 31),
    cv=10, scoring='accuracy'
)

train_mean = np.mean(train_scores, axis=1)
val_mean   = np.mean(val_scores, axis=1)

print('Best k:', np.argmax(val_mean) + 1)

KNN में Bias-Variance का संतुलन

Validation curve bias-variance के संतुलन को सीधे दिखाती है। छोटे k के लिए: training accuracy 100% के पास पहुँचती है (कम bias, मॉडल training डेटा पर पूरी तरह fit होता है), जबकि validation accuracy कम होती है (अधिक variance, मॉडल अलग-अलग बिंदुओं के प्रति अत्यधिक संवेदनशील होता है)। बड़े k के लिए: training accuracy घटती है (मॉडल underfit करता है) और validation accuracy भी घटती है (अधिक bias)। सर्वोत्तम k उस बिंदु पर होता है जहाँ दोनों का प्रतिच्छेदन होता है और training तथा validation accuracy का अंतर छोटा रहते हुए दोनों अधिकतम होते हैं — यही सामान्यीकरण का सबसे उपयुक्त बिंदु है।

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(10, 5))
k_range = list(range(1, 31))

ax.plot(k_range, train_mean, label='Training accuracy', color='blue')
ax.plot(k_range, val_mean, label='Validation accuracy', color='orange')
ax.fill_between(k_range,
    np.mean(train_scores, axis=1) - np.std(train_scores, axis=1),
    np.mean(train_scores, axis=1) + np.std(train_scores, axis=1),
    alpha=0.1, color='blue')

ax.set_xlabel('k')
ax.set_ylabel('Accuracy')
ax.set_title('Bias-Variance Trade-off: KNN Validation Curve')
ax.legend()
plt.show()

विषम और सम k के आधार पर चयन

द्विआधारी classification के लिए बराबरी से बचने हेतु हमेशा k के विषम मानों को प्राथमिकता दें। k=4 और दो वर्गों के साथ दोनों को 2-2 मत मिल सकते हैं — तब बराबरी तोड़ने का नियम परिणाम तय करता है, जो मनमाना हो सकता है। k=3 या k=5 का उपयोग करने पर दो वर्गों के साथ बराबरी संभव नहीं होती। बहु-वर्गीय समस्याओं में C वर्गों के लिए भी इसी कारण k, C का multiple नहीं होना चाहिए। जब सर्वोत्तम k के आसपास के मानों का प्रदर्शन लगभग समान हो, तब यह छोटा-सा लेकिन व्यवहार में महत्वपूर्ण विवरण है।

# Best practice for binary classification: pick odd k
# For multi-class (C classes): avoid multiples of C

def recommend_k(k_optimal, n_classes):
    if n_classes == 2:
        # Make odd
        return k_optimal if k_optimal % 2 == 1 else k_optimal + 1
    else:
        # Avoid multiples of n_classes
        while k_optimal % n_classes == 0:
            k_optimal += 1
        return k_optimal

print('Binary, k=4 -> recommended:', recommend_k(4, 2))  # 5
print('3-class, k=6 -> recommended:', recommend_k(6, 3)) # 7

k चयन के लिए GridSearchCV

GridSearchCV cross-validation के माध्यम से प्रत्येक संभावित मान का मूल्यांकन करके और सर्वोत्तम मान लौटाकर k चयन को स्वचालित करता है। इसे scaling pipeline के साथ मिलाएँ और double-underscore कुंजी के साथ param_grid दें। GridSearchCV पूरे training सेट पर सर्वोत्तम मॉडल को फिर से प्रशिक्षित भी करता है, इसलिए fit करने के तुरंत बाद grid.best_estimator_ उत्पादन में उपयोग के लिए तैयार होता है। यह अनुशंसित तरीका है जब k चयन किसी बड़े हाइपरपैरामीटर अनुकूलन का हिस्सा हो।

from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

pipe = Pipeline([
    ('sc', StandardScaler()),
    ('knn', KNeighborsClassifier())
])

param_grid = {
    'knn__n_neighbors': list(range(1, 31, 2)),  # odd values 1-29
    'knn__weights': ['uniform', 'distance']
}

grid = GridSearchCV(pipe, param_grid, cv=10, scoring='accuracy', n_jobs=-1)
grid.fit(X_train, y_train)

print('Best k:', grid.best_params_['knn__n_neighbors'])
print('Best weights:', grid.best_params_['knn__weights'])
print('Best CV accuracy:', grid.best_score_.round(3))

परिणामों की व्याख्या और अंतिम k चयन

जब कई k मानों से validation scores लगभग समान मिलें, तो बड़ा k चुनें ताकि भविष्यवाणियाँ अधिक चिकनी और मजबूत हों तथा अलग-अलग शोरयुक्त बिंदुओं के प्रति कम संवेदनशील रहें। Cross-validation scores के standard deviation की जाँच करें: यदि छोटे k का mean अधिक हो लेकिन std भी अधिक हो, तो बड़ा k उत्पादन में वास्तव में अधिक विश्वसनीय हो सकता है। अंतिम मॉडल को पूरे training सेट पर फिर से प्रशिक्षित किया जाना चाहिए (केवल cross-validation के training folds पर नहीं), चुने गए k का उपयोग करके, और अलग रखे गए test सेट पर एक बार मूल्यांकन किया जाना चाहिए।

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# Select best k from validation
best_k = 11  # determined from CV

# Retrain on full training data
final_model = Pipeline([
    ('sc', StandardScaler()),
    ('knn', KNeighborsClassifier(n_neighbors=best_k, weights='distance'))
])
final_model.fit(X_train, y_train)

# Evaluate once on held-out test set
test_accuracy = final_model.score(X_test, y_test)
print(f'Final test accuracy with k={best_k}: {test_accuracy:.3f}')

k चुनते समय सामान्य गलतियाँ

इन तीन सामान्य गलतियों से बचें: (1) training डेटा पर मूल्यांकन करना — k=1 हमेशा 100% score करेगा और सर्वोत्तम दिखाई देगा; हमेशा अलग रखे गए या cross-validated डेटा का उपयोग करें। (2) k चुनने से पहले features का scaling न करना — सर्वोत्तम k दूरी की ज्यामिति पर निर्भर करता है, जो scaling के साथ बदलती है; हाइपरपैरामीटर खोज से पहले pipeline में scaler को हमेशा शामिल करें। (3) डेटासेट के आकार से स्वतंत्र रूप से k चुनना — सामान्य नियम के रूप में शुरुआत k को sqrt(N) के आसपास रखकर करें, जहाँ N training सेट का आकार है, फिर CV के माध्यम से इसे बेहतर निर्धारित करें।

import numpy as np

N_train = 1000  # training samples

# Rule of thumb starting point
k_start = int(np.sqrt(N_train))
print(f'sqrt(N) starting point: k = {k_start}')

# Then sweep around this value
k_candidates = list(range(max(1, k_start - 10), k_start + 11, 2))
print('Candidates to sweep:', k_candidates)

# AVOID:
# knn.score(X_train, y_train) -- always pick k=1
# Not including scaler in pipeline before CV

त्वरित जाँच

इस पाठ में दिए गए Python के साथ मशीन लर्निंग की अवधारणाओं की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: छोटा k overfitting और बड़ा k underfitting क्यों कराता है, k मानों की जाँच करके सर्वोत्तम मान खोजने के लिए cross-validation और validation_curve का उपयोग कैसे करें, और द्विआधारी classification में विषम k मान बराबरी को क्यों रोकते हैं। आगे हम अलग-अलग distance metrics — Euclidean, Manhattan और Minkowski — तथा उनके बीच चयन करना सीखेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
30
पाठ
120
निःशुल्क सीखना शुरू करेंपूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “k चुनना: एल्बो विधि और सत्यापन वक्र” पाठ निःशुल्क है?

हाँ—“k चुनना: एल्बो विधि और सत्यापन वक्र” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“k चुनना: एल्बो विधि और सत्यापन वक्र” में मैं क्या सीखूँगा?

शिक्षार्थी k को 1 से 30 तक बदलकर देखेंगे, सत्यापन सटीकता का आलेख बनाएँगे और पक्षपात तथा विचरण के संतुलन वाला सर्वोत्तम बिंदु पहचानेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“k चुनना: एल्बो विधि और सत्यापन वक्र” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. KNN कैसे काम करता है: दूरी, पड़ोसी और मत
  2. k चुनना: एल्बो विधि और सत्यापन वक्र
  3. दूरी के माप: यूक्लिडीय, मैनहैटन और मिंकोव्स्की
  4. प्रतिगमन के लिए KNN और इसकी विस्तार-क्षमता की सीमाएँ
← Machine Learning Academy पर वापस जाएँ