python学智能算法（十二）|机器学习朴素贝叶斯方法初步-拉普拉斯平滑计算条件概率

【1】引言

前序学习进程中，对条件概率进行了简单探索：https://blog.csdn.net/weixin_44855046/article/details/145388138?spm=1001.2014.3001.5501

今天，以此为基础，探索机器学习中朴素贝叶斯方法的基本程序。

【2】代码解读

【2.1】库引入

这里只需要numpy库：

python 复制代码

# 引入numpy模块
import numpy as np

【2.2】初始定义

这里现需要定义一个矩阵用于后续计算：

在机器学习中，可以认为一个3行2列的矩阵，是由3个样本组成的大样本，每个样本包含两个特征。

矩阵的行数就是样本数，矩阵的列数就是特征数。

python 复制代码

# 假设有3个样本，2个特征
# 样本数就是行数，特征数是列数
X = np.array([
    [1, 0],  # 样本1
    [1, 1],  # 样本2
    [0, 1]  # 样本3
])

然后定义一个类别标签数组：

python 复制代码

# 这里天然地认为，0对应第一个样本，后面的1和1对应第2和第3个样本
# y内部的数据认为是类别
y = np.array([0, 1, 1])  # 样本1属于类别0，样本2和3属于类别1

经过y的定义，矩阵X被划分为：

$1, 0\], # 样本1 → 类别0 \[1, 1\], # 样本2 → 类别1 \[0, 1\] # 样本3 → 类别1$

然后需要定义一些变量来存储数据：

python 复制代码

# 定义常数n_classes
n_classes = 2
# 定义n_features存储X的第二个维度特征，也就是列数
n_features = X.shape[1]  # 2个特征
# 定义一个type动态函数，创建一个名为Dummy的类
# 继承自object（object是Python 所有类的基类，提前内置好，无需在代码中定义）
# {}是类的属性和方法，但是此处没有定义，所以没有任何属性和方法
self = type('Dummy', (object,), {})()  # 创建临时对象
# 定义一个conditional的纯0矩阵，大小为n_classes行n_features列
self.conditional = np.zeros((n_classes, n_features))

其中，n_classes和n_features存储单个数据，self.conditional是一个纯0矩阵。

|--------------------|-------------|-----------------------------------|----------------|-------------------|
| 变量 | 类型 | 示例 | 用途 | 说明 |
| n_classes | 标量（int） | 2 | 类别数量，确定矩阵行数 | 可通过X.shape[0]获取 |
| n_features | 标量（int） | 2 | 特征数量，确定矩阵列数 | 可通过X.shape[1]获取 |
| self.conditional | 矩阵（ndarray） | shape=( n_classes,n_features) | 存储条件概率的二维数组 | 初始定义为纯0矩阵 |
| self | Dummy类 | | 使用type()动态函数定义 | 是一个临时对象 |
[变量定义]

其中，n_classes和n_features存储单个数据，self.conditional是一个纯0矩阵。

【2.3】计算

之后进行计算：

python 复制代码

# 定义一个for循环，对y进行枚举
# np.unique(y)是对y进行合并同类项
# i是y合并同类项以后，具体的项对应的位置
# c是y合并同类项以后，具体的项
for i, c in enumerate(np.unique(y)):
    # 当y中的取值为类别c，X_c为True
    # 当y取值为c时，y==c的值应该是True，但X[y==c]可以取出y==c时的X值
    X_c = X[y == c]
    print(f"类别 {c} 的样本：\n{X_c}")

    # 计算条件概率,使用拉普拉斯平滑公式
    self.conditional[i] = (X_c.sum(axis=0) + 1) / (X_c.shape[0] + n_features)
    print(f"类别 {c} 的条件概率：{self.conditional[i]}\n")

这里定义了一个枚举函数enumerate()的for循环：

枚举函数enumerate()函数中的参数是np.unique(y)，可以实现对y这个数组的同类项合并操作。

前面的公式定义了y = np.array([0, 1, 1])，经过执行np.unique(y)，会获得[0,1]这样的精简数组。

执行X_c = X[y == c]时：

先按照y==0进行判断，此时将会对应y的实际定义值[0, 1, 1]得到[True,False,False]，X[y==c]则只会输出True对应位置处的样本[1,0]。
然后按照y==1进行判断，此时将会对应y的实际定义值[0, 1, 1]得到[False,True,True,]，X[y==c]则只会输出True对应位置处的样本[1,1]和[0,1]。

然后就可以调用拉普拉斯平滑公式进行条件概率计算：

self.conditional[i] =(X_c.sum(axis=0) + 1) / (X_c.shape[0] + n_features)

X_c.sum(axis=0) + 1的意思是，先按照各列单独相加求和，然后求和结果再增加1，比如：

y==1是，X_c获得：

$1,1\]， \[0,1$

这两个样本排列成2行2列，执行X_c.sum(axis=0) + 1后，获得：

$1+0,1+1\]+\[1,1\]=\[2,3$

此时的 X_c.shape[0] =2，即样本的数量

n_features=2，即每个样板的特征。

此时计算的结果就是：

$2/(2+2),3/(2+2)\]=\[0.5,0.75$

完整代码为：

python 复制代码

# 引入numpy模块
import numpy as np

# 假设有3个样本，2个特征
# 样本数就是行数，特征数是列数
X = np.array([
    [1, 0],  # 样本1
    [1, 1],  # 样本2
    [0, 1]  # 样本3
])
# 这里天然地认为，0对应第一个样本，后面的1和1对应第2和第3个样本
# y内部的数据认为是类别
y = np.array([0, 1, 1])  # 样本1属于类别0，样本2和3属于类别1

# 定义常数n_classes
n_classes = 2
# 定义n_features存储X的第二个维度特征，也就是列数
n_features = X.shape[1]  # 2个特征
# 定义一个type动态函数，创建一个名为Dummy的类
# 继承自object（object是Python 所有类的基类，提前内置好，无需在代码中定义）
# {}是类的属性和方法，但是此处没有定义，所以没有任何属性和方法
self = type('Dummy', (object,), {})()  # 创建临时对象
# 定义一个conditional的纯0矩阵，大小为n_classes行n_features列
self.conditional = np.zeros((n_classes, n_features))

# 定义一个for循环，对y进行枚举
# np.unique(y)是对y进行合并同类项
# i是y合并同类项以后，具体的项对应的位置
# c是y合并同类项以后，具体的项
for i, c in enumerate(np.unique(y)):
    # 当y中的取值为类别c，X_c为True
    # 当y取值为c时，y==c的值应该是True，但X[y==c]可以取出y==c时的X值
    X_c = X[y == c]
    print(f"类别 {c} 的样本：\n{X_c}")

    # 计算条件概率,使用拉普拉斯平滑公式
    self.conditional[i] = (X_c.sum(axis=0) + 1) / (X_c.shape[0] + n_features)
    print(f"类别 {c} 的条件概率：{self.conditional[i]}\n")

代码运行后的输出为：

类别 0 的样本：
$\[1 0\]$
类别 0 的条件概率：[0.66666667 0.33333333]

类别 1 的样本：
$\[1 1$ $0 1\]$
类别 1 的条件概率：[0.5 0.75]

【3】总结

学习了机器学习朴素贝叶斯方法中拉普拉斯平滑计算条件概率的基本方法。