天天看點
傳回

0502-計算圖

0502-計算圖

目錄

  • 一、手動計算梯度
  • 二、利用 torch 進行反向傳播求梯度
  • 三、在前向傳播中利用動态圖特性建構計算圖
  • 四、variable 的 grad 屬性和 backward函數 的 grad_variables 參數的差別
  • 五、計算圖特點小結

pytorch完整教程目錄：https://www.cnblogs.com/nickchen121/p/14662511.html

一、手動計算梯度

torch 的 autograd 的底層采用了計算圖，它是一種特殊的有向無環圖，記錄算子和變量的關系，如下圖所示：

其中 MUL 和 ADD 都是算子，用矩形表示；w、x、b 都是變量，用橢圓形表示。上述所示的變量 w、x、b 都是葉子節點，一般由使用者創立，不依賴于其他變量。z 稱為根結點，是計算圖的最終目标。

其中各個葉子節點的梯度可以用鍊式法則求出為：

  1. \(\frac{\partial{z}}{\partial{y}}=1, \frac{\partial{z}}{\partial{b}}=1\)
  2. \(\frac{\partial{z}}{\partial{w}}=\frac{\partial{z}}{\partial{y}}\frac{\partial{y}}{\partial{w}}=1*x,\frac{\partial{z}}{\partial{x}}=\frac{\partial{z}}{\partial{y}}\frac{\partial{z}}{\partial{x}}=1*w\)

二、利用 torch 進行反向傳播求梯度

對于上述的計算梯度，如果有了計算圖，則可以通過 torch 的 autograd 反向傳播自動完成。前面說到 autograd 會随着使用者的操作，記錄生産目前的 variable 的所有操作，并由此建立一個有向無環圖，随着使用者的每一個操作，相應的計算圖就會發生改變，更底層的操作就是在圖中記錄了 Function，如下圖的 addBackward。上述所說的有向無環圖如下圖所示：

由于torch 把每一個操作都寫入了計算圖中，也由此每一個變量在圖中的位置可通過 它的grad_fn 屬性在圖中的位置推測得到。

進而在反向傳播過程中，autograd 沿着這個圖從根節點 z 溯源，然後利用鍊式求導法則計算所有葉子節點的梯度。每一個前向傳播操作的函數都會有與之對應的反向傳播函數用來計算輸入的各個 variable 的梯度，這些函數的函數名通常以 Backward 結尾。

x = V(t.ones(1))
b = V(t.rand(1), requires_grad=True)
w = V(t.rand(1), requires_grad=True)
y = w * x  # 等價于 y=w.mul(x)
z = y + b  # 等價于 z=y.add(b)
           
# 由于 y 依賴于求導的 w，故而即使 y 沒有指定requires_grad=True，也為 True；z 同理
x.requires_grad, b.requires_grad, w.requires_grad, y.requires_grad, z.requires_grad
           
(False, True, True, True, True)
           
x.is_leaf, b.is_leaf, w.is_leaf, y.is_leaf, z.is_leaf
           
(True, True, True, False, False)
           
# grad_fn 可以檢視這個 variable 的反向傳播函數
# 由于 z 是 add 函數的輸出，是以它的反向傳播函數是 AddBackward
z.grad_fn
           
<AddBackward0 at 0x7fdd9bbbe470>
           
# next_functions 儲存 grad_fn 的輸入，grad_fn 是一個元組
# 第一個是 y，它是乘法的輸出，是以對應的反向傳播函數 y.grad_fn 是 MulBackward
# 第二個是 b，它是葉子節點，由使用者建立，grad_fn 為 None，但是有 z.grad_fn.next_functions
z.grad_fn.next_functions
           
((<MulBackward0 at 0x7fdd9bbbe908>, 0),
 (<AccumulateGrad at 0x7fdd9bbbe940>, 0))
           
z.grad_fn.next_functions[0][0] == y.grad_fn  # 證明上述所說
           
True
           
# 第一個是 w，葉子節點，但代碼中規定需要求導，梯度是累加的
# 第二個是 x，葉子節點，單不需要求導，是以為 None
y.grad_fn.next_functions
           
((<AccumulateGrad at 0x7fdd9bbc50f0>, 0), (None, 0))
           
# 雖然 w 規定了需要求導，但是葉子節點的 grad_fn 都是 None
w.grad_fn, x.grad_fn
           
(None, None)

計算 w 的梯度時需要用到 x 的數值\((\frac{\partial{y}}{\partial{w}}=x)\)，這些數值在前向過程中會被儲存為 buffer，但是在梯度計算完之後清空。為了能夠多次反向傳播，可以指定 retain_graph 來保留這些 buffer。

# error 的原因是版本問題，PyTorch0.3 中把許多python的操作轉移到了C++中
# saved_variables 現在是一個c++的對象，無法通過python通路。
try:
    y.grad_fn.saved_variables
except Exception as e:
    print(f'error: {e}')
           
error: 'MulBackward0' object has no attribute 'saved_variables'
           
# 使用 retain_graph 儲存 buffer
z.backward(retain_graph=True)
w.grad
           
tensor([1.])
           
# 多次反向傳播，梯度累加，這也就是 w 中 AccumulateGrad 辨別的含義
# 如果第一次 backward 沒有 retain_graph=True 參數，再次反向傳播則會報錯
z.backward()
w.grad
           
tensor([2.])
           
# 由于反向傳播沒有儲存 buffer，前向過程中儲存的 buffer 都被清空，無法在進行正常的反向傳播
z.backward()  # 會報錯
y.grad_fn.saved_variables  # 會報錯

三、在前向傳播中利用動态圖特性建構計算圖

由于 torch 使用的是動态圖，它的計算圖在每次前向傳播開始都是從頭開始建構的，是以可以用使用 Python 的控制語句按照需求建構計算圖。這意味着你不需要事先建構所有可能用到的圖的路徑，圖可以在運作的時候建構。

def abs(x):
    if x.data[0] > 0: return x
    else: return -x


x = V(t.ones(1), requires_grad=True)
y = abs(x)  # 相當于 y = x
y.backward()
x.grad
           
tensor([1.])
           
x = V(-1 * t.ones(1), requires_grad=True)
y = abs(x)  # 相當于 y = -x
y.backward()
x.grad
           
tensor([-1.])
           
t.arange(-2, 4)
           
tensor([-2, -1,  0,  1,  2,  3])
           
def f(x):
    result = 1
    for i in x:
        if i.data > 0:
            result = i * result
    return result


x = V(t.arange(-2, 4, dtype=t.float), requires_grad=True)
y = f(x)  # 相當于 y = x[3]*x[4]*x[5]
y.backward()
x.grad
           
tensor([0., 0., 0., 6., 3., 2.])

在某些場景下，有些節點不需要反向傳播，也不需計算圖的生成，是以可以使用一個上下文管理器

with torch.no_grad()

 
x = V(t.ones(1), requires_grad=True)
y = 2 * x
x.requires_grad, y.requires_grad
           
(True, True)
           
x = V(t.ones(1), requires_grad=True)
with t.no_grad():
    y = 2 * x
x.requires_grad, y.requires_grad
           
(True, False)

反向傳播過程中非葉子節點的導數計算完之後将會被清空，可以通過以下三種方法檢視這邊變量的梯度：

  • 使用retain_grad儲存梯度
  • 使用

    autograd.grad

     函數
  • 使用 hook

上述兩個方法都是很強大的工具，具體的方法可以檢視官網 api，這裡隻給出基礎的用法。

x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)

y = x * w
z = y.sum()

z.backward()
y.retain_grad()
# 非葉子節點grad 計算完後清空，y 是 None
x.grad, w.grad, y.grad
           
(tensor([0.6035, 0.5587, 0.7389]), tensor([1., 1., 1.]), None)
           
# 第一種方法，儲存梯度
x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)

y = x * w
z = y.sum()

y.retain_grad()
z.backward()
# 非葉子節點grad 計算完後清空，y 是 None
y.grad
           
tensor([1., 1., 1.])
           
# 第二種方法，使用 grad 擷取中間變量的梯度
x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)

y = x * w
z = y.sum()

# z 對 y 的梯度，隐式調用 backward()
t.autograd.grad(z, y)
           
(tensor([1., 1., 1.]),)
           
# 第三種方法，使用 hook
# hook 是一個函數，輸入是梯度，不應該有傳回值
def variable_hook(grad):
    print(f'y 的梯度：{grad}')


x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)

y = x * w
z = y.sum()

# 注冊 hook
hook_handle = y.register_hook(variable_hook)
z = y.sum()
z.backward()

# 除非你每次都要使用 hook，否則使用後應該移除 hook
hook_handle.remove()
           
y 的梯度：tensor([1., 1., 1.])

四、variable 的 grad 屬性和 backward函數 的 grad_variables 參數的差別

  • variable X 的梯度是目标函數 f(x) 對 X 的梯度，\(\frac{\partial{f(X)}}{\partial{X}}=(\frac{\partial{f(X)}}{\partial{x_0}},\frac{\partial{f(X)}}{\partial{x_1}},\cdots,\frac{\partial{f(X)}}{\partial{x_n}})\)

  • y.backward(grad_variables)

     中的 grad_variables 相當于鍊式求導法則中的 \(\frac{\partial{z}}{\partial{x}}=\frac{\partial{z}}{\partial{y}}\frac{\partial{y}}{\partial{x}}\) 中的 \(\frac{\partial{z}}{\partial{y}}\)。z 是目标函數，一般是一個标量，是以 \(\frac{\partial{z}}{\partial{y}}\) 的形狀和 y 的形狀一緻。z.backward()等價于 y.backward(grad_y)。z.backward()省略了 grad_variables 參數，因為 z 是一個标量，并且 \(\frac{\partial{z}}{\partial{z}}=1\) 
x = V(t.arange(0, 3, dtype=t.float32), requires_grad=True)
y = x**2 + x * 2  # dy/dz = 2 * x + 2
z = y.sum()
z.backward()  # 從 z 開始反向傳播
x.grad
           
tensor([2., 4., 6.])
           
x = V(t.arange(0, 3, dtype=t.float32), requires_grad=True)
y = x**2 + x * 2  # dy/dz = 2 * x + 2
z = y.sum()
y_grad_variables = V(t.Tensor([1, 1, 1]))  # dz/dy
y.backward(y_grad_variables)
x.grad
           
tensor([2., 4., 6.])

五、計算圖特點小結

在反向傳播時，需要注意的是，隻有對 variable 操作才能使用 autograd，如果對 variable 的 data 操作，無法使用反向傳播，并且除了參數初始化，一般不會修改 varaible.data 值。

講了這麼多，在 torch 中計算圖的特點可總結如下：

  • autograd 根據使用者對 variable 的操作建構計算圖。對 variable 的操作抽象為 Function。
  • 由使用者建立的結點稱作葉子節點，葉子節點的 grad_fn 為 None。并且葉子節點中需要求導的 variable，具有 AccumulateGrad 辨別，因為它的梯度是累加的。
  • variable 預設是不需要求導的。如果某一個節點的

    requeires_grad=True

     ，那麼所有依賴它的節點都為 True。
  • 多次反向傳播時，梯度是累加的。反向傳播的中間緩存會被清空，為進行多次反向傳播需要指定

    retain_graph=True

     來儲存這些緩存。
  • 非葉子節點的梯度計算完之後就會被清空，可以使用 autograd.grad 和 hook 技術擷取非葉子節點梯度的值，也可以通過 retain_grad 儲存它的梯度值。
  • varibale 的 grad 和 data 形狀一緻，應該避免直接修改 variable.data，因為對 data 值的修改無法進行反向傳播。
  • 反向傳播函數 backward 的參數 grad_variables 可以看成是鍊式求導的中間結果，如果是标量，可以省略，預設為 1。
  • torch 采用動态圖的設計，可以很友善的檢視中間層的輸出，動态地設計計算圖的結構。
torch_long
上一篇: html 輸入框顯示“小叉叉”的清空圖示
下一篇: JS擷取textarea的光标位置并插入内容

繼續閱讀