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?
Antworten:
Hier ist eine kurze Erklärung, die auf meinem Verständnis basiert:
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.)
(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:
[0.9,1)) des letzten Schritts.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):
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 :
( 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.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.ZB wenn:
i-te Komponente des Gradienten im ersten Schritt ist1.15i-te Komponente des Gradienten im zweiten Schritt ist1.35i-te Komponente des Gradienten im dritten Schritt ist0.9Dann 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:
learning_rate.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.
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 Speichernwvorheriger 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.)
(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).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.
Bei der Auswahl Ihres Optimierers sind einige Aspekte zu berücksichtigen:
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.