基于美国群众收入数据做相关分析与挖掘

目录

1：引言 2

1.1 研究目的与意义 2

1.2 研究背景 2

2：数据的预处理 3

2.1: 字段数据转换 3

2.2：异常值处理 4

2.3：稀疏值处理 5

3：数据的特征工程与可视化 7

3.1：计算体重、教育年限、工作时长的相关特征值 7

3.2：计算体重、教育年限、工作时长它们之间的皮尔森相关性 7

3.3：变量分布的可视化 9

3.4：其他分析可视化 10

4：数据建模与挖掘 13

4.1：建模前提 13

4.2：逻辑回归模型原理回顾 13

4.3：一次随机建模结果 14

4.4：多次平均建模结果 15

5：总结与展望 16

6：参考文献 17

7：附录1 17

1：引言

研究目的与意义

本文将基于一份外国3万多的人群数的相关收入信息数据，建立机器学习来预测人群收入的多少，其中预测因变量就是年收入是否大于50K美元。如今是大数据和云计算时代，在海量高维数据环境下，再通过人工或者机械行的方法来处理相关数据问题，变得不可行，而且结果也不太客观。然而基于大数据技术来做这些事，将会变得更加有意义。本文就是基于机器学习技术来预测和分析我们所需要的人群收入内在价值信息，通过内在信息做到对人群信息的掌握，从而统筹好社会发展。

研究背景

人群收入是大众关心的非常重要的经济生活话题，然而人群收入受很多方面的因素影响，有年龄因素、工作性质因素、国家来源因素以及每周工作时长因素等等。根据统计和经济学知识，这些因素确实是跟收入有一定关系的，所以我们这里涉及的预测自变量有15个相关的指标，当然为了保护人群的隐私数据，很大部分数据值都存在脱敏处理，但这并不代表我们不能运用这些信息，重新运用这些信息是需要相应的转换和数据分析的。

2：数据的预处理

数据预处理是建模非常重要的组成部分，良好的预处理能对后续建模起到事半功倍的效果。在工程实践中，我们得到的数据会存在有缺失值、重复值等，在使用之前需要进行数据预处理。数据预处理没有标准的流程，通常针对不同的任务和数据集属性的不同而不同。数据预处理的常用流程为：去除唯一属性、处理缺失值、属性编码、数据标准化正则化等。

2.1:字段数据转换

先对数据的缺失值进行删除（缺失值不是很多），由于本身数据很多字段对应的值为字符串数据，但是字符串数据是不能参与运算的，可是我们还非常想充分利用此数据集，所以将字符串数据改写为类别数值数据，因为涉及的数据很多，所以我们必须通过编程自动化处理以上过程（但“教育程度”有个等级存在，跟“教育年限”有关，我们直接取“教育年限”数据即可），原始数据集如下：

2.2：异常值处理

由于数据集数目过多，往往会存在异常的情况，为了高效和有效地检测出每个变量时候存在异常值，我们将采用多项式拟合+统计方法来处理，但不处理类别数据，只对连续型数据（排除“年龄”和“教育年限”，这两列数据非常常规不做处理）做处理。

由上图“资本收益”数据的异常值明显过于多，异常数据将会被其他数据替换。

2.3：稀疏值处理

我们还明显地发现，“资本收益”序列数数存在明显的稀疏情况（0的个数占比92%），“资本损失”也是（0的个数占比95%），稀疏数据的大量存在一方面导致运算复杂，另一方面会对模型造成过拟合现象，我们建议去除这两列数据。最终处理结果如下：

3：数据的特征工程与可视化

特征工程是机器学习，甚至是深度学习中最为重要的一部分特征工程主要是对特征进行筛选，构造与降维等等，可以选择主要特征和构造新的特征，从而增加模型泛化能力。

可视化更是让我们清楚了解数据组成部分，为深度分析做准备。

3.1：计算体重、教育年限、工作时长的相关特征值

上表就是相关数据的描述性统计特征值，由此我们发现，这些数据的分布范围和数量级都是不同的，尤其体重（脱敏后信息）的数量级是非常大的，所以在后面的建模中，我们要主要有些变量的取值不同带来的负面效果。

3.2：计算体重、教育年限、工作时长它们之间的皮尔森相关性

为了减少共线性变量带来的运算资源的浪费，接下来，通过变量之间的相关性分析来筛选变量，根据相关系数理论，当两变量之间的相关系数绝对值大于0.8时，可以认为两变量相关性非常强烈，取之一即可，具体见下表展示：

斯皮曼尔相关系数等级

由于上述三种数据本身就是连续型数值数据，所以我们选择这些数据做特征分析和相关性分析，由上述相关系数值的计算，我们发现这三则的两两之间，并没有什么太大关系，甚至还有点负相关关系。

3.3：变量分布的可视化

上述3幅图就是这三个变量对应的概率密度分布图，我们发现，这些变量的分布并不是很标准的正态分布，但也都有非常突出的区间段数据，尤其是教育年限达到13年左右，也是个人数非常集中的区间段落。每周工作时长集中在40小时左右，看来非常符合8小时工作日的平常制度。

3.4：其他分析可视化

接下来将通过其他图形类型来更多维度展示数据结构。

由上图的扇形图发现，此数据集的人种分布很明显是白人和黑人组成，占了95%以上，这是比较符合美国国情的。

由上述分布柱状图我们发现男性和女性的教育年限基本都分布在9-13年这区域，这点是相同的，但不同的是男性的教育年限在第9年的人数比例是非常大的，比女性要大很多。

此图中的“1”代表的是收入大于50K的，“2”是收入小于50K的，我们发现在大于50K的人数分布比例上，男性是明显大于女性的（女性比值大约是8.1，男性大约是2.3），这侧面说明高收入人群还是男性居多，男性更多是创造社会财富，女性也许更多的是照顾家庭。

4：数据建模与挖掘

数据建模是数据挖掘的重点也是难点，只有在充分理解数据集和模型的基础上，建立的模型才是有效客观的。

4.1：建模前提

我们主要是利用逻辑回归做预测，因为这种模型在处理二分类上有很好的效果，泛化能力强，过拟合概率低。我们开始先对数据集进行训练集：测试集=7:3的比例的随机选取，然后确定好模型的随机种子、其它相关参数等，多次调整取最优，最终给出评价指标来综合评价预测模型的效果。

评价指标我们主要给出六种，一是模型的准确率指标，二是混淆矩阵可视化图，三是ROC修正后的评价指标，四是召回率，五是精准率，六是F1值。

但是为了最终客观评价模型的性能，一次随机实验是不够的，我们将多次实验，取各个指标的平均结果，最为最后的评价指标。

4.2：逻辑回归模型原理回顾

逻辑回归模型中的因变量为0或者取值1的概率，取0的概率是，我们建立逻辑回归变换：

对(1)式在独立个独立自变量下建立回归：

(2)式中的为干扰项，因为取值范围为，所以取值为任意。我们把实际中的数值和计算的值待入(2)中，通过建立方程组结合最小二乘法或者梯度下降算法等，就可以估算出和值来。

4.3：一次随机建模结果

*************一次实验随机种子为211的准确率汇总**************

随机种子是211时，<=50K (6375/6838)准确率：93.229%

随机种子是211时，>50K (992/2211)准确率：44.867%

随机种子是211时，总预测(7367/9049)准确率：81.412%

由于数据存在明显的倾斜现象，所以只看准确率会有逻辑上的不妥，所以我们给出修正指标ROC的可视化图：

由ROC图我们发现，模型的敏感性和特异性还是蛮均衡的，整体来看，我们的模型性能总体还是良好的。

4.4：多次平均建模结果

以上就是我们模型的综合性能，从平均f1值和ROC值发现，我们的模型鲁棒性和准确性还是蛮优良的，有一定的泛化能力，这得力于开始的数据清洗阶段处理的科学有效。

5：总结与展望

本文主要先对数据预处理清洗，然后进行一些可视化分析，再然后我们对逻辑回归模型底层逻辑进行了一些回顾，并选择此机器学习模型，实际建模时，我们设置好模型参数，对数据进行建模和分析，最终我们给出模型的综合评价指标，做到客观科学的评价模型。

通过一系列方法运用，我们客观且科学地建立了基于人群特征数据的人群收入分类器，而且准确率还不错，这很有效地帮助我们解决在实际人群不知道是高收入还是低收入的情况下，通过模型来给出判别结果，在可视化分析阶段，我们也总结了很多人群内在信息的相关特点。

但是方法是多样的，我们可以建立深度学习模型如LSTM、CNN或者其他机器学习如支持向量机模型SVM、随机森林RF模型等等，我们同时可以对特征进行相关建模，比如更高级的特征筛选或者特征降维，这都是我们需要努力的方向！

6：参考文献

[1]刘莹.基于数据挖掘的商品销售预测分析[J].科技通报.2014（07）

[2]李欣海.随机森林模型在分类与回归分析中的应用[J].应用昆虫学报.2013（04）

[3]涂继亮.基于数据挖掘的智能客户关系管理系统研究[D].哈尔滨理工大学2005

[4]岳雪.基于海量数据挖掘关联测度工具的设计[D].西安财经学院2014

[5]冯军.数据挖掘在自动外呼系统中的应用[D].北京邮电大学2009

附录1

数据清洗代码程序

1. # -*- coding: utf-8 -*-  
2. ##一定要注意自身电脑的环境和文件路径，再次提醒一定要注意！！！！  
3. import matplotlib.pyplot as plt  
4. import pandas as pd  
5. import numpy as np  
6. import warnings  
7. import time  
8. warnings.filterwarnings('ignore')  
9.   
10. start_time = time.time()  
11. plt.rcParams['font.sans-serif']=['SimHei']##中文乱码问题！  
12. plt.rcParams['axes.unicode_minus']=False#横坐标负号显示问题！  
13.   
14. path = ''###请正确填写自己的文件路径！！！  
15.   
16. data = pd.read_excel(path + 'income.xlsx',index_col=0)  
17. # print(data)  
18.   
19. colstr = ['workclass','education','marital-status','occupation','relationship','race','sex',  
20.           'native-country','income']  
21.   
22. def transform_type(data,col):##转换数据类型  
23.   
24.     print('original:',data.shape)  
25.     data = data.dropna()  
26.     print('now:',data.shape)  
27.   
28.     for i in col:  
29.         datatemp = data[i]  
30.         msg = set(datatemp)  
31.         for j,k in zip(msg,[l for l in range(1,len(msg) + 1)]):  
32.             data[i][data[i]==j] = k  
33.     return data  
34. res = transform_type(data,colstr)  
35.   
36. res.index = [i for i in range(res.shape[0])]  
37. index_ls = res.index  
38. print(res)  
39.   
40.   
41. def substitute_outliner(data,original_ls,yl,tit,mul1,mul2,num_ls):  
42.   
43.     print('\033[1;34m{0:*^80}\033[1;0m'.format('特征数据“%s”异常值处理'%yl))  
44.     copydata = original_ls.copy()  
45.     for i in data[5]:##获取异常值位置  
46.         del original_ls[i]##按照位置删除最最保险  
47.         upvalue = data[2][i]  
48.         downvalue = data[3][i]  
49.         originalvalue = copydata[i]  
50.         if originalvalue <= downvalue:  
51.             changevaluetemp = downvalue * 0.5 + upvalue * 0.25  
52.             if changevaluetemp >= upvalue:  
53.                 changevalue = upvalue  
54.             else:  
55.                 changevalue = max(changevaluetemp,downvalue)##最小不低于downvalue，防止upvalue过小  
56.             original_ls.insert(i,round(changevalue,1))  
57.             print('\033[1;31m异常数据编号为（原始值%s）：%s，替换的修正值为：%s，downvalue：%s\033[0m' % (originalvalue, num_ls[i], round(changevalue,2),round(downvalue,2)))  
58.         if originalvalue >= upvalue:  
59.             changevaluetemp = upvalue * 0.5 + downvalue * 0.25  
60.             if changevaluetemp <= downvalue:  
61.                 changevalue = downvalue  
62.             else:  
63.                 changevalue = min(changevaluetemp,upvalue)##最大不超过upvalue，防止downvalue过大  
64.             original_ls.insert(i,round(changevalue,1))  
65.             print('\033[1;31m异常数据编号为（原始值%s）：%s，替换的修正值为：%s，upvalue：%s\033[0m'%(originalvalue,num_ls[i],round(changevalue,2),round(upvalue,2)))  
66.   
67.     plt.figure(figsize=(15, 8))  
68.     plt.plot(list(copydata), 'y', label='原始数值')  
69.     plt.plot(data[1], 'r', label='拟合曲线')  
70.     plt.plot(data[2], 'purple', label='拟合上限(%ssigm)曲线'%mul1)  
71.     plt.plot(data[3], 'b', label='拟合下限(%ssigm)曲线'%mul2)  
72.     plt.plot(original_ls, 'g', label='处理完后的数据')  
73.     plt.legend(fontsize=15)  
74.     plt.tick_params(labelsize=15)  
75.     plt.xlabel('编号',fontsize=18)  
76.     plt.ylabel(yl,fontsize=18)  
77.     plt.title(tit,fontsize=20)  
78.     plt.show()  
79.     return original_ls  
80.   
81. def check_outlier(value,mul1,mul2,yl):  
82.   
83.     print('\033[1;34m{0:*^80}\033[1;0m'.format('特征数据“%s”预处理'%yl))  
84.     x = [j for j in range(len(value))]  
85.     coeffs = np.polyfit(x, value, 10)  ##专门求多项式估计参数的函数，根据实际数据波动取相应的阶数  
86.     p = np.poly1d(coeffs)  # 一元估计参数  
87.     sigm = p(x).std()  
88.     sigm_up = p(x) + mul1 * sigm  
89.     sigm_down = p(x) - mul2 * sigm  
90.     outliner = value[(value < sigm_down) | (value > sigm_up)]#条件筛选  
91.     print('\033[1;31m原数据长度：%s，异常数据：%s\033[0m'%(len(value),len(outliner)))  
92.     print(outliner)  
93.     return list(outliner),p(x),sigm_up,sigm_down,x,list(outliner.index)  
94.   
95. col = list(res)  
96. remove_ls = colstr + ['age','education-num']  
97.   
98. for i in remove_ls:  
99.     col.remove(i)##类别数据不作处理  
100. for i in col:##性别和编号不做计算  
101.     mul1 = 500  
102.     mul2 = 500##由于数据很大是人为的，这里mul1和mul2参数慎改  
103.     res1 = check_outlier(res[i],mul1,mul2,i)  
104.     res2 = substitute_outliner(res1,list(res[i]),i,'“%s”数据预处理图'%i,mul1,mul2,index_ls)  
105.     res[i] = res2##数据替换  
106.   
107. del res['capital-gain']  
108. del res['capital-loss']  
109. del res['education']  
110. # res.to_excel(path + '处理好的数据.xlsx')  

数据可视化代码程序

1. # -*- coding: utf-8 -*-  
2. ##一定要注意自身电脑的环境和文件路径，再次提醒一定要注意！！！！  
3. import matplotlib.pyplot as plt  
4. import seaborn as sns  
5. import pandas as pd  
6. import time  
7. import warnings  
8. warnings.filterwarnings('ignore')  
9.   
10. start_time = time.time()  
11. plt.rcParams['font.sans-serif']=['SimHei']##中文乱码问题！  
12. plt.rcParams['axes.unicode_minus']=False#横坐标负号显示问题！  
13.   
14.   
15. path = ''###请正确填写自己的文件路径！！！  
16. data = pd.read_excel(path + '处理好的数据.xlsx',index_col=0)  
17.   
18. newdf1 = data[['fnlwgt','education-num','hours-per-week']].dropna()  
19. print(newdf1.describe())  
20. print(newdf1.corr())  
21.   
22. sns.heatmap(newdf1.corr(),square = True,  vmax=0.8)  
23. plt.show()  
24.   
25. ##循环绘制概率密度图  
26. for i in ['fnlwgt','education-num','hours-per-week']:  
27.     plt.figure(figsize=(15, 8))  
28.     lstemp = data[i]  
29.     sns.distplot(lstemp, rug=False, hist=True, bins=15)  
30.     plt.tick_params(labelsize=18)  
31.     plt.ylabel('概率密度', fontsize=18)  
32.     plt.xlabel(i, fontsize=18)  
33.     plt.title('%s的概率密度分布图'%i,fontsize=20)  
34.     plt.show()  
35. plt.show()  
36.   
37. # 生成数据  
38. datat = pd.read_excel(path + 'income.xlsx',index_col=0)  
39. datat = list(datat['race'])  
40. set_ls = set(datat)  
41. count_ls = []  
42. for i in set_ls:  
43.     count_ls.append(round(datat.count(i) / len(datat),2))  
44. labels = list(set_ls)  
45. share = count_ls  
46.   
47. # 设置分裂属性  
48. explode = [0 for i in range(len(set_ls))]  
49.   
50. # 分裂饼图  
51. plt.figure(figsize=(15, 8))  
52. plt.pie(share, explode = explode,  
53.         labels = labels, autopct = '%3.1f%%',  
54.         startangle = 180, shadow = True,)  
55. plt.tick_params(labelsize=20)  
56. # 标题  
57. plt.title('人种分布扇形图',fontsize=20)  
58. plt.show()  
59.   
60. def makefigure(xname,yname):  
61.   
62.     plt.figure(figsize=(15, 8))  
63.     sns.countplot(x=xname,hue=yname, data=data)  
64.     plt.legend(fontsize=18)  
65.     plt.ylabel(yname,fontsize=18)  
66.     plt.xlabel(xname,fontsize=18)  
67.     plt.title('%s与%s关联的柱状图'%(xname,yname),fontsize=20)  
68.     plt.xticks((0,1),('male','female'))  
69.     plt.tick_params(labelsize=15)  
70.     plt.show()  
71.   
72. makefigure('sex','education-num')  
73. makefigure('sex','income')  

数据建模代码程序

1. # -*- coding: utf-8 -*-  
2. ##一定要注意自身电脑的环境和文件路径，再次提醒一定要注意！！！！  
3. from sklearn.metrics import roc_curve, auc,confusion_matrix,f1_score, precision_score, recall_score  
4. from sklearn.linear_model import LogisticRegression as LR  
5. from sklearn.model_selection import train_test_split  
6. import matplotlib.pyplot as plt  
7. import pandas as pd  
8. import numpy as np  
9.   
10. import warnings  
11. warnings.filterwarnings('ignore')  
12.   
13.   
14. plt.rcParams['font.sans-serif']=['SimHei']##中文乱码问题！  
15. plt.rcParams['axes.unicode_minus']=False#横坐标负号显示问题！  
16.   
17.   
18. path = ''###请正确填写自己的文件路径！！！  
19. data = pd.read_excel(path + '处理好的数据.xlsx',index_col=0)  
20. print(data)  
21.   
22.   
23. # del data['fnlwgt']##去除“体重”变量  
24. data.iloc[:,1:data.shape[1]-1] = (data.iloc[:,1:data.shape[1]-1] - data.iloc[:,1:data.shape[1]-1].min()) \  
25.                                  / (data.iloc[:,1:data.shape[1]-1].max() - data.iloc[:,1:data.shape[1]-1].min())  
26. X = np.array(data.iloc[:,1:data.shape[1]-1])##自变量的读取  
27.   
28. Y = np.array(data.iloc[:,data.shape[1]-1])##因变量的读取  
29. dis_name = [1,2]  
30. rd = 211  
31.   
32.   
33. ##绘制roc图  
34. def make_figure_auc_roc(true_label,score,class_):  
35.     plt.figure(figsize=(15, 8))  
36.   
37.     fpr, tpr, thresholds = roc_curve(true_label,score,pos_label=class_,drop_intermediate=False)  
38.     ###返回的是一系列thresholds阈值  
39.     roc_auc = auc(fpr, tpr)  
40.     roc_result = pd.DataFrame({'fpr' : fpr,'tpr' : tpr, 'tf' : tpr - (1-fpr),'thresholds' : thresholds})  
41. #     roc_result.iloc[(roc_result.tf-0).abs().argsort()[:1]]  
42.     optimal_idx = np.argmax(tpr - fpr)  
43.     optimal_threshold = thresholds[optimal_idx]  
44.     y = tpr[optimal_idx]  
45.     x = fpr[optimal_idx]  
46.     plt.figure(figsize=(8,5))  
47.     plt.plot(fpr, tpr, color='navy',label='AUC=%.3f' % roc_auc)  
48.     plt.plot([-0.005, 1.005], [-0.005, 1.005], color='orange',linestyle='--')  
49.     plt.xlabel('1-特异度',fontsize=10)  
50.     plt.ylabel('敏感度',fontsize=10)  
51.     plt.scatter(x, y, c='red',s=15)  
52.     plt.tick_params(labelsize=12,rotation=10)  
53.     plt.title('ROC曲线',fontsize=12)  
54.     plt.legend(loc='best',fontsize=18)  
55.     plt.text(x+0.05,y-0.05,s='('+str(round(1-x, 3))+', '+str(round(y, 3))+')',fontsize=15)  
56.     plt.show()  
57.     return roc_auc  
58.   
59. def cm_plot(yp, y):##混淆矩阵  
60.     plt.figure(figsize=(15, 8))  
61.     cm = confusion_matrix(yp, y)  # 混淆矩阵  
62.     plt.matshow(cm, cmap=plt.cm.Greens)  # 画混淆矩阵图，配色风格使用cm.Greens，更多风格请参考官网。  
63.     plt.colorbar()  # 颜色标签  
64.   
65.     for x in range(len(cm)):  # 数据标签  
66.         for y in range(len(cm)):  
67.             plt.annotate(cm[x, y], xy=(x, y), horizontalalignment='center', verticalalignment='center')  
68.     plt.ylabel('真实标签',fontsize=10)  # 坐标轴标签  
69.     plt.xlabel('预测标签',fontsize=10)  # 坐标轴标签  
70.     plt.title('预测混淆矩阵图', fontsize=12)  
71.     plt.show()  
72.   
73. ##自定义准确率计算  
74. def show_result(dis_name, pre_ls, real_ls,rd):##准确率  
75.   
76.     ls_r = []  
77.     ls_c = []  
78.     for d in dis_name:  
79.         res_ls = []  
80.         for i, j in zip(pre_ls, list(real_ls)):  
81.             if i == j == d:  
82.                 res_ls.append('正确')  
83.   
84.         ls_r.append(len(res_ls) / list(real_ls).count(d))  
85.         ls_c.append((len(res_ls),list(real_ls).count(d)))  
86.   
87.         print('\033[1;32m随机种子是%s时，%s(%s/%s)准确率：%.3f%%\033[0m' % (rd,d, len(res_ls), list(real_ls).count(d), len(res_ls) / list(real_ls).count(d) * 100))  
88.   
89.     res_ls = []  
90.     for i, j in zip(pre_ls, list(real_ls)):  
91.         if i == j:  
92.             res_ls.append('正确')  
93.         else:  
94.             res_ls.append('错误')  
95.   
96.     print('\033[1;31m随机种子是%s时，总预测(%s/%s)准确率：%.3f%%\033[0m' % (rd,res_ls.count('正确'), len(res_ls), res_ls.count('正确') / len(res_ls) * 100))  
97.     df = pd.DataFrame([list(real_ls), pre_ls, res_ls], index=['真实', '预测', '预测结果']).T  
98.     allcorretrate = res_ls.count('正确') / len(res_ls) * 100  
99.     return df,allcorretrate  
100.   
101.   
102. ##建立LR模型  
103. def model(x,y,rd=rd):  
104.   
105.     xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size=0.3, random_state=rd)  
106.     lr = LR(solver='liblinear')  # 建立逻辑回归模型  
107.     lr.fit(xtrain, ytrain)  # 用特征数据来训练模型  
108.     pre_lr = lr.predict(xtest)  
109.     pro_lr = lr.predict_proba(xtest)  
110.   
111.     return pre_lr,ytest,pro_lr,lr.classes_[0]  
112.   
113. print('\033[1;38m{0:*^80}\033[0m'.format('一次实验随机种子为%s的准确率汇总'%rd))  
114.   
115. res = model(X,Y)  
116. make_figure_auc_roc(res[1], res[2][:, 0], res[3])  
117. cm_plot(res[0],res[1])  
118. show_result(dis_name,res[0],res[1],rd)  
119.   
120. f1 = round(f1_score(res[1], res[0], average='macro'),3)##F计算  
121. p = round(precision_score(res[1], res[0], average='macro'),3)##精准率计算  
122. r = round(recall_score(res[1], res[0], average='macro'),3)##召回率计算  
123. print(f1,p,r)  
124.   
125.   
126. ##循环调用LR模型并可视化结果  
127.   
128. def makefigure(rdls,x,y,func,dn):  
129.   
130.     plt.figure(figsize=(15, 8))  
131.     print('\033[1;38m{0:*^80}\033[0m'.format('多次实验的准确率汇总'))  
132.     lsr = []  
133.     f1_ls = []  
134.     p_ls = []  
135.     r_ls = []  
136.     rou_ls = []  
137.     for k in rdls:  
138.         R = func(x,y,k)##循环调用模型  
139.         rr = show_result(dn, R[0], R[1],k)  
140.         f1 = f1_score(R[1], R[0], average='macro')  
141.         p = precision_score(R[1], R[0], average='macro')  
142.         r = recall_score(R[1], R[0], average='macro')  
143.         roc = make_figure_auc_roc(R[1], R[2][:, 0], R[3])  
144.         f1_ls.append(f1)  
145.         p_ls.append(p)  
146.         r_ls.append(r)  
147.         lsr.append(rr[1])  
148.         rou_ls.append(roc)  
149.     plt.figure(figsize=(15, 8))  
150.     print('\033[1;38m平均准确率：%.3f%%\033[0m'%(pd.Series(lsr).mean()))  
151.     print('\033[1;38m平均f1值：%.3f\033[0m' % (pd.Series(f1_ls).mean()))  
152.     print('\033[1;38m平均召回率值：%.3f\033[0m' % (pd.Series(p_ls).mean()))  
153.     print('\033[1;38m平均精准率值：%.3f\033[0m' % (pd.Series(r_ls).mean()))  
154.     print('\033[1;38m平均ROC值：%.3f\033[0m' % (pd.Series(rou_ls).mean()))  
155.     plt.plot(lsr,label='决策树多次计算结果',marker='*')  
156.     plt.legend(loc='best',fontsize=15)  
157.     plt.tick_params(labelsize=15)  
158.     plt.xticks([j for j in range(len(rdls))],[str(j) for j in rdls])  
159.     plt.xlabel('随机种子数（%s次计算）'%len(rdls),fontsize=18)  
160.     plt.ylabel('准确率（%）',fontsize=18)  
161.     plt.show()  
162.   
163. rand_ls = np.random.randint(0,1000,20)  
164. makefigure(rand_ls,X,Y,model,dis_name)###调用函数