def plot_latex_for_compasison(figure_paths, method_names, name_out_path): methods = len(figure_paths) tex_file = [] tex_file.append('\\documentclass{article}') tex_file.append('\\usepackage{geometry}') tex_file.append('\\usepackage[usenames, dvipsnames]{color}') tex_file.append('\\geometry{margin=1cm}') tex_file.append('\\usepackage[english]{babel}') tex_file.append('\\usepackage{graphicx}') tex_file.append('\\begin{document}') count = 0 for t in xrange(5): for f in ['nasal', 'no', 'non-nasal']: for v in ['long', 'short']: name = '{}_{}_{}'.format(t, v, f) #------------ Figure ----------------# print '{}/{}.eps'.format(figure_paths[0], name) if Utility.is_file_exist('{}/{}.eps'.format( figure_paths[0], name)): tex_file.append('\\begin{figure}[t]') # minipage # for idx, i in enumerate(figure_paths): eps = '{}/{}.eps'.format(figure_paths[idx], name) if Utility.is_file_exist(eps): tex_file.append( '\\begin{{minipage}}[b]{{{}\\textwidth}}'. format(1.0 / float(methods) - 0.01)) tex_file.append('\\centering') tex_file.append( '\\includegraphics[width=\\textwidth]{{{}/{}.eps}}' .format(figure_paths[idx], name)) tex_file.append('{}'.format(method_names[idx])) tex_file.append('\\end{minipage}') # minipage # tex_file.append('\\caption{{{}}}'.format( name.replace('_', '\_'))) tex_file.append('\\end{figure}') #------------ Figure ----------------# count = count + 1 if count == 4: tex_file.append('\\clearpage') count = 0 tex_file.append('\\end{document}') Utility.write_to_file_line_by_line(name_out_path, tex_file) pass
def plot_latent_space(base_path, db_file, name_out_path): names_file = '{}/names.pkl'.format(base_path) out_data = '{}/x.pkl'.format(base_path) input_sensitivity = '{}/input_sensitivity.pkl'.format(base_path) if not Utility.is_file_exist(out_data): print out_data print 'Not exist' return names = Utility.load_obj(names_file) db = Utility.load_obj(db_file) name_list = [] for d in db: name_list.append(d['id']) label = [] for nn in names: idx = name_list.index(nn) label.append(db[idx]['stress']) out = Utility.load_obj(out_data) print out.shape input_sent = Utility.load_obj(input_sensitivity) print input_sent most_dominants = Utility.get_input_sensitivity(input_sent, 2) x = out[:, most_dominants[0]] y = out[:, most_dominants[1]] label = map(int, label) label = np.array(label) print set(label) colors = ['red', 'green', 'blue', 'purple'] plt.clf() plt.scatter(x, y, c=label, cmap=matplotlib.colors.ListedColormap(colors)) plt.savefig(name_out_path)
out_path = '/work/w23/decha/decha_w23/Second_Journal/Latent_space_training_result/05_02a_with_no_duration/input_dim_10/' print out_path for t in [0]: for f in ['nasal', 'no', 'non-nasal']: for v in ['long', 'short']: name = '{}_{}_{}'.format(t, v, f) db_file = '{}/{}.npy'.format(db_path, name) name_out_path = '{}/{}/'.format(out_path, name) Utility.make_directory(name_out_path) if Utility.is_file_exist(db_file): run_training(db_file, name_out_path) # t = '4' # v = 'long' # f = 'no' # name = '{}_{}_{}'.format(t, v, f) # db_file = '{}/{}.npy'.format(db_path, name) # name_out_path = '{}/{}/'.format(out_path, name) # Utility.make_directory(name_out_path) # if Utility.is_file_exist(db_file): # run_training(db_file, name_out_path)
set_syllable_full_path = '{}/{}/'.format(syllable_full_path, ch) set_out_path = '{}/{}/'.format(out_path, ch) Utility.make_directory(set_out_path) if Utility.is_dir_exists(set_stress_path) & Utility.is_dir_exists(set_utt_base_path): print ch for i in xrange(1, 51): name = 'tscsd{}{}'.format(ch, Utility.fill_zero(i, 2)) yaml_filename = '{}/{}.utt.yaml'.format(set_utt_base_path, name ) if not Utility.is_file_exist(yaml_filename): continue full_file = '{}/{}.lab'.format(set_syllable_full_path, name) count = [0] yaml = Utility.yaml_load(yaml_filename) add_stress(yaml, count, name) if not (len(Utility.read_file_line_by_line(full_file)) == count[0] ): print 'Not equal' print name, len(Utility.read_file_line_by_line(full_file)), count[0] out_file = '{}/{}.utt.yaml'.format(set_out_path, name) Utility.yaml_save(out_file, yaml)
def get_data(path): clustered_label = Utility.load_obj('{}/clustered_label.npy'.format(path)) # print len(clustered_label) best_measure_params = Utility.load_obj('{}/best_measure_params.npy'.format(path)) # print best_measure_params name_index = np.array( Utility.load_obj('{}/name_index.npy'.format(path)) ) # print len(name_index) m = Utility.load_obj('{}/GP_model.npy'.format(path)) model = m.X.mean model = np.array(model) # print model input_sensitivity = m.input_sensitivity() print 'Input sent : ', input_sensitivity group_list = ['-1', '0', '1', '2'] sort_list = [] for group in group_list: g = '{}/group_list/{}.npy'.format(path, group) if Utility.is_file_exist(g): names = Utility.load_obj(g) sort_list.append((group, len(names))) Utility.sort_by_index(sort_list, 1) print sort_list unstressed_mean = get_means(sort_list, len(sort_list)-1, name_index, model, path) unstressed_list = Utility.load_obj( '{}/group_list/{}.npy'.format(path, sort_list[len(sort_list)-1][0]) ) stressed_mean = get_means(sort_list, len(sort_list)-2, name_index, model, path) stressed_list = Utility.load_obj( '{}/group_list/{}.npy'.format(path, sort_list[len(sort_list)-2][0]) ) Utility.save_obj( {'unstress_mean': unstressed_mean, 'stress_mean': stressed_mean}, '{}/mean_of_unstress_stress.npy'.format(path) ) lengthscale=1/np.array(input_sensitivity, dtype=float) kernel = GPy.kern.RBF(10, lengthscale=lengthscale, ARD=True) print len(unstressed_list), len(stressed_list) for idx, g in enumerate(sort_list): if idx == (len(sort_list)-2): break names = Utility.load_obj('{}/group_list/{}.npy'.format(path, g[0])) print len(names) latent_data = get_data_from_a_giving_name_index(names, name_index, model) stu = np.array([unstressed_mean, stressed_mean]) distance = -1*np.log(kernel.K( latent_data, stu )) for n, dis in zip(names, distance): if dis[0] > dis[1]: unstressed_list = np.append(unstressed_list, n) else : stressed_list = np.append(stressed_list, n) print len(unstressed_list), len(stressed_list) # print unstressed_list, stressed_list unstressed_data = get_data_from_a_giving_name_index(unstressed_list, name_index, model) stressed_data = get_data_from_a_giving_name_index(stressed_list, name_index, model) unstress_distance = -1*np.log(kernel.K( unstressed_data, np.array([stressed_mean]) )) # print unstress_distance unstress_distance = np.append(unstress_distance, 0.0) unstress_distance = np.reshape(unstress_distance, (len(unstress_distance),1 )) min_max_scaler = preprocessing.MinMaxScaler() unstress_distance = min_max_scaler.fit_transform(unstress_distance) unstress_distance = np.reshape(unstress_distance, len(unstress_distance)) unstress_distance = 1 - unstress_distance # print unstress_distance # print min(unstress_distance), max(unstress_distance) for nam, dis in zip(unstressed_list, unstress_distance): out_dict[nam] = float("{0:.4f}".format(dis)) for nam, dis in zip(stressed_list, [1.0] * len(stressed_list)): out_dict[nam] = dis # print out_dict return (unstressed_list, stressed_list)
def get_training_object(train_list, feature, duration, delta_bool, delta2_bool, base_path): syl_list = [] for t in train_list: syl_obj = Utility.load_obj(t) syl_list += syl_obj.syllables_list syllable_management_object = SyllableDatabaseManagement( syllable_list=syl_list) Y, names, tone, stress, syllable_short_long_type, syllalbe_position, phoneme, syllable_type = syllable_management_object.get_GP_LVM_training_data( feature_key=feature, dur_position=duration, # dur_position=[], delta_bool=delta_bool, delta2_bool=delta2_bool, num_sampling=50, get_only_stress='1') tone = np.array(tone) Y = np.array(Y) for r in range(len(Y[0])): Y[:, r] = preprocessing.normalize(Y[:, r]) arr = np.arange(len(Y)) np.random.shuffle(arr) label_feature = tone alldata = ClassificationDataSet(len(Y[0]), 1, nb_classes=len(set(label_feature))) for a in arr: alldata.addSample(Y[a], label_feature[a]) alldata._convertToOneOfMany() if Utility.is_file_exist('{}/GP_model.npy'.format(base_path)): model = Utility.load_obj('{}/GP_model.npy'.format(base_path)) input_sensitivity = model.input_sensitivity() latent_data = np.array( Utility.load_obj('{}/GP_model.npy'.format(base_path)).X.mean) name_index = np.array( Utility.load_obj('{}/name_index.npy'.format(base_path))) latent_Y = [] for n in names: ind = np.where(name_index == n) # print latent_data[ind][0].shape latent_Y.append(latent_data[ind][0]) latent_Y = np.array(latent_Y) print latent_Y.shape for r in range(len(latent_Y[0])): # latent_Y[:,r] = preprocessing.normalize(latent_Y[:,r]) latent_Y[:, r] = preprocessing.normalize(latent_Y[:, r] * input_sensitivity[r]) lat_data = ClassificationDataSet(len(latent_Y[0]), 1, nb_classes=len(set(label_feature))) for a in arr: # print latent_Y[a], a lat_data.addSample(latent_Y[a], label_feature[a]) else: lat_data = ClassificationDataSet(len(latent_Y[0]), 1, nb_classes=len(set(label_feature))) lat_data._convertToOneOfMany() return (alldata, lat_data)
syllable_predicted_basepath, 'all', data_dict[training_size], data_dict[training_size], block_size, block_size) zero_coeff_predicted_dct_path = '{}/out_{}/tsc/a-{}/infer/a-{}/demo/seed-00/M-{}/B-{}/num_iters-5/dur/predictive_distribution/'.format( zero_coeff_predicted_basepath, 'all', data_dict[training_size], data_dict[training_size], block_size, block_size) #----------Running------------# main_out_data = dict() for num in range(1, 51): name = '{}{}'.format(basename, Utility.fill_zero(num, 2)) f = '{}/{}.pkl'.format(non_optimal_path, name) if Utility.is_file_exist(f): main_out_data[name] = Utility.load_obj(f) continue # outfile = '{}/{}.npy'.format(outpath, name) base_path = '{}/{}/'.format(frame_predicted_lf0_path, name) label_path = '{}/{}.lab'.format(syl_duration_path, name) phone_label_path = '{}/{}.lab'.format(ph_duration_path, name) var_path = '{}/inv_dimension_cov.npy'.format(frame_predicted_lf0_path) #--------Phone--------# phone_base_path = '{}/{}/'.format(phone_predicted_dct_path, name)
def plot_latent_space(base_path, db_file, name_out_path): names_file = '{}/names.pkl'.format(base_path) out_data = '{}/x.pkl'.format(base_path) input_sensitivity = '{}/input_sensitivity.pkl'.format(base_path) if not Utility.is_file_exist(out_data) : print out_data print 'Not exist' return names = Utility.load_obj(names_file) db = Utility.load_obj(db_file) name_list = [] for d in db: name_list.append( d['id'] ) label = [] for nn in names: idx = name_list.index(nn) if db[idx]['stress'] == '1': label.append(db[idx]['stress']) elif nn in potential_list: label.append('3') else : label.append(db[idx]['stress']) out = Utility.load_obj(out_data) # print out.shape input_sent = Utility.load_obj(input_sensitivity) # print 'input_sensitivity : ', sorted(input_sent) most_dominants = Utility.get_input_sensitivity(input_sent, 2) x = out[ :, most_dominants[0] ] y = out[ :, most_dominants[1] ] label = map(int, label) label = np.array(label) # print set(label) train = np.append( out[label==2] , out[label==3], axis=0 ) # train = out[label==2] # print train.shape test = out[label==0] lengthscale=1/np.array(input_sent, dtype=float) k = GPy.kern.RBF(len(train[0]), ARD=True, lengthscale=lengthscale) plt.clf() colors = ['red','green','blue','purple'] md = most_dominants[0] mean = np.mean(train, axis=0) var = np.var(train, axis=0) # rv = multivariate_normal(mean=np.mean(train, axis=0), cov=np.var(train, axis=0)) sd = np.std(train[:,most_dominants[0]], axis=0) for idx, lab in enumerate(label): # if lab == 2: continue # if lab == 3: continue # print out[idx][md], mean d = distance.euclidean(out[idx][md], mean[md]) # print d if d < sd: # label[idx] = 4 label[idx] = 2 elif d < 2*sd: # label[idx] = 6 label[idx] = 2 pass label[label==3] = 2 print len(out), len(names) print set(label), len(label) if len(set(label)) > 3: print 'error : ', name_out_path raise global syl_dict for n, lab in zip(names, label) : syllable = dict() syllable['stress'] = lab syl_dict[n] = syllable # print names # print label # return for idx, s in enumerate( [0,1,4,5,6,2,3] ): # if (s == 3) | (s == 2): if (s == 2): # plt.scatter(x[label==s], y[label==s], c=colors[s], label=s, s=100) plt.scatter(x[label==s], y[label==s], c=colors[s], label='Manual weak stress labeling', s=100) pass elif (s==-1): plt.scatter(x[label==s], y[label==s], c='red', label=s, s=20) elif (s==1): plt.scatter(x[label==s], y[label==s], c='red', label='Stress', s=7) pass elif (s==5): # plt.scatter(x[label==s], y[label==s], c='yellow', label=s, s=20, marker='^', linewidth='0') pass elif (s==4): plt.scatter(x[label==s], y[label==s], c='green', label='Weak stress in 1 SD', s=20, marker='*', linewidth='0') elif (s==6): plt.scatter(x[label==s], y[label==s], c='orange', label='Weak stress in 2 SD', s=20, marker='h', linewidth='0') # else: elif (s==0): plt.scatter(x[label==s], y[label==s], c='black', label='Unstress', s=7, marker='.', linewidth='0') pass plt.scatter(mean[most_dominants[0]], mean[most_dominants[1]], c='red', label=s, s=200, marker='x') x_lim = plt.xlim() y_lim = plt.ylim() xx, yy = np.mgrid[x_lim[0]:x_lim[1]:.01, y_lim[0]:y_lim[1]:.01] pos = np.empty(xx.shape + (2,)) pos[:, :, 0] = xx; pos[:, :, 1] = yy x_train = train[ :, most_dominants[0] ] y_train = train[ :, most_dominants[1] ] # rv = multivariate_normal( # [mean[most_dominants[0]], mean[most_dominants[1]] ], # [var[most_dominants[0]], var[most_dominants[1]] ]) # print rv # print 'means : ', rv.pdf([np.mean(x_train), np.mean(y_train)]) # plt.contourf(xx, yy, rv.pdf(pos), alpha=0.5) # plt.legend(prop={'size':12}) plt.savefig( name_out_path )
def plot_latent_space(base_path, db_file, name_out_path): names_file = '{}/names.pkl'.format(base_path) out_data = '{}/x.pkl'.format(base_path) input_sensitivity = '{}/input_sensitivity.pkl'.format(base_path) if not Utility.is_file_exist(out_data): print out_data print 'Not exist' return names = Utility.load_obj(names_file) db = Utility.load_obj(db_file) name_list = [] for d in db: name_list.append(d['id']) label = [] iden = [] target_id = [] for nn in names: idx = name_list.index(nn) label.append(db[idx]['stress']) iden.append(nn) if nn in ['tscsdm38_55', 'tscsdu01_32', 'tscsdg02_21']: target_id.append(idx) target_id = np.array(target_id) out = Utility.load_obj(out_data) iden = np.array(iden) print out.shape input_sent = Utility.load_obj(input_sensitivity) print input_sent most_dominants = Utility.get_input_sensitivity(input_sent, 2) x = out[:, most_dominants[0]] y = out[:, most_dominants[1]] label = map(int, label) label = np.array(label) print set(label) # ind = np.random.choice(len(label), 20) # x = x[ind] # y = y[ind] # label = label[ind] # iden = iden[ind] colors = ['red', 'green', 'blue', 'purple'] plt.clf() plt.scatter(x, y, c=label, cmap=matplotlib.colors.ListedColormap(colors), alpha=0.5) el = Ellipse((2, -1), 0.5, 0.5) for lab, xx, yy, yyy in zip(['Unstress', 'Strong stress', 'Weak stress'], x[target_id], y[target_id], [50, 100, 50]): # for lab, xx, yy in zip(iden, x, y): # yyy = 20 plt.annotate(lab, xy=(xx, yy), xytext=(0, yyy), textcoords='offset points', ha='left', va='bottom', bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5), arrowprops=dict(arrowstyle="simple", fc="0.6", ec="none", patchB=el, connectionstyle="arc3,rad=0.3", color='g')) plt.savefig(name_out_path)
import numpy as np import matplotlib.pyplot as plt if __name__ == '__main__': frame_less_count = 0 count = 0 for t in [0,1,2,3,4]: for l in ['short', 'long']: for n in ['no', 'nasal', 'non-nasal']: path = '/work/w2/decha/Data/GPR_speccom_data/syllable_database/04_data_with_intepolate_for_training/{}_{}_{}.npy'.format(t, l, n) if Utility.is_file_exist(path): syl_dict = Utility.load_obj(path) for s in syl_dict: syl = s dur = 0.0 for i, d in enumerate(syl['dur']): if i == 0: continue dur = dur + float(d) # print dur # print syl['dur'] frame = dur/50000.0
print outpath label_path = '/work/w2/decha/Data/GPR_speccom_data/00_syllable_level_data/mono/tsc/sd/' for s in Utility.char_range('a', 'z'): set_label_path = '{}/{}/'.format(label_path, s) set_dct_path = '{}/{}/'.format(outpath, s) Utility.make_directory(set_dct_path) for x in range(1, 51): name = 'tscsd{}{}'.format(s, Utility.fill_zero(x, 2)) file_path = '{}/{}.lab'.format(set_label_path, name) if not Utility.is_file_exist(file_path): continue dur_list, names = PoGUtility.gen_dur_and_name_list( file_path, name) if len(dur_list) != len(names): print name # print names dct_list = [] for n in names: if n in syl_dict: if incl_zero == 'not_include_zero_coeff': dct_list.append(syl_dict[n][1:num_coeff])
import matplotlib.pyplot as plt if __name__ == '__main__': base_path = '/work/w13/decha/Inter_speech_2016_workplace/Tonal_projection/10_tone_classification/' for v in Utility.list_file(base_path): if '.' in v: continue for dims in Utility.list_file('{}/{}/'.format(base_path, v)): if '.' in dims: continue for delta in Utility.list_file('{}/{}/{}/'.format( base_path, v, dims)): if '.' in delta: continue for tone in Utility.list_file('{}/{}/{}/{}/'.format( base_path, v, dims, delta)): if '.' in tone: continue tone_path = '{}/{}/{}/{}/{}/'.format( base_path, v, dims, delta, tone) print tone_path gp_model = '{}/GP_model.npy'.format(tone_path) if Utility.is_file_exist(gp_model): m = Utility.load_obj(gp_model) data = m.X.mean data = np.array(data) # print data Utility.save_obj( data, '{}/readable_gp_model.npy'.format(tone_path)) # sys.exit() pass
def gen_latex(db_filepath, figure_path_name, name_out_path, syl_db_name): print db_filepath syl_list = Utility.load_obj(db_filepath) print 'List length : {}'.format(len(syl_list)) fig_path = '{}/{}/'.format(figure_path, figure_path_name) tex_file = [] tex_file.append('\\documentclass{article}') tex_file.append('\\usepackage{geometry}') tex_file.append('\\usepackage[usenames, dvipsnames]{color}') tex_file.append('\\geometry{margin=1cm}') tex_file.append('\\usepackage[english]{babel}') tex_file.append('\\usepackage{graphicx}') tex_file.append('\\begin{document}') tex_file.append('\\begin{figure}[t]') count = 0 db = Utility.load_obj(syl_db_name) for syl in syl_list: # print syl name = syl[0] syl_info = find_syl(db, name) # print name tex_file.append('\\begin{minipage}[b]{.24\\textwidth}') if (syl_info['id'] in potential_list) & (syl[2] == '1'): tex_file.append('\colorbox{yellow}{Stress and potent}') elif (syl_info['id'] in potential_list) & (syl[2] == '2'): tex_file.append('\colorbox{green}{May Stress and potent}') elif syl[2] == '1': tex_file.append('\colorbox{red}{Stress}') elif syl[2] == '2': tex_file.append('\colorbox{blue}{May Stress}') elif syl_info['id'] in potential_list: tex_file.append('\colorbox{Apricot}{Potent}') else: tex_file.append('UnStress') tex_file.append('\\centering') eps = None long_eps = '/work/w2/decha/Data/GPR_speccom_data/figure/lf0_plot_by_vowel_finalconsonant/{}_long_{}/{}.eps'.format( figure_path_name.split('_')[0], figure_path_name.split('_')[1], name) if Utility.is_file_exist(long_eps): eps = long_eps else: eps = '/work/w2/decha/Data/GPR_speccom_data/figure/lf0_plot_by_vowel_finalconsonant/{}_short_{}/{}.eps'.format( figure_path_name.split('_')[0], figure_path_name.split('_')[1], name) tex_file.append( '\\includegraphics[width=\\textwidth]{{{}}}'.format(eps)) tex_file.append('{} {}-{}-{}-{} {}'.format( name.replace('_', '-'), syl_info['consonant'], syl_info['vowel'], syl_info['finalconsonant'].replace('^', '\\textasciicircum'), syl_info['tone'], syl[1] / 50000)) tex_file.append('\\end{minipage}') count = count + 1 if count == 20: tex_file.append('\\end{figure}') tex_file.append('\\clearpage') tex_file.append('\\begin{figure}[t]') count = 0 elif count % 4 == 0: tex_file.append('\\end{figure}') tex_file.append('') tex_file.append('\\begin{figure}[t]') # if not count == 0: tex_file.append('\\end{figure}') tex_file.append('\\end{document}') Utility.write_to_file_line_by_line(name_out_path, tex_file) pass
# sys.exit() if __name__ == '__main__': syllable = dict() outpath_file = '/work/w2/decha/Data/GPR_speccom_data/Interspeech2017/syllable_dictionary_data_with_delta_deltadelta.pkl' base = '/work/w2/decha/Data/GPR_speccom_data/syllable_database/04_data_with_intepolate_for_training/' for tone in [0, 1, 2, 3, 4]: for vowel in ['long', 'short']: for final in ['nasal', 'non-nasal', 'no']: name = '{}_{}_{}'.format(tone, vowel, final) datafile = '{}/{}.npy'.format(base, name) print datafile if Utility.is_file_exist(datafile): mix_data(datafile) # sys.exit() Utility.save_obj(syllable, outpath_file) pass
if __name__ == '__main__': method_path = '/work/w23/decha/decha_w23/Second_Journal/Latent_space_training_result/12c_normalization_by_preprocessing_of_11_data/input_dim_10/' out_main_path = '/work/w23/decha/decha_w23/Second_Journal/Unsupervised_learning_result/12c_normalization_by_preprocessing_of_11_data/' Utility.make_directory(out_main_path) for t in xrange(5): for f in ['nasal', 'no', 'non-nasal']: for v in ['long', 'short']: name = '{}_{}_{}'.format(t, v, f) base_path = '{}/{}/'.format(method_path, name) data_path = '{}/x.pkl'.format(base_path) inverselengthscale_path = '{}/input_sensitivity.pkl'.format( base_path) out_base_path = '{}/{}/'.format(out_main_path, name) if Utility.is_file_exist(data_path): Utility.make_directory(out_base_path) call_run_dbscan(data_path, inverselengthscale_path, out_base_path) else: print 'no ', data_path # sys.exit() pass
d[n] = {'stress': lab} pass d = dict() if __name__ == '__main__': name_path = '/work/w23/decha/decha_w23/Second_Journal/Latent_space_training_result/14_merge_vowel_13_data/input_dim_10/' best_predicted_path = '/work/w23/decha/decha_w23/Second_Journal/Unsupervised_learning_result/01a_gplvm_rerun_dim10/' outpath = '/work/w23/decha/decha_w23/Second_Journal/Evaluation_result/gplvm_result.pkl' for t in xrange(5): for f in ['nasal', 'no', 'non-nasal']: name = '{}_{}'.format(t, f) name_file = '{}/{}/names.pkl'.format(name_path, name) label_file = '{}/{}/prediction_labels.pkl'.format( best_predicted_path, name) if Utility.is_file_exist(name_file): load_name_and_label(name_file, label_file) # sys.exit() Utility.save_obj(d, outpath) pass