def get_context_list_of_a_phone(filepath, target_phone):
yaml_file = Utility.yaml_load(filepath)
# print yaml_file['preprocess']
print 'Target phone : {}'.format(target_phone)
for event in yaml_file['context_events']:
name = event['name']
args = event['value_getter']['event_feature']['args']
type = None
if len(args) > 1:
type = args[1]['args'][0]
# print type
if type == 'entity':
d = "{}".format(args[0])
d = d.split(',')
for ph in d:
if '\'{}\''.format(target_phone) in ph:
ph = '{}'.format(ph)
ph = ph.split('[')[-1].split(']')[0]
# print ph
# if int(ph) == 1:
if 'begin' in name:
if ph == '{}'.format(1):
print name, ph
# print d
# break
# Utility.print_yaml_formatted(yaml_file['context_events'][2])
# Utility.print_yaml_formatted(yaml_file['context_events'][2]['name'])
# Utility.print_yaml_formatted(yaml_file['context_events'][2]['value_getter']['event_feature']['args'][0]['uua'])
pass
def get_data_with_missing_values(self,
num_sampling, subtract_typical_contour, feature_name=None,
delta=False, deltadelta=False):
x = np.linspace(0, len(self.raw_data), num=num_sampling)
Y = np.interp(x, np.arange(len(self.raw_data)), self.raw_data)
data = Y
if feature_name is not None:
training_data = np.interp(x, np.arange(len(self.training_feature[feature_name])), self.training_feature[feature_name])
# print training_data, len(training_data)
data = training_data
data[ Y<0 ] = np.nan
if subtract_typical_contour:
typical_tone_path = '/home/h1/decha/Dropbox/Inter_speech_2016/Syllable_object/Typical_contour/50dims/tone_{}.pickle'.format(self.tone)
typical_tone_obj = Utility.load_obj(typical_tone_path)
data = data - typical_tone_obj
# print data, len(data)
if delta:
y_delta = np.gradient(data)
# print y_delta
if deltadelta:
y_delta_delta = np.gradient(y_delta)
# print y_delta_delta
y_delta = np.append(y_delta, y_delta_delta)
data = np.append(data, y_delta)
# print np.array(data), len(data)
return np.array(data)
def find_min_y(db_all):
max_y = 600
for syl in Utility.load_obj(db_all):
if len(syl['raw_lf0']) == 0: continue
r = syl['raw_lf0']
r = np.array(r)
r[r<0] = np.nan
# print r
# sys.exit()
if min( np.exp( r ) ) < 150:
# print min( np.exp( r ) )
continue
if min( np.exp( r ) ) < max_y:
max_y = min( np.exp( r ) )
print 'min y = ', max_y
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 run_data_processor(db_file):
db = Utility.load_obj(db_file)
real = []
Y = []
for syl in db:
if syl['stress'] == '2':
real.append(1)
elif syl['stress'] in ['0', '1']:
real.append(int(syl['stress']))
else:
print syl['stress']
real.append(int(syl['stress']))
Y.append(
syl['TF']['intepolate151_normalize_by_preprocessing.normalize']
['data'])
# sys.exit()
real = np.array(real)
Y = np.array(Y)
return (Y, real)
pass
def plot(data, inverselengthscale, labels, name_out_file, title):
# most_dominants = Utility.get_input_sensitivity(inverselengthscale, 2)
# x = data[ :, 0 ]
# y = data[ :, 1 ]
x = data[:, 0]
y = data[:, 2]
label = map(int, labels)
label = np.array(labels)
print set(labels)
# colors = ['red','green','blue','purple']
if len(labels) > 1000:
ind = np.random.choice(len(labels), 1000)
x = x[ind]
y = y[ind]
labels = labels[ind]
colors = Utility.get_color_map(len(set(labels)))
plt.clf()
# plt.scatter(x, y, c=labels, cmap=matplotlib.colors.ListedColormap(colors))
for idx, s in enumerate(sorted(set(labels))):
plt.scatter(x[labels == s], y[labels == s], c=colors[idx], label=s)
plt.legend()
plt.title(title)
plt.savefig(name_out_file)
def get_training_object(train_list, feature):
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=[1,2],
delta_bool=True,
delta2_bool=True,
num_sampling=50)
stress = np.array(stress)
stress[stress=='Stress'] = 1
stress[stress=='Unstress'] = 0
label_feature = stress
alldata = ClassificationDataSet(len(Y[0]), 1, nb_classes=len(set(label_feature)))
for idx, yyy in enumerate(Y):
alldata.addSample(yyy, label_feature[idx])
alldata._convertToOneOfMany( )
return alldata
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 run_nn_train_tone_classification(trndata, tstdata, outpath, name, fold):
print 'run_nn_train_tone_classification'
fnn = buildNetwork(trndata.indim, 20, trndata.outdim, hiddenclass=TanhLayer, bias=True)
trainer = BackpropTrainer( fnn, dataset=trndata, weightdecay=0.006)
# trainer = BackpropTrainer( fnn, dataset=trndata, verbose=True)
acc = 0.0
tag = 'No acc'
real_obj = []
predicted_obj = []
class_recog = 0
for i in range(100):
trainer.trainEpochs( 1 )
trnresult = percentError( trainer.testOnClassData(),
trndata['class'] )
tstresult = percentError( trainer.testOnClassData(
dataset=tstdata ), tstdata['class'] )
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
predicted = np.array( trainer.testOnClassData(dataset=tstdata) )
real = np.array( tstdata['class'][:,0] )
# print real
# if (accuracy_score(real, predicted) > acc) & (0 != len(np.where(predicted==1)[0])):
if ( len(set(predicted)) >= class_recog):
class_recog = len(set(predicted))
print 'Tone num : {}'.format(set(predicted))
tag = "Add acc when epoch: %4d" % trainer.totalepochs
real_obj = real
predicted_obj = predicted
acc = accuracy_score(real, predicted)
# else:
# print predicted
Utility.save_obj(real_obj, '{}/{}_fold_{}_real.npy'.format(outpath, name, fold))
Utility.save_obj(predicted_obj, '{}/{}_fold_{}_predicted.npy'.format(outpath, name, fold))
print tag
print 'Accuracy : {}'.format( acc )
print 'Precision : {}'.format( precision_score(real_obj, predicted_obj, average=None) )
print 'Recall : {}'.format( recall_score(real_obj, predicted_obj, average=None) )
print 'F-1 : {}'.format( f1_score(real_obj, predicted_obj, average=None) )
return acc
def is_finish(rmse_list):
if len(rmse_list) < 2:
print 'Finish cause no more input'
return True
Utility.sort_by_index(rmse_list, 0)
print rmse_list
first = rmse_list[0]
second = rmse_list[1]
for a, b in zip(first, second):
if abs(a - b) > threshold:
return False
return True
def run_export_input_sensitivity(system_paths, tones):
for path in system_paths:
for tone in tones:
target_path = '{}/Tone_{}/'.format(path, tone)
model = Utility.load_obj('{}/GP_model.npy'.format(target_path))
input_sensitivity = model.input_sensitivity()
data = model.X.mean
data_object = np.array(data)
input_sensitive_path = '{}/input_sentivity.npy'.format(target_path)
data_object_path = '{}/data_object.npy'.format(target_path)
Utility.save_obj(input_sensitivity, input_sensitive_path)
Utility.save_obj(data_object, data_object_path)
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 get_j_set(db_file, out_file, sort_list_out_file):
j_set_db = []
j_set_sort_list = []
db = Utility.load_obj(db_file)
for syl in db:
if 'j' in syl['id']:
j_set_db.append(syl)
# print syl['dur']
dur = 0
for idx, d in enumerate(syl['dur']):
if idx == 0: continue
dur = dur + d
j_set_sort_list.append((syl['id'], d, syl['stress']))
Utility.sort_by_index(j_set_sort_list, 1)
print j_set_sort_list
Utility.save_obj(j_set_sort_list, sort_list_out_file)
Utility.save_obj(j_set_db, out_file)
pass
def check(v, t, obj_path):
print obj_path
obj = Utility.load_obj(obj_path)
print '------------------------------------------'
print v, t
for syl in obj.syllables_list:
print syl.get_vowel_length_type(), syl.tone
pass
def run(syllable_object, main_out_path):
vowel_type = ['v', 'vv', 'vn', 'vvn', 'vsg', 'vvsg']
tones = ['0', '1', '2', '3', '4']
syllable_lists = dict()
for v in vowel_type:
for t in tones:
syllable_lists['{}_{}'.format(v, t)] = []
for syl in syllable_object.syllables_list:
syllable_lists['{}_{}'.format(syl.get_vowel_length_type(),
syl.tone)].append(syl)
for s in syllable_lists:
spl = s.split('_')
outpath = '{}/{}/{}/'.format(main_out_path, spl[0], spl[1])
Utility.make_directory(outpath)
plot_syllable(syllable_lists[s], outpath)
def cal_lf0(config):
base_path = config['base_path']
label_path = config['label_path']
name = config['name']
outfilepath = config['outfilepath']
var_path = config['var_path']
syllable_base_path = config['syllable_base_path']
syllable_var_path = config['syllable_var_path']
#----------Syllable level--------#
dur_list, names = PoGUtility.gen_dur_and_name_list(label_path, name)
# print dur_list
# print names
syl_mean = np.load('{}/mean.npy'.format(syllable_base_path))
# syl_mean, cccc = gen_mean_and_cov_of_dct_fake(names)
syl_cov = np.load('{}/cov.npy'.format(syllable_base_path))
print syl_cov
var = np.load('{}'.format(syllable_var_path))
vv = []
for i, v in enumerate(var):
vv.append(v[i])
syl_var = np.array(vv)
o = []
for data_dct, dur in zip(syl_mean, dur_list):
i_dct = PoGUtility.generate_inverse_DCT(data_dct, dur)
# print i_dct
o = o + i_dct
o = np.array(o)
o[o < 3] = np.nan
print o.shape
org = Utility.read_lf0_into_ascii(
'/work/w2/decha/Data/GPR_speccom_data/data_before_remove_silence/lf0/tsc/sd/j/{}.lf0'
.format(name))
org[org < 0] = np.nan
diff = len(org) - len(o)
plt.plot(np.arange(len(o)) + diff, o, label='syn')
plt.plot(range(len(org)), org, label='org')
plt.legend()
plt.savefig('./{}_dct_16_test.eps'.format(name))
sys.exit()
pass
def hmm_frame_to_mono_label(dur_path, mono_path, out_path):
for dur_file in Utility.list_file(dur_path):
if not 'dur' in dur_file: continue
base = Utility.get_basefilename(dur_file)
# print base
dur = '{}/{}'.format(dur_path, dur_file)
# print dur
dur_list = get_dir_list_HMM(dur)
# print dur_list
mono = '{}/{}.lab'.format(mono_path, base)
mono_list = load_mono(mono)
out_file = '{}/{}.lab'.format(out_path, base)
# print len(dur_list), len(mono_list)
if len(dur_list) != len(mono_list):
print base
start = 0
out = []
for idx, d in enumerate(dur_list):
# print dur_list[idx][0], mono_list[idx]
o = '{}\t{}\t{}'.format(int(start),
int(start + (dur_list[idx][0] * 10000000)),
mono_list[idx])
out.append(o)
start = start + (dur_list[idx][0] * 10000000)
Utility.write_to_file_line_by_line(out_file, out)
# sys.exit()
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 find_config(name):
for line in config_setting:
spl = Utility.trim(line).split(' ')
if name == spl[0]:
print spl
n_cluster = spl[1]
n_neighbor = spl[2]
return (n_cluster, n_neighbor)
def check_result(object_list_path):
for obj_path in object_list_path:
syl_object = Utility.load_obj(obj_path)
syl_list = syl_object.syllables_list
for syl in syl_list:
print syl.get_phone_duration()
pass
def run_add_and_non_duration(out_base, vowel, d, tone, feature_name, num_dims):
for n in num_dims:
print '------------Start-----------'
print 'Vowel : {}, Delta : {}, Tone : {}'.format(vowel, d, tone)
base_path = '{}/{}/input_dims_{}/delta-{}_delta-delta-{}/BGP_LVM_Tone_{}/'.format(
out_base, vowel, n, d[0], d[1], tone)
syllable_object = '{}/{}/syllable_object_{}_fold/syllable_object_{}_3-fold_'.format(
object_base, vowel, tone, tone)
outpath = '{}/{}/input_dims_{}/delta-{}_delta-delta-{}/BGP_LVM_Tone_{}/feed_forword_ann/{}/'.format(
out_base, vowel, n, d[0], d[1], tone, feature_name)
print 'ANN outpath : {}'.format(outpath)
print 'Syllable object : {}'.format(syllable_object)
Utility.make_directory(outpath)
run(syllable_object, fold, outpath, feature, [1, 2], d[0], d[1],
base_path)
print '------------End-----------'
print '------------Start-----------'
print 'Vowel : No_duration_{}, Delta : {}, Tone : {}'.format(
vowel, d, tone)
base_path = '{}/{}/input_dims_{}/delta-{}_delta-delta-{}/BGP_LVM_Tone_{}/'.format(
out_base, 'No_duration_' + vowel, n, d[0], d[1], tone)
syllable_object = '{}/{}/syllable_object_{}_fold/syllable_object_{}_3-fold_'.format(
object_base, vowel, tone, tone)
outpath = '{}/{}/input_dims_{}/delta-{}_delta-delta-{}/BGP_LVM_Tone_{}/feed_forword_ann/{}/'.format(
out_base, 'No_duration_' + vowel, n, d[0], d[1], tone,
feature_name)
print 'ANN outpath : {}'.format(outpath)
print 'Syllable object : {}'.format(syllable_object)
Utility.make_directory(outpath)
run(syllable_object, fold, outpath, feature, [], d[0], d[1], base_path)
print '------------End-----------'
def lf0_distortion_syn_is_gpr_format(org_path,syn_path):
lf0_true_list = []
lf0_pred_list = []
for base in Utility.list_file(org_path) :
if base.startswith('.'):
continue
# if '12' in base: continue
# 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 lf0_original, lf0_synthesis in 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)
rmse = numpy.sqrt(sklearn.metrics.mean_squared_error(lf0_true_list, lf0_pred_list)) * 1200 / numpy.log(2)
print('LF0 RMSE: {:f} in {} frames'.format(rmse, len(lf0_true_list)))
pass
def check_result():
path = '/home/h1/decha/Dropbox/Inter_speech_2016/Syllable_object/Tonal_object/remove_all_silence_file//vvvsg//syllable_object_01234.pickle'
obj = Utility.load_obj(path)
for syl in obj.syllables_list:
if syl.name_index == 'tscsd_manual_g37_14':
print syl.name_index, syl.stress_manual
pass
def cal_F1(tones, vowel, m, base, types):
real = np.array( [] )
predicted = np.array( [] )
for v in vowel:
for t in tones:
path = '{}/{}/input_dims_10/delta-True_delta-delta-True/BGP_LVM_Tone_{}/feed_forword_ann/{}/'.format(base, v, t, m)
for fold in range(3):
real_obj = Utility.load_obj( '{}/{}_data_fold_{}_real.npy'.format(path, types, fold) )
real = np.append(real, real_obj)
predicted_obj = Utility.load_obj( '{}/{}_data_fold_{}_predicted.npy'.format(path, types,fold) )
predicted = np.append(predicted, predicted_obj)
print tones, m
print f1_score(real, predicted, average=None)
pass
def build_db(db_file):
global db
d = Utility.load_obj(db_file)
db = db + d
# print len(db)
pass
def get_prediction_result(base_method_path, db_file):
pred = Utility.load_obj('{}/prediction_labels.pkl'.format(base_method_path))
real = run_data_processor(db_file)
acc, f1 = cal_result(real, pred)
return (pred, real, acc, f1)
pass
def gen_data(db_file, name_out_path):
out = []
debug = False
for syl in Utility.load_obj(db_file):
# debug = False
# if syl['id'] == 'tscsdj08_19':
# debug = True
y = Syllable.get_normalize_gradient_interpolation(syl['raw_lf0'],
50,
syl['dur'],
debug=debug)
# print y, len(y)
if y is None:
print syl['id']
# print syl['raw_lf0']
# sys.exit()
continue
syl['TF'] = dict()
inte_data = dict()
inte_data['data'] = y
inte_data[
'description'] = 'Raw lf0 (first 50 + delta + delta-delta) + duration in frame unit (the last one). Unvoice frames are interpolated by 3-rd polynomial '
syl['TF']['intepolate151'] = inte_data
# print syl
out.append(syl)
# sys.exit(0)
Utility.save_obj(out, name_out_path)
pass
def read_mos(data_folder):
all_score = dict()
c_all_score = dict()
count = dict()
for score_file in Utility.list_file(data_folder):
if score_file.startswith('.'): continue
if not 'mos' in score_file: continue
# print score_file
score = Utility.load_json('{}/{}'.format(data_folder, score_file))
for s in score:
# print score[s]
for k in score[s]:
# print k, score[s][k]
if k in all_score:
all_score[k] = all_score[k] + float(score[s][k])
# if k=='01_GPR_single_level/':
# print float(score[s][k]), all_score[k]
count[k] = count[k] + 1
c_all_score[k].append(float(score[s][k]))
else:
all_score[k] = float(score[s][k])
count[k] = 1
c_all_score[k] = []
c_all_score[k].append(float(score[s][k]))
print '-----------------------------------------'
for k in all_score:
print k, all_score[k]
print count[k]
print all_score[k] / count[k]
print 'Mean :', np.average(c_all_score[k]), 'Var :', np.var(
c_all_score[k])
def draw_figure(db_name, name_out_path):
db = Utility.load_obj(db_name)
for syl in db:
# print syl
lf0 = syl['raw_lf0']
durs = syl['dur']
n = syl['id']
plot(lf0, durs, n, name_out_path)
def cal_lf0(config):
base_path = config['base_path']
label_path = config['label_path']
name = config['name']
outfilepath = config['outfilepath']
var_path = config['var_path']
syllable_base_path = config['syllable_base_path']
syllable_var_path = config['syllable_var_path']
original = config['original']
koriyama_gen = config['koriyama_gen']
figure_path = config['figure_path']
ph_in_syl_object_path = config['phone_in_syllable_object_path']
stress = config['stress']
original_vuv = config['original_vuv']
p_in_s_file = Utility.load_obj(ph_in_syl_object_path)
vuv = np.load('{}/class.npy'.format(config['vuv_path']))
if mask == 'original':
vuv = original_vuv
#--------Frame-------#
lf0_mean = np.load('{}/mean.npy'.format(base_path))
lf0_cov = np.load('{}/cov.npy'.format(base_path))
var = np.load('{}'.format(var_path))
if len(lf0_cov) > len(vuv):
for i in range(len(lf0_cov) - len(vuv)):
vuv.append(-1, axis=0)
elif len(lf0_cov) < len(vuv):
vuv = vuv[0:len(lf0_cov)]
lf0_var = np.sum(var, axis=0)
lf0_mean = np.array([lf0_mean[:, 0], lf0_mean[:, 1], lf0_mean[:, 2]])
lf0_w = PoGUtility.generate_W_for_GPR_generate_features(len(lf0_cov), vuv)
frame_B = alpha * PoGUtility.cal_sum_of_mean_part(lf0_var, lf0_w, lf0_cov,
lf0_mean)
frame_A = alpha * PoGUtility.cal_sum_of_weight_part(
lf0_var, lf0_w, lf0_cov)
L = linalg.cholesky(frame_A, lower=True)
lf0 = linalg.cho_solve((L, True), frame_B)
lf0[lf0 < 1] = np.nan
np.save(outfilepath, lf0)
pass
