Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 4

introduction

J'ai soudainement commencé à étudier "Deep Learning from scratch ❷ --- traitement du langage naturel" Notez que j'ai trébuché au chapitre 4 est.

L'environnement d'exécution est macOS Catalina + Anaconda 2019.10, et la version Python est 3.7.4. Pour plus de détails, reportez-vous au Chapitre 1 de ce mémo.

Chapitre 4 Accélération de word2vec

Ce chapitre est une accélération du modèle Word2vec CBOW créé au chapitre 3.

4.1 Amélioration de word2vec ①

Le premier est l'accélération de la couche d'entrée à la couche intermédiaire. Cette partie joue le rôle d'incorporer pour convertir les mots en expressions distribuées, mais comme la couche MatMul est inutile, remplacez-la par la couche Embedding.

La couche d'intégration est simple, mais la partie qui ajoute $ dW $ lorsque idx est dupliqué dans l'implémentation de rétropropagation peut être un peu déroutante. Dans le livre, il est repris dans la figure 4-5, et l'explication est omise comme "Réfléchissons à la raison pour laquelle l'ajout est fait par vous-même".

Alors, j'y ai pensé en le comparant au calcul de rétropropagation pour la couche MatMul. En effet, le calque Embedding doit avoir le même résultat que le calque MatMul.

Tout d'abord, remplacez $ idx $ dans la figure 4-5 par $ x $ dans la couche MatMul.

\begin{align}
idx &= 
\begin{pmatrix}
0\\
2\\
0\\
4\\
\end{pmatrix}\\
\\
x &=
\begin{pmatrix}
1 & 0 & 0 & 0 & 0 & 0 & 0\\
0 & 0 & 1 & 0 & 0 & 0 & 0\\
1 & 0 & 0 & 0 & 0 & 0 & 0\\
0 & 0 & 0 & 0 & 1 & 0 & 0\\
\end{pmatrix}
\end{align}

La formule de rétropropagation pour la couche MatMul est $ \ frac {\ partial L} {\ partial W} = x ^ T \ frac {\ partial L} {\ partial y} $ (voir page 33), donc Figure 4-5 Si vous le remplacez par la notation de, il devient $ dw = x ^ Tdh $. En appliquant ici $ x $ et $ dh $ dans la figure 4-5 pour calculer $ dW $, nous obtenons: En fait, je voulais faire $ dh $ comme le montre la Fig. 4-5, mais je ne peux pas exprimer la nuance de ● comme un livre, donc ici je l'exprime avec $ ●, ◆, a, b $.

\begin{align}
dW &= x^Tdh\\
\\
\begin{pmatrix}
? & ? & ? \\
○ & ○ & ○ \\
●_1 & ●_2 & ●_3 \\
○ & ○ & ○ \\
◆_1 & ◆_2 & ◆_3 \\
○ & ○ & ○ \\
○ & ○ & ○ \\
\end{pmatrix}
&=
\begin{pmatrix}
1 & 0 & 1 & 0\\
0 & 0 & 0 & 0\\
0 & 1 & 0 & 0\\
0 & 0 & 0 & 0\\
0 & 0 & 0 & 1\\
0 & 0 & 0 & 0\\
0 & 0 & 0 & 0\\
\end{pmatrix}
\begin{pmatrix}
a_1 & a_2 & a_3 \\
●_1 & ●_2 & ●_3 \\
b_1 & b_2 & b_3 \\
◆_1 & ◆_2 & ◆_3 \\
\end{pmatrix}\\
\end{align}

Comme vous pouvez le voir à partir du calcul, la deuxième ligne ($ ● _1 ● _2 ● _3 ) et la quatrième ligne ( ◆ _1 ◆ _2 ◆ _3 $) de $ dh $ sont telles qu'elles sont $ dW $ comme illustré dans la figure 4-5. Ce seront les 3e et 5e lignes de. Et le $? $ Sur la première ligne du $ dW $ en question ressemble à ceci:

\begin{align}
\begin{pmatrix}
a_1 + b_1 & a_2 + b_2 & a_3 + b_3 \\
○ & ○ & ○ \\
●_1 & ●_2 & ●_3 \\
○ & ○ & ○ \\
◆_1 & ◆_2 & ◆_3 \\
○ & ○ & ○ \\
○ & ○ & ○ \\
\end{pmatrix}
&=
\begin{pmatrix}
1 & 0 & 1 & 0\\
0 & 0 & 0 & 0\\
0 & 1 & 0 & 0\\
0 & 0 & 0 & 0\\
0 & 0 & 0 & 1\\
0 & 0 & 0 & 0\\
0 & 0 & 0 & 0\\
\end{pmatrix}
\begin{pmatrix}
a_1 & a_2 & a_3 \\
●_1 & ●_2 & ●_3 \\
b_1 & b_2 & b_3 \\
◆_1 & ◆_2 & ◆_3 \\
\end{pmatrix}
\end{align}

En d'autres termes, vous pouvez voir que nous ajoutons les première et troisième lignes de $ dh $. La même chose que le calcul de cette couche MatMul doit être implémentée dans la couche Embedding, il est donc nécessaire de l'ajouter.

4.2 Amélioration de word2vec②

Vient ensuite l'amélioration de la couche intermédiaire à la couche de sortie. L'idée de l'échantillonnage négatif pour réduire considérablement l'apprentissage avec des exemples négatifs est intéressante.

Il n'y avait pas de grosse pierre d'achoppement, mais dans le livre, l'explication de la rétropropagation de la couche Embedding Dot est omise car ce n'est "pas un problème difficile, alors réfléchissons-y par vous-même", donc je vais résumer ici un peu. regarder.

Dans la figure 4-12, si vous ne découpez que la partie du calque Embedding Dot, ce sera comme suit.

Ce que fait le nœud de point, c'est multiplier chaque élément et ajouter les résultats. Par conséquent, considérons la rétro-propagation en se décomposant en un nœud de multiplication (voir "1.3.4.1 nœud de multiplication" au chapitre 1) et un nœud de somme (voir "1.3.4.4 nœud de somme" au chapitre 1). Ensuite, il aura la forme suivante. Les lettres bleues sont de retour de la propagation.

En revenant au diagramme de nœud de point précédent, cela ressemble à ceci:

C'est OK s'il est implémenté comme indiqué sur cette figure, mais comme la forme de «dout» ne correspond pas à «h» et «target_W» telle quelle, le produit de chaque élément ne peut pas être calculé par «*» de NumPy. Par conséquent, faites d'abord correspondre les formes avec dout.reshape (dout.shape [0], 1) puis calculez le produit. Si vous l'implémentez de cette manière, vous pouvez voir qu'il devient le code de ʻEmbeddingDot.backwad () `dans le livre.

4.3 Apprentissage amélioré de word2vec

La mise en œuvre de l'apprentissage n'est pas particulièrement trébuchante. J'utilise le corpus PTB dans le livre, mais j'aime le japonais après tout, alors j'ai essayé d'apprendre avec le texte pré-écrit d'Aozora Bunko comme au chapitre 2. C'était.

Pour obtenir le corpus, utilisez la version modifiée de dataset / aozorabunko.py au lieu de dataset / ptb.py. Pour plus d'informations sur cette source et ce mécanisme, reportez-vous au [Chapitre 2, «Amélioration de la méthode basée sur le décompte»](https://qiita.com/segavvy/items/52feabbf7867020e117d#24- Amélioration de la méthode basée sur le décompte). Je l'ai écrit, alors veuillez vous y référer.

ch04 / train.py a également été modifié pour utiliser le corpus d'Aozora Bunko comme suit. Les changements sont ceux avec «★» dans les commentaires.

ch04/train.py

# coding: utf-8
import sys
sys.path.append('..')
from common import config
#Lors de l'exécution sur GPU, supprimez le commentaire ci-dessous (cupy requis)
# ===============================================
# config.GPU = True
# ===============================================
from common.np import *
import pickle
from common.trainer import Trainer
from common.optimizer import Adam
from cbow import CBOW
from skip_gram import SkipGram
from common.util import create_contexts_target, to_cpu, to_gpu
from dataset import aozorabunko  #★ Changé pour utiliser le corpus d'Aozora Bunko

#Paramètres des hyper paramètres
window_size = 5
hidden_size = 100
batch_size = 100
max_epoch = 10

#Lire les données
corpus, word_to_id, id_to_word = aozorabunko.load_data('train')  #★ Changer de corpus
vocab_size = len(word_to_id)

contexts, target = create_contexts_target(corpus, window_size)
if config.GPU:
    contexts, target = to_gpu(contexts), to_gpu(target)

#Génération de modèles etc.
model = CBOW(vocab_size, hidden_size, window_size, corpus)
# model = SkipGram(vocab_size, hidden_size, window_size, corpus)
optimizer = Adam()
trainer = Trainer(model, optimizer)

#Commencer à apprendre
trainer.fit(contexts, target, max_epoch, batch_size)
trainer.plot()

#Enregistrez les données dont vous avez besoin pour une utilisation ultérieure
word_vecs = model.word_vecs
if config.GPU:
    word_vecs = to_cpu(word_vecs)
params = {}
params['word_vecs'] = word_vecs.astype(np.float16)
params['word_to_id'] = word_to_id
params['id_to_word'] = id_to_word
pkl_file = 'cbow_params.pkl'  # or 'skipgram_params.pkl'
with open(pkl_file, 'wb') as f:
    pickle.dump(params, f, -1)

De plus, il a fallu environ 8 heures pour apprendre dans l'environnement à portée de main. Vient ensuite la confirmation du résultat. J'ai changé un peu ch04 / eval.py pour pouvoir essayer différents mots de l'entrée standard. «★» est la partie modifiée.

ch04/eval.py

# coding: utf-8
import sys
sys.path.append('..')
from common.util import most_similar, analogy
import pickle


pkl_file = 'cbow_params.pkl'
# pkl_file = 'skipgram_params.pkl'

with open(pkl_file, 'rb') as f:
    params = pickle.load(f)
    word_vecs = params['word_vecs']
    word_to_id = params['word_to_id']
    id_to_word = params['id_to_word']

#tâche la plus similaire ★ Changement de la requête en entrée standard
while True:
    query = input('\n[similar] query? ')
    if not query:
        break
    most_similar(query, word_to_id, id_to_word, word_vecs, top=5)


#tâche d'analogie ★ Changement de la requête en entrée standard
print('-'*50)
while True:
    query = input('\n[analogy] query? (3 words) ')
    if not query:
        break
    a, b, c = query.split()
    analogy(a, b, c,  word_to_id, id_to_word, word_vecs)

Voici les résultats de divers essais.

Commencez par rechercher des mots similaires. À titre de comparaison, j'ai également énuméré celui basé sur le décompte que j'ai essayé au chapitre 2. De plus, la taille de la fenêtre de CBOW était de 5 dans le code du livre, mais j'ai également essayé 2, ce qui est identique à la base de comptage.

C'est assez déroutant comme c'était le cas au chapitre 2. Aucune supériorité ou infériorité ne peut être donnée. La zone où les «chats» apparaissent dans «moi-même» montre le biais du corpus. Il semble que la raison en soit que la taille du corpus soit trop petite, car il n'utilise que les œuvres de Soseki Natsume, Kenji Miyazawa et Ranpo Edogawa.

Vient ensuite le problème de l'analogie.

Soudain, le premier problème est un mélange de scores faibles mais de résultats angoissants. Des données d'entraînement insuffisantes peuvent provoquer des choses effrayantes. J'ai l'impression d'avoir un aperçu du contexte de la demande récente d'une «IA explicable».

D'autres résultats sont également en lambeaux, mais à peine les bonnes réponses ont été mélangées dans "body: face = car:?" Et "go: come = speak:?". L'apparition de «policiers» et de «policiers» dans des «automobiles» est probablement due à Ranpo Edogawa.

Après tout, j'aurais dû utiliser docilement la version japonaise de Wikipédia, mais c'est une chose diabolique: la sueur: il y a beaucoup de gens qui essaient Wikipédia, donc si vous êtes intéressé, "wikipedia Japanese corpus" Veuillez essayer Google avec.

4.4 Thèmes restants pour word2vec

Le jugement négatif / positif du courrier est expliqué comme un exemple d'apprentissage par transfert, mais avec les connaissances de ce chapitre, même si les mots peuvent être convertis en vecteurs de longueur fixe, les phrases telles que le courrier ne peuvent pas être converties en vecteurs de longueur fixe. .. Par conséquent, nous ne pouvons pas encore contester une telle tâche.

Aussi, en ce qui concerne la qualité des expressions distribuées, dans le cas du japonais, la qualité de l'écriture pré-séparation semble avoir un grand effet. Certains modèles d'expressions distribuées japonais ont été publiés, mais lorsque l'on considère leur apprentissage par transfert, je pense qu'il est indispensable d'utiliser le même mécanisme d'écriture divisionnaire (logique, contenu du dictionnaire, paramètres, etc.). .. Dans ce cas, cela signifie-t-il que l'apprentissage par transfert ne peut pas être facilement réalisé avec des tâches qui traitent de termes techniques spécifiques à l'industrie ou à des entreprises individuelles, par exemple? Le japonais, c'est beaucoup de travail.

4.5 Résumé

La première moitié de ce livre est enfin terminée, mais étant donné que le chapitre 1 était une critique du premier volume, il se peut qu'il en soit encore environ 1/3. La destination semble longue ...

C'est tout pour ce chapitre. Si vous avez des erreurs, je vous serais reconnaissant de bien vouloir les signaler.