Frage Wie setze ich die adaptive Lernrate für GradientDescentOptimizer?


Ich benutze TensorFlow, um ein neurales Netzwerk zu trainieren. So initialisiere ich das GradientDescentOptimizer:

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

mse        = tf.reduce_mean(tf.square(out - out_))
train_step = tf.train.GradientDescentOptimizer(0.3).minimize(mse)

Die Sache hier ist, dass ich nicht weiß, wie man eine Aktualisierungsregel für die Lernrate oder einen Abfallwert dafür einstellt.

Wie kann ich hier eine adaptive Lernrate verwenden?


75
2017-11-25 15:08


Ursprung


Antworten:


Als erstes, tf.train.GradientDescentOptimizer ist so konzipiert, dass für alle Variablen in allen Schritten eine konstante Lernrate verwendet wird. TensorFlow bietet auch adaptive Optimizer einschließlich der tf.train.AdagradOptimizer und das tf.train.AdamOptimizerund diese können als Drop-In-Ersatz verwendet werden.

Allerdings, wenn Sie die Lernrate mit sonst-Vanille-Gradienten-Abstieg steuern möchten, können Sie die Tatsache nutzen, dass die learning_rate Argument zur tf.train.GradientDescentOptimizer Konstrukteur kann ein sein Tensor Objekt. Auf diese Weise können Sie in jedem Schritt einen anderen Wert für die Lernrate berechnen, zum Beispiel:

learning_rate = tf.placeholder(tf.float32, shape=[])
# ...
train_step = tf.train.GradientDescentOptimizer(
    learning_rate=learning_rate).minimize(mse)

sess = tf.Session()

# Feed different values for learning rate to each training step.
sess.run(train_step, feed_dict={learning_rate: 0.1})
sess.run(train_step, feed_dict={learning_rate: 0.1})
sess.run(train_step, feed_dict={learning_rate: 0.01})
sess.run(train_step, feed_dict={learning_rate: 0.01})

Alternativ könnten Sie einen Skalar erstellen tf.Variable Das hält die Lernrate und weist sie jedes Mal zu, wenn Sie die Lernrate ändern möchten.


159
2017-11-25 17:28



Tensorflow bietet eine Option, um automatisch einen exponentiellen Abfall auf einen Lerngeschwindigkeitstensor anzuwenden: tf.train.exponential_decay. Ein Beispiel dafür finden Sie in diese Linie im Beispiel des MNIST-Faltungsmodells. Verwenden Sie dann den obigen Vorschlag von @ mrry, um diese Variable als den Parameter learning_rate an Ihren Optimierer Ihrer Wahl zu liefern.

Der wichtigste zu betrachtende Ausschnitt ist:

# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)

learning_rate = tf.train.exponential_decay(
  0.01,                # Base learning rate.
  batch * BATCH_SIZE,  # Current index into the dataset.
  train_size,          # Decay step.
  0.95,                # Decay rate.
  staircase=True)
# Use simple momentum for the optimization.
optimizer = tf.train.MomentumOptimizer(learning_rate,
                                     0.9).minimize(loss,
                                                   global_step=batch)

Beachten Sie das global_step=batch zu minimierender Parameter Dies weist den Optimierer an, den "Batch" -Parameter bei jedem Training hilfreich für Sie zu erhöhen.


76
2017-11-26 06:14



Der Algorithmus für den Gradientenabstieg verwendet die konstante Lernrate, die Sie bereitstellen können während der Initialisierung. Sie können verschiedene Lernraten auf eine von Mrry gezeigte Weise weitergeben.

Aber statt dessen können Sie auch verwenden fortgeschrittenere Optimierer die eine schnellere Konvergenzrate haben und sich an die Situation anpassen.

Hier ist eine kurze Erklärung basierend auf meinem Verständnis:

  • Schwung  hilft SGD, um entlang der relevanten Richtungen zu navigieren und die Schwingungen im Irrelevanten abzuschwächen. Es fügt einfach einen Bruchteil der Richtung des vorherigen Schritts zu einem aktuellen Schritt hinzu. Dies erreicht eine Verstärkung der Geschwindigkeit in der korrekten Richtung und schwächt die Schwingung in falsche Richtungen. Dieser Bruchteil liegt normalerweise im (0, 1) -Bereich. Es macht auch Sinn, adaptives Momentum zu verwenden. Zu Beginn des Lernens wird ein großer Impuls nur deinen Fortschritt behindern, also macht es Sinn, etwas wie 0,01 zu verwenden und sobald alle hohen Gradienten verschwunden sind, kannst du einen größeren Moment verwenden. Es gibt ein Problem mit der Dynamik: Wenn wir dem Ziel sehr nahe sind, ist unser Momentum in den meisten Fällen sehr hoch und es weiß nicht, dass es langsamer werden sollte. Dies kann dazu führen, dass es um die Minima herum fehlt oder oszilliert
  • Nesterov beschleunigt Gradienten überwindet dieses Problem, indem es anfängt, früh zu verlangsamen. Im Momentum berechnen wir zuerst den Gradienten und machen dann einen Sprung in diese Richtung, verstärkt durch den Impuls, den wir vorher hatten. NAG macht dasselbe, aber in einer anderen Reihenfolge: Zuerst machen wir einen großen Sprung basierend auf unseren gespeicherten Informationen, und dann berechnen wir den Gradienten und führen eine kleine Korrektur durch. Diese scheinbar irrelevante Änderung führt zu erheblichen praktischen Verbesserungen.
  • AdaGrad oder ein adaptiver Gradient ermöglicht die Anpassung der Lernrate basierend auf Parametern. Es führt größere Updates für seltene Parameter und kleinere Updates für häufige Parameter durch. Aus diesem Grund ist es gut geeignet für spärliche Daten (NLP oder Bilderkennung). Ein weiterer Vorteil ist, dass es im Wesentlichen die Notwendigkeit, die Lernrate einzustellen, nicht erfüllt. Jeder Parameter hat seine eigene Lernrate und aufgrund der Besonderheiten des Algorithmus nimmt die Lernrate monoton ab. Dies verursacht das größte Problem: Zu einem bestimmten Zeitpunkt ist die Lernrate so gering, dass das System aufhört zu lernen
  • AdaDelta löst das Problem der monoton fallenden Lernrate in AdaGrad. In AdaGrad wurde die Lernrate ungefähr als eine geteilt durch die Summe der Quadratwurzeln berechnet. In jeder Phase fügen Sie der Summe eine weitere Quadratwurzel hinzu, wodurch der Nenner ständig abnimmt. In AdaDelta wird anstelle der Summe aller vergangenen Quadratwurzeln ein Schiebefenster verwendet, mit dem die Summe verringert werden kann. RMSprop ist sehr ähnlich zu AdaDelta
  • Adam oder adaptives Momentum ist ein AdaDelta ähnlicher Algorithmus. Zusätzlich zum Speichern von Lernraten für jeden der Parameter speichert er auch Impulsänderungen für jeden von ihnen separat

    EIN wenige Visualisierungen: enter image description here enter image description here


60
2018-05-12 06:40



Von Tensorfluss offizielle Dokumente

global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.1
learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
                                       100000, 0.96, staircase=True)

# Passing global_step to minimize() will increment it at each step.
learning_step = (
tf.train.GradientDescentOptimizer(learning_rate)
.minimize(...my loss..., global_step=global_step))

4
2018-03-21 08:35