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)
