呆板学习k近邻，高斯淳厚贝叶斯分类器

1、k近邻分类

1. #  2-14 k近邻分类
2. import pandas as pd
3. import numpy as np
4. import matplotlib.pyplot as plt
5. from scipy import stats  # 导入stats
7. # 参数设置
8. knn_k_max = 20  # k近邻中的最大k值
9. folds = 4  # k份交叉验证的份数k
10. # 读入轮椅数据集
11. df = pd.read_csv('wheelchair_dataset.csv')
12. data = np.array(df)
13. m_all = np.shape(data)[0]  # 样本总数
14. d = np.shape(data)[1] - 1  # 输入特征的维数
15. classes = np.amax(data[:, d])  # 类别数量
16. m_test = m_all // folds  # 测试数据集中样本的数量
17. m_train = m_test * (folds - 1)  # 训练数据集中样本的数量
18. # 构造随机种子为指定值的随机数生成器，并对数据集中样本随机排序
19. rng = np.random.default_rng(1)
20. rng.shuffle(data)
21. # 对所有样本的输入特征进行归一化（因取值范围已知）
22. data = data.astype(float)
23. data[:, 0:d - 1] = (data[:, 0:d - 1] - 0) / (1023 - 0)  # 归一化压力传感器读数
24. data[:, d - 1] = (data[:, d - 1] - 0) / (50 - 0)  # 归一化超声波传感器的读数
25. #  用于保存分类错误的数量
26. train_errors = np.zeros(knn_k_max)
27. test_errors = np.zeros(knn_k_max)
28. #  对k份交叉验证的k个不同数据集划分进行循环
29. for kfold_k in range(folds):
30.     test_start = kfold_k * m_test  # 测试数据集中第一个样本的索引
31.     # 划分数据集
32.     X_test = data[test_start:test_start + m_test, 0:d]
33.     Y_test = data[test_start:test_start + m_test, d]
34.     X_train_p1 = data[0:test_start, 0:d]  # 训练数据集输入特征的前一部分
35.     X_train_p2 = data[test_start + m_test:, 0:d]  # 训练数据集输入特征的后一部分
36.     X_train = np.concatenate((X_train_p1, X_train_p2), axis=0)  # 连接训练数据集输入特征数组
37.     Y_train_p1 = data[0:test_start, d]  # 训练数据集标注的前一部分
38.     Y_train_p2 = data[test_start + m_test:, d]  # 训练数据集标注的后一部分
39.     Y_train = np.concatenate((Y_train_p1, Y_train_p2), axis=0)  # 连接训练数据集输入特征数组
40.     #  对k近邻中的k进行循环
41.     for knn_k in range(1, knn_k_max + 1):  # 对测试数据集中的每个样本
42.         for i in range(m_test):
43.             X = X_test[i, :].reshape((1, -1))  # 当前样本的总输入特征
44.             Y = Y_test[i]  # 当前样本的标注
45.             diff = X - X_train  # 当前样本与训练数据集中所有样本的输入特征之差
46.             dist = np.sum(diff * diff, axis=1)  # 计算距离的平方
47.             sorted_index = np.argsort(dist)  # 对距离排序并得到排序后的索引
48.             k_index = sorted_index[0:knn_k]  # 前k个训练样本的索引
49.             k_label = Y_train[k_index]  # 前k个训练样本的标注
50.             Y_hat = stats.mode(k_label, keepdims=True).mode[0]  # 把前k个训练样本标注的众数作为预测类别值
51.             # 累加测试数据集上的分类错误数量
52.             if(Y_hat !=Y):
53.                 test_errors[knn_k-1]=test_errors[knn_k-1]+1
54.         # 对训练数据集中每一个样本
55.         for i in range(m_train):
56.             X = X_train[i, :].reshape((1, -1))  # 当前样本的总输入特征
57.             Y = Y_train[i]  # 当前样本的标注
58.             diff = X - X_train  # 当前样本与训练数据集中所有样本的输入特征之差
59.             dist = np.sum(diff * diff, axis=1)  # 计算距离的平方
60.             sorted_index = np.argsort(dist)  # 对距离排序并得到排序后的索引
61.             k_index = sorted_index[0:knn_k]  # 前k个训练样本的索引
62.             k_label = Y_train[k_index]  # 前k个训练样本的标注
63.             Y_hat = stats.mode(k_label, keepdims=True).mode[0]  # 把前k个训练样本标注的众数作为预测类别值
64.             # 累加训练数据集上的分类错误数量
65.             if(Y_hat !=Y):
66.                 train_errors[knn_k-1]=train_errors[knn_k-1]+1
67. # 画出两个数据集上的分类错误线
68. plt.plot(np.arange(1, knn_k_max + 1), train_errors, 'r-o', linewidth=2, markersize=5)
69. plt.plot(np.arange(1, knn_k_max + 1), test_errors, 'b-s', linewidth=2, markersize=5)
70. plt.ylabel('Number of errors')
71. plt.xlabel('k of k-NN')
72. plt.legend(['Traininng dataset', 'Test dataset'])
73. plt.show()

复制代码

效果图

2、高斯淳厚贝叶斯分类器

1. #  2-16 高斯朴素贝叶斯分类器
2. import pandas
3. import numpy as np
5. # 参数设置
6. m_train = 200  # 训练样本数量
7. # 读入轮椅数据
8. df = pandas.read_csv('wheelchair_dataset.csv')
9. data = np.array(df)
10. m_all = np.shape(data)[0]  # 样本数量
11. d = np.shape(data)[1] - 1  # 输入特征维数
12. m_test = m_all - m_train  # 测试样本的数量
14. # 构造随机种子为指定值的随机数生成器，并对数据集中的样本随机排序
15. rng = np.random.default_rng(1)
16. rng.shuffle(data)
18. # 划分数据集
19. X_train = data[0:m_train, 0:d]
20. y_train = data[0:m_train, d]
21. X_test = data[m_train:, 0:d]
22. y_test = data[m_train:, d]
24. # 用于保存混淆矩阵
25. test_conf_mat = np.zeros((classes, classes))  # 测试数据集混淆矩阵
26. train_conf_mat = np.zeros((classes, classes))  # 训练数据集混淆矩阵
28. # 用于保存高斯朴素贝叶斯分类器的参数
29. gnb_priors = np.zeros(classes).reshape((-1, 1))  # 各个类别的先验概率
30. gnb_means = np.zeros((classes, d))  # 均值
31. gnb_stds = np.zeros((classes, d))  # 标准差
33. # 训练（估算参数）
34. for c in range(classes):  # 对于每一个类别
35.     x_class_c = np.compress(y_train == c + 1, X_train, axis=0)  # 从训练数据集中抽取该类别训练样本的输入特征
36.     gnb_priors[c, 0] = np.shape(x_class_c)[0] / m_train  # 估算该类别的先验概率
37.     gnb_means[c, :] = np.mean(x_class_c, axis=0)  # 估算该类别训练样本各维输入特征的均值
38.     gnb_stds[c, :] = np.std(x_class_c, axis=0, ddof=1)  # 估算该类别训练样本各维输入特征的标准差
40. # 预测（测试数据集）
41. for i in range(m_test):  # 对测试数据集中每一个样本
42.     x = X_test[i, :].reshape((1, -1))  # 样本的输入特征
43.     std_x = (x - gnb_means) / gnb_stds  # 标准化输入特征
44.     p_class = np.log(gnb_priors) - np.sum(0.5 * std_x * std_x + np.log(gnb_stds), axis=1).reshape(
45.         (-1, 1))  # 该输入特征对应为各个类别的可能性
46.     y_hat = np.argmax(p_class) + 1  # 预测：样本对应为可能性最大的类别
48.     # 累加测试数据集上的混淆矩阵
49.     y = y_test[i]
50.     test_conf_mat[y_hat - 1, y - 1] = test_conf_mat[y_hat - 1, y - 1] + 1
52. # 预测（训练数据集）
53. for i in range(m_train):  # 对训练数据集中每一个样本
54.     x = X_train[i, :].reshape((1, -1))  # 样本的输入特征
55.     std_x = (x - gnb_means) / gnb_stds  # 标准化输入特征
56.     p_class = np.log(gnb_priors) - np.sum(0.5 * std_x * std_x + np.log(gnb_stds), axis=1).reshape(
57.         (-1, 1))  # 该输入特征对应为各个类别的可能性
58.     y_hat = np.argmax(p_class) + 1  # 预测：样本对应为可能性最大的类别
60.     #  累加训练数据集上的混淆矩阵
61.     y = y_train[i]
62.     train_conf_mat[y_hat - 1, y - 1] = train_conf_mat[y_hat - 1, y - 1] + 1
64. # 清零累加变量
65. F1_acc_test, F1_acc_train = 0, 0
67. # 累加测试数据集和训练数据集上各个类别的F1值
68. for c in range(classes):
69.     precision_test = test_conf_mat[c, c] / np.sum(test_conf_mat[c, :])
70.     recall_test = test_conf_mat[c, c] / np.sum(test_conf_mat[:, c])
71.     F1_acc_test = F1_acc_test + 2 * precision_test * recall_test / (precision_test + recall_test)
72.     precision_train = train_conf_mat[c, c] / np.sum(train_conf_mat[c, :])
73.     recall_train = train_conf_mat[c, c] / np.sum(train_conf_mat[:, c])
74.     F1_acc_train = F1_acc_train + 2 * precision_train * recall_train / (precision_train + recall_train)
76. # 计算宏平均F1值
77. test_macro_F1 = F1_acc_test / classes
78. train_macro_F1 = F1_acc_train / classes
80. # 计算训练数据集和测试数据集上的马修斯相关系数
81. test_MCC_a = np.sum(test_conf_mat)
82. test_MCC_s = np.trace(test_conf_mat)
83. test_MCC_h = np.sum(test_conf_mat, axis=1)
84. test_MCC_l = np.sum(test_conf_mat, axis=0)
85. test_MCC = (test_MCC_a * test_MCC_s - np.dot(test_MCC_h, test_MCC_l)) / np.sqrt(
86.     (test_MCC_a * test_MCC_a - np.dot(test_MCC_h, test_MCC_h)) * (
87.                 test_MCC_a * test_MCC_a - np.dot(test_MCC_l, test_MCC_l)))
88. train_MCC_a = np.sum(train_conf_mat)
89. train_MCC_s = np.trace(train_conf_mat)
90. train_MCC_h = np.sum(train_conf_mat, axis=1)
91. train_MCC_l = np.sum(train_conf_mat, axis=0)
92. train_MCC = (train_MCC_a * train_MCC_s - np.dot(train_MCC_h, train_MCC_l)) / np.sqrt(
93.     (train_MCC_a * train_MCC_a - np.dot(train_MCC_h, train_MCC_h)) * (
94.                 train_MCC_a * train_MCC_a - np.dot(train_MCC_l, train_MCC_l)))
96. # 打印结果
97. print(f'Testset macro F1 = {test_macro_F1:.3f}')
98. print(f'Testset MCC = {test_MCC:.3f}')
99. print(f'Trainset macro F1 = {train_macro_F1:.3f}')
100. print(f'Trainset MCC = {train_MCC:.3f}')

复制代码

效果图

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。