Pytorch筆記——2、Pytorch自動求梯度

文章目錄

• ​​使用方法​​
• ​​示例​​

在深度學習中，我們經常需要對函數求梯度（gradient）。PyTorch提供的

​​autograd​​包能夠根據輸入和前向傳播過程自動建構計算圖，并執行反向傳播。本節将介紹如何使用autograd包來進行自動求梯度的有關操作

使用方法

• 将 ​

  ​tensor​

  ​​的屬性​

  ​.requires_grad​

  ​​設定為​

  ​True​

  ​，它将開始追蹤在其上的所有操作（這樣就可以利用鍊式法則進行梯度傳播了）
• 完成計算後，可以調用​

  ​.backward()​

  ​​來完成所有梯度計算。此​

  ​Tensor​

  ​​的梯度将累積到​

  ​.grad​

  ​屬性中
• 如果不想要被繼續追蹤，可以調用​

  ​.detach()​

  ​将其從追蹤記錄中分離出來，這樣就可以防止将來的計算被追蹤，這樣梯度就傳不過去了
• 此外，還可以用​

  ​with torch.no_grad()​

  ​​将不想被追蹤的操作代碼塊包裹起來，這種方法在評估模型的時候很常用，因為在評估模型時，我們并不需要計算可訓練參數（​

  ​requires_grad=True​

  ​）的梯度
• ​

  ​Function​

  ​​是另外一個很重要的類。​

  ​Tensor​

  ​​和​

  ​Function​

  ​​互相結合就可以建構一個記錄有整個計算過程的有向無環圖（DAG）。每個​

  ​Tensor​

  ​​都有一個​

  ​.grad_fn​

  ​​屬性，該屬性即建立該​

  ​Tensor​

  ​​的​

  ​Function​

  ​​, 就是說該​

  ​Tensor​

  ​​是不是通過某些運算得到的，若是，則​

  ​grad_fn​

  ​傳回一個與這些運算相關的對象，否則是None

注意: 在​

​y.backward()​

​​時，如果​

​y​

​​是标量，則不需要為​

​backward()​

​​傳入任何參數；否則，需要傳入一個與​

​y​

​​同形的​

​Tensor​

​

為什麼?

為什麼在​​

​y.backward()​

​​時，如果​

​y​

​​是标量，則不需要為​

​backward()​

​​傳入任何參數；否則，需要傳入一個與​

​y​

​​同形的​

​Tensor​

​​?

簡單來說就是為了避免向量（甚至更高維張量）對張量求導，而轉換成标量對張量求導。舉個例子，假設形狀為 ​​

​m x n​

​​ 的矩陣 X 經過運算得到了 ​

​p x q​

​​ 的矩陣 Y，Y 又經過運算得到了 ​

​s x t​

​​ 的矩陣 Z。那麼按照前面講的規則，dZ/dY 應該是一個 ​

​s x t x p x q​

​​ 四維張量，dY/dX 是一個 ​

​p x q x m x n​

​​的四維張量。問題來了，怎樣反向傳播？怎樣将兩個四維張量相乘？？？這要怎麼乘？？？就算能解決兩個四維張量怎麼乘的問題，四維和三維的張量又怎麼乘？導數的導數又怎麼求，這一連串的問題，感覺要瘋掉……

為了避免這個問題，我們不允許張量對張量求導，隻允許标量對張量求導，求導結果是和自變量同形的張量。是以必要時我們要把張量通過将所有張量的元素權重求和的方式轉換為标量，舉個例子，假設​

​y​

​​由自變量​

​x​

​​計算而來，​

​w​

​​是和​

​y​

​​同形的張量，則​

​y.backward(w)​

​​的含義是：先計算​

​l = torch.sum(y * w)​

​​，則​

​l​

​​是個标量，然後求​

​l​

​​對自變量​

​x​

​的導數。

參考自​​PyTorch 的 backward 為什麼有一個 grad_variables 參數？​​

示例

# 建立一個Tensor并設定requires_grad=True:
x = torch.ones(2, 2, requires_grad=True)
print(x)
print(x.grad_fn)

# 再做一下加法運算操作：
y = x + 2
print(y)
print(y.grad_fn)

# 再來點複雜操作
z = y * y * 3
out = z.mean()
print(z)
print(out)      

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
None

tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward>)
<AddBackward object at 0x1100477b8>

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>)
tensor(27., grad_fn=<MeanBackward0>)      

注意x是直接建立的，是以它沒有​

​grad_fn​

​​，而y是通過一個加法操作建立的，是以它有一個為​

​<AddBackward>​

​​的​

​grad_fn​

​

像x這種直接建立的稱為葉子節點，葉子節點對應的​

​grad_fn​

​​是​

​None​

​ ：

print(x.is_leaf, y.is_leaf) # True False      

通過​

​.requires_grad_()​

​​來用in-place的方式改變​

​requires_grad​

​屬性：

a = torch.randn(2, 2) # 缺失情況下預設 requires_grad = False
a = ((a * 3) / (a - 1))
print(a.requires_grad) # False
a.requires_grad_(True)
print(a.requires_grad) # True
b = (a * a).sum()
print(b.grad_fn)      

False
True
<SumBackward0 object at 0x118f50cc0>      

因為​

​out​

​​是一個标量，是以調用​

​backward()​

​時不需要指定求導變量：

out.backward() # 等價于 out.backward(torch.tensor(1.))      

我們來看看​

​out​

​​關于​

​x​

​​的梯度 :

print(x.grad)      

tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])      

我們令​

​out​

​​為

是以

是以上面的輸出是正确的

數學上，如果有一個函數值和自變量都為向量的函數 , 那麼 關于

而​

​torch.autograd​

​​這個包就是用來計算一些雅克比矩陣的乘積的。例如，如果 是一個标量函數的

那麼根據鍊式法則我們有 關于

注意：grad在反向傳播過程中是累加的(accumulated)，這意味着每一次運作反向傳播，梯度都會累加之前的梯度，是以一般在反向傳播之前需把梯度清零

# 再來反向傳播一次，注意grad是累加的
out2 = x.sum()
out2.backward()
print(x.grad)

out3 = x.sum()
x.grad.data.zero_()
out3.backward()
print(x.grad)      

tensor([[5.5000, 5.5000],
        [5.5000, 5.5000]])
tensor([[1., 1.],
        [1., 1.]])      

來看一些實際例子:

x = torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True)
y = 2 * x
z = y.view(2, 2)
print(z)      

tensor([[2., 4.],
        [6., 8.]], grad_fn=<ViewBackward>)      

現在 ​

​z​

​​ 不是一個标量，是以在調用​

​backward​

​​時需要傳入一個和​

​z​

​同形的權重向量進行權重求和得到一個标量:

v = torch.tensor([[1.0, 0.1], [0.01, 0.001]], dtype=torch.float)
z.backward(v)
print(x.grad)      

tensor([2.0000, 0.2000, 0.0200, 0.0020])      

注意，​

​x.grad​

​​是和​

​x​

​同形的張量。

再來看看中斷梯度追蹤的例子：

x = torch.tensor(1.0, requires_grad=True)
y1 = x ** 2 
with torch.no_grad():
    y2 = x ** 3
y3 = y1 + y2
    
print(x.requires_grad)
print(y1, y1.requires_grad) # True
print(y2, y2.requires_grad) # False
print(y3, y3.requires_grad) # True      

True
tensor(1., grad_fn=<PowBackward0>) True
tensor(1.) False
tensor(2., grad_fn=<ThAddBackward>) True      

可以看到，上面的​

​y2​

​​是沒有​

​grad_fn​

​​而且​

​y2.requires_grad=False​

​​的，而​

​y3​

​​是有​

​grad_fn​

​​的。如果我們将​

​y3​

​​對​

​x​

​求梯度的話會是多少呢？

y3.backward()
print(x.grad)      

tensor(2.)      

為什麼是2呢？，當 時 不應該是5嗎？事實上，由于 的定義是被​​

​torch.no_grad():​

​​包裹的，是以與 有關的梯度是不會回傳的，隻有與 有關的梯度才會回傳，即 對

RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn      

x = torch.ones(1,requires_grad=True)

print(x.data) # 還是一個tensor
print(x.data.requires_grad) # 但是已經是獨立于計算圖之外

y = 2 * x
x.data *= 100 # 隻改變了值，不會記錄在計算圖，是以不會影響梯度傳播

y.backward()
print(x) # 更改data的值也會影響tensor的值
print(x.grad)      

tensor([1.])
False
tensor([100.], requires_grad=True)
tensor([2.])