朴素贝叶斯（Naive Bayes）详细计算公式及代码实现_朴素贝叶斯代码实现

一. 朴素贝叶斯知识点

1.1 概念

  贝叶斯方法是以贝叶斯原理为基础，使用概率统计的知识对样本数据集进行分类。
  贝叶斯方法的特点是结合先验概率和后验概率，既避免了只使用先验概率的主观偏见，也避免了单独使用样本信息的过拟合现象。
  朴素贝叶斯方法是在贝叶斯算法的基础上进行了相应的简化，即假定给定目标值时属性之间相互条件独立。

1.2 优缺点

  优点：算法的逻辑性十分简单，并且算法较为稳定
     算法的健壮性比较好
  缺点：属性独立性的条件同时也是朴素贝叶斯分类器的不足之处。
     因为数据集的属性之间往往都存在着相互关联，会导致分类的效果大大降低。

1.3 应用

  文本分类，垃圾邮件分类，信用评估
  图像识别等方向

二.计算方法

2.1 计算公式

  

2.2 例题

题目：

求：Outlook=Overcast,Temparature=Hot,Humidity=80,Wind=True时是否打球？

三.代码实现

数据集下载：data.txt

import operator
import math
import numpy as np

def readdata(filename):
    label = []  # 属性标签
    data = []  # 数据集
    i = 0
    with open(filename, 'r') as f:
        while True:
            line = f.readline()
            line = line.strip()
            listFromLine = line.split()
            if not line:
                break
            if i == 0:
                label = [listFromLine[1], listFromLine[2], listFromLine[3], listFromLine[4], listFromLine[5]]
            else:
                data.append(
                    [listFromLine[1], listFromLine[2], float(listFromLine[3]), listFromLine[4], listFromLine[5]])
            i += 1
    data1 = []
    data2 = []
    x = data[0][-1]
    for j in data:
        if j[-1] == x:
            data1.append(j)
        else:
            data2.append(j)

    return data, label


def beyes(Data, Label, Test):
    # 统计每种属性的取值可能，拉普拉斯修正用
    number = np.zeros(len(Label))
    for i in range(len(Label)):
        poss = []
        for j in range(len(Data)):
            if j == 0:
                poss.append(Data[j][i])
                number[i] += 1
            elif Data[j][i] not in poss:
                poss.append(Data[j][i])
                number[i] += 1
    # 结果的各个种类数
    kindnum = np.zeros(int(number[-1]))
    kind = []
    kind.append(Data[0][-1])
    for j in Data:
        if j[-1] == kind[0]:
            kindnum[0] += 1
        else:
            kindnum[1] += 1
            if j[-1] not in kind:
                kind.append(j[-1])
    # 计算概率
    probability = np.ones(int(number[-1]))
    for i in range(len(Label) - 1):
        if i == 2:
            aall1 = 0
            ssum1 = 0
            aall2 = 0
            ssum2 = 0
            for j in Data:
                if j[-1] == kind[0]:
                    aall1 += j[i]
                else:
                    aall2 += j[i]
            aver1 = aall1 / kindnum[0]  # 平均数
            aver2 = aall2 / kindnum[1]
            for j in Data:
                if j[-1] == kind[0]:
                    ssum1 += (j[i] - aver1) ** 2
                else:
                    ssum2 += (j[i] - aver2) ** 2
            s1 = ssum1 / kindnum[0]  # 方差
            s2 = ssum2 / kindnum[1]
            pro1 = np.exp(-(Test[i] - aver1) ** 2 / (2 * s1)) / (math.sqrt(2 * math.pi * s1))
            pro2 = np.exp(-(Test[i] - aver2) ** 2 / (2 * s2)) / (math.sqrt(2 * math.pi * s2))
            probability[0] = probability[0] * pro1
            probability[1] = probability[1] * pro2
        else:
            poss = []
            n1 = 0
            n2 = 0
            for j in Data:
                if j[i] == Test[i]:
                    if j[-1] == kind[0]:
                        n1 += 1
                    else:
                        n2 += 1
            probability[0] = probability[0] * (n1 + 1) / (kindnum[0] + number[i])
            probability[1] = probability[1] * (n2 + 1) / (kindnum[1] + number[i])

    print('--------------------------------------')
    print('Test=', Test, '是否打球的类别是', kind[0], '的概率是', probability[0])
    print('Test=', Test, '是否打球的类别是', kind[1], '的概率是', probability[1])
    if probability[0] > probability[1]:
        print('所以估计Test=', Test, '是否打球的结果是', kind[0])
    else:
        print('所以估计Test=', Test, '是否打球的结果是', kind[1])
    print('--------------------------------------')

if __name__ == '__main__':
    # 读取数据集和属性标签
    Data, Label = readdata('data.txt')
    Test = ['Overcast', 'Hot', 80.0, 'TRUE']
    beyes(Data, Label, Test)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

相关运行结果：

四.总结

  文章主要介绍了朴素贝叶斯进行分类的相关计算及代码实现。从上面可以看到，朴素贝叶斯在计算时会将每种可能的情况都会考虑到，然后根据计算出来的概率大小决定最后的结果。可以将该方法应用于表面肌电信号相关动作是别上。