def readVectorFile(word_list, vectors_file, filter=True):
"""Reads a vector file."""
w("Reading VectorFile %s..." %(vectors_file))
D = {}
fl()
with codecs.open(vectors_file, "r", "utf-8") as fin:
for i, line in enumerate(fin):
wil("Reading VectorFile %s - %i lines so far%s"
%(vectors_file, i+1), 20)
vector = [x for x in line.split() if x]
# die ersten zwei zeilen einer word2vec vector-datei kann man ignorieren.
# sie sind nur ein paar informationen zur anzahl der vektoren und
# der vektor </s> (anzahl der zeilen im korpus)
if i > 1:
# hier werden diejenigen vektoren rausgefiltert, die nicht
# im wörterbuch sind
if filter:
if vector[0] in word_list:
D[vector[0]] = [float(x) for x in vector[1:]]
del word_list[word_list.index(vector[0])]
elif not filter:
D[vector[0]] = [float(x) for x in vector[1:]]
fl()
wil("Reading VectorFile %s...Complete!%s\n" %(vectors_file), 30)
return D
def falseFriendsCheck(false_friends, vectorManager, model, devectors, envectors,
dictionary, sample_size, output=True):
ff_sim = 0
r_sim = 0
false_friends = randomSubset(false_friends, sample_size, output)
random_set = randomSubset(dictionary, sample_size, output)
if output:
w("\nChecking the quality of an evaluation with "\
"false-friend-pairs...\n")
# Calculates average similarity for random false friend subset
ff_count = 0
for pair in false_friends:
try:
vector_english = envectors[pair[0]]
vector_german = devectors[pair[1]]
except:
continue
mapped = mapVector(vectorManager, model, vector_english)
mapped = [x.item((0, 0)) for x in mapped]
ff_sim += dotproduct(mapped, vector_german)
ff_count += 1
ff_sim /= ff_count
# Calculates similarity for random dictionary entry subset
r_count = 0
for pair in random_set:
if random_set.index(pair) > ff_count:
break # so both subsets have the same size and are comparable
try:
vector_english = envectors[pair[1]]
vector_german = devectors[pair[0]]
except:
continue
mapped = mapVector(vectorManager, model, vector_english)
mapped = [x.item((0, 0)) for x in mapped]
r_sim += dotproduct(mapped, vector_german)
r_count += 1
r_sim /= r_count
if ff_sim < r_sim:
return True
else:
return False
def writeTupleFile(tuples, output_file, separation_character="\t",
printErrors=True):
"""Enhanced function for writing a tuple file."""
file = codecs.open(output_file, "w", "utf-8")
for i in xrange(len(tuples)):
percentage = i*1.0/len(tuples)*100
wil("Writing file %s - %.2f%% complete"
%(output_file, percentage), 50)
try:
file.write(unicode(tuples[i][0]) + separation_character +
unicode(tuples[i][1]) + "\n")
except Exception, ex:
if printErrors:
w("%s: %s" %(str(ex), str(tuples[i])))
continue
finally:
def main():
cl()
wh("\t\tCrOssinG: CompaRing Of AngliciSmS IN German", 75)
dictionary = readDictionary("../res/dictEntries.txt")
anglicisms = readTupleFile("../res/anglicisms.txt")
devectors = pickle.load(open("../res/DE_VEC.bin"))
envectors = pickle.load(open("../res/EN_VEC.bin"))
false_friends = readTupleFile("../res/false_friends.txt")
alphas = [0.0001, 0.0002, 0.001, 0.002, 0.01, 0.02, 0.1, 0.2]
models = ["ridge", "net", "Lasso"]
model_paras = [(model, alpha) for model in models for alpha in alphas]
i = 1
w("Creating VectorTransformators...\n")
vm = VectorManager.VectorTransformator()
vm.Dictionary = dictionary
vm.V = devectors
vm.W = envectors
for tuple_ in model_paras:
vm.createTransformationMatrix(tuple_[0], tuple_[1])
w("VectorTransformator Nr. %i with Model=%s and alpha=%g has been"
" created\n" %(i, tuple_[0], tuple_[1]))
i += 1
w("Creating VectorTransformators...Complete!\n\n")
models = vm.Models
top_model = compareMatrices(false_friends, vm, models, devectors, envectors)
w("\nChecking the quality of an evaluation with false-friend-pairs...\n")
true_count = 0
false_count = 0
n_tests = 100
for i in range(n_tests):
wil("False friend test nr. %i" %(i+1))
res = falseFriendsCheck(false_friends, vm, top_model, devectors,\
envectors, dictionary, 50, False)
if res:
true_count += 1
elif not res:
false_count += 1
w("\nIn %i out of %i times, a random subset had a lower or equal average"\
"similarity than a random false friend subset.\n" %(false_count, n_tests))
def randomSubset(array, n, output=True):
if output:
w("Creating random subset...")
if isinstance(array, dict):
# conversion to array of tuples
keys = array.keys()
values = array.values()
length = len(array)
array = [(keys[i], values[i]) for i in xrange(length)]
res = []
while len(res) != n:
if output:
percentage = len(res)*1.0/n*100
wil("Creating random subset - %.2f%% complete" %(percentage))
ri = random.randint(0, len(array)-1)
res.append(array[ri])
if output:
fl()
if output:
wil("Creating random subset...Complete!", 50, "\n")
return res
def compareMatrices(false_friends, vm, models, devectors, envectors):
""" Compares differend matrices and finds the best one """
average_diffs = []
for model in models:
diff = evalMatrix(false_friends, devectors, envectors, vm, model,\
output=False)
average_diffs.append(diff)
top_average_diff = 200
for diff in average_diffs:
if diff <= top_average_diff: top_average_diff = diff
i = average_diffs.index(top_average_diff)+1
w("Matrix nr. %i is best by average similarity with %.2f%%\n"
%(i, top_average_diff))
w("Parameters: Model=%s, alpha=%g\n\n"
%(models[i-1].model, models[i-1].alpha))
return models[i-1]
def main():
"""Main function to run most parts of CrOssinG."""
cl()
wh("\t\tCrOssinG: CompaRing Of AngliciSmS IN German", 75)
# paths
ANGLICISMS_PATH = "../res/anglicisms.txt"
DICTENTRIES_PATH = "../res/dictEntries.txt"
FALSE_FRIENDS_PATH = "../res/false_friends.txt"
SUBSET_PATH = "../res/subset.txt"
# 1.: Extracts anglicisms and their translations
w("+++++ Anglicisms (1/3) +++++")
anglicisms_html = getAnglicismsList("http://de.wiktionary.org/wiki/"
"Verzeichnis:Deutsch/Anglizismen")
anglicisms = generateEntries(anglicisms_html, False)
anglicisms_tuples = lookUpTranslations(anglicisms)
anglicisms_tuples = filterTuples(anglicisms_tuples, "AN")
writeTupleFile(anglicisms_tuples, ANGLICISMS_PATH)
# 2.: Extracts dictionary entries and writes them
w("\n++++++ Dictionary Entries (2/3) +++++")
dictLines = readFile("../res/dict_cc_entries.txt", "#")
dictEntries = extractDictEntries(dictLines, False)
dictEntries = filterTuples(dictEntries, "DE", 100)
writeTupleFile(dictEntries, DICTENTRIES_PATH)
subset = createRandomSubset(dictEntries, 300)
writeTupleFile(subset, SUBSET_PATH)
# 3.: Extracts false friends
w("\n+++++ False Friends (3/3) ++++++")
false_friends = readFile("../res/false_friends.txt")
false_friends_tuples = extractFalseFriends(false_friends)
false_friends_tuples = filterTuples(false_friends_tuples,"FF", True)
writeTupleFile(false_friends_tuples, FALSE_FRIENDS_PATH)
def evalMatrix(false_friends, devectors, envectors, vm, model,
output=True, n=5):
""" Evaluates the quality of a matrix """
average_diff = 0
similarities = []
# Calulating the average difference of a false-friend-pair
for pair in false_friends:
try:
if devectors[pair[1]] == []: continue
elif envectors[pair[0]] == []: continue
mapped = mapVector(vm, model, devectors[pair[1]])
mapped = [x.item((0, 0)) for x in mapped]
sim = cosine_similarity(mapped, envectors[pair[0]])
similarities.append((sim, pair))
average_diff += sim
except KeyError:
continue
average_diff /= len(similarities)
# Output
if output:
print "Average similarity was %.2f%% for %i elements"\
%(average_diff*50+50, len(similarities))
sorted_ = sorted(similarities)
print "Highest differences:\n"
for similarity in sorted_[:n]:
w("%.2f%% similarity with %s - %s\n"\
%(similarity[0]*50+50, similarity[1][0], similarity[1][1]))
print "\nLowest differences:\n"
sorted_.reverse()
for similarity in sorted_[:n]:
w("%.2f%% similarity with %s - %s\n"\
%(similarity[0]*50+50, similarity[1][0], similarity[1][1]))
print "\n"
return average_diff*50+50
def finalOutput(similarities, anglicisms, n):
""" Generates the "final output" of crossing, printing the most and least
similar anglicism-pairs """
for key in similarities.keys():
if key not in anglicisms:
del similarities[key]
if len(similarities) < n: n = len(similarities) # Just to be sure
w("\nFinal results\n%s\n\n" %(40*"-"))
w("Top %i pairs with highest similarity:\n" %(n))
top_n = findTopN(similarities, n, 1)
for pair in top_n:
w("%i. %s - %s | %.2f%% similarity\n"\
%(top_n.index(pair)+1, pair[0][0], pair[0][1], pair[1]*50+50))
w("\nTop %i pairs with lowest similarity:\n" %(n))
bottom_n = findTopN(similarities, n, -1)
for pair in bottom_n:
w("%i. %s - %s | %.2f%% similarity\n"\
%(bottom_n.index(pair)+1, pair[0][0], pair[0][1], pair[1]*50+50))
germanEntry = (german_parts[0], german_parts[1], german_parts[2],
german_parts[3], german_parts[4])
englishEntry = (english_parts[0], english_parts[1],
english_parts[2], english_parts[3],
english_parts[4])
tuples.append((germanEntry, englishEntry, _entries[2].
replace("\n", "")))
except Exception, e:
errors.append("%s with line %s" %(e, lines[i]))
continue
finally:
fl()
wil("Extracting dictionary entries...Complete!", 90, "\n")
if printErrors:
w("The following errors occurred:\n")
for error in errors:
w(error)
return tuples
def extractParts(dict_string):
"""Extracts the different parts of an entry."""
entry_array = [] # Main entry
specification = "" # Specification, e.g. numerus or gender
additional_entry_array = [] # Additional Entry
abbr = "" # Abbreviation
comments = [] # Array of comments
entry_end = False # To determine whether the main entry ended already
# Splitting with whitspaces; connecting parts in brackets
parts = connectAnnotations(re.split(" ", dict_string))