├── .idea
├── vcs.xml
├── misc.xml
├── inspectionProfiles
│ └── profiles_settings.xml
├── modules.xml
├── zxf.iml
└── workspace.xml
├── README.md
├── read_test.py
└── main.py
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/.idea/inspectionProfiles/profiles_settings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/zxf.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # zxf_fist_up
2 | 天池全国社会保险大数据应用+精准社保/天池精准社保第一赛季
3 |
4 | # 1、竞赛题目
5 | “精准社保”的赛题为“基本医疗保险医疗服务智能监控”，由参赛队完成数据算法模型的开发设计，实现对各类医疗保险基金欺诈违规行为的准确识别，以进一步丰富现行医保智能监控的医保规则和医学规则，提高医保智能监控的针对性和有效性。违规行为举例如下：
6 |
7 | （1）为了获得不当利益，部分人员从各种途径收集医疗保险参保人员的社保卡，通过社保卡到医院进行虚假诊疗，套取医保基金。
8 |
9 | （2）在门诊特殊疾病的诊疗中，部分人员通过编造病历、诊疗过程，套取医保基金。
10 | 在本次比赛中，将上述两种违规人员统称为涉嫌造假人员。选手需要基于给定的训练集数据得到模型，然后使用模型判定测试集中的人员是否为涉嫌造假人员。
11 |
12 | # 2、评选规则
13 | 本赛题的参赛作品将按统一规则和评分标准进行评选，以算法结果与数据来源地实际稽核执法结果匹配情况作为评价依据。在决赛阶段，大赛评委团将对参赛作品的算法原理、历史成绩和答辩情况进行综合评分，确定最终名次。采用精确度(precision)、召回率(recall)和F1值作为评估指标。具体计算公式如下：
14 |
15 | 其中，PredictionSet为算法预测的涉嫌造假人员集合，ReferenceSet为真实答案的涉嫌造假人员集合。以F1值作为最终的唯一评测标准。
16 |
17 | # 3、数据样本
18 |
19 | （1）数据范围。本赛题数据样本为部分地区以往年度的医疗保险就医结算脱敏数据，主要包括人员医疗费用记录以及费用明细等信息。
20 |
21 | （2）数据规模。初赛阶段主要向参赛队提供数据的类型、代码、库表结构，以及少量的脱敏数据样本，供其离线完成作品设计。复赛阶段的数据样本包含近10万参保人的脱敏数据（含涉嫌造假人员），由天池平台对全部数据样本进行管控，参赛队全程无法复制下载数据，只能在天池平台在线使用数据，完成产品设计后将无法使用数据。
22 |
23 | # 4、数据表描述
24 | ## 表格名称描述
25 | ### df_train.csv
26 | 训练集数据，包含69个字段，其中“顺序号”是ID列，“个人编码”，“医院编码”为外键
27 | ### df_test.csv
28 | 测试集数据，字段与训练集数据相同
29 | ### df_id_train.csv
30 | 训练集标签，提供20000名人员是否涉嫌造假的标签，其中1为涉嫌造假人员0为非涉嫌造假人员
31 | ### fee_detail.csv
32 | 训练集与测试集补充数据，涵盖人员在不同医保地址的消费金额明细与消费内容
33 | ### df_id_test.csv
34 |
35 | ## 选手需要提交的答案格式，请注意：
36 |
37 | 1， 预测的涉嫌造假人员请用1表示，非涉嫌造假人员请用0表示，错误的表示会影响到评测结果。
38 |
39 | 2， 请按照格式中第一列对应的人员顺序在第二列中进行预测。
40 |
41 | 3， 在提交的答案中请注意不要加入列名称（与提交格式.csv保持一致）。
42 |
43 | 4， 选手需要对所有4000名测试集中的人员提交预测结果，如果提交的预测中人员小于或者大于4000人将不提供评测结果。
44 |
45 | 5， 提交的答案中第一列ID列与第二列预测标签列请选手使用逗号分隔并提交csv（Comma-Separated Values）格式的文件。
46 |
47 | ## 个人最后排名：410/1336
48 |
--------------------------------------------------------------------------------
/read_test.py:
--------------------------------------------------------------------------------
1 | import pandas as pd
2 | import numpy as np
3 | import time
4 | from sklearn.preprocessing import StandardScaler
5 | ################
6 | def del_time(file,input_list):
7 | temp_list=[]
8 | for i in range(len(input_list)):
9 | if '时间' in input_list[i]:
10 | temp_list.append(input_list[i])
11 | for l in range(len(temp_list)):
12 | file=file.drop(temp_list[l],axis=1)###删除时间项目
13 | return file
14 | ###############
15 | def search_type(file):
16 | type_list=[]
17 | for i in range(len(file.columns)):
18 | type_list.append(type(file.iloc[0,i]))
19 | for l in range(len(type_list)):
20 | if type_list[l]==str:
21 | file=file.drop(type_list[l],axis=1)
22 | else:
23 | file=file
24 | return file
25 | #################
26 | def split(file,input_list):
27 | total_list=[]
28 | for i in range(len(input_list)):
29 | temp_list=[]
30 | temp_file=file.loc[input_list[i]]
31 | print(i)
32 | temp_list.append(temp_file)
33 | total_list.append(temp_list)
34 | return total_list
35 | df_test_file=pd.read_csv('/Users/zxf-pc/Desktop/天池/df_test.csv',index_col='顺序号')
36 | df_id_test_file=pd.read_csv('/Users/zxf-pc/Desktop/天池/df_id_test.csv')
37 | ########目标个人编码columns处理,以下仍有小问题
38 | test_id=df_id_test_file.columns
39 | df_id_test_file.columns=['个人编码']
40 | df_id_test_file.ix[len(df_id_test_file)]=test_id
41 | temp_id_datafram=pd.DataFrame(df_id_test_file).T
42 | temp_id_datafram.insert(0,'a',int(temp_id_datafram.iloc[:,3999]))
43 | del temp_id_datafram[3999]
44 | person_id=temp_id_datafram.iloc[0,:]
45 | person_id.index=range(len(temp_id_datafram.columns))
46 | ##########
47 | test_file_title=df_test_file.columns
48 | df_test_file.dropna(how='all',axis=1,inplace=True)
49 | transform_test_file=df_test_file.sort_values(by='个人编码')
50 | single_id = list(set(transform_test_file['个人编码']))
51 | train_start_time=time.time()
52 | del_time_file=del_time(transform_test_file,test_file_title)
53 | zuizong_file=search_type(del_time_file)
54 | del zuizong_file['出院诊断病种名称']
55 | ##################
56 | zuizong_file.index=zuizong_file['个人编码']
57 | del zuizong_file['个人编码']
58 | #################
59 | fenqu_list=split(zuizong_file,single_id)
60 | print('finish split')
61 | #################
62 | zui_zong_test_list=[]
63 | for i in range(len(fenqu_list)):
64 | if pd.DataFrame(fenqu_list[i]).shape[1]==59:
65 | temp_index=pd.DataFrame(fenqu_list[i]).index
66 | temp_list=pd.DataFrame(fenqu_list[i]).mean(axis=0)
67 | temp_list1=pd.DataFrame(temp_list,columns=temp_index).T
68 | zui_zong_test_list.append(temp_list1)
69 | else:
70 | temp_index=list(set(pd.concat(fenqu_list[i]).index))
71 | temp_list=pd.concat(fenqu_list[i]).mean(axis=0)
72 | temp_dataframe=pd.DataFrame(temp_list,columns=temp_index).T
73 | zui_zong_test_list.append(temp_dataframe)
74 | print('finish%dconcating'%i)
75 | for i in range(1,len(fenqu_list)):
76 | if pd.concat([zui_zong_test_list[i-1],zui_zong_test_list[i]]).shape[1]>59:
77 | print(i)
78 | final_train_file=pd.concat(zui_zong_test_list,axis=0,ignore_index=False)
79 | final_train_file=final_train_file.sort_index()
80 | ####################
81 | print('finsh concat')
82 | final_train_file.fillna(0,inplace=True)
83 | X=StandardScaler().fit_transform(final_train_file)
84 | ####载入训练之后的分类器进行分类
85 |
86 | ######是结果与目标便签匹配,file为分类器按大到小分类结果
87 | file=pd.read_excel('/Users/zxf-pc/Desktop/天池/jieguo.xlsx')
88 | file_index=file.index
89 | index_list=list(file_index)
90 | answer=[]
91 | for i in range(len(person_id)):
92 | for l in range(len(index_list)):
93 | if index_list[l]==person_id[i]:
94 | answer.append(file.iloc[l,0])
95 | print('finish%d'%i)
96 | #index_list.pop(l,inplace=True)
97 | #print(len(index_list))
98 | ### 输出答案
99 | answer_file=pd.DataFrame(answer,index=person_id)
100 | answer_file.to_csv('/Users/zxf-pc/Desktop/天池/answer.csv',sep=',',header=False)###header=False表示不要列头
101 |
102 |
--------------------------------------------------------------------------------
/.idea/workspace.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 | true
34 | DEFINITION_ORDER
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 | 1502272079390
99 |
100 |
101 | 1502272079390
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # -*- coding: utf-8 -*-
3 | """
4 | Created on Tue Jul 18 20:58:08 2017
5 |
6 | @author: zxf-pc
7 | """
8 | ### 数据预处理部分
9 | import pandas as pd
10 | import numpy as np
11 | from sklearn.model_selection import GridSearchCV
12 | from sklearn.model_selection import cross_val_score
13 | from sklearn.model_selection import train_test_split
14 | import matplotlib.pyplot as plt
15 | from sklearn.preprocessing import StandardScaler
16 | import time
17 | ### 分类器部分
18 | from sklearn.preprocessing import Imputer
19 | from sklearn.linear_model import LogisticRegression##LR二分类
20 | from sklearn.ensemble import BaggingClassifier##bagging提升算法
21 | from sklearn.ensemble import RandomForestClassifier##随机森林
22 | from sklearn.ensemble import GradientBoostingClassifier##GBDT
23 | ###评价体系
24 | from sklearn.metrics import accuracy_score##准确率
25 | from sklearn.metrics import recall_score##召回率
26 | from sklearn.metrics import precision_score##精确率
27 | import matplotlib.pyplot as plt
28 | ### 分区函数
29 | def split(file,input_list):
30 | total_list=[]
31 | for i in range(len(input_list)):
32 | temp_list=[]
33 | temp_file=file.loc[input_list[i]]
34 | print(i)
35 | temp_list.append(temp_file)
36 | total_list.append(temp_list)
37 | return total_list
38 | ### 补值函数有
39 | def get_mean(file):
40 | file=pd.concat(file)
41 | imp=Imputer(missing_values=np.nan, strategy='mean', axis=0)###这种转换函数必须训
42 | imp.fit(file)
43 | new_file=imp.transform(file)
44 | return new_file
45 | ### 筛选出时间列，并暂时做删除处理,返回不含有时间项
46 | def del_time(file,input_list):
47 | temp_list=[]
48 | for i in range(len(input_list)):
49 | if '时间' in input_list[i]:
50 | temp_list.append(input_list[i])
51 | for l in range(len(temp_list)):
52 | file=file.drop(temp_list[l],axis=1)###删除时间项目
53 | return file
54 | ### 查看字段类型并暂时去除字符字段
55 | def search_type(file):
56 | type_list=[]
57 | for i in range(len(file.columns)):
58 | type_list.append(type(file.iloc[0,i]))
59 | for l in range(len(type_list)):
60 | if type_list[l]==str:
61 | file=file.drop(type_list[l],axis=1)
62 | return file
63 | #######缩放函数
64 | def change(probility,train_file):
65 | decision_prb=(probility[:,1]/probility[:,0])*(train_file.count(0)/train_file.count(1))
66 | return decision_prb
67 | ############结果函数
68 | def Print_answer(train_predict_prb,name):
69 | temp_train_decision_label=[]
70 | name=str(name)
71 | for i in range(len(train_predict_prb)):
72 | if train_predict_prb[i]>0.9:
73 | temp_train_decision_label.append(1)
74 | if train_predict_prb[i]<0.9:
75 | temp_train_decision_label.append(0)
76 | print('%s answer'%name)
77 | recall=recall_score(y_test,temp_train_decision_label)
78 | print('recall is %.4f'%recall)
79 | accuracy=accuracy_score(y_test,temp_train_decision_label)
80 | print('accuracy is %.4f'%accuracy)
81 | precision=precision_score(y_test,temp_train_decision_label)
82 | print('precision is %.4f'%precision)
83 | F1=2*precision*recall/(precision+recall)
84 | print('F1 is %.4f'%F1)
85 | #return temp_train_decision_label
86 | ###########
87 | df_train_file=pd.read_csv('/Users/zxf-pc/Desktop/天池文件/df_train.csv'
88 | ,index_col='顺序号')
89 | df_id_train_file=pd.read_csv('/Users/zxf-pc/Desktop/天池文件/df_id_train.csv')
90 | df_id_test_file=pd.read_csv('/Users/zxf-pc/Desktop/天池文件/df_id_test.csv')
91 | train_file_title=df_train_file.columns
92 | ### 去掉全部为Nan的列
93 | df_train_file.dropna(how='all',axis=1,inplace=True)
94 |
95 | ### 排序，将重复项放在一起
96 | transform_train_file=df_train_file.sort_values(by='个人编码')
97 | ### 获得独立的个人id
98 | single_id = list(set(transform_train_file['个人编码']))
99 | ###########直接在总表上去掉时间项和str项
100 | train_start_time=time.time()
101 | del_time_file=del_time(transform_train_file,train_file_title)
102 | zuizong_file=search_type(del_time_file)
103 | ########人为去除错误列
104 | del zuizong_file['出院诊断病种名称']
105 | #zuizong_file.values().astype('float64')
106 | #############
107 | print('get values variable')
108 | ##################转换index
109 | zuizong_file.index=zuizong_file['个人编码']
110 | del zuizong_file['个人编码']
111 | #####个人编码还是出问题，人为改变 7月20日
112 | fenqu_list=split(zuizong_file,single_id)
113 | print('finish split')
114 | ### 进行分区均值代替
115 | zui_zong_train_list=[]
116 | #######以下均值替代有问题，准备人工删除问题列56，58，59，'出院诊断病种名称'
117 | for i in range(len(fenqu_list)):
118 | if pd.DataFrame(fenqu_list[i]).shape[1]==59:
119 | temp_index=pd.DataFrame(fenqu_list[i]).index
120 | temp_list=pd.DataFrame(fenqu_list[i]).mean(axis=0)
121 | temp_list1=pd.DataFrame(temp_list,columns=temp_index).T
122 | zui_zong_train_list.append(temp_list1)
123 | else:
124 | temp_index=list(set(pd.concat(fenqu_list[i]).index))
125 | temp_list=pd.concat(fenqu_list[i]).mean(axis=0)
126 | temp_dataframe=pd.DataFrame(temp_list,columns=temp_index).T
127 | zui_zong_train_list.append(temp_dataframe)
128 | print('finish%dconcating'%i)
129 | for i in range(1,len(fenqu_list)):
130 | if pd.concat([zui_zong_train_list[i-1],zui_zong_train_list[i]]).shape[1]>59:
131 | print(i)
132 | final_train_file=pd.concat(zui_zong_train_list,axis=0,ignore_index=False)
133 | final_train_file=final_train_file.sort_index()
134 | ####################
135 | print('finsh concat')
136 | #train_end_time=time.time()
137 | #print(train_end_time-train_start_time)
138 | #############处理标签
139 | loss_id=df_id_train_file.columns
140 | add_id=list(loss_id)
141 | df_id_train_file.columns=['个人编码','判断']
142 | #person_index=[]
143 | add_id=[int(x) for x in add_id]
144 | df_id_train_file.ix[len(df_id_train_file)+1]=add_id
145 | df_id_train_file=df_id_train_file.sort_values(by='个人编码')
146 | ########原始数据上加上标签
147 | final_train_file['判断']=df_id_train_file['判断']
148 | label=list(df_id_train_file['判断'])
149 | final_train_file['判断']=label
150 | ##########
151 | print('finish adding label')
152 | ### 数据准备完成后，先用IMpute进行简单的插值
153 | imp=Imputer(missing_values='NaN',strategy='mean',axis=0)
154 | imp=imp.fit(final_train_file)
155 | label_train_file=imp.transform(final_train_file)
156 | finally_train_file=pd.DataFrame(label_train_file,columns=final_train_file.columns,index=final_train_file.index)
157 | ########
158 | #train_end_time=time.time()
159 | #print(train_end_time-train_start_time)
160 | X_file=finally_train_file.drop('判断',axis=1)
161 | ###使用svm为器学习的话太慢，超过10000的数据对就不要使用svm了
162 | ### 使用逻辑回归进行学习，判断。（没有进行隔点调参）
163 | ### 不降维情况
164 | X=StandardScaler().fit_transform(X_file)
165 | ###数据标准话
166 | x_train,x_test,y_train,y_test=train_test_split(X,label,train_size=0.8)
167 | ### LR分类器,这里注意到反例，即0分类较多，需要进行分类不平衡问题
168 | ### 使用缩放策略增加了标签1的数量，但这样损失了accuracy_score,不知道如何取舍
169 | '''
170 | print('begin LR')
171 | LR_clf=LogisticRegression(penalty='l2',solver='sag', tol=0.0001,max_iter=500,n_jobs=-1)
172 | LR_clf=LR_clf.fit(x_train,y_train)
173 | LR_predict=LR_clf.predict(x_test)
174 | train_predict_prb=LR_clf.predict_proba(x_test)
175 | ###考虑分类不平衡问题，使用再放缩(p[:,1]/p[:,0])*(m+/m-)
176 | decision_prb=(train_predict_prb[:,1]/train_predict_prb[:,0])*(y_train.count(0)/y_train.count(1))
177 | ###
178 | train_decision_label=[]
179 | for i in range(len(train_predict_prb)):
180 | if decision_prb[i]>1:
181 | train_decision_label.append(1)
182 | if decision_prb[i]<1:
183 | train_decision_label.append(0)
184 | print('LR answer','\n')
185 | recall=recall_score(y_test,train_decision_label)
186 | print('recall is %.4f'%recall)
187 | accuracy=accuracy_score(y_test,train_decision_label)
188 | print('accuracy is %.4f'%accuracy)
189 | precision=precision_score(y_test,train_decision_label)
190 | print('precision is %.4f'%precision)
191 | F1=2*precision*recall/(precision+recall)
192 | print('F1 is %.4f'%F1)
193 | print('No change answer','\n')
194 | print(LR_clf.score(x_test,y_test))
195 | print('%.4f'%recall_score(y_test,LR_predict))
196 | print('%.4f'%precision_score(y_test,LR_predict))
197 | #LRF1=2*recall_score(y_test,LR_predict)*precision_score(y_test,LR_predict)/(recall_score(y_test,LR_predict)+precision_score(y_test,LR_predict))
198 | #print('%.4f'%LRF1)
199 | ### 使用bagging提升LR算法
200 | '''
201 | '''
202 | bagging_LR_clf=BaggingClassifier(LogisticRegression(penalty='l2',solver='sag',
203 | tol=0.0001,max_iter=500,n_jobs=-1),n_estimators=100,max_samples=1.0, max_features=1.0)
204 | bagging_LR_clf=bagging_LR_clf.fit(x_train,y_train)
205 | bagging_LR_clf_predict=bagging_LR_clf.predict_proba(x_test)
206 | bagging_LR_clf_prob=change(bagging_LR_clf_predict,y_train)
207 | #Print_answer(bagging_LR_clf_prob,'bagging_LR_clf')
208 | '''
209 | ### 使用隔点调参的LR
210 | '''
211 | print('begin GridLR')
212 | clf_param={'penalty':['l2'],'solver':['liblinear','newton-cg','lbfgs','sag'],'max_iter':[300,500,800,1000,1500],'tol':[1e-3,1e-4,1e-5]}
213 | GridSearch_clf=GridSearchCV(LogisticRegression(),clf_param,cv=10)
214 | GridSearch_clf=GridSearch_clf.fit(x_test,y_test)
215 | GridSearch_clf_prediction=GridSearch_clf.predict(x_test)
216 | GridSearch_clf_predict=GridSearch_clf.predict_proba(x_test)
217 | GridSearch_clf_predict_prob=change(GridSearch_clf_predict,y_train)
218 | Print_answer(GridSearch_clf_predict_prob,'GridSearch_clf')
219 | print('no change answer')
220 | GridSearch_clf_recall=recall_score(y_test,GridSearch_clf_prediction)
221 | print('%.4f'%GridSearch_clf_recall)
222 | GridSearch_clf_precise=precision_score(y_test,GridSearch_clf_prediction)
223 | print('%.4f'%GridSearch_clf_precise)
224 | GridSearch_clf_F1=2*GridSearch_clf_precise*GridSearch_clf_recall/(GridSearch_clf_precise+GridSearch_clf_recall)
225 | print('%.4f'%GridSearch_clf_F1)
226 | '''
227 | ### 使用随机森林，目前效果最好
228 | print('begin randomforest')#
229 | ###初始设定量为n_estimators=15000,amx_depth=100
230 | ###开始调整（12000，200）目前0.33最高
231 | RandomForest_clf=RandomForestClassifier(n_estimators=8000,max_features='auto',max_depth=200,n_jobs=-1)
232 | RandomForest_clf=RandomForest_clf.fit(x_train,y_train)
233 | RandomForest_clf_predict=RandomForest_clf.predict_proba(x_test)
234 | RandomForest_clf_decision_prb=change(RandomForest_clf_predict,y_train)
235 | RandomForest_clf_prediction=RandomForest_clf.predict(x_test)
236 | Print_answer(RandomForest_clf_decision_prb,'RandomForest')
237 | print(RandomForest_clf.score(x_test,y_test))
238 | print('no change answer','\n')
239 | print('%.4f'%recall_score(y_test,RandomForest_clf_prediction))
240 | print('%.4f'%precision_score(y_test,RandomForest_clf_prediction))
241 | Randomforest_F1=2*recall_score(y_test,RandomForest_clf_prediction)*precision_score(y_test,RandomForest_clf_prediction)/(precision_score(y_test,RandomForest_clf_prediction)+recall_score(y_test,RandomForest_clf_prediction))
242 | print(Randomforest_F1)
243 | ###使用GBDT 第一轮使用的是默认值
244 | '''
245 | print('begin GBDT')
246 | GBDT_clf=GradientBoostingClassifier(loss='exponential',n_estimators=15000,max_depth=200)
247 | GBDT_clf=GBDT_clf.fit(x_train,y_train)
248 | GBDT_clf_predict_proba=GBDT_clf.predict_proba(x_test)
249 | GBDT_clf_predict=GBDT_clf.predict(x_test)
250 | GBDT_clf_predict_proba=change(GBDT_clf_predict_proba,y_train)
251 | Print_answer(GBDT_clf_predict_proba,'GBDT')
252 | print('no change answer','\n')
253 | print('%.4f'%recall_score(y_test,GBDT_clf_predict))
254 | print('%.4f'%precision_score(y_test,GBDT_clf_predict))
255 | GBDT_F1=2*recall_score(y_test,GBDT_clf_predict)*precision_score(y_test,GBDT_clf_predict)/(precision_score(y_test,GBDT_clf_predict)+recall_score(y_test,GBDT_clf_predict))
256 | print(GBDT_F1)
257 | '''
258 | ### 评价结果输出
259 | #Print_answer(decision_prb,'LR')
260 | #Print_answer(bagging_LR_clf_prob,'bagging_LR_clf')
261 | #Print_answer(GridSearch_clf_predict,'GridSearch_clf')
262 | train_end_time=time.time()
263 | print(train_end_time-train_start_time)
--------------------------------------------------------------------------------