8.2. 异步计算

MXNet使用异步计算来提升计算性能。理解它的工作原理既有助于开发更高效的程序，又有助于在内存资源有限的情况下主动降低计算性能从而减小内存开销。我们先导入本节中实验需要的包或模块。

  1. In [1]:
  1. from mxnet import autograd, gluon, nd
  2. from mxnet.gluon import loss as gloss, nn
  3. import os
  4. import subprocess
  5. import time

8.2.1. MXNet中的异步计算

广义上讲，MXNet包括用户直接用来交互的前端和系统用来执行计算的后端。例如，用户可以使用不同的前端语言编写MXNet程序，如Python、R、Scala和C++。无论使用何种前端编程语言，MXNet程序的执行主要都发生在C++实现的后端。换句话说，用户写好的前端MXNet程序会传给后端执行计算。后端有自己的线程在队列中不断收集任务并执行它们。

MXNet通过前端线程和后端线程的交互实现异步计算。异步计算指，前端线程无须等待当前指令从后端线程返回结果就继续执行后面的指令。为了便于解释，假设Python前端线程调用以下4条指令。

  1. In [2]:
  1. a = nd.ones((1, 2))
  2. b = nd.ones((1, 2))
  3. c = a * b + 2
  4. c
  1. Out[2]:
  1. [[3. 3.]]
  2. <NDArray 1x2 @cpu(0)>

在异步计算中，Python前端线程执行前3条语句的时候，仅仅是把任务放进后端的队列里就返回了。当最后一条语句需要打印计算结果时，Python前端线程会等待C++后端线程把变量c的结果计算完。此设计的一个好处是，这里的Python前端线程不需要做实际计算。因此，无论Python的性能如何，它对整个程序性能的影响很小。只要C++后端足够高效，那么不管前端编程语言性能如何，MXNet都可以提供一致的高性能。

为了演示异步计算的性能，我们先实现一个简单的计时类。

  1. In [3]:
  1. class Benchmark():  # 本类已保存在d2lzh包中方便以后使用
  2.     def __init__(self, prefix=None):
  3.         self.prefix = prefix + ' ' if prefix else ''
  4.  
  5.     def __enter__(self):
  6.         self.start = time.time()
  7.  
  8.     def __exit__(self, *args):
  9.         print('%stime: %.4f sec' % (self.prefix, time.time() - self.start))

下面的例子通过计时来展示异步计算的效果。可以看到，当y = nd.dot(x, x).sum()返回的时候并没有等待变量y真正被计算完。只有当print函数需要打印变量y时才必须等待它计算完。

  1. In [4]:
  1. with Benchmark('Workloads are queued.'):
  2.     x = nd.random.uniform(shape=(2000, 2000))
  3.     y = nd.dot(x, x).sum()
  4.  
  5. with Benchmark('Workloads are finished.'):
  6.     print('sum =', y)
  1. Workloads are queued. time: 0.0007 sec
  2. sum =
  3. [2.0003661e+09]
  4. <NDArray 1 @cpu(0)>
  5. Workloads are finished. time: 0.1712 sec

的确，除非我们需要打印或者保存计算结果，否则我们基本无须关心目前结果在内存中是否已经计算好了。只要数据是保存在NDArray里并使用MXNet提供的运算符，MXNet将默认使用异步计算来获取高计算性能。

8.2.2. 用同步函数让前端等待计算结果

除了刚刚介绍的print函数外，我们还有其他方法让前端线程等待后端的计算结果完成。我们可以使用wait_to_read函数让前端等待某个的NDArray的计算结果完成，再执行前端中后面的语句。或者，我们可以用waitall函数令前端等待前面所有计算结果完成。后者是性能测试中常用的方法。

下面是使用wait_to_read函数的例子。输出用时包含了变量y的计算时间。

  1. In [5]:
  1. with Benchmark():
  2.     y = nd.dot(x, x)
  3.     y.wait_to_read()
  1. time: 0.0646 sec

下面是使用waitall函数的例子。输出用时包含了变量y和变量z的计算时间。

  1. In [6]:
  1. with Benchmark():
  2.     y = nd.dot(x, x)
  3.     z = nd.dot(x, x)
  4.     nd.waitall()
  1. time: 0.1269 sec

此外，任何将NDArray转换成其他不支持异步计算的数据结构的操作都会让前端等待计算结果。例如，当我们调用asnumpy函数和asscalar函数时：

  1. In [7]:
  1. with Benchmark():
  2.     y = nd.dot(x, x)
  3.     y.asnumpy()
  1. time: 0.0670 sec
  1. In [8]:
  1. with Benchmark():
  2.     y = nd.dot(x, x)
  3.     y.norm().asscalar()
  1. time: 0.1585 sec

上面介绍的wait_to_read函数、waitall函数、asnumpy函数、asscalar函数和print函数会触发让前端等待后端计算结果的行为。这类函数通常称为同步函数。

8.2.3. 使用异步计算提升计算性能

在下面的例子中，我们用for循环不断对变量y赋值。当在for循环内使用同步函数wait_to_read时，每次赋值不使用异步计算；当在for循环外使用同步函数waitall时，则使用异步计算。

  1. In [9]:
  1. with Benchmark('synchronous.'):
  2.     for _ in range(1000):
  3.         y = x + 1
  4.         y.wait_to_read()
  5.  
  6. with Benchmark('asynchronous.'):
  7.     for _ in range(1000):
  8.         y = x + 1
  9.     nd.waitall()
  1. synchronous. time: 0.5856 sec
  2. asynchronous. time: 0.3696 sec

我们观察到，使用异步计算能提升一定的计算性能。为了解释这一现象，让我们对Python前端线程和C++后端线程的交互稍作简化。在每一次循环中，前端和后端的交互大约可以分为3个阶段：

  • 前端令后端将计算任务y = x + 1放进队列；
  • 后端从队列中获取计算任务并执行真正的计算；
  • 后端将计算结果返回给前端。 我们将这3个阶段的耗时分别设为

8.2. 异步计算 - 图1 。如果不使用异步计算，执行1000次计算的总耗时大约为 8.2. 异步计算 - 图2 ；如果使用异步计算，由于每次循环中前端都无须等待后端返回计算结果，执行1000次计算的总耗时可以降为 8.2. 异步计算 - 图3 （假设 8.2. 异步计算 - 图4 ）。

8.2.4. 异步计算对内存的影响

为了解释异步计算对内存使用的影响，让我们先回忆一下前面章节的内容。在前面章节中实现的模型训练过程中，我们通常会在每个小批量上评测一下模型，如模型的损失或者精度。细心的读者也许已经发现了，这类评测常用到同步函数，如asscalar函数或者asnumpy函数。如果去掉这些同步函数，前端会将大量的小批量计算任务在极短的时间内丢给后端，从而可能导致占用更多内存。当我们在每个小批量上都使用同步函数时，前端在每次迭代时仅会将一个小批量的任务丢给后端执行计算，并通常会减小内存占用。

由于深度学习模型通常比较大，而内存资源通常有限，建议大家在训练模型时对每个小批量都使用同步函数，例如，用asscalar函数或者asnumpy函数评价模型的表现。类似地，在使用模型预测时，为了减小内存的占用，也建议大家对每个小批量预测时都使用同步函数，例如，直接打印出当前小批量的预测结果。

下面我们来演示异步计算对内存的影响。我们先定义一个数据获取函数data_iter，它会从被调用时开始计时，并定期打印到目前为止获取数据批量的总耗时。

  1. In [10]:
  1. def data_iter():
  2.     start = time.time()
  3.     num_batches, batch_size = 100, 1024
  4.     for i in range(num_batches):
  5.         X = nd.random.normal(shape=(batch_size, 512))
  6.         y = nd.ones((batch_size,))
  7.         yield X, y
  8.         if (i + 1) % 50 == 0:
  9.             print('batch %d, time %f sec' % (i + 1, time.time() - start))

下面定义多层感知机、优化算法和损失函数。

  1. In [11]:
  1. net = nn.Sequential()
  2. net.add(nn.Dense(2048, activation='relu'),
  3.         nn.Dense(512, activation='relu'),
  4.         nn.Dense(1))
  5. net.initialize()
  6. trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.005})
  7. loss = gloss.L2Loss()

这里定义辅助函数来监测内存的使用。需要注意的是，这个函数只能在Linux或macOS上运行。

  1. In [12]:
  1. def get_mem():
  2.     res = subprocess.check_output(['ps', 'u', '-p', str(os.getpid())])
  3.     return int(str(res).split()[15]) / 1e3

现在我们可以做测试了。我们先试运行一次，让系统把net的参数初始化。有关初始化的讨论可参见“模型参数的延后初始化”一节。

  1. In [13]:
  1. for X, y in data_iter():
  2.     break
  3. loss(y, net(X)).wait_to_read()

对于训练模型net来说，我们可以自然地使用同步函数asscalar将每个小批量的损失从NDArray格式中取出，并打印每个迭代周期后的模型损失。此时，每个小批量的生成间隔较长，不过内存开销较小。

  1. In [14]:
  1. l_sum, mem = 0, get_mem()
  2. for X, y in data_iter():
  3.     with autograd.record():
  4.         l = loss(y, net(X))
  5.     l_sum += l.mean().asscalar()  # 使用同步函数asscalar
  6.     l.backward()
  7.     trainer.step(X.shape[0])
  8. nd.waitall()
  9. print('increased memory: %f MB' % (get_mem() - mem))
  1. batch 50, time 3.371737 sec
  2. batch 100, time 6.779474 sec
  3. increased memory: 2.896000 MB

如果去掉同步函数，虽然每个小批量的生成间隔较短，但训练过程中可能会导致内存占用较高。这是因为在默认异步计算下，前端会将所有小批量计算在短时间内全部丢给后端。这可能在内存积压大量中间结果无法释放。实验中我们看到，不到一秒，所有数据（X和y）就都已经产生。但因为训练速度没有跟上，所以这些数据只能放在内存里不能及时清除，从而占用额外内存。

  1. In [15]:
  1. mem = get_mem()
  2. for X, y in data_iter():
  3.     with autograd.record():
  4.         l = loss(y, net(X))
  5.     l.backward()
  6.     trainer.step(X.shape[0])
  7. nd.waitall()
  8. print('increased memory: %f MB' % (get_mem() - mem))
  1. batch 50, time 0.079871 sec
  2. batch 100, time 0.159572 sec
  3. increased memory: 198.924000 MB

8.2.5. 小结

  • MXNet包括用户直接用来交互的前端和系统用来执行计算的后端。
  • MXNet能够通过异步计算提升计算性能。
  • 建议使用每个小批量训练或预测时至少使用一个同步函数，从而避免在短时间内将过多计算任务丢给后端。

8.2.6. 练习

  • 在“使用异步计算提升计算性能”一节中，我们提到使用异步计算可以使执行1000次计算的总耗时降为 8.2. 异步计算 - 图5 。这里为什么要假设 8.2. 异步计算 - 图6 ？