pytorch 自動求梯度

在深度學習中，我們經常需要對函數求梯度（gradient）。PyTorch提供的autograd包能夠根據輸入和前向傳播過程自動構建計算圖，並執行反向傳播。

概念

將Tensor的屬性.requires_grad設置爲True，它將開始追蹤在其上的所有操作，完成計算後，可以調用.backward()來完成所有梯度計算。此Tensor的梯度將累積到.grad屬性中。

如果y.backward()時，y是標量，則不需要爲backward()傳入任何參數；否則需要傳入一個與y同形的Tensor

如果不想被繼續追蹤，則可以調用.detach()將其從追蹤記錄中分離出來，這樣就可以防止將來的計算被追蹤，這樣梯度就傳不下去。此外，還可以調用with torch.no_grad()將不想被追蹤的操作代碼塊包裹起來，這種方法在評估模型的時候很常用。

Function是另外一個很重要的類。Tensor和Function互相結合就可以構建一個記錄有整個計算過程的有向無環圖（DAG）。每個Tensor都有一個.grad_fn屬性，該屬性即創建該Tensor的Function, 就是說該Tensor是不是通過某些運算得到的，若是，則grad_fn返回一個與這些運算相關的對象，否則是None。

下面通過例子來理解這些概念。

Tensor

創建一個Tensor並設置requires_grad=True:

x = torch.ones(2, 2, requires_grad=True)
print(x)
print(x.grad_fn)

輸出：

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

再做一下運算操作：

y = x + 2
print(y)
print(y.grad_fn)

輸出：

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

注意x是直接創建的，所以它沒有grad_fn, 而y是通過一個加法操作創建的，所以它有一個爲<AddBackward>的grad_fn。

像x這種直接創建的稱爲葉子節點，葉子節點對應的grad_fn是None。

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

再來點複雜度運算操作：

z = y * y * 3
out = z.mean()
print(z, out)

輸出：

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward>) tensor(27., grad_fn=<MeanBackward1>)

通過.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的梯度 $\frac{d(out)}{dx}$:

print(x.grad)

輸出：

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

我們令out爲 $o$ , 因爲
$o=\frac14\sum_{i=1}^4z_i=\frac14\sum_{i=1}^43(x_i+2)^2$
所以
$\frac{\partial{o}}{\partial{x_i}}\bigr\rvert_{x_i=1}=\frac{9}{2}=4.5$
所以上面的輸出是正確的。

數學上，如果有一個函數值和自變量都爲向量的函數 $\vec{y}=f(\vec{x})$, 那麼 $\vec{y}$ 關於 $\vec{x}$ 的梯度就是一個雅可比矩陣（Jacobian matrix）:
$J=\left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)$
而torch.autograd這個包就是用來計算一些雅克比矩陣的乘積的。例如，如果 $v$ 是一個標量函數的 $l=g\left(\vec{y}\right)$ 的梯度：
$v=\left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right)$
那麼根據鏈式法則我們有 $l$ 關於 $\vec{x}$ 的雅克比矩陣就爲:
$v J=\left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right) \left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)=\left(\begin{array}{ccc}\frac{\partial l}{\partial x_{1}} & \cdots & \frac{\partial l}{\partial x_{n}}\end{array}\right)$

注意：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.]])

爲什麼在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的導數。
參考

來看一些實際例子。

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呢？$y_3 = y_1 + y_2 = x^2 + x^3$，當 $x=1$ 時 $\frac {dy_3} {dx}$ 不應該是5嗎？事實上，由於 $y_2$ 的定義是被torch.no_grad():包裹的，所以與 $y_2$ 有關的梯度是不會回傳的，只有與 $y_1$ 有關的梯度纔會回傳，即 $x^2$ 對 $x$ 的梯度。

上面提到，y2.requires_grad=False，所以不能調用 y2.backward()，會報錯：

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

此外，如果我們想要修改tensor的數值，但是又不希望被autograd記錄（即不會影響反向傳播），那麼我麼可以對tensor.data進行操作。

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.])

參考：

動手學pytorch