Bagaimana cara menerapkan pemotongan gradien di TensorFlow?

Mempertimbangkan kode contoh .

Saya ingin tahu Bagaimana cara menerapkan pemotongan gradien pada jaringan ini di RNN di mana ada kemungkinan gradien yang meledak.

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

Ini adalah contoh yang dapat digunakan tetapi di mana saya memperkenalkan ini? Di def dari 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)

Tapi ini tidak masuk akal karena tensor _X adalah input dan bukan grad yang akan dipotong?

Apakah saya harus menentukan Pengoptimal saya sendiri untuk ini atau adakah opsi yang lebih sederhana?

Pemotongan gradien perlu terjadi setelah menghitung gradien, tetapi sebelum menerapkannya untuk memperbarui parameter model. Dalam contoh Anda, kedua hal tersebut ditangani oleh AdamOptimizer.minimize()metode.

Untuk memangkas gradien, Anda harus menghitung, memotong, dan menerapkannya secara eksplisit seperti yang dijelaskan di bagian ini dalam dokumentasi API TensorFlow . Secara khusus, Anda perlu mengganti panggilan ke minimize()metode dengan sesuatu seperti berikut:

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)

Terlepas dari apa yang tampaknya populer, Anda mungkin ingin memotong seluruh gradien dengan norma globalnya:

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

Memotong setiap matriks gradien secara individual mengubah skala relatifnya tetapi juga memungkinkan:

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

Di TensorFlow 2, sebuah pita menghitung gradien, pengoptimal berasal dari Keras, dan kita tidak perlu menyimpan op pembaruan karena ini berjalan secara otomatis tanpa meneruskannya ke sesi:

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

Ini sebenarnya dijelaskan dengan benar dalam dokumentasi. :

Memanggil minimalkan () menangani komputasi gradien dan menerapkannya ke variabel. Jika Anda ingin memproses gradien sebelum menerapkannya, Anda dapat menggunakan pengoptimal dalam tiga langkah:

• Hitung gradien dengan compute_gradients ().
• Proses gradien sesuai keinginan.
• Terapkan gradien yang diproses dengan apply_gradients ().

Dan dalam contoh yang mereka berikan, mereka menggunakan 3 langkah berikut:

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

Berikut MyCapperadalah fungsi apa pun yang membatasi gradien Anda. Daftar fungsi yang berguna (selain tf.clip_by_value()) ada di sini .

Bagi mereka yang ingin memahami gagasan pemotongan gradien (menurut norma):

Setiap kali norma gradien lebih besar dari ambang tertentu, kami memotong norma gradien sehingga tetap dalam ambang. Ambang batas ini terkadang disetel ke 5.

Biarkan gradien menjadi g dan max_norm_threshold menjadi j .

Sekarang, jika || g || > j , kami melakukan:

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

Ini adalah implementasi yang dilakukan di tf.clip_by_norm

IMO solusi terbaik adalah membungkus pengoptimal Anda dengan dekorator penaksir 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)

Dengan cara ini Anda hanya perlu mendefinisikan ini sekali, dan tidak menjalankannya setelah setiap perhitungan gradien.

Dokumentasi: https://www.tensorflow.org/api_docs/python/tf/contrib/estimator/clip_gradients_by_norm

Pemotongan Gradien pada dasarnya membantu jika gradien meledak atau menghilang. Katakan kerugian Anda terlalu tinggi yang akan mengakibatkan gradien eksponensial mengalir melalui jaringan yang dapat menghasilkan nilai Nan. Untuk mengatasinya, kami memotong gradien dalam rentang tertentu (-1 hingga 1 atau rentang apa pun sesuai kondisi).

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

di mana lulusan _and_vars adalah pasangan gradien (yang Anda hitung melalui tf.compute_gradients) dan variabelnya akan diterapkan.

Setelah pemotongan, kami hanya menerapkan nilainya menggunakan pengoptimal. optimizer.apply_gradients(clipped_value)