Deep Learning von Grund auf neu Kapitel 6

Sag nicht Deep Learning Dieses Kapitel 6 befasst sich mit sehr wichtigen Dingen des maschinellen Lernens.

Parameteraktualisierung

Zweck des neuronalen Netzwerks = Finden von Parametern, die den Wert der Verlustfunktion so klein wie möglich machen Das Lösen solcher Probleme wird als "Optimierung" bezeichnet.

SGD: Probabilistische Gradientenabstiegsmethode


W \leftarrow  W - \eta\frac{\partial L}{\partial W}

class SGD:
    def __init__(self, lr=0.01):
        self.lr = lr
    
    def update(self, params, grads):
        for key in params.keys():
            params[key] -= self.lr * grads[key]
            
    network = TwoLayerNet(...)



#optimizer:Die Person, die optimiert
optimizer = SGD()

for i in range(10000) :
	    ...
	x_bath, t_bath = get_mini_batch(...)
    grads = network.gradient(x_batch, t_batch)
    params = network.params
    optimizer.update(params, grads)
    ...

Die Parameter werden vom Opetimizer aktualisiert Sie müssen lediglich die Parameter- und Verlaufsinformationen an den Optimierer übergeben

Durch die separate Implementierung der Optimierungsklasse wie oben beschrieben wird es einfacher, die Funktion zu modularisieren.

Wenn Sie beispielsweise eine andere Optimierungsmethode namens Momentum implementieren, die als Nächstes angezeigt wird, implementieren Sie sie so, dass sie auch eine allgemeine Methode namens update (params, grads) enthält. Dann können Sie SGD auf Momentum umschalten, indem Sie optimizer = SGD () in optimizer = Momentum () ändern.

Nachteile von SGD

Der Nachteil von SGD besteht darin, dass, wenn die Form der Funktion nicht isotrop erscheint, sie auf einem ineffizienten Weg gesucht wird (wenn es sich um eine längliche Funktion handelt).

Die Hauptursache für die obigen Nachteile ist, dass die Richtung des Gradienten auf eine andere Richtung als den ursprünglichen Mindestwert zeigt.

Kobito.a81EO2.png

Um diesen Mangel an SGD zu verbessern, werden drei Methoden als alternative Methoden zu SGD eingeführt. · Schwung ・ AdaGrad · Adam

Momentum

Momentum ist "Momentum" Ein Bild einer Kugel, die auf dem Boden rollt und sich aufgrund von Reibung oder Luftwiderstand allmählich verlangsamt, wenn sie keine Kraft erhält

v \leftarrow  \alpha v - \eta\frac{\partial L}{\partial W}\\

W \leftarrow  W + v

class Momentum:
	def __init__(self, lr=0.01, momentum=0.9): 
		self.lr = lr
		self.momentum = momentum
		self.v = None
		
	def update(self, params, grads):
		if self.v is None:
			self.v = {}
			for key, val in params.items():
				self.v[key] = np.zeros_like(val)
				
		for key in params.keys():
			self.v[key] = self.momentum*self.v[key] - self.lr * grads[key]
			param[key] += self.v[key]

Kobito.g9jOgk.png

x-Achsenrichtung: Die empfangene Kraft ist gering, aber da die Kraft immer in die gleiche Richtung gerichtet ist, beschleunigt sie konstant in die gleiche Richtung. Richtung der y-Achse: Die empfangene Kraft ist groß, aber die positiven und negativen Kräfte werden abwechselnd empfangen und gesungen, wobei sie sich gegenseitig aufheben, und die Geschwindigkeit zur y-Achse ist nicht stabil. → Sie können schneller als SGD näher an die Richtung der x-Achse heranrücken und die Zick-Zack-Bewegung reduzieren.

AdaGrad

Diese Methode reduziert die Lernrate Dies ist eine Methode zur Reduzierung des Lernkoeffizienten im Verlauf des Lernens. Ada: Abgeleitet von Adaptive Adaptive

h \leftarrow  h + \frac{\partial L}{\partial W}\odot\frac{\partial L}{\partial W}\\

W \leftarrow  W - \eta \frac{1}{\sqrt{h}} \frac{\partial L}{\partial W}

Das Multiplizieren von 1 / √h bedeutet, dass die Elemente, die sich in der Parameteraktualisierung gut bewegen (weitgehend aktualisiert), einen kleineren Lernkoeffizienten haben.

class AdaGrad:
	def __init__(self, lr=0.01): 
		self.lr = lr
		self.h = None
		
	def update(self, params, grads):
		if self.h is None:
			self.h = {}
			for key, val in params.items():
				self.h[key] = np.zeros_like(val)
				
		for key in params.keys():
			self.h[key] += grads[key] * grads[key]
			param[key] += self.lr * grads[key] / (np.sqrt(self.h[key] + le-7)

Der kleine Wert le-7 wird addiert, denn wenn in self.h [key] 0 vorhanden ist, wird er durch 0 geteilt.

RMSProp AdaGrad zeichnet alle vergangenen Farbverläufe als Quadratsumme auf Wenn Sie also unendlich viel lernen, beträgt die Verlängerungsgebühr 0 und wird überhaupt nicht verlängert.

Es gibt auch eine andere Methode als RMS Drop, mit der dieses Problem gelöst wurde RMS Prop ist eine Methode, die so berechnet wird, dass die vergangenen Gradienten allmählich vergessen werden und die neuen Gradienteninformationen stark reflektiert werden, anstatt alle Gradienten einheitlich hinzuzufügen. Dies wird als "exponentieller gleitender Durchschnitt" bezeichnet.

Es gibt keine Formel im Buch, aber es sieht aus wie diese Formel, wenn man aus dem Programm zurückrechnet

\begin{align}
Anfangswert d&=0.99\\
h &\leftarrow  h * d + (1 - d)\frac{\partial L}{\partial W}\odot\frac{\partial L}{\partial W}\\

W &\leftarrow  W - \eta \frac{1}{\sqrt{h}} \frac{\partial L}{\partial W}
\end{align}

class RMSprop:

    """RMSprop"""

    def __init__(self, lr=0.01, decay_rate = 0.99):
        self.lr = lr
        self.decay_rate = decay_rate
        self.h = None
        
    def update(self, params, grads):
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)
            
        for key in params.keys():
            self.h[key] *= self.decay_rate
            self.h[key] += (1 - self.decay_rate) * grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)

Adam

Impuls: Bewegung nach den Gesetzen der Physik AdaGrad: Passen Sie die Aktualisierungsschritte für jedes Element des Parameters adaptiv an

Adam = Momentum + AdaGrad + Hyperparameter "Bias Correction (Bias Correction)"

Ebenso enthält das Buch keine Formeln Als ich gegoogelt habe, kam die Formel heraus, also überprüfe das

Zitat: http://postd.cc/optimizing-gradient-descent/#adam

Adam (Adaptive Moment Optimization) 14 verwendet eine andere Methode, um die Lernrate für jeden Parameter zu berechnen und anzupassen. Adadelta und RMSprop haben exponentielle Abklingmittelwerte des Quadrats v_t vergangener Gradienten akkumuliert. Darüber hinaus behält Adam auch den exponentiell abnehmenden Durchschnitt des vergangenen Gradienten m_t bei. Es ist ähnlich wie Momentum.



\begin{align}
Ursprünglicher Wert\beta_1 &= 0.9,\beta_2=0.999,\epsilon=10^{-8}\\
\\
m_t &= \beta_1 m_{t-1} + (1 – \beta_1) g_t\\
v_t &= \beta_2 v_{t-1} + (1 – \beta_2) g_t^2\\
\\
\hat{m}_t &= \dfrac{m_t}{1 – \beta^t_1}\\
\hat{v}_t &= \dfrac{v_t}{1 – \beta^t_2}\\
\\
\theta_{t+1} &= \theta_{t} – \dfrac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t\\

\end{align}

class Adam:

    """Adam (http://arxiv.org/abs/1412.6980v8)"""

    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None
        self.v = None
        
    def update(self, params, grads):
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)
        
        self.iter += 1
        lr_t  = self.lr * np.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)         
        
        for key in params.keys():
            #self.m[key] = self.beta1*self.m[key] + (1-self.beta1)*grads[key]
            #self.v[key] = self.beta2*self.v[key] + (1-self.beta2)*(grads[key]**2)
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])
            
            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)
            
            #unbias_m += (1 - self.beta1) * (grads[key] - self.m[key]) # correct bias
            #unbisa_b += (1 - self.beta2) * (grads[key]*grads[key] - self.v[key]) # correct bias
            #params[key] += self.lr * unbias_m / (np.sqrt(unbisa_b) + 1e-7)

Vergleich

AdaGrad sieht im Bild unten gut aus Aber leider ist keine Methode besser (vorerst) Jedes hat seine eigenen Eigenschaften, und es scheint, dass es Probleme gibt, in denen es gut ist, und Probleme, in denen es nicht gut ist.

Anfangswert des Gewichts

Probleme, wenn der Anfangswert des Gewichts 0 ist

Weight Decay, eine Technik, die Überlernen unterdrückt und die Generalisierungsleistung verbessert Gewichtsabfall: Eine Methode, mit der gelernt werden soll, den Wert des Gewichtsparameters zu reduzieren Durch Verringern des Gewichtswerts ist es weniger wahrscheinlich, dass Überlernen auftritt.

Wenn Sie das Gewicht reduzieren möchten, ist es natürlich, dass Sie mit dem Anfangswert beginnen möchten, der so klein wie möglich ist. Der anfängliche Gewichtswert betrug bisher 0,01 * np.random.randn (10, 100). (Gaußsche Verteilung mit Standardabweichung von 0,01)

Wenn das Gewicht jedoch 0 ist, scheint es eine schlechte Idee zu sein. (Um genau zu sein, sollte der Gewichtswert nicht auf einen einheitlichen Wert eingestellt werden.) Der Grund ist ** bei der Fehlerausbreitungsmethode, dass alle Gewichtswerte einheitlich aktualisiert werden **. Daher ist ein zufälliger Anfangswert erforderlich.

Best Practice für Anfangsgewichte

Die Schlussfolgerung lautet wie folgt.

Bei Verwendung von ReLU für die Aktivierungsfunktion "Anfangswert von He"
Für S-förmige Kurven wie Sigmoid und Tanh "Anfangswert von Xavier"

Wenn die Anzahl der Knoten in der vorherigen Ebene n ist

Anfangswert von Xavier: Standardabweichung\frac{１}{\sqrt{n}}Gaußsche Verteilung mit Standardabweichung von\\
Anfangswert von He: Standardabweichung\sqrt\frac{2}{n}Gaußsche Verteilung mit Standardabweichung von\\

Versteckte Schichtaktivierungsverteilung (Ausgabedaten nach Aktivierungsfunktion)

Daten auf 0 und 1 vorgespannt → Der Wert des Rückausbreitungsgradienten wird immer kleiner und verschwindet Dieses Problem wird als "Verschwinden des Gradienten **" bezeichnet.

Jedes Neuron gibt fast den gleichen Wert aus → Aktivierungsverzerrung Es wird ein Problem der "** Grenze der Ausdruckskraft **"

Daher ist es wünschenswert, dass die Ergebnisse angemessen gestreut sind.

Änderungen in der Aktivierungsverteilung bei Verwendung von Sigmoid für die Aktivierungsfunktion

Verteilung der Aktivierung jeder Schicht bei Verwendung einer Gaußschen Verteilung mit einer Standardabweichung von 1 als Anfangswert des Gewichts

Verteilung der Aktivierung jeder Schicht bei Verwendung einer Gaußschen Verteilung mit einer Standardabweichung von 0,01 als Anfangswert des Gewichts

Verteilung der Aktivierung jeder Schicht, wenn der Anfangswert von Xavier als Anfangswert des Gewichts verwendet wird

Verteilung der Aktivierung jeder Schicht, wenn der Anfangswert von He als Anfangswert des Gewichts verwendet wird

Änderungen in der Aktivierungsverteilung bei Verwendung von ReLU als Aktivierungsfunktion

Verteilung der Aktivierung jeder Schicht bei Verwendung einer Gaußschen Verteilung mit einer Standardabweichung von 1 als Anfangswert des Gewichts

Verteilung der Aktivierung jeder Schicht bei Verwendung einer Gaußschen Verteilung mit einer Standardabweichung von 0,01 als Anfangswert des Gewichts

Verteilung der Aktivierung jeder Schicht, wenn der Anfangswert von Xavier als Anfangswert des Gewichts verwendet wird

Verteilung der Aktivierung jeder Schicht, wenn der Anfangswert von He als Anfangswert des Gewichts verwendet wird

Gewichtsvergleich nach MNIST-Datensatz

Wenn std = 0,01 ist, hat das Lernen kaum Fortschritte gemacht. Bei He und Xavier schreitet das knusprige Lernen voran → Sie sehen, dass das Problem des Anfangswertes sehr wichtig ist

Batch Normalization

Aktivierungsanpassungen "erzwingen", so dass die Verteilung der Aktivierungen in jeder Schicht eine moderate Streuung aufweist

Vorteile der Chargennormalisierung

Lernen kann schneller ablaufen (Lernkoeffizient kann erhöht werden)
Nicht so abhängig vom Anfangswert (Sie müssen nicht so nervös über den Anfangswert sein)
Überlernen unterdrücken (weniger Schulabbrecher usw.)

Es ist meine persönliche Meinung, aber es ist wie der Geschmack des Kochens.

Batch-Normalisierungsalgorithmus

Passen Sie die Aktivierungsverteilung jeder Schicht so an, dass sie eine moderate Verteilung aufweist → Mit anderen Worten, fügen Sie eine Ebene, die die Datenverteilung (Verteilung mit Mittelwert 0 und Varianz 1) normalisiert, in das neuronale Netzwerk ein.

\begin{align}
&B als Mini-Charge=\{x_1, x_2, \cdots, x_m\}Für einen Satz von m Eingabedaten\\
&durchschnittlich\mu_B, Dispersion\sigma_B^Fragen Sie nach 2\\
&Ebenfalls\Epsilon ist 10^{-7}Sehr kleiner Wert wie
\end{align}

\begin{align}
\mu_B &\leftarrow \frac{1}{m} \sum_{i-1}^{m} x_i\\
\sigma_B^2 &\leftarrow \frac{1}{m} \sum_{i-1}^{m} (x_i - \mu_B)^2\\
\hat{x_i} &\leftarrow \frac{x_i-\mu_B}{\sqrt{\sigma_B^2 + \epsilon}}

\end{align}

Darüber hinaus transformiert die Bath Norm-Ebene diese normalisierten Daten mit ihrer eigenen Skalierung und Verschiebung. γ und β sind Parameter, beginnend mit γ = 1 und β = 0 und durch Lernen auf geeignete Werte eingestellt.

y_i \leftarrow \gamma \hat{x_i} + \beta

Rückausbreitung usw. Sie lesen Frederik Kratzerts Blog.

https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html

Bewertung der Chargennormalisierung

Regulierung

Überlernen

Ursachen für Überlernen ・ Ein Modell mit einer Vielzahl von Parametern und hoher Ausdruckskraft ・ Es gibt nur wenige Trainingsdaten

Bewusstes Überlernen verursacht

Weight decay

Gewichtsabnahme: Lastabnahme

Der Zweck des Lernens des neuronalen Netzes besteht darin, den Wert der Verlustfunktion zu verringern. Wenn zu diesem Zeitpunkt die doppelte Norm des Gewichts (L2-Norm) hinzugefügt wird, kann verhindert werden, dass das Gewicht groß wird.

Wenn das Gewicht W ist, ist der Gewichtsabfall der L2-Norm

\frac{1}{2}\lambda W^2

λ ist ein Hyperparameter, der die Stärke der Regularisierung steuert 1/2 ist eine Konstante für die Anpassung, um das Ergebnis der Differenzierung von W ^ 2 λW zu erhalten

L2 Norm

\sqrt{w_1^2+w_2^2+\cdots+w_n^2}

L1 Norm

|w_1^2|+|w_2^2|+\cdots+|w_n^2|

Um ehrlich zu sein, war es einfacher zu verstehen, wenn man sich auf andere bezog als auf die Erklärung des Buches

Zitat: http://qiita.com/supersaiakujin/items/97f4c0017ef76e547976

In einem tiefen neuronalen Netzwerk ist das Modell umso aussagekräftiger, je mehr Schichten vorhanden sind. Je höher die Anzahl der Schichten ist, desto höher ist jedoch das Risiko einer Überanpassung. Das Risiko einer Überanpassung wird verringert, indem die Parameterfreiheit unter Beibehaltung der Ausdruckskraft des Modells eingeschränkt wird. Eine der Methoden ist der Gewichtsabfall. Die Formel zur Gewichtsaktualisierung lautet wie folgt.

{w \leftarrow w -\eta \frac{\partial C(w)}{\partial w} - \eta \lambda w\\
}

Die obige Formel ist etwas schwer zu verstehen, was Sie tun möchten, aber sie stammt tatsächlich aus der unten gezeigten Kostenfunktion.

{\tilde C(w) = C(w) + \frac{\lambda}{2}||w||^2
}

Dies ist die Kostenfunktion mit dem L2-Regularisierungsterm. Dieser Abschnitt reduziert den Gewichtswert. Bei der tatsächlichen Implementierung wird der Abschnitt zur L2-Regularisierung zu den Kosten hinzugefügt.

Obwohl es im Text durchlaufen wird, wird nur die Quelle des verwendeten Teils extrahiert: Es ist leicht zu verstehen, wenn Sie mit weight_decay_lambda suchen Wird zur Initialisierung, Berechnung der Verlustfunktion und Gewichtseinstellung verwendet

    def __init__(self, input_size, hidden_size_list, output_size,
                 activation='relu', weight_init_std='relu', weight_decay_lambda=0):
        self.input_size = input_size
        self.output_size = output_size
        self.hidden_size_list = hidden_size_list
        self.hidden_layer_num = len(hidden_size_list)
        self.weight_decay_lambda = weight_decay_lambda
        self.params = {}

        #Gewichtsinitialisierung
        self.__init_weight(weight_init_std)

        #Schichterzeugung
        activation_layer = {'sigmoid': Sigmoid, 'relu': Relu}
        self.layers = OrderedDict()
        for idx in range(1, self.hidden_layer_num+1):
            self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
                                                      self.params['b' + str(idx)])
            self.layers['Activation_function' + str(idx)] = activation_layer[activation]()

        idx = self.hidden_layer_num + 1
        self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
            self.params['b' + str(idx)])

        self.last_layer = SoftmaxWithLoss()

    def loss(self, x, t):
        """Finden Sie die Verlustfunktion

        Parameters
        ----------
        x :Eingabedaten
        t :Lehreretikett

        Returns
        -------
Wert der Verlustfunktion
        """
        y = self.predict(x)

        weight_decay = 0
        for idx in range(1, self.hidden_layer_num + 2):
            W = self.params['W' + str(idx)]
            weight_decay += 0.5 * self.weight_decay_lambda * np.sum(W ** 2)

        return self.last_layer.forward(y, t) + weight_decay


    def gradient(self, x, t):
        """Finden Sie den Gradienten (Fehlerrückausbreitungsmethode)

        Parameters
        ----------
        x :Eingabedaten
        t :Lehreretikett

        Returns
        -------
Wörterbuchvariable mit Farbverlauf jeder Ebene
            grads['W1']、grads['W2']、...Ist das Gewicht jeder Schicht
            grads['b1']、grads['b2']、...Ist die Vorspannung jeder Schicht
        """
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.last_layer.backward(dout)

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        #Aufbau
        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            grads['W' + str(idx)] = self.layers['Affine' + str(idx)].dW + self.weight_decay_lambda * self.layers['Affine' + str(idx)].W
            grads['b' + str(idx)] = self.layers['Affine' + str(idx)].db

        return grads

Dropout

Dropout: Eine Lernmethode, bei der Neuronen zufällig gelöscht werden

↓

Dropout in Chainer implementiert

    class Dropout:
        def __init__(self, dropout_ratio=0.5):
            self.dropout_ratio = dropout_ratio
            self.mask = None

        def forward(self, x, train_flg=True):
            if train_flg:
                self.mask = np.random.rand(*x.shape) > self.dropout_ratio
                return x * self.mask
            else
                return x * (1.0 - self.dropout_ratio)

        def backward(self, dout):
            return dout * self.mask

Ergebnisse bei Verwendung von Dropout

Hyperparameter-Validierung

Bisherige Beispiele für Hyperparameter ・ Anzahl der Neuronen in jeder Schicht ・ Chargengröße ・ Lernkoeffizient ・ Gewichtsabnahme

Validierungsdaten

Hyperparameter sollten nicht mit Testdaten auf ihre Leistung hin bewertet werden → Weil es zu Überlernen kommt

Verwenden Sie daher * Validierungsdaten *, bei denen es sich um Verifizierungsdaten handelt, die Hyperparametern gewidmet sind.

Abhängig vom Inhalt der Daten kann es erforderlich sein, sie vom Benutzer zu erstellen Code, der zuerst etwa 20% der Trainingsdaten als Verifizierungsdaten trennt

(x_train, t_train), (x_test, t_test) = load_mnist()

#Mische Trainingsdaten
x_train, t_train = shuffle_dataset(x_train, t_train)

#Validierungsdaten aufteilen
validation_rate = 0.20
validation_num = int(x_train.shape[0] * validation_rate)

x_val - x_train[:validation_num]
t_val - t_train[:validation_num]
x_train - x_train[validation_num:]
t_train - t_train[validation_num:]

Hyperparameteroptimierung

Wiederholen Sie die folgenden Schritte, um die Hyperparameter zu optimieren

STEP0 Geben Sie den Bereich der Hyperparameter an: Geben Sie zunächst grob an
STEP1 Zufällige Stichprobe aus dem eingestellten Hyperparameterbereich
STEP2 Lernen Sie die Verwendung der in STEP1 erfassten Hyperparameterwerte Bewerten Sie die Erkennungsgenauigkeit von Trubel-Daten (Die Epoche ist jedoch klein eingestellt)
STEP3 STEP21 und STEP2wp Wiederholen Sie eine bestimmte Anzahl von Malen (100 Mal usw.) und aus dem Ergebnis ihrer Erkennungsgenauigkeit Grenzen Sie den Bereich der Hyperparameter ein

Implementierung einer zufälligen Stichprobe

wight_decay = 10 ** np.random.uniform(-8, -4)
lr = 10 ** np.random.uniform(-6, -2)

Best-1(val acc:0.84) | lr:0.008596628403945712, weight decay:3.075068633526172e-06 Best-2(val acc:0.83) | lr:0.009688160706596694, weight decay:5.876005684736357e-08 Best-3(val acc:0.78) | lr:0.007897858091143213, weight decay:3.792675246120474e-08 Best-4(val acc:0.77) | lr:0.008962267845301249, weight decay:4.0961888275354916e-07 Best-5(val acc:0.74) | lr:0.009453193380059509, weight decay:1.5625175027026464e-08 Best-6(val acc:0.73) | lr:0.0066257479672272536, weight decay:4.6591905625864734e-05 Best-7(val acc:0.72) | lr:0.007814005955583136, weight decay:4.9330072714643424e-06 Best-8(val acc:0.72) | lr:0.008895526423573389, weight decay:4.297901358238285e-06 Best-9(val acc:0.71) | lr:0.006419577071135049, weight decay:1.0848308972057103e-08 Best-10(val acc:0.69) | lr:0.006304961469167366, weight decay:1.6652787617252613e-07

Wenn man sich die obigen Ergebnisse ansieht, ist es das nächste? wight_decay:10^-5-10^-8 lr:0.01-0,0001

Drücken Sie und rennen Sie erneut

Best-1(val acc:0.82) | lr:0.009567378324697062, weight decay:8.329914422037397e-07 Best-2(val acc:0.81) | lr:0.009548817455702163, weight decay:1.9982550859731867e-08 Best-3(val acc:0.8) | lr:0.009291306660458992, weight decay:2.2402127139457002e-07 Best-4(val acc:0.8) | lr:0.008381207344259718, weight decay:8.66434339086022e-08 Best-5(val acc:0.8) | lr:0.009034895918329205, weight decay:1.2694550788849033e-08 Best-6(val acc:0.78) | lr:0.0057717685490679006, weight decay:5.933415739833589e-08 Best-7(val acc:0.77) | lr:0.005287013083466725, weight decay:5.585759633899539e-06 Best-8(val acc:0.77) | lr:0.006997138970399023, weight decay:3.1968420191793365e-06 Best-9(val acc:0.77) | lr:0.007756581950864435, weight decay:1.0281187459919625e-08 Best-10(val acc:0.77) | lr:0.008298200180190944, weight decay:7.389218444784364e-06

nochmal wight_decay:10^-6-10^-8 lr:0.01-0.001

Best-1(val acc:0.84) | lr:0.00971135118325034, weight decay:1.0394539789935165e-07 Best-2(val acc:0.83) | lr:0.009584343636422769, weight decay:3.1009381429608424e-07 Best-3(val acc:0.8) | lr:0.00832916652339643, weight decay:6.618592237280191e-07 Best-4(val acc:0.8) | lr:0.00959218016681805, weight decay:1.6405007969017657e-07 Best-5(val acc:0.78) | lr:0.006451172600874767, weight decay:4.0323875599954127e-07 Best-6(val acc:0.77) | lr:0.008024291255610844, weight decay:2.0050763243482884e-07 Best-7(val acc:0.77) | lr:0.009809009860349643, weight decay:4.934310445408953e-07 Best-8(val acc:0.77) | lr:0.009275309843754197, weight decay:5.343909279054936e-08 Best-9(val acc:0.76) | lr:0.00741122584285725, weight decay:1.588771824270857e-07 Best-10(val acc:0.75) | lr:0.006528687212003595, weight decay:1.3251120646717308e-07

[PYTHON] [Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 6]