自動微分實作高效梯度計算

– 15 分鐘閱讀

在深度學習模型訓練中，梯度計算是核心環節，它決定了模型引數的更新方向和幅度。傳統的數值微分方法容易產生誤差且計算效率低，而符號微分則難以處理複雜的函式結構。自動微分技術結合了兩者的優點，兼具計算效率和準確性，成為現代深度學習框架中不可或缺的組成部分。本文將深入探討自動微分技術的原理和應用，並以 Python 程式碼示範如何在 TensorFlow、PyTorch 和 SymPy 等工具中實作自動微分。透過實際案例，展示自動微分如何高效計算梯度，並應用於神經網路訓練和最佳化。

瞭解導數的重要性

在神經網路中，導數是一個至關重要的概念。它代表了函式輸出的變化率與輸入的變化率之間的關係。在上述例子中，我們計算了一個簡單函式的導數，以瞭解其在某一點的變化率。

然而，當函式變得更加複雜時，計算導數就變得更加困難。例如，當函式是其他函式的乘積或組合時，計算導數就需要使用許多不同的規則和技巧。這種情況下，計算導數可能需要大量的時間和精力，並且容易出錯。

使用自動微分

幸運的是，現在有許多工具和技術可以幫助我們計算導數。其中之一就是自動微分（Automatic Differentiation）。自動微分是一種計算導數的方法，它使用電腦代替人工計算導數。這種方法可以快速、準確地計算導數，即使函式非常複雜。

Mermaid 圖表：自動微分流程

  flowchart TD
    A[輸入函式] --> B[計算導數]
    B --> C[自動微分]
    C --> D[輸出導數]

圖表翻譯：

上述圖表展示了自動微分的流程。首先，輸入一個函式，然後計算其導數。接下來，使用自動微分演算法計算導數，最後輸出結果。

實際應用

在神經網路中，自動微分是一個非常重要的工具。它可以幫助我們快速、準確地計算導數，從而最佳化神經網路的效能。例如，在反向傳播演算法中，自動微分可以幫助我們計算誤差梯度，從而更新神經網路的權重。

程式碼範例：使用自動微分計算導數

import numpy as np

def f(x):
    return (2*x + 7)*(17*x**2 - 3*x)*(x**2 - 1/x)*(x**3 + 21*x)/(17*x - 5/x**2)

x = 11.0
h = 1e-7

# 使用自動微分計算導數
f_prime = (f(x + h) - f(x - h)) / (2 * h)

print(f_prime)

內容解密：

上述程式碼範例展示瞭如何使用自動微分計算導數。首先，定義一個函式 f(x)，然後選擇一個點 x 和一個小的步長 h。接下來，使用自動微分演算法計算導數，最後輸出結果。

4.1.2 符號微分

在前一節中，我們使用 WolframAlpha 取得函式的導數，其引擎使用符號微分，執行所有人工微分的步驟。您可以程式設計所有微分規則，電腦可以比人類更快地遵循這些規則，並且更可靠地執行，無需擔心偶發性錯誤（除非有人引入錯誤或您具有錯誤的硬體）。

有不同的選項可用於符號微分。在 Python 中，您可以使用 SymPy（請參閱 https://docs.sympy.org/latest/modules/core.html）。它是由玄貓安裝的，但您也可以在您的部分安裝它。

4.3 SymPy 示例：取得符號導數

import sympy

x = 11.0
x_sym = sympy.symbols('x')
f_sym = x_sym**4 + 12*x_sym + 1/x_sym
df_sym = sympy.diff(f_sym)
print(f_sym)
# >>> x**4 + 12*x + 1/x
print(df_sym)
# >>> 4*x**3 + 12 - 1/x**2

f = sympy.lambdify(x_sym, f_sym)
print(f(x))
# >>> 14773.09090909091

df = sympy.lambdify(x_sym, df_sym)
print(df(x))
# >>> 5335.99173553719

定義了一個變數 x，然後使用 SymPy 的 symbols 函式建立一個符號變數 x_sym。接下來，定義了一個符號函式 f_sym，然後使用 diff 函式計算其導數 df_sym。最後，使用 lambdify 函式將符號函式和導數轉換為可呼叫的函式，並計算其值。

內容解密：

  • sympy.symbols('x') 建立了一個符號變數 x。
  • x_sym**4 + 12*x_sym + 1/x_sym 定義了一個符號函式 f_sym。
  • sympy.diff(f_sym) 計算了 f_sym 的導數 df_sym。
  • sympy.lambdify(x_sym, f_sym) 將符號函式 f_sym 轉換為可呼叫的函式 f。
  • sympy.lambdify(x_sym, df_sym) 將符號導數 df_sym 轉換為可呼叫的函式 df。

圖表翻譯：

  flowchart TD
    A[定義變數 x] --> B[建立符號變數 x_sym]
    B --> C[定義符號函式 f_sym]
    C --> D[計算導數 df_sym]
    D --> E[轉換為可呼叫的函式 f 和 df]
    E --> F[計算函式和導數的值]

此圖表展示了使用 SymPy 進行符號微分的過程。首先，定義了一個變數 x，然後建立了一個符號變數 x_sym。接下來，定義了一個符號函式 f_sym，然後計算其導數 df_sym。最後，將符號函式和導數轉換為可呼叫的函式，並計算其值。

符號運算與數值評估

在進行數學運算時，符號運算（Symbolic Computation）是一種強大的工具，能夠幫助我們處理複雜的數學表示式。下面，我們將探討如何使用 Python 中的 SymPy 函式庫進行符號運算，並將符號表示式轉換為可數值評估的形式。

定義符號變數

首先，我們需要定義一個符號變數。這個變數將用於構建我們的符號表示式。

import sympy as sp

# 定義符號變數
x = sp.symbols('x')

建立符號表示式

接下來，我們可以使用這個符號變數來建立一個符號表示式。例如，我們可以定義一個簡單的多項式。

# 建立符號表示式
f = x**2 + 2*x + 1

計算符號導數

SymPy 也提供了計算符號導數的功能。這對於理解函式的行為非常有用。

# 計算符號導數
f_prime = sp.diff(f, x)

顯示符號表示式

我們可以使用 SymPy 的 pprint 函式來以更易於閱讀的格式顯示符號表示式。

# 顯示符號表示式
sp.pprint(f)
sp.pprint(f_prime)

將 SymPy 表示式轉換為可評估的形式

如果我們想要對這個符號表示式進行數值評估，我們需要將其轉換為一個可評估的函式。SymPy 提供了 lambdify 函式來完成這個任務。

# 將 SymPy 表示式轉換為可評估的形式
f_eval = sp.lambdify(x, f, 'numpy')
f_prime_eval = sp.lambdify(x, f_prime, 'numpy')

數值評估

現在，我們可以使用這些可評估的函式來計算原始函式和其導數在特定點的值。

import numpy as np

# 數值評估
x_value = 2
print(f_eval(x_value))
print(f_prime_eval(x_value))

圖表翻譯：

  graph LR
    A[定義符號變數] --> B[建立符號表示式]
    B --> C[計算符號導數]
    C --> D[顯示符號表示式]
    D --> E[將 SymPy 表示式轉換為可評估的形式]
    E --> F[數值評估]

內容解密：

上述過程展示瞭如何使用 SymPy 進行符號運算和數值評估。從定義符號變數開始，到建立符號表示式、計算導數、顯示表示式，最後轉換為可評估的形式並進行數值計算。這個流程對於理解和操作複雜的數學函式非常重要。

第四章：計算梯度

在深度學習中，計算梯度是一個至關重要的步驟。梯度代表了函式輸出的變化率與輸入的變化率之間的關係。在本章中，我們將探討三種計算梯度的方法：手動微分、符號微分和自動微分。

4.1.3 數值微分

數值微分是一種估計函式導數的方法。它透過計算函式在兩個鄰近點上的值，然後使用這兩個值來估計導數。這種方法在科學和工程領域中被廣泛使用。數值微分的一個常見方法是使用有限差分法，根據導數的定義來估計導數。

x = 11.0
dx = 1e-6
df_x_numeric = (f(x+dx)-f(x))/dx
print(df_x_numeric)

數值微分有一些問題，包括速度、準確性和數值穩定性。首先，數值微分需要兩次函式評估，這對於複雜的函式來說可能很耗時。其次，數值微分的準確性不夠高，因為它使用的是近似值。最後，數值微分對步長的選擇很敏感，如果步長太小，可能會出現溢位錯誤。

內容解密：

在上面的程式碼中，我們使用有限差分法來估計函式 f 在點 x 的導數。函式 f 定義為 f(x) = x^2。我們使用步長 dx 來估計導數，並將結果儲存到 df_x_numeric 中。

4.1.4 自動微分

自動微分是一種計算梯度的方法，它透過跟蹤計算過程和使用鏈式法則來計算導數。自動微分在深度學習中被廣泛使用，因為它可以高效地計算複雜函式的導數。

  flowchart TD
    A[計算函式] --> B[跟蹤計算過程]
    B --> C[使用鏈式法則計算導數]
    C --> D[輸出導數]

圖表翻譯：

上面的流程圖展示了自動微分的過程。首先，我們計算函式 f 的輸出。然後，我們跟蹤計算過程，並使用鏈式法則來計算導數。最後，我們輸出導數。

自動微分有一些優點，包括速度快、準確性高和易於實作。然而，它也有一些限制，例如需要跟蹤計算過程和使用鏈式法則，這可能會增加計算複雜度。

使用自動微分計算梯度

自動微分（Autodiff）是一種強大的工具，允許計算複雜函式的導數，包括控制結構、分支、迴圈和遞迴等難以用閉式表示式表示的情況。這對於神經網路訓練和最佳化至關重要，因為它可以快速計算梯度。

自動微分的優點

自動微分相比於手動計算導數或使用數值導數有多個優點：

  1. 效率：自動微分可以快速計算導數，尤其是在神經網路中，這對於大規模的輸入資料非常重要。
  2. 準確性：自動微分可以提供準確的導數計算，減少手動計算導數的錯誤風險。
  3. 靈活性：自動微分可以應用於各種函式，包括具有控制結構、分支、迴圈和遞迴的函式。

JAX 中的自動微分

JAX 是一個現代的深度學習框架，它提供了自動微分功能。使用 JAX，可以輕鬆地計算函式的導數，並且可以將其應用於神經網路訓練中。

範例：線性迴歸

線性迴歸是一個簡單但常見的例子。假設我們有一組噪聲資料，我們想要計算一條線性趨勢來描述這些資料。這可以使用自動微分來實作。

import numpy as np
import matplotlib.pyplot as plt
import jax
import jax.numpy as jnp

# 生成資料
x = np.linspace(0, 10*np.pi, num=1000)
e = np.random.normal(scale=10.0, size=x.size)
y = 65.0 + 1.8*x + np.cos(x) + e

# 定義線性迴歸模型
def linear_regression(x, w, b):
    return w*x + b

# 定義損失函式
def loss(w, b, x, y):
    return jnp.mean((linear_regression(x, w, b) - y)**2)

# 使用自動微分計算梯度
grad_loss = jax.grad(loss, argnums=(0, 1))

# 訓練模型
w = 0.0
b = 0.0
for i in range(1000):
    w_grad, b_grad = grad_loss(w, b, x, y)
    w -= 0.01 * w_grad
    b -= 0.01 * b_grad

# 繪製結果
plt.plot(x, y, label='原始資料')
plt.plot(x, linear_regression(x, w, b), label='線性趨勢')
plt.legend()
plt.show()

這個範例示範瞭如何使用 JAX 中的自動微分來計算梯度，並且使用梯度下降法來訓練線性迴歸模型。結果顯示了原始資料和線性趨勢的繪製結果。

資料視覺化與模型訓練

在進行資料分析時，視覺化是理解資料分佈和模式的一種有效方法。下面是一個使用Python的Matplotlib函式庫來生成散點圖的例子：

import matplotlib.pyplot as plt
import numpy as np

# 生成1000個點的x和y資料
x = np.linspace(0, 10 * np.pi, 1000)
y = np.sin(x) + 0.1 * np.random.randn(1000)

# 繪製散點圖
plt.scatter(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('視覺化的溫度測量資料')
plt.show()

這段程式碼會生成一張散點圖，展示x和y資料之間的關係。

內容解密：

  • np.linspace(0, 10 * np.pi, 1000)：生成1000個點的x資料，範圍從0到10π。
  • np.sin(x) + 0.1 * np.random.randn(1000)：生成對應的y資料，包括正弦函式和隨機噪聲。
  • plt.scatter(x, y)：繪製x和y資料的散點圖。
  • plt.xlabel('x')和plt.ylabel('y')：設定x軸和y軸的標籤。
  • plt.title('視覺化的溫度測量資料')：設定圖表的標題。
  • plt.show()：顯示圖表。

模型訓練流程

模型訓練的流程通常包括以下步驟：

  1. 資料準備：準備訓練資料，包括輸入x和目標輸出y。
  2. 模型定義：定義一個模型函式f(x)來預測y值。
  3. 損失函式：定義一個損失函式來評估預測誤差。
  4. 梯度下降：使用梯度下降演算法來更新模型引數，減少損失函式的值。

這個流程可以用以下的Mermaid圖表來表示：

  flowchart TD
    A[輸入資料] --> B[模型函式]
    B --> C[預測輸出]
    C --> D[損失函式]
    D --> E[梯度下降]
    E --> F[更新模型引數]

圖表翻譯：

  • 輸入資料（A）：代表訓練資料的輸入x。
  • 模型函式（B）：代表預測y值的模型f(x)。
  • 預測輸出（C）：代表模型預測的y值。
  • 損失函式（D）：代表評估預測誤差的損失函式。
  • 梯度下降（E）：代表更新模型引數的梯度下降演算法。
  • 更新模型引數（F）：代表更新後的模型引數。

這個流程是機器學習中常見的監督學習過程，目的是找到一個最佳的模型來預測目標輸出。

使用自動微分計算梯度

現在，我們將探討如何使用自動微分（autodiff）計算梯度。這是一種強大的工具，能夠自動計算複雜函式的梯度。

4.2.1 在TensorFlow中工作 với梯度

在TensorFlow中，您需要告訴框架哪些張量需要跟蹤計算以收集梯度。您可以透過設定trainable=True來完成此操作。然後，您可以使用張量進行計算，框架將跟蹤所進行的計算。在TensorFlow中，您需要使用梯度磁帶（gradient tapes）來跟蹤計算。

4.2.2 自動微分的工作原理

自動微分是一種計算梯度的方法，透過跟蹤函式的計算過程來計算梯度。它可以用於計算複雜函式的梯度，並且比手動計算梯度更快、更方便。

4.2.3 在JAX中工作與梯度

在JAX中，您可以使用grad函式來計算梯度。這個函式可以用於計算任何函式的梯度，並且比TensorFlow中的gradient函式更簡單、更方便。

示例：計算梯度

import jax.numpy as jnp
from jax import grad

# 定義一個簡單的函式
def model(x):
    return x ** 2

# 計算梯度
x = 2.0
gradient = grad(model)(x)

print(gradient)  # 輸出：4.0

在這個示例中，我們定義了一個簡單的函式model(x) = x ** 2，然後使用grad函式來計算其梯度。結果是4.0，這是因為函式的導數是2x，而當x = 2.0時，導數是4.0。

4.2.4 梯度下降法

梯度下降法是一種最佳化演算法，使用梯度來更新模型引數以最小化損失函式。它是機器學習中的一種基本演算法，並且被廣泛用於各種應用中。

示例：梯度下降法

import jax.numpy as jnp
from jax import grad

# 定義一個簡單的函式
def model(x):
    return x ** 2

# 定義損失函式
def loss(x):
    return (model(x) - 1) ** 2

# 計算梯度
x = 2.0
gradient = grad(loss)(x)

# 更新模型引數
learning_rate = 0.1
x -= learning_rate * gradient

print(x)  # 輸出：1.8

在這個示例中，我們定義了一個簡單的函式model(x) = x ** 2，然後定義了一個損失函式loss(x) = (model(x) - 1) ** 2。我們使用grad函式來計算損失函式的梯度，然後使用梯度下降法來更新模型引數。結果是x被更新為1.8。

圖表翻譯：

  graph LR
    A[模型] -->|輸入|> B[損失函式]
    B -->|計算梯度|> C[梯度下降法]
    C -->|更新模型引數|> D[新模型引數]

這個圖表展示了梯度下降法的過程。首先，模型接收輸入並計算損失函式。然後，損失函式的梯度被計算並用於更新模型引數。最後，新的模型引數被輸出。

第四章：計算梯度

在深度學習中，計算梯度是訓練模型的關鍵步驟。梯度代表了損失函式對模型引數的偏導數，指導了模型引數的更新方向。在本章中，我們將探討如何在 TensorFlow 和 PyTorch 中計算梯度。

4.1 使用 TensorFlow 計算梯度

在 TensorFlow 中，計算梯度需要使用 tf.GradientTape 來記錄計算過程。以下是計算梯度的步驟：

import tensorflow as tf

# 定義損失函式
def loss_fn(prediction, y):
    return tf.reduce_mean(tf.square(prediction - y))

# 建立模型引數
w = tf.Variable(1.0)
b = tf.Variable(1.0)

# 計算梯度
with tf.GradientTape() as tape:
    prediction = w * x + b
    loss = loss_fn(prediction, y)

# 取得梯度
dw, db = tape.gradient(loss, [w, b])

# 更新模型引數
w.assign_sub(learning_rate * dw)
b.assign_sub(learning_rate * db)

4.2 使用 PyTorch 計算梯度

在 PyTorch 中，計算梯度需要使用 torch.tensor 來建立可計算梯度的張量，並使用 requires_grad=True 來標記需要計算梯度的引數。以下是計算梯度的步驟：

import torch

# 建立模型引數
w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)

# 計算梯度
xt = torch.tensor(x)
yt = torch.tensor(y)
learning_rate = 1e-2

# 前向傳播
prediction = w * xt + b
loss = (prediction - yt) ** 2
loss = loss.mean()

# 反向傳播
loss.backward()

# 更新模型引數
w.data -= learning_rate * w.grad
b.data -= learning_rate * b.grad

內容解密：

在上述程式碼中，我們使用 tf.GradientTape 來記錄計算過程，並使用 tape.gradient 來計算梯度。在 PyTorch 中，我們使用 torch.tensor 來建立可計算梯度的張量，並使用 requires_grad=True 來標記需要計算梯度的引數。然後，我們使用 loss.backward() 來計算梯度，並更新模型引數。

圖表翻譯：

  graph LR
    A[前向傳播] --> B[損失函式]
    B --> C[反向傳播]
    C --> D[更新模型引數]

在上述圖表中，我們展示了計算梯度的過程。首先，我們進行前向傳播，然後計算損失函式，接著進行反向傳播，最後更新模型引數。

線性模型與均方誤差損失函式

在深度學習中，線性模型是一種基本且重要的模型。它的輸出可以表示為輸入的線性組合，通常用於簡單的迴歸任務。線性模型的輸出可以用以下公式表示：

def linear_model(x, w, b):
    """
    線性模型的實作。
    
    引數：
    x (tensor): 輸入資料
    w (tensor): 權重
    b (tensor): 偏差
    
    傳回：
    tensor: 線性模型的輸出
    """
    return torch.matmul(x, w) + b

另一方面，均方誤差（MSE）損失函式是一種常用的損失函式，尤其是在迴歸任務中。它計算預測值和真實值之間的平均平方差。以下是均方誤差損失函式的實作：

def mse_loss(prediction, y):
    """
    均方誤差損失函式的實作。
    
    引數：
    prediction (tensor): 預測值
    y (tensor): 真實值
    
    傳回：
    tensor: 均方誤差損失
    """
    return torch.mean((prediction - y) ** 2)

自動微分與梯度下降

PyTorch 提供了自動微分功能，可以自動計算梯度，這對於訓練神經網路非常重要。以下是如何使用 PyTorch 進行梯度下降的示例：

# 定義模型、損失函式和最佳化器
model = linear_model
loss_fn = mse_loss
optimizer = torch.optim.SGD([w, b], lr=0.01)

# 訓練模型
for epoch in range(100):
    # 預測
    prediction = model(x, w, b)
    
    # 計算損失
    loss = loss_fn(prediction, y)
    
    # 反向傳播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

在這個過程中，我們首先定義了線性模型和均方誤差損失函式。然後，我們使用 PyTorch 的 torch.optim 模組定義了一個隨機梯度下降（SGD）最佳化器。最後，我們進行了 100 個 epoch 的訓練，在每個 epoch 中，我們計算預測值、損失值，然後使用反向傳播更新模型引數。

圖表翻譯：

此圖示

  graph LR
    A[輸入資料] --> B[線性模型]
    B --> C[預測值]
    C --> D[均方誤差損失函式]
    D --> E[損失值]
    E --> F[反向傳播]
    F --> G[梯度下降]

此圖示了從輸入資料到梯度下降的整個過程。首先，輸入資料被輸入到線性模型中，得到預測值。然後，預測值被輸入到均方誤差損失函式中，得到損失值。最後，損失值被用於反向傳播和梯度下降，以更新模型引數。

內容解密：

線性模型是一種簡單的模型，它假設輸出是輸入的線性組合。均方誤差損失函式是一種常用的損失函式，尤其是在迴歸任務中。PyTorch 提供了自動微分功能，可以自動計算梯度，這對於訓練神經網路非常重要。在訓練過程中，我們首先定義了線性模型和均方誤差損失函式。然後，我們使用 PyTorch 的 torch.optim 模組定義了一個隨機梯度下降（SGD）最佳化器。最後，我們進行了 100 個 epoch 的訓練，在每個 epoch 中，我們計算預測值、損失值，然後使用反向傳播更新模型引數。

深入剖析自動微分技術的核心概念與實作後，我們可以發現，從手動計算導數到符號微分，再到自動微分，計算梯度的效率和準確性都得到了顯著提升。自動微分技術的多種實作方式，例如 TensorFlow 和 JAX 中的 grad 函式，以及 PyTorch 的自動求導機制，都展現了其在現代深度學習框架中的重要地位。透過多維比較分析，自動微分不僅克服了手動計算的繁瑣和容易出錯的問題，也避免了符號微分的表示式膨脹問題，更在數值微分的基礎上提升了計算精確度和效率。然而，自動微分並非完美無缺，它仍需面對計算圖的構建和管理等挑戰，特別是在處理複雜的控制流程和動態圖結構時。

綜合考量自動微分的優勢與限制，我們深入分析了其線上性迴歸模型訓練中的實際應用，並透過資料視覺化和模型訓練流程圖，更清晰地展現了其運作機制。技術限制深析顯示，自動微分在處理某些特定型別的函式時，例如包含非可微分運算的函式，仍需要額外的處理策略。此外，不同深度學習框架的自動微分實作也存在差異，開發者需要根據實際情況選擇合適的工具和方法。

展望未來，自動微分技術將持續朝向更高效、更靈活的方向發展，以支援更複雜的模型架構和更龐大的資料規模。預計未來將出現更多針對特定硬體平臺最佳化的自動微分技術，例如利用 GPU 或 TPU 加速計算，以及更易於使用的自動微分 API 和工具，降低開發者的使用門檻。同時，自動微分與其他技術的融合，例如機率程式設計和可微分程式設計，也將開闢更多新的應用場景。

玄貓認為，自動微分已成為深度學習領域不可或缺的根本技術，掌握其核心原理和應用技巧對於深度學習的進階學習至關重要。對於追求高效能和高精確度模型訓練的開發者而言，深入理解並善用自動微分技術將是提升模型效能的關鍵所在。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。