机器学习 梯度下降算法数学原理（以多元线性回归为例）及Python实现_基于梯度下降算法的回归分析原理及其python应用实现

1、参数说明

训练集中样本用$\hat{x}$表示，每个样本可以多个特征，第i个样本的第j个特征记为x_ij 用向量形式表示，则为$\widehat{x_i}$=[x_i1,x_i2,x_i3…x_in]^T
训练集每个样本的真实值用y表示，第i个样本的真实值为y_i
特征与真实值是基于训练目的来定的。比如训练一个输入身高体重，输出年龄的模型，则特征就为身高体重，样本真实值就为年龄。
模型对每个样本的预测值记为$h_{\theta }$($\hat{x}$)=${\theta }_0$+${\theta }_1{x}_1$+${\theta }_2{x}_2$…+${\theta }_n{x}_n$
其中，${\theta }_i$为样本$\hat{x}$的第i个特征对应的权重，即预测值为样本所有特征值的线性加权求和（梯度下降考虑的是线性加权求和，在此不考虑非线性）
若记x₀=1，则$h_{\theta }$($\hat{x}$)可写为${\sum }_{i=0}^n{\theta }_i{x}_i$
如果把权重也写成向量形式，即$\hat{\theta }$=[$\theta 1$,$\theta 2$,$\theta 3$…$\theta n$]^T，则预测值$h_{\theta }$($\hat{x}$)可写为$h_{\theta }$($\hat{x}$)=($\hat{\theta }$)^T$\hat{x}$。注意，真实值和预测值都是一个数值

2、梯度：

对一个多元函数F(x₁,x₂,…x_n)来说，记每个分量x_i方向上的单位矢量为$\widehat{e_i}$，则它的梯度$▽$F=$\frac{\partial F}{\partial x_1}$$\widehat{e_1}$+$\frac{\partial F}{\partial x_2}$$\widehat{e_2}$+…+$\frac{\partial F}{\partial x_n}$$\widehat{e_n}$。微积分告诉我们梯度在所有方向导数中增长最快，即在多元函数某一点，沿它的梯度方向增长是最快的。

3、批处理梯度下降

现在，假定有m个训练样本，初始的权重向量$\hat{\theta }$=[$\theta 1$,$\theta 2$,$\theta 3$…$\theta n$]^T，则损失函数可定义为J($\theta$)=$\frac{1}{2m}$ ${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)²，即每个样本的预测值减去真实值 的平方求和后乘$\frac{1}{2}$.平方放大了较大的误差，$\frac{1}{2}$在下面求偏导时会约去常数。
初始的权重向量下，损失函数可能会很大，梯度下降的目的就是为了降低损失函数。损失函数值小意味着模型预测值与真实值误差小。
把损失函数看成关于${\theta }_i$的多元函数J(${\theta }_1$,${\theta }_2$…${\theta }_n$)，对它求梯度，得到的方向就是损失函数增长最快的方向。因此，若把$\hat{\theta }$沿梯度负方向前进一点的$\hat{\theta }$代替原来的$\hat{\theta }$，损失函数就以最快速度减小的一点。不断迭代该过程，最终损失函数就会趋向于落在极小值点（极小值点：${\lim }_{\Delta \theta \to 0}J(\theta +\Delta \theta )>J(\theta )$)
在每一次迭代中,$\hat{\theta }$_k+1=$\hat{\theta }$_k-$\alpha$$▽$J($\theta$)，其中,$\alpha$为训练步长，即每次沿梯度方向前进多少。若$\alpha$过小，则前进速度过慢可能导致运行时间极长；若$\alpha$过大，则前进速度过快可能导致极小值点被跳过。因此，需要合理选择$\alpha$值的大小。
由于$▽$J($\theta$)=$\frac{1}{2m}$${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i) 2 $\frac{\partial (h_{\theta }(x_i)-y_i)}{\partial \theta }$。y_i对$\theta$求偏导为0，而$h_{\theta }$($\hat{x}$)=${\theta }_0$+${\theta }_1{x}_1$+${\theta }_2{x}_2$…+${\theta }_n{x}_n$=${\sum }_{i=0}^n{\theta }_i{x}_i$,对$\theta$求偏导后的向量为[x_i0$\frac{\widehat{{\theta }_0}}{|{\hat{\theta }}_0|}$,x_i1$\frac{\widehat{{\theta }_1}}{|{\hat{\theta }}_1|}$,x_i2$\frac{\widehat{{\theta }_2}}{|{\hat{\theta }}_2|}$,…x_in$\frac{\widehat{{\theta }_n}}{|{\hat{\theta }}_n|}$]^T.
因此$▽$J($\theta$) =$\frac{1}{m}$${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)[x₀$\frac{\widehat{{\theta }_0}}{|{\hat{\theta }}_0|}$, x_i1$\frac{\widehat{{\theta }_1}}{|{\hat{\theta }}_1|}$,x_i2$\frac{\widehat{{\theta }_2}}{|{\hat{\theta }}_2|}$,…x_in$\frac{\widehat{{\theta }_n}}{|{\hat{\theta }}_n|}$]^T =
$\frac{1}{m}$[${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_i0$\frac{\widehat{{\theta }_0}}{|{\hat{\theta }}_0|}$, ${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_i1$\frac{\widehat{{\theta }_1}}{|{\hat{\theta }}_1|}$, ${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_i2$\frac{\widehat{{\theta }_2}}{|{\hat{\theta }}_2|}$…${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_in$\frac{\widehat{{\theta }_n}}{|{\hat{\theta }}_n|}$]
因此上述方程的数学推导为：
$\hat{\theta }$_k+1=$\hat{\theta }$_k-$\alpha$$▽$J($\theta$)=$\hat{\theta }$_k-$\frac{\alpha }{m}$[${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_i0$\frac{\widehat{{\theta }_0}}{|{\hat{\theta }}_0|}$, ${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_i1$\frac{\widehat{{\theta }_1}}{|{\hat{\theta }}_1|}$, ${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_i2$\frac{\widehat{{\theta }_2}}{|{\hat{\theta }}_2|}$…${\sum }_{i=1}^m$($h_{\theta }$(x_i) - y_i)x_in$\frac{\widehat{{\theta }_n}}{|{\hat{\theta }}_n|}$]，即$\hat{\theta }$递减的每个分量为所有样本（m个）在相应下标特征（共n个特征）的加权累加。因此计算量极为巨大。
权重向量$\hat{\theta }$的初始值可以为零向量，也可以为一个随机向量。理论上一个多元函数可以有多个极小值点，即梯度下降的结果可能不同，但实际中一般都只有一个极小值点。

4、随机梯度下降法

当样本数量极大时，批处理梯度下降由于要处理所有样本的所有特征，计算力会不够用，运行时间也会极长。因此，若在m个样本中随机挑选p个向量用来进行梯度下降，运算时间会大大减少，并且，计算损失函数时每次只使用一个样本，即：
J($\theta$)=$\frac{1}{2m}$($h_{\theta }$(x_p)-y_p)^2
这样每次迭代时，权重向量$\hat{\theta }$_k+1=$\hat{\theta }$_k - $\alpha ▽J(\theta )$=$\hat{\theta }$_k - $\frac{\alpha }{m}$[($h_{\theta }[x_p]-y_p)$x_p0$\frac{\widehat{{\theta }_0}}{|{\hat{\theta }}_0|}$, ($h_{\theta }(x_p)-y_p)$x_p1$\frac{\widehat{{\theta }_1}}{|{\hat{\theta }}_1|}$, ($h_{\theta }(x_p)-y_p)$x_p2$\frac{\widehat{{\theta }_2}}{|{\hat{\theta }}_2|}$, ($h_{\theta }(x_p)-y_p)$x_pn$\frac{\widehat{{\theta }_n}}{|{\hat{\theta }}_n|}$ ]

5、算法收敛

一般由以下三种方法判断梯度下降结束。

1)预设循环次数，循环次数结束就结束

2)监测两次迭代间权重向量$\hat{\theta }$的变化量，当变化量减小的预设阈值时停止

3)监测两次迭代间损失函数J($\theta$)，当损失函数减小的预设阈值时停止

6、两种梯度下降的比较

批处理梯度下降由于每次迭代时涉及所有样本，因此精确度较高，但运行时间较长。而随机梯度下降由于只选择少量样本，因此精确度略低，但运行时间较短。且由于每次迭代时使用的都是一个样本的数值而不是样本的和，因此随机梯度下降运行完后大量的训练集可以删除，因为需要的样本都可以在运算中找到。

7、批处理梯度下降法用Python实现

#批处理梯度下降
#y = o1x1+o2x2 定为y = 2*x1+3*x2
#input x1 : 1 2 3 4
#input x2 : 5 6 8 7
#output y : 17 22 30 29
input_x = [[1,5],[2,6],[3,8],[4,7]]
output_y = [17,22,30,29]
theta = [0,0]#theta向量初值定为零向量
loss = 1#损失的初值
step_size = 0.001#步长
finish_loss = 0.01#算法收敛条件，损失小于这个值就结束
iter_count = 0#迭代次数
max_iters = 1000#最大迭代次数
error_1 = [0,0,0,0]#求o1梯度的中间变量,四个输入损失函数求梯度后的第一维
error_2 = [0,0,0,0]#求o2梯度的中间变量,四个输入损失函数求梯度后的第二维
while(loss > finish_loss and iter_count<max_iters):
    loss = 0
    errorsum_axis0 = 0#第1维的损失之和
    errorsum_axis1 = 0#第2维的损失之和
    #计算每个样本在2个维度上的损失
    for i in range(0,4):
        pred_yi = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
        error_1[i] = (pred_yi-output_y[i])*input_x[i][0]
        errorsum_axis0 += error_1[i]
        error_2[i] = (pred_yi-output_y[i])*input_x[i][1]
        errorsum_axis1 += error_2[i]
    #沿梯度方向下降
    theta[0] -= step_size/4*errorsum_axis0
    theta[1] -= step_size/4*errorsum_axis1
    #计算迭代后的损失
    for i in range(0,4):
        pred_y = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
        error_i = (1/(2*4))*(pred_y-output_y[i])**2#第i个样本的损失
        loss += error_i#将各项样本的损失累加
    iter_count += 1
    print('current iter_count:',iter_count)
    print(iter_count,'times loss is',loss)
print('iter_count:',iter_count)
print('theta vector:',theta)
print('loss',loss)
if iter_count == max_iters:
    print('Reason of convergence is iter_count meets prevalue')
else :
    print('Reason of convergence is loss meets prevalue')
print('end')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

运行结果：

8、随机梯度下降用Python实现

#随机梯度下降
#前面都与批处理一样
#y = o1x1+o2x2 定为y = 2*x1+3*x2
#input x1 : 1 2 3 4
#input x2 : 5 6 8 7
#output y : 17 22 30 29
import random
input_x = [[1,5],[2,6],[3,8],[4,7]]
output_y = [17,22,30,29]
theta = [0,0]#theta向量初值定为零向量
loss = 1#损失的初值
step_size = 0.01#步长
finish_loss = 0.01#算法收敛条件，损失小于这个值就结束
iter_count = 0#迭代次数
max_iters = 1000#最大迭代次数
#error_1 = [0,0,0,0]#求o1梯度的中间变量,四个输入损失函数求梯度后的第一维
#error_2 = [0,0,0,0]#求o2梯度的中间变量,四个输入损失函数求梯度后的第二维
while(iter_count<max_iters and loss > finish_loss):
    loss = 0 
    error_axis0 = 0#第1维的损失之和
    error_axis1 = 0#第2维的损失之和
    i = random.randint(0,3)#在0，1，2，3间返回一个随机数
    print((iter_count+1),'current random i is:',i)
    pred_yi = theta[0]*input_x[i][0]+theta[1]*input_x[i][1]
    error_axis0 = (pred_yi-output_y[i])*input_x[i][0]
    error_axis1 = (pred_yi-output_y[i])*input_x[i][1]
    theta[0] -= step_size*error_axis0
    theta[1] -= step_size*error_axis1
    for j in range(0,4):
        pred_y = theta[0]*input_x[j][0]+theta[1]*input_x[j][1]
        error_i = (1/(2*4))*(pred_y-output_y[j])**2#第i个样本的损失
        loss += error_i#将各项样本的损失累加
    iter_count += 1
    print('current iter_count:',iter_count)
    print('current loss:',loss)
print('iter_count:',iter_count)
print('theta vector:',theta)
print('loss',loss)
if iter_count == max_iters:
    print('Reason of convergence is iter_count meets prevalue')
else :
    print('Reason of convergence is loss meets prevalue')
print('end')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

运行结果

2018.11.25