Gaussian Naive Bayes, Explained - Plato AiStream V2.1

प्लेटो द्वारा पुनर्प्रकाशित

अनुयायियों: 0

गॉसियन नैवे बेयस, समझाया गया
गॉसियन नैव बेयस क्लासिफायरियर का निर्णय क्षेत्र। लेखक द्वारा छवि.

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

इस आर्टिकल में आप सीख सकते हैं

अनुभवहीन बेयस क्लासिफायर कैसे काम करते हैं,
उन्हें वैसे ही परिभाषित करना क्यों उचित है जैसे वे हैं और
NumPy का उपयोग करके उन्हें Python में कैसे कार्यान्वित करें।

आप कोड यहां पा सकते हैं मेरा जीथूब.

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

हम अनुभवहीन बेयस वर्गीकरण के आश्चर्यजनक रूप से सरल सिद्धांत की खोज शुरू करेंगे और फिर कार्यान्वयन की ओर बढ़ेंगे।

वर्गीकरण करते समय हमारी वास्तव में क्या रुचि होती है? हम वास्तव में क्या कर रहे हैं, इनपुट और आउटपुट क्या है? उत्तर सीधा है:

डेटा बिंदु x को देखते हुए, x के किसी वर्ग c से संबंधित होने की क्या संभावना है?

हम बस यही उत्तर देना चाहते हैं कोई वर्गीकरण. आप इस कथन को सीधे सशर्त संभाव्यता के रूप में मॉडल कर सकते हैं: p(c|x).

उदाहरण के लिए, यदि वहाँ हैं

3 कक्षाएं सी₁, सी₂, सी₃, तथा
x इसमें 2 विशेषताएं शामिल हैं x₁, x₂,

क्लासिफायरियर का परिणाम कुछ इस प्रकार हो सकता है p(सी₁|x₁, x₂) = 0.3, p(सी₂|x₁, x₂)=0.5 और p(सी₃|x₁, x₂)=0.2. यदि हम आउटपुट के रूप में एकल लेबल की परवाह करते हैं, तो हम सबसे अधिक संभावना वाले को चुनेंगे, यानी। सी₂ यहां 50% की संभावना के साथ।

अनुभवहीन बेयस क्लासिफायर इन संभावनाओं की सीधे गणना करने का प्रयास करता है।

भोले भाले

ठीक है, तो एक डेटा बिंदु दिया गया है x, हम गणना करना चाहते हैं p(c|x) सभी वर्गों के लिए c और फिर आउटपुट करें c उच्चतम संभावना के साथ. सूत्रों में आप अक्सर इसे इस रूप में देखते हैं

गॉसियन नैवे बेयस, समझाया गया
लेखक द्वारा छवि।

नोट: मैक्स p(c|x) argmax होने पर अधिकतम संभावना लौटाता है p(c|x) लौटाता है c इस उच्चतम संभावना के साथ.

लेकिन इससे पहले कि हम अनुकूलन कर सकें p(c|x), हमें इसकी गणना करने में सक्षम होना होगा। इसके लिए हम प्रयोग करते हैं बेयस प्रमेय:

गॉसियन नैवे बेयस, समझाया गया
बेयस प्रमेय. लेखक द्वारा छवि.

यह भोले बेयस का बेयस भाग है। लेकिन अब, हमारे सामने निम्नलिखित समस्या है: क्या हैं p(x|c) और p(c)?

एक अनुभवहीन बेयस क्लासिफायरियर का प्रशिक्षण इसी बारे में है।

ट्रेनिंग

सब कुछ स्पष्ट करने के लिए, आइए हम एक खिलौना डेटासेट का उपयोग करें दो वास्तविक विशेषताएं x₁, x₂, तथा तीन वर्ग सी₁, सी₂, सी₃ निम्नलिखित में।

गॉसियन नैवे बेयस, समझाया गया
डेटा, विज़ुअलाइज़ किया गया। लेखक द्वारा छवि.

आप इसके माध्यम से यह सटीक डेटासेट बना सकते हैं

from sklearn.datasets import make_blobs X, y = make_blobs(n_samples=20, centers=[(0,0), (5,5), (-5, 5)], random_state=0)

शुरुआत करते हैं वर्ग संभाव्यता p(c), संभावना है कि कुछ वर्ग c लेबल किए गए डेटासेट में देखा गया है। इसका अनुमान लगाने का सबसे सरल तरीका केवल वर्गों की सापेक्ष आवृत्तियों की गणना करना और उन्हें संभावनाओं के रूप में उपयोग करना है। हम अपने डेटासेट का उपयोग यह देखने के लिए कर सकते हैं कि इसका वास्तव में क्या मतलब है।

7 में से 20 अंक वर्ग लेबल वाले हैं सी₁ (नीला) डेटासेट में, इसलिए हम कहते हैं p(सी₁)=7/20. हमारे पास कक्षा के लिए 7 अंक हैं सी₂ (लाल) भी, इसलिए हम सेट करते हैं p(सी₂)=7/20. आखिरी कक्षा सी₃ इसलिए, (पीला) में केवल 6 अंक हैं p(सी₃)=6/20.

वर्ग संभावनाओं की यह सरल गणना अधिकतम संभावना दृष्टिकोण से मिलती जुलती है। हालाँकि, आप दूसरे का भी उपयोग कर सकते हैं पूर्व वितरण, यदि आप चाहें। उदाहरण के लिए, यदि आप जानते हैं कि यह डेटासेट वास्तविक जनसंख्या का प्रतिनिधि नहीं है क्योंकि वर्ग सी₃ 50% मामलों में दिखना चाहिए, फिर आप सेट करें p(सी₁) = 0.25, p(सी₂)=0.25 और p(सी₃)=0.5. जो कुछ भी आपको परीक्षण सेट पर प्रदर्शन को बेहतर बनाने में मदद करता है।

अब हम बारी करते हैं संभावना p(x|c)=p(x₁, x₂|c). इस संभावना की गणना करने का एक तरीका लेबल के साथ नमूनों के लिए डेटासेट को फ़िल्टर करना है c और फिर एक वितरण (उदाहरण के लिए 2-आयामी गाऊसी) ढूंढने का प्रयास करें जो सुविधाओं को कैप्चर करता है x₁, x₂.

दुर्भाग्य से, आमतौर पर, संभावना का उचित अनुमान लगाने के लिए हमारे पास प्रति वर्ग पर्याप्त नमूने नहीं होते हैं।

अधिक मजबूत मॉडल बनाने में सक्षम होने के लिए, हम बनाते हैं भोली धारणा वह विशेषताएँ x₁, x₂ रहे स्टोकेस्टिक रूप से स्वतंत्र, दिया हुआ c. यह गणित को आसान बनाने का एक शानदार तरीका है

गॉसियन नैवे बेयस, समझाया गया
लेखक द्वारा छवि

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

ऊपर दिए गए तर्क किसी भी अनुभवहीन बेयस क्लासिफायर के लिए समान हैं जिन्हें आप पा सकते हैं। अब यह सिर्फ इस पर निर्भर करता है कि आप कैसा मॉडल बनाते हैं p(x₁|c₁), p(x₁|c₁), p(x₁|c₂), p(x₂|c₂), p(x₁|c₃) और p(x₂|c₃).

यदि आपकी विशेषताएँ केवल 0 और 1 हैं, तो आप a का उपयोग कर सकते हैं बर्नौली वितरण. यदि वे पूर्णांक हैं, a बहुपद वितरण. हालाँकि, हमारे पास वास्तविक सुविधा मूल्य हैं और हम इसके लिए निर्णय लेते हैं गाऊसी वितरण, इसलिए इसका नाम गॉसियन नैवे बेयस पड़ा। हम निम्नलिखित रूप धारण करते हैं

गॉसियन नैवे बेयस, समझाया गया
लेखक द्वारा छवि।

जहां μᵢ,ⱼ माध्य है और σᵢ,ⱼ मानक विचलन है जिसका अनुमान हमें डेटा से लगाना है। इसका मतलब है कि हमें प्रत्येक सुविधा के लिए एक माध्य मिलता है i एक वर्ग के साथ युग्मित cⱼ, हमारे मामले में 2*3=6 का अर्थ है। मानक विचलन के लिए भी यही बात लागू होती है। इसके लिए एक उदाहरण की आवश्यकता है.

आइए अनुमान लगाने का प्रयास करें μ₂,₁ और σ₂,₁। इसलिये j=1, हम केवल कक्षा में रुचि रखते हैं सी₁, आइए हम केवल इस लेबल वाले नमूने ही रखें। निम्नलिखित नमूने बचे हैं:

# samples with label = c_1 array([[ 0.14404357, 1.45427351], [ 0.97873798, 2.2408932 ], [ 1.86755799, -0.97727788], [ 1.76405235, 0.40015721], [ 0.76103773, 0.12167502], [-0.10321885, 0.4105985 ], [ 0.95008842, -0.15135721]])

अब, के कारण i=2 हमें केवल दूसरे कॉलम पर विचार करना है। μ₂,₁ माध्य है और σ₂,₁ इस कॉलम के लिए मानक विचलन, यानी। μ₂,₁ = 0.49985176 और σ₂,₁ = 0.9789976.

यदि आप ऊपर से स्कैटर प्लॉट को फिर से देखते हैं तो ये संख्याएँ समझ में आती हैं। सुविधाएं x₂ कक्षा से नमूनों की सी₁ लगभग 0.5 हैं, जैसा कि आप चित्र से देख सकते हैं।

अब हम अन्य पांच संयोजनों के लिए इसकी गणना करते हैं और हमारा काम हो गया!

पायथन में, आप इसे इस तरह कर सकते हैं:

from sklearn.datasets import make_blobs
import numpy as np # Create the data. The classes are c_1=0, c_2=1 and c_3=2.
X, y = make_blobs( n_samples=20, centers=[(0, 0), (5, 5), (-5, 5)], random_state=0
) # The class probabilities.
# np.bincounts counts the occurence of each label.
prior = np.bincount(y) / len(y) # np.where(y==i) returns all indices where the y==i.
# This is the filtering step.
means = np.array([X[np.where(y == i)].mean(axis=0) for i in range(3)])
stds = np.array([X[np.where(y == i)].std(axis=0) for i in range(3)])

हमें मिलता है

# priors
array([0.35, 0.35, 0.3 ])
# means array([[ 0.90889988, 0.49985176], [ 5.4111385 , 4.6491892 ], [-4.7841679 , 5.15385848]])
# stds
array([[0.6853714 , 0.9789976 ], [1.40218915, 0.67078568], [0.88192625, 1.12879666]])

यह गाऊसी अनुभवहीन बेयस क्लासिफायरियर के प्रशिक्षण का परिणाम है।

पूर्वानुमान करना

संपूर्ण भविष्यवाणी सूत्र है

गॉसियन नैवे बेयस, समझाया गया
लेखक द्वारा छवि।

आइए एक नया डेटा बिंदु मान लें एक्स*=(-2) आता है।

गॉसियन नैवे बेयस, समझाया गया
लेखक द्वारा छवि।

यह देखने के लिए कि यह किस वर्ग का है, आइए गणना करें p(c|x*) सभी वर्गों के लिए। चित्र से, यह वर्ग से संबंधित होना चाहिए सी₃ = 2, लेकिन आइए देखें। आइए हम हर को अनदेखा करें p(x) एक सेकेंड के लिए। निम्नलिखित लूप का उपयोग करके नामांकनकर्ताओं की गणना की गई j = 1, 2, 3.

x_new = np.array([-2, 5]) for j in range(3): print( f"Probability for class {j}: {(1/np.sqrt(2*np.pi*stds[j]**2)*np.exp(-0.5*((x_new-means[j])/stds[j])**2)).prod()*p[j]:.12f}" )

हमें मिलता है

Probability for class 0: 0.000000000263
Probability for class 1: 0.000000044359
Probability for class 2: 0.000325643718

बेशक, ये संभावनाओं (हमें उन्हें इस तरह से नहीं बुलाना चाहिए) क्योंकि हमने हर को नजरअंदाज कर दिया है इसलिए इसे एक में न जोड़ें। हालाँकि, यह कोई समस्या नहीं है क्योंकि हम इन असामान्य संभावनाओं को ले सकते हैं और उन्हें उनके योग से विभाजित कर सकते हैं, फिर उनका योग एक हो जाएगा। तो, इन तीन मानों को लगभग 0.00032569 के योग से विभाजित करने पर, हमें प्राप्त होता है

गॉसियन नैवे बेयस, समझाया गया
लेखक द्वारा छवि।

एक स्पष्ट विजेता, जैसा कि हमें उम्मीद थी। अब, आइए इसे लागू करें!

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

बस ध्यान दें कि मैंने एक कार्यान्वित किया है predict_proba संभावनाओं की गणना करने के लिए सबसे पहले विधि। प्रक्रिया predict बस इस विधि को कॉल करें और argmax फ़ंक्शन का उपयोग करके उच्चतम संभावना के साथ सूचकांक (= वर्ग) लौटाएं (वहाँ यह फिर से है!)। कक्षा 0 से कक्षा तक की प्रतीक्षा कर रही है k-1, जहां k कक्षाओं की संख्या है.

import numpy as np
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.utils.validation import check_X_y, check_array, check_is_fitted class GaussianNaiveBayesClassifier(BaseEstimator, ClassifierMixin): def fit(self, X, y): X, y = check_X_y(X, y) self.priors_ = np.bincount(y) / len(y) self.n_classes_ = np.max(y) + 1 self.means_ = np.array( [X[np.where(y == i)].mean(axis=0) for i in range(self.n_classes_)] ) self.stds_ = np.array( [X[np.where(y == i)].std(axis=0) for i in range(self.n_classes_)] ) return self def predict_proba(self, X): check_is_fitted(self) X = check_array(X) res = [] for i in range(len(X)): probas = [] for j in range(self.n_classes_): probas.append( ( 1 / np.sqrt(2 * np.pi * self.stds_[j] ** 2) * np.exp(-0.5 * ((X[i] - self.means_[j]) / self.stds_[j]) ** 2) ).prod() * self.priors_[j] ) probas = np.array(probas) res.append(probas / probas.sum()) return np.array(res) def predict(self, X): check_is_fitted(self) X = check_array(X) res = self.predict_proba(X) return res.argmax(axis=1)

कार्यान्वयन का परीक्षण

हालाँकि कोड काफी छोटा है, फिर भी यह पूरी तरह से आश्वस्त होने के लिए बहुत लंबा है कि हमने कोई गलती नहीं की है। तो, आइए देखें कि इसके मुकाबले इसका प्रदर्शन कैसा है स्किकिट-लर्न गॉसियनएनबी क्लासिफायरियर.

my_gauss = GaussianNaiveBayesClassifier()
my_gauss.fit(X, y)
my_gauss.predict_proba([[-2, 5], [0,0], [6, -0.3]])

outputs के

array([[8.06313823e-07, 1.36201957e-04, 9.99862992e-01], [1.00000000e+00, 4.23258691e-14, 1.92051255e-11], [4.30879705e-01, 5.69120295e-01, 9.66618838e-27]])

का उपयोग करते हुए भविष्यवाणियाँ predict विधि हैं

# my_gauss.predict([[-2, 5], [0,0], [6, -0.3]])
array([2, 0, 1])

अब, आइए स्किकिट-लर्न का उपयोग करें। कुछ कोड डाल रहा हूँ

from sklearn.naive_bayes import GaussianNB gnb = GaussianNB()
gnb.fit(X, y)
gnb.predict_proba([[-2, 5], [0,0], [6, -0.3]])

पैदावार

array([[8.06314158e-07, 1.36201959e-04, 9.99862992e-01], [1.00000000e+00, 4.23259111e-14, 1.92051343e-11], [4.30879698e-01, 5.69120302e-01, 9.66619630e-27]])

संख्याएँ हमारे क्लासिफायरियर के समान ही दिखती हैं, लेकिन अंतिम कुछ प्रदर्शित अंकों में वे थोड़ी हटकर हैं। क्या हमने कुछ गलत किया? नहीं. स्किकिट-लर्न संस्करण केवल एक अन्य हाइपरपैरामीटर का उपयोग करता है var_smoothing=1e-09 . यदि हम इसे इस पर सेट करते हैं शून्य, हमें बिल्कुल हमारे नंबर मिलते हैं। उत्तम!

हमारे क्लासिफायरियर के निर्णय क्षेत्रों पर एक नज़र डालें। मैंने उन तीन बिंदुओं को भी चिह्नित किया जिनका उपयोग हमने परीक्षण के लिए किया था। सीमा के करीब एक बिंदु पर लाल वर्ग से संबंधित होने की केवल 56.9% संभावना है, जैसा कि आप देख सकते हैं predict_proba आउटपुट. अन्य दो बिंदुओं को बहुत अधिक आत्मविश्वास के साथ वर्गीकृत किया गया है।

गॉसियन नैवे बेयस, समझाया गया

3 नए बिंदुओं के साथ निर्णय क्षेत्र। लेखक द्वारा छवि.

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

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

अंत में, हमने स्किकिट-लर्न्स के स्वयं के गाऊसी बेयस क्लासिफायर को आयात करके एक छोटी सी विवेक जांच की और परीक्षण किया कि क्या हमारे और स्किकिट-लर्न के क्लासिफायरियर दोनों एक ही परिणाम देते हैं। यह परीक्षण सफल रहा.

डॉ रॉबर्ट कुब्लेरी पब्लिसिस मीडिया में डेटा साइंटिस्ट हैं और डेटा साइंस की ओर लेखक हैं।

मूल। अनुमति के साथ पुनर्प्रकाशित।