1.梯度下降图形解释

  • 上一篇已经介绍了代价函数J(θ0,θ1)，我们的目的是要求出使代价函数最小的θ0、θ1，那么我们先从三维图像来描述一下梯度下降怎样寻找代价函数的最小值。

​ 这里就是一个J(θ0,θ1)的图像，要找J的最小值，这里假设图像是一座一座山峰，我们就从任意一个点出发，先假设 θ0=0,θ1=0，取得J的值在红色的山上，这时假如我们要快速下山，我们就环顾四周寻找下降最快的方向，向下走一小步，得到了新的θ0,θ1，这时我们又重新环顾四周找下一个下降最快的方向，以此类推，我们就到了山底，此时的θ0,θ1就是我们想要的，我们得到了一个局部最优解。

​ 当然如果我们最初选的点不是θ0=0,θ1=0的点，假如刚开始的点靠右一点，重复上述步骤，梯度下降就将带领我们到另一个山底，就有了另一个与之前完全不一样的局部最优解。如下图所示：

这就是梯度下降的特点，后面我们会讨论这个问题。

2.梯度下降的数学解释

  • 这里强调一点θ0,θ1是同时更新的，temp0和temp1所求的偏导都是上一次的θ0和θ1。ɑ 为学习速率，他控制我们以多大的速率来更新参数。

  • 下面讨论仅有θ1的情况，即代价函数为J(θ1)，此时的temp1如下：

​ 这时的temp1中求导部分就是求得斜率，假设θ1在右边，斜率为正，那么下一次的θ1就是减去ɑ斜率，得到的θ1变小，逐渐向左；反之当θ1在左边，斜率为负，那么下一次的θ1就是减去ɑ\斜率(<0)，得到的θ1变大，逐渐向右。

  • 下面讨论ɑ的取值大小对梯度下降的影响

    当ɑ较小时，则J(θ1)向最小值移动的速度会比较慢，但最终会到达最小值点，只是下降速率很慢。

    当ɑ较大时，每走一步太大，可能永远都不能到达最小值点，甚至越离越远，最后无法收敛甚至发散。

  • 如果此时已经是最低点了，那么此时的斜率就为0，他就不会继续下降，所得的就是我们要找的θ1。

  • 当θ1所对应的变化率较大时，θ1下降的幅值就越大，反之当θ1对应的变化率较小时，θ1下降的幅值就越小，所以梯度下降是自动改变J(θ1)的变化速度的，即我们不需要实时改变ɑ。

3.梯度下降的最终表示总结

  • 下面将J(θ0,θ1)带入到梯度下降的公式里面:

即：

4.用python实现线性回归的梯度下降(“Batch” Gradient Descent)

  • 线性回归的问题可以用到梯度下降，只要每一次的θ0,θ1按照上面的公式进行，就可以实现直线拟合，下面作者使用了python中的matplotlib来进行可视化，更清楚的了解梯度下降的线性回归。

    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
    46
    47
    48
    49
    50
    51
    52
    53
    import matplotlib.pyplot as plt
    x_train = [100,80,120,75,60,43,140,132,63,55,74,44,88] #数据集
    y_train = [120,92,143,87,60,50,167,147,80,60,90,57,99]

    alpha = 0.00001    #a步长
    m = len(x_train)   #数据集长度


    def h(x,theta_list):
    	"""假设函数，传入参数为x，和theta_list列表，[theta0，theta1]，返回h(x)的值"""
    	return theta_list[1]*x + theta_list[0]

    def Get_theta(theta_list):
    	"""求下一次的θ0和θ1，返回他们的列表，传入的是上一次的θ0和θ1"""
    	theta0_sum = 0
    	theta1_sum = 0
    	for i in range(m):
    		theta0_sum+=(h(x_train[i],theta_l·ist)-y_train[i])
    		theta1_sum+=(h(x_train[i],theta_list)-y_train[i])*x_train[i]
    	theta1=theta_list[1]-alpha/m*theta1_sum
    	theta0=theta_list[0]-alpha/m*theta0_sum
    	return [theta0,theta1]
    def J(theta_list):
    	"""代价函数"""
    	result = 0
    	for i in range(m):
    		result += ((y_train[i] - (theta_list[0] + theta_list[1] * x_train[i])) ** 2) /2/m
    	return result

    def main():
    	result_last=0
    	result=0
    	plt.plot(x_train,y_train,'go')   #画数据集
    	n = 0                            #更新次数
    	theta_list = [0,0]
    	while True:
    		theta_list = Get_theta(theta_list)
    		result = J(theta_list)
    		print(abs(result - result_last))        #输出前后两次的幅值差值
    		if n % 5 == 0:
    			plt.plot(x_train,[h(x,theta_list) for x in x_train],'blue')  #每隔5次画一条拟合的蓝线
    		n = n + 1
    		if abs(result - result_last) < 0.00001:    #判断前后两次的幅值是否小于0.00001，表示达到最优解
    			break					
    		else:
    			result_last = result
    	print(n)
    	plt.plot(x_train,[h(x, theta_list) for x in x_train],'red') #画出最终的拟合出来的结果	
    	plt.show()

    if __name__ == '__main__':
    	main()

    经过拟合之后画出的图像如下：，蓝色是每隔5次梯度下降的结果，最后的红色线是最终拟合出来的，发现拟合结果较好。

输出的结果如下：

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
4504.186913638355
671.3310878745829
571.0121868517417
485.6842226173276
413.10705713650077
351.3753025295284
298.86829841041344
254.20756425312902
216.22060977096407
183.91015321312648
156.42793945824315
133.05247054411154
113.17006398730985
96.2587416116138
81.87452591429951
69.6397842051465
59.23331451367534
50.3819129872748
42.853201396852626
36.44952644857389
31.002770738689122
26.36993912203485
22.429404621961453
19.077715324546077
16.22687842762265
13.80205014203905
11.739570797495972
9.985293568070375
8.493162941005416
7.224005608925999
6.144502042446071
5.22631174358542
4.445329215041596
3.781051112073655
3.2160379626685014
2.73545632438449
2.3266893579893555
1.979005594180542
1.683277197431007
1.4317403304630503
1.2177913281371993
1.0358133296511092
0.8810288175806704
0.7493741924269344
0.6373930898443572
0.5421456397758924
0.461131285252538
0.3922231345973213
0.33361212356539127
0.2837595214924651
0.2413565345847779
0.2052899458023809
0.17461288927263574
0.148519991965113
0.1263262300167245
0.10744894461538301
0.09139254530129293
0.07773549909730626
0.06611926388976208
0.05623887552603435
0.047834941508360984
0.04068683109269777
0.03460688301041337
0.02943547874640906
0.025036852031139034
0.02129552453241601
0.01811327417135722
0.0154065564718735
0.013104311244887867
0.011146097026182744
0.009480504290294789
0.008063805782375866
0.006858808534742522
0.005833877430042378
0.004962104675847456
0.004220603387107502
0.0035899067307632038
0.003053456857548653
0.002597170204365895
0.0022090677548600723
0.0018789605507478768
0.001598182198762288
0.0013593613491309497
0.001156228173753604
0.000983449762603783
0.0008364901175763606
0.0007114910674754782
0.000605170978552394
0.000514738600895015
0.0004378197888890156
0.00037239517227760643
0.000316747140949758
0.00026941475214670163
0.0002291553759317111
0.00019491207202904093
0.00016578584178716937
0.0001410120263809489
0.00011994023224559669
0.00010201725580216703
8.677256037081804e-05
7.380592283290355e-05
6.277692660638934e-05
5.339602441445379e-05
4.5416936940156916e-05
3.863018707583876e-05
3.285760040050434e-05
2.7947627637914252e-05
2.3771366009839312e-05
2.0219174929891892e-05
1.719779781517161e-05
1.462791361639404e-05
1.2442054456940355e-05
1.0582834423900067e-05
9.00144288351612e-06
114
  • 可以发现前面的下降速率比较快，越向后下降速率越慢，最终θ0，θ1改变了114次得到了最优解，完美拟合直线，与之前的理论相对应。