[PYTHON] Tutoriel TensorFlow - Représentation vectorielle des mots (traduction)

Tutoriel TensorFlow (Représentations vectorielles des mots) https://www.tensorflow.org/versions/master/tutorials/word2vec/index.html C'est une traduction de. Nous sommes impatients de signaler toute erreur de traduction.

Dans ce tutoriel, nous examinerons le modèle word2vec de Mikolov et al.. Je vais continuer. Ce modèle est utilisé pour apprendre une représentation vectorielle de mots appelée «incorporation de mots».

surligner

Ce tutoriel vise à mettre en évidence la partie intéressante et substantielle de la construction d'un modèle word2vec dans TensorFlow.

Commencez par expliquer la motivation pour vectoriser les mots
Nous examinerons l'intuition derrière le modèle et la façon dont le modèle est formé (par l'utilisation flashy des mathématiques comme bonne mesure)
Montre également une implémentation simple du modèle avec TensorFlow
Enfin, je vais vous montrer comment créer une version naïve qui s'adapte mieux

Nous aborderons le code plus tard dans le didacticiel, mais si vous préférez commencer directement, tensorflow / examples / tutorials / word2vec / word2vec_basic.py Voir l'implémentation minimale de /tensorflow/examples/tutorials/word2vec/word2vec_basic.py). Cet exemple de base contient le code nécessaire pour télécharger certaines données, s'entraîner un peu avec ces données et visualiser les résultats. Une fois que vous vous êtes habitué à lire et à exécuter la version de base, [tensorflow / models / embedding / word2vec.py](https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/models/embedding/word2vec. Vous pouvez passer à py). Il s'agit d'une implémentation plus lourde et montre des principes TensorFlow plus avancés, tels que l'utilisation des threads pour déplacer efficacement les données dans un modèle de texte, la création de points de contrôle pendant l'entraînement, etc.

Mais d'abord, voyons pourquoi nous formons l'intégration de mots. Si vous êtes un professionnel de l'intégration, vous pouvez ignorer cette section et entrer dans les détails.

Motivation: pourquoi apprendre à intégrer des mots?

Le système de traitement d'image ou audio fonctionne sur un ensemble de données riche et de grande dimension codé en tant que vecteur des intensités de pixel brutes individuelles des données d'image, ou, par exemple, un vecteur des coefficients de densité spectrale de puissance des données audio. Pour des tâches telles que la reconnaissance d'objets et la reconnaissance vocale, toutes les informations nécessaires pour réussir la tâche (car on peut effectuer ces tâches à partir de données brutes) sont encodées dans les données. Je comprends. Cependant, les systèmes de traitement du langage naturel traitent traditionnellement les mots comme des symboles atomiques individuels, tels que "chat" comme "Id537" et "chien" comme "Id143". Ces codages sont arbitraires et ne fournissent pas au système des informations utiles sur les relations qui peuvent exister entre les symboles individuels. En d'autres termes, ce que le modèle apprend sur les «chats» peut difficilement être utilisé pour traiter des données sur les «chiens» (par exemple, les deux animaux, quatre pattes, les animaux de compagnie, etc.). En outre, la représentation de mots avec des identifiants uniques et discrets conduit à des données rares, ce qui signifie souvent que davantage de données sont nécessaires pour entraîner avec succès les modèles statistiques. Les représentations vectorielles peuvent être utilisées pour surmonter certains de ces obstacles.

Le modèle d'espace vectoriel (https://en.wikipedia.org/wiki/Vector_space_model) (VSM) mappe des mots sémantiquement similaires à des points proches («Les points sont imbriqués les uns à côté des autres»). ), Représente un mot (incorporé) dans un espace vectoriel continu. En PNL, VSM a une histoire longue et riche, mais toutes les méthodes sont disponibles de différentes manières dans l'hypothèse de distribution (https://en.wikipedia.org/wiki/Distributional_semantics#Distributional_Hypothesis) (hypothèse distributionnelle). Dépend. L'hypothèse de la distribution est que les mots qui apparaissent dans le même contexte partagent une signification sémantique. Les approches qui utilisent ce principe peuvent être divisées en deux catégories: les méthodes basées sur le décompte (par exemple, l'analyse sémantique potentielle (https://en.wikipedia.org/wiki/Latent_semantic_analysis)) et les prédictions. (Par exemple, Modèles de langage probabiliste neuronal).

Cette distinction est décrite plus en détail par Baroni et al.. En parlant de: La méthode basée sur le nombre est une méthode de calcul de statistiques sur la fréquence à laquelle un mot coïncide avec ses voisins dans un grand corpus de texte et de mappage de ces statistiques de comptage sur un petit vecteur dense de chaque mot. Ainsi, le modèle prédictif tente de prédire les mots directement à partir des mots adjacents en utilisant un petit vecteur intégré dense qui a été formé (qui est considéré comme un paramètre du modèle).

Word2vec est un modèle prédictif particulièrement efficace pour l'apprentissage de l'incorporation de mots à partir de texte brut. Il existe deux types: le modèle d'ensembles de mots continus (CBOW) et le modèle de skipgramme. Ces modèles sont algorithmiquement similaires, mais CBOW prédit le mot cible (par exemple, "mat") à partir du mot de contexte d'origine ("chat assis"), et skipgram à l'inverse prédit l'original à partir du mot cible. Prédisez les mots contextuels. Cette inversion peut sembler une option, mais statistiquement, le CBOW a pour effet de lisser beaucoup d'informations de distribution (en traitant l'ensemble du contexte comme une seule observation). Dans la plupart des cas, CBOW s'est avéré utile dans des ensembles de données plus petits. Les Skipgrams, quant à eux, traitent chaque paire de mots contextuels / cibles comme une nouvelle observation, ce qui a tendance à être mieux pour des ensembles de données plus volumineux. Désormais, ce tutoriel se concentrera sur le modèle skipgram.

Passez à l'échelle avec une formation sur le contrôle du bruit

Le modèle de langage probabiliste neuronal traditionnellement [fonction softmax] la probabilité du mot suivant $ w_t $ (t dans "target") à partir de plusieurs mots $ h $ (h dans "history") déjà apparus Entraînez-vous en utilisant la méthode Most Probable (ML) pour (https://en.wikipedia.org/wiki/Softmax_function).

P(w_t | h) = \text{softmax}(\text{score}(w_t, h)) \\
           = \frac{\exp\{\text{score}(w_t, h)\}}
             {\sum_\text{Word w' in Vocab} \exp \{ \text{score}(w', h) \} }.

Ici, $ \ text {score} (w_t, h) $ calcule la compatibilité du mot $ w_t $ avec le contexte $ h $ (généralement par le produit interne). Entraînez ce modèle en maximisant la probabilité logarithmique de l'ensemble d'apprentissage. Autrement dit, maximisez les éléments suivants:

 J_\text{ML} = \log P(w_t | h) \\
  = \text{score}(w_t, h) -
     \log \left( \sum_\text{Word w' in Vocab} \exp \{ \text{score}(w', h) \} \right)

Cela produit un modèle probabiliste bien normalisé pour la modélisation du langage. Cependant, cela est dû au fait qu'à chaque étape d'apprentissage, chaque probabilité doit être calculée et normalisée en utilisant les scores de tous les autres mots $ V $ $ w '$ dans le contexte courant $ h $. C'est très coûteux.

D'autre part, l'apprentissage des fonctionnalités avec word2vec ne nécessite pas un modèle probabiliste complet. Les modèles CBOW et Skipgram utilisent à la place la méthode de notation binaire pour identifier le mot cible réel $ w_t $ à partir de $ k $ mots virtuels (bruit) $ \ tilde w $ dans le même contexte. Il est formé à l'aide de la régression logistique). Ceci est expliqué pour le modèle CBOW. Pour les skipgrammes, l'orientation est simplement inversée.

Mathématiquement, le but (pour chaque exemple) est de maximiser:

J_\text{NEG} = \log Q_\theta(D=1 |w_t, h) +
  k \mathop{\mathbb{E}}_{\tilde w \sim P_\text{noise}}
     \left[ \log Q_\theta(D = 0 |\tilde w, h) \right]

Où $ Q_ \ theta (D = 1 | w, h) $ apprend la probabilité que le mot $ w $ apparaisse dans le contexte $ h $ dans l'ensemble de données $ D $ sous le modèle. Calculé pour le vecteur $ \ theta $. Il se rapproche en fait de la valeur attendue en tirant un mot de contrôle $ k $ à partir de la distribution du bruit (c'est-à-dire en calculant le Monte Carlo Mean).

Cette fonction objective est maximisée lorsque le modèle attribue des probabilités élevées aux mots vrais et des probabilités faibles aux faux mots. Techniquement, cela s'appelle échantillonnage d'exemple négatif. , Il existe une bonne motivation mathématique pour utiliser cette fonction de perte: la mise à jour proposée par cette méthode se rapproche de la mise à jour de la fonction softmax à l'extrême. Cependant, le calcul de la fonction de perte est particulièrement intéressant car il est proportionnel au nombre de $ k $ mots de bruit sélectionnés et non au $ V $ de tous les mots du vocabulaire. Cela rend la formation beaucoup plus rapide. En fait, il est très similaire Noise Control Evaluation (NCE) Utilisez la perte. TensorFlow a une fonction d'assistance pratique tf.nn.nce_loss ().

Voyons maintenant comment cela fonctionne réellement!

Modèle Skipgram

À titre d'exemple, considérons l'ensemble de données suivant.

the quick brown fox jumped over the lazy dog

Premièrement, il forme un ensemble de données de mots et le contexte dans lequel ils apparaissent. Vous pouvez définir un «contexte» de n'importe quelle manière significative. En fait, le contexte syntaxique (c'est-à-dire la dépendance syntaxique du mot actuellement ciblé, [Levy et al.](Https://levyomer.files.wordpress.com/2014/04/dependency-based-word- Voir embeddings-acl-2014.pdf)), plusieurs mots sur le côté gauche de la cible, plusieurs mots sur le côté droit de la cible, etc. ont été pris en compte. Prenons ici une définition simple et définissons le «contexte» comme une fenêtre de plusieurs mots à gauche et à droite du mot cible. En utilisant la taille de fenêtre 1, vous obtenez la paire d'ensembles de données suivante (contexte, cible).

([the, brown], quick), ([quick, fox], brown), ([brown, jumped], fox), ...

Rappelez-vous que Skipgram inverse le contexte et la cible et tente de prédire chaque mot de contexte à partir du mot cible. Par conséquent, la tâche est de prédire «le» et «brun» de «rapide» et «rapide» et «renard» de «brun». Par conséquent, l'ensemble de données est la paire (entrée, sortie) suivante.

(quick, the), (quick, brown), (brown, quick), (brown, fox), ...

La fonction objectif est définie dans l'ensemble de l'ensemble de données, mais en utilisant généralement un échantillon à la fois (ou un "mini-lot" d'échantillons batch_size, où 16 <= batch_size <= 512) en général [ Optimisez cela avec la descente de gradient probabiliste (https://en.wikipedia.org/wiki/Stochastic_gradient_descent) (SGD). Jetons un coup d'œil à une étape de ce processus.

Imaginez en observant le premier cas d'entraînement ci-dessus à l'étape d'entraînement $ t $, le but ici est de prédire "le" à partir de "rapide". Sélectionnez les échantillons de bruit num_noise (contrôle) en tirant parti d'une distribution de bruit, généralement une distribution unigramme, $ P (w) $. Par souci de simplicité, définissons num_noise = 1 et sélectionnons "mouton" comme échantillon de bruit. Ensuite, calculons la perte de cette paire d'échantillons échantillon-bruit observée, c'est-à-dire que la fonction objectif à l'étape $ t $ est:

J^{(t)}_\text{NEG} = \log Q_\theta(D=1 | \text{the, quick}) +
  \log(Q_\theta(D=0 | \text{sheep, quick}))

Le but est de mettre à jour le paramètre embarqué $ \ theta $ pour améliorer (maximiser dans ce cas) cette fonction objectif. Nous faisons cela en dérivant la pente de perte pour le paramètre embarqué $ \ theta $, c'est-à-dire $ \ frac {\ partial} {\ partial \ theta} J_ \ text {NEG} $ (lucky) TensorFlow fournit également une fonction d'assistance simple pour ce faire). Mettez ensuite à jour l'incorporation en effectuant de petits pas dans la direction du dégradé. La répétition de ce processus sur l'ensemble de l'ensemble d'apprentissage a pour effet de "déplacer" le vecteur intégré pour chaque mot jusqu'à ce que le modèle réussisse à identifier le mot réel à partir du mot de bruit.

Le vecteur appris peut être visualisé en le projetant en deux dimensions en utilisant, par exemple, méthode de réduction de dimension t-SNE. L'examen de ces visualisations révèle que les vecteurs capturent des informations sémantiques générales et pratiquement très utiles sur les mots et leurs relations les uns avec les autres. J'ai d'abord découvert qu'une direction particulière dans l'espace vectoriel dérivé est spécifique à une relation sémantique particulière, par exemple, le sexe des hommes et des femmes et la relation entre les mots du pays et de la capitale, comme le montre la figure suivante. C'était très intéressant quand je l'ai fait (voir aussi Mikolov et al., 2013).

Cela explique pourquoi ces vecteurs sont utiles en tant que fonctionnalités dans de nombreuses tâches de prédiction PNL standard, telles que le balisage de mots partiels et la reconnaissance d'expressions propres ([Collobert et al., 2011](https: :). Recherche originale de //arxiv.org/abs/1103.0398) (pdf) et [Turian et al., 2010](http: // www. Voir suivi par aclweb.org/anthology/P10-1040)).

Mais ici, utilisons-les simplement pour dessiner de jolies images!

Construire un graphique

Tout est question d'intégration. Définissons maintenant une matrice intégrée. Il s'agit initialement d'une grande matrice aléatoire. Initialisez la valeur avec un nombre aléatoire uniforme.

embeddings = tf.Variable(
    tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))

Définit la perte d'évaluation du contrôle du bruit pour un modèle de régression logistique. Pour cette raison, nous devons définir des poids et des biais pour chaque mot du vocabulaire (appelés "poids de sortie" par opposition à "incorporation d'entrée"). Maintenant, définissons-le.

nce_weights = tf.Variable(
  tf.truncated_normal([vocabulary_size, embedding_size],
                      stddev=1.0 / math.sqrt(embedding_size)))
nce_biases = tf.Variable(tf.zeros([vocabulary_size]))

Maintenant que vous avez défini les paramètres, vous pouvez définir un graphique pour le modèle skipgramme. Par souci de simplicité, disons que chaque mot du vocabulaire est représenté par un entier et que le corpus de texte est déjà entier (pour plus d'informations [tensorflow / https: //www.tensorflow.org/versions/master/tutorials] /word2vec/index.html/tutorials/word2vec/word2vec_basic.py](voir https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/g3doc/tutorials/word2vec/word2vec_basic.py). Le modèle skipgram prend deux entrées. L'un est un lot rempli d'entiers représentant le mot de contexte source et l'autre est pour le mot cible. Créons un nœud d'espace réservé pour ces entrées afin que nous puissions envoyer des données plus tard.

# Placeholders for inputs
train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])

Ce que nous devons faire ici est de rechercher le vecteur pour chaque mot source du lot. TensorFlow a une aide pratique pour rendre cela facile.

embed = tf.nn.embedding_lookup(embeddings, train_inputs)

OK, maintenant que vous avez intégré chaque mot, essayons de prédire le mot cible en utilisant la fonction objective de la formation au contrôle du bruit.

# Compute the NCE loss, using a sample of the negative labels each time.
loss = tf.reduce_mean(
  tf.nn.nce_loss(nce_weights, nce_biases, embed, train_labels,
                 num_sampled, vocabulary_size))

Maintenant que nous avons un nœud pour la perte, nous devons ajouter plus de nœuds, comme le calcul du gradient et la mise à jour des paramètres. Nous utilisons la descente de gradient probabiliste pour cela, mais TensorFlow a également une aide pratique pour rendre cela facile.

# We use the SGD optimizer.
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.0).minimize(loss)

Formation modèle

L'entraînement du modèle est facile, utilisez feed_dict pour pousser les données vers les espaces réservés, et en boucle avec ces nouvelles données session.run Appelez simplement /client.html#Session.run).

for inputs, labels in generate_batch(...):
  feed_dict = {training_inputs: inputs, training_labels: labels}
  _, cur_loss = session.run([optimizer, loss], feed_dict=feed_dict)

Voir tensorflow / g3doc / tutorials / word2vec / word2vec_basic.py pour un exemple de code complet.

Visualisation de l'intégration formée

Après l'entraînement, vous pouvez utiliser t-SNE pour visualiser les incorporations entraînées.

C'est fait! Comme prévu, des mots similaires forment finalement des groupes proches les uns des autres. Pour une implémentation word2vec plus lourde qui démontre davantage les fonctionnalités avancées de TensorFlow, voir tensorflow / models / embedding / word2vec.py Voir l'implémentation de /embedding/word2vec.py).

Évaluation de l'intégration: raisonnement par analogie

L'intégration est utile dans diverses tâches prédictives de la PNL. Manque de formation dans un modèle de partie du discours ou d'expression propre à part entière, un moyen simple d'évaluer l'incorporation est de prédire directement les relations syntaxiques ou sémantiques, telles que "Qu'est-ce qu'une reine pour un roi pour un père?" Est de les utiliser pour. C'est ce qu'on appelle l'inférence par analogie, la tâche a été introduite par Mikolov et al., et l'ensemble de données Vous pouvez le télécharger ici: https://word2vec.googlecode.com/svn/trunk/questions-words.txt

Pour savoir comment l'évaluer, build_eval_graph () dans tensorflow / models / embedding / word2vec.py See et la fonction eval ().

Le choix des hyperparamètres a un fort impact sur la précision de cette tâche. Pour obtenir des performances de pointe dans cette tâche, entraînez-vous sur un très grand ensemble de données, ajustez soigneusement les hyperparamètres et sous-échantillonnez les données qui sortent du cadre de ce didacticiel. Vous devez utiliser des astuces comme celle-ci.

Optimisation de la mise en œuvre

Cette implémentation simple illustre la flexibilité de TensorFlow. Par exemple, changer les objectifs de formation est aussi simple que de remplacer l'appel à tf.nn.nce_loss () par une alternative standard telle que tf.nn.sampled_softmax_loss (). Si vous avez une nouvelle idée pour une fonction de perte, vous pouvez écrire manuellement une nouvelle expression cible dans TensorFlow et laisser l'optimiseur calculer sa dérivée. Cette flexibilité est inestimable pour essayer et itérer rapidement plusieurs idées différentes pendant la phase exploratoire du développement de modèles d'apprentissage automatique.

Une fois que vous avez une structure de modèle satisfaisante, il peut être utile d'optimiser votre implémentation pour une exécution plus efficace (et pour couvrir plus de données en moins de temps). Par exemple, le code naïf de ce didacticiel est ralenti car le backend TensorFlow utilise Python pour lire et fournir des éléments de données, ce qui nécessite peu de travail. Si vous trouvez un sérieux goulot d'étranglement dans les données d'entrée de votre modèle, comme décrit dans Nouveaux formats de données (https://www.tensorflow.org/versions/master/how_tos/new_data_formats/index.html) Vous pouvez également implémenter un lecteur de données personnalisé pour le problème. Pour le modèle skipgram, par exemple, tensorflow / models / embedding / word2vec.py J'ai déjà fait cela.

Si votre modèle ne détermine plus le débit d'E / S et que vous avez toujours besoin de plus de performances, accédez à Ajouter une nouvelle opération (https://www.tensorflow.org/versions/master/how_tos/adding_an_op/index.html) Comme mentionné, vous pouvez obtenir encore plus de performances en écrivant votre propre opération TensorFlow. Encore une fois, comme exemple de skipgrams, nous fournissons tensorflow / models / embedding / word2vec_optimized.py. Faire. Essayez de vous comparer les uns aux autres pour mesurer l'amélioration des performances à chaque étape.

Conclusion

Ce didacticiel a couvert le modèle word2vec, un modèle efficace en termes de calcul pour apprendre l'incorporation de mots. Motivé sur l'utilité de l'intégration, discuté des techniques de formation efficaces et montré comment implémenter tout cela dans TensorFlow. Dans l'ensemble, nous espérons avoir été en mesure de montrer comment TensorFlow offre la flexibilité nécessaire pour les premières expériences et les contrôles nécessaires pour les implémentations optimisées sur mesure ultérieures. Je suis.