स्किकिट लर्न - केएनएन लर्निंग

k-NN (k-निकटतम पड़ोसी), जो सबसे सरल मशीन लर्निंग एल्गोरिदम में से एक है, प्रकृति में गैर-पैरामीट्रिक और आलसी है। गैर-पैरामीट्रिक का अर्थ है कि अंतर्निहित डेटा वितरण के लिए कोई धारणा नहीं है अर्थात मॉडल संरचना डेटासेट से निर्धारित होती है। आलसी या उदाहरण-आधारित सीखने का मतलब है कि मॉडल पीढ़ी के उद्देश्य के लिए, इसे किसी भी प्रशिक्षण डेटा बिंदु की आवश्यकता नहीं है और परीक्षण चरण में पूरे प्रशिक्षण डेटा का उपयोग किया जाता है।

K-NN एल्गोरिथ्म निम्नलिखित दो चरणों से मिलकर बनता है -

चरण 1

इस चरण में, यह प्रशिक्षण सेट में प्रत्येक नमूने के लिए निकटतम पड़ोसियों की गणना करता है और संग्रहीत करता है।

चरण 2

इस चरण में, एक अनलेब किए गए नमूने के लिए, यह डेटासेट से निकटतम पड़ोसियों को पुनः प्राप्त करता है। फिर इन के-निकटतम पड़ोसियों के बीच, यह वोटिंग के माध्यम से वर्ग की भविष्यवाणी करता है (बहुमत वोट जीत के साथ वर्ग)।

मॉड्यूल, sklearn.neighbors कि k- निकटतम पड़ोसियों के एल्गोरिथ्म को लागू करता है, के लिए कार्यक्षमता प्रदान करता है unsupervised साथ ही साथ supervised पड़ोसी-आधारित सीखने के तरीके।

अनियंत्रित निकटतम पड़ोसी प्रत्येक नमूने के लिए निकटतम पड़ोसी (एस) को खोजने के लिए अलग-अलग एल्गोरिदम (बॉलट्री, केडीट्री या ब्रूट फोर्स) को लागू करते हैं। यह अनसुलझा संस्करण मूल रूप से केवल चरण 1 है, जिस पर ऊपर चर्चा की गई है, और कई एल्गोरिदम (केएनएन और के-साधन प्रसिद्ध होने का आधार) की आवश्यकता है जो पड़ोसी खोज की आवश्यकता होती है। सरल शब्दों में, यह पड़ोसी खोजों को लागू करने के लिए अनसुचित शिक्षार्थी है।

दूसरी ओर, पर्यवेक्षित पड़ोसी आधारित शिक्षा को वर्गीकरण के साथ-साथ प्रतिगमन के लिए उपयोग किया जाता है।

Unsupervised KNN Learning

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

स्किकिट-सीखो मॉड्यूल

sklearn.neighbors.NearestNeighborsमॉड्यूल का उपयोग किया गया है जिसका उपयोग अनपढ़ निकटतम पड़ोसी शिक्षण को लागू करने के लिए किया जाता है। यह विशिष्ट निकटतम पड़ोसी एल्गोरिदम का उपयोग करता है जिसका नाम बॉलट्री, केडीट्री या ब्रूट फोर्स है। दूसरे शब्दों में, यह इन तीन एल्गोरिदम के लिए एक समान इंटरफ़ेस के रूप में कार्य करता है।

मापदंडों

अनुसरण तालिका में उपयोग किए गए पैरामीटर शामिल हैं NearestNeighbors मॉड्यूल -

अनु क्रमांक	पैरामीटर और विवरण
1	n_neighbors - इंट, वैकल्पिक पड़ोसियों की संख्या प्राप्त करने के लिए। डिफ़ॉल्ट मान 5 है।
2	radius - फ्लोट, वैकल्पिक यह पड़ोसियों की वापसी की दूरी को सीमित करता है। डिफ़ॉल्ट मान 1.0 है।
3	algorithm - {'ऑटो', 'बॉल_ट्री', 'kd_tree', 'जानवर'}, वैकल्पिक यह पैरामीटर उस एल्गोरिथ्म (BallTree, KDTree या Brute-Force) को ले जाएगा जिसका उपयोग आप निकटतम पड़ोसियों की गणना करने के लिए करना चाहते हैं। यदि आप 'ऑटो' प्रदान करेंगे, तो यह फिट विधि के लिए पारित मूल्यों के आधार पर सबसे उपयुक्त एल्गोरिदम को तय करने का प्रयास करेगा।
4	leaf_size - इंट, वैकल्पिक यह निर्माण और क्वेरी की गति और साथ ही पेड़ को स्टोर करने के लिए आवश्यक मेमोरी को प्रभावित कर सकता है। इसे बॉलट्री या केडीट्री को पास किया जाता है। यद्यपि इष्टतम मूल्य समस्या की प्रकृति पर निर्भर करता है, लेकिन इसका डिफ़ॉल्ट मान 30 है।
5	metric - स्ट्रिंग या कॉल करने योग्य यह बिंदुओं के बीच दूरी की गणना के लिए उपयोग करने के लिए मीट्रिक है। हम इसे एक स्ट्रिंग या कॉल करने योग्य फ़ंक्शन के रूप में पास कर सकते हैं। कॉल करने योग्य फ़ंक्शन के मामले में, मीट्रिक को प्रत्येक जोड़ी की पंक्तियों पर बुलाया जाता है और परिणामी मूल्य दर्ज किया जाता है। यह एक स्ट्रिंग के रूप में मीट्रिक नाम को पारित करने से कम कुशल है। हम मैट्रिक से स्किकिट-लर्न या स्काइप.स्पैटियल.डिस्टेंस से चुन सकते हैं। मान्य मान इस प्रकार हैं - स्किकिट-लर्न - ['कोसाइन', 'मैनहट्टन', 'यूक्लिडियन', 'एल 1', 'एल 2', 'सिटीब्लॉक'] Scipy.spatial.distance - ['ब्रेयर्टिस', 'कैनबरा', 'चेबीशेव', 'पासा', 'हैमिंग', 'जेकॉर्ड', 'सहसंबंध', 'कुल्लिंस्की', 'महालनोबिस,' मिंकोव्स्की ',' रॉजेरिस्टिमोटो ',' रुसेलेराव ',' sokalmicheme ',' sokalsneath ',' seuclidean ',' sqeuclidean ',' yule ']। डिफ़ॉल्ट मीट्रिक 'मिंकोव्स्की' है।
6	P - पूर्णांक, वैकल्पिक यह Minkowski मीट्रिक के लिए पैरामीटर है। डिफ़ॉल्ट मान 2 है जो यूक्लिडियन_डिस्टेंस (एल 2) का उपयोग करने के बराबर है।
7	metric_params - तानाशाही, वैकल्पिक यह मीट्रिक फ़ंक्शन के लिए अतिरिक्त कीवर्ड तर्क है। कोई डिफ़ॉल्ट मान नहीं है।
8	N_jobs - int या कोई नहीं, वैकल्पिक यह पड़ोसी खोज के लिए समानांतर नौकरियों के अंक को फिर से शुरू करता है। कोई डिफ़ॉल्ट मान नहीं है।

Implementation Example

नीचे दिए गए उदाहरण से डेटा के दो सेटों के बीच निकटतम पड़ोसियों का उपयोग किया जाएगा sklearn.neighbors.NearestNeighbors मापांक।

सबसे पहले, हमें आवश्यक मॉड्यूल और पैकेज आयात करने की आवश्यकता है -

from sklearn.neighbors import NearestNeighbors
import numpy as np

अब पैकेजों को आयात करने के बाद, हम निकटतम पड़ोसियों को ढूंढना चाहते हैं, बीच में डेटा के सेट को परिभाषित करें -

Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])

इसके बाद, अनियोजित शिक्षण एल्गोरिथ्म लागू करें, इस प्रकार है -

nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm = 'ball_tree')

अगला, इनपुट डेटा सेट के साथ मॉडल फिट करें।

nrst_neigh.fit(Input_data)

अब, डेटा सेट के K- पड़ोसियों को खोजें। यह प्रत्येक बिंदु के पड़ोसियों के सूचकांकों और दूरी को लौटाएगा।

distances, indices = nbrs.kneighbors(Input_data)
indices

Output

array(
   [
      [0, 1, 3],
      [1, 2, 0],
      [2, 1, 0],
      [3, 4, 0],
      [4, 5, 3],
      [5, 6, 4],
      [6, 5, 4]
   ], dtype = int64
)
distances

Output

array(
   [
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712],
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712]
   ]
)

उपरोक्त आउटपुट से पता चलता है कि प्रत्येक बिंदु का निकटतम पड़ोसी बिंदु ही शून्य पर है। ऐसा इसलिए है क्योंकि क्वेरी सेट प्रशिक्षण सेट से मेल खाता है।

Example

हम निम्नानुसार एक विरल ग्राफ का निर्माण करके पड़ोसी बिंदुओं के बीच संबंध भी दिखा सकते हैं -

nrst_neigh.kneighbors_graph(Input_data).toarray()

Output

array(
   [
      [1., 1., 0., 1., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 0., 0., 1., 1., 0., 0.],
      [0., 0., 0., 1., 1., 1., 0.],
      [0., 0., 0., 0., 1., 1., 1.],
      [0., 0., 0., 0., 1., 1., 1.]
   ]
)

एक बार हम अनसुने के बाद फिट होते हैं NearestNeighbors मॉडल, डेटा को तर्क के लिए निर्धारित मूल्य के आधार पर डेटा संरचना में संग्रहीत किया जाएगा ‘algorithm’। उसके बाद हम इस अप्रशिक्षित शिक्षार्थी का उपयोग कर सकते हैंkneighbors एक मॉडल में जिसे पड़ोसी खोजों की आवश्यकता होती है।

Complete working/executable program

from sklearn.neighbors import NearestNeighbors
import numpy as np
Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])
nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm='ball_tree')
nrst_neigh.fit(Input_data)
distances, indices = nbrs.kneighbors(Input_data)
indices
distances
nrst_neigh.kneighbors_graph(Input_data).toarray()

केएनएन लर्निंग का पर्यवेक्षण किया

पर्यवेक्षित पड़ोसी आधारित सीखने का उपयोग निम्नलिखित के लिए किया जाता है -

असतत लेबल वाले डेटा के लिए वर्गीकरण
प्रतिगमन, निरंतर लेबल वाले डेटा के लिए।

निकटतम पड़ोसी क्लासिफायर

हम निम्नलिखित दो विशेषताओं की सहायता से पड़ोसियों के आधार पर वर्गीकरण को समझ सकते हैं -

इसकी गणना प्रत्येक बिंदु के निकटतम पड़ोसियों के एक साधारण बहुमत से की जाती है।
यह बस प्रशिक्षण डेटा के उदाहरणों को संग्रहीत करता है, यही कारण है कि यह एक प्रकार का गैर-सामान्यकरण सीखने है।

स्किकिट-सीखें मॉड्यूल

फॉलोइंग दो अलग-अलग प्रकार के निकटतम पड़ोसी क्लासीफायर हैं जिनका उपयोग शिकिट-लर्न द्वारा किया जाता है -

क्र.सं.	क्लासीफायर और विवरण
1।	KNeighborsClassifier इस क्लासिफायर के नाम के K, निकटतम पड़ोसियों का प्रतिनिधित्व करता है, जहां k उपयोगकर्ता द्वारा निर्दिष्ट पूर्णांक मान है। इसलिए जैसा कि नाम से पता चलता है, यह क्लासिफायरर निकटतम पड़ोसियों के आधार पर सीखने को लागू करता है। K के मूल्य का चुनाव डेटा पर निर्भर है।
2।	RadiusNeighborsClassifier इस क्लासिफायर के नाम पर त्रिज्या एक निर्दिष्ट त्रिज्या आर के भीतर निकटतम पड़ोसियों का प्रतिनिधित्व करता है, जहां आर उपयोगकर्ता द्वारा निर्दिष्ट एक अस्थायी-बिंदु मान है। इसलिए जैसा कि नाम से पता चलता है, यह क्लासिफायर प्रत्येक प्रशिक्षण बिंदु के निश्चित त्रिज्या r के भीतर संख्या पड़ोसियों के आधार पर सीखता है।

निकटतम पड़ोसी रेजिस्टर

इसका उपयोग उन मामलों में किया जाता है जहां डेटा लेबल प्रकृति में निरंतर होते हैं। असाइन किए गए डेटा लेबल की गणना उसके निकटतम पड़ोसियों के लेबल के माध्य के आधार पर की जाती है।

फॉलोइंग दो अलग-अलग प्रकार के नज़दीकी पड़ोसी रेजिस्टर हैं जिनका उपयोग शिकिट-लर्न द्वारा किया जाता है -

KNeighborsRegressor

इस रजिस्ट्रार के नाम के K, निकटतम पड़ोसियों का प्रतिनिधित्व करता है, जहां k है एक integer valueउपयोगकर्ता द्वारा निर्दिष्ट। इसलिए, जैसा कि नाम से पता चलता है, यह प्रतिगामी k निकटतम पड़ोसियों के आधार पर सीखता है। K के मूल्य का चुनाव डेटा पर निर्भर है। आइए इसे एक कार्यान्वयन उदाहरण की सहायता से अधिक समझते हैं।

कार्यान्वयन उदाहरण

इस उदाहरण में, हम scikit-learn का उपयोग करके Iris Flower डेटा सेट नाम के डेटा सेट पर KNN को लागू करेंगे KNeighborsRegressor।

सबसे पहले, आईरिस डेटासेट निम्नानुसार आयात करें -

from sklearn.datasets import load_iris
iris = load_iris()

अब, हमें डेटा को प्रशिक्षण और परीक्षण डेटा में विभाजित करने की आवश्यकता है। हम स्केलेरन का उपयोग करेंगेtrain_test_split 70 (प्रशिक्षण डेटा) और 20 (परीक्षण डेटा) के अनुपात में डेटा को विभाजित करने के लिए कार्य -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

इसके बाद, हम स्केलेर प्रीप्रोसेसिंग मॉड्यूल की मदद से डेटा स्केलिंग करेंगे: -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

अगला, आयात करें KNeighborsRegressor Sklearn से वर्ग और निम्न के रूप में पड़ोसियों के मूल्य प्रदान करते हैं।

उदाहरण

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 8)
knnr.fit(X_train, y_train)

उत्पादन

KNeighborsRegressor(
   algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = None, n_neighbors = 8, p = 2,
   weights = 'uniform'
)

उदाहरण

अब, हम एमएसई (मीन चुकता त्रुटि) निम्नानुसार पा सकते हैं -

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

उत्पादन

The MSE is: 4.4333349609375

उदाहरण

अब, मूल्य का अनुमान लगाने के लिए इसका उपयोग इस प्रकार करें -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

उत्पादन

[0.66666667]

पूर्ण कार्य / निष्पादन योग्य कार्यक्रम

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=8)
knnr.fit(X_train, y_train)

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

RadiusNeighborsRegressor

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

कार्यान्वयन उदाहरण

इस उदाहरण में, हम scikit-learn का उपयोग करके Iris Flower डेटा सेट नाम के डेटा सेट पर KNN को लागू करेंगे RadiusNeighborsRegressor -

सबसे पहले, आईरिस डेटासेट निम्नानुसार आयात करें -

from sklearn.datasets import load_iris
iris = load_iris()

अब, हमें डेटा को प्रशिक्षण और परीक्षण डेटा में विभाजित करने की आवश्यकता है। हम डेटा को 70 (प्रशिक्षण डेटा) और 20 (परीक्षण डेटा) के अनुपात में विभाजित करने के लिए Sklearn train_test_split फ़ंक्शन का उपयोग करेंगे -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

अगला, आयात करें RadiusneighborsRegressor स्केलेर से वर्ग और त्रिज्या का मूल्य निम्नानुसार प्रदान करते हैं -

import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X_train, y_train)

उदाहरण

अब, हम एमएसई (मीन चुकता त्रुटि) निम्नानुसार पा सकते हैं -

print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))

उत्पादन

The MSE is: The MSE is: 5.666666666666667

उदाहरण

अब, मूल्य का अनुमान लगाने के लिए इसका उपयोग इस प्रकार करें -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))

उत्पादन

[1.]

पूर्ण कार्य / निष्पादन योग्य कार्यक्रम

from sklearn.datasets import load_iris

iris = load_iris()

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X_train, y_train)
print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))