def merge_tracks(tracks, dest_path):
# Merging is easier with pianorollls
quantization = 64
T = 0
for track in tracks:
# Add a 4 quarter silence
T += get_time(track, quantization) + quantization * 4
t = 0
flag_time_increment = True
pr = {}
for track in tracks:
a = read_midi(track, quantization)
for k in a.keys():
if flag_time_increment:
tt = t + a[k].shape[0]
flag_time_increment = False
if k not in pr.keys():
pr[k] = np.zeros((T, 128))
pr[k][t:tt] = a[k]
t = tt + quantization * 4
flag_time_increment = True
write_midi(pr, quantization, dest_path, tempo=80)
return
def generate(model,
piano, orchestra, indices,
generation_length, seed_size, quantization_write,
generated_folder, logger_generate):
# Generate sequences from a trained model
# piano, orchestra and index are data used to seed the generation
# Note that generation length is fixed by the length of the piano input
logger_generate.info("# Generating")
generate_sequence = model.get_generate_function(
piano=piano, orchestra=orchestra,
generation_length=generation_length,
seed_size=seed_size,
batch_generation_size=len(indices),
name="generate_sequence")
# Load the mapping between pitch space and instrument
metadata = pickle.load(open('../Data/metadata.pkl', 'rb'))
instru_mapping = metadata['instru_mapping']
# Given last indices, generate a batch of sequences
(generated_sequence,) = generate_sequence(indices)
if generated_folder is not None:
for write_counter in xrange(generated_sequence.shape[0]):
# Write midi
pr_orchestra = reconstruct_pr(generated_sequence[write_counter], instru_mapping)
write_path = generated_folder + '/' + str(write_counter) + '.mid'
write_midi(pr_orchestra, quantization_write, write_path, tempo=80)
return
def check_orchestration_alignment(path_db, subfolder_names, temporal_granularity, quantization, unit_type, gapopen, gapextend):
output_dir = 'DEBUG/' +\
'Grid_search_database_alignment/' + str(quantization) +\
'_' + temporal_granularity +\
'_' + unit_type +\
'_' + str(gapopen) +\
'_' + str(gapextend)
if temporal_granularity == "event_level":
quantization_write = 1
else:
quantization_write = quantization
counter = 0
sum_score = 0
nbFrame = 0
nbId = 0
nbDiffs = 0
for sub_db in subfolder_names:
print '#' * 30
print sub_db
sub_db_path = path_db + '/' + sub_db
if not os.path.isdir(sub_db_path):
continue
for folder_name in os.listdir(sub_db_path):
print '# ' + sub_db + ' : ' + folder_name
folder_path = sub_db_path + '/' + folder_name
if not os.path.isdir(folder_path):
continue
# Skip already computed folders
save_folder_name = output_dir +\
'/' + sub_db + '_' + folder_name
if os.path.isdir(save_folder_name):
continue
pr_piano_no_map, _, _, _, _, pr_orchestra_no_map, _, _, instru_orch, _, duration =\
build_data_aux.process_folder(folder_path, quantization, binary_piano, binary_orch, temporal_granularity, gapopen, gapextend)
# Apply the mapping
pr_piano = {}
pr_orchestra = {}
for k, v in pr_piano_no_map.iteritems():
if 'Piano' in pr_piano:
pr_piano['Piano'] = np.maximum(pr_piano['Piano'], v)
else:
pr_piano['Piano'] = v
for k, v in pr_orchestra_no_map.iteritems():
# unmix instrus
new_k = instru_orch[k.rstrip('\x00')]
instru_names = build_data_aux.unmixed_instru(new_k)
for instru_name in instru_names:
if instru_name in pr_orchestra:
pr_orchestra[instru_name] = np.maximum(pr_orchestra[instru_name], v)
else:
pr_orchestra[instru_name] = v
# Sum all instrument
piano_aligned = sum_along_instru_dim(pr_piano)
orchestra_aligned = sum_along_instru_dim(pr_orchestra)
OOO_aligned = np.zeros((duration, 30), dtype=np.int16)
CCC_aligned = np.concatenate((piano_aligned, OOO_aligned, orchestra_aligned), axis=1)
# Update statistics
# nbFrame += duration
# sum_score += this_sum_score
# nbId += this_nbId
# nbDiffs += this_nbDiffs
# counter = counter + 1
# Save every 100 example
# if counter % 10 == 0:
# import pdb; pdb.set_trace()
if not os.path.isdir(save_folder_name):
os.makedirs(save_folder_name)
visualize_mat(CCC_aligned, save_folder_name, 'aligned')
# write_midi(pr={'piano1': sum_along_instru_dim(pr0)}, quantization=quantization, write_path=save_folder_name + '/0.mid', tempo=80)
# write_midi(pr={'piano1': sum_along_instru_dim(pr1)}, quantization=quantization, write_path=save_folder_name + '/1.mid', tempo=80)
write_midi(pr=pr_piano, quantization=quantization_write, write_path=save_folder_name + '/0.mid', tempo=80)
write_midi(pr=pr_orchestra, quantization=quantization_write, write_path=save_folder_name + '/1.mid', tempo=80)
write_midi(pr={'Piano': piano_aligned, 'Violin': orchestra_aligned}, quantization=quantization_write, write_path=save_folder_name + '/both_aligned.mid', tempo=80)
def check_orchestration_alignment(path_db, subfolder_names, quantization, gapopen, gapextend):
output_dir = 'DEBUG/' + str(quantization) +\
'_' + str(gapopen) +\
'_' + str(gapextend)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
else:
# Avoid re-running the algo on already tested parameters
return
counter = 0
sum_score = 0
nbFrame = 0
nbId = 0
nbDiffs = 0
# num_track_browsed = 30
for sub_db in subfolder_names:
print '#' * 30
print sub_db
sub_db_path = path_db + '/' + sub_db
if not os.path.isdir(sub_db_path):
continue
# list_tracks_dir = os.listdir(sub_db_path)
# ind_folder = np.random.permutation(len(list_tracks_dir))
# for ind in ind_folder[:num_track_browsed]:
# for ind in list_tracks_dir:
# folder_name = list_tracks_dir[ind]
for folder_name in os.listdir(sub_db_path):
print '#' * 20
print '#' + folder_name + '\n'
folder_path = sub_db_path + '/' + folder_name
if not os.path.isdir(folder_path):
continue
# Get instrus and prs from a folder name name
pr0, instru0, T0, path_0, pr1, instru1, T1, path_1 = build_data_aux.get_instru_and_pr_from_folder_path(folder_path, quantization=quantization, clip=True)
# name_0 = re.split('/', path_0)[-1]
# name_1 = re.split('/', path_1)[-1]
################################################
################################################
# def auxiaux(pr, limit):
# pr_bis = pr
# pr = {}
# for k,v in pr_bis.iteritems():
# pr[k] = v[:limit,:]
# return pr
# pr0 = auxiaux(pr0, 26)
# pr1 = auxiaux(pr1, 48)
################################################
################################################
# Get trace from needleman_wunsch algorithm
# Traces are binary lists, 0 meaning a gap is inserted
trace_0, trace_1, this_sum_score, this_nbId, this_nbDiffs = needleman_chord_wrapper(sum_along_instru_dim(pr0), sum_along_instru_dim(pr1))
# Wrap dictionnaries according to the traces
assert(len(trace_0) == len(trace_1)), "size mismatch"
pr0_warp = warp_dictionnary_trace(pr0, trace_0)
pr1_warp = warp_dictionnary_trace(pr1, trace_1)
# In fact we just discard 0 in traces for both pr
trace_prod = [e1 * e2 for (e1,e2) in zip(trace_0, trace_1)]
if sum(trace_prod) == 0:
# It's definitely not a match...
# Check for the files : are they really an piano score and its orchestration ??
with(open('log.txt', 'a')) as f:
f.write(folder_path + '\n')
continue
pr0_aligned = remove_zero_in_trace(pr0_warp, trace_prod)
pr1_aligned = remove_zero_in_trace(pr1_warp, trace_prod)
# Sum all instrument
AAA_warp = sum_along_instru_dim(pr0_warp)
BBB_warp = sum_along_instru_dim(pr1_warp)
OOO_warp = np.zeros((BBB_warp.shape[0], 30), dtype=np.int16)
CCC_warp = np.concatenate((AAA_warp, OOO_warp, BBB_warp), axis=1)
AAA_aligned = sum_along_instru_dim(pr0_aligned)
BBB_aligned = sum_along_instru_dim(pr1_aligned)
OOO_aligned = np.zeros((BBB_aligned.shape[0], 30), dtype=np.int16)
CCC_aligned = np.concatenate((AAA_aligned, OOO_aligned, BBB_aligned), axis=1)
# Update statistics
nbFrame += len(trace_0)
sum_score += this_sum_score
nbId += this_nbId
nbDiffs += this_nbDiffs
counter = counter + 1
# Save every 100 example
if not counter % 10 == 0:
continue
save_folder_name = output_dir +\
'/' + sub_db + '_' + folder_name
if not os.path.exists(save_folder_name):
os.makedirs(save_folder_name)
temp_csv = save_folder_name + '/warp.csv'
np.savetxt(temp_csv, CCC_warp, delimiter=',')
dump_to_csv(temp_csv, temp_csv)
write_numpy_array_html(save_folder_name + "/pr_warp.html", "warp")
temp_csv = save_folder_name + '/aligned.csv'
np.savetxt(temp_csv, CCC_aligned, delimiter=',')
dump_to_csv(temp_csv, temp_csv)
write_numpy_array_html(save_folder_name + "/pr_aligned.html", "aligned")
write_midi(pr={'piano1': sum_along_instru_dim(pr0)}, quantization=quantization, write_path=save_folder_name + '/0.mid', tempo=80)
write_midi(pr={'piano1': sum_along_instru_dim(pr1)}, quantization=quantization, write_path=save_folder_name + '/1.mid', tempo=80)
write_midi(pr={'piano1': AAA_warp, 'piano2': BBB_warp}, quantization=quantization, write_path=save_folder_name + '/both__warp.mid', tempo=80)
write_midi(pr={'piano1': AAA_aligned, 'piano2': BBB_aligned}, quantization=quantization, write_path=save_folder_name + '/both__aligned.mid', tempo=80)
# Write statistics
mean_score = float(sum_score) / nbFrame
nbId_norm = nbId / quantization
nbDiffs_norm = nbDiffs / quantization
with open(output_dir + '/log.txt', 'wb') as f:
f.write("##########################\n" +
"quantization = %d\n" % quantization +
"Gapopen = %d\n" % gapopen +
"Gapextend = %d\n" % gapextend +
"Number frame = %d\n" % nbFrame +
"\n\n\n" +
"Sum score = %d\n" % sum_score+
"Mean score = %f\n" % mean_score+
"Number id = %d\n" % nbId +
"Number id / quantization = %d\n" % nbId_norm+
"Number diffs = %d\n" % nbDiffs+
"Number diffs / quantization = %d\n" % nbDiffs_norm)