神经网络优化算法及代码实现——从SGD、Momentum、AdaGrad、RMSProp到Adam

梯度下降（Gradient Descent ）

$$x:=x-\alpha \cdot \mathrm{d}x$$
其中$\alpha$为学习率。代码如下：

while True:
    dx = compute_gradient(x)
    x += - learning_rate * dx #perform parameter update

带动量的梯度下降（Gradient Descent + Momentum）

$$\begin{gathered} v:=\rho \cdot v+\mathrm{d}w \\ x:=x-\alpha \cdot v \end{gathered}$$
$\rho$为动量因子，一般取0.9、0.99。动量的引入使下降的方向不仅受到当前梯度方向影响，还受到历史方向的影响，即有一个初速度。这使得本来由某一点开始的梯度下降过程是及其曲折的，并不是直接走向中心点，而是需要浪费很多时间折来折去，加入动量后会避免这个问题，加快学习速度。代码如下：

vx = 0
while True:
    dx = computed_gradient(x)
    vx = rho * vx + dx
    x += - learning_rate * vx

Nesterov Momentum

$$\begin{gathered} v:=\rho \cdot v-\alpha \cdot \mathrm{d}(x+\rho \cdot v) \\ x:=x+v \end{gathered}$$
Nesterov Momentum是对Momentum的改进，可以理解为nesterov动量在标准动量方法中添加了一个校正因子。变形代码：

while True:
	dx = compute_gradient(x)
	old_v = v
	v = rho * v - learning_rate * dx
	x += - rho * old_v + (1+rho) * v

AdaGrad

$$\begin{gathered} g=\mathrm{d}{x}^{\top }\cdot \mathrm{d}x \\ x:=x-\alpha \cdot \frac{\mathrm{d}x}{\sqrt{g}+ϵ} \end{gathered}$$
优点：抑制梯度大的维度的下降速度，增大梯度小的维度的下降速度。
缺点：随着迭代，步长越来越小，在非凸问题上容易卡在鞍点和局部极小值。
代码：

grad_squared = 0
while True:
    dx = compute_gradient(x)
    grad_squared += dx * dx
    x -= learning_rate * dx / (np.sqrt(grad_squared) + 1e-7)

RMSProp

$$\begin{gathered} g:=\beta \cdot g+(1-\beta )\cdot \mathrm{d}{x}^{\top }\cdot \mathrm{d}x \\ x:=x-\alpha \cdot \frac{\mathrm{d}x}{\sqrt{g}+ϵ} \end{gathered}$$
解决AdaGrad的缺点，类似给dx*dx加了动量, decay_rate $\beta$一般为 0.9、0.99。代码如下：

grad_squared = 0
while True:
    dx = compute_gradient(x)
    grad_squared = decay_rate * grad_squared + (1-decay_rate) * dx * dx
    x -= learning_rate * dx / (np.sqrt(grad_squared) + 1e-7)

Adam

$$\begin{gathered} g:={\beta }_1\cdot g+(1-{\beta }_1)\cdot \mathrm{d}x \\ gg:={\beta }_2\cdot gg+(1-{\beta }_2)\cdot \mathrm{d}{x}^{\top }\cdot \mathrm{d}x \\ x:=x-\alpha \cdot \frac{g}{\sqrt{gg}+ϵ} \end{gathered}$$
结合momentum和Ada的思想，真是秀操作啊。代码：
beta1 = 0.9
beta2 = 0.999
learning_rate = 1e-3 or 5e-4

first_moment = 0
second_moment = 0
while True:
    dx = computed_gradient(x)
    first_moment = beta1 * first_moment + (1-beta1) * dx  # Momentum
    second_moment = beta2 * second_moment + (1-beta2) * dx *dx #AdaGrad/RMSProp
    x -= learning_rate * first_moment / (np.sqrt(second_moment) + 1e-7)

上面的Adam前几次迭代的步长会非常大，这里增加了偏置矫正项t：
注意t的值会随着迭代次数增加

first_moment = 0
second_moment = 0
for t in range(num_iterations):
    dx = compute_gradient(x)
    first_moment = beta1 * first_moment + (1-beta1) * dx
    second_moment = beta2 * second_moment = （1-beta2) * dx * dx
    first_unbias = first_moment / (1 - beta1 ** t) #偏置纠正
    second_unbias = second_moment / (1 - beta2 ** t)
    x -= learning_rate * first_unbias / (np.sqrt(second_unbias) + 1e-7)

至此，欢迎交流，谢谢指正！
[1]https://blog.csdn.net/u012328159/article/details/80311892
[2]https://www.bilibili.com/video/av53754154/?p=3