วิธีการใช้ Gradient Clipping ใน TensorFlow

พิจารณาโค้ดตัวอย่าง

ฉันต้องการทราบวิธีใช้การตัดแบบไล่ระดับกับเครือข่ายนี้บน RNN ซึ่งมีความเป็นไปได้ที่จะมีการไล่ระดับสีแบบระเบิด

tf.clip_by_value(t, clip_value_min, clip_value_max, name=None)

นี่เป็นตัวอย่างที่สามารถใช้ได้ แต่จะแนะนำได้ที่ไหน ใน def ของ RNN

    lstm_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0)
    # Split data because rnn cell needs a list of inputs for the RNN inner loop
    _X = tf.split(0, n_steps, _X) # n_steps
tf.clip_by_value(_X, -1, 1, name=None)

แต่สิ่งนี้ไม่สมเหตุสมผลเนื่องจากเทนเซอร์ _X เป็นอินพุตไม่ใช่สิ่งที่จะถูกตัดจบ?

ฉันต้องกำหนดเครื่องมือเพิ่มประสิทธิภาพของตัวเองสำหรับสิ่งนี้หรือมีตัวเลือกที่ง่ายกว่านี้ไหม

การตัดแบบไล่ระดับจะต้องเกิดขึ้นหลังจากคำนวณการไล่ระดับสี แต่ก่อนที่จะนำไปใช้เพื่ออัปเดตพารามิเตอร์ของโมเดล ในตัวอย่างของคุณทั้งสองสิ่งนั้นได้รับการจัดการโดยAdamOptimizer.minimize()วิธีการ

เพื่อที่จะตัดการไล่ระดับสีของคุณคุณจะต้องชัดเจนคำนวณคลิปและนำไปใช้ตามที่อธิบายในส่วนนี้ในเอกสาร API TensorFlow ของ โดยเฉพาะอย่างยิ่งคุณจะต้องแทนที่การเรียกใช้minimize()วิธีการดังต่อไปนี้:

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
gvs = optimizer.compute_gradients(cost)
capped_gvs = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gvs]
train_op = optimizer.apply_gradients(capped_gvs)

แม้จะเป็นที่นิยม แต่คุณอาจต้องการตัดการไล่ระดับสีทั้งหมดตามบรรทัดฐานทั่วโลก:

optimizer = tf.train.AdamOptimizer(1e-3)
gradients, variables = zip(*optimizer.compute_gradients(loss))
gradients, _ = tf.clip_by_global_norm(gradients, 5.0)
optimize = optimizer.apply_gradients(zip(gradients, variables))

การตัดแต่ละเมทริกซ์ไล่ระดับสีทีละรายการจะเปลี่ยนมาตราส่วนสัมพัทธ์ แต่ก็เป็นไปได้เช่นกัน:

optimizer = tf.train.AdamOptimizer(1e-3)
gradients, variables = zip(*optimizer.compute_gradients(loss))
gradients = [
    None if gradient is None else tf.clip_by_norm(gradient, 5.0)
    for gradient in gradients]
optimize = optimizer.apply_gradients(zip(gradients, variables))

ใน TensorFlow 2 เทปจะคำนวณการไล่ระดับสีเครื่องมือเพิ่มประสิทธิภาพมาจาก Keras และเราไม่จำเป็นต้องจัดเก็บตัวอัปเดตเนื่องจากจะทำงานโดยอัตโนมัติโดยไม่ส่งต่อไปยังเซสชัน:

optimizer = tf.keras.optimizers.Adam(1e-3)
# ...
with tf.GradientTape() as tape:
  loss = ...
variables = ...
gradients = tape.gradient(loss, variables)
gradients, _ = tf.clip_by_global_norm(gradients, 5.0)
optimizer.apply_gradients(zip(gradients, variables))

สิ่งนี้ได้อธิบายไว้อย่างถูกต้องในเอกสารประกอบ :

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

• คำนวณการไล่ระดับสีด้วย compute_gradients ()
• ประมวลผลการไล่ระดับสีตามที่คุณต้องการ
• ใช้การไล่ระดับสีที่ประมวลผลด้วย apply_gradients ()

และในตัวอย่างที่ระบุให้ใช้ 3 ขั้นตอนเหล่านี้:

# Create an optimizer.
opt = GradientDescentOptimizer(learning_rate=0.1)

# Compute the gradients for a list of variables.
grads_and_vars = opt.compute_gradients(loss, <list of variables>)

# grads_and_vars is a list of tuples (gradient, variable).  Do whatever you
# need to the 'gradient' part, for example cap them, etc.
capped_grads_and_vars = [(MyCapper(gv[0]), gv[1]) for gv in grads_and_vars]

# Ask the optimizer to apply the capped gradients.
opt.apply_gradients(capped_grads_and_vars)

นี่MyCapperคือฟังก์ชันใด ๆ ที่ จำกัด การไล่ระดับสีของคุณ รายชื่อของฟังก์ชันที่มีประโยชน์อื่น ๆ (กว่าtf.clip_by_value()) เป็นที่นี่

สำหรับผู้ที่ต้องการทำความเข้าใจแนวคิดของการตัดแบบไล่ระดับสี (ตามบรรทัดฐาน):

เมื่อใดก็ตามที่บรรทัดฐานการไล่ระดับสีมีค่ามากกว่าเกณฑ์เฉพาะเราจะตัดบรรทัดฐานการไล่ระดับสีเพื่อให้อยู่ในเกณฑ์ บางครั้งเกณฑ์นี้ถูกตั้งค่าเป็น5เกณฑ์นี้บางครั้งการตั้งค่าให้

ให้การไล่ระดับสีเป็นgและ max_norm_threshold เป็นjเจ

ตอนนี้ถ้า || ก. || > jเราทำ:

ก = ( j * g ) / || ก ||

นี่คือการใช้งานที่ทำใน tf.clip_by_norm

IMO ทางออกที่ดีที่สุดคือการตัดเพิ่มประสิทธิภาพของคุณกับ TF ของมัณฑนากรประมาณการtf.contrib.estimator.clip_gradients_by_norm:

original_optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
optimizer = tf.contrib.estimator.clip_gradients_by_norm(original_optimizer, clip_norm=5.0)
train_op = optimizer.minimize(loss)

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

เอกสารประกอบ: https://www.tensorflow.org/api_docs/python/tf/contrib/estimator/clip_gradients_by_norm

Gradient Clipping โดยทั่วไปจะช่วยในกรณีของการไล่ระดับสีที่ระเบิดหรือหายไปกล่าวว่าการสูญเสียของคุณสูงเกินไปซึ่งจะส่งผลให้การไล่ระดับสีแบบเอ็กซ์โพเนนเชียลไหลผ่านเครือข่ายซึ่งอาจส่งผลให้ค่าน่าน เพื่อเอาชนะสิ่งนี้เราตัดการไล่ระดับสีภายในช่วงที่กำหนด (-1 ถึง 1 หรือช่วงใดก็ได้ตามเงื่อนไข)

clipped_value=tf.clip_by_value(grad, -range, +range), var) for grad, var in grads_and_vars

โดยที่ grads _and_vars คือคู่ของการไล่ระดับสี (ซึ่งคุณคำนวณผ่าน tf.compute_gradients) และตัวแปรของมันจะถูกนำไปใช้

หลังจากตัดเราก็ใช้ค่าของมันโดยใช้เครื่องมือเพิ่มประสิทธิภาพ optimizer.apply_gradients(clipped_value)

เป็นเรื่องง่ายสำหรับ tf.keras!

optimizer = tf.keras.optimizers.Adam(clipvalue=1.0)

[-1.0, 1.0]เพิ่มประสิทธิภาพนี้จะตัดการไล่ระดับสีเป็นค่าระหว่าง

ดูเอกสาร