Skip to main content

Word Embeddings

Word Embeddings sind eine Methode der distributionellen Semantik und gehört zu den Methoden des Machine Learning. Jedem Wort wird dazu ein Vektor (mit etwa 300 Dimensionen) zugewiesen und diese Wortvektoren werden dann in einen mehrdimensionalen Vektorraum projiziert. Das trainierte Modell ordnet die Vektoren dabei so an, dass semantisch ähnliche Wörter nah beieinander im Raum liegen und semantisch nur wenig oder unverwandte Wörter weit(er) auseinanderliegen. Aussschlaggebend für die Anordnung der Wörter und somit die Grundlage auf denen das Modell (es gibt allerdings viele verschiedene trainierte Modelle, beispielsweise für spezifische Textsorten) trainiert wird, ist der Kontext der Wörter. Wörter, die in einem ähnlichen Kontext vorkommen, werden im Vektorraum nah beieinander projiziert. Dies bedeutet also, dass der Kontext die Semantik der Wörter formt bzw. massgeblich beeinflusst.

Eines der grundlegendsten Paper zu Word Embeddings stammt von Mikolov et al. (2013).

Libraries installieren​

Gensim​

Gensim ist eine Python-Bibliothek erstellt von Radim Řehůřek, die sehr viele Möglichkeiten für die semantische Verarbeitung von Rohtexten bereithält, insbesondere Word-Embeddings. Die Dokumentation von Gensim finden Sie hier.

Vorbereitung​

Installieren Sie folgende Libraries, um die Skripte ausführen zu können:

pip install gensim
pip install plotly

Word Embeddings berechnen​

word2vec_model.py​

Dieses Skript erstellt ein Word Embedding Model und speichert es ab. Als Input geben Sie ein .vrt File an, in welchem auf jeder Zeile ein lemmatisiertes Dokument steht, wie es mit Promethia und der anschliessenden Konvertierung mit vrt2docperline.py erzeugt werden kann.

python3 word2vec_model.py inputfile.txt

Der Namen des Outputfiles entspricht dem Namen des Inputfiles; das Outputfile hat die Endung .word_vectors, ist aber grundsätzlich gleich lesbar wie ein .txt file.

"""
Skript um ein Word-Embedding Modell von einem Korpus zu erstellen.

Quelle und weiterführende Informationen:
https://radimrehurek.com/gensim/models/word2vec.html

Input:
	.vrt Datei, welche ein lemmatisiertes Dokument pro Zeile enthält

Output:
	.word_vectors Datei, welche die Vektoren eines Modells enthält
"""

import argparse
from gensim.models import Word2Vec


def create_we_model(infile):

	# in diesem Block kannst du ein neues Modell erstellen und speichern
	data_lemmatized = []
	with open(infile, "r", encoding="utf8") as in_file_open:
		# liest die einzelnen Zeilen ein und entfernt Leerzeichen
		lines = in_file_open.readlines()
		for line in lines:
			line_splitted = line.strip().split(" ")
			data_lemmatized.append(line_splitted)
	print("calculating models now")

	# Diese Parameter sind anpassbar. Insbesondere kann es sinnvoll sein, den min_count nicht auf 1 zu setzen,
	# um eine gewisse Grundlage für die Berechnungen der Vektoren sicherzustellen.
	model = Word2Vec(sentences= data_lemmatized, vector_size=300, window=5, min_count=10, workers=4)

	# Man kann das Modell als Vektoren speichern, wenn sie nicht mehr weiter trainiert werden sollen.
	word_vectors = model.wv

	# die Flag binary = False speichert die Vektoren im txt Format
	name_output=infile.split('.')[0]+".word_vectors"
	word_vectors.save_word2vec_format(name_output, binary = False)

if __name__ == "__main__":
	parser = argparse.ArgumentParser(description="Erstellt und speichert ein Word Embeddings-Modell im .txt Format")
	parser.add_argument("in_file", type=str, help="Input-Datei: Lemmatisierte Dokumente im .vrt Format")
	args = parser.parse_args()
	create_we_model(args.in_file)

word2vec_basics.py​

Dieses Skript enthält Bausteine, mit denen einige Funktionen von Word Embeddings in gensim ausprobiert werden können.

python3 word2vec_basics.py inputfile.word_vectors

Die Resultate der kleinen Fragen an das Modell werden im Terminal ausgegeben.

"""
Skript, um Grundoperationen mit Word Embeddings kennenzulernen.

Quelle und weiterführende Informationen:
https://radimrehurek.com/gensim/models/word2vec.html

Input:
	.word_vectors Datei, welche z.B. mit dem Skript create_we_model.py erstellt wurde.
	Das .txt Format ist default, falls man ein binary-File verwenden möchte, muss die
	Flag in Zeile 21 angepasst werden.

Output:
	Informationen in der Command Line / im Terminal
"""

import argparse
from gensim.models import KeyedVectors


def we_basics(infile):
    model = KeyedVectors.load_word2vec_format(infile, binary=False)

    # In diesem Block kann man ähnliche Vektoren zu
    # einem gegebenen token ausgeben, hier z.B. die 10 nächsten zum
    # Vektor des Wortes 'Schule'
    sims = model.most_similar('Schule', topn=10)
    print('Ähnliche Vektoren zu "Schule":')
    print(sims)

    """
    # In diesem Block kann man mit den Word-Embeddings Vektorberechnungen durchführen.
    # Also zum Beispiel die Vektoren von 'Frau' und 'König' addieren, und danach 'Mann' abziehen.
    # Danach wird das Wort des passendsten Vektor ausgegeben. Klappt natürlich nur mit Vektoren, die 
    # im Text vorkommen, und ist erst ab einer gewissen Korpusgrösse sinnvoll.
    result = model.most_similar_cosmul(positive = ['Frau', 'König'], negative = ['Mann'])
    most_similar_key, similarity = result[0]  # look at the first match
    print(f"{most_similar_key}: {similarity:.4f}")
    """

    """
    # Auch die Ähnlichkeit zweier Vektoren kann man berechnen. 
    similarity = model.similarity('Hund', 'Katze')
    print(similarity)
    """


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Enthält Bausteine für einfache Operationen mit Word Embeddings")
    parser.add_argument("in_file", type=str, help="Input-Datei: Word Embeddings Modell im word_vectors Format")
    args = parser.parse_args()
    we_basics(args.in_file)

word2vec2tsv.py​

Mit diesem Skript kann das Word Embedding Modell auf die Visualisierung mit dem Tensorflow Projector vorbereitet werden. Es konvertiert vom .word_vectors-Format ins .tsv-Format.

python3 word2vec2tsv.py model.word_vectors vectors.tsv metadata.tsv
"""
Skript, um Vektoren aus einem word_vectors Format in ein tsv-Format umzuschreiben.

Input:
    - Datei im word_vectors Format
    - Name der .tsv-Datei, die die Vektoren enthalten soll
    - Name der .tsv-Datei, die die MEtadaten zu den Vektoren enthalten soll

Output:
    - .tsv-Datei, die die Vektoren enthalten soll
    - .tsv-Datei, die die Metadaten zu den Vektoren enthalten soll
"""

import argparse
import csv

def wvec2tsv(infile, outf_vecs, outf_meta):
    with open(infile, "r", encoding='utf-8') as vec_file:
        with open(outf_vecs, "w", encoding='utf-8') as vec_tsv:
            with open(outf_meta, "w", encoding='utf-8') as meta_tsv:
                tsv_writer1 = csv.writer(vec_tsv, delimiter='\t')
                tsv_writer2 = csv.writer(meta_tsv, delimiter='\t')
                # erste Linie überspringen, sie ist ohne relevanten Inhalt
                line = vec_file.readline()
                line = vec_file.readline()
                currvec = line.strip().split(' ')
                counter = 0
                while line:
                    counter += 1
                    if currvec[0] == "":
                        break
                    tsv_writer2.writerow([currvec[0]])
                    currvec.pop(0)
                    tsv_writer1.writerow(currvec)
                    currvec = vec_file.readline().strip().split(' ')
                print("Done!")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Konvertiert .word_vectors format zu .tsv")
    parser.add_argument("infile", type=str, help="Input-Datei: Datei im word_vectors Format")
    parser.add_argument("outf_vecs", type=str, help="Output-Datei: enthält die Vektoren der Word-Embeddings")
    parser.add_argument("outf_meta", type=str, help="Output-Datei: enthält die Metadaten zu den Vektoren der Word-Embeddings")
    args = parser.parse_args()
    wvec2tsv(args.infile, args.outf_vecs, args.outf_meta)

Literatur

  • Installationsanleitung und Skripte übernommen von KoDuP.