def __init__(self, sess, weights=None):
self.sess = sess
self.CATEGORY_NUM = 151
self.IMAGE_SIZE = [224, 224]
self.IMAGE_CHANNEL = 3
data_dir = '/home/give/Documents/dataset/ADEChallengeData2016'
self.model_save_path = '/home/give/PycharmProjects/MyFCN/pretrain_vgg16/model/'
self.dataset = DataSet(data_dir)
self.learning_rate = 1e-3
self.itertator_number = int(1e+5)
self.learning_rate_decay = 0.9
self.BATCH_SIZE = 20
self.imgs = tf.placeholder(tf.float32,
shape=[
self.BATCH_SIZE, self.IMAGE_SIZE[0],
self.IMAGE_SIZE[0], self.IMAGE_CHANNEL
])
self.y_ = tf.placeholder(tf.float32,
shape=[
self.BATCH_SIZE, self.IMAGE_SIZE[0],
self.IMAGE_SIZE[1], self.CATEGORY_NUM
])
tf.summary.image("input_image", self.imgs, max_outputs=2)
self.layers_name = [
'conv6_1',
'conv6_2',
'conv6_3',
'upconv1_1',
'pooling4_score',
'upconv2_1',
'pooling3_score',
'upconv3_1',
]
tf.summary.image("ground_truth",
tf.cast(
tf.expand_dims(tf.argmax(self.y_, dimension=3),
dim=3), tf.uint8),
max_outputs=2)
if weights is None:
vgg_weights_path = './vgg16.npy'
else:
vgg_weights_path = None
self.vgg = vgg16(self.imgs,
weights=vgg_weights_path,
sess=self.sess,
skip_layers=['fc6', 'fc7', 'fc8'])
self.inference()
if weights is not None and sess is not None:
load_with_skip(weights, sess, [])
def __init__(self, imgs, weights=None, sess=None, skip_layers=[]):
self.imgs = imgs
self.trainable = {
'conv1_1': True,
'conv1_2': True,
'conv2_1': True,
'conv2_2': True,
'conv3_1': True,
'conv3_2': True,
'conv3_3': True,
'conv4_1': True,
'conv4_2': True,
'conv4_3': True,
'conv5_1': True,
'conv5_2': True,
'conv5_3': True,
'fc6': True,
'fc7': True,
'fc8': True
}
self.layers_name = [
'conv1_1',
'conv1_2',
'conv2_1',
'conv2_2',
'conv3_1',
'conv3_2',
'conv3_3',
'conv4_1',
'conv4_2',
'conv4_3',
'conv5_1',
'conv5_2',
'conv5_3',
]
self.classesnumber = 2
self.regularizer = None
self.convlayers()
if weights is not None and sess is not None:
load_with_skip(weights, sess, skip_layers)
def ext_dataset_fea_use_vgg16(dataset_root_path, dataset_feature_root_path):
pre_trained_weights = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/logs/train/vgg16.npy'
img_path = tf.placeholder(tf.string)
img_content = tf.read_file(img_path)
img = tf.image.decode_image(img_content, channels=3)
img = tf.image.resize_image_with_crop_or_pad(img, config.IMG_W, config.IMG_H)
img = tf.image.per_image_standardization(img)
# with tf.Session() as sess:
# image = sess.run(img, feed_dict={img_path:'agricultural00.jpg'})
# plt.imshow(image)
# plt.show()
x = tf.placeholder(tf.float32, shape=[1, config.IMG_W, config.IMG_H, 3])
# y_ = tf.placeholder(tf.int16, shape=[1, config.N_CLASSES])
#
img_fea = VGG.VGG16N_CNN(x, config.N_CLASSES, False)
with tf.Session() as sess:
tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8'])
for class_name in os.listdir(dataset_root_path):
class_path = os.path.join(dataset_root_path, class_name)
print('--**extracting %s**--' % class_path)
fea_class_path = os.path.join(dataset_feature_root_path, class_name)
if not os.path.exists(fea_class_path):
os.mkdir(fea_class_path)
for img_name in os.listdir(class_path):
jpg_img_path = os.path.join(class_path, img_name)
fea_txt_path = os.path.join(fea_class_path, img_name[:-4]+'.txt')
print('extracting %s' % jpg_img_path)
image = sess.run(img, feed_dict={img_path: jpg_img_path})
# plt.imshow(image)
# plt.show()
img_fea_out = sess.run(img_fea, feed_dict={x: [image]})
# print(img_fea_out.shape)
str_img_fea = ','.join(map(str, img_fea_out[0].tolist()))
with open(fea_txt_path, 'w') as f:
f.write(str_img_fea)
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)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run(tf.initialize_all_variables())
# testImage = sess.run(img_tf)
# testImage3 = sess.run(img_tf3)
# print(testImage.shape)
# print(testImage3.shape)
# fig = plt.figure()
# fig.add_subplot(1,2,1)
# plt.imshow(testImage)
# fig.add_subplot(1,2,2)
# plt.imshow(testImage3)
# plt.show()
tools.load_with_skip('./VGG16_pretrain/vgg16.npy', sess, [])
print('Testing Network!\n')
logits = VGG.VGG16(img_tf2, 1000, True)
print(logits.eval(session=sess), '\n')
# with tf.Graph().as_default():
# log_dir = './logs2/train/'
# test_dir = '/home/yuxin/data/cifar10_data/'
# n_test = 10000
#
# logits = VGG.VGG16(test_iamge_batch, N_CLASSES, IS_PRETRAIN)
# correct = tools.num_correct_prediction(logits, test_label_batch)
# saver = tf.train.Saver(tf.global_variables())
#
# with tf.Session() as sess:
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():
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()
## 内容损失
content_loss = tools.content_loss(generated_feature_maps[CONTENT_LAYER],
content_features[CONTENT_LAYER],
content_weight)
## 总损失
loss = content_loss + style_loss
train_step = tf.train.AdamOptimizer(learning_rate=1e-3).minimize(loss)
init = tf.global_variables_initializer()
with tf.Session() as sess:
print('in')
sess.run(init)
# 加载vgg参数，跳过list中的参数不加载
tools.load_with_skip(pre_trained_weights, sess,
['conv5_2', 'conv5_3', 'fc6', 'fc7', 'fc8'])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
## 计算风格图像 的各层特征图的Gram矩阵
style_gram_data = sess.run([style_gram],
feed_dict={style_image: styImgReaded})
print('over')
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():
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)
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 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)
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():
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(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()
yield random.randint(0, 100)
def generate_ix():
while True:
i = random.randint(0, 10000 / batch_size)
if is_train:
with tf.Session(config=config) as sess:
init = tf.global_variables_initializer()
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter('/disk3/Graduate-design/train_log/',
sess.graph)
sess.run(init)
tools.load_with_skip('/tmp/deep_matting/vgg16.npy', sess,
['conv1_1', 'fc6', 'fc7', 'fc5', 'fc8'])
test_data = np.load("/disk3/Graduate-design/test/{:0>3}.npy".format(0))
F_test = np.stack([np.array(x["F"]) for x in test_data[0:1000]])
B_test = np.stack([np.array(x["B"]) for x in test_data[0:1000]])
I_test = np.stack([np.array(x["I"]) for x in test_data[0:1000]])
alpha_diff_target_test = np.stack(
[np.array([x["alpha_diff"]]) for x in test_data[0:1000]])
for idx_f in range(1000):
# pics = np.load("/disk3/Graduate-design/data/{:0>3}.npy".format(idx_f))
pics = np.load(
"/disk3/Graduate-design/data/{:0>3}.npy".format(idx_f))
for ix in range(0, 1000, batch_size):
F_train = np.stack(
[np.array(x["F"]) for x in pics[ix:ix + batch_size + 1]])
B_train = np.stack(
[np.array(x["B"]) for x in pics[ix:ix + batch_size + 1]])
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 train():
pre_trained_weights = './/vgg16.npy'
style_image_dir = 'style_image/mosaic.jpg'
image_file_dir = 'train2014'
save_dir = 'myModel'
exp_dir = 'myGenerate'
now_exp_dir = myutil.makeExpDir(exp_dir)
## 读取一张固定的风格图像(实际数据)
#styImgReaded = data_io.get_style_batch(style_image_dir)
styImgReaded = np.expand_dims(misc.imread(style_image_dir), axis=0)#---喂给style_image
styImgReadedsize = styImgReaded.shape
styImg_W = styImgReadedsize[1]
styImg_H = styImgReadedsize[2]
## 读取一批内容图像（是通道，没有实际数据）
ContImgReaded = data_io.get_cont_batch(image_file_dir, 256, 256, BATCH_SIZE, num_epochs)#---喂给content_images
## 一张固定的风格图像 通道
style_image = tf.placeholder(tf.float32, shape=[1, styImg_W, styImg_H, 3])
## 一批内容图像 的某层特征图 通道
content_images = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
##一批风格转换网络的生成图像
# generated_image = transform.net(content_images)
generated_image = model.net(content_images, training=True)
## 风格损失
style_gram_dict = myutil.img2Gram(style_image)#风格图像的Gram矩阵字典
gen_gram_dict = myutil.img2Gram(generated_image)#生成图像的Gram矩阵字典
style_loss = tools.style_loss(gen_gram_dict, style_gram_dict, style_weight)
## 内容损失
content_map_dict = myutil.img2ContMap(content_images)#内容图像的内容特征字典
generated_feature_maps = myutil.img2ContMap(generated_image)#生成图像的内容特征字典
content_loss = tools.content_loss(generated_feature_maps[CONTENT_LAYER], content_map_dict[CONTENT_LAYER], content_weight)
## tv损失
# tv_loss = tools.tv_loss(generated_image, tv_weight)
## 总损失
# loss = content_loss + style_loss + tv_loss
loss = content_loss + style_loss
## 变学习率
global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(learning_rate=1e-3, global_step=global_step,
decay_steps=300, decay_rate=0.98, staircase=True)
## 训练操作
train_op = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss, global_step=global_step)
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
# 加载vgg参数，跳过list中的参数不加载
tools.load_with_skip(pre_trained_weights, sess, ['conv5_1','conv5_2','conv5_3','fc6','fc7','fc8'])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
print('in')
img_index = 0
try:
while True:
img_index += 1
#获取一批内容图像
ContImgBatch = sess.run(ContImgReaded)
## 计算风格图像 的各层特征图的Gram矩阵
sess.run(train_op, feed_dict={style_image:styImgReaded, content_images:ContImgBatch})
if img_index % 10 == 0:
tra_loss, res, now_lr = sess.run([loss,generated_image,learning_rate], feed_dict={style_image:styImgReaded, content_images:ContImgBatch})
misc.imsave(now_exp_dir+'/res'+str(img_index)+'.jpg', res[0])
print ('img_index: %d, loss: %.4f, lr: %.3f*e-3' % (img_index, tra_loss, now_lr*1000))
if img_index % 100 == 0:#保存模型
checkpoint_path = os.path.join(save_dir, 'myModel.ckpt')
saver.save(sess, checkpoint_path, global_step=img_index)
print('img_index : ', img_index)
except tf.errors.OutOfRangeError:
print("done")
finally:
coord.request_stop()
coord.join(threads)
sess.close()
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 finetune_train():
pre_trained_weights = './vgg16_pretrain/vgg16.npy'
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.VGG16()
logits = model.fc8
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())
sess.run(tf.global_variables_initializer())
# 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)
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(finetune_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)
