《动手学深度学习》
Table Of Contents
《动手学深度学习》
Table Of Contents

小批量随机梯度下降

在每一次迭代中,梯度下降使用整个训练数据集来计算梯度,因此它有时也被称为批量梯度下降(batch gradient descent)。而随机梯度下降在每次迭代中只随机采样一个样本来计算梯度。正如我们在前几章中所看到的,我们还可以在每轮迭代中随机均匀采样多个样本来组成一个小批量,然后使用这个小批量来计算梯度。下面我们将描述小批量随机梯度下降。

设目标函数 \(f(\boldsymbol{x}): \mathbb{R}^d \rightarrow \mathbb{R}\)。在迭代开始前的时间步设为 0。该时间步的自变量记为 \(\boldsymbol{x}_0\in \mathbb{R}^d\),通常由随机初始化得到。在接下来的每一个时间步 \(t>0\) 中,小批量随机梯度下降随机均匀采样一个由训练数据样本索引所组成的小批量 \(\mathcal{B}_t\)。我们可以通过重复采样(sampling with replacement)或者不重复采样(sampling without replacement)得到一个小批量中的各个样本。前者允许同一个小批量中出现重复的样本,后者则不允许如此,且更常见。对于这两者间的任一种方式,我们都可以使用

\[\boldsymbol{g}_t \leftarrow \nabla f_{\mathcal{B}_t}(\boldsymbol{x}_{t-1}) = \frac{1}{|\mathcal{B}|} \sum_{i \in \mathcal{B}_t}\nabla f_i(\boldsymbol{x}_{t-1})\]

来计算时间步 \(t\) 的小批量 \(\mathcal{B}_t\) 上目标函数位于 \(\boldsymbol{x}_{t-1}\) 处的梯度 \(\boldsymbol{g}_t\)。这里 \(|\mathcal{B}|\) 代表批量大小,即小批量中样本的个数,是一个超参数。同随机梯度一样,重复采样所得的小批量随机梯度 \(\boldsymbol{g}_t\) 也是对梯度 \(\nabla f(\boldsymbol{x}_{t-1})\) 的无偏估计。给定学习率 \(\eta_t\)(取正数),小批量随机梯度下降对自变量的迭代如下:

\[\boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \eta_t \boldsymbol{g}_t.\]

基于随机采样得到的梯度的方差在迭代过程中无法减小,因此在实际中,(小批量)随机梯度下降的学习率可以在迭代过程中自我衰减,例如 \(\eta_t=\eta t^\alpha\)(通常 \(\alpha=-1\) 或者 \(-0.5\))、\(\eta_t = \eta \alpha^t\)(例如 \(\alpha=0.95\))或者每迭代若干次后将学习率衰减一次。如此一来,学习率和(小批量)随机梯度乘积的方差会减小。而梯度下降在迭代过程中一直使用目标函数的真实梯度,无需自我衰减学习率。

小批量随机梯度下降中每次迭代的计算开销为 \(\mathcal{O}(|\mathcal{B}|)\)。当批量大小为 1 时,该算法即为随机梯度下降;当批量大小等于训练数据样本数时,该算法即为梯度下降。当批量较小时,每次迭代中使用的样本少,这会导致并行处理和内存使用效率变低。这使得在计算同样数目样本的情况下比使用更大批量时所花时间更多。当批量较大时,每个小批量梯度里可能含有更多的冗余信息。为了得到较好的解,批量较大时比批量较小时可能需要计算更多数目的样本,例如增大迭代周期数。

读取数据

这一章里我们将使用一个来自 NASA 的测试不同飞机机翼噪音的数据集来比较各个优化算法 [1]。我们使用该数据集的前 1500 个样本和 5 个特征,并使用标准化对数据进行预处理。

In [1]:
%matplotlib inline
import gluonbook as gb
from mxnet import autograd, gluon, init, nd
from mxnet.gluon import nn, data as gdata, loss as gloss
import numpy as np
import time

def get_data_ch7():  # 本函数已保存在 gluonbook 包中方便以后使用。
    data = np.genfromtxt('../data/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return nd.array(data[:1500, :-1]), nd.array(data[:1500, -1])

features, labels = get_data_ch7()
features.shape
Out[1]:
(1500, 5)

从零开始实现

“线性回归的从零开始实现”一节中已经实现过小批量随机梯度下降算法。我们在这里将它的输入参数变得更加通用,主要是为了方便本章后面介绍的其他优化算法也可以使用同样的输入。具体来说,我们添加了一个状态输入states并将超参数放在字典hyperparams里。此外,我们将在训练函数里对各个小批量样本的损失求平均,因此优化算法里的梯度不需要除以批量大小。

In [2]:
def sgd(params, states, hyperparams):
    for p in params:
        p[:] -= hyperparams['lr'] * p.grad

下面实现一个通用的训练函数,以方便本章后面介绍的其他优化算法使用。它初始化一个线性回归模型,然后可以使用小批量随机梯度下降以及后续小节介绍的其它算法来训练模型。

In [3]:
# 本函数已保存在 gluonbook 包中方便以后使用。
def train_ch7(trainer_fn, states, hyperparams, features, labels,
              batch_size=10, num_epochs=2):
    # 初始化模型。
    net, loss = gb.linreg, gb.squared_loss
    w = nd.random.normal(scale=0.01, shape=(features.shape[1], 1))
    b = nd.zeros(1)
    w.attach_grad()
    b.attach_grad()

    def eval_loss():
        return loss(net(features, w, b), labels).mean().asscalar()

    ls = [eval_loss()]
    data_iter = gdata.DataLoader(
        gdata.ArrayDataset(features, labels), batch_size, shuffle=True)
    for _ in range(num_epochs):
        start = time.time()
        for batch_i, (X, y) in enumerate(data_iter):
            with autograd.record():
                l = loss(net(X, w, b), y).mean()  # 使用平均损失。
            l.backward()
            trainer_fn([w, b], states, hyperparams)  # 迭代模型参数。
            if (batch_i + 1) * batch_size % 100 == 0:
                ls.append(eval_loss())  # 每 100 个样本记录下当前训练误差。
    # 打印结果和作图。
    print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
    gb.set_figsize()
    gb.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
    gb.plt.xlabel('epoch')
    gb.plt.ylabel('loss')

当批量大小为样本总数 1500 时,优化使用的是梯度下降。梯度下降的 1 个迭代周期对模型参数只迭代 1 次。可以看到 6 次迭代后目标函数值(训练损失)的下降趋向了平稳。

In [4]:
def train_sgd(lr, batch_size, num_epochs=2):
    train_ch7(sgd, None, {'lr': lr}, features, labels, batch_size, num_epochs)

train_sgd(1, 1500, 6)
loss: 0.246095, 0.046151 sec per epoch
../_images/chapter_optimization_minibatch-sgd_7_1.svg

当批量大小为 1 时,优化使用的是随机梯度下降。为了简化实现,有关(小批量)随机梯度下降的实验中,我们未对学习率进行自我衰减,而是直接采用较小的常数学习率。随机梯度下降中,每处理一个样本会更新一次自变量(模型参数),一个迭代周期里会对自变量进行 1500 次更新。可以看到,目标函数值的下降在 1 个迭代周期后变得较为平缓。

虽然随机梯度下降和梯度下降在一个迭代周期里都处理了 1500 个样本,但实验中随机梯度下降的一个迭代周期耗时更多。这是因为随机梯度下降在一个迭代周期里做了更多次的自变量迭代,而且单样本的梯度计算难以有效利用并行计算。

In [5]:
train_sgd(0.005, 1)
loss: 0.244367, 1.942461 sec per epoch
../_images/chapter_optimization_minibatch-sgd_9_1.svg

当批量大小为 10 时,优化使用的是小批量随机梯度下降。它在每个迭代周期的耗时介于梯度下降和随机梯度下降的耗时之间。

In [6]:
train_sgd(0.05, 10)
loss: 0.243652, 0.186314 sec per epoch
../_images/chapter_optimization_minibatch-sgd_11_1.svg

Gluon 实现

在 Gluon 里我们可以通过Trainer类来调用优化算法。下面实现一个通用的训练函数,它通过优化算法的名字trainer_name和超参数trainer_hyperparams来创建Trainer实例。

In [7]:
# 本函数已保存在 gluonbook 包中方便以后使用。
def train_gluon_ch7(trainer_name, trainer_hyperparams, features, labels,
                    batch_size=10, num_epochs=2):
    # 初始化模型。
    net = nn.Sequential()
    net.add(nn.Dense(1))
    net.initialize(init.Normal(sigma=0.01))
    loss = gloss.L2Loss()

    def eval_loss():
        return loss(net(features), labels).mean().asscalar()

    ls = [eval_loss()]
    data_iter = gdata.DataLoader(
        gdata.ArrayDataset(features, labels), batch_size, shuffle=True)
    # 创建 Trainer 实例来迭代模型参数。
    trainer = gluon.Trainer(
        net.collect_params(), trainer_name, trainer_hyperparams)
    for _ in range(num_epochs):
        start = time.time()
        for batch_i, (X, y) in enumerate(data_iter):
            with autograd.record():
                l = loss(net(X), y)
            l.backward()
            trainer.step(batch_size)  # 在 Trainer 实例里做梯度平均。
            if (batch_i + 1) * batch_size % 100 == 0:
                ls.append(eval_loss())
    # 打印结果和作图。
    print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
    gb.set_figsize()
    gb.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
    gb.plt.xlabel('epoch')
    gb.plt.ylabel('loss')

使用 Gluon 重复上一个实验。

In [8]:
train_gluon_ch7('sgd', {'learning_rate': 0.05}, features, labels, 10)
loss: 0.243539, 0.182642 sec per epoch
../_images/chapter_optimization_minibatch-sgd_15_1.svg

小结

  • 小批量随机梯度每次随机均匀采样一个小批量的训练样本来计算梯度。
  • 在实际中,(小批量)随机梯度下降的学习率可以在迭代过程中自我衰减。
  • 通常,小批量随机梯度的每个迭代周期的耗时介于梯度下降和随机梯度下降的耗时之间。

练习

  • 修改批量大小和学习率,观察目标函数值的下降速度和每个迭代周期的耗时。
  • 查阅 MXNet 文档,使用Trainer类的set_learning_rate函数,令小批量随机梯度下降的学习率每过一个迭代周期减小到原值的 1/10。

扫码直达讨论区

image0

参考文献

[1] 飞机机翼噪音数据集。https://archive.ics.uci.edu/ml/datasets/Airfoil+Self-Noise