人工智能-python-深度學習-自動微分

自動微分：基礎概念與應用

自動微分（Autograd）是現代深度學習框架（如PyTorch、TensorFlow）中的一個核心功能。它通過構建計算圖并在計算圖上自動計算梯度，簡化了反向傳播算法的實現。以下是自動微分的基本概念及其操作。

1. 基礎概念

自動微分指的是通過跟蹤計算圖中的每一步計算，自動計算目標函數相對于模型參數的梯度。這些計算圖是在每次前向傳播時動態構建的。基于這個圖，系統可以在反向傳播時自動計算梯度，而不需要手動推導每個梯度。

1.1 張量

torch中一切皆為張量，屬性requires_grad決定是否對其進行梯度計算。默認是False，如需計算梯度則設置為True

1.2 計算圖

torch.autograd通過創建一個動態計算圖來跟蹤張良的操作，每個張量是計算圖中的一個節點，節點之間的操作構成圖的邊。

在Pytorch中，當張量的requiers_grad=Ture時，Pytorch會自動跟蹤與該張量相關的所有操作，并構建計算圖。每個操作都會生成一個新的張量，并記錄其依賴關系。當設置為True時，表示該張量在計算圖中需要參與梯度計算，即在反向傳播（Backpropagation）過程中惠子dog計算其梯度；當設置為False時，不會計算梯度。
例如：
$y\\loss = z.sum()$
在上述代碼中，x 和 y 是輸入張量，即葉子節點，z 是中間結果，loss 是最終輸出。每一步操作都會記錄依賴關系：

z = x * y：z 依賴于 x 和 y。

loss = z.sum()：loss 依賴于 z。

這些依賴關系形成了一個動態計算圖，如下所示：

	  x       y\     /\   /\ /z||vloss

葉子節點：

在 PyTorch 的自動微分機制中，葉子節點（leaf node）是計算圖中：

由用戶直接創建的張量，并且它的 requires_grad=True。
這些張量是計算圖的起始點，通常作為模型參數或輸入變量。

特征：

沒有由其他張量通過操作生成。
如果參與了計算，其梯度會存儲在 leaf_tensor.grad 中。
默認情況下，葉子節點的梯度不會自動清零，需要顯式調用 optimizer.zero_grad() 或 x.grad.zero_() 清除。

如何判斷一個張量是否是葉子節點？

通過 tensor.is_leaf 屬性，可以判斷一個張量是否是葉子節點。

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)  # 葉子節點
y = x ** 2  # 非葉子節點（通過計算生成）
z = y.sum()print(x.is_leaf)  # True
print(y.is_leaf)  # False
print(z.is_leaf)  # False

葉子節點與非葉子節點的區別

特性	葉子節點	非葉子節點
創建方式	用戶直接創建的張量	通過其他張量的運算生成
is_leaf 屬性	True	False
梯度存儲	梯度存儲在 .grad 屬性中	梯度不會存儲在 .grad，只能通過反向傳播傳遞
是否參與計算圖	是計算圖的起點	是計算圖的中間或終點
刪除條件	默認不會被刪除	在反向傳播后，默認被釋放（除非 retain_graph=True）

detach()：張量 x 從計算圖中分離出來，返回一個新的張量，與 x 共享數據，但不包含計算圖（即不會追蹤梯度）。

特點：

返回的張量是一個新的張量，與原始張量共享數據。
對 x.detach() 的操作不會影響原始張量的梯度計算。
推薦使用 detach()，因為它更安全，且在未來版本的 PyTorch 中可能會取代 data。

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x.detach()  # y 是一個新張量，不追蹤梯度y += 1  # 修改 y 不會影響 x 的梯度計算
print(x)  # tensor([1., 2., 3.], requires_grad=True)
print(y)  # tensor([2., 3., 4.])

反向傳播

使用tensor.backward()方法執行反向傳播，從而計算張量的梯度。這個過程會自動計算每個張量對損失函數的梯度。例如：調用 loss.backward() 從輸出節點 loss 開始，沿著計算圖反向傳播，計算每個節點的梯度。

梯度

計算得到的梯度通過tensor.grad訪問，這些梯度用于優化模型參數，以最小化損失函數。

2. 計算梯度

2.1 標量梯度計算

標量梯度計算指的是計算標量（通常是損失函數）相對于模型參數的梯度。在深度學習中，常見的損失函數（如均方誤差、交叉熵等）都是標量值。

import torch# 定義張量
x = torch.tensor(2.0, requires_grad=True)
y = x**2 + 3*x + 1  # 定義標量函數# 計算梯度
y.backward()  # 反向傳播
print(x.grad)  # 輸出x的梯度

為何需要標量梯度？

在訓練過程中，我們需要計算損失函數相對于各個參數的梯度，從而調整模型參數。標量梯度的計算是整個訓練過程中優化模型的基礎。

2.2 向量梯度計算

向量梯度計算用于計算多維向量函數相對于輸入向量的梯度。例如，輸出是一個向量時，我們希望計算每個分量的梯度。

# 定義張量
x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x**2  # 計算每個元素的平方# 計算梯度
y.backward(torch.tensor([1.0, 1.0]))  # 向量梯度計算
print(x.grad)  # 輸出x的梯度

為何需要向量梯度？

在多輸入多輸出的情況下，向量梯度計算能有效地描述每個輸入對于輸出的影響。

2.3 多標量梯度計算

在一些復雜的場景中，損失函數可能有多個標量輸出。我們需要計算每個標量輸出對參數的梯度。

x = torch.tensor([2.0, 3.0], requires_grad=True)
y1 = x[0]**2 + 3*x[0] + 1
y2 = x[1]**3 + 2*x[1] - 5
y = y1 + y2  # 多標量函數y.backward()  # 計算梯度
print(x.grad)

為何需要多標量梯度？

多標量梯度有助于處理多任務學習中的梯度計算，特別是當每個任務有不同的損失函數時。

2.4 多向量梯度計算

當輸出是多個向量時，我們通常需要計算每個向量對每個輸入的梯度。比如在生成對抗網絡（GAN）或多任務學習中，常見這種情況。

x = torch.tensor([1.0, 2.0], requires_grad=True)
y1 = x[0]**2 + 3*x[0]
y2 = x[1]**3 + 2*x[1]grad_outputs = torch.tensor([1.0, 1.0])  # 指定多個輸出梯度
y1.backward(grad_outputs)  # 分別計算y1和y2的梯度

為何需要多向量梯度？

計算多個輸出的梯度可以幫助我們進行多維度的優化，尤其是在復雜的網絡結構中，多個輸出有助于提高模型的多樣性和魯棒性。

3. 梯度上下文控制

在深度學習中，常常需要控制梯度計算的上下文，以節省內存或者針對性地優化某些參數。

3.1 控制梯度計算

我們可以通過torch.no_grad()或with torch.set_grad_enabled(False)來臨時停止梯度計算，這對于不需要計算梯度的操作（例如推理階段）非常有用。

with torch.no_grad():y = x * 2  # 在此塊中，不會計算梯度

為何控制梯度計算？

在推理階段，我們不需要梯度，這樣可以節省計算資源和內存。

3.2 累計梯度

在某些情況下，梯度計算需要分多個小批次進行累計。例如，使用小批次訓練時，梯度會在每個小批次上累加。

optimizer.zero_grad()  # 清空之前的梯度
y.backward()  # 累計梯度
optimizer.step()  # 更新參數

為何累計梯度？

累計梯度可以使得模型在小批次上進行優化，而不丟失總體梯度信息，適用于大規模數據的訓練。

3.3 梯度清零

在每次更新前，我們需要清空之前計算的梯度，否則它會在下一步的計算中累加。

optimizer.zero_grad()  # 清除上次計算的梯度

為何清零梯度？

防止梯度計算的累積影響下一次計算，確保每次計算梯度時的準確性。

4. 案例分析

4.1 求函數最小值

通過計算梯度并使用優化算法（如梯度下降），我們可以找到函數的最小值。

x = torch.tensor(2.0, requires_grad=True)
for _ in range(100):y = x**2 + 3*x + 1y.backward()with torch.no_grad():x -= 0.1 * x.grad  # 使用梯度更新xx.grad.zero_()  # 清空梯度

為何使用梯度下降求解最小值？

通過不斷調整參數，沿著梯度方向前進，直到收斂到函數的最小值。

4.2 函數參數求解

如果已知函數并希望通過梯度來求解某些未知參數，可以使用反向傳播來更新這些參數。

def func(x):return x**2 - 4*x + 3x = torch.tensor(3.0, requires_grad=True)
for i in range(100):y = func(x)y.backward()x.data -= 0.1 * x.gradx.grad.zero_()