机器学习：逻辑回归--下采样

目录
媒介
一、为什么使用下采样
1.例如：
2.导致：
3.办法：
4.结果：
二、代码实现
1.完整代码
2.导入库
3.可视化混淆矩阵
4.导入数据
5数据预处理
6.下采样
7.取出练习集和测试集
8.建立模型
9.举行测试
总结

---

媒介

        下采样（Downsampling）是一种在数据处理中减少样本数量的技能。这种方法通常用于减少数据集的大小，以便举行更高效的盘算或处理。下采样可以应用于差别范例的数据，包括信号、图像和分类数据。 
 
一、为什么使用下采样

• creditcard（点击这里下载文件）
  
• 有时我们的标签数据两极分化太严重
  

1.例如：

        标签为0的数据28w条，为1的数据只有400多条

 
2.导致：

        如许练习出来的模型，使用测试集举行测试之后，对差别真实值的数据预测的结果差别很大，那么这个模型也就是一个不可用的模型

 
3.办法：

这时就需要使用下采样方法：

• 从数据量多的标签数据里随机选择与数据量少的标签数据等量的数据，并组合成小数据集
  

 
4.结果：

使用下采样练习模型之后，测试集的召回率有了很大提高。

 
 

二、代码实现

1.完整代码

1. import pandas as pd
2. import matplotlib.pyplot as plt
3. import numpy as np
6. # 可视化混淆矩阵
7. def cm_plot(y, yp):
8.     from sklearn.metrics import confusion_matrix
9.     import matplotlib.pyplot as plt
11.     cm = confusion_matrix(y, yp)
12.     plt.matshow(cm, cmap=plt.cm.Blues)
13.     plt.colorbar()
14.     for x in range(len(cm)):
15.         for y in range(len(cm)):
16.             plt.annotate(cm[x, y], xy=(y, x), horizontalalignment='center',
17.                          verticalalignment='center')
18.             plt.ylabel('True label')
19.             plt.xlabel('Predicted label')
20.     return plt
22. # 导入数据
23. data = pd.read_csv("creditcard.csv")
25. # 数据标准化: Z标准化
26. from sklearn.preprocessing import StandardScaler  # 可对多列进行标准化
28. scaler = StandardScaler()
29. a = data[['Amount']]  # 取出来变成df数据 因为fit_transform()需要传入df数据
30. data['Amount'] = scaler.fit_transform(a)  # 对Amount列数据进行标准化
31. data = data.drop(['Time'], axis=1)  # 删除无用列
33. """下采样"""
34. positive_eg = data[data['Class'] == 0]
35. negative_eg = data[data['Class'] == 1]
36. np.random.seed(seed=22)  # 随机种子
37. positive_eg = positive_eg.sample(len(negative_eg))  # 从标签为0的样本中随机抽取与标签1数量相同的样本
38. data_c = pd.concat([positive_eg, negative_eg])  # 拼接数据 成为小数据集
40. plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置字体
41. plt.rcParams['axes.unicode_minus'] = False  # 解决符号显示为方块的问题
42. labels_count = pd.value_counts(data_c['Class'])  # 统计0有多少个数据，1有多个数据
43. plt.title("正负例样本数")
44. plt.xlabel("类别")
45. plt.ylabel("频数")
46. labels_count.plot(kind='bar')  # 生成一个条形图，展示每个类别的样本数量。
47. plt.show()
49. # 随机取数据
50. from sklearn.model_selection import train_test_split
52. # 从小数据集中取出训练集和测试集
53. x_c = data_c.drop('Class', axis=1)
54. y_c = data_c.Class
55. x_c_train, x_c_test, y_c_train, y_c_test = \
56.     train_test_split(x_c, y_c, test_size=0.3, random_state=0)  # 随机取数据
58. # 从大数据集里取出训练集和测试集
59. x_w = data.drop('Class', axis=1)
60. y_w = data.Class
61. x_w_train, x_w_test, y_w_train, y_w_test = \
62.     train_test_split(x_w, y_w, test_size=0.3, random_state=0)  # 随机取数据
64. # 交叉验证选择较优惩罚因子 λ
65. from sklearn.model_selection import cross_val_score  # 交叉验证的函数
66. from sklearn.linear_model import LogisticRegression
68. # k折交叉验证选择C参数   使用小数据集
69. scores = []
70. c_param_range = [0.01, 0.1, 1, 10, 100]  # 待选C参数
71. for i in c_param_range:
72.     lr = LogisticRegression(C=i, penalty='l2', solver='lbfgs', max_iter=1000)  # 创建逻辑回归模型  lbfgs 拟牛顿法
73.     score = cross_val_score(lr, x_c_train, y_c_train, cv=8, scoring='recall')  # k折交叉验证 比较召回率
74.     score_mean = sum(score) / len(score)
75.     scores.append(score_mean)
76.     # print(score_mean)
78. best_c = c_param_range[np.argmax(scores)]  # 寻找到scores中最大值的对应的C参数
79. print(f"最优惩罚因子为:{best_c}")
81. # 建立最优模型  使用小数据集训练模型
82. lr = LogisticRegression(C=best_c, penalty='l2', max_iter=1000)
83. lr.fit(x_c_train, y_c_train)
85. """绘制混淆矩阵"""
86. from sklearn import metrics
88. # 使用小数据集的训练集进行出厂前测试
89. train_predicted = lr.predict(x_c_train)  # 训练集特征数据x的预测值
90. # print(metrics.classification_report(y_c_train, train_predicted))  # 传入训练集真实的结果数据 与预测值组成矩阵
91. # cm_plot(y_train, train_predicted).show()   # 可视化混淆矩阵
93. # 使用小数据集的训练集进行测试
94. test_predicted = lr.predict(x_c_test)
95. # print(metrics.classification_report(y_c_test, test_predicted))
96. # cm_plot(y_test, test_predicted).show()
98. # 使用大数据集进行测试
99. w_test_predicted = lr.predict(x_w_test)
100. print(metrics.classification_report(y_w_test, w_test_predicted))
102. # 设置阈值  比较每个阈值的召回率 选出最优阈值  测试模型的阈值 用小数据集的测试集
103. thresholds = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
104. recalls = []
105. for i in thresholds:
106.     y_predict_proba = lr.predict_proba(x_w_test)  # 每条数据分类的预测概率
107.     y_predict_proba = pd.DataFrame(y_predict_proba)
108.     y_predict_proba = y_predict_proba.drop([0], axis=1)  # axis=1 表示删除列而不是行 与下面两行代码联动
109.     y_predict_proba[y_predict_proba[[1]] > i] = 1  # 数据大于i即判断为1类 人为设置阈值
110.     y_predict_proba[y_predict_proba[[1]] <= i] = 0
111.     a = y_predict_proba[y_predict_proba[1] > i]
112.     # cm_plot(y_w_test, y_predict_proba[1]).show()
113.     recall = metrics.recall_score(y_w_test, y_predict_proba[1])  # 计算召回率
114.     recalls.append(recall)
115.     print(f"{i} Recall metric in the testing dataset: {recall:.3f}")

复制代码

 
2.导入库

1. import pandas as pd
2. import matplotlib.pyplot as plt
3. import numpy as np

复制代码

 
3.可视化混淆矩阵

• 这是通用代码
  

1. # 可视化混淆矩阵
2. def cm_plot(y, yp):
3.     from sklearn.metrics import confusion_matrix
4.     import matplotlib.pyplot as plt
6.     cm = confusion_matrix(y, yp)
7.     plt.matshow(cm, cmap=plt.cm.Blues)
8.     plt.colorbar()
9.     for x in range(len(cm)):
10.         for y in range(len(cm)):
11.             plt.annotate(cm[x, y], xy=(y, x), horizontalalignment='center',
12.                          verticalalignment='center')
13.             plt.ylabel('True label')
14.             plt.xlabel('Predicted label')
15.     return plt

复制代码

 
4.导入数据

1. # 导入数据
2. data = pd.read_csv("creditcard.csv")

复制代码

 
5数据预处理

• 对特征数据举行尺度化
  
• 去除无用数据
  

1. # 数据标准化: Z标准化
2. from sklearn.preprocessing import StandardScaler  # 可对多列进行标准化
4. scaler = StandardScaler()
5. a = data[['Amount']]  # 取出来变成df数据 因为fit_transform()需要传入df数据
6. data['Amount'] = scaler.fit_transform(a)  # 对Amount列数据进行标准化
7. data = data.drop(['Time'], axis=1)  # 删除无用列

复制代码

 
6.下采样

• 分别取出各标签的数据
  
• 随机种子可以保证每一次取出来的随机数据是固定的
  
• 使用sample函数举行下采样操作
  
• 拼接数据 组成小数据集
  
• 绘制各标签数据条形图
  

1. """下采样"""
2. positive_eg = data[data['Class'] == 0]
3. negative_eg = data[data['Class'] == 1]
4. np.random.seed(seed=22)  # 随机种子
5. positive_eg = positive_eg.sample(len(negative_eg))  # 从标签为0的样本中随机抽取与标签1数量相同的样本
6. data_c = pd.concat([positive_eg, negative_eg])  # 拼接数据 成为小数据集
8. plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置字体
9. plt.rcParams['axes.unicode_minus'] = False  # 解决符号显示为方块的问题
10. labels_count = pd.value_counts(data_c['Class'])  # 统计0有多少个数据，1有多个数据
11. plt.title("正负例样本数")
12. plt.xlabel("类别")
13. plt.ylabel("频数")
14. labels_count.plot(kind='bar')  # 生成一个条形图，展示每个类别的样本数量。
15. plt.show()

复制代码

 
7.取出练习集和测试集

• 分别取出小数据集和大数据集的练习集和测试集
  

1. # 随机取数据
2. from sklearn.model_selection import train_test_split
4. # 从小数据集中取出训练集和测试集
5. x_c = data_c.drop('Class', axis=1)
6. y_c = data_c.Class
7. x_c_train, x_c_test, y_c_train, y_c_test = \
8.     train_test_split(x_c, y_c, test_size=0.3, random_state=0)  # 随机取数据
10. # 从大数据集里取出训练集和测试集
11. x_w = data.drop('Class', axis=1)
12. y_w = data.Class
13. x_w_train, x_w_test, y_w_train, y_w_test = \
14.     train_test_split(x_w, y_w, test_size=0.3, random_state=0)  # 随机取数据

复制代码

 
8.建立模型

• 使用k折交叉验证获取最佳C参数，使用的是小数据集
  
• 使用最佳C参数建立逻辑回归模型
  

1. # 交叉验证选择较优惩罚因子 λ
2. from sklearn.model_selection import cross_val_score  # 交叉验证的函数
3. from sklearn.linear_model import LogisticRegression
5. # k折交叉验证选择C参数   使用小数据集
6. scores = []
7. c_param_range = [0.01, 0.1, 1, 10, 100]  # 待选C参数
8. for i in c_param_range:
9.     lr = LogisticRegression(C=i, penalty='l2', solver='lbfgs', max_iter=1000)  # 创建逻辑回归模型  lbfgs 拟牛顿法
10.     score = cross_val_score(lr, x_c_train, y_c_train, cv=8, scoring='recall')  # k折交叉验证 比较召回率
11.     score_mean = sum(score) / len(score)
12.     scores.append(score_mean)
13.     # print(score_mean)
15. best_c = c_param_range[np.argmax(scores)]  # 寻找到scores中最大值的对应的C参数
16. print(f"最优惩罚因子为:{best_c}")

复制代码

 
9.举行测试

代码：

1. """绘制混淆矩阵"""
2. from sklearn import metrics
4. # 使用小数据集的训练集进行出厂前测试
5. train_predicted = lr.predict(x_c_train)  # 训练集特征数据x的预测值
6. # print(metrics.classification_report(y_c_train, train_predicted))  # 传入训练集真实的结果数据 与预测值组成矩阵
7. # cm_plot(y_train, train_predicted).show()   # 可视化混淆矩阵
9. # 使用小数据集的训练集进行测试
10. test_predicted = lr.predict(x_c_test)
11. # print(metrics.classification_report(y_c_test, test_predicted))
12. # cm_plot(y_test, test_predicted).show()
14. # 使用大数据集进行测试
15. w_test_predicted = lr.predict(x_w_test)
16. print(metrics.classification_report(y_w_test, w_test_predicted))

复制代码

结果：
        显然，测试集的召回率大大提高，且更加匀称，模型更加优秀

 
总结

        下采样方法实用于数据会合类别分布极不平衡的环境，可以或许平衡类别分布，可以减少过拟合的风险，使练习出的模型更加优秀。

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