Tensorflow: Verwirrung in Bezug auf die adam-Optimierer

Ich bin verwirrt in Bezug darauf, wie die adam optimizer funktioniert tatsächlich in tensorflow.

Dem Weg, ich lese die docs, es sagt, dass die learning-rate geändert wird jedem gradient-descent-iteration.

Aber wenn ich die Funktion aufrufen ich ihm eine Lern-rate. Und ich glaube nicht, rufen Sie die Funktion sagen wir mal, eine Epoche (implizit aufrufen # Iterationen so durch meine Daten training). Rufe ich die Funktion für jeden batch explizit wie

for epoch in epochs
     for batch in data
          sess.run(train_adam_step, feed_dict={eta:1e-3})

Also mein eta kann nicht verändert werden. Und ich bin nicht durch eine Zeit-variable in. Oder ist dies eine Art generator geben, was wo auf der Sitzung Schöpfung t jedes mal erhöht wird, nenne ich den optimizer?

Vorausgesetzt, es ist einige generator-Typ-Sache und die learning-rate wird unsichtbar, reduziert: Wie bekomme ich die zum ausführen der adam-Optimierer, ohne verfallende die learning-rate? Es scheint mir, wie RMSProp ist im Grunde das gleiche, das einzige, was ich würde tun müssen, um es gleich (learning rate ignoriert) ist die änderung der hyperparameters momentum und decay passend beta1 und beta2 beziehungsweise. Ist das richtig?

InformationsquelleAutor Nimitz14 | 2016-06-15

python tensorflow

23

Ich finde die Dokumentation ziemlich klar, ich werde hier einfügen, den Algorithmus in pseudo-code:

Ihre Parameter:
- learning_rate: zwischen 1e-4 und 1e-2 ist standard
- beta1: 0.9 standardmäßig
- beta2: 0.999 standardmäßig
- epsilon: 1e-08 standardmäßig
  
  Den default-Wert von 1e-8 für epsilon könnte nicht eine gute Standard im Allgemeinen. Zum Beispiel, wenn die Ausbildung einer Gründung Netzwerk auf ImageNet eine gute Wahl ist 1.0 oder 0.1.
Initialisierung:
```
m_0 <- 0 (Initialize initial 1st moment vector)
v_0 <- 0 (Initialize initial 2nd moment vector)
t <- 0 (Initialize timestep)
```
m_t und v_t wird verfolgen eine gleitenden Durchschnitt des Verlaufs und seinen Platz, für jeden Parameter des Netzes. (Also, wenn Sie 1M Parameter, Adam in Erinnerung behalten 2M mehr Parameter)

Bei jeder iteration t, und für jeden parameter des Modells:
```
t <- t + 1
lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t)

m_t <- beta1 * m_{t-1} + (1 - beta1) * gradient
v_t <- beta2 * v_{t-1} + (1 - beta2) * gradient ** 2
variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon)
```
Hier lr_t ein bisschen anders aus learning_rate weil für die ersten Iterationen, die gleitenden Durchschnitte nicht konvergierte doch so haben wir zu normalisieren, indem die Multiplikation durch sqrt(1 - beta2^t) /(1 - beta1^t). Wenn t hoch ist (t > 1./(1.-beta2)), lr_t ist fast gleich learning_rate

Ihre Frage zu beantworten, die Sie gerade brauchen, um passieren eine festen learning rate, halten beta1 und beta2 default-Werte, vielleicht ändern epsilon, und Adam wird die Magie 🙂

Link mit RMSProp

Adam mit beta1=1 entspricht RMSProp mit momentum=0. Das argument beta2 von Adam und das argument decay von RMSProp sind die gleichen.

Jedoch RMSProp nicht halten einen gleitenden Durchschnitt der Steigung. Aber kann es halten eine Dynamik, wie MomentumOptimizer.

Eine detaillierte Beschreibung der rmsprop.
- halten einen Umzug (ermäßigt) Durchschnitt der Quadrate der Gradienten
- teilen Gradienten durch die Wurzel aus der durchschnittlichen
- (halten kann ein momentum)
Hier ist der pseudo-code:
```
v_t <- decay * v_{t-1} + (1-decay) * gradient ** 2
mom = momentum * mom{t-1} + learning_rate * gradient / sqrt(v_t + epsilon)
variable <- variable - mom
```
- Ich hatte nicht realisiert, dass die learning-rate war nicht verwest sondern normalisiert. Also danke für, die.
- Ich sehe. Ja es gibt einen Unterschied zwischen halten eines Impuls und halten Sie einen gleitenden Durchschnitt der Steigung. Danke.
- Ich kann mich irren, aber ist es nicht sqrt(1 - beta1^t) / (1 - beta2^t)?
- Diese Werte sind gemeint, wenn gradient ist konstant bei allen Iterationen, das update zu variable ist auch konstant.
InformationsquelleAutor Olivier Moindrot
2

RMS_PROP und ADAM haben beide adaptive Lern-Preisen .

Die grundlegenden RMS_PROP
```
cache = decay_rate * cache + (1 - decay_rate) * dx**2
x += - learning_rate * dx / (np.sqrt(cache) + eps)
```
Können Sie sehen, ursprünglich war diese hat zwei Parameter decay_rate & eps

Dann können wir hinzufügen, ein Schwung, um unseren gradient mehr stabil, Dann können wir schreiben
```
cache = decay_rate * cache + (1 - decay_rate) * dx**2
**m = beta1*m + (1-beta1)*dx**  [beta1 =momentum parameter in the doc ]
x += - learning_rate * dx / (np.sqrt(cache) + eps)
```
Jetzt Sie sehen können hier, wenn wir weiter beta1 = o, Dann ist es rms_prop ohne Schwung .

Dann Grundlagen der ADAM

In cs-231 Andrej Karpathy hat, beschrieb zunächst den adam, wie dieser

Adam ist ein kürzlich vorgeschlagene Aktualisierung, die ein bisschen aussieht wie RMSProp mit
Dynamik

Also ja ! Was macht dann diesen Unterschied aus der rms_prop mit Schwung ?
```
m = beta1*m + (1-beta1)*dx
v = beta2*v + (1-beta2)*(dx**2)
**x += - learning_rate * m / (np.sqrt(v) + eps)**
```
Er wieder erwähnt Sie in der Update-Gleichung m , v sind mehr glatt .

Also der Unterschied von der rms_prop ist das update weniger laut .

Was macht dieses Geräusch ?

Gut in der Initialisierungs-Prozedur initialisieren wir m und v als null .

m=v=0

Um diese zu senken initialisieren der Effekt-es ist immer einige warm-up . So dann Gleichung ist wie
```
m = beta1*m + (1-beta1)*dx          beta1 -o.9 beta2-0.999
**mt = m / (1-beta1**t)**
v = beta2*v + (1-beta2)*(dx**2)
**vt = v / (1-beta2**t)**
x += - learning_rate * mt / (np.sqrt(vt) + eps)
```
Nun führen wir diese für einige Iterationen . Klar achten Sie auf den Fett dargestellten Linien können Sie sehen, wenn t zunimmt (iteration Nummer) folgende Sache passiert mit der mt ,

mt = m

InformationsquelleAutor Shamane Siriwardhana

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Link mit RMSProp

Eine detaillierte Beschreibung der rmsprop.