1. 朴素贝叶斯算法

首先，构造朴素贝叶斯类，初始化x和y。

class naive_bayes(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

其次，计算先验概率。

    def cal_prior_probability(self):
        self.prior_probability = dict(Counter(self.y))
        for k in self.prior_probability.keys():
            self.prior_probability[k] /= len(self.y)

再次，计算条件概率。

    def cal_conditional_probability(self):
        self.conditional_probability = {}
        for c in self.prior_probability.keys():
            self.conditional_probability[c] = {}
            x = self.x[np.where(self.y == c)]
            for d in range(x.shape[1]):
                self.conditional_probability[c][d] = dict(Counter(x[:, d]))
                for k in self.conditional_probability[c][d].keys():
                    self.conditional_probability[c][d][k] /= len(x)

然后，预测x的类别。

    def predict_c(self, x):
        self.cal_prior_probability()
        self.cal_conditional_probability()
        c0 = 0
        p0 = 0
        for c, v in self.prior_probability.items():
            p = v
            for xc, d in self.conditional_probability[c].items():
                p *= [v for k, v in d.items() if k == str(x[xc])][0]
            if p > p0:
                p0 = p
                c0 = c
        self.predict = c0

最后，用参考文献1的例子做个简单验证。

if __name__ == "__main__":
    x = np.array([[1, 'S'], [1, 'M'], [1, 'M'], [1, 'S'], [1, 'S'], [2, 'S'], [2, 'M'], [2, 'M'], [2, 'L'], [2, 'L'], [3, 'L'], [3, 'M'], [3, 'M'], [3, 'L'], [3, 'L']])
    y = np.array([-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1])
    nb = naive_bayes(x, y)
    nb.predict_c([2, 'S'])
    print(nb.predict)

预测结果为-1类。

2. 贝叶斯算法

只需要对朴素贝叶斯类做些简单的修正，就可以扩展成贝叶斯类。

首先，类名改成bayes。

class bayes(object):

其次，__init__函数中增加λ。

    def __init__(self, x, y, lam=0):
        self.x = x
        self.y = y
        self.lam = lam

再次，修改先验概率计算方法。

    def cal_prior_probability(self):
        self.prior_probability = dict(Counter(self.y))
        for k in self.prior_probability.keys():
            self.prior_probability[k] = (self.prior_probability[k] + self.lam) / (len(self.y) + len(self.prior_probability) * self.lam)

然后，修改条件概率计算方法。

    def cal_conditional_probability(self):
        self.conditional_probability = {}
        for c in self.prior_probability.keys():
            self.conditional_probability[c] = {}
            x = self.x[np.where(self.y == c)]
            for d in range(x.shape[1]):
                self.conditional_probability[c][d] = dict(Counter(x[:, d]))
                for k in self.conditional_probability[c][d].keys():
                    self.conditional_probability[c][d][k] = (self.conditional_probability[c][d][k] + self.lam) / (len(x) + len(self.conditional_probability[c][d]) * self.lam)

最后，测试下贝叶斯算法与朴素贝叶斯算法的区别。

if __name__ == "__main__":
    x = np.array([[1, 'S'], [1, 'M'], [1, 'M'], [1, 'S'], [1, 'S'], [2, 'S'], [2, 'M'], [2, 'M'], [2, 'L'], [2, 'L'], [3, 'L'], [3, 'M'], [3, 'M'], [3, 'L'], [3, 'L']])
    y = np.array([-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1])
    print('朴素贝叶斯算法：')
    nb = bayes(x, y)
    nb.predict_c([2, 'S'])
    print('predict_y=', nb.predict)
    print('贝叶斯算法：')
    nb = bayes(x, y, 1)
    nb.predict_c([2, 'S'])
    print('predict_y=', nb.predict)

得到：
朴素贝叶斯算法：
-1 0.06666666666666667
1 0.02222222222222222
predict_y= -1
贝叶斯算法：
-1 0.06100217864923746
1 0.0326797385620915
predict_y= -1

参考文献

【1】统计学习方法（第2版），李航著，清华大学出版社

相关链接：

1. 学习笔记|k近邻法的实现
2. 学习笔记|k近邻分类算法
3. 学习笔记|感知机的实现
4. 学习笔记|朴素贝叶斯法
5. 学习笔记|决策树模型及其学习