朴素贝叶斯分类算法详解与Python实现

一、贝叶斯决策论

  对于一个多分类任务，假设有标签$y=\{y_1,y_2,...,y_n\}$，记${\lambda }_{ij}$为将真实标签为$y_j$的样本误分类为$y_i$的代价，则可以得到将样本$x$分类为$y_i$的期望代价：
$$loss(y_i|x)=\sum _{j=1}^n{\lambda }_{ij}P(y_j|x)$$
在贝叶斯分类模型中，想要尽可能准确地预测出类标，则只需选择一个期望代价最小的样本。
  设损失函数：
$${\lambda }_{ij}=\{\begin{array}{l}0,i=j\\ 1,i\ne j\end{array}$$
则有：
$$loss(y_i|x)=1-P(y_i|x)$$
那么，最小化$loss$函数就变成了最大化$P(y_i|x)$，贝叶斯分类模型的分类依据变为：
$$h(x)=\underset{y_i\in y}{\mathrm{argmax}}P(y_i|x)=\underset{y_i\in y}{\mathrm{argmax}}\frac{P(y_i)P(x|y_i)}{P(x)}=\underset{y_i\in y}{\mathrm{argmax}}P(y_i)P(x|y_i)$$

二、朴素贝叶斯

  根据上面给出的分类依据，可以知道建立模型的关键在于估计$P(x|y_i)$。这是一个在样本所有属性上的联合分布，难以估计，所以朴素贝叶斯模型提出了一个前提假设：所有的样本属性相互独立。
  在上述前提假设下，分类依据可以改写为：
$$h(x)=\underset{y_i\in y}{\mathrm{argmax}}P(y_i)P(x|y_i)=\underset{y_i\in y}{\mathrm{argmax}}P(y_i)\prod _{i=0}^{m}P(x_i|y_i)$$
此处的$x_i$表示样本的每个属性值，$m$为属性数量。
  设$D$是所有的样本，$D_{y_i}$是类标为$y_i$的样本，则可估计：
$$P(y_i)=\frac{|D_{y_i}|}{|D|}$$
  如果$x_i$为离散属性，设$D_{y_i,x_i}$是类标为$y_i$且第$i$个属性值为$x_i$的样本数量，则可估计：
$$P(x_i|y_i)=\frac{|D_{y_i,x_i}|}{|D|}$$
  如果$x_i$为连续属性，设概率函数$p(x_i|y_i)=N(\mu ,{\sigma }^2)$，其中$\mu$和$\sigma$为第$i$个属性取值的均值和标准差，则可估计：
$$P(x_i|y_i)=\frac{1}{\sqrt{2\pi }\sigma }\exp (-\frac{(x-\mu {)}^2}{2{\sigma }^2})$$

三、Python实现

import numpy as np

class NaiveBayesClassifier(object):
    def __init__(self):
        self.fit_X = None
        self.fit_y = None

    def _gauss_func(self, feature, xi, yi):
        sample = self.fit_X[self.fit_y == yi, feature]
        sigma = np.std(sample)
        u = np.mean(sample)
        return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(-(xi - u)**2 / (2 * sigma**2))

    def fit(self, X, y):
        self.fit_X = X
        self.fit_y = y
        return self

    def _predict(self, x):
        N = len(np.unique(self.fit_y))
        score = []
        for i in range(N):
            P_c = (len(self.fit_y[self.fit_y == i]) + 1) / (len(self.fit_y) + N)
            log_P_xc = []
            features = list(range(self.fit_X.shape[1]))
            for f in features:
                log_P_xc.append(np.log(self._gauss_func(f, x[f], i)))
            score.append(np.log(P_c) + sum(log_P_xc))
        return np.argmax(score)

    def predict(self, X):
        y = []
        for x in X:
            y.append(self._predict(x))
        return np.array(y)