[PYTHON] Sujets> Deep Learning: Day3 RNN

Apprentissage en profondeur

table des matières [Apprentissage en profondeur: Day1 NN] (https://qiita.com/matsukura04583/items/6317c57bc21de646da8e) [Apprentissage en profondeur: Day2 CNN] (https://qiita.com/matsukura04583/items/29f0dcc3ddeca4bf69a2) [Apprentissage en profondeur: Day3 RNN] (https://qiita.com/matsukura04583/items/9b77a238da4441e0f973) [Deep learning: Day4 Strengthening learning / Tensor Flow] (https://qiita.com/matsukura04583/items/50806b750c8d77f2305d)

Deep Learning: Day3 CNN (Résumé de la conférence)

Examen de la vue d'ensemble de l'apprentissage profond - concept d'apprentissage

Dernier CNN

•AlexNet AlexNet est un modèle qui a remporté la deuxième place du concours de reconnaissance d'image organisé en 2012 par une large marge. Avec l'avènement d'AlexNet, l'apprentissage en profondeur a reçu beaucoup d'attention. Structure du modèle Se compose de 3 couches entièrement connectées qui suivent, dont 5 couches convolutives et une couche de regroupement

À propos du réseau neuronal récursif

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

• 1-1 Aperçu RNN

• 1-1-1 Qu'est-ce que RNN?

• Qu'est-ce que RNN? $ \ Rightarrow $ Un réseau neuronal qui peut gérer des données de séries temporelles.

• 1-1-2 Données de séries chronologiques

• Que sont les données de séries chronologiques? $ \ Rightarrow $ Une série de données qui sont observées à intervalles réguliers dans l'ordre chronologique et qui ont des dépendances statistiques les unes sur les autres.

• Que sont les données de séries chronologiques spécifiques? $ \ Rightarrow $ Données vocales / données texte ... etc

• 1-1-3 À propos de RNN

• Quelles sont les fonctionnalités de RNN? Pour gérer le modèle de série temporelle $ \ Rightarrow $, nous avons besoin d'une structure récursive qui contient l'état initial et l'état du temps passé t-1 et trouve récursivement t à la prochaine fois.

• 

• Vue d'ensemble de RNN

• 

• Formule

• 

• Code

python

u[:,t+1] = np.dot(X, W_in) + np.dot(z[:,t].reshape(1, -1), W)
z[:,t+1] = functions.sigmoid(u[:,t+1])
np.dot(z[:,t+1].reshape(1, -1), W_out)
y[:,t] = functions.sigmoid(np.dot(z[:,t+1].reshape(1, -1), W_out))np.dot(z[:,t+1].reshape(1, -1), W_out)

• 1-2BPTT

• 1-2-1 Qu'est-ce que BPTT? Examen de la méthode de propagation de retour d'erreur

• 

• 1-2-2 Description mathématique du BPTT

• 

• Lorsqu'il est lié au code ci-dessus + np.dot(X.T,delta[:,t].reshape(1,-1)) + np.dot(z[:,t+1].reshape(-1,1),delta_out[:,t].reshape(-1,1)) + 3)np.dot(z[:,t].reshape(-1,1), delta[:,t].reshape(1,-1))

• (B et c) omis dans le code RNN simple par souci de concision

• (B et c) omis dans le code RNN simple par souci de concision

  • u^t=W_{(in)}x^t+Wz^{t-1}+b
    (Code) </ span style color = "blue;"> u [:, t + 1] = np.dot (X, W_in) + np.dot (z [:, t] .reshape (1, -1) , W) </ span>
  • z^t=f(W_{(in)}x^t+Wz^{t-1}+b)
    (Code) z [:, t + 1] = fonctions.sigmoïde (u [:, t + 1])
  • v^t=W_{(out)}z^t+c
    

• (Code) y [:, t] = fonctions.sigmoïde (np.dot (z [:, t + 1] .reshape (1, -1), W_out))

• 

• Formule de mise à jour des paramètres

• 
• 

• 1-2-3 Vue d'ensemble du BPTT

• 

• Souligné $ \ Longrightarrow $

Section2) LSTM Vue d'ensemble (flux précédent et vision de la vue d'ensemble des problèmes)

Vue d'ensemble de LTSM

• 2-1CEC

• En tant que solution pour la disparition du gradient et l'explosion du gradient, il peut être résolu si le gradient est 1. Le poids des données d'entrée de la tâche est uniforme quelle que soit la dépendance temporelle. $ \ Rightarrow $ Il n'y a pas de caractéristique d'apprentissage du réseau neuronal. Couche d'entrée → poids vers couche masquée Collision de poids d'entrée. Couche cachée → Poids de la collision du poids de sortie avec la couche de sortie.

• 2-2 Porte d'entrée et porte de sortie

• Quel est le rôle de la porte d'entrée / sortie? En ajoutant des portes d'entrée / sortie $ \ Rightarrow $, les poids des valeurs d'entrée de chaque porte peuvent être modifiés par les matrices de poids W et U. Résolution du problème de $ \ Rightarrow $ CEC.

• 2-3 Porte de l'oubli

• La porte Oblivion est née de la tâche du bloc LSTM

• Problème Lorsque les informations passées ne sont plus nécessaires, elles ne peuvent pas être supprimées et restent stockées. L'état actuel du LSTM CEC stocke toutes les informations passées. Solution Lorsque vous n'avez plus besoin d'informations passées, vous avez besoin d'une fonction pour oublier les informations à ce moment-là. $ \ Rightarrow $ Naissance d'Oblivion Gate

• 2-4 connexion judas

• 

Un mécanisme qui a été créé pour répondre aux besoins de diffusion des informations passées du stockage CEC à d'autres nœuds à tout moment ou de l'oublier à tout moment. La valeur de CEC elle-même n'affecte pas la commande de porte. Qu'est-ce qu'une connexion judas? Une structure qui permet la propagation à la valeur de $ \ Rightarrow $ CEC elle-même via une matrice de poids.

Section3) GRU

Vue d'ensemble du GRU

• 

• (Contexte) LSTM a un problème en ce que le nombre de paramètres est grand et la charge de calcul est élevée. Naissance de $ \ Rightarrow $ GRU

• Qu'est-ce que GRU? $ \ Rightarrow $ Dans le LSTM conventionnel, il y avait de nombreux paramètres, donc la charge de calcul était lourde. Cependant, dans GRU, les paramètres ont été considérablement réduits et on peut s'attendre à ce que la précision soit égale ou supérieure à cela.

• Merit $ \ Rightarrow $ La charge de calcul est faible.

Section 4) RNN bidirectionnel

• Un modèle pour améliorer la précision en ajoutant des informations futures ainsi que des informations passées
• Exemple pratique Élaboration de texte, traduction automatique, etc.
• 

Traitement du langage naturel avec RNN

Section5)Seq2Seq

Seq2Seq Grande image

• 5-1Encoder RNN

• Structure qui transmet les données textuelles saisies par l'utilisateur en les divisant en jetons tels que des mots

• Prise: divisez la phrase en jetons tels que des mots et divisez-la en ID pour chaque jeton.
  Embedding: Conversion de l'ID en vecteur de représentation distribuée représentant le jeton.
  Encoder RNN: vecteurs d'entrée vers RNN dans l'ordre.

• Procédure de traitement RNN du codeur

• Entrée vec1 dans RNN et sortie état caché. Cet état caché et la prochaine entrée vec2 sont à nouveau entrés dans le RNN, et l'état caché est sorti, qui est répété.

• Enregistrer l'état caché lorsque le dernier vec est inséré comme état final. Cet état final est appelé un vecteur de pensée et devient un vecteur qui exprime le sens de la phrase d'entrée.

• 

• 5-2Decoder RNN

• Une structure dans laquelle le système génère des données de sortie pour chaque jeton, comme un mot.

• 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éfinit l'état final comme état initial du décodeur RNN et entrez Embedding.
• 2. Échantillonnage: sélectionnez au hasard des jetons en fonction de la probabilité de génération.
• 3. Incorporation: Incorporation du jeton sélectionné en 2 comme entrée suivante du décodeur RNN.
• 4. Detokenize: 1 Répétez -3 pour convertir le jeton obtenu en 2 en une chaîne.
• 

• 5-3HRED

• Problèmes Seq2seq Une seule question peut être répondue. Il n'y a pas de contexte à la question, juste la réponse continue. HRED est né pour résoudre ce problème.

• Qu'est-ce que HRED? Générez le prochain énoncé à partir des n-1 énoncés précédents. Système: Inco est mignon, n'est-ce pas? Utilisateur: Ouais Système: Je comprends le mignon Inco. Dans Seq2seq, la réponse a été faite en ignorant le contexte de la conversation, mais dans HRED, la réponse suit le flux du mot précédent, donc une phrase plus humaine est générée.

• 5-4VHRED

• Qu'est-ce que VHRED? $ \ Rightarrow $ HRED avec l'ajout du concept de variables latentes en VAE (appelées mouches).

• Une structure qui résout le problème de la HRED en ajoutant le concept de variables latentes de VAE.

• 5-5VAE

• 5-5-1 Encodeur automatique-

• Qu'est-ce qu'un encodeur automatique? $ \ Rightarrow $ L'un des apprentissages non supervisés. Par conséquent, les données d'entrée au moment de l'apprentissage ne sont que des données de formation, pas des données d'enseignant.

• Exemple spécifique à l'encodeur automatique Dans le cas de MNIST, il s'agit d'un réseau neuronal qui met une image de 28x28 nombres et produit la même image.

• Structure de l'encodeur automatique

• Dessin structurel
  <img width = 25% alt = "Capture d'écran 2020-01-03 22.40.52.png " src = "https: //qiita-image-store.s3.ap-northeast-1.amazonaws" .com / 0/357717 / 9a74cfde-b8f7-f0d4-7bca-49d192d811e4.png ">

• Explication de la structure de l'encodeur automatique $ \ Rightarrow $ Encoder est un réseau neuronal qui convertit les données d'entrée en variable latente z. Au contraire, Decoder est un réseau neuronal qui restaure l'image d'origine en utilisant la variable latente z comme entrée.

• ** Avantages $ \ Rightarrow $ Réduction de dimension **

• Si la dimension de z est plus petite que les données d'entrée, elle peut être considérée comme une réduction de dimension.

• 5-5-2VAE
• Dans le cas d'un encodeur automatique normal, les données sont en quelque sorte poussées dans la variable latente z, mais je ne sais pas quelle est la structure.
• VAE suppose ** distribution de probabilité ** z à N (0,1) pour cette variable latente z.
• VAE permet de pousser des données dans une structure appelée distribution de probabilité de la variable latente z.
• Diagramme de structure VAE
• 

Section6)Word2vec

• Créer un vocabulaire à partir des données d'entraînement Ex) Je veux manger des pommes. J'aime les pommes. {Apples, eat, I, like, to, want} * Si vous créez un vocabulaire de 7 mots facile à comprendre, vous aurez à l'origine autant de mots qu'il y en a dans le dictionnaire.

• Avantages

• L'apprentissage de la représentation distribuée de données à grande échelle est devenu possible avec une vitesse de calcul et une quantité de mémoire réalistes.

• ✗: Une matrice de poids uniquement pour le vocabulaire x le vocabulaire est née.

• ○: Vocabulaire × Une matrice de poids est née dans n'importe quelle dimension de vecteur de mot + Section7)AttentionMechanism

• Défi: Le problème avec seq2seq est qu'il est difficile de traiter des phrases longues. Avec seq2seq, vous devez saisir 2 mots ou 100 mots dans un vecteur de dimension fixe

• Solution: Nous avons besoin d'un mécanisme qui plus la phrase est longue, plus la dimension de la représentation interne de la séquence est grande.

• Un mécanisme pour apprendre le degré de pertinence de "quel mot d'entrée et de sortie est lié"

• Mécanisme d'attention Exemple spécifique $ \ Rigtharrow $ * "a" a un faible degré de pertinence, et "I" a un haut degré de pertinence pour "I".

• 

Test de confirmation

[P11] Test de confirmation Répondez à la taille de l'image de sortie lorsque l'image d'entrée de taille 5x5 est pliée avec le filtre de taille 3x3. La foulée est de 2 et le rembourrage est de 1. ⇒ [Discussion] Réponse 3 ✖️ 3 Hauteur de la taille d'entrée (H), largeur de la taille d'entrée (W) Output Hight（OH） Output Width（OW） Filler Hight（FH） Filler Width（FW） Foulée (S) Panoramique (P)

[P12] Trouvez dz / dx en utilisant le principe de la loi des chaînes.

     z = t^2,t=x+y

⇒ [Discussion] Il peut être calculé par le calcul suivant.

 \frac{dz}{dx}=\frac{dz}{dy}\frac{dy}{dx}

,t=x+y

z = t^Puisqu'il est 2, si vous différenciez par t\frac{dz}{dt}=2t

t=x+Puisqu'il est y, si vous différenciez par x\frac{dt}{dx}=1

\frac{dz}{dx}=2 t ・ 1=2t=2(x+y)

   OH =\frac{H+2P-FH}{S}+1 =\frac{5+2,1-3}{2}+1=3

   OH =\frac{W+2P-FW}{S}+1 =\frac{5+2,1-3}{2}+1=3

C'est une méthode de calcul fixe, alors souvenons-nous-en comme une formule.

[P23] Test de confirmation Le réseau RNN a trois poids principaux. L'un est le poids appliqué lors de la définition de la couche intermédiaire actuelle à partir de l'entrée, et l'autre est le poids appliqué lors de la définition de la sortie de la couche intermédiaire. Expliquez le poids restant. ⇒ [Discussion] La réponse est le poids passé d'une couche intermédiaire à la suivante.

[P37] Trouvez dz / dx en utilisant le principe de la loi des chaînes.

     z = t^2,t=x+y

⇒ [Discussion] Il peut être calculé par le calcul suivant.

 \frac{dz}{dx}=\frac{dz}{dy}\frac{dy}{dx}

,t=x+y

z = t^Puisqu'il est 2, si vous différenciez par t\frac{dz}{dt}=2t

t=x+Puisqu'il est y, si vous différenciez par x\frac{dt}{dx}=1

\frac{dz}{dx}=2 t ・ 1=2t=2(x+y)

[P46] Test de confirmation

Exprimez y1 dans la figure ci-dessous sous forme de formule en utilisant x, s0, s1, win, w et wout. * Définissez le biais avec n'importe quel caractère. * Aussi, laissez la fonction sigmoïde g (x) agir sur la sortie de la couche intermédiaire.

Z_1=sigmoid(S_0W+x_1W_{(in)}+b)

La couche de sortie utilise également le sigmoïde

y_1=sigmoid(Z_1W_{(out)}+c)

Connaissez l'essence car la manière d'écrire les symboles diffère selon le livre.

[P54] Exercices de code ⇒ [Discussion] La réponse est (2) [Explication] Dans RNN, la sortie de couche intermédiaire h_ {t} dépend de la sortie de couche intermédiaire passée h_ {t-1}, .., h_ {1}. Lorsque nous différencions partiellement la fonction de perte par rapport aux poids W et U dans RNN, nous devons en tenir compte et noter que dh_ {t} / dh_ {t-1} = U, U à chaque fois que nous remontons dans le temps. Est pendu. Autrement dit, delta_t = delta_t.dot (U).

[P63] Lorsque la fonction sigmoïde est différenciée, la valeur maximale est prise lorsque la valeur d'entrée est 0. Sélectionnez la valeur correcte parmi les options. (1) 0,15 (2) 0,25 (3) 0,35 (4) 0,45

⇒ [Discussion] Différenciation du sigumoïde

     (sigmoid)'=(1-sigmoid)(sigmoid)

Puisque la fonction sigmoïde est maximale à 0,5,

     (sigmoid)'=(1-0.5)(0.5)=0.Sera 25 ans

[P65] Défi d'exercice

⇒ [Discussion] Bonne réponse: 1 [Explication] Lorsque la norme du gradient est supérieure à la valeur de seuil, la norme du gradient est normalisée à la valeur de seuil, donc le gradient écrêté est calculé comme gradient × (seuil / norme du gradient). À. Autrement dit, gradient * rate. Il est facile à comprendre car la valeur seuil est simplement multipliée par le gradient et normalisée.

[P79] Test de confirmation Supposons que vous souhaitiez saisir la phrase suivante dans LSTM et prédire les mots qui entrent dans les espaces. Le mot «très» dans le texte n'est pas considéré comme ayant un effet même s'il disparaît dans la prédiction à blanc. Quelle porte est considérée comme fonctionnelle dans un tel cas? "Le film était intéressant. Au fait, j'avais tellement faim que quelque chose ____." ⇒ [Discussion] Bonne réponse: porte de l'oubli. Le rôle de la porte de l'oubli est utilisé pour déterminer le degré d'impact immédiat considéré.

[P80] Défi d'exercice

⇒ [Discussion] Bonne réponse: 3 [Explication] L'état de la nouvelle cellule est exprimé comme la somme de l'entrée de la cellule calculée et de l'état de la cellule un pas avant, multipliée par la porte d'entrée et la porte d'oubli. Autrement dit, input_gate * a + forget_gate * c.

[P89] Test de confirmation Décrivez brièvement les défis auxquels font face LSTM et CEC

⇒ [Discussion] Défis rencontrés par LSTM et CEC. LSTM a un problème en ce que le nombre de paramètres est grand et la charge de calcul est élevée. Dans la CEC, il n'y a pas de concept d'apprentissage et aucune pondération n'est utilisée. Il n'est pas possible de répondre à la nécessité de propager les informations passées enregistrées à d'autres nœuds à tout moment ou de les oublier à tout moment.

[P91] Défi d'exercice

[P93] Test de confirmation Décrivez brièvement la différence entre LSTM et GRU. ⇒ [Discussion] Dans LSTM, il y avait un problème que le nombre de paramètres était grand et la charge de calcul était élevée, mais dans GRU, les paramètres ont été réduits et le traitement est devenu plus rapide. Cependant, tous les GRU ne sont pas supérieurs et il est préférable de comparer et de sélectionner dans certains cas.

[P96] Défi d'exercice

[P111] Défi d'exercice ⇒ [Discussion] Bonne réponse: 1 [Explication] Le mot w est un vecteur one-hot, qui est converti en une autre caractéristique en incorporant le mot. Cela peut être écrit comme E.dot (w) en utilisant la matrice intégrée E. w est constitué d'un vecteur One-hot.

(Référence) Apprenez la relation entre le traitement du langage naturel et on-hot ici Lorsque le document est volumineux, les données actives deviennent également volumineuses et il existe un problème lié au fait que le traitement peut ne pas être effectué à temps. [P120] Test de confirmation seq2 Décrivez brièvement la différence entre seq et HRED et entre HRED et VHRED. ⇒ [Discussion] seq2seq ne pouvait répondre qu'à une seule question à la fois, mais HRED a été créé pour résoudre ce problème. La différence entre HRED et VHRED est qu'il y a des problèmes auxquels HRED ne peut pas répondre de la même manière, et VHRED peut répondre à ces problèmes tout en modifiant l'expression.

[P129] Test de confirmation Répondez aux blancs dans la description ci-dessous à propos de VAE. Introduction de ____ dans la variable latente du codeur automatique ⇒ [Discussion] La réponse est l'introduction de «variables de probabilité» dans les variables latentes.

[P138] Test de confirmation Décrivez brièvement la différence entre RNN et word2vec et seq2seq et Attention. ⇒ [Discussion] RNN nécessaire pour générer une matrice de nombres de vocabulaire ✖️ poids de nombres de vocabulaire, mais word2vec peut être constitué d'un nombre de vocabulaire ✖️ matrice de poids de nombres de vecteurs de mots arbitraires. Avec seq2seq et Attention, vous ne pouvez donner la même réponse à la même question qu'avec seq2seq, mais avec Attention, vous pouvez utiliser l'importance et la pertinence, et vous pourrez retourner des réponses avec des variantes. Grâce à l'apprentissage itératif, vous serez en mesure de donner des réponses qui conduiront à une meilleure précision.

[Vidéo DN60] Exercice Challenge ⇒ [Discussion] La réponse est (2). Il est représenté par un vecteur de représentation et des poids sont appliqués aux vecteurs de représentation adjacents les uns aux autres par la gauche et la droite.

# Exercice

Exercice DN42_source ①

simple RNN Addition binaire Résultat d'exécution de l'addition binaire

[essayez] Modifions weight_init_std, learning_rate, hidden_layer_size weight_init_std　1→10 learning_rate 0.1→0.01 hidden_layer_size 16→32 L'apprentissage a empiré.

[essayez] Modifions la méthode d'initialisation du poids Essayez de changer à la fois Xavier et He. (Changement de source)

python

###########changements##############
#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)

#Initialisation du poids avec 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))

#Initialisation du poids à l'aide de 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)

#####################################

Résultats avec Xavier Résultats utilisant HE Les résultats étaient presque proches.

[essayez] Modifions la fonction d'activation de la couche intermédiaire ReLU (Vérifions l'explosion du gradient)

changements de python

     #  z[:,t+1] = functions.sigmoid(u[:,t+1])
        z[:,t+1] = functions.relu(u[:,t+1])
     #  z[:,t+1] = functions.np.tanh(u[:,t+1])

tanh (tanh est fourni dans numpy. Créons un dérivé comme d_tanh)

changement python Ajout d'une définition dérivée

def d_tanh(x):
     return np.tanh(x)

changements de python

     #  z[:,t+1] = functions.sigmoid(u[:,t+1])
     #  z[:,t+1] = functions.relu(u[:,t+1])
        z[:,t+1] = d_tanh(u[:,t+1])