0502-計算圖

二十三歲的有德發表於2021-04-24

0502-計算圖

目錄

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

一、手動計算梯度

torch 的 autograd 的底層採用了計算圖，它是一種特殊的有向無環圖，記錄運算元和變數的關係，如下圖所示：

0502-計算圖

其中 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。上述所說的有向無環圖如下圖所示：

0502-計算圖

由於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 採用動態圖的設計，可以很方便的檢視中間層的輸出，動態地設計計算圖的結構。

相關文章