06_pytorch的autograd操作

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

06_pytorch的autograd操作

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

一、引言

上一篇文章簡單的講解了 tensor 的使用方法，雖然看起來很多，但還是很不全面的，不過對於接下來各種專案的搭建是足夠的，而且一通百通，真遇到一個兩個不太會的方法，百度是個好東西。

在使用 torch 搭建一個專案時，就好比在搭建一個房子，而 tensor 就相當於各種原料，對於房子的骨架結構，則更多的需要我們接下來要介紹的東西來實現。

也就是 autograd，autogra 的中文名叫做自動微分，顧名思義，就是讓 torch 幫我們自動計算微分，它也是 torch 進行神經網路優化的核心。因此站在神經網路架構中講，autograd 這個東西能夠根據輸入和前向傳播過程自動構建計算圖，並執行反向傳播。

注：計算圖可以簡單的看做網路的架構圖，只不過這個“架構圖”轉載的是各個流程單元的資料資訊。

二、Variable

2.1 Variable 的資料結構

autograd 模組的核心資料結構是 Variable，它是對 tensor 的封裝，並且會記錄 tensor 的操作記錄用來構建計算圖。Variable 的資料結構如下圖所示：

上圖主要包含三個屬性：

data：儲存 variable 所包含的 tensor
grad：儲存 data 對應的梯度，grad 也是 variable，而非 tensor，它與 data 形狀一致
grad_fn：指向一個 Function，記錄 variable 的操作歷史，即它是什麼操作的輸出，用來構建計算圖。如果某一變數是使用者建立的，則它為葉子節點，對應的 grad_fn 為 None

Variable 的建構函式需要傳入 tensor，也有兩個可選的引數：

requires_grad(bool)：是否需要對該 Variable 求導
volatile(bool)：設定為 True，構建在該 Variable 之上的圖都不會求導

2.2 反向傳播

Variable 支援大部分 tensor 支援的函式，但不支援部分 inplace 函式，因為它們會修改 tensor 自身，然而在反向傳播中，Variable 需要快取原來的 tensor 計算梯度。如果想要計算各個 Variable 的梯度，只需要呼叫根結點的 backward 方法，autograd 則會自動沿著計算圖反向傳播，計算每一個葉子節點的梯度。

variable.backward(grad_variable=None, retain_fraph=None, create_graph=None)的引數解釋如下：

grad_variables：形狀與 Variable 一直，對於 y.backward()，grad_variables 相當於鏈式法則\(\frac{\partial{z}}{\partial{x}} = \frac{\partial{z}}{\partial{y}}\frac{\partial{y}}{\partial{x}}\)。grad_variables 也可以是 tensor 或序列
retain_graph：反向傳播會快取一些中間結果，反向傳播之後，這些快取就會清除，可通過這個引數指定不清除快取，用來多次反向傳播
create_graph：對反向傳播過程中再次構建計算圖

import torch as t
from torch.autograd import Variable as V

a = V(t.ones(3, 4), requires_grad=True)
a

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

b = V(t.zeros(3, 4))
b

tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])

c = a.add(b)  # variable 函式的使用和 tensor 一致，等同於 c=a+b
c

tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]], grad_fn=<AddBackward0>)

# 注：雖然沒有指定 c 需要求導，但 c 依賴於 a，由於 a 需要求導，因此 c 的 requeires_grad 預設設定為 True
a.requires_grad, b.requires_grad, c.requires_grad

(True, False, True)

# 注：`c.data.sum()`是在去 data 後變為 tensor，從 tensor 計算sum；`c.sum()`計算後仍然是 variable
d = c.sum()
d.backward()  # 反向傳播

a.grad

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

# 由使用者建立的 Variable 屬於葉子節點，對應的 grad_fn 是 None
a.is_leaf, b.is_leaf, c.is_leaf

(True, True, False)

# 雖然 `c.requires_grad=True`，但是它的梯度計算完之後就會被釋放
c.retain_grad()  # 對於非葉節點求導，需進行儲存，否則會被自動釋放，這裡我們先儲存然後再檢視，如果沒有這一行，會報錯
c.grad is None

True

2.3 autograd 求導數和手動求導數

通過對函式\(y=x^2e^x\)求導，我們可以看看 autograd 求導數和自己寫個方法求導數的區別。這個函式的導數如下：

\[\frac{dy}{dx}=2xe^x+x^2e^x \]

def f(x):
    """計算 y"""
    y = x**2 * t.exp(x)
    return y


def grad_f(x):
    """手動對函式求導"""
    dx = 2 * x * t.exp(x) + x**2 * t.exp(x)
    return dx


x = V(t.randn(3, 4), requires_grad=True)
y = f(x)
y

tensor([[0.1456, 0.0344, 0.5350, 0.0165],
        [0.9979, 0.3471, 0.5367, 0.4838],
        [0.2595, 0.0010, 0.2002, 0.2058]], grad_fn=<MulBackward0>)

y_grad_variables = t.ones(
    y.size())  # 由於dz/dy=1，並且grad_variables 形狀需要與 y 一致，詳解看下面的 3.4 小節
y.backward(y_grad_variables)
x.grad

tensor([[ 1.0434, -0.3003, -0.0624,  0.2895],
        [ 3.8373,  1.8350,  0.0467, -0.2063],
        [-0.4456,  0.0655, -0.4609, -0.4604]])

grad_f(x)  # autograd 計算的結果和利用公式計算的結果一致

tensor([[ 1.0434, -0.3003, -0.0624,  0.2895],
        [ 3.8373,  1.8350,  0.0467, -0.2063],
        [-0.4456,  0.0655, -0.4609, -0.4604]], grad_fn=<AddBackward0>)

三、計算圖

3.1 手動計算梯度

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

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

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

\(\frac{\partial{z}}{\partial{y}}=1, \frac{\partial{z}}{\partial{b}}=1\)
\(\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\)

3.2 利用 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  # 會報錯

3.3 在前向傳播中利用動態圖特性構建計算圖

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

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

3.5 計算圖特點小結

在反向傳播時，需要注意的是，只有對 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 採用動態圖的設計，可以很方便的檢視中間層的輸出，動態地設計計算圖的結構。

四、用 variable 實現線性迴歸（autograd 實戰）

import torch as t
from torch.autograd import Variable as V
# 不是 jupyter 執行請註釋掉下面一行，為了 jupyter 顯示圖片
%matplotlib inline
from matplotlib import pyplot as plt
from IPython import display

t.manual_seed(1000)  # 隨機數種子


def get_fake_data(batch_size=8):
    """產生隨機資料：y = x * 2 + 3，同時加上了一些噪聲"""
    x = t.rand(batch_size, 1) * 20
    y = x * 2 + (1 + t.randn(batch_size, 1)) * 3  # 噪聲為 |3-((1 + t.randn(batch_size, 1)) * 3)|

    return x, y


# 檢視 x，y 的分佈情況
x, y = get_fake_data()
plt.scatter(x.squeeze().numpy(), y.squeeze().numpy())
plt.show()

png

# 隨機初始化引數
w = V(t.rand(1, 1), requires_grad=True)
b = V(t.zeros(1, 1), requires_grad=True)

lr = 0.001  # 學習率

for i in range(8000):
    x, y = get_fake_data()
    x, y = V(x), V(y)

    # forwad：計算 loss
    y_pred = x.mm(w) + b.expand_as(y)
    loss = 0.5 * (y_pred - y)**2
    loss = loss.sum()

    # backward：自動計算梯度
    loss.backward()

    # 更新引數
    w.data.sub_(lr * w.grad.data)
    b.data.sub_(lr * b.grad.data)

    # 梯度清零，不清零則會進行疊加，影響下一次梯度計算
    w.grad.data.zero_()
    b.grad.data.zero_()

    if i % 1000 == 0:
        # 畫圖
        display.clear_output(wait=True)
        x = t.arange(0, 20, dtype=t.float).view(-1, 1)
        y = x.mm(w.data) + b.data.expand_as(x)
        plt.plot(x.numpy(), y.numpy(), color='red')  # 預測效果

        x2, y2 = get_fake_data(batch_size=20)
        plt.scatter(x2.numpy(), y2.numpy(), color='blue')  # 真實資料

        plt.xlim(0, 20)
        plt.ylim(0, 41)
        plt.show()
        plt.pause(0.5)
        break  # 登出這一行，可以看到動態效果

png

# y = x * 2 + 3
w.data.squeeze(), b.data.squeeze()  # 列印訓練好的 w 和 b

(tensor(2.3009), tensor(0.1634))

五、總結

本篇文章介紹了 torch 的一個核心——autograd，其中 autograd 中的 variable 和 Tensor 都屬於 torch 中的基礎資料結構，variable 封裝了 Tensor ，擁有著和 Tensor 幾乎一樣的介面，並且提供了自動求導技術。autograd 是 torch 的自動微分引擎，採用動態計算圖的技術，可以更高效的計算導數。

這篇文章說實話是有點偏難的，可以多看幾遍，尤其是對於還沒有寫過實際專案的小白，不過相信有前面幾個小專案練手，以及最後一個線性迴歸的小 demo，相信你差也不差的能看懂，但這都不要緊，在未來的專案實戰中，你將會對 autograd 的體會越來越深刻。

autograd實現
2020-10-30
pytorch程式碼示例筆記 -- Autograd
2020-12-30
PyTorch筆記
PyTorch 介紹 | AUTOMATIC DIFFERENTIATION WITH TORCH.AUTOGRAD
2022-02-08
PyTorch
[原始碼解析] PyTorch 分散式 Autograd (5) ---- 引擎(上)
2021-12-04
原始碼PyTorch分散式
[原始碼解析] PyTorch 分散式 Autograd (6) ---- 引擎(下)
2021-12-06
原始碼PyTorch分散式
[原始碼解析] PyTorch 分散式 Autograd (1) ---- 設計
2021-11-29
原始碼PyTorch分散式
[原始碼解析] PyTorch 分散式 Autograd (4) ---- 如何切入引擎
2021-12-03
原始碼PyTorch分散式
[原始碼解析] PyTorch 分散式 Autograd (2) ---- RPC基礎
2021-11-30
原始碼PyTorch分散式RPC
[原始碼解析] PyTorch 分散式(14) --使用 Distributed Autograd 和 Distributed Optimizer
2021-12-13
原始碼PyTorch分散式
[原始碼解析] PyTorch 分散式 Autograd (3) ---- 上下文相關
2021-12-01
原始碼PyTorch分散式
Go 操作 Redis 的基本操作
2019-09-19
GoRedis
熟悉常用的Linux操作和Hadoop操作
2020-10-01
LinuxHadoop
庫的操作
2018-10-15
表的操作
2018-10-15
字串的操作
2019-07-21
字串
git的操作
2022-11-24
Git
陣列的reduce操作+物件陣列的map操作
2024-07-08
陣列物件
MongoDB的常用Query操作及操作符
2019-03-21
MongoDB
flowable的查詢操作和刪除操作
2024-03-11
JAVA棧操作 Stack——不可不知的操作
2020-11-24
Java
JQ操作類與JS操作類的區別
2020-12-24
JS
js的dom操作
2018-12-09
JS
Docker的基本操作
2018-09-17
Docker
grep的或操作
2018-05-16
MySQL的基本操作
2018-06-04
MySql
KVM的常用操作
2020-05-26
Promethues的常用操作
2019-01-02
git的基本操作
2018-03-07
Git
Netty的常用操作
2024-08-16
Netty
JQuery的DOM操作
2024-09-07
jQuery
Selenium的等待操作
2024-06-26
#define 的神奇操作
2022-12-04
openCV入門核心操作 1 影像的基礎操作
2020-10-03
OpenCV
docker操作mongo+docker的常用操作+mongo與.net
2024-06-12
DockerGo
類操作是什麼意思?jQuery的類操作教程
2021-07-15
jQuery
DG的切換操作
2019-02-28
JS — 物件的基本操作
2019-01-16
JS物件
make:migration 的騷操作
2019-03-23

06_pytorch的autograd操作

06_pytorch的autograd操作

一、引言

二、Variable

2.1 Variable 的資料結構

2.2 反向傳播

2.3 autograd 求導數和手動求導數

三、計算圖

3.1 手動計算梯度

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

3.3 在前向傳播中利用動態圖特性構建計算圖

3.4 variable 的 grad 屬性和 backward函式 的 grad_variables 引數的區別

3.5 計算圖特點小結

四、用 variable 實現線性迴歸（autograd 實戰）

五、總結

相關文章

3.4 variable 的 grad 屬性和 backward函式的 grad_variables 引數的區別