1 梯度下降 Gradient Descent

梯度下降沿着导数的负方向更新参数。
批量梯度下降法（Batch Gradient Descent）：在更新参数时使用所有的样本来进行更新。
随机梯度下降法（Stochastic Gradient Descent）：每次仅仅随机选取一个样本j来求梯度。
小批量梯度下降法（Mini-batch Gradient Descent）：小批量梯度下降法是批量梯度下降法和随机梯度下降法的折衷。

2 带momentum梯度下降

考虑上一次的权重和偏差，并取一个固定数值0.8作为上一次的权重影响。

plt_x = []
plt_y = []
for epoch in range(1500):
    i = np.random.randint(N)

    gradient_w, gradient_b = get_gradient(x[i], y[i])

    #这是更新动量的数学公式,0.8是过去动量的权重
    momentum_w = 0.8 * momentum_w + gradient_w
    momentum_b = 0.8 * momentum_b + gradient_b

    #这里更新参数不再使用梯度,而是使用动量
    w -= momentum_w * 1e-3
    b -= momentum_b * 1e-3

    #思考一下,在时刻0,动量都是0.此时更新动量,动量就等于梯度.
    #也就是说,再时刻0,其实就是再用梯度下降.
    #时刻1,是上一个时刻的梯度乘以0.8,再加上当前时刻的梯度
    #所以在时刻1,差不多可以认为是梯度乘以了1.8.不过这里面两部分的梯度是在两个不同的点上评估出来的.
    #在时刻2,差不多等同于时刻1.往后都差不多.

    plt_x.append(epoch)
    plt_y.append(total_loss())

    if epoch % 150 == 0:
        print(epoch, momentum_w, momentum_b, total_loss())

3 ada_grad

（1）AdaGrad是一种优化方法，它可以为不同的变量提供不同的学习率。需要多一个参数；
（2）每epoch的学习率 = 1 / 累计权重平方和的开方。 1可以是别的数值。
（3）在adagrad中lr是单调递减的。因为累加权重会越来越大，分母是越来越大的。
在这里插入图片描述

plt_x = []
plt_y = []
for epoch in range(2500):
    i = np.random.randint(N)
    gradient_w, gradient_b = get_gradient(x[i], y[i])

    #adagrad的特点是每个变量都有属于自己的lr
    #要计算各个变量的lr,先要计算S
    #这是S的计算公式
    S_w = S_w + gradient_w**2
    S_b = S_b + gradient_b**2

    #计算lr的公式,其中的1e-1是原本的lr,1e-6是防止除0的
    lr_w = 1e-1 / ((S_w + 1e-6)**0.5)
    lr_b = 1e-1 / ((S_b + 1e-6)**0.5)

    #所以在时刻0,lr就等于梯度的倒数
    #梯度大的变量会有小lr,梯度小的变量会有大lr
    #往后的每一个时刻,都是类似动量法,考虑上一步的梯度

    w -= gradient_w * lr_w
    b -= gradient_b * lr_b

    plt_x.append(epoch)
    plt_y.append(total_loss())

    if epoch % 150 == 0:
        print(epoch, lr_w, lr_b, total_loss())

4 RMS Prop

（1）和adagrad唯一的区别,就是多了两个系数,也就是0.2和0.8。rmsprop中lr可能上升。

plt_x = []
plt_y = []
for epoch in range(2500):
    i = np.random.randint(N)
    gradient_w, gradient_b = get_gradient(x[i], y[i])

    #和adagrad唯一的区别,就是多了两个系数,也就是0.2和0.8
    #rmsprop是对adagrad的一个改进,在adagrad中lr是单调递减的.
    #但是在rmsprop中lr可能上升
    S_w = 0.2 * S_w + 0.8 * gradient_w**2
    S_b = 0.2 * S_b + 0.8 * gradient_b**2

    #这部分和adagrad没有任何区别
    lr_w = 1e-2 / ((S_w + 1e-6)**0.5)
    lr_b = 1e-2 / ((S_b + 1e-6)**0.5)

    w -= gradient_w * lr_w
    b -= gradient_b * lr_b

    plt_x.append(epoch)
    plt_y.append(total_loss())

    if epoch % 150 == 0:
        print(epoch, lr_w, lr_b, total_loss())

5 Ada delta

（）和rmsprop的学习率计算方式不同；

plt_x = []
plt_y = []

for epoch in range(5500):
    i = np.random.randint(N)
    gradient_w, gradient_b = get_gradient(x[i], y[i])

    #ada_delta算法不需要设定超参数lr
    #他需要维持两个变量,delta和S

    #S的计算和rmsprop完全一致
    S_w = 0.2 * S_w + 0.8 * gradient_w**2
    S_b = 0.2 * S_b + 0.8 * gradient_b**2

    #计算lr的公式,这里的1e-6是为了防止除0
    lr = (delta_w + 1e-6) / (S_w + 1e-6)
    gradient_w = lr**0.5 * gradient_w

    lr = (delta_b + 1e-6) / (S_b + 1e-6)
    gradient_b = lr**0.5 * gradient_b

    #更新参数
    w -= gradient_w
    b -= gradient_b

    #更新delta,这里的两个系数和计算S时用的要一样
    delta_w = 0.2 * delta_w + 0.8 * gradient_w**2
    delta_b = 0.2 * delta_b + 0.8 * gradient_b**2

    #思考一下,在时刻0,S就是梯度的平方乘以0.8
    #所以在一开始的时候,S是比较大的.但delta还是0
    #所以一开始的时候lr是比较大的.
    #delta更新为变量更新量的平方*0.8
    #所以delta当中差不多相当于存储了变量更新量的历史信息
    #所以最后的lr,应该是取两者的比值

    plt_x.append(epoch)
    plt_y.append(total_loss())

    if epoch % 500 == 0:
        print(epoch, delta_w[:2], delta_b, total_loss())

6 Adam

plt_x = []
plt_y = []

for t in range(1, 5500):
    i = np.random.randint(N)
    gradient_w, gradient_b = get_gradient(x[i], y[i])

    v_w = 0.9 * v_w + 0.1 * gradient_w
    v_b = 0.9 * v_b + 0.1 * gradient_b

    #S的计算和rmsprop完全一致
    S_w = 0.999 * S_w + 0.001 * gradient_w**2
    S_b = 0.999 * S_b + 0.001 * gradient_b**2

    #根据以上公式,在时刻0
    #v = [0.1 * gradient_0]

    #这可能太过于小,为了消除这个影响,需要做偏差修正,也就是除以系数
    #v = 0.1 * sigma[0.9**(t-i) * gradient_i]
    #S = 0.001 * sigma[0.999**(t-i) * gradient_i**2]
    
    #将梯度的系数部分整理得到
    #0.1 * sigma[0.9**(t-i)] = 1-0.9**t

    #偏差修正
    v_hat_w = v_w / (1 - 0.9**t)
    v_hat_b = v_b / (1 - 0.9**t)
    S_hat_w = S_w / (1 - 0.999**t)
    S_hat_b = S_b / (1 - 0.999**t)

    #下面是adam参数更新的公式
    #这里的1e-2是超参数lr
    gradient_w = (1e-2 * v_hat_w) / (S_hat_w**0.5 + 1e-6)
    gradient_b = (1e-2 * v_hat_b) / (S_hat_b**0.5 + 1e-6)

    #更新参数
    w -= gradient_w
    b -= gradient_b

    plt_x.append(t)
    plt_y.append(total_loss())

    if t % 500 == 0:
        print(t, v_hat_w[:2], S_hat_w[:2], total_loss())