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 run_gen(full_path, dur_path, lf0_path, start, stop):
for sett in Utility.char_range(start, stop):
dur_set_path = '{}/{}/'.format(dur_path, sett)
full_set_path = '{}/{}/'.format(full_path, sett)
lf0_set_path = '{}/{}/'.format(lf0_path, sett)
if not (Utility.is_dir_exists(dur_set_path)
& Utility.is_dir_exists(full_set_path)
& Utility.is_dir_exists(lf0_set_path)):
print 'No set : ', sett
continue
for f in Utility.list_file(full_set_path):
if f.startswith('.'): continue
print f
base = Utility.get_basefilename(f)
dur_list = '{}/{}.dur'.format(dur_set_path, base)
lf0_list = '{}/{}/'.format(lf0_set_path, base)
full_list = '{}/{}.lab'.format(full_set_path, base)
run_make_obj_for_an_utterance(full_list, dur_list, lf0_list)
# sys.exit(0)
pass
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
b = Utility.get_basefilename(base)
# 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))
synthesis_vector = np.nan_to_num(synthesis_vector)
synthesis_vector[np.where(synthesis_vector <= 0.0)] = UNDEF_VALUE
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)
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)))
pass
def duration_distortion_from_numpy_list(org_path, syn_path):
path = syn_path
original_path = org_path
ori = []
ph_list = []
syn = []
for f in Utility.list_file(path):
if f.startswith('.'): continue
if 'mean' not in f: continue
syn_path = '{}/{}'.format(path, f)
# print syn_path
syn_list = numpy.load(syn_path)
sl = syn_list.flatten()
syn.extend(list(sl))
base = Utility.get_basefilename(f)
base = base[0:len(base) - 5]
ori_path = '{}/{}.lab'.format(original_path, base)
# print ori_path
phone_list, dur_list = Distortion.load_ori_list_in_sec(ori_path)
ori.extend(dur_list)
ph_list.extend(phone_list)
# print len(ph_list), len(ori), len(syn)
dur_true_list = []
dur_pred_list = []
for idx, p in enumerate(ph_list):
if (p == 'sil') | (p == 'pau'): continue
dur_true_list.append(1000 * ori[idx])
dur_pred_list.append(1000 * syn[idx])
if len(dur_true_list) != len(dur_pred_list):
print "Not equal"
print dur_pred_list
print dur_true_list
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)))
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 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 load_data_into_syllable_object(self,
pattern,
lf0_path=None,
label_path_list=None):
out_list = []
print 'load_data_into_syllable_object'
for file in label_path_list:
# print file
set = SyllableDatabaseManagement.get_file_set(file)
# print set
filename = Utility.get_basefilename(file)
# print filename
file_index = filename[-2:]
# print file_index
count = 0
for line in Utility.read_file_line_by_line(file):
# print line
match = re.match(pattern, line)
if match:
tone = match.group('tone')
if 'x' in tone:
continue
count += 1
syllable_position_in_word = match.group(
'syllable_position')
number_of_syllable_in_word = match.group(
'number_of_syllable')
# stress = match.group('stress')
if 'stress' in match.groupdict():
stress = match.group('stress')
else:
stress = None
consonant = match.group('consonant')
vowel = match.group('vowel')
finalconsonant = match.group('finalconsonant')
part_of_speech = match.group('part_of_speech')
time_duration = int(match.group('end')) - int(
match.group('start'))
raw_data_path = '{}/{}/{}/{}.lf0'.format(
lf0_path, set, filename, count)
raw_data = np.loadtxt(raw_data_path)
duration = len(raw_data)
name_index = 'tscsd_gpr_{}{}_{}'.format(
set, file_index, count)
syllable = Syllable(
raw_data=raw_data,
name_index=name_index,
number_of_syllable_in_word=number_of_syllable_in_word,
syllable_position_in_word=syllable_position_in_word,
syllable_index_in_file=count,
tone=int(tone),
stress_manual=stress,
filename=filename,
consonant=consonant,
vowel=vowel,
final_consonant=finalconsonant,
duration=duration,
part_of_speech=part_of_speech,
time_duration=time_duration)
out_list.append(syllable)
# print syllable
# print len(syllable.raw_data)
else:
print line
# print count
# return
print 'Load finish : {} Syllables'.format(len(out_list))
self.syllables_list = out_list
pass
def cal_syllable_dur(dur_path, syl_dur_path, hmm=False):
org_all, gen_all = [], []
file_count = 0
# print Utility.list_file(dur_path)
for dur_file in Utility.list_file(dur_path):
# print dur_file
if hmm:
if 'dur' not in dur_file:
continue
elif 'npy' not in dur_file:
continue
file_count = file_count + 1
basename = Utility.get_basefilename(dur_file)
# print basename
org_path = '{}/{}.lab'.format(syl_dur_path, basename)
org_dur_list, num_phone = get_org_syllable_list(org_path)
if not hmm:
gen_dur = get_dur_list('{}/{}'.format(dur_path, dur_file))
else:
gen_dur = get_dir_list_HMM('{}/{}'.format(dur_path, dur_file))
gen_syn_dur = []
idx = 0
# print len(num_phone)
# print num_phone
# print gen_dur
summ = 0
for num in num_phone:
# print num
if num == 'x':
gen_syn_dur.append(gen_dur[idx][0])
idx = idx + 1
else:
syllable_duration = 0
summ = summ + int(num)
for n in range(1, int(num) + 1):
# print n, num
syllable_duration = syllable_duration + gen_dur[idx][0]
idx = idx + 1
# print syllable_duration
gen_syn_dur.append(syllable_duration)
# print len(num_phone), idx, len(gen_dur), summ
if len(gen_syn_dur) != len(org_dur_list):
print 'Not equal'
print dur_path
# print gen_syn_dur
for idx, num in enumerate(num_phone):
if num == 'x':
continue
org = org_dur_list[idx] * 1000
gen = gen_syn_dur[idx] * 1000
org_all.append(org)
gen_all.append(gen)
# print org, gen
# break
# RMSE for dur in syllable
rmse = numpy.sqrt(sklearn.metrics.mean_squared_error(org_all, gen_all))
# print file_count
print rmse
pass
lf0_out_path = '{}/{}/'.format(lf0_outpath, s)
mcep_out_path = '{}/{}/'.format(mcep_outpath, s)
bap_out_path = '{}/{}/'.format(bap_outpath, s)
# Utility.make_directory(cmp_outpath)
Utility.make_directory(lf0_out_path)
Utility.make_directory(mcep_out_path)
Utility.make_directory(bap_out_path)
print s
for f in Utility.list_file(mono_set_path):
if f.startswith('.'): continue
base = Utility.get_basefilename(f)
# print base
mono = Utility.read_file_line_by_line('{}/{}.lab'.format(
mono_set_path, base))
mono_remove = Utility.read_file_line_by_line('{}/{}.lab'.format(
mono_remove_silence_path, base))
# cmp_file = '{}/{}/{}.cmp'.format(cmp_path, s, base)
# out_cmp_file = '{}/{}/{}.cmp'.format(out_path, s, base)
mono_head = mono[0].split(' ')
mono_tail = mono[len(mono) - 1].split(' ')
mono_head_dur = int(mono_head[1]) - int(mono_head[0])
pass
if __name__ == '__main__':
full_path = '/home/h1/decha/Dropbox/Inter_speech_2016/Test_set/full/'
outpath = '/work/w2/decha/Data/GPR_data/label/09_stress_manual_labeling/utt/tsc/sd/'
start_set, end_set = 'i', 'i'
for sett in Utility.char_range(start_set, end_set):
set_path = '{}/{}/'.format(full_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
base_name = Utility.get_basefilename(f).split('.')[0]
out_file = '{}/{}.utt.yaml'.format(out_set_path, base_name)
file_path = '{}/{}'.format(set_path, f)
print out_file
# sys.exit()
gen_utt(file_path, out_file)
# for line in Utility.read_file_line_by_line(file_path):
# sys.exit()
pass
db_dict = dict()
lab_path = '/work/w23/decha/decha_w23/Second_Journal/sync_google_drive/Second_journal_Code/12_plot_j_set/j_set_for_3_level_stress_label/'
for f in Utility.list_file(lab_path):
if 'wav' in f: continue
if f.startswith('.'): continue
print f
count = 0
for line in Utility.read_file_line_by_line('{}/{}'.format(lab_path,
f)):
count = count + 1
name = '{}_{}'.format(Utility.get_basefilename(f), count)
spl = line.split(' ')
stress = Utility.trim(spl[2].split('_')[5])
# print name, stress
if stress not in ['0', '1', '2']:
print name, 'Error'
sys.exit()
syl = dict()
syl['stress'] = stress
db_dict[name] = syl
lf0_set_path = '{}/{}/'.format(lf0_path, sett)
out_set_path = '{}/{}/'.format(out_path, sett)
plot_set_out = '{}/{}/'.format(plot_out_path, sett)
Utility.make_directory(plot_set_out)
for f in Utility.list_file(set_path):
if f.startswith('.'):
continue
file_path = '{}/{}'.format(set_path, f)
# print file_path
base = Utility.get_basefilename(file_path)
print f, base
lf0_file_path = '{}/{}.lf0'.format(lf0_set_path, base)
# print plot_set_out
plot_syllable(file_path, lf0_file_path, out_set_path, base,
plot_set_out)
# sys.exit()
pass
# 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
out = []
if __name__ == '__main__':
label_path = '/work/w2/decha/Data/GPR_speccom_data/00_syllable_level_data/full_time/tsc/sd/'
for sett in ['j']:
label_set_path = '{}/{}/'.format(label_path, sett)
for f in Utility.list_file(label_set_path):
if f.startswith('.'): continue
filepath = '{}/{}'.format(label_set_path, f)
get_last_syllable(filepath, Utility.get_basefilename(f))
# sys.exit()
Utility.save_obj(out, './potential_list.pkl')
pass
def run_make_obj_for_an_utterance(full_path, dur_path, lf0_path):
global syl_database
pattern = re.compile(
r"""(?P<start>.+)\s(?P<end>.+)\s(?P<consonant>.+)\-(?P<vowel>.+)\+(?P<finalconsonant>.+)/A:.+/B:.+\-(?P<tone>.+)\+.+/C:.+/E:.+""",
re.VERBOSE)
# print dur_path
# print lf0_path
dur_list = Utility.load_obj(dur_path)
lf0_list = Utility.list_file(lf0_path)
lf0_list = sort_dur_list_by_index(lf0_list)
# print lf0_list
for idx, line in enumerate(Utility.read_file_line_by_line(full_path)):
c = idx + 1
# print line
l = Utility.trim(line)
match = re.match(pattern, line)
if match:
start = float(match.group('start'))
end = float(match.group('end'))
consonant = match.group('consonant')
vowel = match.group('vowel')
finalconsonant = match.group('finalconsonant')
tone = match.group('tone')
dur = dur_list[idx]
lf0 = Utility.read_file_line_by_line('{}/{}'.format(
lf0_path, lf0_list[idx]))
lf0 = [float(i) for i in lf0]
iden = '{}_{}'.format(Utility.get_basefilename(full_path), c)
# print start, end, consonant, vowel, finalconsonant, tone, dur, lf0, iden
syl = dict(
) #Syllable(iden, tone, consonant, vowel, finalconsonant, dur, lf0)
syl['id'] = iden
syl['tone'] = tone
syl['consonant'] = consonant
syl['vowel'] = vowel
syl['finalconsonant'] = finalconsonant
syl['dur'] = dur
syl['raw_lf0'] = lf0
syl_database.append(syl)
# sys.exit(0)
else:
raise TypeError("WTF")
pass
def lf0_distortion_syn_is_gpr_format(org_path, data_dict, stress_list,
mono_label, tone, stress_type):
UNDEF_VALUE = -1.0e+10
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([])
# Load Synthesis
synthesis_vector = data_dict['initial'][1][b]
for st, mono in zip(stress, mono_file):
spl = mono.split(' ')
start = int(spl[0]) / 50000
end = int(spl[1]) / 50000
if not (st[0] == '1'):
st[0] = '0'
if (st[0] == str(stress_type)):
if str(st[2]) == '0':
pt = 'initial'
elif str(st[2]) == '1':
pt = 'vowel'
elif str(st[2]) == '2':
pt = 'final'
synthesis_vector[start:end] = data_dict[pt][int(
st[1])][b][start:end]
if '{}'.format(tone) == 'all':
stress_index = np.append(stress_index,
np.arange(start, end),
axis=0)
elif 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 = np.loadtxt(
Utility.read_lf0_into_ascii(original_file))
# print synthesis_vector
synthesis_vector = np.nan_to_num(synthesis_vector)
synthesis_vector[np.where(synthesis_vector <= 0.0)] = UNDEF_VALUE
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)
print 'Stress {}, Tone {}'.format(stress_type, tone)
rmse = np.sqrt(
sklearn.metrics.mean_squared_error(lf0_true_list,
lf0_pred_list)) * 1200 / np.log(2)
print('All LF0 RMSE: {:f} in {} frames'.format(rmse, len(lf0_true_list)))
rmse = np.sqrt(
sklearn.metrics.mean_squared_error(
lf0_true_stress_list, lf0_pred_stress_list)) * 1200 / np.log(2)
print('Only specific case LF0 RMSE: {:f} in {} frames'.format(
rmse, len(lf0_true_stress_list)))
return rmse
pass
outpath = '/work/w2/decha/Data/GPR_data/label/11_stress_unsupervised_continuous_labeling/utt/tsc/sd/'
Utility.make_directory(outpath)
stress_dict = Utility.load_obj(
'/home/h1/decha/Dropbox/python_workspace/Inter_speech_2016/Gen_context_from_latent_variable/stress_distance_dict.npy'
)
start_set, end_set = 'a', 'h'
for sett in Utility.char_range(start_set, end_set):
set_path = '{}/{}/'.format(full_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
base_name = Utility.get_basefilename(f).split('_')[2]
out_file = '{}/tscsd{}.utt.yaml'.format(out_set_path, base_name)
file_path = '{}/{}'.format(set_path, f)
print out_file
gen_utt(file_path, out_file, base_name)
# 1248 9493 30
print unclass_count
pass
def duration_distortion_from_numpy_list_syllable_level(org_path, syn_path):
path = syn_path
original_path = org_path
ori = []
ph_list = []
syn = []
for f in Utility.list_file(path):
if f.startswith('.'): continue
if 'mean' not in f: continue
syn_path = '{}/{}'.format(path, f)
# print syn_path
syn_list = numpy.load(syn_path)
sl = list(syn_list.flatten())
base = Utility.get_basefilename(f)
base = base[0:len(base) - 5]
ori_path = '{}/{}.lab'.format(original_path, base)
# print ori_path
phone_num, dur_list = Distortion.load_ori_list_in_sec_and_num_phone_list(
ori_path)
s_out = []
sl_count = 0
for pn in phone_num:
if pn is 'x':
s_out.append(sl[sl_count])
sl_count = sl_count + 1
else:
d = 0
for i in range(int(pn)):
d = d + sl[sl_count]
sl_count = sl_count + 1
s_out.append(d)
ori.extend(dur_list)
ph_list.extend(phone_num)
syn.extend(s_out)
# print len(ph_list), len(ori), len(syn)
dur_true_list = []
dur_pred_list = []
for idx, p in enumerate(ph_list):
if (p == 'x'): continue
dur_true_list.append(1000 * ori[idx])
dur_pred_list.append(1000 * syn[idx])
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)))
plt.savefig(outfile)
pass
if __name__ == '__main__':
org = '/work/w2/decha/Data/GPR_speccom_data/mono_to_syl_dur/'
hmm = '/work/w25/decha/decha_w25/ICASSP_2017_workspace/mono_label/01_GPR/mono_to_syl_dur/'
gpr = '/work/w25/decha/decha_w25/ICASSP_2017_workspace/mono_label/02_GPR_with_multi_level/mono_to_syl_dur/'
gpr_with_multi_level = '/work/w25/decha/decha_w25/ICASSP_2017_workspace/mono_label/03_PoG/mono_to_syl_dur/'
outpath = './dur_distortion_syl/'
Utility.make_directory(outpath)
for lab in Utility.list_file(org):
print lab
o = '{}/{}'.format(org, lab)
h = '{}/{}'.format(hmm, lab)
g = '{}/{}'.format(gpr, lab)
gm = '{}/{}'.format(gpr_with_multi_level, lab)
outfile = '{}/{}.eps'.format(outpath, Utility.get_basefilename(lab))
plot(o, h, g, gm, outfile)
# sys.exit()
pass
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 gen_fold_with_balance_stress_unstress(syl_object, fold):
base_path = Utility.get_base_path(syl_object)
print base_path
base_name = Utility.get_basefilename(syl_object)
print base_name
outpath = '{}/{}_fold'.format(base_path, base_name)
Utility.make_directory(outpath)
syl_manage_object = Utility.load_obj(syl_object)
stress_list = []
unstress_list = []
print len(syl_manage_object.syllables_list)
for syl in syl_manage_object.syllables_list:
# print syl.stress_manual
if syl.stress_manual == '1':
stress_list.append(syl)
elif syl.stress_manual == '0':
unstress_list.append(syl)
print len(stress_list), len(unstress_list)
out_list = []
for i in range(fold):
out_list.append([])
print out_list
i = 0
for syl in stress_list:
out_list[i].append(syl)
i += 1
if i == fold:
i = 0
print 'Stress length: '
for o in out_list:
print len(o)
i = 0
for syl in unstress_list:
out_list[i].append(syl)
i += 1
if i == fold:
i = 0
print 'Unstress length: '
for o in out_list:
print len(o)
for i in range(fold):
syl_o = SyllableDatabaseManagement(syllable_list=out_list[i])
Utility.save_obj(
syl_o, '{}/{}_{}-fold_{}.pickle'.format(outpath, base_name, fold,
i))
pass
