def main():
dataset_train = ASR_align_DataSet(file=[args.dirs.train.data],
args=args,
_shuffle=False,
transform=True)
dataset_dev = ASR_align_DataSet(file=[args.dirs.dev.data],
args=args,
_shuffle=False,
transform=True)
tfdata_train = TFData(dataset=dataset_train,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.train.tfdata,
args=args)
tfdata_dev = TFData(dataset=dataset_dev,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.dev.tfdata,
args=args)
tfdata_train.save('0')
tfdata_dev.save('0')
# tfdata_train.get_bucket_size(100, True)
# split_save()
# for sample in tfdata_dev.read():
# # for sample in dataset_train:
# # print(sample['feature'].shape)
# # print(sample['label'])
# print(sample[0].shape)
# import pdb; pdb.set_trace()
dataset_train.get_dataset_ngram(n=args.data.ngram,
k=10000,
savefile=args.dirs.ngram)
def Decode(save_file):
dataset = ASR_align_DataSet(trans_file=args.dirs.train.trans,
align_file=None,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
G = PhoneClassifier(args)
G.summary()
optimizer_G = tf.keras.optimizers.Adam(1e-4)
ckpt = tf.train.Checkpoint(G=G, optimizer_G=optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(ckpt_manager.latest_checkpoint))
fer, cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, G)
decode(dataset, G, args.idx2token, 'output/' + save_file)
def main():
# dataset_train = ASR_align_ArkDataSet(
# scp_file=args.dirs.train.scp,
# trans_file=args.dirs.train.trans,
# align_file=None,
# feat_len_file=None,
# args=args,
# _shuffle=True,
# transform=False)
# dataset_dev = ASR_align_ArkDataSet(
# scp_file=args.dirs.dev.scp,
# trans_file=args.dirs.dev.trans,
# align_file=None,
# feat_len_file=None,
# args=args,
# _shuffle=False,
# transform=False)
# dataset_untrain = ASR_align_ArkDataSet(
# scp_file=args.dirs.untrain.scp,
# trans_file=None,
# align_file=None,
# feat_len_file=None,
# args=args,
# _shuffle=True,
# transform=False)
dataset_train = ASR_align_DataSet(trans_file=args.dirs.train.trans,
align_file=args.dirs.train.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
uttid2wav=args.dirs.dev.wav_scp,
align_file=args.dirs.dev.align,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args)
# feature_untrain = TFData(dataset=dataset_untrain,
# dir_save=args.dirs.untrain.tfdata,
# args=args)
# feature_train_supervise = TFData(dataset=dataset_train_supervise,
# dir_save=args.dirs.train_supervise.tfdata,
# args=args)
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args)
feature_train.split_save(capacity=100000)
feature_dev.split_save(capacity=100000)
def Decode(save_file):
dataset = ASR_align_DataSet(trans_file=None,
align_file=None,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train = TFData(dataset=dataset,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
feature_train = feature_train.cache().repeat().shuffle(500).padded_batch(
args.batch_size, ((), [None, args.dim_input])).prefetch(buffer_size=5)
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
# model = GRNN(args)
model = GRNN_Cell(args)
model.summary()
optimizer = tf.keras.optimizers.Adam(1e-4)
ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(ckpt_manager.latest_checkpoint))
# plot_align(model, dataset_dev, 0)
for batch in feature_train:
uttids, x = batch
batch_size = len(x)
h1 = h2 = tf.zeros([batch_size, args.model.num_hidden_rnn])
for x_t in tf.split(x, x.shape[1], axis=1):
x_fc, x_cell, h1, h2 = model([x_t, h1, h2], training=False)
z, r = get_GRU_activation(model.layers[3],
cell_inputs=x_fc[:, 0, :],
hiddens=h1)
def split_save(capacity=10000):
fw = open(args.dirs.train.tfdata / '0.csv', 'w')
with open(args.dirs.train.data) as f:
for num, line in enumerate(f):
if num % capacity == 0:
idx_file = num // capacity
print('package file ', idx_file)
try:
fw.close()
fw = open(
args.dirs.train.tfdata / (str(idx_file) + '.csv'), 'w')
except:
pass
fw.write(line)
print('processed {} utts.'.format(num + 1))
fw.close()
for i in Path(args.dirs.train.tfdata).glob('*.csv'):
print('converting {}.csv to record'.format(i.name))
dataset_train = ASR_align_DataSet(file=[i],
args=args,
_shuffle=False,
transform=True)
tfdata_train = TFData(dataset=dataset_train,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.train.tfdata,
args=args)
tfdata_train.save(i.name.split('.')[0])
def decode(model):
dataset = ASR_align_DataSet(file=[args.dirs.dev.data],
args=args,
_shuffle=False,
transform=True)
sample = dataset[0]
x = np.array([sample['feature']], dtype=np.float32)
logits = model(x, training=False)
predits = model.get_predicts(logits)
print('predict: \n', predits.numpy()[0])
print('label: \n', sample['label'])
print('align: ', sample['align'])
def Decode(save_file):
# dataset = ASR_align_DataSet(
# trans_file=args.dirs.train.trans,
# align_file=None,
# uttid2wav=args.dirs.train.wav_scp,
# feat_len_file=args.dirs.train.feat_len,
# args=args,
# _shuffle=False,
# transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
model = PhoneClassifier(args)
model.summary()
optimizer_G = tf.keras.optimizers.Adam(1e-4)
ckpt = tf.train.Checkpoint(model=model, optimizer_G=optimizer_G)
_ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(_ckpt_manager.latest_checkpoint))
# fer, cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, model, beam_size=0, with_stamp=True)
# fer, cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, model, beam_size=0, with_stamp=False)
decode_outs = np.zeros((300), dtype=np.int32)
wfst = WFST_Decoder(decode_outs=decode_outs,
fcdll="../WFST/libctc_wfst_lib.so",
fcfg="wfst/timit.json")
fer, cer = evaluate(feature_dev,
dataset_dev,
args.data.dev_size,
model,
wfst=wfst)
print('FER:{:.3f}\t WFST PER:{:.3f}'.format(fer, cer))
fer, cer = evaluate(feature_dev,
dataset_dev,
args.data.dev_size,
model,
beam_size=0,
with_stamp=False)
print('FER:{:.3f}\t PER:{:.3f}'.format(fer, cer))
def Train():
with tf.device("/cpu:0"):
# dataset_train = ASR_align_ArkDataSet(
# scp_file=args.dirs.train.scp,
# trans_file=args.dirs.train.trans,
# align_file=None,
# feat_len_file=None,
# args=args,
# _shuffle=False,
# transform=False)
# dataset_dev = ASR_align_ArkDataSet(
# scp_file=args.dirs.dev.scp,
# trans_file=args.dirs.dev.trans,
# align_file=None,
# feat_len_file=None,
# args=args,
# _shuffle=False,
# transform=False)
dataset_train = ASR_align_DataSet(
trans_file=args.dirs.train.trans,
align_file=args.dirs.train.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
uttid2wav=args.dirs.dev.wav_scp,
align_file=args.dirs.dev.align,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
# wav data
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read(transform=True)
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read(transform=True)
bucket = tf.data.experimental.bucket_by_sequence_length(
element_length_func=lambda uttid, x: tf.shape(x)[0],
bucket_boundaries=args.list_bucket_boundaries,
bucket_batch_sizes=args.list_batch_size,
padded_shapes=((), [None, args.dim_input]))
iter_feature_train = iter(
feature_train.repeat().shuffle(10).apply(bucket).prefetch(
buffer_size=5))
# iter_feature_train = iter(feature_train.repeat().shuffle(500).padded_batch(args.batch_size,
# ((), [None, args.dim_input])).prefetch(buffer_size=5))
# feature_dev = feature_dev.apply(bucket).prefetch(buffer_size=5)
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
# create model paremeters
model = Model(args)
model.summary()
# lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
# args.opti.lr,
# decay_steps=args.opti.decay_steps,
# decay_rate=0.5,
# staircase=True)
optimizer = tf.keras.optimizers.Adam(args.opti.lr, beta_1=0.5, beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dir_checkpoint,
max_to_keep=20)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(
_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
while step < 99999999:
start = time()
uttids, x = next(iter_feature_train)
trans = dataset_train.get_attrs('trans', uttids.numpy())
loss_supervise = train_CTC_supervised(x, trans, model, optimizer)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
print('loss: {:.3f}\tbatch: {}\tused: {:.3f}\t {:.3f}% step: {}'.
format(loss_supervise, x.shape,
time() - start, progress * 100, step))
with writer.as_default():
tf.summary.scalar("costs/loss_supervise",
loss_supervise,
step=step)
if step % args.dev_step == 0:
cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, model)
with writer.as_default():
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
monitor(dataset_dev[0], model)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format(
(datetime.now() - start_time).total_seconds() / 3600))
def train():
with tf.device("/cpu:0"):
dataset_train = ASR_align_DataSet(
trans_file=args.dirs.train.trans,
align_file=args.dirs.train.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=True,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_train_supervise = ASR_align_DataSet(
trans_file=args.dirs.train_supervise.trans,
align_file=args.dirs.train_supervise.align,
uttid2wav=args.dirs.train_supervise.wav_scp,
feat_len_file=args.dirs.train_supervise.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train_supervise = TFData(
dataset=dataset_train_supervise,
dir_save=args.dirs.train_supervise.tfdata,
args=args).read()
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
supervise_uttids, supervise_x = next(iter(feature_train_supervise.take(args.num_supervised).\
padded_batch(args.num_supervised, ((), [None, args.dim_input]))))
supervise_aligns = dataset_train_supervise.get_attrs(
'align', supervise_uttids.numpy())
supervise_bounds = dataset_train_supervise.get_attrs(
'bounds', supervise_uttids.numpy())
iter_feature_train = iter(
feature_train.cache().repeat().shuffle(500).padded_batch(
args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5))
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
dataset_text = TextDataSet(list_files=[args.dirs.lm.data],
args=args,
_shuffle=True)
tfdata_train = tf.data.Dataset.from_generator(dataset_text, (tf.int32),
(tf.TensorShape([None])))
iter_text = iter(tfdata_train.cache().repeat().shuffle(1000).map(
lambda x: x[:args.model.D.max_label_len]).padded_batch(
args.batch_size,
([args.model.D.max_label_len])).prefetch(buffer_size=5))
# create model paremeters
G = PhoneClassifier(args)
D = PhoneDiscriminator3(args)
G.summary()
D.summary()
optimizer_G = tf.keras.optimizers.Adam(args.opti.G.lr,
beta_1=0.5,
beta_2=0.9)
optimizer_D = tf.keras.optimizers.Adam(args.opti.D.lr,
beta_1=0.5,
beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(G=G, optimizer_G=optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dir_checkpoint,
max_to_keep=20)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(
_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
while step < 99999999:
start = time()
for _ in range(args.opti.D_G_rate):
uttids, x = next(iter_feature_train)
stamps = dataset_train.get_attrs('stamps', uttids.numpy())
text = next(iter_text)
P_Real = tf.one_hot(text, args.dim_output)
cost_D, gp = train_D(x, stamps, P_Real, text > 0, G, D,
optimizer_D, args.lambda_gp,
args.model.D.max_label_len)
# cost_D, gp = train_D(x, P_Real, text>0, G, D, optimizer_D,
# args.lambda_gp, args.model.G.len_seq, args.model.D.max_label_len)
uttids, x = next(iter_feature_train)
stamps = dataset_train.get_attrs('stamps', uttids.numpy())
cost_G, fs = train_G(x, stamps, G, D, optimizer_G, args.lambda_fs)
# cost_G, fs = train_G(x, G, D, optimizer_G,
# args.lambda_fs, args.model.G.len_seq, args.model.D.max_label_len)
loss_supervise = train_G_supervised(supervise_x, supervise_aligns, G,
optimizer_G, args.dim_output,
args.lambda_supervision)
# loss_supervise, bounds_loss = train_G_bounds_supervised(
# supervise_x, supervise_bounds, supervise_aligns, G, optimizer_G, args.dim_output)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
print(
'cost_G: {:.3f}|{:.3f}\tcost_D: {:.3f}|{:.3f}\tloss_supervise: {:.3f}\tbatch: {}|{}\tused: {:.3f}\t {:.3f}% iter: {}'
.format(cost_G, fs, cost_D, gp, loss_supervise, x.shape,
text.shape,
time() - start, progress * 100.0, step))
with writer.as_default():
tf.summary.scalar("costs/cost_G", cost_G, step=step)
tf.summary.scalar("costs/cost_D", cost_D, step=step)
tf.summary.scalar("costs/gp", gp, step=step)
tf.summary.scalar("costs/fs", fs, step=step)
tf.summary.scalar("costs/loss_supervise",
loss_supervise,
step=step)
if step % args.dev_step == 0:
# fer, cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, G)
fer, cer_0 = evaluate(feature_dev,
dataset_dev,
args.data.dev_size,
G,
beam_size=0,
with_stamp=True)
fer, cer = evaluate(feature_dev,
dataset_dev,
args.data.dev_size,
G,
beam_size=0,
with_stamp=False)
with writer.as_default():
tf.summary.scalar("performance/fer", fer, step=step)
tf.summary.scalar("performance/cer_0", cer_0, step=step)
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
monitor(dataset_dev[0], G)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format(
(datetime.now() - start_time).total_seconds() / 3600))
def train():
with tf.device("/cpu:0"):
dataset_train = ASR_align_DataSet(
trans_file=args.dirs.train.trans,
align_file=args.dirs.train.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=True,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_train_supervise = ASR_align_DataSet(
trans_file=args.dirs.train_supervise.trans,
align_file=args.dirs.train_supervise.align,
uttid2wav=args.dirs.train_supervise.wav_scp,
feat_len_file=args.dirs.train_supervise.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train_supervise = TFData(
dataset=dataset_train_supervise,
dir_save=args.dirs.train_supervise.tfdata,
args=args).read()
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
iter_feature_supervise = iter(
feature_train_supervise.cache().repeat().padded_batch(
args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5))
iter_feature_train = iter(
feature_train.cache().repeat().shuffle(500).padded_batch(
args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5))
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
dataset_text = TextDataSet(list_files=[args.dirs.lm.data],
args=args,
_shuffle=True)
tfdata_train = tf.data.Dataset.from_generator(dataset_text, (tf.int32),
(tf.TensorShape([None])))
iter_text = iter(tfdata_train.cache().repeat().shuffle(1000).map(
lambda x: x[:args.model.D.max_label_len]).padded_batch(
args.batch_size,
([args.model.D.max_label_len])).prefetch(buffer_size=5))
# create model paremeters
G = PhoneClassifier(args)
D = PhoneDiscriminator3(args)
G.summary()
D.summary()
optimizer_G = tf.keras.optimizers.Adam(args.opti.G.lr,
beta_1=0.1,
beta_2=0.5)
optimizer_D = tf.keras.optimizers.Adam(args.opti.D.lr,
beta_1=0.5,
beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(G=G, optimizer_G=optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dir_checkpoint,
max_to_keep=20)
step = 0
best = 999
phrase_ctc = False
step_retention = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
ckpt.restore(args.dirs.checkpoint)
print('checkpoint {} restored!!'.format(args.dirs.checkpoint))
step = int(args.dirs.checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
while step < 99999999:
start = time()
if phrase_ctc:
# CTC phrase
uttids, x = next(iter_feature_supervise)
trans = dataset_train_supervise.get_attrs('trans', uttids.numpy())
loss_G_ctc = train_CTC_G(x, trans, G, D, optimizer_G)
else:
# GAN phrase
## D sub phrase
for _ in range(args.opti.D_G_rate):
uttids, x = next(iter_feature_train)
text = next(iter_text)
P_Real = tf.one_hot(text, args.dim_output)
loss_D, loss_D_fake, loss_D_real, gp = train_D(
x, P_Real, text > 0, G, D, optimizer_D, args.lambda_gp,
args.model.D.max_label_len)
## G sub phrase
uttids, x = next(iter_feature_train)
_uttids, _x = next(iter_feature_supervise)
_trans = dataset_train_supervise.get_attrs('trans',
_uttids.numpy())
train_GAN_G(x, _x, _trans, G, D, optimizer_G,
args.model.D.max_label_len, args.lambda_supervise)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
if phrase_ctc:
print(
'loss_G_ctc: {:.3f}\tbatch: {}\tused: {:.3f}\t {:.3f}% iter: {}'
.format(loss_G_ctc, x.shape,
time() - start, progress * 100.0, step))
with writer.as_default():
tf.summary.scalar("costs/loss_G_supervise",
loss_G_ctc,
step=step)
else:
print(
'loss_GAN: {:.3f}|{:.3f}|{:.3f}\tbatch: {}|{}\tused: {:.3f}\t {:.3f}% iter: {}'
.format(loss_D_fake, loss_D_real, gp, x.shape, text.shape,
time() - start, progress * 100.0, step))
if step % args.dev_step == 0:
cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, G)
if cer < best:
best = cer
G_values = save_varibales(G)
elif step_retention < 2000:
pass
else:
phrase_ctc = not phrase_ctc
step_retention = 0
load_values(G, G_values)
print('====== switching phrase ======')
with writer.as_default():
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
monitor(dataset_dev[0], G)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
step_retention += 1
print('training duration: {:.2f}h'.format(
(datetime.now() - start_time).total_seconds() / 3600))
def Train():
dataset_train = ASR_align_DataSet(trans_file=args.dirs.train.trans,
align_file=args.dirs.train.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=True,
transform=True)
dataset_dev = ASR_align_DataSet(trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
with tf.device("/cpu:0"):
# wav data
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
if args.num_supervised:
dataset_train_supervise = ASR_align_DataSet(
trans_file=args.dirs.train_supervise.trans,
align_file=args.dirs.train_supervise.align,
uttid2wav=args.dirs.train_supervise.wav_scp,
feat_len_file=args.dirs.train_supervise.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train_supervise = TFData(
dataset=dataset_train_supervise,
dir_save=args.dirs.train_supervise.tfdata,
args=args).read()
supervise_uttids, supervise_x = next(iter(feature_train_supervise.take(args.num_supervised).\
padded_batch(args.num_supervised, ((), [None, args.dim_input]))))
supervise_aligns = dataset_train_supervise.get_attrs(
'align', supervise_uttids.numpy())
# supervise_bounds = dataset_train_supervise.get_attrs('bounds', supervise_uttids.numpy())
iter_feature_train = iter(
feature_train.repeat().shuffle(500).padded_batch(
args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5))
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
# create model paremeters
model = PhoneClassifier(args)
model.summary()
optimizer_G = tf.keras.optimizers.Adam(args.opti.lr,
beta_1=0.5,
beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(model=model, optimizer_G=optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dir_checkpoint,
max_to_keep=20)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(
_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
while step < 99999999:
start = time()
if args.num_supervised:
x = supervise_x
loss_supervise = train_G_supervised(supervise_x, supervise_aligns,
model, optimizer_G,
args.dim_output)
# loss_supervise, bounds_loss = train_G_bounds_supervised(
# x, supervise_bounds, supervise_aligns, model, optimizer_G, args.dim_output)
else:
uttids, x = next(iter_feature_train)
aligns = dataset_train.get_attrs('align', uttids.numpy())
# trans = dataset_train.get_attrs('trans', uttids.numpy())
loss_supervise = train_G_supervised(x, aligns, model, optimizer_G,
args.dim_output)
# loss_supervise = train_G_TBTT_supervised(x, aligns, model, optimizer_G, args.dim_output)
# bounds = dataset_train.get_attrs('bounds', uttids.numpy())
# loss_supervise, bounds_loss = train_G_bounds_supervised(x, bounds, aligns, model, optimizer_G, args.dim_output)
# loss_supervise = train_G_CTC_supervised(x, trans, model, optimizer_G)
if step % 10 == 0:
print('loss_supervise: {:.3f}\tbatch: {}\tused: {:.3f}\tstep: {}'.
format(loss_supervise, x.shape,
time() - start, step))
# print('loss_supervise: {:.3f}\tloss_bounds: {:.3f}\tbatch: {}\tused: {:.3f}\tstep: {}'.format(
# loss_supervise, bounds_loss, x.shape, time()-start, step))
with writer.as_default():
tf.summary.scalar("costs/loss_supervise",
loss_supervise,
step=step)
if step % args.dev_step == 0:
fer, cer_0 = evaluate(feature_dev,
dataset_dev,
args.data.dev_size,
model,
beam_size=0,
with_stamp=True)
fer, cer = evaluate(feature_dev,
dataset_dev,
args.data.dev_size,
model,
beam_size=0,
with_stamp=False)
with writer.as_default():
tf.summary.scalar("performance/fer", fer, step=step)
tf.summary.scalar("performance/cer_0", cer_0, step=step)
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
monitor(dataset_dev[0], model)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format(
(datetime.now() - start_time).total_seconds() / 3600))
def train():
with tf.device("/cpu:0"):
dataset_train = ASR_align_DataSet(
trans_file=args.dirs.train.trans,
align_file=None,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=True,
transform=True)
dataset_dev = ASR_align_DataSet(
trans_file=args.dirs.dev.trans,
align_file=None,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
iter_feature_train = iter(feature_train.cache().repeat().shuffle(500).padded_batch(args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5))
feature_dev = feature_dev.padded_batch(args.batch_size, ((), [None, args.dim_input]))
# create model paremeters
assigner = attentionAssign(args)
G = PhoneClassifier(args, dim_input=args.model.attention.num_hidden)
assigner.summary()
G.summary()
optimizer_G = tf.keras.optimizers.Adam(args.opti.G.lr, beta_1=0.9, beta_2=0.95)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(G=G, optimizer_G=optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt, args.dir_checkpoint, max_to_keep=20)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt, args.dirs.checkpoint, max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
while step < 99999999:
start = time()
uttids, x = next(iter_feature_train)
y = dataset_train.get_attrs('trans', uttids.numpy())
ce_loss_supervise, quantity_loss_supervise, _ctc_loss = train_G_supervised(
x, y, assigner, G, optimizer_G, args.dim_output, args.lambda_supervision)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
print('loss_supervise: {:.3f}|{:.3f}|{:.3f}\tbatch: {}|{}\tused: {:.3f}\t {:.3f}% iter: {}'.format(
ce_loss_supervise, quantity_loss_supervise, _ctc_loss, x.shape, None, time()-start, progress*100.0, step))
# with writer.as_default():
# tf.summary.scalar("costs/cost_G", cost_G, step=step)
# tf.summary.scalar("costs/cost_D", cost_D, step=step)
# tf.summary.scalar("costs/gp", gp, step=step)
# tf.summary.scalar("costs/loss_supervise", loss_supervise, step=step)
if step % args.dev_step == 0:
cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, assigner, G)
with writer.as_default():
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
monitor(dataset_dev[0], assigner, G)
step += 1
print('training duration: {:.2f}h'.format((datetime.now()-start_time).total_seconds()/3600))
def train():
dataset_dev = ASR_align_DataSet(
file=[args.dirs.dev.data],
args=args,
_shuffle=False,
transform=True)
with tf.device("/cpu:0"):
# wav data
tfdata_train = TFData(dataset=None,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.train.tfdata,
args=args).read(_shuffle=False)
tfdata_dev = TFData(dataset=None,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.dev.tfdata,
args=args).read(_shuffle=False)
x_0, y_0, _ = next(iter(tfdata_train.take(args.num_supervised).map(lambda x, y, z: (x, y, z[:args.max_seq_len])).\
padded_batch(args.num_supervised, ([None, args.dim_input], [None], [None]))))
iter_train = iter(tfdata_train.cache().repeat().shuffle(3000).map(lambda x, y, z: (x, y, z[:args.max_seq_len])).\
padded_batch(args.batch_size, ([None, args.dim_input], [None], [args.max_seq_len])).prefetch(buffer_size=3))
tfdata_dev = tfdata_dev.padded_batch(args.batch_size, ([None, args.dim_input], [None], [None]))
# text data
dataset_text = TextDataSet(
list_files=[args.dirs.lm.data],
args=args,
_shuffle=True)
tfdata_train_text = tf.data.Dataset.from_generator(
dataset_text, (tf.int32), (tf.TensorShape([None])))
iter_text = iter(tfdata_train_text.cache().repeat().shuffle(100).map(lambda x: x[:args.max_seq_len]).padded_batch(args.batch_size,
([args.max_seq_len])).prefetch(buffer_size=5))
# create model paremeters
G = PhoneClassifier(args)
D = PhoneDiscriminator2(args)
G.summary()
D.summary()
optimizer_G = tf.keras.optimizers.Adam(args.opti.G.lr, beta_1=0.5, beta_2=0.9)
optimizer_D = tf.keras.optimizers.Adam(args.opti.D.lr, beta_1=0.5, beta_2=0.9)
optimizer = tf.keras.optimizers.Adam(args.opti.G.lr, beta_1=0.5, beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(G=G, optimizer_G = optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt, args.dir_checkpoint, max_to_keep=5)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt, args.dirs.checkpoint, max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
while step < 99999999:
start = time()
for _ in range(args.opti.D_G_rate):
x, _, aligns = next(iter_train)
text = next(iter_text)
P_Real = tf.one_hot(text, args.dim_output)
cost_D, gp = train_D(x, aligns, P_Real, text>0, G, D, optimizer_D, args.lambda_gp)
x, _, aligns = next(iter_train)
cost_G, fs = train_G(x, aligns, G, D, optimizer_G, args.lambda_fs)
loss_supervise = train_G_supervised(x_0, y_0, G, optimizer_G, args.dim_output)
num_processed += len(x)
if step % 10 == 0:
print('cost_G: {:.3f}|{:.3f}\tcost_D: {:.3f}|{:.3f}\tloss_supervise: {:.3f}\tbatch: {}|{}\tused: {:.3f}\t {:.3f}% iter: {}'.format(
cost_G, fs, cost_D, gp, loss_supervise, x.shape, text.shape, time()-start, progress*100.0, step))
with writer.as_default():
tf.summary.scalar("costs/cost_G", cost_G, step=step)
tf.summary.scalar("costs/cost_D", cost_D, step=step)
tf.summary.scalar("costs/gp", gp, step=step)
tf.summary.scalar("costs/fs", fs, step=step)
tf.summary.scalar("costs/loss_supervise", loss_supervise, step=step)
if step % args.dev_step == 0:
fer, cer = evaluation(tfdata_dev, args.data.dev_size, G)
with writer.as_default():
tf.summary.scalar("performance/fer", fer, step=step)
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
decode(dataset_dev[0], G)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format((datetime.now()-start_time).total_seconds()/3600))
def train():
# load external LM
with tf.device("/cpu:0"):
dataset_train = ASR_align_DataSet(
trans_file=args.dirs.train.trans,
align_file=args.dirs.train.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=True,
transform=True)
dataset_dev = ASR_align_DataSet(
trans_file=args.dirs.dev.trans,
align_file=args.dirs.dev.align,
uttid2wav=args.dirs.dev.wav_scp,
feat_len_file=args.dirs.dev.feat_len,
args=args,
_shuffle=False,
transform=True)
dataset_train_supervise = ASR_align_DataSet(
trans_file=args.dirs.train_supervise.trans,
align_file=args.dirs.train_supervise.align,
uttid2wav=args.dirs.train.wav_scp,
feat_len_file=args.dirs.train.feat_len,
args=args,
_shuffle=False,
transform=True)
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
supervise_uttids, supervise_x = next(iter(feature_train.take(args.num_supervised).\
padded_batch(args.num_supervised, ((), [None, args.dim_input]))))
supervise_aligns = dataset_train_supervise.get_attrs('align', supervise_uttids.numpy())
iter_feature_train = iter(feature_train.cache().repeat().shuffle(500).padded_batch(args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5))
feature_dev = feature_dev.padded_batch(args.batch_size, ((), [None, args.dim_input]))
# get dataset ngram
ngram_py, total_num = read_ngram(args.data.k, args.dirs.ngram, args.token2idx, type='list')
kernel, py = ngram2kernel(ngram_py, args)
# create model paremeters
G = PhoneClassifier(args)
compute_p_ngram = P_Ngram(kernel, args)
G.summary()
compute_p_ngram.summary()
# build optimizer
if args.opti.type == 'adam':
optimizer = tf.keras.optimizers.Adam(args.opti.lr, beta_1=0.5, beta_2=0.9)
elif args.opti.type == 'sgd':
optimizer = tf.keras.optimizers.SGD(lr=args.opti.lr, momentum=0.9, decay=0.98)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(G=G, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, args.dir_checkpoint, max_to_keep=5)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt, args.dirs.checkpoint, max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
while step < 99999999:
start = time()
uttids, x = next(iter_feature_train)
stamps = dataset_train.get_attrs('stamps', uttids.numpy())
loss_EODM, loss_fs = train_step(x, stamps, py, G, compute_p_ngram, optimizer, args.lambda_fs)
# loss_EODM = loss_fs = 0
loss_supervise = train_G_supervised(supervise_x, supervise_aligns, G, optimizer, args.dim_output, args.lambda_supervision)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
print('EODM loss: {:.2f}\tloss_fs: {:.3f} * {}\tloss_supervise: {:.3f} * {}\tbatch: {} time: {:.2f} s {:.3f}% step: {}'.format(
loss_EODM, loss_fs, args.lambda_fs, loss_supervise, args.lambda_supervision, x.shape, time()-start, progress*100.0, step))
with writer.as_default():
tf.summary.scalar("costs/loss_EODM", loss_EODM, step=step)
tf.summary.scalar("costs/loss_fs", loss_fs, step=step)
tf.summary.scalar("costs/loss_supervise", loss_supervise, step=step)
if step % args.dev_step == 0:
fer, cer = evaluate(feature_dev, dataset_dev, args.data.dev_size, G)
with writer.as_default():
tf.summary.scalar("performance/fer", fer, step=step)
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
monitor(dataset_dev[0], G)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format((datetime.now()-start_time).total_seconds()/3600))
def train():
dataset_dev = ASR_align_DataSet(file=[args.dirs.dev.data],
args=args,
_shuffle=False,
transform=True)
with tf.device("/cpu:0"):
# wav data
tfdata_train = TFData(dataset=None,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.train.tfdata,
args=args).read(_shuffle=False)
tfdata_dev = TFData(dataset=None,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.dev.tfdata,
args=args).read(_shuffle=False)
if args.num_supervised:
x_0, y_0, aligns_0 = next(iter(tfdata_train.take(args.num_supervised).\
padded_batch(args.num_supervised, ([None, args.dim_input], [None], [None]))))
iter_train = iter(
tfdata_train.cache().repeat().shuffle(500).padded_batch(
args.batch_size, ([None, args.dim_input
], [None], [None])).prefetch(buffer_size=5))
tfdata_dev = tfdata_dev.padded_batch(
args.batch_size, ([None, args.dim_input], [None], [None]))
# create model paremeters
model = PhoneClassifier(args)
model.summary()
optimizer_G = tf.keras.optimizers.Adam(args.opti.lr,
beta_1=0.5,
beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(model=model, optimizer_G=optimizer_G)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dir_checkpoint,
max_to_keep=5)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(
_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
while step < 99999999:
start = time()
if args.num_supervised:
x = x_0
loss_supervise = train_G_supervised(x_0, y_0, model, optimizer_G,
args.dim_output)
else:
x, y, aligns = next(iter_train)
loss_supervise = train_G_supervised(x, y, model, optimizer_G,
args.dim_output)
if step % 10 == 0:
print('loss_supervise: {:.3f}\tbatch: {}\tused: {:.3f}\tstep: {}'.
format(loss_supervise, x.shape,
time() - start, step))
with writer.as_default():
tf.summary.scalar("costs/loss_supervise",
loss_supervise,
step=step)
if step % args.dev_step == 0:
fer, cer = evaluation(tfdata_dev, args.data.dev_size, model)
with writer.as_default():
tf.summary.scalar("performance/fer", fer, step=step)
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
decode(dataset_dev[0], model)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format(
(datetime.now() - start_time).total_seconds() / 3600))
def train(Model):
# load external LM
with tf.device("/cpu:0"):
dataset_dev = ASR_align_DataSet(
file=[args.dirs.dev.data],
args=args,
_shuffle=False,
transform=True)
tfdata_train = TFData(dataset=None,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.train.tfdata,
args=args).read(_shuffle=False)
tfdata_dev = TFData(dataset=None,
dataAttr=['feature', 'label', 'align'],
dir_save=args.dirs.dev.tfdata,
args=args).read(_shuffle=False)
x_0, y_0, aligns_0 = next(iter(tfdata_train.take(args.num_supervised).\
padded_batch(args.num_supervised, ([None, args.dim_input], [None], [None]))))
iter_train = iter(tfdata_train.cache().repeat().shuffle(3000).\
padded_batch(args.batch_size, ([None, args.dim_input], [None], [None])).prefetch(buffer_size=3))
tfdata_dev = tfdata_dev.padded_batch(args.batch_size, ([None, args.dim_input], [None], [None]))
# get dataset ngram
ngram_py, total_num = read_ngram(args.data.k, args.dirs.ngram, args.token2idx, type='list')
kernel, py = ngram2kernel(ngram_py, args)
# create model paremeters
model = Model(args)
compute_p_ngram = P_Ngram(kernel, args)
model.summary()
compute_p_ngram.summary()
# build optimizer
if args.opti.type == 'adam':
optimizer = tf.keras.optimizers.Adam(args.opti.lr, beta_1=0.5, beta_2=0.9)
# optimizer = tf.keras.optimizers.Adam(args.opti.lr*0.1, beta_1=0.5, beta_2=0.9)
elif args.opti.type == 'sgd':
optimizer = tf.keras.optimizers.SGD(lr=args.opti.lr, momentum=0.9, decay=0.98)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(model=model, optimizer = optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, args.dir_checkpoint, max_to_keep=5)
step = 0
# if a checkpoint exists, restore the latest checkpoint.
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt, args.dirs.checkpoint, max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print ('checkpoint {} restored!!'.format(_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
# step = 1600
while step < 99999999:
start = time()
x, _, aligns = next(iter_train)
loss_EODM, loss_fs = train_step(x, aligns, py, model, compute_p_ngram, optimizer, args.lambda_fs)
loss_supervise = train_G_supervised(x_0, y_0, model, optimizer, args.dim_output)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
print('EODM loss: {:.2f}\tloss_fs: {:.3f} * {}\tloss_supervise: {:.3f} * {}\tbatch: {} time: {:.2f} s {:.3f}% step: {}'.format(
loss_EODM, loss_fs, args.lambda_fs, loss_supervise, args.lambda_supervision, x.shape, time()-start, progress*100.0, step))
with writer.as_default():
tf.summary.scalar("costs/loss_EODM", loss_EODM, step=step)
tf.summary.scalar("costs/loss_fs", loss_fs, step=step)
tf.summary.scalar("costs/loss_supervise", loss_supervise, step=step)
if step % args.dev_step == 0:
fer, cer = evaluation(tfdata_dev, args.data.dev_size, model)
with writer.as_default():
tf.summary.scalar("performance/fer", fer, step=step)
tf.summary.scalar("performance/cer", cer, step=step)
if step % args.decode_step == 0:
decode(dataset_dev[0], model)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format((datetime.now()-start_time).total_seconds()/3600))
def train():
with tf.device("/cpu:0"):
dataset_train = ASR_align_DataSet(uttid2wav=args.dirs.train.wav_scp,
trans_file=None,
align_file=None,
feat_len_file=None,
args=args,
_shuffle=True,
transform=True)
dataset_dev = ASR_align_DataSet(uttid2wav=args.dirs.dev.wav_scp,
trans_file=None,
align_file=None,
feat_len_file=None,
args=args,
_shuffle=False,
transform=True)
feature_train = TFData(dataset=dataset_train,
dir_save=args.dirs.train.tfdata,
args=args).read()
feature_dev = TFData(dataset=dataset_dev,
dir_save=args.dirs.dev.tfdata,
args=args).read()
feature_train = feature_train.cache().repeat().shuffle(
500).padded_batch(
args.batch_size,
((), [None, args.dim_input])).prefetch(buffer_size=5)
feature_dev = feature_dev.padded_batch(args.batch_size,
((), [None, args.dim_input]))
# create model paremeters
model = GRNN(args)
model.summary()
optimizer = tf.keras.optimizers.Adam(args.opti.lr, beta_1=0.5, beta_2=0.9)
writer = tf.summary.create_file_writer(str(args.dir_log))
ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dir_checkpoint,
max_to_keep=10)
step = 0
if args.dirs.checkpoint:
_ckpt_manager = tf.train.CheckpointManager(ckpt,
args.dirs.checkpoint,
max_to_keep=1)
ckpt.restore(_ckpt_manager.latest_checkpoint)
print('checkpoint {} restored!!'.format(
_ckpt_manager.latest_checkpoint))
step = int(_ckpt_manager.latest_checkpoint.split('-')[-1])
start_time = datetime.now()
num_processed = 0
progress = 0
for batch in feature_train:
start = time()
uttids, x = batch
loss = train_step(x, model, optimizer)
num_processed += len(x)
progress = num_processed / args.data.train_size
if step % 10 == 0:
print('loss: {:.3f}\tbatch: {}\tused: {:.3f}\t {:.3f}% step: {}'.
format(loss, x.shape,
time() - start, progress * 100.0, step))
with writer.as_default():
tf.summary.scalar("losses/loss", loss, step=step)
if step % args.dev_step == 0:
loss_dev = evaluate(feature_dev, model)
with writer.as_default():
tf.summary.scalar("losses/loss_dev", loss_dev, step=step)
if step % args.save_step == 0:
save_path = ckpt_manager.save(step)
print('save model {}'.format(save_path))
step += 1
print('training duration: {:.2f}h'.format(
(datetime.now() - start_time).total_seconds() / 3600))