¿Cómo aplicar el recorte de degradado en TensorFlow?

Considerando el código de ejemplo .

Me gustaría saber cómo aplicar el recorte de gradiente en esta red en el RNN donde existe la posibilidad de explosiones de gradientes.

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

Este es un ejemplo que podría usarse, pero ¿dónde lo introduzco? En la def de 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)

Pero esto no tiene sentido ya que el tensor _X es la entrada y no el grad. ¿Qué se va a recortar?

¿Tengo que definir mi propio Optimizador para esto o hay una opción más simple?

El recorte de degradado debe ocurrir después de calcular los degradados, pero antes de aplicarlos para actualizar los parámetros del modelo. En su ejemplo, ambas cosas son manejadas por el AdamOptimizer.minimize()método.

Para recortar sus degradados, deberá calcularlos, recortarlos y aplicarlos explícitamente como se describe en esta sección en la documentación de la API de TensorFlow . Específicamente, deberá sustituir la llamada al minimize()método con algo como lo siguiente:

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)

A pesar de lo que parece ser popular, probablemente desee recortar todo el degradado según su norma global:

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

Recortar cada matriz de degradado cambia individualmente su escala relativa, pero también es posible:

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

En TensorFlow 2, una cinta calcula los gradientes, los optimizadores provienen de Keras y no necesitamos almacenar la operación de actualización porque se ejecuta automáticamente sin pasarla a una sesión:

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

En realidad, esto se explica correctamente en la documentación. :

Llamar a minimizar () se encarga tanto de calcular los gradientes como de aplicarlos a las variables. Si desea procesar los degradados antes de aplicarlos, puede utilizar el optimizador en tres pasos:

• Calcule los gradientes con compute_gradients ().
• Procese los gradientes como desee.
• Aplique los degradados procesados ​​con apply_gradients ().

Y en el ejemplo que proporcionan, utilizan estos 3 pasos:

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

Aquí MyCapperhay cualquier función que limite su degradado. La lista de funciones útiles (distintas de tf.clip_by_value()) está aquí .

Para aquellos que quieran entender la idea del recorte de gradiente (por norma):

Siempre que la norma de gradiente es mayor que un umbral particular, recortamos la norma de gradiente para que permanezca dentro del umbral. Este umbral a veces se establece en 5.

Deje que el gradiente sea gy el max_norm_threshold sea j .

Ahora, si || g || > j , hacemos:

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

Esta es la implementación realizada en tf.clip_by_norm

En mi opinión, la mejor solución es envolver su optimizador con el decorador de estimadores de 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)

De esta manera, solo tiene que definir esto una vez y no ejecutarlo después de cada cálculo de gradientes.

Documentación: https://www.tensorflow.org/api_docs/python/tf/contrib/estimator/clip_gradients_by_norm

El recorte de gradiente básicamente ayuda en caso de explosión o desaparición de gradientes. Diga que su pérdida es demasiado alta, lo que resultará en gradientes exponenciales para fluir a través de la red, lo que puede dar como resultado valores de Nan. Para superar esto, recortamos los degradados dentro de un rango específico (-1 a 1 o cualquier rango según la condición).

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

donde grads _and_vars son los pares de gradientes (que calcula a través de tf.compute_gradients) y sus variables a las que se aplicarán.

Después del recorte, simplemente aplicamos su valor usando un optimizador. optimizer.apply_gradients(clipped_value)