天池比赛二手车预测Task4-建模调参

四、建模与调参

4.1 学习目标

了解常用的机器学习模型，并掌握机器学习模型的建模与调参流程

4.2内容介绍

1.线性回归模型：

• 线性回归对于特征的要求；
• 处理长尾分布；
• 理解线性回归模型；

2.模型性能验证：

• 评价函数与目标函数；
• 交叉验证方法；
• 留一验证方法；
• 针对时间序列问题的验证；
• 绘制学习率曲线；
• 绘制验证曲线；

3.嵌入式特征选择：

• Lasso回归；
• Ridge回归；
• 决策树；

4.模型对比：

• 常用线性模型；
• 常用非线性模型；

5.模型调参：

• 贪心调参方法；
• 网格调参方法；
• 贝叶斯调参方法；

4.3 相关原理介绍与推荐

线性回归模型
线性回归模型
决策树模型
GBDT模型
XGBoost模型
LightGBM模型
推荐教材：
《机器学习》
《统计学习方法》
《Python大战机器学习》
《面向机器学习的特征工程》
《数据科学家访谈录》

4.4 代码实现

4.4.1 读取数据

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

reduce_mem_usage 函数通过调整数据类型，帮助我们减少数据在内存中占用的空间

def reduce_mem_usage(df):
    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

sample_feature = reduce_mem_usage(pd.read_csv('data_for_tree.csv'))
# print(sample_feature)
continuous_feature_names = [x for x in sample_feature.columns if x not in ['price','brand','model','brand']]

Memory usage of dataframe is 62099672.00 MB
Memory usage after optimization is:16520303.00 MB
Decreased by 73.4%

4.4.2 线性回归 & 五折交叉验证 & 模拟真实业务情况

sample_feature = sample_feature.dropna().replace('-',0).reset_index(drop=True)
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']

1）简单建模

model = LinearRegression(normalize=True)
model = model.fit(train_x,train_y)

查看训练的线性回归模型的截距(intercept)与权重(coef)

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

[(‘v_6’, 3342612.384537345),
, (‘v_8’, 684205.534533214),
, (‘v_9’, 178967.94192530424),
, (‘v_7’, 35223.07319016895),
, (‘v_5’, 21917.550249749802),
, (‘v_3’, 12782.03250792227),
, (‘v_12’, 11654.925634146672),
, (‘v_13’, 9884.194615297649),
, (‘v_11’, 5519.182176035517),
, (‘v_10’, 3765.6101415594258),
, (‘gearbox’, 900.3205339198406),
, (‘fuelType’, 353.5206495542567),
, (‘bodyType’, 186.51797317460046),
, (‘city’, 45.17354204168846),
, (‘power’, 31.163045441455335),
, (‘brand_price_median’, 0.535967111869784),
, (‘brand_price_std’, 0.4346788365040235),
, (‘brand_amount’, 0.15308295553300566),
, (‘brand_price_max’, 0.003891831020467389),
, (‘seller’, -1.2684613466262817e-06),
, (‘offerType’, -4.759058356285095e-06),
, (‘brand_price_sum’, -2.2430642281682917e-05),
, (‘name’, -0.00042591632723759166),
, (‘used_time’, -0.012574429533889028),
, (‘brand_price_average’, -0.414105722833381),
, (‘brand_price_min’, -2.3163823428971835),
, (‘train’, -5.392535065078232),
, (‘power_bin’, -59.24591853031839),
, (‘v_14’, -233.1604256172217),
, (‘kilometer’, -372.96600915402496),
, (‘notRepairedDamage’, -449.29703564695365),
, (‘v_0’, -1490.6790578168238),
, (‘v_4’, -14219.648899108111),
, (‘v_2’, -16528.55239086934),
, (‘v_1’, -42869.43976200439)]

subsample_index = np.random.randint(low=0,high=len(train_y),size=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()

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

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)])
plt.show()

通过作图可以发现数据的标签(price)呈现长尾分布，不利于我们的建模预测。原因是很多模型都假设数据差项符合正态分布，而长尾分布的数据违背了这一假设。参考博客

在这里我们对标签进行log(x+1)变换，使标签接近于正态分布：

train_y_ln = np.log(train_y + 1)

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)])
plt.show()

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

再次进行可视化，发现预测结果与真实值较为接近，且未出现异常状况

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()

2）五折交叉验证

在使用训练集对参数进行训练的时候，经常会发现人们通常会将一整个训练集分为三个部分（比如mnist手写训练集）。一般分为：训练集（train_set），评估集（valid_set），测试集（test_set）这三个部分。这其实是为了保证训练效果而特意设置的。其中测试集很好理解，其实就是完全不参与训练的数据，仅仅用来观测测试效果的数据。而训练集和评估集则牵涉到下面的知识了。

因为在实际的训练中，训练的结果对于训练集的拟合程度通常还是挺好的（初始条件敏感），但是对于训练集之外的数据的拟合程度通常就不那么令人满意了。因此我们通常并不会把所有的数据集都拿来训练，而是分出一部分来（这一部分不参加训练）对训练集生成的参数进行测试，相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证（Cross Validation）

def log_transfer(func):
    def wrapper(y,yhat):
        result = func(np.log(y),np.nan_to_num(np.log(yhat)))
        return result
    return wrapper
scores = cross_val_score(model,X=train_x,y=train_y,verbose=1,cv=5,scoring=make_scorer(log_transfer(mean_absolute_error)))

[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done 5 out of 5 | elapsed: 1.1s finished

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

print('AVG',np.mean(scores))

AVG 1.36580240424085

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

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))

[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
AVG 1.36580240424085
[Parallel(n_jobs=1)]: Done 5 out of 5 | elapsed: 1.4s finished

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

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

sample_feature = sample_feature.reset_index(drop=True)
split_point = len(sample_feature)

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

train_x = train[continuous_feature_names]
train_y_ln = np.log(train['price'] + 1)
val_x = val[continuous_feature_names]
val_y_ln = np.log(val['price'] + 1)
model = model.fit(train_x,train_y_ln)
mean_absolute_error(val_y_ln,model.predict(val_x))

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

def plot_learning_curve(estimator,title,x,y,ylim=None,cv=None,n_jobs=1,train_size=np.linspace(.1,1.0,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_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')
    plt.show()
    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)

4.4.3 多种模型对比

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)

要求提前了解过拟合、模型复杂度、正则化等概念。

• 用简单易懂的语言描述「过拟合 overfitting」？
• 模型复杂度与模型的泛化能力
• 正则化的直观理解

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

LinearRegression is finished
Ridge is finished
Lasso is finished

对三种方法的效果比较

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

model = LinearRegression().fit(train_x,train_y_ln)
print('intercept:' + str(model.intercept_))
sns.barplot(abs(model.coef_),continuous_feature_names)
plt.show()

intercept:18.750745460114032

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

model = Ridge().fit(train_x,train_y_ln)
print('intercept:' + str(model.intercept_))
sns.barplot(abs(model.coef_),continuous_feature_names)
plt.show()

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)
plt.show()

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

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')

LinearRegression is finished
DecisionTreeRegressor is finished
RandomForestRegressor is finished
GradientBoostingRegressor is finished
MLPRegressor is finished
XGBRegressor is finished
LGBMRegressor is finished

• Python可视化 | Seaborn5分钟入门(二)——barplot&countplot&pointplot
• seaborn 数据可视化(二）带有类别属性的数据可视化