S19L01-KNN पृष्ठभूमि

html
वर्गीकरण और प्रतिगमन के लिए K-निकटतम पड़ोसी (KNN) को समझना

सामग्री सूची

K-निकटतम पड़ोसी का परिचय
KNN कैसे काम करता है
    
        डेटा निरूपण
        दूरी मीट्रिक
    

सही 'K' मान चुनना
वर्गीकरण के लिए KNN
प्रतिगमन के लिए KNN
KNN के फायदे और नुकसान
Python में KNN लागू करना
    
        डेटा पूर्व-संसाधन
        मॉडल प्रशिक्षण और मूल्यांकन
    

व्यावहारिक उदाहरण
निष्कर्ष
संदर्भ


1. K-निकटतम पड़ोसियों का परिचय

K-निकटतम पड़ोसी (KNN) एक सरल, फिर भी शक्तिशाली, पर्यवेक्षित मशीन लर्निंग एल्गोरिदम है जिसका उपयोग वर्गीकरण और प्रतिगमन कार्यों दोनों के लिए किया जाता है। मूल विचार यह है कि नए डेटा बिंदु का लेबल उसके फीचर स्पेस में 'K' सबसे निकटतम पड़ोसियों के लेबल के आधार पर पूर्वानुमानित किया जाए।

क्यों KNN?


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


2. KNN कैसे काम करता है

KNN इस सिद्धांत पर कार्य करता है कि समान डेटा बिंदु समान परिणाम होने की संभावना रखते हैं। यहां एल्गोरिदम के कार्य करने के चरण-दर-चरण स्पष्टीकरण दिया गया है:

डेटा निरूपण

एक दो-आयामी स्थान की कल्पना करें जहाँ प्रत्येक डेटा बिंदु दो विशेषताओं के आधार पर एक कार का प्रतिनिधित्व करता है:

निर्माण समय (X-अक्ष)
निर्माण लागत (Y-अक्ष)


डेटा बिंदुओं को रंग के अनुसार कोडित किया गया है:

लाल बिंदु: पेट्रोल कारें
नीले बिंदु: इलेक्ट्रिक कारें


दूरी मीट्रिक

"निकटता" निर्धारित करने के लिए, KNN दूरी मीट्रिक का उपयोग करता है। सबसे आम रूप से उपयोग किए जाने वाले मीट्रिक हैं:


युक्लिडियन दूरी
    \[
    d(p, q) = \sqrt{\sum_{i=1}^{n} (q_i - p_i)^2}
    \]
    
        कब उपयोग करें: जब डेटा सतत स्थान में हो।
        प्रो टिप: युक्लिडियन दूरी कई KNN कार्यान्वयन, सहित scikit-learn में डिफ़ॉल्ट मीट्रिक है।
    

मैनहट्टन दूरी
    \[
    d(p, q) = \sum_{i=1}^{n} |q_i - p_i|
    \]
    
        कब उपयोग करें: जब डेटा ग्रिड समान हो और आंदोलन क्षैतिज और ऊर्ध्वाधर पथों तक सीमित हो।
    

मिंकोव्स्की दूरी
    युक्लिडियन और मैनहट्टन दूरियों दोनों का सामान्यीकरण।
    \[
    d(p, q) = \left( \sum_{i=1}^{n} |q_i - p_i|^p \right)^{1/p}
    \]
    
        जब \( p = 1 \): यह मैनहट्टन दूरी के बराबर होता है।
        जब \( p = 2 \): यह युक्लिडियन दूरी के बराबर होता है।
    



3. सही 'K' मान चुनना

'K' पैरामीटर तय करता है कि पूर्वानुमान करने के समय कितने पड़ोसियों पर विचार किया जाए। KNN एल्गोरिदम के प्रदर्शन के लिए इष्टतम 'K' मान का चयन करना महत्वपूर्ण है।

'K' का प्रभाव


छोटा 'K' (उदा., K=1):
    
        शोर के प्रति अधिक संवेदनशील होता है।
        ओवरफिटिंग का कारण बन सकता है।
    

बड़ा 'K' (उदा., K=20):
    
        निर्णय सीमा को अधिक चिकना बनाता है।
        डेटा को अधिक सरल बनाकर अंडरफिटिंग कर सकता है।
    



सर्वोत्तम प्रथाएँ


क्रॉस-वैलिडेशन: 'K' मान खोजने के लिए क्रॉस-वैलिडेशन जैसी तकनीकों का उपयोग करें जो सबसे अच्छी सटीकता प्रदान करे।
बिजोड़ा संख्याएँ: द्विआधारी वर्गीकरण के मामले में, टाई से बचने में मदद के लिए विषम 'K' मानों का उपयोग करें।


4. वर्गीकरण के लिए KNN

वर्गीकरण में, KNN नए डेटा बिंदु को उसके 'K' सबसे निकटतम पड़ोसियों में सबसे सामान्य वर्ग को सौंपता है।

उदाहरण परिदृश्य

निर्माण समय और लागत की विशिष्टताओं के साथ एक नई कार डेटा बिंदु पर विचार करें। KNN एल्गोरिदम निम्नलिखित करेगा:

गणना: इस बिंदु से डेटासेट में सभी अन्य बिंदुओं तक की दूरी को गणना करें।
पहचान: 'K' सबसे निकटतम पड़ोसियों की पहचान करें।
सौंपना: इन पड़ोसियों में बहुमत वोट के आधार पर वर्ग (इलेक्ट्रिक या पेट्रोल) सौंपें।


'K' के प्रति संवेदनशीलता

ट्रांस्क्रिप्ट में दिखाए गए अनुसार, 'K' में बदलाव से वर्गीकरण परिणाम बदल सकते हैं। उदाहरण के लिए:

K=1: नए बिंदु को उसके एकल सबसे निकटतम पड़ोसी के आधार पर वर्गीकृत किया जाता है।
K=5: पांच पड़ोसियों में बहुमत वोट से वर्गीकरण निर्धारित होता है।


5. प्रतिगमन के लिए KNN

हालांकि KNN का प्रमुख रूप से वर्गीकरण के लिए उपयोग होता है, यह प्रतिगमन कार्य भी कर सकता है 'K' सबसे निकटतम पड़ोसियों के औसत मान की भविष्यवाणी करके।

प्रतिगमन में चुनौतियाँ


ओवरफिटिंग: कम 'K' मान ओवरफिटिंग का कारण बन सकते हैं।
अंडरफिटिंग: उच्च 'K' मान मॉडल को अधिक सरल बना सकते हैं।


लागू करने की अंतर्दृष्टि

प्रस्तुत Jupyter Notebook में, KNN प्रतिगमन का उपयोग हीरे की कीमतों की भविष्यवाणी के लिए किया गया था। इसका संक्षिप्त अवलोकन यहां दिया गया है:

डेटा पूर्व-संसाधन:
    
        वर्गीकृत परिवर्तनों को संख्यात्मक मानों में मैप किया गया।
        मानककरण का उपयोग करके फीचर्स को स्केल किया गया।
    

मॉडल प्रशिक्षण:
    
        उत्तम प्रदर्शन निर्धारित करने के लिए विभिन्न 'K' मानों के साथ KNN रेग्रессर को प्रशिक्षित किया।
    

मूल्यांकन:
    
        K=4 पर लगभग 98.05% की अधिकतम सटीकता स्कोर प्राप्त किया।
        बेहतर व्याख्यात्मकता के लिए Plotly का उपयोग करके वास्तविक और भविष्यवाणी की गई कीमतों को विज़ुअलाइज़ किया।
    



6. KNN के फायदे और नुकसान

फायदे


सरल और सहज: समझने और लागू करने में आसान।
कोई प्रशिक्षण चरण नहीं: प्रशिक्षण के दौरान कैलकुलेशन लागत को कम करता है।
अनुकूलन योग्य: दोनों वर्गीकरण और प्रतिगमन के लिए उपयुक्त।


नुकसान


गणनात्मक रूप से सघन: पूरे डेटासेट का उपयोग करके भविष्यवाणियाँ करता है, जो बड़े डेटासेट के लिए धीमा हो सकता है।
अनुपयुक्त फीचर्स के प्रति संवेदनशील: अप्रासंगिक या अधिशेष फीचर्स प्रदर्शन को बिगाड़ सकते हैं।
'K' चुनना: इष्टतम 'K' मान का चयन चुनौतीपूर्ण हो सकता है।


7. Python में KNN लागू करना

Python की scikit-learn लाइब्रेरी का उपयोग करके KNN को लागू करना सरल हो जाता है। नीचे, हम डेटा पूर्व-संसाधन से लेकर मॉडल मूल्यांकन तक के मुख्य चरणों का विवरण देते हैं।

डेटा पूर्व-संसाधन

KNN लागू करने से पहले, डेटा तैयार करना आवश्यक है:

श्रेणीबद्ध परिवर्तनों को संभालना:
    
        मैपिंग डिक्शनरीज़ का उपयोग करके श्रेणीबद्ध पाठ डेटा को संख्यात्मक मानों में बदलें।
    







		
		
			
			
Java
			
			cut_dict = {'Fair': 1, 'Good': 2, 'Very Good': 3, 'Premium': 4, 'Ideal': 5}
clarity_dict = {'I1': 1, 'SI2': 2, 'SI1': 3, 'VS2': 4, 'VS1': 5, 'VVS2': 6, 'VVS1': 7, 'IF': 8}
color_dict = {'D':7, 'E':6, 'F':5, 'G':4, 'H':3, 'I':2, 'J':1}

df['cut'] = df['cut'].map(cut_dict)
df['clarity'] = df['clarity'].map(clarity_dict)
df['color'] = df['color'].map(color_dict)
df = df.drop('Unnamed: 0', axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						cut_dict = {'Fair': 1, 'Good': 2, 'Very Good': 3, 'Premium': 4, 'Ideal': 5}
clarity_dict = {'I1': 1, 'SI2': 2, 'SI1': 3, 'VS2': 4, 'VS1': 5, 'VVS2': 6, 'VVS1': 7, 'IF': 8}
color_dict = {'D':7, 'E':6, 'F':5, 'G':4, 'H':3, 'I':2, 'J':1}
 
df['cut'] = df['cut'].map(cut_dict)
df['clarity'] = df['clarity'].map(clarity_dict)
df['color'] = df['color'].map(color_dict)
df = df.drop('Unnamed: 0', axis=1)
					
				
			
		




फीचर्स को स्केल करना:
    
        फीचर सेट को सामान्यीकृत करें ताकि सभी फीचर्स दूरी गणनाओं में समान रूप से योगदान दें।
    







		
		
			
			
Java
			
			from sklearn import preprocessing

X = df.drop(['price'], axis=1).values
X = preprocessing.scale(X)
y = df['price'].values
y = preprocessing.scale(y)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
X = df.drop(['price'], axis=1).values
X = preprocessing.scale(X)
y = df['price'].values
y = preprocessing.scale(y)
					
				
			
		



मॉडल प्रशिक्षण और मूल्यांकन


डेटासेट को विभाजित करना:







		
		
			
			
Java
			
			from sklearn.utils import shuffle

df = shuffle(df, random_state=42)
test_size = 200
X_train = X[:-test_size]
y_train = y[:-test_size]
X_test = X[-test_size:]
y_test = y[-test_size:]
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.utils import shuffle
 
df = shuffle(df, random_state=42)
test_size = 200
X_train = X[:-test_size]
y_train = y[:-test_size]
X_test = X[-test_size:]
y_test = y[-test_size:]
					
				
			
		




KNN रेग्रессर को प्रशिक्षित करना:







		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsRegressor

score = []
for k in range(1, 20):
    clf = KNeighborsRegressor(n_neighbors=k, weights='distance', p=1)
    clf.fit(X_train, y_train)
    score.append(clf.score(X_test, y_test))
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.neighbors import KNeighborsRegressor
 
score = []
for k in range(1, 20):
    clf = KNeighborsRegressor(n_neighbors=k, weights='distance', p=1)
    clf.fit(X_train, y_train)
    score.append(clf.score(X_test, y_test))
					
				
			
		




प्रदर्शन का विज़ुअलाइज़ेशन:







		
		
			
			
Java
			
			import plotly.graph_objs as go
from plotly.offline import iplot

trace0 = go.Scatter(
    y=score,
    x=np.arange(1, len(score)+1),
    mode='lines+markers',
    marker=dict(color='rgb(100, 200, 150)')
)
layout = go.Layout(
    title='K Value vs. Accuracy Score',
    xaxis=dict(title='K Value', tickmode='linear'),
    yaxis=dict(title='Score')
)
fig = go.Figure(data=[trace0], layout=layout)
iplot(fig, filename='basic-line')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						import plotly.graph_objs as go
from plotly.offline import iplot
 
trace0 = go.Scatter(
    y=score,
    x=np.arange(1, len(score)+1),
    mode='lines+markers',
    marker=dict(color='rgb(100, 200, 150)')
)
layout = go.Layout(
    title='K Value vs. Accuracy Score',
    xaxis=dict(title='K Value', tickmode='linear'),
    yaxis=dict(title='Score')
)
fig = go.Figure(data=[trace0], layout=layout)
iplot(fig, filename='basic-line')
					
				
			
		




इष्टतम 'K' निर्धारित करना:







		
		
			
			
Java
			
			k_max = score.index(max(score)) + 1
print(f"At K = {k_max}, Max Accuracy = {max(score) * 100:.2f}%")
			
				
					
				
					1
2
				
						k_max = score.index(max(score)) + 1
print(f"At K = {k_max}, Max Accuracy = {max(score) * 100:.2f}%")
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			At K = 4, Max Accuracy = 98.05%
			
				
					
				
					1
				
						At K = 4, Max Accuracy = 98.05%
					
				
			
		




अंतिम मॉडल मूल्यांकन:







		
		
			
			
Java
			
			clf = KNeighborsRegressor(n_neighbors=50)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
y_pred = clf.predict(X_test)
			
				
					
				
					1
2
3
4
				
						clf = KNeighborsRegressor(n_neighbors=50)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
y_pred = clf.predict(X_test)
					
				
			
		



आउटपुट:




		
		
			
			
Java
			
			0.9543611406331687
			
				
					
				
					1
				
						0.9543611406331687
					
				
			
		




वास्तविक बनाम भविष्यवाणी की गई कीमतों की तुलना:







		
		
			
			
Java
			
			import plotly.graph_objs as go
from plotly.offline import iplot

trace0 = go.Scatter(
    y=y_test,
    x=np.arange(200),
    mode='lines+markers',
    name='Actual Price',
    marker=dict(color='rgb(110, 10, 150)')
)

trace1 = go.Scatter(
    y=y_pred,
    x=np.arange(200),
    mode='lines+markers',
    name='Predicted Price',
    line=dict(color='rgb(200, 50, 10)', dash='dot')
)

layout = go.Layout(
    xaxis=dict(title='Index'),
    yaxis=dict(title='Normalized Price')
)

figure = go.Figure(data=[trace0, trace1], layout=layout)
iplot(figure)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						import plotly.graph_objs as go
from plotly.offline import iplot
 
trace0 = go.Scatter(
    y=y_test,
    x=np.arange(200),
    mode='lines+markers',
    name='Actual Price',
    marker=dict(color='rgb(110, 10, 150)')
)
 
trace1 = go.Scatter(
    y=y_pred,
    x=np.arange(200),
    mode='lines+markers',
    name='Predicted Price',
    line=dict(color='rgb(200, 50, 10)', dash='dot')
)
 
layout = go.Layout(
    xaxis=dict(title='Index'),
    yaxis=dict(title='Normalized Price')
)
 
figure = go.Figure(data=[trace0, trace1], layout=layout)
iplot(figure)
					
				
			
		



यह विज़ुअलाइज़ेशन वास्तविक और भविष्यवाणी की गई मूल्य मानों को ओवरले करके मॉडल की भविष्यवाणी सटीकता का आकलन करने में मदद करता है।

8. व्यावहारिक उदाहरण

आइए Python की scikit-learn लाइब्रेरी का उपयोग करके एक व्यावहारिक कार्यान्वयन के माध्यम से चलें, जैसा कि प्रदान किए गए Jupyter Notebook में वर्णित है।

चरण 1: आवश्यक लाइब्रेरी इम्पोर्ट करना





		
		
			
			
Java
			
			import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import preprocessing, utils
from sklearn.neighbors import KNeighborsRegressor
import plotly.graph_objs as go
from plotly.offline import iplot
			
				
					
				
					1
2
3
4
5
6
7
8
				
						import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import preprocessing, utils
from sklearn.neighbors import KNeighborsRegressor
import plotly.graph_objs as go
from plotly.offline import iplot
					
				
			
		



चरण 2: डेटासेट लोड करना और अन्वेषण करना





		
		
			
			
Java
			
			df = pd.read_csv('diamonds.csv')
print(df.head())
sns.FacetGrid(df, hue='cut', height=6).map(sns.distplot, 'price').add_legend()
plt.show()
			
				
					
				
					1
2
3
4
				
						df = pd.read_csv('diamonds.csv')
print(df.head())
sns.FacetGrid(df, hue='cut', height=6).map(sns.distplot, 'price').add_legend()
plt.show()
					
				
			
		



चरण 3: डेटा पूर्व-संसाधन

श्रेणीबद्ध परिवर्तनों को संख्यात्मक में बदलें और फीचर्स को स्केल करें।





		
		
			
			
Java
			
			cut_dict = {'Fair': 1, 'Good': 2, 'Very Good': 3, 'Premium': 4, 'Ideal': 5}
clarity_dict = {'I1': 1, 'SI2': 2, 'SI1': 3, 'VS2': 4, 'VS1': 5, 'VVS2': 6, 'VVS1': 7, 'IF': 8}
color_dict = {'D':7, 'E':6, 'F':5, 'G':4, 'H':3, 'I':2, 'J':1}

df['cut'] = df['cut'].map(cut_dict)
df['clarity'] = df['clarity'].map(clarity_dict)
df['color'] = df['color'].map(color_dict)
df = df.drop('Unnamed: 0', axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						cut_dict = {'Fair': 1, 'Good': 2, 'Very Good': 3, 'Premium': 4, 'Ideal': 5}
clarity_dict = {'I1': 1, 'SI2': 2, 'SI1': 3, 'VS2': 4, 'VS1': 5, 'VVS2': 6, 'VVS1': 7, 'IF': 8}
color_dict = {'D':7, 'E':6, 'F':5, 'G':4, 'H':3, 'I':2, 'J':1}
 
df['cut'] = df['cut'].map(cut_dict)
df['clarity'] = df['clarity'].map(clarity_dict)
df['color'] = df['color'].map(color_dict)
df = df.drop('Unnamed: 0', axis=1)
					
				
			
		



चरण 4: फीचर स्केलिंग और डेटा शफल करना





		
		
			
			
Java
			
			df = utils.shuffle(df, random_state=42)
X = df.drop(['price'], axis=1).values
X = preprocessing.scale(X)
y = df['price'].values
y = preprocessing.scale(y)
			
				
					
				
					1
2
3
4
5
				
						df = utils.shuffle(df, random_state=42)
X = df.drop(['price'], axis=1).values
X = preprocessing.scale(X)
y = df['price'].values
y = preprocessing.scale(y)
					
				
			
		



चरण 5: डेटासेट को विभाजित करना





		
		
			
			
Java
			
			test_size = 200
X_train = X[:-test_size]
y_train = y[:-test_size]
X_test = X[-test_size:]
y_test = y[-test_size:]
			
				
					
				
					1
2
3
4
5
				
						test_size = 200
X_train = X[:-test_size]
y_train = y[:-test_size]
X_test = X[-test_size:]
y_test = y[-test_size:]
					
				
			
		



चरण 6: KNN रेग्रस्सर को प्रशिक्षित करना और प्रदर्शन का मूल्यांकन करना





		
		
			
			
Java
			
			score = []
for k in range(1, 20):
    clf = KNeighborsRegressor(n_neighbors=k, weights='distance', p=1)
    clf.fit(X_train, y_train)
    score.append(clf.score(X_test, y_test))
			
				
					
				
					1
2
3
4
5
				
						score = []
for k in range(1, 20):
    clf = KNeighborsRegressor(n_neighbors=k, weights='distance', p=1)
    clf.fit(X_train, y_train)
    score.append(clf.score(X_test, y_test))
					
				
			
		



चरण 7: सटीकता स्कोर को विज़ुअलाइज़ करना





		
		
			
			
Java
			
			trace0 = go.Scatter(
    y=score,
    x=np.arange(1, len(score)+1),
    mode='lines+markers',
    marker=dict(color='rgb(100, 200, 150)')
)
layout = go.Layout(
    title='K Value vs. Accuracy Score',
    xaxis=dict(title='K Value', tickmode='linear'),
    yaxis=dict(title='Score')
)
fig = go.Figure(data=[trace0], layout=layout)
iplot(fig, filename='basic-line')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						trace0 = go.Scatter(
    y=score,
    x=np.arange(1, len(score)+1),
    mode='lines+markers',
    marker=dict(color='rgb(100, 200, 150)')
)
layout = go.Layout(
    title='K Value vs. Accuracy Score',
    xaxis=dict(title='K Value', tickmode='linear'),
    yaxis=dict(title='Score')
)
fig = go.Figure(data=[trace0], layout=layout)
iplot(fig, filename='basic-line')
					
				
			
		



चरण 8: इष्टतम 'K' मान निर्धारित करना





		
		
			
			
Java
			
			k_max = score.index(max(score)) + 1
print(f"At K = {k_max}, Max Accuracy = {max(score) * 100:.2f}%")
			
				
					
				
					1
2
				
						k_max = score.index(max(score)) + 1
print(f"At K = {k_max}, Max Accuracy = {max(score) * 100:.2f}%")
					
				
			
		



चरण 9: अंतिम मॉडल प्रशिक्षण और भविष्यवाणी





		
		
			
			
Java
			
			clf = KNeighborsRegressor(n_neighbors=50)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
y_pred = clf.predict(X_test)
			
				
					
				
					1
2
3
4
				
						clf = KNeighborsRegressor(n_neighbors=50)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
y_pred = clf.predict(X_test)
					
				
			
		



चरण 10: वास्तविक बनाम भविष्यवाणी की गई मानों की तुलना करना





		
		
			
			
Java
			
			trace0 = go.Scatter(
    y=y_test,
    x=np.arange(200),
    mode='lines+markers',
    name='Actual Price',
    marker=dict(color='rgb(110, 10, 150)')
)

trace1 = go.Scatter(
    y=y_pred,
    x=np.arange(200),
    mode='lines+markers',
    name='Predicted Price',
    line=dict(color='rgb(200, 50, 10)', dash='dot')
)

layout = go.Layout(
    xaxis=dict(title='Index'),
    yaxis=dict(title='Normalized Price')
)

figure = go.Figure(data=[trace0, trace1], layout=layout)
iplot(figure)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						trace0 = go.Scatter(
    y=y_test,
    x=np.arange(200),
    mode='lines+markers',
    name='Actual Price',
    marker=dict(color='rgb(110, 10, 150)')
)
 
trace1 = go.Scatter(
    y=y_pred,
    x=np.arange(200),
    mode='lines+markers',
    name='Predicted Price',
    line=dict(color='rgb(200, 50, 10)', dash='dot')
)
 
layout = go.Layout(
    xaxis=dict(title='Index'),
    yaxis=dict(title='Normalized Price')
)
 
figure = go.Figure(data=[trace0, trace1], layout=layout)
iplot(figure)
					
				
			
		



उपयोग किए गए 'K' मान के आधार पर हीरे की कीमतों की KNN मॉडल कितनी अच्छी तरह से भविष्यवाणी करता है, इसका एक दृश्य प्रतिनिधित्व प्रदान करने के लिए उत्पन्न प्लॉट्स मदद करते हैं।

9. निष्कर्ष

K-निकटतम पड़ोसियों का एल्गोरिदम एक बहुमुखी और सरल मशीन लर्निंग उपकरण है जो वर्गीकरण और प्रतिगमन में विभिन्न अनुप्रयोगों के लिए उपयुक्त है। इसकी प्रभावशीलता काफी हद तक 'K' के चुनाव और उपयोग किए गए दूरी मीट्रिक पर निर्भर करती है। सही डेटा पूर्व-संसाधन और फीचर स्केलिंग मॉडल के प्रदर्शन को बढ़ाने के महत्वपूर्ण चरण हैं। जबकि KNN बड़े डेटासेट के लिए गणनात्मक रूप से सघन है, इसकी सरलता इसे मशीन लर्निंग के अभ्यासकारियों के लिए एक उत्कृष्ट प्रारंभिक बिंदु बनाती है।

10. संदर्भ


Scikit-learn दस्तावेज़ीकरण: KNN
KNN में दूरी मीट्रिक
Python डेटा साइंस हैंडबुक




हमें उम्मीद है कि इस गाइड ने आपको K-निकटतम पड़ोसियों के एल्गोरिदम की स्पष्ट समझ प्रदान की है। मशीन लर्निंग तकनीकों में और अधिक गहराई वाले ट्यूटोरियल और अंतर्दृष्टि के लिए बने रहें।