动手学EDA-建模调参

了解各种模型以及模型的评价和调参策略
建模调参部分

学习目标

了解常用的机器学习模型，并掌握机器学习模型的建模与调参过程
完成相应学习打卡任务

主要内容

1、线性回归模型：
线性回归对于特征的要求；
处理长尾分布；
理解线性回归模型；
2、模型性能验证：
评价函数与目标函数；
交叉验证方法；
留一验证方法；
针对时间序列问题的验证；
绘制学习率曲线；
绘制验证曲线；
3、嵌入式特征选择：
Lasso回归；
Ridge回归；
决策树；
4、模型对比：
常用线性模型；
常用非线性模型；
5、模型调参：
贪心调参方法；
网格调参方法；
贝叶斯调参方法；

常用模型

来源：参考小雨姑娘的博客记录笔记

线性回归模型

机器学习里面最基本的模型：它有很多种推广形式，本质上它是一系列特征的线性组合；
在二维空间中：视作一条直线；三维空间中：视作一个平面；
线性回归的最普通形式：f(x)=w’x+b
x向量代表一条样本{x1,x2,x3…xn}，其中x1，x2，x3代表样本的各个特征，w是一条向量代表了每个特征所占的权重，b是一个标量代表特征都为0时的预测值；
数学意义：两种理解（相通的）
1、向量：w乘以x在线性代数中其实代表的是两个向量的内积，假设w和x均为列向量，即代表了w和x向量的内积w’x。
2、矩阵：同样的这里的x也可以是一个矩阵X，w与X也可以写成w’X；

代码实现：
#w是列向量 矩阵由一个个列向量构成  y = dot(w_t,X)+b
import numpy as np
w_t,b = np.array([1,2,3,4,5]),1
X = np.array([[1,1,1,1,1],[1,2,5,3,4],[5,5,5,5,5]]).T
y_hat = np.dot(w,X) + b

损失函数

线性回归的重点：在于我们如何获得w和b这两个向量，在李航老师的统计学习方法中把一个学习过程分为了三部分，模型、策略、算法，为了获得w和b我们需要制定一定的策略，而这个策略在机器学习的领域中，往往描述为真实值与回归值的偏差：
f(x):预测值 y:真实值
目标：能够减少在测试集上的预测值f(x)与真实值y的差别，从而获得一个最佳的权重参数，因此这里采用最小二乘估计法—这就是策略
数学估计方法:https://zhuanlan.zhihu.com/p/41015902

优化方法

怎样调整w才能使估计值与真实值的差别尽可能小呢？两种经常使用的凸优化方法，最小二乘优化与梯度下降优化：https://zhuanlan.zhihu.com/p/42522867

最小二乘法

思路:线性代数中的矩阵求导，学过导数的人都知道，如果我们想要让loss取到最小，只需要对这个式子进行求导，导数为0的地方就是极值点,在这情景下-就是最小点；
任务即转化为：变成了求这个 [公式] 的数学问题。求出来是:
矩阵求导公式： https://zhuanlan.zhihu.com/p/43141758

# 代码实现
w_t = np.dot(np.dot(y,X.T), np.linalg.inv(np.dot(X,X.T))) 
## 这是个调用函数，里面函数当参数

梯度下降法

梯度下降的策略与最小二乘优化不同，它采用的不是用数学方法一步求出解析解，而是一步一步的往让loss变到最小值的方向走，直到走到那个点。
梯度即变化最快的方向；梯度方向就是增长最快的方向，如果我们想要函数值减小，只需要沿着负梯度方向走就行了；
求梯度 grad的方法：对loss求偏导

然后以微分代替连续

然后再重复求偏导、走、求偏导、走就可以得到最终的权重向量w；对于一个连续可导的函数而言，越靠近我们想要的那个极值点的地方，它的梯度就越小，这点有点不理解，事后查一下；

# 代码实现：
while True:
    grad = np.dot((np.dot(w_t,X)-y), X.t)
    w_t -= 0.1 * grad
    if np.linalg.norm(w_t, ord = 2) < 1e-3:
        break

决策树

决策树，感觉没什么好讲的，按照周志华老师西瓜书上的算法流程一步一步撸下来就好了；
树的建立是一个递归的过程；
决策树的代码实现：https://zhuanlan.zhihu.com/p/65304798

梯度提升树 GBDT

GBDT模型： https://zhuanlan.zhihu.com/p/45145899
GBDT是一个集成模型，可以看做是很多个基模型的线性相加，其中的基模型就是CART回归树；

CART回归树

CART树的主要特征是，他是一颗二分树，每个节点特征取值为“是”和“不是”；
这样的决策树递归的划分每个特征，并且在输入空间的每个划分单元中确定唯一的输出；
1、回归树生成
to add

XGBoost模型

to do

LigthtGBM模型

to do

代码实现

#!/usr/bin/env python
# coding: utf-8

# # 1 读取数据
# 就是导入各种包函数，直接提供应用上层服务

# In[2]:


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


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

# In[4]:


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


# In[5]:


sample_feature = reduce_mem_usage(pd.read_csv('data_for_tree.csv'))


# In[6]:


continuous_feature_names = [x for x in sample_feature.columns if x not in ['price','brand','model','brand']]


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

# In[8]:


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


# ## 2.1 简单建模

# In[10]:


from sklearn.linear_model import LinearRegression
model = LinearRegression(normalize=True)
model = model.fit(train_X, train_y)


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

# In[11]:


'intercept:'+ str(model.intercept_)

sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True)


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

# In[12]:


from matplotlib import pyplot as plt
subsample_index = np.random.randint(low=0, high=len(train_y), size=50)


# In[13]:


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


# **通过作图我们发现数据的标签（price）呈现长尾分布，不利于我们的建模预测。原因是很多模型都假设数据误差项符合正态分布，而长尾分布的数据违背了这一假设。参考博客：https://blog.csdn.net/Noob_daniel/article/details/76087829**

# In[14]:


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


# 在这里我们对标签只是进行了log(x+1)变换，使标签贴近于正态分布

# In[15]:


train_y_ln = np.log(train_y + 1)


# In[16]:


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


# In[17]:


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)


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

# In[18]:


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

# ### 2.2.1 导入包函数即库函数的某一个函数

# In[20]:


from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_absolute_error,  make_scorer


# In[21]:


#定义函数
def log_transfer(func):
    def wrapper(y, yhat):
        result = func(np.log(y), np.nan_to_num(np.log(yhat)))
        return result
    return wrapper


# In[22]:


scores = cross_val_score(model, X=train_X, y=train_y, verbose=1, cv = 5, scoring=make_scorer(log_transfer(mean_absolute_error)))


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

# In[23]:


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


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

# In[24]:


scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=1, cv = 5, scoring=make_scorer(mean_absolute_error))


# In[25]:


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


# In[26]:


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


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

# ### 2.3.1 导包并读取数据

# In[27]:


import datetime


# In[28]:


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)


# In[29]:


model = model.fit(train_X, train_y_ln)
mean_absolute_error(val_y_ln, model.predict(val_X))


# ## 2.4 绘制学习率曲线和验证曲线

# In[30]:


from sklearn.model_selection import learning_curve, validation_curve
get_ipython().run_line_magic('pinfo', 'learning_curve')


# 这就是像labview那样的即时帮助，硬生生的记住所有输入和输出含义以及参数有点难，这样即时显示帮助文档 

# In[34]:


get_ipython().run_line_magic('pinfo', 'validation_curve')


# 定义函数

# In[35]:


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")  
    return plt 


# In[36]:


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


# # 3 多种模型对比

# In[37]:


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)


# ## 3.1 线性模型 & 嵌入式特征选择
# 本章节默认，学习者已经了解关于过拟合、模型复杂度、正则化等概念。否则请寻找相关资料或参考如下连接：
# 
# 用简单易懂的语言描述「过拟合 overfitting」？ https://www.zhihu.com/question/32246256/answer/55320482
# 模型复杂度与模型的泛化能力 http://yangyingming.com/article/434/
# 正则化的直观理解 https://blog.csdn.net/jinping_shi/article/details/52433975

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

# In[39]:


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


# In[40]:


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


# In[42]:


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


# 对三种效果方法对比

# In[43]:


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


# In[44]:


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


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

# In[45]:


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


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

# In[46]:


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


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

# ## 3.2 非线性模型
# 除了线性模型以外，还有许多我们常用的非线性模型如下，在此篇幅有限不再一一讲解原理
# 

# 我们选择了部分常用模型与线性模型进行效果比对。导入包里的函数或者函数集

# In[50]:


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


# In[52]:


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


# In[54]:


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


# In[53]:


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


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

# # 4 模型调参
# 在此我们介绍了三种常用的调参方法如下：
# 
# 1、贪心算法 https://www.jianshu.com/p/ab89df9759c8
# 
# 2、网格调参 https://blog.csdn.net/weixin_43172660/article/details/83032029
# 
# 3、贝叶斯调参 https://blog.csdn.net/linxid/article/details/81189154

# In[55]:


## 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 = []


# In[56]:


## 4.1 贪心调参


# In[57]:


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


# In[59]:


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


# ## 4.2 Grid Search 调参

# In[60]:


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)


# In[62]:


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


# ## 4.3 贝叶斯调参

# In[64]:


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


# In[ ]:

## 自己没有XGBOST和light 那两个模块包，导致后来没有做运算
## 怎么自己添加包呢，而且包一般放在什么目录下才能顺利导包呢？

总结

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