[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


In diesem Abschnitt wird die folgende Schichtstruktur verwendet, um den Verlust zu ermitteln.

1e49abb0-2cb2-dd5d-d881-5ee1cf946b46.png


Fügen Sie die Ebenen Softmax und Cross Entropy Error zusammen

bd2831b7-351e-9951-be8e-115321114a48.png

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

logx.png


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


↓ 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

097c0e7d-5245-f3a6-7445-c9e8b198efd7.png e22cfed3-f846-7607-fb78-0c8299b16700.png

Reverse Propagation ist "Back Propagation"

6981c2fe-1898-d29b-0ba1-aee35c912493.png


Unten typische arithmetische Knoten

--Multiplizieren Sie den Knoten 951e8bee-fef4-df5b-d9a2-d7de611e25bd.png

--MatMul-Knoten 744aada9-deea-379a-a8de-eb76267e1066.png


1.3.5 Gradientenableitung und Backpropagation-Implementierung

Implementieren Sie jede Ebene

bd2831b7-351e-9951-be8e-115321114a48.png


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

c725a5fc-e5b6-c377-ff33-df7bc4451a17.png


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

df1bab77-9c16-6624-2670-7e30a02b4abd.png


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

f9240a28-a5d5-0b1f-03aa-e22edfed5c13.png

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
  1. Gradientenberechnung --Finden Sie den Gradienten der Verlustfunktion für jeden Gewichtsparameter mit der Methode der Fehlerrückübertragung.
  2. Parameteraktualisierung
  3. 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 **

sample.png


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

Recommended Posts

Deep Learning 2 von Grund auf 1.3 Verarbeitung natürlicher Sprache 1.3 Zusammenfassung
[Python] [Verarbeitung natürlicher Sprache] Ich habe Deep Learning ausprobiert (auf Japanisch von Grund auf neu erstellt)
Python: Tiefes Lernen in der Verarbeitung natürlicher Sprache: Grundlagen
Deep Learning / Deep Learning von Grund auf neu 2 Kapitel 4 Memo
Deep Learning / Deep Learning von Grund auf neu Kapitel 3 Memo
Deep Learning / Deep Learning von Null 2 Kapitel 5 Memo
Deep Learning / Deep Learning von Null 2 Kapitel 7 Memo
Deep Learning / Deep Learning von Null 2 Kapitel 8 Memo
Deep Learning / Deep Learning von Grund auf neu Kapitel 5 Memo
Deep Learning / Deep Learning von Grund auf neu Kapitel 4 Memo
Deep Learning / Deep Learning von Grund auf neu 2 Kapitel 3 Memo
Deep Learning Memo von Grund auf neu gemacht
Installationszusammenfassung des Analysators für die Verarbeitung natürlicher Sprache
Deep Learning / Deep Learning von Null 2 Kapitel 6 Memo
Verbessertes Lernen, um von null bis tief zu lernen
[Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 7]
Deep Learning / Deep Learning von Grund auf neu Kapitel 6 Memo
[Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 5]
[Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 6]
Deep Learning / Deep Learning von Grund auf neu Kapitel 7 Memo
[Lernnotiz] Deep Learning von Grund auf neu gemacht [~ Kapitel 4]
Python vs Ruby "Deep Learning von Grund auf neu" Zusammenfassung
Python: Verarbeitung natürlicher Sprache
Deep Learning von Grund auf neu
RNN_LSTM2 Verarbeitung natürlicher Sprache
Python: Deep Learning in der Verarbeitung natürlicher Sprache: Implementierung eines Antwortsatzauswahlsystems
Anwendung von Deep Learning 2 von Grund auf neu Spam-Filter
Deep Learning von Grund auf 1-3 Kapitel
Verarbeitung natürlicher Sprache 1 Morphologische Analyse
Verarbeitung natürlicher Sprache 3 Wortkontinuität
Verarbeitung natürlicher Sprache 2 Wortähnlichkeit
100 Amateur-Sprachverarbeitungsklopfen: Zusammenfassung
Studieren Sie die Verarbeitung natürlicher Sprache mit Kikagaku
100 Klicks in der Verarbeitung natürlicher Sprache Kapitel 4 Kommentar
[Sprachverarbeitung 100 Schläge 2020] Kapitel 6: Maschinelles Lernen
Verarbeitung natürlicher Sprache für vielbeschäftigte Menschen
Lua-Version Deep Learning von Grund auf neu Teil 6 [Inferenzverarbeitung für neuronale Netze]
[Verarbeitung natürlicher Sprache] Vorverarbeitung mit Japanisch
Tiefes Lernen von Grund auf neu (Kostenberechnung)
100 Sprachverarbeitung Knock 2020 Kapitel 6: Maschinelles Lernen
Schreiben Sie Ihre Eindrücke von der Deep Learning 3 Framework Edition, die von Grund auf neu erstellt wurde
100 Sprachverarbeitung Knock-73 (mit Scikit-Learn): Lernen
Vorbereitung zum Starten der Verarbeitung natürlicher Sprache
Zusammenfassung der Mehrprozessverarbeitung der Skriptsprache
Deep Learning Tutorial aus dem Umgebungsbau
Sprachverarbeitung durch tiefes Lernen: Lassen Sie uns anhand der Stimme herausfinden, wer der Sprecher ist
[Verarbeitung natürlicher Sprache] Extrahieren Sie Schlüsselwörter aus der Kakenhi-Datenbank mit MeCab-ipadic-neologd und termextract
Zusammenfassender Hinweis zu Deep Learning -4.2 Verlustfunktion-
Tiefes Lernen von Grund auf neu (Vorwärtsausbreitung)
Verarbeiten Sie den Namen der Yugioh-Karte in natürlicher Sprache - Yugiou Data Science 2. NLP
100 Klopfen der Verarbeitung natürlicher Sprache Kapitel 1 (Vorbereitungsbewegung)
Tiefes Lernen / Tiefes Lernen von Grund auf 2-Versuchen Sie, GRU zu bewegen
3. Verarbeitung natürlicher Sprache durch Python 2-1. Netzwerk für das gleichzeitige Auftreten
[WIP] Vorverarbeiten von Notizen in der Verarbeitung natürlicher Sprache
3. Verarbeitung natürlicher Sprache durch Python 1-1. Word N-Gramm
Bildausrichtung: von SIFT bis Deep Learning
"Deep Learning von Grund auf neu" mit Haskell (unvollendet)
[Windows 10] Aufbau einer "Deep Learning from Scratch" -Umgebung
Lernbericht über das Lesen von "Deep Learning von Grund auf neu"
Informationen zur Datenerweiterungsverarbeitung für tiefes Lernen
Ich habe versucht, natürliche Sprache mit Transformatoren zu verarbeiten.