统计学习方法——朴素贝叶斯（二）

朴素贝叶斯

前面介绍了朴素贝叶斯的算法原理，这里我们通过一个例子介绍一下朴素贝叶斯的使用。

数据来源

这里我们以教材中的例子为例，实现两种朴素贝叶斯算法，待测数据为$\left(2,S\right)$。

说明：这些程序的目的是为了更深地了解算法，所以不会使用太复杂的数据，也不会使用Python的sklearn库。

极大似然朴素贝叶斯

• 导入相关库

#####极大似然估计
import pandas as pd    #用来读取数据
import numpy as np     #用来处理数据

• 定义朴素贝叶斯的实现接口

#定义实现朴素贝叶斯的实现
class psbys(object):
    #读取训练集
    def getTrainSet(self):
        dataset=pd.read_csv('naivebayes_data.csv')
        datasetNP=np.array(dataset)      #将数据转化为数组
        trainData=datasetNP[:,0:datasetNP.shape[1]-1]  #单独存储训练数据的x1，x2
        labels=datasetNP[:,datasetNP.shape[1]-1]    #单独存储标签
        return trainData,labels
    
    def classify(self,trainData,labels,features):
        #计算每个类的先验概率
        labels=list(labels)   #先转换为list类型
        P_y={}     #存入label的概率
        for label in labels:
            P_y[label]=labels.count(label)/float(len(labels))    #计算每个类对应的概率
        
        #计算标签和属性同时发生的概率
        P_xy={}
        for y in P_y.keys():
            y_index=[i for i,label in enumerate(labels) if label==y]   #找到每个标签对应的样本
            for j in range(len(features)):
                x_index=[i for i,feature in enumerate(trainData[:,j]) if feature==features[j]]   # 按照属性取值进行划分
                xy_count=len(set(x_index)&set(y_index))   #显示连个列表相同的元素
                pkey=str(features[j])+'*'+str(y)
                P_xy[pkey]=xy_count / float(len(labels))  #计算联合分布
        
        #求条件概率
        P={}
        for y in P_y.keys():
            for x in features:
                pkey=str(x)+'|'+str(y)
                P[pkey]=P_xy[str(x)+'*'+str(y)]/float(P_y[y])   #针对每个标签计算条件概率
                
        #求待测样本的分类
        F={}
        for y in P_y:
            F[y]=P_y[y]
            for x in features:
                F[y]=F[y]*P[str(x)+'|'+str(y)]     #P[y|X]=P[X|y]*P[y]/P[X]
        features_label=max(F,key=F.get)  #取概率最大值
        return features_label

• 进行验证

if __name__=='__main__':
    nb=psbys()
    #训练数据
    trainData,labels=nb.getTrainSet()
    #x1,x2
    features=[2,'S']
    # 返回结果
    result=nb.classify(trainData,labels,features)
    print (features,'属于',result)

结果如下所示：

[2, ‘S’] 属于 -1

贝叶斯估计

• 导入的库与上面类似。
• 实现贝叶斯估计的接口

# 贝叶斯估计接口（拉普拉斯平滑）
# λ=1  K=2， S=3； λ=1 拉普拉斯平滑
class NavieBayesB(object):
    def __init__(self):
        self.A = 1    # 即λ=1
        self.K = 2
        self.S = 3

    def getTrainSet(self):
        trainSet = pd.read_csv('naivebayes_data.csv')
        trainSetNP = np.array(trainSet)     #由dataframe类型转换为数组类型
        trainData = trainSetNP[:,0:trainSetNP.shape[1]-1]     #训练数据x1,x2
        labels = trainSetNP[:,trainSetNP.shape[1]-1]          #训练数据所对应的所属类型Y
        return trainData, labels

    def classify(self, trainData, labels, features):
        labels = list(labels)    #转换为list类型
        #求先验概率
        P_y = {}
        for label in labels:
            P_y[label] = (labels.count(label) + self.A) / float(len(labels) + self.K*self.A)

        #求条件概率
        P = {}
        for y in P_y.keys():
            y_index = [i for i, label in enumerate(labels) if label == y]   # y在labels中的所有下标
            y_count = labels.count(y)     # y在labels中出现的次数
            for j in range(len(features)):
                pkey = str(features[j]) + '|' + str(y)
                x_index = [i for i, x in enumerate(trainData[:,j]) if x == features[j]]   # x在trainData[:,j]中的所有下标
                xy_count = len(set(x_index) & set(y_index))   #x y同时出现的次数
                P[pkey] = (xy_count + self.A) / float(y_count + self.S*self.A)   #条件概率

        #features所属类
        F = {}
        for y in P_y.keys():
            F[y] = P_y[y]
            for x in features:
                F[y] = F[y] * P[str(x)+'|'+str(y)]

        features_y = max(F, key=F.get)   #概率最大值对应的类别
        return features_y

• 验证也与上面类似。

完整代码

https://github.com/canshang/-/blob/master/朴素贝叶斯.ipynb

参考文献

https://www.cnblogs.com/yiyezhouming/p/7364688.html