PyTorch 的 Autograd詳解

PyTorch 作為一個深度學(xué)習(xí)平臺，在深度學(xué)習(xí)任務(wù)中比 NumPy 這個科學(xué)計(jì)算庫強(qiáng)在哪里呢？我覺得一是 PyTorch 提供了自動求導(dǎo)機(jī)制，二是對 GPU 的支持。由此可見，自動求導(dǎo) (autograd) 是 PyTorch，乃至其他大部分深度學(xué)習(xí)框架中的重要組成部分。

了解自動求導(dǎo)背后的原理和規(guī)則，對我們寫出一個更干凈整潔甚至更高效的 PyTorch 代碼是十分重要的。但是，現(xiàn)在已經(jīng)有了很多封裝好的 API，我們在寫一個自己的網(wǎng)絡(luò)的時候，可能幾乎都不用去注意求導(dǎo)這些問題，因?yàn)檫@些 API 已經(jīng)在私底下處理好了這些事情?，F(xiàn)在我們往往只需要，搭建個想要的模型，處理好數(shù)據(jù)的載入，調(diào)用現(xiàn)成的 optimizer 和 loss function，直接開始訓(xùn)練就好了。仔細(xì)一想，好像連需要設(shè)置 requires_grad=True 的地方好像都沒有。有人可能會問，那我們?nèi)チ私庾詣忧髮?dǎo)還有什么用?。?/strong>

原因有很多，可以幫我們更深入地了解 PyTorch 這些寬泛的理由我就不說了，我舉一個例子：當(dāng)我們想使用一個 PyTorch 默認(rèn)中并沒有的 loss function 的時候，比如目標(biāo)檢測模型 YOLO 的 loss，我們可能就得自己去實(shí)現(xiàn)。如果我們不熟悉基本的 PyTorch 求導(dǎo)機(jī)制的話，對于實(shí)現(xiàn)過程中比如 tensor 的 in-place 操作等很容易出錯，導(dǎo)致需要話很長時間去 debug，有的時候即使定位到了錯誤的位置，也不知道如何去修改。相反，如果我們理清楚了背后的原理，我們就能很快地修改這些錯誤，甚至根本不會去犯這些錯誤。鑒于現(xiàn)在官方支持的 loss function 并不多，而且深度學(xué)習(xí)領(lǐng)域日新月異，很多新的效果很好的 loss function 層出不窮，如果要用的話可能需要我們自己來實(shí)現(xiàn)。基于這個原因，我們了解一下自動求導(dǎo)機(jī)制還是很有必要的。

本文所有代碼例子都基于 Python3 和 PyTorch 1.1, 也就是不會涉及 0.4 版本以前的 Variable 這個數(shù)據(jù)結(jié)構(gòu)。在文章中我們不會去分析一些非常底層的代碼，而是通過一系列實(shí)例來理解自動求導(dǎo)機(jī)制。在舉例的過程中我盡量保持場景的一致性，不用每個例子都需要重新了解假定的變量。另外，本文篇幅比較長。如果發(fā)現(xiàn)文章中有錯誤或者沒有講清楚的地方，歡迎大家在評論區(qū)指正和討論。

目錄

1. 計(jì)算圖
2. 一個具體的例子
3. 葉子張量
4. inplace 操作
5. 動態(tài)圖，靜態(tài)圖

計(jì)算圖

首先，我們先簡單地介紹一下什么是計(jì)算圖（Computational Graphs），以方便后邊的講解。假設(shè)我們有一個復(fù)雜的神經(jīng)網(wǎng)絡(luò)模型，我們把它想象成一個錯綜復(fù)雜的管道結(jié)構(gòu)，不同的管道之間通過節(jié)點(diǎn)連接起來，我們有一個注水口，一個出水口。我們在入口注入數(shù)據(jù)的之后，數(shù)據(jù)就沿著設(shè)定好的管道路線緩緩流動到出水口，這時候我們就完成了一次正向傳播。想象一下輸入的 tensor 數(shù)據(jù)在管道中緩緩流動的場景，這就是為什么 TensorFlow 叫 TensorFlow 的原因！emmm，好像走錯片場了，不過計(jì)算圖在 PyTorch 中也是類似的。至于這兩個非常有代表性的深度學(xué)習(xí)框架在計(jì)算圖上有什么區(qū)別，我們稍后再談。

計(jì)算圖通常包含兩種元素，一個是 tensor，另一個是 Function。張量 tensor 不必多說，但是大家可能對 Function 比較陌生。這里 Function 指的是在計(jì)算圖中某個節(jié)點(diǎn)（node）所進(jìn)行的運(yùn)算，比如加減乘除卷積等等之類的，F(xiàn)unction 內(nèi)部有 forward() 和 backward() 兩個方法，分別應(yīng)用于正向、反向傳播。

a?=?torch.tensor(2.0,?requires_grad=True)
b?=?a.exp()
print(b)
#?tensor(7.3891,?grad_fn=)

在我們做正向傳播的過程中，除了執(zhí)行 forward() 操作之外，還會同時會為反向傳播做一些準(zhǔn)備，為反向計(jì)算圖添加 Function 節(jié)點(diǎn)。在上邊這個例子中，變量 b 在反向傳播中所需要進(jìn)行的操作是 。

一個具體的例子

了解了基礎(chǔ)知識之后，現(xiàn)在我們來看一個具體的計(jì)算例子，并畫出它的正向和反向計(jì)算圖。假如我們需要計(jì)算這么一個模型：

l1 = input x w1
l2 = l1 + w2
l3 = l1 x w3
l4 = l2 x l3
loss = mean(l4)

這個例子比較簡單，涉及的最復(fù)雜的操作是求平均，但是如果我們把其中的加法和乘法操作換成卷積，那么其實(shí)和神經(jīng)網(wǎng)絡(luò)類似。我們可以簡單地畫一下它的計(jì)算圖：

圖1：正向計(jì)算圖

下面給出了對應(yīng)的代碼，我們定義了input，w1，w2，w3 這三個變量，其中 input 不需要求導(dǎo)結(jié)果。根據(jù) PyTorch 默認(rèn)的求導(dǎo)規(guī)則，對于 l1 來說，因?yàn)橛幸粋€輸入需要求導(dǎo)（也就是 w1 需要），所以它自己默認(rèn)也需要求導(dǎo)，即 requires_grad=True（如果對這個規(guī)則不熟悉，歡迎參考 我上一篇博文的第一部分 或者直接查看 官方 Tutorial 相關(guān)部分）。在整張計(jì)算圖中，只有 input 一個變量是 requires_grad=False 的。正向傳播過程的具體代碼如下：

input?=?torch.ones([2,?2],?requires_grad=False)
w1?=?torch.tensor(2.0,?requires_grad=True)
w2?=?torch.tensor(3.0,?requires_grad=True)
w3?=?torch.tensor(4.0,?requires_grad=True)

l1?=?input?*?w1
l2?=?l1?+?w2
l3?=?l1?*?w3
l4?=?l2?*?l3
loss?=?l4.mean()


print(w1.data,?w1.grad,?w1.grad_fn)
#?tensor(2.)?None?None

print(l1.data,?l1.grad,?l1.grad_fn)
#?tensor([[2.,?2.],
#?????????[2.,?2.]])?None?

print(loss.data,?loss.grad,?loss.grad_fn)
#?tensor(40.)?None?

正向傳播的結(jié)果基本符合我們的預(yù)期。我們可以看到，變量 l1 的 grad_fn 儲存著乘法操作符 ，用于在反向傳播中指導(dǎo)導(dǎo)數(shù)的計(jì)算。而 w1 是用戶自己定義的，不是通過計(jì)算得來的，所以其 grad_fn 為空；同時因?yàn)檫€沒有進(jìn)行反向傳播，grad 的值也為空。接下來，我們看一下如果要繼續(xù)進(jìn)行反向傳播，計(jì)算圖應(yīng)該是什么樣子：

圖2：反向計(jì)算圖

反向圖也比較簡單，從 loss 這個變量開始，通過鏈?zhǔn)椒▌t，依次計(jì)算出各部分的導(dǎo)數(shù)。說到這里，我們不妨先自己手動推導(dǎo)一下求導(dǎo)的結(jié)果，再與程序運(yùn)行結(jié)果作對比。如果對這部分不感興趣的讀者，可以直接跳過。

再擺一下公式：

input = [1.0, 1.0, 1.0, 1.0]
w1 = [2.0, 2.0, 2.0, 2.0]
w2 = [3.0, 3.0, 3.0, 3.0]
w3 = [4.0, 4.0, 4.0, 4.0]
l1 = input x w1 = [2.0, 2.0, 2.0, 2.0]
l2 = l1 + w2 = [5.0, 5.0, 5.0, 5.0]
l3 = l1 x w3 = [8.0, 8.0, 8.0, 8.0]
l4 = l2 x l3 = [40.0, 40.0, 40.0, 40.0]
loss = mean(l4) = 40.0

首先 , 所以 對 的偏導(dǎo)分別為 ;

接著 , 同時 ;

現(xiàn)在看 對它的兩個變量的偏導(dǎo): ,

因此 , 其和為 10 ;

同理，再看一下求 導(dǎo)數(shù)的過程：

，其和為 8。

其他的導(dǎo)數(shù)計(jì)算基本上都類似，因?yàn)檫^程太多，這里就不全寫出來了，如果有興趣的話大家不妨自己繼續(xù)算一下。

接下來我們繼續(xù)運(yùn)行代碼，并檢查一下結(jié)果和自己算的是否一致：

loss.backward()

print(w1.grad,?w2.grad,?w3.grad)
#?tensor(28.)?tensor(8.)?tensor(10.)
print(l1.grad,?l2.grad,?l3.grad,?l4.grad,?loss.grad)
#?None?None?None?None?None

首先我們需要注意一下的是，在之前寫程序的時候我們給定的 w 們都是一個常數(shù)，利用了廣播的機(jī)制實(shí)現(xiàn)和常數(shù)和矩陣的加法乘法，比如 w2 + l1，實(shí)際上我們的程序會自動把 w2 擴(kuò)展成 [[3.0, 3.0], [3.0, 3.0]]，和 l1 的形狀一樣之后，再進(jìn)行加法計(jì)算，計(jì)算的導(dǎo)數(shù)結(jié)果實(shí)際上為 [[2.0, 2.0], [2.0, 2.0]]，為了對應(yīng)常數(shù)輸入，所以最后 w2 的梯度返回為矩陣之和 8 。另外還有一個問題，雖然 w 開頭的那些和我們的計(jì)算結(jié)果相符，但是為什么 l1，l2，l3，甚至其他的部分的求導(dǎo)結(jié)果都為空呢？想要解答這個問題，我們得明白什么是葉子張量。

葉子張量

對于任意一個張量來說，我們可以用 tensor.is_leaf 來判斷它是否是葉子張量（leaf tensor）。在反向傳播過程中，只有 is_leaf=True 的時候，需要求導(dǎo)的張量的導(dǎo)數(shù)結(jié)果才會被最后保留下來。

對于 requires_grad=False 的 tensor 來說，我們約定俗成地把它們歸為葉子張量。但其實(shí)無論如何劃分都沒有影響，因?yàn)閺埩康?is_leaf 屬性只有在需要求導(dǎo)的時候才有意義。

我們真正需要注意的是當(dāng) requires_grad=True 的時候，如何判斷是否是葉子張量：當(dāng)這個 tensor 是用戶創(chuàng)建的時候，它是一個葉子節(jié)點(diǎn)，當(dāng)這個 tensor 是由其他運(yùn)算操作產(chǎn)生的時候，它就不是一個葉子節(jié)點(diǎn)。我們來看個例子：

a?=?torch.ones([2,?2],?requires_grad=True)
print(a.is_leaf)
#?True

b?=?a?+?2
print(b.is_leaf)
#?False
#?因?yàn)?b?不是用戶創(chuàng)建的，是通過計(jì)算生成的

這時有同學(xué)可能會問了，為什么要搞出這么個葉子張量的概念出來？原因是為了節(jié)省內(nèi)存（或顯存）。我們來想一下，那些非葉子結(jié)點(diǎn)，是通過用戶所定義的葉子節(jié)點(diǎn)的一系列運(yùn)算生成的，也就是這些非葉子節(jié)點(diǎn)都是中間變量，一般情況下，用戶不會去使用這些中間變量的導(dǎo)數(shù)，所以為了節(jié)省內(nèi)存，它們在用完之后就被釋放了。

我們回頭看一下之前的反向傳播計(jì)算圖，在圖中的葉子節(jié)點(diǎn)我用綠色標(biāo)出了?？梢钥闯鰜?，被叫做葉子，可能是因?yàn)橛坞x在主干之外，沒有子節(jié)點(diǎn)，因?yàn)樗鼈兌际潜挥脩魟?chuàng)建的，不是通過其他節(jié)點(diǎn)生成。對于葉子節(jié)點(diǎn)來說，它們的 grad_fn 屬性都為空；而對于非葉子結(jié)點(diǎn)來說，因?yàn)樗鼈兪峭ㄟ^一些操作生成的，所以它們的 grad_fn 不為空。

我們有辦法保留中間變量的導(dǎo)數(shù)嗎？當(dāng)然有，通過使用 tensor.retain_grad() 就可以：

#?和前邊一樣
#?...
loss?=?l4.mean()

l1.retain_grad()
l4.retain_grad()
loss.retain_grad()

loss.backward()

print(loss.grad)
#?tensor(1.)
print(l4.grad)
#?tensor([[0.2500,?0.2500],
#?????????[0.2500,?0.2500]])
print(l1.grad)
#?tensor([[7.,?7.],
#?????????[7.,?7.]])

如果我們只是想進(jìn)行 debug，只需要輸出中間變量的導(dǎo)數(shù)信息，而不需要保存它們，我們還可以使用 tensor.register_hook，例子如下：

#?和前邊一樣
#?...
loss?=?l4.mean()

l1.register_hook(lambda?grad:?print('l1?grad:?',?grad))
l4.register_hook(lambda?grad:?print('l4?grad:?',?grad))
loss.register_hook(lambda?grad:?print('loss?grad:?',?grad))

loss.backward()

#?loss?grad:??tensor(1.)
#?l4?grad:??tensor([[0.2500,?0.2500],
#?????????[0.2500,?0.2500]])
#?l1?grad:??tensor([[7.,?7.],
#?????????[7.,?7.]])

print(loss.grad)
#?None
#?loss?的?grad?在?print?完之后就被清除掉了

這個函數(shù)的功能遠(yuǎn)遠(yuǎn)不止打印導(dǎo)數(shù)信息用以 debug，但是一般很少用，所以這里就不擴(kuò)展了，更多請參考知乎提問：pytorch中的鉤子（Hook）有何作用？

到此為止，我們已經(jīng)討論完了這個實(shí)例中的正向傳播和反向傳播的有關(guān)內(nèi)容了?；剡^頭來看， input 其實(shí)很像神經(jīng)網(wǎng)絡(luò)輸入的圖像，w1, w2, w3 則類似卷積核的參數(shù)，而 l1, l2, l3, l4 可以表示4個卷積層輸出，如果我們把節(jié)點(diǎn)上的加法乘法換成卷積操作的話。實(shí)際上這個簡單的模型，很像我們平時的神經(jīng)網(wǎng)絡(luò)的簡化版，通過這個例子，相信大家多少也能對神經(jīng)網(wǎng)絡(luò)的正向和反向傳播過程有個大致的了解了吧。

inplace 操作

現(xiàn)在我們來看一下本篇的重點(diǎn)，inplace operation。可以說，我們求導(dǎo)時候大部分的 bug，都出在使用了 inplace 操作上?，F(xiàn)在我們以 PyTorch 不同的報錯信息作為驅(qū)動，來講一講 inplace 操作吧。第一個報錯信息：

RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: balabala...

不少人可能會感到很熟悉，沒錯，我就是其中之一。之前寫代碼的時候竟經(jīng)常報這個錯，原因是對 inplace 操作不了解。要搞清楚為什么會報錯，我們先來了解一下什么是 inplace 操作：inplace 指的是在不更改變量的內(nèi)存地址的情況下，直接修改變量的值。我們來看兩種情況，大家覺得這兩種情況哪個是 inplace 操作，哪個不是？或者兩個都是 inplace？

#?情景?1
a?=?a.exp()

#?情景?2
a[0]?=?10

答案是：情景1不是 inplace，類似 Python 中的 i=i+1, 而情景2是 inplace 操作，類似 i+=1。依稀記得當(dāng)時做機(jī)器學(xué)習(xí)的大作業(yè)，很多人都被其中一個 i+=1 和 i=i+1 問題給坑了好長時間。那我們來實(shí)際測試一下：

#?我們要用到?id()?這個函數(shù)，其返回值是對象的內(nèi)存地址
#?情景?1
a?=?torch.tensor([3.0,?1.0])
print(id(a))?#?2112716404344
a?=?a.exp()
print(id(a))?#?2112715008904
#?在這個過程中?a.exp()?生成了一個新的對象，然后再讓?a
#?指向它的地址，所以這不是個?inplace?操作

#?情景?2
a?=?torch.tensor([3.0,?1.0])
print(id(a))?#?2112716403840
a[0]?=?10
print(id(a),?a)?#?2112716403840?tensor([10.,??1.])
#?inplace?操作，內(nèi)存地址沒變

PyTorch 是怎么檢測 tensor 發(fā)生了 inplace 操作呢？答案是通過 tensor._version 來檢測的。我們還是來看個例子：

a?=?torch.tensor([1.0,?3.0],?requires_grad=True)
b?=?a?+?2
print(b._version)?#?0

loss?=?(b?*?b).mean()
b[0]?=?1000.0
print(b._version)?#?1

loss.backward()
#?RuntimeError:?one?of?the?variables?needed?for?gradient?computation?has?been?modified?by?an?inplace?operation?...

每次 tensor 在進(jìn)行 inplace 操作時，變量 _version 就會加1，其初始值為0。在正向傳播過程中，求導(dǎo)系統(tǒng)記錄的 b 的 version 是0，但是在進(jìn)行反向傳播的過程中，求導(dǎo)系統(tǒng)發(fā)現(xiàn) b 的 version 變成1了，所以就會報錯了。但是還有一種特殊情況不會報錯，就是反向傳播求導(dǎo)的時候如果沒用到 b 的值（比如 y=x+1， y 關(guān)于 x 的導(dǎo)數(shù)是1，和 x 無關(guān)），自然就不會去對比 b 前后的 version 了，所以不會報錯。

上邊我們所說的情況是針對非葉子節(jié)點(diǎn)的，對于 requires_grad=True 的葉子節(jié)點(diǎn)來說，要求更加嚴(yán)格了，甚至在葉子節(jié)點(diǎn)被使用之前修改它的值都不行。我們來看一個報錯信息：

RuntimeError: leaf variable has been moved into the graph interior

這個意思通俗一點(diǎn)說就是你的一頓 inplace 操作把一個葉子節(jié)點(diǎn)變成了非葉子節(jié)點(diǎn)了。我們知道，非葉子節(jié)點(diǎn)的導(dǎo)數(shù)在默認(rèn)情況下是不會被保存的，這樣就會出問題了。舉個小例子：

a?=?torch.tensor([10.,?5.,?2.,?3.],?requires_grad=True)
print(a,?a.is_leaf)
#?tensor([10.,??5.,??2.,??3.],?requires_grad=True)?True

a[:]?=?0
print(a,?a.is_leaf)
#?tensor([0.,?0.,?0.,?0.],?grad_fn=)?False

loss?=?(a*a).mean()
loss.backward()
#?RuntimeError:?leaf?variable?has?been?moved?into?the?graph?interior

我們看到，在進(jìn)行對 a 的重新 inplace 賦值之后，表示了 a 是通過 copy operation 生成的，grad_fn 都有了，所以自然而然不是葉子節(jié)點(diǎn)了。本來是該有導(dǎo)數(shù)值保留的變量，現(xiàn)在成了導(dǎo)數(shù)會被自動釋放的中間變量了，所以 PyTorch 就給你報錯了。還有另外一種情況：

a?=?torch.tensor([10.,?5.,?2.,?3.],?requires_grad=True)
a.add_(10.)?#?或者?a?+=?10.
#?RuntimeError:?a?leaf?Variable?that?requires?grad?has?been?used?in?an?in-place?operation.

這個更厲害了，不等到你調(diào)用 backward，只要你對需要求導(dǎo)的葉子張量使用了這些操作，馬上就會報錯。那是不是需要求導(dǎo)的葉子節(jié)點(diǎn)一旦被初始化賦值之后，就不能修改它們的值了呢？我們?nèi)绻谀撤N情況下需要重新對葉子變量賦值該怎么辦呢？有辦法！

#?方法一
a?=?torch.tensor([10.,?5.,?2.,?3.],?requires_grad=True)
print(a,?a.is_leaf,?id(a))
#?tensor([10.,??5.,??2.,??3.],?requires_grad=True)?True?2501274822696

a.data.fill_(10.)
#?或者?a.detach().fill_(10.)
print(a,?a.is_leaf,?id(a))
#?tensor([10.,?10.,?10.,?10.],?requires_grad=True)?True?2501274822696

loss?=?(a*a).mean()
loss.backward()
print(a.grad)
#?tensor([5.,?5.,?5.,?5.])

#?方法二
a?=?torch.tensor([10.,?5.,?2.,?3.],?requires_grad=True)
print(a,?a.is_leaf)
#?tensor([10.,??5.,??2.,??3.],?requires_grad=True)?True

with?torch.no_grad():
????a[:]?=?10.
print(a,?a.is_leaf)
#?tensor([10.,?10.,?10.,?10.],?requires_grad=True)?True

loss?=?(a*a).mean()
loss.backward()
print(a.grad)
#?tensor([5.,?5.,?5.,?5.])

修改的方法有很多種，核心就是修改那個和變量共享內(nèi)存，但 requires_grad=False 的版本的值，比如通過 tensor.data 或者 tensor.detach()（至于這二者更詳細(xì)的介紹與比較，歡迎參照我上一篇文章的第四部分）。我們需要注意的是，要在變量被使用之前修改，不然等計(jì)算完之后再修改，還會造成求導(dǎo)上的問題，會報錯的。

為什么 PyTorch 的求導(dǎo)不支持絕大部分 inplace 操作呢？從上邊我們也看出來了，因?yàn)檎娴暮?tricky。比如有的時候在一個變量已經(jīng)參與了正向傳播的計(jì)算，之后它的值被修改了，在做反向傳播的時候如果還需要這個變量的值的話，我們肯定不能用那個后來修改的值吧，但沒修改之前的原始值已經(jīng)被釋放掉了，我們怎么辦？一種可行的辦法就是我們在 Function 做 forward 的時候每次都開辟一片空間儲存當(dāng)時輸入變量的值，這樣無論之后它們怎么修改，都不會影響了，反正我們有備份在存著。但這樣有什么問題？這樣會導(dǎo)致內(nèi)存（或顯存）使用量大大增加。因?yàn)槲覀儾淮_定哪個變量可能之后會做 inplace 操作，所以我們每個變量在做完 forward 之后都要儲存一個備份，成本太高了。除此之外，inplace operation 還可能造成很多其他求導(dǎo)上的問題。

總之，我們在實(shí)際寫代碼的過程中，沒有必須要用 inplace operation 的情況，而且支持它會帶來很大的性能上的犧牲，所以 PyTorch 不推薦使用 inplace 操作，當(dāng)求導(dǎo)過程中發(fā)現(xiàn)有 inplace 操作影響求導(dǎo)正確性的時候，會采用報錯的方式提醒。但這句話反過來說就是，因?yàn)橹灰?inplace 操作不當(dāng)就會報錯，所以如果我們在程序中使用了 inplace 操作卻沒報錯，那么說明我們最后求導(dǎo)的結(jié)果是正確的，沒問題的。這就是我們常聽見的沒報錯就沒有問題。

動態(tài)圖，靜態(tài)圖

可能大家都聽說過，PyTorch 使用的是動態(tài)圖（Dynamic Computational Graphs）的方式，而 TensorFlow 使用的是靜態(tài)圖（Static Computational Graphs）。所以二者究竟有什么區(qū)別呢，我們本節(jié)來就來討論這個事情。

所謂動態(tài)圖，就是每次當(dāng)我們搭建完一個計(jì)算圖，然后在反向傳播結(jié)束之后，整個計(jì)算圖就在內(nèi)存中被釋放了。如果想再次使用的話，必須從頭再搭一遍，參見下邊這個例子。而以 TensorFlow 為代表的靜態(tài)圖，每次都先設(shè)計(jì)好計(jì)算圖，需要的時候?qū)嵗@個圖，然后送入各種輸入，重復(fù)使用，只有當(dāng)會話結(jié)束的時候創(chuàng)建的圖才會被釋放（不知道這里我對 tf.Session 的理解對不對，如果有錯誤希望大佬們能指正一下），就像我們之前舉的那個水管的例子一樣，設(shè)計(jì)好水管布局之后，需要用的時候就開始搭，搭好了就往入口加水，什么時候不需要了，再把管道都給拆了。

#?這是一個關(guān)于 PyTorch 是動態(tài)圖的例子：
a?=?torch.tensor([3.0,?1.0],?requires_grad=True)
b?=?a?*?a
loss?=?b.mean()

loss.backward()?#?正常
loss.backward()?#?RuntimeError

#?第二次：從頭再來一遍
a?=?torch.tensor([3.0,?1.0],?requires_grad=True)
b?=?a?*?a
loss?=?b.mean()
loss.backward()?#?正常

從描述中我們可以看到，理論上來說，靜態(tài)圖在效率上比動態(tài)圖要高。因?yàn)槭紫?，靜態(tài)圖只用構(gòu)建一次，然后之后重復(fù)使用就可以了；其次靜態(tài)圖因?yàn)槭枪潭ú恍枰淖兊?，所以在設(shè)計(jì)完了計(jì)算圖之后，可以進(jìn)一步的優(yōu)化，比如可以將用戶原本定義的 Conv 層和 ReLU 層合并成 ConvReLU 層，提高效率。

但是，深度學(xué)習(xí)框架的速度不僅僅取決于圖的類型，還很其他很多因素，比如底層代碼質(zhì)量，所使用的底層 BLAS 庫等等等都有關(guān)。從實(shí)際測試結(jié)果來說，至少在主流的模型的訓(xùn)練時間上，PyTorch 有著至少不遜于靜態(tài)圖框架 Caffe，TensorFlow 的表現(xiàn)。具體對比數(shù)據(jù)可以參考：

https://github.com/ilkarman/DeepLearningFrameworks

大家不要急著糾正我，我知道，我現(xiàn)在就說：當(dāng)然，在 9102 年的今天，動態(tài)圖和靜態(tài)圖直接的界限已經(jīng)開始慢慢模糊。PyTorch 模型轉(zhuǎn)成 Caffe 模型越來越方便，而 TensorFlow 也加入了一些動態(tài)圖機(jī)制。

除了動態(tài)圖之外，PyTorch 還有一個特性，叫 eager execution。意思就是當(dāng)遇到 tensor 計(jì)算的時候，馬上就回去執(zhí)行計(jì)算，也就是，實(shí)際上 PyTorch 根本不會去構(gòu)建正向計(jì)算圖，而是遇到操作就執(zhí)行。真正意義上的正向計(jì)算圖是把所有的操作都添加完，構(gòu)建好了之后，再運(yùn)行神經(jīng)網(wǎng)絡(luò)的正向傳播。

正是因?yàn)?PyTorch 的兩大特性：動態(tài)圖和 eager execution，所以它用起來才這么順手，簡直就和寫 Python 程序一樣舒服，debug 也非常方便。除此之外，我們從之前的描述也可以看出，PyTorch 十分注重占用內(nèi)存（或顯存）大小，沒有用的空間釋放很及時，可以很有效地利用有限的內(nèi)存。

總結(jié)

本篇文章主要討論了 PyTorch 的 Autograd 機(jī)制和使用 inplace 操作不當(dāng)可能會導(dǎo)致的各種報錯。在實(shí)際寫代碼的過程中，涉及需要求導(dǎo)的部分，不建議大家使用 inplace 操作。除此之外我們還比較了動態(tài)圖和靜態(tài)圖框架，PyTorch 作為動態(tài)圖框架的代表之一，對初學(xué)者非常友好，而且運(yùn)行速度上不遜于靜態(tài)圖框架，再加上現(xiàn)在通過 ONNX 轉(zhuǎn)換為其他框架的模型用以部署也越來越方便，我覺得是一個非常稱手的深度學(xué)習(xí)工具。

最后，感謝閱讀，希望大家讀完之后有所收獲。

參考資料