PyTorch教程-13.2. 異步計(jì)算

當(dāng)今的計(jì)算機(jī)是高度并行的系統(tǒng)，由多個(gè) CPU 內(nèi)核（通常每個(gè)內(nèi)核多個(gè)線程）、每個(gè) GPU 多個(gè)處理元素以及每個(gè)設(shè)備通常多個(gè) GPU 組成。簡(jiǎn)而言之，我們可以同時(shí)處理許多不同的事情，通常是在不同的設(shè)備上。不幸的是，Python 并不是編寫并行和異步代碼的好方法，至少在沒(méi)有一些額外幫助的情況下是這樣。畢竟 Python 是單線程的，這在未來(lái)不太可能改變。MXNet 和 TensorFlow 等深度學(xué)習(xí)框架采用 異步編程模型來(lái)提高性能，而 PyTorch 使用 Python 自己的調(diào)度程序?qū)е虏煌男阅軝?quán)衡。對(duì)于 PyTorch，默認(rèn)情況下，GPU 操作是異步的。當(dāng)您調(diào)用使用 GPU 的函數(shù)時(shí)，操作會(huì)排入特定設(shè)備的隊(duì)列，但不一定會(huì)在稍后執(zhí)行。這使我們能夠并行執(zhí)行更多計(jì)算，包括在 CPU 或其他 GPU 上的操作。

因此，了解異步編程的工作原理有助于我們通過(guò)主動(dòng)減少計(jì)算要求和相互依賴性來(lái)開發(fā)更高效的程序。這使我們能夠減少內(nèi)存開銷并提高處理器利用率。

import os
import subprocess
import numpy
import torch
from torch import nn
from d2l import torch as d2l

import os
import subprocess
import numpy
from mxnet import autograd, gluon, np, npx
from mxnet.gluon import nn
from d2l import mxnet as d2l

npx.set_np()

13.2.1。通過(guò)后端異步

作為熱身，請(qǐng)考慮以下玩具問(wèn)題：我們想要生成一個(gè)隨機(jī)矩陣并將其相乘。讓我們?cè)?NumPy 和 PyTorch 張量中都這樣做以查看差異。請(qǐng)注意，PyTorchtensor是在 GPU 上定義的。

# Warmup for GPU computation
device = d2l.try_gpu()
a = torch.randn(size=(1000, 1000), device=device)
b = torch.mm(a, a)

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: 2.2001 sec
torch: 0.0057 sec

通過(guò) PyTorch 的基準(zhǔn)輸出要快幾個(gè)數(shù)量級(jí)。NumPy 點(diǎn)積在 CPU 處理器上執(zhí)行，而 PyTorch 矩陣乘法在 GPU 上執(zhí)行，因此后者預(yù)計(jì)會(huì)更快。但巨大的時(shí)差表明一定有其他事情在發(fā)生。默認(rèn)情況下，GPU 操作在 PyTorch 中是異步的。強(qiáng)制 PyTorch 在返回之前完成所有計(jì)算顯示了之前發(fā)生的情況：計(jì)算由后端執(zhí)行，而前端將控制權(quán)返回給 Python。

with d2l.Benchmark():
  for _ in range(10):
    a = torch.randn(size=(1000, 1000), device=device)
    b = torch.mm(a, a)
  torch.cuda.synchronize(device)

Done: 0.0039 sec

從廣義上講，PyTorch 有一個(gè)用于與用戶直接交互的前端（例如，通過(guò) Python），以及一個(gè)供系統(tǒng)用來(lái)執(zhí)行計(jì)算的后端。如圖13.2.1所示，用戶可以使用Python、C++等多種前端語(yǔ)言編寫PyTorch程序。無(wú)論使用何種前端編程語(yǔ)言，PyTorch 程序的執(zhí)行主要發(fā)生在 C++ 實(shí)現(xiàn)的后端。前端語(yǔ)言發(fā)出的操作被傳遞到后端執(zhí)行。后端管理自己的線程，這些線程不斷收集和執(zhí)行排隊(duì)的任務(wù)。請(qǐng)注意，要使其正常工作，后端必須能夠跟蹤計(jì)算圖中各個(gè)步驟之間的依賴關(guān)系。因此，不可能并行化相互依賴的操作。

For a warmup consider the following toy problem: we want to generate a random matrix and multiply it. Let’s do that both in NumPy and in mxnet.np to see the difference.

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

with d2l.Benchmark('mxnet.np'):
  for _ in range(10):
    a = np.random.normal(size=(1000, 1000))
    b = np.dot(a, a)

numpy: 2.1419 sec
mxnet.np: 0.0728 sec

The benchmark output via MXNet is orders of magnitude faster. Since both are executed on the same processor something else must be going on. Forcing MXNet to finish all the backend computation prior to returning shows what happened previously: computation is executed by the backend while the frontend returns control to Python.

with d2l.Benchmark():
  for _ in range(10):
    a = np.random.normal(size=(1000, 1000))
    b = np.dot(a, a)
  npx.waitall()

Done: 2.1325 sec

Broadly speaking, MXNet has a frontend for direct interactions with users, e.g., via Python, as well as a backend used by the system to perform the computation. As shown in Fig. 13.2.1, users can write MXNet programs in various frontend languages, such as Python, R, Scala, and C++. Regardless of the frontend programming language used, the execution of MXNet programs occurs primarily in the backend of C++ implementations. Operations issued by the frontend language are passed on to the backend for execution. The backend manages its own threads that continuously collect and execute queued tasks. Note that for this to work the backend must be able to keep track of the dependencies between various steps in the computational graph. Hence, it is not possible to parallelize operations that depend on each other.

圖 13.2.1編程語(yǔ)言前端和深度學(xué)習(xí)框架后端。

讓我們看另一個(gè)玩具示例以更好地理解依賴關(guān)系圖。

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

tensor([[3., 3.]], device='cuda:0')

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

array([[3., 3.]])

圖 13.2.2后端跟蹤計(jì)算圖中各個(gè)步驟之間的依賴關(guān)系。

上面的代碼片段也如圖 13.2.2所示 。每當(dāng) Python 前端線程執(zhí)行前三個(gè)語(yǔ)句之一時(shí)，它只是將任務(wù)返回到后端隊(duì)列。當(dāng)需要打印最后一條語(yǔ)句的結(jié)果時(shí)， Python 前端線程將等待 C++ 后端線程完成對(duì)變量結(jié)果的計(jì)算z。這種設(shè)計(jì)的一個(gè)好處是 Python 前端線程不需要執(zhí)行實(shí)際計(jì)算。因此，無(wú)論 Python 的性能如何，對(duì)程序的整體性能影響都很小。 圖 13.2.3說(shuō)明了前端和后端如何交互。

圖 13.2.3前后端交互。

13.2.2。障礙和阻滯劑

有許多操作會(huì)強(qiáng)制 Python 等待完成：

最明顯的npx.waitall()是等待所有計(jì)算完成，而不管計(jì)算指令何時(shí)發(fā)出。在實(shí)踐中，除非絕對(duì)必要，否則使用此運(yùn)算符不是一個(gè)好主意，因?yàn)樗鼤?huì)導(dǎo)致性能不佳。

如果我們只想等到特定變量可用，我們可以調(diào)用z.wait_to_read(). z在這種情況下，MXNet 會(huì)阻止返回 Python，直到計(jì)算出變量為止。之后可能會(huì)繼續(xù)進(jìn)行其他計(jì)算。

讓我們看看這在實(shí)踐中是如何工作的。

with d2l.Benchmark('waitall'):
  b = np.dot(a, a)
  npx.waitall()

with d2l.Benchmark('wait_to_read'):
  b = np.dot(a, a)
  b.wait_to_read()

waitall: 0.0155 sec
wait_to_read: 0.0500 sec

完成這兩個(gè)操作大約需要相同的時(shí)間。除了明顯的阻塞操作之外，我們建議您了解 隱式阻塞程序。打印變量顯然需要變量可用，因此是一個(gè)障礙。最后，轉(zhuǎn)換為 NumPy via z.asnumpy()和轉(zhuǎn)換為標(biāo)量 viaz.item()是阻塞的，因?yàn)?NumPy 沒(méi)有異步的概念。它需要像函數(shù)一樣訪問(wèn)值print。

頻繁地將少量數(shù)據(jù)從 MXNet 的范圍復(fù)制到 NumPy 并返回可能會(huì)破壞原本高效代碼的性能，因?yàn)槊總€(gè)此類操作都需要計(jì)算圖來(lái)評(píng)估獲得相關(guān)術(shù)語(yǔ)所需的所有中間結(jié)果，然后才能完成任何其他操作。

with d2l.Benchmark('numpy conversion'):
  b = np.dot(a, a)
  b.asnumpy()

with d2l.Benchmark('scalar conversion'):
  b = np.dot(a, a)
  b.sum().item()

numpy conversion: 0.0780 sec
scalar conversion: 0.0727 sec

13.2.3。改進(jìn)計(jì)算

在高度多線程的系統(tǒng)上（即使是普通筆記本電腦也有 4 個(gè)或更多線程，而在多插槽服務(wù)器上，這個(gè)數(shù)字可能超過(guò) 256），調(diào)度操作的開銷會(huì)變得很大。這就是為什么非常需要異步和并行進(jìn)行計(jì)算和調(diào)度的原因。為了說(shuō)明這樣做的好處，讓我們看看如果我們將變量遞增 1 多次（順序或異步）會(huì)發(fā)生什么。我們通過(guò)wait_to_read在每次添加之間插入一個(gè)屏障來(lái)模擬同步執(zhí)行。

with d2l.Benchmark('synchronous'):
  for _ in range(10000):
    y = x + 1
    y.wait_to_read()

with d2l.Benchmark('asynchronous'):
  for _ in range(10000):
    y = x + 1
  npx.waitall()

synchronous: 1.4076 sec
asynchronous: 1.1700 sec

Python前端線程和C++后端線程之間的一個(gè)稍微簡(jiǎn)化的交互可以概括如下： 1. 前端命令后端將計(jì)算任務(wù)插入到隊(duì)列中。1. 后端從隊(duì)列中接收計(jì)算任務(wù)并進(jìn)行實(shí)際計(jì)算。1. 后端將計(jì)算結(jié)果返回給前端。假設(shè)這三個(gè)階段的持續(xù)時(shí)間是y = x + 1t1,t2和t3， 分別。如果我們不使用異步編程，執(zhí)行 10000 次計(jì)算所花費(fèi)的總時(shí)間大約是10000(t1+t2+t3). 如果使用異步編程，執(zhí)行10000次計(jì)算的總時(shí)間可以減少到t1+10000t2+t3（假設(shè) 10000t2>9999t1), 因?yàn)榍岸瞬槐氐却蠖朔祷孛總€(gè)循環(huán)的計(jì)算結(jié)果。

13.2.4。概括

深度學(xué)習(xí)框架可以將 Python 前端與執(zhí)行后端分離。這允許將命令快速異步插入后端??和相關(guān)的并行性。

異步會(huì)導(dǎo)致響應(yīng)相當(dāng)靈敏的前端。但是，請(qǐng)注意不要使任務(wù)隊(duì)列過(guò)滿，因?yàn)檫@可能會(huì)導(dǎo)致過(guò)多的內(nèi)存消耗。建議對(duì)每個(gè) minibatch 進(jìn)行同步，以保持前端和后端大致同步。

芯片供應(yīng)商提供復(fù)雜的性能分析工具，以更細(xì)致地了解深度學(xué)習(xí)的效率。

請(qǐng)注意，從 MXNet 的內(nèi)存管理轉(zhuǎn)換為 Python 將強(qiáng)制后端等待特定變量準(zhǔn)備就緒。print,asnumpy和等函數(shù)item都有這個(gè)效果。這可能是可取的，但不小心使用同步可能會(huì)破壞性能。

13.2.5。練習(xí)