Distance Metrics — Euclidean, Manhattan, Minkowski & Hamming

The Story That Explains Distance Metricsवह कहानी जो Distance Metrics समझाती है一个解释 Distance Metrics 的故事

Euclidean Distance — The Straight LineEuclidean Distance — सीधी LineEuclidean Distance — 直线距离

Let us work through an example. Point A = (1, 2) and Point B = (4, 6).

एक उदाहरण देखें। Point A = (1, 2) और Point B = (4, 6).

来看一个例子：Point A = (1, 2)，Point B = (4, 6)。

Properties of Euclidean DistanceEuclidean Distance की PropertiesEuclidean Distance 的性质

Manhattan Distance — The City GridManhattan Distance — शहर का GridManhattan Distance — 城市网格

Manhattan vs Euclidean — Key DifferencesManhattan vs Euclidean — मुख्य अंतरManhattan vs Euclidean — 主要区别

Minkowski Distance — The Unifying FormulaMinkowski Distance — सबको जोड़ने वाला FormulaMinkowski Distance — 统一公式

Minkowski distance is not a new metric. It is a family of metrics with one dial, p. Manhattan and Euclidean are two settings of that dial.

Minkowski distance कोई नया metric नहीं है। यह एक dial p वाला metrics का परिवार है। Manhattan और Euclidean उसी dial की दो settings हैं।

Minkowski distance 不是新的 metric，而是一个带有旋钮 p 的 metric 家族。Manhattan 和 Euclidean 只是这个旋钮的两个档位。

The Unit Ball — What Each p Looks LikeUnit Ball — हर p कैसा दिखता हैUnit Ball — 每个 p 的样子

Hamming Distance — Comparing SequencesHamming Distance — Sequences की तुलनाHamming Distance — 比较序列

Side by Side — All Metrics on the Same Dataसाथ-साथ — एक ही Data पर सभी Metrics并排比较 — 同一数据上的所有 Metric

Apply every metric to the same two points: A = (1, 2, 3) and B = (4, 6, 3).

हर metric को एक ही दो points पर लगाएँ: A = (1, 2, 3) और B = (4, 6, 3).

把每个 metric 用在同样两个点上：A = (1, 2, 3) 和 B = (4, 6, 3)。

Python ImplementationPython ImplementationPython 实现

All Distances — From Scratchसभी Distances — Scratch से所有距离 — 从零实现

import numpy as np

# ── Euclidean Distance (L2) ───────────────────────────────────
def euclidean(a, b):
    a, b = np.asarray(a, dtype=float), np.asarray(b, dtype=float)
    return np.sqrt(np.sum((a - b) ** 2))

# ── Manhattan Distance (L1) ───────────────────────────────────
def manhattan(a, b):
    a, b = np.asarray(a, dtype=float), np.asarray(b, dtype=float)
    return np.sum(np.abs(a - b))

# ── Minkowski Distance (Lp) ── p=1 Manhattan, p=2 Euclidean ──
def minkowski(a, b, p=2):
    a, b = np.asarray(a, dtype=float), np.asarray(b, dtype=float)
    if p == np.inf:
        return np.max(np.abs(a - b))          # Chebyshev
    return np.sum(np.abs(a - b) ** p) ** (1 / p)

# ── Hamming Distance ──────────────────────────────────────────
def hamming(a, b, normalise=False):
    if len(a) != len(b):
        raise ValueError("Sequences must be the same length")
    count = sum(x != y for x, y in zip(a, b))
    return count / len(a) if normalise else count

A = [1, 2, 3]
B = [4, 6, 3]

print(f"Euclidean    : {euclidean(A, B):.4f}")
print(f"Manhattan    : {manhattan(A, B):.4f}")
print(f"Minkowski p=1: {minkowski(A, B, p=1):.4f}")
print(f"Minkowski p=2: {minkowski(A, B, p=2):.4f}")
print(f"Minkowski p=3: {minkowski(A, B, p=3):.4f}")
print(f"Chebyshev    : {minkowski(A, B, p=np.inf):.4f}")

s1, s2 = "KAROLIN", "KATHRIN"
print(f"\nHamming (raw):        {hamming(s1, s2)}")
print(f"Hamming (normalised): {hamming(s1, s2, normalise=True):.4f}")

Using scipy — Production-Grade Functionsscipy का उपयोग — Production-Grade Functions使用 scipy — 生产级函数

Note: scipy's hamming() returns the normalised value. Multiply by the length to get the raw count.

ध्यान दें: scipy का hamming() normalised value देता है। Raw count के लिए length से गुणा करें।

注意：scipy 的 hamming() 返回的是归一化的值。乘以长度才得到原始计数。

from scipy.spatial.distance import euclidean, cityblock, minkowski, chebyshev, hamming
import numpy as np

A = np.array([1, 2, 3], dtype=float)
B = np.array([4, 6, 3], dtype=float)

print(f"Euclidean  : {euclidean(A, B):.4f}")
print(f"Manhattan  : {cityblock(A, B):.4f}")
print(f"Minkowski 3: {minkowski(A, B, p=3):.4f}")
print(f"Chebyshev  : {chebyshev(A, B):.4f}")

b1 = np.array([1, 0, 1, 1, 1, 0, 1])
b2 = np.array([1, 0, 0, 1, 0, 0, 1])
print(f"Hamming    : {hamming(b1, b2):.4f}")          # normalised
print(f"Hamming raw: {hamming(b1, b2) * len(b1):.0f} positions differ")

Distance Matrix — All Pairs at OnceDistance Matrix — सभी Pairs एक साथDistance Matrix — 一次计算所有点对

Columns are age, weight-like value and BMI-like value. The data is not scaled, so the second column dominates every matrix.

Columns हैं age, एक weight जैसी value और एक BMI जैसी value. Data scaled नहीं है, इसलिए हर matrix पर दूसरा column हावी है।

三列分别是 age、类似体重的值和类似 BMI 的值。数据没有做 scaling，所以每个矩阵都被第二列主导。

import numpy as np
import pandas as pd
from scipy.spatial.distance import pdist, squareform

X = np.array([
    [25, 80,  22.0],
    [35, 150, 28.5],
    [45, 180, 33.0],
    [28, 90,  23.5],
    [50, 200, 35.5],
])
names = [f"P{i+1}" for i in range(len(X))]

for metric in ['euclidean', 'cityblock', 'chebyshev']:
    D = squareform(pdist(X, metric=metric))
    df = pd.DataFrame(D.round(1), index=names, columns=names)
    print(f"\n{metric.upper()} distance matrix:")
    print(df.to_string())

Comparing Metrics in KNNKNN में Metrics की तुलना在 KNN 中比较 Metric

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

X, y = load_iris(return_X_y=True)

metrics = {
    'Euclidean':    dict(metric='euclidean'),
    'Manhattan':    dict(metric='manhattan'),
    'Minkowski p3': dict(metric='minkowski', p=3),
    'Chebyshev':    dict(metric='chebyshev'),
}

print(f"{'Metric':15s} {'CV Accuracy':>12} {'Std Dev':>10}")
print("-" * 40)
for name, kwargs in metrics.items():
    pipe = Pipeline([
        ('scaler', StandardScaler()),
        ('knn',    KNeighborsClassifier(n_neighbors=5, **kwargs)),
    ])
    scores = cross_val_score(pipe, X, y, cv=5, scoring='accuracy')
    print(f"{name:15s}  {scores.mean():.4f}       ±{scores.std():.4f}")

On the small, clean Iris dataset, the metrics score close to each other. Euclidean wins narrowly here. On other data the ranking can change, so always test.

छोटे और साफ़ Iris dataset पर सभी metrics के score पास-पास हैं। यहाँ Euclidean थोड़ा आगे है। दूसरे data पर ranking बदल सकती है, इसलिए हमेशा test करें।

在小而干净的 Iris 数据集上，各 metric 的分数很接近，这里 Euclidean 略胜。在其他数据上排名可能会变，所以一定要实际测试。

Choosing the Right Distance Metricसही Distance Metric चुनना选择合适的 Distance Metric

Complete Reference Tableपूरी Reference Table完整参考表

Real-World Applicationsअसली दुनिया में उपयोग实际应用

Golden RulesGolden Rules黄金法则