31-35【动手学深度学习】深度学习硬件

1. CPU和GPU

1.1 CPU

CPU每秒钟计算的浮点运算数为0.15，GPU为12。GPU的显存很低，16GB（可能32G封顶），CPU可以一直插内存。

左边是GPU（只能做些很简单的游戏，视频处理），中间是CPU，右边是连接的通道，shared LLC第三级缓存（最后一级缓存）。

a和b都是向量，刚开始放在内存中，数据只有加载到寄存器中，才能参与运算，L3就是shared LLC。最快的是寄存器。

物理上直观上看有四个核（见上面的图），但是其实每个cpu有多个超线程（2个），所以有8个核，但是不一定提升性能，因为寄存器共用。

1.2 GPU

框红的就是一个核，十个（黄色线下）小核是一个大核，3060和3080的区别就是一个大核小，一个大核多。每个绿点是一个寄存单元，可以在一个绿点上开一个线程（上千个），（对于CPU来说，一个核算一个值，但是GPU是一个绿点算一个值）。就算一个绿点比GPU的一个核计算能力弱，但是GPU胜在绿点多。

/斜杠两侧分别是低端和高端CPU，GPU。GPU的显存很贵，所以内存很小。CPU的可能一半都是在做逻辑控制，所以控制流更强，（因为CPU不经常计算一个矩阵，但是可能渲染一个html网页）。

AMD的GPU游戏性能好，但是对高性能计算支持不算好。Intel有集成显卡，ARM的CPU和GPU在嵌入式端（手机）常用。

1.3 QA

①固定其他，增加数据（高质量数据）是提高泛化性最简单和最有效的办法，当有很多数据时，调参就没那么有用，固定数据集，调参有用

2. TPU和其他

ASIC容易造，不同于通用GPU，ASIC比较专用，容易开发

一个Systolic Array相当于一个核

3. 多GPU训练

3.1 理论

数据并行：加入一个batch是128个样本，有两个GPU，每个GPU计算64个样本的梯度再求和

模型并行：ResNet的前50层在GPU0，后50层在GPU1上。在前50层计算完结果后，传给GPU1。transformer常用到。

四个卡计算效率差不多，并行性很好

3.2 代码

3.2.1 复杂实现

%matplotlib inline
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

简单网络

scale = 0.01
W1 = torch.randn(size=(20, 1, 3, 3)) * scale
b1 = torch.zeros(20)
W2 = torch.randn(size=(50, 20, 5, 5)) * scale
b2 = torch.zeros(50)
W3 = torch.randn(size=(800, 128)) * scale
b3 = torch.zeros(128)
W4 = torch.randn(size=(128, 10)) * scale
b4 = torch.zeros(10)
params = [W1, b1, W2, b2, W3, b3, W4, b4]

def lenet(X, params):
    h1_conv = F.conv2d(input=X, weight=params[0], bias=params[1])
    h1_activation = F.relu(h1_conv)
    h1 = F.avg_pool2d(input=h1_activation, kernel_size=(2, 2), stride=(2, 2))
    h2_conv = F.conv2d(input=h1, weight=params[2], bias=params[3])
    h2_activation = F.relu(h2_conv)
    h2 = F.avg_pool2d(input=h2_activation, kernel_size=(2, 2), stride=(2, 2))
    h2 = h2.reshape(h2.shape[0], -1)
    h3_linear = torch.mm(h2, params[4]) + params[5]
    h3 = F.relu(h3_linear)
    y_hat = torch.mm(h3, params[6]) + params[7]
    return y_hat

loss = nn.CrossEntropyLoss(reduction='none')

向多个设备分发参数

def get_params(params, device):
    new_params = [p.clone().to(device) for p in params]
    for p in new_params:
        p.requires_grad_()
    return new_params

new_params = get_params(params, d2l.try_gpu(0))
print('b1 weight:', new_params[1])
print('b1 grad:', new_params[1].grad)

allreduce 函数将所有向量相加(相加到一块GPU上)，并将结果广播给所有 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)

data = [torch.ones((1, 2), device=d2l.try_gpu(i)) * (i + 1) for i in range(2)]
print('before allreduce:\n', data[0], '\n', data[1])
allreduce(data)
print('after allreduce:\n', data[0], '\n', data[1])

将一个小批量数据均匀地分布在多个 GPU 上

data = torch.arange(20).reshape(4, 5)
devices = [torch.device('cuda:0'), torch.device('cuda:1')]
split = nn.parallel.scatter(data, devices)
print('input:',data)
print('load into', devices)
print('output:', split)

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()
    with 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])   # 在这里，我们使用全尺寸的小批量

定义训练函数

def train(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)]
    # 将模型参数复制到num_gpus个GPU
    device_params = [get_params(params, d) for d in devices]
    num_epochs = 10
    animator = d2l.Animator('epoch', 'test acc', xlim=[1, num_epochs])
    timer = d2l.Timer()
    for epoch in range(num_epochs):
        timer.start()
        for X, y in train_iter:
            # 为单个小批量执行多GPU训练
            train_batch(X, y, device_params, devices, lr)
            torch.cuda.synchronize()
        timer.stop()
        # 在GPU0上评估模型
        animator.add(epoch + 1, (d2l.evaluate_accuracy_gpu(
            lambda x: lenet(x, device_params[0]), test_iter, devices[0]),))
    print(f'test acc: {animator.Y[0][-1]:.2f}, {timer.avg():.1f} sec/epoch '
          f'on {str(devices)}')

在单个GPU上运行

train(num_gpus=1, batch_size=256, lr=0.2)

多个GPU

train(num_gpus=2, batch_size=256, lr=0.2)

小结

有多种方法可以在多个GPU上拆分深度网络的训练。拆分可以在层之间、跨层或跨数据上实现。前两者需要对数据传输过程进行严格编排，而最后一种则是最简单的策略。
数据并行训练本身是不复杂的，它通过增加有效的小批量数据量的大小提高了训练效率。
在数据并行中，数据需要跨多个GPU拆分，其中每个GPU执行自己的前向传播和反向传播，随后所有的梯度被聚合为一，之后聚合结果向所有的GPU广播。
小批量数据量更大时，学习率也需要稍微提高一些。

3.2.2 简洁实现

import torch
from torch import nn
from d2l import torch as d2l

简单网络

def resnet18(num_classes, in_channels=1):
    """稍加修改的 ResNet-18 模型"""
    def resnet_block(input_channels, output_channels, num_residuals, first_block=False):
        blk = []
        for i in range(num_residuals):
            if i == 0 and not first_block:
                # 第一个残差块且不是第一个block时，使用1x1卷积和下采样
                blk.append(d2l.Residual(output_channels, 
                                    use_1x1conv=True, strides=2))
            else:
                # 其他情况不使用1x1卷积
                blk.append(d2l.Residual(output_channels, output_channels))
        return nn.Sequential(*blk)

    # 网络结构
    net = nn.Sequential(
        nn.Conv2d(in_channels, 64, kernel_size=3, stride=1, padding=1),
        nn.BatchNorm2d(64), 
        nn.ReLU())
    
    # 添加残差块
    net.add_module("resnet_block1", resnet_block(64, 64, 2, first_block=True))
    net.add_module("resnet_block2", resnet_block(64, 128, 2))
    net.add_module("resnet_block3", resnet_block(128, 256, 2))
    net.add_module("resnet_block4", resnet_block(256, 512, 2))
    
    # 全局平均池化和全连接层
    net.add_module("global_avg_pool", nn.AdaptiveAvgPool2d((1, 1)))
    net.add_module("fc", nn.Sequential(
        nn.Flatten(), 
        nn.Linear(512, num_classes)))
    
    return net

# 创建网络实例
net = resnet18(10)
devices = d2l.try_all_gpus()

网络初始化

net = resnet18(10)
# 获取GPU列表
devices = d2l.try_all_gpus()
# 我们将在训练代码实现中初始化网络

训练

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(), 10
    animator = 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)}')

在单个GPU上训练网络

train(net, num_gpus=1, batch_size=256, lr=0.1)

在多个GPU上训练网络

train(net, num_gpus=2, batch_size=512, lr=0.2)

小结

神经网络可以在（可找到数据的）单GPU上进行自动评估。
每台设备上的网络需要先初始化，然后再尝试访问该设备上的参数，否则会遇到错误。
优化算法在多个GPU上自动聚合。

4. 分布式训练

t1最好是大t2 20%左右

当batchsize变大时，系统性能变好，但是批量越大，需要训练更多epoch达到原始的训练目标