当前位置：网站首页>【机器学习】随机森林、GBDT、XGBoost、LightGBM等集成学习代码练习

【机器学习】随机森林、GBDT、XGBoost、LightGBM等集成学习代码练习

2022-08-09 07:17:00 【51CTO】

本文是中国大学慕课《机器学习》的“集成学习”章节的课后代码。
课程地址：
https://www.icourse163.org/course/WZU-1464096179
课程完整代码：
https://github.com/fengdu78/WZU-machine-learning-course
代码修改并注释：黄海广，[email protected]

       
       import 
       
       warnings
       
       warnings
       
       .
       
       filterwarnings(
       
       "ignore")
       
       import 
       
       pandas 
       
       as 
       
       pd
       
       from 
       
       sklearn
       
       .
       
       model_selection 
       
       import 
       
       train_test_split
      
1.
2.
3.
4.

生成数据

生成12000行的数据，训练集和测试集按照3:1划分

       
       from 
       
       sklearn
       
       .
       
       datasets 
       
       import 
       
       make_hastie_10_2
       
       data, 
       
       target 
       
       = 
       
       make_hastie_10_2()
      
1.
2.
3.

       
       X_train, 
       
       X_test, 
       
       y_train, 
       
       y_test 
       
       = 
       
       train_test_split(
       
       data, 
       
       target, 
       
       random_state
       
       =
       
       123)
       
       X_train
       
       .
       
       shape, 
       
       X_test
       
       .
       
       shape
      
1.
2.

模型对比

对比六大模型，都使用默认参数，因为数据是

       
       from 
       
       sklearn
       
       .
       
       linear_model 
       
       import 
       
       LogisticRegression
       
       from 
       
       sklearn
       
       .
       
       ensemble 
       
       import 
       
       RandomForestClassifier
       
       from 
       
       sklearn
       
       .
       
       ensemble 
       
       import 
       
       AdaBoostClassifier
       
       from 
       
       sklearn
       
       .
       
       ensemble 
       
       import 
       
       GradientBoostingClassifier
       
       from 
       
       xgboost 
       
       import 
       
       XGBClassifier
       
       from 
       
       lightgbm 
       
       import 
       
       LGBMClassifier
       
       from 
       
       sklearn
       
       .
       
       model_selection 
       
       import 
       
       cross_val_score
       
       import 
       
       time
       
       clf1 
       
       = 
       
       LogisticRegression()
       
       clf2 
       
       = 
       
       RandomForestClassifier()
       
       clf3 
       
       = 
       
       AdaBoostClassifier()
       
       clf4 
       
       = 
       
       GradientBoostingClassifier()
       
       clf5 
       
       = 
       
       XGBClassifier()
       
       clf6 
       
       = 
       
       LGBMClassifier()
       
       for 
       
       clf, 
       
       label 
       
       in 
       
       zip([
       
       clf1, 
       
       clf2, 
       
       clf3, 
       
       clf4, 
       
       clf5, 
       
       clf6], [
       
       'Logistic Regression', 
       
       'Random Forest', 
       
       'AdaBoost', 
       
       'GBDT', 
       
       'XGBoost',
       
       'LightGBM'
       
]):
       
       start 
       
       = 
       
       time
       
       .
       
       time()
       
       scores 
       
       = 
       
       cross_val_score(
       
       clf, 
       
       X_train, 
       
       y_train, 
       
       scoring
       
       =
       
       'accuracy', 
       
       cv
       
       =
       
       5)
       
       end 
       
       = 
       
       time
       
       .
       
       time()
       
       running_time 
       
       = 
       
       end 
       
       - 
       
       start
       
       print(
       
       "Accuracy: %0.8f (+/- %0.2f),耗时%0.2f秒。模型名称[%s]" 
       
       %
       
          (
       
       scores
       
       .
       
       mean(), 
       
       scores
       
       .
       
       std(), 
       
       running_time, 
       
       label))
      
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.

       
       Accuracy: 
       
       0
       
       .47488889 (
       
       +/- 
       
       0
       
       .00),
       
       耗时0
       
       .04
       
       秒。模型名称[
       
       Logistic 
       
       Regression]
       
       Accuracy: 
       
       0
       
       .88966667 (
       
       +/- 
       
       0
       
       .01),
       
       耗时16
       
       .34
       
       秒。模型名称[
       
       Random 
       
       Forest]
       
       Accuracy: 
       
       0
       
       .88311111 (
       
       +/- 
       
       0
       
       .00),
       
       耗时3
       
       .39
       
       秒。模型名称[
       
       AdaBoost]
       
       Accuracy: 
       
       0
       
       .91388889 (
       
       +/- 
       
       0
       
       .01),
       
       耗时13
       
       .14
       
       秒。模型名称[
       
       GBDT]
       
       Accuracy: 
       
       0
       
       .92977778 (
       
       +/- 
       
       0
       
       .00),
       
       耗时3
       
       .60
       
       秒。模型名称[
       
       XGBoost]
       
       Accuracy: 
       
       0
       
       .93188889 (
       
       +/- 
       
       0
       
       .01),
       
       耗时0
       
       .58
       
       秒。模型名称[
       
       LightGBM]
      
1.
2.
3.
4.
5.
6.

对比了六大模型，可以看出，逻辑回归速度最快，但准确率最低。而LightGBM，速度快，而且准确率最高，所以，现在处理结构化数据的时候，大部分都是用LightGBM算法。

XGBoost的使用

1.原生XGBoost的使用

       
       import 
       
       xgboost 
       
       as 
       
       xgb
       
       #记录程序运行时间
       
       import 
       
       time
       
       start_time 
       
       = 
       
       time
       
       .
       
       time()
       
       #xgb矩阵赋值
       
       xgb_train 
       
       = 
       
       xgb
       
       .
       
       DMatrix(
       
       X_train, 
       
       y_train)
       
       xgb_test 
       
       = 
       
       xgb
       
       .
       
       DMatrix(
       
       X_test, 
       
       label
       
       =
       
       y_test)
       
       #
       
       #参数
       
       params 
       
       = {
       
       'booster': 
       
       'gbtree',
       
       #     
       
       'silent': 
       
       1,  
       
       #设置成1则没有运行信息输出，最好是设置为0
       
       .
       
       #
       
       'nthread':
       
       7,
       
       # 
       
       cpu 
       
       线程数 
       
       默认最大
       
       'eta': 
       
       0
       
       .007,  
       
       # 
       
       如同学习率
       
       'min_child_weight': 
       
       3,
       
       # 
       
       这个参数默认是 
       
       1
       
       ，是每个叶子里面 
       
       h 
       
       的和至少是多少，对正负样本不均衡时的 
       
       0
       
       -
       
       1 
       
       分类而言
       
       #，假设 
       
       h 
       
       在 
       
       0
       
       .01 
       
       附近，min_child_weight 
       
       为 
       
       1 
       
       意味着叶子节点中最少需要包含 
       
       100 
       
       个样本。
       
       #这个参数非常影响结果，控制叶子节点中二阶导的和的最小值，该参数值越小，越容易 
       
       overfitting。
       
       'max_depth': 
       
       6,  
       
       # 
       
       构建树的深度，越大越容易过拟合
       
       'gamma': 
       
       0
       
       .1,  
       
       # 
       
       树的叶子节点上作进一步分区所需的最小损失减少,
       
       越大越保守，一般0
       
       .1
       
       、0
       
       .2
       
       这样子。
       
       'subsample': 
       
       0
       
       .7,  
       
       # 
       
       随机采样训练样本
       
       'colsample_bytree': 
       
       0
       
       .7,  
       
       # 
       
       生成树时进行的列采样 
       
       'lambda': 
       
       2,  
       
       # 
       
       控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
       
       #
       
       'alpha':
       
       0, 
       
       # 
       
       L1 
       
       正则项参数
       
       #
       
       'scale_pos_weight':
       
       1, 
       
       #如果取值大于0的话，在类别样本不平衡的情况下有助于快速收敛。
       
       #
       
       'objective': 
       
       'multi:softmax', 
       
       #多分类的问题
       
       #
       
       'num_class':
       
       10, 
       
       # 
       
       类别数，多分类与 
       
       multisoftmax 
       
       并用
       
       'seed': 
       
       1000,  
       
       #随机种子
       
       #
       
       'eval_metric': 
       
       'auc'
       
}
       
       plst 
       
       = 
       
       list(
       
       params
       
       .
       
       items())
       
       num_rounds 
       
       = 
       
       500  
       
       # 
       
       迭代次数
       
       watchlist 
       
       = [(
       
       xgb_train, 
       
       'train'), (
       
       xgb_test, 
       
       'val')]
      
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.
34.

       
       #训练模型并保存
       
       # 
       
       early_stopping_rounds 
       
       当设置的迭代次数较大时，early_stopping_rounds 
       
       可在一定的迭代次数内准确率没有提升就停止训练
       
       model 
       
       = 
       
       xgb
       
       .
       
       train(
       
       plst,
       
       xgb_train,
       
       num_rounds,
       
       watchlist,
       
       early_stopping_rounds
       
       =
       
       100,
       
)
       
       #model
       
       .
       
       save_model(
       
       './model/xgb.model') 
       
       # 
       
       用于存储训练出的模型
       
       print(
       
       "best best_ntree_limit", 
       
       model
       
       .
       
       best_ntree_limit)
       
       y_pred 
       
       = 
       
       model
       
       .
       
       predict(
       
       xgb_test, 
       
       ntree_limit
       
       =
       
       model
       
       .
       
       best_ntree_limit)
       
       print(
       
       'error=%f' 
       
       %
       
      (
       
       sum(
       
       1
       
       for 
       
       i 
       
       in 
       
       range(
       
       len(
       
       y_pred)) 
       
       if 
       
       int(
       
       y_pred[
       
       i] 
       
       > 
       
       0
       
       .5) 
       
       != 
       
       y_test[
       
       i]) 
       
       /
       
       float(
       
       len(
       
       y_pred))))
       
       # 
       
       输出运行时长
       
       cost_time 
       
       = 
       
       time
       
       .
       
       time() 
       
       - 
       
       start_time
       
       print(
       
       "xgboost success!", 
       
       '\n', 
       
       "cost time:", 
       
       cost_time, 
       
       "(s)......")
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

……

       
       [
       
       497]    
       
       train
       
       -
       
       rmse:
       
       0
       
       .62135    
       
       val
       
       -
       
       rmse:
       
       0
       
       .68680
       
[
       
       498]    
       
       train
       
       -
       
       rmse:
       
       0
       
       .62096    
       
       val
       
       -
       
       rmse:
       
       0
       
       .68650
       
[
       
       499]    
       
       train
       
       -
       
       rmse:
       
       0
       
       .62056    
       
       val
       
       -
       
       rmse:
       
       0
       
       .68624
       
       best 
       
       best_ntree_limit 
       
       500
       
       error
       
       =
       
       0
       
       .826667
       
       xgboost 
       
       success
       
       ! 
       
       cost 
       
       time: 
       
       3.5742645263671875 (
       
       s)
       
       .
       
       .
       
       .
       
       .
       
       .
       
       .
      
1.
2.
3.
4.
5.
6.
7.

2.使用scikit-learn接口

会改变的函数名是：

eta -> learning_rate

lambda -> reg_lambda

alpha -> reg_alpha

       
       from 
       
       sklearn
       
       .
       
       model_selection 
       
       import 
       
       train_test_split
       
       from 
       
       sklearn 
       
       import 
       
       metrics
       
       from 
       
       xgboost 
       
       import 
       
       XGBClassifier
       
       clf 
       
       = 
       
       XGBClassifier(
       
       #     
       
       silent
       
       =
       
       0,  
       
       #设置成1则没有运行信息输出，最好是设置为0
       
       .
       
       是否在运行升级时打印消息。
       
       #nthread
       
       =
       
       4,
       
       # 
       
       cpu 
       
       线程数 
       
       默认最大
       
       learning_rate
       
       =
       
       0
       
       .3,  
       
       # 
       
       如同学习率
       
       min_child_weight
       
       =
       
       1,
       
       # 
       
       这个参数默认是 
       
       1
       
       ，是每个叶子里面 
       
       h 
       
       的和至少是多少，对正负样本不均衡时的 
       
       0
       
       -
       
       1 
       
       分类而言
       
       #，假设 
       
       h 
       
       在 
       
       0
       
       .01 
       
       附近，min_child_weight 
       
       为 
       
       1 
       
       意味着叶子节点中最少需要包含 
       
       100 
       
       个样本。
       
       #这个参数非常影响结果，控制叶子节点中二阶导的和的最小值，该参数值越小，越容易 
       
       overfitting。
       
       max_depth
       
       =
       
       6,  
       
       # 
       
       构建树的深度，越大越容易过拟合
       
       gamma
       
       =
       
       0,  
       
       # 
       
       树的叶子节点上作进一步分区所需的最小损失减少,
       
       越大越保守，一般0
       
       .1
       
       、0
       
       .2
       
       这样子。
       
       subsample
       
       =
       
       1,  
       
       # 
       
       随机采样训练样本 
       
       训练实例的子采样比
       
       max_delta_step
       
       =
       
       0,  
       
       #最大增量步长，我们允许每个树的权重估计。
       
       colsample_bytree
       
       =
       
       1,  
       
       # 
       
       生成树时进行的列采样 
       
       reg_lambda
       
       =
       
       1,  
       
       # 
       
       控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
       
       #reg_alpha
       
       =
       
       0, 
       
       # 
       
       L1 
       
       正则项参数
       
       #scale_pos_weight
       
       =
       
       1, 
       
       #如果取值大于0的话，在类别样本不平衡的情况下有助于快速收敛。平衡正负权重
       
       #objective
       
       = 
       
       'multi:softmax', 
       
       #多分类的问题 
       
       指定学习任务和相应的学习目标
       
       #num_class
       
       =
       
       10, 
       
       # 
       
       类别数，多分类与 
       
       multisoftmax 
       
       并用
       
       n_estimators
       
       =
       
       100,  
       
       #树的个数
       
       seed
       
       =
       
       1000  
       
       #随机种子
       
       #eval_metric
       
       = 
       
       'auc'
       
)
       
       clf
       
       .
       
       fit(
       
       X_train, 
       
       y_train)
       
       y_true, 
       
       y_pred 
       
       = 
       
       y_test, 
       
       clf
       
       .
       
       predict(
       
       X_test)
       
       print(
       
       "Accuracy : %.4g" 
       
       % 
       
       metrics
       
       .
       
       accuracy_score(
       
       y_true, 
       
       y_pred))
      
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.

LIghtGBM的使用

1.原生接口

       
       import 
       
       lightgbm 
       
       as 
       
       lgb
       
       from 
       
       sklearn
       
       .
       
       metrics 
       
       import 
       
       mean_squared_error
       
       # 
       
       加载你的数据
       
       # 
       
       print(
       
       'Load data...')
       
       # 
       
       df_train 
       
       = 
       
       pd
       
       .
       
       read_csv(
       
       '../regression/regression.train', 
       
       header
       
       =
       
       None, 
       
       sep
       
       =
       
       '\t')
       
       # 
       
       df_test 
       
       = 
       
       pd
       
       .
       
       read_csv(
       
       '../regression/regression.test', 
       
       header
       
       =
       
       None, 
       
       sep
       
       =
       
       '\t')
       
       #
       
       # 
       
       y_train 
       
       = 
       
       df_train[
       
       0]
       
       .
       
       values
       
       # 
       
       y_test 
       
       = 
       
       df_test[
       
       0]
       
       .
       
       values
       
       # 
       
       X_train 
       
       = 
       
       df_train
       
       .
       
       drop(
       
       0, 
       
       axis
       
       =
       
       1)
       
       .
       
       values
       
       # 
       
       X_test 
       
       = 
       
       df_test
       
       .
       
       drop(
       
       0, 
       
       axis
       
       =
       
       1)
       
       .
       
       values
       
       # 
       
       创建成lgb特征的数据集格式
       
       lgb_train 
       
       = 
       
       lgb
       
       .
       
       Dataset(
       
       X_train, 
       
       y_train)  
       
       # 
       
       将数据保存到LightGBM二进制文件将使加载更快
       
       lgb_eval 
       
       = 
       
       lgb
       
       .
       
       Dataset(
       
       X_test, 
       
       y_test, 
       
       reference
       
       =
       
       lgb_train)  
       
       # 
       
       创建验证数据
       
       # 
       
       将参数写成字典下形式
       
       params 
       
       = {
       
       'task': 
       
       'train',
       
       'boosting_type': 
       
       'gbdt',  
       
       # 
       
       设置提升类型
       
       'objective': 
       
       'regression',  
       
       # 
       
       目标函数
       
       'metric': {
       
       'l2', 
       
       'auc'},  
       
       # 
       
       评估函数
       
       'num_leaves': 
       
       31,  
       
       # 
       
       叶子节点数
       
       'learning_rate': 
       
       0
       
       .05,  
       
       # 
       
       学习速率
       
       'feature_fraction': 
       
       0
       
       .9,  
       
       # 
       
       建树的特征选择比例
       
       'bagging_fraction': 
       
       0
       
       .8,  
       
       # 
       
       建树的样本采样比例
       
       'bagging_freq': 
       
       5,  
       
       # 
       
       k 
       
       意味着每 
       
       k 
       
       次迭代执行bagging
       
       'verbose': 
       
       1  
       
       # 
       
       <
       
       0 
       
       显示致命的, 
       
       =
       
       0 
       
       显示错误 (
       
       警告), 
       
       >
       
       0 
       
       显示信息
       
}
       
       print(
       
       'Start training...')
       
       # 
       
       训练 
       
       cv 
       
       and 
       
       train
       
       gbm 
       
       = 
       
       lgb
       
       .
       
       train(
       
       params,
       
       lgb_train,
       
       num_boost_round
       
       =
       
       500,
       
       valid_sets
       
       =
       
       lgb_eval,
       
       early_stopping_rounds
       
       =
       
       5)  
       
       # 
       
       训练数据需要参数列表和数据集
       
       print(
       
       'Save model...')
       
       gbm
       
       .
       
       save_model(
       
       'model.txt')  
       
       # 
       
       训练后保存模型到文件
       
       print(
       
       'Start predicting...')
       
       # 
       
       预测数据集
       
       y_pred 
       
       = 
       
       gbm
       
       .
       
       predict(
       
       X_test, 
       
       num_iteration
       
       =
       
       gbm
       
       .
       
       best_iteration
       
                     )  
       
       #如果在训练期间启用了早期停止，可以通过best_iteration方式从最佳迭代中获得预测
       
       # 
       
       评估模型
       
       print(
       
       'error=%f' 
       
       %
       
      (
       
       sum(
       
       1
       
       for 
       
       i 
       
       in 
       
       range(
       
       len(
       
       y_pred)) 
       
       if 
       
       int(
       
       y_pred[
       
       i] 
       
       > 
       
       0
       
       .5) 
       
       != 
       
       y_test[
       
       i]) 
       
       /
       
       float(
       
       len(
       
       y_pred))))
      
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.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.

       
       Start 
       
       training
       
       .
       
       .
       
       .
       
[
       
       LightGBM] [
       
       Warning] 
       
       Auto
       
       -
       
       choosing 
       
       col
       
       -
       
       wise 
       
       multi
       
       -
       
       threading, 
       
       the 
       
       overhead 
       
       of 
       
       testing 
       
       was 
       
       0
       
       .000448 
       
       seconds
       
       .
       
       You 
       
       can 
       
       set 
       
       `force_col_wise=true` 
       
       to 
       
       remove 
       
       the 
       
       overhead
       
       .
       
[
       
       LightGBM] [
       
       Info] 
       
       Total 
       
       Bins 
       
       2550
       
[
       
       LightGBM] [
       
       Info] 
       
       Number 
       
       of 
       
       data 
       
       points 
       
       in 
       
       the 
       
       train 
       
       set: 
       
       9000, 
       
       number 
       
       of 
       
       used 
       
       features: 
       
       10
       
[
       
       LightGBM] [
       
       Info] 
       
       Start 
       
       training 
       
       from 
       
       score 
       
       0
       
       .012000
       
[
       
       1]    
       
       valid_0
       
       's auc: 0.814399 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .965563
       
       Training 
       
       until 
       
       validation 
       
       scores 
       
       don
       
       't improve for 5 rounds
       
[
       
       2]    
       
       valid_0
       
       's auc: 0.84729 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .934647
       
[
       
       3]    
       
       valid_0
       
       's auc: 0.872805 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .905265
       
[
       
       4]    
       
       valid_0
       
       's auc: 0.884117 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .877875
       
[
       
       5]    
       
       valid_0
       
       's auc: 0.895115 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .852189
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

……

       
       [
       
       191]    
       
       valid_0
       
       's auc: 0.982783 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .319851
       
[
       
       192]    
       
       valid_0
       
       's auc: 0.982751 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .319971
       
[
       
       193]    
       
       valid_0
       
       's auc: 0.982685 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .320043
       
       Early 
       
       stopping, 
       
       best 
       
       iteration 
       
       is:
       
[
       
       188]    
       
       valid_0
       
       's auc: 0.982794 valid_0'
       
       s 
       
       l2: 
       
       0
       
       .319746
       
       Save 
       
       model
       
       .
       
       .
       
       .
       
       Start 
       
       predicting
       
       .
       
       .
       
       .
       
       error
       
       =
       
       0
       
       .664000
      
1.
2.
3.
4.
5.
6.
7.
8.

2.scikit-learn接口

       
       from 
       
       sklearn 
       
       import 
       
       metrics
       
       from 
       
       lightgbm 
       
       import 
       
       LGBMClassifier
       
       clf 
       
       = 
       
       LGBMClassifier(
       
       boosting_type
       
       =
       
       'gbdt',  
       
       # 
       
       提升树的类型 
       
       gbdt,
       
       dart,
       
       goss,
       
       rf
       
       num_leaves
       
       =
       
       31,  
       
       #树的最大叶子数，对比xgboost一般为2
       
       ^(
       
       max_depth)
       
       max_depth
       
       =-
       
       1,  
       
       #最大树的深度
       
       learning_rate
       
       =
       
       0
       
       .1,  
       
       #学习率
       
       n_estimators
       
       =
       
       100,  
       
       # 
       
       拟合的树的棵树，相当于训练轮数
       
       subsample_for_bin
       
       =
       
       200000,
       
       objective
       
       =
       
       None,
       
       class_weight
       
       =
       
       None,
       
       min_split_gain
       
       =
       
       0
       
       .0,  
       
       # 
       
       最小分割增益
       
       min_child_weight
       
       =
       
       0
       
       .001,  
       
       # 
       
       分支结点的最小权重
       
       min_child_samples
       
       =
       
       20,
       
       subsample
       
       =
       
       1.0,  
       
       # 
       
       训练样本采样率 
       
       行
       
       subsample_freq
       
       =
       
       0,  
       
       # 
       
       子样本频率
       
       colsample_bytree
       
       =
       
       1.0,  
       
       # 
       
       训练特征采样率 
       
       列
       
       reg_alpha
       
       =
       
       0
       
       .0,  
       
       # 
       
       L1正则化系数
       
       reg_lambda
       
       =
       
       0
       
       .0,  
       
       # 
       
       L2正则化系数
       
       random_state
       
       =
       
       None,
       
       n_jobs
       
       =-
       
       1,
       
       silent
       
       =
       
       True,
       
)
       
       clf
       
       .
       
       fit(
       
       X_train, 
       
       y_train, 
       
       eval_metric
       
       =
       
       'auc')
       
       #设置验证集合 
       
       verbose
       
       =
       
       False不打印过程
       
       clf
       
       .
       
       fit(
       
       X_train, 
       
       y_train)
       
       y_true, 
       
       y_pred 
       
       = 
       
       y_test, 
       
       clf
       
       .
       
       predict(
       
       X_test)
       
       print(
       
       "Accuracy : %.4g" 
       
       % 
       
       metrics
       
       .
       
       accuracy_score(
       
       y_true, 
       
       y_pred))
      
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.

参考

1.https://xgboost.readthedocs.io/

2.https://lightgbm.readthedocs.io/

【机器学习】随机森林、GBDT、XGBoost、LightGBM等集成学习代码练习_tensorflow

原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://blog.51cto.com/u_15671528/5557794