摘要：還提供了，將多項式特征數(shù)據(jù)歸一化和線性回歸組合在了一起，大大方便的編程的過程。在機器學(xué)習(xí)算法中，主要的挑戰(zhàn)來自方差，解決的方法主要有降低模型復(fù)雜度降維增加樣本數(shù)使用驗證集模型正則化。

非線性曲線如圖：

假設(shè)曲線表達式為：$y=ax^2+bx+c$，如果將 $x^2$ 看作為 $x_1$，即 $y_1=ax_1+bx+c$，此時就有了兩個特征，則可以看作是線性曲線表達式。

首先生成一組樣本數(shù)據(jù)：

import numpy as np
import matplotlib.pyplot as plt

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, size=100)

(x, y) 如圖所示（橫軸為 x，縱軸為 y）：

接著在 $X$ 的基礎(chǔ)上增加一個新的特征 $x1(x^2)$ 形成一個新的 $X2$：

X2 = np.hstack([X, X**2])

再使用線性回歸算法：

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(X2, y)
y_predict = lin_reg.predict(X2)

此時對 $X2$ 的預(yù)測值反映到圖中就是第一張圖里的曲線。

對于增加新的特征（如：$x^2$），Scikit Learn 提供了 PolynomialFeatures，使用方式如下：

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=2)
poly.fit(X)
X2 = poly.transform(X)

參數(shù) degree 表示最高次冪；得到的新的 $X2$ 前5行數(shù)據(jù)如下：

# X2[:5,:]
array([[ 1.        ,  1.16207716,  1.35042333],
       [ 1.        , -2.62969804,  6.91531181],
       [ 1.        ,  0.99966958,  0.99933928],
       [ 1.        ,  0.35525362,  0.12620514],
       [ 1.        , -2.48933626,  6.19679503]])

第一列為 $x^0$，第二列為 $x$，第三列為 $x^2$。

Scikit Learn 還提供了 Pipeline，將多項式特征、數(shù)據(jù)歸一化和線性回歸組合在了一起，大大方便的編程的過程。使用方式如下：

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

poly_regression = Pipeline([
    ("poly", PolynomialFeatures(degree=2)),
    ("std_scaler", StandardScaler()),
    ("lin_reg", LinearRegression())
])

Pipeline() 傳入的是一個列表，包含了執(zhí)行每一個步驟的實例，每一個步驟又是一個元組類型，其中第二個表示實例，第一個表示給實例取的名稱。接著就可以進行 fit()、predict() 等內(nèi)容了：

poly_regression.fit(X, y)
y_predict = poly_regression.predict(X)

在使用多項式回歸的過程中需要考慮一個問題，即欠擬合和過擬合。

如果對前面的樣本單單使用線性回歸，得到的模型如圖（這里省略的代碼實現(xiàn)）：

訓(xùn)練出來的模型很簡單，但它并不能完整的表述數(shù)據(jù)之間的關(guān)系，這就是欠擬合（underfitting）。

如果使用多項式回歸，代碼如下：

def PolynomialRegression(degree):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lin_reg", LinearRegression())
    ])

poly100_reg = PolynomialRegression(degree=100)
poly100_reg.fit(X, y)

y_predict100 = poly100_reg.predict(X)

將 degree 設(shè)置為100，即最高次冪為 100，訓(xùn)練出來的模型對訓(xùn)練數(shù)據(jù) X 的預(yù)測結(jié)果如圖：

可見該模型對訓(xùn)練數(shù)據(jù)解釋的很好，但是如果用測試數(shù)據(jù)來預(yù)測一下：

X_plot = np.linspace(-3, 3, 100).reshape(-1, 1)
y_plot = poly100_reg.predict(X_plot)

可以看出對預(yù)測數(shù)據(jù)預(yù)測的非常糟糕，這是因為訓(xùn)練的模型過多的表達了訓(xùn)練數(shù)據(jù)中的噪音，從而造成了對預(yù)測數(shù)據(jù)的結(jié)果也含有了尋多噪音，這就是過擬合（overfitting）。

上面的過擬合出來的模型對訓(xùn)練數(shù)據(jù)解釋的很好，但對測試數(shù)據(jù)（新的數(shù)據(jù)）解釋的非常差，也就是模型的泛化能力差。

所以為了防止模型過擬合，通常將數(shù)據(jù)分為訓(xùn)練數(shù)據(jù)和測試數(shù)據(jù)，通過測試數(shù)據(jù)來檢驗是否過擬合。一般模型準確率與訓(xùn)練數(shù)據(jù)和測試數(shù)據(jù)的關(guān)系為：

圖形中左邊屬于欠擬合，右邊屬于過擬合，而中間對于測試數(shù)據(jù)模型準確率高的地方就是模型泛化能力好的地方。

除了模型復(fù)雜度曲線，還可以使用學(xué)習(xí)曲線來可視化欠擬合和過擬合。

所謂學(xué)習(xí)曲線，就是隨著訓(xùn)練樣本的逐漸增多，訓(xùn)練出的模型的能力的變化。

首先將數(shù)據(jù)分為訓(xùn)練數(shù)據(jù)和測試數(shù)據(jù)：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y)

learning_curve() 函數(shù)中使用均方誤差來表示模型的優(yōu)劣，并且訓(xùn)練數(shù)據(jù)（75個）從1個慢慢增大為75個，記錄對訓(xùn)練數(shù)據(jù)和測試數(shù)據(jù)預(yù)測值的均方誤差，用于畫學(xué)習(xí)曲線。

from sklearn.metrics import mean_squared_error  # 均方誤差

def learning_curve(algo, X_train, X_test, y_train, y_test):
    train_score = []
    test_score = []
    for i in range(1, 76):
        algo.fit(X_train[:i], y_train[:i])

        y_train_predict = algo.predict(X_train[:i])
        train_score.append(mean_squared_error(y_train[:i], y_train_predict))

        y_test_predict = algo.predict(X_test)
        test_score.append(mean_squared_error(y_test, y_test_predict))

先來看看使用線性回歸的情況（根據(jù)前文已經(jīng)知道是欠擬合）：

learning_curve(LinearRegression(), X_train, X_test, y_train, y_test)

作出的學(xué)習(xí)曲線如圖：

可以看出均方誤差最后趨于穩(wěn)定。

接著來看看使用多項式回歸并且設(shè)定最高次冪為2的情況：

poly2_reg = PolynomialRegression(degree=2)
learning_curve(poly2_reg, X_train, X_test, y_train, y_test)

作出的學(xué)習(xí)曲線如圖：

可以看出均方誤差最后也趨于穩(wěn)定，但是比過擬合情況下均方誤差的值要小，表示模型更好。

接著來看看使用多項式回歸并且設(shè)定最高次冪為20的情況：

poly20_reg = PolynomialRegression(degree=20)
learning_curve(poly20_reg, X_train, X_test, y_train, y_test)

作出的學(xué)習(xí)曲線如圖：

可以看出對訓(xùn)練數(shù)據(jù)的軍方誤差最后會趨于穩(wěn)定，但對測試數(shù)據(jù)則不然，這種情況就是過擬合的表現(xiàn)。

雖然將數(shù)據(jù)集劃分為訓(xùn)練數(shù)據(jù)集和測試數(shù)據(jù)集能夠為判斷模型是否過擬合提供參考，但這樣的劃分方式并不嚴謹，因為模型可能是針對測試數(shù)據(jù)集過擬合的。

更好的方式是將數(shù)據(jù)集劃分為訓(xùn)練數(shù)據(jù)集、驗證數(shù)據(jù)集和測試數(shù)據(jù)集。驗證數(shù)據(jù)集用于驗證模型的效果，方便調(diào)整超參數(shù)來改善模型；測試數(shù)據(jù)集用于衡量最終的模型性能。

但是這種方式也有可能對驗證數(shù)據(jù)集過擬合，此時可以使用交叉驗證（Cross Validation）。

交叉驗證即將數(shù)據(jù)集劃分為訓(xùn)練數(shù)據(jù)集和測試數(shù)據(jù)集，并將訓(xùn)練數(shù)據(jù)集分成 k 份，每次將其中一份作為驗證數(shù)據(jù)集，剩下的（k-1）份作為訓(xùn)練數(shù)據(jù)集，如此可以得到 k 個模型，再將這 k 個模型的均值作為結(jié)果調(diào)參。以 kNN 手寫數(shù)字識別算法舉例說明：

首先準備數(shù)據(jù)：

from sklearn import datasets
from sklearn.model_selection import train_test_split

digits = datasets.load_digits()
X = digits.data
y = digits.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4)

Scikit Learn 中提供了用于交叉驗證的 cross_val_score，模型將數(shù)據(jù)分成三份用于交叉驗證，返回三個模型的估算分數(shù)：

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score

knn_clf = KNeighborsClassifier()
cross_val_score(knn_clf, X_train, y_train)
# 返回 array([0.9640884 , 0.97506925, 0.96901408])

接著進行調(diào)參：

best_score, best_p, best_k = 0, 0, 0
for k in range(2, 10):
    for p in range(1, 5):
        knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=k, p=p)
        scores = cross_val_score(knn_clf, X_train, y_train)
        score = np.mean(scores)
        if score > best_score:
            best_score, best_p, best_k = score, p, k
            
print("best score is:", best_score)
print("best p is:", best_p)
print("best k is:", best_k)
# best score is: 0.9795997710242826
# best p is: 3
# best k is: 2

循環(huán)中每次比較 cross_val_score 返回數(shù)組的均值，最大的對應(yīng)的 k 和 p 就是最優(yōu)的超參數(shù)。

拿到了想要的超參數(shù)就可以進行模型訓(xùn)練了：

best_knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=2, p=3)
best_knn_clf.fit(X_train, y_train)
best_knn_clf.score(X_test, y_test)
# 結(jié)果0.9902642559109874

Scikit Learn 提供了網(wǎng)格搜索（GridSearchCV）整合了上面交叉驗證和調(diào)參的全過程：

from sklearn.model_selection import GridSearchCV

param_grid = [
    {
        "weights": ["distance"],
        "n_neighbors": [i for i in range(1, 11)],
        "p": [i for i in range(1, 6)]
    }
]

knn_clf = KNeighborsClassifier()
grid_search = GridSearchCV(knn_clf, param_grid=param_grid, verbose=1)
grid_search.fit(X_train, y_train)

grid_search.best_params_ 返回得到的最優(yōu)超參數(shù)；best_knn_clf = grid_search.best_estimator_ 返回最優(yōu)的模型。

在 cross_val_score 和 GridSearchCV 中可以指定參數(shù) cv 來設(shè)置將訓(xùn)練數(shù)據(jù)集分為幾份（默認為3）。

對于一個模型而言，模型誤差=偏差（Bias）+方差（Variance）+不可避免的誤差。偏差和方差表示如圖

導(dǎo)致偏差的主要原因是對問題本身的假設(shè)不正確，導(dǎo)致方差的主要原因是使用的模型太復(fù)雜。對于欠擬合，就屬于高偏差；而過擬合，就屬于高方差。

在機器學(xué)習(xí)算法中，主要的挑戰(zhàn)來自方差，解決的方法主要有：

降低模型復(fù)雜度；

降維；

增加樣本數(shù)；

使用驗證集；

模型正則化。

接下來主要看看模型正則化。

對于高方差的模型可以用模型正則化（Regularization）處理，限制參數(shù)的大小。

以使用梯度下降法的線性回歸為例，其目標函數(shù)為：使 $J( heta) = MSE(y, hat{y}; heta)$ 盡可能?。蝗绻Ｐ瓦^擬合，得到的 $ heta$ 就可能非常大，因此需要對 $J( heta)$ 加入限制是的 $ heta$ 盡可能小。

有兩種主要方式：嶺回歸和 LASSO 回歸。

嶺回歸（Ridge Regression）就是在目標函數(shù)中加入了 $alphafrac{1}{2}sum_{i=1}^n heta_i^2$，即使 $J( heta) = MSE(y, hat{y}; heta)+alphafrac{1}{2}sum_{i=1}^n heta_i^2$ 盡可能小。

Scikit Learn 中提供了 Ridge 類表示嶺回歸，參數(shù)為 $alpha$。使用過程如下：

from sklearn.linear_model import Ridge

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x + 3 + np.random.normal(0, 1, size=100)

def PolynomialRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("ridge_reg", Ridge(alpha=alpha))
    ])

設(shè)置 degree 為20，alpha 為0.0001 訓(xùn)練模型：

ridge_reg = PolynomialRegression(20, 0.0001)
ridge_reg.fit(X_train, y_train)

y_predict = ridge_reg.predict(X_test)

畫出來的圖形為：

設(shè)置 degree 為20，alpha 為1 訓(xùn)練模型：

ridge_reg = PolynomialRegression(20, 1)
ridge_reg.fit(X_train, y_train)

y_predict = ridge_reg.predict(X_test)

畫出來的圖形為：

相比之下模型好上了不少。

LASSO 回歸（Least Absolute Shrinkage and Selection Operator Regression）與嶺回歸不同的是使用 $alphasum_{i=1}^n| heta_i|$ 對 $ heta$ 進行限制，即使 $J( heta) = MSE(y, hat{y}; heta)+alphasum_{i=1}^n| heta_i|$ 盡可能小。

Scikit Learn 中提供了 Lasso 類表示嶺回歸，參數(shù)為 $alpha$。使用過程如下：

from sklearn.linear_model import Lasso

def LassoRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lasso_reg", Lasso(alpha=alpha))
    ])

設(shè)置 degree 為20，alpha 為0.01 訓(xùn)練模型：

lasso_reg = PolynomialRegression(20, 0.01)
lasso_reg.fit(X_train, y_train)

y_predict = lasso_reg.predict(X_test)

畫出來的圖形為：

設(shè)置 degree 為20，alpha 為0.1 訓(xùn)練模型：

lasso_reg = PolynomialRegression(20, 0.1)
lasso_reg.fit(X_train, y_train)

y_predict = lasso_reg.predict(X_test)

畫出來的圖形為：

相比之下模型也好上了不少。

LASSO 回歸相比嶺回歸趨向于使得一部分 $	heta$ 等于0，因此畫出來的曲線也相對更直一些。

彈性網(wǎng)（Elastic Net）則同時使用了嶺回歸和LASSO 回歸，即使用了 $alphafrac{1-r}{2}sum_{i=1}^n heta_i^2 +r alphasum_{i=1}^n| heta_i|$ 對 $ heta$ 進行限制。

使用上面的例子就是使 $J( heta) = MSE(y, hat{y}; heta)+alphafrac{1-r}{2}sum_{i=1}^n heta_i^2 +r alphasum_{i=1}^n| heta_i|$ 盡可能小。

Github | ML-Algorithms-Action