Wie trainiert man ein word2vec-Modell mit der Gensim-Bibliothek?

Was ist Worteinbettung?

Worteinbettung ist ein Prozess des Textverständnisses durch Algorithmen des maschinellen Lernens. Wir sagen auch, dass Worteinbettung eine gelernte Darstellung für Text ist, bei der der Kontext des Wortes in einem Dokument, die semantische und syntaktische Ähnlichkeit sowie die Beziehung zwischen anderen Wörtern im Korpus erfasst wird.

Dieser Ansatz ist der Schlüssel zur Lösung von Problemen bei der Verarbeitung natürlicher Sprache durch maschinelles Lernen und Deep-Learning-Algorithmen. Im Grunde ist die Worteinbettung eine Vektordarstellung von Wörtern. Durch die Berechnung des Abstands oder der Position von Wörtern stellt sie die Bedeutung von Wörtern, Sätzen, Absätzen oder Dokumenten dar.

Es gibt mehrere Techniken der Worteinbettung, die bisher eingeführt wurden. Generell kann man sagen, dass es zwei Arten der Worteinbettung gibt –

• Statische Worteinbettung
• Kontextuelle Worteinbettung

1. Statische Worteinbettung: Traditionelle Methoden wie Skip-Gram und Continuous Bag-of-Words lernen statische Einbettung, indem sie Lookup-Tabellen trainieren, die Wörter in dichte Vektoren übersetzen. Statische Einbettung ist direkt für die Lösung von lexikalischen Semantikaufgaben nützlich.

Problem: Kann Mehrdeutigkeiten für polysemische Wörter nicht auflösen. Wenn z.B. ein Wort mehrere Bedeutungen in zwei verschiedenen Sätzen repräsentiert, dann versagen die Skip-Gram- oder BOW-Methoden.

2. Kontextuelle Worteinbettung: Die kontextualisierte Worteinbettung zielt darauf ab, die Wortsemantik in verschiedenen Kontexten zu erfassen, um das Problem der Polysemie und der kontextabhängigen Natur von Wörtern anzugehen. LSTM-, bidirektionale LSTM-Modelle usw. helfen, die Vektorform von Wörtern zu erhalten.

Word2Vec-Modell: Word2Vec ist eine Methode, um eine solche statische Worteinbettung zu konstruieren. Dies wurde durch zwei Methoden erreicht: Skip Gram und Common Bag of Words (CBOW) mit Hilfe von neuronalen Netzen. Sie wurde 2013 von Tomas Mikolov bei Google entwickelt.

Warum brauchen wir sie?

Angenommen, wir haben die folgenden Sätze.

„I love coding in Jupyter.“ und „I enjoy coding in Pycharm“.

Beide Sätze liegen sehr nahe beieinander. Wenn wir ein erschöpfendes Vokabular erstellen (nennen wir es V), dann hat es V = {I, liebe, genießen, kodieren, in, Jupyter, Pycharm}. Wenn wir mit einer heißen Kodierung arbeiten. Wir werden nicht in der Lage sein, die genaue Bedeutung zu erhalten, da love, enjoy, coding jedes Wort als dasselbe behandelt wird, während love und enjoy sehr nahe beieinander liegen.

Unser Motiv ist es, dass Wörter mit ähnlichem Kontext sehr nahe aneinander liegen. Mathematisch gesehen gibt der Kosinusabstand an, wie nahe sich zwei Wörter sind. Der Cosinus-Abstand oder Cosinus des Engels des nächstgelegenen Wortes wird nahe bei 0 liegen und für das am weitesten entfernte Wort wird er nahe bei 1 liegen.

Wie funktioniert Word2Vec?

Das Word2Vec Modell kann mit zwei Algorithmen arbeiten –

• Skip-gram
• CBOW (Continuous Bag of Words)

CBOW Modell: Diese Methode nimmt den Kontext eines jeden Wortes als Eingabe und versucht, das dem Kontext entsprechende Wort vorherzusagen. Bei der Vorhersage des Zielwortes lernen wir die Vektordarstellung des Zielwortes. Die Eingabe besteht aus mehreren Wörtern gemäß der Fenstergröße (5 Wörter), aber die Ausgabe besteht aus einem Wort.

Schauen wir uns die Architektur genauer an:

Skip-Gram-Modell: Dies ist ein weiterer Algorithmus für Word2Vec. Er ist genau das Gegenteil des CBOW-Modells. Das Modell nimmt ein Wort als Eingabe, aber es gibt mehrere Wörter je nach Fenstergröße zurück.

Implementierung von Word Embedding mit Gensim Word2Vec Modell:

Hier werde ich Schritt für Schritt erklären, wie man das Word2Vec Modell mit Gensim trainiert. Dataset, habe ich von Kaggle-Plattform gesammelt. Dieser Datensatz stammt aus den öffentlichen Daten des Myers-Briggs Type Indicator. Er enthält zwei Spalten „type“ und „post“. „type“ definiert 16 Persönlichkeitstypen und „post“ definiert den Kommentar zu diesen 16 Typen der personalisierten Person.

1. Laden der Daten und Datenbeschreibung

# Laden des Datensatzes
data_df = pd.read_csv(„data/mbti_1.csv“)
data_df.head()

2. Datenbereinigung und Vorverarbeitung

Nach dem Laden der Daten müssen wir herausfinden, ob die Daten NA-Werte enthalten; wenn NA-Werte im Datensatz enthalten sind, werden sie entfernt.

# Entfernen von NA-Werten aus dem Datenrahmen
def data_na_value_cleaning(data):
print(„\nBefore cleaning, Data Shape : „, data.shape)
print(„\nVor dem Entfernen von Nullwerten: – – – – – – – -„)
print(data.isna().sum())
data.dropna(inplace=True)
data.reset_index(inplace=True,drop=True)
print(„Nach dem Entfernen von Nullwerten: – – – – – – – -„)
print(data.isna().sum())
print(„\nAfter cleaning, Data Shape : „, data.shape)
return data

Da unsere Daten keine NA-Werte haben. Es wurden also keine Zeilen entfernt. Jetzt prüfen wir, ob es irgendwelche doppelten Werte im Datensatz gibt.

# Entfernen doppelter Werte
def duplicate_content_removal(data, col, ini_row):
print(„\nBefore removing duplicates, number of data was : „, ini_row)
duplicate_count = data.duplicated().sum()
print(„\nAnzahl der Duplikate: „, duplicate_count)

description_data = data.drop_duplicates()
cleaned_row = len(description_data)
if (ini_row – cleaned_row) > 0:
print(„\nGesamtdatenreduktion : „, (ini_row – cleaned_row))
print(„\nNach Entfernen von Duplikaten beträgt die Anzahl der Daten :“, cleaned_row)
else:
print(„\nDatensatz enthält keine doppelten Daten.“)
return list(description_data)

posts = duplicate_content_removal(data_df, ‚posts‘, data_df.shape)

Nun werden wir als Teil des Reinigungsprozesses Links und Interpunktion entfernen. Außerdem werden wir zum besseren Training nur Wörter, nicht aber Zahlen und alphanumerische Wörter berücksichtigen. Wir werden Stoppwörter entfernen, um das Modell besser zu verstehen und die Genauigkeit zu erhöhen.

def remove_link_punc(string):
# removing links
temp_string = re.sub(‚http?://(?:|||(?:%))+‘, ‚ ‚, string)

# Entfernen von allem außer den englischen Buchstaben a-z
regex = re.compile(“)
temp_string = regex.sub(‚ ‚, temp_string)

# Entfernen von zusätzlichen Leerzeichen
clean_string = re.sub(‚ +‘, ‚ ‚, temp_string).lower()

return clean_string

Nächste Methode data_cleaning

def data_cleaning(content):
sentences =
for idx in tqdm(range(len(content)))):
if content !=““:
# Sentence tokenization using NLTK library
for each_sent in sent_tokenize(str(content)):
if each_sent != „“:
temp_sent =
# Entfernen von Link und Interpunktion
jeder_sent = remove_link_punc(jeder_sent.lower())

# Entfernen von Stoppwörtern und Anwendung von Lemmatisierung
for jedes_Wort in jeder_sent.split():
wenn jedes_Wort nicht in stop_words und len(jedes_Wort)>= 3:
temp_sent.append(lemmatizer.lemmatize(jedes_Wort))

# Nur wenn die Länge der Wortliste größer als gleich 5 ist
if len(temp_sent) >= 5:
sentences.append(temp_sent)
Rückgabe Sätze

sent_corpus = data_cleaning(posts)

# Sentence words stats
len_count =
for l in sent_corpus:
len_count.append(len(l))

print(„Gesamtzahl der Sätze : „, len(len_count))
word_sent_df = pd.DataFrame(sorted(Counter(len_count).items()), columns=)
word_sent_df.head(10)

Nach der Bereinigung und Vorverarbeitung der Daten sehen die Daten wie jedes Wort in einer Liste aus. Jede Liste ist eine Darstellung eines Satzes. Genism word2vec benötigt für das Training das Format „Liste von Listen“, wobei jedes Dokument in einer Liste enthalten ist und jede Liste Listen von Token dieses Dokuments enthält.

3. Modelltraining

Nun werden wir das word2vec Modell mit Hilfe der Gensim Bibliothek mit unserem eigenen Datensatz trainieren.

model = Word2Vec(sentences=sent_corpus, size=200, window=4, min_count=1, workers=4)

sentences : hier können wir unseren vorbereiteten Datensatz übergeben, der sent_corpus ist

size : Dimension der generierten Vektorform jedes Wortes, standardmäßig ist die Größe 100.

window : Maximaler Abstand zwischen dem aktuellen und dem vorhergesagten Wort innerhalb eines Satzes, Standardwert ist 5

min_count : Ignoriert alle Wörter, deren Häufigkeit kleiner als min_count ist, Standardwert ist 5. Da wir alle Wörter im Korpus hinzufügen wollten, haben wir den Wert 1 angegeben.

workers : Verwendet so viele Threads, um das Modell zu trainieren. Standardwert ist 3

sg : Wird verwendet, um den Trainingsalgorithmus zu wählen: 1 für skip-gram; 0 für CBOW. Standardmäßig wird CBOW für das Training verwendet.

4. Vektorisiertes Wort

Nachdem das Modelltraining abgeschlossen ist. Wir können nun die vektorisierte Form jedes Wortes erhalten. Es gibt zwei Methoden, um die Vektorform zu erhalten. Die Form des Vektors ist 200 gemäß der angegebenen Größe.

# Get vector form of word king
model.wv.get_vector(‚king‘)

Oder

# Ein anderer Weg, um die vektorisierte Form von word2vec
model.wv.word_vec(‚king‘)

5. Ähnlichkeit und Abstand zwischen zwei Wörtern

Wir werden zwei Listen mit Wörtern „König“, „männlich“ in einer Liste und „Königin“, „weiblich“ in einer anderen Liste erstellen. Wir werden versuchen, herauszufinden, wie ähnlich diese beiden Listenwörter sind.

# Liste der Wortähnlichkeit
model.wv.n_similarity(,)

Hier werden wir schauen, wie groß der Abstand zwischen zwei Wörtern ist.Ähnliche Arten von Wörtern haben weniger Abstand.

# Abstand zwischen zwei Wörtern
model.wv.distance(‚king‘,’queen‘)

Wenn wir ähnliche Wörter erhalten wollen, dann können wir folgenden Code verwenden.

# Ähnliches Wort für König
model.wv.similar_by_word(‚king‘)

6. Andere Techniken unter Verwendung von word2Vec

# Eines aus der Liste der Wörter herausnehmen
model.wv.doesnt_match()

Dies hilft uns, ungerade Wörter in einer Liste zu finden.

# word pairs evaluation
model.wv.evaluate_word_pairs(‚data/SimLex-999/SimLex-999_2.txt‘,)

Dies hilft uns, das Wortpaar zu bewerten

# Wortanalogie aus Wortliste
model.wv.evaluate_word_analogies(‚data/questions-words.txt‘)

Dies wird für die Wortanalogie nützlich sein

7. Laden des trainierten Modells

Wenn wir das trainierte Modell verwenden müssen, kann dies mit dem folgenden Code erreicht werden.

# Loading google pre-train model
from gensim import models

models.KeyedVectors.load_word2vec_format(‚data/GoogleNews-vectors-negative300.bin‘, binary=True)

Hier habe ich versucht, das von Google trainierte Modell zu laden. Wir können es vom Link herunterladen. Dieses Modell ist auch sehr leistungsfähig und trainiert auf riesigen Datensatz.

Für weitere Details über die Implementierung, können Sie einen Blick auf meinen Code auf github.

Danke für das Lesen, lassen Sie mich bitte, wenn Frage oder Zweifel gibt. Ich werde gerne Ihre Fragen beantworten.