from hyperopt import fmin, tpe, hp,space_eval,rand,Trials,partial,STATUS_OK
from sklearn.model_selection import cross_val_score
from xgboost import XGBClassifier as XGBC
def GBM(argsDict):
max_depth = argsDict["max_depth"]
n_estimators = argsDict['n_estimators'] * 10 + 50
learning_rate = argsDict["learning_rate"] * 0.01 + 0.05
subsample = argsDict["subsample"] * 0.1 + 0.7
colsample_bytree = argsDict["colsample_bytree"] * 0.1 + 0.7
min_child_weight = argsDict["min_child_weight"]+1
print ("max_depth:" + str(max_depth))
print ("n_estimator:" + str(n_estimators))
print ("learning_rate:" + str(learning_rate))
print ("subsample:" + str(subsample))
print ("colsample_bytree:" + str(colsample_bytree))
print ("min_child_weight:" + str(min_child_weight))
global X_train,Y_train
gbm = XGBC(nthread=4, #进程数
max_depth=max_depth, #最大深度
n_estimators=n_estimators, #树的数量
learning_rate=learning_rate, #学习率
subsample=subsample, #采样数
colsample_bytree = colsample_bytree,
min_child_weight=min_child_weight,
max_delta_step = 10, #10步不降则停止
objective="binary:logistic")
metric = cross_val_score(gbm,X_train,Y_train,cv=5,scoring="roc_auc").mean()
print (metric)
● 【1 流失预警模型】
构建实动预测模型（LightGBM），基于客户当月消费、APP登录、分期循环等特征，预测客户下月是否实动。针对预测不动客户，推送微信立减券(18-10)，达到促活效果。模型训练集准确率92.17%，AUC为0.97，验证集91.57%，AUC为0.96，测试集90.63%，AUC为0.95。
● 【2.销量预测模型】
搭建销量预测模型（Random Forest），基于上月活动人力、工作日产能、地区表现等因素，进行滑动特征衍生，预测寿险渠道下月产能，模型训练集误差率7.34%，误差率11.80%，整体误差率7.58%，为制定业绩目标、分配渠道资源，提供科学依据。建模报告可视化了销量走势与特征重要性，对比了Python随机森林与Tableau时间序列预测的精度差异，受到上级领导高度认可。
● 【3.新户获客分析】
针对银行渠道929新户活动，每周提供重点客户清单，输出复盘分析报告，对客户进行分层促动。11月新户三绑率相比10月，环比提升6pct（47% Vs 41%），M0首刷率环比提升5pct（52% Vs 47%），两者均达全年峰值，取得出色效果。分析建议在代发量大，首刷率低的分中心，采取类似的新户活动，对于参与率低的汽融、消金通路，可以改变活动形式（如无门槛券），提升通路表现。
● 【4.客户经营分析】
围绕12.06上线的现金分期产品，进行漏斗分析，以全面掌握经营动态。分析发现，尽管不同渠道客户在资格率上差异不大(约50%)，但在转化率方面差异显著：网络渠道进件客户意愿明显更高，户均成交金额也相对较高。分析指出，尽管成交额连创新高，但银行渠道自有进件客户成交占比仅1/5，有为其他渠道做嫁衣的风险，有必要在银行渠道内各通路加强宣导，投注更多资源，提升贡献占比。
● 【5.自动报表开发】
编写大量HQL/SQL调度作业，开发多套核心的自动化报表：《银行渠道新户表现报表》，《策盟渠道客户画像报表》、《策盟渠道基础表现报表》、《策盟渠道新户Vintage报表》、《策盟渠道损益报表》、《Costco产能日报》、《Costco苏州店活动报表》、《中石油四省加油活动报表》等。
return -metric
space = {"max_depth":hp.randint("max_depth",11),
"n_estimators":hp.randint("n_estimators",3), #[0,1,2,3] -> [50,]
"learning_rate":hp.randint("learning_rate",6), #[0,1,2,3,4,5] -> 0.05,0.06
"subsample":hp.randint("subsample",4), #[0,1,2,3] -> [0.7,0.8,0.9,1.0]
"colsample_bytree":hp.randint("colsample_bytree",4), #[0,1,2,3] -> [0.7,0.8,0.9,1.0]
"min_child_weight":hp.randint("min_child_weight",6), #[0,1,2,3,4,5]
}
algo = partial(tpe.suggest,n_startup_jobs=1)
best = fmin(GBM,space,algo=algo,max_evals=4)#max_evals表示想要训练的最大模型数量，越大越容易找到最优解
print (best)
print (GBM(best))
early_stopping_rounds
第一轮，原始参数
第二轮，调整最大深度，改为2
第三轮，调整最大深度，改为3，发现不如2
第四轮，调整最大深度，改为1，发现不如2
第五轮，固定最大深度为2，更改学习率为0.1， 发现效果较好
第六轮，固定最大深度为2，更改学习率为0.05，发现效果更好（对比0.1）
第七轮，调整最小结构分数之差gamma,从0调整为5，10，20，发现效果不明显，因为树的深度低，效果覆盖了这里，所以固定为0
第八轮，调整L2正则项lambda ,从1调为0.5，效果略有变差，区别不大，因此固定为1
第九轮，调整L1正则项alpha,从0调整为1、10，效果略有变差，区别不大，因此固定为0
第十轮，调整colsample_bytree，发现意义不大，选择1，后续colsample_bylevel类似
第十一轮，调整 num_boost_round，调整为300
结论：通常先确定n_estimators 和eta, 然后gamma和最大深度随便选，然后调纵向抽样，最后调正则化参数
fig,ax = plt.subplots(1,figsize=(15,8))
ax.set_ylim(top=5)
ax.grid()
#--------------------------------------------------------------------------------------------------------------------------------
params_1 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
,"max_depth":6 # 默认6， [default=6]： 树的最大深度
,"eta":0.3 # 默认为3， [default=0.3]：学习率, alias: learning_rate
,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
,"colsample_bytree":1 # 默认为1，列采样比例： 树
,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
,"colsample_bynode":1 # 默认为1，列采样比例： 节点
}
cv_result_1 = xgb.cv( dtrain =dtrain, # 数据
params = params_1, # xgb参数
num_boost_round=300, # 最大迭代次数，即建立的树数目
nfold = 5,
metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
ax.plot(range(1,301),cv_result_1.iloc[:,0],c="red",label="train,original")
ax.plot(range(1,301),cv_result_1.iloc[:,2],c="orange",label="test,original")
#--------------------------------------------------------------------------------------------------------------------------------
# 调整最大深度 max_depth为2
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# # ,"eta":0.3 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# # ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
#--------------------------------------------------------------------------------------------------------------------------------
# 调整最大深度 max_depth为3，发现不如2
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":3 # 默认6， [default=6]： 树的最大深度
# # ,"eta":0.3 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# # ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
#--------------------------------------------------------------------------------------------------------------------------------
# 调整最大深度 max_depth为1，发现不如2
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":1 # 默认6， [default=6]： 树的最大深度
# # ,"eta":0.3 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# # ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
#--------------------------------------------------------------------------------------------------------------------------------
#固定max_depth为2，调整学习率eta为0.1，发现效果较好
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.1 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# # ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
#--------------------------------------------------------------------------------------------------------------------------------
# 调整最大深度 max_depth为2调整学习率eta为0.1，对比0.05，
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.1 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# # ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
# #--------------------------------------------------------------------------------------------------------------------------------
# #固定max_depth为2，调整学习率eta为0.05，发现效果较好
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# # ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
#--------------------------------------------------------------------------------------------------------------------------------
# #固定最大深度 max_depth为2，学习率eta为0.05，调整最小结构分数之差gamma，默认0
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
# #--------------------------------------------------------------------------------------------------------------------------------
# #固定最大深度 max_depth为2，学习率eta为0.05，调整最小结构分数之差gamma，从默认0调整为5，没区别，再调整为10，20，50，意义不大，所以固定为0
# #因为最大深度调整得低，所以gamma的性质就会被覆盖掉
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":50 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# # ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
# #--------------------------------------------------------------------------------------------------------------------------------
# # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为默认的1
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
# # #--------------------------------------------------------------------------------------------------------------------------------
# # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda调整为0.5，0.1,效果略有变差，区别不大
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":0.5 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# # ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
# #--------------------------------------------------------------------------------------------------------------------------------
# #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, ,"alpha":0
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
# # #--------------------------------------------------------------------------------------------------------------------------------
# # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, "alpha"为1，影响不大
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":10 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# # ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# # ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
# #--------------------------------------------------------------------------------------------------------------------------------
# #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, ,"alpha":0 ，调整colsample_bytree
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
# # # #--------------------------------------------------------------------------------------------------------------------------------
# # # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, "alpha"为0，colsample_bytree调整为0.5，0.7，意义不大
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# ,"colsample_bylevel":0.3 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
# # #--------------------------------------------------------------------------------------------------------------------------------
# #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, ,"alpha":0 ，调整colsample_bytree
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# ,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=300, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,301),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,301),cv_result_2.iloc[:,2],c="green",label="test,original")
# # # #--------------------------------------------------------------------------------------------------------------------------------
# # # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, "alpha"为0，colsample_bytree调整为0.5，0.7，意义不大
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# ,"colsample_bylevel":0.3 # 默认为1，列采样比例： 层级
# # ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=300, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,301),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,301),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
# #--------------------------------------------------------------------------------------------------------------------------------
#固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, ,"alpha":0 ，调整colsample_bytree
# params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# ,"colsample_bylevel":0.4 # 默认为1，列采样比例： 层级
# ,"colsample_bynode":1 # 默认为1，列采样比例： 节点
# }
# cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
# params = params_2, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_2.iloc[:,0],c="yellow",label="train,original")
# ax.plot(range(1,201),cv_result_2.iloc[:,2],c="green",label="test,original")
# # # #--------------------------------------------------------------------------------------------------------------------------------
# # # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, "alpha"为0，colsample_bytree调整为0.5，0.7，意义不大
# params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
# ,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
# ,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
# ,"max_depth":2 # 默认6， [default=6]： 树的最大深度
# ,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
# ,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
# ,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
# ,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
# ,"colsample_bytree":1 # 默认为1，列采样比例： 树
# ,"colsample_bylevel":0.4 # 默认为1，列采样比例： 层级
# ,"colsample_bynode":0.3 # 默认为1，列采样比例： 节点
# }
# cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
# params = params_3, # xgb参数
# num_boost_round=200, # 最大迭代次数，即建立的树数目
# nfold = 5,
# metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
# ax.plot(range(1,201),cv_result_3.iloc[:,0],c="cyan",label="train,original")
# ax.plot(range(1,201),cv_result_3.iloc[:,2],c="blue",label="test,original")
# ax.legend(fontsize="xx-large")
# plt.show()
# #--------------------------------------------------------------------------------------------------------------------------------
#固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, ,"alpha":0 ，调整colsample_bytree
params_2 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
,"subsample":1
,"eta":0.05
,"gamma":20
,"lambda":3.5
,"alpha":0.2
,"max_depth":4
,"colsample_bytree":0.4
,"colsample_bylevel":0.6
,"colsample_bynode":1
}
cv_result_2 = xgb.cv( dtrain =dtrain, # 数据
params = params_2, # xgb参数
num_boost_round=300, # 最大迭代次数，即建立的树数目
nfold = 5,
metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
ax.plot(range(1,301),cv_result_2.iloc[:,0],c="yellow",label="train,original")
ax.plot(range(1,301),cv_result_2.iloc[:,2],c="green",label="test,original")
# # #--------------------------------------------------------------------------------------------------------------------------------
# # #固定最大深度 max_depth为2，学习率eta为0.05，最小结构分数之差gamma为0，lambda为1, "alpha"为0，colsample_bytree调整为0.5，0.7，意义不大
params_3 = { 'verbosity':1 # 非默认，0 (silent), 1 (warning), 2 (info), 3 (debug).
,'objective':'reg:squarederror' # 默认，MSE：均方误差： （Σ（yi - y预测）²）/n，而均方根误差RMSE就是对MSE开平方，这是生成每颗树时，所用的损失函数
,"subsample":1 # 默认1，[default=1]：有放回随机抽样比例
,"max_depth":2 # 默认6， [default=6]： 树的最大深度
,"eta":0.05 # 默认为3， [default=0.3]：学习率, alias: learning_rate
,"gamma":0 # 默认为0，[default=0]：最小结构分数之差, alias: min_split_loss
,"lambda":1 # 默认为1，[default=1]: L2正则项的参数, alias: reg_lambda ：
,"alpha":0 # 默认为0，[default=0]：L1正则项的参数：alias: reg_alpha
,"colsample_bytree":1 # 默认为1，列采样比例： 树
,"colsample_bylevel":1 # 默认为1，列采样比例： 层级
,"colsample_bynode":1 # 默认为1，列采样比例： 节点
}
cv_result_3 = xgb.cv( dtrain =dtrain, # 数据
params = params_3, # xgb参数
num_boost_round=300, # 最大迭代次数，即建立的树数目
nfold = 5,
metrics = 'rmse') # 评估指标：rmse,均方根误差，mae：mean absolute error这是每次建立好模型以后对训练样本和验证样本的回测评估指标
ax.plot(range(1,301),cv_result_3.iloc[:,0],c="cyan",label="train,original")
ax.plot(range(1,301),cv_result_3.iloc[:,2],c="blue",label="test,original")
ax.legend(fontsize="xx-large")
plt.show()
