记录学习记录学习《手动学习深度学习》这本书的笔记（九）

马不停蹄地来到了第十二章：计算性能……

感觉应该是讲并行计算方面的，比如GPU、CPU、CUDA那些。

第十二章：计算性能

12.1 编译器和解释器

这里先提出了命令式编程和符号式编程的概念。

命令式编程VS符号式编程

目前为止，本书讲的主要是命令式编程，通过直接的方式改变程序的状态，比如"+"、"print"这些，而符号式编程主要通过一些接口，主要关注任务的目的。

问了下ai：命令式编程主要关注每一步要做什么，改变程序状态一步步实现具体功能，达到预期结果；而符号式式编程关注数学符号和逻辑表达式的操作，主要用于逻辑推理。

命令式编程效率不高，因为编译器一步步执行这些操作，却不关注程序整体架构，比如一个函数可能连续调用两次，如果在一个或多个GPU上执行，则开销可能会非常大，并且每走一步都要保留以后可能不会用到的值……总之走一步看一步总是很麻烦的。

考虑另一种符号式编程，它不会马上计算每一步，只在完全定义了整个过程后才执行计算，深度学习的TensorFlow框架就使用了这种编程。

符号式编程流程：

①定义计算流程

②将流程编译成可执行程序

③给定输入，调用编译好的程序执行

而非命令式编程的一步步执行，所以这允许了大量优化，因为编译器在执行之前就可以看到完整的代码，在发现之后不需要某个变量后编译器就可以释放它的内存。

但之前我们一般都是用更好使用更好调试的命令式编程，因为无论是打印中间变量还是使用调试工具命令式编程都更简单。

符号式编程优点在效率高，程序容易移植，甚至可以将python程序移植到与python无关的格式中，使其在非python环境下运行。

混合编程

深度学习编程框架们有使用符号式也有使用命令式的，目前主流的Pytorch（命令式）和Tensorflow（混合式）都有向对方靠拢的趋势。

作者这里拿Pytorch举例（我的书是Pytorch版本的，电子版有Tensorflow版本）。

先构建一个普通MLP：

import torch
from torch import nn
from d2l import torch as d2l# 生产网络的工厂模式
def get_net():net = nn.Sequential(nn.Linear(512, 256),nn.ReLU(),nn.Linear(256, 128),nn.ReLU(),nn.Linear(128, 2))return netx = torch.randn(size=(1, 512)

命令式编程版本：

net = get_net()
net(x)

符号式编程：

net = torch.jit.script(net)
net(x)

测试两种编程方法的性能：

#@save
class Benchmark:"""用于测量运行时间"""def __init__(self, description='Done'):self.description = descriptiondef __enter__(self):self.timer = d2l.Timer()return selfdef __exit__(self, *args):print(f'{self.description}: {self.timer.stop():.4f} sec')net = get_net()
with Benchmark('无torchscript'):for i in range(1000): net(x)net = torch.jit.script(net)
with Benchmark('有torchscript'):for i in range(1000): net(x)

结果

并且符号式编程要求先定义并编译程序，编译程序的好处之一是可以将模型及其参数序列化保存到磁盘，这样保存的训练好的模型可以迁移到其他设备，与其他前端编程语言结合。

（看到这里想到前几天做的情感计算实验，文件就是有前端有后端，后端训练模型并保存，前端只需调用模型就行，这样提高了计算效率）

12.2 异步计算

Python是单线程的，它不擅长处理并行和异步代码。

（怪不得并行计算课的代码要用C语言实现……）

在深度学习框架中，Tensorflow采用异步编程模式提高性能，Pytorch则采用Python自有的调度器实现不同性能的权衡，GPU操作默认情况下是异步的，调用一个使用GPU的函数时，操作会在特定设备上排队，但之后控制权会立刻返还给使用者，不需要等待GPU完成这个任务再执行后续代码。这允许我们并行执行更多运算。

异步编程通过主动减少计算需求和相互依赖，开发更高效的程序。

作者再次做了个实验比较Pytorch（GPU上）和Numpy中矩阵相乘花费的时间：

with d2l.Benchmark('numpy'):for _ in range(10):a = numpy.random.normal(size=(1000, 1000))b = numpy.dot(a, a)with d2l.Benchmark('torch'):for _ in range(10):a = torch.randn(size=(1000, 1000), device=device)b = torch.mm(a, a)

结果：

因为Numpy的矩阵乘法是在CPU上执行，而Pytorch在GPU上，默认情况是异步的。

其实，Pytorch可以看作分为前端和后端，用户通过Python调用Pytorch，这是前端，而执行计算的后端主要由C++实现。用户调用Pytorch后，操作被传到后端执行，后端有自己的多线程，所以Pytorch支持异步计算。

注意：如果要按上述方式工作，后端必须跟踪整个计算图中各步骤直接依赖关系，因此不可以并行化相互依赖的工作。

这就是为什么编程时要主动减少相互依赖的操作。

作者举了一个很直观的例子：

比如这样一段代码：

x = torch.ones((1, 2), device=device)
y = torch.ones((1, 2), device=device)
z = x * y + 2
z

内部是这样运行的：

两个构造矩阵的操作可以并行实现，意思是前端只需要将任务返回后端队列，Python前端等待C++后端线程完成计算结果，而不需要实际计算，这样任务就可以并行计算。（前端Python的性能对计算任务没有什么影响）

总而言之，异步产生了一个相当灵活的前端。

电子书上还有一个直观的例子：

12.3 自动并行

深度学习框架会在后端自动构建计算图。

比如上面那个例子中，初始化两个张量这个步骤，系统就可以选择并发运行它们。

模拟并行计算

在有多个计算设备的情况下，选择并发运行就可以大大提高效率，接下来作者用代码模拟了系统内部并发和不并发执行任务：

def run(x):return [x.mm(x) for _ in range(50)]

假设这个是我们的任务，也就是让 x 自乘50次。

然后设置两个 x ，分别放在两个GPU设备上。

devices = d2l.try_all_gpus()
x_gpu1 = torch.rand(size=(4000, 4000), device=devices[0])
x_gpu2 = torch.rand(size=(4000, 4000), device=devices[1])

torch.cuda.synchronize函数会等待当前设备计算执行结束才往后执行。

于是可以写出串行代码：

with d2l.Benchmark('GPU1 time'):run(x_gpu1)torch.cuda.synchronize(devices[0])with d2l.Benchmark('GPU2 time'):run(x_gpu2)torch.cuda.synchronize(devices[1])

删除俩任务之间的torch.cuda.synchronize，就可以实现俩GPU并行。

并行代码：

with d2l.Benchmark('GPU1 & GPU2'):run(x_gpu1)run(x_gpu2)torch.cuda.synchronize()

可以看出，总执行时间小于两部分执行时间的总和。

所以可以看出，深度学习框架中会默认让两个任务并行执行，提高计算效率。

模拟设备间通信

然后作者又用代码模拟了一个设备之间的通信。

之前我们可以将一个数据迁移到另一个设备上，那么数据可不可以边计算边迁移呢？

def copy_to_cpu(x, non_blocking=False):return [y.to('cpu', non_blocking=non_blocking) for y in x]

（利用Pytorch中的to函数将某个数据迁移设备）

按照之前的样子，写一个串行执行俩步骤的代码：

with d2l.Benchmark('在GPU1上运行'):y = run(x_gpu1)torch.cuda.synchronize()with d2l.Benchmark('复制到CPU'):y_cpu = copy_to_cpu(y)torch.cuda.synchronize()

这样的话效率不高，但是想想其实可以边运算边迁移，将运算完的部分先迁移过去。

这时候就要to函数中的non_blocking参数了，当这个参数为true时，就可以在不需要同步时调用同步，从而实现一边运算一边迁移。

并行代码：

with d2l.Benchmark('在GPU1上运行并复制到CPU'):y = run(x_gpu1)y_cpu = copy_to_cpu(y, True)torch.cuda.synchronize()

这样做就可以让系统先将运算完的部分先迁移，减少运行时间。

这两个任务看着简单，但在实际应用中要通过Python实现还是非常复杂的，比如一个简单的两层感知机在两个GPU和一个CPU下运行的例子：

手动调度其实是非常复杂的，这就体现了基于图的计算后端优化的优势了。

12.4 硬件

这一节主要是讲计算机组成方面的内容，理解计算机内部的组成对于实现高性能的算法有很大帮助。

首先，计算机是由以下关键部分组成的：

中央处理器（CPU）：运行计算机的大部分功能，如操作系统，也能够执行给定的程序。
主存（RAM，也叫内存）：用于存储计算结果，使CPU可以较快访问到数据。
以太网连接：网络。
高速扩展总线：用于连接GPU，通常用更高级的方式拓扑连接。
持久性存储设备（辅存）：固态硬盘（SSD）、硬盘驱动器（HDD），用高速扩展总线连接，提高传输速率。

接下来我们一一讲解这些组成。

1. 高速扩展总线

其中高速扩展总线由多个直连到CPU的通道组成，将CPU与网络、GPU、存储连接到一起。

在计算机上执行代码时，需要将数据移到处理器（CPU或GPU）上计算，然后将结果移到主存或辅存上，为了保证无缝衔接，就要拥有一个较快的高速扩展总线；如果是在多台设备上运行，就要有一个较快的以太网连接。

2. 内存

在读取内存方面有两种方式，一种是随机读取，直接跳到指定位置，只读取需要的部分数据；一种是突发读取，以连续的快速读取完成更大片的数据的访问。在数据连续存储的情况下，突发读取效率快得多。

GPU对内存存取速率的要求更高，内存也比CPU小。

3. 存储器

对于存储器，关键特性是带宽和延迟。

硬盘驱动器（HDD）比较古早，最大的优点是便宜，众多缺点之一是灾难性故障和高读取延迟。

主要原因是磁盘转速就那么快，如果太快会因为施加在盘片的离心力过大而破碎，性能很难有较大提升，对于较大数据集很难存储。

固态驱动器（SDD）就可以持久并且更快存储信息，它的设计方式使它必须满足一些条件：

以块的方式存储信息。而块只能作为一个整体写入，需要耗费大量时间，按位写入时性能会非常差。
存储单元磨损较快，所以不适合用于交换分区文件和大型日志文件。
带宽大幅增加，必须与高速扩展总线相连。

还有一种存储器是云存储，虚拟机的存储在数量和速度上可以与用户需求相匹配。

4. CPU

中央处理器是计算机的核心。

它的关键组成部分有处理器核心（用于执行机器代码）、总线（用于连接不同组件）、缓存cache（缓解内存到核心间的传输速率）、向量处理单元（用于辅助高性能线性代数和卷积计算）。

每个处理器都由复杂的组件构成，前端加载指令并尝试预测用哪条路径，然后指令从汇编代码解码为微指令（更低级别的操作），最后才由实际核心处理。

通常执行指令的核心可以同时执行多个操作，所以高效的程序可以在每个时间周期执行多条独立指令。

在这里我们可以知道为什么对任务进行向量化，而不是单个单个求解效率会高很多。

为了满足需求，CPU需要在同一个时钟周期内执行许多操作，这种执行方式是通过向量处理单元实现的，处理单元可以执行单指令多数据（SIMD）操作。

比如八个任务要求将两个整数相加，就可以在一个时钟周期完成：

（这张图的意思是八对整数加法，先将八个整数排成向量，将俩向量相加）

然后书里讲了高速缓存Cache的内容，但这部分内容在计组和操作系统课里讲过，就简略带过。

总之Cache主要是缓解CPU核心处理速度过快，而主存到CPU数据传输相对过慢的情况，在两者中间加入速度介于两者之间的缓存，就可以大大缓解这种速度差。

CPU要从主存中读取数据时，先将主存中的一片数据读入Cache，如果将来CPU又要用到这些数据，或者要用到这些数据旁边的数据，就可以直接从Cache中查找。

5. GPU和其他加速卡

GPU对于深度学习非常非常重要。

虽然对于训练（需要反向传播，要求高精度）来说可能没什么，但对于推断（只需前向传播，不需要存储中间数据），我们需要更大的内存和处理能力。

在之前说过向量化能够提高运算效率，当然矩阵化就更好了。利用多个张量核，可以优化矩阵运算的数值精确度。

GPU不太擅长的主要在于稀疏数据和中断。

6. 网络和总线

单个设备不足时就要用到多个设备运算。

平常人们最常用的网络应该是wifi，但是在深度学习中wifi提供的带宽和延迟相对一般，下面介绍几种深度学习中更好用的互连方式。

PCIe（高速扩展总线）：一种专用总线，适合大批量数据传输。
以太网：连接计算机时最常用的方式，比上面那位慢，但优点是按照成本低，覆盖距离长。
交换机：一种连接多个设备的方式，每一对设备都能同时进行点对点连接。
NVLink：PCIe的替代品，适用于带宽非常高的互连，纯粹的强大。

（ps：看完这些仿佛又回到了计网……）

12.5 多GPU训练

这一节主要讲如何用多个GPU并行进行神经网络的训练。

有三种思路，第一种是将不同层分配给不同GPU，第二种是将每一层任务拆解到不同GPU，第三种是跨多个GPU对数据进行拆分。

第一种：网络并行。可以处理更大的网络，并且每个GPU的内存占用都能得到很好的控制。然而，GPU接口之间的密集同步很难实现，每个GPU间可能需要大量数据传输，总之不太好办。
第二种，按层并行。是我们并行计算课实验的内容，比如将矩阵拆分到不同处理单元进行计算，或者按通道划分给不同GPU，这样就可以处理不断变大的网络了。但是，这需要很多同步操作，因为每一层都依赖上一层输出结果，需要传输的数据量不比第一种方法小，总之也不太好办。
第三种，数据并行。对数据进行拆分，每个GPU处理小批量数据的部分训练，最后汇总梯度，这种方法最简单并且可以用于任何情况，只需要在每个小批量处理后同步。只不过添加更多GPU并对训练更大的模型没什么帮助。

三种方法的比较图如下：

另外，GPU的内存对训练很重要，内存大会很方便，在早期是个很棘手的问题，不过现在已经解决。

因为数据并行最好用且最实用，所以我们将按照数据并行的方法实现并行计算。

数据并行时系统内部大致如下（2个GPU的情况）：

如图，随机小批量数据被分为2个部分，在不同GPU上计算梯度，最后汇总在一起。

k个GPU并行训练过程：

小批量数据被均匀分成k个部分，每个部分都被分给不同GPU。
每个GPU计算各自部分的损失和梯度。
将所有GPU上的梯度汇总，获得当前小批量的梯度。
聚合梯度再一次被分成k个部分，分给每个GPU更新参数。

实际中需要将小批量扩大成k的倍数，以便均匀分配，如果会显著增大数据量大小，那么相应可能还要提高学习率（关于为什么可以提高学习率，问了ai但是没有结果，我猜测是因为批量增大，方差更小，数据更稳定，学习率就可以提高），批量规范化也要调整，每个GPU独自进行批量归一化。

然后就是如何用代码实现，这里介绍了几种关键的技术：

1. 数据同步

这里需要构建一个函数，模拟两个GPU同步的过程，也就是两个设备计算出的梯度相加。

def allreduce(data):for i in range(1, len(data)):data[0][:] += data[i].to(data[0].device)for i in range(1, len(data)):data[i][:] = data[0].to(data[i].device)

运行结果示例：

2. 数据分发

这里直接借用了Pytorch框架中的函数，将数据分发给每个设备：

split = nn.parallel.scatter(data, devices)

其中data是需要分配的数据，devices是设备列表，返回的split是分发结果。

构建一个数据分发的函数：

#@save
def split_batch(X, y, devices):"""将X和y拆分到多个设备上"""assert X.shape[0] == y.shape[0]return (nn.parallel.scatter(X, devices),nn.parallel.scatter(y, devices))

然后我们就可以利用构建的这两个辅助函数构造多GPU的数据并行训练函数。

之前说过只要没有互相依赖的关系，系统就会自动并行计算，所以不需要添加什么并行计算的代码，直接用循环让各个设备计算自己的部分就行了。

单个批量训练：

def train_batch(X, y, device_params, devices, lr):X_shards, y_shards = split_batch(X, y, devices)# 在每个GPU上分别计算损失ls = [loss(lenet(X_shard, device_W), y_shard).sum()for X_shard, y_shard, device_W in zip(X_shards, y_shards, device_params)]for l in ls:  # 反向传播在每个GPU上分别执行l.backward()# 将每个GPU的所有梯度相加，并将其广播到所有GPUwith torch.no_grad():for i in range(len(device_params[0])):allreduce([device_params[c][i].grad for c in range(len(devices))])# 在每个GPU上分别更新模型参数for param in device_params:d2l.sgd(param, lr, X.shape[0]) # 在这里，我们使用全尺寸的小批量

随后的train函数和之前没什么区别，都是对每个批量执行上面的批量训练函数。

12.6 多GPU的简洁实现

也可以使用深度学习框架中的API实现，内部原理和上面差不多。

比起之前的训练函数，主要添加的步骤只有利用API在所有设备上设置模型。

def train(net, num_gpus, batch_size, lr):train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)devices = [d2l.try_gpu(i) for i in range(num_gpus)]def init_weights(m):if type(m) in [nn.Linear, nn.Conv2d]:nn.init.normal_(m.weight, std=0.01)net.apply(init_weights)# 在多个GPU上设置模型net = nn.DataParallel(net, device_ids=devices)trainer = torch.optim.SGD(net.parameters(), lr)loss = nn.CrossEntropyLoss()timer, num_epochs = d2l.Timer(), 10animator = d2l.Animator('epoch', 'test acc', xlim=[1, num_epochs])for epoch in range(num_epochs):net.train()timer.start()for X, y in train_iter:trainer.zero_grad()X, y = X.to(devices[0]), y.to(devices[0])l = loss(net(X), y)l.backward()trainer.step()timer.stop()animator.add(epoch + 1, (d2l.evaluate_accuracy_gpu(net, test_iter),))print(f'测试精度：{animator.Y[0][-1]:.2f}，{timer.avg():.1f}秒/轮，'f'在{str(devices)}')

即net = nn.DataParallel(net, device_ids=devices)这一步。

这一个API的具体作用有：