def main(flags): current_time = time.strftime("%m/%d/%H/%M/%S") train_logdir = os.path.join(flags.logdir, "image", current_time) test_logdir = os.path.join(flags.logdir, "test", current_time) train = pd.read_csv(flags.data_dir) num_train = train.shape[0] test = pd.read_csv(flags.test_dir) num_test = test.shape[0] tf.reset_default_graph() X = tf.placeholder(tf.float32, shape = [None,h,w,c_image],name = 'X') y = tf.placeholder(tf.float32,shape = [None,h,w,c_label], name = 'y') mode = tf.placeholder(tf.bool, name='mode') pred = model.unet(X,mode) if flags.is_cross_entropy: loss = loss_CE(pred,y) CE_op = loss_CE(pred, y) tf.summary.scalar("CE", CE_op) else: loss = -loss_IOU(pred,y) IOU_op = loss_IOU(pred, y) tf.summary.scalar('IOU:', IOU_op) global_step = tf.Variable(0, dtype=tf.int64, trainable=False, name='global_step') update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) learning_rate = tf.train.exponential_decay(flags.learning_rate, global_step, tf.cast(num_train / flags.batch_size * flags.decay_step, tf.int32), flags.decay_rate, staircase=True) with tf.control_dependencies(update_ops): training_op = train_op(loss,learning_rate) train_csv = tf.train.string_input_producer(['data_image.csv']) test_csv = tf.train.string_input_producer(['data_test.csv']) train_image, train_label = read_csv(train_csv,augmentation=True) test_image, test_label = read_csv(test_csv,augmentation=False) #batch_size是返回的一个batch样本集的样本个数。capacity是队列中的容量 X_train_batch_op, y_train_batch_op = tf.train.shuffle_batch([train_image, train_label],batch_size = flags.batch_size, capacity = flags.batch_size*5,min_after_dequeue = flags.batch_size*2, allow_smaller_final_batch = True) X_test_batch_op, y_test_batch_op = tf.train.batch([test_image, test_label],batch_size = flags.batch_size, capacity = flags.batch_size*2,allow_smaller_final_batch = True) print('Shuffle batch done') #tf.summary.scalar('loss/Cross_entropy', CE_op) tf.add_to_collection('inputs', X) tf.add_to_collection('inputs', mode) tf.add_to_collection('pred', pred) tf.summary.image('Input Image:', X) tf.summary.image('Label:', y) tf.summary.image('Predicted Image:', pred) tf.summary.scalar("learning_rate", learning_rate) # 添加任意shape的Tensor,统计这个Tensor的取值分布 tf.summary.histogram('Predicted Image:', pred) #添加一个操作,代表执行所有summary操作,这样可以避免人工执行每一个summary op summary_op = tf.summary.merge_all() with tf.Session() as sess: train_writer = tf.summary.FileWriter(train_logdir, sess.graph) test_writer = tf.summary.FileWriter(test_logdir) init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver() if os.path.exists(flags.model_dir) and tf.train.checkpoint_exists(flags.model_dir): latest_check_point = tf.train.latest_checkpoint(flags.model_dir) saver.restore(sess, latest_check_point) else: print('No model') try: os.rmdir(flags.model_dir) except Exception as e: print(e) os.mkdir(flags.model_dir) try: #global_step = tf.train.get_global_step(sess.graph) #使用tf.train.string_input_producer(epoch_size, shuffle=False),会默认将QueueRunner添加到全局图中, #我们必须使用tf.train.start_queue_runners(sess=sess),去启动该线程。要在session当中将该线程开启,不然就会挂起。然后使用coord= tf.train.Coordinator()去做一些线程的同步工作, #否则会出现运行到sess.run一直卡住不动的情况。 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) for epoch in range(flags.epochs): for step in range(0,num_train,flags.batch_size): X_train, y_train = sess.run([X_train_batch_op,y_train_batch_op]) if flags.is_cross_entropy: _,step_ce,step_summary,global_step_value = sess.run([training_op,CE_op,summary_op,global_step],feed_dict={X:X_train,y:y_train,mode:True}) train_writer.add_summary(step_summary,global_step_value) print('epoch:{} step:{} loss_CE:{}'.format(epoch+1, global_step_value, step_ce)) else: _,step_iou,step_summary,global_step_value = sess.run([training_op, IOU_op, summary_op, global_step],feed_dict={X: X_train, y: y_train, mode: True}) train_writer.add_summary(step_summary, global_step_value) print('epoch:{} step:{} loss_IOU:{}'.format(epoch + 1, global_step_value, step_iou)) for step in range(0,num_test,flags.batch_size): if flags.is_cross_entropy: X_test, y_test = sess.run([X_test_batch_op,y_test_batch_op]) step_ce,step_summary = sess.run([CE_op,summary_op],feed_dict={X: X_test,y:y_test,mode:False}) test_writer.add_summary(step_summary,epoch * (num_train // flags.batch_size) + step // flags.batch_size * num_train // num_test) print('Test loss_CE:{}'.format(step_ce)) else: X_test, y_test = sess.run([X_test_batch_op, y_test_batch_op]) step_iou,step_summary = sess.run([IOU_op,summary_op],feed_dict={X: X_test, y: y_test, mode: False}) test_writer.add_summary(step_summary,epoch * (num_train // flags.batch_size) + step // flags.batch_size * num_train // num_test) print('Test loss_IOU:{}'.format(step_iou)) saver.save(sess, '{}/model.ckpt'.format(flags.model_dir)) finally: coord.request_stop() coord.join(threads) saver.save(sess, "{}/model.ckpt".format(flags.model_dir))
def train(): if not os.path.isfile(train_data_pickle): # trainig data train_features, train_labels = features(['fold0', 'fold1', 'fold2']) traindata = TrainData(train_features, train_labels) with open(train_data_pickle, mode='wb') as f: pickle.dump(traindata, f) else: print("loading: %s" % (train_data_pickle)) with open(train_data_pickle, mode='rb') as f: traindata = pickle.load(f) train_features = traindata.train_inputs train_labels = traindata.train_targets if not os.path.isfile(test_data_pickle): test_features, test_labels = features(['fold3']) testdata = TestData(test_features, test_labels) with open(test_data_pickle, mode='wb') as f: pickle.dump(testdata, f) else: print("loading: %s" % (test_data_pickle)) with open(test_data_pickle, mode='rb') as f: testdata = pickle.load(f) test_features = testdata.test_inputs test_labels = testdata.test_targets # TODO change to use train and test train_labels = one_hot_encode(train_labels) test_labels = one_hot_encode(test_labels) # random train and test sets. train_test_split = np.random.rand(len(train_features)) < 0.70 train_x = train_features[train_test_split] train_y = train_labels[train_test_split] test_x = train_features[~train_test_split] test_y = train_labels[~train_test_split] n_dim = train_features.shape[1] print("input dim: %s" % (n_dim)) # create placeholder X = tf.placeholder(tf.float32, [None, n_dim]) Y = tf.placeholder(tf.float32, [None, FLAGS.num_classes]) # build graph logits = model.inference(X, n_dim) weights = tf.all_variables() saver = tf.train.Saver(weights) # create loss loss = model.loss(logits, Y) tf.scalar_summary('loss', loss) accracy = model.accuracy(logits, Y) tf.scalar_summary('test accuracy', accracy) # train operation train_op = model.train_op(loss) # variable initializer init = tf.initialize_all_variables() # get Session sess = tf.Session() # sumary merge and writer merged = tf.merge_all_summaries() train_writer = tf.train.SummaryWriter(FLAGS.summaries_dir) # initialize sess.run(init) for step in xrange(MAX_STEPS): t_pred = sess.run(tf.argmax(logits, 1), feed_dict={X: train_features}) t_true = sess.run(tf.argmax(train_labels, 1)) print("train samples pred: %s" % t_pred[:30]) print("train samples target: %s" % t_true[:30]) print('Train accuracy: ', sess.run(accracy, feed_dict={ X: train_x, Y: train_y })) for epoch in xrange(training_epochs): summary, logits_val, _, loss_val = sess.run( [merged, logits, train_op, loss], feed_dict={ X: train_x, Y: train_y }) train_writer.add_summary(summary, step) print("step:%d, loss: %s" % (step, loss_val)) y_pred = sess.run(tf.argmax(logits, 1), feed_dict={X: test_x}) y_true = sess.run(tf.argmax(test_y, 1)) print("test samples pred: %s" % y_pred[:10]) print("test samples target: %s" % y_true[:10]) accracy_val = sess.run([accracy], feed_dict={X: test_x, Y: test_y}) # print('Test accuracy: ', accracy_val) # train_writer.add_summary(accracy_val, step) p, r, f, s = precision_recall_fscore_support(y_true, y_pred, average='micro') print("F-score: %s" % f) if step % 1000 == 0: saver.save(sess, FLAGS.ckpt_dir, global_step=step)
FLAGS.batch_size = 8 FLAGS.is_training = True FLAGS.minimal_summaries = True FLAGS.initial_learning_rate = 1e-4 FLAGS.stddev = 5e-2 FLAGS.weight_decay = 5e-5 # global step global_step = tf.Variable(0, trainable=False) # get training batch images, labels = model.get_train_input() # inference outputs = model.inference_resnet(images) # calculate total loss loss = model.loss(outputs, labels) # train operation train_op = model.train_op(loss, global_step) # initialize init = tf.initialize_all_variables() # Start running operations on the Graph. config = tf.ConfigProto(log_device_placement=False) config.gpu_options.allow_growth = True sess = tf.InteractiveSession(config=config) sess.run(init) # resnet saver # saver_resnet = tf.train.Saver(tf.trainable_variables()) saver_resnet = tf.train.Saver( [v for v in tf.trainable_variables() if not "fc" in v.name]) saver_resnet.restore(sess, FLAGS.resnet_param) # start queue runner tf.train.start_queue_runners(sess=sess) # pass once
def main(flags): current_time = time.strftime("%m/%d/%H/%M/%S") train_logdir = os.path.join(flags.logdir, "pig", current_time) test_logdir = os.path.join(flags.logdir, "test", current_time) train = pd.read_csv(flags.data_dir) num_train = train.shape[0] test = pd.read_csv(flags.test_dir) num_test = test.shape[0] tf.reset_default_graph() X = tf.placeholder(tf.float32, shape=[flags.batch_size, h, w, c_image], name='X') y = tf.placeholder(tf.float32, shape=[flags.batch_size, h, w, c_label], name='y') mode = tf.placeholder(tf.bool, name='mode') score_dsn6_up, score_dsn5_up, score_dsn4_up, score_dsn3_up, score_dsn2_up, score_dsn1_up, upscore_fuse = model.unet( X, mode) #print(score_dsn6_up.get_shape().as_list()) loss6 = loss_CE(score_dsn6_up, y) loss5 = loss_CE(score_dsn5_up, y) loss4 = loss_CE(score_dsn4_up, y) loss3 = loss_CE(score_dsn3_up, y) loss2 = loss_CE(score_dsn2_up, y) loss1 = loss_CE(score_dsn1_up, y) loss_fuse = loss_CE(upscore_fuse, y) tf.summary.scalar("CE6", loss6) tf.summary.scalar("CE5", loss5) tf.summary.scalar("CE4", loss4) tf.summary.scalar("CE3", loss3) tf.summary.scalar("CE2", loss2) tf.summary.scalar("CE1", loss1) tf.summary.scalar("CE_fuse", loss_fuse) Loss = loss6 + loss5 + loss4 + loss3 + loss2 + 2 * loss1 + loss_fuse tf.summary.scalar("CE_total", Loss) global_step = tf.Variable(0, dtype=tf.int64, trainable=False, name='global_step') update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) learning_rate = tf.train.exponential_decay(flags.learning_rate, global_step, decay_steps=flags.decay_step, decay_rate=flags.decay_rate, staircase=True) with tf.control_dependencies(update_ops): training_op = train_op(Loss, learning_rate) train_csv = tf.train.string_input_producer(['pig1.csv']) test_csv = tf.train.string_input_producer(['pigtest1.csv']) train_image, train_label = read_csv(train_csv, augmentation=True) test_image, test_label = read_csv(test_csv, augmentation=False) #batch_size是返回的一个batch样本集的样本个数。capacity是队列中的容量 X_train_batch_op, y_train_batch_op = tf.train.shuffle_batch( [train_image, train_label], batch_size=flags.batch_size, capacity=flags.batch_size * 5, min_after_dequeue=flags.batch_size * 2, allow_smaller_final_batch=True) X_test_batch_op, y_test_batch_op = tf.train.batch( [test_image, test_label], batch_size=flags.batch_size, capacity=flags.batch_size * 2, allow_smaller_final_batch=True) print('Shuffle batch done') #tf.summary.scalar('loss/Cross_entropy', CE_op) score_dsn6_up = tf.nn.sigmoid(score_dsn6_up) score_dsn5_up = tf.nn.sigmoid(score_dsn5_up) score_dsn4_up = tf.nn.sigmoid(score_dsn4_up) score_dsn3_up = tf.nn.sigmoid(score_dsn3_up) score_dsn2_up = tf.nn.sigmoid(score_dsn2_up) score_dsn1_up = tf.nn.sigmoid(score_dsn1_up) upscore_fuse = tf.nn.sigmoid(upscore_fuse) print(upscore_fuse.get_shape().as_list()) tf.add_to_collection('inputs', X) tf.add_to_collection('inputs', mode) tf.add_to_collection('score_dsn6_up', score_dsn6_up) tf.add_to_collection('score_dsn5_up', score_dsn5_up) tf.add_to_collection('score_dsn4_up', score_dsn4_up) tf.add_to_collection('score_dsn3_up', score_dsn3_up) tf.add_to_collection('score_dsn2_up', score_dsn2_up) tf.add_to_collection('score_dsn1_up', score_dsn1_up) tf.add_to_collection('upscore_fuse', upscore_fuse) tf.summary.image('Input Image:', X) tf.summary.image('Label:', y) tf.summary.image('score_dsn6_up:', score_dsn6_up) tf.summary.image('score_dsn5_up:', score_dsn5_up) tf.summary.image('score_dsn4_up:', score_dsn4_up) tf.summary.image('score_dsn3_up:', score_dsn3_up) tf.summary.image('score_dsn2_up:', score_dsn2_up) tf.summary.image('score_dsn1_up:', score_dsn1_up) tf.summary.image('upscore_fuse:', upscore_fuse) tf.summary.scalar("learning_rate", learning_rate) # 添加任意shape的Tensor,统计这个Tensor的取值分布 tf.summary.histogram('score_dsn1_up:', score_dsn1_up) tf.summary.histogram('score_dsn2_up:', score_dsn2_up) tf.summary.histogram('score_dsn3_up:', score_dsn3_up) tf.summary.histogram('score_dsn4_up:', score_dsn4_up) tf.summary.histogram('score_dsn5_up:', score_dsn5_up) tf.summary.histogram('score_dsn6_up:', score_dsn6_up) tf.summary.histogram('upscore_fuse:', upscore_fuse) #添加一个操作,代表执行所有summary操作,这样可以避免人工执行每一个summary op summary_op = tf.summary.merge_all() with tf.Session() as sess: train_writer = tf.summary.FileWriter(train_logdir, sess.graph) test_writer = tf.summary.FileWriter(test_logdir) init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver() # if not os.listdir(flags.model_dir): # print('No model') # try: # os.rmdir(flags.model_dir) # except Exception as e: # print(e) # os.mkdir(flags.model_dir) # else: # latest_check_point = tf.train.latest_checkpoint(flags.model_dir) # saver.restore(sess, latest_check_point) if os.path.exists(flags.model_dir) and tf.train.checkpoint_exists( flags.model_dir): latest_check_point = tf.train.latest_checkpoint(flags.model_dir) saver.restore(sess, latest_check_point) else: print('No model') try: os.rmdir(flags.model_dir) except Exception as e: print(e) os.mkdir(flags.model_dir) try: #global_step = tf.train.get_global_step(sess.graph) #使用tf.train.string_input_producer(epoch_size, shuffle=False),会默认将QueueRunner添加到全局图中, #我们必须使用tf.train.start_queue_runners(sess=sess),去启动该线程。要在session当中将该线程开启,不然就会挂起。然后使用coord= tf.train.Coordinator()去做一些线程的同步工作, #否则会出现运行到sess.run一直卡住不动的情况。 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) for epoch in range(flags.epochs): for step in range(0, num_train, flags.batch_size): X_train, y_train = sess.run( [X_train_batch_op, y_train_batch_op]) _, step_ce, step_summary, global_step_value = sess.run( [training_op, Loss, summary_op, global_step], feed_dict={ X: X_train, y: y_train, mode: True }) train_writer.add_summary(step_summary, global_step_value) print('epoch:{} step:{} loss_CE:{}'.format( epoch + 1, global_step_value, step_ce)) for step in range(0, num_test, flags.batch_size): X_test, y_test = sess.run( [X_test_batch_op, y_test_batch_op]) step_ce, step_summary = sess.run([Loss, summary_op], feed_dict={ X: X_test, y: y_test, mode: False }) test_writer.add_summary( step_summary, epoch * (num_train // flags.batch_size) + step // flags.batch_size * num_train // num_test) print('Test loss_CE:{}'.format(step_ce)) saver.save(sess, '{}/model.ckpt'.format(flags.model_dir)) finally: coord.request_stop() coord.join(threads) saver.save(sess, "{}/model.ckpt".format(flags.model_dir))
def train_nvidia(): with tf.Graph().as_default(): FLAGS.batch_size = 512 FLAGS.minimal_summaries = False FLAGS.initial_learning_rate = 1e-3 FLAGS.stddev = 0.1 FLAGS.weight_decay = 1e-5 # global step global_step = tf.Variable(0, trainable=False) with tf.device("/gpu:" + FLAGS.gpu_id): # train net train_images, train_labels = model.get_train_input() outputs_train = model.inference_nvidianet2(train_images) loss_train = model.loss(outputs_train, train_labels) # validation net val_images, val_labels = model.get_val_input() tf.get_variable_scope().reuse_variables() outputs_val = model.inference_nvidianet(val_images) loss_val = model.loss(outputs_val, val_labels) # train operation train_op = model.train_op(loss_train, global_step) # saver saver = tf.train.Saver(tf.all_variables()) # summarize if not FLAGS.minimal_summaries: tf.image_summary('images', train_images) for var in tf.trainable_variables(): tf.histogram_summary(var.op.name, var) summary_op = tf.merge_all_summaries() # initialize init = tf.initialize_all_variables() # Start running operations on the Graph. config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True) config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(init) print('network initialized') # start queue runner tf.train.start_queue_runners(sess=sess) # write summary summary_writer = tf.train.SummaryWriter(FLAGS.logdir, sess.graph) max_iter = int(FLAGS.max_epoch * FLAGS.num_examples_train / FLAGS.batch_size) print('total iteration:', str(max_iter)) for step in xrange(max_iter): start_time = time.time() _, loss_value = sess.run([train_op, loss_train]) # loss_value = sess.run(loss) # test inference time only duration = time.time() - start_time assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step % 200 == 0: val_iter = 16 val_losses = np.zeros((val_iter)) for ival in range(val_iter): val_loss_value = sess.run(loss_val) val_losses[ival] = val_loss_value print("mean validation loss:", np.mean(val_losses)) if step % 10 == 0: num_examples_per_step = FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ('%s: step %d, loss = %.2f' ' (%.1f examples/sec; %.3f sec/batch)') print(format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch)) if step % 200 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) # Save the model checkpoint periodically. if step % 1000 == 0 or (step + 1) == max_iter: checkpoint_path = os.path.join(FLAGS.logdir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
path+'data/dataset3_train.tfrecords', # path+'data/dataset4_train.tfrecords', ], num_epochs=100000000) val_filename_queue = tf.train.string_input_producer(\ [path+'data/dataset1_test.tfrecords', # path+'data/dataset2_test.tfrecords', path+'data/dataset3_test.tfrecords', # path+'data/dataset4_test.tfrecords', ], num_epochs=1000000000) train_data_sets = dl.dataloader(train_filename_queue, batchsize=32) # val_data_sets = dl.dataloader(val_filename_queue, batchsize=8) image, label = train_data_sets.get_batch() logits = unet.inference(image, True, num_classes=3) loss = unet.loss(logits, label) # iou = unet.iou(logits, label) train_op = unet.train_op(loss) loss_sumary = tf.summary.scalar('loss', loss) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) saver = tf.train.Saver() # print('trainable variables:---------------------------------------') # for var in tf.trainable_variables(): # print(var.name, var.shape) with tf.Session() as sess: summary_writer = tf.summary.FileWriter(path + 'logs', sess.graph) sess.run(init_op) checkpoint_file = os.path.join(path, 'logs', 'model.ckpt') saver.save(sess, checkpoint_file, global_step=0) coord = tf.train.Coordinator()
def train_resnet(): with tf.Graph().as_default(): # set flag to training FLAGS.batch_size = 8 FLAGS.is_training = True FLAGS.minimal_summaries = False FLAGS.initial_learning_rate = 1e-3 FLAGS.stddev = 5e-2 FLAGS.weight_decay = 1e-6 # global step global_step = tf.Variable(0, trainable=False) # get training batch images, labels = model.get_train_input() # inference outputs = model.inference_resnet(images) # calculate total loss loss = model.loss(outputs, labels) # train operation train_op = model.train_op(loss, global_step) # saver saver = tf.train.Saver(tf.all_variables()) # summarize if not FLAGS.minimal_summaries: tf.image_summary('images', images) for var in tf.trainable_variables(): tf.histogram_summary(var.op.name, var) summary_op = tf.merge_all_summaries() # initialize init = tf.initialize_all_variables() # Start running operations on the Graph. config = tf.ConfigProto(log_device_placement=False) config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(init) print('network initialized') # saver_resnet = tf.train.Saver(tf.trainable_variables()) saver_resnet = tf.train.Saver( [v for v in tf.trainable_variables() if not "fc" in v.name]) saver_resnet.restore(sess, FLAGS.resnet_param) # start queue runner tf.train.start_queue_runners(sess=sess) # write summary summary_writer = tf.train.SummaryWriter(FLAGS.logdir, sess.graph) # max_iter = int(FLAGS.max_epoch * FLAGS.num_examples_train / FLAGS.batch_size) print('total iteration:', str(max_iter)) for step in xrange(max_iter): start_time = time.time() _, loss_value = sess.run([train_op, loss]) # loss_value = sess.run(loss) # test inference time only duration = time.time() - start_time assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step % 10 == 0: num_examples_per_step = FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ('%s: step %d, loss = %.2f' ' (%.1f examples/sec; %.3f sec/batch)') print(format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch)) if step % 200 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) # Save the model checkpoint periodically. if step % 1000 == 0 or (step + 1) == max_iter: checkpoint_path = os.path.join(FLAGS.logdir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
def train(): sess = tf.InteractiveSession() global_step = tf.contrib.framework.get_or_create_global_step() #Load data train_sets = PRMUDataSet("1_train_0.9") train_sets.load_data_target() n_train_samples = train_sets.get_n_types_target() print("n_train_samples = " + str(n_train_samples)) if not os.path.isfile('save/current/model.ckpt.index'): print('Create new model') x, y_ = model.input() y_conv = model.inference(x) loss = model.loss(y_conv=y_conv, y_=y_) train_step = model.train_op(loss, global_step) sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() else: print('Load exist model') saver = tf.train.import_meta_graph('save/current/model.ckpt.meta') saver.restore(sess, 'save/current/model.ckpt') learning_rate = tf.get_collection('learning_rate')[0] cross_entropy_loss = tf.get_collection('cross_entropy_loss')[0] train_step = tf.get_collection('train_step')[0] keep_prob_fc1 = tf.get_collection('keep_prob_fc1')[0] keep_prob_fc2 = tf.get_collection('keep_prob_fc2')[0] x = tf.get_collection('x')[0] y_ = tf.get_collection('y_')[0] y_conv = tf.get_collection('y_conv')[0] correct_prediction = tf.equal(tf.arg_max(y_conv, 1), tf.arg_max(y_, 1)) true_pred = tf.reduce_sum(tf.cast(correct_prediction, dtype=tf.float32)) for epoch in range(nb_epochs): print("Epoch: %d" % epoch) print("Learning rate: " + str(learning_rate.eval())) avg_ttl = [] nb_true_pred = 0 # shuffle data perm = np.random.permutation(n_train_samples) print('x_train = ' + str(perm)) if epoch % 10 == 0: saver.save(sess, "save/current/model.ckpt") for i in range(0, n_train_samples, batch_size): x_batch = train_sets.data[perm[i:(i + batch_size)]] #print('x_batch['+str(i)+'] = '+str(perm[i:(i+batch_size)])) batch_target = np.asarray(train_sets.target[perm[i:i + batch_size]]) y_batch = np.zeros((len(x_batch), 46), dtype=np.float32) y_batch[np.arange(len(x_batch)), batch_target] = 1.0 #print('batch_target = '+str(batch_target)) ttl, _ = sess.run( [cross_entropy_loss, train_step], feed_dict={ x: x_batch, y_: y_batch, keep_prob_fc1: (1 - drop_out_prob), keep_prob_fc2: (1 - drop_out_prob) }) avg_ttl.append(ttl * len(x_batch)) nb_true_pred += true_pred.eval(feed_dict={ x: x_batch, y_: y_batch, keep_prob_fc1: 1, keep_prob_fc2: 1 }) print('Batch ' + str(i) + ' : Number of true prediction: ' + str(nb_true_pred)) print("Average total loss: " + str(np.sum(avg_ttl) / n_train_samples)) print("Train accuracy: " + str(nb_true_pred * 1.0 / n_train_samples))