贝叶斯定理

问题背景

当知道事件 $B$ 发生的情况下事件 $A$ 发生的概率 $P(A\mid B)$ ，如何求 $P(B\mid A)$ ？

根据条件概率公式可以得到:
$$P(B\mid A)=\frac{P(AB)}{P(A)}\text{\hspace{1em}(1a)}$$
$$P(AB)=P(B\mid A)\times P(A)\text{\hspace{1em}(1b)}$$
同理：
$$P(A\mid B)=\frac{P(AB)}{P(B)}\text{\hspace{1em}(2a)}$$
$$P(AB)=P(A\mid B)\times P(B)\text{\hspace{1em}(1b)}$$
联立得贝叶斯定理公式：
$$P(B\mid A)=\frac{P(AB)}{P(A)}=\frac{P(A\mid B)\times P(B)}{P(A)}\text{\hspace{1em}(3)}$$

这里的$P(A),P(B)$都是依据原有数据集可知的，称为先验概率；而$P(B|A)$是通过贝叶斯定理求出来的，称为后验概率。

在机器学习的背景下，调整贝叶斯公式如下：
$$P(\text{类别}\mid \text{特征})=\frac{P(\text{特征}\mid \text{类别})\times P(\text{类别})}{P(\text{特征})}\text{\hspace{1em}(4)}$$
公式 $(4)$ 利用先验概率，即特征和类别的概率；再利用不同类别中各个特征的概率分布，最后计算得到后验概率，即各个特征分布下的预测不同的类别。

朴素贝叶斯

朴素贝叶斯中的「朴素」，即条件独立，表示其假设预测的各个属性都是相互独立的,每个属性独立地对分类结果产生影响，条件独立在数学上的表示为：$P(AB)=P(A)\times P(B)$ 。

显然，不同类别之间不一定是完全独立的关系，朴素贝叶斯算法是简化后的算法，但会牺牲一定的分类准确率。

朴素贝叶斯分类算法原理

$$P(\text{类别}\mid \text{特征})=\frac{P(\text{特征}\mid \text{类别})\times P(\text{类别})}{P(\text{特征})}\text{\hspace{1em}(4)}$$
公式 $(4)$ 利用先验概率，即特征和类别的概率；再利用不同类别中各个特征的概率分布，最后计算得到后验概率，即各个特征分布下的预测不同的类别。

对于每个特征，其预测的不同类别中概率最高的就是这个特征的分类的类别，达到分类的目的。对于每种特征来说，$P(\text{特征})$都是一样的，只需要比较$P(\text{特征}\mid \text{类别})\times P(\text{类别})$大小即可。

朴素贝叶斯分类算法步骤

• 第 1 步：设 X = { a 1 , a 2 , a 3 , … , a n } X = \left \{ a_{1},a_{2},a_{3},…,a_{n} \right \} X={a1​,a2​,a3​,…,an​} 为预测数据，其中 $a_i$ 是预测数据的特征值。

• 第 2 步：设 Y = { y 1 , y 2 , y 3 , … , y m } Y = \left \{y_{1},y_{2},y_{3},…,y_{m} \right \} Y={y1​,y2​,y3​,…,ym​} 为类别集合。

• 第 3 步：计算 $P(y_1\mid x)$ , $P(y_2\mid x)$ , $P(y_3\mid x)$ , $\dots$, $P(y_m\mid x)$ 。

• 第 4 步：寻找 $P(y_1\mid x)$ , $P(y_2\mid x)$ , $P(y_3\mid x)$ , $\dots$, $P(y_m\mid x)$ 中最大的概率 $P(y_k\mid x)$ ，则 $x$ 属于类别 $y_k$。

给定示例数据

import pandas as pd

def create_data():
    # 生成示例数据
    data = {"x": ['r', 'g', 'r', 'b', 'g', 'g', 'r', 'r', 'b', 'g', 'g', 'r', 'b', 'b', 'g'],
            "y": ['m', 's', 'l', 's', 'm', 's', 'm', 's', 'm', 'l', 'l', 's', 'm', 'm', 'l'],
            "labels": ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B', 'B', 'B']}
    data = pd.DataFrame(data, columns=["labels", "x", "y"])
    return data

data = create_data()

极大似然估计

如何求$P(\text{特征}\mid \text{类别})\times P(\text{类别})$？

如何求$P(\text{类别})$？

$$P(y_i=c_k)=\frac{{\sum }_{i=1}^{N}I(y_i=c_k)}{N},k=1,2,3,\dots ,m\text{\hspace{1em}(5)}$$
这个很好理解，就是每种类别$y_i$的数量$I$占总样本$N$的比值。

# 先验概率求解
def get_P_labels(labels):
    # P(\text{类别}) 先验概率计算
    labels = list(labels)  # 转换为 list 类型
    P_label = {}  # 设置空字典用于存入 label 的概率
    label_name=list(set(labels))
    for label in label_name:
        P_label[label] = labels.count(
            label) / float(len(labels))  # p = count(y) / count(Y)
    return P_label

P_labels = get_P_labels(data["labels"])
# {'A': 0.5333333333333333, 'B': 0.4666666666666667}

如何求$P(\text{特征}\mid \text{类别})$？

首先我们将特征按序号合并生成一个 NumPy 数组。

import numpy as np
train_data = np.array(data.drop("labels",axis=1))
'''
array([['r', 'm'],
       ['g', 's'],
       ['r', 'l'],
       ['b', 's'],
       ['g', 'm'],
       ['g', 's'],
       ['r', 'm'],
       ['r', 's'],
       ['b', 'm'],
       ['g', 'l'],
       ['g', 'l'],
       ['r', 's'],
       ['b', 'm'],
       ['b', 'm'],
       ['g', 'l']], dtype=object)
'''

得到每一个类别的索引：

labels = data["labels"]
label_index = []
for y in P_labels.keys():
    temp_index = []
    # enumerate 函数返回 Series 类型数的索引和值，其中 i 为索引，label 为值
    for i, label in enumerate(labels):
        if (label == y):
            temp_index.append(i)
        else:
            pass
    label_index.append(temp_index)
# [[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]]

得到 $A$ 和 $B$ 的索引，其中是 $A$ 类别为前 $8$ 条数据，$B$ 类别为后 $7$ 条数据。
在得到类别的索引之后，接下来就是找到我们需要的特征的索引， 以 $A$ 类别中$r$特征 为例。

r_index = [i for i, feature in enumerate(
    train_data[:, 0]) if feature == 'r']  # 效果等同于求类别索引中 for 循环
# [0, 2, 6, 7, 11]

计算出 $P(r|A)$ 。

x_label = set(x_index) & set(label_index[0])
print('既符合 x = r 又是 A 类别的索引值：', x_label)
# 既符合 x = r 又是 A 类别的索引值： {0, 2, 6, 7}
x_label_count = len(x_label)
print('先验概率 P(r|A):', x_label_count / float(len(label_index[0])))
# 先验概率 P(r|A): 0.5

将上述流程转化为一个函数：

def get_P_fea_lab(P_label, features, data):
    # P(\text{特征}∣种类) 先验概率计算
    P_fea_lab = {}
    train_data = data.iloc[:, 1:]
    train_data = np.array(train_data)
    labels = data["labels"]
    for each_label in P_label.keys():
        label_index = [i for i, label in enumerate(
            labels) if label == each_label]  # labels 中出现 y 值的所有数值的下标索引
        # features[0] 在 trainData[:,0] 中出现的值的所有下标索引
        for j in range(len(features)):
            feature_index = [i for i, feature in enumerate(
                train_data[:, j]) if feature == features[j]]
            # set(x_index)&set(y_index) 列出两个表相同的元素
            fea_lab_count = len(set(feature_index) & set(label_index))
            key = str(features[j]) + '|' + str(each_label)
            P_fea_lab[key] = fea_lab_count / float(len(label_index))
    return P_fea_lab


features = ['r', 'm']
get_P_fea_lab(P_labels, features, data)
'''
{'r|A': 0.5,
 'm|A': 0.375,
 'r|B': 0.14285714285714285,
 'm|B': 0.42857142857142855}
'''

可以得到当特征 $x$ 和 $y$ 的值为 $r$ 和 $m$ 时，在不同类别下的先验概率。

完整代码

def classify(data, features):
    # 朴素贝叶斯分类器
    # 求 labels 中每个 label 的先验概率
    labels = data['labels']
    P_label = get_P_labels(labels)
    P_fea_lab = get_P_fea_lab(P_label, features, data)

    P = {}
    P_show = {}  # 后验概率
    for each_label in P_label:
        P[each_label] = P_label[each_label]
        for each_feature in features:
            key = str(each_label)+'|'+str(features)
            P_show[key] = P[each_label] * \
                P_fea_lab[str(each_feature) + '|' + str(each_label)]
            P[each_label] = P[each_label] * \
                P_fea_lab[str(each_feature) + '|' +
                          str(each_label)]  # 由于分母相同，只需要比较分子
    print(P_show)
    features_label = max(P, key=P.get)  # 概率最大值对应的类别
    return features_label
classify(data, ['r', 'm'])
# {"A|['r', 'm']": 0.1, "B|['r', 'm']": 0.02857142857142857}
# 这里类别A的概率大于B，故[r,m]特征分为A类别

贝叶斯估计

在做极大似然估计时，若类别中缺少一些特征，则就会出现概率值为 0 的情况。此时，就会影响后验概率的计算结果，使得分类产生偏差。于是引入贝叶斯估计。

贝叶斯估计的数学表达式为：
$$P(y_i=c_k)=\frac{{\sum }_{i=1}^{N}I(y_i=c_k)+\lambda }{N+k\lambda }\text{\hspace{1em}(6)}$$

其中 $\lambda \ge 0$ 等价于在随机变量各个取值的频数上赋予一个正数，当 $\lambda =0$ 时就是极大似然估计。在平时常取 $\lambda =1$，这时称为拉普拉斯平滑。$k$取值为类别数目。

朴素贝叶斯的三种常见模型

多项式模型

上述过程就是多项式模型，特征离散，参数估计方法采用贝叶斯估计。

伯努利模型

伯努利模型中每个特征的取值只能是 1 和 0。

高斯模型

处理连续的特征变量，采用高斯模型。高斯模型是假设连续变量的特征数据是服从高斯分布的，高斯分布函数表达式为：
$$P(x_i|y_k)=\frac{1}{\sqrt{2\pi }{\sigma }_{y_k,i}}exp(-\frac{(x-{\mu }_{y_k,i}{)}^2}{2{\sigma }_{y_k}^2,i})$$

• ${\mu }_{y_k,i}$ 表示类别为 $y_k$ 的样本中，第 $i$ 维特征的均值。
• ${\sigma }_{y_k}^2,i$ 表示类别为 $y_k$ 的样本中，第 $i$ 维特征的方差。