บันทึกวันที่! Google I / O ส่งคืนวันที่ 18-20 พฤษภาคม ลงทะเบียนเลย
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

ความแตกต่างอัตโนมัติขั้นสูง

ดูใน TensorFlow.org เรียกใช้ใน Google Colab ดูแหล่งที่มาบน GitHubดาวน์โหลดสมุดบันทึก

คู่มือการสร้างความแตกต่างอัตโนมัติ ประกอบด้วยทุกสิ่งที่จำเป็นในการคำนวณการไล่ระดับสี คู่มือนี้มุ่งเน้นไปที่คุณสมบัติที่ลึกกว่าและไม่ค่อยพบบ่อยของ apitf.GradientTape

ติดตั้ง

import tensorflow as tf

import matplotlib as mpl
import matplotlib.pyplot as plt

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

การควบคุมการบันทึกแบบไล่ระดับสี

ใน คู่มือการสร้างความแตกต่างอัตโนมัติ คุณจะเห็นวิธีการควบคุมตัวแปรและเทนเซอร์ที่จะดูโดยเทปขณะสร้างการคำนวณการไล่ระดับสี

เทปยังมีวิธีการจัดการการบันทึก

หากคุณต้องการหยุดบันทึกการไล่ระดับสีคุณสามารถใช้ 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

หากคุณต้องการเริ่มต้นใหม่ทั้งหมดให้ใช้การ 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:
    # Throw out all the tape recorded so far
    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 = y**2
  z = x**2 + 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

การไล่ระดับสีที่กำหนดเอง

ในบางกรณีคุณอาจต้องการควบคุมวิธีคำนวณการไล่ระดับสีแทนการใช้ค่าเริ่มต้น สถานการณ์เหล่านี้ ได้แก่ :

  • ไม่มีการไล่ระดับสีที่กำหนดไว้สำหรับ op ใหม่ที่คุณกำลังเขียน
  • การคำนวณเริ่มต้นไม่แน่นอนในเชิงตัวเลข
  • คุณต้องการแคชการคำนวณที่มีราคาแพงจากบัตรเดินหน้า
  • คุณต้องการแก้ไขค่า (ตัวอย่างเช่นใช้: tf.clip_by_value , tf.math.round ) โดยไม่ต้องแก้ไขการไล่ระดับสี

สำหรับการเขียน op ใหม่คุณสามารถใช้ tf.RegisterGradient เพื่อตั้งค่าของคุณเอง ดูรายละเอียดในหน้านั้น (โปรดทราบว่าการลงทะเบียนไล่ระดับสีเป็นแบบโกลบอลดังนั้นโปรดเปลี่ยนด้วยความระมัดระวัง)

สำหรับสามกรณีหลังคุณสามารถใช้ tf.custom_gradient

นี่คือตัวอย่างที่ใช้tf.clip_by_norm กับการไล่ระดับสีกลาง

# Establish an identity operation, but clip during the gradient pass
@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))  # calls "backward", which clips 4 to 2
tf.Tensor(2.0, shape=(), dtype=float32)

ดูรายละเอียดเพิ่มเติมที่ tf.custom_gradient มัณฑนากร

หลายเทป

หลายเทปโต้ตอบได้อย่างราบรื่น ตัวอย่างเช่นที่นี่แต่ละเทปจะดูชุดเทนเซอร์ที่แตกต่างกัน:

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

การไล่ระดับสีที่สูงขึ้น

การดำเนินการภายในตัวจัดการบริบท GradientTape จะถูกบันทึกไว้สำหรับการสร้างความแตกต่างโดยอัตโนมัติ หากมีการคำนวณการไล่ระดับสีในบริบทนั้นการคำนวณการไล่ระดับสีจะถูกบันทึกด้วย ด้วยเหตุนี้ API เดียวกันจึงทำงานสำหรับการไล่ระดับสีลำดับที่สูงขึ้นเช่นกัน ตัวอย่างเช่น:

x = tf.Variable(1.0)  # Create a Tensorflow variable initialized to 1.0

with tf.GradientTape() as t2:
  with tf.GradientTape() as t1:
    y = x * x * x

  # Compute the gradient inside the outer `t2` context manager
  # which means the gradient computation is differentiable as well.
  dy_dx = t1.gradient(y, x)
d2y_dx2 = t2.gradient(dy_dx, x)

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

แม้ว่าจะให้อนุพันธ์อันดับสองของฟังก์ชัน สเกลาร์ แก่คุณ แต่รูปแบบนี้ไม่ได้เป็นการสรุปเพื่อสร้างเมทริกซ์ Hessian เนื่องจาก GradientTape.gradient คำนวณเฉพาะการไล่ระดับสีของสเกลาร์เท่านั้น ในการสร้าง Hessian โปรดดู ตัวอย่าง Hessian ใน หัวข้อ Jacobian

"การเรียกซ้อนไปยัง GradientTape.gradient " เป็นรูปแบบที่ดีเมื่อคุณคำนวณสเกลาร์จากการไล่ระดับสีจากนั้นสเกลาร์ที่ได้จะทำหน้าที่เป็นแหล่งที่มาสำหรับการคำนวณการไล่ระดับสีที่สองดังตัวอย่างต่อไปนี้

ตัวอย่าง: การจัดลำดับการไล่ระดับสีของอินพุต

โมเดลจำนวนมากมีความอ่อนไหวต่อ "ตัวอย่างฝ่ายตรงข้าม" คอลเลกชันของเทคนิคนี้จะปรับเปลี่ยนอินพุตของโมเดลเพื่อทำให้เอาต์พุตของโมเดลสับสน การนำไป ใช้ งานที่ง่ายที่สุด ใช้ขั้นตอนเดียวตามการไล่ระดับสีของเอาต์พุตที่เกี่ยวข้องกับอินพุต "การไล่ระดับสีของอินพุต"

เทคนิคหนึ่งในการเพิ่มความแข็งแกร่งให้กับตัวอย่างที่เป็นปฏิปักษ์คือการ ป้อนข้อมูลการไล่ระดับสีสม่ำเสมอ ซึ่งจะพยายามลดขนาดของการไล่ระดับสีของอินพุตให้เหลือน้อยที่สุด หากการไล่ระดับสีของอินพุตมีขนาดเล็กการเปลี่ยนแปลงของเอาต์พุตก็ควรมีขนาดเล็กเช่นกัน

ด้านล่างนี้เป็นการใช้การทำให้เป็นมาตรฐานของการไล่ระดับสีของอินพุต การใช้งานคือ:

  1. คำนวณการไล่ระดับสีของเอาต์พุตที่เกี่ยวข้องกับอินพุตโดยใช้เทปด้านใน
  2. คำนวณขนาดของการไล่ระดับสีอินพุตนั้น
  3. คำนวณการไล่ระดับสีของขนาดนั้นตามโมเดล
x = tf.random.normal([7, 5])

layer = tf.keras.layers.Dense(10, activation=tf.nn.relu)
with tf.GradientTape() as t2:
  # The inner tape only takes the gradient with respect to the input,
  # not the variables.
  with tf.GradientTape(watch_accessed_variables=False) as t1:
    t1.watch(x)
    y = layer(x)
    out = tf.reduce_sum(layer(x)**2)
  # 1. Calculate the input gradient.
  g1 = t1.gradient(out, x)
  # 2. Calculate the magnitude of the input gradient.
  g1_mag = tf.norm(g1)

# 3. Calculate the gradient of the magnitude with respect to the model.
dg1_mag = t2.gradient(g1_mag, layer.trainable_variables)
[var.shape for var in dg1_mag]
[TensorShape([5, 10]), TensorShape([10])]

จาโคเบียน

ตัวอย่างก่อนหน้านี้ทั้งหมดใช้การไล่ระดับสีของเป้าหมายสเกลาร์เทียบกับเทนเซอร์ต้นทางบางส่วน

เมทริกซ์จาโคเบียน แสดงถึงการไล่ระดับสีของฟังก์ชันที่มีค่าเวกเตอร์ แต่ละแถวมีการไล่ระดับสีของหนึ่งในองค์ประกอบของเวกเตอร์

วิธี GradientTape.jacobian ช่วยให้คุณคำนวณเมทริกซ์จาโคเบียนได้อย่างมีประสิทธิภาพ

โปรดทราบว่า:

  • เช่นเดียวกับการ gradient : อาร์กิวเมนต์ sources อาจเป็นเทนเซอร์หรือคอนเทนเนอร์ของเทนเซอร์
  • ไม่เหมือนกับการ gradient : เทนเซอร์ target ต้องเป็นเทนเซอร์ตัวเดียว

ที่มาสเกลาร์

ตัวอย่างแรกนี่คือจาโคเบียนของเวกเตอร์เป้าหมายที่เกี่ยวกับแหล่งที่มาของสเกลาร์

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)

เมื่อคุณนำจาโคเบียนไปเทียบกับสเกลาร์ผลลัพธ์จะมีรูปร่างของ เป้าหมาย และให้การไล่ระดับสีของแต่ละองค์ประกอบตามแหล่งที่มา:

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')

png

แหล่งที่มาของ Tensor

ไม่ว่าอินพุตจะเป็นสเกลาร์หรือเทนเซอร์ 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])

และรูปร่างของเคอร์เนลของเลเยอร์คือ (5, 10) :

layer.kernel.shape
TensorShape([5, 10])

รูปร่างของจาโคเบียนของผลลัพธ์ที่เกี่ยวกับเคอร์เนลคือรูปทรงทั้งสองที่เรียงต่อกัน:

j = tape.jacobian(y, layer.kernel)
j.shape
TensorShape([7, 10, 5, 10])

หากคุณรวมกับขนาดของเป้าหมายคุณจะเหลือการไล่ระดับสีของผลรวมที่ 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: 4.7683716e-07

ตัวอย่าง: Hessian

ในขณะที่tf.GradientTape ไม่ได้ให้วิธีการที่ชัดเจนในการสร้างเมทริกซ์ Hessian แต่ก็เป็นไปได้ที่จะสร้างขึ้นโดยใช้วิธี 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(x**2)

  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)

ในการใช้เฮสเซียนนี้สำหรับขั้นตอนวิธีการของนิวตันก่อนอื่นคุณต้องแผ่แกนออกเป็นเมทริกซ์และทำให้การไล่ระดับสีเป็นเวกเตอร์:

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])

เมทริกซ์เฮสเซียนควรสมมาตร:

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)

png

ขั้นตอนการอัปเดตวิธีการของ Newton แสดงไว้ด้านล่าง

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)

# Reshape the update and apply it to the variable.
_ = layer1.kernel.assign_sub(tf.reshape(update, layer1.kernel.shape))

แม้ว่าสิ่งนี้จะค่อนข้างง่ายสำหรับ tf.Variable เดียว แต่การนำสิ่งนี้ไปใช้กับแบบจำลองที่ไม่สำคัญจะต้องมีการต่อและแบ่งส่วนอย่างระมัดระวังเพื่อสร้าง Hessian แบบเต็มในหลายตัวแปร

แบทช์จาโคเบียน

ในบางกรณีคุณต้องการใช้จาโคเบียนของแต่ละกลุ่มของเป้าหมายที่เกี่ยวข้องกับแหล่งที่มาหลายชุดโดยที่จาโคเบียนสำหรับคู่แหล่งที่มาเป้าหมายแต่ละคู่จะเป็นอิสระ

ตัวอย่างเช่นที่นี่อินพุต 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 มีรูปร่าง (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')

png

def plot_as_patches(j):
  # Reorder axes so the diagonals will each form a contiguous patch.
  j = tf.transpose(j, [1, 0, 3, 2])
  # Pad in between each patch.
  lim = tf.reduce_max(abs(j))
  j = tf.pad(j, [[0, 0], [1, 1], [0, 0], [1, 1]],
             constant_values=-lim)
  # Reshape to form a single image.
  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')

png

เพื่อให้ได้ผลลัพธ์ที่ต้องการคุณสามารถรวมมิติ 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)

การคำนวณโดยไม่มีมิติพิเศษในตอนแรกจะมีประสิทธิภาพมากขึ้น วิธี GradientTape.batch_jacobian ทำอย่างนั้น

jb = tape.batch_jacobian(y, x)
jb.shape
WARNING:tensorflow:5 out of the last 5 calls to <function pfor.<locals>.f at 0x7f9a400e8620> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
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}')
WARNING:tensorflow:6 out of the last 6 calls to <function pfor.<locals>.f at 0x7f9a401090d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
j.shape: (7, 6, 7, 5)
plot_as_patches(j)

_ = plt.title('These slices are not diagonal')
_ = plt.xlabel("Don't use `batch_jacobian`")

png

ในกรณีนี้ batch_jacobian ยังคงรันและส่งคืน บางสิ่งที่ มีรูปร่างที่คาดไว้ แต่เนื้อหามีความหมายที่ไม่ชัดเจน

jb = tape.batch_jacobian(y, x)
print(f'jb.shape: {jb.shape}')
WARNING:tensorflow:7 out of the last 7 calls to <function pfor.<locals>.f at 0x7f9a4c0637b8> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
jb.shape: (7, 6, 5)