def add_stress_to_full(full_file, out_file, out_full_no_time_file, name): # print name pattern = re.compile(r"""(?P<start>.+)\s(?P<end>.+)\s.+ /A:.+\-(?P<cur_phone_position>.+)_.+\+.+ /B:.+ """,re.VERBOSE) count = 0 o = [] for line in Utility.read_file_line_by_line(full_file): match = re.match(pattern, line) if match: cur_phone_position = match.group('cur_phone_position') # print cur_phone_position if (cur_phone_position == '1') | (cur_phone_position == 'x'): count = count + 1 # syl_id = '{}_{}'.format(name, count) # print syl_id pre_syl = '{}_{}'.format(name, count-1) cur_syl = '{}_{}'.format(name, count) suc_syl = '{}_{}'.format(name, count+1) if pre_syl not in db: pre_stress = 'x' else: pre_stress = db[pre_syl]['stress'] if cur_phone_position == 'x': cur_stress = 'x' else : cur_stress = db[cur_syl]['stress'] if suc_syl not in db: suc_stress = 'x' else: suc_stress = db[suc_syl]['stress'] stress_context = '/I:{}-{}+{}'.format(pre_stress, cur_stress, suc_stress) # print stress_context context = '{}{}'.format(Utility.trim(line), stress_context) # print context o.append(context) o_no_time = get_remove_time(o) # print o_no_time if (not (len(Utility.read_file_line_by_line(full_file)) == len(o))) & (not (len(Utility.read_file_line_by_line(full_file)) == len(o_no_time))): print name Utility.write_to_file_line_by_line(out_file, o) Utility.write_to_file_line_by_line(out_full_no_time_file, o_no_time) pass
def gen_dur_and_name_list_for_phone(syllable_label_path, name, phone_duration_path): pattern = re.compile(r""".+/A:.+/D:.+\-(?P<num_phone>.+)\+.+/E:.+""", re.VERBOSE) dur_list = [] for idx, line in enumerate( Utility.read_file_line_by_line(phone_duration_path)): spl = Utility.trim(line).split(' ') frame = int(spl[1]) - int(spl[0]) frame = frame / 50000 dur_list.append(frame) names = [] for idx, line in enumerate( Utility.read_file_line_by_line(syllable_label_path)): spl = Utility.trim(line).split(' ') match = re.match(pattern, line) if match: num_phone = match.group('num_phone') if num_phone == 'x': num_phone = 1 else: num_phone = int(num_phone) for phone_index in xrange(num_phone): names.append('{}_{}_{}'.format(name, (idx + 1), phone_index)) return (dur_list, names)
def gen_phone_duration_in_syllable(filepath, outpath_file): pattern = re.compile( r"""(?P<start>.+)\s(?P<end>.+)\s.+\-(?P<curphone>.+)\+.+/A:.+\-(?P<cur_phone_index>.+)_.+\+.+/B:.+/D:.+\-(?P<phone_number>.+)\+.+/E:.+""", re.VERBOSE) # 87545000 108545472 n^-sil+X/A:3_10-x_x+x_x/B:0-x+x/C:4_29-x_x+x_x/D:3-x+x/E:18-x+x/F:10_4-x_x+x_x/G:x_29_18/H:2-x+x # 85143750 87545000 aa-n^+sil/A:2_9-3_10+x_x/B:0-0+x/C:3_28-4_29+x_x/D:3-3+x/E:17-18+x/F:2_1-10_4+x_x/G:x_29_18/H:45-2+x main_duration = [] temp_dur = [] for line in Utility.read_file_line_by_line(filepath): # print line match = re.match(pattern, line) if match: start = float(match.group('start')) end = float(match.group('end')) phone_index = match.group('cur_phone_index') phone_number = match.group('phone_number') # print phone_index, phone_number, start, end if phone_index == 'x': temp_dur = [] temp_dur.append(end - start) main_duration.append(temp_dur) elif phone_index == '1': temp_dur = [] temp_dur.append(end - start) elif phone_index == phone_number: temp_dur.append(end - start) main_duration.append(temp_dur) else: temp_dur.append(end - start) # print main_duration c = 0 for m in main_duration: # print m c = c + len(m) if c != len(Utility.read_file_line_by_line(filepath)): print 'No equal', filepath Utility.save_obj(main_duration, outpath_file) pass
def cal_duration_distortion_from_label_and_npy_list(org_path, syn_path): dur_true_list = [] dur_pred_list = [] for file in Utility.list_file(org_path): if file.startswith('.'): continue base = Utility.get_basefilename(file) syn = numpy.load('{}/{}.npy'.format(syn_path, base)) for idx, line in enumerate( Utility.read_file_line_by_line('{}/{}'.format( org_path, file))): if ('sil' in line) | ('pau' in line): continue # print syn[idx] o = line.split(' ') dur_true_list.append(1000 * (float(o[1]) - float(o[0])) / 10000000) dur_pred_list.append(1000 * syn[idx]) rmse = numpy.sqrt( sklearn.metrics.mean_squared_error(dur_true_list, dur_pred_list)) return rmse, len(dur_true_list), len(dur_pred_list)
def get_last_syllable(filepath, name): # sil-sil+sil/A:X-X+X/S:l-x+z^/B:x-x+3/C:x_x-x_x+1_1/D:x-x+2/E:x-x+1/F:x_x-x_x+2_1/G:x_35_23/H:x-x+45 global out pattern = re.compile(r"""(?P<start>.+)\s(?P<end>.+)\s.+\-(?P<curphone>.+)\+.+/A:.+/C:.+\-(?P<cur_position_syl>.+)_.+\+.+/D:.+/F:.+\-.+_(?P<cur_num_syl>.+)\+.+/G:.+""",re.VERBOSE) count = 0 for line in Utility.read_file_line_by_line(filepath): count = count + 1 match = re.match(pattern, line) if match: cur_position_syl = match.group('cur_position_syl') cur_num_syl = match.group('cur_num_syl') iden = '{}_{}'.format(name, count) # print iden if cur_position_syl == 'x': continue if ( cur_position_syl == cur_num_syl ) & ( ( cur_num_syl != '1' ) ): # print iden out.append(iden) pass
def set_pre_suc(): tones = ['01234'] name_list_path = '/home/h1/decha/Dropbox/python_workspace/Inter_speech_2016/playground/list_file_for_preceeding_suceeding/list_gpr_file/' for t in tones: path = '/home/h1/decha/Dropbox/Inter_speech_2016/Syllable_object/mix_object/current_version/all_vowel_type/syllable_object_{}.pickle'.format( t) print path syl_management = Utility.load_obj(path) for syl in syl_management.syllables_list: if 'manual' in syl.name_index: continue name = syl.name_index.split('_') file_tar = '{}/{}/{}.lab'.format(name_list_path, name[2][0], name[2]) list_file = Utility.read_file_line_by_line(file_tar) for idx, l in enumerate(list_file): f = Utility.trim(l) if f == syl.name_index: # print '--------------------' preceeding = Utility.trim(list_file[idx - 1]) # print f succeeding = Utility.trim(list_file[idx + 1]) # print '--------------------' syl.set_preceeding_succeeding_name_index( preceeding, succeeding) # sys.exit() Utility.save_obj(syl_management, path)
def gen_syllable_tag(syllable_label_path, tone, start_set, end_set, tag): # Format a_tscsda01_3 # 'tscsd_manual' lf0_tags = [] for set in Utility.char_range(start_set, end_set): path = '{}/{}'.format(syllable_label_path, set) count = Utility.count_valid_file(path) for i in range(1, count + 1): filepath = '{}/tscsd_stust_{}{}.stresslab'.format( path, set, Utility.fill_zero(i, 2)) syllable_count = 0 for line in Utility.read_file_line_by_line(filepath): syllable_count += 1 if tone == '01234': lf0_tags.append('{}_{}_{}{}_{}'.format( set, tag, set, Utility.fill_zero(i, 2), syllable_count)) else: if line[0] == tone: lf0_tags.append('{}_{}_{}{}_{}'.format( set, tag, set, Utility.fill_zero(i, 2), syllable_count)) return lf0_tags pass
def fix_database(db_file, change_list_file, out_file): global db db = None db = Utility.load_obj(db_file) change_list = [] less_than = None for line in Utility.read_file_line_by_line(change_list_file): if 'tsc' in line: n = Utility.trim(line).replace(' ', '_') change_list.append(n) elif '<' in line: # print line less_than = line.split(' ')[1] pass # print change_list # print less_than if (len(change_list) == 0) | (less_than == None): raise 'Change list file false' new_list = change_stress(change_list, less_than) Utility.save_obj(new_list, out_file) pass
def get_org_syllable_list(filename): dur_list = [] num_phone_list = [] for line in Utility.read_file_line_by_line(filename): pattern = re.compile( r"""(?P<start>.+)\s(?P<end>.+)\s.+/D:.+\-(?P<num_phone>.+)\+.+/E:.+""", re.VERBOSE) match = re.match(pattern, line) if match: num_phone = match.group('num_phone') start = match.group('start') end = match.group('end') # print start, end, num_phone d = float(int(end) - int(start)) / 10000000 # print d dur_list.append(d) num_phone_list.append(num_phone) return (dur_list, num_phone_list) pass
def read_rmse_file(rmse_file): param_old = [] rmse_old = 100000000.0 line_old = '' const = '' thefile = Utility.read_file_line_by_line(rmse_file) # print rmse_file for idx, line in enumerate(thefile): if 'const' in line: const = Utility.trim(line) l = thefile[idx + 1].split(' ') current_param = [l[0], l[1], l[2], l[3], l[4]] if 'Only' in line: spl = line.split(' ') rmse = float(spl[5]) if rmse < rmse_old: rmse_old = rmse param_old = current_param line_old = line return (rmse_old, param_old, line_old, const)
def gen_file_list(): outpath = '/home/h1/decha/Dropbox/python_workspace/Inter_speech_2016/playground/list_file_for_preceeding_suceeding/list_gpr_file/' label_path = '/work/w2/decha/Data/GPR_data/label/03_GPR_syllable_level/full/tsc/sd/' start_set = 'a' end_set = 'j' for sett in Utility.char_range(start_set, end_set): set_path = '{}/{}/'.format(label_path, sett) out_set_path = '{}/{}/'.format(outpath, sett) Utility.make_directory(out_set_path) for f in Utility.list_file(set_path): if f.startswith('.'): continue file_path = '{}/{}'.format(set_path, f) count = 0 # print f file_number = f[6] + f[7] out_list = [] for line in Utility.read_file_line_by_line(file_path): # print Utility.trim(line) out = '' if 'sil-sil+sil/A:' in line: out = 'sil' elif 'pau-pau+pau/A:' in line: out = 'pau' else: count += 1 out = 'tscsd_gpr_{}{}_{}'.format(sett, file_number, count) # print out out_list.append(out) if len(out_list) != len(Utility.read_file_line_by_line(file_path)): print file_path out_file_name = '{}/{}{}.lab'.format(out_set_path, sett, file_number) # print out_file_name Utility.write_to_file_line_by_line(out_file_name, out_list)
def load_fix_list(path): out = [] for f in Utility.list_file(path): if f.startswith('.'): continue for line in Utility.read_file_line_by_line('{}/{}'.format(path, f)): # print Utility.trim(line) out.append(Utility.trim(line)) return out pass
def gen_tonal_part_duration(phone_level_label, pattern, start_set, end_set, outpath): for sett in Utility.char_range(start_set, end_set): set_path = '{}/{}/'.format(phone_level_label, sett) for f in Utility.list_file(set_path): if f.startswith('.'): continue file_path = '{}/{}'.format(set_path, f) phone_frame_list = [] syllable_count = 0 for line in Utility.read_file_line_by_line(file_path): match = re.match(pattern, line) if match: start_time = match.group('start_time') end_time = match.group('end_time') if match.group('phone_position_in_syllable') == 'x': continue phone_position_in_syllable = int( match.group('phone_position_in_syllable')) phone_number_in_syllable = int( match.group('phone_number_in_syllable')) frame = (float(end_time) - float(start_time)) / 50000 if phone_position_in_syllable == 1: phone_frame_list = [] phone_frame_list.append(frame) elif phone_position_in_syllable == phone_number_in_syllable: phone_frame_list.append(frame) if phone_number_in_syllable == 2: phone_frame_list.append(0) syllable_count += 1 print phone_frame_list outfile = '{}/{}/{}/{}_dur.npy'.format( outpath, sett, f.split('.')[0], syllable_count) print outfile Utility.make_directory('{}/{}/{}/'.format( outpath, sett, f.split('.')[0])) Utility.save_obj(phone_frame_list, outfile) elif phone_position_in_syllable == 2: phone_frame_list.append(frame) else: print 'Not match', f pass
def gen_dur_and_name_list(label_path, name): dur_list = [] names = [] for idx, line in enumerate(Utility.read_file_line_by_line(label_path)): spl = Utility.trim(line).split(' ') frame = int(spl[1]) - int(spl[0]) frame = frame / 50000 dur_list.append(frame) names.append('{}_{}'.format(name, (idx + 1))) return (dur_list, names)
def gen_all_method(base): print base mono = '{}/{}.lab'.format(mono_label, base) stress_tone = '{}/{}.npy'.format(stress_list, base) lf0_out = np.array([]) for line, (st, t) in zip(Utility.read_file_line_by_line(mono), np.load(stress_tone)): # print line, st, t l = Utility.trim(line) spl = l.split(' ') stress_type = 'unstress' if st == '1': stress_type = 'stress' if spl[2] in ['sil', 'pau']: target_file = original_file else: config = result_450['{}_{}'.format(stress_type, t)] if config['beta'] == '': target_file = original_file else: target_file = np.load( '{}/tone_{}/Alpha_1.0_Beta_{}_Gamma_{}/lf0/{}.npy'.format( config['basepath'], t, config['beta'], config['gamma'], base)) start = int(float(spl[0]) / 50000.0) end = int(float(spl[1]) / 50000.0) # print target_file.shape target_lf0 = target_file[start:end] lf0_out = np.append(lf0_out, target_lf0, axis=0) print lf0_out.shape np.save('{}/{}.npy'.format(outpath, base), lf0_out) # sys.exit() pass
def get_all_context_names(filepath): pattern = re.compile(r""".+-\sname:\s(?P<name>.+begin.*)""", re.VERBOSE) for line in Utility.read_file_line_by_line(filepath): match = re.match(pattern, line) if match is None: continue print match.group('name') pass
def load_mono(mono_file): m = [] for line in Utility.read_file_line_by_line(mono_file): spl = line.split(' ') ph = Utility.trim(spl[2]) # print ph m.append(ph) # print m return m pass
def gen_json_data(): outpath = '/home/h1/decha/Dropbox/python_workspace/Inter_speech_2016/playground/generate_json/latent_data/' obj = Utility.load_obj( '/home/h1/decha/Dropbox/Inter_speech_2016/Syllable_object/mix_object/current_version/all_vowel_type/syllable_object_01234.pickle' ) start_set, end_set = 'a', 'j' base_path = '/home/h1/decha/Dropbox/python_workspace/Inter_speech_2016/playground/list_file_for_preceeding_suceeding/list_gpr_file/' for sett in Utility.char_range(start_set, end_set): set_path = '{}/{}/'.format(base_path, sett) for f in Utility.list_file(set_path): if f.startswith('.'): continue file_path = '{}/{}'.format(set_path, f) out_list = [] for line in Utility.read_file_line_by_line(file_path): name = Utility.trim(line) # "duration" "syllable_context" duration = '' syllable_context = '' d = dict() if name == 'sil': syllable_context = 'sil-sil-sil-x' duration = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] elif name == 'pau': syllable_context = 'pau-pau-pau-x' duration = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] else: syl = obj.get_syllable_by_name_index(name) syllable_context = '{}-{}-{}-{}'.format( syl.consonant, syl.vowel, syl.final_consonant, syl.tone) duration = syl.single_space_latent.tolist() d['duration'] = duration d['syllable_context'] = syllable_context out_list.append(d) outfile_path = '{}/tscsd{}.json'.format(outpath, f) Utility.save_json(outfile_path, out_list)
def plot_syllable(lab_path, lf0_path, out_set_path, name, plot_set_out): lines = Utility.read_file_line_by_line(lab_path) lf0 = Utility.read_lf0_into_ascii(lf0_path) print lf0 path = '{}/{}/'.format(out_set_path, name) Utility.make_directory(path) for idx, line in enumerate(lines): line = Utility.trim(line) spl = line.split(' ') # print spl start = float(spl[0]) / 50000 end = float(spl[1]) / 50000 syl = spl[2] # print start, end, syl if end > len(lf0): end = len(lf0) - 1 cur_lf0 = lf0[start:end] # print len(cur_lf0) o = '{}_{}'.format((idx + 1), syl) out_name = '{}/{}.lf0'.format(path, o) print out_name # Utility.write_to_file_line_by_line(out_name, cur_lf0) Utility.make_directory('{}/{}/'.format(plot_set_out, name)) plot_out_file_path = '{}/{}/{}.eps'.format(plot_set_out, name, o) plot(cur_lf0, plot_out_file_path) print len(lf0) pass
def run_gen_mono(utt_set): set_path = '{}/{}/'.format(utterance_path, utt_set) set_syllable_base_path = '{}/{}/'.format(syllable_base, utt_set) out_set_path = '{}/{}/'.format(output_path, utt_set) Utility.make_directory(out_set_path) for i in xrange(1, 51): utt_file = Utility.yaml_load('{}/tscsd{}{}.utt.yaml'.format( set_path, utt_set, Utility.fill_zero(i, 2))) # print utt_file out_file = '{}/tscsd{}{}.lab'.format(out_set_path, utt_set, Utility.fill_zero(i, 2)) stress_list = [] recursion(utt_file, stress_list) syllable_time_label = Utility.read_file_line_by_line( '{}/tscsd{}{}.lab'.format(set_syllable_base_path, utt_set, Utility.fill_zero(i, 2))) # print stress_list, len(stress_list) # print len(syllable_time_label) if len(syllable_time_label) != len(stress_list): print utt_set, i # print 'Error' # sys.exit() out = [] for idx, line in enumerate(syllable_time_label): # print line, stress_list[idx] o = '{}::{}'.format( Utility.trim(line).replace('-', '_').replace('+', '_'), stress_list[idx]) # print o out.append(o) Utility.write_to_file_line_by_line(out_file, out) # sys.exit() pass
def load_mono_ori_list_in_sec(file_path): pattern = re.compile( r"""(?P<start>.+)\s+(?P<end>.+)\s+(?P<curphone>.+)""", re.VERBOSE) phone_list = [] dur_list = [] for line in Utility.read_file_line_by_line(file_path): match = re.match(pattern, line) if match: phone = match.group('curphone') start = match.group('start') end = match.group('end') phone_list.append(phone) dur_list.append((float(end) - float(start)) / 10000000) return (phone_list, dur_list)
def get_dir_list_HMM(dur_path): dur = [] for d in Utility.read_file_line_by_line(dur_path): if 'state' in d: continue pattern = re.compile(r""".+\sduration=(?P<frame>.+)\s\(frame\).+""", re.VERBOSE) match = re.match(pattern, d) if match: frame = match.group('frame') # print frame dur.append([float(frame) * 50000 / 10000000]) return dur pass
def read_file_to_W(label_file): pattern = re.compile( r"""(?P<start>.+)\s(?P<end>.+)\s.+/A:.+/D:.+\-(?P<phone_num>.+)\+.+/E:.+""", re.VERBOSE) phone_list = [] for line in Utility.read_file_line_by_line(label_file): # print line match = re.match(pattern, line) if match: phone_num = match.group('phone_num') # print phone_num if phone_num == 'x': phone_list.append(1) else: phone_list.append(int(phone_num)) row = len(phone_list) column = sum(phone_list) # print row, column w = [] cur = 0 for i in phone_list: r = np.zeros(column) r[cur:cur + i] = 1 w.append(r) cur = cur + i w = np.array(w) # print w # for idx, i in enumerate(phone_list): # print i, w[idx] return w pass
def load_ori_list_in_sec_and_num_phone_list(file_path): pattern = re.compile( r"""(?P<start>.+)\s(?P<end>.+)\s.+/A:.+/D:.+\-(?P<phone_num>.+)\+.+/E:.+""", re.VERBOSE) num_phone_list = [] dur_list = [] for line in Utility.read_file_line_by_line(file_path): match = re.match(pattern, line) if match: phone_num = match.group('phone_num') start = match.group('start') end = match.group('end') num_phone_list.append(phone_num) dur_list.append((float(end) - float(start)) / 10000000) return (num_phone_list, dur_list)
def run_gen(base_path, start_set, end_set, pattern, outpath): out = [] for sett in Utility.char_range(start_set, end_set): set_path = '{}/{}/'.format(base_path, sett) for f in Utility.list_file(set_path): if f.startswith('.'): continue file_path = '{}/{}'.format(set_path, f) # print file_path count = 0 # tscsd_gpr_g37_13 prefix = 'tscsd_gpr' lines = Utility.read_file_line_by_line(file_path) for idx, line in enumerate(lines): # print line match = re.match(pattern, line) if match: phone = match.group('curphone') # print phone if phone not in ['sil', 'pau']: count += 1 # print f name_index = '{}_{}{}_{}'.format( prefix, sett, f[6:8], count) if ('sil-sil+sil/A:' in lines[idx + 1]) | ( 'pau-pau+pau/A:' in lines[idx + 1]): print name_index out.append(name_index) print len(out) outpath_file = '{}/gpr_followed_by_sil_list.npy'.format(outpath) Utility.save_obj(out, outpath_file) pass
def find_stress_info(stress_path, name): spl = name.split('_') sett = spl[0][5] syl_index = spl[1] filename = spl[0] # print sett, syl_index for s in Utility.list_file(stress_path): if s[0] == sett: file_path = '{}/{}/{}.lab'.format(stress_path, s, filename) # print file_path lines = Utility.read_file_line_by_line(file_path) ss = lines[int(syl_index) - 1].split(' ') return Utility.trim(ss[3]) break
def gen_new_file(file_path, out_file): print file_path count = 0 out = [] base = Utility.get_basefilename(file_path) print base for line in Utility.read_file_line_by_line(file_path): count = count + 1 name = '{}_{}'.format(base, count) # print name # print db['tscsdj46_2'] # sys.exit() stress = 0 syl = 'x_x_x_x' if name in db: if name in multi_level_list: stress = multi_level_list[name]['stress'] else: stress = 0 syl = '{}_{}_{}_{}'.format(db[name]['consonant'], db[name]['vowel'], db[name]['finalconsonant'], db[name]['tone']) if stress == 2: print name spl = line.split(' ') o = '{} {} {}_{}_{}'.format(spl[0], spl[1], syl, count, stress) # print o out.append(o) Utility.write_to_file_line_by_line(out_file, out)
def gen_stress(filepath, outpath): # sil-l+xx/A:x_x-1_1+2_2/B:x-3+0/C:x_x-1_1+1_2/D:x-3+3/E:x-1+2/F:x_x-3_1+6_2/G:x_18_12/H:x-47+47/I:x-0+0 out = [] pattern = re.compile( r""".+/A:.+\-(?P<cur_phone_position>.+)_.+\+.+/B:.+\-(?P<tone>.+)\+.+/C:.+/I:.+\-(?P<stress>.+)\+.+""", re.VERBOSE) for line in Utility.read_file_line_by_line(filepath): match = re.match(pattern, line) if match: cur_phone_position = match.group('cur_phone_position') stress = match.group('stress') tone = match.group('tone') # print line, cur_phone_position, stress if cur_phone_position in ['1', 'x']: out.append((stress, tone)) np.save(outpath, np.array(out))
def lf0_distortion_syn_is_gpr_format(org_path, syn_path, stress_list, mono_label): lf0_true_list = [] lf0_pred_list = [] lf0_true_stress_list = [] lf0_pred_stress_list = [] for base in Utility.list_file(org_path): if base.startswith('.'): continue b = Utility.get_basefilename(base) stress = np.load('{}/{}.npy'.format(stress_list, b)) mono_file = Utility.read_file_line_by_line('{}/{}.lab'.format( mono_label, b)) stress_index = np.array([]) for st, mono in zip(stress, mono_file): spl = mono.split(' ') start = int(spl[0]) / 50000 end = int(spl[1]) / 50000 if (st[0] == '1') & (st[1] == '{}'.format(tone)): stress_index = np.append(stress_index, np.arange(start, end), axis=0) # Load Original original_file = os.path.join(org_path, base) original_vector = numpy.loadtxt( Utility.read_lf0_into_ascii(original_file)) # Load Synthesis synthesis_file = '{}/{}.npy'.format(syn_path, Utility.get_basefilename(base)) synthesis_vector = numpy.load(synthesis_file) synthesis_vector = synthesis_vector.reshape(len(synthesis_vector)) # print synthesis_vector synthesis_vector = np.nan_to_num(synthesis_vector) synthesis_vector[np.where(synthesis_vector <= 0.0)] = UNDEF_VALUE # print synthesis_vector # sys.exit() for idx, (lf0_original, lf0_synthesis) in enumerate( zip(original_vector, synthesis_vector)): if lf0_original == UNDEF_VALUE: continue if lf0_synthesis == UNDEF_VALUE: continue lf0_true_list.append(lf0_original) lf0_pred_list.append(lf0_synthesis) if idx in stress_index: lf0_true_stress_list.append(lf0_original) lf0_pred_stress_list.append(lf0_synthesis) # rmse = numpy.sqrt(sklearn.metrics.mean_squared_error(lf0_true_list, lf0_pred_list)) * 1000 / numpy.log(2) rmse = numpy.sqrt( sklearn.metrics.mean_squared_error( lf0_true_list, lf0_pred_list)) * 1200 / numpy.log(2) print('All LF0 RMSE: {:f} in {} frames'.format(rmse, len(lf0_true_list))) rmse = numpy.sqrt( sklearn.metrics.mean_squared_error( lf0_true_stress_list, lf0_pred_stress_list)) * 1200 / numpy.log(2) print('Only stress LF0 RMSE: {:f} in {} frames'.format( rmse, len(lf0_true_stress_list))) pass
def dur_distortion(org_path, syn_path): dur_true_list = [] dur_pred_list = [] for base in Utility.list_file(org_path): if base.startswith('.'): continue basename = base.split('.') # print basename # Load Original org_file = os.path.join(org_path, '{}{}'.format(basename[0], '.lab')) org_duration_vector = Utility.read_file_line_by_line(org_file) syn_file = os.path.join(syn_path, '{}{}'.format(basename[0], '.dur')) syn_duration_vector_temp = Utility.read_file_line_by_line(syn_file) syn_duration_vector = [] for vec in syn_duration_vector_temp: if not "state" in vec: syn_duration_vector.append(vec) pattern = re.compile( r"""(?P<start>.+)\s(?P<end>.+)\s.+\-(?P<curphone>.+)\+.+/A:.+""", re.VERBOSE) syn_pattern = re.compile( r""".+\-(?P<phone>.+)\+.+/A:.+\sduration=(?P<duration>.+)\s\(frame\).+""", re.VERBOSE) #X-sil+ph/A:x_x-x_x+1_1/B:x-x+0/C:x_x-x_x+1_1/D:x-x+2/E:x-x+1/F:x_x-x_x+9_4/G:x_22_14/H:x_x-56_1+2_1.state[2]: duration=5 (frame), mean=4.609594e+00 if len(org_duration_vector) != len(syn_duration_vector): print "Not equal" for org, syn in zip(org_duration_vector, syn_duration_vector): match = re.match(pattern, org) if match.group('curphone') in ["sil", "pau"]: continue phone = match.group('curphone') duration = (int(match.group('end')) - int(match.group('start'))) / 50000 syn_match = re.match(syn_pattern, syn) syn_duration = int(syn_match.group('duration')) # print phone, duration, syn_match.group('phone') , syn_duration dur_true_list.append(1000 * duration * 0.005) dur_pred_list.append(1000 * syn_duration * 0.005) if len(dur_true_list) != len(dur_pred_list): print "Not equal" rmse = numpy.sqrt( sklearn.metrics.mean_squared_error(dur_true_list, dur_pred_list)) print('Duration RMSE: {:f} in {} phones'.format( rmse, len(dur_true_list)))