在深度學習模型訓練中，自動微分扮演著至關重要的角色，它讓開發者能輕鬆計算梯度，進而最佳化模型引數。然而，當神經網路結構變得複雜，特別是涉及多層次網路和分享權重時，反向傳播的梯度計算和合併會變得相當棘手。本文將深入剖析這些挑戰，並提供實用的解決方案。
反向傳播的複雜性與解決方案
當一個神經網路層的輸出被多個後續層使用時，反向傳播計算梯度時需要特別注意。因為每個後續層都會根據自身的運算產生一個梯度，這些梯度需要正確地合併，才能反映出該層對最終輸出的影響。
以下列程式碼為例，b2 的輸出同時被 add2 和 mult3 兩個層使用：
import torch
a1 = torch.randn(3, 3, requires_grad=True)
w1 = torch.randn(3, 3, requires_grad=True)
a2 = torch.randn(3, 3, requires_grad=True)
w2 = torch.randn(3, 3, requires_grad=True)
w3 = torch.randn(3, 3, requires_grad=True)
b1 = a1 @ w1 # 使用矩陣乘法
b2 = a2 @ w2
c1 = b1 + b2
L = c1 * b2
L.backward(torch.ones_like(L)) # 使用與L形狀相同的張量計算梯度
print(w1.grad)
print(w2.grad)
內容解密
這段程式碼模擬了一個簡化的神經網路，其中 @ 代表矩陣乘法。requires_grad=True 設定表示我們需要計算這些張量的梯度。L.backward() 啟動反向傳播，torch.ones_like(L) 建立一個與 L 形狀相同的全 1 張量作為初始梯度，用於計算 L 對每個葉節點（例如 a1, w1, a2, w2）的梯度。PyTorch 會自動處理 b2 的梯度合併，確保 w2 的梯度正確反映了 b2 對 L 的影響。
graph LR
A[a1] --> B(b1 = a1 @ w1)
C[w1] --> B
D[a2] --> E(b2 = a2 @ w2)
F[w2] --> E
B --> G(c1 = b1 + b2)
E --> G
G --> H(L = c1 * b2)
E --> H
圖表翻譯
此圖示展示了計算圖的結構。從輸入 a1 和權重 w1 計算 b1，從輸入 a2 和權重 w2 計算 b2。b1 和 b2 相加得到 c1，c1 和 b2 相乘得到最終輸出 L。需要注意的是，b2 出現在兩個計算節點中，這意味著在反向傳播過程中，b2 的梯度需要進行合併。
自動微分系統的實作
為了更深入地理解自動微分，我們可以自己動手實作一個簡化的版本。以下是一個根據 Python 的 NumberWithGrad 類別的實作：
class NumberWithGrad:
def __init__(self, data, depends_on=None, op=None):
self.data = data
self.grad = None
self.depends_on = depends_on or []
self.op = op
def __add__(self, other):
other = ensure_number(other)
result = NumberWithGrad(self.data + other.data, [self, other], '+')
return result
def __mul__(self, other):
other = ensure_number(other)
result = NumberWithGrad(self.data * other.data, [self, other], '*')
return result
def backward(self, grad=1.0):
if self.grad is None:
self.grad = grad
else:
self.grad += grad
if self.depends_on:
if self.op == '+':
self.depends_on[0].backward(self.grad)
self.depends_on[1].backward(self.grad)
elif self.op == '*':
self.depends_on[0].backward(self.grad * self.depends_on[1].data)
self.depends_on[1].backward(self.grad * self.depends_on[0].data)
def ensure_number(x):
if isinstance(x, NumberWithGrad):
return x
return NumberWithGrad(x)
內容解密
NumberWithGrad 類別儲存了數值 (data)、梯度 (grad)、依賴的變數 (depends_on) 以及執行的操作 (op)。__add__ 和 __mul__ 方法定義了加法和乘法運算，並建立新的 NumberWithGrad 物件，記錄依賴關係和操作。backward 方法實作了反向傳播，根據操作型別計算並累加梯度。ensure_number 函式確保運算元都是 NumberWithGrad 類別的例項。
graph LR
A[NumberWithGrad(a)] --> O(+)
B[NumberWithGrad(b)] --> O
O --> C[NumberWithGrad(c)]
C --> M(*)
D[NumberWithGrad(d)] --> M
M --> E[NumberWithGrad(e)]
圖表翻譯
此圖示說明瞭 NumberWithGrad 物件之間的運算和依賴關係。a 和 b 進行加法運算得到 c，c 和 d 進行乘法運算得到 e。每個 NumberWithGrad 物件都記錄了其依賴的物件和執行的操作，以便在反向傳播過程中正確計算梯度。
自動微分是現代深度學習框架的核心，理解其運作原理對於開發和除錯模型至關重要。本文透過例項和程式碼，深入淺出地解釋了自動微分和反向傳播的機制，並展示瞭如何處理複雜網路結構中的梯度計算。希望讀者能藉此更深入地理解自動微分，並在實務中更有效地應用。
自動微分的挑戰：反向傳播的複雜性
在深度學習中，自動微分是一種強大的工具，能夠自動計算神經網路中每個引數的梯度。然而，在某些情況下，自動微分可能會遇到挑戰，尤其是在反向傳播（backpropagation）中。
問題描述
假設我們有一個神經網路，包含多個層次和操作。每個層次都有一個前向傳播（forward pass）和反向傳播（backward pass）。在前向傳播中，輸入資料會被處理和轉換，而在反向傳播中，則會計算每個引數的梯度，以便更新引數。
然而，在某些情況下，反向傳播可能會變得複雜。例如，如果一個層次的輸出被多個層次使用，那麼在反向傳播中，就需要計算每個層次的梯度，並將其合併。
示例
以下是一個示例：
a1 = torch.randn(3, 3)
w1 = torch.randn(3, 3)
a2 = torch.randn(3, 3)
w2 = torch.randn(3, 3)
w3 = torch.randn(3, 3)
wm1 = WeightMultiply(w1)
wm2 = WeightMultiply(w2)
add2 = Add(2, 1)
mult3 = Multiply(2, 1)
b1 = wm1.forward(a1)
b2 = wm2.forward(a2)
c1 = add2.forward((b1, b2))
L = mult3.forward((c1, b2))
在這個示例中，b2 的輸出被 add2 和 mult3 兩個層次使用。在反向傳播中，需要計算 b2 的梯度，並將其合併。
解決方案
為瞭解決這個問題，可以使用以下方法：
c1_grad, b2_grad_1 = mult3.backward(L_grad)
b1_grad, b2_grad_2 = add2.backward(c1_grad)
在這個方法中，首先計算 mult3 的梯度，然後計算 add2 的梯度，並將 b2 的梯度合併。
自動微分的概念與實作
在神經網路中，自動微分是一種重要的技術，用於計算神經網路中各個引數的梯度。梯度是用於最佳化神經網路引數的關鍵資料，透過計算梯度，可以實作神經網路的反向傳播和最佳化。
自動微分的基本原理
自動微分的基本原理是透過將神經網路中各個操作視為一個有向無環圖（DAG），然後透過圖的遍歷來計算梯度。每個節點在圖中代表了一個操作，例如加法、乘法等，而邊則代表了操作之間的依賴關係。
自動微分的實作
要實作自動微分，需要定義一個類別，該類別可以包裝資料並記錄操作的歷史。這樣，當資料進行操作時，可以自動計算梯度並記錄下來。
以下是一個簡單的實作例子：
class NumberWithGrad:
def __init__(self, num, depends_on=None, creation_op=''):
self.num = num
self.depends_on = depends_on
self.creation_op = creation_op
self.grad = 0
def __add__(self, other):
new_num = self.num + other.num
new_depends_on = [self, other]
new_creation_op = '+'
return NumberWithGrad(new_num, new_depends_on, new_creation_op)
def __mul__(self, other):
new_num = self.num * other.num
new_depends_on = [self, other]
new_creation_op = '*'
return NumberWithGrad(new_num, new_depends_on, new_creation_op)
def backward(self):
if self.depends_on is not None:
for depend in self.depends_on:
depend.grad += self.grad * depend.num
self.grad = 0
在這個例子中，NumberWithGrad 類別包裝了一個數字，並記錄了操作的歷史。當進行加法或乘法操作時，會建立一個新的 NumberWithGrad 物件，並記錄下操作的歷史。當呼叫 backward 方法時，會計算梯度並記錄下來。
自動微分的優點
自動微分有以下優點：
- 可以自動計算梯度，減少人工計算的工作量
- 可以處理複雜的神經網路結構，包括迴圈神經網路
- 可以提高神經網路的訓練速度和準確率
自動微分與反向傳播
在神經網路中，自動微分是一種計算梯度的方法，對於訓練模型至關重要。下面，我們將實作一個簡單的自動微分系統，以演示其工作原理。
NumberWithGrad 類別
class NumberWithGrad:
def __init__(self, num, depends_on=None, creation_op=None):
self.num = num
self.grad = None
self.depends_on = depends_on or []
self.creation_op = creation_op
def __add__(self, other):
"""實作加法運算"""
return NumberWithGrad(self.num + ensure_number(other).num,
depends_on=[self, ensure_number(other)],
creation_op='add')
def __mul__(self, other):
"""實作乘法運算"""
return NumberWithGrad(self.num * ensure_number(other).num,
depends_on=[self, ensure_number(other)],
creation_op='mul')
def backward(self, backward_grad=None):
"""反向傳播，計算梯度"""
if backward_grad is None: #第一次呼叫backward
self.grad = 1
else:
if self.grad is None:
self.grad = backward_grad
else:
self.grad += backward_grad
# 對依賴的數值進行反向傳播
for depend in self.depends_on:
if self.creation_op == "add":
# 將梯度傳遞給依賴的數值
depend.backward(self.grad)
elif self.creation_op == "mul":
# 對於乘法，梯度需要根據相應的乘法規則進行傳遞
depend.backward(self.grad * depend.num)
ensure_number 函式
def ensure_number(num):
if isinstance(num, NumberWithGrad):
return num
else:
return NumberWithGrad(num)
示例使用
a = NumberWithGrad(2)
b = NumberWithGrad(3)
c = a + b # c = 5
d = c * 2 # d = 10
d.backward() # 啟動反向傳播
print(a.grad) # 輸出：2
print(b.grad) # 輸出：2
在這個例子中，NumberWithGrad 類別代表了一個帶有梯度的數值。backward 方法用於啟動反向傳播，計算每個數值的梯度。這個過程對於神經網路的訓練至關重要，因為它使我們能夠根據輸出的誤差來調整模型的引數。
Mermaid 圖表：自動微分過程
flowchart TD
A[輸入] --> B[前向傳播]
B --> C[計算輸出]
C --> D[計算誤差]
D --> E[反向傳播]
E --> F[更新梯度]
F --> G[更新引數]
圖表翻譯
上述 Mermaid 圖表展示了神經網路中自動微分的過程。首先，輸入資料被前向傳播到網路中，然後計算輸出和誤差。接著，啟動反向傳播，計算每個引數的梯度，並根據梯度更新引數。這個過程不斷迭代，直到模型收斂或達到預設的停止條件。
自動微分的奧秘
自動微分是一種強大的工具，能夠自動計算函式的導數。這在機器學習和深度學習中尤其重要，因為它可以幫助我們最佳化模型的引數。今天，我們將探討一個名為 NumberWithGrad 的類別，它可以自動計算導數。
NumberWithGrad 類別
NumberWithGrad 類別是一個特殊的類別，它可以記錄數值及其導數。每當對 NumberWithGrad 物件進行運算時，會建立一個新的 NumberWithGrad 物件，該物件依賴於原始物件。這樣，當我們呼叫 backward 方法時，可以自動計算所有相關物件的導數。
實際運作
讓我們來看看下面的例子：
a = NumberWithGrad(3)
b = a * 4
c = b + 5
在這個例子中，a、b 和 c 都是 NumberWithGrad 物件。當我們呼叫 c.backward() 時，會自動計算 a、b 和 c 的導數。
如何工作
當我們對 NumberWithGrad 物件進行運算時，會建立一個新的 NumberWithGrad 物件，該物件依賴於原始物件。這樣，當我們呼叫 backward 方法時，可以自動計算所有相關物件的導數。
例如，在上面的例子中，當我們計算 b = a * 4 時，會建立一個新的 NumberWithGrad 物件 b，該物件依賴於 a。同樣，當我們計算 c = b + 5 時，會建立一個新的 NumberWithGrad 物件 c，該物件依賴於 b。
當我們呼叫 c.backward() 時，會自動計算 c 的導數。由於 c 依賴於 b，所以也會計算 b 的導數。同樣，由於 b 依賴於 a，所以也會計算 a 的導數。
結果
最終，我們可以得到 a、b 和 c 的導數：
print(a.grad) # 4
print(b.grad) # 1
這些導數是自動計算的，我們不需要手動計算它們。
梯度計算與自動微分
在深度學習中，梯度計算是最佳化模型引數的關鍵步驟。梯度代表了函式輸出的變化率與輸入的變化率之間的關係。在本文中，我們將探討如何使用數學方法和自動微分系統計算梯度。
數學方法
給定一個函式 $d = c \times (a + 2)$，其中 $c = b + 3$ 和 $b = 4a$。我們可以使用鏈式法則計算梯度。首先，計算 $d$ 對 $a$ 的導數：
$$ \frac{\partial d}{\partial a} = \frac{\partial (c \times (a + 2))}{\partial a} = \frac{\partial c}{\partial a} \times (a + 2) + c \times \frac{\partial (a + 2)}{\partial a} $$
由於 $c = b + 3$ 和 $b = 4a$，因此：
$$ \frac{\partial c}{\partial a} = \frac{\partial (b + 3)}{\partial a} = \frac{\partial b}{\partial a} = 4 $$
且：
$$ \frac{\partial (a + 2)}{\partial a} = 1 $$
因此：
$$ \frac{\partial d}{\partial a} = 4 \times (a + 2) + (4a + 3) \times 1 = 8a + 11 $$
深度學習的基本：自動微分技術解析
自動微分是現代深度學習框架的核心技術，它讓開發者能輕鬆計算複雜函式的梯度，進而有效地訓練神經網路。本文將深入剖析自動微分的原理，並以實際案例說明其在反向傳播中的應用。
反向傳播與梯度計算
在訓練神經網路時，我們需要計算損失函式對每個引數的梯度，以便利用梯度下降法更新引數。反向傳播是一種高效計算梯度的方法，它根據微積分的鏈式法則，將梯度從輸出層逐層傳遞到輸入層。
程式碼範例：簡易神經網路的反向傳播
import torch
# 定義一個簡單的線性模型
model = torch.nn.Linear(in_features=10, out_features=1)
# 輸入資料和目標值
input_data = torch.randn(1, 10)
target = torch.randn(1, 1)
# 前向傳播
output = model(input_data)
# 計算損失
loss = torch.nn.MSELoss()(output, target)
# 反向傳播
loss.backward()
# 顯示梯度
print(model.weight.grad)
內容解密
這段程式碼展示瞭如何使用 PyTorch 框架進行反向傳播。首先，我們定義一個簡單的線性模型，並輸入資料和目標值。接著，進行前向傳播計算輸出，並使用均方誤差計算損失。loss.backward() 啟動反向傳播，自動計算損失對模型引數（權重）的梯度。最後，model.weight.grad 顯示計算出的梯度。
graph LR
A[輸入資料] --> B(線性模型)
B --> C[輸出]
C --> D(損失函式)
D --> E[梯度]
圖表翻譯
此圖示展示了資料在神經網路中的流動過程。輸入資料經過線性模型處理後產生輸出，接著利用損失函式計算誤差，最後透過反向傳播計算梯度，用於更新模型引數。
自動微分的實作：建構計算圖
自動微分系統的核心概念是計算圖（Computational Graph）。計算圖將複雜的函式分解成一系列基本操作，每個操作都表示為圖中的一個節點。節點之間的邊代表資料的流動方向。
計算圖的建構與運算
當我們定義一個函式時，自動微分系統會自動建構對應的計算圖。例如，對於函式 f(x, y) = x * y + x，系統會建立一個包含乘法和加法節點的計算圖。當我們輸入具體的數值時，系統會依照計算圖的拓撲順序執行每個操作，最終得到函式值。
程式碼範例：使用計算圖計算函式值
class Value:
def __init__(self, data, _children=(), _op=''):
self.data = data
self._prev = set(_children)
self._op = _op
def __add__(self, other):
out = Value(self.data + other.data, (self, other), '+')
return out
def __mul__(self, other):
out = Value(self.data * other.data, (self, other), '*')
return out
a = Value(2)
b = Value(3)
c = a * b + a # c = 2 * 3 + 2 = 8
print(c.data) # 輸出 8
內容解密
這段程式碼展示瞭如何使用自定義的 Value 類別建構計算圖。Value 物件儲存了資料以及其來源節點和操作型別。__add__ 和 __mul__ 方法過載了加法和乘法運運算元，使得我們可以像操作普通數字一樣操作 Value 物件，同時自動構建計算圖。
graph LR
A[a=2] --> C(*)
B[b=3] --> C
C --> D(+)
A --> D
D --> E[c=8]
圖表翻譯
此圖示呈現了計算 c = a * b + a 的計算圖。a 和 b 分別代表數值 2 和 3，它們經過乘法運算後得到中間結果，再與 a 相加，最終得到 c 的值 8。
自動微分的未來：效能最佳化與應用拓展
展望未來，自動微分技術將持續朝向效能最佳化和應用拓展兩個方向發展。效能最佳化方面，研究者致力於開發更高效的計算圖表示方法和梯度計算演算法，以提升深度學習模型的訓練速度。應用拓展方面，自動微分技術正被廣泛應用於科學計算、機器人控制等領域，展現出巨大的潛力。
從技術演進角度來看，自動微分已成為深度學習不可或缺的基本。對於臺灣的開發者而言，深入理解自動微分的原理和實作，將有助於掌握深度學習的核心技術，並在快速發展的人工智慧領域保持競爭力。
