[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour3)

introduction

C'est un record d'apprentissage lorsque j'ai pris le Rabbit Challenge dans le but de réussir la qualification JDLA (Japan Deep Learning Association) E, qui se tiendra les 19 et 20 janvier 2021.

Rabbit Challenge est un cours qui utilise le matériel pédagogique édité à partir de la vidéo enregistrée du cours de fréquentation scolaire du «cours d'apprentissage en profondeur qui peut être écrasé sur le terrain». Il n'y a pas de support pour les questions, mais c'est un cours bon marché (le prix le plus bas en juin 2020) pour passer l'examen de qualification E.

Veuillez vérifier les détails à partir du lien ci-dessous.

Liste des sujets

Mathématiques appliquées Apprentissage automatique Apprentissage en profondeur (jour1) Apprentissage en profondeur (jour2) Apprentissage en profondeur (jour3) Apprentissage en profondeur (jour 4)

Section 1: Concept de réseau neuronal récursif

Le réseau neuronal récurrent (RNN) est un réseau neuronal capable de gérer des données chronologiques. Les données de séries chronologiques sont une série de données qui sont observées à intervalles réguliers dans l'ordre chronologique et qui ont une dépendance statistique les unes sur les autres, et qui incluent des données audio et des données textuelles.

Puisque RNN gère les données de séries chronologiques, il a besoin d'une structure récursive qui contient l'état initial et l'état de $ t-1 $ dans le passé, et trouve l'état de $ t $ la fois suivante.

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)

En tant que méthode de réglage des paramètres dans RNN, il existe BPTT qui est une sorte de propagation de retour d'erreur.

[Formule de mise à jour des paramètres] $ 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 (addition binaire)


import sys, os
sys.path.append(os.pardir)  #Paramètres d'importation des fichiers dans le répertoire parent
import numpy as np
from common import functions
import matplotlib.pyplot as plt


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

#Préparez les données
#Nombre de chiffres binaires
binary_dim = 8
#Valeur maximum+ 1
largest_number = pow(2, binary_dim)
# largest_Préparez des nombres binaires jusqu'au nombre
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

#Initialisation du poids(Le biais est omis pour plus de simplicité)
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)


#Pente
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,Initialisation B(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
    
    #Corriger les données de réponse
    d_int = a_int + b_int
    d_bin = binary[d_int]
    
    #Sortie binaire
    out_bin = np.zeros_like(d_bin)
    
    #Erreur sur la série chronologique
    all_loss = 0    
    
    #Boucle de séries temporelles
    for t in range(binary_dim):
        #Valeur d'entrée
        X = np.array([a_bin[ - t - 1], b_bin[ - t - 1]]).reshape(1, -1)
        #Corriger les données de réponse au temps 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))


        #Erreur
        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])    

        #Mise à jour du dégradé
        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))
    
    #Application de dégradé
    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

--Modification du poids_init_std image.png → Lorsque weight_init_std a été réduit de 1,0 à 0,5 ou augmenté à 2,0, les deux ont convergé lentement.

--Changé taille_couche_cachée image.png → Diminuer hidden_layer_size de 16 à 8 ralentit l'apprentissage, mais l'augmenter à 32 accéléra l'apprentissage et l'augmenter à 128 ralentit l'apprentissage.

--Modification de la méthode d'initialisation du poids ・ Changer pour Xavier image.png ・ Changer pour He image.png → Les deux méthodes d'initialisation ont ralenti l'apprentissage.

--Changé la fonction d'activation de la couche intermédiaire

・ Changer pour ReLU image.png

・ Changer pour tanh image.png

Section2:LSTM(Long Short-Term Memory) Avec un RNN simple, les dépendances à longue distance ne peuvent pas être bien apprises en raison de la disparition du gradient lors de l'exécution de la propagation de retour d'erreur. LSTM est utilisé comme méthode pour résoudre le problème.

Section3:GRU(Gated Recurrent Unit) Dans le LSTM conventionnel, comme il y avait de nombreux paramètres, l'ajout de calcul était important. Par conséquent, GRU a une structure dans laquelle les paramètres sont considérablement réduits et la précision peut être espérée égale ou supérieure à cela.

image.png

Section 4: RNN bidirectionnel (RNN bidirectionnel)

Un modèle pour améliorer la précision en ajoutant non seulement des informations passées mais également des informations futures. Utilisé pour l'élaboration de texte et la traduction automatique.

image.png

Section5:Seq2Seq Les RNN normaux doivent avoir la même longueur et ordre d'entrée et de sortie. D'autre part, Seq2Seq est une sorte de modèle Encoder-Decoder et utilise différents RNN du côté entrée et du côté sortie. Utilisé pour le dialogue automatique et la traduction automatique.

image.png

[Procédure de traitement RNN du décodeur]

  1. Décodeur RNN: affiche la probabilité de génération de chaque jeton à partir de l'état final (vecteur de pensée) du codeur RNN. Définissez l'état final comme état initial du décodeur RNN et entrez Embedding.
  2. Échantillonnage: sélectionnez les jetons au hasard en fonction de la probabilité de génération.
  3. Incorporation: incorporation du jeton sélectionné dans 2 comme entrée suivante du décodeur RNN.
  4. Detokenize: Répétez 1-3 pour convertir le jeton obtenu en 2 en une chaîne de caractères.

Section6:Word2vec Dans RNN, il n'est pas possible de donner à NN une chaîne de caractères de longueur variable telle qu'un mot. Dans word2vec, un vocabulaire a été créé à partir de données d'apprentissage, et une matrice pondérée «nombre de vocabulaire x nombre de dimensions du vecteur de mot arbitraire» a permis de réaliser l'apprentissage de la représentation distribuée de données à grande échelle avec une vitesse de calcul et une quantité de mémoire réalistes. Le vecteur numérique résultant peut être utilisé pour transformer du texte brut en une représentation numérique adaptée à la visualisation de données, à l'apprentissage automatique et à l'apprentissage en profondeur.

Section7:Attention Mechanism Un mécanisme pour apprendre le degré de pertinence de «quel mot d'entrée et de sortie est lié». En utilisant la moyenne pondérée de l'état caché de chaque mot dans le codeur en tant qu'entrée en tant qu'information lorsque le décodeur sort chaque mot, les informations de contexte de la phrase source de traduction peuvent être appréhendées plus en détail. Avec l'introduction du mécanisme Attention, la précision de la traduction automatique neuronale a été considérablement améliorée, dépassant les performances des modèles de traduction automatique statistiques conventionnels.

image.png

Recommended Posts

[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour2)
[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour3)
[Rabbit Challenge (E qualification)] Deep learning (day4)
[Rabbit Challenge (E qualification)] Mathématiques appliquées
Défi de lapin d'apprentissage automatique
<Cours> Apprentissage en profondeur: Day2 CNN
<Cours> Apprentissage en profondeur: Jour 1 NN
Sujets> Deep Learning: Day3 RNN
[Deep Learning Association E Qualification] Que faire pour recevoir
Étudiez en profondeur le Deep Learning [DW Day 0]
L'apprentissage en profondeur
<Cours> Deep Learning Day4 Renforcement de l'apprentissage / flux de tension
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Apprentissage Python jour 4
Apprentissage en profondeur Python
Apprentissage profond × Python
Premier apprentissage profond ~ Lutte ~
Python: pratique du Deep Learning
Fonctions d'apprentissage en profondeur / d'activation
Apprentissage profond à partir de zéro
Fiche d'apprentissage 4 (8e jour)
Fiche d'apprentissage 9 (13e jour)
Fiche d'apprentissage 3 (7e jour)
Deep learning 1 Pratique du deep learning
Apprentissage profond / entropie croisée
Fiche d'apprentissage 5 (9e jour)
Fiche d'apprentissage 6 (10e jour)
Premier apprentissage profond ~ Préparation ~
Enregistrement d'apprentissage de la programmation 2ème jour
Première solution d'apprentissage en profondeur ~
Fiche d'apprentissage 8 (12e jour)
[AI] Apprentissage métrique profond
Fiche d'apprentissage 1 (4e jour)
Fiche d'apprentissage 7 (11e jour)
J'ai essayé le deep learning
Python: réglage du Deep Learning
Fiche d'apprentissage 2 (6e jour)
Technologie d'apprentissage en profondeur à grande échelle
Fiche d'apprentissage 16 (20e jour)
Dossier d'apprentissage 22 (26e jour)
Fonction d'apprentissage profond / softmax
[Apprentissage en profondeur] Classification d'images avec un réseau neuronal convolutif [DW jour 4]
Chanson auto-exploitée par apprentissage en profondeur (édition Stacked LSTM) [DW Day 6]