本篇对应全书第四章，讲的是朴素贝叶斯法。朴素贝叶斯（Naive Bayes）是基于贝叶斯定理与特征条件独立假设的分类方法。对于给定的训练数据集，首先基于特征条件独立假设学习输入/输出的联合概率分布；然后基于此模型，对给定的输入 $x$ ，利用贝叶斯定理求出后验概率最大的输出 $y$ 。

1、理论讲解

1.1、模型原理

设输入空间 $\mathbf X \subseteq \mathbf R^n$ 为 $n$ 维向量的集合，输出空间为类标记集合 $\mathbf Y=\{c_1,c_2,\dots,c_K\}$ 。输入为特征向量 $x \in \mathbf X$ ，输出为类标记 $y \in \mathbf Y$ 。 $X$ 是定义在输入空间 $\mathbf X$ 上的随机向量， $Y$ 是定义在输出空间 $\mathbf Y$ 上的随机变量。 $P(X,Y)$ 是 $X$ 和 $Y$ 的联合概率分布。训练集 $T=\{(x_1,y_1),(x_2,y_2),\dots,(x_N,y_N)\}$ 由 $P(X,Y)$ 独立同分布产生。
朴素贝叶斯通过训练集学习联合概率分布 $P(X,Y)$ 。具体地，学习以下先验概率分布及条件概率分布。先验概率分布：
$P(Y=c_k),k=1,2,\dots,K$
条件概率分布：
$P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},\dots,X^{(n)}=x^{(n)}|Y=c_k),k=1,2,\dots,K$
于是学习到联合概率分布 $P(X,Y)$ 。
朴素贝叶斯对条件概率分布作了条件独立性的假设，即用于分类的特征在类确定的条件下都是条件独立的。由于这是一个较强的假设，朴素贝叶斯法也由此得名。具体地，条件独立性假设是：
$P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},\dots,X^{(n)}=x^{(n)}|Y=c_k)=\prod^n_{j=1}P(X^{(j)}=x^{(j)}|Y=c_k)$
这一假设使模型变得简单，但有时会牺牲一定的分类准确率。
朴素贝叶斯分类时，对给定的输入 $x$ ，通过学习到的模型计算后验概率分布 $P(Y=c_k|X=x)$ ，将后验概率最大的类输出：
$y=f(x)=arg \underset {c_k}{max} \frac{P(Y=c_k)\prod_{j}P(X^{(j)}=x^{(j)}|Y=c_k)}{\sum_k \\ P(Y=c_k)\prod_{j}P(X^{(j)}=x^{(j)}|Y=c_k)} \\ =arg \underset {c_k}{max} P(Y=c_k) \prod_j P(X^{(j)}=x^{(j)}|Y=c_k)\\ k=1,2,\dots,K$
此处，后验概率最大化的本质是0-1损失函数下的期望风险最小化。

1.2、参数估计

在朴素贝叶斯中，学习意味着估计 $P(Y=c_k)$ 和 $P(X^{(j)}=x^{(j)}|Y=c_k)$ ，既可以采用极大似然估计也可以采用贝叶斯估计。

1.2.1、极大似然估计

先验概率 $P(Y=c_k)$ 的极大似然估计：
$P(Y=c_k)=\frac {\sum^{N}_{i=1}I(y_i=c_k)}{N},k=1,2,\dots,K$
设第 $j$ 个特征 $x^{j}$ 可能取值的集合为 $\{a_{j1},a_{j2},\dots,a_{jS_j}\}$ ，条件概率 $P(X^{(j)}=a_{jl}|Y=c_k)$ 的极大似然估计：
$P(X^{(j)}=a_{jl}|Y=c_k)=\frac {\sum^N_{i=1}I(x^{(j)}_i=a_{jl},y_i=c_k)}{\sum^N_{i=1}I(y_i=c_k)} \\ j=1,2,\dots,n;l=1,2,\dots,S_j;k=1,2,\dots,K$
其中， $x^{(j)}_i$ 是第 $i$ 个样本的第 $j$ 个特征； $a_{jl}$ 是第 $j$ 个特征可能取的第 $l$ 个值。

1.2.2、贝叶斯估计

用极大似然估计可能会出现所要估计的概率值为0的情况。这时会影响到后验概率的计算结果，使分类产生偏差。解决这一问题的方法是采用贝叶斯估计。
先验概率 $P(Y=c_k)$ 的贝叶斯估计：
$P(Y=c_k)=\frac {\sum^{N}_{i=1}I(y_i=c_k)+\lambda}{N+k\lambda},k=1,2,\dots,K$
条件概率 $P(X^{(j)}=a_{jl}|Y=c_k)$ 的贝叶斯估计：
$P(X^{(j)}=a_{jl}|Y=c_k)=\frac {\sum^N_{i=1}I(x^{(j)}_i=a_{jl},y_i=c_k)+\lambda}{\sum^N_{i=1}I(y_i=c_k)+S_j \lambda} \\ j=1,2,\dots,n;l=1,2,\dots,S_j;k=1,2,\dots,K$
其中， $\lambda \ge 0$ ，当 $\lambda=0$ 时，就是极大似然估计。常取 $\lambda=1$ ，这时称为拉普拉斯平滑。

1.3、小结

朴素贝叶斯是典型的生成学习方法；
由于条件独立性假设，朴素贝叶斯高效且易于实现，但也因此损失了分类性能；
如果输入特征彼此存在概率依存关系，即没有条件独立性假设，模型就变成了贝叶斯网络；
实际应用中，对应于条件概率分布 $P(X^{(j)}=x^{(j)}|Y=c_k)$ 所做的不同假设，朴素贝叶斯有三种模型：高斯模型、多项式模型和伯努利模型。高斯模型常应用于特征连续的情况中，多项式模型和伯努利模型常应用于文本分类中。读者可阅读参考文献详细了解。

2、代码实现

2.1、手工实现

from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter


class GaussianNB:
        def __init__(self, X_train, y_train):
                self.X_train = X_train
                self.y_train = y_train
                self.get_params()

        def get_params(self):
                samples_num = len(self.y_train)
                label_count = Counter(self.y_train).items()
                self.class_ = np.array([_[0] for _ in label_count])
                self.class_count_ = np.array([_[1] for _ in label_count])
                self.class_prior_ = self.class_count_/samples_num

                sample_split = [self.X_train[self.y_train == _] for _ in self.class_]
                self.theta_ = np.array([np.transpose(_).mean(axis = 1) for _ in sample_split])
                self.sigma_ = np.array([np.transpose(_).var(axis = 1) for _ in sample_split])

        def gaussian_func(self, X):
                prob_list = []
                for theta, sigma, prior in zip(self.theta_, self.sigma_, self.class_prior_):
                        prob_ = np.prod(1/np.sqrt(2 * np.pi * sigma) * np.exp(-np.square(X - theta)/(2 * sigma))) * prior
                        prob_list.append(prob_)
                return np.array(prob_list)

        def predict(self, X_test):
                label_list = []
                for X in X_test:
                        prob_list = self.gaussian_func(X)
                        label = self.class_[np.argmax(prob_list)]
                        label_list.append(label)
                return np.array(label_list)

        def score(self, X_test, y_test):
                total_num = len(X_test)
                pre = (self.predict(X_test) == y_test).sum()
                score = pre/total_num
                return score


if __name__ == "__main__":
        iris = load_iris()
        X = iris.data[:100, :2]
        y = iris.target[:100]
        y[y == 0] = -1
        xlabel = iris.feature_names[0]
        ylabel = iris.feature_names[1]

        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

        X_0 = X_train[y_train == -1]
        X_1 = X_train[y_train == 1]

        plt.figure("nb-mine")
        plt.scatter(X_0[:, 0], X_0[:, 1], label = '-1')
        plt.scatter(X_1[:, 0], X_1[:, 1], label = '1')
        plt.xlabel(xlabel)
        plt.ylabel(ylabel)
        plt.legend()

        clf = GaussianNB(X_train, y_train)
        score = clf.score(X_test, y_test)
        print "score : %s" % score

        y_pre = clf.predict(X_test)
        X_test_pre_0 = X_test[y_pre == -1]
        X_test_pre_1 = X_test[y_pre == 1]
        plt.scatter(X_test_pre_0[:, 0], X_test_pre_0[:, 1], color = 'r', label = 'pre -1')
        plt.scatter(X_test_pre_1[:, 0], X_test_pre_1[:, 1], color = 'k', label = 'pre 1')
        plt.legend()
        plt.show()

2.2、sklearn实现

from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split


if __name__ == "__main__":
        iris = load_iris()
        X = iris.data[:100, :2]
        y = iris.target[:100]
        y[y == 0] = -1
        xlabel = iris.feature_names[0]
        ylabel = iris.feature_names[1]

        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

        X_0 = X_train[y_train == -1]
        X_1 = X_train[y_train == 1]

        plt.figure("GaussianNB-sklearn")
        plt.scatter(X_0[:, 0], X_0[:, 1], label = '-1')
        plt.scatter(X_1[:, 0], X_1[:, 1], label = '1')
        plt.xlabel(xlabel)
        plt.ylabel(ylabel)
        plt.legend()

        clf = GaussianNB()
        clf.fit(X_train, y_train)
        score = clf.score(X_test, y_test)
        print "score : %s" % score

        y_pre = clf.predict(X_test)
        X_test_pre_0 = X_test[y_pre == -1]
        X_test_pre_1 = X_test[y_pre == 1]
        plt.scatter(X_test_pre_0[:, 0], X_test_pre_0[:, 1], color = 'r', label = 'pre -1')
        plt.scatter(X_test_pre_1[:, 0], X_test_pre_1[:, 1], color = 'k', label = 'pre 1')
        plt.legend()
        plt.show()

代码已上传至github：https://github.com/xiongzwfire/statistical-learning-method

#参考文献

[1] http://scikit-learn.org/stable/modules/naive_bayes.html
[2] https://www.letiantian.me/2014-10-12-three-models-of-naive-nayes/
以上为本文全部参考文献，对原作者表示感谢。

《统计学习方法》系列（4）