[PYTHON] [Rabbit Challenge (E-Qualifikation)] Deep Learning (Tag 3)

Einführung

Dies ist ein Lernrekord, als ich die Rabbit Challenge mit dem Ziel absolvierte, die Qualifikation der Japan Deep Learning Association (JDLA) E zu bestehen, die am 19. und 20. Januar 2021 stattfinden wird.

Rabbit Challenge ist ein Kurs, der die Unterrichtsmaterialien verwendet, die aus dem aufgezeichneten Video des Schulbesuchskurses "Deep Learning-Kurs, der vor Ort zerstört werden kann" bearbeitet wurden. Es gibt keine Unterstützung für Fragen, aber es ist ein billiger Kurs (der niedrigste Preis ab Juni 2020) für die E-Qualifikationsprüfung.

Bitte überprüfen Sie die Details über den unten stehenden Link.

Liste der Themen

Angewandte Mathematik Maschinelles Lernen Deep Learning (Tag 1) Deep Learning (Tag 2) Deep Learning (Tag 3) Deep Learning (Tag 4)

Abschnitt 1: Konzept des rekursiven neuronalen Netzwerks

Das Recurrent Neural Network (RNN) ist ein neuronales Netzwerk, das Zeitreihendaten verarbeiten kann. Zeitreihendaten sind Datenreihen, die in regelmäßigen Abständen in chronologischer Reihenfolge beobachtet werden, statistisch voneinander abhängig sind und Audiodaten und Textdaten enthalten.

Da RNN Zeitreihendaten verarbeitet, benötigt es eine rekursive Struktur, die den Anfangszustand und den Zustand von $ t-1 $ in der Vergangenheit enthält und beim nächsten Mal den Zustand von $ t $ findet.

image.png

u^t = W_{(in)}x^t+Wz^{(t-1)}+b
z^t = f(W_{(in)}x^t+Wz^{(t-1)}+b)
v^t = W_{(out)}z^t+c
y^t = g(W_{(out)}z^t+c)

Als Parameteranpassungsmethode in RNN gibt es BPTT, eine Art Fehlerrückausbreitung.

[Parameteraktualisierungsformel] $ W_{(in)}^{t+1} = W_{(in)}^{t}-\epsilon\frac{\partial E}{\partial W_{(in)}} = W_{(in)}^{t}-\epsilon \sum_{z=0}^{T_t}\delta^{t-z}[x^{t-z}]^T $ $ W_{(out)}^{t+1} = W_{(out)}^{t}-\epsilon\frac{\partial E}{\partial W_{(out)}} = W_{(out)}^{t}-\epsilon \delta^{out,t}[z^{t}]^T $ $ W^{t+1} = W^{t}-\epsilon\frac{\partial E}{\partial W} = W_{(in)}^{t}-\epsilon \sum_{z=0}^{T_t}\delta^{t-z}[x^{t-z-1}]^T $ $ b^{t+1} = b^t-\epsilon\frac{\partial E}{\partial b} = b^t-\epsilon \sum_{z=0}^{T_t}\delta^{t-z} $ $ c^{t+1} = c^t-\epsilon\frac{\partial E}{\partial c} = c^t-\epsilon \delta^{out,t} $

simple_RNN (binäre Addition)


import sys, os
sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
import numpy as np
from common import functions
import matplotlib.pyplot as plt


def d_tanh(x):
    return 1/(np.cosh(x) ** 2)

#Daten vorbereiten
#Anzahl der Binärziffern
binary_dim = 8
#Maximalwert+ 1
largest_number = pow(2, binary_dim)
# largest_Bereiten Sie Binärzahlen bis zur Nummer vor
binary = np.unpackbits(np.array([range(largest_number)],dtype=np.uint8).T,axis=1)

input_layer_size = 2
hidden_layer_size = 16
output_layer_size = 1

weight_init_std = 1
learning_rate = 0.1

iters_num = 10000
plot_interval = 100

#Gewichtsinitialisierung(Die Vorspannung ist der Einfachheit halber weggelassen)
W_in = weight_init_std * np.random.randn(input_layer_size, hidden_layer_size)
W_out = weight_init_std * np.random.randn(hidden_layer_size, output_layer_size)
W = weight_init_std * np.random.randn(hidden_layer_size, hidden_layer_size)
# Xavier
# W_in = np.random.randn(input_layer_size, hidden_layer_size) / (np.sqrt(input_layer_size))
# W_out = np.random.randn(hidden_layer_size, output_layer_size) / (np.sqrt(hidden_layer_size))
# W = np.random.randn(hidden_layer_size, hidden_layer_size) / (np.sqrt(hidden_layer_size))
# He
# W_in = np.random.randn(input_layer_size, hidden_layer_size) / (np.sqrt(input_layer_size)) * np.sqrt(2)
# W_out = np.random.randn(hidden_layer_size, output_layer_size) / (np.sqrt(hidden_layer_size)) * np.sqrt(2)
# W = np.random.randn(hidden_layer_size, hidden_layer_size) / (np.sqrt(hidden_layer_size)) * np.sqrt(2)


#Steigung
W_in_grad = np.zeros_like(W_in)
W_out_grad = np.zeros_like(W_out)
W_grad = np.zeros_like(W)

u = np.zeros((hidden_layer_size, binary_dim + 1))
z = np.zeros((hidden_layer_size, binary_dim + 1))
y = np.zeros((output_layer_size, binary_dim))

delta_out = np.zeros((output_layer_size, binary_dim))
delta = np.zeros((hidden_layer_size, binary_dim + 1))

all_losses = []

for i in range(iters_num):
    
    # A,B-Initialisierung(a + b = d)
    a_int = np.random.randint(largest_number/2)
    a_bin = binary[a_int] # binary encoding
    b_int = np.random.randint(largest_number/2)
    b_bin = binary[b_int] # binary encoding
    
    #Richtige Antwortdaten
    d_int = a_int + b_int
    d_bin = binary[d_int]
    
    #Binär ausgeben
    out_bin = np.zeros_like(d_bin)
    
    #Fehler über Zeitreihen
    all_loss = 0    
    
    #Zeitreihenschleife
    for t in range(binary_dim):
        #Eingegebener Wert
        X = np.array([a_bin[ - t - 1], b_bin[ - t - 1]]).reshape(1, -1)
        #Richtige Antwortdaten zum Zeitpunkt t
        dd = np.array([d_bin[binary_dim - t - 1]])
        
        u[:,t+1] = np.dot(X, W_in) + np.dot(z[:,t].reshape(1, -1), W)
        z[:,t+1] = functions.sigmoid(u[:,t+1])
#         z[:,t+1] = functions.relu(u[:,t+1])
#         z[:,t+1] = np.tanh(u[:,t+1])    
        y[:,t] = functions.sigmoid(np.dot(z[:,t+1].reshape(1, -1), W_out))


        #Error
        loss = functions.mean_squared_error(dd, y[:,t])
        
        delta_out[:,t] = functions.d_mean_squared_error(dd, y[:,t]) * functions.d_sigmoid(y[:,t])        
        
        all_loss += loss

        out_bin[binary_dim - t - 1] = np.round(y[:,t])
    
    
    for t in range(binary_dim)[::-1]:
        X = np.array([a_bin[-t-1],b_bin[-t-1]]).reshape(1, -1)        

        delta[:,t] = (np.dot(delta[:,t+1].T, W.T) + np.dot(delta_out[:,t].T, W_out.T)) * functions.d_sigmoid(u[:,t+1])
#         delta[:,t] = (np.dot(delta[:,t+1].T, W.T) + np.dot(delta_out[:,t].T, W_out.T)) * functions.d_relu(u[:,t+1])
#         delta[:,t] = (np.dot(delta[:,t+1].T, W.T) + np.dot(delta_out[:,t].T, W_out.T)) * d_tanh(u[:,t+1])    

        #Verlaufsaktualisierung
        W_out_grad += np.dot(z[:,t+1].reshape(-1,1), delta_out[:,t].reshape(-1,1))
        W_grad += np.dot(z[:,t].reshape(-1,1), delta[:,t].reshape(1,-1))
        W_in_grad += np.dot(X.T, delta[:,t].reshape(1,-1))
    
    #Gradientenanwendung
    W_in -= learning_rate * W_in_grad
    W_out -= learning_rate * W_out_grad
    W -= learning_rate * W_grad
    
    W_in_grad *= 0
    W_out_grad *= 0
    W_grad *= 0
    

    if(i % plot_interval == 0):
        all_losses.append(all_loss)        
        print("iters:" + str(i))
        print("Loss:" + str(all_loss))
        print("Pred:" + str(out_bin))
        print("True:" + str(d_bin))
        out_int = 0
        for index,x in enumerate(reversed(out_bin)):
            out_int += x * pow(2, index)
        print(str(a_int) + " + " + str(b_int) + " = " + str(out_int))
        print("------------")

lists = range(0, iters_num, plot_interval)
plt.plot(lists, all_losses, label="loss")
plt.xlabel("iters_num", fontsize=14)
plt.ylabel("loss", fontsize=14)

plt.show()

image.png

--Changed weight_init_std image.png → Wenn weight_init_std von 1,0 auf 0,5 verringert oder auf 2,0 erhöht wurde, konvergierten beide langsam.

・ Wechseln Sie zu ReLU image.png

・ Wechseln Sie zu tanh image.png

Section2：LSTM（Long Short-Term Memory） Mit einem einfachen RNN können Fernabhängigkeiten aufgrund des Verschwindens des Gradienten bei der Durchführung der Fehlerrückübertragung nicht gut gelernt werden. LSTM wird als Methode zur Lösung des Problems verwendet.

Section3：GRU（Gated Recurrent Unit） Bei der herkömmlichen LSTM war der Berechnungszusatz groß, da es viele Parameter gab. Daher hat GRU eine Struktur, in der die Parameter signifikant reduziert sind und erwartet werden kann, dass die Genauigkeit gleich oder höher als diese ist.

image.png

Abschnitt 4: Bidirektionales RNN (Bidirektionales RNN)

Ein Modell zur Verbesserung der Genauigkeit, indem nicht nur vergangene, sondern auch zukünftige Informationen hinzugefügt werden. Wird für die Textausarbeitung und maschinelle Übersetzung verwendet.

image.png

Section5：Seq2Seq Normale RNNs müssen dieselbe Eingangs- und Ausgangslänge und -reihenfolge haben. Andererseits ist Seq2Seq eine Art Encoder-Decoder-Modell und verwendet unterschiedliche RNNs auf der Eingangs- und der Ausgangsseite. Wird für maschinelle Dialoge und maschinelle Übersetzung verwendet.

image.png

[Decoder RNN-Verarbeitungsverfahren]

  1. Decoder RNN: Gibt die Generierungswahrscheinlichkeit jedes Tokens aus dem Endzustand (Gedankenvektor) des Encoder RNN aus. Stellen Sie den Endzustand als Anfangszustand von Decoder RNN ein und geben Sie Embedding ein.
  2. Stichprobe: Wählen Sie Token basierend auf der Generierungswahrscheinlichkeit zufällig aus.
  3. Einbetten: Einbetten des in 2 ausgewählten Tokens als nächste Eingabe in den Decoder-RNN.
  4. Detokenize: Wiederholen Sie 1-3, um das in 2 erhaltene Token in eine Zeichenfolge umzuwandeln.

Section6：Word2vec In RNN ist es nicht möglich, NN eine Zeichenfolge variabler Länge wie ein Wort zu geben. In word2vec wurde ein Vokabular aus Trainingsdaten erstellt, und eine gewichtete Matrix aus "Anzahl der Vokabeln x Anzahl der Dimensionen eines beliebigen Wortvektors" ermöglichte es, das Lernen der verteilten Darstellung großer Datenmengen mit einer realistischen Berechnungsgeschwindigkeit und Speichermenge zu realisieren. Der resultierende numerische Vektor kann verwendet werden, um Rohtext in eine numerische Darstellung umzuwandeln, die für Datenvisualisierung, maschinelles Lernen und tiefes Lernen geeignet ist.

Section7：Attention Mechanism Ein Mechanismus, um den Grad der Relevanz zu erfahren, "welches Wort der Eingabe und Ausgabe in Beziehung steht". Indem der gewichtete Durchschnitt des verborgenen Zustands jedes Wortes in Encoder als Eingabe als Information verwendet wird, wenn der Decoder jedes Wort ausgibt, können die Kontextinformationen des Übersetzungsquellensatzes detaillierter erfasst werden. Mit der Einführung des Aufmerksamkeitsmechanismus wurde die Genauigkeit der neuronalen maschinellen Übersetzung erheblich verbessert und die Leistung herkömmlicher statistischer maschineller Übersetzungsmodelle übertroffen.

image.png

Recommended Posts

[Rabbit Challenge (E-Qualifikation)] Deep Learning (Tag 2)
[Rabbit Challenge (E-Qualifikation)] Deep Learning (Tag 3)
[Rabbit Challenge (E-Qualifikation)] Deep Learning (Tag 4)
[Rabbit Challenge (E-Qualifikation)] Angewandte Mathematik
Maschinelles Lernen Kaninchen Herausforderung
<Kurs> Tiefes Lernen: Day2 CNN
<Kurs> Tiefes Lernen: Tag 1 NN
Themen> Deep Learning: Tag 3 RNN
[Deep Learning Association E-Qualifikation] Was tun, um zu erhalten?
Studiere gründlich Deep Learning [DW Tag 0]
Tiefes Lernen
<Kurs> Deep Learning Day4 Stärkung des Lernens / Tensorflusses
Deep Learning Memorandum
Starten Sie Deep Learning
Python-Lerntag 4
Python Deep Learning
Deep Learning × Python
Erstes tiefes Lernen ~ Kampf ~
Python: Deep Learning-Praxis
Deep Learning / Aktivierungsfunktionen
Deep Learning von Grund auf neu
Lernrekord 4 (8. Tag)
Lernrekord 9 (13. Tag)
Lernrekord 3 (7. Tag)
Deep Learning 1 Übung des Deep Learning
Deep Learning / Cross Entropy
Lernrekord 5 (9. Tag)
Lernrekord 6 (10. Tag)
Erstes tiefes Lernen ~ Vorbereitung ~
Programmieren des Lernprotokolls 2. Tag
Erstes tiefes Lernen ~ Lösung ~
Lernrekord 8 (12. Tag)
[AI] Deep Metric Learning
Lernrekord 1 (4. Tag)
Lernrekord 7 (11. Tag)
Ich habe versucht, tief zu lernen
Python: Deep Learning Tuning
Lernrekord 2 (6. Tag)
Deep Learning Großtechnologie
Lernrekord 16 (20. Tag)
Lernrekord 22 (26. Tag)
Deep Learning / Softmax-Funktion
[Deep Learning] Bildklassifizierung mit Faltungsnetz [DW Tag 4]
Selbstgesteuertes Lied durch tiefes Lernen (gestapelte LSTM-Ausgabe) [DW Tag 6]