【機器學習】回歸分析、過擬合、分類

一、Linear Regression

線性回歸是相對簡單的一種，表達式如下

其中，θ0表示bias，其他可以看做weight，可以轉換為如下形式

為了更好回歸，定義損失函數，並盡量縮小這個函數值，使用MSE方法（mean square equal）

縮小方法采用梯度下降法，即不斷地向現在站立的山坡往下走，走的速度就是學習速率η（learning rate），太小耗盡計算資源，太大走過了山谷。

（1）Normal Equation

from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt

# 數據集
X = 2*np.random.rand(100, 1)
y = 4+3*X+np.random.randn(100,1)

# X每個元素加1
X_b = np.c_[np.ones((100,1)), X]
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)

# 訓練
lin_reg = LinearRegression()
lin_reg.fit(X, y)
print(lin_reg.intercept_, lin_reg.coef_)

# 測試數據
X_new = np.array([[0],[2]])
X_new_b = np.c_[np.ones((2,1)), X_new]
y_predict = X_new_b.dot(theta_best)
print(y_predict)

# 畫圖
plt.plot(X_new, y_predict, "r-")
plt.plot(X, y, "b.")
plt.axis([0,2,0,15])
plt.show()

（2）Batch Gradient Descent

　　基本算是遍歷了所有數據，不適用於數據規模大的數據

# BGD梯度下降
eta = 0.1
n_iterations = 1000
m = 100
theta = np.random.randn(2,1)
for iteration in range(n_iterations):
    gradients = 2/m * X_b.T.dot(X_b.dot(theta) - y)
    theta = theta - eta*gradients
print(theta)

可以看出，結果是差不多的

（3）Stochastic Gradient Descent

　　可以避免局部最優結果，但是會震來震去。為了防止這種震盪，讓學習速率η不斷減小（類似模擬退火）

# SGD梯度下降
m = 100
n_epochs = 50
t0, t1 = 5, 50 # η初始值0.1
def learning_schedule(t):
    return t0 / (t + t1)

theta = np.random.randn(2,1) # random initialization
for epoch in range(n_epochs):
    for i in range(m):
        random_index = np.random.randint(m)
        xi = X_b[random_index:random_index+1]
        yi = y[random_index:random_index+1]
        gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(epoch * m + i)
        theta = theta - eta * gradients
print(theta)

# sklearn 提供了SGDRegressor的方法
from sklearn.linear_model import SGDRegressor
sgd_reg = SGDRegressor(max_iter=50, penalty=None, eta0=0.1)
sgd_reg.fit(X, y.ravel())
print(sgd_reg.intercept_, sgd_reg.coef_)

（4）Min-batch Gradient Descent

　　使用小批隨機數據，結合SGD與BGD優點

以下是各種方法對比

二、Polynomial Regression

但有的時候，y本身是由x取平方所得，無法找出來一條合適的線性回歸線來擬合數據，該怎么辦呢？

我們可以嘗試將x取平方，取3次方等方法，多加嘗試

三、誤差分析

四、防止過擬合

用懲罰系數（penalty），即正則項（regularize the model）

（1）嶺回歸ridge regression

　　控制參數自由度，減少模型復雜度。所控制的α=α，越大控制結果越強

　優勢：直接用公式可以計算出結果

 

from sklearn.linear_model import Ridge
ridge_reg = Ridge(alpha=1, solver="cholesky")
ridge_reg.fit(X, y)

 

(2)Lasso Regression（least absolute shrinkage and selection operator regression）

正則化項同ridge regression不同，正則化的控制更強

 

# Lasso Regression
from sklearn.linear_model import Lasso
lasso_reg = Lasso(alpha=0.1)
lasso_reg.fit(X, y)
lasso_reg.predict([[1.5]])

對於高階degree regularize尤為明顯，是一個sparse model，很多高階參數項成為了0

 （3）Elastic Net（一般推薦使用）

 相當於ridge和lasso regression的結合，用超參數r來控制其平衡

# Elastic Net
from sklearn.linear_model import ElasticNet
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5)
elastic_net.fit(X, y)

（4）Early Stopping

找到開始上升的點，從那里停止（整體找到，取最優的）

from sklearn.base import clone
sgd_reg = SGDRegressor(n_iter=1, warm_start=True, penalty=None,
                                             learning_rate="constant", eta0=0.0005)
minimum_val_error = float("inf")
best_epoch = None
best_model = None
for epoch in range(1000):
    sgd_reg.fit(X_train_poly_scaled, y_train) # continues where it left off
    y_val_predict = sgd_reg.predict(X_val_poly_scaled)
    val_error = mean_squared_error(y_val_predict, y_val)
    if val_error < minimum_val_error:
        minimum_val_error = val_error
        best_epoch = epoch
        best_model = clone(sgd_reg)

五、Logistic Regression（可用作分類）

（使用sigmod函數，y在（0,1）之間）

定義cost function，由於p在（0,1）之間，故最前面加一個符號，保證代價始終為正的。p值越大，整體cost越小，預測的越對

即

不存在解析解，故用偏導數計算

以Iris花的種類划分為例

import matplotlib.pyplot as plt
from sklearn import datasets
iris = datasets.load_iris()
print(list(iris.keys()))
# ['DESCR', 'data', 'target', 'target_names', 'feature_names']
X = iris["data"][:, 3:] # petal width
y = (iris["target"] == 2).astype(np.int) # 1 if Iris-Virginica, else 0

from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X, y)
X_new = np.linspace(0, 3, 1000).reshape(-1, 1)
# estimated probabilities for flowers with petal widths varying from 0 to 3 cm:
y_proba = log_reg.predict_proba(X_new)

plt.plot(X_new, y_proba[:, 1], "g-", label="Iris-Virginica")
plt.plot(X_new, y_proba[:, 0], "b--", label="Not Iris-Virginica")
plt.show()
# + more Matplotlib code to make the image look pretty

六、Softmax Regression

可以用做多分類

使用交叉熵

　　

X = iris["data"][:, (2, 3)] # petal length, petal width
y = iris["target"]
softmax_reg = LogisticRegression(multi_class="multinomial",solver="lbfgs", C=10)
softmax_reg.fit(X, y)

print(softmax_reg.predict([[5, 2]]))
# array([2])
print(softmax_reg.predict_proba([[5, 2]]))
# array([[ 6.33134078e-07, 5.75276067e-02, 9.42471760e-01]])