多元线性回归与梯度下降法原理及公式推导（附Python代码）

引

以线性方程为例，设有线性方程：

$$y_{true}={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2\dots +{\theta }_n{x}_n$$

如果现在我们手头上已经有了N组数据，其中第$i$组数据为$[x_{i,1}{x}_{i,2}{x}_{i,3}\dots x_{i,n}]$和其对应的$y_{i,true}$。

我们想要通过这N组数据，估计出上述方程中的${\theta }_0$到${\theta }_n$。

现在问题转化为：

我们想求出一组$\hat{\theta }$，使得这组$\hat{\theta }$无限逼近上述方程中的$\theta$，又因为真实的$\theta$是未知的，我们无法直接比较两者的误差关系，所以我们引入Lose Function即误差函数来描述我们求得的$\hat{\theta }$到底准确与否。

有:

$$Lose=J=\frac{1}{N}\sum _{i=1}^N(y_{i,ture}-\widehat{y_i}{)}^2$$

又因为，若设$x_0=1$有：

$$\hat{y}=\widehat{{\theta }_0}{x}_0+\widehat{{\theta }_1}{x}_1+\widehat{{\theta }_2}{x}_2\dots +\widehat{{\theta }_n}{x}_n$$

则$LoseFunction$可改写为：

$$J=\frac{1}{N}\sum _{i=1}^N(y_{i,ture}-\widehat{{\theta }_0}{x}_0-\widehat{{\theta }_1}{x}_1-\widehat{{\theta }_2}{x}_2\dots -\widehat{{\theta }_n}{x}_n{)}^2$$

可知上述误差函数$J$有极小值，且使得$J$最小的那一组$\hat{\theta }$最接近真实的$\theta$。

形象理解梯度下降

我们把问题简化一下若要求的线性方程为：

$$y=\theta x$$

则根据上述$LoseFunction$可得出以下关系：

要想让误差值即$J$的值最小，目前估计的点P就需要朝着蓝色箭头的方向移动，直到找到这个二次曲线的极小值即最小值点。在程序中，若想让P向目标点移动，需要加上$-\eta \frac{dJ}{d\theta },\theta ={\theta }_p$。这里的$\eta$就是学习率。

通过不断的移动P点，使得该次计算的$J$值与上一次计算的$J$值只差小于一个阀值，我们就认为找到了这个极小值点，且当前的$\hat{\theta }$接近真实的$\theta$。

而这个过程就是对$LoseFunction$优化的过程。

梯度下降解决线性回归的原理

回到之前我们讨论的线性方程：

$$y_{true}={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2\dots +{\theta }_n{x}_n$$

对于多元线性方程的优化过程，由于参数由一个变成多个，所以这里的导数也上升为梯度，即$J$在其所在点要对当前组中${\theta }_0$到${\theta }_n$均求偏导，而这样一组求偏导结果构成该点的梯度。

我们令$x_0=1$，则原方程可以改写为：

$$y_{true}={\theta }_0{x}_0+{\theta }_1{x}_1+{\theta }_2{x}_2\dots +{\theta }_n{x}_n$$

有$LoseFunction$为：

$$J=\frac{1}{N}\sum _{i=1}^N(y_{i,ture}-\widehat{{\theta }_0}{x}_0-\widehat{{\theta }_1}{x}_1-\widehat{{\theta }_2}{x}_2\dots -\widehat{{\theta }_n}{x}_n{)}^2$$

上式$J$对${\theta }_0$求偏导的结果为：

$$\frac{\partial J}{\partial {\theta }_0}=\frac{2}{N}\sum _{i=1}^N(y_{i,true}-\widehat{{\theta }_0}{x}_0-\widehat{{\theta }_1}{x}_1-\widehat{{\theta }_2}{x}_2\dots -\widehat{{\theta }_n}{x}_n)(-x_0)$$

即：

$$\frac{\partial J}{\partial {\theta }_0}=\frac{2}{N}\sum _{i=1}^N(y_{i,true}-\hat{\theta }x)(-x_0)$$

=>$\frac{\partial J}{\partial {\theta }_0}=\frac{2}{N}{\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_0)$，左式中$\hat{\theta }$为行向量，$x$为列向量。

则$J$对${\theta }_i$求偏导的结果为：

$$\frac{\partial J}{\partial {\theta }_0}=\frac{2}{N}\sum _{i=1}^N(\hat{\theta }x-y_{i,true})(x_i)$$

这样求完所有$\theta$的偏导，构成该点的梯度：

$$\frac{\nabla J}{\nabla \theta }=\left[\begin{array}{c}\frac{\partial J}{\partial {\theta }_0}=\frac{2}{N}{\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_0)\\ \frac{\partial J}{\partial {\theta }_1}=\frac{2}{N}{\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_1)\\ \frac{\partial J}{\partial {\theta }_2}=\frac{2}{N}{\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_2)\\ \dots \\ \dots \\ \frac{\partial J}{\partial {\theta }_n}=\frac{2}{N}{\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_n)\end{array}\right]$$

若此时估计的$\theta$为：

$${\hat{\theta }}_{now}=\left[\begin{array}{c}\widehat{{\theta }_0}\\ \widehat{{\theta }_1}\\ .\\ .\\ .\\ \widehat{{\theta }_n}\end{array}\right]$$

若学习率为$\eta$，则下一次迭代的${\hat{\theta }}_{next}$为：

$${\hat{\theta }}_{next}={\hat{\theta }}_{now}-\eta \frac{\nabla J}{\nabla \theta }=\left[\begin{array}{c}\widehat{{\theta }_0}\\ \widehat{{\theta }_1}\\ \widehat{{\theta }_2}\\ .\\ .\\ \widehat{{\theta }_n}\end{array}\right]-\frac{2\eta }{N}\left[\begin{array}{c}{\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_0)\\ {\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_1)\\ {\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_2)\\ \dots \\ \dots \\ {\sum }_{i=1}^N(\hat{\theta }x-y_{i,true})(x_n)\end{array}\right]$$

有的地方将除以$N$凑成除以$2N$这样后边的因数化简为$-\frac{\eta }{N}$。

以上便是梯度下降解决线性回归的原理，大家可以自行对公式进行推导加深理解，附上Python仿真代码。

Python仿真代码

import matplotlib.pyplot as plt
import numpy as np


# 根据当前的theta求Y的估计值
# 传入的data_x的最左侧列为全1，即设X_0 = 1
def return_Y_estimate(theta_now, data_x):
    # 确保theta_now为列向量
    theta_now = theta_now.reshape(-1, 1)
    _Y_estimate = np.dot(data_x, theta_now)

    return _Y_estimate


# 求当前theta的梯度
# 传入的data_x的最左侧列为全1，即设X_0 = 1
def return_dJ(theta_now, data_x, y_true):
    y_estimate = return_Y_estimate(theta_now, data_x)
    # 共有_N组数据
    _N = data_x.shape[0]
    # 求解的theta个数
    _num_of_features = data_x.shape[1]
    # 构建
    _dJ = np.zeros([_num_of_features, 1])
    
    for i in range(_num_of_features):
        _dJ[i, 0] = 2 * np.dot((y_estimate - y_true).T, data_x[:, i]) / _N
    
    return _dJ


# 计算J的值
# 传入的data_x的最左侧列为全1，即设X_0 = 1
def return_J(theta_now, data_x, y_true):
    # 共有N组数据
    N = data_x.shape[0]
    temp = y_true - np.dot(data_x, theta_now)
    _J = np.dot(temp.T, temp) / N
    
    return _J


# 梯度下降法求解线性回归
# data_x的一行为一组数据
# data_y为列向量，每一行对应data_x一行的计算结果
# 学习率默认为0.3
# 误差默认为1e-8
# 默认最大迭代次数为1e4
def gradient_descent(data_x, data_y, Learning_rate = 0.01, ER = 1e-10, MAX_LOOP = 1e5):
    # 样本个数为
    _num_of_samples = data_x.shape[0]
    # 在data_x的最左侧拼接全1列
    X_0 = np.ones([_num_of_samples, 1])
    new_x = np.column_stack((X_0, data_x))
    # 确保data_y为列向量
    new_y = data_y.reshape(-1, 1)
    # 求解的未知元个数为
    _num_of_features = new_x.shape[1]
    # 初始化theta向量
    theta = np.zeros([_num_of_features, 1]) * 0.3
    flag = 0  	# 定义跳出标志位
    last_J = 0  # 用来存放上一次的Lose Function的值
    ct = 0  	# 用来计算迭代次数
    
    while flag == 0 and ct < MAX_LOOP:
        last_theta = theta
        # 更新theta
        gradient =  return_dJ(theta, new_x, new_y)
        theta = theta - Learning_rate * gradient
        er = abs(return_J(last_theta, new_x, new_y) - return_J(theta, new_x, new_y))
        
        # 误差达到阀值则刷新跳出标志位
        if er < ER :
            flag = 1
        
        # 叠加迭代次数
        ct += 1
        
    return theta
            

def main():
    # =================== 样本数据生成 =======================
    # 生成数据以1元为例,要估计的theta数为2个
    num_of_features = 1
    num_of_samples = 2000
    # 设置噪声系数
    rate = 0
    X = []
    
    for i in range(num_of_features):
        X.append(np.random.random([1, num_of_samples]) * 10)
        
    X = np.array(X).reshape(num_of_samples, num_of_features)
    print("X的数据规模为 ： ", X.shape)
    
    # 利用方程生成X对应的Y
    Y = []

    for i in range(num_of_samples):
        Y.append(3 + 3.27 * X[i][0] + np.random.rand() * rate)

    Y = np.array(Y).reshape(-1, 1)
    print("Y的数据规模为 ： ", Y.shape)
    # ======================================================
    
   	# 计算并打印结果
    print(gradient_descent(X, Y))
    

if __name__ == '__main__':
    main()