Sujets> Deep Learning: Day3 RNN

sutudy-ai


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

スクリーンショット 2020-01-02 14.09.10.png

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 スクリーンショット 2020-01-02 14.50.59.png

À propos du réseau neuronal récursif

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

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)

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

Vue d'ensemble de LTSM

スクリーンショット 2020-01-03 15.25.30.png

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

Section 4) RNN bidirectionnel

Traitement du langage naturel avec RNN

Section5)Seq2Seq

Seq2Seq Grande image

スクリーンショット 2020-01-03 21.38.30.png Quelle est l'utilisation spécifique de Seq2seq? $ \ Rightarrow $ Il est utilisé pour le dialogue automatique et la traduction automatique. Qu'est-ce que Seq2seq? $ \ Rightarrow $ Encoder-A type de modèle de décodeur.

Section6)Word2vec

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. スクリーンショット 2020-01-03 6.53.48.png

[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 スクリーンショット 2020-01-03 13.43.56.png ⇒ [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 スクリーンショット 2020-01-03 14.28.59.png

⇒ [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 スクリーンショット 2020-01-03 16.10.21.png

⇒ [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 スクリーンショット 2020-01-03 16.53.16.png

[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

スクリーンショット 2020-01-03 20.20.29.png ⇒ [Discussion] Bonne réponse: 4 [Explication] Dans RNN bidirectionnel, la quantité d'entités est la combinaison de la représentation de couche intermédiaire lors de la propagation dans les sens aller et retour, donc np.concatenate ([h_f, h_b [:: -1]]] , Axe = 1). (Référence) [Apprenez la syntaxe np.concatenate ici](https://www.sejuku.net/blog/67869)

[P111] Défi d'exercice スクリーンショット 2020-01-03 21.07.54.png ⇒ [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 スクリーンショット 2020-01-04 1.29.38.png ⇒ [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 スクリーンショット 2020-01-03 4.42.29.png

[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 スクリーンショット 2020-01-03 4.53.56.png 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 スクリーンショット 2020-01-03 5.38.13.png Résultats utilisant HE スクリーンショット 2020-01-03 5.41.19.png 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])
スクリーンショット 2020-01-03 5.55.44.png

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])
スクリーンショット 2020-01-03 6.00.26.png

Recommended Posts

Sujets> Deep Learning: Day3 RNN
<Cours> Apprentissage en profondeur: Day2 CNN
<Cours> Apprentissage en profondeur: Jour 1 NN
L'apprentissage en profondeur
Étudiez en profondeur le Deep Learning [DW Day 0]
[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour2)
[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour3)
<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
[Rabbit Challenge (E qualification)] Deep learning (day4)
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 ~
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
Dossier d'apprentissage n ° 21 (25e jour)
Apprentissage profond à partir de zéro 1 à 3 chapitres
Essayez l'apprentissage en profondeur avec TensorFlow
Deep Learning Gaiden ~ Programmation GPU ~
Dossier d'apprentissage n ° 10 (14e jour)
Dossier d'apprentissage n ° 17 (21e jour)
Fiche d'apprentissage 12 (16e jour) Kaggle2
Reconnaissance d'image par apprentissage profond 1 théorie
Dossier d'apprentissage n ° 18 (22e jour)
Deep running 2 Réglage de l'apprentissage profond
Apprentissage profond / code de travail LSTM
Prédiction des ondes sinusoïdales à l'aide de RNN dans la bibliothèque d'apprentissage en profondeur Keras
Dossier d'apprentissage n ° 24 (28e jour)
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Présentation d'Udacity Deep Learning Nanodegree