KNN कैसे काम करता है: दूरी, पड़ोसी और मत
शिक्षार्थी 2D डेटासेट का दृश्यांकन करेंगे, यूक्लिडीय दूरियों की गणना करेंगे, k निकटतम पड़ोसियों की पहचान करेंगे और बहुमत के मत से वर्गीकरण करेंगे।
KNN कैसे काम करता है: दूरी, पड़ोसी और मत, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
KNN के पीछे की मूल अंतर्दृष्टि
K-Nearest Neighbors (KNN) मशीन लर्निंग के सबसे सहज एल्गोरिदमों में से एक है: किसी नए बिंदु का लेबल उसके सबसे पास के k लेबल किए गए बिंदुओं को देखकर और बहुमत के आधार पर निर्धारित करें। इसमें कोई स्पष्ट प्रशिक्षण चरण नहीं होता — एल्गोरिदम प्रशिक्षण डेटा को केवल स्मृति में रखता है और सारी गणना पूर्वानुमान के समय करता है। इसी कारण इसे सुस्त शिक्षार्थी कहा जाता है। यह तब अच्छी तरह काम करता है जब समान इनपुट के आउटपुट भी समान हों — उत्पादों की सिफारिश करने या रोगों का निदान करने जैसी कई वास्तविक समस्याओं में यह एक उचित मान्यता है।
# Conceptual pseudocode
def knn_predict(X_train, y_train, x_new, k=3):
# 1. Compute distance from x_new to every training point
distances = [euclidean(x_new, x_i) for x_i in X_train]
# 2. Find indices of k smallest distances
nearest = sorted(range(len(distances)), key=lambda i: distances[i])[:k]
# 3. Majority vote among k neighbors
votes = [y_train[i] for i in nearest]
return max(set(votes), key=votes.count)यूक्लिडीय दूरी: डिफ़ॉल्ट माप
KNN में सबसे सामान्य दूरी माप यूक्लिडीय दूरी है, जो फीचर स्पेस में दो बिंदुओं के बीच सीधी रेखा की दूरी होती है। दो बिंदुओं A=(a1, a2) और B=(b1, b2) के लिए यूक्लिडीय दूरी sqrt((a1-b1)^2 + (a2-b2)^2) होती है। उच्च आयामों में यही सूत्र सभी फीचरों तक विस्तारित हो जाता है। चूँकि यूक्लिडीय दूरी सभी आयामों को समान महत्त्व देती है, इसलिए फीचरों का एक ही पैमाना होना आवश्यक है — अन्यथा बड़े परिमाण वाले फीचर दूरी की गणना पर हावी हो जाते हैं और KNN का प्रदर्शन खराब हो जाता है।
import numpy as np
def euclidean_distance(a, b):
return np.sqrt(np.sum((a - b) ** 2))
point_a = np.array([1.0, 2.0])
point_b = np.array([4.0, 6.0])
dist = euclidean_distance(point_a, point_b)
print('Euclidean distance:', dist) # 5.0
# Verify with numpy
print('Using numpy:', np.linalg.norm(point_a - point_b))k निकटतम पड़ोसी खोजना
किसी क्वेरी बिंदु के दिए जाने पर, KNN सभी N प्रशिक्षण बिंदुओं से दूरी की गणना करता है, उन्हें क्रमबद्ध करता है और सबसे पास के k बिंदु चुनता है। छोटे 2D डेटासेट पर आप नए बिंदु के चारों ओर एक वृत्त बनाकर इसे देख सकते हैं, जो तब तक फैलता है जब तक उसमें ठीक k प्रशिक्षण नमूने न आ जाएँ — यही पड़ोसी हैं। प्रत्येक पूर्वानुमान की गणनात्मक लागत O(N * d) होती है, जहाँ N प्रशिक्षण बिंदुओं की संख्या और d फीचरों की संख्या है। छोटे डेटासेट के लिए यह ठीक है, लेकिन बड़े डेटासेट पर यह अत्यधिक धीमा हो जाता है।
import numpy as np
# Training data
X_train = np.array([[1,2],[2,3],[3,1],[6,5],[7,7],[8,6]])
y_train = np.array([0, 0, 0, 1, 1, 1]) # 0=class A, 1=class B
# Query point
x_new = np.array([4, 4])
# Distances to all training points
dists = np.linalg.norm(X_train - x_new, axis=1)
print('Distances:', dists.round(2))
# Indices of 3 nearest
k = 3
nearest_idx = np.argsort(dists)[:k]
print('3 nearest labels:', y_train[nearest_idx])बहुमत के आधार पर वर्गीकरण
k निकटतम पड़ोसियों को खोजने के बाद, KNN में वर्गीकरण के लिए पड़ोसियों में सबसे अधिक मत पाने वाला वर्ग चुना जाता है। k=3 के लिए, यदि 2 पड़ोसी वर्ग A के और 1 वर्ग B का है, तो पूर्वानुमान वर्ग A होगा। बराबरी की स्थिति का समाधान कार्यान्वयन द्वारा किया जाता है (आमतौर पर सबसे पास वाले एकल पड़ोसी का वर्ग चुनकर)। प्रतिगमन के लिए KNN मतदान करने के बजाय k पड़ोसियों के लक्ष्य मानों का औसत निकालता है। k=1 चुनना सबसे अधिक लचीला, लेकिन बहुत शोरयुक्त होता है; बड़ा k अधिक सहज परिणाम देता है, लेकिन मॉडल कम-फिट हो सकता है।
from collections import Counter
import numpy as np
neighbor_labels = np.array([0, 0, 1]) # 2 votes for class 0, 1 for class 1
# Majority vote
vote_counts = Counter(neighbor_labels)
prediction = vote_counts.most_common(1)[0][0]
print('Predicted class:', prediction) # 0
# For regression: average instead of vote
neighbor_values = np.array([15.2, 18.7, 14.1])
prediction_reg = np.mean(neighbor_values)
print('Regression prediction:', prediction_reg.round(2))scikit-learn के साथ KNN: KNeighborsClassifier
Scikit-learn KNeighborsClassifier और KNeighborsRegressor के माध्यम से KNN लागू करता है। ये class मानक fit/predict API का पालन करते हैं। प्रमुख पैरामीटरों में n_neighbors (k का मान), metric (दूरी फलन), और weights (समान या दूरी-भारित मतदान) शामिल हैं। दूरी-भारित मतदान (weights='distance') निकटतम पड़ोसियों को अधिक प्रभाव देता है, जिससे चुने गए k में सबसे दूर (सबसे कम समान) पड़ोसियों का प्रभाव घटने के कारण अक्सर प्रदर्शन बेहतर होता है।
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)
knn = KNeighborsClassifier(n_neighbors=5, weights='uniform')
knn.fit(X_train_s, y_train)
print('Test accuracy:', knn.score(X_test_s, y_test).round(3))निर्णय सीमा को दृश्य रूप में देखना
KNN की निर्णय सीमा मूल रूप से गैर-रैखिक और स्थानीय होती है। k=1 के साथ सीमा प्रशिक्षण डेटा का बिल्कुल अनुसरण करती है (जिससे खुरदरे Voronoi-जैसे क्षेत्र बनते हैं), जबकि बड़ा k अधिक सहज सीमाएँ बनाता है। आप 2D डेटासेट पर बारीक जाल ग्रिड पर पूर्वानुमान लगाकर और प्रत्येक क्षेत्र को उसके पूर्वानुमानित वर्ग के अनुसार रंगकर इसे देख सकते हैं। कम k प्रशिक्षण के शोर पर अत्यधिक फिट हो जाता है (हर बिंदु अपना अलग वर्ग-द्वीप बन जाता है); अधिक k अत्यधिक समतल कर देता है, जिससे अलग-अलग समूह आपस में मिल सकते हैं। आदर्श k इस पक्षपात-प्रसरण संतुलन को साधता है।
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
# Create 2D mesh for decision boundary
def plot_decision_boundary(clf, X, y):
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(
np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h)
)
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y)KNN के लिए फीचर स्केलिंग क्यों अत्यंत महत्त्वपूर्ण है
KNN फीचर स्पेस में दूरियों की गणना करता है, इसलिए प्रत्येक फीचर का पैमाना सीधे प्रभावित करता है कि किन बिंदुओं को निकटतम माना जाएगा। यदि एक फीचर के मान हजारों में हों (जैसे, आय) और दूसरे के एक अंकीय हों (जैसे, बच्चों की संख्या), तो बड़े परिमाण वाला फीचर दूरी की सभी गणनाओं पर हावी हो जाएगा। आय में 1 का अंतर रखने वाला, लेकिन अन्य सभी फीचरों में समान पड़ोसी, उस पड़ोसी से अधिक दूर माना जा सकता है जिसका अन्य सभी फीचरों में बहुत अधिक अंतर हो। KNN से पहले हमेशा StandardScaler या MinMaxScaler लागू करें।
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
# Without scaling
knn_raw = KNeighborsClassifier(n_neighbors=5)
raw_score = cross_val_score(knn_raw, X, y, cv=5).mean()
# With scaling inside pipeline
pipe = Pipeline([('sc', StandardScaler()), ('knn', KNeighborsClassifier(n_neighbors=5))])
scaled_score = cross_val_score(pipe, X, y, cv=5).mean()
print(f'Without scaling: {raw_score:.3f}')
print(f'With scaling: {scaled_score:.3f}')पड़ोसियों की दूरियाँ और इंडेक्स प्राप्त करना
कभी-कभी आपको केवल पूर्वानुमानित वर्ग से अधिक जानकारी चाहिए — आपको यह जानना होता है कि कौन-से प्रशिक्षण उदाहरण पड़ोसी थे और वे कितनी दूरी पर थे। KNN की kneighbors() विधि निकटतम प्रशिक्षण नमूनों की दूरियाँ और इंडेक्स दोनों लौटाती है। यह असामान्यता का पता लगाने (पड़ोसियों से बड़ी औसत दूरी बाहरी मान का संकेत देती है), सिफारिश प्रणालियों और अंतिम उपयोगकर्ताओं को सबसे समान ज्ञात उदाहरण दिखाकर पूर्वानुमानों की व्याख्या करने के लिए उपयोगी है।
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
X_train = np.array([[1,2],[2,3],[5,5],[8,7]])
y_train = np.array([0, 0, 1, 1])
knn = KNeighborsClassifier(n_neighbors=2)
knn.fit(X_train, y_train)
x_query = np.array([[4, 4]])
distances, indices = knn.kneighbors(x_query)
print('Neighbor indices:', indices)
print('Distances to neighbors:', distances.round(2))
print('Neighbor labels:', y_train[indices[0]])दूरी के आधार पर भारित मतदान
समान मतदान सभी k पड़ोसियों को उनकी दूरी की परवाह किए बिना समान मानता है। दूरी-भारित मतदान (weights='distance') प्रत्येक पड़ोसी को उसकी दूरी के व्युत्क्रमानुपाती भार देता है — बहुत पास के पड़ोसियों का प्रभाव दूर वाले पड़ोसियों की तुलना में बहुत अधिक होता है। यह निर्णय सीमाओं पर विशेष रूप से उपयोगी है, जहाँ सबसे निकटतम और सबसे दूर का पड़ोसी वास्तविक सीमा के अलग-अलग पक्षों पर हो सकते हैं। भारित KNN लगभग हमेशा समान KNN से बेहतर प्रदर्शन करता है, विशेषकर तब जब k बड़ा हो।
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
X, y = load_digits(return_X_y=True)
uniform_pipe = Pipeline([('sc', StandardScaler()),
('knn', KNeighborsClassifier(n_neighbors=7, weights='uniform'))])
distance_pipe = Pipeline([('sc', StandardScaler()),
('knn', KNeighborsClassifier(n_neighbors=7, weights='distance'))])
print('Uniform: ', cross_val_score(uniform_pipe, X, y, cv=5).mean().round(3))
print('Distance: ', cross_val_score(distance_pipe, X, y, cv=5).mean().round(3))वर्ग संभावनाओं का पूर्वानुमान लगाना
कठोर वर्ग लेबल के बजाय, KNN predict_proba() का उपयोग करके वर्ग संभावनाएँ लौटा सकता है। k=5 के लिए, यदि 3 पड़ोसी वर्ग 1 के और 2 वर्ग 0 के हों, तो पूर्वानुमानित संभावना [0.4, 0.6] होगी। इन संभावनाओं के लिए सटीकता-पुनःस्मरण नियंत्रण हेतु सीमा निर्धारित की जा सकती है, उनका उपयोग एन्सेम्बल मॉडलों में किया जा सकता है, या यदि कच्चे अंश वास्तविक संभावनाओं को व्यक्त न करते हों तो CalibratedClassifierCV से उनका कैलिब्रेशन किया जा सकता है। दूरी-भारित KNN के लिए संभावनाएँ साधारण अंशों के बजाय भारित योग होती हैं।
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import numpy as np
X_train = np.array([[1,1],[1,2],[5,5],[6,5],[5,6]])
y_train = np.array([0, 0, 1, 1, 1])
scaler = StandardScaler()
X_s = scaler.fit_transform(X_train)
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_s, y_train)
x_new = scaler.transform([[3, 3]])
proba = knn.predict_proba(x_new)
print('Class probabilities:', proba)
print('Predicted class:', knn.predict(x_new))KNN की खूबियाँ और कमियाँ
KNN की कई खूबियाँ हैं: इसे समझना आसान है, इसमें प्रशिक्षण के लिए समय नहीं लगता, यह स्वाभाविक रूप से बहु-वर्गीय समस्याओं को संभालता है और जटिल गैर-रैखिक सीमाओं का मॉडल बना सकता है। बड़े डेटासेट के लिए इसकी कमियाँ महत्वपूर्ण हैं: हर अनुमान के लिए O(N * d) समय लगने के कारण भविष्यवाणी धीमी होती है, प्रशिक्षण के सभी डेटा को मेमोरी में रखना पड़ता है और उच्च आयामों में इसका प्रदर्शन घट जाता है (इसे आयामिकता का अभिशाप कहते हैं)। अच्छी तरह स्केल की गई विशेषताओं वाले छोटे से मध्यम डेटासेट के लिए KNN एक मजबूत आधारभूत मॉडल है, लेकिन बड़े स्तर पर उत्पादन में आमतौर पर इसकी जगह अधिक तेज़ मॉडल इस्तेमाल किए जाते हैं।
# Summary of KNN trade-offs
strengths = [
'No training time -- all computation at prediction',
'No assumptions about data distribution',
'Naturally handles multi-class classification',
'Non-linear decision boundary',
]
weaknesses = [
'Slow prediction: O(N*d) per query',
'High memory: stores all training data',
'Sensitive to irrelevant and scaled features',
'Poor in very high dimensions (curse of dimensionality)',
]
for s in strengths: print('+', s)
for w in weaknesses: print('-', w)त्वरित जाँच
इस पाठ में दिए गए Python के साथ मशीन लर्निंग की अवधारणाओं की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: Euclidean दूरी का उपयोग करके निकटतम k पड़ोसियों के बहुमत मत से KNN वर्गीकरण कैसे करता है, KNN लागू करने से पहले विशेषताओं का स्केल निर्धारित करना क्यों महत्वपूर्ण है, और अधिक सूक्ष्म भविष्यवाणियों के लिए दूरी-भारित मतदान और predict_proba कैसे काम करते हैं। आगे हम elbow विधि और validation curves का उपयोग करके सबसे अच्छा k चुनना सीखेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “KNN कैसे काम करता है: दूरी, पड़ोसी और मत” पाठ निःशुल्क है?
हाँ—“KNN कैसे काम करता है: दूरी, पड़ोसी और मत” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“KNN कैसे काम करता है: दूरी, पड़ोसी और मत” में मैं क्या सीखूँगा?
शिक्षार्थी 2D डेटासेट का दृश्यांकन करेंगे, यूक्लिडीय दूरियों की गणना करेंगे, k निकटतम पड़ोसियों की पहचान करेंगे और बहुमत के मत से वर्गीकरण करेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“KNN कैसे काम करता है: दूरी, पड़ोसी और मत” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- KNN कैसे काम करता है: दूरी, पड़ोसी और मत
- k चुनना: एल्बो विधि और सत्यापन वक्र
- दूरी के माप: यूक्लिडीय, मैनहैटन और मिंकोव्स्की
- प्रतिगमन के लिए KNN और इसकी विस्तार-क्षमता की सीमाएँ