केएनएन क्लासिफायर

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

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

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

एल्गोरिथ्म

परीक्षण नमूने के प्रत्येक ऑब्जेक्ट को वर्गीकृत करने के लिए, निम्नलिखित संचालन क्रमिक रूप से किए जाने चाहिए:

• प्रशिक्षण सेट में प्रत्येक ऑब्जेक्ट के लिए दूरी की गणना करें
• प्रशिक्षण नमूने की k वस्तुओं का चयन करें, जिसकी दूरी न्यूनतम है
• एक वर्गीकृत वस्तु का वर्ग वह वर्ग है जो अक्सर निकटतम पड़ोसियों के बीच पाया जाता है

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

import random import math import pylab as pl import numpy as np from matplotlib.colors import ListedColormap 

स्रोत डेटा

उदाहरण के लिए क्लासिफायर के काम पर विचार करें। आरंभ करने के लिए, हमें डेटा तैयार करना होगा, जिस पर प्रयोग किए जाएंगे:

 #Train data generator def generateData (numberOfClassEl, numberOfClasses): data = [] for classNum in range(numberOfClasses): #Choose random center of 2-dimensional gaussian centerX, centerY = random.random()*5.0, random.random()*5.0 #Choose numberOfClassEl random nodes with RMS=0.5 for rowNum in range(numberOfClassEl): data.append([ [random.gauss(centerX,0.5), random.gauss(centerY,0.5)], classNum]) return data 

सादगी के लिए, मैंने एक दो-आयामी स्थान चुना, जिसमें 0.5 के मानक विचलन के साथ एक दो-आयामी गाऊसी के गणितीय अपेक्षा के स्थान को प्रत्येक अक्ष के साथ 0 से 5 तक के खंड पर बेतरतीब ढंग से चुना गया है। मान 0.5 को चुना जाता है ताकि ऑब्जेक्ट काफी अच्छी तरह से अलग हो जाएं ( तीन सिग्मा का नियम )।
परिणामी चयन को देखने के लिए, आपको निम्नलिखित कोड चलाने की आवश्यकता है:

 def showData (nClasses, nItemsInClass): trainData = generateData (nItemsInClass, nClasses) classColormap = ListedColormap(['#FF0000', '#00FF00', '#FFFFFF']) pl.scatter([trainData[i][0][0] for i in range(len(trainData))], [trainData[i][0][1] for i in range(len(trainData))], c=[trainData[i][1] for i in range(len(trainData))], cmap=classColormap) pl.show() showData (3, 40) 

इस कोड के निष्पादन से उत्पन्न छवि का एक उदाहरण इस प्रकार है:

प्रशिक्षण और परीक्षण के नमूने प्राप्त करना

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

 #Separate N data elements in two parts: # test data with N*testPercent elements # train_data with N*(1.0 - testPercent) elements def splitTrainTest (data, testPercent): trainData = [] testData = [] for row in data: if random.random() < testPercent: testData.append(row) else: trainData.append(row) return trainData, testData 

क्लासिफायर इम्प्लीमेंटेशन

अब, एक प्रशिक्षण नमूना होने पर, हम वर्गीकरण एल्गोरिथम को स्वयं कार्यान्वित कर सकते हैं:

 #Main classification procedure def classifyKNN (trainData, testData, k, numberOfClasses): #Euclidean distance between 2-dimensional point def dist (a, b): return math.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2) testLabels = [] for testPoint in testData: #Claculate distances between test point and all of the train points testDist = [ [dist(testPoint, trainData[i][0]), trainData[i][1]] for i in range(len(trainData))] #How many points of each class among nearest K stat = [0 for i in range(numberOfClasses)] for d in sorted(testDist)[0:k]: stat[d[1]] += 1 #Assign a class with the most number of occurences among K nearest neighbours testLabels.append( sorted(zip(stat, range(numberOfClasses)), reverse=True)[0][1] ) return testLabels 

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

निष्पादन उदाहरण

अब आप मूल्यांकन कर सकते हैं कि हमारा क्लासिफायर कितनी अच्छी तरह काम करता है। ऐसा करने के लिए, हम डेटा उत्पन्न करेंगे, हम इसे एक प्रशिक्षण और परीक्षण नमूने में विभाजित करेंगे, हम परीक्षण नमूने की वस्तुओं को वर्गीकृत करेंगे और परिणामी वर्गीकरण के साथ वर्ग के वास्तविक मूल्य की तुलना करेंगे:

 #Calculate classification accuracy def calculateAccuracy (nClasses, nItemsInClass, k, testPercent): data = generateData (nItemsInClass, nClasses) trainData, testDataWithLabels = splitTrainTest (data, testPercent) testData = [testDataWithLabels[i][0] for i in range(len(testDataWithLabels))] testDataLabels = classifyKNN (trainData, testData, k, nClasses) print "Accuracy: ", sum([int(testDataLabels[i]==testDataWithLabels[i][1]) for i in range(len(testDataWithLabels))]) / float(len(testDataWithLabels)) 

क्लासिफायर की गुणवत्ता का मूल्यांकन करने के लिए, विभिन्न एल्गोरिदम और विभिन्न उपायों का उपयोग किया जाता है, अधिक विवरण यहां पाया जा सकता है: विकी

अब सबसे दिलचस्प बात बनी हुई है: क्लासिफायर के ऑपरेशन को ग्राफिक रूप से दिखाना। नीचे दिए गए चित्रों में, मैंने 3 वर्गों का उपयोग किया, प्रत्येक में 40 तत्वों के साथ, एल्गोरिथ्म के लिए k का मूल्य तीन होने के लिए लिया गया था।





इन चित्रों को प्रदर्शित करने के लिए निम्न कोड का उपयोग किया गया था:

 #Visualize classification regions def showDataOnMesh (nClasses, nItemsInClass, k): #Generate a mesh of nodes that covers all train cases def generateTestMesh (trainData): x_min = min( [trainData[i][0][0] for i in range(len(trainData))] ) - 1.0 x_max = max( [trainData[i][0][0] for i in range(len(trainData))] ) + 1.0 y_min = min( [trainData[i][0][1] for i in range(len(trainData))] ) - 1.0 y_max = max( [trainData[i][0][1] for i in range(len(trainData))] ) + 1.0 h = 0.05 testX, testY = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) return [testX, testY] trainData = generateData (nItemsInClass, nClasses) testMesh = generateTestMesh (trainData) testMeshLabels = classifyKNN (trainData, zip(testMesh[0].ravel(), testMesh[1].ravel()), k, nClasses) classColormap = ListedColormap(['#FF0000', '#00FF00', '#FFFFFF']) testColormap = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAAA']) pl.pcolormesh(testMesh[0], testMesh[1], np.asarray(testMeshLabels).reshape(testMesh[0].shape), cmap=testColormap) pl.scatter([trainData[i][0][0] for i in range(len(trainData))], [trainData[i][0][1] for i in range(len(trainData))], c=[trainData[i][1] for i in range(len(trainData))], cmap=classColormap) pl.show() 

निष्कर्ष

केएनएन सबसे सरल वर्गीकरण एल्गोरिदम में से एक है, इसलिए यह अक्सर वास्तविक समस्याओं में अप्रभावी हो जाता है। वर्गीकरण की सटीकता के अलावा, इस क्लासिफ़ायर की समस्या वर्गीकरण की गति है: यदि प्रशिक्षण सेट में एन ऑब्जेक्ट्स, टेस्ट सेट में एम ऑब्जेक्ट्स और अंतरिक्ष आयाम के हैं, तो परीक्षण के नमूने को वर्गीकृत करने के लिए संचालन की संख्या को ओ (के * एम * एन) के रूप में अनुमानित किया जा सकता है। फिर भी, मशीन लर्निंग के साथ आरंभ करने के लिए kNN एल्गोरिथ्म एक अच्छा उदाहरण है।

संदर्भ

1. Machinelearning.ru पर निकटतम पड़ोसियों की विधि
2. Machinelearning.ru पर वेक्टर मॉडल
3. सूचना पुनर्प्राप्ति पर पुस्तक
4. शिक-सीख के ढांचे में निकटतम पड़ोसियों की पद्धति का विवरण
5. "सामूहिक मन की प्रोग्रामिंग" पुस्तक