Matplotlib में k-NN निर्णय सीमाओं को ग्राफ करें

Matplotlib और scikit-learn का उपयोग करके k-Nearest Neighbors (k-NN) क्लासिफायर की निर्णय सीमाओं (decision boundaries) को विज़ुअलाइज़ करें।

चरण

1. फिगर आकार सेट करें और पैडिंग समायोजित करें
2. n_neighbors वेरिएबल इनिशियलाइज़ करें
3. iris डेटासेट लोड करें (वर्गीकरण)
4. x और y डेटा बिंदु बनाएं
5. गहरे और हल्के रंगों की सूची बनाएं
6. k-NN क्लासिफायर बनाएं और फिट करें
7. xmin, xmax, ymin, ymax डेटा बिंदु बनाएं
8. नया फिगर बनाएं
9. contourf प्लॉट बनाएं (निर्णय क्षेत्र)
10. डेटासेट के साथ स्कैटर प्लॉट बनाएं
11. एक्सिस लेबल, शीर्षक, स्केल सेट करें
12. plt.show() से प्रदर्शित करें

उदाहरण

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.colors import ListedColormap
from sklearn import neighbors, datasets

plt.rcParams["figure.figsize"] = [7.00, 3.50]
plt.rcParams["figure.autolayout"] = True

n_neighbors = 15

# Iris डेटासेट लोड करें (पहले 2 फीचर)
iris = datasets.load_iris()
X = iris.data[:, :2]  # केवल पहली दो विशेषताएं
y = iris.target

# मेश ग्रिड के लिए स्टेप साइज
h = .02

# कलर मैप्स
cmap_light = ListedColormap(['orange', 'cyan', 'cornflowerblue'])
cmap_bold = ['darkorange', 'c', 'darkblue']

# k-NN क्लासिफायर
clf = neighbors.KNeighborsClassifier(n_neighbors, weights='uniform')
clf.fit(X, y)

# प्लॉट सीमाएं
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.figure()
plt.contourf(xx, yy, Z, cmap=cmap_light, alpha=0.8)

# प्रशिक्षण बिंदु
sns.scatterplot(x=X[:, 0], y=X[:, 1], hue=iris.target_names[y],
                palette=cmap_bold, alpha=1.0, edgecolor="black")

plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.title(f"3-Class classification (k = {n_neighbors}, weights='uniform')")
plt.xlabel(iris.feature_names[0])
plt.ylabel(iris.feature_names[1])
plt.show()

आउटपुट

रंगीन निर्णय क्षेत्रों (नारंगी, सियान, कॉर्नफ्लावर ब्लू) वाला प्लॉट, जिस पर प्रशिक्षण डेटा बिंदु काले किनारे के साथ ओवरले हैं।

मुख्य अवधारणाएं

• निर्णय सीमा: फीचर स्पेस में वह सतह जो विभिन्न वर्गों को अलग करती है
• k-NN: k निकटतम पड़ोसियों के बहुमत वर्ग के आधार पर वर्गीकरण
• meshgrid + contourf: घने ग्रिड पर भविष्यवाणी करके निर्णय क्षेत्र विज़ुअलाइज़ करता है
• h (स्टेप साइज): छोटा = स्मूथ सीमाएं, धीमा; बड़ा = तेज़, खुरदरा

विभिन्न k मानों के लिए

for k in [1, 3, 5, 15]:
    clf = neighbors.KNeighborsClassifier(k, weights='uniform')
    clf.fit(X, y)
    # ... प्लॉटिंग कोड ...
    plt.title(f"k = {k}")

छोटा k = जटिल/ओवरफिट सीमाएं, बड़ा k = स्मूथ/अंडरफिट सीमाएं।