机器学习经典算法---贝叶斯公式（ bayes）

相关概念

先验概率和后验概率

摘自百度百科：

先验概率是指根据以往经验和分析得到的概率,如全概率公式,它往往作为"由因求果"问题中的"因"出现.
后验概率是指依据得到"结果"信息所计算出的最有可能是那种事件发生,如贝叶斯公式中的,是"执果寻因"问题中的"因".

贝叶斯决策理论

贝叶斯决策论是概率框架下实施决策的基本方法，对分类任务来说，在所有相关概率都已知的理想情形下，贝叶斯决策论考虑如何基于这些概率和误判损失来选择最优的类别标记。

假设有N种可能标记， ${\lambda }_{ij}$是将类$c_j$误分类为$c_i$所产生的损失，基于后验概率$ P(c_i | x)$ 可以获得样本x分类为$c_i$所产生的期望损失 ，即在样本x上的条件风险：

$$R(c_i|\mathbf{x})=\sum _{j=1}^N{\lambda }_{ij}P(c_j|\mathbf{x})$$
我们的任务是寻找一个判定准则 $h:X\to Y$以最小化总体风险

$$R(h)={\mathbb{E}}_x[R(h((x))|(x))]$$

显然，对每个样本x，若h能最小化条件风险 $R(h((x))|(x))$,则总体风险R(h)也将被最小化。这就产生了贝叶斯判定准则：为最小化总体风险，只需要在每个样本上选择那个能使条件风险R(c|x)最小的类别标记，即：

$$h^{\ast }(x)=argmi{n}_{c\in y}R(c|\mathbf{x})$$
此时，h 称作贝叶斯最优分类器，与之对应的总体风险R(h )称为贝叶斯风险，1-R(h*)反映了分类器能达到的最好性能，即机器学习所产生的模型精度的上限。

具体来说，若目标是最小化分类错误率（对应0/1损失），则${\lambda }_{ij}$可以用0/1损失改写，得到条件风险和最小化分类错误率的最优分类器分别为：
$$R(c|\mathbf{x})=1-P(c|\mathbf{x})$$

$$h^{\ast }(x)=argma{x}_{c\in \mathcal{Y}}P(c|\mathbf{x})$$

即对每个样本x，选择能使后验概率P(c|x)最大的类别标识。

获得后验概率的两种方法：

1. 判别式模型:给定x，可以通过直接建模P(c|x)来预测c。
2. 生成模型:先对联合分布p(x, c)建模，然后再有此获得P(c|x)。

贝叶斯公式

对生成模型来说，必然考虑：
$$P(c|x)=\frac{P(x,c)}{P(x)}=\frac{P(c)P(x|c)}{P(x)}$$
其中P©是“先验概率”；

P(x|c)是样本x对于类标记c的类条件概率，或称为“似然”；

P(x)是用于归一化的“证据”因子。

上式即为贝叶斯公式。

可以将其看做$$P(类别|特征)=\frac{P(特征,类别)}{P(特征)}=\frac{P(类别)P(特征|类别)}{P(特征)}$$

对类条件概率P(x|c)来说，直接根据样本出现的频率来估计将会遇到严重的困难，所以引入了极大似然估计。极大似然估计可参考极大似然估计最通俗的讲解

朴素贝叶斯分类器

基于贝叶斯公式来估计后验概率P(c|x)主要困难在于类条件概率P(x|c)是所有属性上的联合概率，难以从有限的训练样本直接估计而得。
基于有限训练样本直接计算联合概率，在计算上将会遭遇组合爆炸问题；在数据上将会遭遇样本稀疏问题；属性越多，问题越严重。

为了避开这个障碍，朴素贝叶斯分类器采用了$“属性条件独立性假设”$:对已知类别，假设所有属性相互独立。换言之，假设每个属性独立的对分类结果发生影响相互独立。

回答西瓜的例子就可以认为｛色泽 根蒂 敲声 纹理 脐部 触感｝这些属性对西瓜是好还是坏的结果所产生的影响相互独立。

基于条件独立性假设，对于多个属性的后验概率可以写成：
$$P(c|\mathbf{x})=\frac{P(C)P(\mathbf{x}|c)}{P(\mathbf{x})}=\frac{P(c)}{P(\mathbf{x})}\prod _{i=1}^{d}P(x_i|c)$$

d为属性数目，$x_i$是x在第i个属性上取值。
对于所有的类别来说P(x)相同，基于极大似然的贝叶斯判定准则有朴素贝叶斯的表达式：
$$h_{nb}(\mathbf{x})=\arg ma{x}_{c\in \mathcal{Y}}P(c)\prod _{i=1}^{d}P(x_i|c)(1)$$

极值问题情况下的每个类的分类概率

极值问题

很多时候遇到求出各种目标函数（object function）的最值问题（最大值或者最小值）。关于函数最值问题，其实在高中的时候我们就已经了解不少，最经典的方法就是：直接求出极值点。这些极值点的梯度为0。若极值点唯一，则这个点就是代入函数得出的就是最值；若极值点不唯一，那么这些点中，必定存在最小值或者最大值（去除函数的左右的最端点），所以把极值代入函数，经对比后可得到结果。

请注意：并不一定所有函数的极值都可以通过设置导数为0的方式求 出。也就是说，有些问题中当我们设定导数为0时，未必能直接计算出满足导数为0的点（比如逻辑回归模型），这时候就需要利用数值计算相关的技术（最典型为梯度下降法，牛顿法……）。

下溢问题如何解决

数值下溢问题：是指计算机浮点数计算的结果小于可以表示的最小数，因为计算机的能力有限，当数值小于一定数时，其无法精确保存，会造成数值的精度丢失，由上述公式可以看到，求概率时多个概率值相乘，得到的结果往往非常小；因此通常采用取对数的方式，将连乘转化为连加，以避免数值下溢。

零概率问题如何解决？

零概率问题，就是在计算实例的概率时，如果某个量x，在观察样本库（训练集）中没有出现过，会导致整个实例的概率结果是0.

在实际的模型训练过程中，可能会出现零概率问题（因为先验概率和反条件概率是根据训练样本算的，但训练样本数量不是无限的，所以可能出现有的情况在实际中存在，但在训练样本中没有，导致为0的概率值，影响后面后验概率的计算），即便可以继续增加训练数据量，但对于有些问题来说，数据怎么增多也是不够的。这时我们说模型是不平滑的，我们要使之平滑，一种方法就是将训练（学习）的方法换成贝叶斯估计。

现在看一个示例，及$P(敲声=清脆|好瓜=是)=\frac{8}{0}=0$
不论样本的其他属性如何，分类结果都会为“好瓜=否”，这样显然不太合理。

朴素贝叶斯算法的先天缺陷：其他属性携带的信息被训练集中某个分类下未出现的属性值“抹去”，造成预测出来的概率绝对为0。为了拟补这一缺陷，前辈们引入了拉普拉斯平滑的方法：对先验概率的分子(划分的计数)加1，分母加上类别数；对条件概率分子加1，分母加上对应特征的可能取值数量。这样在解决零概率问题的同时，也保证了概率和依然为1：
$$P(c)=\frac{|D_c|}{|D|}\to P(c)=\frac{|D_c|+1}{|D|+N}$$
$$P(x_i|c)=\frac{|D_{x_i|c}|}{|D_c|}\to P(x_i|c)=\frac{|D_{x_i|c}|+1}{|D_c|+N_i}$$

其中，N表示数据集中分类标签，$N_i$表示第$i$个属性的取值类别数，|D|样本容量，$|D_c|$表示类别c的记录数量，$|D_{x_i|c}|$表示类别c中第i个属性取值为$x_i$的记录数量。

将这两个式子应用到上面的计算过程中，就可以弥补朴素贝叶斯算法的这一缺陷问题。

用西瓜的数据来看，当我们计算

P(好瓜=是)时，样本有17个，所以|D| = 17，N，好瓜标签可以分为｛是，否｝两类，所以N=2，（好瓜=是）的样本个数有8个，所以这里$|D_c|$=8。

综上，根据拉普拉斯平滑后有 $$P(好瓜=是)=\frac{|D_c|+1}{|D|+N}=\frac{|8|+1}{|17|+2}$$
P（色泽=青绿|好瓜=是）时，色泽青绿的样本有8个，所以|D_c| = 8，N，色泽标签可以分为｛青绿，浅白，乌黑｝三类，所以N=3，（好瓜=是）的样本个数有3个，所以这里$|D_{c,x_i}|$=3。
综上，根据拉普拉斯平滑后有$$P（色泽=青绿|好瓜=是）=\frac{|D_{x_i|c}|+1}{|D_c|+N_i}=\frac{|3|+1}{|8|+3}$$
同理，分析可知，之前不合理的$P(敲声=清脆|好瓜=是)=\frac{8}{0}=0$在进行拉普拉斯平滑后为$$P(敲声=清脆|好瓜=是)=\frac{|D_{x_i|c}|+1}{|D_c|+N_i}=\frac{|0|+1}{|8|+3}$$显然结果不是0，使结果变得合理。

sklearn参数详解

1. 高斯朴素贝叶斯算法是假设特征的可能性(即概率)为高斯分布。

class sklearn.naive_bayes.GaussianNB(priors=None)
参数：
priors:先验概率大小，如果没有给定，模型则根据样本数据自己计算（利用极大似然法）。
var_smoothing：可选参数，所有特征的最大方差
属性：
class_prior_:每个样本的概率
class_count:每个类别的样本数量
classes_:分类器已知的标签类型
theta_:每个类别中每个特征的均值
sigma_:每个类别中每个特征的方差
epsilon_:方差的绝对加值方法
# 贝叶斯的方法和其他模型的方法一致。
fit(X,Y):在数据集(X,Y)上拟合模型。
get_params():获取模型参数。
predict(X):对数据集X进行预测。
predict_log_proba(X):对数据集X预测，得到每个类别的概率对数值。predict_proba(X):对数据集X预测，得到每个类别的概率。
score(X,Y):得到模型在数据集(X,Y)的得分情况。

根据李航老师的代码构建自己的朴素贝叶斯模型

这里采用GaussianNB 高斯朴素贝叶斯,概率密度函数为
$$P(x_i|y_k)=\frac{1}{\sqrt{2\pi {\sigma }_{y_k}^2}}exp(-\frac{(x_i-{\mu }_{y_k}{)}^2}{2{\sigma }_{y_k}^2})$$
数学期望：$\mu$
方差：${\sigma }^2=\frac{1}{n}{\sum }_i^n(x_i-\overline{x}{)}^2$
链接: https://github.com/fengdu78/lihang-code/blob/master/%E7%AC%AC04%E7%AB%A0%20%E6%9C%B4%E7%B4%A0%E8%B4%9D%E5%8F%B6%E6%96%AF/4.NaiveBayes.ipynb.

import math
class NaiveBayes:
    def __init__(self):
        self.model = None

    # 数学期望
    @staticmethod
    def mean(X):
        """计算均值
        Param: X : list or np.ndarray
        
        Return:
            avg : float
        
        """
        avg = 0.0
        # ========= show me your code ==================
        avg = sum(X) / float(len(X))
        # ========= show me your code ==================
        return avg

    # 标准差（方差）
    def stdev(self, X):
        """计算标准差
        Param: X : list or np.ndarray
        
        Return:
            res : float
        
        """
        res = 0.0
        # ========= show me your code ==================
        avg = self.mean(X)
        res = math.sqrt(sum([pow(x - avg, 2) for x in X]) / float(len(X)))
        # ========= show me your code ==================
        return res
        
    # 概率密度函数
    def gaussian_probability(self, x, mean, stdev):
        """根据均值和标注差计算x符号该高斯分布的概率
        Parameters:
        ----------
        x : 输入
        mean : 均值
        stdev : 标准差
        
        Return:
        
        res : float， x符合的概率值
            
        """
        res = 0.0
        # ========= show me your code ==================
        exponent = math.exp(-(math.pow(x - mean, 2) /
                              (2 * math.pow(stdev, 2))))
        res = (1 / (math.sqrt(2 * math.pi) * stdev)) * exponent
        # ========= show me your code ==================
        
        return res
        
    # 处理X_train
    def summarize(self, train_data):
        """计算每个类目下对应数据的均值和标准差
        Param: train_data : list
        
        Return : [mean, stdev]
        """
        summaries = [0.0, 0.0]
        # ========= show me your code ==================
        summaries = [(self.mean(i), self.stdev(i)) for i in zip(*train_data)]
        
        # ========= show me your code ==================
        return summaries

    # 分类别求出数学期望和标准差
    def fit(self, X, y):
        labels = list(set(y))
        data = {label: [] for label in labels}
        for f, label in zip(X, y):
            data[label].append(f)
        self.model = {
            label: self.summarize(value) for label, value in data.items()
        }
        return 'gaussianNB train done!'

    # 计算概率
    def calculate_probabilities(self, input_data):
        """计算数据在各个高斯分布下的概率
        Paramter:
        input_data : 输入数据
        
        Return:
        probabilities : {label : p}
        """
        # summaries:{0.0: [(5.0, 0.37),(3.42, 0.40)], 1.0: [(5.8, 0.449),(2.7, 0.27)]}
        # input_data:[1.1, 2.2]
        probabilities = {}
        # ========= show me your code ==================
        for label, value in self.model.items():
            probabilities[label] = 1
            for i in range(len(value)):
                mean, stdev = value[i]
                probabilities[label] *= self.gaussian_probability(
                    input_data[i], mean, stdev)
        # ========= show me your code ==================
        return probabilities

    # 类别
    def predict(self, X_test):
        # {0.0: 2.9680340789325763e-27, 1.0: 3.5749783019849535e-26}
        label = sorted(self.calculate_probabilities(X_test).items(), key=lambda x: x[-1])[-1][0]
        return label
    # 计算得分
    def score(self, X_test, y_test):
        right = 0
        for X, y in zip(X_test, y_test):
            label = self.predict(X)
            if label == y:
                right += 1

        return right / float(len(X_test))

参考：
链接：https://samanthachen.github.io/2016/08/05/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0_%E5%91%A8%E5%BF%97%E5%8D%8E_%E7%AC%94%E8%AE%B07/