入门数据挖掘(二手车交易价格预测案例)(三)：建模调参

二手车交易价格预测是由Datawhale与天池联合发起的0基础入门系列赛事。赛题以二手车市场为背景，要求选手预测二手汽车的交易价格，这是一个典型的回归问题。
比赛地址：二手车交易价格预测
首先回顾一下前面两章的内容。
看下初始数据集的特征有哪些：

然后看一下我们上一章特征工程做了哪些处理：

• 1.power异常值处理，分箱；
• 2.creatDate - regDate = used_time（天数），删除creatDate 和 regDate；
• 3.regionCode取前四位的城市信息，新特征为city，删除.regionCode；
• 4.以品牌分组统计，添加新特征；

处理到这里是给树模型使用，数据保存在data_for_tree.csv。
接着处理：

• 5.power归一化；
• 6.kilometer归一化；
• 7.brand分组统计特征归一化；
• 8.‘model’, ‘brand’, ‘bodyType’, ‘fuelType’,‘gearbox’, ‘notRepairedDamage’, 'power_bin’这些类别特征做OneEncoder。

以上处理完给给 LR 模型用，数据保存在data_for_lr.csv。

下面开始我们整个建模调参过程。

1. 读取数据

import pandas as pd
import numpy as np
import warnings
warnings.filterwarnings('ignore') # 

pandas里常见的数据类型有int8、int16、Int32、int64、float16、float32、complex64、bool、object等，其中后面位数越大，占用内存越大，用过把实际大小的数据重塑到指定数据类型，可以减少内存占用。自定义一个reduce_mem_usage 函数通过调整数据类型，帮助我们减少数据在内存中占用的空间。

def reduce_mem_usage(df):
    """ iterate through all the columns of a dataframe and modify the data type
        to reduce memory usage.        
    """
    start_mem = df.memory_usage().sum() 
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    
    for col in df.columns:
        col_type = df[col].dtype  
        if col_type != object:
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)  
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
        else:
            df[col] = df[col].astype('category')

    end_mem = df.memory_usage().sum() 
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    return df
# np.iinfo(type)整型类型的范围信息，np.iinfo(type).min该数据类型的最小值，np.iinfo(type).max该数据类型的最大值。
# 同理np.finfo(type)是浮点型的范围

我们运行一下，看一下实际效果：

sample_feature = reduce_mem_usage(pd.read_csv('data_for_tree.csv'))
# 结果
Memory usage of dataframe is 60507328.00 MB
Memory usage after optimization is: 15724107.00 MB
Decreased by 74.0%

可以看到帮我们节省的74%的内存空间。
下面看一下我们的数据特征有哪些：

sample_feature.info()
# 结果如下
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 199037 entries, 0 to 199036
Data columns (total 39 columns):
SaleID                 199037 non-null int32
bodyType               193130 non-null float16
brand                  199037 non-null int8
fuelType               187512 non-null float16
gearbox                191173 non-null float16
kilometer              199037 non-null float16
model                  199036 non-null float16
name                   199037 non-null int32
notRepairedDamage      199037 non-null category
offerType              199037 non-null int8
power                  199037 non-null int16
price                  149037 non-null float32
seller                 199037 non-null int8
train                  199037 non-null int8
v_0                    199037 non-null float16
v_1                    199037 non-null float16
v_10                   199037 non-null float16
v_11                   199037 non-null float16
v_12                   199037 non-null float16
v_13                   199037 non-null float16
v_14                   199037 non-null float16
v_2                    199037 non-null float16
v_3                    199037 non-null float16
v_4                    199037 non-null float16
v_5                    199037 non-null float16
v_6                    199037 non-null float16
v_7                    199037 non-null float16
v_8                    199037 non-null float16
v_9                    199037 non-null float16
used_time              183965 non-null float16
city                   150392 non-null float16
brand_amount           199037 non-null float16
brand_price_max        199037 non-null float32
brand_price_median     199037 non-null float16
brand_price_min        199037 non-null float16
brand_price_sum        199037 non-null float32
brand_price_std        199037 non-null float16
brand_price_average    199037 non-null float16
power_bin              179090 non-null float16
dtypes: category(1), float16(28), float32(3), int16(1), int32(2), int8(4)
memory usage: 15.8 MB

线性回归建模

使用连续型特征进行线性回归拟合。

# 连续型特征名称
continuous_feature_names = [x for x in sample_feature.columns if x not in ['price','brand','model','brand']]
# 删除缺失值、把'-'替换成0、删除原来的索引，重新设置从0开始连续的整型索引
sample_feature = sample_feature.dropna().replace('-', 0).reset_index(drop=True)
# notRepairedDamage有0和1两种，把category转为np.float32
sample_feature['notRepairedDamage'] = sample_feature['notRepairedDamage'].astype(np.float32)
train = sample_feature[continuous_feature_names + ['price']]
# 训练集和真实值
train_X = train[continuous_feature_names]
train_y = train['price']

# 导入线性回归模型
from sklearn.linear_model import LinearRegression
model = LinearRegression(normalize=True)
# normalize如果为True,回归器会标准化输入参数：减去平均值，并且除以相应的L2范数。
model = model.fit(train_X, train_y)  #训练模型
print('intercept:'+ str(model.intercept_))  #截距
print(sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True))  # 权重
# intercept:-110670.68277075785
# 权重结果
[('v_6', 3367064.341641869),
 ('v_8', 700675.5609398916),
 ('v_9', 170630.2772322144),
 ('v_7', 32322.66193202752),
 ('v_12', 20473.670796962964),
 ('v_3', 17868.07954149201),
 ('v_11', 11474.938996740202),
 ('v_13', 11261.764560011892),
 ('v_10', 2683.9200905552707),
 ('gearbox', 881.8225039249025),
 ('fuelType', 363.90425072165164),
 ('bodyType', 189.60271012073065),
 ('city', 44.94975120522174),
 ('power', 28.553901616752594),
 ('brand_price_median', 0.5103728134078995),
 ('brand_price_std', 0.45036347092633167),
 ('brand_amount', 0.14881120395065975),
 ('brand_price_max', 0.0031910186703138377),
 ('SaleID', 5.35598991985751e-05),
 ('seller', 4.227447789162397e-06),
 ('offerType', 1.965701812878251e-06),
 ('train', -1.5418627299368382e-06),
 ('brand_price_sum', -2.1750068681876972e-05),
 ('name', -0.0002980012713042195),
 ('used_time', -0.0025158943328787604),
 ('brand_price_average', -0.40490484510115926),
 ('brand_price_min', -2.2467753486893227),
 ('power_bin', -34.42064411725974),
 ('v_14', -274.78411807741304),
 ('kilometer', -372.89752666073394),
 ('notRepairedDamage', -495.1903844629476),
 ('v_0', -2045.0549573541437),
 ('v_5', -11022.98624053434),
 ('v_4', -15121.731109854549),
 ('v_2', -26098.299920545614),
 ('v_1', -45556.18929732383)]

下面以v_9特征为例可视化一下实际值与拟合值得差距大不大。

from matplotlib import pyplot as plt
subsample_index = np.random.randint(low=0, high=len(train_y), size=50) # 选取50个样本的索引
plt.scatter(train_X['v_9'][subsample_index], train_y[subsample_index], color='black')
plt.scatter(train_X['v_9'][subsample_index], model.predict(train_X.loc[subsample_index]), color='blue')
plt.xlabel('v_9')
plt.ylabel('price')
plt.legend(['True Price','Predicted Price'],loc='upper right')
print('The predicted price is obvious different from true price')
plt.show()

结果如下：

图片发现模型的预测结果（蓝色点）与真实标签（黑色点）的分布差异较大，且部分预测值出现了小于0的情况，说明我们的模型存在一些问题。

import seaborn as sns
print('It is clear to see the price shows a typical exponential distribution')
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
sns.distplot(train_y)
plt.subplot(1,2,2)
sns.distplot(train_y[train_y < np.quantile(train_y, 0.9)])

对于这种不符合正态分布的变量，有个trick，就是对标签进行了log变换，使标签贴近于正态分布。

train_y_ln = np.log(train_y + 1)
import seaborn as sns
print('The transformed price seems like normal distribution')
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
sns.distplot(train_y_ln)
plt.subplot(1,2,2)
sns.distplot(train_y_ln[train_y_ln < np.quantile(train_y_ln, 0.9)])

然后我们再用转换的数据建模试一下：

model = model.fit(train_X, train_y_ln)

print('intercept:'+ str(model.intercept_))
print(sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True))

intercept:18.7507494655882
[('v_9', 8.052409900566975),
 ('v_5', 5.76423659665043),
 ('v_12', 1.6182081236808878),
 ('v_1', 1.4798310582957113),
 ('v_11', 1.1669016563630523),
 ('v_13', 0.9404711296035345),
 ('v_7', 0.7137273083560814),
 ('v_3', 0.6837875771090364),
 ('v_0', 0.008500518010179769),
 ('power_bin', 0.008497969302895196),
 ('gearbox', 0.007922377278325341),
 ('fuelType', 0.00668476970683032),
 ('bodyType', 0.004523520092704702),
 ('power', 0.000716189420535513),
 ('brand_price_min', 3.3343511147504113e-05),
 ('brand_amount', 2.8978797042776285e-06),
 ('brand_price_median', 1.2571172873047128e-06),
 ('brand_price_std', 6.659176363479574e-07),
 ('brand_price_max', 6.194956307516032e-07),
 ('brand_price_average', 5.999345965001714e-07),
 ('SaleID', 2.1194170039653628e-08),
 ('seller', 1.665849680421161e-10),
 ('train', -1.8616219676914625e-11),
 ('offerType', -8.449063670923351e-11),
 ('brand_price_sum', -1.5126504215926567e-10),
 ('name', -7.015512588899606e-08),
 ('used_time', -4.122479372350831e-06),
 ('city', -0.0022187824810424675),
 ('v_14', -0.004234223418122385),
 ('kilometer', -0.013835866226883747),
 ('notRepairedDamage', -0.27027942349846434),
 ('v_4', -0.8315701200995588),
 ('v_2', -0.9470842241646801),
 ('v_10', -1.6261466689783433),
 ('v_8', -40.343007487617676),
 ('v_6', -238.79036385506822)]

再次进行可视化:

plt.scatter(train_X['v_9'][subsample_index], train_y[subsample_index], color='black')
plt.scatter(train_X['v_9'][subsample_index], np.exp(model.predict(train_X.loc[subsample_index])), color='blue')
plt.xlabel('v_9')
plt.ylabel('price')
plt.legend(['True Price','Predicted Price'],loc='upper right')
print('The predicted price seems normal after np.log transforming')
plt.show()

3.五折交叉验证

在使用训练集对参数进行训练的时候，通常会将一整个训练集分为三个部分（比如mnist手写训练集）。一般分为：训练集（train_set），评估集（valid_set），测试集（test_set）这三个部分。这其实是为了保证训练效果而特意设置的。其中测试集很好理解，其实就是完全不参与训练的数据，仅仅用来观测测试效果的数据。而训练集和评估集则牵涉到下面的知识了。
因为在实际的训练中，训练的结果对于训练集的拟合程度通常还是挺好的（初始条件敏感），但是对于训练集之外的数据的拟合程度通常就不那么令人满意了。因此我们通常并不会把所有的数据集都拿来训练，而是分出一部分来（这一部分不参加训练）对训练集生成的参数进行测试，相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证（Cross Validation）。

# 把初始训练样本分成k份，其中（k-1）份被用作训练集，剩下一份被用作评估集
# 这样一共以对分类器做k次训练，并且得到k个训练结果的数组。
from sklearn.model_selection import cross_val_score 
# mean_absolute_error是平均绝对误差做评价指标
# make_scorer是自定义函数作为评价指标
from sklearn.metrics import mean_absolute_error,  make_scorer  

def log_transfer(func):  #定义一个将数据转为log的闭包函数
    def wrapper(y, yhat):
        result = func(np.log(y), np.nan_to_num(np.log(yhat)))
        return result
    return wrapper
# np.nan_to_num()将数组中NaN转为0，inf转为与数据类型对应的有限数字

使用线性回归模型，对未处理标签的特征数据进行五折交叉验证：

scores = cross_val_score(model, X=train_X, y=train_y, verbose=1, cv = 5, scoring=make_scorer(log_transfer(mean_absolute_error)))
print('AVG:', np.mean(scores))
# AVG: 1.3641908155886227

使用线性回归模型，对处理过标签的特征数据进行五折交叉验证：

scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=1, cv = 5, scoring=make_scorer(mean_absolute_error))
print('AVG:', np.mean(scores))
# AVG: 0.19382863663604424

下面把分数矩阵转为Dataframe：

scores = pd.DataFrame(scores.reshape(1,-1))
scores.columns = ['cv' + str(x) for x in range(1, 6)]
scores.index = ['MAE']
print(scores)

但在事实上，由于我们并不具有预知未来的能力，五折交叉验证在某些与时间相关的数据集上反而反映了不真实的情况。通过2018年的二手车价格预测2017年的二手车价格，这显然是不合理的，因此我们还可以采用时间顺序对数据集进行分隔。在本例中，我们选用靠前时间的4/5样本当作训练集，靠后时间的1/5当作验证集，最终结果与五折交叉验证差距不大。

sample_feature = sample_feature.reset_index(drop=True)
split_point = len(sample_feature) // 5 * 4

train = sample_feature.loc[:split_point].dropna()
val = sample_feature.loc[split_point:].dropna()

train_X = train[continuous_feature_names] #训练集的x
train_y_ln = np.log(train['price'] + 1)	# 训练集的y
val_X = val[continuous_feature_names] #验证集的x
val_y_ln = np.log(val['price'] + 1)	#验证集的y
model = model.fit(train_X, train_y_ln)
mean_absolute_error(val_y_ln, model.predict(val_X))
# 误差为0.19443858353490887

4. 绘制学习率曲线和验证曲线

学习曲线是一种用来判断训练模型的一种方法，它会自动 把训练样本的数量按照预定的规则逐渐增加，然后画出不同训练样本数量时的模型准确度。通过学习曲线，可以直观地观察到模型的准确性和训练数据大小的关系，可以用来判断（可视化）模型是否过拟合的。
验证集曲线）是展示某个参数在取不同值时候，训练集与测试集得分情况的对比。主要是用来查看在参数不同的取值下模型的性能。
具体可参考：机器学习的学习率曲线的验证曲线
sklearn模型调优

from sklearn.model_selection import learning_curve, validation_curve
? learning_curve
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,n_jobs=1, train_size=np.linspace(.1, 1.0, 5 )):  
	'''
	estimator:分类器模型
	title：图标题
	X：训练集
	y：数据真实值
	ylim：y轴显示范围
	cv：训练过程中k折交叉验证的k
	n_jobs：并行运行的作业数
	train_size：指定训练样品数量的变化规则，此处我们分5次增加
	'''
    plt.figure()  
    plt.title(title)  
    if ylim is not None:  
        plt.ylim(*ylim)  
    plt.xlabel('Training example')  
    plt.ylabel('score')  
    train_sizes, train_scores, test_scores = learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_size, scoring = make_scorer(mean_absolute_error))  
    # train_sizes：训练集的数量，按照我们定义的数量变化规则，维度为(5,)
    # train_scores：训练集分数矩阵，维度为(5，cv)，行是训练了5次，列是交叉验证次数
    # test_scores：测试集分数矩阵，维度为(5，cv)
    train_scores_mean = np.mean(train_scores, axis=1)# 每次训练的分数平均
    train_scores_std = np.std(train_scores, axis=1) # 每次训练的分数标准差
    test_scores_mean = np.mean(test_scores, axis=1)  
    test_scores_std = np.std(test_scores, axis=1)  
    plt.grid()#绘制刻度线的网格线
    # 填充曲线上下标准差区域
    plt.fill_between(train_sizes, train_scores_mean - train_scores_std,  
                     train_scores_mean + train_scores_std, alpha=0.1,  
                     color="r")  
    plt.fill_between(train_sizes, test_scores_mean - test_scores_std,  
                     test_scores_mean + test_scores_std, alpha=0.1,  
                     color="g")  
    # 画出分数随着训练集数量增加的变化
    plt.plot(train_sizes, train_scores_mean, 'o-', color='r',  
             label="Training score")  
    plt.plot(train_sizes, test_scores_mean,'o-',color="g",  
             label="Cross-validation score")  
    plt.legend(loc="best")  
    return plt  

plot_learning_curve(LinearRegression(), 'Liner_model', train_X[:1000], train_y_ln[:1000], ylim=(0.0, 0.5), cv=5, n_jobs=1)  

图形如下：

5.多种模型对比

train = sample_feature[continuous_feature_names + ['price']].dropna()

train_X = train[continuous_feature_names]
train_y = train['price']
train_y_ln = np.log(train_y + 1)

在过滤式和包裹式特征选择方法中，特征选择过程与学习器训练过程有明显的分别。而嵌入式特征选择在学习器训练过程中自动地进行特征选择。嵌入式选择最常用的是L1正则化与L2正则化。在对线性回归模型加入两种正则化方法后，他们分别变成了岭回归与Lasso回归。

from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso

models = [LinearRegression(),
          Ridge(),
          Lasso()]

result = dict()
for model in models:
    model_name = str(model).split('(')[0]
    scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error))
    result[model_name] = scores
    print(model_name + ' is finished')

对三种方法的效果对比:

result = pd.DataFrame(result)
result.index = ['cv' + str(x) for x in range(1, 6)]
result

结果如下:

下面看一下三种模型的参数分布：
1.普通的线性回归

model = LinearRegression().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
# intercept:18.750749399255973

2.Ridge回归
L2正则化在拟合过程中通常都倾向于让权值尽可能小，最后构造一个所有参数都比较小的模型。因为一般认为参数值小的模型比较简单，能适应不同的数据集，也在一定程度上避免了过拟合现象。可以设想一下对于一个线性回归方程，若参数很大，那么只要数据偏移一点点，就会对结果造成很大的影响；但如果参数足够小，数据偏移得多一点也不会对结果造成什么影响，专业一点的说法是『抗扰动能力强』

model = Ridge().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
# intercept:4.671709787502074

3.lasso回归
L1正则化有助于生成一个稀疏权值矩阵，进而可以用于特征选择。如下图，我们发现power与userd_time特征非常重要。

model = Lasso().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
# intercept:8.672182402894254

除此之外，决策树通过信息熵或GINI指数选择分裂节点时，优先选择的分裂特征也更加重要，这同样是一种特征选择的方法。XGBoost与LightGBM模型中的model_importance指标正是基于此计算的。

除了线性模型以外，还有许多我们常用的非线性模型。这里我们分别用几种进行建模，比较效果。对于这几种模型不了解的话，可以去查找资料学习，或者也可以跳过此部分，后面还会写相关文章。

# 导包
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from xgboost.sklearn import XGBRegressor
from lightgbm.sklearn import LGBMRegressor

models = [LinearRegression(),
          DecisionTreeRegressor(),
          RandomForestRegressor(),
          GradientBoostingRegressor(),
          MLPRegressor(solver='lbfgs', max_iter=100), 
          XGBRegressor(n_estimators = 100, objective='reg:squarederror'), 
          LGBMRegressor(n_estimators = 100)]

result = dict()
for model in models:
    model_name = str(model).split('(')[0]
    scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error))
    result[model_name] = scores   # 把模型对应分数存入字典
    print(model_name + ' is finished')

result = pd.DataFrame(result)
result.index = ['cv' + str(x) for x in range(1, 6)]
print(result)

结果如下：

可以看到随机森林模型在每一个fold中均取得了更好的效果。

6.模型调参

在此我们介绍了三种常用的调参方法如下：`

• 贪心算法 https://www.jianshu.com/p/ab89df9759c8
• 网格调参https://blog.csdn.net/weixin_43172660/article/details/83032029
• 贝叶斯调参 https://blog.csdn.net/linxid/article/details/81189154

首先设定好要调的参数集合：

## LGB的参数集合：

objective = ['regression', 'regression_l1', 'mape', 'huber', 'fair']  # 目标函数

num_leaves = [3,5,10,15,20,40, 55]  # 叶子节点数
max_depth = [3,5,10,15,20,40, 55] # 树的深度
bagging_fraction = []
feature_fraction = []
drop_rate = []

6.1 贪心调参

所谓贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，它所做出的仅仅是在某种意义上的局部最优解。
下面以LGBMRegressor为例，寻找最佳参数。对模型不了解的话也可以了解贪心的思想。

依次去使用每个参数训练模型，看模型分数：

# 首先调节损失函数参数，依次把各个损失函数的分数存在字典里
best_obj = dict()
for obj in objective:
    model = LGBMRegressor(objective=obj)
    score = np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
    best_obj[obj] = score
# 再使用上面最好的损失函数参数，依次调节叶子节点参数，同样把各个叶子节点下的分数存在字典    
best_leaves = dict()
for leaves in num_leaves:
    model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0], num_leaves=leaves)
    score = np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
    best_leaves[leaves] = score
# 使用上面最好的损失函数和叶子节点参数，依次训练树深度参数，同样把各个深度下的分数存在字典
best_depth = dict()
for depth in max_depth:
    model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0],
                          num_leaves=min(best_leaves.items(), key=lambda x:x[1])[0],
                          max_depth=depth)
    score = np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
    best_depth[depth] = score

然后画出原始参数及上面三步调参训练的模型最佳分数走势：

sns.lineplot(x=['0_initial','1_turning_obj','2_turning_leaves','3_turning_depth'], y=[0.143 ,min(best_obj.values()), min(best_leaves.values()), min(best_depth.values())])

可以看到，模型是表现越来愈好的。到后面的话提升不是特别明显了。贪心算法的主要体现在每次只调节一个参数，寻找当前最优参数，每次都是此状态下的最优解，所以不能保证参数是全局最优解，但是如果数据集很大的情况下，能够节省大量时间。

6.2 Grid Search 调参

Grid Search即网格搜索，会穷举各种参数组合，根据设定的评分机制找到最好的那一组设置，主要用于系统地遍历多种参数组合，通过交叉验证确定最佳效果参数。这个方法适合于小数据集，一旦数据的量级上去了，很难得出结果。

# 建立模型
from sklearn.model_selection import GridSearchCV
parameters = {'objective': objective , 'num_leaves': num_leaves, 'max_depth': max_depth}
model = LGBMRegressor()
clf = GridSearchCV(model, parameters, cv=5)
clf = clf.fit(train_X, train_y)

clf.best_params_
# {'max_depth': 15, 'num_leaves': 55, 'objective': 'regression'}

下面使用最佳参数看下我们模型的分数：

model = LGBMRegressor(objective='regression',
                          num_leaves=55,
                          max_depth=15)
np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
# 0.13626164479243302

网格搜索能找到全局最优，但是耗时特别大。

6.3 贝叶斯调参

是基于数据使用贝叶斯定理估计目标函数的后验分布，然后再根据分布选择下一个采样的超参数组合。它充分利用了前一个采样点的信息，其优化的工作方式是通过对目标函数形状的学习，并找到使结果向全局最大提升的参数。
下面自定义一个函数，里面放入我们的优化目标函数，即5折交叉验证的分数，如下：

# 安装：pip install bayesian-optimization
from bayes_opt import BayesianOptimization
def rf_cv(num_leaves, max_depth, subsample, min_child_samples):
    val = cross_val_score(
        LGBMRegressor(objective = 'regression_l1',
            num_leaves=int(num_leaves),
            max_depth=int(max_depth),
            subsample = subsample,
            min_child_samples = int(min_child_samples)
        ),
        X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)
    ).mean()
    return 1 - val

然后实例化一个bayes优化对象了：

# 里面的第一个参数是我们的优化目标函数，第二个参数是我们所需要输入的超参数名称，以及其范围。
# 超参数名称必须和目标函数的输入名称一一对应。
rf_bo = BayesianOptimization(
    rf_cv,
    {
    'num_leaves': (2, 100),
    'max_depth': (2, 100),
    'subsample': (0.1, 1),
    'min_child_samples' : (2, 100)
    }
)

完成上面两步之后，就可以运行bayes优化了：

rf_bo.maximize()

完成的时候会不断地输出结果，如下图所示：

等到程序结束，我们可以查看当前最优的参数和结果：

1 - rf_bo.max['target']
# 0.13067999340240388

总结

在本章中，我们完成了建模与调参的工作，并对我们的模型进行了验证。此外，我们还采用了一些基本方法来提高预测的精度，提升如下图所示。

plt.figure(figsize=(13,5))
sns.lineplot(x=['0_origin','1_log_transfer','2_L1_&_L2','3_change_model','4_parameter_turning'], y=[1.36 ,0.19, 0.19, 0.14, 0.13])