进阶 tensorflow.org 2026-10-22 02:47:47 · 23 阅读

第13章 TensorFlow 高级自动微分详解

高级自动微分

使用收藏功能整理内容

根据你的偏好保存和分类内容。

在 TensorFlow.org 上查看
在 Google Colab 中运行
在 GitHub 上查看源码
下载 Notebook

《梯度与自动微分入门》指南包含了在 TensorFlow 中计算梯度所需的一切内容。本指南聚焦于 tf.GradientTape API 中更深层次、较少使用的特性。

环境配置

import tensorflow as tf

import matplotlib as mpl

import matplotlib.pyplot as plt

mpl.rcParams['figure.figsize'] = (8, 6)

(注:以下日志输出为系统调试信息,表示 cuFFT、cuDNN、cuBLAS 工厂注册警告及 NUMA 节点读取日志,通常可忽略。)

控制梯度记录

在自动微分指南中,你已经了解了在构建梯度计算时,如何控制哪些变量和张量被磁带(tape)监听。

磁带还提供了一些方法来操作记录行为。

停止记录

如果你希望停止记录梯度,可以使用 tf.GradientTape.stop_recording 来临时暂停记录。

当你不希望微分模型中间某个复杂操作时,这有助于减少开销。这可能包括计算度量指标或中间结果:

x = tf.Variable(2.0)

y = tf.Variable(3.0)

with tf.GradientTape() as t:

    x_sq = x * x

    with t.stop_recording():

        y_sq = y * y

    z = x_sq + y_sq

grad = t.gradient(z, {'x': x, 'y': y})

print('dz/dx:', grad['x'])  # 2*x => 4

print('dz/dy:', grad['y'])

dz/dx: tf.Tensor(4.0, shape=(), dtype=float32)

dz/dy: None

从头开始记录(重置)

如果你希望完全重新开始,请使用 tf.GradientTape.reset。通常,直接退出梯带动带块并重新开始代码可读性更好,但在退出磁带块困难或不可能时,你可以使用 reset 方法。

x = tf.Variable(2.0)

y = tf.Variable(3.0)

reset = True

with tf.GradientTape() as t:

    y_sq = y * y

    if reset:

        # 丢弃磁带目前记录的所有内容

        t.reset()

    z = x * x + y_sq

grad = t.gradient(z, {'x': x, 'y': y})

print('dz/dx:', grad['x'])  # 2*x => 4

print('dz/dy:', grad['y'])

dz/dx: tf.Tensor(4.0, shape=(), dtype=float32)

dz/dy: None

精确停止梯度流动

与上述全局磁带控制不同,tf.stop_gradient 函数更加精确。它可以用于阻止梯度沿特定路径流动,而无需访问磁带本身:

x = tf.Variable(2.0)

y = tf.Variable(3.0)

with tf.GradientTape() as t:

    y_sq = y2

    z = x2 + tf.stop_gradient(y_sq)

grad = t.gradient(z, {'x': x, 'y': y})

print('dz/dx:', grad['x'])  # 2*x => 4

print('dz/dy:', grad['y'])

dz/dx: tf.Tensor(4.0, shape=(), dtype=float32)

dz/dy: None

自定义梯度

在某些情况下,你可能希望精确控制梯度的计算方式,而不是使用默认方法。这种情况包括:

  • 你正在编写的新算子没有定义梯度。
  • 默认计算在数值上不稳定的情况。
  • 你希望缓存前向传播中的昂贵计算结果。
  • 你想修改某个值(例如使用 tf.clip_by_value 或 tf.math.round),但不想改变梯度。

对于第一种情况,编写新算子时可以使用 tf.RegisterGradient 来设置你自己的梯度(详见 API 文档)。(注意梯度注册表是全局的,请谨慎修改。)

对于后三种情况,可以使用 tf.custom_gradient。

以下是一个示例,演示如何对中间梯度应用 tf.clip_by_norm:

# 建立一个恒等操作,但在梯度传递期间进行裁剪。

@tf.custom_gradient

def clip_gradients(y):

    def backward(dy):

        return tf.clip_by_norm(dy, 0.5)

    return y, backward

v = tf.Variable(2.0)

with tf.GradientTape() as t:

    output = clip_gradients(v * v)

print(t.gradient(output, v))  # 调用 "backward",将 4 裁剪为 2

tf.Tensor(2.0, shape=(), dtype=float32)

更多详情请参考 tf.custom_gradient 装饰器的 API 文档。

在 SavedModel 中使用自定义梯度

通过选项 tf.saved_model.SaveOptions(experimental_custom_gradients=True),可以将自定义梯度保存到 SavedModel 中。

为了保存到 SavedModel,梯度函数必须是可追踪的(欲了解更多,请查看《使用 tf.function 获得更好性能》指南)。

class MyModule(tf.Module):

    @tf.function(input_signature=[tf.TensorSpec(None)])

    def call_custom_grad(self, x):

        return clip_gradients(x)

model = MyModule()

tf.saved_model.save(

    model,

    'saved_model',

    options=tf.saved_model.SaveOptions(experimental_custom_gradients=True))

# 加载的梯度将与上述示例相同。

v = tf.Variable(2.0)

loaded = tf.saved_model.load('saved_model')

with tf.GradientTape() as t:

    output = loaded.call_custom_grad(v * v)

print(t.gradient(output, v))

INFO:tensorflow:Assets written to: saved_model/assets

tf.Tensor(2.0, shape=(), dtype=float32)

关于上述示例的一点说明:如果你尝试用 tf.saved_model.SaveOptions(experimental_custom_gradients=False) 替换上述代码,加载时梯度仍然会产生相同的结果。原因是梯度注册表中仍然包含在 call_custom_op 函数中使用的自定义梯度。然而,如果在没有保存自定义梯度的情况下重启运行时,在 tf.GradientTape 下运行加载的模型将抛出错误:LookupError: No gradient defined for operation 'IdentityN' (op type: IdentityN)。

多个磁带

多个磁带可以无缝交互。

例如,这里每个磁带监听不同的一组张量:

x0 = tf.constant(0.0)

x1 = tf.constant(0.0)

with tf.GradientTape() as tape0, tf.GradientTape() as tape1:

    tape0.watch(x0)

    tape1.watch(x1)

    y0 = tf.math.sin(x0)

    y1 = tf.nn.sigmoid(x1)

    y = y0 + y1

    ys = tf.reduce_sum(y)

tape0.gradient(ys, x0).numpy()   # cos(x) => 1.0

1.0

tape1.gradient(ys, x1).numpy()   # sigmoid(x1)*(1-sigmoid(x1)) => 0.25

0.25

高阶梯度

在 tf.GradientTape 上下文管理器内部的操作会被记录下来以供自动微分使用。如果在该上下文中计算梯度,那么梯度计算本身也会被记录。因此,完全相同的 API 也适用于高阶梯度。

例如:

x = tf.Variable(1.0)  # 创建一个初始化为 1.0 的 TensorFlow 变量

with tf.GradientTape() as t2:

    with tf.GradientTape() as t1:

        y = x * x * x

    # 在外层 `t2` 上下文管理器内计算梯度,

    # 这意味着梯度计算也是可微分的。

    dy_dx = t1.gradient(y, x)

d2y_dx2 = t2.gradient(dy_dx, x)

print('dy_dx:', dy_dx.numpy())   # 3 * x2 => 3.0

print('d2y_dx2:', d2y_dx2.numpy())  # 6 * x => 6.0

dy_dx: 3.0

d2y_dx2: 6.0

虽然这给出了标量函数的二阶导数,但这种模式不能推广到生成 Hessian 矩阵,因为 tf.GradientTape.gradient 只计算标量的梯度。要构造 Hessian 矩阵,请前往 Jacobian 部分下的 Hessian 示例。

“对 tf.GradientTape.gradient 的嵌套调用”是一个很好的模式,适用于当你从梯度计算出一个标量,然后该标量作为第二次梯度计算的源的情况,如下例所示。

示例:输入梯度正则化

许多模型容易受到“对抗性样本”的影响。这类技术通过修改模型的输入来干扰模型的输出。最简单的实现——例如使用快速梯度签名方法攻击的对抗性样本示例——沿着输出相对于输入的梯度(即“输入梯度”)迈出一大步。

提高对抗性样本鲁棒性的一种技术是输入梯度正则化(Finlay & Oberman, 2019),它试图最小化输入梯度的幅度。如果输入梯度很小,那么输出的变化也应该很小。

以下是输入梯度正则化的朴素实现。该实现包括:

  1. 使用内部磁带计算输出相对于输入的梯度。
  2. 计算该输入梯度的幅度。
  3. 计算该幅度相对于模型的梯度。

x = tf.random.normal([7, 5])

layer = tf.keras.layers.Dense(10, activation=tf.nn.relu)

with tf.GradientTape() as t2:

    # 内部磁带只计算相对于输入的梯度,

    # 而不是相对于变量的梯度。

    with tf.GradientTape(watch_accessed_variables=False) as t1:

        t1.watch(x)

        y = layer(x)

        out = tf.reduce_sum(layer(x)2)

    # 1. 计算输入梯度。

    g1 = t1.gradient(out, x)

    # 2. 计算输入梯度的幅度。

    g1_mag = tf.norm(g1)

# 3. 计算幅度相对于模型的梯度。

dg1_mag = t2.gradient(g1_mag, layer.trainable_variables)

[var.shape for var in dg1_mag]

[TensorShape([5, 10]), TensorShape([10])]

Jacobian(雅可比矩阵)

之前所有的示例都是计算标量目标相对于某些源张量的梯度。

Jacobian 矩阵表示向量值函数的梯度。每一行包含向量中一个元素的梯度。

tf.GradientTape.jacobian 方法允许你高效地计算 Jacobian 矩阵。

请注意:

  • 与 gradient 相同:sources 参数可以是张量或张量容器。
  • 与 gradient 不同:target 张量必须是单个张量。

标量源

作为第一个示例,这里是向量目标相对于标量源的 Jacobian。

x = tf.linspace(-10.0, 10.0, 200+1)

delta = tf.Variable(0.0)

with tf.GradientTape() as tape:

    y = tf.nn.sigmoid(x+delta)

dy_dx = tape.jacobian(y, delta)

当对标量取 Jacobian 时,结果具有目标的形状,并给出每个元素相对于源的梯度:

print(y.shape)

print(dy_dx.shape)

(201,)

(201,)

plt.plot(x.numpy(), y, label='y')

plt.plot(x.numpy(), dy_dx, label='dy/dx')

plt.legend()

_ = plt.xlabel('x')

张量源

无论输入是标量还是张量,tf.GradientTape.jacobian 都能高效计算目标的每个元素相对于源的每个元素的梯度。

例如,此层的输出形状为 (10, 7):

x = tf.random.normal([7, 5])

layer = tf.keras.layers.Dense(10, activation=tf.nn.relu)

with tf.GradientTape(persistent=True) as tape:

    y = layer(x)

y.shape

TensorShape([7, 10])

而层的 kernel 形状为 (5, 10):

layer.kernel.shape

TensorShape([5, 10])

输出相对于 kernel 的 Jacobian 的形状是这两个形状连接在一起:

j = tape.jacobian(y, layer.kernel)

j.shape

TensorShape([7, 10, 5, 10])

如果你对目标的维度求和,你将得到由 tf.GradientTape.gradient 计算出的和的梯度:

g = tape.gradient(y, layer.kernel)

print('g.shape:', g.shape)

j_sum = tf.reduce_sum(j, axis=[0, 1])

delta = tf.reduce_max(abs(g - j_sum)).numpy()

assert delta < 1e-3

print('delta:', delta)

g.shape: (5, 10)

delta: 2.3841858e-07

示例:Hessian 矩阵

虽然 tf.GradientTape 没有提供构建 Hessian 矩阵的显式方法,但可以使用 tf.GradientTape.jacobian 方法来构建。

x = tf.random.normal([7, 5])

layer1 = tf.keras.layers.Dense(8, activation=tf.nn.relu)

layer2 = tf.keras.layers.Dense(6, activation=tf.nn.relu)

with tf.GradientTape() as t2:

    with tf.GradientTape() as t1:

        x = layer1(x)

        x = layer2(x)

        loss = tf.reduce_mean(x2)

    g = t1.gradient(loss, layer1.kernel)

h = t2.jacobian(g, layer1.kernel)

print(f'layer.kernel.shape: {layer1.kernel.shape}')

print(f'h.shape: {h.shape}')

layer.kernel.shape: (5, 8)

h.shape: (5, 8, 5, 8)

要使用此 Hessian 矩阵进行牛顿法步骤,你需要先将其轴展平为矩阵,并将梯度展平为向量:

n_params = tf.reduce_prod(layer1.kernel.shape)

g_vec = tf.reshape(g, [n_params, 1])

h_mat = tf.reshape(h, [n_params, n_params])

Hessian 矩阵应该是对称的:

def imshow_zero_center(image, kwargs):

    lim = tf.reduce_max(abs(image))

    plt.imshow(image, vmin=-lim, vmax=lim, cmap='seismic', kwargs)

    plt.colorbar()

imshow_zero_center(h_mat)

牛顿法的更新步骤如下所示:

eps = 1e-3

eye_eps = tf.eye(h_mat.shape[0])*eps

# X(k+1) = X(k) - (∇²f(X(k)))^-1 @ ∇f(X(k))

# h_mat = ∇²f(X(k))

# g_vec = ∇f(X(k))

update = tf.linalg.solve(h_mat + eye_eps, g_vec)

# 重塑更新量并将其应用到变量上。

_ = layer1.kernel.assign_sub(tf.reshape(update, layer1.kernel.shape))

虽然这对于单个 tf.Variable 来说相对简单,但将其应用于非平凡的模型时,需要仔细的拼接和切片,以生成跨越多个变量的完整 Hessian 矩阵。

批量 Jacobian

在某些情况下,你想对一叠(stack)目标中的每一个相对于一叠源取 Jacobian,其中每个目标-源对的 Jacobian 是独立的。

例如,这里输入 x 的形状为 (batch, ins),输出 y 的形状为 (batch, outs):

x = tf.random.normal([7, 5])

layer1 = tf.keras.layers.Dense(8, activation=tf.nn.elu)

layer2 = tf.keras.layers.Dense(6, activation=tf.nn.elu)

with tf.GradientTape(persistent=True, watch_accessed_variables=False) as tape:

    tape.watch(x)

    y = layer1(x)

    y = layer2(y)

y.shape

TensorShape([7, 6])

y 相对于 x 的完整 Jacobian 形状为 (batch, ins, batch, outs),即使你只想要 (batch, ins, outs):

j = tape.jacobian(y, x)

j.shape

TensorShape([7, 6, 7, 5])

如果堆叠中每个项的梯度是独立的,那么这个张量的每个 (batch, batch) 切片都是一个对角矩阵:

imshow_zero_center(j[:, 0, :, 0])

_ = plt.title('A (batch, batch) slice')

def plot_as_patches(j):

    # 重新排列轴,使每个对角线形成一个连续的 patch

    j = tf.transpose(j, [1, 0, 3, 2])

    # 在每个 patch 之间填充

    lim = tf.reduce_max(abs(j))

    j = tf.pad(j, [[0, 0], [1, 1], [0, 0], [1, 1]],

               constant_values=-lim)

    # 重塑为单个图像

    s = j.shape

    j = tf.reshape(j, [s[0]*s[1], s[2]*s[3]])

    imshow_zero_center(j, extent=[-0.5, s[2]-0.5, s[0]-0.5, -0.5])

plot_as_patches(j)

_ = plt.title('All (batch, batch) slices are diagonal')

要获得期望的结果,你可以对重复的 batch 维度求和,或者使用 tf.einsum 选择对角线:

j_sum = tf.reduce_sum(j, axis=2)

print(j_sum.shape)

j_select = tf.einsum('bxby->bxy', j)

print(j_select.shape)

(7, 6, 5)

(7, 6, 5)

一开始就避免多余的维度会高效得多。tf.GradientTape.batch_jacobian 方法正是这样做的:

jb = tape.batch_jacobian(y, x)

jb.shape

(注:日志显示关于 tf.function 重新追踪的警告,这通常发生在循环中重复创建 @tf.function 或传递不同形状的张量时。)

TensorShape([7, 6, 5])

error = tf.reduce_max(abs(jb - j_sum))

assert error < 1e-3

print(error.numpy())

0.0

x = tf.random.normal([7, 5])

layer1 = tf.keras.layers.Dense(8, activation=tf.nn.elu)

bn = tf.keras.layers.BatchNormalization()

layer2 = tf.keras.layers.Dense(6, activation=tf.nn.elu)

with tf.GradientTape(persistent=True, watch_accessed_variables=False) as tape:

    tape.watch(x)

    y = layer1(x)

    y = bn(y, training=True)

    y = layer2(y)

j = tape.jacobian(y, x)

print(f'j.shape: {j.shape}')

(注:再次出现 tf.function 重新追踪的警告日志。)

j.shape: (7, 6, 7, 5)

plot_as_patches(j)

_ = plt.title('These slices are not diagonal')

_ = plt.xlabel("Don't use `batch_jacobian`")

在这种情况下,batch_jacobian 仍然运行并返回具有预期形状的内容,但其内容含义不明确:

jb = tape.batch_jacobian(y, x)

print(f'jb.shape: {jb.shape}')

jb.shape: (7, 6, 5)

评论 (0)