def test_asr_qagent(restore_run_name,
train_subset,
name_env_to_eval,
demo=False,
train_with_asr=False,
num_episodes=100):
run_config = AsrQConfig()
# We want to do the data split the same way it was done during training of the CTCModel
assert train_subset in ('fl', 'non-fl', 'all')
if train_subset == 'fl':
data_splits = tidigits_db.get_split_fl_dataset()
elif train_subset == 'non-fl':
data_splits = tidigits_db.get_split_fl_dataset()
else:
data_splits = tidigits_db.get_split_all_dataset()
envs = make_split_envs(run_config, demo=False, data_splits=data_splits)
valid_env_states = list(range(envs['train'].nS))
with tf.Session() as sess:
ctc_model = CTCModel(sess, restore_run_name)
state_recognizer = StateRecognizer(valid_env_states,
ctc_model,
verbose=False)
asr_qagent = AsrQlearnAgent(envs, state_recognizer)
asr_qagent.train(train_with_asr)
env_to_eval = envs[name_env_to_eval]
env_to_eval.demo = demo
asr_qagent.evaulate(env_to_eval, num_trials=num_episodes, verbose=True)
def make_train_val_test_envs(cls, base_env_name, data_splits=None):
data_splits = data_splits or tidigits_db.get_split_fl_dataset()
train_env, val_env, test_env = [
AudioFrozenlake(gym.make(base_env_name), data_splits[usage], usage)
for usage in ('train', 'test', 'val')
]
return train_env, val_env, test_env
def make_train_val_test_envs(cls,
base_env_name,
data_splits=None,
num_mfcc=13,
use_synthesized=False,
demo=False):
logger.info('Making train/val/test envs. use_synthesized=' +
str(use_synthesized))
data_splits = data_splits or tidigits_db.get_split_fl_dataset()
train_env, val_env, test_env = [
MfccFrozenlake(gym.make(base_env_name),
data_splits[usage],
usage,
num_mfcc=num_mfcc,
use_synthesized=use_synthesized,
demo=demo) for usage in ('train', 'val', 'test')
]
return train_env, val_env, test_env
def get_split_fl_dataset(self):
tidigits_db.get_split_fl_dataset()
def transfer_train_ctcmodel(ctc_run_name, restore_run_name):
run_config = Config(ctc_run_name)
datasets = tidigits_db.get_split_fl_dataset()
for dset_type, sample_ids in datasets.items():
if dset_type == 'test':
continue
dset = []
for sample_id in tqdm.tqdm(sample_ids):
sample = DigitsSample(sample_id)
features = sample.to_mfccs(run_config.num_mfcc_features)
seqlen = features.shape[0]
label = tuple(tidigits_db.index_mapping[ch] for ch in sample.digits)
dset.append((features, label, seqlen))
datasets[dset_type] = zip(*dset)
# Make minibatches
train_feature_minibatches, train_labels_minibatches, train_seqlens_minibatches = \
make_batches(datasets['train'], batch_size=run_config.batch_size)
val_feature_minibatches, val_labels_minibatches, val_seqlens_minibatches = \
make_batches(datasets['val'], batch_size=run_config.batch_size)
def pad_all_batches(batch_feature_array):
for batch_num in range(len(batch_feature_array)):
batch_feature_array[batch_num] = pad_sequences(batch_feature_array[batch_num])[0]
return batch_feature_array
train_feature_minibatches = pad_all_batches(train_feature_minibatches)
val_feature_minibatches = pad_all_batches(val_feature_minibatches)
num_examples = np.sum([mb_idx.shape[0] for mb_idx in train_feature_minibatches])
num_batches_per_epoch = int(math.ceil(num_examples / run_config.batch_size))
with tf.Graph().as_default():
with tf.Session() as session:
saved_run_dir = os.path.join(project_config.saved_runs_dir, restore_run_name)
model_weights_dir = os.path.join(saved_run_dir, 'model.weights')
assert os.path.exists(model_weights_dir)
ctc_model = CTCModel()
# # NOTE: Could do it this way and skip the init after restoration,
# # but want to double check that GRU weights were actually
# # restored, so will do specific initialization of non-GRU vars after restoration
# # Initialize all vars in CTCModel graph - will re-init the GRU vars with AQN weights
# session.run(tf.global_variables_initializer())
# Restore all GRU vars from AQN to the CTCModel
aqn_var_names = [u'q/rnn/multi_rnn_cell/cell_0/gru_cell/gates/weights:0',
u'q/rnn/multi_rnn_cell/cell_0/gru_cell/gates/biases:0',
u'q/rnn/multi_rnn_cell/cell_0/gru_cell/candidate/weights:0',
u'q/rnn/multi_rnn_cell/cell_0/gru_cell/candidate/biases:0']
ctc_aqn_vars = [tf.get_default_graph().get_tensor_by_name(vn) for vn in aqn_var_names]
saver = tf.train.Saver(ctc_aqn_vars)
saver.restore(session, tf.train.latest_checkpoint(model_weights_dir))
pre_init_norms = [
np.linalg.norm(session.run(tf.get_default_graph().get_tensor_by_name(var_name)))
for var_name in aqn_var_names
]
# Specifically initialize variables that we did not restore
vars_to_init = [
var for var in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
if var.name not in aqn_var_names
]
logger.info([var.name for var in vars_to_init])
session.run(tf.variables_initializer(vars_to_init))
# Check to make sure the restored variables were not written over during
# initialization of other vars
post_init_norms = [
np.linalg.norm(session.run(tf.get_default_graph().get_tensor_by_name(var_name)))
for var_name in aqn_var_names
]
logger.info('Pre-init GRU norms' + repr(pre_init_norms))
logger.info('Post-init GRU norms' + repr(post_init_norms))
assert pre_init_norms == post_init_norms
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=run_config.max_saves_to_keep)
train_writer = tf.summary.FileWriter(run_config.run_results_path, session.graph)
step_ii = 0
for curr_epoch in range(run_config.num_epochs):
total_train_cost = total_train_wer = 0
for mb_idx in random.sample(range(num_batches_per_epoch), num_batches_per_epoch):
cur_batch_size = len(train_seqlens_minibatches[mb_idx])
batch_cost, batch_ler, summary = ctc_model.train_on_batch(
train_feature_minibatches[mb_idx],
train_labels_minibatches[mb_idx],
train_seqlens_minibatches[mb_idx],
train=True)
total_train_cost += batch_cost * cur_batch_size
total_train_wer += batch_ler * cur_batch_size
train_writer.add_summary(summary, step_ii)
step_ii += 1
train_cost = total_train_cost / num_examples
train_wer = total_train_wer / num_examples
val_batch_cost, val_batch_ler, _ = ctc_model.train_on_batch(
val_feature_minibatches[0],
val_labels_minibatches[0],
val_seqlens_minibatches[0],
train=False)
log_msg = "Epoch {}/{}, train_cost = {:.3f}, train_ed = {:.3f}, " \
"val_cost = {:.3f}, val_ed = {:.3f}"
logger.info(
log_msg.format(curr_epoch + 1, Config.num_epochs, train_cost,
train_wer, val_batch_cost, val_batch_ler))
if run_config.log_every is not None and \
(curr_epoch + 1) % run_config.log_every == 0:
batch_ii = 0
ctc_model.print_results(train_feature_minibatches[batch_ii],
train_labels_minibatches[batch_ii],
train_seqlens_minibatches[batch_ii])
if run_config.save_every is not None and \
run_config.model_outputs_path is not None and \
(curr_epoch + 1) % run_config.save_every == 0:
if not os.path.exists(run_config.model_outputs_path):
os.makedirs(run_config.model_outputs_path)
saver.save(session, run_config.model_outputs_path, global_step=curr_epoch + 1)
def train_ctcmodel(run_name):
run_config = Config(run_name)
if run_config.tidigits_subset == 'fl':
datasets = tidigits_db.get_split_fl_dataset()
elif run_config.tidigits_subset == 'non-fl':
datasets = tidigits_db.get_split_non_fl_dataset()
else:
datasets = tidigits_db.get_split_all_dataset()
for dset_type, sample_ids in datasets.items():
if dset_type == 'test':
continue
dset = []
for sample_id in tqdm.tqdm(sample_ids):
sample = DigitsSample(sample_id)
features = sample.to_mfccs(run_config.num_mfcc_features)
seqlen = features.shape[0]
label = tuple(tidigits_db.index_mapping[ch] for ch in sample.digits)
dset.append((features, label, seqlen))
datasets[dset_type] = zip(*dset)
# Make minibatches
train_feature_minibatches, train_labels_minibatches, train_seqlens_minibatches = \
make_batches(datasets['train'], batch_size=run_config.batch_size)
val_feature_minibatches, val_labels_minibatches, val_seqlens_minibatches = \
make_batches(datasets['val'], batch_size=run_config.batch_size)
def pad_all_batches(batch_feature_array):
for batch_num in range(len(batch_feature_array)):
batch_feature_array[batch_num] = pad_sequences(batch_feature_array[batch_num])[0]
return batch_feature_array
train_feature_minibatches = pad_all_batches(train_feature_minibatches)
val_feature_minibatches = pad_all_batches(val_feature_minibatches)
num_examples = np.sum([mb_idx.shape[0] for mb_idx in train_feature_minibatches])
num_batches_per_epoch = int(math.ceil(num_examples / run_config.batch_size))
with tf.Graph().as_default():
with tf.Session() as session:
ctc_model = CTCModel()
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=run_config.max_saves_to_keep)
session.run(tf.global_variables_initializer())
train_writer = tf.summary.FileWriter(run_config.run_results_path, session.graph)
step_ii = 0
for curr_epoch in range(run_config.num_epochs):
total_train_cost = total_train_wer = 0
for mb_idx in random.sample(range(num_batches_per_epoch), num_batches_per_epoch):
cur_batch_size = len(train_seqlens_minibatches[mb_idx])
batch_cost, batch_ler, summary = ctc_model.train_on_batch(
train_feature_minibatches[mb_idx],
train_labels_minibatches[mb_idx],
train_seqlens_minibatches[mb_idx],
train=True)
total_train_cost += batch_cost * cur_batch_size
total_train_wer += batch_ler * cur_batch_size
train_writer.add_summary(summary, step_ii)
step_ii += 1
train_cost = total_train_cost / num_examples
train_wer = total_train_wer / num_examples
val_batch_cost, val_batch_ler, _ = ctc_model.train_on_batch(
val_feature_minibatches[0],
val_labels_minibatches[0],
val_seqlens_minibatches[0],
train=False)
log_msg = "Epoch {}/{}, train_cost = {:.3f}, train_ed = {:.3f}, " \
"val_cost = {:.3f}, val_ed = {:.3f}"
logger.info(
log_msg.format(curr_epoch + 1, Config.num_epochs, train_cost,
train_wer, val_batch_cost, val_batch_ler))
if run_config.log_every is not None and \
(curr_epoch + 1) % run_config.log_every == 0:
batch_ii = random.randint(0, len(train_feature_minibatches) - 1)
ctc_model.print_results(train_feature_minibatches[batch_ii],
train_labels_minibatches[batch_ii],
train_seqlens_minibatches[batch_ii])
if run_config.save_every is not None and \
run_config.model_outputs_path is not None and \
(curr_epoch + 1) % run_config.save_every == 0:
if not os.path.exists(run_config.model_outputs_path):
os.makedirs(run_config.model_outputs_path)
saver.save(session, run_config.model_outputs_path, global_step=curr_epoch + 1)
def resume_train_ctcmodel(run_name):
run_config = Config(run_name, resume=True)
if run_config.tidigits_subset == 'fl':
datasets = tidigits_db.get_split_fl_dataset()
elif run_config.tidigits_subset == 'non-fl':
datasets = tidigits_db.get_split_non_fl_dataset()
else:
datasets = tidigits_db.get_split_all_dataset()
for dset_type, sample_ids in datasets.items():
if dset_type == 'test':
continue
dset = []
for sample_id in tqdm.tqdm(sample_ids):
sample = DigitsSample(sample_id)
features = sample.to_mfccs(run_config.num_mfcc_features)
seqlen = features.shape[0]
label = tuple(tidigits_db.index_mapping[ch] for ch in sample.digits)
dset.append((features, label, seqlen))
datasets[dset_type] = zip(*dset)
# Make minibatches
train_feature_minibatches, train_labels_minibatches, train_seqlens_minibatches = \
make_batches(datasets['train'], batch_size=run_config.batch_size)
val_feature_minibatches, val_labels_minibatches, val_seqlens_minibatches = \
make_batches(datasets['val'], batch_size=run_config.batch_size)
def pad_all_batches(batch_feature_array):
for batch_num in range(len(batch_feature_array)):
batch_feature_array[batch_num] = pad_sequences(batch_feature_array[batch_num])[0]
return batch_feature_array
train_feature_minibatches = pad_all_batches(train_feature_minibatches)
val_feature_minibatches = pad_all_batches(val_feature_minibatches)
num_examples = np.sum([mb_idx.shape[0] for mb_idx in train_feature_minibatches])
num_batches_per_epoch = int(math.ceil(num_examples / run_config.batch_size))
with tf.Graph().as_default():
with tf.Session() as session:
saved_run_dir = run_config.run_results_path
model_weights_dir = os.path.join(saved_run_dir, 'model.weights')
logger.info(model_weights_dir)
assert os.path.exists(model_weights_dir)
saved_model_metas = glob.glob(os.path.join(model_weights_dir, '*.meta'))
assert len(saved_model_metas) > 0
ckpt_iters = sorted(
[int(os.path.basename(fp).split('.')[0][1:]) for fp in saved_model_metas])
logger.info('Found model checkpoints for iterations: ' + repr(ckpt_iters))
latest_ckpt_iter = ckpt_iters[-1]
latest_model_meta_path = [smm for smm in saved_model_metas
if str(latest_ckpt_iter) in smm][0]
ctc_model = CTCModel()
session.run(tf.global_variables_initializer())
logger.info([v.name for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)])
aqn_var_names = [u'q/rnn/multi_rnn_cell/cell_0/gru_cell/gates/weights:0',
u'q/rnn/multi_rnn_cell/cell_0/gru_cell/gates/biases:0',
u'q/rnn/multi_rnn_cell/cell_0/gru_cell/candidate/weights:0',
u'q/rnn/multi_rnn_cell/cell_0/gru_cell/candidate/biases:0']
pre_init_norms = [
np.linalg.norm(session.run(tf.get_default_graph().get_tensor_by_name(var_name)))
for var_name in aqn_var_names
]
# We load meta graph and restore weights
logger.info('Loading model meta information from "%s"' % latest_model_meta_path)
saver = tf.train.Saver(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES))
saver.restore(session, tf.train.latest_checkpoint(model_weights_dir))
logger.info([v.name for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)])
# Check to make sure the restored variables were not written over during
# initialization of other vars
post_init_norms = [
np.linalg.norm(session.run(tf.get_default_graph().get_tensor_by_name(var_name)))
for var_name in aqn_var_names
]
logger.info('Pre-init GRU norms' + repr(pre_init_norms))
logger.info('Post-init GRU norms' + repr(post_init_norms))
assert pre_init_norms != post_init_norms
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=run_config.max_saves_to_keep)
train_writer = tf.summary.FileWriter(run_config.run_results_path, session.graph)
curr_epoch = latest_ckpt_iter
step_ii = curr_epoch * num_batches_per_epoch
while curr_epoch < run_config.num_epochs:
total_train_cost = total_train_wer = 0
for mb_idx in random.sample(range(num_batches_per_epoch), num_batches_per_epoch):
cur_batch_size = len(train_seqlens_minibatches[mb_idx])
batch_cost, batch_ler, summary = ctc_model.train_on_batch(
train_feature_minibatches[mb_idx],
train_labels_minibatches[mb_idx],
train_seqlens_minibatches[mb_idx],
train=True)
total_train_cost += batch_cost * cur_batch_size
total_train_wer += batch_ler * cur_batch_size
train_writer.add_summary(summary, step_ii)
step_ii += 1
train_cost = total_train_cost / num_examples
train_wer = total_train_wer / num_examples
val_batch_cost, val_batch_ler, _ = ctc_model.train_on_batch(
val_feature_minibatches[0],
val_labels_minibatches[0],
val_seqlens_minibatches[0],
train=False)
log_msg = "Epoch {}/{}, train_cost = {:.3f}, train_ed = {:.3f}, " \
"val_cost = {:.3f}, val_ed = {:.3f}"
logger.info(
log_msg.format(curr_epoch + 1, Config.num_epochs, train_cost,
train_wer, val_batch_cost, val_batch_ler))
if run_config.log_every is not None and \
(curr_epoch + 1) % run_config.log_every == 0:
batch_ii = random.randint(0, len(train_feature_minibatches) - 1)
ctc_model.print_results(train_feature_minibatches[batch_ii],
train_labels_minibatches[batch_ii],
train_seqlens_minibatches[batch_ii])
if run_config.save_every is not None and \
run_config.model_outputs_path is not None and \
(curr_epoch + 1) % run_config.save_every == 0:
if not os.path.exists(run_config.model_outputs_path):
os.makedirs(run_config.model_outputs_path)
saver.save(session, run_config.model_outputs_path, global_step=curr_epoch + 1)
curr_epoch += 1