[PYTHON] Deep Learning 2 von Grund auf 1.3 Verarbeitung natürlicher Sprache 1.3 Zusammenfassung

Was ist das

Dies ist das Material, das bei der Präsentation auf einer internen Lernsitzung verwendet wird.

1.3 Lernen neuronaler Netze

1.3.1 Verlustfunktion

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

• Quadratischer Fehler (in Deep Learning 1 ab Null) ―― @ohakutsu Wird es für die Regression verwendet?
• Kreuzentropiefehler
• Wird häufig für die Klassifizierung mehrerer Klassen verwendet

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)}

• Charakteristisch
• Reale Nummer mit Ausgabe von 0.0 bis 1.0
• Fügen Sie alle Ausgänge hinzu, um 1.0 zu erhalten
• Kann als Wahrscheinlichkeit interpretiert werden

Was ist ein Kreuzentropiefehler? → ** Kreuzentropiefehler **

L = - \sum_{k}t_k\space log\space y_k

• Charakteristisch --t ist eine Lehrerbezeichnung für one_hot expression (0 oder 1), daher wird nur der natürliche Logarithmus zurückgegeben, wenn die Bezeichnung 1 ist.
• Je näher y an 0 liegt, desto kleiner wird es und je näher es an 1 liegt, desto mehr konvergiert es gegen 0.

Berücksichtigung der Mini-Batch-Verarbeitung

L = - \frac{1}{N} \sum_{n}\sum_{k}t_{nk}\space log\space y_{nk}

verwenden

1.3.2 Differenzierung und Gradient

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)

1.3.3 Kettenregeln

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 **

• Kettenregeln
• Das Gesetz der Differenzierung bezüglich synthetischer Funktionen

↓ 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.

1.3.4 Berechnungsdiagramm

Eine visuelle Darstellung der Berechnung

Beispiel)

z = x + y

Reverse Propagation ist "Back Propagation"

Unten typische arithmetische Knoten

• Zusatzknoten

--Multiplizieren Sie den Knoten

• Zweigknoten

• Knoten wiederholen

• Summenknoten

--MatMul-Knoten

1.3.5 Gradientenableitung und Backpropagation-Implementierung

Implementieren Sie jede Ebene

Sigmoidschicht

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

Affine Schicht

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

Softmax mit Verlustschicht

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

1.3.6 Gewichtsaktualisierung

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.

1. Mini-Charge

• Wenn viele Daten vorhanden sind, dauert es einige Zeit. Verwenden Sie daher einen Teil der Daten als Annäherung an das Ganze (ab Deep Learning 1 ab Null).

2. Gradientenberechnung --Finden Sie den Gradienten der Verlustfunktion für jeden Gewichtsparameter mit der Methode der Fehlerrückübertragung.
3. Parameteraktualisierung
4. Wiederholen Sie die Schritte 1 bis 3

3. Parameteraktualisierung

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

Das Ende

Verknüpfung

• O'Reilly Japan - Tiefes Lernen von Grund auf ❷
• [oreilly-japan / Deep-Learning-from-Scratch-2: "Deep Learning from Scratch ❷" (O'Reilly Japan, 2018)](https://github.com/oreilly-japan/deep-learning- von Grund auf neu-2)