예제 #1
0
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
예제 #2
0
파일: eval.py 프로젝트: Eroica/crossing
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
예제 #3
0
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:
예제 #4
0
파일: eval.py 프로젝트: Eroica/crossing
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))
예제 #5
0
파일: eval.py 프로젝트: Eroica/crossing
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
예제 #6
0
파일: eval.py 프로젝트: Eroica/crossing
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]
예제 #7
0
파일: main.py 프로젝트: Eroica/crossing
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)
예제 #8
0
파일: eval.py 프로젝트: Eroica/crossing
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
예제 #9
0
파일: eval.py 프로젝트: Eroica/crossing
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))
예제 #10
0
            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))