4 朴素贝叶斯法

4. 朴素贝叶斯法

4.1 朴素贝叶斯的学习与分类

4.1.1 基本方法

​ 设输入空间X是n维向量的集合输出空间为类标记集合Y={c1, c2, … , ck}。输入为特征向量x∈X，输出为类标记(class label) y∈Y。X是定义在输入空间上的随机变量，Y是定义在输出空间上的随机变量。P(X,Y)是X和Y的联合分布概率。训练数据集：
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T = \{(x_1,y_1), (x_2,y_2),...,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}
由P(X,Y)独立同分布产生。

​ 朴素贝叶斯法通过训练数据集学习联合概率分布P(X,Y)。具体的，学习以下先验概率分布以及条件概率分布。先验概率分布
$$P(Y=c_k),k=1,2,3,...,K$$
条件概率分布：
$$P(X=x|Y=c_k)=P(X^{(1)}=x^{x_1},...,X^{(n)}=x^{(n)}|Y=c_k)$$
朴素贝叶斯法对条件概率分布作了条件独立性的假设。由于这是一个较强的假设，因此称为朴素贝叶斯法。具体的，条件独立性假设是：
$$\begin{gathered} P(X=x|Y=c_k)=P(X^1=x^{(1)},...,X^{(n)}=x^{(n)}) \\ =\prod _{j=1}^{n}P(X^{(j)}=x^{(j)}|Y=c_k) \end{gathered}$$
​ 朴素贝叶斯法实际上学习到生成数据的机制，所以属于生成模型。条件独立假设等于是说用于分类的特征在类确定的条件下是条件独立的。这一假设使朴素贝叶斯法变得简单，但有时候会牺牲一定的分类准确率。

​ 朴素贝叶斯分类时，对于给定的输入x,通过学习到的模型计算后验概率分布P(Y=c_k|X=x)，将后验概率最大的类作为x的类输出。后验概率计算根据贝叶斯定理进行：
$$P(Y=c_k|X=x)=\frac{P(X=x|Y=c_k)P(Y=c_k)}{\sum _{k}P(X=x|Y=c_k)P(Y=c_k)}$$
朴素贝叶斯分类器(基本公式)表示如下：
$$y=f(x)=argma{x}_{c_k}=\frac{P(Y=c_k)\prod _{j}P(X^{(i)}=x^{(i)}|Y=c_k)}{\sum _{k}P(Y=c_k)\prod _{j}P(X^{(i)}=x^{(i)}|Y=c_k)}k=1,2,3,...,K$$
由于朴素贝叶斯具有条件独立性，因此，朴素贝叶斯分类器被变换为：
$$y=f(x)=argma{x}_{c_k}=P(Y=c_k)\prod _{j}P(X^{(j)}=x^{(j)}|Y=c_k)$$

4.1.2 后验概率最大化的含义

朴素贝叶斯法将实例分到后验概率最大的类。这等于期望风险最小化。假设选择0-1损失函数
$$L(Y,f(x))=\{\begin{array}{l}1,Y\ne f(X)\\ 0,Y=f(X)\end{array}$$
f(X)是分类决策函数。此时，期望风险函数为：
$$R_{exp}(f)=E[L(Y,f(X))]$$
期望是对联合分布P(X,Y)取的。由此取条件期望
$$R_{exp}(f)=E_X\sum _{k=1}^K[L(c_k,f(X))]P(c_k|X)$$
为了使期望风险最小化，只需对 X=x 逐个极小化。这样就根据期望风险最小化准则得到了后验概率最大化准则：
$$f(x)=argma{x}_{y\in Y}P(y=c_k|X=x)$$

4.2 朴素贝叶斯法的参数估计

4.2.1 极大似然估计

​ 在朴素贝叶斯中，学习意味着估计P(Y=c_k)和P(X_i=x_i|Y=c_k)。可以应用极大似然估计法估计相应的概率。先验概率P(Y=c_k)的极大似然估计是：
$$P(Y=c_k)=\frac{\sum _{i=1}^{N}I(y_i=c_k)}{N}k=1,2,3,...,K$$
设第j个特征x^(j)可能取值的集合为{a_j1, a_j2, a_j3,…,a_jSj}, 条件概率P(X^(j)=a_jl | Y=c_k)的极大似然估计
$$\begin{gathered} P(X^{(j)}=a_{jl}|Y=c_k)=\frac{\sum _{i=1}^{N}I(x_i^{(j)}=a_{jl},y_i=c_k)}{\sum _{i=1}^{N}I(y_i=c_k)} \\ j=1,2,...,n;l=1,2,3,...,S_j;k=1,2,3,...,K \end{gathered}$$

4.2.2 学习与分类算法

输入：训练数据
KaTeX parse error: Undefined control sequence: \ at position 167: …S_j}\},\ \ \ \ \̲ ̲a_{jl}是第j个特征可能取…
输出：实例x的分类

(1)计算先验概率及条件概率:利用极大似然估计

(2) 对于给定的实例 x=(x^(1),x(2),…,x⁽ⁿ⁾⁾T,计算f(x)
$$f(x)=P(Y=c_k)\prod _{j=1}^{n}P(X^{(i)}=x^{(i)}|Y=c_k),k=1,2,3,...,K$$
(3) 确定实例x的类
$$y=argma{x}_{c_k}f(x)$$

4.2.3 贝叶斯估计

用极大似然估计可能出现所要估计的概率值为0的情况。这时会影响到后验概率的计算结果，使分类产生偏差。解决这一问题的方法就是采用贝叶斯估计：
$$\begin{gathered} P_{\lambda }(X^{(i)}=a_{jl}|Y=c_k)=\frac{\sum _{i=1}^{N}I(x_i^{(j)}=a_{jl},y_i=c_k)+\lambda }{\sum _{i=1}^{N}I(y_i=c_k)+S_i\lambda } \\ Note:\lambda \ge 0.当\lambda =0，为极大似然估计。当\lambda =1时，称为Laplaciansmoothing \end{gathered}$$

4.3 代码

测试数据示范

import pandas as pd

'''
对每一个输入特征X^j进行计算
'''


if __name__ == '__main__':
    # 读入训练集
    filepath = "test.xlsx"
    data = pd.read_excel(filepath)
    x0, y0 = data.shape
    # 切割数据集
    X = data[0:x0 - 1]  # 输入
    Y = data[x0 - 1:]  # 目标
    # 计算先验概率P(Y)
    x1, y1 = Y.shape
    re=dict()
    for i in range(1,y1):
        v=Y[i].values[0]
        if v in re.keys():
            re[v]=re[v]+1;
        else:
            re[v]=1
    PY=dict()# 存放先验概率
    for item in re.keys():
        if item not in PY.keys():
            PY[item]=re[item]/(y1-1)
    # 计算条件概率
    XV=[]#记录每一个特征中不重复的元素
    x2,y2=X.shape
    for i in range(0,x2):
        tmpx=[]
        for j in range(1,y2):
            tmp=X[j].values
            if tmp[i] not in tmpx:
                tmpx.append(tmp[i]);
        XV.append(tmpx)
    ## 计算每个特征的条件概率
    PX = dict();  # 记录特征的条件概率
    index=0
    for itemX in XV:

        for item in itemX:
            tmp=dict();
            for itemy in re.keys():
                ixy=0
                for i in range(1,y2):
                    dtmp=data[i].values
                    if dtmp[index]==item and dtmp[x0-1]==itemy:
                        ixy=ixy+1
                if itemy not in tmp.keys():
                    tmp[itemy]=ixy/re[itemy]
            if item not in PX.keys():
                PX[item]=tmp
        index=index+1;
    # 对于给定的实例计算
    ## 输入实例
    xt=[2,"S"]
    ## 开始计算
    num=0
    rep=0 #这个取值一定不要与目标值的重复
    for item in re.keys():
        tmp=PY[item]
        for ixt in xt:
            tmp=tmp*PX[ixt][item]
        if num<=tmp:
            num=tmp;
            rep=item;
    # 输出识别的值
    print(rep)