動手學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 那兩個模塊包，導致後來沒有做運算
## 怎麼自己添加包呢，而且包一般放在什麼目錄下才能順利導包呢？

總結

完成了建模與調參的工作，並對我們的模型進行了驗證。此外，我們還採用了一些基本方法來提高預測的精度；