Langage naturel: Word2Vec Part3 - Modèle CBOW

Cible

Une suite de Word2Vec utilisant le Microsoft Cognitive Toolkit (CNTK).

Dans la partie 3 également, Word2Vec par CNTK sera réalisé à l'aide du corpus japonais préparé dans la partie 1. On suppose que CNTK et NVIDIA GPU CUDA sont installés.

introduction

Natural Language: Word2Vec Part2 --Skip-gram model traitait du modèle Skip-gram, donc la troisième partie a un autre sac de mots continu (CBOW). ) J'ai entraîné le modèle et je l'ai comparé avec Skip-gram.

Modèle CBOW et paramètres de formation

Pour créer CBOW, un autre modèle proposé dans Word2Vec [1], il suffit de faire quelques modifications au code utilisé dans Part2.

La couche incorporée a une dimension de 100, le terme de polarisation de la couche de sortie n'est pas adopté et la taille de la fenêtre est de 5.

La fonction de perte, l'algorithme d'optimisation et les hyperparamètres utilisés pour la formation sont exactement les mêmes que dans la partie 2.

Entrées et sorties CBOW

Afin de former CBOW, le fichier texte lu par CTFDeserializer doit également être légèrement modifié. Tout ce que vous avez à faire est de modifier la dernière partie de word2vec_corpus.py que vous avez exécutée dans la partie 2 avec le code suivant.

word2vec_corpus.py

    ...
    
    #
    # CBOW
    #
    targets = corpus[num_window:-num_window]
    words = []
    for i in range(num_window, len(corpus) - num_window):
        word_list = []
        for j in range(-num_window, num_window + 1):
            if j == 0:
                continue
            word_list.append(corpus[i + j])
        words.append(word_list)

    words, targets = np.array(words, dtype=int), np.array(targets, dtype=int)

    print("\nCBOW\n")

    num_samples = 0
    with open("./cbow_corpus.txt", "w") as word_file:
        for i in range(len(words)):
            word_file.write("{} |word {}:1\t|target {}:1\n".format(i, words[i, 0], targets[i]))
            for j in range(1, num_window * 2):
                word_file.write("{} |word {}:1\n".format(i, words[i, j]))

            num_samples += 1
            if num_samples % 10000 == 0:
                print("Now %d samples..." % num_samples)

    print("\nNumber of samples", num_samples)

Le CBOW que nous formons cette fois considère 5 mots avant et après, donc le CTFDeserializer ressemble à ceci:

cbow_corpus.txt

0 |word 982:1	|target 254:1
0 |word 3368:1
0 |word 2178:1
0 |word 3368:1
0 |word 2179:1
0 |word 545:1
0 |word 2180:1
0 |word 3368:1
0 |word 2181:1
0 |word 254:1
1 |word 3368:1	|target 545:1
1 |word 2178:1
1 |word 3368:1
1 |word 2179:1
1 |word 254:1
1 |word 2180:1
1 |word 3368:1
1 |word 2181:1
1 |word 254:1
1 |word 169:1
...

Contrairement à Skip-gram, il y a un mot cible pour 10 mots d'entrée.

la mise en oeuvre

Environnement d'exécution

Matériel

・ Processeur Intel (R) Core (TM) i7-6700K 4,00 GHz ・ GPU NVIDIA GeForce GTX 1060 6 Go

Logiciel

・ Windows 10 Professionnel 1909 ・ CUDA 10.0 ・ CuDNN 7.6 ・ Python 3.6.6 ・ Cntk-gpu 2.7 ・ Pandas 0.25.0

Programme à exécuter

Le programme de formation est disponible sur GitHub.

word2vec_training.py

Commentaire

Je vais extraire et compléter certaines parties du programme à exécuter. Nous espérons que cela vous aidera à comprendre la mise en œuvre de CNTK et les techniques de formation.

Cette fois, j'ai utilisé Dynamic Axis, qui est l'avantage de CNTK, pour créer le modèle CBOW.

word2vec_training.py

input = C.sequence.input_variable(shape=(num_word,))

Lorsque l'entrée est déclarée de cette façon, CNTK interprète la variable d'entrée comme ([#, \ *], [num_word]). Où # représente la taille du lot et * représente l'axe dynamique. À l'origine, c'est une fonction utile lorsqu'il s'agit de données de longueur variable, et cette fois, l'axe dynamique est fixé à 10, mais je l'ai appliqué car il était plus facile d'implémenter le modèle CBOW.

La principale différence entre CBOW et l'implémentation Skip-gram est la moyenne de la sortie de la couche Embedding.

word2vec_training.py

embed = C.sequence.reduce_sum(Embedding(num_hidden)(input)) / (num_window * 2)

La fonction C.sequence.reduce_sum qui apparaît ici calcule la somme pour Dynamic Axis. Cela réduira l'axe dynamique et la sortie sera ([#], [num_hidden]).

Le traitement ultérieur est exactement le même.

résultat

J'ai essayé la même vérification en utilisant la représentation distribuée des mots acquis dans la formation CBOW.

Similitude des mots et analogie des mots

[similarity]la magie
transfiguration:0.54
Produit:0.48
Abattage:0.47
utilisation:0.46
Fluctuation:0.39

Contrairement à Skip-gram, le mot qui a un degré élevé de similitude avec «magie» est «transformation».

[analogy]Hazuki-lotus+Jin= ?
réalisé par:0.57
Confluence:0.50
Supplémentaire:0.48
femme:0.47
Tu:0.45

Le mot analogie a également donné un résultat légèrement différent de celui de Skip-gramme.

Visualisation de la couche embarquée par t-SNE

Comme avec Skip-gram, j'ai utilisé la distribution t Stochastic Neighbor Embedding (t-SNE) [2] pour visualiser la couche d'inclusion de mots acquise par le modèle CBOW en deux dimensions. .. La perplexité, qui est l'un des paramètres du t-SNE, est disposée à partir de la gauche comme 5, 10, 20, 30, 50. La figure supérieure est le modèle CBOW et la figure inférieure est le modèle Skip-gram.

J'ai l'impression que CBOW et Skip-gram ont des distributions similaires.

référence

Natural Language : Word2Vec Part1 - Japanese Corpus Natural Language : Word2Vec Part2 - Skip-gram model

1. Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. "Efficient Estimation of Word Representations in Vector Space", arXiv preprint arXiv:1301.3781 (2013).
2. Laurens van der Maaten and Geoffrey Hinton. "Visualizing Data using t-SNE", Journal of Machine Learning Research. 2008, 9 Nov: 2579-2605.