朴素贝叶斯--学习笔记--基本原理及代码实现

朴素贝叶斯

概述

Bayes是首先通过以训练集进行概率计算，得到先验概率分布和条件概率分布，而对于这两种概率，Bayes分类器是采用的用样本估计整体（极大似然估计）的思路，通过训练集中样本的这两种概率分布，进行总体近似。也就是计算出

1. 先验概率分布：每个样本标签可能的概率，也就是各分类样本所占比例
2. 在已经知道标签的条件下,各类属性发生的条件可能

再知道这两种概率之后，就能利用贝叶斯定理
$$P(A|B)=\frac{P(AB)}{P(B)}=\frac{P(B|A)P(A)}{P(B)}$$
计算出在已知样本特征之后预测样本的标签。

基本方法

先验概率分布：
$$P(Y=c_k),k=1,2,\cdots ,K$$
条件概率分布：朴素贝叶斯的朴素也表现在这里，“朴素”假设样本不同特征相互独立
$$\begin{array}{rl}P\left(X=x\mid Y=c_k\right)& =P\left(X^{(1)}=x^{(1)},\cdots ,X^{(n)}=x^{(n)}\mid Y=c_k\right)\\ & =\prod _{j=1}^{n}P\left(X^{(j)}=x^{(j)}\mid Y=c_k\right)\end{array}$$
于是可以由乘法公式得到$P(X,Y)$，再利用贝叶斯定理求出后验概率分布，也就是相当于已知了某样本的相关特征属性，预测它属性$c_k$的概率是多少，从而达到了预测的效果。

$$\begin{array}{rl}P\left(Y=C_{\mathrm{k}}\mid X=x\right)& =\frac{P(X=x|Y=c_k)\cdot P(Y=c_k)}{P(X=x)}\\ & =\frac{P\left(X=x\mid Y=C_k\right)P\left(Y=C_k\right)}{{\sum }_{k}P\left(X=x\mid Y=C_k\right)P\left(Y=C_k\right)}\\ & =\frac{P\left(Y=C_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}\mid Y=C_k\right)}{{\sum }_{k}P\left(Y=C_k\right){\prod }_{j}P\left(X^{(j)}=x^{(j)}\mid Y=C_k\right)}\end{array}$$

极大似然估计

对于整个事件的概率分布，我们一般不可能知道各个类型的分布情况，以及在某个类型发生情况下，各个属性发生的概率分布，因此我们可以使用极大似然估计，以样本预测总体的概率。

先验概率分布的极大似然估计：
$$P(Y=c_k)=\frac{{\sum }_{i=1}^{n}I(y_i=c_K)}{N},k=1,2,\cdots ,K$$
条件概率的极大似然估计：
$$\begin{gathered} P\left(X^{(j)}=a_{jl}\mid Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(x_i^{(j)}=a_{jl},y_i=c_k\right)}{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)} \\ j=1,2,\cdots ,n,l=1,2,\cdots ,S_j,y_i\in \{c_1,c_2,\cdots ,c_K\} \end{gathered}$$

朴素贝叶斯算法 (naive Bayes algorithm)

• 输入: 训练数据 $T=\left\{\left(x_1,y_1\right),\left(x_2,y_2\right),\cdots ,\left(x_N,y_N\right)\right\}$，其中 $x_i={\left(x_i^{(1)},x_i^{(2)},\cdots ,x_i^{(n)}\right)}^T$ ,$x_i^j$ 是第i个样本的第 j个特征, $x_i^j\in a_{j1},a_{j2},\dots ,a_{j{S}_j}$,$a_{jl}$是第j个特征可能取得第l个值， $j=1,2,\cdots ,n,l=1,2,\cdots ,S_j,$$y_i\in \{c_1,c_2,\cdots ,c_K\}$ ; 实例 $x$ ;
• 输出：实例$x$ 的分类.

1. 计算先验概率及条件概率

$$\begin{array}{l}P\left(Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)}{N},k=1,2,\cdots ,K\\ P\left(X^{(j)}=a_{jl}\mid Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(x_i^{(j)}=a_{j1},y_i=c_k\right)}{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)}\\ j=1,2,\cdots ,n;l=1,2,\cdots ,S_j;k=1,2,\cdots ,K\end{array}$$

2. 对于给定的实例$x={\left(x^{(1)},x^{(2)},\cdots ,x^{(n)}\right)}^{\mathrm{T}}$, 由上述得到的后验概率，可以得到其分母为条件概率和先验概率组合，相当于为已知参数，所以我们可以只计算分子进行最后预测评估。

$$P\left(Y=c_k\right)\prod _{j=1}^{n}P\left(X^{(j)}=x^{(n)}\mid Y=c_k\right),k=1,2,\cdots ,K$$

3. 确定实例 $x$ 的类，就是通过已知特征去计算它是属性哪一类的样本，然后计算概率值最大的索引也就是其属于哪一类。

$$y=\arg \underset{c_k}{\max }P\left(Y=c_k\right)\prod _{j=1}^{n}P\left(X^{(j)}=x^{(j)}\mid Y=c_k\right)$$

概率密度函数

伯努利模型

处理布尔型特征(true和false，或者1和0)，使用伯努利模型。

如果特征值为1,那么$P\left(x_i\mid y_k\right)=P\left(x_i=1\mid y_k\right)$

如果特征值为0,那么$P\left(x_i\mid y_k\right)=1-P\left(x_i=1\mid y_k\right)$

贝叶斯估计–平滑处理

用极大似然估计可能会出现所要估计的概率值为 0 的情况. 这时会影响到后验概率的计算结果, 使分类产生偏差. 解决这一问题的方法是采用贝叶斯估计. 具体地, 条件概率的贝叶斯估计是
$$P_{\lambda }\left(X^{(j)}=a_{jl}\mid Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(x_i^{(j)}=a_{jl},y_i=c_k\right)+\lambda }{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)+S_j\lambda }$$
式中$\lambda ⩾0$ . 等价于在随机变量各个取值的频数上赋予一个正数 $\lambda >0$. 当 $\lambda =0$时 就是极大似然估计. 常取$\lambda =1$ , 这时称为拉普拉斯平滑 (Laplace smoothing). 显然, 对任何 $l=1,2,\cdots ,S_j,k=1,2,\cdots ,K$ , 有
$$\begin{gathered} P_{\lambda }\left(X^{(j)}=a_{jl}\mid Y=c_k\right)>0 \\ \sum _{l=1}^{s_j}P\left(X^{(j)}=a_{jl}\mid Y=c_k\right)=1 \end{gathered}$$
同样, 先验概率的贝叶斯估计是
$$P_{\lambda }\left(Y=c_k\right)=\frac{{\sum }_{i=1}^{N}I\left(y_i=c_k\right)+\lambda }{N+K\lambda }$$

GaussianNB 高斯朴素贝叶斯

特征的可能性被假设为高斯

概率密度函数：
$$P(x_i|y_k)=\frac{1}{\sqrt{2\pi {\sigma }_{yk}^2}}exp(-\frac{(x_i-{\mu }_{yk}{)}^2}{2{\sigma }_{yk}^2})$$

数学期望(mean)：$\mu$

方差：${\sigma }^2=\frac{\sum (X-\mu {)}^2}{N}$

代码实现：

参考：

class NaiveBayes:
    def __init__(self):
        self.model = None
        
    def summarize(self, train_data):
        train_data = np.array(train_data)
        mean = np.mean(train_data, axis=0)
        std = np.std(train_data, axis=0)
        summaries = np.stack((mean, std), axis=1)
        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 gaussian_probability(self, x, mean, stdev):
        exponent = math.exp(-(math.pow(x - mean, 2) /(2 * math.pow(stdev, 2))))
        prod=(1 / (math.sqrt(2 * math.pi) * stdev)) * exponent
        return prod

    def gaussian_probability_np(self, x, summarize):
        x=np.array(x)
        x = x.reshape(x.shape[0], 1)
        mean, std = np.hsplit(summarize, indices_or_sections=2)
        exponent = np.exp(-((x - mean) ** 2 /(2 * (std ** 2))))
        prod = (1 / (np.sqrt(2 * np.pi) * std)) * exponent
        prod=np.prod(prod, axis=0)
        return prod

    # 计算概率
    def calculate_probabilities_np(self, input_data):
        probabilities = {
    }
        for label, value in self.model.items():
            # 初始化权重概率为1
            probabilities[label] = 1
            # 计算有多少个属性遍历几次
            probabilities[label] *= self.gaussian_probability_np(input_data, value)
        return probabilities

    def calculate_probabilities(self, input_data):
        probabilities = {
    }
        for label, value in self.model.items():
            # 初始化权重概率为1
            probabilities[label] = 1
            for i in range(len(value)):
                mean, stdev = value[i]
                probabilities[label] *= self.gaussian_probability(input_data[i], mean, stdev)
        print('math:',probabilities)
        return probabilities

    # 类别
    def predict(self, X_test):
        # {0.0: 2.9680340789325763e-27, 1.0: 3.5749783019849535e-26}
        label = sorted(
            self.calculate_probabilities_np(X_test).items(),
            key=lambda x: x[-1])
        label = label[-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))
    

如下是再利用贝叶斯分类器进行数据集的分类之后，得到的最终概率

实例实现

1.IRIS鸢尾花数据集

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import math


# data
def create_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['label'] = iris.target
    df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
    data = np.array(df.iloc[:, :])

    return data[:, :-1], data[:, -1]


X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
model = NaiveBayes()
model.fit(X_train, y_train)
score=model.score(X_test, y_test)
print(model.predict([4.4, 3.2, 1.3, 0.2]))
print(score)