PricingLoginStart free
Machine Learning Academy · पाठ

दूरी के माप: यूक्लिडीय, मैनहैटन और मिंकोव्स्की

शिक्षार्थी दूरी के मापों की तुलना करेंगे, समझेंगे कि मैनहैटन दूरी यूक्लिडीय दूरी से कब बेहतर होती है और KNeighborsClassifier में कस्टम माप देंगे।

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

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

KNN में Distance Metrics क्यों महत्वपूर्ण हैं

KNN निकटतम पड़ोसियों को एक distance metric की मदद से परिभाषित करता है — यह एक गणितीय फलन है जो feature space में दो बिंदुओं के बीच की दूरी को मापता है। metric का चुनाव सीधे यह प्रभावित करता है कि कौन-से पड़ोसी चुने जाएँगे और इसलिए मॉडल क्या भविष्यवाणी करेगा। अलग-अलग metrics डेटा की ज्यामिति के बारे में अलग-अलग मान्यताएँ बनाते हैं। Euclidean दूरी मानती है कि विकर्ण दिशा में चलना मान्य है; Manhattan दूरी केवल अक्षों के समानांतर चलने देती है; cosine similarity परिमाण को नज़रअंदाज़ करके दिशा पर ध्यान देती है। कोई एक metric हर स्थिति में सर्वोत्तम नहीं होता — सही चुनाव समस्या की संरचना पर निर्भर करता है।

import numpy as np

A = np.array([0, 0])
B = np.array([3, 4])

# Euclidean: straight-line distance
euclidean = np.sqrt(np.sum((A - B)**2))
print('Euclidean:', euclidean)  # 5.0

# Manhattan: sum of absolute differences
manhattan = np.sum(np.abs(A - B))
print('Manhattan:', manhattan)  # 7

# Chebyshev: maximum single-axis difference
chebyshev = np.max(np.abs(A - B))
print('Chebyshev:', chebyshev)  # 4

Euclidean Distance: L2 Norm

Euclidean distance (इसे L2 distance या L2 norm भी कहा जाता है) दो बिंदुओं के बीच सीधी रेखा की दूरी मापती है। 2D में यह पाइथागोरस प्रमेय का पालन करती है: sqrt(dx^2 + dy^2)। n आयामों में: sqrt(sum of squared differences)। यह सबसे सहज metric है और KNeighborsClassifier में डिफ़ॉल्ट होती है। Euclidean distance तब अच्छी तरह काम करती है जब features continuous हों, समान scale पर हों और विकर्ण निकटता का विचार भौतिक रूप से अर्थपूर्ण हो — जैसे भौगोलिक coordinates या sensor readings।

import numpy as np

def euclidean(a, b):
    return np.sqrt(np.sum((np.array(a) - np.array(b))**2))

# 2D example
print('2D:', euclidean([0, 0], [3, 4]))  # 5.0

# 3D example
print('3D:', euclidean([1, 2, 3], [4, 6, 3]).round(2))  # 5.0

# Using scipy for efficiency
from scipy.spatial.distance import euclidean as sp_euclidean
print('scipy:', sp_euclidean([0, 0], [3, 4]))

Manhattan Distance: L1 Norm

Manhattan distance (L1 norm, city-block distance, taxicab distance) प्रत्येक अक्ष के साथ होने वाले absolute differences का योग करती है: sum(|a_i - b_i|)। इसका नाम Manhattan की सड़कों की grid layout से आया है — आप केवल blocks के साथ चल सकते हैं, विकर्ण दिशा में नहीं। Manhattan distance Euclidean की तुलना में outliers के प्रति अधिक मजबूत होती है, क्योंकि इसमें squares के बजाय absolute values का उपयोग होता है। इसे अक्सर उच्च-आयामी sparse डेटा तथा उन features के लिए प्राथमिकता दी जाती है जो counts, ratings या ऐसी अन्य मात्राओं को दर्शाते हैं जहाँ विकर्ण दिशा में चलने का कोई भौतिक अर्थ नहीं होता।

import numpy as np

def manhattan(a, b):
    return np.sum(np.abs(np.array(a) - np.array(b)))

print('Manhattan (0,0)-(3,4):', manhattan([0,0], [3,4]))  # 7
print('Euclidean (0,0)-(3,4):', np.linalg.norm([3,4]))    # 5.0

# Manhattan treats 3+4=7 units of travel
# Euclidean takes the diagonal shortcut = 5.0
# In a grid city, only Manhattan is physically achievable

from scipy.spatial.distance import cityblock
print('scipy cityblock:', cityblock([0,0], [3,4]))

Minkowski Distance: L1 और L2 का सामान्यीकरण

Minkowski distance एक सामान्यीकृत रूप है जो एक ही सूत्र के अंतर्गत Euclidean और Manhattan को एकीकृत करता है: (sum(|a_i - b_i|^p))^(1/p)। जब p=1 होता है, तो यह Manhattan distance के बराबर होती है। जब p=2 होता है, तो यह Euclidean distance के बराबर होती है। जब p → infinity होता है, तो यह Chebyshev distance (एकल अक्ष पर अधिकतम अंतर) के निकट पहुँचती है। scikit-learn में KNeighborsClassifier डिफ़ॉल्ट रूप से p=2 वाली Minkowski का उपयोग करता है। आप p के अन्य मानों को हाइपरपैरामीटर के रूप में आज़मा सकते हैं — हालांकि व्यवहार में 1 और 2 के अलावा p के मानों का उपयोग बहुत कम होता है।

import numpy as np

def minkowski(a, b, p):
    a, b = np.array(a), np.array(b)
    return np.sum(np.abs(a - b)**p)**(1/p)

a, b = [0, 0], [3, 4]

for p in [1, 2, 3, 10, 100]:
    d = minkowski(a, b, p)
    print(f'p={p}: {d:.4f}')

# p=1  -> 7.0 (Manhattan)
# p=2  -> 5.0 (Euclidean)
# p->inf -> 4.0 (Chebyshev = max(3,4))

KNeighborsClassifier में Metrics देना

Scikit-learn आपको metric पैरामीटर के माध्यम से distance metric निर्दिष्ट करने देता है। सामान्य string विकल्पों में 'euclidean', 'manhattan', 'minkowski' (अतिरिक्त p पैरामीटर के साथ), 'chebyshev' और 'cosine' शामिल हैं। आप custom metric के रूप में callable Python function भी दे सकते हैं। गैर-मानक metrics का उपयोग करते समय, पड़ोसियों को कुशलता से खोजने के लिए algorithm='ball_tree' या algorithm='kd_tree' सेट करें, अथवा निश्चित रूप से सही लेकिन धीमी संपूर्ण खोज के लिए algorithm='brute' का उपयोग करें।

from sklearn.neighbors import KNeighborsClassifier

# Euclidean (default)
knn_l2 = KNeighborsClassifier(n_neighbors=5, metric='euclidean')

# Manhattan
knn_l1 = KNeighborsClassifier(n_neighbors=5, metric='manhattan')

# Minkowski with p=1.5
knn_mk = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=1.5)

# Chebyshev
knn_ch = KNeighborsClassifier(n_neighbors=5, metric='chebyshev')

# Cosine similarity (for text/angle-based)
knn_cos = KNeighborsClassifier(n_neighbors=5, metric='cosine',
                                algorithm='brute')

Euclidean बनाम Manhattan: व्यावहारिक तुलना

Euclidean और Manhattan की अनुभवजन्य तुलना करने पर अंतर outlier features की मौजूदगी में सबसे स्पष्ट दिखाई देता है। Euclidean अंतरों का square करती है, जिससे एक बड़ा विचलन कुल दूरी पर हावी हो जाता है। Manhattan absolute values का योग करती है, इसलिए सभी विचलनों को उनके अनुपात में महत्व मिलता है। व्यवहार में image डेटा या continuous भौतिक मापों के लिए Euclidean अक्सर बेहतर रहती है। उच्च-आयामी sparse डेटा (text, user-item ratings, counts) के लिए Manhattan अधिक स्थिर रहती है, क्योंकि यह किसी एक आयाम के प्रभाव को बढ़ाती नहीं है।

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_wine

X, y = load_wine(return_X_y=True)

for metric in ['euclidean', 'manhattan', 'chebyshev']:
    pipe = Pipeline([
        ('sc', StandardScaler()),
        ('knn', KNeighborsClassifier(n_neighbors=5, metric=metric))
    ])
    score = cross_val_score(pipe, X, y, cv=10).mean()
    print(f'{metric:12}: {score:.3f}')

Text डेटा के लिए Cosine Similarity

कोसाइन समानता दो सदिशों के परिमाण के बजाय उनके बीच के कोण को मापती है। दो दस्तावेज़ों को समान माना जाता है यदि वे विशेषता-स्थान में एक ही दिशा की ओर संकेत करते हैं, चाहे दस्तावेज़ की लंबाई कुछ भी हो। कोसाइन दूरी = 1 - कोसाइन समानता। TF-IDF सदिशों के साथ पाठ वर्गीकरण के लिए यह पसंदीदा माप है, जहाँ दो दस्तावेज़ों की लंबाई बहुत अलग हो सकती है, लेकिन वे समान अनुपात में एक ही शब्दावली का उपयोग करते हैं। ध्यान दें कि कोसाइन दूरी वास्तविक माप नहीं है (यह त्रिभुज असमता का उल्लंघन करती है), लेकिन पाठ पर KNN के लिए व्यवहार में अच्छी तरह काम करती है।

import numpy as np

def cosine_distance(a, b):
    a, b = np.array(a, dtype=float), np.array(b, dtype=float)
    cos_sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
    return 1 - cos_sim

# Long and short documents with same topic should be close
doc1 = [2, 1, 0, 3]  # counts of words: 'python', 'ml', 'java', 'data'
doc2 = [4, 2, 0, 6]  # same proportions, longer document
doc3 = [0, 0, 5, 1]  # different topic

print('doc1 vs doc2 (same topic):', cosine_distance(doc1, doc2).round(3))  # near 0
print('doc1 vs doc3 (diff topic):', cosine_distance(doc1, doc3).round(3))  # larger

वर्गीय और बाइनरी विशेषताओं के लिए हैमिंग दूरी

हैमिंग दूरी उन स्थानों की संख्या गिनती है जहाँ दो सदिश अलग होते हैं। यह बाइनरी या वर्गीय विशेषताओं के लिए आदर्श है, जहाँ परिमाण के अंतर की अवधारणा अर्थहीन होती है। उदाहरण के लिए, बाइनरी लक्षण सदिशों के रूप में एन्कोड किए गए दो रोगी रिकॉर्ड की तुलना करते समय (1=मौजूद, 0=अनुपस्थित), हैमिंग दूरी बताती है कि कितने लक्षण अलग हैं। scikit-learn में metric='hamming' को KNeighborsClassifier में पास करें। हैमिंग दूरी का उपयोग DNA अनुक्रमों की तुलना, बाइनरी कोड में त्रुटि-पहचान और आनुवंशिक फिंगरप्रिंटिंग के लिए भी किया जाता है।

import numpy as np

def hamming(a, b):
    a, b = np.array(a), np.array(b)
    return np.sum(a != b) / len(a)

# Binary symptom vectors: [fever, cough, headache, fatigue]
patient1 = [1, 1, 0, 1]
patient2 = [1, 1, 1, 1]  # only headache differs
patient3 = [0, 0, 1, 0]  # very different

print('p1 vs p2:', hamming(patient1, patient2))  # 0.25
print('p1 vs p3:', hamming(patient1, patient3))  # 0.75

# sklearn usage
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=3, metric='hamming')

आयामों की विपदा और दूरी

जैसे-जैसे विशेषताओं (आयामों) की संख्या बढ़ती है, सभी दूरी-आधारित विधियाँ आयामों की विपदा से प्रभावित होती हैं: उच्च आयामों में किसी भी दो यादृच्छिक बिंदुओं के बीच की दूरी एक ही मान की ओर अभिसरित होने लगती है, जिससे सभी बिंदु समान रूप से दूर दिखाई देते हैं। जब दूरियों में अंतर करना कठिन हो जाता है, तो 'निकटतम पड़ोसी' की अवधारणा अपना अर्थ खो देती है। इसी कारण KNN आम तौर पर 20-50 से कम विशेषताओं वाले डेटासेट पर सबसे अच्छा काम करता है और उच्च-आयामी परिस्थितियों में KNN से पहले अक्सर आयाम-घटाव (PCA, विशेषता चयन) लागू किया जाता है।

import numpy as np

np.random.seed(42)

for d in [2, 10, 50, 100, 500]:
    # Random points in d-dimensional unit hypercube
    X = np.random.rand(1000, d)
    query = np.random.rand(d)
    dists = np.linalg.norm(X - query, axis=1)
    # High-dimensional: max/min ratio -> 1 (all distances similar)
    ratio = dists.max() / dists.min()
    print(f'd={d:3}: min={dists.min():.2f}, max={dists.max():.2f}, ratio={ratio:.2f}')

# As d grows, ratio approaches 1: distances become indistinguishable

माप चुनना: एक व्यावहारिक मार्गदर्शिका

दूरी का माप चुनने के लिए यह मार्गदर्शिका उपयोग करें: समान पैमाने वाली सतत विशेषताओं के लिए (StandardScaler के बाद) यूक्लिडीय (L2) का उपयोग करें; विरल या उच्च-आयामी डेटा के लिए और बाहरी मानों के प्रति मजबूती आवश्यक होने पर मैनहैटन (L1) का उपयोग करें; ऐसे पाठ/TF-IDF सदिशों के लिए कोसाइन का उपयोग करें जहाँ परिमाण का महत्व नहीं होना चाहिए; बाइनरी या वर्गीय विशेषताओं के लिए हैमिंग का उपयोग करें; और कस्टम p वाले मिंकोव्स्की का उपयोग केवल तब करें जब आपके पास किसी विशिष्ट ज्यामिति का सुझाव देने वाला डोमेन ज्ञान हो। व्यवहार में, क्रॉस-वैलिडेशन का उपयोग करके पहले यूक्लिडीय और मैनहैटन आज़माएँ और बेहतर परिणाम वाले विकल्प को चुनें।

def recommend_metric(data_type, is_sparse, has_outliers):
    if data_type == 'text':
        return 'cosine'
    elif data_type == 'binary' or data_type == 'categorical':
        return 'hamming'
    elif is_sparse or has_outliers:
        return 'manhattan'
    else:
        return 'euclidean'  # default, safe choice

print(recommend_metric('text', False, False))       # cosine
print(recommend_metric('binary', False, False))     # hamming
print(recommend_metric('continuous', True, False))  # manhattan
print(recommend_metric('continuous', False, False)) # euclidean

ग्रिड सर्च में माप शामिल करना

आप अपने GridSearchCV में metric पैरामीटर शामिल करके k और दूरी के माप का सर्वोत्तम संयोजन एक साथ खोज सकते हैं। इससे विभिन्न मापों पर मैन्युअल परीक्षण और त्रुटि से बचा जा सकता है। ऐसे मापों पर खोज करते समय जिनके लिए अतिरिक्त पैरामीटर आवश्यक हैं (जैसे Minkowski का p), उन्हें भी पैरामीटर ग्रिड में शामिल करें। सबसे अच्छा माप डेटा पर निर्भर करता है और अक्सर केवल डोमेन ज्ञान से स्पष्ट नहीं होता — क्रॉस-वैलिडेशन को निर्णय लेने देना सैद्धांतिक रूप से उचित और व्यावहारिक दोनों है।

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': [3, 5, 7, 11],
     'knn__metric': ['euclidean', 'manhattan'],
     'knn__weights': ['uniform', 'distance']},
    {'knn__n_neighbors': [3, 5, 7],
     'knn__metric': ['minkowski'],
     'knn__p': [1, 1.5, 2, 3]}
]

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

त्वरित जाँच

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

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

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

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

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

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

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

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

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

क्या “दूरी के माप: यूक्लिडीय, मैनहैटन और मिंकोव्स्की” पाठ निःशुल्क है?

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

“दूरी के माप: यूक्लिडीय, मैनहैटन और मिंकोव्स्की” में मैं क्या सीखूँगा?

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

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

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

“दूरी के माप: यूक्लिडीय, मैनहैटन और मिंकोव्स्की” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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