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_hatloss = 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_paramsnew_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個GPUdevice_params = [get_params(params, d) for d in devices]num_epochs = 10animator = 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(), 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)}')

在單個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達到原始的訓練目標?