伯努利朴素贝叶斯

TIME : 2018-05-17

sklearn.naive_bayes.BernoulliNB

与多项式模型一样，伯努利模型适用于离散特征的情况，所不同的是，伯努利模型中每个特征的取值只能是1和0(以文本分类为例，某个单词在文档中出现过，则其特征值为1，否则为0).
伯努利模型和多项式模型是一致的，BernoulliNB需要比MultinomialNB多定义一个二值化的方法，该方法会接受一个阈值并将输入的特征二值化(1，0).当然也可以直接采用MultinomialNB，但需要预先将输入的特征二值化.

参数:

BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True,class_prior=None)

alpha
binarize
fit_prior
class_prior

[其他参数说明见<<多项式朴素贝叶斯>>文章]

属性:

class_log_prior_

参数说明:

参数 binarize：将数据特征二值化的阈值
<=binarize的值处理为0,>binarize的值处理为1

import numpy as np  
from sklearn.naive_bayes import BernoulliNB  
x = np.array([[1,2,3,4],[1,3,4,4],[2,4,5,5]])
# 等价于 <=>  X = np.array([[0,0,0,1],[0,0,1,1],[0,1,1,1]]) 
y = np.array([1,1,2])  
clf = BernoulliNB(alpha=2.0,binarize = 3.0,fit_prior=True)  
clf.fit(x,y)

属性说明:

属性 class_log_prior_
类先验概率对数值，类先验概率=各类的个数/类的总个数

clf.class_log_prior_  
#>>output:
[-0.40546511, -1.09861229]  

等价于 <=>
print(np.log(1/3))
>>output:-1.0986122886681098

print(np.log(2/3))  
>>output:-0.40546510810816444

属性 feature_log_prob_
指定类的各特征概率(条件概率)对数值，返回形状为(n_classes, n_features)数组

计算过程：
假设X对应的四个特征为A1、A2、A3、A4，类别为c1,c2,类别为c1时，特征A1的概率为：P(A1|c=c1) = P(A1=0|c=c1)* A1+P(A1=1|c=c1)* A1
由于A1=0, 所以:
P(A1|c=c1)=(类c1中含有A1特征的样本数 +α )/(当前类别的样本数 + α*类别数)

import numpy as np  
from sklearn.naive_bayes import BernoulliNB  
X = np.array([[1,2,3,4],[1,3,4,4],[2,4,5,5]])  
y = np.array([1,1,2])  
clf = BernoulliNB(alpha=2.0,binarize = 3.0,fit_prior=True)  
clf.fit(X,y)
print(clf.feature_log_prob_) 
>>output:
[[-1.09861229 -1.09861229 -0.69314718 -0.40546511]  
 [-0.91629073 -0.51082562 -0.51082562 -0.51082562]]  

print(
[np.log((2+2)/(2+2*2))*0+np.log((0 + 2 )/(2+    2 * 2))*1,
 np.log((2+2)/(2+2*2))*0+np.log((0 + 2 )/(2+    2 * 2))*1,
 np.log((1+2)/(2+2*2))*0+np.log((1 + 2 )/(2+    2 * 2))*1,
 np.log((0+2)/(2+2*2))*0+np.log((2 + 2 )/(2+    2 * 2))*1])
         ↑A                      ↑B  ↑α   ↑样本  ↑α  ↑类别数     
#说明:
二值化后如下
[[0,0,0,1],   类别1
 [0,0,1,1],   类别1
 [0,1,1,1]]   类别2
A列为2,2,1,0  类别1中0个数        
B列为0,0,1,2  类别2中1个数
样本:为当前类别样本数
>>output: 
[-1.0986122886681098, -1.0986122886681098, 
-0.69314718055994529, -0.40546510810816444]  

print(
[np.log((0+2)/(1+2*2))*1,
 np.log((1+2)/(1+2*2))*1,
 np.log((1+2)/(1+2*2))*1,
 np.log((1+2)/(1+2*2))*1])
>>output:
>[-0.916290731874155, -0.5108256237659907, 
  -0.5108256237659907, -0.5108256237659907]

属性 class_count_
按类别顺序输出其对应的个数

print(clf.class_count_)  

#>>output:[ 2.,  1.]

属性 eature_count_
各类别各特征值之和，按类的顺序输出，返回形状为(n_classes, n_features) 的数组

clf.feature_count_  

#>>output:
[[ 0.,  0.,  1.,  2.],  
[ 0.,  1.,  1.,  1.]]

方法说明:

[见<<多项式朴素贝叶斯>>文章]

伯努利与多项式区别:

多项式模型中：

设某文档d=(t1,t2,…,tk)，tk是该文档中出现过的单词，允许重复，则

(1)先验概率P(c)= 类c下样本总数/整个训练样本的样本总数

(2)类条件概率P(tk|c) =(类c下单词tk数目+α)/(指定类下所有特征出现次数之和+类别数*α)

伯努利模型中：