本文將繼續修煉回歸模型算法，并總結了一些常用的除線性回歸模型之外的模型，其中包括一些單模型及集成學習器。

保序回歸、多項式回歸、多輸出回歸、多輸出K近鄰回歸、決策樹回歸、多輸出決策樹回歸、AdaBoost回歸、梯度提升決策樹回歸、人工神經網絡、隨機森林回歸、多輸出隨機森林回歸、XGBoost回歸。

需要面試或者需要總體了解/復習機器學習回歸模型的小伙伴可以通讀下本文，理論總結加代碼實操，有助于理解模型。

保序回歸

保序回歸或單調回歸是一種將自由形式的直線擬合到一系列觀測值上的技術，這樣擬合的直線在所有地方都是非遞減(或非遞增)的，并且盡可能靠近觀測值。

理論規則是

• 如果預測輸入與訓練中的特征值完全匹配，則返回相應標簽。如果一個特征值對應多個預測標簽值，則返回其中一個，具體是哪一個未指定。
• 如果預測輸入比訓練中的特征值都高（或者都低），則相應返回最高特征值或者最低特征值對應標簽。如果一個特征值對應多個預測標簽值，則相應返回最高值或者最低值。
• 如果預測輸入落入兩個特征值之間，則預測將會是一個分段線性函數，其值由兩個最近的特征值的預測值計算得到。如果一個特征值對應多個預測標簽值，則使用上述兩種情況中的處理方式解決。

n = len(dataset['Adj Close'])
X = np.array(dataset['Open'].values)
y = dataset['Adj Close'].values
from sklearn.isotonic import IsotonicRegression

ir=IsotonicRegression()
y_ir=ir.fit_transform(X,y)

將擬合過程可視化

紅色散點圖是原始數據X-y關系圖，綠色線為保序回歸擬合后的數據X-y_ir關系圖。這里以可視化的形式表現了保序回歸的理論規則。

lines=[[[i,y[i]],[i,y_ir[i]]] for i in range(n)]
lc=LineCollection(lines)
plt.figure(figsize=(15,6))
plt.plot(X,y,'r.',markersize=12)
plt.plot(X,y_ir,'g.-',markersize=12)
plt.gca().add_collection(lc)
plt.legend(('Data','Isotonic Fit','Linear Fit'))
plt.title("Isotonic Regression")
plt.show()

多項式回歸

多項式回歸(PolynomialFeatures)是一種用多項式函數作為自變量的非線性方程的回歸方法。

將數據轉換為多項式。多項式回歸是一般線性回歸模型的特殊情況。它對于描述曲線關系很有用。曲線關系可以通過平方或設置預測變量的高階項來實現。

sklearn中的多項式擬合

X = dataset.iloc[ : , 0:4].values
Y = dataset.iloc[ : ,  4].values

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

poly=PolynomialFeatures(degree=3)
poly_x=poly.fit_transform(X)

regressor=LinearRegression()
regressor.fit(poly_x,Y)

plt.scatter(X,Y,color='red')
plt.plot(X,regressor.predict(poly.fit_transform(X)),color='blue')
plt.show()

以原始數據繪制X-Y紅色散點圖，并繪制藍色的、經過多項式擬合后再進行線性回歸模型擬合的直線圖。

一元自變量計算三階多項式

from scipy import *
f = np.polyfit(X,Y,3)
p = np.poly1d(f)
print(p)

3            2
-6.228e-05x + 0.0023x + 0.9766x + 0.05357

多元自變量的多項式

from sklearn.preprocessing import PolynomialFeatures
from sklearn import linear_model
X = np.array(dataset[['Open', 'High', 'Low']].values)
Y = np.array(dataset['Adj Close'].values)

Y = Y.reshape(Y.shape[0], -1)
poly = PolynomialFeatures(degree=3)
X_ = poly.fit_transform(X)
predict_ = poly.fit_transform(Y)

Pipeline形式

from sklearn.pipeline import Pipeline
X = np.array(dataset['Open'].values)
Y = np.array(dataset['Adj Close'].values)
X = X.reshape(X.shape[0], -1)
Y = Y.reshape(Y.shape[0], -1)
Input=[('scale',StandardScaler()),('polynomial', PolynomialFeatures(include_bias=False)),('model',LinearRegression())]
pipe = Pipeline(Input)
pipe.fit(X,Y)
yhat = pipe.predict(X)
yhat[0:4]

array([[3.87445269],
       [3.95484371],
       [4.00508501],
       [4.13570206]])

numpy 中的多項式擬合

首先理解nump用于多項式擬合的兩個主要方法。

np.poly1d

np.poly1d(c_or_r, 
          r=False, 
          variable=None)

一維多項式類，用于封裝多項式上的"自然"操作，以便上述操作可以在代碼中采用慣用形式。如何理解呢？看看下面幾個例子。

• c_or_r系數向量

import numpy as np
a=np.array([2,1,1])
f=np.poly1d(a)
print(f)

2
2 x + 1 x + 1

• r=False是否反推

表示把數組中的值作為根，然后反推多項式。

f=np.poly1d([2,3,5],r=True)
#(x - 2)*(x - 3)*(x - 5)  = x^3 - 10x^2 + 31x -30
print(f)

3      2
1 x - 10 x + 31 x - 30

• variable=None表示改變未知數的字母

f=np.poly1d([2,3,5],r=True,variable='z')
print(f)

3      2
1 z - 10 z + 31 z - 30

np.polyfit

np.polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False)

最小二乘多項式擬合。

擬合多項式。返回一個系數'p'的向量，以最小化平方誤差的順序'deg'，'deg-1'，…"0"。

推薦使用 類方法，因為它在數值上更穩定。

下圖是以原始數據繪制的藍色X-Y散點圖，以及紅色的X分布圖。

X = dataset['Open'].values
y = dataset['Adj Close'].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
plt.figure(figsize=(10,6))
plt.plot(X_train, y_train, 'bo')
plt.plot(X_test, np.zeros_like(X_test), 'r+')
plt.show()

numpy與sklearn中的多項式回歸對比

# numpy
model_one = np.poly1d(np.polyfit(X_train, y_train,1))
preds_one = model_one(X_test)
print(preds_one[:3])
> >> [11.59609048 10.16018804 25.23716889]
# sklearn
from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(X_train.reshape(-1, 1), y_train)
preds = model.predict(X_test.reshape(-1, 1))
preds[:3]
> >> array([11.59609048, 10.16018804, 25.23716889])
# 預測結果是一樣的
print("all close?", np.allclose(preds, preds_one))
> >> 'all close? True

結果表明兩者相比預測結果時一致的。

多階多項式效果對比

比較一階、二階及三階多項式擬合，多線性回歸模型的效果影響。由圖可看出，三條線基本重合，且RMSE相差不大。

model_one = np.poly1d(np.polyfit(X_train, y_train,1))
model_two = np.poly1d(np.polyfit(X_train, y_train, 2))
model_three = np.poly1d(np.polyfit(X_train, y_train, 3))

fig, axes = plt.subplots(1, 2, figsize=(14, 5),sharey=True)
labels = ['line', 'parabola', 'nonic']
models = [model_one, model_two, model_three]
train = (X_train, y_train)
test = (X_test, y_test)
for ax, (ftr, tgt) in zip(axes, [train, test]):
    ax.plot(ftr, tgt, 'k+')
    num = 0
    for m, lbl in zip(models, labels):
        ftr = sorted(ftr)
        ax.plot(ftr, m(ftr), '-', label=lbl)
        if ax == axes[1]:
            ax.text(2,55-num, f"{lbl}_RMSE: {round(np.sqrt(mse(tgt, m(tgt))),3)}")
            num += 5
axes[1].set_ylim(-10, 60)
axes[0].set_title("Train")
axes[1].set_title("Test");
axes[0].legend(loc='best');

繪制類似學習曲線

因低階多項式效果相差并不明顯，因此增大多項式階數，并以殘差平方和為y軸，看模型擬合效果，由圖可以看出，隨著多項式階數越來越高，模型出現嚴重的過擬合（訓練集殘差平方和降低，而測試集卻在上漲）。

results = []
for complexity in [1, 2, 3, 4, 5, 6,7,8, 9]:
    model = np.poly1d(np.polyfit(X_train, y_train, complexity))
    train_error = np.sqrt(mse(y_train, model(X_train)))
    test_error = np.sqrt(mse(y_test,model(X_test)))
    results.append((complexity, train_error, test_error))
columns = ["Complexity", "Train Error", "Test Error"]
results_df = pd.DataFrame.from_records(results, 
              columns=columns,
              index="Complexity")
results_df
results_df.plot(figsize=(10,6))

多輸出回歸

多輸出回歸為每個樣本分配一組目標值。這可以認為是預測每一個樣本的多個屬性，比如說一個具體地點的風的方向和大小。

多輸出回歸支持 MultiOutputRegressor 可以被添加到任何回歸器中。這個策略包括對每個目標擬合一個回歸器。因為每一個目標可以被一個回歸器精確地表示，通過檢查對應的回歸器，可以獲取關于目標的信息。因為 MultiOutputRegressor 對于每一個目標可以訓練出一個回歸器，所以它無法利用目標之間的相關度信息。

支持多類-多輸出分類的分類器:

sklearn.tree.DecisionTreeClassifier 
sklearn.tree.ExtraTreeClassifier  
sklearn.ensemble.ExtraTreesClassifier  
sklearn.neighbors.KNeighborsClassifier
sklearn.neighbors.RadiusNeighborsClassifier
sklearn.ensemble.RandomForestClassifier

X = dataset.drop(['Adj Close', 'Open'], axis=1)
Y = dataset[['Adj Close', 'Open']]

from sklearn.multioutput import MultiOutputRegressor
from sklearn.svm import LinearSVR

model = LinearSVR()
wrapper = MultiOutputRegressor(model)
wrapper.fit(X, Y)

data_in = [[23.98, 22.91, 7.00, 7.00, 
            1.62, 1.62, 4.27, 4.25]]
yhat = wrapper.predict(data_in)
print(yhat[0])
> >> [16.72625136 16.72625136]
wrapper.score(X, Y)

多輸出K近鄰回歸

多輸出K近鄰回歸可以不使用MultiOutputRegressor作為外包裝器，直接使用KNeighborsRegressor便可以實現多輸出回歸。

X = dataset.drop(['Adj Close', 'Open'], axis=1)
Y = dataset[['Adj Close', 'Open']]
from sklearn.neighbors import KNeighborsRegressor
model = KNeighborsRegressor()
model.fit(X, Y)
data_in = [[23.98, 22.91, 7.00, 7.00, 
            1.62, 1.62, 4.27, 4.25]]
yhat = model.predict(data_in)
print(yhat[0])
> >> [2.34400001 2.352     ]
model.score(X, Y)
> >> 0.7053689393640217

決策樹回歸

決策樹是一種樹狀結構，她的每一個葉子結點對應著一個分類，非葉子結點對應著在某個屬性上的劃分，根據樣本在該屬性上的不同取值降氣劃分成若干個子集。

基本原理

數模型通過遞歸切割的方法來尋找最佳分類標準，進而最終形成規則。CATA樹，對回歸樹用平方誤差最小化準則，進行特征選擇，生成二叉樹。

CATA回歸樹的生成

在訓練數據集所在的空間中，遞歸地將每個空間區域劃分為兩個子區域，并決定每個子區域上的輸出值，生產二叉樹。

選擇最優切分變量 和最優切分點 ，求解

遍歷 ，對固定的切分變量 掃描切分點 ，使得上式達到最小值的對 ，不斷循環直至滿足條件停止。

X = dataset.drop(['Adj Close', 'Close'], axis=1)  
y = dataset['Adj Close'] 
# 劃分訓練集和測試集略 
# 模型實例化
from sklearn.tree import DecisionTreeRegressor  
regressor = DecisionTreeRegressor()  
# 訓練模型
regressor.fit(X_train, y_train)
# 回歸預測
y_pred = regressor.predict(X_test)
df = pd.DataFrame({'Actual':y_test, 'Predicted':y_pred})  
print(df.head(2))

Actual  Predicted
Date                         
2017-08-09   12.83      12.63
2017-11-14   11.12      11.20

模型評價

from sklearn import metrics 
# 平均絕對誤差
print(metrics.mean_absolute_error(
    y_test, y_pred))  
# 均方差
print(metrics.mean_squared_error(
    y_test, y_pred))
# 均方根誤差
print(np.sqrt(
    metrics.mean_squared_error(
      y_test, y_pred)))

0.0924680893617
0.0226966010212
0.1506539114039

交叉驗證

from sklearn.model_selection import cross_val_score
dt_fit = regressor.fit(X_train, y_train)
dt_scores = cross_val_score(
    dt_fit, X_train, y_train, cv = 5)

print("Mean cross validation score: {}".format(np.mean(dt_scores)))
print("Score without cv: {}".format(dt_fit.score(X_train, y_train)))

Mean cross validation score: 0.99824909037
Score without cv: 1.0

R2

from sklearn.metrics import r2_score

print('r2 score:', r2_score(y_test, dt_fit.predict(X_test)))
print('Accuracy Score:', dt_fit.score(X_test, y_test))

r2 score: 0.9989593390532074
Accuracy Score: 0.9989593390532074

多輸出決策樹回歸

多輸出回歸是根據輸入預測兩個或多個數字輸出。在多輸出回歸中，通常，輸出依賴于輸入并且彼此依賴。這意味著輸出經常不是彼此獨立的，可能需要一個模型來預測兩個輸出在一起或每個輸出取決于其他輸出。

一個示例說明決策樹多輸出回歸（Decision Tree for Multioutput Regression）。

X = dataset.drop(['Adj Close', 'Open'], axis=1)
Y = dataset[['Adj Close', 'Open']]
from sklearn.tree import DecisionTreeRegressor
model = DecisionTreeRegressor()
model.fit(X, Y)
# 統計值
# dataset.describe()
# 根據統計信息輸入data_in
data_in = [23.98, 22.91, 7.00, 7.00, 1.62, 1.62, 4.27, 4.25]
yhat = model.predict([data_in])
# 預測值
print(yhat[0])
print(model.score(X, Y))

[15.64999962 16.64999962]
1

集成算法回歸

裝袋法

裝袋法 (Bagging)的核?思想是構建多個 相互獨?的評估器 ，然后對其預測進?平均或多數表決原則來決定集成評估器的結果。裝袋法的代表模型就是隨機森林。

個體學習器間不存在強依賴關系、可同時生成的并行化方法。

提升法

提升法(Boosting)中，基評估器是相關的，是按順序??構建的。其核?思想是結合弱評估器的?量?次次對難以評估的樣本進?預測，從?構成?個強評估器。提升法的代表模型Adaboost和梯度提升樹GBDT。

個體學習器間存在強依賴關系、必須串行生成的序列化方法。

AdaBoost 回歸

AdaBoost Regressor 自適應增強回歸

通過提高那些被前一輪基學習器錯誤分類的樣本的權值，降低那些被正確分類的樣本的權值來改變訓練樣本分布。并對所有基學習器采用加權結合，增大分類誤差小的基學習器的權值，減少分類誤差率大的基學習器的權值。

理論上的AdaBoost可以使用任何算法作為基學習器，但一般來說，使用最廣泛的AdaBoost的弱學習器是決策樹和神經網絡。

AdaBoost的核心原則是在反復修改的數據版本上擬合一系列弱學習者(即比隨機猜測略好一點的模型，如小決策樹)。他們所有的預測然后通過加權多數投票(或總和)合并產生最終的預測。

每次所謂的增強迭代的數據修改包括對每個訓練樣本應用權重。

1. 最初，這些權重都被設置為，所以第一步僅僅是在原始數據上訓練一個能力較弱的學習器。
2. 對于每一次連續迭代，樣本權值被單獨修改，學習算法被重新應用到重新加權的數據。
3. 在給定的步驟中，那些被前一步引入的增強模型錯誤預測的訓練例子的權重增加，而那些被正確預測的訓練例子的權重減少。
4. 隨著迭代的進行，難以預測的例子受到越來越大的影響。因此，每一個隨后的弱學習器都被迫將注意力集中在前一個學習器錯過的例子上。

基分類器 在加權數據集上的分類誤差率等于被 誤分類樣本的權重之和。

Adaboost基本性質

能在學習過程中不斷減少訓練誤差，即在訓練數據集上的訓練誤差率。且誤差率是以指數數率下降的。

X = dataset[['Open', 'High', 'Low', 'Volume']].values
y = dataset['Buy_Sell'].values
# 劃分訓練集與測試集略
from sklearn.ensemble import AdaBoostClassifier
ada = AdaBoostClassifier(n_estimators=180, random_state=0)
ada.fit(X_train, y_train)

y_pred_proba = ada.predict_proba(X_test)[:,1]
ada.feature_importances_

array([ 0.18888889,  0.15      ,
        0.26666667,  0.39444444])

模型評價

ada.predict(X_test)
ada.score(X, y)
from sklearn.metrics import roc_auc_score
ada_roc_auc = roc_auc_score(y_test, y_pred_proba)
print('ROC AUC score: {:.2f}'.format(ada_roc_auc))

梯度提升決策樹回歸

GBDT(Gradient Boosting Decision Tree) 又叫 MART（Multiple Additive Regression Tree)，是一種迭代的決策樹算法，該算法由多棵決策樹組成，所有樹的結論累加起來做最終答案。它在被提出之初就和SVM一起被認為是泛化能力較強的算法。

提升樹是迭代多棵回歸樹來共同決策。當采用平方誤差損失函數時，每一棵回歸樹學習的是之前所有樹的結論和殘差，擬合得到一個當前的殘差回歸樹，殘差的意義如公式：殘差 = 真實值 - 預測值 。提升樹即是整個迭代過程生成的回歸樹的累加。

提升樹利用加法模型和前向分步算法實現學習的優化過程。當損失函數時平方損失和指數損失函數時，每一步的優化很簡單，如平方損失函數學習殘差回歸樹。

簡單解釋：每一次的計算是為了減少上一次的殘差，GBDT在殘差減少（負梯度）的方向上建立一個新的模型。

提升樹模型算法原理

我們利用平方誤差來表示損失函數，其中每一棵回歸樹學習的是之前所有樹的結論和殘差 ，擬合得到一個當前的殘差回歸樹。提升樹即是整個迭代過程生成的回歸樹的累加。

GBDT需要將多棵樹的得分累加得到最終的預測得分，且每一次迭代，都在現有樹的基礎上，增加一棵樹去擬合前面樹的預測結果與真實值之間的殘差。

梯度提升樹模型算法原理

采用向前分布算法，先確定初始提升樹，然后每一次提升都是靠上次的預測結果與訓練數據中標簽值作為新的訓練數據進行重新訓練，利用損失函數的負梯度來擬合本輪損失函數的近似值，進而擬合一個CART回歸樹。

對于梯度提升回歸樹來說，每個樣本的預測結果可以表示為所有樹上的結果的加權求和。

GBDT正則化

子采樣比例方法: subsample（子采樣），取值為(0,1]，采用的不放回采樣。

定義步長v方法來防止過擬合: Shrinkage，即在每一輪迭代獲取最終學習器的時候按照一定的步長進行更新。

GBDT分裂規則

利用來構建Cart回歸樹的時候，GBDT分裂會選取使得誤差下降最多（如果cart樹采用的是均方差作為損失，那么就是最小均方差）的特征進行分裂，如果這棵樹不能擬合好，那么就要通過負梯度計算出新的殘差向量來擬合新的Cart回歸樹。

GBDT如何做特征選擇

特征 的全局重要度通過特征 在單顆樹中的重要度的平均值來衡量。

其中， 是樹的數量。特征 在單顆樹中的重要度（ 通過計算按這個特征i分裂之后損失的減少值 ）的如下：

其中， 為樹的葉子節點數量， 即為樹的非葉子節點數量（構建的樹都是具有左右孩子的二叉樹）， 是和節點 相關聯的特征， 是節點 分裂之后平方損失的減少值。

優點

• 相對少的調參時間情況下可以得到較高的準確率。
• 可靈活處理各種類型數據，包括連續值和離散值，使用范圍廣。
• 可使用一些健壯的損失函數，對異常值的魯棒性較強，比如Huber損失函數。

缺點

• 弱學習器之間存在依賴關系，難以并行訓練數據。
• 需要先處理缺失值。

X = dataset[['Open', 'High', 'Low', 'Volume']].values
y = dataset['Adj Close'].values
# 劃分訓練集與測試集略
from sklearn.ensemble import GradientBoostingRegressor
gb = GradientBoostingRegressor(max_depth=4, 
            n_estimators=200,
            random_state=2)
# 用訓練集訓練數據
gb.fit(X_train, y_train)
# 預測測試集標簽
y_pred = gb.predict(X_test)
from sklearn.metrics import mean_squared_error as MSE
# 計算 MSE
mse_test = MSE(y_test, y_pred)
# 計算 RMSE
rmse_test = mse_test**(1/2)
# 輸出 RMSE
print('Test set RMSE of gb: {:.3f}'.format(rmse_test))

模型提升

estimator_imp = tf.estimator.DNNRegressor(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ))
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None)

{'average_loss': 6.139895, 
'global_step': 1000, 
'loss': 1442.8754}

隨機森林回歸

隨機森林采用決策樹作為弱分類器，在bagging的樣本隨機采樣基礎上，?加上了特征的隨機選擇。

當前結點特征集合（ 個特征），隨機選擇 個特征子集，再選擇最優特征進行劃分。 控制了隨機性的引入程度，推薦值：

對預測輸出進行結合時，分類任務——簡單投票法；回歸任務——簡單平均法

采用有交疊的采樣子集的目的

1. 為集成中的個體學習器應盡可能相互獨立，盡可能具有較大差異，以得到泛化能力強的集成。對訓練樣本進行采樣，得到不同的數據集。
2. 如果采樣出的每個子集都完全不同，每個學習器只用到一小部分訓練數據，甚至不足以進行有效學習。
3. Bagging能不經修改的用于多分類、回歸等任務。而Adaboost只適用二分類任務有 的袋外數據用于驗證集。

算法

1. 從樣本集N中有放回隨機采樣選出n個樣本。
2. 從所有特征中隨機選擇k個特征，對選出的樣本利用這些特征建立決策樹(一般是CART方法)。
3. 重復以上兩步m次，生成m棵決策樹，形成隨機森林，其中生成的決策樹不剪枝。
4. 對于新數據，經過每棵決策樹投票分類。

隨機森林的優點

1. 決策樹選擇部分樣本及部分特征，一定程度上避免過擬合 。
2. 決策樹隨機選擇樣本并隨機選擇特征，模型具有很好的抗噪能力，性能穩定。
3. 能夠處理高維度數據，并且不用做特征選擇，能夠展現出哪些變量比較重要。
4. 對缺失值不敏感，如果有很大一部分的特征遺失，仍可以維持準確度。
5. 訓練時樹與樹之間是相互獨立的，訓練速度快，容易做成并行化方法。
6. 隨機森林有袋外數據obb，不需要單獨劃分交叉驗證集。

隨機森林的缺點

1. 可能有很多相似決策樹，掩蓋真實結果。
2. 對小數據或低維數據可能不能產生很好分類。
3. 產生眾多決策樹，算法較慢。

X = dataset.drop(['Adj Close', 'Close'], axis=1)  
y = dataset['Adj Close']

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, random_state=42)

# 數據標準化
scaler = StandardScaler().fit(X_train)
X_train_scaled = pd.DataFrame(scaler.transform(X_train), index=X_train.index.values, columns=X_train.columns.values)
X_test_scaled = pd.DataFrame(scaler.transform(X_test), index=X_test.index.values, columns=X_test.columns.values)

# PCA降維
from sklearn.decomposition import PCA
pca = PCA()
pca.fit(X_train)
cpts = pd.DataFrame(pca.transform(X_train))
x_axis = np.arange(1, pca.n_components_+1)

# 標準化后的降維
pca_scaled = PCA()
pca_scaled.fit(X_train_scaled)
cpts_scaled = pd.DataFrame(pca.transform(X_train_scaled))

模型建立與評價

from sklearn.ensemble import RandomForestRegressor
rf = RandomForestRegressor(n_estimators=500, oob_score=True, random_state=0)
rf.fit(X_train, y_train)
from sklearn.metrics import r2_score
from scipy.stats import spearmanr, pearsonr
    
predicted_train = rf.predict(X_train)
predicted_test = rf.predict(X_test)

test_score = r2_score(y_test, predicted_test)
spearman = spearmanr(y_test, predicted_test)
pearson = pearsonr(y_test, predicted_test)

print('Out-of-bag R-2 score estimate:', rf.oob_score_)
print('Test data R-2 score:', test_score)
print('Test data Spearman correlation:',spearman[0])
print('Test data Pearson correlation:',pearson[0])

Out-of-bag R-2 score estimate: 0.99895617164
Test data R-2 score: 0.999300318737
Test data Spearman correlation: 0.999380233068
Test data Pearson correlation: 0.999650364791

多輸出隨機森林回歸

X = dataset.drop(['Adj Close', 'Open'], axis=1)
Y = dataset[['Adj Close', 'Open']]
from sklearn.ensemble import RandomForestRegressor

model = RandomForestRegressor()
model.fit(X, Y)
data_in = [[23.98, 22.91, 7.00, 7.00, 1.62, 1.62, 4.27, 4.25]]
yhat = model.predict(data_in)
model.score(X, Y)
print(yhat[0])

[10.96199994 10.57600012]

XGBoost回歸

XGBoost是boosting算法的其中一種。Boosting算法的思想是將許多弱分類器集成在一起形成一個強分類器。因為XGBoost是一種提升樹模型，所以它是將許多樹模型集成在一起，形成一個很強的分類器。而所用到的樹模型則是CART回歸樹模型。

回歸樹的生成步驟如下

1. 從根節點開始分裂。
2. 節點分裂之前，計算所有可能的特征及它們所有可能的切分點分裂后的平方誤差（結構分數之差）。
3. 如果所有的平方誤差均相同或減小值小于某一閾值，或者節點包含的樣本數小于某一閾值，則分裂停止；否則，選擇使平方誤差最小的特征和切分點作為最優特征和最優切分點進行分裂，并生成兩個子節點。
4. 對于每一個新生成的子節點，遞歸執行步驟2和步驟3，直到滿足停止條件。

算法原理

不斷地添加樹，不斷地進行特征分裂來生長一棵樹，每次添加一個樹，其實是學習一個新函數，去擬合上次預測的殘差

當我們訓練完成得到k棵樹，我們要預測一個樣本的分數，其實就是根據這個樣本的特征，在每棵樹中會落到對應的一個葉子節點，每個葉子節點就對應一個分數

最后只需要將每棵樹對應的分數加起來就是該樣本的預測值。

XGB vs GBDT 核心區別：求解預測值的方式不同

GBDT中 預測值是由所有弱分類器上的預測結果的加權求和 ，其中每個樣本上的預測結果就是樣本所在的葉子節點的均值。

而XGBT中的 預測值是所有弱分類器上的葉子權重直接求和得到。 這個葉子權重就是所有在這個葉子節點上的樣本在這一棵樹上的回歸取值，用或者來表示，其中表示第棵決策樹， 表示樣本對應的特征向量

目標函數

第一項是衡量我們的偏差，模型越不準確，第一項就會越大。第二項是衡量我們的方差，模型越復雜，模型的學習就會越具體，到不同數據集上的表現就會差異巨大，方差就會越大。

代碼實現

X = dataset[['Open', 'High', 'Low', 'Volume']].values
y = dataset['Adj Close'].values
from xgboost import XGBRegressor

xgb = XGBRegressor(max_depth=5, learning_rate=0.01, n_estimators=2000, colsample_bytree=0.1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
xgb.fit(X_train,y_train)
y_pred = xgb.predict(X_test)
xgb.score(X_test, y_test)

人工神經網絡

深度神經網絡(DNN)回歸器

• 3層: 輸入、隱藏和輸出
• 特征: 輸入數據到網絡(特征)
• 標簽: 網絡輸出(標簽)
• 損失函數: 用于估計學習階段的性能的度量
• 優化器: 通過更新網絡中的知識來提高學習效果

數據準備

X = dataset.drop(['Adj Close', 'Close'], axis=1)  
y = dataset['Adj Close'] 
#  數據劃分略
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

數據轉換

## 數據歸一化
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

tensorflow結構

import tensorflow as tf
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

建模

estimator = tf.estimator.DNNRegressor(
    feature_columns=feature_columns,
    hidden_units=[300, 100])

# 訓練模型
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 
 >> >

{'average_loss': 6.4982734, 
'global_step': 1000, 
'loss': 1527.0942}



好了今天的總結就到這里，沒看夠到我們后面再見～