Ich verwende TensorFlow, um ein neuronales Netzwerk zu trainieren. So initialisiere ich die 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 Abklingwert dafür festlegt.
Wie kann ich hier eine adaptive Lernrate verwenden?
mrry
Zunächst, tf.train.GradientDescentOptimizer wurde entwickelt, um eine konstante Lernrate für alle Variablen in allen Schritten zu verwenden. TensorFlow bietet auch sofort einsatzbereite adaptive Optimierer, einschließlich der tf.train.AdagradOptimizer und das tf.train.AdamOptimizer, und diese können als Drop-in-Ersatz verwendet werden.
Wenn Sie jedoch die Lernrate mit dem ansonsten Vanille-Gradientenabstieg steuern möchten, können Sie sich die Tatsache zunutze machen, dass die learning_rate Argument gegen die tf.train.GradientDescentOptimizer Konstrukteur kann 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önnen Sie einen Skalar erstellen tf.Variable die die Lernrate enthält, und weisen Sie sie jedes Mal zu, wenn Sie die Lernrate ändern möchten.
Gute Antwort. Kann dieselbe Technik für das Beschneiden von Farbverläufen verwendet werden? tf.clip_by_norm akzeptiert keinen Tensor für die Clipnorm, also wie wäre es mit? [(tf.minimum(gv[0], ct), gv[1]) for gv in optimizer.compute_gradients(cost, vars)], wo ct = tf.placeholder('float32', shape=[])
– richizy
21. Dezember ’15 um 4:42
Das sollte funktionieren, ja. (Obwohl es sich anschaut tf.clip_by_norm, das einzige, was es daran hindert, einen Tensor als Eingabe zu akzeptieren, ist die constant_op.constant(1.0 / clip_norm). Ersetze diesen Ausdruck durch math_ops.inv(clip_norm) würde es mit einer Platzhaltereingabe (oder einem anderen Tensor) funktionieren lassen.)
– mrry
21. Dezember ’15 um 5:57
@mrry Ich habe es wie gesagt gemacht und irgendwie ist die Trainingsgeschwindigkeit viel langsamer. Wird es bitte erwartet?
– tnq177
17. September ’18 um 14:05
dga
Tensorflow bietet eine Option zum automatischen Anwenden eines exponentiellen Abfalls auf einen Lernratentensor: tf.train.exponential_decay. Ein Anwendungsbeispiel finden Sie unter diese Zeile im Beispiel des MNIST-Faltungsmodells. Verwenden Sie dann den obigen Vorschlag von @mrry, um diese Variable als Parameter für die Lernrate an Ihren Optimierer Ihrer Wahl zu übergeben.
Der wichtigste Auszug 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 Parameter zu minimieren. Das weist den Optimierer an, den Parameter ‘batch’ bei jedem Training hilfreich für Sie zu erhöhen.
Normalerweise ist die Variable, die Sie aufrufen batch wird genannt global_step und es gibt mehrere Komfortfunktionen, eine zum Erstellen tf.train.create_global_step() (was einfach eine ganze Zahl erzeugt tf.Variable und fügt es dem hinzu tf.GraphKeys.GLOBAL_STEP Sammlung) und tf.train.get_global_step().
– Lenar Hoyt
31. August ’17 um 1:39
Salvador Dali
Der Gradientenabstiegsalgorithmus verwendet die konstante Lernrate, die Sie in . bereitstellen können während der Initialisierung. Sie können verschiedene Lernraten auf eine von Mrry gezeigte Weise bestehen.
Aber stattdessen kannst du auch verwenden fortgeschrittenere Optimierer die eine schnellere Konvergenzrate haben und sich der Situation anpasst.
Hier eine kurze Erklärung nach meinem Verständnis:
Adam oder adaptives Momentum ist ein Algorithmus ähnlich AdaDelta. Aber zusätzlich zum Speichern der Lernraten für jeden der Parameter speichert es auch Impulsänderungen für jeden von ihnen separat
Zum Vergleich verschiedener Optimierer in TensorFlow sehen Sie sich das folgende ipython-Notebook an: github.com/vsmolyakov/experiments_with_python/blob/master/chp03/… Pro
– Vadim Smolyakov
13. September ’17 um 3:54
Fortgeschrittenere Optimierer sind nicht “stattdessen” zu verwenden, aber zusätzlich siehe stats.stackexchange.com/questions/200063/…
– Dima Litujew
14. März ’18 um 0:22
@DimaLituiev können Sie zwei Optimierer gleichzeitig verwenden? Wenn nein, verwenden Sie Optimierer1 anstelle von Optimierer2.
– Salvador Dali
14. März ’18 um 2:08
das ist nicht das, was ich sage, und das war hier auch nicht die Frage. Sie schlagen vor, erweiterte Optimierer anstelle der adaptiven Lernrate zu verwenden. Ich sage, Sie würden lieber erweiterte Optimierer zusätzlich zur adaptiven Lernrate verwenden
– Dima Litujew
14. März ’18 um 6:21
Prakash Vanapalli
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))
Wenn Sie bestimmte Lernraten für Intervalle von Epochen wie 0 < a < b < c < .... Dann können Sie Ihre Lernrate als bedingten Tensor, bedingt vom globalen Schritt, definieren und diesen wie gewohnt dem Optimierer zuführen.
Sie könnten dies mit einer Reihe von verschachtelten tf.cond -Anweisungen, aber es ist einfacher, den Tensor rekursiv aufzubauen:
def make_learning_rate_tensor(reduction_steps, learning_rates, global_step):
assert len(reduction_steps) + 1 == len(learning_rates)
if len(reduction_steps) == 1:
return tf.cond(
global_step < reduction_steps[0],
lambda: learning_rates[0],
lambda: learning_rates[1]
)
else:
return tf.cond(
global_step < reduction_steps[0],
lambda: learning_rates[0],
lambda: make_learning_rate_tensor(
reduction_steps[1:],
learning_rates[1:],
global_step,)
)
Dann müssen Sie für die Nutzung wissen, wie viele Trainingsschritte es in einer einzelnen Epoche gibt, damit wir mit dem globalen Schritt zum richtigen Zeitpunkt wechseln und schließlich die gewünschten Epochen und Lernraten definieren können. Also wenn ich die Lernraten will [0.1, 0.01, 0.001, 0.0001] während der Epochenintervalle von [0, 19], [20, 59], [60, 99], [100, infty] bzw. würde ich tun:
global_step = tf.train.get_or_create_global_step()
learning_rates = [0.1, 0.01, 0.001, 0.0001]
steps_per_epoch = 225
epochs_to_switch_at = [20, 60, 100]
epochs_to_switch_at = [x*steps_per_epoch for x in epochs_to_switch_at ]
learning_rate = make_learning_rate_tensor(epochs_to_switch_at , learning_rates, global_step)
.
Es ist eine gute Angewohnheit, alle Variablen zu initialisieren nach Sie geben Ihren Optimierer an, da einige Optimierer wie AdamOptimizer eigene Variablen verwenden, die ebenfalls initialisiert werden müssen. Andernfalls erhalten Sie möglicherweise einen Fehler, der wie folgt aussieht:
FailedPreconditionError (see above for traceback): Attempting to use uninitialized value beta2_power– JYun
7. Februar ’18 um 0:02
Ich erhalte diesen oben genannten Fehler, wenn ich versuche, eine neue Lernrate in Tensorflow einzustellen von
tf.train.GradientDescentOptimizer(new_lr).minimize(loss). Es scheint, dass das Festlegen einer neuen Lernrate die Initialisierung des Modells mit den bereits trainierten Variablen erfordert. Kann aber nicht rausfinden wie das geht.– Siladittya
31. März ’18 um 13:00