Dies ist das Material, das bei der Präsentation auf einer internen Lernsitzung verwendet wird.
Optimale Parameter müssen eingestellt werden, um "gute Schlussfolgerungen" in einem neuronalen Netzwerk zu ziehen
Das Lernen neuronaler Netze erfordert einen Index, um zu wissen, wie gut das Lernen funktioniert → ** Verlust **
** Verlustfunktion ** wird verwendet, um den Verlust des neuronalen Netzwerks zu ermitteln
--Verlustfunktion
In diesem Abschnitt wird die folgende Schichtstruktur verwendet, um den Verlust zu ermitteln.
Fügen Sie die Ebenen Softmax und Cross Entropy Error zusammen
Softmax mit Verlust
Was ist Softmax? → ** Softmax-Funktion **
y_k = \frac {exp(s_k)}{\displaystyle \sum _{i=1}^{n} exp(s_i)}
Was ist ein Kreuzentropiefehler? → ** Kreuzentropiefehler **
L = - \sum_{k}t_k\space log\space y_k
one_hot expression
(0 oder 1), daher wird nur der natürliche Logarithmus zurückgegeben, wenn die Bezeichnung 1 ist.Berücksichtigung der Mini-Batch-Verarbeitung
L = - \frac{1}{N} \sum_{n}\sum_{k}t_{nk}\space log\space y_{nk}
verwenden
Das Ziel des Lernens eines neuronalen Netzwerks besteht darin, Parameter zu finden, die Verluste minimieren Was hier wichtig ist, ist ** Differenzierung ** und ** Gradient **.
Differential → Änderungsbetrag zu einem bestimmten Zeitpunkt @ohakutsu Einführung in die Mathematik für KI (Künstliche Intelligenz) ab Mathematik der Junior High School --YouTube
y = f(x)
Die Differenzierung von y zu x ist
\frac{dy}{dx}
Kann ausgedrückt werden als
Eine Differenzierung kann auch dann erhalten werden, wenn mehrere Variablen vorhanden sind Mit x als Vektor
L = f(x)
\frac{\partial L}{\partial x} = \left( \frac{\partial L}{\partial x_1}, \frac{\partial L}{\partial x_2}, ..., \frac{\partial L}{\partial x_n} \right)
Die Summe der Differentiale jedes Elements des Vektors wird als ** Gradient ** bezeichnet.
Im Fall einer Matrix kann der Gradient auf die gleiche Weise betrachtet werden. Sei W eine m × n-Matrix
L = g(W)
\frac{\partial L}{\partial W} = \left(
\begin{array}{ccc}
\frac{\partial L}{\partial w_{11}} & \cdots & \frac{\partial L}{\partial w_{1n}} \\
\vdots & \ddots & \\
\frac{\partial L}{\partial w_{m1}} & & \frac{\partial L}{\partial w_{mn}}
\end{array}
\right)
Das neuronale Netz zum Zeitpunkt des Trainings gibt einen Verlust aus, wenn Trainingsdaten angegeben werden Sobald der Verlustgradient für jeden Parameter erhalten wurde, kann er zum Aktualisieren der Parameter verwendet werden.
So finden Sie den Gradienten des neuronalen Netzwerks → ** Fehlerrückvermehrungsmethode **
Der Schlüssel zum Verständnis der Methode der Fehlerrückübertragung ist die ** Kettenregel **
↓ So ein Typ
y = f(x) \\
z = g(y) \\
Umschreiben
z = g(f(x)) \\
Die Differenzierung von z zu x ist
\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y}\frac{\partial y}{\partial x}
Egal wie komplex eine Funktion ist, ihre Differenzierung kann durch die Differenzierung einzelner Funktionen bestimmt werden.
Eine visuelle Darstellung der Berechnung
Beispiel)
z = x + y
Reverse Propagation ist "Back Propagation"
Unten typische arithmetische Knoten
--Multiplizieren Sie den Knoten
Zweigknoten
Knoten wiederholen
Summenknoten
--MatMul-Knoten
Implementieren Sie jede Ebene
Die Sigmoidfunktion ist
y = \frac {1}{1 + exp(-x)}
Die Differenzierung der Sigmoidfunktion ist
\frac{\partial y}{\partial x} = y(1 - y)
Das Berechnungsdiagramm der Sigmoid-Schicht ist
Bei Implementierung in Python
class Sigmoid:
def __init__(self):
self.params, self.grads = [], []
self.out = None
def forward(self, x):
out = 1 / (1 + np.exp(-x))
self.out = out
return out
def backward(self, dout):
dx = dout * (1.0 - self.out) * self.out
return dx
Vorwärtsausbreitung der affinen Schicht
y = np.dot(x, W) + b
Bias Addition wird ausgestrahlt
Bei Implementierung in Python
class Affine:
def __init__(self, W, b):
self.params = [W, b]
self.grads = [np.zeros_like(W), np.zeros_like(b)]
self.x = None
def forward(self, x):
W, b = self.params
out = np.dot(x, W) + b
self.x = x
return out
def backward(self, dout):
W, b = self.params
dx = np.dot(dout, W.T)
dW = np.dot(self.x.T, dout)
db = np.sum(dout, axis=0)
self.grads[0][...] = dW
self.grads[1][...] = db
return dx
class SoftmaxWithLoss:
def __init__(self):
self.params, self.grads = [], []
self.y = None #Ausgabe von Softmax
self.t = None #Lehreretikett
def forward(self, x, t):
self.t = t
self.y = softmax(x)
#Das Lehrerlabel ist eins-Konvertieren Sie für einen heißen Vektor in den richtigen Index
if self.t.size == self.y.size:
self.t = self.t.argmax(axis=1)
loss = cross_entropy_error(self.y, self.t)
return loss
def backward(self, dout=1):
batch_size = self.t.shape[0]
dx = self.y.copy()
dx[np.arange(batch_size), self.t] -= 1
dx *= dout
dx = dx / batch_size
return dx
Aktualisieren Sie die Parameter des neuronalen Netzwerks unter Verwendung des Gradienten, der durch die Fehlerrückausbreitungsmethode erhalten wird
Gehen Sie wie folgt vor, um das neuronale Netzwerk zu lernen.
Aktualisieren Sie die Parameter mit dem in "2. Gradientenberechnung" erhaltenen Gradienten in der entgegengesetzten Richtung des Gradienten (Richtung zur Reduzierung des Verlusts). → ** Gradientenabstiegsmethode **
Hier verwende ich die einfachste ** SGD ** -Methode zum Aktualisieren von Gewichten (ich habe in Deep Learning 1 geschrieben, das bei Null beginnt).
W \leftarrow W - \eta \frac{\partial L}{\partial W} \\
\eta :Lernkoeffizient
Bei Implementierung in Python
class SGD:
def __init__(self, lr=0.01):
self.lr = lr
def update(self, params, grads):
for i in range(len(params)):
params[i] -= self.lr * grads[i]
Die tatsächliche Aktualisierung der neuronalen Netzwerkparameter ist wie folgt
model = TwoLayerNet( ... )
optimizer = SGD()
for i in range(10000):
...
x_batch, t_batch = get_mini_batch( ... ) #Holen Sie sich eine Mini-Charge
loss = model.forward(x_batch, t_batch)
model.backward()
optimizer.update(model.params, model.grads)
...
Trainieren Sie tatsächlich das neuronale Netzwerk in 1.4
Recommended Posts