內容:線性回歸；邏輯回歸，應用場景。

一、線性回歸

有監督學習，根據學習樣本{x->y},學習一個映射f：X->Y(線性相關),輸出預測結果y_i。最簡單的例子：y=ax+b

重要組成：訓練數據集 training set, 學習算法 learning algorithm, 損失函數 loss function.

訓練數據集：x-->y的對應數據

損失函數cost： 權衡訓練到的x-y的映射的好壞，最小化這個損失函數。 比較常見的最小二乘法，一般為凸函數

學習算法：梯度下降，逐步最小化損失函數，朝著斜率為負的方向邁進。關鍵知識點：學習率，終止條件，欠/過擬和，正則化

過擬合：特征過多，對源數據擬合的很好但是喪失了一般性，對預測樣本預測效果差

欠擬合：模型沒有很好地捕捉到數據特征，不能夠很好地擬合數據 。

正則化：類似於模型參數與誤差的平方和最小（L2）.

例，擬合一個y=ax+b.

取X_i=[x1,x2]^T,$$\theta=[a,b], y_i=\theta*X$$

，

python代碼實現:

##梯度下降的過程

import numpy as np

def gradientDesc(x,y, theta=np.zeros((2,1)),alpha=.01,iterations=1000):

    m=y.size
    J=[]

    for numbers in range(iterations):
        a = theta[0][0] - alpha * (1 / m) * sum((x.dot(theta).flatten() - y.flatten() ) * x[:, 0])
        b = theta[1][0] - alpha * (1 / m) * sum((x.dot(theta).flatten() - y.flatten() ) * x[:, 1])
        theta[0][0],theta[1][0] = a,b
        J.append(cost(x,y,theta))
        if numbers%100==0:print("第%d步:%.3f,%.3f"%(numbers+100,theta[0][0],theta[1][0]))
    return theta
def cost(x,y,theta=np.zeros((2,1))):
    m=len(x)
    J = 1 / (2 * m) * sum((x.dot(theta).flatten() - y) ** 2)
    return J

##測試
 

x=np.array([[1,2],[2,1],[3,1],[4.1,1]])
y=np.array([[1],[2],[3],[4.1]])

theta = gradientDesc(x,y)

二、邏輯回歸

邏輯回歸一般解決分類問題，離散點，回歸+閾值（sigmoid）,損失函數--》判定邊界。多分類可以設計多個分類器。

梯度：

基本函數：

#### 帶正則化項的損失函數
#### $$ J(\theta) = \frac{1}{m}\sum_{i=1}^{m}\big[-y^{(i)}\, log\,( h_\theta\,(x^{(i)}))-(1-y^{(i)})\,log\,(1-h_\theta(x^{(i)}))\big] + \frac{\lambda}{2m}\sum_{j=1}^{n}\theta_{j}^{2}$$
#### 向量化的損失函數
#### $$ J(\theta) = \frac{1}{m}\big((\,log\,(g(X\theta))^Ty+(\,log\,(1-g(X\theta))^T(1-y)\big) + \frac{\lambda}{2m}\sum_{j=1}^{n}\theta_{j}^{2}$$

#### 偏導(梯度)

#### $$ \frac{\delta J(\theta)}{\delta\theta_{j}} = \frac{1}{m}\sum_{i=1}^{m} ( h_\theta (x^{(i)})-y^{(i)})x^{(i)}_{j} + \frac{\lambda}{m}\theta_{j}$$
#### 向量化
#### $$ \frac{\delta J(\theta)}{\delta\theta_{j}} = \frac{1}{m} X^T(g(X\theta)-y) + \frac{\lambda}{m}\theta_{j}$$
##### $$\text{Note: 要註意的是參數 } \theta_{0} \text{ 是不需要正則化的}$$

##定義sigmoid函數
def sigmoid(z):
    return(1 / (1 + np.exp(-z)))

# 定義損失函數

def costFunctionReg(theta, reg, *args):
    m = y.size
    h = sigmoid(XX.dot(theta))

    J = -1 * (1 / m) * (np.log(h).T.dot(y) + np.log(1 - h).T.dot(1 - y)) + (reg / (2 * m)) * np.sum(
        np.square(theta[1:]))

    if np.isnan(J[0]):
        return (np.inf)
    return (J[0])


def gradientReg(theta, reg, *args):
    m = y.size
    h = sigmoid(XX.dot(theta.reshape(-1, 1)))

    grad = (1 / m) * XX.T.dot(h - y) + (reg / m) * np.r_[[[0]], theta[1:].reshape(-1, 1)]

    return (grad.flatten())

我的機器學習之旅（四）：回歸與工程應用