Explication et implémentation de l'algorithme Decomposable Attention

L'explication de l'algorithme et la mise en œuvre de l'article suivant.

L'histoire est que l'algorithme Decomposable Attention [^ 1] semble être utilisable lorsque vous souhaitez étudier la relation entre deux phrases, telles que des hypothèses et des hypothèses, des réponses, et si oui ou non il est déjà mentionné, alors comment améliorer les performances? En l'introduisant, c'est une histoire que j'ai essayé de mettre en œuvre avec Keras [^ 4].

Qu'est-ce que l'attention décomposable [^ 1]?

--Réseau pour l'inférence de langage naturel (NLI)

image.png Figure: À partir d'une attention décomposable pour l'inférence de langage naturel [^ 1]

algorithme

Pour utiliser cet algorithme, il est nécessaire de convertir chaque mot en une représentation distribuée avec GloVe [^ 7] ou Word2Vec [^ 8].

❏ Flux

--Assister?

❏ Variables d'entrée

Une paire de phrases d'entrée

\bar{a} = (a_1, ..., a_{l_a})^\mathrm{T} \\
\bar{b} = (b_1, ..., b_{l_b})^\mathrm{T} \\

Laisser. Ici, $ l_a et l_b $ représentent la longueur du document.

De plus, $ a_i, b_j \ in \ mathbb {R} ^ d $ est une sorte de représentation distribuée.

--Dans l'expérience, GloVe [^ 7] est utilisé pour convertir en un vecteur de dispersion à 300 dimensions. --Les vecteurs distribués $ \ bar {a}, \ bar {b} $ sont normalisés à la norme $ l_2 $ de $ 1 $

❏ Attend

Le poids de l'attention est calculé ci-dessous. En faisant cela, les mots importants sont triés afin qu'ils soient fortement corrélés.

e_{ij} := F'(\bar{a_i}, \bar{b_j}) := F(\bar{a})^{\mathrm{T}}F(\bar{b})

Laisser. Ce poids d'attention $ e_ {ij} $ rend les poids des mots étroitement liés aux documents $ a $ et $ b $ plus forts.

La fonction $ F $ au moment de l'implémentation n'est qu'un réseau de neurones.

Si vous calculez avec $ F '$, la dimension de la variable d'entrée sera $ l_a \ times l_b $, ce qui est grand. Lors du calcul réel, le nombre de dimensions d'entrée de $ l_a + l_b $ est simplifié en $ F $.

Ce $ F $ est un réseau de neurones entièrement connecté au moment de la mise en œuvre.

Sur la base du poids d'attention calculé $ e_ {ij} $, trouvez la valeur normalisée de $ \ bar {a_i}, \ bar {b_j} $ $ \ alpha_i, \ beta_j $.

\beta_i := \sum_{j=1}^{l_b} \frac{ \exp(e_{ij}) }{ \sum_{k=1}^{l_b} \exp(e_{ik})} \bar{b}_j \quad \forall i \in \left\{1,...,l_a \right\} \\

\alpha_j := \sum_{i=1}^{l_a} \frac{ \exp(e_{ij}) }{ \sum_{k=1}^{l_b} \exp(e_{kj})} \bar{a}_j \quad \forall j \in \left\{1,...,l_b \right\} 

❏ Compare

v_{1,i} := G([\bar{\alpha_i}, \beta_i]) \quad \forall i \in \left\{1,...,l_a \right\} \\
v_{2,j} := G([\bar{\beta_j}, \alpha_i]) \quad \forall j \in \left\{1,...,l_b \right\}

Ici, $ G $ est un réseau de neurones au moment de la mise en œuvre.

❏ Aggregate

v_1 = \sum_{i=1}^{l_a} v_{1,i} \\
v_2 = \sum_{j=1}^{l_b} v_{2,j} \\
\hat{y} = H([v_1, v_2])

❏ Attention intra-phrase (facultatif)

Dans la partie d'intégration de mots, j'ai pensé que le sens en tant que phrase pouvait être repris en utilisant un réseau neuronal au lieu de simplement convertir chaque mot.

f_{ij} := F_{\rm{intra}}(a_i)^{\mathrm{T}}F_{\rm{intra}}(a_j)

Ici, $ F_ {\ rm {intra}} $ est utilisé en tant que filet d'avance, et $ \ bar {a_i} et \ bar {b_i} $ sont modifiés comme suit.

\bar{a_i} := [a_i, a'_i]\\
\bar{b_i} := [b_i, b'_i]

Où $ a'_i $ est

a'_i := \sum_{j=1}^{l_a} \frac{\exp(f_{ij} + d_{i-j})}{\sum_{k=1}^{l_a} \exp(f_{ik + d_{i-k}})} a_j

C'est dit. Ce $ d_ {i-j} \ in \ mathbb {R} $ est un biais. La même chose s'applique à $ b'_i $

Mise en œuvre [^ 4]

Il est créé avec Keras [^ 9] en référence au code [^ 2] [^ 6] [^ 10].

https://gist.github.com/namakemono/f4f273dbc63fc2174940415a9f689a6f

References

Recommended Posts

Explication et implémentation de l'algorithme Decomposable Attention
Explication et implémentation de l'algorithme ESIM
Explication et mise en œuvre de SocialFoceModel
Explication et mise en œuvre de PRML Chapitre 4
Explication et mise en œuvre du perceptron simple
Explication de la distance d'édition et de l'implémentation en Python
Explication du CSV et exemple d'implémentation dans chaque langage de programmation
Introduction et mise en œuvre de JoCoR-Loss (CVPR2020)
Introduction et mise en œuvre de la fonction d'activation
Implémentation de la méthode Dyxtra par python
Explication mathématique de la recherche de dichotomie et de trisection et méthode de mise en œuvre sans bogues
Mise en œuvre et expérience de la méthode de clustering convexe
Implémentation et description à l'aide de XGBoost pour les débutants
Résumé de la classification et de la mise en œuvre des algorithmes d'apprentissage automatique
Explication et implémentation du protocole XMPP utilisé dans Slack, HipChat et IRC
Implémentation de l'arbre TRIE avec Python et LOUDS
Comparaison d'écriture R et Python (méthode de division mutuelle euclidienne)
Python - Explication et résumé de l'utilisation des 24 meilleurs packages
Mise à jour séquentielle de la co-distribution pour la dérivation et l'implémentation des expressions
Implémentation de l'écran de l'administrateur DB par Flask-Admin et Flask-Login
Explication des outils et commandes de package pour le système d'exploitation Linux
Implémentation de la séquence de Fibonacci
Principes de base et mise en œuvre de Perceptron
Algorithme de lapin et de tortue
Implémentation Python du mode de fusion CSS3 et discussion sur l'espace colorimétrique
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Dérivation et implémentation d'équations de mise à jour pour la décomposition de facteurs tensoriels non négatifs
[Avec une explication simple] Implémentation Scratch d'une machine Boltsman profonde avec Python ②
[Avec une explication simple] Implémentation Scratch d'une machine Boltzmann profonde avec Python ①
Théorie et mise en œuvre de modèles de régression multiple - pourquoi une régularisation est nécessaire -
Vérification et mise en œuvre de la méthode de reconstruction vidéo en utilisant GRU et Autoencoder
Dérivation de l'algorithme EM et exemple de calcul pour le tirage au sort
Implémentation de la méthode ML-EM, algorithme de reconstruction en coupe pour scanner