第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),它试图最小化输入梯度的幅度。如果输入梯度很小,那么输出的变化也应该很小。
以下是输入梯度正则化的朴素实现。该实现包括:
- 使用内部磁带计算输出相对于输入的梯度。
- 计算该输入梯度的幅度。
- 计算该幅度相对于模型的梯度。
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)