Die lexikalische Semantik befasst sich mit der Bedeutung von Wörtern. Statt uns die fast philosophische Frage zu stellen, was die Bedeutung eines Wortes genau ist und diese irgendwie zu kodieren, versuchen wir oft, die Bedeutung eines Wortes durch Beziehungen zu anderen Wörern zu umschreiben. Vorallem Synonyme sind hier sehr hilfreich. Wenn wir mehrere Synonyme, aber vielleicht auch Antonyme und Hypernyme eines Wortes kennen, wird die Bedeutung schnell klar.
Bereits am Anfang des 20. Jahrhunderts bemerkte Wittgenstein, dass die Verwendung eines Wortes sehr viel über seine Semantik verrät. De Saussure präzisiert das mit der Unterscheidung zwischen syntagmatische und paradigmatische Beziehungen zwischen Wörter. Wörter in syntagmatischen Beziehungen, kommen oft zusammen vor, wie Messer und schneiden. Wörter in paradigmatischen Beziehungen kommen in den gleichen Kontexten vor und ähneln sich in ihren syntaktischen und semantischen Eigenschaften. In den fünfziger Jahre wurde diese Idee aufgegriffen, der englische Sprachwissenschaftler John Rubert Firth formulierte die sogenannte Distributionalitätshypothese, die sagt, dass die Bedeutung eines Wortes durch eine Statistik über den Kontexten, in denen es vorkommt, erfasst werden kann.
Erste Implementierungen, die versuchen die Semantik eines Wortes mit einem Merkmalsvektor, der aggregierte Kontexte darstellt, zu erfassen, gibt es ab etwa von Rubenstein und Goodenough (1965), Ruge und Schawarz (1990), Crouch (1990), Crouch und Yang (1992), Grefenstette (1992) und anderen.
Warnung
Das Ausführen der Trainingsphasenin diesem Notebook dauert an einigen Stellen sehr lang! Wenn Sie alles nachbauen wollen, brauchen Sie etwas Geduld. In diesem Tutorial wird ausserdem etwas mehr Vorkenntnisse vorausgesetzt als in den anderen Tutorials.
Um einige Verfahren testen zu können brauchen wir (allgemeinsprachliche) Texte. Einerseits möchten wir möglichst viel Text haben, da Verfahren der distributionellen Semantik mit mehr Daten immer besser werden. Andererseits möchten wir nicht zu viele Texte verarbeiten, um die Verarbeitungs- und Wartezeit nicht ausufern zu lassen.
Auf der Webseite der Abteilung für Computerlinguistik der Universität Leipzig stehen einige geeignete Textkorpora. Von der Seite http://wortschatz.uni-leipzig.de/en/download/ laden wir die Datei deu_wikipedia_2016_300K-sentences herunter.
Wir lesen die Sätze ein und führen sofort eine Tokenisierung aus. Ggf. könnten wir die Wörter auch Lemmatisieren oder Groß- und Kleinschreibung normalisieren. Wir belassen die Wörter jetzt aber so wie wir sie finden.
import codecs
import nltk
sentences = []
quelle = codecs.open('Corpora/deu_wikipedia_2016_300K/deu_wikipedia_2016_300K-sentences.txt','r','utf8')
for line in quelle:
nr,satz = line.split('\t')
sentences.append(nltk.word_tokenize(satz.strip()))
und testen mal einen willkürlichen Satz:
sentences[447]
Wir schreiben eine Funktion, die für eine gegebene Liste von Wörtern einen Vektor mit Kookkurrenzzahlen für eine Reihe anderer Wörter berechnet. Als Liste von Wörtern, mit denen wir die Kookkurrenz berechnen, nehmen wir alle Wörter, die eine festgelegte Mindesthäufigkeit übersteigen. Kookkurrenzen mit seltenen Wörtern werden kaum etwas zum Vergleich zwischen Kontextvektoren beitragen. Ein weiterer Parameter, der festgelegt werden muss, ist die maximale Entfernung zwischen zwei Wörtern um als Kookkurrenz gezählt werden zu können. Wir gehen hier Satzweise vor. Das heißt, dass das letzte Wort eines Satzes und das erste Wort des nächsten Satzes nie als Kookkurrenz gezählt werden. Oft werden bei solchen Verfahren Satzgrenzen nicht berücksichtigt. Ob dies große Unterschiede mit sich bringt ist nicht klar. Ein weiteres Detail, das zu beachten ist, ist dass, wir zuerst die Fenstergröße für die Kookkurrenz berechnen, und dann die relevante Wörter in dem Fenster bestimmen. Alternativ kann man zuerst alle irrelevante Wörter entfernen und dann die Wörter innerhalb vom Fenster bestimmen.
Im Allgemeinen kann ein größeres Fenster ein zu kleines Korpus kompensieren. Außerdem erfasst man mit einem kleineren Fenster mehr syntaktische Eigenschaften eines Wortes, während ein größeres Fenster weitläufigere semantische Beziehungen berücksichtigt.
Wenn alle Kookkurrenzen berechnet sind, normalisieren wir die Länge der Vektoren.
from scipy import sparse
from collections import Counter
import numpy as np
def mag(x):
return np.sqrt(x.dot(x))
def makeCV(words,sentences, window = 2, minfreq = 10):
freq = Counter()
for s in sentences:
freq.update(s)
context_words = [w for w,f in freq.items() if f > minfreq]
for w in words:
if w not in context_words:
context_words.append(w)
dim = len(context_words)
cw2nr = {}
for i in range(dim):
cw = context_words[i]
cw2nr[cw] = i
w2nr = {}
for i in range(len(words)):
w = words[i]
w2nr[w] = i
matrix = sparse.lil_matrix((len(words),dim))
n = 0
for s in sentences:
n+=1
i_s = [cw2nr.get(w,-1) for w in s]
for i in range(len(s)):
w = s[i]
if w in words:
i_w = w2nr[w]
for j in range(max(0,i-window),min(i+window+1,len(s))):
if i != j:
i_cw = i_s[j]
if i_cw > 0:
matrix[i_w,i_cw] += 1
wordvectors = {}
for w,i_w in w2nr.items():
v = matrix[i_w].toarray()[0]
wordvectors[w] = v/mag(v)
return wordvectors
Wir berechnen die Vektoren für einige wenige Wörter:
vectors_count = makeCV(['Kloster','Kirche','Garten','Haus','Hof','Schweden','Deutschland','betrachten','anschauen','beobachten'],sentences,window=2)
Da die Vektoren die gleiche Länge haben, können wir das innere Produkt, das also identisch mit dem Kosinus ist, zum vergleichen nutzen:
# cosinus(vectors['Kirche'],vectors['Kloster'])
print(vectors_count['Schweden'].dot(vectors_count['Deutschland']))
print(vectors_count['Schweden'].dot(vectors_count['Hof']))
Wenn wir den Kosinus zwischen einem Wort und allen anderen Wörtern im Vokabular berechnen, können wir die ähnlichsten Wörter bestimmen. Wir nutzen hierzu eine geordnete Liste. Da diese immer aufsteigend sortiert ist, sortieren wir nach $-1 \cdot cosinus$.
import bisect
def most_similar(word,vectors,n):
best = []
vec_w = vectors[word]
for z in vectors:
if z == word:
continue
sim = vec_w.dot(vectors[z])
#best.append((z,sim))
if len(best) > n:
opt,_ = best[-1]
else:
opt = 0
if -sim < opt:
bisect.insort_left(best,(-sim,z))
best = best[:n]
#best = sorted(best, key=lambda x: x[1], reverse = True)[:n]
return [(w,-sim) for (sim,w) in best]
most_similar('Garten',vectors_count,3)
Interessanter werden diese Listen natürlich, wenn wir Vektoren für mehr Wörter berechnen. Hierfür wählen wir alle Wörter aus, die nicht zu selten und nicht zu häufig sind, also die Wörter, die inhaltlich interessant sind.
wortfrequenz = Counter()
for satz in sentences:
wortfrequenz.update(satz)
vocabulary = [w for w,f in wortfrequenz.items() if 50 < f < 2000]
vocabulary_size = len(vocabulary)
print(vocabulary_size)
vectors_count = makeCV(vocabulary,sentences,window=2)
most_similar('Garten',vectors_count,10)
most_similar('betrachten',vectors_count,10)
most_similar('Schweden',vectors_count,10)
most_similar('Direktor',vectors_count,10)
Die Beispiele sehen zwar ganz nett aus, aber wie gut sind unsere Vektoren wirklich? Es gibt eine Reihe von Tests, die man durchführen kann, um die Qualität der Vektoren zu überprüfen. Eine Art von Test ist es, die berechnete Ähnlichkeit, zwischen zwei Wörtern zu vergleichen mit der Ähnlichkeit, die Probanden für Wortpaare angegeben haben. Um die Ähnlichkeit zu prüfen können wir einfach die Korrelation nutzen.
Ein Datensatz mit Ähnlichkeitseinschätzungen für Deutsche Wortpaare ist der sogenannte Gur350 Datensatz, der von der Arbeitsgruppe von Prof. Dr. Iryna Gurevych an der TU Darmstadt zusammengestellt wurde. Weitere Informationen und ein Link für den Download finden Sie hier: https://www.informatik.tu-darmstadt.de/ukp/research_6/data/semantic_relatedness/german_relatedness_datasets/index.en.jsp
Die Daten geben nicht eine Ähnllichkeit zwischen den Wörtern sondern eine Verwandschaft, was nicht ganz das Gleiche ist. Für die Evaluierung nutzen wir nur die Wortpaare, für die beide Worte in unserem Vokabular enthalten sind.
import math
testfile = codecs.open('Corpora/wortpaare350.gold.pos.txt','r','utf8')
testfile.readline()
testdata = []
for line in testfile:
w1,w2,sim,p1,p2 = line.split(':')
if w1 in vocabulary and w2 in vocabulary:
testdata.append((w1,w2,float(sim)))
def evaluate(data,vectors):
gold = []
predicted = []
for v,w,sim in data:
pred = vectors[v].dot(vectors[w])
gold.append(sim)
predicted.append(pred)
#print(v,w,pred,sim,sep = '\t')
av_p = sum(predicted)/len(predicted)
av_g = sum(gold)/len(gold)
cov = 0
var_g = 0
var_p = 0
for s,t in zip(gold,predicted):
cov += (s-av_g) * (t-av_p)
var_g += (s-av_g) * (s-av_g)
var_p += (t-av_p) * (t-av_p)
return cov / math.sqrt(var_g*var_p)
evaluate(testdata,vectors_count)
Trotz der gut aussehenden Listen, die wir weiter oben generiert haben, sehen wir, dass die berechnete Ähnlichkeiten mit den Ähnlichkeitsurteilen nur sehr schwach korrellieren.
Wir nehmen noch einen zweiten Datensatz zum testen. Von http://textmining.wp.hs-hannover.de/datasets.html können Sie eine Liste STW German Synonyms herunterladen. Diese Liste enthält 132 Wortpaare. In der Hälfte der Fälle sind beide Wörter alternative Benennungen für das gleiche Konzept in dem Standard Thesaurus Wirtschaft. In den anderen Fällen wurden die Begriffe willkürlich zusammengesucht. Die positive Fälle sind also Synonyme oder stark verwandte Wörter, während die negeative Fälle semantisch unähnliche sein sollten. Wenn wir jetzt für jedes Paar die Ähnlichkeit berechen und die Liste absteigend nach Ähnlichkeit sortieren, sollten die positive Paare oben stehen und die negative unten. Die Area under the ROC-Curve (AUC) ist ein Maß, das genau angibt inwiefern das auch tatsächlich der Fall ist.
Wir lesen die Liste ein und schreiben eine zweite Evaluierungsfunktion.
import numpy as np
from sklearn import metrics
stw = codecs.open('Corpora/STW-Syn.txt','r','utf8')
testdata_stw = []
for line in stw:
w1,w2,sim = line.strip().split('\t')
if w1 in vocabulary and w2 in vocabulary:
testdata_stw.append((w1,w2,sim))
def evaluate_bin(data,vectors):
labels = []
predictions = []
for v,w,sim in data:
pred = vectors[v].dot(vectors[w])
labels.append(sim)
predictions.append(pred)
fpr, tpr, thresholds = metrics.roc_curve(labels, predictions, pos_label='+')
return metrics.auc(fpr, tpr)
evaluate_bin(testdata_stw,vectors_count)
Das Ergebnis ist ähnlich, wie beim ersten Datensatz: wir sind etwas besser als man durch Zufall erwarten würde, aber nicht sehr viel.
Unser erster Versuch bietet noch verschiedene Optimierungsmöglichkeiten. Zunächst nutzen wir nicht die einfache Kookkurrenzhäufigkeiten sondern die Positive Pointwise Mutual Information (PPMI). Die Pointwise Mutual Information zwischen zwei Wörter a und b ist im Prinzip das Verhältnis zwischen der tatsächlichen Wahrscheinlichkeit, dass sie zusammen vorkommen, und die erwartete Wahrscheinlicheit, dass sie zusammen vorkommen, wenn ihre Vorkommen unabhängig voneinander wären. Wir definieren $pmi(a,b) = log(\frac{p(ab)}{p(a)p(b)})$. Die ppmi(a,b) ist nun die pmi(a,b), wenn dieser Wert positiv ist, und sonst 0. Die Benutzung der ppmi beruht auf der Annahme, dass nur die Tatsache, dass Wörter häufiger als erwartet zusammen vorkommen interessant ist, während geringere Wahrscheinlichkeiten vermutlich eher auf Zufall beruhen oder jedenfalls nichts interesantes über Wortpaare aussagen.
Ein Problem unseres naiven Ansatzes war, dass die Vektoren extrem lang sind. Die Vektoren brauchen nicht nur sehr viel Speicheplatz. Viele der Dimensionen enthalten auch wenig oder nur redundante Informationen. Dieses Problem kann durch die Anwendung eines gängigen Dimensionsreduktionsverfahren gelöst werden. Hierunten werden wir hierfür Singular Value Decomposition nutzen und anschließend die wichtigste 100 Dimensionen nutzen.
from sklearn.decomposition import TruncatedSVD
import math
def makeCV_SVD(words,sentences, window = 2, minfreq = 10, size =256):
N = 0
freq = Counter()
for s in sentences:
N += len(s)
freq.update(s)
context_words = [w for w,f in freq.items() if f > minfreq]
for w in words:
if w not in context_words:
context_words.append(w)
dim = len(context_words)
cw2nr = {}
for i in range(dim):
cw = context_words[i]
cw2nr[cw] = i
w2nr = {}
for i in range(len(words)):
w = words[i]
w2nr[w] = i
matrix = sparse.lil_matrix((len(words),dim))
n = 0
for s in sentences:
n+=1
i_s = [cw2nr.get(w,-1) for w in s]
for i in range(len(s)):
w = s[i]
if w in words:
i_w = w2nr[w]
for j in range(max(0,i-window),min(i+window+1,len(s))):
if i != j:
i_cw = i_s[j]
if i_cw > 0:
matrix[i_w,i_cw] += 1
probabilities = []
for cw in context_words:
probabilities.append(freq[cw]/N)
N2 = matrix.sum()/2
(rows,cols) = matrix.nonzero()
for i_w,i_cw in zip(rows,cols):
p_w = probabilities[i_w]
p_cw = probabilities[i_cw]
p = matrix[i_w,i_cw]/N2
ppmi = max(0,math.log(p/(p_w * p_cw * 2 * window) ))
matrix[i_w,i_cw] = ppmi
svd = TruncatedSVD(n_components=size)
svd.fit(matrix)
matrix = svd.transform(matrix)
wordvectors = {}
for w,i_w in w2nr.items():
v = matrix[i_w]
wordvectors[w] = v/mag(v)
return wordvectors
vectors_SVD = makeCV_SVD(vocabulary,sentences,window=2,size=100)
most_similar('Garten',vectors_SVD,10)
most_similar('betrachten',vectors_SVD,10)
most_similar('Schweden',vectors_SVD,10)
most_similar('Park',vectors_SVD,10)
Wir sehen jetzt, dass Park hier nicht mehr als Synonym von Garten interpretiert wird, sondern vielmehr als Bestandteil von Englischen Ortsbezeichnungen wahrgenommen wird. Der Kontext 'Englische Wörter' hat offenbar an Bedeutung gewonnen.
evaluate(testdata,vectors_SVD)
evaluate_bin(testdata_stw,vectors_SVD)
Die Optimierung war offenbar erfolgreich: sowohl die Korrellation im ersten Test als die AUCH im zweiten Test sind deutlich größer geworden. Überblicke über die Kombinationen von Parametern, Trainingsmengen usw., die zu optimalen Ergebnissen führen geben beispielsweise Bullinaria und Levy (2007), Mohammad und Hirst (2012), Bullinaria und Levy (2012) und Kiela und Clark (2014)
Eine relativ wenig beachtete Alternative bietet Random Indexing (Karlgren und Sahlgren, 2004). Beim Random Indexing wird jedes Wort zunächst durch einen relativ kurzer Vektor dargestellt. Fast alle Werte in diesem Vektor sind 0 und einige zufällige Dimensionen bekommen den Wert 1 oder -1. Jedes Wort bekommt hiermit einen zufällig gewählten Fingeabdruck. Wir nennen diese Vektoren die Randomvektoren.
Um einen sinnvollen Wortvektor für ein Wort $w$ zu berechnen, addieren wir alle Randomvektoren der Wörter, die im Kontext von $w$ vorkommen.
Der Vorteil des Random Indexings ist, dass wir nicht erst komplette Kokkurrenzmatrizen aufgebaut haben müssen, sondern dass wir vom Anfang an kurze Wortvektoren haben und diese sukzessive aufbauen können.
import numpy
import random
def makeCVri(words,sentences, window = 2, minfreq = 10, size =256):
freq = Counter()
for s in sentences:
freq.update(s)
context_words = [w for w,f in freq.items() if f > minfreq]
for w in words:
if w not in context_words:
context_words.append(w)
randomvectors = {}
for cw in context_words:
v = numpy.zeros(shape=(size,))
for i in range(3):
r = random.randrange(0,size)
v[r] = 1
for i in range(3):
r = random.randrange(0,size)
v[r] = -1
randomvectors[cw] = v #sparse.csr_matrix(v)
wordvectors = {}
for w in words:
v = numpy.zeros(shape=(size,))
wordvectors[w] = v
for s in sentences:
for i in range(len(s)):
w = s[i]
if w in words:
for j in range(max(0,i-window),min(i+window+1,len(s))):
if i != j:
cw = s[j]
if cw in context_words:
wordvectors[w] += randomvectors[cw]
for w in wordvectors:
wordvectors[w] = wordvectors[w]/mag(wordvectors[w])
return wordvectors
vectors_ri = makeCVri(vocabulary,sentences,window=2,size=100)
most_similar('Garten',vectors_ri,10)
most_similar('betrachten',vectors_ri,10)
most_similar('Schweden',vectors_ri,10)
most_similar('Direktor',vectors_ri,10)
most_similar('Park',vectors_ri,10)
evaluate(testdata,vectors_ri)
evaluate_bin(testdata_stw,vectors_ri)
Die Ergebnisse sind, jedenfalls im ersten Test, schlechter als die, die wir mit den anderen Vektoren erzielt haben. Im zweiten Test sind de Ergebnisse vergleichbar mit denen aus den ersten Vektoren ohne PPMI und SVD. Wir haben es also geschafft ohne viel Qualitätsverlust mit wesentlich kürzeren Vektoren zu arbeiten, aber haben nicht die Vorteile der PPMI Gewichtung und der SVD. Da wir mit Random Indexing leichter größere Korpora verarbeiten können als mit den vorherigen Verfahren, kann Random Indexing trotzdem sinnvolle Ergebnisse liefern.
Die bisherige Versuche haben alle das Problem, dass jede Dimension beim Vergleich von zwei Vektoren genau so stark berücksichtigt wird. Dabei kann es aber sein, dass manche Dimensionen sehr wichtig sind um Wörter voneinander zu unterscheiden, während andere vielleicht für fast alle Wörter gleich sind. Eine geniale Idee, dies zu verbessern stammt von Mikolov et al. (2013) und wurde von Google patentiert. Jedes Wort wird zunächst durch einen kurzen (einige dutzende bis einige hunder Dimensionen) zufällig initialisierten Vektor dargestellt. Jetzt wird ein Classifier trainiert, der aus einem Wort ein Wort im Kontext vorhersagen kann (oder andersherum). In jedem Schritt werden die Werte der Wortvektoren ein wenig angepasst, damit diese Vorhersage besser klappt. Wenn wir ausgehend von einem Wort versuchen die Kontextwörter vorherzusagen, nennen wir das Model ein Skip Gram Model. Wenn wir versuchen aus den Kontextwörter das Zielwort vorherzusagen wird das Model ein Continuous Bag of Words genannt.
Um dieses aufwändige Verfahren zu implementieren eignen sich künstliche neuronale Netze besonders gut. Wir implementieren hier die Grundidee mit der Keras-Bibliothek für Deep Learning.
Damit die Rechenzeit einigermaßen handhabbar bleibt, berücksichtigen wir für den Kontext nur die Wörter aus unserem Vokabular. Wir schließen also sowohl seltene Wörter als auch hochfrequente Wörter aus. Bei den word2vec-Verfahren berechnen wir Wortvektoren für alle Wörter, die wir irgendwie berücksichtigen. Wir unterscheiden also nicht zwischen Zielwörter und Kontextwörter, wie in den vorherigen Verfahren.
Die Archirektur unseres Netzes besteht aus drei Schichten: in der ersten Schicht haben wir für jedes Wort genau ein Knoten. In dieser Schicht wird immer ein Knoten aktiviert. Unser Vokabular muss also vorher bekannt sein und kann nicht erweitert werden. Die zweite Schicht hat genau so viele Konten, wie unsere Wortvektoren Dimensionen haben sollen. Für jedes Wort, bzw. Knoten in der ersten Schicht werden Gewichte für jeden Knoten in dieser zweiten Schicht gelernt. Diese Gewichte sind genau die Werte, die wir später für die Darstellung der Wörter verwenden können. Keras bietet einen speziellen Schichttyp um diese mittlere Schicht samt der Aktivierung durch einen einzelnen Knoten im ersten Schicht an: keras.layers.Embedding.
Die letzte Schicht hat wieder so viele Knoten wie es Wörter gibt. Die Gewichte der Knoten geben hier, für ein gewähltes Ausgangswort, eine Art Wahrscheinlichkeit, dass das Wort das mit einem Knoten in dieser Schicht korrespondiert im Kontext vorkommt. Keras hat für diesen Fall eine spezielle Loss-Funktion (eine Funktion, die berechnet, wie groß der Unterschied zwischen dem aktuellen und gewünschten Ergebnis ist). Als Ergebnis brauchen wir lediglich die Nummer des Knotens, der die höchste Wahrscheinlichkeit haben soll, anzugeben.
Da Wörter jetzt zu durchnummerierten Knoten gehören, geben wir allen Wörtern im Vokabular eine Nummer und erstellen eine Liste von Paare von Wortnummern: jeweils die Nummer eines Wortes als Eingabe und die Nummer eines Kontextwortes als Ziel.
Wir müssen die Daten jetzt mehrfach durch das Netz schicken, damit wir sinnvolle Gewichte bekommen. Wir brechen das hier nach 5 Durchgänge ('Epochen') ab. Da die Ergebnisse immer noch besser werden, sollten wir eigentlich noch einige weitere Durchgänge machen.
embedding_size = 100
window_size = 2
word2id = {w:vocabulary.index(w) for w in vocabulary}
def make_skipgram_data(sents,window):
x = []
y = []
for sent in sents:
for i in range(len(sent)):
w = sent[i]
if w not in word2id:
continue
for j in range(max(0,i-window),min(len(sent),i+window+1)):
if i == j:
continue
cw = sent[j]
if cw not in word2id:
continue
x.append(word2id[w])
y.append(word2id[cw])
return x,y
sgdata, sglabels = make_skipgram_data(sentences,window_size)
import tensorflow as tf
def make_vectors_sg():
model = tf.keras.Sequential([
tf.keras.layers.Embedding(vocabulary_size, embedding_size,name = "embedding"),
tf.keras.layers.Dense(vocabulary_size, activation='softmax'),
])
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')
model.fit(sgdata, sglabels, epochs=5)
embed_layer = model.get_layer(name = "embedding")
id_embeddings = embed_layer.get_weights()[0]
word_embeddings = {}
for word in word2id:
wid = word2id[word]
vect = id_embeddings[wid]
word_embeddings[word] = vect /mag(vect)
return word_embeddings
vectors_sg = make_vectors_sg()
most_similar('Garten',vectors_sg,10)
most_similar('betrachten',vectors_sg,10)
most_similar('Schweden',vectors_sg,10)
most_similar('Direktor',vectors_sg,10)
most_similar('Park',vectors_sg,10)
evaluate(testdata,vectors_sg)
evaluate_bin(testdata_stw,vectors_sg)
Die Ergebnisse der Evaluierung sind jetzt nochmal wesentlich besser.
Die Ergebnisse unserer einfachen Implementierung sind zwar gut, aber das Training kostet sehr viel Zeit und wir haben viele häufige Wörter nicht berücksichtigt. Würden wir alle Wörter, die mindestens 10 mal vorkommen berücksichtigen, hätten wir etwas 10 mal so viele Trainingsdaten und würden nochmal wesentlich mehr Zeit zum trainieren brauchen. Es gibt aber einen Trick, um effizient mit häufigen Wörtern umzugehen: wir berücksichtigen nicht jedes Wortpaar, sondern wählen zufällig Wortpaare aus, wobei die Wahrscheinlichkeit dass ein Kontextwort gewählt wird, kleiner wird, wenn seine Häufigkeit im Korpus größer ist. In der Architektur vom Netz und in der Loss-Funktion können noch einige Optimierungen vorgenommen werden. Es gibt verschiedene Bibliotheken, die das bereits alles effizient implementiert haben. Wir schauen uns zum Schluss die Gensim Bibliothek an, und nehmen die gleiche Parameter, die wir auch für die frühere Modelle genutzt haben:
import gensim
model = gensim.models.Word2Vec(sentences, min_count=10, window=2,size = 100)
print(model.wv.similarity('Kirche','Kloster'))
print(model.wv.similarity('Kirche','Schweden'))
print(model.wv.similarity('Deutschland','Schweden'))
model.wv.most_similar(positive=['Garten'], topn=10)
model.wv.most_similar(positive=['Park'], topn=10)
model.wv.most_similar(positive=['betrachten'], topn=10)
model.wv.most_similar(positive=['Schweden'], topn=10)
model.wv.most_similar(positive=['Direktor'], topn=10)
Da das Model selber eine Methode most similar hat und wir nicht direkt mit den Vektoren arbeiten, müssen wir unsere Evaluierungsfunktion etwas anpassen:
def evaluate_w2v(data,model):
gold = []
predicted = []
for v,w,sim in data:
pred = model.wv.similarity(v,w)
gold.append(sim)
predicted.append(pred)
#print(v,w,pred,sim,sep = '\t')
av_p = sum(predicted)/len(predicted)
av_g = sum(gold)/len(gold)
cov = 0
var_g = 0
var_p = 0
for s,t in zip(gold,predicted):
cov += (s-av_g) * (t-av_p)
var_g += (s-av_g) * (s-av_g)
var_p += (t-av_p) * (t-av_p)
return cov / math.sqrt(var_g*var_p)
def evaluate_bin_w2v(data,model):
labels = []
predictions = []
for v,w,sim in data:
pred = model.wv.similarity(v,w)
labels.append(sim)
predictions.append(pred)
fpr, tpr, thresholds = metrics.roc_curve(labels, predictions, pos_label='+')
return metrics.auc(fpr, tpr)
evaluate_w2v(testdata,model)
evaluate_bin_w2v(testdata_stw,model)
Das Ergebnis ist hier etwas schlechter als bei der einfachen Implementerung mit Keras. Wir sollten hieraus aber nicht schließen, dass diese Implementierung besser ist als die Gensim-Bibliothek. Vielmehr zeigt es, dass die Evaluierung mit zwei kleinen Datensätze nicht sehr aussagekräftig ist.
Welches Verfahren die Beste Ergebnisse liefert, ist ohnehin nicht ganz einfach zu ermitteln. Neben dem Verfahren spielen die gewählte Einstellungen und die Trainingsdaten eine große Rolle. Wir haben hier für alle Verfahren etas die gleiche EInstellungen gewählt. Dabei ist aber nicht gesagt, dass diese Einstellungen für jedes Verfahren, für unsere Traningsdaten und Testaufgaben optimal sind. Eine interessante Diskussion über den Einfluss der Parameter und Trainigsdaten geben Levy, Goldberg und Dagan (2015).
Rubenstein, H., & Goodenough, J. B. (1965). Contextual Correlates of Synonymy. Commun. ACM, 8(10), 627–633.
Ruge, G., & Schwarz, C. (1990). Linguistically based term associations—A new semantic component for a hyperterm system. Proceedings of 1st International ISKO-Confercence, Darmstadt, 88-96.
Crouch, C. J. (1990). An approach to the automatic construction of global thesauri. Information Processing & Management, 5, 629–640.
Crouch, C. J., & Yang, B. (1992). Experiments in automatic statistical thesaurus construction. In Proceedings of the 15th annual international ACM SIGIR conference on Research and development in information retrieval (pp. 77-88). ACM.
Grefenstette, G. (1992). Use of syntactic context to produce term association lists for text retrieval. 89–97.
Karlgren, J., & Sahlgren, M. (2001). From Words to Understanding. In Foundations of Real-World Intelligence (S. 294–308). CSLI Publications.
Bullinaria, J. A., & Levy, J. P. (2007). Extracting semantic representations from word co-occurrence statistics: A computational study. Behavior research methods, 39(3), 510-526.
Mohammad, S. M., & Hirst, G. (2012). Distributional measures of semantic distance: A survey. arXiv preprint arXiv:1203.1858.
Bullinaria, J. A., & Levy, J. P. (2012). Extracting Semantic Representations from Word Co-occurrence Statistics: Stop-lists, Stemming and SVD. Behaviour Research Methods, 44(3), 890–907.
Mikolov, T., Sutskever, I., Chen, K., Corrado, G. S., & Dean, J. (2013). Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems (pp. 3111-3119).
Kiela, D., & Clark, S. (2014). A Systematic Study of Semantic Vector Space Model Parameters. In 2nd Workshop on Continuous Vector Space Models and their Compositionality (CVSC).
Levy, O., Goldberg, Y., & Dagan, I. (2015). Improving distributional similarity with lessons learned from word embeddings. Transactions of the Association for Computational Linguistics, 3, 211-225.