当前位置：网站首页>【机器学习】随机森林、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]
生成数据
生成12000行的数据，训练集和测试集按照3:1划分
模型对比
对比六大模型，都使用默认参数，因为数据是
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.
……
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/
边栏推荐
- 2019南昌网络赛 C题，Hello 2019
- P1505 [National Training Team] Tourism Tree Chain Breakdown
- 【nuxt】服务器部署步骤
- 浅识微服务架构
- 日期处理，字符串日期格式转换
- 搭载开源鸿蒙系统的嵌入式XM-RK3568工业互联方案
- 高德地图JS - 已知经纬度来获取街道、城市、详细地址等信息
- 2017 G icpc shenyang Infinite Fraction Path BFS + pruning
- The maximum validity period of an SSL certificate is 13 months. Is it necessary to apply for multiple years at a time?
- The JVM thread state
猜你喜欢
随机推荐
Pytorch 训练技巧
搭载开源鸿蒙系统的嵌入式XM-RK3568工业互联方案
Leetcode 70 stairs issues (Fibonacci number)
低成本、大容量、高交互…Polkadot 引领 GameFi 实现新突破
金九银十即将到来，求职套路多，面试指南我来分享~
更改Jupyter Notebook默认打开目录
字节也开始缩招了...
Transaction concluded
高项 04 项目变更管理
MUI无法滚动？完美解决
TCP段重组PDU
高德地图JS - 已知经纬度来获取街道、城市、详细地址等信息
Classes and Structures
Lottie系列四：使用建议
【ROS2原理8】节点到参与者的重映射
Sklearn data preprocessing
2022年7月小结
用tensorflow.keras模块化搭建神经网络模型
长沙学院2022暑假训练赛（一）六级阅读
训练好的深度学习模型，多种部署方式