Como aplicar o recorte de gradiente no TensorFlow?

Considerando o código de exemplo .

Gostaria de saber como aplicar gradiente nessa rede no RNN onde existe a possibilidade de explodir gradientes.

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

Este é um exemplo que poderia ser usado, mas onde posso apresentá-lo? Na defesa do 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)

Mas isso não faz sentido porque o tensor _X é a entrada e não o grad que deve ser recortado?

Tenho que definir meu próprio Otimizador para isso ou existe uma opção mais simples?

O recorte do gradiente precisa acontecer depois de computar os gradientes, mas antes de aplicá-los para atualizar os parâmetros do modelo. Em seu exemplo, ambas as coisas são tratadas pelo AdamOptimizer.minimize()método.

Para cortar seus gradientes, você precisará computar, cortar e aplicá-los explicitamente conforme descrito nesta seção na documentação da API do TensorFlow . Especificamente, você precisará substituir a chamada ao minimize()método por algo como o seguinte:

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)

Apesar do que parece ser popular, você provavelmente deseja cortar todo o gradiente por sua 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 gradiente individualmente altera sua escala relativa, mas também é possível:

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

No TensorFlow 2, uma fita calcula os gradientes, os otimizadores vêm de Keras e não precisamos armazenar a operação de atualização porque ela é executada automaticamente sem passá-la para uma sessão:

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

Na verdade, isso é explicado de maneira adequada na documentação. :

Chamar minimize () cuida de computar os gradientes e aplicá-los às variáveis. Se quiser processar os gradientes antes de aplicá-los, você pode usar o otimizador em três etapas:

• Calcule os gradientes com compute_gradients ().
• Processe os gradientes como desejar.
• Aplique os gradientes processados ​​com apply_gradients ().

E no exemplo que eles fornecem, eles usam estas 3 etapas:

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

Aqui MyCapperestá qualquer função que limite seu gradiente. A lista de funções úteis (exceto tf.clip_by_value()) está aqui .

Para quem gostaria de entender a ideia de recorte gradiente (por norma):

Sempre que a norma do gradiente é maior do que um determinado limite, recortamos a norma do gradiente para que permaneça dentro do limite. Esse limite às vezes é definido como 5.

Seja o gradiente ge o max_norm_threshold seja j .

Agora, se || g || > j , nós fazemos:

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

Esta é a implementação feita em tf.clip_by_norm

IMO, a melhor solução é envolver seu otimizador com o decorador de estimadores do 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)

Dessa forma, você só precisa definir isso uma vez e não executá-lo após cada cálculo de gradiente.

Documentação: https://www.tensorflow.org/api_docs/python/tf/contrib/estimator/clip_gradients_by_norm

O recorte de gradiente basicamente ajuda no caso de gradientes explodindo ou desaparecendo. Diga que sua perda é muito alta, o que resultará em gradientes exponenciais para fluir pela rede, o que pode resultar em valores Nan. Para superar isso, recortamos gradientes dentro de um intervalo específico (-1 a 1 ou qualquer intervalo conforme a condição).

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

onde grads _and_vars são os pares de gradientes (que você calcula via tf.compute_gradients) e suas variáveis ​​às quais eles serão aplicados.

Após o recorte, simplesmente aplicamos seu valor usando um otimizador. optimizer.apply_gradients(clipped_value)