代码详解：运用Numpy实现梯度下降优化算法的不同变体

╰+攻爆jí腚メ 2023-06-13 11:24 19阅读 0赞

> 全文共14118字，预计学习时长30分钟或更长

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy]

想了解如何使用numpy在tensorflow或pytorch中实现优化算法，以及如何使用matplotlib创建精美的动画？

本文将讨论如何实现梯度下降优化技术的不同变体，以及如何使用matplotlib将用于这些变体更新规则的运作可视化出来。

本文的内容和结构基于 One-Fourth Labs。

梯度下降是优化神经网络最常用的技术之一。梯度下降算法是通过向相对于网络参数的目标函数梯度的相反方向移动来更新参数。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 1]

**运用Numpy在Python中实现**

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 2]

照片来源：Unsplash，克里斯托弗·高尔

编码部分将讨论以下主题。

• Sigmoid神经元类

• 总体设置——何为数据、模型、任务

• 绘图功能——3D和轮廓图

• 个体算法及其执行方式

在开始实现梯度下降之前，首先需要输入所需的库。从mpl\_toolkits.mplot3d输入的Axes3D提供了一些基本的3D绘图（散点、曲面、直线、网格）工具。它并非最快或功能最完整的3D库，而是Matplotlib附带的。还从 Matplotlib输入colors和colormap(cm)。我们想要制作动画图来演示每种优化算法的工作原理，所以我们输入animation和rc来让图表看起来美观。为了显示HTML，在Jupyter Notebook中成线性排列。最后为了计算目的来输入numpy，这项计算任务很繁重。

from mpl_toolkits.mplot3d import Axes3D
    
    import matplotlib.pyplot as plt
    
    from matplotlib import cm
    
    import matplotlib.colors
    
    from matplotlib import animation, rc
    
    from IPython.display import HTML
    
    import numpy as np

实施Sigmoid神经元

为了实现梯度下降优化技术，以sigmoid神经元（逻辑函数）为例，看看梯度下降的不同变体是如何学习参数“ w”和“ b”的。

Sigmoid神经元复查

Sigmoid神经元类似于感知机神经元（perceptron neuron），因为对于每个输入xi，其都有与输入相关的权重wi。权重表明了输入在决策过程中的重要性。来自sigmoid的输出不同于感知机模型，其输出不是0或1，而是一个介于0到1之间的实数值，可以解释为概率。最常用的sigmoid 函数是逻辑函数，它具有“ S”形曲线的特征。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 3]

Sigmoid神经元标注（逻辑函数）

学习算法

学习算法的目标是确定参数（w和b）的最佳可能值，以使模型的整体损失（平方误差损失）尽可能最小化。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 4]

对w和b进行随机初始化。然后，对数据中的所有观测值进行迭代。使用sigmoid函数找到每个观测值相应的预测结果，并计算均方误差损失。基于损失值，将更新权重，以使在新参数下模型的整体损失将小于模型的当前损失。

Sigmoid神经元类

在开始分析梯度下降算法的不同变体之前，将在名为SN的类中构建模型。

class SN:
    
    #constructor
    
    def __init__(self, w_init, b_init, algo):
    
    self.w = w_init
    
    self.b = b_init
    
    self.w_h = []
    
    self.b_h = []
    
    self.e_h = []
    
    self.algo = algo
    
    #logistic function
    
    def sigmoid(self, x, w=None, b=None):
    
    if w is None:
    
    w = self.w
    
    if b is None:
    
    b = self.b
    
    return 1. / (1. + np.exp(-(w*x + b)))
    
    #loss function
    
    def error(self, X, Y, w=None, b=None):
    
    if w is None:
    
    w = self.w
    
    if b is None:
    
    b = self.b
    
    err = 0
    
    for x, y in zip(X, Y):
    
    err += 0.5 * (self.sigmoid(x, w, b) - y) ** 2
    
    return err
    
    def grad_w(self, x, y, w=None, b=None):
    
    if w is None:
    
    w = self.w
    
    if b is None:
    
    b = self.b
    
    y_pred = self.sigmoid(x, w, b)
    
    return (y_pred - y) * y_pred * (1 - y_pred) * x
    
    def grad_b(self, x, y, w=None, b=None):
    
    if w is None:
    
    w = self.w
    
    if b is None:
    
    b = self.b
    
    y_pred = self.sigmoid(x, w, b)
    
    return (y_pred - y) * y_pred * (1 - y_pred)
    
    def fit(self, X, Y,
    
    epochs=100, eta=0.01, gamma=0.9, mini_batch_size=100, eps=1e-8,
    
    beta=0.9, beta1=0.9, beta2=0.9
    
    ):
    
    self.w_h = []
    
    self.b_h = []
    
    self.e_h = []
    
    self.X = X
    
    self.Y = Y
    
    if self.algo == 'GD':
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    self.w -= eta * dw / X.shape[0]
    
    self.b -= eta * db / X.shape[0]
    
    self.append_log()
    
    elif self.algo == 'MiniBatch':
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    points_seen = 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    points_seen += 1
    
    if points_seen % mini_batch_size == 0:
    
    self.w -= eta * dw / mini_batch_size
    
    self.b -= eta * db / mini_batch_size
    
    self.append_log()
    
    dw, db = 0, 0
    
    elif self.algo == 'Momentum':
    
    v_w, v_b = 0, 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    v_w = gamma * v_w + eta * dw
    
    v_b = gamma * v_b + eta * db
    
    self.w = self.w - v_w
    
    self.b = self.b - v_b
    
    self.append_log()
    
    elif self.algo == 'NAG':
    
    v_w, v_b = 0, 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    v_w = gamma * v_w
    
    v_b = gamma * v_b
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y, self.w - v_w, self.b - v_b)
    
    db += self.grad_b(x, y, self.w - v_w, self.b - v_b)
    
    v_w = v_w + eta * dw
    
    v_b = v_b + eta * db
    
    self.w = self.w - v_w
    
    self.b = self.b - v_b
    
    self.append_log()
    
    #logging
    
    def append_log(self):
    
    self.w_h.append(self.w)
    
    self.b_h.append(self.b)
    
    self.e_h.append(self.error(self.X, self.Y))
    
    #constructor
    
    def __init__(self, w_init, b_init, algo):
    
    self.w = w_init
    
    self.b = b_init
    
    self.w_h = []
    
    self.b_h = []
    
    self.e_h = []
    
    self.algo = algo

init\_\_函数（构造函数）有助于将sigmoid神经元的参数初始化为w权重和b偏差。这个函数有三个参数：

• w\_init,b\_init，这些取参数“w”和“b”的初始值，而非随机设置参数，将其设置为特定值。这样能够通过可视化不同初始点来理解算法的执行方式。有些算法在某些参数下陷入局部最小值。

• algo指出使用何种梯度下降算法的变体来发现最佳参数。

在此函数中，我们对参数进行初始化，并定义了三种带有后缀'\_h'的新数组变量，表示它们是历史变量，以跟踪权重（w\_h）、偏差（b\_h）和误差（e\_h）的值是如何随着sigmoid神经元学习参数而变化的。

def sigmoid(self, x, w=None, b=None):
    
    if w is None:
    
    w = self.w
    
    if b is None:
    
    b = self.b
    
    return 1. / (1. + np.exp(-(w*x + b)))

有一个sigmoid函数，它接受输入x-强制参数，并计算输入的逻辑函数及参数。该函数还接受其他两个可选参数。

• w & b，以“ w”和“ b”用作参数，它有助于根据特定的参数值来计算sigmoid函数的值。如果未传递这些参数，它将使用已学的参数值来计算逻辑函数。

def error(self, X, Y, w=None, b=None):
    
    if w is None:
    
    w = self.w
    
    if b is None:
    
    b = self.b
    
    err = 0
    
    for x, y in zip(X, Y):
    
    err += 0.5 * (self.sigmoid(x, w, b) - y) ** 2
    
    return err

下面，有error 函数，输入X和Y作为强制参数和可选参数 ，像sigmoid函数一样。在这个函数中，通过每个数据点进行迭代，并使用sigmoid函数计算实际特征值和预测特征值之间的累积均方误差。正如在sigmoid函数中看到的，它支持在指定参数值下计算误差。

def grad\_w(self, x, y, w=None, b=None):

.....

def grad\_b(self, x, y, w=None, b=None):

.....

接下来，将定义两个函数grad\_w和grad\_b。输入“x”和“y”作为强制参数，有助于分别计算sigmoid相对于参数“w”和“b”输入的梯度。还有两个可选参数，计算指定参数值处的梯度。

def fit(self, X, Y, epochs=100, eta=0.01, gamma=0.9, mini\_batch\_size=100, eps=1e-8,beta=0.9, beta1=0.9, beta2=0.9):

self.w\_h = \[\]

.......

接下来，定义“ fit”法，它接受输入“ X”，“ Y”和其他一系列参数。每当将其用于梯度下降算法的特定变体时，都会解释这些参数。该函数首先初始化历史记录变量并设置本地输入变量以存储输入参数数据。

然后，对于该函数支持的每个算法，有一堆不同的“if-else”语句。依据选择的算法，将在fit法中实现梯度下降。在本文的后半部分，将详细解释这些实现。

def append\_log(self):

self.w\_h.append(self.w)

self.b\_h.append(self.b)

self.e\_h.append(self.error(self.X, self.Y))

最后，有theappend\_log函数，用以存储各时期各梯度下降的参数值和损失函数值。

绘图设置

本节将定义一些配置参数，使用简单的二维toy数据集来模拟梯度下降更新规则。还定义了一些函数，创建三维和二维图并为其设置动画，可视化更新规则的运作。这种设置有助于针对不同起点、不同超参数设置和不同梯度下降变量的绘图/动画更新规则运行不同的实验。

#Data
    
    X = np.asarray([3.5, 0.35, 3.2, -2.0, 1.5, -0.5])
    
    Y = np.asarray([0.5, 0.50, 0.5, 0.5, 0.1, 0.3])
    
    #Algo and parameter values
    
    algo = 'GD'
    
    w_init = 2.1
    
    b_init = 4.0
    
    #parameter min and max values- to plot update rule
    
    w_min = -7
    
    w_max = 5
    
    b_min = -7
    
    b_max = 5
    
    #learning algorithum options
    
    epochs = 200
    
    mini_batch_size = 6
    
    gamma = 0.9
    
    eta = 5
    
    #animation number of frames
    
    animation_frames = 20
    
    #plotting options
    
    plot_2d = True
    
    plot_3d = False

首先，采用一个简单的二维玩具数据集，它包括两个输入和两个输出。在第5行定义一个字符串变量algo，它接受要执行的算法类型。初始化第6-7行中的参数'w'和'b'，以指示算法的开始位置。

从第9-12行开始，设置参数的极限，即signoid神经元在指定范围内搜索最佳参数的范围。这些精心挑选的数字，用以说明梯度下降更新规则的运作。接下来将设置超参数的值，将某些变量特定于某些算法。在我们讨论算法实现的时候，我会对此进行讨论。最后，从19-22行开始，明确制作动画或绘制更新规则所需的变量。

sn = SN(w_init, b_init, algo)
    
    sn.fit(X, Y, epochs=epochs, eta=eta, gamma=gamma, mini_batch_size=mini_batch_size)
    
    plt.plot(sn.e_h, 'r')
    
    plt.plot(sn.w_h, 'b')
    
    plt.plot(sn.b_h, 'g')
    
    plt.legend(('error', 'weight', 'bias'))
    
    plt.title("Variation of Parameters and loss function")
    
    plt.xlabel("Epoch")
    
    plt.show()

设置好配置参数后，将SN类进行初始化，然后使用配置参数调用fit法。此外，绘制三个历史变量，用以将参数和损失函数值在各个时期之间的变化进行可视化。

3D和2D绘图设置

if plot_3d:
    
    W = np.linspace(w_min, w_max, 256)
    
    b = np.linspace(b_min, b_max, 256)
    
    WW, BB = np.meshgrid(W, b)
    
    Z = sn.error(X, Y, WW, BB)
    
    fig = plt.figure(dpi=100)
    
    ax = fig.gca(projection='3d')
    
    surf = ax.plot_surface(WW, BB, Z, rstride=3, cstride=3, alpha=0.5, cmap=cm.coolwarm, linewidth=0, antialiased=False)
    
    cset = ax.contourf(WW, BB, Z, 25, zdir='z', offset=-1, alpha=0.6, cmap=cm.coolwarm)
    
    ax.set_xlabel('w')
    
    ax.set_xlim(w_min - 1, w_max + 1)
    
    ax.set_ylabel('b')
    
    ax.set_ylim(b_min - 1, b_max + 1)
    
    ax.set_zlabel('error')
    
    ax.set_zlim(-1, np.max(Z))
    
    ax.view_init (elev=25, azim=-75) # azim = -20
    
    ax.dist=12
    
    title = ax.set_title('Epoch 0')

首先为了创建3D绘图，要在“ w”和“ b”的最小值和最大值之间创建256个相等间隔的值来创建网格，如第2-5行所示。使用网格通过调用Sigmoid类中的error函数来计算这些值的误差（第5行）SN。在第8行创建轴手柄以创建三维绘图。

为了创建3D绘图，使用ax.plot\_surface函数，通过设置rstride和cstride，指定采样点和数据的频率，创建关于权重和误差的表面图。接下来，使用ax.contourf函数，通过将误差值指定为“ Z”方向（第9-10行），在表面顶部绘制相对于权重和偏差的误差轮廓。在11-16行中，为每个轴设置标签，并为所有三维设置轴限。正在绘制三维绘图，所以需要定义视点。在第17–18行中为绘图设置了一个视点，该视点在“ z”轴上的高度为25度，距离为12个单位。

def plot_animate_3d(i):
    
    i = int(i*(epochs/animation_frames))
    
    line1.set_data(sn.w_h[:i+1], sn.b_h[:i+1])
    
    line1.set_3d_properties(sn.e_h[:i+1])
    
    line2.set_data(sn.w_h[:i+1], sn.b_h[:i+1])
    
    line2.set_3d_properties(np.zeros(i+1) - 1)
    
    title.set_text('Epoch: {: d}, Error: {:.4f}'.format(i, sn.e_h[i]))
    
    return line1, line2, title
    
    if plot_3d:
    
    #animation plots of gradient descent
    
    i = 0
    
    line1, = ax.plot(sn.w_h[:i+1], sn.b_h[:i+1], sn.e_h[:i+1], color='black',marker='.')
    
    line2, = ax.plot(sn.w_h[:i+1], sn.b_h[:i+1], np.zeros(i+1) - 1, color='red', marker='.')
    
    anim = animation.FuncAnimation(fig, func=plot_animate_3d, frames=animation_frames)
    
    rc('animation', html='jshtml')
    
    anim

基于静态三维绘图，想要可视化该算法的动态操作，该操作是由用于参数和误差函的历史变量在算法的各个时期捕获。要创建梯度下降算法的动画，将使用通过传递自定义函数plot\_animate\_3d作为参数之一的animation.FuncAnimation函数，并指定创建动画所需的帧数。plot\_animate\_3d函数plot\_animate\_3d为“ w”和“ b”的相应值更新参数值和误差值。在第7行的相同函数中，将文本设置为显示该特定时期的误差值。最后，为了在线显示动画，调用rc函数以在jupyter笔记本中呈现HTML内容。

类似于三维绘图，可以创建一个函数用以绘制二维等高线图。

if plot_2d:
    
    W = np.linspace(w_min, w_max, 256)
    
    b = np.linspace(b_min, b_max, 256)
    
    WW, BB = np.meshgrid(W, b)
    
    Z = sn.error(X, Y, WW, BB)
    
    fig = plt.figure(dpi=100)
    
    ax = plt.subplot(111)
    
    ax.set_xlabel('w')
    
    ax.set_xlim(w_min - 1, w_max + 1)
    
    ax.set_ylabel('b')
    
    ax.set_ylim(b_min - 1, b_max + 1)
    
    title = ax.set_title('Epoch 0')
    
    cset = plt.contourf(WW, BB, Z, 25, alpha=0.8, cmap=cm.bwr)
    
    plt.savefig("temp.jpg",dpi = 2000)
    
    plt.show()
    
    def plot_animate_2d(i):
    
    i = int(i*(epochs/animation_frames))
    
    line.set_data(sn.w_h[:i+1], sn.b_h[:i+1])
    
    title.set_text('Epoch: {: d}, Error: {:.4f}'.format(i, sn.e_h[i]))
    
    return line, title
    
    if plot_2d:
    
    i = 0
    
    line, = ax.plot(sn.w_h[:i+1], sn.b_h[:i+1], color='black',marker='.')
    
    anim = animation.FuncAnimation(fig, func=plot_animate_2d, frames=animation_frames)
    
    rc('animation', html='jshtml')
    
    anim

算法的实现

本节将实现梯度下降算法的不同变体，并生成三维和二维动画图。

Vanilla梯度下降

梯度下降算法是通过向相对于网络参数的目标函数梯度的相反方向移动来更新参数。

参数更新规则由下式给出：

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 5]

梯度下降更新规则：

for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    self.w -= eta * dw / X.shape[0]
    
    self.b -= eta * db / X.shape[0]
    
    self.append_log()

在批量梯度下降中，迭代所有训练数据点，并计算参数“ w”和“ b”的梯度累积和。然后根据累积梯度值和学习率更新参数值。

要执行梯度下降算法，请如下所示更改配置设置。

X = np.asarray([0.5, 2.5])
    
    Y = np.asarray([0.2, 0.9])
    
    algo = 'GD'
    
    w_init = -2
    
    b_init = -2
    
    w_min = -7
    
    w_max = 5
    
    b_min = -7
    
    b_max = 5
    
    epochs = 1000
    
    eta = 1
    
    animation_frames = 20
    
    plot_2d = True
    
    plot_3d = True

在配置设置中，设置变量algo 为‘GD’，表明在sigmoid神经元中执行vanilla梯度下降算法，以便找到最佳参数值。设置好配置参数后，将继续执行SN类“fit”法，训练小型数据上的sigmoid神经元。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 6]

梯度下降的历史

上图显示了在算法学习最佳参数的同时，误差、权重和偏差的历史值在不同阶段之间的变化方式。图中需要注意的关键一点是，在初始阶段，误差值徘徊在0.5左右，但在200个阶段后，误差几乎达到零。

如果想要绘制三维或二维动画，则可以设置布尔变量plot\_2d和 plot\_3d。展示三维误差面在对应值“w”和“b”下的外观。学习算法的目标是向误差/损失最小的深蓝色区域移动。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 7]

为了可视化动态执行的算法，可以使用函数plot\_animate\_3d生成动画。播放动画时，可以看到该阶段的编号和相应的误差值。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 8]

如果想要放慢动画的速度，可以通过单击视频控件中的减号来实现，如上动画所示。同样，可以为二维等高线图生成动画，以查看算法如何向全局最小值移动。

基于Momentum的梯度下降

在Momentum GD中，以先前梯度和当前梯度指数衰减的累积平均值移动。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 9]

Momentum GD的代码如下：

v_w, v_b = 0, 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    v_w = gamma * v_w + eta * dw
    
    v_b = gamma * v_b + eta * db
    
    self.w = self.w - v_w
    
    self.b = self.b - v_b
    
    self.append_log()

基于Momentum GD，涵盖了历史变量，以便跟踪先前的梯度值。变量gamma表示需要给算法施加多少Momentum。变量v\_w和 v\_b用来计算基于历史记录和当前梯度的运动。在每个阶段结束时，调用append\_log函数来存储参数和损失函数值的历史记录。

为sigmoid神经元执行Momentum GD，需要修改配置设置，如下所示：

X = np.asarray([0.5, 2.5])
    
    Y = np.asarray([0.2, 0.9])
    
    algo = 'Momentum'
    
    w_init = -2
    
    b_init = -2
    
    w_min = -7
    
    w_max = 5
    
    b_min = -7
    
    b_max = 5
    
    epochs = 1000
    
    mini_batch_size = 6
    
    gamma = 0.9
    
    eta = 1
    
    animation_frames = 20
    
    plot_2d = True
    
    plot_3d = True

变量algo被设置为“Momentum”，以示想要使用Momentum GD为sigmoid神经元找到最佳参数；另一个重要的变化是gamma变量，该变量用于控制在学习算法中Momentum的所需量。Gamma值在0-1之间变化。设置好配置参数后，将继续执行SN类“ fit”法来训练toy数据上的sigmoid神经元。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 10]

Momentum GD的变化

由图可见，累积的历史Momentum GD在极小值内外波动，权重和偏差项的值也出现了一些波动。

Nesterov加速梯度下降

在Nesterov加速梯度下降过程中，希望在根据当前梯度值采取另一步骤之前，了解是否接近最小值，从而避免出现过冲问题。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 11]

Momentum GD的代码如下：

v_w, v_b = 0, 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    v_w = gamma * v_w
    
    v_b = gamma * v_b
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y, self.w - v_w, self.b - v_b)
    
    db += self.grad_b(x, y, self.w - v_w, self.b - v_b)
    
    v_w = v_w + eta * dw
    
    v_b = v_b + eta * db
    
    self.w = self.w - v_w
    
    self.b = self.b - v_b
    
    self.append_log()

NAG GD代码的主要变化是v\_w和 v\_b的计算。在Momentum GD中，一步完成这些变量的计算，但在NAG中，分两个步骤进行计算。

v_w = gamma * v_w
    
    v_b = gamma * v_b
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y, self.w - v_w, self.b - v_b)
    
    db += self.grad_b(x, y, self.w - v_w, self.b - v_b)
    
    v_w = v_w + eta * dw
    
    v_b = v_b + eta * db

第一部分中，在遍历数据之前，将gamma与历史变量相乘，然后使用self.w和 self.b中减去的历史值来计算梯度。只需要设置algo变量为“NAG”。可以生成三维或二维动画，以查看NAG GD与Momentum GD在达到全局最小值方面有何差异。

Mini-Batch and Stochastic梯度下降

无需一次查看所有数据点，将整个数据分为多个子集。针对数据的每个子集，计算子集中存在的每个点的导数，并更新参数。不存在针对损失函数计算整个数据的导数，而是将其近似为更少的点或较小的mini-batch size。这种批量计算梯度的方法称为 “ Mini-Batch 梯度下降”。

Mini-Batch GD的代码如下所示：

for i in range(epochs):
    
    dw, db = 0, 0
    
    points_seen = 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    points_seen += 1
    
    if points_seen % mini_batch_size == 0:
    
    self.w -= eta * dw / mini_batch_size
    
    self.b -= eta * db / mini_batch_size
    
    self.append_log()
    
    dw, db = 0, 0

在Mini Batch中，遍历整个数据并使用变量points\_seen跟踪已看到的点数。如果看到的点数是mini-batch size 的倍数，那么是正在更新sigmoid神经元的参数。在特殊情况下，当mini-batch size等于1时，它将成为随机梯度下降。要执行Mini-Batch GD，只需要将算法变量设置为“MiniBatch”。可以生成3D或2D动画，以了解Mini-Batch GD在达到全局最小值方面与Momentum GD有何差异。

AdaGrad梯度下降

AdaGrad隐藏的主要动机是针对数据集中不同特征的自适应学习率，即不是针对数据集中所有特征，使用相同的学习率，而是不同特征采用不同学习率。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 12]

Adagrad的代码如下所示：

v_w, v_b = 0, 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    v_w += dw**2
    
    v_b += db**2
    
    self.w -= (eta / np.sqrt(v_w) + eps) * dw
    
    self.b -= (eta / np.sqrt(v_b) + eps) * db
    
    self.append_log()

在Adagrad中，保持梯度的平方和，然后将学习率除以历史值的平方根更新参数。这里并非静态学习，而是密集和稀疏型的动态学习。生成图/动画的机制与上文相同。此处的想法是使用不同的toy数据集和不同的超参数配置。

RMSProp梯度下降

在RMSProp中，不同于AdaGrad中的梯度总和，梯度历史是根据指数衰减的平均值计算的，这有助于防止密集型的分母快速增长。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 13]

RMSProp的代码如下所示：

v_w, v_b = 0, 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw += self.grad_w(x, y)
    
    db += self.grad_b(x, y)
    
    v_w = beta * v_w + (1 - beta) * dw**2
    
    v_b = beta * v_b + (1 - beta) * db**2
    
    self.w -= (eta / np.sqrt(v_w) + eps) * dw
    
    self.b -= (eta / np.sqrt(v_b) + eps) * db
    
    self.append_log()

在AdaGrad代码中唯一的更改是更新变量v\_w和 v\_b的方式。在AdaGrad中,v\_w和v\_b，从第一阶段开始，总是按每个参数的梯度平方递增，但在RMSProp 中，v\_w和 v\_b是使用“gamma”的超参数指数衰减的梯度加权和。要执行RMSProp GD，只需将algo变量设置为“RMSProp”。可以生成3D或2D动画，以查看RMSProp GD在达到全局最小值方面与 AdaGrad GD有何差异。

Adam梯度下降

Adam 拥有两个历史记录，“mₜ”和Momentum GD中使用的历史类似，“vₜ”和RMSProp中使用的历史类似。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 14]

在运作中，Adam执行偏差校正。它对“mₜ”和“vₜ”使用以下等式：

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 15]

偏差校正

偏差校正可确保在训练开始时不会出现怪异的行为。Adam的要点是，它结合了Momentum GD（在温和地区移动更快）和RMSProp GD（调整学习率）的优势。

Adam GD的代码如下所示：

v_w, v_b = 0, 0
    
    m_w, m_b = 0, 0
    
    num_updates = 0
    
    for i in range(epochs):
    
    dw, db = 0, 0
    
    for x, y in zip(X, Y):
    
    dw = self.grad_w(x, y)
    
    db = self.grad_b(x, y)
    
    num_updates += 1
    
    m_w = beta1 * m_w + (1-beta1) * dw
    
    m_b = beta1 * m_b + (1-beta1) * db
    
    v_w = beta2 * v_w + (1-beta2) * dw**2
    
    v_b = beta2 * v_b + (1-beta2) * db**2
    
    m_w_c = m_w / (1 - np.power(beta1, num_updates))
    
    m_b_c = m_b / (1 - np.power(beta1, num_updates))
    
    v_w_c = v_w / (1 - np.power(beta2, num_updates))
    
    v_b_c = v_b / (1 - np.power(beta2, num_updates))
    
    self.w -= (eta / np.sqrt(v_w_c) + eps) * m_w_c
    
    self.b -= (eta / np.sqrt(v_b_c) + eps) * m_b_c
    
    self.append_log()

在Adam优化器中，计算m\_w & m\_b来跟踪momentum 历史，并计算v\_w & v\_b以衰减分母并阻止其快速增长，就像在RMSProp中一样。

之后，对基于Momentum和RMSProp的历史变量实施偏差校正。一旦计算出参数“ w”和“ b”的校正值，将使用这些值来更新参数值。

执行Adam梯度下降算法，请如下所示更改配置设置。

X = np.asarray([3.5, 0.35, 3.2, -2.0, 1.5, -0.5])
    
    Y = np.asarray([0.5, 0.50, 0.5, 0.5, 0.1, 0.3])
    
    algo = 'Adam'
    
    w_init = -6
    
    b_init = 4.0
    
    w_min = -7
    
    w_max = 5
    
    b_min = -7
    
    b_max = 5
    
    epochs = 200
    
    gamma = 0.9
    
    eta = 0.5
    
    eps = 1e-8
    
    animation_frames = 20
    
    plot_2d = True
    
    plot_3d = False

变量algo被设置为“Adam”，表示使用Adam GD为sigmoid神经元找到最佳参数；另一个重要的变化是gamma 变量，该变量用于控制学习算法所需的momentum。Gamma值在0-1之间变化。设置配置参数后，将继续执行SN类“ fit”法以训练toy数据上的sigmoid神经元。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 16]

Adam GD中的参数变化

创建2D等高线动画，该动画显示Adam GD学习通向全局极小值的路径的方式。

![代码详解：运用Numpy实现梯度下降优化算法的不同变体][Numpy 17]

Adam GD动画

不同于RMSProp案例，没有太多波动。尤其在最初几个阶段之后，更加确定地朝着最小值移动。

关于如何使用Numpy实现优化技术的讨论到此结束。

实践学习

本文中介绍了不同的情况，使用了带有静态初始化点的toy数据集。但是可以使用不同的初始化点，并针对每个初始化点，使用不同的算法，看看在超参数中需要进行何种调整。本文讨论的全部代码都在GitHub存储库中。随意分类或下载。最棒的是，可以直接在google colab中运行代码，而不必担心安装软件包。

https://github.com/Niranjankumar-c/GradientDescent\_Implementation?source=post\_page-----809e7ab3bab4----------------------

综上所述，本文介绍了如何通过采取简单的sigmoid神经元实现梯度算法的不同变种。此外，还了解了如何为每个变体（显示学习算法如何找到最佳参数）创建精美的3D或2D动画。

[Numpy]: https://imgconvert.csdnimg.cn/aHR0cDovL3AzLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzFiNjQ5MjVhZGI2NDRlODI4NDgzZWI2YjQ5N2NmMDlh?x-oss-process=image/format,png
[Numpy 1]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzI0YzEwOTc0MTExMzRjOTViMjc4NzE3OThkZmE5YzAx?x-oss-process=image/format,png
[Numpy 2]: https://imgconvert.csdnimg.cn/aHR0cDovL3AzLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzlhNDBiZDdkZjBjYzRjMDI5MWYzZjllOGJhNGFmYjU2?x-oss-process=image/format,png
[Numpy 3]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2E4MmZiYTEyMWY0NjQ5OTg5YjQ5ODhjN2VmZTU4NzJk?x-oss-process=image/format,png
[Numpy 4]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzY2NjRlMTY4YWMyNjQ0YzJhMDkxOGRjNGEzYzlmMWZl?x-oss-process=image/format,png
[Numpy 5]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2NhOWQ0ZjI1ZjRkNjQ1Y2RiZDcwN2FjMTY3ZDgwOTJm?x-oss-process=image/format,png
[Numpy 6]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2Y4M2RmMDg5MWQ3NTQ4OGY5YjBhMTVhYjI4MzM2MmI1?x-oss-process=image/format,png
[Numpy 7]: https://imgconvert.csdnimg.cn/aHR0cDovL3AzLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2U1NTEyYzllYmIyMzQ4Y2ZiMGZlZDgyOWU4MWI0ZThm?x-oss-process=image/format,png
[Numpy 8]: https://imgconvert.csdnimg.cn/aHR0cDovL3AzLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2U4NGU1YTE2YjA2ZTQwNjA4MjdjNjdmOWUyYzMxZGUy?x-oss-process=image/format,png
[Numpy 9]: https://imgconvert.csdnimg.cn/aHR0cDovL3AzLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2I4NTBmM2JlOGNlNjQ2ZTVhZDY3ZWZhNmJmNDQxMjU0?x-oss-process=image/format,png
[Numpy 10]: https://imgconvert.csdnimg.cn/aHR0cDovL3AzLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzU5MzE4MTRmNjgyMTRlZmY5YjU3ZTg0N2U5MjYwNjM2?x-oss-process=image/format,png
[Numpy 11]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2I3ZTgyMjliNDc1MTRmMzdiYzU0NzFkOGU4YzJmOWFi?x-oss-process=image/format,png
[Numpy 12]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzg5NjIzZjc4YjFmODQzMzM5NmNjYTg3NGZkOTMwZmNm?x-oss-process=image/format,png
[Numpy 13]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzNlMjUwM2JhZjRlMTQ3MWFhNDhiOTQ5ZTNmOWIzM2Ey?x-oss-process=image/format,png
[Numpy 14]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzk2MTYwNDI0OGFjMjRkMTc5NTBlMThlZWZiNDU5NmRk?x-oss-process=image/format,png
[Numpy 15]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzdjOTQyNWRkMzU2OTRjYmNiZTJlNmE1MmZhZWFhNjVl?x-oss-process=image/format,png
[Numpy 16]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlLzhmMjZjZmFhNDhlMzQ1NzI5NWYyMWQwYWJkOTE4Njhi?x-oss-process=image/format,png
[Numpy 17]: https://imgconvert.csdnimg.cn/aHR0cDovL3AxLnBzdGF0cC5jb20vbGFyZ2UvcGdjLWltYWdlL2ExMTg0MjEyOGYwMzRjYzM4OWU4NmQwNzk2ZmNiMDVj?x-oss-process=image/format,png