PyTorch模型訓練實戰技巧，突破速度瓶頸

點擊關注上方 「 AI深度學習視線 」，並「 星標 」公號

做者：William Falcon

編譯：ronghuaiyang 來源：AI公園

導讀

一個step by step的指南，很是的實用。

不要讓你的神經網絡變成這樣

讓咱們面對現實吧，你的模型可能還停留在石器時代。我敢打賭你仍然使用32位精度或GASP甚至只在一個GPU上訓練。

我明白，網上都是各類神經網絡加速指南，可是一個checklist都沒有（如今有了），使用這個清單，一步一步確保你能榨乾你模型的全部性能。

本指南從最簡單的結構到最複雜的改動都有，可使你的網絡獲得最大的好處。我會給你展現示例Pytorch代碼以及能夠在Pytorch- lightning Trainer中使用的相關flags，這樣你能夠不用本身編寫這些代碼！

**這本指南是爲誰準備的？**任何使用Pytorch進行深度學習模型研究的人，如研究人員、博士生、學者等，咱們在這裏談論的模型可能須要你花費幾天的訓練，甚至是幾周或幾個月。

咱們會講到：

1. 使用DataLoaders
2. DataLoader中的workers數量
3. Batch size
4. 梯度累計
5. 保留的計算圖
6. 移動到單個
7. 16-bit 混合精度訓練
8. 移動到多個GPUs中（模型複製）
9. 移動到多個GPU-nodes中 (8+GPUs)
10. 思考模型加速的技巧

Pytorch-Lightning

你能夠在Pytorch的庫Pytorch- lightning中找到我在這裏討論的每個優化。Lightning是在Pytorch之上的一個封裝，它能夠自動訓練，同時讓研究人員徹底控制關鍵的模型組件。Lightning 使用最新的最佳實踐，並將你可能出錯的地方最小化。

咱們爲MNIST定義LightningModel並使用Trainer來訓練模型。

from pytorch_lightning import Trainer
model = LightningModule(…)
trainer = Trainer()
trainer.fit(model)

1. DataLoaders

這多是最容易得到速度增益的地方。保存h5py或numpy文件以加速數據加載的時代已經一去不復返了，使用Pytorch dataloader加載圖像數據很簡單(對於NLP數據，請查看TorchText)。

在lightning中，你不須要指定訓練循環，只須要定義dataLoaders和Trainer就會在須要的時候調用它們。

dataset = MNIST(root=self.hparams.data_root, train=train, download=True)
loader = DataLoader(dataset, batch_size=32, shuffle=True)
for batch in loader:
  x, y = batch
  model.training_step(x, y)
  ...

2. DataLoaders 中的 workers 的數量

另外一個加速的神奇之處是容許批量並行加載。所以，您能夠一次裝載nb_workers個batch，而不是一次裝載一個batch。

# slow
loader = DataLoader(dataset, batch_size=32, shuffle=True)
# fast (use 10 workers)
loader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=10)

3. Batch size

在開始下一個優化步驟以前，將batch size增大到CPU-RAM或GPU-RAM所容許的最大範圍。

下一節將重點介紹如何幫助減小內存佔用，以便你能夠繼續增長batch size。

記住，你可能須要再次更新你的學習率。一個好的經驗法則是，若是batch size加倍，那麼學習率就加倍。

4. 梯度累加

在你已經達到計算資源上限的狀況下，你的batch size仍然過小(好比8)，而後咱們須要模擬一個更大的batch size來進行梯度降低，以提供一個良好的估計。

假設咱們想要達到128的batch size大小。咱們須要以batch size爲8執行16個前向傳播和向後傳播，而後再執行一次優化步驟。

# clear last step
optimizer.zero_grad()

# 16 accumulated gradient steps
scaled_loss = 0
for accumulated_step_i in range(16):
     out = model.forward()
     loss = some_loss(out,y)    
     loss.backward()
      scaled_loss += loss.item()
      
# update weights after 8 steps. effective batch = 8*16
optimizer.step()

# loss is now scaled up by the number of accumulated batches
actual_loss = scaled_loss / 16

在lightning中，所有都給你作好了，只須要設置accumulate_grad_batches=16：

trainer = Trainer(accumulate_grad_batches=16)
trainer.fit(model)

5. 保留的計算圖

一個最簡單撐爆你的內存的方法是爲了記錄日誌存儲你的loss。

losses = []
...
losses.append(loss)

print(f'current loss: {torch.mean(losses)'})

上面的問題是，loss仍然包含有整個圖的副本。在這種狀況下，調用.item()來釋放它。

![1_CER3v8cok2UOBNsmnBrzPQ](9 Tips For Training Lightning-Fast Neural Networks In Pytorch.assets/1_CER3v8cok2UOBNsmnBrzPQ.gif)# bad
losses.append(loss)

# good
losses.append(loss.item())

Lightning會很是當心，確保不會保留計算圖的副本。

6. 單個GPU訓練

一旦你已經完成了前面的步驟，是時候進入GPU訓練了。在GPU上的訓練將使多個GPU cores之間的數學計算並行化。你獲得的加速取決於你所使用的GPU類型。我推薦我的用2080Ti，公司用V100。

乍一看，這可能會讓你不知所措，但你真的只須要作兩件事:1)移動你的模型到GPU, 2)每當你運行數據經過它，把數據放到GPU上。

# put model on GPU
model.cuda(0)

# put data on gpu (cuda on a variable returns a cuda copy)
x = x.cuda(0)

# runs on GPU now
model(x)

若是你使用Lightning，你什麼都不用作，只須要設置Trainer(gpus=1)。

# ask lightning to use gpu 0 for training
trainer = Trainer(gpus=[0])
trainer.fit(model)

在GPU上進行訓練時，要注意的主要事情是限制CPU和GPU之間的傳輸次數。

# expensive
x = x.cuda(0)# very expensive
x = x.cpu()
x = x.cuda(0)

若是內存耗盡，不要將數據移回CPU以節省內存。在求助於GPU以前，嘗試以其餘方式優化你的代碼或GPU之間的內存分佈。

另外一件須要注意的事情是調用強制GPU同步的操做。清除內存緩存就是一個例子。

# really bad idea. Stops all the GPUs until they all catch up
torch.cuda.empty_cache()

可是，若是使用Lightning，唯一可能出現問題的地方是在定義Lightning Module時。Lightning會特別注意不去犯這類錯誤。

7. 16-bit 精度

16bit精度是將內存佔用減半的驚人技術。大多數模型使用32bit精度數字進行訓練。然而，最近的研究發現，16bit模型也能夠工做得很好。混合精度意味着對某些內容使用16bit，但將權重等內容保持在32bit。

要在Pytorch中使用16bit精度，請安裝NVIDIA的apex庫，並對你的模型進行這些更改。

# enable 16-bit on the model and the optimizer
model, optimizers = amp.initialize(model, optimizers, opt_level='O2')

# when doing .backward, let amp do it so it can scale the loss
with amp.scale_loss(loss, optimizer) as scaled_loss:                      
    scaled_loss.backward()

amp包會處理好大部分事情。若是梯度爆炸或趨向於0，它甚至會縮放loss。

在lightning中，啓用16bit並不須要修改模型中的任何內容，也不須要執行我上面所寫的操做。設置Trainer(precision=16)就能夠了。

trainer = Trainer(amp_level='O2', use_amp=False)
trainer.fit(model)

8. 移動到多個GPUs中

如今，事情變得很是有趣了。有3種(也許更多？)方法來進行多GPU訓練。

分batch訓練

A) 拷貝模型到每一個GPU中，B) 給每一個GPU一部分batch

第一種方法被稱爲「分batch訓練」。該策略將模型複製到每一個GPU上，每一個GPU得到batch的一部分。

# copy model on each GPU and give a fourth of the batch to each
model = DataParallel(model, devices=[0, 1, 2 ,3])

# out has 4 outputs (one for each gpu)
out = model(x.cuda(0))

在lightning中，你只須要增長GPUs的數量，而後告訴trainer，其餘什麼都不用作。

# ask lightning to use 4 GPUs for training
trainer = Trainer(gpus=[0, 1, 2, 3])
trainer.fit(model)

模型分佈訓練

將模型的不一樣部分放在不一樣的GPU上，batch按順序移動

有時你的模型可能太大不能徹底放到內存中。例如，帶有編碼器和解碼器的序列到序列模型在生成輸出時可能會佔用20GB RAM。在本例中，咱們但願將編碼器和解碼器放在獨立的GPU上。

# each model is sooo big we can't fit both in memory
encoder_rnn.cuda(0)
decoder_rnn.cuda(1)

# run input through encoder on GPU 0
encoder_out = encoder_rnn(x.cuda(0))

# run output through decoder on the next GPU
out = decoder_rnn(encoder_out.cuda(1))

# normally we want to bring all outputs back to GPU 0
out = out.cuda(0)

對於這種類型的訓練，在Lightning中不須要指定任何GPU，你應該把LightningModule中的模塊放到正確的GPU上。

class MyModule(LightningModule):
    def __init__():
        self.encoder = RNN(...)
        self.decoder = RNN(...)
    def forward(x):
        # models won't be moved after the first forward because 
        # they are already on the correct GPUs
        self.encoder.cuda(0)
        self.decoder.cuda(1)
        out = self.encoder(x)
        out = self.decoder(out.cuda(1))
        
# don't pass GPUs to trainer
model = MyModule()
trainer = Trainer()
trainer.fit(model)

二者混合

在上面的狀況下，編碼器和解碼器仍然能夠從並行化操做中獲益。

# change these lines
self.encoder = RNN(...)
self.decoder = RNN(...)

# to these
# now each RNN is based on a different gpu set
self.encoder = DataParallel(self.encoder, devices=[0, 1, 2, 3])
self.decoder = DataParallel(self.encoder, devices=[4, 5, 6, 7])

# in forward...
out = self.encoder(x.cuda(0))

# notice inputs on first gpu in device
sout = self.decoder(out.cuda(4))  # <--- the 4 here

使用多個GPU時要考慮的注意事項：

• 若是模型已經在GPU上了，model.cuda()不會作任何事情。
• 老是把輸入放在設備列表中的第一個設備上。
• 在設備之間傳輸數據是昂貴的，把它做爲最後的手段。
• 優化器和梯度會被保存在GPU 0上，所以，GPU 0上使用的內存可能會比其餘GPU大得多。

9. 多節點GPU訓練

每臺機器上的每一個GPU都有一個模型的副本。每臺機器得到數據的一部分，而且只在那部分上訓練。每臺機器都能同步梯度。

若是你已經作到了這一步，那麼你如今能夠在幾分鐘內訓練Imagenet了！這並無你想象的那麼難，可是它可能須要你對計算集羣的更多知識。這些說明假設你正在集羣上使用SLURM。

Pytorch容許多節點訓練，經過在每一個節點上覆制每一個GPU上的模型並同步梯度。因此，每一個模型都是在每一個GPU上獨立初始化的，本質上獨立地在數據的一個分區上訓練，除了它們都從全部模型接收梯度更新。

在高層次上：

1. 在每一個GPU上初始化一個模型的副本(確保設置種子，讓每一個模型初始化到相同的權重，不然它會失敗)。
2. 將數據集分割成子集(使用DistributedSampler)。每一個GPU只在它本身的小子集上訓練。
3. 在.backward()上，全部副本都接收到全部模型的梯度副本。這是模型之間惟一一次的通訊。

Pytorch有一個很好的抽象，叫作DistributedDataParallel，它能夠幫你實現這個功能。要使用DDP，你須要作4的事情：

def tng_dataloader():
     d = MNIST()
     
     # 4: Add distributed sampler
     # sampler sends a portion of tng data to each machine
     dist_sampler = DistributedSampler(dataset)
     dataloader = DataLoader(d, shuffle=False, sampler=dist_sampler)
     
def main_process_entrypoint(gpu_nb):
     # 2: set up connections  between all gpus across all machines
     # all gpus connect to a single GPU "root"
     # the default uses env://
     world = nb_gpus * nb_nodes
     dist.init_process_group("nccl", rank=gpu_nb, world_size=world)
     
     # 3: wrap model in DPP
     torch.cuda.set_device(gpu_nb)
     model.cuda(gpu_nb)
     model = DistributedDataParallel(model, device_ids=[gpu_nb])
     
     # train your model now...
     
if  __name__ == '__main__':
     # 1: spawn number of processes
     # your cluster will call main for each machine
     mp.spawn(main_process_entrypoint, nprocs=8)

然而，在Lightning中，只需設置節點數量，它就會爲你處理其他的事情。

# train on 1024 gpus across 128 nodes
trainer = Trainer(nb_gpu_nodes=128, gpus=[0, 1, 2, 3, 4, 5, 6, 7])

Lightning還附帶了一個SlurmCluster管理器，能夠方便地幫助你提交SLURM做業的正確詳細信息。

10. 福利！在單個節點上多GPU更快的訓練

事實證實，distributedDataParallel比DataParallel快得多，由於它只執行梯度同步的通訊。因此，一個好的hack是使用distributedDataParallel替換DataParallel，即便是在單機上進行訓練。

在Lightning中，這很容易經過將distributed_backend設置爲ddp和設置GPUs的數量來實現。

# train on 4 gpus on the same machine MUCH faster than DataParallel
trainer = Trainer(distributed_backend='ddp', gpus=[0, 1, 2, 3])

對模型加速的思考

儘管本指南將爲你提供了一系列提升網絡速度的技巧，但我仍是要給你解釋一下如何經過查找瓶頸來思考問題。

我將模型分紅幾個部分：

首先，我要確保在數據加載中沒有瓶頸。爲此，我使用了我所描述的現有數據加載解決方案，可是若是沒有一種解決方案知足你的須要，請考慮離線處理和緩存到高性能數據存儲中，好比h5py。

接下來看看你在訓練步驟中要作什麼。確保你的前向傳播速度快，避免過多的計算以及最小化CPU和GPU之間的數據傳輸。最後，避免作一些會下降GPU速度的事情(本指南中有介紹)。

接下來，我試圖最大化個人batch size，這一般是受GPU內存大小的限制。如今，須要關注在使用大的batch size的時候如何在多個GPUs上分佈並最小化延遲（好比，我可能會嘗試着在多個gpu上使用8000 +的有效batch size）。

然而，你須要當心大的batch size。針對你的具體問題，請查閱相關文獻，看看人們都忽略了什麼！

—END—

英文原文：https://towardsdatascience.com/9-tips-for-training-lightning-fast-neural-networks-in-pytorch-8e63a502f565

推薦閱讀

目標檢測：

• 乾貨 | YOLOV5 訓練自動駕駛數據集，並轉Tensorrt，收藏！

• 超越YOLOv4-tiny！YOLObile：移動設備上的實時目標檢測

• 52.1 AP！RepPoints V2：用於目標檢測的驗證+迴歸，剛剛開源！
  

• 50.4mAP(已開源) | FCOSv2.0強勢歸來！Anchor-free家族再添猛將(長文解析)

• COCO 迎來新榜首！DetectoRS以54.7mAP成就目前最高精度檢測網絡

• 52.1 %AP！AutoAssign：Anchor-free最強檢測網絡！密集目標檢測的可微標籤分配

• mAP提高40%！YOLO3改進版—— Poly-YOLO：更快，更精確的檢測和實例分割

• YOLOv4 詳解版！一句話總結：速度差很少的精度碾壓，精度差很少的速度碾壓！

• ... 更多精彩內容請進入公號查看
  

目標分割：

• 75.5%mIoU / 58FPS！FANet：帶有快速注意力的實時語義分割
  

• CVPR 2020 | CenterMask : Anchor-Free 實時實例分割(長文詳解)

• ECCV2020 | 300+FPS！超快的結構感知車道檢測新網絡

• 50.1%mAP | D2Det：高質量目標檢測和實例分割新高度！(文末送書！)

• 圖像分割 | CCNet: Criss-Cross Attention for Semantic Segmentation

• 【長文】圖像分割 |  YOLACT：開創性的one-stage實時實例分割檢測器，名字致敬YOLO

• 投稿CVPR 2021 | BiSeNet V2出來了！72.6%的mIOU, 156FPS的速度！讓分割飛起來！

• ... 更多精彩內容請進入公號查看

潮水自會來去，但心志得堅若磐石。即使成不了那根定海神針，也至少不是那隨意被拍上岸的野鬼遊魂。 

長按關注 "AI深度視線"
最新人工智能、深度學習、SLAM乾貨奉上！

本文分享自微信公衆號 - AI深度學習視線（AI_DeepSight）。
若有侵權，請聯繫 support@oschina.cn 刪除。
本文參與「OSC源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。