Hier ist eine Schritt-für-Schritt-Erklärung des GloVe-Algorithmus:
- Konstruieren Koexistenz Matrix:
Glove beginnt mit der Konstruktion einer Koexistenzmatrix aus einem großen Korpus. Die Kookkurrenzmatrix stellt dar, wie häufig Wörter in einem bestimmten Kontextfenster gleichzeitig vorkommen.
Der Größe der Koexistenzmatrix wird durch die bestimmt Wortschatzgrößewobei jede Zeile und Spalte einem bestimmten Wort entspricht.
import numpy as np
from collections import defaultdictcorpus = [ "I love chocolate", "I love ice cream", "I enjoy playing tennis"]
# Initialize vocabulary and co-occurrence matrix
vocab = set()
co_occurrence = defaultdict(float)
window_size = 4
# Iterate by the corpus to construct vocabulary and co-occurrence matrix
for sentence in corpus:
phrases = sentence.break up()
for i in vary(len(phrases)):
phrase = phrases[i]
vocab.add(phrase)
for j in vary(max(0, i - window_size), min(i + window_size + 1, len(phrases))):
if i != j:
co_occurrence[(word, words[j])] += 1.0 / abs(i - j)
Hier in der letzten Zeile haben wir verwendet co_occurrence[(word, words[j])]+= 1,0 / abs(i — j), Der Ausdruck 1.0 / abs(i - j) wird zur Berechnung des Kookkurrenzwerts verwendet. Im Grunde verfolgt die Kookkurenzmatrix die Wörter, die zusammen im Korpus vorhanden sind, was bedeutet, dass ihre Indizes (i, j) ein Maß für den Abstand zwischen ihnen sind. Je kleiner der Abstand, desto besser ist die Kohärenz bzw. desto besser ist ihre Beziehung zueinanderadditionally nehmen wir den Kehrwert davon, um das umzusetzen.
Da wir nun unsere Koexistenzmatrix haben, fahren wir mit dem nächsten Schritt fort, d. h
So initialisieren Sie Worteinbettungen:
embedding_dim = 10
word_embeddings = {
phrase: np.random.randn(embedding_dim) for phrase in vocab
}
Hier können wir, wie Sie sehen, das definieren Einbettungsmaße dh es ist ein Hyperparameter, Es definiert im Wesentlichen die Anzahl der Funktionen, die Ihr Wort haben soll.
Jetzt kommt der letzte Schritt zu dieser grundlegenden Implementierung von Glove, und Sie haben es erraten! Wir müssen nur die Worteinbettungen trainieren.
Dazu benötigen wir zunächst eine Verlustfunktion. Hier haben wir Worteinbettungen gerade als Zufallszahlen initialisiert. Wenn wir nun die nehmen Kosinusähnlichkeit zwischen zwei Worteinbettungen unter Verwendung des Skalarprodukts zwischen den beiden und berechnen Sie dann die mittlerer quadratischer Verlust zwischen den aktuelle Ähnlichkeit und der tatsächliche Wert mit dem KoexistenzmatrixMithilfe dieses Verlusts können wir unsere Worteinbettungen mithilfe des negativen Gradienten aktualisieren (wie das Konzept der maximalen Wahrscheinlichkeit besagt).
learning_rate = 0.1
num_epochs = 100# Gradient descent to replace phrase embeddings
for epoch in vary(num_epochs):
total_loss = 0
for (word_i, word_j), observed_count in co_occurrence.gadgets():
# Calculate dot product of phrase embeddings
dot_product = np.dot(word_embeddings[word_i], word_embeddings[word_j])
# Calculate distinction and replace
diff = dot_product - np.log(observed_count)
total_loss += 0.5 * diff**2
gradient = diff * word_embeddings[word_j]
word_embeddings[word_i] -= learning_rate * gradient
print(f"Epoch: {epoch+1}, Loss: {total_loss}")
Nachdem wir nun über die aktualisierten Worteinbettungen verfügen, wiederholen wir den Vorgang für n Epochen. Am Ende werden wir über unsere aktualisierten Worteinbettungen verfügen, die dann für eine Vielzahl von NLP-Aufgaben wie maschinelle Übersetzung, Paraphrasierung usw. verwendet werden können.
Dies conflict additionally die Implementierung des Glove-Algorithmus für Worteinbettungen von Grund auf.
Hinweis – Dies conflict nur eine grundlegende Implementierung des Algorithmus. Bessere Ergebnisse können durch Skalieren der Koexistenzwerte und deren Darstellung als Wahrscheinlichkeiten erzielt werden. Dadurch wird der Freiheitsgrad der Daten verringert, was zu einer besseren Anpassung führt.
Colab-Notizbuch — https://colab.research.google.com/drive/1IxAnnFSqk3mL3A8n1PKYWdEzDSd2Y9rF?usp=sharing
Lerne weiter!
