def train_running(): with tf.name_scope('input'): train_batch, train_label_batch, _ = input_data.get_batch(train_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_batch, val_label_batch, _ = input_data.get_batch(val_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) model = models.model(x, N_CLASSES) model.AlexNet() logits = model.fc3 loss = tools.loss(logits, y_) acc = tools.accuracy(logits, y_) train_op = tools.optimize(loss, LEARNING_RATE) with tf.Session() as sess: saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, acc], feed_dict={x: tra_images, y_: tra_labels}) if step % 50 == 0: print('Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={x: tra_images, y_: tra_labels}) train_writer.add_summary(summary_str, step) # if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, acc], feed_dict={x: val_images, y_: val_labels}) print('** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={x: val_images, y_: val_labels}) val_writer.add_summary(summary_str, step) # if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def run(batch_size=300, learning_rate=0.01): #region create network data, label = CifarInput.read_cifar10( r"C:\Projects\Programming\CsDiscount\cifar-10-binary", True, batch_size, True) logit = CapsNet.CapsNet(data, batch_size) reconstruction = tools.decoder(logit) reconstruction_p = tf.placeholder(dtype=tf.float32, shape=[batch_size, 32, 32, 3]) print("Network Created") #endregion #region create optimizer global_step = tf.Variable(0, trainable=False, name="global_step") loss = tools.loss(logit, label, data, reconstruction_p, batch_size) accuracy = tools.accuracy(logit, label) train_op = tools.optimize(loss, learning_rate, global_step) print("Optimizer Created") #endregion #region create sessions, queues and savers sess = tf.Session() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) init = tf.global_variables_initializer() saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() train_summary_writer = tf.summary.FileWriter(train_log_dir) sess.run(init) print("Sessions, Queues and Savers Created") #endregion for x in range(1000): print(x) reconstruction_run = sess.run(reconstruction) sess.run(train_op, feed_dict={reconstruction_p: reconstruction_run}) if x % 5 == 0: mainwindow.newimg(reconstruction_run[0]) if x % 100 == 0: print(sess.run(accuracy)) checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, save_path=checkpoint_path, global_step=x)
def run(args_input, args_net, args_log): # Input train_file = ['data/train.tfrecords'] val_file = ['data/val.tfrecords'] train_image_batch, train_label_batch = train_batch(train_file, batch_size=64) val_image_batch, val_label_batch = val_batch(val_file, batch_size=128) x = tf.placeholder(tf.float32, shape=[None, 224, 224, 3]) y_ = tf.placeholder(tf.int16, shape=[None, 2]) # Model Creation network = net.catalogue[args_net['net']](args_net['num_classes'], args_net['weight_decay'], args_net['batch_norm_decay']) logits = network.build(x, is_training=True) loss = tools.softmax_cross_entropy_with_logits(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, args_net['learning_rate'], my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session(config=configure_session()) sess.run(init) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(args_log['train_log_dir'], sess.graph) val_summary_writer = tf.summary.FileWriter(args_log['val_log_dir'], sess.graph) try: MAX_STEP = args_net['max_step'] for step in np.arange(MAX_STEP): if coord.should_stop(): break if step == 8000: train_op = tools.optimize(loss, 0.001, my_global_step) elif step == 26000: train_op = tools.optimize(loss, 0.0001, my_global_step) train_images, train_labels = sess.run( [train_image_batch, train_label_batch]) _, train_loss, train_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: train_images, y_: train_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, train_loss, train_acc)) summary_str = sess.run(summary_op, feed_dict={ x: train_images, y_: train_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: train_images, y_: train_labels }) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(args_log['train_log_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): print('loding data............') #导入数据 with tf.name_scope('input'): train, train_label, test, test_label = Process.get_data( train_path, test_path) train_batch, train_label_batch = Process.get_batch( train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) test_batch, test_label_batch = Process.get_batch( test, test_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) print('loding batch_data complete.......') #创建placeholder作为输入和标签 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASS]) #定义模型 logits = vgg.VGG16N(x, N_CLASS, IS_PRETRAIN) #定义损失 loss = tools.loss(logits, y_) #计算准确率 accuracy = tools.accuracy(logits, y_) #全局步骤 my_global_step = tf.Variable(0, name='global_step', trainable=False) #梯度下降 train_op = tools.optimize(loss, learning_rate, my_global_step) #保存训练步骤 saver = tf.train.Saver(tf.global_variables()) #summary_op = tf.summary.merge_all() #全局变量初始操作 init = tf.global_variables_initializer() #创建sess sess = tf.Session() #全局变量操作 sess.run(init) #启动coord coord = tf.train.Coordinator() #启动队列 threads = tf.train.start_queue_runners(sess=sess, coord=coord) #一些tensorboard的可视化操作,由于会出现问题,我先注释掉了 # tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) # val_summary_writer = tf.summary.FileWriter(test_log_dir, sess.graph) print('all init has been done! start training') try: for step in np.arange(MAX_STEP): print('step + ' + str(step) + 'is now') if coord.should_stop(): break #从队列中取batch tra_images, tra_labels = sess.run([train_batch, train_label_batch]) #计算损失和准确率 _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) #如果到达10步的倍数,打印在现在的batch_size上的训练准确率 if step % 10 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) # summary_str = sess.run(summary_op) # tra_summary_writer.add_summary(summary_str, step) #如果步骤达到200的倍数,输入一些训练数据查看在训练集上的准确率 if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [test_batch, test_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) # summary_str = sess.run(summary_op) # val_summary_writer.add_summary(summary_str, step) #如果步骤达到了2000步,保存当前点的数据 if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): pre_trained_weights = './vgg16_pretrain/vgg16.npy' train_data_dir = './data/train/scene_train_images_20170904/' train_label_json = './data/train/scene_train_annotations_20170904.json' val_data_dir = './data/val/scene_validation_images_20170908/' val_label_json = './data/val/scene_validation_annotations_20170908.json' train_log_dir = './logs/train/' val_log_dir = './logs/val/' with tf.name_scope('input'): tra_images, tra_labels = input_data.get_files(train_label_json, train_data_dir) tra_image_batch, tra_label_batch = input_data.get_batch( tra_images, tra_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY, N_CLASSES) val_images, val_labels = input_data.get_files(val_label_json, val_data_dir) val_image_batch, val_label_batch = input_data.get_batch( val_images, val_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY, N_CLASSES) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) keep_prob = tf.placeholder(tf.float32) # %% logits = VGG.VGG16N(x, N_CLASSES, keep_prob, IS_PRETRAIN) # #%% # import ResNet # resnet = ResNet.ResNet() # _, logits = resnet.build(x, N_CLASSES, last_layer_type="softmax") # #%% # import InceptionV4 # inception = InceptionV4.InceptionModel(x, [BATCH_SIZE, IMG_W, IMG_H, 3], [BATCH_SIZE, N_CLASSES], keep_prob, # ckpt_path='train_model/model', model_path='saved_model/model') # logits = inception.define_model() # print('shape{}'.format(logits.shape)) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) # summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers # tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) # val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break train_images, train_labels = sess.run( [tra_image_batch, tra_label_batch]) # print(str(train_images.get_shape())) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: train_images, y_: train_labels, keep_prob: 0.2 }) if step % 50 == 0 or (step + 1) == MAX_STEP: # _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], # feed_dict={x: train_images, y_: train_labels}) print('Step: %d, loss: %.3f, accuracy: %.3f%%' % (step, tra_loss, tra_acc)) # summary_str = sess.run(summary_op) # tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: validation_images, validation_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: validation_images, y_: validation_labels, keep_prob: 1 }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) # summary_str = sess.run(summary_op) # val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): # pre_trained_weights1 = './/vgg16.npy' pre_trained_weights = './/vgg-face.mat' data_dir = '/home/hadoop/Desktop/My-TensorFlow-tutorials-master/VGG face segmentation recognition/data/segmentation/training/' train_log_dir = './/logss/train_shuffle/' val_log_dir = './/logss/va_shuffle/' # image_batch, label_batch = notMNIST_input.read_and_decode(tfrecords_file,BATCH_SIZE) image, label = notMNIST_input.get_file(data_dir) # image_batch,label_batch=notMNIST_input.get_batch(image, label, IMG_W, IMG_H, BATCH_SIZE, capacity) X = np.array(image) Y = np.array(label) kf = KFold(n_splits=10, shuffle=False) total_acc = 0 for train, test in kf.split(X, Y): tf.reset_default_graph() image_batch, label_batch = notMNIST_input.get_batch(X[train], Y[train], IMG_W, IMG_H, BATCH_SIZE, capacity, shuffle=True) image_batch_validate, label_batch_validate = notMNIST_input.get_batch( X[test], Y[test], IMG_W, IMG_H, BATCH_SIZE, capacity, shuffle=False) # print("dddd") ## print("train_index: , test_index:", (X[train],Y[train],X[test],Y[test])) print("X[train]/n", len(X[train])) print("Y[train]/n", len(Y[train])) print("X[test]", len(X[test])) print("Y[test]", len(Y[test])) #cast (1.8,3.4)float32 to (1,3)int64 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3], name='place_x') y_ = tf.placeholder(tf.int64, shape=[ BATCH_SIZE, ], name='place_y') logits = VGG.VGG16N(x, N_CLASSES, IS_PRETRAIN) print("****logits shape is ", logits.shape) loss = tools.loss(logits, y_) print("label_batch is ", y_.shape) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) #learning_rate = tf.train.exponential_decay(starter_learning_rate, my_global_step, # 2200, 0.96, staircase=True) train_op = tools.optimize(loss, starter_learning_rate, my_global_step) # train_op_vali = tools.optimize(loss_vali, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) merged_summaries = tf.summary.merge_all() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir) max_acc = 0 total_time = 0 try: for step in np.arange(MAX_STEP): if coord.should_stop(): break start_time = time.time() # with tf.Session() as sess: # for train, test in kf.split(X,Y): # image_batch,label_batch=notMNIST_input.get_batch(X[train], Y[train], IMG_W, IMG_H, BATCH_SIZE, capacity) # image_batch_validate, label_batch_validate=notMNIST_input.get_batch(X[test], Y[test], IMG_W, IMG_H, BATCH_SIZE, capacity) # label_batch = tf.cast(label_batch,dtype=tf.int64) x_train_a, y_train_a = sess.run([image_batch, label_batch]) x_test_a, y_test_a = sess.run( [image_batch_validate, label_batch_validate]) # _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy]) # tra_images,tra_labels = sess.run([image_batch, label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: x_train_a, y_: y_train_a }) if step % 10 == 0 or (step + 1) == MAX_STEP: feed_dict = {x: x_train_a, y_: y_train_a} summary_str = sess.run(summary_op, feed_dict=feed_dict) tra_summary_writer.add_summary(summary_str, step) time_elapsed = time.time() - start_time print( 'Step:%d , loss: %.2f, accuracy: %.2f%%(%.2f sec/step)' % (step, tra_loss, tra_acc * 100, time_elapsed)) total_time = total_time + time_elapsed if step % 50 == 0: print('total time is :%.2f' % (total_time)) if step % 200 == 0 or (step + 1) == MAX_STEP: val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: x_test_a, y_: y_test_a }) feed_dict = {x: x_test_a, y_: y_test_a} summary_str = sess.run(summary_op, feed_dict=feed_dict) val_summary_writer.add_summary(summary_str, step) # if cur_val_loss > max_acc: # max_acc = cur_val_loss # best_step = step # checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') # saver.save(sess, checkpoint_path, global_step=step) # val_summary_writer.add_summary(summary, step) # print("Model updated and saved in file: %s" % checkpoint_path) # print ('*************step %5d: loss %.5f, acc %.5f --- loss val %0.5f, acc val %.5f************'%(best_step,tra_loss, tra_acc, cur_val_loss, cur_val_eval)) # print( '************validate result:Step:%d , loss: %.2f, accuracy: %.2f%%(%.2f sec/step)' % (step, val_loss, val_acc * 100, time_elapsed)) if val_acc > max_acc: max_acc = val_acc checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if max_acc > total_acc: total_acc = max_acc checkpoint_path = os.path.join(val_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): with tf.name_scope('input'): train, train_label, val, val_label = input_train_val_split.get_files( train_dir, RATIO) tra_image_batch, tra_label_batch = input_train_val_split.get_batch( train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_image_batch, val_label_batch = input_train_val_split.get_batch( val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) logits = VGG.VGG16N(x, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) tools.load_with_skip(pre_trained_weights, sess, ['fc8']) print("load weights done") coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 2 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) _, summary_str = sess.run([train_op, summary_op], feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 4 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) _, summary_str = sess.run([train_op, summary_op], feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) if step % 8 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def train_running(): with tf.Graph().as_default(): with tf.name_scope('input'): mnist = input_data.read_data_sets('../MNIST_data/', one_hot=True) x = tf.placeholder(tf.float32, shape=[None, 784]) x_reshape = tf.reshape(x, [-1, 28, 28, 1]) y_ = tf.placeholder(tf.float32, [None, num_classes]) keep_prob = tf.placeholder(tf.float32) model = models.Model(x_reshape, num_classes) model.lenet5() logits = model.logits loss = tools.loss(logits, y_) regular_loss = tf.add_n(tf.get_collection('loss')) loss = loss + 1e-4 * regular_loss acc = tools.accuracy(logits, y_) train_op = tools.optimize(loss, learning_rate) with tf.Session() as sess: saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) start_time = time.time() print('Training Start...') for step in np.arange(max_step): tra_images, tra_labels = mnist.train.next_batch(batch_size) _, tra_loss, tra_acc = sess.run([train_op, loss, acc], feed_dict={ x: tra_images, y_: tra_labels, keep_prob: 0.5 }) if step % 50 == 0: print( 'Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels, keep_prob: 0.5 }) train_writer.add_summary(summary_str, step) # # if step % 200 == 0 or (step + 1) == max_step: val_loss, val_acc = sess.run( [loss, acc], feed_dict={ x: mnist.validation.images, y_: mnist.validation.labels, keep_prob: 1.0 }) print( '** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: mnist.validation.images, y_: mnist.validation.labels, keep_prob: 1.0 }) val_writer.add_summary(summary_str, step) # if step % 2000 == 0 or (step + 1) == max_step: checkpoint_path = os.path.join(model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step + 1) end_time = time.time() time_dif = end_time - start_time print('Training end...') print('Time usage: ' + str(timedelta(seconds=int(round(time_dif))))) print('Testing...') test_acc = sess.run(acc, feed_dict={ x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0 }) print('Test accuarcy: %.2f%%' % test_acc)
def train(): pre_trained_weights = r'/home/vincent/Desktop/jsl thesis/grad thesis/data/vgg16_pretrained/vgg16.npy' data_train_dir = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/train' data_test_dir = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/validation/' train_log_dir = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/logs/train' val_log_dir = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/logs/val' with tf.name_scope('input'): # tra_image_batch, tra_label_batch = input_data.read_cifar10(data_dir=data_dir, # is_train=True, # batch_size=BATCH_SIZE, # shuffle=True) # val_image_batch, val_label_batch = input_data.read_cifar10(data_dir=data_dir, # is_train=False, # batch_size=BATCH_SIZE, # shuffle=False) image_train_list, label_train_list = get_files(data_train_dir) image_val_list, label_val_list = get_files(data_test_dir) # image_batch, label_batch = get_batch(image_train_list, label_train_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) # val_image_batch, val_label_batch = get_batch(image_val_list, label_val_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) image_batch = get_batch_datasetVersion(image_train_list, label_train_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_batch = get_batch_datasetVersion(image_val_list, label_val_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) # x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) # y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) x = tf.placeholder(tf.float32, shape=[None, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[None, N_CLASSES]) logits = VGG.VGG16N(x, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() #threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) #restore older checkpoints if RESTORE_MODEL == True: print("Reading checkpoints.../n") log_dir = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/logs/train' model_name = r'model.ckpt-2000.meta' data_name = r'model.ckpt-2000' #restore Graph saver = tf.train.import_meta_graph(log_dir + os.sep + model_name) #restore paras saver.restore(sess, log_dir + os.sep + data_name) print("Loading checkpoints successfully!! /n") try: for step in np.arange(MAX_STEP): if coord.should_stop(): break #tra_images, tra_labels = sess.run([image_batch, label_batch]) tra_images, tra_labels = sess.run(image_batch) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run(val_batch) #val_images, val_labels = sess.run([val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() #coord.join(threads) sess.close()
def train(): # pre_trained_weights = '/home/daijiaming/GalaxyClassification/data2/vgg16.npy' train_dir = '/home/daijiaming/Galaxy/data3/trainset/' train_label_dir = '/home/daijiaming/Galaxy/data3/train_label.csv' test_dir = '/home/daijiaming/Galaxy/data3/testset/' test_label_dir = '/home/daijiaming/Galaxy/data3/test_label.csv' train_log_dir = '/home/daijiaming/Galaxy/VGG16/logs/train/' val_log_dir = '/home/daijiaming/Galaxy/VGG16/logs/val/' tra_image_batch, tra_label_batch, tra_galalxyid_batch = input_data.read_galaxy11( data_dir=train_dir, label_dir=train_label_dir, batch_size=BATCH_SIZE) val_image_batch, val_label_batch, val_galalxyid_batch = input_data.read_galaxy11_test( data_dir=test_dir, label_dir=test_label_dir, batch_size=BATCH_SIZE) x = tf.placeholder(tf.float32, [BATCH_SIZE, 64, 64, 3]) y_ = tf.placeholder(tf.float32, [BATCH_SIZE, N_CLASSES]) keep_prob = tf.placeholder(tf.float32) logits, fc_output = VGG.VGG16N(x, N_CLASSES, keep_prob, IS_PRETRAIN) loss = tools.loss(logits, y_) # rmse=resnet_v2.compute_rmse(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # tools.load_with_skip(pre_trained_weights, sess, ['fc6','fc7','fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc, summary_str = sess.run( [train_op, loss, accuracy, summary_op], feed_dict={ x: tra_images, y_: tra_labels, keep_prob: 0.5 }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, tra_loss: %.4f, tra_accuracy: %.2f%%' % (step, tra_loss, tra_acc)) # summary_str = sess.run(summary_op,feed_dict={x:tra_images, y_:tra_labels}) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc, summary_str = sess.run( [loss, accuracy, summary_op], feed_dict={ x: val_images, y_: val_labels, keep_prob: 1 }) print( '** Step %d, test_loss = %.4f, test_accuracy = %.2f%% **' % (step, val_loss, val_acc)) # summary_str = sess.run([summary_op],feed_dict={x:val_images,y_:val_labels}) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(retrain=False): data_dir = '/home/rong/something_for_deep/cifar-10-batches-bin' npy_dir = '/home/rong/something_for_deep/vgg16.npy' train_log_dir = './logs/train' val_log_dir = './logs/val' train_image_batch, train_label_batch = input_data.read_cifar10( data_dir=data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10( data_dir=data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) #宣布图片batch和标签batch的占位符 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, IMG_CHANNELS]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, NUM_CLASSES]) #宣布VGG16类型的变量 vgg = model.VGG16() #宣布损失,精确度等关键节点 logits = vgg.build(x, NUM_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) train_op2 = tools.optimize2(loss, learning_rate) saver = tf.train.Saver() #括号那个参数不知道是干什么的 summary_op = tf.summary.merge_all() #初始化所有的variable,之前我看过另外一种写法,那种写法好像废弃了 init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) #从npy文件加载除了全连接之外,其他层的权重 tools.load_with_skip(npy_dir, sess, ['fc6', 'fc7', 'fc8']) saver.restore(sess, './logs/train/model.ckpt-6000') output_graph_def = convert_variables_to_constants( sess, sess.graph_def, output_node_names=['fc8/relu']) with tf.gfile.FastGFile('vgg_6000.pb', mode='wb') as f: f.write(output_graph_def.SerializeToString()) ''' #下面的和多线程有关,暂时不懂 coord = tf.train.Coordinator() #宣布线程管理器 threads = tf.train.start_queue_runners(sess=sess, coord=coord) #线程负责把文件加入队列(input_data那个file队列) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) ''' ''' if retrain == False: print('Reading checkpoints') ckpt = tf.train.get_checkpoint_state(train_log_dir) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, './logs/train/model.ckpt-10000') print('Loading success, global_step is %s' % global_step) else: print('No checkpoint file found') return saver.restore(sess, './logs/train/model.ckpt-10000') for step in range(50): train_images, train_labels = sess.run([train_image_batch, train_label_batch]) _, train_loss, train_acc = sess.run([train_op2, loss, accuracy], feed_dict={x: train_images, y_: train_labels}) print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, train_loss, train_acc)) saver.restore(sess, './logs/train/model.ckpt-14999') ''' ''' #下面的try语句可以当做模板使用 try: for step in np.arange(MAX_STEP): if coord.should_stop(): break #运行计算节点,从计算节点中得到真实的image,label train_images, train_labels = sess.run([train_image_batch, train_label_batch]) #运行损失, 精确度计算节点, 得到具体数值 _, train_loss, train_acc = sess.run([train_op, loss, accuracy], feed_dict={x: train_images, y_: train_labels}) #每到50步或者最后一步就当前batch的损失值大小和准确度大小 if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, train_loss, train_acc)) #summary_str = sess.run(summary_op) #tra_summary_writer.add_summary(summary_str, step) #每到200步或者最后一步就从测试集取一个batch, 计算损失值大小和准确度 if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={x: val_images, y_: val_labels}) print('** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) #summary_str = sess.run(summary_op) #val_summary_writer.add_summary(summary_str, step) #每到2000步就保存一次 if step % 2000 == 0 or (step + 1) == MAX_STEP: if step == 0: continue checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) ''' sess.close()
def train(): pre_trained_weights = './VGG16_pretrain/vgg16.npy' data_dir = config.dataPath train_log_dir = './logs2/train/' val_log_dir = './logs2/val/' with tf.name_scope('input'): train_image_batch, train_label_batch = input_data.read_cifar10( data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10( data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) logits = VGG.VGG16(train_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, train_label_batch) accuracy = tools.accuracy(logits, train_label_batch) my_global_step = tf.Variable(0, trainable=False, name='global_step') update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3]) y_ = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE, N_CLASSES]) tf.summary.image('input', x, 10) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() '''if exit checkpoint restore else: init ''' print('Reading checkpoint...') ckpt = tf.train.get_checkpoint_state(train_log_dir) sess = tf.Session() if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) print('Load success, global step: %s' % global_step) else: init = tf.global_variables_initializer() sess.run(init) # load pretrain weights tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) print('Load pre_trained_weights success!!!') coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) train_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break train_images, train_labels = sess.run( [train_image_batch, train_label_batch]) _, train_loss, train_accuracy = sess.run( [train_op, loss, accuracy], feed_dict={ x: train_images, y_: train_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print("Step: %d, loss: %.4f, accuracy: %.4f%%" % (step, train_loss, train_accuracy)) summary_str = sess.run(summary_op, feed_dict={ x: train_images, y_: train_labels }) train_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_accuracy = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print("** Step: %d, loss: %.4f, accuracy: %.4f%%" % (step, val_loss, val_accuracy)) summary_str = sess.run(summary_op, feed_dict={ x: train_images, y_: train_labels }) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, save_path=checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limited reached') finally: coord.request_stop() coord.join(threads) sess.close()
x = tools.pool1D('Cov2_pool', x, window_shape=[2], stride=[2], padding='VALID', is_max_pool=False) print(x.get_shape().as_list()) x = tools.BiLSTM('birnn', x, 128, GRU_layer_num=3) print('BIRNN', x.get_shape().as_list()) x = tf.layers.flatten(x, 'flatten') x = tools.FC_layer('FC2', x, 256, True, activation_fn=True, l2_value=0.001) Logits = tools.FC_layer('FC3', x, 2, True, activation_fn=False, l2_value=0.001) loss = tools.loss(Logits, y_input) op = tools.optimize(loss, learning_rate=0.0001) prediction, batch_bool, pred, auc, update_op = tools.accuracy(Logits, y_input) saver = tf.train.Saver(tf.global_variables(), max_to_keep=10000) with tf.Session() as sess: X_train_1, Y_train_1 = shuffle(X_train_1, Y_train_1) kf = KFold(n_splits=10) count = 1 for train_index, test_index in kf.split(X_train_1): sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) X_train_, Y_train_ = X_train_1[train_index], Y_train_1[train_index] X_val, Y_val = X_train_1[test_index], Y_train_1[test_index] X_val, Y_val = RandomUnderSampler().fit_sample(X_val, Y_val) test_acc_list = [] max_acc = 0
def train(): data_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/JPG/trainval/' train_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/train/' val_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/val/' with tf.name_scope('input'): train, train_label, val, val_label = input_trainval.get_files( data_dir, 0.2) train_batch, train_label_batch = input_trainval.get_batch( train, train_label, IMG_H, IMG_W, BATCH_SIZE, CAPACITY) val_batch, val_label_batch = input_trainval.get_batch( val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) logits = model_structure.AlexNet(x, 5) loss = tools.loss('loss', y_, logits) accuracy = tools.accuracy('accuracy', y_, logits) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize('optimize', loss, LEARNING_RATE, my_global_step) #?? saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 10 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f' % (step, tra_loss, tra_acc)) #summary_str = sess.run(summary_op) #tra_summary_writer.add_summary(summary_str, step) checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if step % 20 == 0 or (step + 1) == MAX_STEP: valid_images, valid_labels = sess.run( [val_batch, val_label_batch]) valid_loss, valid_acc = sess.run([loss, accuracy], feed_dict={ x: valid_images, y_: valid_labels }) print('** step: %d, loss: %.4f, accuracy: %.4f' % (step, valid_loss, valid_acc)) #summary_str = sess.run(summary_op) #val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.error.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def train(): with tf.name_scope('input'): image_batch, label_batch = input_data.read_SVHN(data_dir=data_dir, ratio=0.1, batch_size=64) tra_image_batch = image_batch[0] tra_label_batch = label_batch[0] val_image_batch = image_batch[1] val_label_batch = label_batch[1] x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 1]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) logits = model.SVHN(x, N_CLASSES) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) _, summary_str = sess.run([train_op, summary_op], feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 50 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) _, summary_str = sess.run([train_op, summary_op], feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) if step % 1000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step, write_meta_graph=False) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def train(): pre_trained_weights = '/home/xiaoyi/data/LED/VGG16_pretrained/vgg16.npy' large_dir = '/home/xiaoyi/data/LED/data/train/train_large_crop/' small_dir = '/home/xiaoyi/data/LED/data/train/train_small_crop/' val_large_dir = '/home/xiaoyi/data/LED/test/test_large/' val_small_dir = '/home/xiaoyi/data/LED/test/test_small/' train_log_dir = '/home/xiaoyi/data/LED/logs1/train/' val_log_dir = '/home/xiaoyi/data/LED/logs1/val/' with tf.name_scope('input'): train, train_laebl = input_data.get_files(large_dir, small_dir) train_batch, train_label_batch = input_data.get_batch( train, train_laebl, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val, val_label = input_data.get_files(val_large_dir, val_small_dir) val_batch, val_label_batch = input_data.get_batch( val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) logits = VGG.VGG16N(train_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, train_label_batch) accuracy = tools.accuracy(logits, train_label_batch) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d,loss:%.4f,accuracy:%.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print('** Step %d,val loss = %.2f,val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): step = 0 #step bs = 128 #batch size pre_trained_weights = main_dir + 'vgg16.npy' #vgg16 weight train_log_dir = main_dir + 'trainloggm1rss/tlog' #train log path val_log_dir = main_dir + 'trainloggm1rss/vlog' # val log path train_data_dir = main_dir + 'ymodellog' # save model path # rd=main_dir+'modellog' #train data tra_filename = np.load(main_dir + "sf_filename.npy") tra_label = np.load(main_dir + "sf_label.npy") tra_vector = np.load(main_dir + "sf_vector.npy") tra_4 = np.load(main_dir + "sf_4.npy") #val data val_filename = np.load(main_dir + "sf_gm1vfilename.npy") val_label = np.load(main_dir + "sf_gm1vlabel.npy") val_vector = np.load(main_dir + "sf_gm1vvector.npy") val_4 = np.load(main_dir + "sf_gm1v4.npy") with tf.Graph().as_default() as g: tra_image_p = tf.placeholder(tra_filename.dtype, tra_filename.shape) tra_label_p = tf.placeholder(tra_label.dtype, tra_label.shape) tra_vector_p = tf.placeholder(tra_vector.dtype, tra_vector.shape) tra_4_p = tf.placeholder(tra_4.dtype, tra_4.shape) tdataset = tf.contrib.data.Dataset.from_tensor_slices( (tra_image_p, tra_label_p, tra_vector_p, tra_4_p)) tdataset = tdataset.map(pre_function, num_threads=64) tdataset = tdataset.shuffle(1024 * 16) tdataset = tdataset.repeat() #重复 tdataset = tdataset.batch(bs) tra_iterator = tdataset.make_initializable_iterator() val_image_p = tf.placeholder(val_filename.dtype, val_filename.shape) val_label_p = tf.placeholder(val_label.dtype, val_label.shape) val_vector_p = tf.placeholder(val_vector.dtype, val_vector.shape) val_4_p = tf.placeholder(val_4.dtype, val_4.shape) vdataset = tf.contrib.data.Dataset.from_tensor_slices( (val_image_p, val_label_p, val_vector_p, val_4_p)) vdataset = vdataset.map(pre_function) vdataset = vdataset.repeat() #重复 vdataset = vdataset.batch(bs) val_iterator = vdataset.make_initializable_iterator() # Generate placeholders for the images and labels. x = tf.placeholder(tf.float32, shape=[bs, 224, 224, 3]) v = tf.placeholder(tf.float32, shape=[bs, 280]) y_ = tf.placeholder(tf.int32, shape=[bs, 2]) #?? s_ = tf.placeholder(tf.float32, shape=[bs, 4]) #?? BN_istrain = tf.placeholder(tf.bool) # Build a Graph that computes predictions from the inference model. logits = VGG16N.VGG16N(x, N_CLASSES, v, BN_istrain) # Add to the Graph the Ops for loss calculation. loss, mean_summary, total_loss_summary, loss_averages_op = tools.loss( logits, y_, s_) # Add to the Graph the Ops that calculate and apply gradients. my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, my_global_step, loss_averages_op) # Add the Op to compare the logits to the labels during evaluation. accuracy, accuracy_summary = tools.accuracy(logits, y_) # Build the summary Tensor based on the TF collection of Summaries. summary = tf.summary.merge( [mean_summary, accuracy_summary, total_loss_summary]) # Add the variable initializer Op. saver = tf.train.Saver(max_to_keep=100) init = tf.global_variables_initializer() # Create a saver for writing training checkpoints. # Create a session for running Ops on the Graph. sess = tf.Session() # Instantiate a SummaryWriter to output summaries and the Graph. tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) # And then after everything is built: # Run the Op to initialize the variables. sess.run(init) tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) # sess.run(tra_iterator.initializer, feed_dict={tra_image_p: tra_filename,tra_label_p: tra_label,tra_vector_p: tra_vector}) sess.run(val_iterator.initializer, feed_dict={ val_image_p: val_filename, val_label_p: val_label, val_vector_p: val_vector, val_4_p: val_4 }) tra_next = tra_iterator.get_next() val_next = val_iterator.get_next() print("Reading checkpoints...") for epoch in range(num_epoch): shuu.shu() tra_filename = np.load(main_dir + "gm1sf_filename.npy") tra_label = np.load(main_dir + "gm1sf_label.npy") tra_vector = np.load(main_dir + "gm1sf_vector.npy") tra_4 = np.load(main_dir + "gm1sf_4.npy") sess.run(tra_iterator.initializer, feed_dict={ tra_image_p: tra_filename, tra_label_p: tra_label, tra_vector_p: tra_vector, tra_4_p: tra_4 }) while True: try: for step in range(MAX_STEP): tra_all = sess.run(tra_next) tra_i = tra_all[0] tra_l = tra_all[1] tra_v = tra_all[2] tra_f = tra_all[3] summary_str, _, tra_loss, tra_acc = sess.run( [summary, train_op, loss, accuracy], feed_dict={ x: tra_i, y_: tra_l, v: tra_v, s_: tra_f, BN_istrain: True }) if step % 20 == 0 or (step + 1) == MAX_STEP: tra_summary_writer.add_summary(summary_str, step) # print ('Step: %d, loss: %.4f' % (step, tra_loss)) if step % 20 == 0 or (step + 1) == MAX_STEP: val_all = sess.run(val_next) val_i = val_all[0] val_l = val_all[1] val_v = val_all[2] val_f = val_all[3] val_loss, val_acc = sess.run( [loss, accuracy], feed_dict={ x: val_i, y_: val_l, v: val_v, s_: val_f, BN_istrain: False }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary, feed_dict={ x: val_i, y_: val_l, v: val_v, s_: val_f, BN_istrain: False }) val_summary_writer.add_summary(summary_str, step) # if step == 99: # Record execution stats # run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) # run_metadata = tf.RunMetadata() # summary_str, _= sess.run([summary,train_op], # feed_dict={x:tra_i, y_:tra_l, v:tra_v, BN_istrain:True},options=run_options,run_metadata=run_metadata) # tra_summary_writer.add_run_metadata(run_metadata, 'step%d' % step) # tra_summary_writer.add_summary(summary_str, step) # print('Adding run metadata for', step) if step % 10000 == 0: checkpoint_path = os.path.join( train_data_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: break sess.close()
def train(): data_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/JPG/trainval/' train_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/train/' val_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/val/' with tf.name_scope('input'): train, train_label, val, val_label = input_trainval.get_files(data_dir, 0.2) train_batch, train_label_batch = input_trainval.get_batch(train, train_label, IMG_H, IMG_W, BATCH_SIZE, CAPACITY) val_batch, val_label_batch = input_trainval.get_batch(val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) logits = model_structure.AlexNet(x, 5) loss = tools.loss('loss', y_, logits) accuracy = tools.accuracy('accuracy', y_, logits) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize('optimize', loss, LEARNING_RATE, my_global_step) #?? saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir,sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],feed_dict={x:tra_images, y_:tra_labels}) if step % 10 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f' %(step, tra_loss, tra_acc)) #summary_str = sess.run(summary_op) #tra_summary_writer.add_summary(summary_str, step) checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if step % 20 == 0 or (step + 1) == MAX_STEP: valid_images, valid_labels = sess.run([val_batch, val_label_batch]) valid_loss, valid_acc = sess.run([loss, accuracy], feed_dict={x:valid_images, y_:valid_labels}) print( '** step: %d, loss: %.4f, accuracy: %.4f' %(step, valid_loss, valid_acc)) #summary_str = sess.run(summary_op) #val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.error.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def train(): pre_trained_weights = './/vgg16_pretrain//vgg16.npy' data_dir = './/data//cifar-10-batches-bin//' train_log_dir = './/logs//train//' val_log_dir = './/logs//val//' with tf.name_scope('input'): tra_image_batch, tra_label_batch = input_data.read_cifar10(data_dir=data_dir, is_train=True, batch_size= BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10(data_dir=data_dir, is_train=False, batch_size= BATCH_SIZE, shuffle=False) logits = VGG.VGG16N(tra_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, tra_label_batch) accuracy = tools.accuracy(logits, tra_label_batch) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6','fc7','fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images,tra_labels = sess.run([tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={x:tra_images, y_:tra_labels}) if step % 50 == 0 or (step + 1) == MAX_STEP: print ('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={x:val_images,y_:val_labels}) print('** Step %d, val loss = %.2f, val accuracy = %.2f%% **' %(step, val_loss, val_acc)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train_and_test(): with tf.name_scope('input'): train_image, train_label, val_image, val_label, n_test = input_data.get_files( data_dir, RATIO, ret_val_num=True) train_batch, train_label_batch = input_data.get_batch( train_image, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_batch, val_label_batch = input_data.get_batch( val_image, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) logits = models.AlexNet(x, N_CLASSES) loss = tools.loss(logits, y_) acc = tools.accuracy(logits, y_) train_op = tools.optimize(loss, LEARNING_RATE) top_k_op = tf.nn.in_top_k(logits, y_, 1) with tf.Session() as sess: saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, acc], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0: print( 'Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels }) train_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, acc], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: val_images, y_: val_labels }) val_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print('----------------') print('Testing Now!') print('There are %d test examples' % (n_test)) num_iter = int(math.ceil(n_test / BATCH_SIZE)) true_count = 0 total_sample_count = num_iter * BATCH_SIZE step = 0 while step < num_iter: if coord.should_stop(): break val_images, val_labels = sess.run([val_batch, val_label_batch]) predictions = sess.run([top_k_op], feed_dict={ x: val_images, y_: val_labels }) true_count += np.sum(predictions) step += 1 precision = true_count / total_sample_count * 100.0 print('precision = %.2f%%' % precision) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def run_training(): num_classes = 1329 IMG_W = 448 IMG_H = 448 CAPACITY = 1000 train_dir = 'tfrecords' BATCH_SIZE = FLAGS.batch_size train_all = FLAGS.train_all learning_rate = FLAGS.learning_rate momentum = FLAGS.momentum num_epoch = FLAGS.num_epoch logger.info('learning_rate ' + str(learning_rate)) logger.info('num_epoch ' + str(num_epoch)) total_train_count, total_val_count, total_test_count = input_data.get_total_count( 'total_count.txt') train_batch, train_label_batch = input_data.get_batch( train_dir, 'train', IMG_W, IMG_H, BATCH_SIZE, CAPACITY, True) val_batch, val_label_batch = input_data.get_batch(train_dir, 'validataion', IMG_W, IMG_H, BATCH_SIZE, CAPACITY, False) test_batch, test_label_batch = input_data.get_batch( train_dir, 'test', IMG_W, IMG_H, BATCH_SIZE, CAPACITY, False) imgs = tf.placeholder(tf.float32, [BATCH_SIZE, IMG_W, IMG_H, 3]) labels = tf.placeholder(tf.int32, [BATCH_SIZE]) keep_pro = tf.placeholder(tf.float32) vgg = bilinear_vgg(imgs, num_classes, train_all, keep_pro) loss = tools.loss(vgg.logits, labels) accuracy, num_correct_preds = tools.evaluation(vgg.logits, labels) optimizer = tools.optimize(loss, learning_rate, momentum) gpu_options = tf.GPUOptions(allow_growth=True) config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(config=config) as sess: if not os.path.exists(checkpoint): os.makedirs(checkpoint) sess.run(tf.global_variables_initializer()) weight_files = ['vgg19.npy'] if train_all == True: weight_files.append('last_layers.npz') tools.load_initial_weights(weight_files, sess, train_all) saver = tf.train.Saver() ''' logger.info("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(checkpoint) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) logger.info('Loading success, global_step is ' + global_step) else: print('No checkpoint file found') ''' coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) total_batch = total_train_count / BATCH_SIZE total_val_batch = total_val_count / BATCH_SIZE for epoch in range(0, num_epoch): for i in range(total_batch): try: batch_xs, batch_ys = sess.run( [train_batch, train_label_batch]) #左右两边命名不要一样 _ = sess.run(optimizer, feed_dict={ imgs: batch_xs, labels: batch_ys, keep_pro: 0.7 }) if i % 50 == 0: train_loss, train_accuracy, summary_str = sess.run( [loss, accuracy, summary_op], feed_dict={ imgs: batch_xs, labels: batch_ys, keep_pro: 0.7 }) train_writer.add_summary(summary_str, epoch * total_batch + i) logger.info("Epoch: " + str(epoch) + " Step: " + str(i) + " Loss: " + str(train_loss)) logger.info("Training Accuracy --> " + str(train_accuracy)) batch_val_x, batch_val_y = sess.run( [val_batch, val_label_batch]) val_loss, val_accuracy, val_summary_str = sess.run( [loss, accuracy, summary_op], feed_dict={ imgs: batch_val_x, labels: batch_val_y, keep_pro: 1.0 }) val_writer.add_summary(val_summary_str, epoch * total_batch + i) logger.info("val Loss: " + str(train_loss)) logger.info("val Accuracy --> " + str(train_accuracy)) except tf.errors.OutOfRangeError: logger.info('batch out of range') break checkpoint_path = os.path.join(checkpoint, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=epoch) if train_all == False: tools.save_last_layers_weights(sess, vgg) # correct_val_count = 0 # val_loss_total = 0.0 #for i in range(total_val_batch): # try: # batch_val_x,batch_val_y = sess.run([val_batch, val_label_batch]) # val_loss,preds = sess.run([loss,num_correct_preds], feed_dict={imgs: batch_val_x, labels: batch_val_y}) # val_loss_total += val_loss # correct_val_count+=preds #val_writer.add_summary(summary_str, epoch * total_batch + i) # except tf.errors.OutOfRangeError: # logger.info('val batch out of range') # break #logger.info("------------") #logger.info("Epoch: "+str (epoch+1)+" correct_val_count, total_val_count "+ str(correct_val_count)+" , "+str( total_val_count)) #logger.info("Epoch: "+str (epoch+1)+ " Step: "+ str(i)+" Loss: "+str( val_loss_total/total_val_batch)) #logger.info("Validation Data Accuracy --> "+str( 100.0*correct_val_count/(1.0*total_val_count))) #logger.info("------------") #break correct_test_count = 0 total_test_batch = total_test_count / BATCH_SIZE for i in range(total_test_batch): try: batch_test_x, batch_test_y = sess.run( [test_batch, test_label_batch]) preds = sess.run(num_correct_preds, feed_dict={ imgs: batch_test_x, labels: batch_test_y, keep_pro: 1.0 }) correct_test_count += preds except tf.errors.OutOfRangeError: logger.info('test batch out of range') break logger.info("correct_test_count, total_test_count " + str(correct_test_count) + " , " + str(total_test_count)) logger.info("Test Data Accuracy --> " + str(100.0 * correct_test_count / (1.0 * total_test_count))) coord.request_stop() coord.join(threads)
def patch_train(cluster, folder_clustermaps): ''' :param cluster: the cluster to perform patch-wise classify :param folder_clustermaps: folder of cluster maps ''' train_log_dir = './/logs//train//' val_log_dir = './/logs//val//' feature_dict = input_data.get_feature_dict('D://data//1-10//data.csv', feature_to_classify) # setup of VGG16-like CNN x = tf.placeholder(tf.float32, shape=(BATCH_SIZE, IMG_W, IMG_H, IMG_D)) y_ = tf.placeholder(tf.int16, shape=(BATCH_SIZE, N_CLASSES)) logits = VGG.VGG16_nobn(x, N_CLASSES, TRAINABLE) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) if IS_FINETUNING: # load the parameter file, assign the parameters, skip the specific layers print('** Loading pre-trained weights **') tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) shuffled_list_train = input_data.get_full_list( data_type='train', cluster=cluster, folder=data_dir, folder_clustermaps=folder_clustermaps) shuffled_list_val = input_data.get_full_list( data_type='val', cluster=cluster, folder=data_dir, folder_clustermaps=folder_clustermaps) shuffled_list_val = np.hstack((shuffled_list_val, shuffled_list_val)) shuffled_list_val = np.hstack((shuffled_list_val, shuffled_list_val)) shuffled_list_val = np.hstack((shuffled_list_val, shuffled_list_val)) try: for epoch in np.arange(MAX_EPOCH): np.random.shuffle(shuffled_list_train) np.random.shuffle(shuffled_list_val) max_step = int(len(shuffled_list_train) / BATCH_SIZE) for step in np.arange(max_step): tra_image_batch, tra_label_batch = input_data.read_local_data( data_dir=data_dir, batch_size=BATCH_SIZE, step=step, feature_dict=feature_dict, n_classes=N_CLASSES, name_list=shuffled_list_train) if coord.should_stop(): break tra_labels = sess.run(tra_label_batch) tra_images = tra_image_batch _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 10 == 0: print( 'Epoch: %d (MAX_EPOCH = %d), Step: %d (MAX_Step = %d), loss: %.4f, accuracy: %.4f%%' % (epoch, MAX_EPOCH, step, max_step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 50 == 0: val_image_batch, val_label_batch = input_data.read_local_data( data_dir=data_dir, batch_size=BATCH_SIZE, step=step / 50, feature_dict=feature_dict, n_classes=N_CLASSES, name_list=shuffled_list_val) val_labels = sess.run(val_label_batch) val_images = val_image_batch val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Epoch: %d, Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (epoch, step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) # logits_array = sess.run(logits, feed_dict={x: tra_images}) # labels_array = sess.run(y_, feed_dict={y_: tra_labels}) # logits_array = np.around(logits_array, decimals=3) # print('==========TRAAIN==========') # print(np.hstack((logits_array, labels_array))) # # logits_array = sess.run(logits, feed_dict={x: val_images}) # labels_array = sess.run(y_, feed_dict={y_: val_labels}) # logits_array = np.around(logits_array, decimals=3) # print('=========VALIDATE=========') # print(np.hstack((logits_array, labels_array))) if step % 2000 == 0: checkpoint_path = os.path.join( train_log_dir, 'model_' + str(epoch) + '_' + str(step) + '.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
# Sample repulsive batch if required if args.repulsive is not None: br = repulsive_sampler.sample_batch() kwargs = { 'reference_net': reference_net, 'batch_repulsive': br, 'bandwidth_repulsive': bandwidth_repulsive, 'lambda_repulsive': args.lambda_repulsive } else: kwargs = {} data, target = data.cpu(), target.cpu() info_batch = optimize(net, optimizer, batch=(data, target), add_repulsive_constraint=args.repulsive is not None, **kwargs) step += 1 for k, v in info_batch.items(): experiment.log_metric('train_{}'.format(k), v, step=step) # Save the model if not Path.exists(savepath / 'models'): os.makedirs(savepath / 'models') model_path = savepath / 'models' / '{}_{}epochs.pt'.format( model_name, epoch + 1) if not Path.exists(model_path): torch.save(net.state_dict(), model_path) else:
def train(): data_dir = '.' train_log_dir = './logs/train/' val_log_dir = './logs/val/' with tf.name_scope('input'): tra_data_batch, tra_label_batch = input_data.read_data( data_dir=data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_data_batch, val_label_batch = input_data.read_data( data_dir=data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 30]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) logits = FNET.FNET(x, N_CLASSES, IS_PRETRAIN, train=True, droprate=0.6) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) #summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) #tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) #val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) numk = 3000 / 100 numk = int(numk) bestaka = 0 try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_data_batch, tra_label_batch]) _, tra_loss, tra_acc, llg = sess.run( [train_op, loss, accuracy, logits], feed_dict={ x: tra_images, y_: tra_labels }) if step % 20 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) #summary_str = sess.run(summary_op) #tra_summary_writer.add_summary(summary_str, step) if step % 400 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_data_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) #summary_str = sess.run(summary_op) #val_summary_writer.add_summary(summary_str, step) if step % 400 == 0: for i in llg: print(i) if step % 800 == 0 or (step + 1) == MAX_STEP and step != 0: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if step % 600 == 0 and step != 0: aka = 0 for ii in range(numk): val_images, val_labels = sess.run( [val_data_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) aka += val_acc aka = aka / numk print('*****test accuracy = %.3f%% ***' % (aka)) if (aka > bestaka): bestaka = aka checkpoint_path = os.path.join("./logs/train_best", 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if step == int(0.08 * MAX_STEP): train_op = tools.optimize(loss, 0.002, my_global_step) if step == int(0.24 * MAX_STEP): train_op = tools.optimize(loss, 0.0004, my_global_step) if step == int(0.4 * MAX_STEP): train_op = tools.optimize(loss, 0.0001, my_global_step) if step == int(0.6 * MAX_STEP): train_op = tools.optimize(loss, 0.00001, my_global_step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def test(test_dir, checkpoint_dir='./checkpoint/'): import json # predict the result test_images = os.listdir(test_dir) features = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) labels = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) # one_hot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=80) # train_step, cross_entropy, logits, keep_prob = network.inference(features, one_hot_labels) resnet = ResNet.ResNet() _, logits = resnet.build(features, N_CLASSES, last_layer_type="softmax") loss = tools.loss(logits, labels) accuracy = tools.accuracy(logits, labels) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) values, indices = tf.nn.top_k(logits, 3) keep_prob = tf.placeholder(tf.float32) with tf.Session() as sess: saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: print('Restore the model from checkpoint %s' % ckpt.model_checkpoint_path) # Restores from checkpoint saver.restore(sess, ckpt.model_checkpoint_path) start_step = int( ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]) else: raise Exception('no checkpoint find') result = [] test_imglist = [] for test_image in test_images: test_imgpath = os.path.join(test_dir, test_image) test_imglist.append(test_imgpath) image = tf.cast(test_imglist, tf.string) # make a input queue input_queue = tf.train.slice_input_producer([image]) image_contents = tf.read_file(input_queue[0]) image = tf.image.decode_jpeg(image_contents, channels=3) ################################################# # data agumentation should go to here ################################################# image = tf.image.resize_image_with_crop_or_pad(image, IMG_W, IMG_H) image = tf.image.per_image_standardization(image) # image_batch, label_batch = tf.train.batch([image, label], # batch_size=batch_size, # num_threads=64, # capacity=capacipy) image_batch = tf.train.shuffle_batch([image], batch_size=1, num_threads=64, capacity=CAPACITY, min_after_dequeue=200) image_batch = tf.cast(image_batch, tf.float32) img = sess.run([image_batch]) for i in range(len(img)): x = img[i] temp_dict = {} # x = scene_input.img_resize(os.path.join(test_dir, test_image), IMG_W) predictions = np.squeeze(sess.run(indices, feed_dict={ features: np.expand_dims(x, axis=0), keep_prob: 1 }), axis=0) temp_dict['image_id'] = test_image temp_dict['label_id'] = predictions.tolist() result.append(temp_dict) print('image %s is %d,%d,%d' % (test_image, predictions[0], predictions[1], predictions[2])) with open('submit.json', 'w') as f: json.dump(result, f) print('write result json, num is %d' % len(result))
def train_aid(): pre_trained_weights = r'/media/jsl/ubuntu/pretrain_weight/vgg16.npy' data_train_dir = os.path.join(config.aid_data_root_path, 'train') data_test_dir = os.path.join(config.aid_data_root_path, 'val') train_log_dir = os.path.join(config.aid_log_root_path, 'train') val_log_dir = os.path.join(config.aid_log_root_path, 'val') with tf.name_scope('input'): image_train_list, label_train_list = get_files(data_train_dir) image_val_list, label_val_list = get_files(data_test_dir) image_batch, label_batch = get_batch(image_train_list, label_train_list, config.aid_img_weight, config.aid_img_height, BATCH_SIZE, CAPACITY) val_image_batch, val_label_batch = get_batch(image_val_list, label_val_list, config.aid_img_weight, config.aid_img_height, BATCH_SIZE, CAPACITY) x = tf.placeholder( tf.float32, shape=[BATCH_SIZE, config.aid_img_weight, config.aid_img_height, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, config.aid_n_class]) logits = VGG.VGG16N(x, config.aid_n_class, IS_PRETRAIN) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) start_time = time.strftime('%Y-%m-%d %H-%M-%S', time.localtime(time.time())) print('start_time:', start_time) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([image_batch, label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close() end_time = time.strftime('%Y-%m-%d %H-%M-%S', time.localtime(time.time())) print('end_time:', end_time)
def mytrain(): # pre_trained_weights = './VGG16_pretrain/vgg16.npy' data_dir = '/content/data/' train_log_dir = './logs2/train/' val_log_dir = './logs2/val/' with tf.name_scope('input'): train_image_batch, train_label_batch = input_data.read_cifar10( data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10( data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) logits = VGG.Myvgg(train_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, train_label_batch) accuracy = tools.accuracy(logits, train_label_batch) my_global_step = tf.Variable(0, trainable=False, name='global_step') train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3]) y_ = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load pretrain weights # tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) train_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break train_images, train_labels = sess.run( [train_image_batch, train_label_batch]) #print(train_images.shape,train_labels) _, train_loss, train_accuracy = sess.run( [train_op, loss, accuracy], feed_dict={ x: train_images, y_: train_labels }) if step % 128 == 0 or (step + 1) == MAX_STEP: print("Step: %d, loss: %.8f, accuracy: %.4f%%" % (step, train_loss, train_accuracy)) summary_str = sess.run(summary_op) train_summary_writer.add_summary(summary_str, step) if step % 128 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_accuracy = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print("** Step: %d, loss: %.8f, test_accuracy: %.4f%%" % (step, val_loss, val_accuracy)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, save_path=checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limited reached') finally: coord.request_stop() coord.join(threads) sess.close()
activaction_function=tf.nn.relu) outputs = tools.batch_norm(outputs) outputs = tools.FC_layer('fc7', outputs, out_nodes=1024, activaction_function=tf.nn.relu) outputs = tools.batch_norm(outputs) logits = tools.FC_layer('fc8', outputs, out_nodes=10, activaction_function=tf.nn.softmax) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) sess = tf.Session() sess.run(tf.global_variables_initializer()) summary_op = tf.summary.merge_all() tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) for step in range(MAX_STEP): batch_xs, batch_ys = mnist.train.next_batch(100) #采用minbatch自助放回采样 _train_r, _train_acc, _train_loss = sess.run( [train_op, accuracy, loss], feed_dict={ x: batch_xs, y_: batch_ys }) if step % 50 == 0 or (step + 1) == MAX_STEP:
def train(): pre_trained_weights = './/vgg16_pretrain//vgg16.npy' data_dir = './/data//cifar-10-batches-bin//' train_log_dir = './/logs//train//' val_log_dir = './/logs//val//' with tf.name_scope('input'): tra_image_batch, tra_label_batch = input_data.read_cifar10( data_dir=data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10( data_dir=data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) logits = VGG.VGG16N(tra_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, tra_label_batch) accuracy = tools.accuracy(logits, tra_label_batch) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def retrain_running(): with tf.name_scope('input'): train_batch, train_label_batch = input_data.read_and_decode( train_tfrecords_file, IMG_W, IMG_H, BATCH_SIZE, MIN_AFTER_DEQUENE) val_batch, val_label_batch = input_data.read_and_decode( val_tfrecords_file, IMG_W, IMG_H, BATCH_SIZE, MIN_AFTER_DEQUENE) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) logits = models.AlexNet(x, N_CLASSES) loss = tools.loss(logits, y_) acc = tools.accuracy(logits, y_) train_op = tools.optimize(loss, LEARNING_RATE) with tf.Session() as sess: saver = tf.train.Saver(tf.global_variables()) print("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(model_dir) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split( '-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) print('Loading success, global_step is %s' % global_step) else: print('No checkpoint file found') return coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, acc], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0: print( 'Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels }) train_writer.add_summary(summary_str, step) # if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, acc], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: val_images, y_: val_labels }) val_writer.add_summary(summary_str, step) # if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(new_model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)