def update_graph(self, word_vocab, char_vocab, max_word_length, epoch):
with self._graph.as_default():
with tf.device('/gpu:%d' % self._gpu_id):
initializer = tf.random_uniform_initializer(
-FLAGS.param_init, FLAGS.param_init)
# TODO: other way to rebuild graph?
reuse = None
# if epoch > 0:
# reuse = True
with tf.variable_scope("Epoch_%d_Individual_%d" %
(epoch, self._id_number),
initializer=initializer,
reuse=reuse):
my_model = model.individual_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=self._knowledge.char_embed_size[-1],
batch_size=FLAGS.batch_size,
max_word_length=max_word_length,
num_unroll_steps=FLAGS.num_unroll_steps,
num_highway_layers=2,
cnn_layer=self._cnn_layer,
rnn_layers=self._rnn_layers,
dropout=self._knowledge.dropout[-1])
my_model.update(
model.loss_graph(my_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
my_model.update(
model.training_graph(
my_model.loss * FLAGS.num_unroll_steps,
FLAGS.learning_rate, FLAGS.max_grad_norm))
saver = tf.train.Saver(max_to_keep=1)
with tf.variable_scope("Epoch_%d_Individual_%d" %
(epoch, self._id_number),
reuse=True):
valid_model = model.individual_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=self._knowledge.char_embed_size[-1],
batch_size=FLAGS.batch_size,
max_word_length=max_word_length,
num_unroll_steps=FLAGS.num_unroll_steps,
num_highway_layers=2,
cnn_layer=self._cnn_layer,
rnn_layers=self._rnn_layers,
dropout=self._knowledge.dropout[-1])
valid_model.update(
model.loss_graph(valid_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
return my_model, valid_model, saver
def main(_):
''' Trains model from data '''
if not os.path.exists(FLAGS.train_dir):
os.mkdir(FLAGS.train_dir)
print('Created training directory', FLAGS.train_dir)
word_vocab, char_vocab, word_tensors, char_tensors, max_word_length = \
load_data(FLAGS.data_dir, FLAGS.max_word_length, eos=FLAGS.EOS)
train_reader = DataReader(word_tensors['train'], char_tensors['train'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
test_reader = DataReader(word_tensors['test'], char_tensors['test'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
print('initialized all dataset readers')
minimum_valid_ppl = 1000000
minimum_vl_epoch = 0
text_file = open("train_log.txt", "w")
# text_file.write("Purchase Amount: %s" % TotalAmount)
with tf.Graph().as_default(), tf.Session() as session:
# tensorflow seed must be inside graph
tf.set_random_seed(FLAGS.seed)
np.random.seed(seed=FLAGS.seed)
''' build training graph '''
initializer = tf.random_uniform_initializer(-FLAGS.param_init,
FLAGS.param_init)
with tf.variable_scope("Model", initializer=initializer):
train_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=FLAGS.dropout)
train_model.update(
model.loss_graph(train_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
# scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor.
# we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be
# much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately.
# Thus, scaling gradients so that this trainer is exactly compatible with the original
train_model.update(
model.training_graph(train_model.loss * FLAGS.num_unroll_steps,
FLAGS.learning_rate, FLAGS.max_grad_norm))
# create saver before creating more graph nodes, so that we do not save any vars defined below
saver = tf.train.Saver(max_to_keep=10)
''' build graph for validation and testing (shares parameters with the training graph!) '''
with tf.variable_scope("Model", reuse=True):
valid_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=0.0)
valid_model.update(
model.loss_graph(valid_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
if FLAGS.load_model:
saver.restore(session, FLAGS.load_model)
print('Loaded model from', FLAGS.load_model,
'saved at global step', train_model.global_step.eval())
else:
tf.global_variables_initializer().run()
session.run(train_model.clear_char_embedding_padding)
print('Created and initialized fresh model. Size:',
model.model_size())
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=session.graph)
''' take learning rate from CLI, not from saved graph '''
session.run(tf.assign(train_model.learning_rate,
FLAGS.learning_rate), )
''' training starts here '''
best_valid_loss = None
rnn_state = session.run(train_model.initial_rnn_state)
for epoch in range(FLAGS.max_epochs):
epoch_start_time = time.time()
avg_train_loss = 0.0
count = 0
for x, y in train_reader.iter():
count += 1
start_time = time.time()
loss, _, rnn_state, gradient_norm, step, _ = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state, train_model.global_norm,
train_model.global_step,
train_model.clear_char_embedding_padding
], {
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
avg_train_loss += 0.05 * (loss - avg_train_loss)
time_elapsed = time.time() - start_time
if count % FLAGS.print_every == 0:
print(
'%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f'
% (step, epoch, count, train_reader.length, loss,
np.exp(loss), time_elapsed, gradient_norm))
text_file.write(
'%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f \n'
% (step, epoch, count, train_reader.length, loss,
np.exp(loss), time_elapsed, gradient_norm))
print('Epoch training time:', time.time() - epoch_start_time)
# text_file.write('Epoch training time:'+str( time.time()-epoch_start_time)
# epoch done: time to evaluate
avg_valid_loss = 0.0
count = 0
rnn_state = session.run(valid_model.initial_rnn_state)
for x, y in valid_reader.iter():
count += 1
start_time = time.time()
loss, rnn_state = session.run(
[valid_model.loss, valid_model.final_rnn_state], {
valid_model.input: x,
valid_model.targets: y,
valid_model.initial_rnn_state: rnn_state,
})
if count % FLAGS.print_every == 0:
print("\t> validation loss = %6.8f, perplexity = %6.8f" %
(loss, np.exp(loss)))
avg_valid_loss += loss / valid_reader.length
print("at the end of epoch:", epoch)
print("train loss = %6.8f, perplexity = %6.8f" %
(avg_train_loss, np.exp(avg_train_loss)))
print("validation loss = %6.8f, perplexity = %6.8f" %
(avg_valid_loss, np.exp(avg_valid_loss)))
text_file.write("at the end of epoch:" + str(epoch) + '\n')
text_file.write("train loss = %6.8f, perplexity = %6.8f \n" %
(avg_train_loss, np.exp(avg_train_loss)))
text_file.write("validation loss = %6.8f, perplexity = %6.8f \n" %
(avg_valid_loss, np.exp(avg_valid_loss)))
if (np.exp(avg_valid_loss) < minimum_valid_ppl):
minimum_valid_ppl = np.exp(avg_valid_loss)
minimum_vl_epoch = epoch
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model', save_as)
elif (epoch % 4 == 0):
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model', save_as)
''' write out summary events '''
summary = tf.Summary(value=[
tf.Summary.Value(tag="train_loss",
simple_value=avg_train_loss),
tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss)
])
summary_writer.add_summary(summary, step)
''' decide if need to decay learning rate '''
if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp(
best_valid_loss) - FLAGS.decay_when:
print(
'validation perplexity did not improve enough, decay learning rate'
)
current_learning_rate = session.run(train_model.learning_rate)
print('learning rate was:', current_learning_rate)
current_learning_rate *= FLAGS.learning_rate_decay
if current_learning_rate < 1.e-5:
print('learning rate too small - stopping now')
break
session.run(
train_model.learning_rate.assign(current_learning_rate))
print('new learning rate is:', current_learning_rate)
else:
best_valid_loss = avg_valid_loss
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model', save_as)
print("----------------------------------------------")
print(
"Minimum Valid PPL is attained in epoch:%d and Validation PPL is %6.8f"
% (minimum_vl_epoch, minimum_valid_ppl))
def build_model(word_vocab, max_doc_length, train):
'''build a training or inference graph, based on the model choice'''
my_model = None
if train:
pretrained_emb = None
embedding_path = FLAGS.embedding_path
if FLAGS.load_model is None and embedding_path != None and os.path.exists(
embedding_path):
pretrained_emb = load_wordvec(embedding_path, word_vocab)
if FLAGS.model_choice == 'bilstm':
my_model = model.cnn_sen_enc(
word_vocab_size=word_vocab.size,
word_embed_size=FLAGS.word_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
max_sen_length=FLAGS.max_sen_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
max_doc_length=max_doc_length,
pretrained=pretrained_emb)
my_model.update(
model.bilstm_doc_enc(my_model.input_cnn,
batch_size=FLAGS.batch_size,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_doc_length=max_doc_length,
dropout=FLAGS.dropout))
my_model.update(model.label_prediction(my_model.enc_outputs))
my_model.update(
model.loss_extraction(my_model.logits, FLAGS.batch_size,
max_doc_length))
my_model.update(
model.training_graph(my_model.loss * max_doc_length,
FLAGS.learning_rate, FLAGS.max_grad_norm))
elif FLAGS.model_choice == 'lstm':
my_model = model.cnn_sen_enc(
word_vocab_size=word_vocab.size,
word_embed_size=FLAGS.word_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
max_sen_length=FLAGS.max_sen_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
max_doc_length=max_doc_length,
pretrained=pretrained_emb)
my_model.update(
model.lstm_doc_enc(my_model.input_cnn,
batch_size=FLAGS.batch_size,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_doc_length=max_doc_length,
dropout=FLAGS.dropout))
my_model.update(
model.lstm_doc_dec(my_model.input_cnn,
my_model.final_enc_state,
batch_size=FLAGS.batch_size,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_doc_length=max_doc_length,
dropout=FLAGS.dropout))
my_model.update(
model.label_prediction_att(my_model.enc_outputs,
my_model.dec_outputs))
my_model.update(
model.loss_extraction(my_model.logits, FLAGS.batch_size,
max_doc_length))
my_model.update(
model.training_graph(my_model.loss * max_doc_length,
FLAGS.learning_rate, FLAGS.max_grad_norm))
else:
if FLAGS.model_choice == 'bilstm':
my_model = model.cnn_sen_enc(
word_vocab_size=word_vocab.size,
word_embed_size=FLAGS.word_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
max_sen_length=FLAGS.max_sen_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
max_doc_length=max_doc_length)
my_model.update(
model.bilstm_doc_enc(my_model.input_cnn,
batch_size=FLAGS.batch_size,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_doc_length=max_doc_length,
dropout=FLAGS.dropout))
my_model.update(model.label_prediction(my_model.enc_outputs))
my_model.update(
model.loss_extraction(my_model.logits, FLAGS.batch_size,
max_doc_length))
elif FLAGS.model_choice == 'lstm':
my_model = model.cnn_sen_enc(
word_vocab_size=word_vocab.size,
word_embed_size=FLAGS.word_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
max_sen_length=FLAGS.max_sen_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
max_doc_length=max_doc_length)
my_model.update(
model.lstm_doc_enc(my_model.input_cnn,
batch_size=FLAGS.batch_size,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_doc_length=max_doc_length,
dropout=FLAGS.dropout))
my_model.update(
model.lstm_doc_dec(my_model.input_cnn,
my_model.final_enc_state,
batch_size=FLAGS.batch_size,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_doc_length=max_doc_length,
dropout=FLAGS.dropout))
my_model.update(
model.label_prediction_att(my_model.enc_outputs,
my_model.dec_outputs))
my_model.update(
model.loss_extraction(my_model.logits, FLAGS.batch_size,
max_doc_length))
return my_model
def main(print):
''' Trains model from data '''
if not os.path.exists(FLAGS.train_dir):
os.mkdir(FLAGS.train_dir)
print('Created training directory' + FLAGS.train_dir)
# CSV initialize
pd.DataFrame(FLAGS.flag_values_dict(),
index=range(1)).to_csv(FLAGS.train_dir +
'/train_parameters.csv')
epochs_results = initialize_epoch_data_dict()
fasttext_model_path = None
if FLAGS.fasttext_model_path:
fasttext_model_path = FLAGS.fasttext_model_path
word_vocab, char_vocab, word_tensors, char_tensors, max_word_length, words_list = \
load_data(FLAGS.data_dir, FLAGS.max_word_length, eos=FLAGS.EOS)
fasttext_model = None
if 'fasttext' in FLAGS.embedding:
fasttext_model = FasttextModel(
fasttext_path=fasttext_model_path).get_fasttext_model()
train_ft_reader = DataReaderFastText(
words_list=words_list,
batch_size=FLAGS.batch_size,
num_unroll_steps=FLAGS.num_unroll_steps,
model=fasttext_model,
data='train')
valid_ft_reader = DataReaderFastText(
words_list=words_list,
batch_size=FLAGS.batch_size,
num_unroll_steps=FLAGS.num_unroll_steps,
model=fasttext_model,
data='valid')
train_reader = DataReader(word_tensors['train'], char_tensors['train'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
test_reader = DataReader(word_tensors['test'], char_tensors['test'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
print('initialized all dataset readers')
with tf.Graph().as_default(), tf.Session() as session:
# tensorflow seed must be inside graph
tf.set_random_seed(FLAGS.seed)
np.random.seed(seed=FLAGS.seed)
''' build training graph '''
initializer = tf.random_uniform_initializer(-FLAGS.param_init,
FLAGS.param_init)
with tf.variable_scope("Model", initializer=initializer):
train_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=FLAGS.dropout,
embedding=FLAGS.embedding,
fasttext_word_dim=300,
acoustic_features_dim=4)
train_model.update(
model.loss_graph(train_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
train_model.update(
model.training_graph(train_model.loss * FLAGS.num_unroll_steps,
FLAGS.learning_rate, FLAGS.max_grad_norm))
# create saver before creating more graph nodes, so that we do not save any vars defined below
saver = tf.train.Saver(max_to_keep=50)
''' build graph for validation and testing (shares parameters with the training graph!) '''
with tf.variable_scope("Model", reuse=True):
valid_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=0.0,
embedding=FLAGS.embedding,
fasttext_word_dim=300,
acoustic_features_dim=4)
valid_model.update(
model.loss_graph(valid_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
if FLAGS.load_model_for_training:
saver.restore(session, FLAGS.load_model_for_training)
string = str('Loaded model from' +
str(FLAGS.load_model_for_training) +
'saved at global step' +
str(train_model.global_step.eval()))
print(string)
else:
tf.global_variables_initializer().run()
session.run(train_model.clear_char_embedding_padding)
string = str('Created and initialized fresh model. Size:' +
str(model.model_size()))
print(string)
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=session.graph)
''' take learning rate from CLI, not from saved graph '''
session.run(tf.assign(train_model.learning_rate,
FLAGS.learning_rate), )
''' training starts here '''
best_valid_loss = None
rnn_state = session.run(train_model.initial_rnn_state)
for epoch in range(FLAGS.max_epochs):
epoch_start_time = time.time()
avg_train_loss = 0.0
count = 0
if fasttext_model:
iter_over = zip(train_reader.iter(), train_ft_reader.iter())
else:
iter_over = train_reader.iter()
for batch_kim, batch_ft in iter_over:
if fasttext_model:
x, y = batch_kim
else:
x, y = batch_kim, batch_ft
count += 1
start_time = time.time()
if fasttext_model:
ft_vectors = fasttext_model.wv[
words_list['train'][count]].reshape(
fasttext_model.wv.vector_size, 1)
loss, _, rnn_state, gradient_norm, step, _, probas = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state,
train_model.global_norm, train_model.global_step,
train_model.clear_char_embedding_padding
], {
train_model.input2: batch_ft,
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
else:
loss, _, rnn_state, gradient_norm, step, _ = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state,
train_model.global_norm, train_model.global_step,
train_model.clear_char_embedding_padding
], {
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
avg_train_loss += 0.05 * (loss - avg_train_loss)
time_elapsed = time.time() - start_time
if count % FLAGS.print_every == 0:
string = str(
'%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f'
% (step, epoch, count, train_reader.length, loss,
np.exp(loss), time_elapsed, gradient_norm))
print(string)
string = str('Epoch training time:' +
str(time.time() - epoch_start_time))
print(string)
epochs_results['epoch_training_time'].append(
str(time.time() - epoch_start_time))
# epoch done: time to evaluate
avg_valid_loss = 0.0
count = 0
rnn_state = session.run(valid_model.initial_rnn_state)
for batch_kim, batch_ft in zip(valid_reader.iter(),
valid_ft_reader.iter()):
x, y = batch_kim
count += 1
start_time = time.time()
loss, rnn_state = session.run(
[valid_model.loss, valid_model.final_rnn_state], {
valid_model.input2: batch_ft,
valid_model.input: x,
valid_model.targets: y,
valid_model.initial_rnn_state: rnn_state,
})
if count % FLAGS.print_every == 0:
string = str(
"\t> validation loss = %6.8f, perplexity = %6.8f" %
(loss, np.exp(loss)))
print(string)
avg_valid_loss += loss / valid_reader.length
print("at the end of epoch:" + str(epoch))
epochs_results['epoch_number'].append(str(epoch))
print("train loss = %6.8f, perplexity = %6.8f" %
(avg_train_loss, np.exp(avg_train_loss)))
epochs_results['train_loss'].append(avg_train_loss)
epochs_results['train_perplexity'].append(np.exp(avg_train_loss))
print("validation loss = %6.8f, perplexity = %6.8f" %
(avg_valid_loss, np.exp(avg_valid_loss)))
epochs_results['validation_loss'].append(avg_valid_loss)
epochs_results['valid_perplexity'].append(np.exp(avg_valid_loss))
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model' + str(save_as))
epochs_results['model_name'].append(str(save_as))
epochs_results['learning_rate'].append(
str(session.run(train_model.learning_rate)))
''' write out summary events '''
summary = tf.Summary(value=[
tf.Summary.Value(tag="train_loss",
simple_value=avg_train_loss),
tf.Summary.Value(tag="train_perplexity",
simple_value=np.exp(avg_train_loss)),
tf.Summary.Value(tag="valid_loss",
simple_value=avg_valid_loss),
tf.Summary.Value(tag="valid_perplexity",
simple_value=np.exp(avg_valid_loss)),
])
summary_writer.add_summary(summary, step)
''' decide if need to decay learning rate '''
if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp(
best_valid_loss) - FLAGS.decay_when:
print(
'validation perplexity did not improve enough, decay learning rate'
)
current_learning_rate = session.run(train_model.learning_rate)
string = str('learning rate was:' + str(current_learning_rate))
print(string)
current_learning_rate *= FLAGS.learning_rate_decay
if current_learning_rate < 1.e-3:
print('learning rate too small - stopping now')
break
session.run(
train_model.learning_rate.assign(current_learning_rate))
string = str('new learning rate is:' +
str(current_learning_rate))
print(string)
else:
best_valid_loss = avg_valid_loss
# Save model performance data
pd.DataFrame(epochs_results).to_csv(FLAGS.train_dir + '/train_results.csv')
def main(file,
batch_size=20,
num_unroll_steps=35,
char_embed_size=15,
rnn_size=650,
kernels="[1,2,3,4,5,6,7]",
kernel_features="[50,100,150,200,200,200,200]",
max_grad_norm=5.0,
learning_rate=1.0,
learning_rate_decay=0.5,
decay_when=1.0,
seed=3435,
param_init=0.05,
max_epochs=25,
print_every=5):
''' Trains model from data '''
if not os.path.exists(TRAINING_DIR):
os.mkdir(TRAINING_DIR)
print('Created training directory', TRAINING_DIR)
word_vocab, char_vocab, word_tensors, char_tensors, max_word_length = \
load_dataset()
print('initialized all dataset readers')
with tf.Graph().as_default(), tf.Session() as session:
train_reader = DataReader(word_tensors['train'], char_tensors['train'],
batch_size, num_unroll_steps, char_vocab)
valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'],
batch_size, num_unroll_steps, char_vocab)
test_reader = DataReader(word_tensors['test'], char_tensors['test'],
batch_size, num_unroll_steps, char_vocab)
# tensorflow seed must be inside graph
tf.set_random_seed(seed)
np.random.seed(seed=seed)
''' build training graph '''
initializer = tf.random_uniform_initializer(param_init, param_init)
with tf.variable_scope("Model", initializer=initializer):
train_model = model.inference_graph(
char_vocab_size=char_vocab.size(),
word_vocab_size=word_vocab.size(),
char_embed_size=char_embed_size,
batch_size=batch_size,
rnn_size=rnn_size,
max_word_length=max_word_length,
kernels=eval(kernels),
kernel_features=eval(kernel_features),
num_unroll_steps=num_unroll_steps)
train_model.update(
model.loss_graph(train_model.logits, batch_size,
num_unroll_steps))
# scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor.
# we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be
# much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately.
# Thus, scaling gradients so that this trainer is exactly compatible with the original
train_model.update(
model.training_graph(train_model.loss * num_unroll_steps,
learning_rate, max_grad_norm))
# create saver before creating more graph nodes, so that we do not save any vars defined below
saver = tf.train.Saver(max_to_keep=50)
''' build graph for validation and testing (shares parameters with the training graph!) '''
with tf.variable_scope("Model", reuse=True):
valid_model = model.inference_graph(
char_vocab_size=char_vocab.size(),
word_vocab_size=word_vocab.size(),
char_embed_size=char_embed_size,
batch_size=batch_size,
rnn_size=rnn_size,
max_word_length=max_word_length,
kernels=eval(kernels),
kernel_features=eval(kernel_features),
num_unroll_steps=num_unroll_steps)
valid_model.update(
model.loss_graph(valid_model.logits, batch_size,
num_unroll_steps))
'''if load_model:
saver.restore(session, load_model)
print('Loaded model from', load_model, 'saved at global step', train_model.global_step.eval())
else:'''
tf.global_variables_initializer().run()
session.run(train_model.clear_char_embedding_padding)
print('Created and initialized fresh model. Size:', model.model_size())
summary_writer = tf.summary.FileWriter(TRAINING_DIR,
graph=session.graph)
''' take learning rate from CLI, not from saved graph '''
session.run(tf.assign(train_model.learning_rate, learning_rate), )
''' training starts here '''
best_valid_loss = None
rnn_state = session.run(train_model.initial_rnn_state)
for epoch in range(max_epochs):
epoch_start_time = time.time()
avg_train_loss = 0.0
count = 0
for x, y in train_reader.iter():
count += 1
start_time = time.time()
loss, _, rnn_state, gradient_norm, step, _ = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state, train_model.global_norm,
train_model.global_step,
train_model.clear_char_embedding_padding
], {
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
avg_train_loss += 0.05 * (loss - avg_train_loss)
time_elapsed = time.time() - start_time
if count % print_every == 0:
print(
'%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f'
% (step, epoch, count, train_reader.length, loss,
np.exp(loss), time_elapsed, gradient_norm))
print('Epoch training time:', time.time() - epoch_start_time)
# epoch done: time to evaluate
avg_valid_loss = 0.0
count = 0
rnn_state = session.run(valid_model.initial_rnn_state)
for x, y in valid_reader.iter():
count += 1
start_time = time.time()
loss, rnn_state = session.run(
[valid_model.loss, valid_model.final_rnn_state], {
valid_model.input: x,
valid_model.targets: y,
valid_model.initial_rnn_state: rnn_state,
})
if count % print_every == 0:
print("\t> validation loss = %6.8f, perplexity = %6.8f" %
(loss, np.exp(loss)))
avg_valid_loss += loss / valid_reader.length
print("at the end of epoch:", epoch)
print("train loss = %6.8f, perplexity = %6.8f" %
(avg_train_loss, np.exp(avg_train_loss)))
print("validation loss = %6.8f, perplexity = %6.8f" %
(avg_valid_loss, np.exp(avg_valid_loss)))
save_as = '%s/epoch%03d_%.4f.model' % (TRAINING_DIR, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model', save_as)
''' write out summary events '''
summary = tf.Summary(value=[
tf.Summary.Value(tag="train_loss",
simple_value=avg_train_loss),
tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss)
])
summary_writer.add_summary(summary, step)
''' decide if need to decay learning rate '''
if best_valid_loss is not None and np.exp(
avg_valid_loss) > np.exp(best_valid_loss) - decay_when:
print(
'validation perplexity did not improve enough, decay learning rate'
)
current_learning_rate = session.run(train_model.learning_rate)
print('learning rate was:', current_learning_rate)
current_learning_rate *= learning_rate_decay
if current_learning_rate < 1.e-5:
print('learning rate too small - stopping now')
break
session.run(
train_model.learning_rate.assign(current_learning_rate))
print('new learning rate is:', current_learning_rate)
else:
best_valid_loss = avg_valid_loss
def train():
dataset_tensors, labels_tensors = dl.make_batches()
input_tensor_tr, label_tensor_tr, seq_tensor_tr = dl.sequence_init(
dataset_tensors,
labels_tensors,
FLAGS.num_unroll_steps,
'Train',
allow_short_seq=False)
input_tensor_te, label_tensor_te, seq_tensor_te = dl.sequence_init(
dataset_tensors,
labels_tensors,
FLAGS.num_unroll_steps,
'Devel',
allow_short_seq=True)
train_reader = dl.TrainDataReader(input_tensor_tr, label_tensor_tr,
seq_tensor_tr, FLAGS.batch_size,
FLAGS.num_unroll_steps, False)
eval_reader = dl.EvalDataReader(input_tensor_te, label_tensor_te,
seq_tensor_te, FLAGS.batch_size_eval,
FLAGS.num_unroll_steps, False)
labels = tf.placeholder(tf.float32, [None, FLAGS.num_unroll_steps, 3],
name='labels')
train_model = model.inference_graph(
word_vocab_size=FLAGS.word_vocab_size,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
rnn_size=FLAGS.rnn_size,
dropout=FLAGS.dropout,
num_rnn_layers=FLAGS.rnn_layers,
num_highway_layers=FLAGS.highway_layers,
num_unroll_steps=FLAGS.num_unroll_steps,
max_sent_length=FLAGS.max_sent_length,
# batch_size= FLAGS.batch_size,
embed_size=FLAGS.word_embed_size,
trnn_size=eval(FLAGS.trnn_size),
num_trnn_layers=eval(FLAGS.trnn_layers),
num_heads=FLAGS.head_attention_layers)
predictions_arousal = train_model.predictions_arousal
predictions_valence = train_model.predictions_valence
predictions_liking = train_model.predictions_liking
predictions_AV = tf.concat([predictions_arousal, predictions_valence], 1)
predictions = tf.concat(
[predictions_arousal, predictions_valence, predictions_liking], 1)
embedding_matrix = dl.loadPickle(Embedding_PATH,
'Embedding_300_fastText_training.pkl')
AV_losses = model.loss_graph_ccc_arousal_valence(predictions_AV, labels)
eval_model = model.metric_graph()
loss_av = AV_losses.AV_CCC
eval_arousal = eval_model.eval_metric_arousal
eval_valence = eval_model.eval_metric_valence
eval_liking = eval_model.eval_metric_liking
optimize_graph = model.training_graph(loss_av, FLAGS.learning_rate,
FLAGS.max_grad_norm)
train_op = optimize_graph.train_op
saver = tf.train.Saver(max_to_keep=100)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
train_writer = tf.summary.FileWriter('.\logs\\train', graph=sess.graph)
eval_writer = tf.summary.FileWriter('.\logs\\eval', graph=sess.graph)
best, inx = 0.92, 1
epoch = 0
global_step = 0
while epoch < FLAGS.max_epochs:
batch = 1
epoch += 1
train_reader.make_batches()
for minibatch in train_reader.iter():
x, y = minibatch
_, l = sess.run(
[train_op, loss_av],
feed_dict={
train_model.input: x,
labels: y,
train_model.sequence_length: [96] * x.shape[0],
train_model.batch_size: x.shape[0],
train_model.training: True,
train_model.word_embedding: embedding_matrix,
train_model.dropout_LSTM: 0.0,
train_model.dropout_text: 0.1,
train_model.dropout_atdnn: 0.3,
train_model.dropout_trnn: 0.3,
train_model.dropout_mlattention: 0.2
})
with open(ArchivePathTrain, 'a') as apt:
apt.write(str(l) + ';' + str(global_step))
apt.write('\n')
print('Epoch: %5d/%5d -- batch: %5d -- loss: %.4f' %
(epoch, FLAGS.max_epochs, batch, l))
summary = tf.Summary(
value=[tf.Summary.Value(tag="TRAIN_LOSS", simple_value=l)])
train_writer.add_summary(summary, global_step)
if batch % 9 == 0: # 7, change print from 7 to 9 20180725
print(
'-------------------Devel Set Start------------------------------'
)
cnt = 0
prev = None
eval_x_total = None
eval_y = None
for mb in eval_reader.iter():
eval_x_list, eval_y_list, eval_z_list = mb
for eval_x, eval_z in zip(eval_x_list, eval_z_list):
cnt += np.sum(eval_z)
eval_tmp_preds = sess.run(
[predictions],
feed_dict={
train_model.input: eval_x,
train_model.sequence_length: eval_z,
train_model.batch_size: eval_x.shape[0],
train_model.training: False,
train_model.word_embedding:
embedding_matrix,
train_model.dropout_LSTM: 0.0,
train_model.dropout_text: 0.0,
train_model.dropout_atdnn: 0.0,
train_model.dropout_trnn: 0.0,
train_model.dropout_mlattention: 0.0
})
if prev is None:
prev = eval_tmp_preds[0]
else:
prev = np.vstack((prev, eval_tmp_preds[0]))
prev = prev[:cnt]
if eval_x_total is None:
eval_x_total = prev
else:
eval_x_total = np.vstack((eval_x_total, prev))
if eval_y is None:
eval_y = np.array(eval_y_list).reshape([-1,
3])[:cnt]
else:
eval_y = np.vstack(
(eval_y,
np.array(eval_y_list).reshape([-1, 3])[:cnt]))
prev = None
cnt = 0
e_arousal, e_valence, e_liking = sess.run(
[eval_arousal, eval_valence, eval_liking],
feed_dict={
eval_model.eval_predictions: eval_x_total,
eval_model.eval_labels: eval_y
})
eval_res = np.array([e_arousal, e_valence, e_liking])
eval_loss = 2. - eval_res[0] - eval_res[1]
with open(ArchivePathEval, 'a') as ape:
ape.write(str(eval_loss) + ';' + str(global_step))
ape.write('\n')
summary_eval = tf.Summary(value=[
tf.Summary.Value(tag="Eval_LOSS",
simple_value=eval_loss)
])
eval_writer.add_summary(summary_eval, global_step)
if eval_loss < best:
saver.save(sess, SAVE_PATH + '-{}'.format(inx))
inx += 1
log = open(LOGGING_PATH, 'a')
log.write('Model, ' + SAVE_PATH + '-{}'.format(inx) +
'\n')
log.write(
'%s, Epoch: %d, Batch: %d, Loss: %.4f, Arousal: %.4f, Valence: %.4f\n'
% ('Devel', epoch, batch, eval_loss, eval_res[0],
eval_res[1]))
log.write(
'======================================================\n'
)
log.close()
print(
'Devel Set, Epoch: %5d/%5d -- batch: %5d -- loss: _%.4f -- arousal: %.4f -- valence: %.4f -- liking: %.4f'
% (epoch, FLAGS.max_epochs, batch, eval_loss,
eval_res[0], eval_res[1], eval_res[2]))
print(
'---------------------Devel Finished----------------------'
)
global_step += 1
batch += 1
def main(_):
''' Trains model from data '''
print("we in main")
print(sys.argv[2])
print(FLAGS)
if not os.path.exists(FLAGS.train_dir):
os.mkdir(FLAGS.train_dir)
print('Created training directory', FLAGS.train_dir)
word_vocab, char_vocab, word_tensors, char_tensors, max_word_length = \
load_data(FLAGS.data_dir, FLAGS.max_word_length, eos=FLAGS.EOS)
train_reader = DataReader(word_tensors['train'], char_tensors['train'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
valid_reader = DataReader(word_tensors['valid'], char_tensors['valid'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
test_reader = DataReader(word_tensors['test'], char_tensors['test'],
FLAGS.batch_size, FLAGS.num_unroll_steps)
print('initialized all dataset readers')
with tf.Graph().as_default(), tf.Session() as session:
# tensorflow seed must be inside graph
tf.set_random_seed(FLAGS.seed)
np.random.seed(seed=FLAGS.seed)
''' build training graph '''
initializer = tf.random_uniform_initializer(-FLAGS.param_init, FLAGS.param_init)
with tf.variable_scope("Model", initializer=initializer):
train_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=FLAGS.dropout)
train_model.update(model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps))
# scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor.
# we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be
# much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately.
# Thus, scaling gradients so that this trainer is exactly compatible with the original
train_model.update(model.training_graph(train_model.loss * FLAGS.num_unroll_steps, FLAGS.learning_rate, FLAGS.max_grad_norm))
# create saver before creating more graph nodes, so that we do not save any vars defined below
saver = tf.train.Saver(max_to_keep=50)
''' build graph for validation and testing (shares parameters with the training graph!) '''
with tf.variable_scope("Model", reuse=True):
valid_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=0.0)
valid_model.update(model.loss_graph(valid_model.logits, FLAGS.batch_size, FLAGS.num_unroll_steps))
with tf.variable_scope("Model", reuse=True):
test_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=1,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=1,
dropout=0.0)
test_model.update(model.loss_graph(test_model.logits, 1, 1))
if FLAGS.load_model:
saver.restore(session, FLAGS.load_model)
print('Loaded model from', FLAGS.load_model, 'saved at global step', train_model.global_step.eval())
else:
tf.initialize_all_variables().run()
print('Created and initialized fresh model. Size:', model.model_size())
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, graph=session.graph)
''' take learning rate from CLI, not from saved graph '''
session.run(
tf.assign(train_model.learning_rate, FLAGS.learning_rate),
)
def clear_char_embedding_padding():
char_embedding = session.run(train_model.char_embedding)
char_embedding[0,:] = 0.0
session.run(tf.assign(train_model.char_embedding, char_embedding))
char_embedding = session.run(train_model.char_embedding)
clear_char_embedding_padding()
run_test2(session, test_model, train_reader)
#exit(1)
''' training starts here '''
best_valid_loss = None
rnn_state = session.run(train_model.initial_rnn_state)
for epoch in range(FLAGS.max_epochs):
avg_train_loss = 0.0
count = 0
for x, y in train_reader.iter():
count += 1
start_time = time.time()
print (x)
exit(1)
loss, _, rnn_state, gradient_norm, step = session.run([
train_model.loss,
train_model.train_op,
train_model.final_rnn_state,
train_model.global_norm,
train_model.global_step,
], {
train_model.input : x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
clear_char_embedding_padding()
avg_train_loss += 0.05 * (loss - avg_train_loss)
time_elapsed = time.time() - start_time
if count % FLAGS.print_every == 0:
print('%6d: %d [%5d/%5d], train_loss/perplexity = %6.8f/%6.7f secs/batch = %.4fs, grad.norm=%6.8f' % (step,
epoch, count,
train_reader.length,
loss, np.exp(loss),
time_elapsed,
gradient_norm))
# epoch done: time to evaluate
avg_valid_loss = 0.0
count = 0
rnn_state = session.run(valid_model.initial_rnn_state)
for x, y in valid_reader.iter():
count += 1
start_time = time.time()
loss, rnn_state = session.run([
valid_model.loss,
valid_model.final_rnn_state
], {
valid_model.input : x,
valid_model.targets: y,
valid_model.initial_rnn_state: rnn_state,
})
if count % FLAGS.print_every == 0:
print("\t> validation loss = %6.8f, perplexity = %6.8f" % (loss, np.exp(loss)))
avg_valid_loss += loss / valid_reader.length
print("at the end of epoch:", epoch)
print("train loss = %6.8f, perplexity = %6.8f" % (avg_train_loss, np.exp(avg_train_loss)))
print("validation loss = %6.8f, perplexity = %6.8f" % (avg_valid_loss, np.exp(avg_valid_loss)))
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch, avg_valid_loss)
saver.save(session, save_as)
print('Saved model', save_as)
''' write out summary events '''
summary = tf.Summary(value=[
tf.Summary.Value(tag="train_loss", simple_value=avg_train_loss),
tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss)
])
summary_writer.add_summary(summary, step)
''' decide if need to decay learning rate '''
if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp(best_valid_loss) - FLAGS.decay_when:
print('** validation perplexity did not improve enough, decay learning rate')
current_learning_rate = session.run(train_model.learning_rate)
print('learning rate was:', current_learning_rate)
current_learning_rate *= FLAGS.learning_rate_decay
if current_learning_rate < 1.e-5:
print('learning rate too small - stopping now')
break
session.run(train_model.learning_rate.assign(current_learning_rate))
print('new learning rate is:', current_learning_rate)
else:
best_valid_loss = avg_valid_loss
run_test2(session, test_model, train_reader)
print ("AGAIN")
run_test2(session, test_model, train_reader)
def main(print):
''' Trains model from data '''
if not os.path.exists(FLAGS.train_dir):
os.mkdir(FLAGS.train_dir)
print('Created training directory' + FLAGS.train_dir)
# CSV initialize
df_train_params = pd.DataFrame(FLAGS.flag_values_dict(), index=range(1))
df_train_params['comment'] = ''
df_train_params.to_csv(FLAGS.train_dir + '/train_parameters.csv')
epochs_results = initialize_epoch_data_dict()
fasttext_model_path = None
if FLAGS.fasttext_model_path:
fasttext_model_path = FLAGS.fasttext_model_path
word_vocab, char_vocab, word_tensors, char_tensors, max_word_length, words_list, wers, acoustics = \
load_data(FLAGS.data_dir, FLAGS.max_word_length, num_unroll_steps=FLAGS.num_unroll_steps, eos=FLAGS.EOS, batch_size=FLAGS.batch_size)
word_vocab_valid, char_vocab_valid, word_tensors_valid, char_tensors_valid, max_word_length_valid, words_list_valid, wers_valid,\
acoustics_valid, files_name_valid, kaldi_sents_index_valid = \
load_test_data(FLAGS.data_dir, FLAGS.max_word_length, num_unroll_steps=FLAGS.num_unroll_steps, eos=FLAGS.EOS,
datas=['valid'])
fasttext_model = None
if 'fasttext' in FLAGS.embedding:
fasttext_model = FasttextModel(
fasttext_path=fasttext_model_path).get_fasttext_model()
train_ft_reader = DataReaderFastText(
words_list=words_list,
batch_size=FLAGS.batch_size,
num_unroll_steps=FLAGS.num_unroll_steps,
model=fasttext_model,
data='train',
acoustics=acoustics)
valid_ft_reader = DataReaderFastText(
words_list=words_list,
batch_size=FLAGS.batch_size,
num_unroll_steps=FLAGS.num_unroll_steps,
model=fasttext_model,
data='valid',
acoustics=acoustics)
train_reader = DataReader(word_tensors['train'], char_tensors['train'],
FLAGS.batch_size, FLAGS.num_unroll_steps,
wers['train'])
valid_reader = TestDataReader(word_tensors_valid['valid'],
char_tensors_valid['valid'],
FLAGS.batch_size, FLAGS.num_unroll_steps,
wers_valid['valid'],
files_name_valid['valid'],
kaldi_sents_index_valid['valid'])
# test_reader = DataReader(word_tensors['test'], char_tensors['test'],
# FLAGS.batch_size, FLAGS.num_unroll_steps, wers['train'], word_vocab, char_vocab)
print('initialized all dataset readers')
with tf.Graph().as_default(), tf.Session() as session:
# tensorflow seed must be inside graph
tf.set_random_seed(FLAGS.seed)
np.random.seed(seed=FLAGS.seed)
''' build training graph '''
initializer = tf.random_uniform_initializer(-FLAGS.param_init,
FLAGS.param_init)
with tf.variable_scope("Model", initializer=initializer):
train_model = model.inference_graph(
char_vocab_size=char_vocab.size,
word_vocab_size=word_vocab.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=FLAGS.dropout,
embedding=FLAGS.embedding,
fasttext_word_dim=300,
acoustic_features_dim=4)
train_model.update(
model.loss_graph(train_model.logits, FLAGS.batch_size))
# scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor.
# we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be
# much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately.
# Thus, scaling gradients so that this trainer is exactly compatible with the original
train_model.update(
model.training_graph(train_model.loss * FLAGS.num_unroll_steps,
FLAGS.learning_rate, FLAGS.max_grad_norm))
''' build graph for validation and testing (shares parameters with the training graph!) '''
with tf.variable_scope("Model", reuse=True):
valid_model = model.inference_graph(
char_vocab_size=char_vocab_valid.size,
word_vocab_size=word_vocab_valid.size,
char_embed_size=FLAGS.char_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
max_word_length=max_word_length,
kernels=eval(FLAGS.kernels),
kernel_features=eval(FLAGS.kernel_features),
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=0.0,
embedding=FLAGS.embedding,
fasttext_word_dim=300,
acoustic_features_dim=4)
valid_model.update(
model.loss_graph(valid_model.logits, FLAGS.batch_size))
# create saver before creating more graph nodes, so that we do not save any vars defined below
if FLAGS.load_model_for_training:
# delete last layers (softmax) - SimpleLinear/Matrix + Bias
variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
subset_grpah_for_loading = variables[:29] + variables[31:]
loader = tf.train.Saver(max_to_keep=50,
var_list=subset_grpah_for_loading)
saver = tf.train.Saver(max_to_keep=50)
if FLAGS.load_model_for_training:
loader.restore(session, FLAGS.load_model_for_training)
string = str('Loaded model from' +
str(FLAGS.load_model_for_training) +
'saved at global step' +
str(train_model.global_step.eval()))
print(string)
session.run(tf.variables_initializer(var_list=variables[29:31]))
string = str('initialized specific scope for fresh model. Size:' +
str(model.model_size()))
print(string)
else:
tf.global_variables_initializer().run()
session.run(train_model.clear_char_embedding_padding)
string = str('Created and initialized fresh model. Size:' +
str(model.model_size()))
print(string)
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=session.graph)
''' take learning rate from CLI, not from saved graph '''
session.run(tf.assign(train_model.learning_rate,
FLAGS.learning_rate), )
''' training starts here '''
best_valid_loss = None
rnn_state = session.run(train_model.initial_rnn_state)
for epoch in range(FLAGS.max_epochs):
epoch_start_time = time.time()
avg_train_loss = 0.0
count = 0
for batch_kim, batch_ft in zip(train_reader.iter(),
train_ft_reader.iter()):
x, y = batch_kim
count += 1
start_time = time.time()
if fasttext_model:
ft_vectors = fasttext_model.wv[
words_list['train'][count]].reshape(
fasttext_model.wv.vector_size, 1)
loss, _, rnn_state, gradient_norm, step, _, logits = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state,
train_model.global_norm, train_model.global_step,
train_model.clear_char_embedding_padding,
train_model.logits
], {
train_model.input2: batch_ft,
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
else:
loss, _, rnn_state, gradient_norm, step, _, logits = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state,
train_model.global_norm, train_model.global_step,
train_model.clear_char_embedding_padding,
train_model.logits
], {
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
avg_train_loss += 0.05 * (loss - avg_train_loss)
time_elapsed = time.time() - start_time
if count % FLAGS.print_every == 0:
string = str(
'%6d: %d [%5d/%5d], train_loss = %6.8f secs/batch = %.4fs'
% (step, epoch, count, train_reader.length, loss,
time_elapsed))
print(string)
string = str('Epoch training time:' +
str(time.time() - epoch_start_time))
print(string)
epochs_results['epoch_training_time'].append(
str(time.time() - epoch_start_time))
# epoch done: time to evaluate
avg_valid_loss = 0.
labels = []
predictions = []
files_name_list = []
kaldi_sents_index_list = []
count = 0
rnn_state = session.run(valid_model.initial_rnn_state)
for batch_kim, batch_ft in zip(valid_reader.iter(),
valid_ft_reader.iter()):
x, y, files_name_batch, kaldi_sents_index_batch = batch_kim
count += 1
start_time = time.time()
loss, logits = session.run(
[valid_model.loss, valid_model.logits], {
valid_model.input2: batch_ft,
valid_model.input: x,
valid_model.targets: y,
valid_model.initial_rnn_state: rnn_state,
})
labels.append(y)
predictions.append(logits)
files_name_list.append(files_name_batch)
kaldi_sents_index_list.append(kaldi_sents_index_batch)
if count % FLAGS.print_every == 0:
string = str("\t> validation loss = %6.8f" % (loss))
print(string)
avg_valid_loss = get_valid_rescore_loss(labels, predictions,
files_name_list,
kaldi_sents_index_list)
print("at the end of epoch:" + str(epoch))
epochs_results['epoch_number'].append(str(epoch))
print("train loss = %6.8f" % (avg_train_loss))
epochs_results['train_loss'].append(avg_train_loss)
print("validation loss = %6.8f" % (avg_valid_loss))
epochs_results['validation_loss'].append(avg_valid_loss)
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model' + str(save_as))
epochs_results['model_name'].append(str(save_as))
epochs_results['learning_rate'].append(
str(session.run(train_model.learning_rate)))
current_learning_rate = session.run(train_model.learning_rate)
''' decide if need to decay learning rate '''
if best_valid_loss is not None and avg_valid_loss > best_valid_loss - FLAGS.decay_when:
print(
'validation perplexity did not improve enough, decay learning rate'
)
current_learning_rate = session.run(train_model.learning_rate)
string = str('learning rate was:' + str(current_learning_rate))
print(string)
current_learning_rate *= FLAGS.learning_rate_decay
if current_learning_rate < 1.e-6:
print('learning rate too small - stopping now')
break
session.run(
train_model.learning_rate.assign(current_learning_rate))
string = str('new learning rate is:' +
str(current_learning_rate))
print(string)
else:
best_valid_loss = avg_valid_loss
''' write out summary events '''
summary = tf.Summary(value=[
tf.Summary.Value(tag="train_loss",
simple_value=avg_train_loss),
tf.Summary.Value(tag="valid_loss",
simple_value=avg_valid_loss),
tf.Summary.Value(tag="learning_rate",
simple_value=current_learning_rate)
])
summary_writer.add_summary(summary, step)
# Save model performance data
pd.DataFrame(epochs_results).to_csv(FLAGS.train_dir + '/train_results.csv')
def main(_):
''' Trains model from data '''
min = [1000, 1000, 1000, 1000] # [t_loss, t_ppl, v_loss, v_ppl]
total_time = 0.
if not os.path.exists(FLAGS.train_dir):
os.mkdir(FLAGS.train_dir)
print('Created training directory', FLAGS.train_dir)
word_vocab, \
char_vocab, \
word_tensors, \
char_tensors, \
max_word_length = load_data(FLAGS.data_dir, FLAGS.max_word_length, flist = FILE_NAME_LIST, eos=FLAGS.EOS)
train_reader = DataReader(word_tensors[FILE_NAME_LIST[0]],
FLAGS.batch_size, FLAGS.num_unroll_steps)
valid_reader = DataReader(word_tensors[FILE_NAME_LIST[1]],
FLAGS.batch_size, FLAGS.num_unroll_steps)
test_reader = DataReader(word_tensors[FILE_NAME_LIST[2]], FLAGS.batch_size,
FLAGS.num_unroll_steps)
print('initialized all dataset readers')
with tf.Graph().as_default(), tf.Session() as session:
# tensorflow seed must be inside graph
tf.set_random_seed(FLAGS.seed)
np.random.seed(seed=FLAGS.seed)
''' build training graph '''
initializer = tf.random_uniform_initializer(-FLAGS.param_init,
FLAGS.param_init)
with tf.variable_scope("Model", initializer=initializer):
train_model = model.inference_graph(
word_vocab_size=word_vocab.size,
word_embed_size=FLAGS.word_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=FLAGS.dropout)
train_model.update(
model.loss_graph(train_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
# scaling loss by FLAGS.num_unroll_steps effectively scales gradients by the same factor.
# we need it to reproduce how the original Torch code optimizes. Without this, our gradients will be
# much smaller (i.e. 35 times smaller) and to get system to learn we'd have to scale learning rate and max_grad_norm appropriately.
# Thus, scaling gradients so that this trainer is exactly compatible with the original
train_model.update(
model.training_graph(train_model.loss * FLAGS.num_unroll_steps,
FLAGS.learning_rate, FLAGS.max_grad_norm))
# create saver before creating more graph nodes, so that we do not save any vars defined below
saver = tf.train.Saver(max_to_keep=5)
''' build graph for validation and testing (shares parameters with the training graph!) '''
with tf.variable_scope("Model", reuse=True):
valid_model = model.inference_graph(
word_vocab_size=word_vocab.size,
word_embed_size=FLAGS.word_embed_size,
batch_size=FLAGS.batch_size,
num_highway_layers=FLAGS.highway_layers,
num_rnn_layers=FLAGS.rnn_layers,
rnn_size=FLAGS.rnn_size,
num_unroll_steps=FLAGS.num_unroll_steps,
dropout=0.0)
valid_model.update(
model.loss_graph(valid_model.logits, FLAGS.batch_size,
FLAGS.num_unroll_steps))
if FLAGS.load_model:
saver.restore(session, FLAGS.load_model)
print('Loaded model from', FLAGS.load_model,
'saved at global step', train_model.global_step.eval())
else:
tf.global_variables_initializer().run()
session.run(train_model.clear_char_embedding_padding)
print('Created and initialized fresh model. Size:',
model.model_size())
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=session.graph)
''' take learning rate from CLI, not from saved graph '''
session.run(tf.assign(train_model.learning_rate, FLAGS.learning_rate))
print("=" * 89)
print("=" * 89)
all_weights = {v.name: v for v in tf.trainable_variables()}
total_size = 0
pi = 1 # 0 is for sum of grad_sses
for v_name in list(all_weights): # sorted()
v = all_weights[v_name]
v_size = int(np.prod(np.array(v.shape.as_list())))
print("%02d-Weight %s\tshape %s\ttsize %d" %
(pi, v.name[:-2].ljust(80), str(v.shape).ljust(20), v_size))
total_size += v_size
pi += 1
print("Total size %d, %.3fMiB" % (total_size,
(total_size * 4) / (1024 * 1024)))
print("-" * 89)
''' training starts here '''
best_valid_loss = None
rnn_state = session.run(train_model.initial_rnn_state)
for epoch in range(1, FLAGS.max_epochs + 1):
epoch_start_time = time.time()
avg_train_loss = 0.0
count = 0
for x, y in train_reader.iter():
count += 1
start_time = time.time()
loss, _, rnn_state, gradient_norm, step, _ = session.run(
[
train_model.loss, train_model.train_op,
train_model.final_rnn_state, train_model.global_norm,
train_model.global_step,
train_model.clear_char_embedding_padding
], {
train_model.input: x,
train_model.targets: y,
train_model.initial_rnn_state: rnn_state
})
avg_train_loss += 0.05 * (loss - avg_train_loss)
time_elapsed = time.time() - start_time
if count % FLAGS.print_every == 0:
cur_lr = session.run(train_model.learning_rate)
print(
'%6d: -%d- [%5d/%5d], train_loss/ppl = %6.8f/%6.7f batch/secs = %.1fb/s, cur_lr = %2.5f, grad.norm=%6.8f'
% (step, epoch, count, train_reader.length, loss,
np.exp(loss), FLAGS.print_every / time_elapsed,
cur_lr, gradient_norm))
print('Epoch training time:', time.time() - epoch_start_time)
total_time += (time.time() - epoch_start_time)
# epoch done: time to evaluate
avg_valid_loss = 0.0
count = 0
rnn_state = session.run(valid_model.initial_rnn_state)
for x, y in valid_reader.iter():
count += 1
start_time = time.time()
loss, rnn_state = session.run(
[valid_model.loss, valid_model.final_rnn_state], {
valid_model.input: x,
valid_model.targets: y,
valid_model.initial_rnn_state: rnn_state,
})
if count % FLAGS.print_every == 0:
print("\t> validation loss = %6.8f, perplexity = %6.8f" %
(loss, np.exp(loss)))
avg_valid_loss += loss / valid_reader.length
print("at the end of epoch:", epoch)
print("train loss = %6.8f, perplexity = %6.8f" %
(avg_train_loss, np.exp(avg_train_loss)))
print("validation loss = %6.8f, perplexity = %6.8f" %
(avg_valid_loss, np.exp(avg_valid_loss)))
if min[2] > avg_valid_loss:
min[0] = avg_train_loss
min[1] = np.exp(avg_train_loss)
min[2] = avg_valid_loss
min[3] = np.exp(avg_valid_loss)
save_as = '%s/epoch%03d_%.4f.model' % (FLAGS.train_dir, epoch,
avg_valid_loss)
saver.save(session, save_as)
print('Saved model', save_as)
''' write out summary events '''
summary = tf.Summary(value=[
tf.Summary.Value(tag="train_loss",
simple_value=avg_train_loss),
tf.Summary.Value(tag="valid_loss", simple_value=avg_valid_loss)
])
summary_writer.add_summary(summary, step)
''' decide if need to decay learning rate '''
if best_valid_loss is not None and np.exp(avg_valid_loss) > np.exp(
best_valid_loss) - FLAGS.decay_when:
print(
'validation perplexity did not improve enough, decay learning rate'
)
current_learning_rate = session.run(train_model.learning_rate)
print('learning rate was:', current_learning_rate)
current_learning_rate *= FLAGS.learning_rate_decay
if current_learning_rate < 1.e-5:
print('learning rate too small - stopping now')
break
session.run(
train_model.learning_rate.assign(current_learning_rate))
print('new learning rate is:', current_learning_rate)
else:
best_valid_loss = avg_valid_loss
''' test on the test set '''
ave_test_loss = 0.
trnn_state = session.run(valid_model.initial_rnn_state)
for x, y in test_reader.iter():
loss, trnn_state = session.run(
[valid_model.loss, valid_model.final_rnn_state], {
valid_model.input: x,
valid_model.targets: y,
valid_model.initial_rnn_state: trnn_state
})
disp_loss = loss
ave_test_loss += disp_loss / test_reader.length
print("=" * 89)
print("=" * 89)
print("Total training time(not included the valid time): %f" %
total_time)
print("The best result:")
print("train loss = %.3f, ppl = %.4f" % (min[0], min[1]))
print("valid loss = %.3f, ppl = %.4f" % (min[2], min[3]))
print("test loss = %.3f, ppl = %.4f" %
(ave_test_loss, np.exp(ave_test_loss)))
print("=" * 89)
def main():
pretrain_word2id, pretrain_id2word, pretrain_emb = reader.load_pretrain(
FLAGS.pretrain_path,
[FLAGS.train_path, FLAGS.validate_path, FLAGS.test_path])
vocabs = reader.build_vocab(FLAGS.train_path)
traindata = reader.DataSet(FLAGS.train_path, FLAGS.max_word_len,
pretrain_word2id, pretrain_id2word, pretrain_emb, vocabs)
traindata.load_data()
validate = reader.DataSet(FLAGS.validate_path, FLAGS.max_word_len,
pretrain_word2id, pretrain_id2word, pretrain_emb, vocabs)
validate.load_data()
test = reader.DataSet(FLAGS.test_path, FLAGS.max_word_len,
pretrain_word2id, pretrain_id2word, pretrain_emb, vocabs)
test.load_data()
seq_lens = FLAGS.num_steps * np.ones(FLAGS.batch_size)
with tf.Graph().as_default(), tf.Session() as sess:
with tf.variable_scope("Model"):
train_model = model.inference_graph(
char_vocab_size=len(traindata.char2id),
pretrain_embedding=traindata.pretrain_emb,
max_word_len=FLAGS.max_word_len,
ntags=len(traindata.tag2id),
batch_size=FLAGS.batch_size,
num_steps=FLAGS.num_steps,
char_emb_size=FLAGS.char_emb_size,
lstm_state_size=FLAGS.lstm_state_size,
num_rnn_layers=FLAGS.num_rnn_layers,
dropout=FLAGS.dropout,
filter_sizes=[FLAGS.filter_size],
nfilters=[FLAGS.nfilter])
train_model.update(model.loss_graph(train_model.logits, FLAGS.batch_size, FLAGS.num_steps, FLAGS.crf, seq_lens))
train_model.update(model.training_graph(train_model.loss * FLAGS.num_steps, FLAGS.learning_rate, FLAGS.max_grad_norm))
#train_model.update(model.training_graph(train_model.loss))
saver = tf.train.Saver()
'''Validate model'''
with tf.variable_scope("Model", reuse=True):
validate_model=model.inference_graph(
char_vocab_size=len(validate.char2id),
pretrain_embedding=validate.pretrain_emb,
max_word_len=FLAGS.max_word_len,
ntags=len(validate.tag2id),
batch_size=FLAGS.batch_size,
num_steps=FLAGS.num_steps,
char_emb_size=FLAGS.char_emb_size,
lstm_state_size=FLAGS.lstm_state_size,
num_rnn_layers=FLAGS.num_rnn_layers,
dropout=0, #No dropout when testing!
filter_sizes=[FLAGS.filter_size],
nfilters=[FLAGS.nfilter])
validate_model.update(model.loss_graph(validate_model.logits, FLAGS.batch_size, FLAGS.num_steps, FLAGS.crf, seq_lens))
validate_model.update(model.adict(name="validation"))
'''Test model'''
with tf.variable_scope("Model", reuse=True):
test_model=model.inference_graph(
char_vocab_size=len(test.char2id),
pretrain_embedding=test.pretrain_emb,
max_word_len=FLAGS.max_word_len,
ntags=len(test.tag2id),
batch_size=FLAGS.batch_size,
num_steps=FLAGS.num_steps,
char_emb_size=FLAGS.char_emb_size,
lstm_state_size=FLAGS.lstm_state_size,
num_rnn_layers=FLAGS.num_rnn_layers,
dropout=0,
filter_sizes=[FLAGS.filter_size],
nfilters=[FLAGS.nfilter])
test_model.update(model.loss_graph(test_model.logits, FLAGS.batch_size, FLAGS.num_steps, FLAGS.crf, seq_lens))
test_model.update(model.adict(name="test"))
init_op = tf.global_variables_initializer()
sess.run(init_op)
lstm_state_fw = sess.run(train_model.initial_lstm_state_fw)
lstm_state_bw = sess.run(train_model.initial_lstm_state_bw)
print "Start Training..."
current_best_Fscore = 0.0
for epoch in range(FLAGS.total_epoch):
print "epoch", epoch
start_time = time.time()
loss = run_epoch(sess, traindata, train_model, lstm_state_fw, lstm_state_bw, FLAGS.batch_size, FLAGS.num_steps)
if FLAGS.crf:
Fscore = crf_eval(sess, validate, validate_model, FLAGS.batch_size, FLAGS.num_steps, FLAGS.eval_path, FLAGS.eval_script_path)
else:
Fscore = evaluate(sess, validate, validate_model, FLAGS.batch_size, FLAGS.num_steps, FLAGS.eval_path)
if Fscore > current_best_Fscore:
current_best_Fscore = Fscore
print "**Results on test set with current best F:", current_best_Fscore
crf_eval(sess, test, test_model, FLAGS.batch_size, FLAGS.num_steps, FLAGS.eval_path,
FLAGS.eval_script_path)
saver.save(sess, FLAGS.checkpoint_path)
print "Model saved!"
new_learning_rate = FLAGS.learning_rate / (1 + FLAGS.decay_rate * (epoch + 1))
sess.run(train_model.learning_rate.assign(new_learning_rate))
end_time = time.time()
print "Epoch training time:", end_time - start_time
