def train(word2vec, dataset, parameters, class_weights): modeldir = os.path.join(parameters["runs_dir"], parameters["model_name"]) if not os.path.exists(modeldir): os.mkdir(modeldir) logdir = os.path.join(modeldir, "log") if not os.path.exists(logdir): os.mkdir(logdir) logdir_train = os.path.join(logdir, "train") if not os.path.exists(logdir_train): os.mkdir(logdir_train) logdir_test = os.path.join(logdir, "test") if not os.path.exists(logdir_test): os.mkdir(logdir_test) # logdir_dev = os.path.join(logdir, "dev") # if not os.path.exists(logdir_dev): # os.mkdir(logdir_dev) savepath = os.path.join(modeldir, "save") #device_string = "/gpu:{}".format(parameters["gpu"]) if parameters["gpu"] else "/cpu:0" device_string = "/cpu:0" with tf.device(device_string): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) config_proto = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options) sess = tf.Session(config=config_proto) headline_ph = tf.placeholder(tf.float32, shape=[ parameters["sequence_length"], None, parameters["embedding_dim"] ], name="headline") body_ph = tf.placeholder(tf.float32, shape=[ parameters["sequence_length"], None, parameters["embedding_dim"] ], name="body") targets_ph = tf.placeholder(tf.int32, shape=[None], name="targets") keep_prob_ph = tf.placeholder(tf.float32, name="keep_prob") _projecter = TensorFlowTrainable() projecter = _projecter.get_4Dweights( filter_height=1, filter_width=parameters["embedding_dim"], in_channels=1, out_channels=parameters["num_units"], name="projecter") optimizer = tf.train.AdamOptimizer( learning_rate=parameters["learning_rate"], name="ADAM", beta1=0.9, beta2=0.999) with tf.variable_scope(name_or_scope="headline"): headline = RNN(cell=LSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], projecter=projecter, keep_prob=keep_prob_ph, class_weights=class_weights) headline.process(sequence=headline_ph) with tf.variable_scope(name_or_scope="body"): body = RNN(cell=AttentionLSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], hiddens=headline.hiddens, states=headline.states, projecter=projecter, keep_prob=keep_prob_ph, class_weights=class_weights) body.process(sequence=body_ph) loss, loss_summary, accuracy, accuracy_summary = body.loss( targets=targets_ph) weight_decay = tf.reduce_sum([ tf.reduce_sum(parameter) for parameter in headline.parameters + body.parameters ]) global_loss = loss + parameters["weight_decay"] * weight_decay train_summary_op = tf.summary.merge([loss_summary, accuracy_summary]) train_summary_writer = tf.summary.FileWriter(logdir_train, sess.graph) test_summary_op = tf.summary.merge([loss_summary, accuracy_summary]) test_summary_writer = tf.summary.FileWriter(logdir_test) saver = tf.train.Saver(max_to_keep=10) summary_writer = tf.summary.FileWriter(logdir) tf.train.write_graph(sess.graph_def, modeldir, "graph.pb", as_text=False) loader = tf.train.Saver(tf.global_variables()) optimizer = tf.train.AdamOptimizer( learning_rate=parameters["learning_rate"], name="ADAM", beta1=0.9, beta2=0.999) train_op = optimizer.minimize(global_loss) sess.run(tf.global_variables_initializer()) batcher = Batcher(word2vec=word2vec) train_batches = batcher.batch_generator( dataset=dataset["train"], num_epochs=parameters["num_epochs"], batch_size=parameters["batch_size"]["train"], sequence_length=parameters["sequence_length"]) num_step_by_epoch = int( math.ceil( len(dataset["train"]["targets"]) / parameters["batch_size"]["train"])) for train_step, (train_batch, epoch) in enumerate(train_batches): feed_dict = { headline_ph: np.transpose(train_batch["headline"], (1, 0, 2)), body_ph: np.transpose(train_batch["body"], (1, 0, 2)), targets_ph: train_batch["targets"], keep_prob_ph: parameters["keep_prob"], } _, summary_str, train_loss, train_accuracy = sess.run( [train_op, train_summary_op, loss, accuracy], feed_dict=feed_dict) train_summary_writer.add_summary(summary_str, train_step) if train_step % 10 == 0: sys.stdout.write( "\rTRAIN | epoch={0}/{1}, step={2}/{3} | loss={4:.2f}, accuracy={5:.2f}% " .format(epoch + 1, parameters["num_epochs"], train_step % num_step_by_epoch, num_step_by_epoch, train_loss, 100. * train_accuracy)) sys.stdout.flush() if train_step % 500 == 0: test_batches = batcher.batch_generator( dataset=dataset["test"], num_epochs=1, batch_size=parameters["batch_size"]["test"], sequence_length=parameters["sequence_length"]) for test_step, (test_batch, _) in enumerate(test_batches): feed_dict = { headline_ph: np.transpose(test_batch["headline"], (1, 0, 2)), body_ph: np.transpose(test_batch["body"], (1, 0, 2)), targets_ph: test_batch["targets"], keep_prob_ph: 1., } summary_str, test_loss, test_accuracy = sess.run( [test_summary_op, loss, accuracy], feed_dict=feed_dict) print "\nTEST | loss={0:.2f}, accuracy={1:.2f}% ".format( test_loss, 100. * test_accuracy) print "" test_summary_writer.add_summary(summary_str, train_step) break if train_step % 5000 == 0: saver.save(sess, save_path=savepath, global_step=train_step) print ""
def model_load(word2vec, dataset, data_ids, parameters): model_number = input("model num:") with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)) as sess: saver = tf.train.import_meta_graph("../runs/attention_lstm/save-{}.meta".format(model_number)) saver.restore(sess, "../runs/attention_lstm/save-{}".format(model_number)) graph = tf.get_default_graph() headline = graph.get_tensor_by_name("headline:0") body = graph.get_tensor_by_name("body:0") targets = graph.get_tensor_by_name("targets:0") keep_prob = graph.get_tensor_by_name("keep_prob:0") batcher = Batcher(word2vec=word2vec) test_batches = batcher.batch_generator(dataset=dataset["test"], data_ids=data_ids["test"], num_epochs=1, batch_size=1000, sequence_length=parameters["sequence_length"], return_body=True) for test_step, (test_batch,_) in enumerate(test_batches): feed_dict = { headline: np.transpose(test_batch["headline"], (1, 0, 2)), body: np.transpose(test_batch["body"], (1, 0, 2)), targets: test_batch["targets"], keep_prob: 1., } accuracy_op = graph.get_tensor_by_name("accuracy/Mean:0") predictions_op = graph.get_tensor_by_name("accuracy/ToInt32:0") test_accuracy, predictions = sess.run([accuracy_op, predictions_op], feed_dict=feed_dict) print"\nTEST | accuracy={0:.2f}% ".format(100.*test_accuracy) print "prediction={0}".format(predictions) predictions_name = [] test_predictions = map(str,predictions) for predictions_num in range(len(test_predictions)): #if test_predictions[predictions_num] == "0": #predictions_name.append(["neutral"]) #if test_predictions[predictions_num] == "1": #predictions_name.append(["entailment"]) #if test_predictions[predictions_num] == "2": #predictions_name.append(["contradiction"]) #if test_predictions[predictions_num] == "3": #predictions_name.append(["unrelated"]) if test_predictions[predictions_num] == "0": predictions_name.append(["True"]) if test_predictions[predictions_num] == "1": predictions_name.append(["False"]) with open('../runs/attention_lstm/log/predictions.csv', "w") as f_predictions: writer_predictions = csv.writer(f_predictions, lineterminator="\n") writer_predictions.writerow("0") writer_predictions.writerows(predictions_name) alphas_values = [] for i in range(parameters["sequence_length"]-1): num = str(3*i+5) alphas_op = graph.get_tensor_by_name("body_1/ExpandDims_{}:0".format(num)) alphas_values.append(sess.run(alphas_op, feed_dict=feed_dict)) for j in range(parameters["sequence_length"]-1): if j==0: attention_matrix = np.array(alphas_values[j]) else: attention_matrix = np.append(attention_matrix, np.array(alphas_values[j]),axis = 0) attention_matrix = np.matrix(attention_matrix) df_headlines = pd.read_csv(os.path.join("../runs/attention_lstm/log/", "headlines.csv"), delimiter=",") df_bodies = pd.read_csv(os.path.join("../runs/attention_lstm/log/", "bodies.csv"), delimiter=",") df_headlines = df_headlines.dropna(axis=1) df_bodies = df_bodies.dropna(axis=1) header_headlines = range(len(df_headlines.columns)) header_headlines = map(str,header_headlines) header_bodies = range(len(df_bodies.columns)) header_bodies = map(str,header_bodies) headlines = df_headlines[header_headlines] bodies = df_bodies[header_bodies] resize_row_attention_matrix = np.delete(attention_matrix, np.s_[len(df_headlines.columns):parameters["sequence_length"]], 1) resize_line_attention_matrix = np.delete(resize_row_attention_matrix, np.s_[len(df_bodies.columns):parameters["sequence_length"]-1], 0) fig = plt.figure() ax = fig.add_subplot(1,1,1) ax.set_aspect('equal') plt.imshow(resize_line_attention_matrix, interpolation='nearest', cmap=plt.cm.Greys) plt.yticks(np.arange(0,len(bodies.ix[0])), bodies.ix[0]) plt.xticks(np.arange(0,len(headlines.ix[0])), headlines.ix[0]) plt.ylabel('articlebody',fontsize=18) plt.xlabel('headline',fontsize=18) plt.colorbar() plt.show() break
def test(word2vec, dataset, parameters, loadpath): print "1" device_string = "/gpu:{}".format( parameters["gpu"]) if parameters["gpu"] else "/cpu:0" with tf.device(device_string): print "2" gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) config_proto = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options) sess = tf.Session(config=config_proto) premises_ph = tf.placeholder(tf.float32, shape=[ parameters["sequence_length"], None, parameters["embedding_dim"] ], name="premises") hypothesis_ph = tf.placeholder(tf.float32, shape=[ parameters["sequence_length"], None, parameters["embedding_dim"] ], name="hypothesis") targets_ph = tf.placeholder(tf.int32, shape=[None], name="targets") keep_prob_ph = tf.placeholder(tf.float32, name="keep_prob") _projecter = TensorFlowTrainable() projecter = _projecter.get_4Dweights( filter_height=1, filter_width=parameters["embedding_dim"], in_channels=1, out_channels=parameters["num_units"], name="projecter") with tf.variable_scope(name_or_scope="premise"): premise = RNN(cell=LSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], projecter=projecter, keep_prob=keep_prob_ph) premise.process(sequence=premises_ph) with tf.variable_scope(name_or_scope="hypothesis"): hypothesis = RNN(cell=AttentionLSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], hiddens=premise.hiddens, states=premise.states, projecter=projecter, keep_prob=keep_prob_ph) hypothesis.process(sequence=hypothesis_ph) loss, loss_summary, accuracy, accuracy_summary = hypothesis.loss( targets=targets_ph) loader = tf.train.Saver() loader.restore(sess, loadpath) batcher = Batcher(word2vec=word2vec, settings=parameters) test_batches = batcher.batch_generator( dataset=dataset["test"], num_epochs=1, batch_size=parameters["batch_size"]["test"], sequence_length=parameters["sequence_length"]) print "2.5" for test_step, (test_batch, _) in enumerate(test_batches): print "3" feed_dict = { premises_ph: np.transpose(test_batch["premises"], (1, 0, 2)), hypothesis_ph: np.transpose(test_batch["hypothesis"], (1, 0, 2)), targets_ph: test_batch["targets"], keep_prob_ph: 1., } test_loss, test_accuracy = sess.run([loss, accuracy], feed_dict=feed_dict) print "\nTEST | loss={0:.2f}, accuracy={1:.2f}% ".format( test_loss, 100. * test_accuracy) print ""
def train(word2vec, dataset, parameters): modeldir = os.path.join(parameters["runs_dir"], parameters["model_name"]) if not os.path.exists(modeldir): os.mkdir(modeldir) logdir = os.path.join(modeldir, "log") if not os.path.exists(logdir): os.mkdir(logdir) logdir_train = os.path.join(logdir, "train") if not os.path.exists(logdir_train): os.mkdir(logdir_train) logdir_test = os.path.join(logdir, "test") if not os.path.exists(logdir_test): os.mkdir(logdir_test) logdir_dev = os.path.join(logdir, "dev") if not os.path.exists(logdir_dev): os.mkdir(logdir_dev) savepath = os.path.join(modeldir, "save") device_string = "/gpu:{}".format(parameters["gpu"]) if parameters["gpu"] else "/cpu:0" with tf.device(device_string): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) config_proto = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options) sess = tf.Session(config=config_proto) premises_ph = tf.placeholder(tf.float32, shape=[parameters["sequence_length"], None, parameters["embedding_dim"]], name="premises") hypothesis_ph = tf.placeholder(tf.float32, shape=[parameters["sequence_length"], None, parameters["embedding_dim"]], name="hypothesis") targets_ph = tf.placeholder(tf.int32, shape=[None], name="targets") keep_prob_ph = tf.placeholder(tf.float32, name="keep_prob") _projecter = TensorFlowTrainable() projecter = _projecter.get_4Dweights(filter_height=1, filter_width=parameters["embedding_dim"], in_channels=1, out_channels=parameters["num_units"], name="projecter") optimizer = tf.train.AdamOptimizer(learning_rate=parameters["learning_rate"], name="ADAM", beta1=0.9, beta2=0.999) with tf.variable_scope(name_or_scope="premise"): premise = RNN(cell=LSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], projecter=projecter, keep_prob=keep_prob_ph) premise.process(sequence=premises_ph) with tf.variable_scope(name_or_scope="hypothesis"): hypothesis = RNN(cell=AttentionLSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], hiddens=premise.hiddens, states=premise.states, projecter=projecter, keep_prob=keep_prob_ph) hypothesis.process(sequence=hypothesis_ph) loss, loss_summary, accuracy, accuracy_summary = hypothesis.loss(targets=targets_ph) weight_decay = tf.reduce_sum([tf.reduce_sum(parameter) for parameter in premise.parameters + hypothesis.parameters]) global_loss = loss + parameters["weight_decay"] * weight_decay train_summary_op = tf.merge_summary([loss_summary, accuracy_summary]) train_summary_writer = tf.train.SummaryWriter(logdir_train, sess.graph) test_summary_op = tf.merge_summary([loss_summary, accuracy_summary]) test_summary_writer = tf.train.SummaryWriter(logdir_test) saver = tf.train.Saver(max_to_keep=10) summary_writer = tf.train.SummaryWriter(logdir) tf.train.write_graph(sess.graph_def, modeldir, "graph.pb", as_text=False) loader = tf.train.Saver(tf.all_variables()) optimizer = tf.train.AdamOptimizer(learning_rate=parameters["learning_rate"], name="ADAM", beta1=0.9, beta2=0.999) train_op = optimizer.minimize(global_loss) sess.run(tf.initialize_all_variables()) batcher = Batcher(word2vec=word2vec) train_batches = batcher.batch_generator(dataset=dataset["train"], num_epochs=parameters["num_epochs"], batch_size=parameters["batch_size"]["train"], sequence_length=parameters["sequence_length"]) num_step_by_epoch = int(math.ceil(len(dataset["train"]["targets"]) / parameters["batch_size"]["train"])) for train_step, (train_batch, epoch) in enumerate(train_batches): feed_dict = { premises_ph: np.transpose(train_batch["premises"], (1, 0, 2)), hypothesis_ph: np.transpose(train_batch["hypothesis"], (1, 0, 2)), targets_ph: train_batch["targets"], keep_prob_ph: parameters["keep_prob"], } _, summary_str, train_loss, train_accuracy = sess.run([train_op, train_summary_op, loss, accuracy], feed_dict=feed_dict) train_summary_writer.add_summary(summary_str, train_step) if train_step % 100 == 0: sys.stdout.write("\rTRAIN | epoch={0}/{1}, step={2}/{3} | loss={4:.2f}, accuracy={5:.2f}% ".format(epoch + 1, parameters["num_epochs"], train_step % num_step_by_epoch, num_step_by_epoch, train_loss, 100. * train_accuracy)) sys.stdout.flush() if train_step % 5000 == 0: test_batches = batcher.batch_generator(dataset=dataset["test"], num_epochs=1, batch_size=parameters["batch_size"]["test"], sequence_length=parameters["sequence_length"]) for test_step, (test_batch, _) in enumerate(test_batches): feed_dict = { premises_ph: np.transpose(test_batch["premises"], (1, 0, 2)), hypothesis_ph: np.transpose(test_batch["hypothesis"], (1, 0, 2)), targets_ph: test_batch["targets"], keep_prob_ph: 1., } summary_str, test_loss, test_accuracy = sess.run([test_summary_op, loss, accuracy], feed_dict=feed_dict) print"\nTEST | loss={0:.2f}, accuracy={1:.2f}% ".format(test_loss, 100. * test_accuracy) print "" test_summary_writer.add_summary(summary_str, train_step) break if train_step % 5000 == 0: saver.save(sess, save_path=savepath, global_step=train_step) print ""
def train(word2vec, dataset, parameters): modeldir = os.path.join(parameters["runs_dir"], parameters["model_name"]) if not os.path.exists(modeldir): os.mkdir(modeldir) logdir = os.path.join(modeldir, "log") if not os.path.exists(logdir): os.mkdir(logdir) logdir_train = os.path.join(logdir, "train") if not os.path.exists(logdir_train): os.mkdir(logdir_train) logdir_test = os.path.join(logdir, "test") if not os.path.exists(logdir_test): os.mkdir(logdir_test) logdir_dev = os.path.join(logdir, "dev") if not os.path.exists(logdir_dev): os.mkdir(logdir_dev) savepath = os.path.join(modeldir, "save") device_string = "/gpu:{}".format( parameters["gpu"]) if parameters["gpu"] else "/cpu:0" with tf.device(device_string): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) config_proto = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options) sess = tf.Session(config=config_proto) premises_ph = tf.placeholder(tf.float32, shape=[ parameters["sequence_length"], None, parameters["embedding_dim"] ], name="premises") hypothesis_ph = tf.placeholder(tf.float32, shape=[ parameters["sequence_length"], None, parameters["embedding_dim"] ], name="hypothesis") targets_ph = tf.placeholder(tf.int32, shape=[None], name="targets") keep_prob_ph = tf.placeholder(tf.float32, name="keep_prob") _projecter = TensorFlowTrainable() projecter = _projecter.get_4Dweights( filter_height=1, filter_width=parameters["embedding_dim"], in_channels=1, out_channels=parameters["num_units"], name="projecter") # optimizer = tf.train.AdamOptimizer(learning_rate=parameters["learning_rate"], name="ADAM", beta1=0.9, beta2=0.999) with tf.variable_scope(name_or_scope="premise"): premise = RNN(cell=LSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], projecter=projecter, keep_prob=keep_prob_ph) premise.process(sequence=premises_ph) with tf.variable_scope(name_or_scope="hypothesis"): hypothesis = RNN(cell=AttentionLSTMCell, num_units=parameters["num_units"], embedding_dim=parameters["embedding_dim"], hiddens=premise.hiddens, states=premise.states, projecter=projecter, keep_prob=keep_prob_ph) hypothesis.process(sequence=hypothesis_ph) loss, loss_summary, accuracy, accuracy_summary = hypothesis.loss( targets=targets_ph) weight_decay = tf.reduce_sum([ tf.reduce_sum(parameter) for parameter in premise.parameters + hypothesis.parameters ]) global_loss = loss + parameters["weight_decay"] * weight_decay train_summary_op = tf.merge_summary([loss_summary, accuracy_summary]) # train_summary_op = tf.summary.merge([loss_summary, accuracy_summary]) train_summary_writer = tf.train.SummaryWriter(logdir_train, sess.graph) # train_summary_writer = tf.summary.FileWriter(logdir_train, sess.graph) # test_summary_op = tf.merge_summary([loss_summary, accuracy_summary]) dev_summary_op = tf.merge_summary([loss_summary, accuracy_summary]) # test_summary_writer = tf.train.SummaryWriter(logdir_test) dev_summary_writer = tf.train.SummaryWriter(logdir_dev) saver = tf.train.Saver(max_to_keep=10) # summary_writer = tf.train.SummaryWriter(logdir) tf.train.write_graph(sess.graph_def, modeldir, "graph.pb", as_text=False) optimizer = tf.train.AdamOptimizer( learning_rate=parameters["learning_rate"], name="ADAM", beta1=0.9, beta2=0.999) train_op = optimizer.minimize(global_loss) sess.run(tf.initialize_all_variables()) # sess.run(tf.global_variables_initializer()) batcher = Batcher(word2vec=word2vec, settings=parameters) #train_split = "train" #train_batches = batcher.batch_generator(dataset=dataset[train_split], num_epochs=parameters["num_epochs"], # batch_size=parameters["batch_size"]["train"], # sequence_length=parameters["sequence_length"]) #print("train data size: %d" % len(dataset["train"]["targets"])) #num_step_by_epoch = int(math.ceil(len(dataset[train_split]["targets"]) / parameters["batch_size"]["train"])) #best_dev_accuracy = 0 print("train data size: %d" % len(dataset["train"]["targets"])) best_dev_accuracy = 0.0 total_loss = 0.0 timestamp = time.time() for epoch in range(parameters["num_epochs"]): print("epoch %d" % epoch) train_batches = batcher.batch_generator( dataset=dataset["train"], num_epochs=1, batch_size=parameters["batch_size"]["train"], sequence_length=parameters["sequence_length"]) steps = len(dataset["train"] ["targets"]) / parameters["batch_size"]["train"] # progress bar http://stackoverflow.com/a/3002114 bar = progressbar.ProgressBar(maxval=steps / 10 + 1, widgets=[ progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage() ]) bar.start() for step, (train_batch, train_epoch) in enumerate(train_batches): feed_dict = { premises_ph: np.transpose(train_batch["premises"], (1, 0, 2)), hypothesis_ph: np.transpose(train_batch["hypothesis"], (1, 0, 2)), targets_ph: train_batch["targets"], keep_prob_ph: parameters["keep_prob"], } _, summary_str, train_loss, train_accuracy = sess.run( [train_op, train_summary_op, loss, accuracy], feed_dict=feed_dict) total_loss += train_loss train_summary_writer.add_summary(summary_str, step) if step % 100 == 0: # eval 1 random dev batch # eval 1 random dev batch dev_batches = batcher.batch_generator( dataset=dataset["dev"], num_epochs=1, batch_size=parameters["batch_size"]["dev"], sequence_length=parameters["sequence_length"]) for dev_step, (dev_batch, _) in enumerate(dev_batches): feed_dict = { premises_ph: np.transpose(dev_batch["premises"], (1, 0, 2)), hypothesis_ph: np.transpose(dev_batch["hypothesis"], (1, 0, 2)), targets_ph: dev_batch["targets"], keep_prob_ph: 1., } summary_str, dev_loss, dev_accuracy = sess.run( [dev_summary_op, loss, accuracy], feed_dict=feed_dict) dev_summary_writer.add_summary(summary_str, step) break bar.update(step / 10 + 1) bar.finish() # eval on all dev dev_batches = batcher.batch_generator( dataset=dataset["dev"], num_epochs=1, batch_size=len(dataset["dev"]["targets"]), sequence_length=parameters["sequence_length"]) dev_accuracy = 0 for dev_step, (dev_batch, _) in enumerate(dev_batches): feed_dict = { premises_ph: np.transpose(dev_batch["premises"], (1, 0, 2)), hypothesis_ph: np.transpose(dev_batch["hypothesis"], (1, 0, 2)), targets_ph: dev_batch["targets"], keep_prob_ph: 1., } summary_str, dev_loss, dev_accuracy = sess.run( [dev_summary_op, loss, accuracy], feed_dict=feed_dict) print "\nDEV full | loss={0:.2f}, accuracy={1:.2f}% ".format( dev_loss, 100. * dev_accuracy) print "" if dev_accuracy > best_dev_accuracy: saver.save(sess, save_path=savepath + '_best', global_step=(epoch + 1) * steps) break saver.save(sess, save_path=savepath, global_step=(epoch + 1) * steps) current_time = time.time() print("Iter %3d Loss %-8.3f Dev Acc %-6.2f Time %-5.2f at %s" % (epoch, total_loss, dev_accuracy, (current_time - timestamp) / 60.0, str(datetime.datetime.now()))) total_loss = 0.0 print ""