Gradient Descent gegen Adagrad gegen Momentum in TensorFlow

Ich lerne TensorFlow und wie man es benutzt, auch wenn ich kein Experte für neuronale Netze und tiefes Lernen bin (nur die Grundlagen).

Nach den Tutorials verstehe ich die tatsächlichen und praktischen Unterschiede zwischen den drei Verlustoptimierern nicht. Ich schaue auf die API und verstehe die Prinzipien, aber meine Fragen sind:

1. Wann ist es vorzuziehen, eine anstelle der anderen zu verwenden?

2. Gibt es wichtige Unterschiede zu wissen?

Hier ist eine kurze Erklärung, die auf meinem Verständnis basiert:

• Der Impuls hilft SGD, in die relevanten Richtungen zu navigieren, und mildert die Schwingungen im Irrelevanten. Es fügt einem aktuellen Schritt einfach einen Bruchteil der Richtung des vorherigen Schritts hinzu. Dies erreicht eine Verstärkung der Geschwindigkeit in die richtige Richtung und mildert die Schwingung in die falschen Richtungen. Diese Fraktion liegt normalerweise im Bereich (0, 1). Es ist auch sinnvoll, adaptiven Impuls zu verwenden. Zu Beginn des Lernens behindert ein großer Impuls nur Ihren Fortschritt. Daher ist es sinnvoll, etwa 0,01 zu verwenden. Wenn alle hohen Gradienten verschwunden sind, können Sie einen größeren Impuls verwenden. Es gibt ein Problem mit der Dynamik: Wenn wir dem Ziel sehr nahe sind, ist unsere Dynamik in den meisten Fällen sehr hoch und es ist nicht bekannt, dass sie sich verlangsamen sollte. Dies kann dazu führen, dass es um die Minima herum verfehlt oder schwingt
• Der beschleunigte Gradient von nesterov überwindet dieses Problem, indem er früh langsamer wird. Im Impuls berechnen wir zuerst den Gradienten und machen dann einen Sprung in diese Richtung, verstärkt durch den Impuls, den wir zuvor hatten. NAG macht dasselbe, aber in einer anderen Reihenfolge: Zuerst machen wir einen großen Sprung basierend auf unseren gespeicherten Informationen, dann berechnen wir den Gradienten und nehmen eine kleine Korrektur vor. Diese scheinbar irrelevante Änderung führt zu erheblichen praktischen Beschleunigungen.
• AdaGrad oder adaptiver Gradient ermöglicht die Anpassung der Lernrate basierend auf Parametern. Es führt größere Aktualisierungen für seltene Parameter und kleinere Aktualisierungen für häufige Parameter durch. Aus diesem Grund eignet es sich gut für spärliche Daten (NLP oder Bilderkennung). Ein weiterer Vorteil besteht darin, dass die Lernrate nicht mehr angepasst werden muss. Jeder Parameter hat seine eigene Lernrate und aufgrund der Besonderheiten des Algorithmus nimmt die Lernrate monoton ab. Dies verursacht das größte Problem: Irgendwann ist die Lernrate so gering, dass das System aufhört zu lernen.
• AdaDelta löst das Problem der monoton sinkenden Lernrate in AdaGrad. In AdaGrad wurde die Lernrate ungefähr als eins geteilt durch die Summe der Quadratwurzeln berechnet. In jeder Phase fügen Sie der Summe eine weitere Quadratwurzel hinzu, wodurch der Nenner ständig zunimmt. In AdaDelta wird anstelle der Summierung aller vergangenen Quadratwurzeln ein Schiebefenster verwendet, mit dem die Summe verringert werden kann. RMSprop ist AdaDelta sehr ähnlich

• Adam oder adaptiver Impuls ist ein Algorithmus ähnlich wie AdaDelta. Zusätzlich zum Speichern der Lernraten für jeden der Parameter werden jedoch auch Impulsänderungen für jeden von ihnen separat gespeichert.

  Ein paar Visualisierungen :

Ich würde sagen, dass SGD, Momentum und Nesterov schlechter sind als die letzten 3.

Salvador Dalis Antwort erklärt bereits die Unterschiede zwischen einigen gängigen Methoden (z. B. Optimierern), aber ich würde versuchen, sie noch näher zu erläutern.
(Beachten Sie, dass unsere Antworten in einigen Punkten nicht übereinstimmen, insbesondere in Bezug auf ADAGRAD.)

Klassischer Impuls (CM) gegen Nesterovs beschleunigten Gradienten (NAG)

(Hauptsächlich basierend auf Abschnitt 2 in der Arbeit über die Bedeutung von Initialisierung und Dynamik beim tiefen Lernen .)

Jeder Schritt in CM und NAG besteht tatsächlich aus zwei Unterschritten:

• Ein Impulsunterschritt - Dies ist einfach ein Bruchteil (normalerweise im Bereich [0.9,1)) des letzten Schritts.
• Ein gradientenabhängiger Teilschritt - Dies ist wie der übliche Schritt bei SGD - er ist das Produkt aus der Lernrate und dem dem Gradienten entgegengesetzten Vektor, während der Gradient dort berechnet wird, wo dieser Teilschritt beginnt.

CM nimmt zuerst den Gradientenunterschritt, während NAG zuerst den Impulsunterschritt nimmt.

Hier ist eine Demonstration aus einer Antwort über die Intuition für CM und NAG :

NAG scheint also besser zu sein (zumindest im Bild), aber warum?

Das Wichtigste ist, dass es keine Rolle spielt, wann der Momentum-Teilschritt kommt - es wäre so oder so dasselbe. Daher können wir uns genauso gut verhalten, wenn der Momentum-Teilschritt bereits ausgeführt wurde.

Die Frage ist also tatsächlich: Unter der Annahme, dass der Gradiententeilschritt nach dem Impulsunterschritt ausgeführt wird, sollten wir den Gradiententeilschritt so berechnen, als ob er an der Position vor oder nach dem Impulsunterschritt begonnen hätte?

"Danach" scheint die richtige Antwort zu sein, da im Allgemeinen der Gradient an einem bestimmten Punkt θungefähr in die Richtung von θeinem Minimum (mit der relativ richtigen Größe) zeigt, während der Gradient an einem anderen Punkt Sie weniger wahrscheinlich zeigt die Richtung von θbis zu einem Minimum (mit der relativ richtigen Größe).

Hier ist eine Demonstration (aus dem GIF unten):

• Das Minimum ist, wo sich der Stern befindet, und die Kurven sind Konturlinien . (Eine Erklärung zu Konturlinien und warum sie senkrecht zum Farbverlauf stehen, finden Sie in den Videos 1 und 2 des legendären 3Blue1Brown .)
• Der (lange) lila Pfeil ist der Impulsunterschritt.
• Der transparente rote Pfeil ist der Gradienten-Unterschritt, wenn er vor dem Impuls-Unterschritt beginnt.
• Der schwarze Pfeil ist der Gradienten-Unterschritt, wenn er nach dem Impuls-Unterschritt beginnt.
• CM würde im Ziel des dunkelroten Pfeils landen.
• NAG würde im Ziel des schwarzen Pfeils landen.

Beachten Sie, dass dieses Argument, warum NAG besser ist, unabhängig davon ist, ob der Algorithmus nahe an einem Minimum liegt.
Im Allgemeinen haben sowohl NAG als auch CM häufig das Problem, mehr Schwung zu sammeln, als für sie gut ist. Wenn sie also die Richtung ändern sollten, haben sie eine peinliche "Reaktionszeit". Der von uns erläuterte Vorteil von NAG gegenüber CM verhindert das Problem nicht, sondern macht die "Reaktionszeit" von NAG nur weniger peinlich (aber immer noch peinlich).

Dieses Problem der "Reaktionszeit" wird im GIF von Alec Radford (der in Salvador Dalis Antwort erschien ) wunderbar demonstriert :

ADAGRAD

( Hauptsächlich basierend auf Abschnitt 2.2.2 in ADADELTA: Eine adaptive Lernratenmethode (das ursprüngliche ADADELTA-Papier), da ich finde, dass es viel zugänglicher ist als adaptive subgradiente Methoden für Online-Lernen und stochastische Optimierung (das ursprüngliche ADAGRAD-Papier).)

In SGD ist der Schritt gegeben durch - learning_rate * gradient, während learning_ratees sich um einen Hyperparameter handelt.
ADAGRAD hat auch einen learning_rateHyperparameter, aber die tatsächliche Lernrate für jede Komponente des Gradienten wird einzeln berechnet.
Die i-te Komponente des t-ten Schritts ist gegeben durch:

              learning_rate 
- --------------------------------------- * gradient_i_t
  norm((gradient_i_1, ..., gradient_i_t))

während:

• gradient_i_kist die i-te Komponente des Gradienten im k-ten Schritt
• (gradient_i_1, ..., gradient_i_t)ist ein Vektor mit tKomponenten. Dies ist (zumindest für mich) nicht intuitiv, dass die Konstruktion eines solchen Vektors sinnvoll ist, aber genau das tut der Algorithmus (konzeptionell).
• norm(vector)ist die eukldische Norm (auch bekannt als l2Norm) von vector, die unser intuitiver Begriff der Länge von ist vector.
• Verwirrenderweise wird in ADAGRAD (wie auch in einigen anderen Methoden) der Ausdruck, der mit gradient_i_t(in diesem Fall learning_rate / norm(...)) multipliziert wird, oft als "Lernrate" bezeichnet (tatsächlich habe ich ihn im vorherigen Absatz "die tatsächliche Lernrate" genannt ). Ich denke, das liegt daran, dass in SGD der learning_rateHyperparameter und dieser Ausdruck ein und dasselbe sind.
• In einer realen Implementierung würde dem Nenner eine Konstante hinzugefügt, um eine Division durch Null zu verhindern.

ZB wenn:

• Die i-te Komponente des Gradienten im ersten Schritt ist1.15
• Die i-te Komponente des Gradienten im zweiten Schritt ist1.35
• Die i-te Komponente des Gradienten im dritten Schritt ist0.9

Dann ist die Norm von (1.15, 1.35, 0.9)die Länge der gelben Linie, die ist :
sqrt(1.15^2 + 1.35^2 + 0.9^2) = 1.989.
Und so ist die i-te Komponente des dritten Schritts:- learning_rate / 1.989 * 0.9

Beachten Sie zwei Dinge über die i-te Komponente des Schritts:

1. Es ist proportional zu learning_rate.
2. Bei den Berechnungen steigt die Norm und damit die Lernrate.

Dies bedeutet, dass ADAGRAD empfindlich auf die Wahl des Hyperparameters reagiert learning_rate.
Außerdem kann es sein, dass die Schritte nach einiger Zeit so klein werden, dass ADAGRAD praktisch stecken bleibt.

ADADELTA und RMSProp

Aus dem ADADELTA-Papier :

Die in diesem Artikel vorgestellte Idee wurde von ADAGRAD abgeleitet, um die beiden Hauptnachteile der Methode zu verbessern: 1) den kontinuierlichen Rückgang der Lernraten während des Trainings und 2) die Notwendigkeit einer manuell ausgewählten globalen Lernrate.

Das Papier erklärt dann eine Verbesserung, die den ersten Nachteil angehen soll:

Anstatt die Summe der quadratischen Gradienten über die gesamte Zeit zu akkumulieren, haben wir das Fenster vergangener Gradienten, die akkumuliert werden, auf eine feste Größe w[...] beschränkt. Dies stellt sicher, dass das Lernen auch nach vielen Iterationen von Aktualisierungen weiter Fortschritte macht.
Da das Speichern wvorheriger quadratischer Gradienten ineffizient ist, implementieren unsere Methoden diese Akkumulation als exponentiell abfallenden Durchschnitt der quadratischen Gradienten.

Mit "exponentiell abfallendem Durchschnitt der quadratischen Gradienten" bedeutet das Papier, dass iwir für jeden einen gewichteten Durchschnitt aller quadratischen i-ten Komponenten aller berechneten Gradienten berechnen.
Das Gewicht jeder quadratischen iKomponente ist größer als das Gewicht der quadratischen iKomponente im vorherigen Schritt.

Dies ist eine Annäherung an ein Fenster mit einer Größe, wda die Gewichte in früheren Schritten sehr klein sind.

(Wenn ich an einen exponentiell abfallenden Durchschnitt denke, stelle ich mir gerne die Spur eines Kometen vor , die immer dunkler wird, je weiter sie vom Kometen entfernt ist:

)

Wenn Sie nur diese Änderung an ADAGRAD vornehmen, erhalten Sie RMSProp, eine Methode, die Geoff Hinton in Vorlesung 6e seiner Coursera-Klasse vorgeschlagen hat .

In RMSProp ist die i-te Komponente des t-ten Schritts also gegeben durch:

                   learning_rate
- ------------------------------------------------ * gradient_i_t
  sqrt(exp_decay_avg_of_squared_grads_i + epsilon)

während:

• epsilon ist ein Hyperparameter, der eine Division durch Null verhindert.
• exp_decay_avg_of_squared_grads_iist ein exponentiell abfallender Durchschnitt der quadratischen iKomponenten aller berechneten Gradienten (einschließlich gradient_i_t).

Wie bereits erwähnt, zielt ADADELTA auch darauf ab, den learning_rateHyperparameter loszuwerden. Es muss also mehr los sein.

In ADADELTA ist die i-te Komponente des t-ten Schritts gegeben durch:

  sqrt(exp_decay_avg_of_squared_steps_i + epsilon)
- ------------------------------------------------ * gradient_i_t
  sqrt(exp_decay_avg_of_squared_grads_i + epsilon) 

während exp_decay_avg_of_squared_steps_iist ein exponentiell abfallender Durchschnitt der quadratischen i-ten Komponenten aller berechneten Schritte (bis zum t-1-ten Schritt).
sqrt(exp_decay_avg_of_squared_steps_i + epsilon)ist dem Impuls etwas ähnlich und wirkt laut dem Papier "als Beschleunigungsterm". (Das Papier gibt auch einen weiteren Grund an, warum es hinzugefügt wurde, aber meine Antwort ist bereits zu lang. Wenn Sie also neugierig sind, lesen Sie Abschnitt 3.2.)

Adam

(Hauptsächlich basierend auf Adam: Eine Methode zur stochastischen Optimierung , dem Original-Adam-Papier.)

Adam ist die Abkürzung für Adaptive Moment Estimation ( eine Erklärung zum Namen finden Sie in dieser Antwort ).
Die i-te Komponente des t-ten Schritts ist gegeben durch:

                   learning_rate
- ------------------------------------------------ * exp_decay_avg_of_grads_i
  sqrt(exp_decay_avg_of_squared_grads_i) + epsilon

während:

• exp_decay_avg_of_grads_iist ein exponentiell abfallender Durchschnitt der i-ten Komponenten aller berechneten Gradienten (einschließlich gradient_i_t).
• Tatsächlich werden beide exp_decay_avg_of_grads_iund exp_decay_avg_of_squared_grads_iauch korrigiert, um eine Tendenz zu berücksichtigen 0(mehr dazu in Abschnitt 3 des Dokuments und auch in stats.stackexchange ).

Beachten Sie, dass Adam einen exponentiell abfallenden Durchschnitt der i-ten Komponenten der Gradienten verwendet, wobei die meisten SGD- Methoden die i-te Komponente des aktuellen Gradienten verwenden. Dies führt dazu, dass sich Adam wie ein "schwerer Ball mit Reibung" verhält, wie in dem Artikel GANs erläutert, die durch eine Zwei-Zeitskalen-Aktualisierungsregel trainiert wurden, die zu einem lokalen Nash-Gleichgewicht konvergieren .
In dieser Antwort erfahren Sie mehr darüber, wie sich Adams impulsartiges Verhalten von dem üblichen impulsartigen Verhalten unterscheidet.

Lassen Sie es uns auf ein paar einfache Fragen reduzieren:

Welcher Optimierer würde mir das beste Ergebnis / die beste Genauigkeit liefern?

Es gibt keine Silberkugel. Einige Optimierer für Ihre Aufgabe würden wahrscheinlich besser funktionieren als die anderen. Es gibt keine Möglichkeit, dies vorher zu sagen. Sie müssen einige ausprobieren, um die beste zu finden. Eine gute Nachricht ist, dass die Ergebnisse verschiedener Optimierer wahrscheinlich nahe beieinander liegen. Sie müssen jedoch die besten Hyperparameter für jeden einzelnen Optimierer finden, den Sie auswählen.

Welchen Optimierer soll ich jetzt verwenden?

Nehmen Sie vielleicht AdamOptimizer und führen Sie es für learning_rate 0.001 und 0.0001 aus. Wenn Sie bessere Ergebnisse erzielen möchten, versuchen Sie, andere Lernraten zu erzielen. Oder probieren Sie andere Optimierer aus und optimieren Sie deren Hyperparameter.

Lange Geschichte

Bei der Auswahl Ihres Optimierers sind einige Aspekte zu berücksichtigen:

• Einfach zu bedienen (dh wie schnell Sie Parameter finden können, die für Sie funktionieren);
• Konvergenzgeschwindigkeit (einfach als SGD oder schneller als jede andere);
• Speicherbedarf (normalerweise zwischen 0 und x2 Ihres Modells);
• Beziehung zu anderen Teilen des Trainingsprozesses.

Einfache SGD ist das absolute Minimum: Sie multipliziert einfach die Gradienten mit der Lernrate und addiert das Ergebnis zu den Gewichten. SGD hat eine Reihe von schönen Eigenschaften: Es hat nur 1 Hyperparameter; es benötigt keinen zusätzlichen Speicher; Es hat nur minimale Auswirkungen auf die anderen Teile des Trainings. Es hat auch zwei Nachteile: Es ist möglicherweise zu empfindlich für die Wahl der Lernrate und das Training kann länger dauern als bei anderen Methoden.

Anhand dieser Nachteile von einfachem SGD können wir erkennen, wofür die komplizierteren Aktualisierungsregeln (Optimierer) gelten: Wir opfern einen Teil unseres Gedächtnisses, um ein schnelleres Training zu erreichen und möglicherweise die Auswahl der Hyperparameter zu vereinfachen.

Der Speicheraufwand ist normalerweise nicht signifikant und kann ignoriert werden. Es sei denn, das Modell ist extrem groß oder Sie trainieren auf GTX760 oder kämpfen um die Führung von ImageNet. Einfachere Methoden wie der Impuls oder der beschleunigte Nesterov-Gradient benötigen eine Modellgröße von 1,0 oder weniger (Größe der Modellhyperparameter). Methoden zweiter Ordnung (Adam benötigt möglicherweise doppelt so viel Speicher und Rechenaufwand.

Konvergenzgeschwindigkeit - so ziemlich alles ist besser als SGD und alles andere ist schwer zu vergleichen. Ein Hinweis könnte sein, dass AdamOptimizer fast sofort ohne Aufwärmen gut mit dem Training beginnen kann.

Ich halte die Benutzerfreundlichkeit für das Wichtigste bei der Auswahl eines Optimierers. Verschiedene Optimierer haben eine unterschiedliche Anzahl von Hyperparametern und eine unterschiedliche Empfindlichkeit für sie. Ich halte Adam für den einfachsten aller leicht verfügbaren. Normalerweise müssen Sie 2-4 Lernraten zwischen überprüfen 0.001und 0.0001herausfinden, ob das Modell gut konvergiert. Zum Vergleich für SGD (und Momentum) versuche ich normalerweise [0.1, 0.01, ... 10e-5]. Adam hat 2 weitere Hyperparameter, die selten geändert werden müssen.

Beziehung zwischen Optimierer und anderen Teilen des Trainings . Bei der Optimierung von Hyperparametern wird normalerweise {learning_rate, weight_decay, batch_size, droupout_rate}gleichzeitig ausgewählt. Alle von ihnen sind miteinander verbunden und können als eine Form der Modellregulierung angesehen werden. Man muss zum Beispiel genau aufpassen, wenn genau weight_decay oder L2-Norm verwendet wird und möglicherweise AdamWOptimizerstattdessen wählen AdamOptimizer.