「建模调参」之零基础入门数据挖掘

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()以列表返回可遍历的(键, 值) 元组数组sort(iterable, cmp, key, reverse)排序函数
iterable指定要排序的list或者iterablekey指定取待排序元素的哪一项进行排序 - 这里x[1]表示按照列表中第二个元素排序reverse是一个bool变量，表示升序还是降序排列，默认为False(升序)np.quantile(train_y, 0.9)求train_y 的90%的分位数

下面这个代码是把价格大于90%分位数的部分截断了,就是长尾分布截断


绘制特征v_9的值与标签的散点图，图片发现模型的预测结果（蓝色点）与真实标签（黑色点）的分布差异较大。

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)

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)

mean_absolute_error(val_y_ln, model.predict(val_X))

0.19443858353490887

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
结果对比如下：

SVM
通过寻求结构化风险最小来提高学习机泛化能力,基本模型定义为特征空间上的间隔最大的线性分类器支持向量机的学习策略便是间隔最大化。SVR：用于标签连续值的回归问题
SVC：用于分类标签的分类问题

Boosting
一堆弱分类器的组合就可以成为一个强分类器；不断地在错误中学习，迭代来降低犯错概率通过一系列的迭代来优化分类结果，每迭代一次引入一个弱分类器，来克服现在已经存在的弱分类器组合的短板。
Adaboost
整个训练集上维护一个分布权值向量W，用赋予权重的训练集通过弱分类算法产生分类假设（基学习器）y(x)， 然后计算错误率,用得到的错误率去更新分布权值向量w，对错误分类的样本分配更大的权值,正确分类的样本赋予更小的权值，每次更新后用相同的弱分类算法产生新的分类假设,这些分类假设的序列构成多分类器，对这些多分类器用加权的方法进行联合,最后得到决策结果
Gradient Boosting
迭代的时候选择梯度下降的方向来保证最后的结果最好。损失函数用来描述模型的'靠谱'程度,假设模型没有过拟合,损失函数越大,模型的错误率越高。如果我们的模型能够让损失函数持续的下降,最好的方式就是让损失函数在其梯度方向下降。

GradientBoostingRegressor()

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’时使用

参数:

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损失函数

常用的三种调参方法：

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

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

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

参考
【1】Liner Regression-线性回归
【2】Python实现决策树
【3】机器学习大杀器——梯度提升树GBDT
【4】