[PYTHON] Natürliche Sprache: Word2Vec Part3 - CBOW-Modell

Ziel

Eine Fortsetzung von Word2Vec mit dem Microsoft Cognitive Toolkit (CNTK).

Auch in Teil 3 wird Word2Vec von CNTK mit dem in Teil 1 erstellten japanischen Korpus durchgeführt. Es wird davon ausgegangen, dass CNTK und NVIDIA GPU CUDA installiert sind.

Einführung

Natürliche Sprache: Word2Vec Teil 2 - Skip-Gramm-Modell befasste sich mit dem Skip-Gramm-Modell, sodass Teil 3 eine weitere fortlaufende Worttasche (CBOW) enthält. ) Ich habe das Modell trainiert und mit Skip-Gramm verglichen.

CBOW-Modell und Trainingseinstellungen

Um CBOW zu erstellen, ein anderes in Word2Vec [[1]] vorgeschlagenes Modell (#reference), müssen Sie nur einige Änderungen am in Teil2 verwendeten Code vornehmen.

Die eingebettete Schicht hat eine Dimension von 100, der Vorspannungsterm der Ausgangsschicht wird nicht übernommen und die Fenstergröße beträgt 5.

Die Verlustfunktion, der Optimierungsalgorithmus und die für das Training verwendeten Hyperparameter sind genau die gleichen wie in Teil 2.

CBOW Ein- und Ausgänge

Um CBOW zu trainieren, muss auch die von CTFDeserializer gelesene Textdatei leicht geändert werden. Sie müssen lediglich den letzten Teil von word2vec_corpus.py, den Sie in Teil 2 ausgeführt haben, mit dem folgenden Code ändern.

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)

Die CBOW, die wir dieses Mal trainieren, berücksichtigt 5 Wörter davor und danach, sodass der CTFDeserializer folgendermaßen aussieht:

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
...

Anders als bei Skip-Gramm gibt es ein Zielwort pro 10 Eingabewörter.

Implementierung

Ausführungsumgebung

Hardware-

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

Software

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

Programm zum Ausführen

Das Schulungsprogramm ist auf [GitHub] verfügbar (https://github.com/sho-watari/NaturalLanguage/tree/master/Word2Vec).

word2vec_training.py

Kommentar

Ich werde einige Teile des auszuführenden Programms extrahieren und ergänzen. Wir hoffen, dass es Ihnen hilft, die Implementierung von CNTK und Schulungstechniken zu verstehen.

Dieses Mal habe ich Dynamic Axis verwendet, was der Vorteil von CNTK ist, um das CBOW-Modell zu erstellen.

word2vec_training.py

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

Wenn die Eingabe auf diese Weise deklariert wird, interpretiert CNTK die Eingabevariable als ([#, \ *], [num_word]). Wobei # für die Stapelgröße und * für die dynamische Achse steht. Ursprünglich ist es eine nützliche Funktion beim Umgang mit Daten variabler Länge, und diesmal ist die dynamische Achse auf 10 festgelegt, aber ich habe sie angewendet, weil es einfacher war, das CBOW-Modell zu implementieren.

Der Hauptunterschied zwischen CBOW und der Skip-Gramm-Implementierung besteht in der Mittelung der Ausgabe von der Einbettungsschicht.

word2vec_training.py

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

Die hier angezeigte Funktion C.sequence.reduce_sum berechnet die Summe für die dynamische Achse. Dies reduziert die dynamische Achse und die Ausgabe ist ([#], [num_hidden]).

Die anschließende Verarbeitung ist genau das gleiche.

Ergebnis

Ich habe die gleiche Überprüfung anhand der verteilten Darstellung der im CBOW-Training erworbenen Wörter versucht.

Wortähnlichkeit und Wortanalogie

[similarity]Magie
Verklärung:0.54
Produziert:0.48
Schlachten:0.47
verwenden:0.46
Fluktuation:0.39

Anders als in Skip-Gramm ist das Wort, das einen hohen Grad an Ähnlichkeit mit "Magie" aufweist, "Transformation".

[analogy]Hazuki-Lotus+Jin= ?
unter der Regie von:0.57
Zusammenfluss:0.50
Extra:0.48
Frau:0.47
Du:0.45

Das Wort Analogie ergab auch ein etwas anderes Ergebnis als in Skip-Gramm.

Visualisierung der eingebetteten Schicht durch t-SNE

Wie bei Skip-Gramm habe ich die t-Verteilung Stochastic Neighbor Embedding (t-SNE) [2] verwendet, um die vom CBOW-Modell erfasste Worteinbettungsschicht in zwei Dimensionen zu visualisieren. .. Die Ratlosigkeit, die einer der Parameter von t-SNE ist, ist von links als 5, 10, 20, 30, 50 angeordnet. Die obere Abbildung ist das CBOW-Modell und die untere Abbildung ist das Skip-Gramm-Modell.

Ich habe den Eindruck, dass sowohl CBOW als auch Skip-Gramm ähnliche Verteilungen haben.

Referenz

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.