def test():
"""
Test Mode: Loads an existing model and test it on the test set
"""
# Training: use the tf default graph
with tf.Graph().as_default() and tf.device('/gpu:2'):
config = tf.ConfigProto(allow_soft_placement = True)
# Start a session
with tf.Session(config = config) as sess:
### Prepare data for training
print("Prepare vocab dict and read pretrained word embeddings ...")
vocab_dict, word_embedding_array = DataProcessor().prepare_vocab_embeddingdict()
# vocab_dict contains _PAD and _UNK but not word_embedding_array
print("Prepare test data ...")
test_data = DataProcessor().prepare_news_data(vocab_dict, data_type="test")
# Create Model with various operations
model = MY_Model(sess, len(vocab_dict)-2)
# # Initialize word embedding before training
# print("Initialize word embedding vocabulary with pretrained embeddings ...")
# sess.run(model.vocab_embed_variable.assign(word_embedding_array))
# Select the model
if (os.path.isfile(FLAGS.train_dir+"/step-a.model.ckpt.epoch-"+str(FLAGS.model_to_load))):
selected_modelpath = FLAGS.train_dir+"/step-a.model.ckpt.epoch-"+str(FLAGS.model_to_load)
else:
print("Model not found in checkpoint folder.")
exit(0)
# Reload saved model and test
print("Reading model parameters from %s" % selected_modelpath)
model.saver.restore(sess, selected_modelpath)
print("Model loaded.")
# Initialize word embedding before training
print("Initialize word embedding vocabulary with pretrained embeddings ...")
sess.run(model.vocab_embed_variable.assign(word_embedding_array))
# Test Accuracy and Prediction
print("Performance on the test data:")
FLAGS.authorise_gold_label = False
test_logits, test_labels, test_weights = batch_predict_with_a_model(test_data, model, session=sess)
test_acc = sess.run(model.final_accuracy, feed_dict={model.logits_placeholder: test_logits.eval(session=sess),
model.label_placeholder: test_labels.eval(session=sess),
model.weight_placeholder: test_weights.eval(session=sess)})
# Print Test Summary
print("Test ("+str(len(test_data.fileindices))+") accuracy= {:.6f}".format(test_acc))
# Writing test predictions and final summaries
test_data.write_prediction_summaries(test_logits, "step-a.model.ckpt.epoch-"+str(FLAGS.model_to_load), session=sess)
def train():
"""
Training Mode: Create a new model and train the network
"""
# Training: use the tf default graph
with tf.Graph().as_default() and tf.device(FLAGS.use_gpu):
config = tf.ConfigProto(allow_soft_placement=True)
# Start a session
with tf.Session(config=config) as sess:
### Prepare data for training
print("Prepare vocab dict and read pretrained word embeddings ...")
vocab_dict, word_embedding_array = DataProcessor(
).prepare_vocab_embeddingdict()
# vocab_dict contains _PAD and _UNK but not word_embedding_array
print("Prepare training data ...")
train_data = DataProcessor().prepare_news_data(
vocab_dict, data_type="training")
print("Prepare validation data ...")
validation_data = DataProcessor().prepare_news_data(
vocab_dict, data_type="validation")
print("Prepare ROUGE reward generator ...")
rouge_generator = Reward_Generator()
# Create Model with various operations
model = MY_Model(sess, len(vocab_dict) - 2)
# Start training with some pretrained model
start_epoch = 1
# selected_modelpath = FLAGS.train_dir+"/model.ckpt.epoch-"+str(start_epoch-1)
# if not (os.path.isfile(selected_modelpath)):
# print("Model not found in checkpoint folder.")
# exit(0)
# # Reload saved model and test
# print("Reading model parameters from %s" % selected_modelpath)
# model.saver.restore(sess, selected_modelpath)
# print("Model loaded.")
# Initialize word embedding before training
print(
"Initialize word embedding vocabulary with pretrained embeddings ..."
)
sess.run(model.vocab_embed_variable.assign(word_embedding_array))
########### Start (No Mixer) Training : Reinforcement learning ################
# Reward aware training as part of Reward weighted CE ,
# No Curriculam learning: No annealing, consider full document like in MRT
# Multiple Samples (include gold sample), No future reward, Similar to MRT
# During training does not use PYROUGE to avoid multiple file rewritings
# Approximate MRT with multiple pre-estimated oracle samples
# June 2017: Use Single sample from multiple oracles
###############################################################################
print(
"Start Reinforcement Training (single rollout from largest prob mass) ..."
)
for epoch in range(start_epoch, FLAGS.train_epoch_wce + 1):
print("MRT: Epoch " + str(epoch))
print("MRT: Epoch " + str(epoch) +
" : Reshuffle training document indices")
train_data.shuffle_fileindices()
print("MRT: Epoch " + str(epoch) + " : Restore Rouge Dict")
rouge_generator.restore_rouge_dict()
# Start Batch Training
step = 1
while (step * FLAGS.batch_size) <= len(train_data.fileindices):
# Get batch data as Numpy Arrays
batch_docnames, batch_docs, batch_label, batch_weight, batch_oracle_multiple, batch_reward_multiple = train_data.get_batch(
((step - 1) * FLAGS.batch_size),
(step * FLAGS.batch_size))
# print(batch_docnames)
# print(batch_label[0])
# print(batch_weight[0])
# print(batch_oracle_multiple[0])
# print(batch_reward_multiple[0])
# exit(0)
# Print the progress
if (step % FLAGS.training_checkpoint) == 0:
ce_loss_val, ce_loss_sum, acc_val, acc_sum = sess.run(
[
model.
rewardweighted_cross_entropy_loss_multisample,
model.
rewardweighted_ce_multisample_loss_summary,
model.accuracy, model.taccuracy_summary
],
feed_dict={
model.document_placeholder: batch_docs,
model.predicted_multisample_label_placeholder:
batch_oracle_multiple,
model.actual_reward_multisample_placeholder:
batch_reward_multiple,
model.label_placeholder: batch_label,
model.weight_placeholder: batch_weight
})
# Print Summary to Tensor Board
model.summary_writer.add_summary(
ce_loss_sum,
((epoch - 1) * len(train_data.fileindices) +
step * FLAGS.batch_size))
model.summary_writer.add_summary(
acc_sum,
((epoch - 1) * len(train_data.fileindices) +
step * FLAGS.batch_size))
print(
"MRT: Epoch " + str(epoch) + " : Covered " +
str(step * FLAGS.batch_size) + "/" +
str(len(train_data.fileindices)) +
" : Minibatch Reward Weighted Multisample CE Loss= {:.6f}"
.format(ce_loss_val) +
" : Minibatch training accuracy= {:.6f}".format(
acc_val))
# Run optimizer: optimize policy network
sess.run(
[model.train_op_policynet_expreward],
feed_dict={
model.document_placeholder: batch_docs,
model.predicted_multisample_label_placeholder:
batch_oracle_multiple,
model.actual_reward_multisample_placeholder:
batch_reward_multiple,
model.weight_placeholder: batch_weight
})
# Increase step
step += 1
# if step == 20:
# break
# Save Model
print("MRT: Epoch " + str(epoch) +
" : Saving model after epoch completion")
checkpoint_path = os.path.join(
FLAGS.train_dir, "model.ckpt.epoch-" + str(epoch))
model.saver.save(sess, checkpoint_path)
# Backup Rouge Dict
print("MRT: Epoch " + str(epoch) +
" : Saving rouge dictionary")
rouge_generator.save_rouge_dict()
# Performance on the validation set
print("MRT: Epoch " + str(epoch) +
" : Performance on the validation data")
# Get Predictions: Prohibit the use of gold labels
validation_logits, validation_labels, validation_weights = batch_predict_with_a_model(
validation_data, model, session=sess)
# Validation Accuracy and Prediction
validation_acc, validation_sum = sess.run(
[model.final_accuracy, model.vaccuracy_summary],
feed_dict={
model.logits_placeholder:
validation_logits.eval(session=sess),
model.label_placeholder:
validation_labels.eval(session=sess),
model.weight_placeholder:
validation_weights.eval(session=sess)
})
# Print Validation Summary
model.summary_writer.add_summary(
validation_sum, (epoch * len(train_data.fileindices)))
print("MRT: Epoch " + str(epoch) + " : Validation (" +
str(len(validation_data.fileindices)) +
") accuracy= {:.6f}".format(validation_acc))
# Writing validation predictions and final summaries
print("MRT: Epoch " + str(epoch) +
" : Writing final validation summaries")
validation_data.write_prediction_summaries(
validation_logits,
"model.ckpt.epoch-" + str(epoch),
session=sess)
# Extimate Rouge Scores
rouge_score = rouge_generator.get_full_rouge(
FLAGS.train_dir + "/model.ckpt.epoch-" + str(epoch) +
".validation-summary-topranked", "validation")
print("MRT: Epoch " + str(epoch) + " : Validation (" +
str(len(validation_data.fileindices)) +
") rouge= {:.6f}".format(rouge_score))
# break
print("Optimization Finished!")
def train():
"""
Training Mode: Create a new model and train the network
"""
# Training: use the tf default graph
with tf.Graph().as_default() and tf.device('/gpu:2'):
config = tf.ConfigProto(allow_soft_placement = True)
# Start a session
with tf.Session(config = config) as sess:
### Prepare data for training
print("Prepare vocab dict and read pretrained word embeddings ...")
vocab_dict, word_embedding_array = DataProcessor().prepare_vocab_embeddingdict()
# vocab_dict contains _PAD and _UNK but not word_embedding_array
print("Prepare training data ...")
train_data = DataProcessor().prepare_news_data(vocab_dict, data_type="training")
print("Prepare validation data ...")
validation_data = DataProcessor().prepare_news_data(vocab_dict, data_type="validation")
print("Prepare ROUGE reward generator ...")
rouge_generator = Reward_Generator()
# Create Model with various operations
model = MY_Model(sess, len(vocab_dict)-2)
# model = MY_Model(sess, 100)
# Initialize word embedding before training
print("Initialize word embedding vocabulary with pretrained embeddings ...")
sess.run(model.vocab_embed_variable.assign(word_embedding_array))
### STEP A : Start Pretraining the policy with Supervised Labels: Simple Cross Entropy Training
validation_epochvsrougescores = []
for epoch in range(1, FLAGS.train_epoch_crossentropy+1):
print("STEP A: Epoch "+str(epoch)+" : Start pretraining with supervised labels")
print("STEP A: Epoch "+str(epoch)+" : Reshuffle training document indices")
train_data.shuffle_fileindices()
# Start Batch Training
step = 1
while (step * FLAGS.batch_size) <= len(train_data.fileindices):
# Get batch data as Numpy Arrays
batch_docnames, batch_docs, batch_label, batch_weight = train_data.get_batch(((step-1)*FLAGS.batch_size), (step * FLAGS.batch_size))
# print(batch_docnames,batch_label)
# Run optimizer: optimize policy and reward estimator
sess.run([model.train_op_policynet_withgold], feed_dict={model.document_placeholder: batch_docs,
model.label_placeholder: batch_label,
model.weight_placeholder: batch_weight})
# Print the progress
if (step % FLAGS.training_checkpoint) == 0:
ce_loss_val, acc_val, ce_loss_sum, acc_sum = sess.run([model.cross_entropy_loss, model.accuracy, model.ce_loss_summary, model.tstepa_accuracy_summary],
feed_dict={model.document_placeholder: batch_docs,
model.label_placeholder: batch_label,
model.weight_placeholder: batch_weight})
print("STEP A: Epoch "+str(epoch)+" : Covered " + str(step*FLAGS.batch_size)+"/"+str(len(train_data.fileindices))+
" : Minibatch CE Loss= {:.6f}".format(ce_loss_val) + ", Minibatch Accuracy= {:.6f}".format(acc_val))
# Print Summary to Tensor Board
model.summary_writer.add_summary(ce_loss_sum, (epoch-1)*len(train_data.fileindices)+step*FLAGS.batch_size)
model.summary_writer.add_summary(acc_sum, (epoch-1)*len(train_data.fileindices)+step*FLAGS.batch_size)
# Increase step
step += 1
# if step == 100:
# break
# Save Model
print("STEP A: Epoch "+str(epoch)+" : Saving model after epoch completion")
checkpoint_path = os.path.join(FLAGS.train_dir, "step-a.model.ckpt.epoch-"+str(epoch))
model.saver.save(sess, checkpoint_path)
# Performance on the validation set
print("STEP A: Epoch "+str(epoch)+" : Performance on the validation data")
# Get Predictions: Prohibit the use of gold labels
FLAGS.authorise_gold_label = False
validation_logits, validation_labels, validation_weights = batch_predict_with_a_model(validation_data, model, session=sess)
FLAGS.authorise_gold_label = True
# Validation Accuracy and Prediction
validation_acc, validation_sum = sess.run([model.final_accuracy, model.vstepa_accuracy_summary], feed_dict={model.logits_placeholder: validation_logits.eval(session=sess),
model.label_placeholder: validation_labels.eval(session=sess),
model.weight_placeholder: validation_weights.eval(session=sess)})
# Print Validation Summary
model.summary_writer.add_summary(validation_sum, epoch*len(train_data.fileindices))
print("STEP A: Epoch "+str(epoch)+" : Validation ("+str(len(validation_data.fileindices))+") accuracy= {:.6f}".format(validation_acc))
# Writing validation predictions and final summaries
print("STEP A: Epoch "+str(epoch)+" : Writing final validation summaries")
validation_data.write_prediction_summaries(validation_logits, "step-a.model.ckpt.epoch-"+str(epoch), session=sess)
# Extimate Rouge Scores
rouge_score = rouge_generator.get_full_rouge(FLAGS.train_dir+"/step-a.model.ckpt.epoch-"+str(epoch)+".validation-summary-rankedtop3", "validation")
print("STEP A: Epoch "+str(epoch)+" : Validation ("+str(len(validation_data.fileindices))+") rouge= {:.6f}".format(rouge_score))
# Store validation rouge scores
validation_epochvsrougescores.append([rouge_score, epoch])
# break
print(validation_epochvsrougescores)
print("Optimization Finished!")