कोड की 25 लाइनों में Naive Bayesian क्लासिफायरियर

भोले बेसेसियन क्लासिफ़ायरफ़ायर सरल वर्गीकरण एल्गोरिदम में से एक है। हालाँकि, बहुत बार यह अधिक जटिल एल्गोरिदम की तुलना में कोई बदतर या इससे भी बेहतर काम करता है। यहां मैं कोड और एक विवरण साझा करना चाहता हूं कि यह सब कैसे काम करता है।

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

सिद्धांत की बिट

मान लें कि हमारे पास पाठ O की एक पंक्ति है। इसके अलावा, वर्ग C हैं, जिनमें से एक में हमें एक पंक्ति शामिल करनी चाहिए। हमें एक वर्ग c खोजने की आवश्यकता है जिसमें किसी दिए गए स्ट्रिंग के लिए इसकी संभावना अधिकतम होगी। गणितीय रूप से, इसे इस तरह लिखा जाता है:



कम्प्यूटिंग पी (सी | ओ) मुश्किल है। लेकिन आप बायेसियन प्रमेय का उपयोग कर सकते हैं और अप्रत्यक्ष संभावनाओं पर जा सकते हैं:



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



हरगिज हमें दिलचस्पी नहीं है। अंश को फिर से लिखा जा सकता है।



लेकिन यह फिर से मुश्किल है। यहाँ हम "भोले" धारणा को शामिल करते हैं कि चर O केवल वर्ग C पर निर्भर करते हैं, और एक दूसरे पर निर्भर नहीं होते हैं। यह बहुत सरलीकरण है, लेकिन अक्सर यह काम करता है। अंश ले जाएगा फार्म:



अंतिम सूत्र फार्म ले जाएगा:

(1)

यानी आपको बस इतना करने की आवश्यकता है कि संभावनाओं की गणना P (C) और P (O | C) है। इन मापदंडों की गणना को क्लासिफायरियर का प्रशिक्षण कहा जाता है।

कोड

नीचे अजगर कोड है। इसमें केवल दो कार्य शामिल हैं: एक प्रशिक्षण के लिए (सूत्र के मापदंडों की गिनती), दूसरा वर्गीकरण के लिए (सूत्र की प्रत्यक्ष गणना)।

from __future__ import division from collections import defaultdict from math import log def train(samples): classes, freq = defaultdict(lambda:0), defaultdict(lambda:0) for feats, label in samples: classes[label] += 1 # count classes frequencies for feat in feats: freq[label, feat] += 1 # count features frequencies for label, feat in freq: # normalize features frequencies freq[label, feat] /= classes[label] for c in classes: # normalize classes frequencies classes[c] /= len(samples) return classes, freq # return P(C) and P(O|C) def classify(classifier, feats): classes, prob = classifier return min(classes.keys(), # calculate argmin(-log(C|O)) key = lambda cl: -log(classes[cl]) + \ sum(-log(prob.get((cl,feat), 10**(-7))) for feat in feats)) 

ट्रेन फ़ंक्शन में, पहली पांच लाइनें वर्ग सी की संख्या, साथ ही एक नमूने में सुविधाओं ओ और सी की घटना की आवृत्ति की गणना करती हैं। विधि का दूसरा भाग बस इन आवृत्तियों को सामान्य करता है। इस प्रकार, संभाव्यता P © और P (O | C) आउटपुट पर प्राप्त की जाती है।

सबसे अधिक संभावना वर्ग के लिए वर्गीकृत फ़ंक्शन खोज। सूत्र (1) से एकमात्र अंतर यह है कि मैं संभावनाओं के उत्पाद को ऋणात्मक चिन्ह के साथ लिए गए लघुगणक के योग से प्रतिस्थापित करता हूं, और मैं argmax की गणना नहीं करता, लेकिन argmin। लॉगरिदम पर स्विच करना बहुत छोटी संख्याओं से बचने के लिए एक सामान्य तकनीक है जिसे संभावनाओं को गुणा करके प्राप्त किया जा सकता है।
संख्या 10 (^ - 7), जिसे लघुगणक में प्रतिस्थापित किया गया है, लघुगणक के तर्क में शून्य से बचने का एक तरीका है (क्योंकि यह अन्यथा अपरिभाषित होगा)।

क्लासीफायर को प्रशिक्षित करने के लिए, पुरुष और महिला नामों की एक चिह्नित सूची लें और इस कोड का उपयोग करें:

 def get_features(sample): return (sample[-1],) # get last letter samples = (line.decode('utf-8').split() for line in open('names.txt')) features = [(get_features(feat), label) for feat, label in samples] classifier = train(features) print 'gender: ', classify(classifier, get_features(u'')) 

फ़ाइल 'name.txt' को यहाँ डाउनलोड किया जा सकता है ।

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

 def get_features(sample): return ( 'll: %s' % sample[-1], # get last letter 'fl: %s' % sample[0], # get first letter 'sl: %s' % sample[1], # get second letter ) 

एल्गोरिथ्म का उपयोग किसी भी संख्या में वर्गों के लिए किया जा सकता है। उदाहरण के लिए, आप भावनात्मक रंग द्वारा ग्रंथों का एक वर्गीकरण बनाने की कोशिश कर सकते हैं।

परीक्षण

मैंने नामों के साथ मूल मामले के कुछ हिस्सों पर वर्गीकरण का परीक्षण किया। सटीकता 96% थी। यह एक शानदार परिणाम नहीं है, लेकिन कई कार्यों के लिए यह काफी पर्याप्त है।