python回归模型调优要运行多久_python机器学习模型参数调优

#机器学习模型选择与参数调优

#三种集成学习算法-GBDT/XGBoost/lightGBM

#1-1 GBDT算法：梯度决策树，加强型模型，构建多个决策树进行合并

import numpy as np

import matplotlib.pyplot as plt

from sklearn import ensemble

from sklearn import datasets

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

'''

#导入数据集

bost=datasets.load_boston()

x,y=bost.data,bost.target

x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=666)

#构建模型

params={"n_estimators":800,"max_depth":4,"min_samples_split":2,"learning_rate":0.01,"loss":"ls"}

clf=ensemble.GradientBoostingRegressor(**params)

clf.fit(x_train,y_train)

y_pre=clf.predict(x_test)

mse=mean_squared_error(y_test,y_pre)

print("MSE:",mse)

#绘制测试误差-每一次所输出的迭代误差

test_score=np.zeros((params["n_estimators"],),dtype=np.float64)

for i ,y_pre in enumerate(clf.staged_predict(x_test)):

test_score[i]=clf.loss_(y_test,y_pre)

plt.figure(figsize=(12,6))

plt.subplot(1,2,1)

plt.title("Deviance")

plt.plot(np.arange(params["n_estimators"])+1,clf.train_score_,"b-",label="Training set deviance")

plt.plot(np.arange(params["n_estimators"])+1,test_score,"r-",label="Test set deviance")

plt.legend(loc="upper right")

plt.xlabel("Boostng Iterations")

plt.ylabel("Deviance")

#绘制特征重要性图

feature_importance=clf.feature_importances_

feature_importance=100.0*(feature_importance/feature_importance.max())

sort_index=np.argsort(feature_importance)

pos=np.arange(sort_index.shape[0])+0.5

plt.subplot(1,2,2)

plt.barh(pos,feature_importance[sort_index],align="center")

plt.yticks(pos,bost.feature_names[sort_index])

plt.xlabel("Relative Importance")

plt.title("Veriable Importance")

plt.show()

#1-2 XGboost扩展的GBDT

import xgboost as xgb

data=np.random.rand(100000,10)

label=np.random.randint(2,size=100000)

dtrain=xgb.DMatrix(data,label=label,missing=-999.0)

data2=np.random.rand(5000,10)

label2=np.random.randint(2,size=5000)

dtest=xgb.DMatrix(data2,label=label2,missing=-999.0)

params={"bst:max_depth":2,"bst:eta":1,"silent":1,"objective":"binary:logistic"}

params["nthread"]=4

params["eval_metric"]="auc"

evallist=[(dtrain,"train"),(dtest,"eval")] #监控效果

num_round=10 #训练迭代的次数

bst=xgb.train(params,dtrain,num_round,evallist)

#设置一种早停，输出最好的效果

bst=xgb.train(params,dtrain,num_round,evallist,early_stopping_rounds=10)

#1-3 lightGBM 轻量级梯度提升机

import lightgbm as lgb

data=np.random.rand(100000,10)

label=np.random.randint(2,size=100000)

train=lgb.Dataset(data,label=label)

data2=np.random.rand(5000,10)

label2=np.random.randint(2,size=5000)

test=lgb.Dataset(data2,label=label2)

params={"num_leaves":31,"num_trees":100,"objective":"binary","metrics":"binary_error"}

num_round=10 #10论训练

bst=lgb.train(params,train,num_round,valid_sets=[test])

#交叉验证

num_round=10

params={"num_leaves":50,"num_trees":100,"objective":"binary"}

print(lgb.cv(params,train,num_round,nfold=5))

bst=lgb.train(params,train,20,valid_sets=test,early_stopping_rounds=10)

'''

#招聘数据的实际项目需要

#2-1 GBDT算法进行训练和预测

import pandas as pd

import numpy as np

df=pd.read_csv("D:\Byrbt2018\Study\Python机器学习全流程项目实战精讲\配套课件\第七讲 机器学习建模\lagou_featured.csv",encoding="gbk")

print(df.shape)

pd.options.display.max_columns=999 #设置最大的展示列数为999

print(df.head())

#首先对salary的目标回归变量进行直方图展示

import matplotlib.pyplot as plt

plt.hist(df["salary"])

plt.show()

#将表格数据转化为目标向量和训练特征矩阵

x=df.drop(["salary"],axis=1).values

y=df["salary"].values.reshape(-1,1)

print(x.shape,y.shape)

from sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=666)

print(x_train.shape,x_test.shape,y_train.shape,y_test.shape)

from sklearn.ensemble import GradientBoostingRegressor

clf=GradientBoostingRegressor(n_estimators=100,max_depth=5)

clf.fit(x_train,y_train)

from sklearn.metrics import mean_squared_error,max_error,mean_absolute_error

y_pre=clf.predict(x_test)

print(np.sqrt(mean_squared_error(y_test,y_pre)))

print(np.sqrt(mean_squared_error(y_test,y_pre)))

print(np.sqrt(mean_absolute_error(y_test,y_pre)))

print(np.sqrt(max_error(y_test,y_pre)))

print(clf.score(x_test,y_test))

plt.plot(y_pre)

plt.plot(y_test)

plt.legend(["y_pre","y_test"])

plt.show()

#对目标回归变量进行对数化处理，消除有偏数据的影响

from sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test=train_test_split(x,np.log(y),random_state=666)

print(x_train.shape,x_test.shape,y_train.shape,y_test.shape)

from sklearn.ensemble import GradientBoostingRegressor

clf=GradientBoostingRegressor(n_estimators=100,max_depth=5)

clf.fit(x_train,y_train)

from sklearn.metrics import mean_squared_error,max_error,mean_absolute_error

y_pre=clf.predict(x_test)

print(np.sqrt(mean_squared_error(np.exp(y_test),np.exp(y_pre))))

print(np.sqrt(mean_absolute_error(np.exp(y_test),np.exp(y_pre))))

print(np.sqrt(max_error(np.exp(y_test),np.exp(y_pre))))

print(clf.score(x_test,y_test))

print()

plt.plot(np.exp(y_pre))

plt.plot(np.exp(y_test))

plt.legend(["y_pre","y_test"])

plt.show()

#2-2 XGBoost模型训练和预测

from sklearn.model_selection import KFold #五划分的交叉验证的方式模块

import xgboost as xgb

from sklearn.metrics import mean_squared_error

import time

kf=KFold(n_splits=5,random_state=123,shuffle=True)

def evalereor(pre,train):

labels=train.getlabel()

return "mse",mean_squared_error(np.exp(pre),np.exp(labels))

y=np.log(y)

valid_pre=np.zeros((330,5))

time_start=time.time()

for i,(train_ind,valid_ind) in enumerate(kf.split(x)):

print("FOLD",i+1,"out of",5)

x_train,y_train=x[train_ind],y[train_ind]

x_valid,y_valid=x[valid_ind],y[valid_ind]

xgb_params={"eta":0.01,"max_depth":6,"subsample":0.9,"colsample_bytree":0.9,"objective":"reg:linear","seed":99,"eval_metgric":"rmse","silent":True}

d_train=xgb.DMatrix(x_train,y_train)

d_valid=xgb.DMatrix(x_valid,y_valid)

watchlist=[(d_train,"train"),(d_valid,"valid")] #监控效果

model=xgb.train(

xgb_params,

d_train,

2000,

watchlist,

verbose_eval=100,

#feval=evalereor,

early_stopping_rounds=1000

)

# valid_pre[:,i]=np.exp(model.predict(d_valid))

print("cv training time{} second".format(time.time()-time_start))

#网格搜索的方式

import xgboost as xgb

xg_train=xgb.DMatrix(x,y)

params={"eta": 0.01, "max_depth": 6, "subsample": 0.9, "colsample_bytree": 0.9, "objective": "reg:linear",

"seed": 99, "eval_metgric": "rmse", "silent": True}

cv=xgb.cv(params,xg_train,1000,nfold=5,early_stopping_rounds=800,verbose_eval=100)

print(cv)

#2-3 lightGBM算法模型

import time

import lightgbm as lgb

from sklearn.model_selection import KFold

from sklearn.metrics import mean_squared_error

from lightgbm import LGBMRegressor

x=df.drop(["salary"],axis=1).values

y=df["salary"].values

y=np.log(y)

def evalerror(pre,train):

labels=train.getlabel()

return "mse",mean_squared_error(np.exp(pre),np.exp(labels))

params={

"learning_rate":0.01,

"boosting_type":"gbdt",

"objective": "regression",

"metric":"mse",

"sub_feature":0.7,

"num_leaves":17,

"colsample_bytree":0.7,

"feature_fraction":0.7,

"min_data":100,

"min_hessian":1,

"verbose":-1

}

print("begin cv 5-fold training...")

scores=[]

time_start=time.time()

kf=KFold(n_splits=5,shuffle=True,random_state=27)

for i,(train_ind,valid_ind) in enumerate(kf.split(x)):

print("FOLD",i+1,"out of",5)

x_train,y_train=x[train_ind],y[train_ind]

x_valid,y_valid=x[valid_ind],y[valid_ind]

d_train=lgb.Dataset(x_train,y_train)

d_valid=lgb.Dataset(x_valid,y_valid)

model=lgb.train(

params,

d_train,

num_boost_round=2000,

valid_sets=d_valid,

verbose_eval=200,

#feval=evalerror(),

early_stopping_rounds=1000)

#valid_pre[:,i]=np.exp(model.predict(d_valid))

print("cv training time{} second".format(time.time()-time_start))