Datawhale 零基础入门数据挖掘-Task4 建模调参
四、Datawhale 零基础入门数据挖掘-Task4 建模调参
文章目录
-
- 四、Datawhale 零基础入门数据挖掘-Task4 建模调参
-
- 1. 前言
- 2. 个人理解模型调参
- 3. 说明
-
- 3.1 回归分析
- 3.2 长尾分布
- 3.3 欠拟合与过拟合
- 3.4正则化
- 3.5 调参方法
- 4. 建模与调参
-
- 4.1 降低存储
- 4.2 线性回归
-
- 4.2.1 模型建立
- 4.2.2 交叉验证
- 4.3 模型对比
-
- 4.3.1 线性模型对比
- 4.3.2 非线性模型
- 4.4 模型调参
-
- 4.4.1 贪心调参
- 4.4.2 网格调参
- 4.4.3 贝叶斯调参
- 5. 总结
- 6. 参考
1. 前言
赛题：零基础入门数据挖掘-二手车交易价格预测
地址：零基础入门数据挖掘-二手车交易价格预测
2. 个人理解模型调参
模型调参基于特征工程的所有构建的模型上限来优化模型.由于模型的不同和复杂度，模型的参数数量也都不一样。线性模型需要调整正则化的系数，而对于随机森林和LGB模型，需要调节的参数增多。
模型调参，我们的第一步就是要有一个明确的目的，就是提升模型的性能度量，对于回归算法，我们要降低模型在未知的数据上的误差；对于分类算法，我们要提高模型在未知数据上的准确率。
3. 说明
3.1 回归分析
回归分析是一种统计学上分析数据的方法，目的在于了解两个或多个变量间是否相关、相关方向与强度，并建立数学模型。以便通过观察特定变量（自变量），来预测研究者感兴趣的变量（因变量）
一般形式：
f(x)=w1X1+w2X2+w3X3+…+wdxd+b
向量形式：
f(x)=wTx+b
其中x向量代表一条样本{x1,x2,x3....xn}，其中x1，x2，x3代表样本的各个特征，w是一条向量代表了每个特征所占的权重，b是一个标量代表特征都为0时的预测值，可以视为模型的basis或者bias。
损失函数
Loss = (f(x)- y)2
我们希望的是能够减少在测试集上的预测值f(x)与真实值y的差别，从而获得一个最佳的权重参数，因此这里采用最小二乘估计。
回归分析
3.2 长尾分布
长尾分布：
这种分布会使得你的采样不准，估值不准，因为尾部占了很大部分。另一方面，尾部的数据少，人们对它的了解就少，那么如果它是有害的，那么它的破坏力就非常大，因为人们对它的预防措施和经验比较少
3.3 欠拟合与过拟合
欠拟合：
训练的模型在训练集上面的表现很差，在验证集上面的表现也很差。即训练误差和泛化误差都很大
原因：
- 模型没有很好或足够数量的训练训练集
- 模型的训练特征过于简单
过拟合：
模型的训练误差远小于它在测试数据集上的误差。即训练误差不错，但是泛化误差比训练误差相差太多。
原因：
- 模型没有很好或足够数量的训练训练集
- 训练数据和测试数据有偏差
- 模型的训练过度，过于复杂，没有学到主要的特征
由此引出模型复杂度概念
模型中的参数，一个简单的二元线性的函数只有两个权重，而多元的复杂的函数的权重可能会什么上百上千。
模型复杂度太低（参数过少），模型学习得太少，就难以训练出有效的模型，便会出现欠拟合。
模型复杂度太高（参数很多），即模型可训练空间很大，容易学习过度，甚至于也将噪声数据学习了，便会出现过拟合。
3.4正则化
损失函数后面会添加一个额外项，称作 L1正则化 和 L2正则化，或者 L1范数 和 L2范数。
1正则化和L2正则化可以看做是损失函数的惩罚项。所谓『惩罚』是指对损失函数中的某些参数做一些限制。对于线性回归模型，使用L1正则化的模型建叫做Lasso回归，使用L2正则化的模型叫做Ridge回归（岭回归）。
L1正则化模型
L2正则化模型
正则化说明:
- L1正则化是指权值向量www中各个元素的绝对值之和，通常表示为||w||
- L2正则化是指权值向量www中各个元素的平方和然后再求平方根（可以看到Ridge回归的L2正则化项有平方符号）
正则化作用：
- L1正则化可以产生稀疏权值矩阵，即产生一个稀疏模型，可以用于特征选择
- L2正则化可以防止模型过拟合（overfitting）
正则化说明
3.5 调参方法
-
贪心调参 （坐标下降）
坐标下降法是一类优化算法，其最大的优势在于不用计算待优化的目标函数的梯度。我们最容易想到一种特别朴实的类似于坐标下降法的方法，与坐标下降法不同的是，其不是循环使用各个参数进行调整，而是贪心地选取了对整体模型性能影响最大的参数。参数对整体模型性能的影响力是动态变化的，故每一轮坐标选取的过程中，这种方法在对每个坐标的下降方向进行一次直线搜索（line search）
贪心调参 -
网格调参
GridSearchCV：作用是在指定的范围内可以自动调参，只需将参数输入即可得到最优化的结果和参数。相对于人工调参更省时省力，相对于for循环方法更简洁灵活，不易出错。
网格调参 -
贝叶斯调参
贝叶斯优化通过基于目标函数的过去评估结果建立替代函数（概率模型），来找到最小化目标函数的值。贝叶斯方法与随机或网格搜索的不同之处在于，它在尝试下一组超参数时，会参考之前的评估结果，因此可以省去很多无用功。
超参数的评估代价很大，因为它要求使用待评估的超参数训练一遍模型，而许多深度学习模型动则几个小时几天才能完成训练，并评估模型，因此耗费巨大。贝叶斯调参发使用不断更新的概率模型，通过推断过去的结果来“集中”有希望的超参数。
贝叶斯调参
4. 建模与调参
4.1 降低存储
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
4.2 线性回归
4.2.1 模型建立
先使用线性回归来查看一下用线性回归模型来拟合我们的题目会有那些缺点
这里使用了 sklearn 的 LinearRegression
sklearn.linear_model.LinearRegression(fit_intercept=True,normalize=False,copy_X=True,n_jobs=1)
model = LinearRegression(normalize=True)
model.fit(data_x, data_y)
model.intercept_, model.coef_
查看训练的线性回归模型的截距与权重
'intercept:'+ str(model.intercept_)
sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True)
## output
zip() - 可以将两个可迭代的对象,组合返回成一个元组数据
dict() - 使用元组数据构建字典
items方法 - items() 函数以列表返回可遍历的(键, 值) 元组数组
sort(iterable, cmp, key, reverse) - 排序函数
iterable - 指定要排序的list或者iterable
key - 指定取待排序元素的哪一项进行排序 - 这里x[1]表示按照列表中第二个元素排序
reverse - 是一个bool变量，表示升序还是降序排列，默认为False(升序)
np.quantile(train_y, 0.9) - 求train_y 的90%的分位数
下面这个代码是把价格大于90%分位数的部分截断了,就是长尾分布截断
绘制特征v_9的值与标签的散点图，图片发现模型的预测结果（蓝色点）与真实标签（黑色点）的分布差异较大
且预测值price出现负数
查看price分布 出现长尾分布 不符合正态分布
线性回归解决方案
进行log变化
再次进行可视化，发现预测结果与真实值较为接近，且未出现异常状况.
4.2.2 交叉验证
大概说一下sklearn的交叉验证的使用方法， 下文会有很多使用
verbose - 日志显示
verbose = 0 为不在标准输出流输出日志信息
verbose = 1 为输出进度条记录
verbose = 2 为每个epoch输出一行记录
make_scorer() - 工厂函数,自己定评分标准
这里的log_transfer()是返回log化的标签预测值和真实值
data_y = np.log(data_y + 1)
# 交叉验证
scores = cross_val_score(LinearRegression(normalize=True), X=data_x, \
y=data_y, cv=5, \
scoring=make_scorer(mean_absolute_error))
np.mean(scores)
模拟
但在事实上，由于我们并不具有预知未来的能力，五折交叉验证在某些与时间相关的数据集上反而反映了不真实的情况。通过2018年的二手车价格预测2017年的二手车价格，这显然是不合理的，因此我们还可以采用时间顺序对数据集进行分隔。在本例中，我们选用靠前时间的4/5样本当作训练集，靠后时间的1/5当作验证集，最终结果与五折交叉验证差距不大。
import datetime
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]
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)
fill_between()
train_sizes - 第一个参数表示覆盖的区域
train_scores_mean - train_scores_std - 第二个参数表示覆盖的下限
train_scores_mean + train_scores_std - 第三个参数表示覆盖的上限
color - 表示覆盖区域的颜色
alpha - 覆盖区域的透明度,越大越不透明 [0,1]
预测结果查看
mean_absolute_error(val_y_ln, model.predict(val_X))
0.19443858353490887
可视化处理
绘制学习率曲线与验证曲线
4.3 模型对比
4.3.1 线性模型对比
先来对比一下三个lr模型的情况:
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
LinearRegression
线性回归：
Lasso回归：
L1正则化有助于生成一个稀疏权值矩阵，进而可以用于特征选择。
由此发现power与userd_time特征非常重要。
Ridge回归：
L2正则化在拟合过程中通常都倾向于让权值尽可能小，最后构造一个所有参数都比较小的模型，因为一般认为参数值小的模型比较简单，能适应不同的数据集，也在一定程度上避免了过拟合现象。
4.3.2 非线性模型
SVM - 支持向量机 - 通过寻求结构化风险最小来提高学习机泛化能力,基本模型定义为特征空间上的间隔最大的线性分类器
支持向量机的学习策略便是间隔最大化
SVR - 用于标签连续值的回归问题
SVC - 用于分类标签的分类问题
Boosting算法思想 - 一堆弱分类器的组合就可以成为一个强分类器;
不断地在错误中学习，迭代来降低犯错概率
通过一系列的迭代来优化分类结果,每迭代一次引入一个弱分类器,来克服现在已经存在的弱分类器组合的短板
Adaboost - 整个训练集上维护一个分布权值向量W
用赋予权重的训练集通过弱分类算法产生分类假设（基学习器）y(x)
然后计算错误率,用得到的错误率去更新分布权值向量w
对错误分类的样本分配更大的权值,正确分类的样本赋予更小的权值
每次更新后用相同的弱分类算法产生新的分类假设,这些分类假设的序列构成多分类器
对这些多分类器用加权的方法进行联合,最后得到决策结果
Gradient Boosting - 迭代的时候选择梯度下降的方向来保证最后的结果最好
损失函数用来描述模型的'靠谱'程度,假设模型没有过拟合,损失函数越大,模型的错误率越高
如果我们的模型能够让损失函数持续的下降,最好的方式就是让损失函数在其梯度方向下降
GradientBoostingRegressor()
loss - 选择损失函数，默认值为ls(least squres),即最小二乘法,对函数拟合
learning_rate - 学习率
n_estimators - 弱学习器的数目,默认值100
max_depth - 每一个学习器的最大深度,限制回归树的节点数目,默认为3
min_samples_split - 可以划分为内部节点的最小样本数,默认为2
min_samples_leaf - 叶节点所需的最小样本数,默认为1
MLPRegressor - 人工神经网络,了解的不多
参数详解
hidden_layer_sizes - hidden_layer_sizes=(50, 50),表示有两层隐藏层,第一层隐藏层有50个神经元,第二层也有50个神经元
activation - 激活函数 {
‘identity’, ‘logistic’, ‘tanh’, ‘relu’},默认relu
identity - f(x) = x
logistic - 其实就是sigmod函数,f(x) = 1 / (1 + exp(-x))
tanh - f(x) = tanh(x)
relu - f(x) = max(0, x)
solver - 用来优化权重 {
‘lbfgs’, ‘sgd’, ‘adam’},默认adam,
lbfgs - quasi-Newton方法的优化器:对小数据集来说,lbfgs收敛更快效果也更好
sgd - 随机梯度下降
adam - 机遇随机梯度的优化器
alpha - 正则化项参数,可选的，默认0.0001
learning_rate - 学习率,用于权重更新,只有当solver为’sgd’时使用
max_iter - 最大迭代次数,默认200
shuffle - 判断是否在每次迭代时对样本进行清洗,默认True,只有当solver=’sgd’或者‘adam’时使用
XGBRegressor - 梯度提升回归树,也叫梯度提升机
采用连续的方式构造树,每棵树都试图纠正前一棵树的错误
与随机森林不同,梯度提升回归树没有使用随机化,而是用到了强预剪枝
从而使得梯度提升树往往深度很小,这样模型占用的内存少,预测的速度也快
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)]
result
虽然随机森林模型在此时取得较好的效果，但LGB的效果与其相差不大。
对LGB进行调参后结果会得到提高
4.4 模型调参
''''
LightGBM - 使用的是histogram算法，占用的内存更低，数据分隔的复杂度更低
思想是将连续的浮点特征离散成k个离散值，并构造宽度为k的Histogram
然后遍历训练数据，统计每个离散值在直方图中的累计统计量
在进行特征选择时，只需要根据直方图的离散值，遍历寻找最优的分割点
LightGBM采用leaf-wise生长策略:
每次从当前所有叶子中找到分裂增益最大（一般也是数据量最大）的一个叶子，然后分裂，如此循环。
因此同Level-wise相比，在分裂次数相同的情况下，Leaf-wise可以降低更多的误差，得到更好的精度
Leaf-wise的缺点是可能会长出比较深的决策树，产生过拟合
因此LightGBM在Leaf-wise之上增加了一个最大深度的限制，在保证高效率的同时防止过拟合
'''
'''
参数:
num_leaves - 控制了叶节点的数目,它是控制树模型复杂度的主要参数,取值应 <= 2 ^（max_depth）
bagging_fraction - 每次迭代时用的数据比例,用于加快训练速度和减小过拟合
feature_fraction - 每次迭代时用的特征比例,例如为0.8时,意味着在每次迭代中随机选择80％的参数来建树,
boosting为random forest时用
min_data_in_leaf - 每个叶节点的最少样本数量。
它是处理leaf-wise树的过拟合的重要参数
将它设为较大的值，可以避免生成一个过深的树。但是也可能导致欠拟合
max_depth - 控制了树的最大深度,该参数可以显式的限制树的深度
n_estimators - 分多少颗决策树(总共迭代的次数)
objective - 问题类型
regression - 回归任务,使用L2损失函数
regression_l1 - 回归任务,使用L1损失函数
huber - 回归任务,使用huber损失函数
fair - 回归任务,使用fair损失函数
mape (mean_absolute_precentage_error) - 回归任务,使用MAPE损失函数
常用的三种调参方法：
- 贪心
- 网格
- 贝叶斯
4.4.1 贪心调参
贪心 先选取自己觉得比较影响模型的参数
选取参数
objectives = ["rank:map", "reg:gamma", "count:poisson", "reg:tweedie", "reg:squaredlogerror"]
max_depths = [1, 3, 5, 10, 15]
lambdas = [.1, 1, 2, 3, 4]
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
这里 “count:poisson” 的损失最小， 所以下个参数调试时会加上这个参数
4.4.2 网格调参
网格调参比较慢， 但他的效果相对比较好
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_
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
4.4.3 贝叶斯调参
使用贝叶斯调参前，得先安装bayes_opt这个第三方库
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
rf_bo = BayesianOptimization(
rf_cv,
{
'num_leaves': (2, 100),
'max_depth': (2, 100),
'subsample': (0.1, 1),
'min_child_samples' : (2, 100)
}
)
rf_bo.maximize()
5. 总结
可以根据自己的喜好去使用不同的机器学习模型去调试自己的模型， 选出一个自己觉得比较好的模型，再去进行调参.
特征工程和模型融合是调参的先行步。
调参是将结果好变成结果更好的手段。
6. 参考
相关原理介绍与推荐：
由于相关算法原理篇幅较长，本文推荐了一些博客与教材供初学者们进行学习。
线性回归模型 /决策树模型/GBDT模型/XGBoost模型/LightGBM模型
推荐教材：
《机器学习》《统计学习方法》《Python大战机器学习》
《面向机器学习的特征工程》《数据科学家访谈录》