def test_uncompress_batch(self):
compressed = utils.compress_batch(self.inp, self.inp_mask)
lens = utils.seg_len_info(self.inp_mask)
answer = np.array([[[0, 1], [0, 1], [4, 5], [6, 7]],
[[8, 9], [8, 9], [8, 9], [14, 15]]])
self.assertTrue(
np.allclose(utils.uncompress_batch(compressed, lens), answer))
def testCompressBatch(self):
compressed = utils.compress_batch(self.inp, self.inp_mask)
# padded = utils.pad_batch(compressed)
answer = [
np.array([[0, 1], [4, 5], [6, 7]]),
np.array([[8, 9], [14, 15], [0, 0]])
]
self.assertTrue(
all([np.allclose(x, y) for x, y in zip(compressed, answer)]))
def eval_net_compress(predict_fn,
data_stream,
hmrnn,
batch_size,
use_ivectors=False):
data_iterator = data_stream.get_epoch_iterator()
total_ce_sum = 0.
total_ce_frame_count = 0
total_accuracy_sum = 0
total_frame_count = 0
for b_idx, data in enumerate(data_iterator, start=1):
input_data, input_mask, ivector_data, ivector_mask, target_data, target_mask = data
n_batch, _, _ = input_data.shape
if n_batch != batch_size:
continue
hmrnn.reset()
z_1_3d = hmrnn.compute_z_1_3d(input_data)
compressed_batch = [compress_batch(src, z_1_3d) for src in data]
len_info = seg_len_info(z_1_3d)
if use_ivectors:
predict_output = predict_fn(*compressed_batch)
else:
predict_output = predict_fn(compressed_batch[0],
compressed_batch[1],
compressed_batch[4],
compressed_batch[5])
ce_frame_sum, pred_idx = predict_output
pred_idx = uncompress_batch(pred_idx, len_info)
match_data = (target_data == pred_idx) * target_mask
total_ce_sum += ce_frame_sum
total_ce_frame_count += compressed_batch[-1].sum()
total_accuracy_sum += match_data.sum()
total_frame_count += target_mask.sum()
avg_ce = total_ce_sum / total_ce_frame_count
avg_fer = 1.0 - (total_accuracy_sum / total_frame_count)
return avg_ce, avg_fer
tparams = init_tparams_with_restored_value(tparams, args.model)
print('Loading data streams from {}'.format(args.data_path))
sync_data(args)
ds = create_ivector_datastream(args.data_path, args.dataset,
args.batch_size)
epoch_sw = StopWatch()
status_sw = StopWatch()
status_sw.reset()
z_1_3d_list = []
for b_idx, batch in enumerate(ds.get_epoch_iterator(), start=1):
reset_state(states)
input_data, input_mask, ivector_data, ivector_mask, target_data, target_mask = batch
n_batch, n_seq, n_feat = input_data.shape
if n_batch < args.batch_size:
continue
input_data_trans = numpy.transpose(input_data, (1, 0, 2))
_, _, _, z_1_3d, _ = f_debug(input_data_trans)
z_1_3d_trans = numpy.transpose(z_1_3d, (1, 0))
compressed_input_data = compress_batch(input_data, z_1_3d_trans)
compressed_input_mask = compress_batch(input_mask, z_1_3d_trans)
compressed_target_data = compress_batch(target_data, z_1_3d_trans)
compressed_target_mask = compress_batch(target_mask, z_1_3d_trans)
for batch_idx, (feat_batch, uttid_batch) in enumerate(
zip(test_ds.get_epoch_iterator(),
uttid_stream.get_epoch_iterator())):
input_data, input_mask, ivector_data, ivector_mask = feat_batch
n_batch, n_seq, n_feat = input_data.shape
if n_batch != args.batch_size:
continue
uttid_batch, = uttid_batch
feat_lens = input_mask.sum(axis=1)
hmrnn.reset()
z_1_3d = hmrnn.compute_z_1_3d(input_data)
compressed_batch = [compress_batch(src, z_1_3d) for src in feat_batch]
len_info = seg_len_info(z_1_3d)
comp_input_mask = compressed_batch[1]
comp_feat_lens = comp_input_mask.sum(axis=1)
orig_len += sum(feat_lens)
compressed_len += sum(comp_feat_lens)
if args.use_ivector_input:
net_output, = ff_fn(*compressed_batch[:3])
else:
net_output, = ff_fn(*compressed_batch[:2])
net_output = uncompress_batch(net_output, len_info)
print('Epoch {} starts'.format(e_idx))
print('--')
total_ce_sum = 0.0
total_frame_count = 0
status_sw = StopWatch()
for b_idx, data in enumerate(train_ds.get_epoch_iterator(), start=1):
input_data, input_mask, ivector_data, ivector_mask, target_data, target_mask = data
n_batch, _, _ = input_data.shape
if n_batch != args.batch_size:
continue
hmrnn.reset()
z_1_3d = hmrnn.compute_z_1_3d(input_data)
compressed_batch = [compress_batch(src, z_1_3d) for src in data]
len_info = seg_len_info(z_1_3d)
if args.use_ivector_input:
train_output = training_fn(*compressed_batch)
else:
train_output = training_fn(compressed_batch[0],
compressed_batch[1],
compressed_batch[4],
compressed_batch[5])
ce_frame_sum, network_grads_norm = train_output
total_ce_sum += ce_frame_sum
total_frame_count += compressed_batch[-1].sum()
if b_idx % args.log_freq == 0: