朴素贝叶斯算法--python实现

朴素贝叶斯算法要理解一下基础：    【朴素：特征条件独立   贝叶斯：基于贝叶斯定理】

1朴素贝叶斯的概念【联合概率分布、先验概率、条件概率**、全概率公式】【条件独立性假设、】   极大似然估计

2优缺点    

【优点： 分类效率稳定；对缺失数据不敏感，算法比较简单，常用于文本分类；在属性相关性较小时，该算法性能最好    缺点：假设属性之间相互独立；先验概率多取决于假设；对输入数据的表达形式很敏感】

3先验概率、后验概率

先验概率的计算比较简单，没有使用贝叶斯公式；

而后验概率的计算，要使用贝叶斯公式，而且在利用样本资料计算逻辑概率时，还要使用理论概率分布，需要更多的数理统计知识。

4朴素贝叶斯的参数估计：

①极大似然估计（可能出现概率为0的情况）②贝叶斯估计（加入常数，拉普拉斯平滑）

 

参考：

教你明白啥是朴素贝叶斯分类器    有助于理解朴素贝叶斯算法

《统计学习方法》-朴素贝叶斯法笔记和python源码     理论总结得很全*   

 

前提python2.7     数据来源：  http://pan.baidu.com/s/1pLoKUMJ

 # 极大似然估计  朴素贝叶斯算法

 #coding:utf-8
 # 极大似然估计  朴素贝叶斯算法
 import pandas as pd
 import numpy as np

 class NaiveBayes(object):
     def getTrainSet(self):
         dataSet = pd.read_csv('C://pythonwork//practice_data//naivebayes_data.csv')
         dataSetNP = np.array(dataSet)  #将数据由dataframe类型转换为数组类型
         trainData = dataSetNP[:,0:dataSetNP.shape[1]-1]   #训练数据x1,x2
         labels = dataSetNP[:,dataSetNP.shape[1]-1]        #训练数据所对应的所属类型Y
         return trainData, labels

     def classify(self, trainData, labels, features):
         #求labels中每个label的先验概率
         labels = list(labels)    #转换为list类型
         P_y = {}       #存入label的概率
         for label in labels:
             P_y[label] = labels.count(label)/float(len(labels))   # p = count(y) / count(Y)

         #求label与feature同时发生的概率
         P_xy = {}
         for y in P_y.keys():
             y_index = [i for i, label in enumerate(labels) if label == y]  # labels中出现y值的所有数值的下标索引
             for j in range(len(features)):      # features[0] 在trainData[:,0]中出现的值的所有下标索引
                 x_index = [i for i, feature in enumerate(trainData[:,j]) if feature == features[j]]
                 xy_count = len(set(x_index) & set(y_index))   # 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])    #P[X1/Y] = P[X1Y]/P[Y]

         #求[2,'S']所属类别
         F = {}   #[2,'S']属于各个类别的概率
         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]，分母相等，比较分子即可，所以有F=P[X/y]*P[y]=P[x1/Y]*P[x2/Y]*P[y]

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

 if __name__ == '__main__':
     nb = NaiveBayes()
     # 训练数据
     trainData, labels = nb.getTrainSet()
     # x1,x2
     features = [2,'S']
     # 该特征应属于哪一类
     result = nb.classify(trainData, labels, features)
     print features,'属于',result

#朴素贝叶斯算法   贝叶斯估计， λ=1  K=2， S=3； λ=1 拉普拉斯平滑

 #coding:utf-8
 #朴素贝叶斯算法   贝叶斯估计， λ=1  K=2， S=3； λ=1 拉普拉斯平滑
 import pandas as pd
 import numpy as np

 class NavieBayesB(object):
     def __init__(self):
         self.A = 1    # 即λ=1
         self.K = 2
         self.S = 3

     def getTrainSet(self):
         trainSet = pd.read_csv('C://pythonwork//practice_data//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

 if __name__ == '__main__':
     nb = NavieBayesB()
     # 训练数据
     trainData, labels = nb.getTrainSet()
     # x1,x2
     features = [2,'S']
     # 该特征应属于哪一类
     result = nb.classify(trainData, labels, features)
     print features,'属于',result