[PYTHON] Einführung in OPTIMIZER ~ Von der linearen Regression über Adam bis Eva

Über diesen Artikel

Einführung in den Optimierer für maschinelles Lernen.

Introduction Beginnen wir mit dem Beispiel der linearen Regression, das Sie alle lieben. Meistens fügen Sie Daten beiläufig in ein maschinelles Lernpaket ein und erhalten es am Ende. Möglicherweise bemerken Sie nicht einmal, dass der Optimierer im Paket zappelt. Aber sie sind da.

Eine kleine Theorie

Nehmen wir nun an, die Zielvariable ist $ y $, die erklärende Variable ist $ X $ und der Regressionskoeffizient ist $ w $, obwohl er etwas abrupt ist. In der linearen Regression wollen wir die Zielvariable mit einer linearen Kombination erklärender Variablen approximieren. Das ist,

y \sim Xw \tag{1.1}

Wir wollen den Koeffizienten $ w $ so "gut" wie möglich bestimmen. Hier werden $ y $ und $ w $ als vertikale Vektoren behandelt, und $ X $ wird als Matrix behandelt. Wenn die Anzahl der Datenproben $ N $ und die Anzahl der erklärenden Variablen $ M $ ist, dann ist $ y $ die Dimension $ N $, $ w $ ist die Dimension $ M $ und $ X $ ist die Dimension $ N \ times M $. ist. Bitte beachten Sie, dass dieser Artikel der Einfachheit halber keine konstanten Begriffe enthält. Sie müssen die Verlustfunktion einstellen, um $ w $ "gut" zu bestimmen. Quadratischer Fehler

L(w) := (y-Xw)^2 \tag{1.2}

Ist typisch, also werde ich es benutzen. Um den Wert von $ w $ zu finden, der die Verlustfunktion $ L $ minimiert, ist es in Ordnung, zu differenzieren und den Punkt zu finden, an dem "= 0" ist. Lassen Sie uns also differenzieren.

\frac{\partial L }{\partial w} = -2(X^Ty-X^TXw)=0 \tag{1.3}

Als,

w=\big(X^TX\big)^{-1}X^Ty \tag{1.4}

Es kann erhalten werden. $ X ^ T $ ist eine transponierte Matrix von $ X $. Das löst alles. Wenn Sie danach denken, dass es in Ordnung ist, $ X $ und $ y $ mechanisch in (1.4) zu werfen, ist dies ein großer Fehler. Erstens ist (1.4) bedeutungslos, wenn die Umkehrung von $ X ^ TX $ nicht existiert. Betrachten wir ein konkretes Beispiel. Versuchen Sie die Einstellung wie folgt.

X=\begin{pmatrix}
1 & 1 & 1 \\
1 & 2 & 3
\end{pmatrix},\;
y=\begin{pmatrix}
0\\1
\end{pmatrix},\;
w=\begin{pmatrix}
a\\b\\c
\end{pmatrix} \tag{1.5}

In diesem Fall, wenn Sie versuchen, $ X ^ TX $ konkret zu berechnen

X^TX=
\begin{pmatrix}
1 & 1 \\
1 & 2 \\
1 & 3 \\
\end{pmatrix}
\begin{pmatrix}
1 & 1 & 1 \\
1 & 2 & 3
\end{pmatrix}
=
\begin{pmatrix}
2 & 3 & 4 \\
3 & 5 & 7 \\
4 & 7 & 10 
\end{pmatrix} \tag{1.6}

Es ist geworden. Wenn Sie auch nach der Matrixformel fragen

\text{det}\big(X^TX\big) = 0 \tag{1.7}

Es stellt sich heraus, dass es keine inverse Matrix gibt. Existiert dann die Lösung von (1.3) nicht? Das ist nicht wahr. Im Gegenteil, es gibt unzählige. Unter der Einstellung von (1.5) ist (1.1) eine Simultangleichung

a+b+c=0, \;\; a+2b+3c=1 \tag{1.8}

Ist äquivalent zu Da es jedoch zwei Gleichungen für drei Variablen gibt, kann die Lösung nicht eindeutig bestimmt werden. Wenn Sie $ a $ und $ b $ für $ c $ lösen, eine Reihe von Lösungen mit $ c $ als Parameter.

a=c-1, \;\; b=1-2c \tag{1.9}

Es kann erhalten werden.

Versuchen Sie es mit dem Paket

Haben Sie hier irgendwelche Zweifel? Was wird zurückgegeben, wenn Sie es mit der Einstellung (1.5) in das Paket für maschinelles Lernen werfen? Machen wir das. Verwenden Sie Python.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from mpl_toolkits.mplot3d import Axes3D
sns.set_context('poster')

Erstellen Sie die Daten entsprechend (1.5).

X = np.array([[1, 1, 1],[1, 2, 3]])
y = np.array([[0],[1]])

Ich werde es in Scikit-Learn werfen.

from sklearn.linear_model import LinearRegression
np.random.seed(0)
model = LinearRegression(fit_intercept=False)
model.fit(X,y)

Lassen Sie uns den Regressionskoeffizienten nach dem Lernen anzeigen.

model.coef_

Die Ergebnisse sind $ a = -0,5 $, $ b = 0 $, $ c = 0,5 $. Es trifft sicherlich (1.8), also ist es sicherlich eines von (1.9). Da es jedoch keine inverse Matrix von $ X ^ TX $ gibt, ist es sicher, dass sie nicht basierend auf (1.4) berechnet wurde. Also was ist passiert?

Gradient Decent Lassen Sie uns etwas allgemeiner sprechen, nicht nur lineare Regression. Angenommen, Sie möchten den minimalen (oder maximalen) Wert einer Funktion $ f (x) $ kennen. Das Argument $ x $ ist ein Vektor. Fixieren Sie an einem bestimmten Punkt ein $ x_0 $ und berücksichtigen Sie eine kleine Schwankung $ x_0 $ → $ x_0 + \ Delta x $ um $ x_0 $. Wenn Sie erweitern, indem Sie bis zum Term erster Ordnung von $ \ Delta x $ belassen

f(x_0+\Delta x)\simeq f(x_0)+\Delta x \cdot \frac{\partial f}{\partial x} (x_0) \tag{1.10}

Kann geschrieben werden. "$ \ Cdot $" repräsentiert das innere Produkt der Vektoren. Übrigens, wenn die Richtung von $ \ Delta x $ auf verschiedene Weise geändert wird, wenn der Änderungsbetrag von $ f (x) $ in Richtung des kleinsten (oder größeren) fortschreitet, wird der minimale Wert (oder der maximale Wert) gut gesucht. Ich denke ich kann es schaffen. Zu diesem Zweck sollte das innere Produkt minimiert (oder maximiert) werden.

\Delta x \propto \mp \frac{\partial f}{\partial x} (x_0) \tag{1.11}

Es sollte sein. Mit anderen Worten, wenn Sie den Mindestwert ermitteln möchten, setzen Sie den Zeitschritt-Index auf $ t $, nachdem Sie die Anfangsposition entsprechend festgelegt haben.

x_{t+1} = x_{t} -\eta \frac{\partial f}{\partial x}(x_t) \tag{1.12}

Sie müssen die Suche nur nacheinander so wiederholen. $ \ eta $ ist eine Konstante namens Lernrate, bei der Sie manuell einen "kleinen" positiven Wert festlegen. Dies ist eine Technik namens Gradient Decent, die der grundlegendste Optimierer ist. Im Fall der linearen Regression (1.1), wenn Sie die Aktualisierungsformel von Gradient Decent aufschreiben

\begin{align}
w_{t+1} &= w_t - \eta \frac{\partial L}{\partial w}(w_t) \\
        &= w_t - \eta \big[-2(X^Ty-X^TXw_t) \big] \tag{1.13}
\end{align}

Und die Umkehrung von $ X ^ TX $ wird nicht benötigt. Auch die Existenz unzähliger Lösungen in (1.9) entspricht dem Anfangswert der Suche.

Lassen Sie uns eine lineare Regression basierend auf (1.13) implementieren.

class LR_GradientDecent(object):
    
    def __init__(self, lr=0.01, n_iter=100, seed=0):
        self.lr = lr # learning rate
        self.n_iter = n_iter # number of iterations
        self.seed = seed # seed for initializing coefficients
        
    def fit(self, X, y):
        np.random.seed(self.seed)
        self.w = np.random.uniform(low=-1.0, high=1.0, size=(X.shape[1], 1)) # initializing coefficients
        self.loss_arr = np.array([])
        for _ in range(self.n_iter):
            self.loss_arr = np.append(self.loss_arr, (y-X.dot(self.w)).T.dot(y-X.dot(self.w)).flatten(), axis=0)
            dw = -2*(X.T.dot(y)-X.T.dot(X).dot(self.w)) # derivatives of the loss function
            self.w -= self.lr * dw # up-date coefficients
            
    def pred(self, X):
        return X.dot(self.w)

Ich werde es versuchen.

model = LR_GradientDecent(n_iter=1000)
model.fit(X,y)

Zeichnen wir die Änderung des Wertes der Verlustfunktion während des Trainings.

plt.plot(model.loss_arr)
plt.xlabel('Number of Iterations')
plt.ylabel('Error')

Schauen wir uns auch den Regressionskoeffizienten an.

model.w.flatten()

coefs = []
err = []
for seed in range(200):
    model = LR_GradientDecent(n_iter=1000, seed=seed)
    model.fit(X, y)
    coefs.append(model.w.flatten())
    err.append(model.loss_arr[-1])
df_sol = pd.DataFrame(coefs)
df_sol.columns = ['a', 'b', 'c']
df_sol['error'] = err

df_sol

Es ist ersichtlich, dass der Konvergenzwert des Regressionskoeffizienten in Abhängigkeit davon, wie der Anfangswert genommen wird, völlig unterschiedlich ist. Dies ist die sogenannte Anfangswertabhängigkeit. Zeichnen Sie als nächstes den erhaltenen Regressionskoeffizienten $ (a, b, c) $ auf eine dreidimensionale Karte.

fig = plt.figure()
ax = Axes3D(fig)
# solutions found by gradient decent
ax.plot(df_sol['a'], df_sol['b'], df_sol['c'], 'o', ms=4, mew=0.5)
# exact solutions
c = np.linspace(0, 1, 100)
a = np.array([i - 1 for i in c])
b = np.array([1-2*i for i in c])
ax.plot(a, b, c, color='yellow', ms=4, mew=0.5, alpha=0.4)
#ax.set_xlim(-1,0)
#ax.set_ylim(-1,1)
#ax.set_zlim(0,1)
#ax.set_xlabel('a')
#ax.set_ylabel('b')
#ax.set_zlabel('c')
ax.view_init(elev=30, azim=45)
plt.show()

In der obigen Abbildung zeigt der blaue Kreis den Regressionskoeffizienten, der durch Schwingen des Anfangswertes erhalten wird, und die hellgelbe Linie zeigt die genaue Lösung (1.9). Durch Schütteln des Anfangswertes können Sie sehen, wie die blauen Kreise auf der gelben Linie verteilt sind.

Eine letzte Sache. Tatsächlich verwendet die LinearRegression von scikit-learn nicht das Gradient Decent-Update (1.13). Ich bin nicht mit den internen Umständen des Scikit-Lernens vertraut, aber als ich mir den Quellcode ansah, hatte ich das Gefühl, dass ein Algorithmus zum Lösen linearer Gleichungen namens LSQR verwendet wurde. Dieser Algorithmus sucht auch nach dem Minimalwert, indem er die iterative Suche wiederholt, aber der Regressionskoeffizient, der durch Berühren des Startwerts erhalten wird, hat sich nicht geändert, wahrscheinlich weil der Anfangswert angegeben wurde. Wenn ich so denke, wenn ich die Daten in das lineare Regressionspaket einfüge und das Ergebnis zurückgegeben wird, habe ich das Gefühl, einen Job beendet zu haben, aber ich frage mich, ob ich eine wirklich aussagekräftige Antwort bekomme. In diesem Artikel möchte ich die Nachfolger von Gradient Decent aus einer allgemeineren Perspektive als einem modellspezifischen Algorithmus vorstellen.

Stochastic Gradient Decent (SGD) Nun, im vorherigen Kapitel haben wir Gradient Decent vorgestellt, bei dem es sich um die Stapelverarbeitung handelte. Mit anderen Worten, alle Daten werden zusammen für jeden 1-Schritt verarbeitet. Im vorherigen Beispiel gab es nur zwei Datenproben, sodass es kein Problem gab. Mit zunehmender Datenmenge wird die Stapelverarbeitung jedoch schwierig. Es ist möglicherweise auch nicht möglich, alle Daten zusammen zu verwenden, z. B. in einem Online-Datenstrom. Daher benötigen wir eine Methode, um Gradient Decent nacheinander zu verarbeiten. Diese werden als Stochastic Gradient Decent (SGD) bezeichnet. Abhängig von der Größe des zu verarbeitenden Klumpens kann er für jede 1 Probe oder in einer bestimmten Einheit (Mini-Charge) verarbeitet werden. Im Allgemeinen ist die Verlustfunktion $ L $ die Summe jeder Datenprobe.

L=\sum_{n=1}^NL_n \tag{2.1}

Daher wird bei der Verarbeitung von 1 Probe für Probe der Algorithmus von (1.12) nacheinander auf jedes $ L_n $ angewendet. Bei der Mini-Batch-Verarbeitung wird der Aktualisierungsalgorithmus für die Summe $ \ sum_ {n \ in \ text {Mini-Batch}} L_n $ der im Mini-Batch enthaltenen Proben verwendet. Übrigens hat SGD auch einige Vorteile, die Gradient Decent nicht hat. In Gradient Decent besteht eine hohe Wahrscheinlichkeit, dass Sie in der lokalen Lösung stecken bleiben und nicht aus dieser herauskommen können. In SGD ist es jedoch wahrscheinlicher, dass Sie aus der lokalen Lösung herauskommen, indem Sie Daten austauschen und den Suchpfad schütteln. Es scheint jedoch, dass die Mini-Batch-Verarbeitung bevorzugt wird, da die 1-Proben-Verarbeitung zu stark wackelt und sich die Konvergenz der Berechnung verschlechtert.

Der folgende Inhalt ist eine allgemeine Geschichte, die nicht davon abhängt, ob alle Daten auf einmal, 1 Probe für Probe oder Mini-Batch verarbeitet werden sollen. Daher habe ich beschlossen, die Verlustfunktion nur als $ L $ zu schreiben. Ich werde.

Nachfolger von SGD

SGD ist ein sehr einfacher Algorithmus, aber die Leistung leidet, wenn die Verlustfunktion komplexer wird. Daher wurden verschiedene Algorithmen vorgeschlagen, die die SGD verbessern. Von hier aus möchte ich eine typische Methode vorstellen.

Momentum SGD Betrachten Sie beispielsweise die folgende Verlustfunktion. Bitte sehen Sie zuerst die Abbildung links.

SGD	Momentum SGD

Angenommen, die schwarze Linie repräsentiert die Konturlinie der Verlustfunktion und die violette Sternmarkierung ist der Mindestwert. Gemäß der Aktualisierungsformel von Gradient Decent (1.12) beginnt die Zick-Zack-Bewegung, weil die Neigung in Richtung des Minimums gedrückt wird und es schwierig ist, die Zielsternmarke zu erreichen. Wenn Sie jedoch genau hinschauen, scheint es, dass wenn Sie den "Durchschnitt" des hin und her gehenden Teils nehmen, die Zickzackbewegung versetzt wird und Sie eine Vorwärtsantriebskraft erhalten (blauer Pfeil in der rechten Abbildung). Dies ist die Idee von Momentum SGD. Wenn in einer Formel geschrieben,

\begin{align}
& m_t = \gamma m_{t-1} + \eta \frac{\partial L}{\partial w}(w_t)　\tag{3.1}\\
& w_{t+1} = w_t - m_t \tag{3.2}
\end{align}

Es wird sein. Setzen Sie den Anfangswert von $ m_t $ auf $ m_0 = 0 $. $ M $ in (3.1) dient dazu, die Zick-Zack-Bewegung in einem Term namens Momentum auszugleichen. Wenn Sie $ g_t ^ {\ eta} setzen: = \ eta \ frac {\ partielles L} {\ partielles w} (w_t) $, ist (3.1)

m_t=g_t^{\eta} + \gamma g_{t-1}^{\eta} + \gamma^2 g_{t-2}^{\eta} + \gamma^3 g_{t-3}^{\eta} + \cdots \tag{3.3}

Da es umgeschrieben werden kann als, können Sie sehen, dass die vergangenen Garadienteninformationen mit der Dämpfungsrate $ \ gamma $ akkumuliert werden. Das Ersetzen von $ m_t $ durch $ g_t ^ \ eta $ in (3.2) wird auf SGD zurückgesetzt. Es scheint, dass $ \ gamma $ oft auf ungefähr 0,9 $ gesetzt ist.

Nesterov accelerated gradient（NAG） Der beschleunigte Nesterov-Gradient (NAG) ist eine leicht modifizierte Version von Momentum SGD. In der vorherigen Abbildung war der lila Stern das Ziel. Selbst wenn ich die Zick-Zack-Bewegung unterdrücke, mache ich mir Sorgen, dass sie am Ziel richtig anhält. Kurz vor Ihrer Ankunft wäre es schön, wenn Sie Ihr Ziel vorhersagen und die Bremsen betätigen könnten. Also die Update-Formel

\begin{align}
& m_t = \gamma m_{t-1} + \eta \frac{\partial L}{\partial w}(w_t - m_{t-1})　\tag{3.4}\\
& w_{t+1} = w_t - m_t \tag{3.5}
\end{align}

Ich werde versuchen. (3.4) Beachten Sie, dass die Auswertung des Gradienten auf der rechten Seite nicht der aktuelle Punkt $ w_t $ ist, sondern der erwartete Bewegungspunkt $ w_t --m_ {t-1} $. Der Zeitschritt von $ m $ ist $ t-1 $, da $ m_t $ selbst nicht zum Konstruieren von $ m_t $ verwendet werden kann, sondern nur ein "vorhergesagter" Bewegungspunkt ist.

AdaGrad AdaGrad basiert auf SGD, entwickelt jedoch eine andere Lernrate für jede Komponente des Lernparameters $ w $ und eine höhere Lernrate für die weniger aktualisierten Komponenten. Nachfolgend zur Vereinfachung der Symbole

g^t_i:=\frac{\partial L}{\partial w_i}(w^t) \tag{3.6}

Übrigens schreibe ich den Zeitschritt-Index $ t $ in die obere rechte Ecke. $ i $ ist ein Index, der die Komponenten des Vektors $ w $ angibt. Der Update-Algorithmus von AdaGrad ist unten angegeben

\begin{align}
& v^t_i = v^{t-1}_i + (g^t_i)^2 \tag{3.7} \\
& w^{t+1}_i = w^t_i - \frac{\eta}{\sqrt{v^t_i} + \epsilon} g^t_i　\tag{3.8}
\end{align}

Setzen Sie den Anfangswert von $ v $ auf $ v_i ^ 0 = 0 $. $ \ eta $ ist eine manuell gegebene Konstante, die auch als Lernrate bezeichnet wird. $ \ Epsilon $ legt einen kleinen Wert fest, um eine Division durch $ 0 $ zu verhindern. Außerdem stammt $ v ^ t_i $ aus (3.7)

v^t_i = (g^t_i)^2 + (g^{t-2}_i)^2 + (g^{t-3}_i)^2 + \cdots \tag{3.9}

Für Lernparameter, die nicht sehr oft aktualisiert werden, ist der Wert von $ v ^ t_i $ klein und die tatsächliche Lernrate $ \ eta / (\ sqrt {v ^ t_i} + \ epsilon) $ ist groß. Werden. Wenn Sie die Quadratwurzel "$ \ sqrt {\ cdot} $", die an $ v ^ t_i $ angehängt ist, nicht hinzufügen, wird die Leistung beeinträchtigt.

RMSprop In AdaGrad nimmt, wie in (3.9) gezeigt, die tatsächliche Lernrate ab, wenn die Aktualisierung wiederholt wird und die Wertaktualisierung stoppt. Der Zweck von RMSprop ist es, dies zu verhindern. Anstatt alle vergangenen Informationen zu akkumulieren, werden wir vergangene Akkumulationen und neueste Informationen in einem Verhältnis von $ \ gamma: 1- \ gamma $ akkumulieren. Das heißt, der Aktualisierungsalgorithmus sieht folgendermaßen aus:

\begin{align}
& v^t_i = \gamma v^{t-1}_i + (1-\gamma)(g^t_i)^2 \tag{3.10} \\
& w^{t+1}_i = w^t_i - \frac{\eta}{\sqrt{v^t_i}+\epsilon} g^t_i　\tag{3.11}
\end{align}

Setzen Sie den Anfangswert von $ v $ auf $ v_i ^ 0 = 0 $. Wenn Sie neu schreiben (3.10)

v^t_i=\gamma^t v^0_i + (1-\gamma)\sum_{l=1}^t \gamma^{t-l}(g^l_i)^2 \tag{3.12}

Daher kann bestätigt werden, dass vergangene Informationen akkumuliert werden, während sie exponentiell abnehmen, und es handelt sich um eine Art Mittelungsmethode, die als mobile Indexmittelung bezeichnet wird.

AdaDelta AdaDelta scheint unabhängig von RMSprop vorgeschlagen worden zu sein, ist jedoch funktional eine weitere Modifikation von RMSprop. Der Punkt besteht darin, die Suchentfernung zu vergrößern, wenn der Lernparameter den nicht durchsuchten Bereich betritt. Der Update-Algorithmus sieht folgendermaßen aus:

\begin{align}
& v^t_i = \gamma v^{t-1}_i + (1-\gamma)(g^t_i)^2 \tag{3.13} \\
& s^t_i = \gamma s^{t-1}_i + (1-\gamma)(\Delta w^{t-1}_i)^2 \tag{3.14} \\
& \Delta w^t_i = -\frac{\sqrt{s^t_i + \epsilon}}{\sqrt{v^t_i + \epsilon}} g^t_i \tag{3.15} \\
& w^{t+1}_i = w^t_i + \Delta w^t_i　\tag{3.16}
\end{align}

Setzen Sie die Anfangswerte auf $ v_i ^ 0 = 0 $ und $ s_i ^ 0 = 0 $. In (3.15) ist $ s ^ t $ anstelle von $ \ eta $ enthalten. Wenn $ w ^ t_i $ erheblich aktualisiert wird, wird ein nicht durchsuchter Bereich betreten, aber (3.14) aktualisiert auch $ s ^ t_i $ erheblich, sodass die Suchentfernung vergrößert werden soll. Ich sehe manchmal Ausdrücke, die den Lernratenparameter enthalten.

Adam Adam sieht aus wie eine Kombination aus RMSprop und der Momentum-Methode. Der Aktualisierungsalgorithmus wird wie folgt angegeben

\begin{align}
& m^t_i = \beta_1 m^{t-1}_i + (1-\beta_1)g^t_i \tag{3.17} \\
& v^t_i = \beta_2 v^{t-1}_i + (1-\beta_2)(g^t_i)^2 \tag{3.18} \\
& \hat{m}^t_i = \frac{m^t_i}{1-\beta_1^t} \tag{3.19} \\
& \hat{v}^t_i = \frac{v^t_i}{1-\beta_2^t} \tag{3.20} \\
& w^{t+1}_i = w^t_i - \frac{\eta}{\sqrt{\hat{v}^t_i}+\epsilon} \hat{m}^t_i　\tag{3.21}
\end{align}

Setzen Sie die Anfangswerte auf $ v_i ^ 0 = 0 $ und $ m_i ^ 0 = 0 $. (3.17)

m^t_i=\beta_1^tm_0 + (1-\beta_1)\sum_{k=1}^t \beta_1^{t-k}g^k_i \tag{3.22}

Ersetzen Sie nach dem Umschreiben den Anfangswert $ m_0 = 0 $ und vergleichen Sie die Bestellungen auf beiden Seiten mit der Reihenfolge von $ g ^ k_i $ als $ g ^ k_i \ sim O [g] $.

O[m] \sim O[g](1-\beta_1) \sum_{k=1}^t \beta_1^{t-k} = O[g](1-\beta_1^t) \tag{3.23}

Es wird sein. Erstens wurde $ m ^ t $ mit der Erwartung eingeführt, dass es der "Durchschnitt" von $ g ^ t $ ist, so dass es unangenehm erscheint, dass eine Abweichung von $ 1- \ beta_1 ^ t $ auftritt. ist. Insbesondere wenn es $ \ beta_1 ^ t \ sim 0 $ ist, wird es zu $ O [m] \ sim 0 $. (3.19) ist die Korrektur dafür. Die Korrektur in (3.20) hat den gleichen Grund.

Eve Eva ist eine Methode, die als Aufwärtskompatibilität mit Adam um November 2016 vorgeschlagen wird. Es wurde darauf hingewiesen, dass es wahrscheinlicher ist, dass flache Bereiche, die als Sattelpunkte und Plateau bezeichnet werden, das Lernen behindern, wenn die Verlustfunktion kompliziert wird, insbesondere beim tiefen Lernen, anstatt im lokalen Mindestwert zu stecken. Ich werde. Da SGD jedoch nur die Informationen zur Differenzierung der Verlustfunktion erster Ordnung verwendet, gibt es einige Aspekte, die nicht behandelt werden können. Daher verwendet Eve direkt die Schwankung der Verlustfunktion, die mit der Aktualisierung der Trainingsparameter einhergeht. Wenn das Ausmaß der Fluktuation gering ist, ist es sehr wahrscheinlich, dass Sie im Sattelpunkt / Plateau gefangen sind und der Suchabstand für Lernparameter erweitert wird. Die anderen Schritte sind die gleichen wie bei Adam und der Aktualisierungsalgorithmus lautet wie folgt.

\begin{align}
& m^t_i = \beta_1 m^{t-1}_i + (1-\beta_1)g^t_i \tag{3.24} \\
& v^t_i = \beta_2 v^{t-1}_i + (1-\beta_2)(g^t_i)^2 \tag{3.25} \\
& \hat{m}^t_i = \frac{m^t_i}{1-\beta_1^t} \tag{3.26} \\
& \hat{v}^t_i = \frac{v^t_i}{1-\beta_2^t} \tag{3.27} \\
& r^t = (\text{feed-back from the loss function}) \tag{3.28} \\
& d^t = \beta_3 d_{t-1} + (1-\beta_3) r^t \tag{3.29} \\
& w^{t+1}_i = w^t_i - \frac{\eta}{d^t \sqrt{\hat{v}^t_i}+\epsilon} \hat{m}^t_i　\tag{3.30}
\end{align}

Der Punkt ist, wie man konfiguriert (3.28). (3.29) ist der gleitende Indexdurchschnitt der vergangenen Rückmeldung und der letzten Rückmeldung und wird im Nenner von (3.30) addiert. Setzen Sie den Anfangswert von $ d $ auf $ d ^ 0 = 1 $. Kommen wir nun zur Erklärung von (3.28). Definieren Sie zunächst $ L ^ t: = L (w ^ t) $ für die Verlustfunktion $ L (w) $. Grundsätzlich ist der nicht negative Änderungsbetrag von $ L $ $ \ frac {L ^ {t} -L ^ {t-1}} {L ^ {t-1}} $ ($ L ^ t> L ^ {t -1} $), $ \ frac {L ^ {t-1} -L ^ {t}} {L ^ {t}} $ ($ L ^ {t-1}> L ^ t $ ) Wird als $ r ^ t $ verwendet, aber die Berechnung ist aufgrund springender Werte möglicherweise nicht stabil. Setzen Sie daher einen geeigneten Satz von Konstanten $ 0 <k <K $ und $ k <r ^ Es wird gerundet, so dass t <K $ ist. Dem Papier zufolge scheint diese einfache Methode jedoch nicht zu funktionieren, und Eve unternimmt die folgenden Schritte: Erstens gilt für $ L ^ 0 = L (w ^ 0) $ $ [\ frac {L ^ 0} {K + 1}, \ frac {L ^ 0} {k + 1}] $ (in der Abbildung) ②), $ [(k + 1) L ^ 0, (K + 1) L ^ 0] $ (⑤ in der Figur). Schneiden Sie außerdem den Abschnitt mit $ L ^ 0 $ als Grenze aus, wie in der Abbildung gezeigt.

\frac{\partial f}{\partial x}(x_0+\Delta x)\simeq \frac{\partial f}{\partial x}(x_0)+ \frac{\partial f}{\partial x \partial x}(x_0) \Delta x \tag{4.1}

\Delta x = - \Big[\frac{\partial f}{\partial x \partial x}(x_0)\Big]^{-1}\frac{\partial f}{\partial x}(x_0) \tag{4.2}

x_{t+1} = x_t -\Big[\frac{\partial f}{\partial x \partial x}(x_t)\Big]^{-1}\frac{\partial f}{\partial x}(x_t) \tag{4.3}