Wie wende ich Gradienten-Clipping in TensorFlow an?

Betrachtet man den Beispielcode .

Ich würde gerne wissen, wie man Gradientenbeschneidungen in diesem Netzwerk auf dem RNN anwendet, wo die Möglichkeit besteht, dass Gradienten explodieren.

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

Dies ist ein Beispiel, das verwendet werden könnte, aber wo führe ich das ein? In der Def von 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)

Dies ist jedoch nicht sinnvoll, da der Tensor _X die Eingabe und nicht der Grad ist. Was soll abgeschnitten werden?

Muss ich dafür meinen eigenen Optimierer definieren oder gibt es eine einfachere Option?

Das Abschneiden von Verläufen muss nach der Berechnung der Verläufe erfolgen, bevor sie angewendet werden, um die Parameter des Modells zu aktualisieren. In Ihrem Beispiel werden beide Dinge von der AdamOptimizer.minimize()Methode behandelt.

Um Ihre Verläufe zu beschneiden, müssen Sie sie explizit berechnen, beschneiden und anwenden, wie in diesem Abschnitt in der API-Dokumentation von TensorFlow beschrieben . Insbesondere müssen Sie den Aufruf der minimize()Methode durch Folgendes ersetzen :

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)

Trotz allem, was populär zu sein scheint, möchten Sie wahrscheinlich den gesamten Farbverlauf nach seiner globalen Norm abschneiden:

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

Das Abschneiden jeder Gradientenmatrix ändert einzeln ihre relative Skalierung, ist aber auch möglich:

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

In TensorFlow 2 berechnet ein Band die Farbverläufe, die Optimierer stammen von Keras, und wir müssen das Update nicht speichern, da es automatisch ausgeführt wird, ohne es an eine Sitzung zu übergeben:

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

Dies wird in der Dokumentation tatsächlich richtig erklärt. ::

Durch Aufrufen von minim () werden sowohl die Gradienten berechnet als auch auf die Variablen angewendet. Wenn Sie die Farbverläufe vor dem Anwenden verarbeiten möchten, können Sie den Optimierer stattdessen in drei Schritten verwenden:

• Berechnen Sie die Farbverläufe mit compute_gradients ().
• Verarbeiten Sie die Farbverläufe nach Ihren Wünschen.
• Wenden Sie die verarbeiteten Verläufe mit apply_gradients () an.

In dem von ihnen bereitgestellten Beispiel verwenden sie diese drei Schritte:

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

Hier MyCapperist jede Funktion, die Ihren Farbverlauf begrenzt. Die Liste der nützlichen Funktionen (außer tf.clip_by_value()) finden Sie hier .

Für diejenigen, die die Idee des Gradientenschneidens (nach Norm) verstehen möchten:

Immer wenn die Gradientennorm größer als ein bestimmter Schwellenwert ist, schneiden wir die Gradientennorm so ab, dass sie innerhalb des Schwellenwerts bleibt. Dieser Schwellenwert wird manchmal auf gesetzt 5.

Der Gradient sei g und der max_norm_threshold sei j .

Nun, wenn || g || > j , wir machen:

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

Dies ist die Implementierung in tf.clip_by_norm

IMO ist die beste Lösung, Ihren Optimierer mit dem Schätzer-Dekorator von TF zu versehen 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)

Auf diese Weise müssen Sie dies nur einmal definieren und nicht nach jeder Gradientenberechnung ausführen.

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

Gradient Clipping hilft im Grunde bei explodierenden oder verschwindenden Gradienten. Sagen Sie, Ihr Verlust ist zu hoch, was dazu führt, dass exponentielle Gradienten durch das Netzwerk fließen, was zu Nan-Werten führen kann. Um dies zu überwinden, schneiden wir Farbverläufe innerhalb eines bestimmten Bereichs (-1 bis 1 oder eines beliebigen Bereichs gemäß der Bedingung).

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

Dabei sind Absolventen _und_vars die Gradientenpaare (die Sie über tf.compute_gradients berechnen) und ihre Variablen, auf die sie angewendet werden.

Nach dem Abschneiden wenden wir den Wert einfach mit einem Optimierer an. optimizer.apply_gradients(clipped_value)