def run(self, args, state):
from jazzparser.formalisms.music_halfspan.evaluation import \
tonal_space_local_alignment, tonal_space_distance
songnum = int(args[0])
name, song = get_song(songnum, state)
songset = state.get_data("songset")
distances = []
# Try comparing this song to each song in the set
for other_name, other_song in songset.analyses:
# Align locally and globally
ops,steps1,steps2,local_distance = \
tonal_space_local_alignment(other_song.lf, song.lf)
global_distance = \
tonal_space_distance(other_song.lf, song.lf)
distances.append((other_name, local_distance, global_distance))
# Sort the results
if self.options['local']:
distances.sort(key=lambda x: x[1])
else:
distances.sort(key=lambda x: x[2])
# Print out each one
print "Aligned %s with:" % name
for other_name, local_distance, global_distance in distances:
print "%s: local: %s, global: %s" % \
(other_name,local_distance,global_distance)
def max_parse(semantics, gold):
max_score = float("inf")
max_index = 0
for i,(prob,sem) in enumerate(semantics):
# get dependency graphs
score = tonal_space_distance(sem.lf, gold.lf)
if max_score > score:
max_score = score
max_index = i
return max_index
def distance(self, sem1, sem2):
# Handle the extra 'dist' case
if self.options['output'] == 'dist':
# If one input is empty, we consider all points to have been deleted
if sem1 is None:
return tonal_space_length(sem2)
elif sem2 is None:
return tonal_space_length(sem1)
# Compute the score using our standard TS distance computation
# This is based on the alignment score of the optimal alignment
# of the two sequences
return tonal_space_distance(sem1.lf, sem2.lf)
else:
# Otherwise the superclass takes care of everything
return super(TonalSpaceEditDistance, self).distance(sem1, sem2)
def reranking(input_files): # Initialization: v = 0 learning_rate = 0.2 v = get_features_vector() input_files = sorted(input_files) # Algorithm: # For t = 1..T, i = 1..n # zi = F(xi) # if (zi != yi) v = v + f(xi, yi) - f(xi, zi) T = 10 for t in range(T): print "========== Loop: %d ==========" % t for parses_result in input_files: # We read in the whole file (it's pickled, so we have to), but don't # keep the pres object after the loop iteration, because it can # be very big try: pres = ParseResults.from_file(parses_result) except ParseResults.LoadError, err: if options.errors: # Print all load errors print >>sys.stderr, "Error loading file: %s" % (err) errors.append(parses_result) continue # get gold semantics and gold dependency graph gold_result = pres.get_gold_semantics() gold_depend_graph = get_depend_graph(gold_result) # calcuate maximum index of parses if len(pres.semantics) > 0: max_index = max_parse(pres.semantics, v) zi = pres.semantics[max_index] # get maximum dependency graph zi_depend_graph = get_depend_graph(zi[1]) if tonal_space_distance(zi[1].lf, gold_result.lf) != 0: gold_features = get_features(gold_depend_graph) zi_features = get_features(zi_depend_graph) for k, val in zi_features.iteritems(): v[k] = v[k] + gold_features[k] - zi_features[k] print sum(v.values())
if options.times:
for (node,time) in sorted(gold_time_map.items(), key=lambda x:x[1]):
print "%d @ %s" % (node, time)
print
# Get the top result's semantics
if len(pres.semantics) == 0:
print >>sys.stderr, "No results"
else:
top_result = pres.semantics[0][1]
graph,time_map = semantics_to_dependency_graph(top_result)
# Before reranking
total_parses = len(pres.semantics)
top_distance = tonal_space_distance(top_result.lf, gold_result.lf)
# After reranking
v = {}
v = json.load(open(FEATURE_PARAMS))
# calcuate reranking index of parses
if len(pres.semantics) > 0:
reranking_index = reranking_parse(pres.semantics, v)
reranking_result = pres.semantics[reranking_index][1]
reranking_distance = tonal_space_distance(reranking_result.lf, gold_result.lf)
reranking_graph,time_map = semantics_to_dependency_graph(reranking_result)
# Perfect reranking
max_index = max_parse(pres.semantics, gold_result)
zi = pres.semantics[max_index][1]
max_distance = tonal_space_distance(zi.lf, gold_result.lf)
