特征工程提取有效的风险特征_20211018

  1. #------------------------------------------------------------------------------
  2. """
  3. 功能说明：
  4.     本代码是第5章特征工程提取有效的风险特征配套代码。
  5. 算法流程：
  6.     1、特征组合多项式特征
  7.     2、非负矩阵分解
  8.     3、featuretools包
  9.     4、TSFresh包
  10. 输入数据：
  11.     使用代码自带数据，无需额外的外部数据
  12. 输出数据：
  13.     各代码段输出相应结果变量
  14. 版本历史：
  15.     20211018：定稿提交出版
  16. """
  18. #------------------------------------------------------------------------------
  19. # 特征组合多项式特征
  21. import numpy as np
  22. from sklearn.preprocessing import PolynomialFeatures
  24. X=np.arange(9).reshape(3,3)
  26. poly=PolynomialFeatures(2) #二阶多项式
  27. poly.fit_transform(X)
  29. poly=PolynomialFeatures(degree=3, interaction_only=True) #三阶多项式仅保留交叉项
  30. poly.fit_transform(X)
  33. #------------------------------------------------------------------------------
  34. # 非负矩阵分解
  36. import numpy as np
  37. from sklearn.decomposition import NMF
  38. from sklearn.datasets import load_iris
  40. X, _ = load_iris(True)
  42. #定义模型
  43. nmf = NMF(n_components=2,  # n_components即前文矩阵分解中的k，如果不设定该参数则默认保留全部特征
  44.           init=None,  # W和H的初始化方法，包括'random','nndsvd'(默认),'nndsvda','nndsvdar','custom'.
  45.           solver='cd',  #取值：'cd'、'mu'
  46.           beta_loss='frobenius',  #取值：{'frobenius','kullback-leibler','itakura-saito'}，一般保持默认
  47.           tol=1e-4,  # 停止迭代的极限条件
  48.           max_iter=1000,  #最大迭代次数
  49.           random_state=None,
  50.           alpha=0.,  #正则化参数
  51.           l1_ratio=0.,  #正则化参数
  52.           verbose=0,  #冗长模式
  53.           shuffle=False  #针对"cd solver"
  54.           )
  56. #模型参数
  57. print('params:', nmf.get_params())  #获取构造函数参数的值，也可以通过nmf.attr得到
  59. #模型拟合
  60. nmf.fit(X)
  61. W = nmf.fit_transform(X)
  62. nmf.inverse_transform(W)
  63. H = nmf.components_  # H矩阵
  64. X_= np.dot(W,H)
  66. print('reconstruction_err_', nmf.reconstruction_err_)  #损失函数值
  67. print('n_iter_', nmf.n_iter_)  #迭代次数
  70. #------------------------------------------------------------------------------
  71. # 使用featuretools包进行特征衍生
  73. #导入相关包
  74. import featuretools as ft
  77. #查看自带的数据情况
  78. es = ft.demo.load_mock_customer(return_entityset=True)
  79. es.plot()
  82. #数据载入
  83. data=ft.demo.load_mock_customer()
  84. customers_df=data["customers"]
  85. sessions_df=data["sessions"]
  86. transactions_df=data["transactions"]
  89. #创建实体和实体间关联关系
  90. dataframes={"customers": (customers_df,"customer_id"),
  91.           "sessions": (sessions_df,"session_id","session_start"),
  92.           "transactions":(transactions_df,"transaction_id","transaction_time")
  93.         }
  95. relationships=[("sessions","session_id","transactions","session_id"),
  96.                ("customers","customer_id","sessions","customer_id")
  97.         ]
  100. #运行DFS衍生特征
  101. feature_matrix_customers, features_defs=ft.dfs(
  102.         dataframes=dataframes,
  103.         relationships=relationships,
  104.         target_dataframe_name="customers")
  107. #查看衍生的变量
  108. feature_matrix_customers_columnslst=list(feature_matrix_customers.columns)
  111. #------------------------------------------------------------------------------
  112. # 使用tsfresh包进行特征衍生
  114. #导入相关包
  115. from tsfresh.examples.robot_execution_failures import download_robot_execution_failures, load_robot_execution_failures
  117. #下载和读入数据
  118. download_robot_execution_failures()  #下载数据
  119. timeseries, y = load_robot_execution_failures() #加载数据
  120. timeseries.head()
  121. y.head()
  123. #显示数据前几行
  124. print(timeseries.head())
  125. print(y.head())
  127. #显示时间序列
  128. import matplotlib.pyplot as plt
  129. timeseries[timeseries['id'] == 3].plot(subplots=True, sharex=True, figsize=(10,10))
  130. y[3] #True正常
  131. plt.show()
  132. timeseries[timeseries['id'] == 21].plot(subplots=True, sharex=True, figsize=(10,10))
  133. y[21] #False有故障
  134. plt.show()
  136. #特征提取
  137. from tsfresh import extract_features
  138. extracted_features = extract_features(timeseries, column_id="id", column_sort="time")
  139. #特征选择，基于上一步特征提取的结果，注意不允许出现NaN值，所以需要使用impute先填充
  140. from tsfresh.utilities.dataframe_functions import impute
  141. impute(extracted_features) #缺失值都用0填充
  142. from tsfresh import select_features
  143. features_filtered = select_features(extracted_features, y)
  145. #特征提取+特征选择
  146. from tsfresh import extract_relevant_features
  147. features_filtered_direct = extract_relevant_features(timeseries, y,column_id='id', column_sort='time')

评分卡模型开发_20211018

  1. #------------------------------------------------------------------------------
  2. """
  3. 功能说明：
  4.     本代码是第7章评分卡模型开发配套代码
  5. 算法流程：
  6.     1、使用scikit-learn包的LogisticRegression类建立逻辑回归模型
  7.     2、使用statsmodels包的Logit类建立逻辑回归模型
  8.     3、使用scorecardpy包建模
  9.     4、使用toad包建模
  10. 输入数据：
  11.     使用代码自带数据，无需额外的外部数据
  12. 输出数据：
  13.     各代码段输出相应结果变量
  14. 版本历史：
  15.     20211018：定稿提交出版
  16. """
  18. #------------------------------------------------------------------------------
  19. # 使用scikit-learn的LogisticRegression类建立逻辑回归模型
  21. #导入相关包和模块
  22. import pandas as pd
  24. from sklearn.datasets import load_breast_cancer #乳腺癌数据，Target：二分类
  25. from sklearn.linear_model import LogisticRegression #分类
  26. from sklearn.model_selection import train_test_split #数据集划分
  28. #准备数据，Target二分类
  29. ds_cancer = load_breast_cancer()
  30. data=pd.DataFrame(ds_cancer.data).add_prefix('X')
  31. target = pd.DataFrame(ds_cancer.target,columns=['y'])
  32. X_train,X_test,y_train,y_test =train_test_split(data,target,test_size=0.3)
  34. #定义分类器
  35. clf=LogisticRegression(fit_intercept=True, random_state=123) #模型带截距项
  36. clf.get_params()
  38. #模型拟合
  39. clf.fit(X_train,y_train)
  41. #获取模型拟合系数
  42. clf.coef_
  43. clf.intercept_
  45. '''
  46. 注：上述代码仅用于演示LogisticRegression类的使用，计算模型拟合结果后还需要进行模型结果的评估和验证，
  47. 必要时需要迭代地进行变量选择。
  48. '''
  51. #------------------------------------------------------------------------------
  52. # 使用statsmodels包的Logit类建立逻辑回归模型
  54. #导入包
  55. import statsmodels.api as sm  #回归类模型
  57. #变量筛选通过相关性
  58. X_train_corr=X_train.corr()[X_train.corr()>0.9] #计算变量相关性发现X0和X1、X2,X20和X22、X23相关性很高
  59. X_train1=X_train.drop(['X0','X2','X3','X10','X12','X13','X20','X22','X23'],axis=1)
  61. #加上常数项
  62. X_train1=sm.add_constant(X_train1)
  64. #拟合模型
  65. model = sm.Logit(y_train, X_train1)
  66. results = model.fit()
  68. #模型结果
  69. print(results.summary())
  70. print(results.params)
  72. '''
  73. 注：上述代码仅用于演示Logit类的使用，计算出模型拟合结果后还需要进行进一步的统计检验，
  74. 统计检验显示，多个变量的p值>0.05，故变量不显著，所以需要迭代地将不显著的变量去除。
  75. '''
  78. #------------------------------------------------------------------------------
  79. # 使用scorecardpy包建模
  81. """
  82. 功能说明：
  83.     本程序使用scorecardpy进行评分卡建模
  84. 算法流程：
  85.     依次读入数据、变量筛选、数据分区、变量分箱、分箱调整、变量转换WOE、训练模型、模型评估、模型验证、评分标尺
  86. 输入数据：
  87.     本程序不需要额外输入数据，sc.germancredit自带建模数据
  88. 输出数据：
  89.     评分卡模型结果
  90. 版本历史：
  91. """
  93. #导入相关包
  94. from sklearn.linear_model import LogisticRegression
  95. from sklearn.metrics import plot_precision_recall_curve
  96. from sklearn.metrics import plot_roc_curve
  98. import scorecardpy as sc
  101. #1.读入数据
  103. #读入数据
  104. data = sc.germancredit()
  106. #数据信息
  107. data.info()
  108. data.describe()
  111. #2.变量筛选
  112. data_s = sc.var_filter(data, 
  113.                        y="creditability",
  114.                        iv_limit=0.02, 
  115.                        missing_limit=0.95, 
  116.                        identical_limit=0.95, 
  117.                        var_rm=None, 
  118.                        var_kp=None, 
  119.                        return_rm_reason=False, 
  120.                        positive='bad|1')
  123. #3.数据分区
  124. train, test = sc.split_df(data_s, 'creditability', ratio=0.7, seed=123).values()
  127. #4.变量分箱
  128. #自动分箱
  129. bins = sc.woebin(train, y="creditability")
  130. #细分箱结果报告
  131. sc.woebin_plot(bins)
  134. #5.分箱调整
  135. #交互式输入cut后分箱
  136. #breaks_adj = sc.woebin_adj(train, "creditability", bins) 
  137. #也可以手动设置
  138. breaks_adj = {'age.in.years': [22, 35, 40,60],
  139.               'other.debtors.or.guarantors': ["none", "co-applicant%,%guarantor"]}
  140. bins_adj = sc.woebin(train, y="creditability", breaks_list=breaks_adj)
  143. #6.变量转换WOE
  144. train_woe = sc.woebin_ply(train, bins_adj)
  145. test_woe = sc.woebin_ply(test, bins_adj)
  148. #7.训练模型
  150. #处理数据
  151. X_train = train_woe.loc[:,train_woe.columns != 'creditability']
  152. y_train = train_woe.loc[:,'creditability']
  153. X_test = test_woe.loc[:,train_woe.columns != 'creditability']
  154. y_test = test_woe.loc[:,'creditability']
  156. #定义分类器
  157. lr = LogisticRegression(penalty='l1', C=0.9, solver='saga', n_jobs=-1)
  158. lr.get_params()
  160. #拟合模型
  161. lr.fit(X_train, y_train)
  163. #拟合的参数
  164. lr.coef_
  165. lr.intercept_
  168. #8.模型评估
  169. # predicted proability for train
  170. y_train_pred = lr.predict_proba(X_train)[:,1]
  171. # 绘制KS和ROC、PR曲线
  172. train_perf = sc.perf_eva(y_train, y_train_pred, plot_type=["ks", "roc","pr","lift"], title = "train")
  173. plot_roc_curve(lr,X_train,y_train) 
  174. plot_precision_recall_curve(lr,X_train,y_train)
  177. #9.模型验证
  178. # predicted proability for test
  179. y_test_pred = lr.predict_proba(X_test)[:,1]
  180. # 绘制KS和ROC、PR曲线
  181. test_perf = sc.perf_eva(y_test, y_test_pred, plot_type=["ks", "roc","pr","lift"], title = "test")
  182. plot_roc_curve(lr,X_test,y_test) 
  183. plot_precision_recall_curve(lr,X_test,y_test) 
  186. #10.评分标尺
  187. card = sc.scorecard(bins_adj, 
  188.                     lr, 
  189.                     X_train.columns,
  190.                     points0=600, 
  191.                     odds0=1/19, 
  192.                     pdo=50, 
  193.                     basepoints_eq0=True)
  195. #使用评分标尺打分
  196. train_score = sc.scorecard_ply(train, card, print_step=0)
  197. test_score = sc.scorecard_ply(test, card, print_step=0)
  199. #比较train/test分数分布是否一致，计算分值分布PSI
  200. sc.perf_psi(
  201.         score = {'train':train_score, 'test':test_score},
  202.         label = {'train':y_train, 'test':y_test})
  206. #------------------------------------------------------------------------------
  207. # 使用toad包建模
  209. """
  210. 功能说明：
  211.     本程序使用toad进行评分卡建模
  212. 算法流程：
  213.     依次进行读入数据、样本分区、数据EDA报告、特征分析、特征预筛选、特征分箱、调整合并分箱、特征选择、模型训练、模型评估、模型验证、评分标尺
  214. 输入数据：
  215.     数据下载为https://www.kaggle.com/c/GiveMeSomeCredit/data
  216. 输出数据：
  217.     评分模型结果
  218. 版本历史：
  219. """
  221. #导入相关包
  222. import pandas as pd
  224. from sklearn.linear_model import LogisticRegression
  225. from sklearn.model_selection import train_test_split
  227. import toad
  228. from toad.plot import badrate_plot, proportion_plot, bin_plot
  229. from toad.metrics import KS, F1, AUC
  232. #1. 读入数据
  234. #读入数据
  235. data = pd.read_csv(r'D:\cs-training.csv')
  237. #数据描述
  238. data.info()
  239. data.describe()
  240. data.head()
  243. #2. 样本分区
  244. Xtr,Xts,Ytr,Yts = train_test_split(data.drop('SeriousDlqin2yrs',axis=1),
  245.                                    data['SeriousDlqin2yrs'],
  246.                                    test_size=0.25,
  247.                                    random_state=450)
  248. data_tr = pd.concat([Xtr,Ytr],axis=1)
  249. data_tr['type'] = 'train'
  250. data_ts = pd.concat([Xts,Yts],axis=1)
  251. data_ts['type'] = 'test'
  254. #3. 数据EDA报告
  255. toad.detector.detect(data_tr).to_excel(r'D:\数据EDA结果.xlsx')
  258. #4. 特征分析计算特征IV、gini、entropy、unique
  259. quality = toad.quality(data,'SeriousDlqin2yrs')
  260. quality.head(6)
  263. #5. 特征预筛选
  264. selected_train, drop_lst= toad.selection.select(data_tr,target = 'SeriousDlqin2yrs', 
  265.                                                empty = 0.5, 
  266.                                                iv = 0.05, 
  267.                                                corr = 0.7, 
  268.                                                return_drop=True, 
  269.                                                exclude='type')
  270. selected_test = data_ts[selected_train.columns]
  271. selected_train.shape
  272. drop_lst  #删除的额变量
  275. #6. 特征分箱，必须基于train数据集来做
  277. # 初始化一个combiner类
  278. combiner = toad.transform.Combiner()
  280. # 训练数据并指定分箱方法，需要分箱的变量共7个
  281. combiner.fit(selected_train,
  282.              y='SeriousDlqin2yrs',
  283.              method='chi',
  284.              min_samples =  0.05,
  285.              exclude='type')
  287. # 以字典形式保存分箱结果
  288. bins = combiner.export()
  290. #查看每个特征的分箱结果
  291. print('DebtRatio分箱cut:',bins['DebtRatio'])
  292. print('MonthlyIncome分箱cut:',bins['MonthlyIncome'])
  293. print('NumberOfOpenCreditLinesAndLoans分箱cut:',bins['NumberOfOpenCreditLinesAndLoans'])
  294. print('NumberOfTimes90DaysLate分箱cut:',bins['NumberOfTimes90DaysLate'])
  295. print('NumberRealEstateLoansOrLines分箱cut:',bins['NumberRealEstateLoansOrLines'])
  296. print('RevolvingUtilizationOfUnsecuredLines分箱cut:',bins['RevolvingUtilizationOfUnsecuredLines'])
  297. print('age分箱cut:',bins['age'])
  299. #使用combiner.transform方法对数据进行分箱转换
  300. selected_train_bin = combiner.transform(selected_train)
  302. #画分箱图，bin_plot双轴图同时绘制分箱占比和分箱badrate
  303. proportion_plot(selected_train_bin['DebtRatio'])
  304. proportion_plot(selected_train_bin['MonthlyIncome'])
  305. proportion_plot(selected_train_bin['NumberOfOpenCreditLinesAndLoans'])
  306. proportion_plot(selected_train_bin['NumberOfTimes90DaysLate'])
  307. proportion_plot(selected_train_bin['NumberRealEstateLoansOrLines'])
  308. proportion_plot(selected_train_bin['RevolvingUtilizationOfUnsecuredLines'])
  309. proportion_plot(selected_train_bin['age'])
  310. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'DebtRatio')
  311. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'MonthlyIncome')
  312. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'NumberOfOpenCreditLinesAndLoans')
  313. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'NumberOfTimes90DaysLate')
  314. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'NumberRealEstateLoansOrLines')
  315. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'RevolvingUtilizationOfUnsecuredLines')
  316. badrate_plot(selected_train_bin, target = 'SeriousDlqin2yrs', x = 'type',by = 'age')
  317. bin_plot(selected_train_bin,x='DebtRatio',target='SeriousDlqin2yrs') 
  318. bin_plot(selected_train_bin,x='MonthlyIncome',target='SeriousDlqin2yrs') 
  319. bin_plot(selected_train_bin,x='NumberOfOpenCreditLinesAndLoans',target='SeriousDlqin2yrs')
  320. bin_plot(selected_train_bin,x='NumberOfTimes90DaysLate',target='SeriousDlqin2yrs')
  321. bin_plot(selected_train_bin,x='NumberRealEstateLoansOrLines',target='SeriousDlqin2yrs')
  322. bin_plot(selected_train_bin,x='RevolvingUtilizationOfUnsecuredLines',target='SeriousDlqin2yrs')
  323. bin_plot(selected_train_bin,x='age',target='SeriousDlqin2yrs')
  326. #7. 调整合并分箱
  328. #定义调整分箱#调整分箱cutpoint
  329. bins_adj=bins
  330. bins_adj["age"]=[22, 35, 45, 60]
  331. bins_adj["NumberOfOpenCreditLinesAndLoans"]=[2]
  332. bins_adj["DebtRatio"]=[0.02,0.4,0.5,2] 
  334. #定义分箱combiner
  335. combiner2 = toad.transform.Combiner() #定义分箱combiner
  336. combiner2.set_rules(bins_adj) #设置需要施加的分箱
  338. #应用调整分箱
  339. selected_train_binadj = combiner2.transform(selected_train)
  341. #画分箱坏账率badrate图
  342. proportion_plot(selected_train_binadj['DebtRatio'])
  343. proportion_plot(selected_train_binadj['MonthlyIncome'])
  344. proportion_plot(selected_train_binadj['NumberOfOpenCreditLinesAndLoans'])
  345. proportion_plot(selected_train_binadj['NumberOfTimes90DaysLate'])
  346. proportion_plot(selected_train_binadj['NumberRealEstateLoansOrLines'])
  347. proportion_plot(selected_train_binadj['RevolvingUtilizationOfUnsecuredLines'])
  348. proportion_plot(selected_train_binadj['age'])
  349. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'DebtRatio')
  350. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'MonthlyIncome')
  351. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'NumberOfOpenCreditLinesAndLoans')
  352. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'NumberOfTimes90DaysLate')
  353. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'NumberRealEstateLoansOrLines')
  354. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'RevolvingUtilizationOfUnsecuredLines')
  355. badrate_plot(selected_train_binadj, target = 'SeriousDlqin2yrs', x = 'type',by = 'age')
  358. #8. 转换WOE值
  360. #设置分箱号
  361. combiner.set_rules(bins_adj)
  363. #将特征的值转化为分箱的箱号。
  364. selected_train_binadj = combiner.transform(selected_train)
  365. selected_test_binadj = combiner.transform(selected_test)
  367. #定义WOE转换器
  368. WOETransformer = toad.transform.WOETransformer()
  370. #对WOE的值进行转化，映射到原数据集上。对训练集用fit_transform，测试集用transform
  371. data_tr_woe = WOETransformer.fit_transform(selected_train_binadj, 
  372.                                            selected_train_binadj['SeriousDlqin2yrs'], 
  373.                                            exclude=['SeriousDlqin2yrs','type'])
  374. data_ts_woe = WOETransformer.transform(selected_test_binadj)
  378. #9. 特征选择，使用stepwise选择变量
  379. train_final = toad.selection.stepwise(data_tr_woe.drop('type',axis=1),
  380.                                      target = 'SeriousDlqin2yrs',
  381.                                      direction = 'both', 
  382.                                      criterion = 'aic')
  384. test_final = data_ts_woe[train_final.columns]
  385. print(train_final.shape) #7个特征减少为5个特征。
  388. #10. 模型训练
  390. #准备数据
  391. Xtr = train_final.drop('SeriousDlqin2yrs',axis=1)
  392. Ytr = train_final['SeriousDlqin2yrs']
  394. #逻辑回归模型拟合
  395. lr = LogisticRegression()
  396. lr.fit(Xtr, Ytr)
  398. #打印模型拟合的参数
  399. lr.coef_
  400. lr.intercept_
  403. #11. 模型评估
  405. #在训练集上的模型表现
  406. EYtr_proba = lr.predict_proba(Xtr)[:,1]
  407. EYtr = lr.predict(Xtr)
  409. print('train F1:', F1(EYtr_proba,Ytr))
  410. print('train KS:', KS(EYtr_proba,Ytr))
  411. print('train AUC:', AUC(EYtr_proba,Ytr))
  413. #分值排序性
  414. tr_bucket = toad.metrics.KS_bucket(EYtr_proba,Ytr,bucket=10,method='quantile')  #等频分段
  415. tr_bucket
  418. #12. 模型验证
  420. #在测试集上的模型表现
  421. Xts = test_final.drop('SeriousDlqin2yrs',axis=1)
  422. Yts = test_final['SeriousDlqin2yrs']
  424. EYts_proba = lr.predict_proba(Xts)[:,1]
  425. EYts = lr.predict(Xts)
  427. print('test F1:', F1(EYts_proba,Yts))
  428. print('test KS:', KS(EYts_proba,Yts))
  429. print('test AUC:', AUC(EYts_proba,Yts))
  431. #比较train、test变量稳定性分布是否有显著差异，基于分箱之后的数据
  432. psi = toad.metrics.PSI(train_final,test_final)
  433. psi.sort_values(0,ascending=False)
  436. #13. 分值转换scaling
  437. scorecard = toad.scorecard.ScoreCard(combiner = combiner, transer = WOETransformer , C = 0.1)
  438. scorecard.fit(Xtr, Ytr)
  439. scorecard.export(to_frame = True,)

评分卡模型部署_20211018

  1. #------------------------------------------------------------------------------
  2. """
  3. 功能说明：
  4.     本代码是第9章评分卡模型部署配套代码。
  5. 算法流程：  
  6.     - 训练模型并将模型持久化为PKL文件
  7.     - 本地加载模型PKL文件
  8.     - 训练模型并将模型持久化为PMML文件
  9.     - 本地加载模型PMML文件
  10.     - 在服务器部署模型PMML，然后在客户端调用打分服务
  11. 输入数据：
  12.     使用代码自带数据，无需额外的外部数据
  13. 输出数据：
  14.     各代码段输出相应结果变量
  15. 版本历史：
  16.     20211018：定稿提交出版
  17. """
  19. #------------------------------------------------------------------------------
  20. # 训练模型并将模型持久化为PKL文件
  22. #导入相关包
  23. import pandas as pd
  24. from sklearn.datasets import load_iris
  25. from sklearn import tree
  26. from sklearn2pmml import PMMLPipeline
  28. #读入数据
  29. iris = load_iris()    
  30. X_train=pd.DataFrame(iris.data,columns=['sepal_length','sepal_width','petal_length', 'petal_width'])
  31. y_train=pd.DataFrame(iris.target,columns=['series'])
  33. #训练模型pipeline
  34. clf = tree.DecisionTreeClassifier(max_depth=2) #定义分类器
  35. pipeline = PMMLPipeline([("classifier", clf)]) #定义pipeline
  36. pipeline.fit(X_train, y_train) #此处使用带columns变量名称的dataframe进行模型训练
  38. #方法1：使用pickle包将模型保存为pkl
  39. import pickle
  40. with open("D:\\mdl.pkl", "wb") as f:
  41.     pickle.dump(pipeline, f)
  43. #方法2：使用joblib包将模型导出为pkl
  44. #from sklearn.externals import joblib  #高版本sklearn不再支持joblib
  45. import joblib
  46. joblib.dump(pipeline, "d:\\mdl.pkl", compress = 9)
  49. #------------------------------------------------------------------------------
  50. # 本地加载和使用模型PKL文件
  52. #使用pickle包读取pickle
  53. with open('D:\\mdl.pkl', 'rb') as f:
  54.     mdl_in = pickle.load(f)
  55. y_pred=mdl_in.predict(iris.data)
  57. #使用joblib包读取pickle
  58. mdl_in=joblib.load("d:\\mdl.pkl")
  59. y_pred=mdl_in.predict(iris.data)
  62. #------------------------------------------------------------------------------
  63. # 将模型持久化为PMML文件
  65. # 方法一：使用sklearn2pmml包导出模型PMML文件
  67. #导入相关包
  68. from sklearn.datasets import load_iris
  69. from sklearn import tree
  70. from sklearn2pmml import PMMLPipeline
  72. #读入数据
  73. iris = load_iris()
  74. X_train=pd.DataFrame(iris.data,columns=['sepal_length','sepal_width','petal_length', 'petal_width'])
  75. y_train=pd.DataFrame(iris.target,columns=['series'])
  77. #训练模型pipeline
  78. clf = tree.DecisionTreeClassifier(max_depth=2) #定义分类器
  79. pipeline = PMMLPipeline([("classifier", clf)]) #定义pipeline
  80. pipeline.fit(X_train, y_train) #此处使用带columns变量名称的dataframe进行模型训练
  82. #模型导出为PMML
  83. from sklearn2pmml import sklearn2pmml
  84. sklearn2pmml(pipeline, "d:\\DecisionTree_Iris_sklearn2pmml.pmml", with_repr = True) #生成PMML时带变量名
  87. # 方法二：使用nyoka包导出模型PMML文件
  89. #导入相关包
  90. from sklearn.datasets import load_iris
  91. from sklearn.tree import DecisionTreeClassifier
  92. from sklearn2pmml import PMMLPipeline
  94. #读入数据
  95. iris = load_iris()
  96. features = iris.feature_names
  97. target = 'Species'
  99. #创建pipeline并训练模型
  100. clf_pipeline=PMMLPipeline([('clf',DecisionTreeClassifier(max_depth=2))])
  101. clf_pipeline.fit(iris.data, iris.target) #此处训练模型时用的是数组不带变量名称
  103. #使用nyoka将模型导出为pmml
  104. from nyoka import skl_to_pmml
  105. skl_to_pmml(clf_pipeline, features, target, "d:\\DecisionTree_iris_nyoka.pmml") #生成PMML时带变量名
  108. #------------------------------------------------------------------------------
  109. # 本地加载和使用PMML模型文件
  111. #加载pmml
  112. from pypmml import Model
  113. model = Model.fromFile("d:\\DecisionTree_Iris_sklearn2pmml.pmml")
  115. #使用PMML的模型打分，整个数据集
  116. y_train_pred=model.predict(X_train) #注：此处待打分的DataFrame是否带变量名称须与训练模型PMML时保持一致
  118. #使用PMML的模型打分，单条记录
  119. model.predict({'sepal_length': 5.1, 'sepal_width': 3.5, 'petal_length': 1.4, 'petal_width': 0.2})
  120. model.predict('[{"sepal_length": 5.1, "sepal_width": 3.5, "petal_length": 1.4, "petal_width": 0.2}]')
  121. model.predict('{"columns": ["sepal_length", "sepal_width", "petal_length", "petal_width"], "data": [[5.1, 3.5, 1.4, 0.2]]}')
  122. model.predict(pd.Series({'sepal_length': 5.1, 'sepal_width': 3.5, 'petal_length': 1.4, 'petal_width': 0.2}))
  125. #------------------------------------------------------------------------------
  126. # 下面代码使用FastAPI包实现在服务器部署模型
  129. # （1）首先将下面代码保存在服务器端，命名为main.py，然后在服务器端执行命令行：先定位到main.py目录，然后执行：uvicorn main:app –-reload
  131. #导入相关包和模块
  132. from fastapi import FastAPI
  133. from pypmml import Model
  135. #定义FastAPI对象
  136. app = FastAPI()
  138. @app.get("/items/{item_id}")
  139. async def read_item(item_id: int, x: str=''):
  141.     #读取模型PMML
  142.     mdl = Model.fromFile("d:\\DecisionTree_Iris_sklearn2pmml.pmml")
  144.     #将读入的字符串x输入predict函数得到预测结果
  145.     y_predict=mdl.predict(x)
  147.     #将计算结果返回给客户端
  148.     return {"item_id": item_id, "x":x, "y_predict": y_predict}
  151. # （2）客户端执行如下代码，在服务器模式下执行时将127.0.0.1替换为服务器IP地址
  152. URL_str='http://127.0.0.1:8000/items/5?x='+'[{"sepal_length":5.1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}]'
  153. res=requests.get(URL_str)
  154. returnjson=res.text
  155. print(returnjson)
  160. #------------------------------------------------------------------------------
  161. # 下面代码使用Flask包实现在服务器部署模型
  163. # （1）首先将下面代码保存在服务器端，命名为main.py，然后在服务器端执行命令行：python main.py
  165. #导入相关包和模块
  166. import numpy as np
  167. import pandas as pd
  169. from pypmml import Model
  171. from flask import Flask
  172. from flask import request
  173. from flask import jsonify
  176. #导入模型
  177. model = Model.fromFile("d:\\DecisionTree_Iris_sklearn2pmml.pmml")
  179. app = Flask(__name__)
  181. @app.route('/',methods=['POST','GET'])
  182. def scoring():
  183.     text=request.args.get('inputdata')
  184.     if text:
  185.         temp =  [float(x) for x in text.split(',')]
  186.         temp = pd.DataFrame(data=np.array(temp).reshape((1, -1)),columns=["sepal_length", "sepal_width", "petal_length", "petal_width"])
  187.         ouputdata = model.predict(temp)    #outputdata是DataFrame格式
  188.         return jsonify(dict(ouputdata.iloc[0])) #进行json化
  190. if __name__ == '__main__':
  191.     app.config['JSON_AS_ASCII'] = False
  192.     app.run(host='127.0.0.1',port=5003)  # 127.0.0.1 #指的是本地ip
  195. # （2）客户端执行如下代码，在服务器模式下执行时将127.0.0.1替换为服务器IP地址
  197. import requests
  199. base = 'http://127.0.0.1:5003/?inputdata=5.1,3.5,1.4,2'
  200. response = requests.get(base)
  201. print(response.text)
  202. answer = response.json()
  203. print('预测结果',answer)

评分卡模型可解释性_20211018

  1. #------------------------------------------------------------------------------
  2. """
  3. 功能说明：
  4.     本代码是第13章评分卡模型可解释性配套代码。
  5. 算法流程：  
  6.     - PDP与ICE
  7.     - 变量重要性方法：XGBoost和LightGBM的plot_importance
  8.     - SKlearn模型解释工具treeinterpreter包
  9.     - 特征随机置换Permutation Importance，使用eli5包
  10.     - LIME
  11.     - SHAP
  12. 输入数据：
  13.     使用代码自带数据，无需额外的外部数据
  14. 输出数据：
  15.     各代码段输出相应结果变量
  16. 版本历史：
  17.     20211018：定稿提交出版
  18. """
  21. #------------------------------------------------------------------------------
  22. # 导入相关包和模块
  24. import numpy as np
  25. import pandas as pd
  26. import matplotlib.pyplot as plt
  28. from sklearn.datasets import load_boston
  29. from sklearn.datasets import fetch_california_housing
  31. from sklearn.tree import DecisionTreeClassifier #分类
  32. from sklearn.tree import DecisionTreeRegressor #回归
  33. from sklearn.ensemble import RandomForestRegressor #随机森林
  34. from sklearn.model_selection import train_test_split
  35. from sklearn.metrics import accuracy_score
  38. #------------------------------------------------------------------------------
  39. # PDP与ICE
  40. """
  41. PDP方法有两个工具包可用：
  42. —— sklearn.inspection
  43. —— pdpbox
  44. """
  46. #读入数据
  47. from sklearn.datasets import fetch_california_housing
  49. cal_housing=fetch_california_housing()
  50. X=pd.DataFrame(cal_housing.data, columns=cal_housing.feature_names)
  51. y=cal_housing.target
  52. X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3,random_state=0)
  55. #训练模型
  56. from sklearn.ensemble import GradientBoostingRegressor
  57. gbdt=GradientBoostingRegressor()
  58. gbdt.fit(X_train,y_train)
  61. #方法一：使用sklearn.inspection进行PDP分析
  62. from sklearn.inspection import plot_partial_dependence
  63. fig,ax=plt.subplots(figsize=(12,4))
  64. plot_partial_dependence(gbdt,
  65.                         X_train,
  66.                         ['MedInc','AveOccup','HouseAge'],
  67.                         method="brute",
  68.                         ax=ax)
  70. #也可以输出三维图形，考察两个变量间的交互性
  71. fig,ax=plt.subplots(figsize=(9,6))
  72. plot_partial_dependence(gbdt,
  73.                         X_train,
  74.                         [('HouseAge','AveOccup')],
  75.                         grid_resolution=50,
  76.                         method="brute",
  77.                         ax=ax)
  80. #方法二：使用pdpbox包
  81. from pdpbox import pdb
  82. pdp_MedInc=pdp.pdp_isolate(model=gbdt,
  83.                            dataset=X_train,
  84.                            model_features=X_train.columns.tolist(),
  85.                            feature='MedInc',
  86.                            num_grid_points=30)
  88. pdb.pdp_plot(pdp_MedInc,
  89.              'MedInc',
  90.              center=False
  91.              )
  93. #使用pdpbox包绘制单实例ICE图
  94. pdb.pdp_plot(pdp_MedInc,
  95.              'MedInc',
  96.              center=False,
  97.              plot_lines=True,
  98.              frac_to_plot=10,
  99.              plot_pts_dist=True)
  104. #------------------------------------------------------------------------------
  105. #变量重要性方法：XGBoost和LightGBM的plot_importance
  107. #导入包
  108. from sklearn.datasets import load_boston
  110. import xgboost as xgb
  111. import lightgbm as lgb
  114. #读取数据
  115. ds=load_boston()
  116. df=pd.DataFrame(data=ds.data)
  117. df=df.add_prefix('X')
  118. df=df.join(pd.DataFrame(ds.target,columns=['y']))
  121. #定义xgb预测器
  122. clf=xgb.XGBRegressor()
  123. clf.get_params()
  125. #拟合模型
  126. clf.fit(df.iloc[:,0:13],df.iloc[:,-1])
  128. #模型评估
  129. clf.score(df.iloc[:,0:13],df.iloc[:,-1])
  131. #打印变量重要性
  132. xgb.plot_importance(clf,importance_type='gain')
  135. #定义ligbm预测器
  136. lgbdata=lgb.Dataset(df.iloc[:,0:13],df.iloc[:,-1])
  137. # 将参数写成字典下形式
  138. params = {
  139.     'task': 'train',
  140.     'boosting_type': 'gbdt',  # 设置提升类型
  141.     'objective': 'regression', # 目标函数
  142.     'metric': {'l2', 'auc'},  # 评估函数
  143.     'num_leaves': 31,   # 叶子节点数
  144.     'learning_rate': 0.05,  # 学习速率
  145.     'feature_fraction': 0.9, # 建树的特征选择比例
  146.     'bagging_fraction': 0.8, # 建树的样本采样比例
  147.     'bagging_freq': 5,  # k 意味着每 k 次迭代执行bagging
  148.     'verbose': 1 # <0 显示致命的, =0 显示错误 (警告), >0 显示信息
  149. }
  150. clf_lgb=lgb.train(params,lgbdata)
  152. #绘制模型重要性
  153. clf_lgb.feature_importance()
  154. plt.bar(height=clf_lgb.feature_importance(),x=df.iloc[:,0:13].columns)
  159. #------------------------------------------------------------------------------
  160. # SKlearn模型解释工具treeinterpreter包
  162. #导入treeinterpreter包
  163. from treeinterpreter import treeinterpreter as ti
  165. #加载数据
  166. ds=load_boston()
  168. #定义分类器
  169. rf=RandomForestRegressor(random_state=123)
  170. #拟合模型
  171. rf.fit(ds.data,ds.target)
  173. #取出一个样本
  174. spl=ds.data[0].reshape(1,-1)
  175. #使用模型打分
  176. rf.predict(spl)
  178. #使用treeinterpreter解释，prediction是预测值，bias是全体样本Y平均值
  179. prediction,bias,contributions=ti.predict(rf,spl)
  181. #各变量的contributions
  182. df_contributions=pd.DataFrame(data=np.hstack([ds.feature_names.reshape(-1,1),
  183.                                             contributions.reshape(-1,1)]),
  184.                             columns=['Feature','contribution'])
  185. df_contributions.sort_values(by=['contribution'],ascending=False)
  187. #验证计算逻辑
  188. print(ds.target.mean()) #全体样本目标真实值平均值
  189. print(rf.predict(ds.data).mean()) #rf预测值平均值
  190. print(rf.predict(spl))
  191. print(prediction)
  192. print(bias)
  193. print(prediction-np.sum(contributions))  #prediction是bias和每个变量贡献的总和
  198. #------------------------------------------------------------------------------
  199. #特征随机置换Permutation Importance，使用eli5包
  201. #导入包
  202. from sklearn.datasets import load_boston
  203. from sklearn.ensemble import RandomForestRegressor #随机森林
  205. import eli5
  206. from eli5.sklearn import PermutationImportance
  209. #加载数据
  210. ds=load_boston()
  212. #定义分类器
  213. rf=RandomForestRegressor(random_state=123)
  214. #拟合模型
  215. rf.fit(pd.DataFrame(ds.data,columns=ds.feature_names),ds.target)
  216. rf.feature_importances_
  219. #计算置换变量值重要性
  220. perm=PermutationImportance(rf).fit(pd.DataFrame(ds.data,columns=ds.feature_names),ds.target)
  221. df_perm=pd.DataFrame(data=np.hstack([ds.feature_names.reshape(-1,1),
  222.                                      perm.feature_importances_.reshape(-1,1).round(4),
  223.                                      perm.feature_importances_std_.reshape(-1,1).round(4)]),
  224.                     columns=['Feature','mean','std'])
  225. df_perm.sort_values(by=['mean'],ascending=False,inplace=True)
  228. #查看置换变量重要性绘图，本段代码只能在notebook中查看
  229. eli5.show_weights(perm,feature_names=ds.feature_names) 
  234. #------------------------------------------------------------------------------
  235. #LIME
  237. #导入包
  238. import numpy as np
  239. import pandas as pd
  240. import matplotlib.pyplot as plt
  242. from sklearn.datasets import load_boston
  243. from sklearn.ensemble import RandomForestRegressor #随机森林
  244. from sklearn.model_selection import train_test_split
  246. import lime
  247. import lime.lime_tabular
  250. #加载数据
  251. ds=load_boston()
  253. #定义分类器
  254. rf=RandomForestRegressor(random_state=123)
  255. #拟合模型
  256. rf.fit(ds.data,ds.target)
  259. #取值水平数小于10的视作分类变量
  260. categorical_features=np.argwhere(np.array([len(set(ds.data[:,1])) for i in range(ds.data.shape[1])])<=10).flatten()
  263. #创建解释器
  264. explainer=lime.lime_tabular.LimeTabularExplainer(
  265.         ds.data,
  266.         feature_names=ds.feature_names,
  267.         class_names=['house_price'],
  268.         categorical_features=None,
  269.         verbose=True,
  270.         mode='regression'
  271.         )
  273. #选取一个样本
  274. spl=ds.data[0]
  275. #生成模型解释结果
  276. exp=explainer.explain_instance(
  277.         spl,
  278.         rf.predict,
  279.         num_features=5
  280.         )
  281. #输出各变量的贡献
  282. exp.as_list()
  283. #进行可视化，本段代码只能在Jupyter notebook中查看
  284. exp.show_in_notebook(show_table=True)
  289. #------------------------------------------------------------------------------
  290. # SHAP
  292. #导入包
  293. import numpy as np
  294. import pandas as pd
  295. import matplotlib.pyplot as plt
  297. from sklearn.datasets import load_boston
  298. from sklearn.ensemble import RandomForestRegressor
  300. import shap
  302. #初始化图形环境
  303. shap.initjs()
  305. #加载数据
  306. ds=load_boston()
  307. #取出一个样本作为下文单样本SHAP的实例
  308. spl=ds.data[0].reshape(1,-1)
  310. #定义基准分类器
  311. rf=RandomForestRegressor(random_state=123)
  312. #拟合模型
  313. rf.fit(ds.data,ds.target)
  316. #定义shap树解释器
  317. explainer=shap.TreeExplainer(rf,data=ds.data)
  319. #训练集上全体样本预测均值作为基准值
  320. explainer.expected_value  #22.28338
  324. #------------------------------------
  325. #该单样本上各变量的SHAP值
  326. splshapvalues=explainer.shap_values(spl).round(4)
  328. df_splshapvalues=pd.DataFrame(data=np.hstack([ds.feature_names.reshape(-1,1),
  329.                                             splshapvalues.reshape(-1,1),
  330.                                             abs(splshapvalues).reshape(-1,1)]),
  331.                             columns=['Feature','shap','shapabs'])
  332. df_splshapvalues.sort_values(by=['shapabs'],ascending=False,inplace=True)  #按SHAP绝对值降序排列
  333. df_splshapvalues.drop(['shapabs'],axis=1,inplace=True) #df_splshapvalues是纵表存储
  334. df_splshapvaluescol=pd.DataFrame(data=splshapvalues,columns=ds.feature_names) #df_splshapvaluescol是横表存储
  336. df_splshapvalues #显示单样本各变量shap值
  339. #该单样本上验证计算逻辑
  340. ds.target.mean()  #全体样本真实值均值 22.533
  341. rf.predict(ds.data).mean() #全体样本rf预测值均值 22.535
  343. explainer.expected_value  #Shap计算基准值即全体样本rf预测值均值22.28338
  344. rf.predict(spl) #给定样本预测值 25.421
  345. rf.predict(spl)-splshapvalues.sum() #22.2835 约等于explainer.expected_value
  348. #查看单样本shap值绘图，本段代码只能在notebook中查看
  349. shap.force_plot(explainer.expected_value,
  350.                 splshapvalues,
  351.                 features=spl,
  352.                 feature_names=ds.feature_names)
  356. #------------------------------------
  357. #样本集上各变量的SHAP值
  358. shapvalues=explainer.shap_values(ds.data)
  360. #查看样本集上shap值绘图，本段代码只能在Jupyter notebook中查看
  361. shap.force_plot(explainer.expected_value,
  362.                 shapvalues,
  363.                 features=ds.data,
  364.                 feature_names=ds.feature_names)
  366. #绘制决策路径图，本段代码只能在Jupyter notebook中查看
  367. shap.decision_plot(explainer.expected_value,
  368.                    shapvalues[:12],
  369.                    ds.feature_names)
  371. #绘制特征依赖图，本段代码只能在Jupyter notebook中查看
  372. shap.dependence_plot(ds.feature_names.tolist().index('LSTAT'),
  373.                      shapvalues,
  374.                      ds.data)
  376. #全局特征重要性，本段代码只能在Jupyter notebook中查看
  377. shap.summary_plot(shapvalues,
  378.                   ds.data,
  379.                   feature_names=ds.feature_names,
  380.                   max_display=5)
  381. #以柱状图方式展示各变量SHAP绝对值平均值
  382. shap.summary_plot(shapvalues,
  383.                   feature_names=ds.feature_names,
  384.                   plot_type='bar',
  385.                   max_display=5)

从评分卡模型到高维机器学习模型_20211018

  1. #------------------------------------------------------------------------------
  2. """
  3. 功能说明：
  4.     本代码是第15章从评分卡模型到高维机器学习模型配套代码。
  5. 算法流程：
  6.     - 使用XGBoost建立预测模型
  7.     - 使用LightGBM建立预测模型
  8. 输入数据：
  9.     使用代码自带数据，无需额外的外部数据
  10. 输出数据：
  11.     各代码段输出相应结果变量
  12. 版本历史：
  13.     20211018：定稿提交出版
  14. """
  16. #------------------------------------------------------------------------------
  17. # 使用XGBoost建立预测模型
  19. #导入库包
  20. import pandas as pd
  22. from sklearn.datasets import load_breast_cancer #乳腺癌数据，Target：二分类
  23. from sklearn.model_selection import train_test_split
  24. from sklearn.metrics import accuracy_score
  25. from sklearn.metrics import roc_auc_score
  26. from sklearn.metrics import roc_curve
  27. from sklearn.metrics import precision_recall_curve
  28. from sklearn.metrics import plot_precision_recall_curve
  29. from sklearn.metrics import plot_roc_curve
  31. import xgboost
  32. from xgboost import XGBClassifier
  34. #准备数据
  35. ds_cancer = load_breast_cancer()
  36. data = pd.DataFrame(data=ds_cancer.data,columns=ds_cancer.feature_names)
  37. target = pd.DataFrame(data=ds_cancer.target,columns=['target'])
  39. #数据分区
  40. X_train,X_test,y_train,y_test =train_test_split(data,target,test_size=0.3)
  42. #定义XGBoost模型
  43. xgb = XGBClassifier(n_estimators=3, max_depth=2)
  45. #显示模型参数
  46. xgb.get_params()
  48. #模型拟合
  49. xgb.fit(X_train, y_train)
  51. #获得模型对象的属性和方法
  52. xgb.score(X_train, y_train)
  53. xgb.feature_importances_ 
  55. #模型预测
  56. y_train_predict=xgb.predict(X_train)
  57. y_train_predict_proba=xgb.predict_proba(X_train)
  59. #模型评估
  60. accuracy_score(y_train,y_train_predict) #Accuracy指标基于真实标签vs预测标签
  61. roc_auc_score(y_train, y_train_predict_proba[:,1]) #AUC指标基于真实标签vs预测概率
  62. plot_roc_curve(xgb,X_train,y_train) #绘制ROC曲线
  63. plot_precision_recall_curve(xgb,X_train,y_train) #绘制PR曲线
  65. #打印变量重要性
  66. xgboost.plot_importance(xgb) 
  72. #------------------------------------------------------------------------------
  73. # 使用LightGBM建立预测模型
  75. #导入库包
  76. import pandas as pd
  77. import matplotlib.pyplot as plt
  79. from sklearn.datasets import load_breast_cancer #乳腺癌数据，Target：二分类
  80. from sklearn.model_selection import train_test_split
  81. from sklearn.metrics import accuracy_score
  82. from sklearn.metrics import roc_auc_score
  83. from sklearn.metrics import roc_curve
  84. from sklearn.metrics import precision_recall_curve
  85. from sklearn.metrics import plot_precision_recall_curve
  86. from sklearn.metrics import plot_roc_curve
  88. import lightgbm as lgb
  89. from lightgbm import LGBMClassifier
  92. # 准备数据
  93. ds_cancer = load_breast_cancer()
  94. data = pd.DataFrame(data=ds_cancer.data,columns=ds_cancer.feature_names)
  95. target = pd.DataFrame(data=ds_cancer.target,columns=['target'])
  97. #数据分区
  98. X_train,X_test,y_train,y_test =train_test_split(data,target,test_size=0.3)
  100. #定义分类器
  101. lgbm = LGBMClassifier(boosting_type="gbdt", class_weight=None, colsample_bytree=0.7, 
  102.                                  isunbalance=True, learning_rate=0.01, max_bin=15, 
  103.                                  max_depth=1, min_child_samples=100, min_child_weight=1, 
  104.                                  min_split_gain=0.04, n_estimators=100, num_leaves=32, 
  105.                                  objective="binary", random_state=27, subsample=0.8, subsample_freq=1)
  107. #显示模型对象参数
  108. lgbm.get_params()
  110. #拟合模型
  111. lgbm.fit(X_train,y_train)
  114. #获得模型对象的属性
  115. lgbm.classes_
  116. lgbm.feature_importances_
  117. lgbm.n_classes_
  118. lgbm.n_features_
  119. lgbm.objective_
  122. #模型预测
  123. y_train_predict=lgbm.predict(X_train)
  124. y_train_predict_proba=lgbm.predict_proba(X_train)
  127. #模型评估
  128. fpr,tpr,pct = roc_curve(y_train, y_train_predict_proba[:,1]) #ROC曲线计算FPR和TPR序列值
  129. ks=abs(fpr-tpr).max() #KS指标
  130. plt.plot(tpr,"b-",fpr,"r-") #KS曲线
  131. accuracy_score(y_train,y_train_predict) #Accuracy指标基于真实标签vs预测标签
  132. roc_auc_score(y_train, y_train_predict_proba[:,1]) #AUC指标基于真实标签vs预测概率
  133. plot_precision_recall_curve(lgbm,X_train,y_train) #绘制PR曲线
  134. plot_roc_curve(lgbm,X_train,y_train) #绘制ROC曲线
  136. #调用lightGBM函数绘制相关图
  137. lgb.create_tree_digraph(lgbm,tree_index=1)
  138. lgb.plot_importance(lgbm)
  139. lgb.plot_tree(lgbm,tree_index=1,figsize=(12,9))