def main(args):
g = tf.Graph() # A new graph
with g.as_default():
with tf.Session() as sess:
# Building graph.
image_data = tf.placeholder(tf.int32, name='input_image')
height = tf.placeholder(tf.int32, name='height')
width = tf.placeholder(tf.int32, name='width')
# Reshape data
image = tf.reshape(image_data, [height, width, 3])
processed_image = utils.mean_image_subtraction(
image, [123.68, 116.779, 103.939]) # Preprocessing image
batched_image = tf.expand_dims(processed_image, 0) # Add batch dimension
generated_image = model.net(batched_image, training=False)
casted_image = tf.cast(generated_image, tf.int32)
# Remove batch dimension
squeezed_image = tf.squeeze(casted_image, [0])
cropped_image = tf.slice(squeezed_image, [0, 0, 0], [height, width, 3])
# stylized_image = tf.image.encode_jpeg(squeezed_image, name='output_image')
stylized_image_data = tf.reshape(cropped_image, [-1], name='output_image')
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(), write_version=tf.train.SaverDef.V1)
sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
# Use absolute path.
model_file = os.path.abspath(args.model_file)
saver.restore(sess, model_file)
if args.is_debug:
content_file = '/Users/Lex/Desktop/t.jpg'
generated_file = '/Users/Lex/Desktop/xwz-stylized.jpg'
with open(generated_file, 'wb') as img:
image_bytes = tf.read_file(content_file)
input_array, decoded_image = sess.run([
tf.reshape(tf.image.decode_jpeg(image_bytes, channels=3), [-1]),
tf.image.decode_jpeg(image_bytes, channels=3)])
start_time = time.time()
img.write(sess.run(tf.image.encode_jpeg(tf.cast(cropped_image, tf.uint8)), feed_dict={
image_data: input_array,
height: decoded_image.shape[0],
width: decoded_image.shape[1]}))
end_time = time.time()
tf.logging.info('Elapsed time: %fs' % (end_time - start_time))
else:
output_graph_def = tf.graph_util.convert_variables_to_constants(
sess, sess.graph_def, output_node_names=['output_image'])
with tf.gfile.FastGFile('/Users/Lex/Desktop/' + args.model_name + '.pb', mode='wb') as f:
f.write(output_graph_def.SerializeToString())
def main(_):
# Get image's height and width.
height = 0
width = 0
with open(FLAGS.image_file, 'rb') as img:
with tf.Session().as_default() as sess:
if FLAGS.image_file.lower().endswith('png'):
image = sess.run(tf.image.decode_png(img.read()))
else:
image = sess.run(tf.image.decode_jpeg(img.read()))
height = image.shape[0]
width = image.shape[1]
tf.logging.info('Image size: %dx%d' % (width, height))
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
# Read image data.
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
FLAGS.loss_model,
is_training=False)
image = reader.get_image(FLAGS.image_file, height, width, image_preprocessing_fn)
# Add batch dimension
image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.cast(generated, tf.uint8)
# Remove batch dimension
generated = tf.squeeze(generated, [0])
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(), write_version=tf.train.SaverDef.V1)
sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
# Use absolute path
FLAGS.model_file = os.path.abspath(FLAGS.model_file)
saver.restore(sess, FLAGS.model_file)
# Make sure 'generated' directory exists.
generated_file = 'generated/res.jpg'
if os.path.exists('generated') is False:
os.makedirs('generated')
# Generate and write image data to file.
with open(generated_file, 'wb') as img:
start_time = time.time()
img.write(sess.run(tf.image.encode_jpeg(generated)))
end_time = time.time()
tf.logging.info('Elapsed time: %fs' % (end_time - start_time))
tf.logging.info('Done. Please check %s.' % generated_file)
def run(optim):
progress = make_progressbar("Training with " + str(optim), 5)
progress.start()
model = net()
model.training()
for epoch in range(5):
train(Xtrain, ytrain, model, optim, criterion, batch_size, "train")
train(Xtrain, ytrain, model, optim, criterion, batch_size, "stats")
progress.update(epoch + 1)
progress.finish()
model.evaluate()
nll, _ = test(Xtrain, ytrain, model, batch_size)
_, nerr = test(Xval, yval, model, batch_size)
print("Trainset NLL: {:.2f}".format(nll))
print("Testset errors: {}".format(nerr))
def main(_):
height = 0
width = 0
with open(FLAGS.image_file, 'rb') as img:
with tf.Session().as_default() as sess:
if FLAGS.image_file.lower().endswith('png'):
image = sess.run(tf.image.decode_png(img.read()))
else:
image = sess.run(tf.image.decode_jpeg(img.read()))
height = image.shape[0]
width = image.shape[1]
tf.logging.info('Image size: %dx%d' % (width, height))
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
FLAGS.loss_model,
is_training=False)
image = reader.get_image(FLAGS.image_file, height, width, image_preprocessing_fn)
image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.squeeze(generated, [0])
saver = tf.train.Saver(tf.all_variables())
sess.run([tf.initialize_all_variables(), tf.initialize_local_variables()])
FLAGS.model_file = os.path.abspath(FLAGS.model_file)
saver.restore(sess, FLAGS.model_file)
start_time = time.time()
generated = sess.run(generated)
generated = tf.cast(generated, tf.uint8)
end_time = time.time()
tf.logging.info('Elapsed time: %fs' % (end_time - start_time))
generated_file = 'generated/res.jpg'
if os.path.exists('generated') is False:
os.makedirs('generated')
with open(generated_file, 'wb') as img:
img.write(sess.run(tf.image.encode_jpeg(generated)))
tf.logging.info('Done. Please check %s.' % generated_file)
def main(argv=None):
with open(FLAGS.IMAGE_PATH, 'rb') as f:
jpg = f.read()
image = tf.image.convert_image_dtype(tf.image.decode_jpeg(jpg, channels=3), tf.float32) * 255.
images = tf.expand_dims(image, 0)
generated_images = model.net(images - reader.mean_pixel, training=False)
output_format = tf.cast(generated_images, tf.uint8)
jpegs = tf.map_fn(lambda image: tf.image.encode_jpeg(image), output_format, dtype=tf.string)
with tf.Session() as sess:
file = tf.train.latest_checkpoint(model_path)
if not file:
print('Could not find trained model in %s' % model_path)
return
print('Using model from %s' % file)
saver = tf.train.Saver()
saver.restore(sess, file)
images_t = sess.run(jpegs)
with open('res.jpg', 'wb') as f:
f.write(images_t[0])
from training_schedules import POLICY
from src.dataloader import load_batch
from src.utils import schedule_verbose, ckpt_reader
from model import net
# DATA_PATH = '/home/jaehyuk/code/own/tracker/data/vot2015'
# check POLICY
# check load_batch, train, sample, test
# check log_dir(slim get latest ckpt)
# ckpt = './logs/Tracker/model.ckpt-1043223'
ckpt = None
log_dir = './logs/Tracker/'
data_type = 'train'
Tracker = net()
schedule_verbose(POLICY, data_type)
# data loader
# TODO, dimension check
pimg_resize, cimg_resize, pbox_xy, pROI, pROI_anchor,\
confs, coord, areas, upleft, botright = load_batch(POLICY, data_type)
# check ckpt variable
if ckpt:
ckpt_reader(ckpt, value=False)
Tracker.train(log_dir=log_dir,
training_schedule=POLICY,
pimg_resize=pimg_resize,
cimg_resize=cimg_resize,
def transform(image_file="img/test4.jpg",
model_file="models/cubist.ckpt-done",
loss_model="vgg_16"):
tf.logging.set_verbosity(tf.logging.INFO)
# Get image's height and width.
height = 0
width = 0
with open(image_file, 'rb') as img:
with tf.Session().as_default() as sess:
if image_file.lower().endswith('png'):
image = sess.run(tf.image.decode_png(img.read()))
else:
image = sess.run(tf.image.decode_jpeg(img.read()))
height = image.shape[0]
width = image.shape[1]
tf.logging.info('图像尺寸为: %dx%d' % (width, height))
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
# Read image data.
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
loss_model, is_training=False)
image = reader.get_image(image_file, height, width,
image_preprocessing_fn)
# Add batch dimension
image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.cast(generated, tf.uint8)
# Remove batch dimension
generated = tf.squeeze(generated, [0])
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(),
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Use absolute path
model_file = os.path.abspath(model_file)
saver.restore(sess, model_file)
# Make sure 'generated' directory exists.
localtime = time.time() #这样生成的是当前时间戳，不包含空格
generatedname = localtime + '.jpg'
generated_file = os.path.join(os.getcwd(), generatedname)
if os.path.exists('generated') is False:
os.makedirs('generated')
# Generate and write image data to file.
with open(generated_file, 'wb') as img:
start_time = time.time()
img.write(sess.run(tf.image.encode_jpeg(generated)))
end_time = time.time()
tf.logging.info('耗时: %fs' % (end_time - start_time))
tf.logging.info('图像风格转换完成. 请查看 %s.' % generated_file)
def main(FLAGS):
style_features_t = losses.get_style_features(FLAGS)
# Make sure the training path exists.
training_path = os.path.join(FLAGS.model_path, FLAGS.naming)
if not (os.path.exists(training_path)):
os.makedirs(training_path)
with tf.Graph().as_default():
with tf.Session() as sess:
"""Build Network"""
network_fn = nets_factory.get_network_fn(FLAGS.loss_model,
num_classes=1,
is_training=False)
image_preprocessing_fn, image_unprocessing_fn = preprocessing_factory.get_preprocessing(
FLAGS.loss_model, is_training=False)
processed_images = reader.image(FLAGS.batch_size,
FLAGS.image_size,
FLAGS.image_size,
'train2014/',
image_preprocessing_fn,
epochs=FLAGS.epoch)
generated = model.net(processed_images, FLAGS=FLAGS, training=True)
processed_generated = [
image_preprocessing_fn(image, FLAGS.image_size,
FLAGS.image_size) for image in
tf.unstack(generated, axis=0, num=FLAGS.batch_size)
]
processed_generated = tf.stack(processed_generated)
_, endpoints_dict = network_fn(tf.concat(
[processed_generated, processed_images], 0),
spatial_squeeze=False)
# Log the structure of loss network
tf.logging.info(
'Loss network layers(You can define them in "content_layers" and "style_layers"):'
)
for key in endpoints_dict:
tf.logging.info(key)
"""Build Losses"""
content_loss = losses.content_loss(endpoints_dict,
FLAGS.content_layers)
style_loss, style_loss_summary = losses.style_loss(
endpoints_dict, style_features_t, FLAGS.style_layers)
tv_loss = losses.total_variation_loss(
generated) # use the unprocessed image
loss = FLAGS.style_weight * style_loss + FLAGS.content_weight * content_loss + FLAGS.tv_weight * tv_loss
# Add Summary for visualization in tensorboard.
"""Add Summary"""
tf.summary.scalar('losses/content_loss', content_loss)
tf.summary.scalar('losses/style_loss', style_loss)
tf.summary.scalar('losses/regularizer_loss', tv_loss)
tf.summary.scalar('weighted_losses/weighted_content_loss',
content_loss * FLAGS.content_weight)
tf.summary.scalar('weighted_losses/weighted_style_loss',
style_loss * FLAGS.style_weight)
tf.summary.scalar('weighted_losses/weighted_regularizer_loss',
tv_loss * FLAGS.tv_weight)
tf.summary.scalar('total_loss', loss)
for layer in FLAGS.style_layers:
tf.summary.scalar('style_losses/' + layer,
style_loss_summary[layer])
tf.summary.image('generated', generated)
# tf.image_summary('processed_generated', processed_generated) # May be better?
tf.summary.image(
'origin',
tf.stack([
image_unprocessing_fn(image) for image in tf.unstack(
processed_images, axis=0, num=FLAGS.batch_size)
]))
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(training_path)
"""Prepare to Train"""
global_step = tf.Variable(0, name="global_step", trainable=False)
variable_to_train = []
for variable in tf.trainable_variables():
if not (variable.name.startswith(FLAGS.loss_model)):
variable_to_train.append(variable)
train_op = tf.train.AdamOptimizer(1e-3).minimize(
loss, global_step=global_step, var_list=variable_to_train)
variables_to_restore = []
for v in tf.global_variables():
if not (v.name.startswith(FLAGS.loss_model)):
variables_to_restore.append(v)
variables_to_restore = [
var for var in variables_to_restore if 'Adam' not in var.name
]
saver = tf.train.Saver(variables_to_restore,
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Restore variables for loss network.
init_func = utils._get_init_fn(FLAGS)
init_func(sess)
# Restore variables for training model if the checkpoint file exists.
last_file = tf.train.latest_checkpoint(training_path)
if last_file:
tf.logging.info('Restoring model from {}'.format(last_file))
saver.restore(sess, last_file)
"""Start Training"""
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
"""logging"""
# print(step)
if step % 10 == 0:
tf.logging.info(
'step: %d, total Loss %f, secs/step: %f' %
(step, loss_t, elapsed_time))
"""summary"""
if step % 25 == 0:
tf.logging.info('adding summary...')
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
writer.flush()
"""checkpoint"""
if step % 1000 == 0:
saver.save(sess,
os.path.join(training_path,
'fast-style-model.ckpt'),
global_step=step)
if step == 20000:
saver.save(
sess,
os.path.join(training_path,
'fast-style-model.ckpt-done'))
break
except tf.errors.OutOfRangeError:
saver.save(
sess,
os.path.join(training_path, 'fast-style-model.ckpt-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def general_nfold_cv(XD, XT, Y, label_row_inds, label_col_inds, prfmeasure,
FLAGS, labeled_sets, val_sets, get_aupr, get_rm2):
paramset1 = FLAGS.num_windows
paramset2 = FLAGS.smi_window_lengths
paramset3 = FLAGS.seq_window_lengths
lamda_set = FLAGS.lamda
batchsz = FLAGS.batch_size # 256
logging("---Parameter Search-----", FLAGS)
w = len(val_sets)
h = len(paramset1) * len(paramset2) * len(paramset3) * len(lamda_set)
all_predictions = [[0 for x in range(w)] for y in range(h)]
all_losses = [[0 for x in range(w)] for y in range(h)]
for foldind in range(len(val_sets)):
valinds = val_sets[foldind]
labeledinds = labeled_sets[foldind]
trrows = label_row_inds[labeledinds]
trcols = label_col_inds[labeledinds]
train_dataset = prepare_interaction_pairs(XD, XT, Y, trrows, trcols)
terows = label_row_inds[valinds]
tecols = label_col_inds[valinds]
test_dataset = prepare_interaction_pairs(XD, XT, Y, terows, tecols)
pointer = 0
train_loader = DataLoader(dataset=train_dataset,
batch_size=batchsz,
shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batchsz)
for param1value in paramset1: # hidden neurons
for param2value in paramset2: # learning rate
for param3value in paramset3:
for lamda in lamda_set:
model = net(FLAGS, param1value, param2value,
param3value).cuda()
model.apply(weights_init)
rperf_list = []
for epochind in range(FLAGS.num_epoch):
model = train(train_loader, model, FLAGS,
param1value, param2value,
param3value, lamda)
rperf, loss, rm2, auc = test(
model, test_loader, FLAGS, param1value,
param2value, param3value, lamda)
rperf_list.append(rperf)
##Set the conditions for early stopping
if (epochind + 1) % 5 == 0:
print(
'val: epoch:{},p1:{},p2:{},p3:{},loss:{:.5f},rperf:{:.5f}, rm2:{:.5f}'
.format(epochind, param1value, param2value,
param3value, loss, rperf, rm2))
if rperf >= max(rperf_list):
torch.save(model, 'checkpoint.pth')
if rperf < max(rperf_list) - 0.1:
print(
'The program is stopped early for better performance.'
)
break
logging(
"P1 = %d, P2 = %d, P3 = %d, Fold = %d, CI-i = %f, MSE = %f, rm2 = %f"
% (param1value, param2value, param3value, foldind,
rperf, loss, rm2), FLAGS)
all_predictions[pointer][
foldind] = rperf # TODO FOR EACH VAL SET allpredictions[pointer][foldind]
all_losses[pointer][foldind] = loss
pointer += 1
bestperf = -float('Inf')
bestpointer = None
best_param_list = []
##Take average according to folds, then chooose best params
pointer = 0
for param1value in paramset1:
for param2value in paramset2:
for param3value in paramset3:
for lamda in lamda_set:
avgperf = 0.
for foldind in range(len(val_sets)):
foldperf = all_predictions[pointer][foldind]
avgperf += foldperf
avgperf /= len(val_sets)
if avgperf > bestperf:
bestperf = avgperf
bestpointer = pointer
best_param_list = [
param1value,
param2value,
param3value,
lamda,
]
pointer += 1
return bestpointer, best_param_list, bestperf, all_predictions, all_losses
def main(args):
g = tf.Graph() # A new graph
with g.as_default():
with tf.Session() as sess:
# Building graph.
image_data = tf.placeholder(tf.int32, name='input_image')
height = tf.placeholder(tf.int32, name='height')
width = tf.placeholder(tf.int32, name='width')
# Reshape data
image = tf.reshape(image_data, [height, width, 3])
processed_image = utils.mean_image_subtraction(
image, [123.68, 116.779, 103.939]) # Preprocessing image
batched_image = tf.expand_dims(processed_image,
0) # Add batch dimension
generated_image = model.net(batched_image, training=False)
casted_image = tf.cast(generated_image, tf.int32)
# Remove batch dimension
squeezed_image = tf.squeeze(casted_image, [0])
cropped_image = tf.slice(squeezed_image, [0, 0, 0],
[height, width, 3])
# stylized_image = tf.image.encode_jpeg(squeezed_image, name='output_image')
stylized_image_data = tf.reshape(cropped_image, [-1],
name='output_image')
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(),
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Use absolute path.
model_file = os.path.abspath(args.model_file)
saver.restore(sess, model_file)
if args.is_debug:
content_file = '/Users/Lex/Desktop/t.jpg'
generated_file = '/Users/Lex/Desktop/xwz-stylized.jpg'
with open(generated_file, 'wb') as img:
image_bytes = tf.read_file(content_file)
input_array, decoded_image = sess.run([
tf.reshape(
tf.image.decode_jpeg(image_bytes, channels=3),
[-1]),
tf.image.decode_jpeg(image_bytes, channels=3)
])
start_time = time.time()
img.write(
sess.run(tf.image.encode_jpeg(
tf.cast(cropped_image, tf.uint8)),
feed_dict={
image_data: input_array,
height: decoded_image.shape[0],
width: decoded_image.shape[1]
}))
end_time = time.time()
tf.logging.info('Elapsed time: %fs' %
(end_time - start_time))
else:
output_graph_def = tf.graph_util.convert_variables_to_constants(
sess, sess.graph_def, output_node_names=['output_image'])
with tf.gfile.FastGFile('/Users/Lex/Desktop/' +
args.model_name + '.pb',
mode='wb') as f:
f.write(output_graph_def.SerializeToString())
def main(argv=None):
run_id = FLAGS.NAME if FLAGS.NAME else str(uuid.uuid4())
model_path = '%s/%s' % (FLAGS.MODEL_PATH, run_id)
if not os.path.exists(model_path):
os.makedirs(model_path)
summary_path = '%s/%s' % (FLAGS.SUMMARY_PATH, run_id)
if not os.path.exists(summary_path):
os.makedirs(summary_path)
style_paths = FLAGS.STYLE_IMAGES.split(',')
style_layers = FLAGS.STYLE_LAYERS.split(',')
content_layers = FLAGS.CONTENT_LAYERS.split(',')
style_features_t = get_style_features(style_paths, style_layers)
images = reader.image(FLAGS.BATCH_SIZE, FLAGS.IMAGE_SIZE, FLAGS.TRAIN_IMAGES_PATH)
generated = model.net(images - reader.mean_pixel, training=True)
# Put both generated and training images in same batch through VGG net for efficiency
net, _ = vgg.net(FLAGS.VGG_PATH, tf.concat(0, [generated, images]) - reader.mean_pixel)
content_loss = 0
for layer in content_layers:
generated_images, content_images = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
shape = tf.shape(generated_images)
width = shape[1]
height = shape[2]
num_filters = shape[3]
content_loss += tf.nn.l2_loss(generated_images - content_images) / tf.to_float(size)
content_loss = content_loss
style_loss = 0
for style_grams, layer in zip(style_features_t, style_layers):
generated_images, _ = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
for style_gram in style_grams:
style_loss += tf.nn.l2_loss(gram(generated_images) - style_gram) / tf.to_float(size)
style_loss = style_loss / len(style_paths)
tv_loss = total_variation_loss(generated)
loss = FLAGS.STYLE_WEIGHT * style_loss + FLAGS.CONTENT_WEIGHT * content_loss + FLAGS.TV_WEIGHT * tv_loss
global_step = tf.Variable(0, name="global_step", trainable=False)
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=global_step)
# Statistics
with tf.name_scope('losses'):
tf.scalar_summary('content loss', content_loss)
tf.scalar_summary('style loss', style_loss)
tf.scalar_summary('regularizer loss', tv_loss)
with tf.name_scope('weighted_losses'):
tf.scalar_summary('weighted content loss', content_loss * FLAGS.CONTENT_WEIGHT)
tf.scalar_summary('weighted style loss', style_loss * FLAGS.STYLE_WEIGHT)
tf.scalar_summary('weighted regularizer loss', tv_loss * FLAGS.TV_WEIGHT)
tf.scalar_summary('total loss', loss)
tf.image_summary('original', images)
tf.image_summary('generated', generated)
summary = tf.merge_all_summaries()
step=0
with tf.Session() as sess:
writer = tf.train.SummaryWriter(summary_path, sess.graph)
saver = tf.train.Saver(tf.all_variables())
file = tf.train.latest_checkpoint(model_path)
sess.run([tf.initialize_all_variables(), tf.initialize_local_variables()])
if file:
print('Restoring model from {}'.format(file))
saver.restore(sess, file)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while step<=1000:
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
if step % 10== 0:
print(step, loss_t, elapsed_time)
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
if step % 10 == 0:
saver.save(sess, model_path + '/fast-style-model', global_step=step)
except tf.errors.OutOfRangeError:
saver.save(sess, model_path + '/fast-style-model-done')
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def main(argv=None):
content_layers = FLAGS.content_layers.split(',')
style_layers = FLAGS.style_layers.split(',')
style_layers_weights = [
float(i) for i in FLAGS.style_layers_weights.split(",")
]
#num_steps_decay = 82786 / FLAGS.batch_size
num_steps_decay = 10000
style_features_t = losses.get_style_features(FLAGS)
training_path = os.path.join(FLAGS.model_path, FLAGS.naming)
if not (os.path.exists(training_path)):
os.makedirs(training_path)
with tf.Session() as sess:
"""Build Network"""
network_fn = nets_factory.get_network_fn(FLAGS.loss_model,
num_classes=1,
is_training=False)
image_preprocessing_fn, image_unprocessing_fn = preprocessing_factory.get_preprocessing(
FLAGS.loss_model, is_training=False)
processed_images = reader.image(FLAGS.batch_size,
FLAGS.image_size,
FLAGS.image_size,
'train2014/',
image_preprocessing_fn,
epochs=FLAGS.epoch)
generated = model.net(processed_images, FLAGS.alpha)
processed_generated = [
image_preprocessing_fn(image, FLAGS.image_size, FLAGS.image_size)
for image in tf.unstack(generated, axis=0, num=FLAGS.batch_size)
]
processed_generated = tf.stack(processed_generated)
_, endpoints_dict = network_fn(tf.concat(
[processed_generated, processed_images], 0),
spatial_squeeze=False)
"""Build Losses"""
content_loss = losses.content_loss(endpoints_dict, content_layers)
style_loss, style_losses = losses.style_loss(endpoints_dict,
style_features_t,
style_layers,
style_layers_weights)
tv_loss = losses.total_variation_loss(
generated) # use the unprocessed image
content_loss = FLAGS.content_weight * content_loss
style_loss = FLAGS.style_weight * style_loss
tv_loss = FLAGS.tv_weight * tv_loss
loss = style_loss + content_loss + tv_loss
"""Prepare to Train"""
global_step = tf.Variable(0, name="global_step", trainable=False)
variable_to_train = []
for variable in tf.trainable_variables():
if not (variable.name.startswith(FLAGS.loss_model)):
variable_to_train.append(variable)
lr = tf.train.exponential_decay(learning_rate=1e-1,
global_step=global_step,
decay_steps=num_steps_decay,
decay_rate=1e-1,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate=lr, epsilon=1e-8)
train_op = optimizer.minimize(loss,
global_step=global_step,
var_list=variable_to_train)
#train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=global_step, var_list=variable_to_train)
variables_to_restore = []
for v in tf.global_variables():
if not (v.name.startswith(FLAGS.loss_model)):
variables_to_restore.append(v)
saver = tf.train.Saver(variables_to_restore)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
init_func = utils._get_init_fn(FLAGS)
init_func(sess)
last_file = tf.train.latest_checkpoint(training_path)
if last_file:
saver.restore(sess, last_file)
"""Start Training"""
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
try:
while not coord.should_stop():
_, c_loss, s_losses, t_loss, total_loss, step = sess.run([
train_op, content_loss, style_losses, tv_loss, loss,
global_step
])
"""logging"""
if step % 10 == 0:
print(step, c_loss, s_losses, t_loss, total_loss)
"""checkpoint"""
if step % 10000 == 0:
saver.save(sess,
os.path.join(training_path, 'fast-style-model'),
global_step=step)
if step == FLAGS.max_iter:
saver.save(
sess,
os.path.join(training_path, 'fast-style-model-done'))
break
except tf.errors.OutOfRangeError:
saver.save(sess,
os.path.join(training_path, 'fast-style-model-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def main():
# get the style features of the style image in the loss model
style_features = get_style_features()
training_path = os.path.join(model_path, style_name)
if os.path.exists(training_path) is False:
os.makedirs(training_path)
with tf.Graph().as_default():
with tf.Session() as sess:
"""Build Network"""
# loss network
net_fn = nets_factory.get_network_fn(loss_model,
num_classes=1,
is_training=False)
# get preprocessing function
preprocessing_fn, unprocessing_fn = preprocessing_factory.get_preprocessing(
loss_model, is_training=False)
# read images for training
processed_images = read_images(train_image_path,
preprocessing_fn,
image_size,
image_size,
batch_size=batch_size,
epoch=2,
shuffle=True)
generated = model.net(processed_images, training=True)
processed_generated = [
preprocessing_fn(image, image_size, image_size)
for image in tf.unstack(generated, axis=0, num=batch_size)
]
processed_generated = tf.stack(processed_generated)
_, endpoints_dict = net_fn(tf.concat(
[processed_generated, processed_images], 0),
spatial_squeeze=False)
# Log the structure of loss network
tf.logging.info(
'Loss network layers(You can define them in "content_layers" and "style_layers"):'
)
for key in endpoints_dict:
tf.logging.info(key)
# calculate losses
content_loss = calcu_content_loss(endpoints_dict, content_layers)
style_loss, style_loss_summary = calcu_style_loss(
endpoints_dict, style_features, style_layers)
tv_loss = total_variation_loss(generated)
loss = content_loss * content_weight + style_loss * style_weight + tv_loss * tv_weight
# Add Summary for visualization in tensorboard.
"""Add Summary"""
tf.summary.scalar('losses/content_loss', content_loss)
tf.summary.scalar('losses/style_loss', style_loss)
tf.summary.scalar('losses/regularizer_loss', tv_loss)
tf.summary.scalar('weighted_losses/weighted_content_loss',
content_loss * content_weight)
tf.summary.scalar('weighted_losses/weighted_style_loss',
style_loss * style_weight)
tf.summary.scalar('weighted_losses/weighted_regularizer_loss',
tv_loss * tv_weight)
tf.summary.scalar('total_loss', loss)
for layer in style_layers:
tf.summary.scalar('style_losses/' + layer,
style_loss_summary[layer])
tf.summary.image('generated', generated)
# tf.image_summary('processed_generated', processed_generated) # May be better?
tf.summary.image(
'origin',
tf.stack([
unprocessing_fn(image) for image in tf.unstack(
processed_images, axis=0, num=batch_size)
]))
tf.summary.image(
'processed',
tf.stack([
image for image in tf.unstack(
processed_images, axis=0, num=batch_size)
]))
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(training_path, sess.graph)
"""Prepare to Train"""
global_step = tf.Variable(0, name='global_step', trainable=False)
variable_to_train = []
for variable in tf.trainable_variables():
if not (variable.name.startswith(loss_model)):
variable_to_train.append(variable)
train_optimizer = tf.train.AdamOptimizer(1e-3).minimize(
loss, global_step=global_step, var_list=variable_to_train)
variables_to_restore = []
for variable in tf.global_variables():
if not (variable.name.startswith(loss_model)):
variables_to_restore.append(variable)
saver = tf.train.Saver(variables_to_restore,
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Restore variables for loss network.
init_func = get_init_fn(loss_model_file, checkpoint_exclude_scopes)
init_func(sess)
last_file = tf.train.latest_checkpoint(training_path)
if last_file:
tf.logging.info('Restoring model from {}'.format(last_file))
saver.restore(sess, last_file)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run(
[train_optimizer, loss, global_step])
evaluate_time = time.time() - start_time
start_time = time.time()
if step % 10 == 0:
tf.logging.info(
'step: %d, total Loss %f, secs/step: %f' %
(step, loss_t, evaluate_time))
if step % 25 == 0:
tf.logging.info('adding summary...')
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
writer.flush()
if step % 200 == 0:
saver.save(sess,
os.path.join(training_path,
'fast-style-model.ckpt'),
global_step=step)
evaluate(
evaluate_test_image,
os.path.join(
training_path,
'fast-style-model.ckpt' + '-' + str(step)),
os.path.join(training_path,
str(step) + '.jpg'))
except tf.errors.OutOfRangeError:
saver.save(
sess,
os.path.join(training_path, 'fast-style-model.ckpt-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
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)
def main(_):
# Get image's height and width.
height = 0
width = 0
with tf.gfile.GFile(FLAGS.image_file, 'rb') as f:
with tf.Session().as_default() as sess:
if FLAGS.image_file.lower().endswith('png'):
image = sess.run(tf.image.decode_png(f.read()))
else:
image = sess.run(tf.image.decode_jpeg(f.read()))
height = image.shape[0]
width = image.shape[1]
tf.logging.info('Image size: %dx%d' % (width, height))
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
# Read image data.
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
FLAGS.loss_model,
is_training=False)
image = reader.get_image(FLAGS.image_file, height, width, image_preprocessing_fn)
print(image)
plt.subplot(121)
plt.imshow(sess.run(image))
# Add batch dimension
image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.cast(generated, tf.uint8)
# Remove batch dimension
generated = tf.squeeze(generated, [0])
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(), write_version=tf.train.SaverDef.V1)
sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
# Use absolute path
FLAGS.model_file = os.path.abspath(FLAGS.model_file)
saver.restore(sess, FLAGS.model_file)
summary_writer = tf.summary.FileWriter("logs",sess.graph)
# Make sure 'generated' directory exists.
generated_file = 'generated/res.jpg'
if os.path.exists('generated') is False:
os.makedirs('generated')
# Generate and write image data to file.
with tf.gfile.GFile(generated_file, 'wb') as f:
plt.subplot(122)
plt.imshow(sess.run(generated))
plt.show()
start_time = time.time()
f.write(sess.run(tf.image.encode_jpeg(generated)))
end_time = time.time()
tf.logging.info('Elapsed time: %fs' % (end_time - start_time))
tf.logging.info('Done. Please check %s.' % generated_file)
def infer():
# Load arguments
args = parse_args()
# args.batch_size = 1
word2id = data.read_dictionary("data/pre_trained_word2id.pkl")
embeddings = np.load("data/pre_trained_embeddings.npy")
# word2id = data.read_dictionary("data/pre_trained_copy_mini_word2id.pkl")
# embeddings = np.load("data/pre_trained_copy_mini_embeddings.npy")
# word2id_output_mini = {}
# for i, k in enumerate(word2id):
# word2id_output_mini[k] = i
# if i > 9100:
# break
# word2id_output_mini["<S>"] = 1
# word2id_output_mini["<E>"] = 2
# word2id = word2id_output_mini
word2id_output = word2id.copy()
word_ori_size = len(word2id)
# word_mini_size = len(word2id_output)
# word_size = word_ori_size
# word_size = word_mini_size
word_size = 0
tag_size = 0
for k in tag2label:
if tag2label[k] > tag_size:
tag_size = tag2label[k]
tag2label[k] += args.max_length
if tag2label[k] > word_size:
word_size = tag2label[k]
# word2id_output.update(tag2label)
word2id_output = tag2label
word2id_output["<S>"] = word_size + 1
word2id_output["<E>"] = word_size + 2
word_size += 3
tag_size += 3
print("output size", word_size, tag_size)
# # Dictrionaries init
# word2id = data.read_dictionary("data/pre_trained_word2id.pkl")
# embeddings = np.load("data/pre_trained_embeddings.npy")
# word2id_output = word2id.copy()
# word_mini_size = len(word2id)
# word_size = 0
# for k in tag2label:
# tag2label[k] += word_mini_size
# if tag2label[k] > word_size:
# word_size = tag2label[k]
# tag2label["<S>"] = word_size + 1
# tag2label["<E>"] = word_size + 2
# word_size += 3
# word2id_output.update(tag2label)
# # print(type(word2id), len(word2id))
# # print(type(entity2id), len(entity2id))
# # print(type(pos2id), len(pos2id))
# # print(type(word2id_output), len(word2id_output))
id2entity = {}
for k in entity2id:
id2entity[entity2id[k]] = k
id2word = {}
for k in word2id:
id2word[word2id[k]] = k
id2word_output = {}
for k in word2id_output:
id2word_output[word2id_output[k]] = k
src_dict, trg_dict = id2word, id2word_output
# Load data
# data_train = data_load("data/train_pos.txt",
# data=data, word2id=word2id, entity2id=entity2id,
# pos2id=pos2id, word2id_output=word2id_output,
# event_args=event_args)
data_train = data_load("data/ace_data/train.txt",
data=data,
word2id=word2id,
entity2id=entity2id,
pos2id=pos2id,
word2id_output=word2id_output,
event_args=event_args,
generate=True)
data_dev = data_load("data/ace_data/dev.txt",
data=data,
word2id=word2id,
entity2id=entity2id,
pos2id=pos2id,
word2id_output=word2id_output,
event_args=event_args,
generate=True)
data_test = data_load("data/ace_data/test.txt",
data=data,
word2id=word2id,
entity2id=entity2id,
pos2id=pos2id,
word2id_output=word2id_output,
event_args=event_args,
generate=True)
# data_test = data_train
print("=====Init scores")
scores = generate_pr(word_dict=id2word_output)
scores.append_label(data_test)
# Inference
net = model.net(
args.embedding_dim,
args.encoder_size,
args.decoder_size,
word_ori_size,
word_size,
tag_size,
True,
# False,
beam_size=args.beam_size,
max_length=args.max_length,
source_entity_dim=len(entity2id),
source_pos_dim=len(pos2id),
embedding_entity_dim=args.embedding_entity_dim,
embedding_pos_dim=args.embedding_pos_dim,
end_id=word2id_output["<E>"])
# test_batch_generator = paddle.batch(
# paddle.reader.shuffle(
# paddle.dataset.wmt14.test(args.dict_size), buf_size=1000),
# batch_size=args.batch_size,
# drop_last=False)
dev_batch_generator = paddle.batch(paddle.reader.buffered(data_dev,
size=1000),
batch_size=args.batch_size,
drop_last=False)
test_batch_generator = paddle.batch(paddle.reader.buffered(data_test,
size=1000),
batch_size=args.batch_size,
drop_last=False)
print("begin memory optimization ...")
# fluid.memory_optimize(train_program)
fluid.memory_optimize(framework.default_main_program())
print("end memory optimization ...")
place = core.CUDAPlace(0) if args.use_gpu else core.CPUPlace()
exe = Executor(place)
exe.run(framework.default_startup_program())
# # exe = fluid.ParallelExecutor(use_cuda=args.use_gpu)
# os.environ['CPU_NUM'] = "2"
# exe = fluid.parallel_executor.ParallelExecutor(
# use_cuda=args.use_gpu, num_trainers=2,
# # loss_name=avg_cost.name,
# main_program=fluid.default_main_program())
# LOAD Model
model_path = os.path.join(args.save_dir, str(args.load_pass_num))
fluid.io.load_persistables(executor=exe,
dirname=model_path,
main_program=framework.default_main_program())
print("==Model loaded", args.save_dir)
translation_ids = net.translation_ids
translation_scores = net.translation_scores
feed_order = net.feeding_list
feed_list = [
framework.default_main_program().global_block().var(var_name)
for var_name in feed_order
]
# print(feed_list)
feeder = fluid.DataFeeder(feed_list, place)
scores.reset()
for batch_id, _data in enumerate(test_batch_generator()):
print("=====", batch_id, len(_data))
# The value of batch_size may vary in the last batch
batch_size = len(_data)
# Setup initial ids and scores lod tensor
# init_ids_data = np.array([0 for _ in range(batch_size)], dtype='int64')
init_ids_data = np.array(
[word2id_output["<S>"] for _ in range(batch_size)], dtype='int64')
init_scores_data = np.array([1. for _ in range(batch_size)],
dtype='float32')
init_ids_data = init_ids_data.reshape((batch_size, 1))
init_scores_data = init_scores_data.reshape((batch_size, 1))
init_recursive_seq_lens = [1] * batch_size
init_recursive_seq_lens = [
init_recursive_seq_lens, init_recursive_seq_lens
]
init_ids = fluid.create_lod_tensor(init_ids_data,
init_recursive_seq_lens, place)
init_scores = fluid.create_lod_tensor(init_scores_data,
init_recursive_seq_lens, place)
# print(init_ids_data.shape)
# print(init_recursive_seq_lens)
# print(init_ids.lod())
# print(init_scores.lod())
# Feed dict for inference
feed_dict = feeder.feed([x for x in _data])
feed_dict['init_ids'] = init_ids
feed_dict['init_scores'] = init_scores
print("=====")
fetch_outs = exe.run(
framework.default_main_program(),
feed=feed_dict,
fetch_list=[translation_ids, translation_scores],
# fetch_list=[translation_ids],
return_numpy=False)
# print(np.array(fetch_outs[0]))
# print(np.array(fetch_outs[0]).shape)
print("=====Update scores")
scores.update(preds=fetch_outs[0],
labels=[_[-1] for _ in _data],
words_list=[_[0] for _ in _data],
for_generate=True)
# Split the output words by lod levels
end_id = word2id_output["<E>"]
result = []
paragraphs = []
for ids in np.array(fetch_outs[0]):
# print("##", ids.shape)
# print("##", ids)
new_ids = []
new_words = []
pre_id = -1
for _id in ids:
if _id == end_id or \
_id == pre_id:
break
pre_id = _id
new_ids.append(_id)
if _id < args.max_length:
new_words.append(str(_id))
else:
new_words.append(trg_dict[_id])
result.append(new_ids)
paragraphs.append(new_words)
# lod_level_1 = fetch_outs[0].lod()[1]
# token_array = np.array(fetch_outs[0])
# result = []
# for i in six.moves.xrange(len(lod_level_1) - 1):
# sentence_list = [
# trg_dict[token]
# for token in token_array[lod_level_1[i]:lod_level_1[i + 1]]
# ]
# sentence = " ".join(sentence_list[1:-1])
# result.append(sentence)
# lod_level_0 = fetch_outs[0].lod()[0]
# paragraphs = [
# result[lod_level_0[i]:lod_level_0[i + 1]]
# for i in six.moves.xrange(len(lod_level_0) - 1)
# ]
# target_sentence_list = [" ".join(
# [trg_dict[__]
# for __ in _[-1]])
# for _ in _data]
target_sentence_list = []
for item in _data:
target_words = []
for _id in item[-1]:
if _id < args.max_length:
target_words.append(str(_id))
else:
target_words.append(trg_dict[_id])
target_sentence_list.append(" ".join(target_words))
source_sentence_list = []
source_entity_list = []
for item in _data:
target_words = []
for _id in item[0]:
target_words.append(src_dict[_id])
source_sentence_list.append(target_words)
entity_tag = []
for _id in item[1]:
entity_tag.append(id2entity[_id])
source_entity_list.append(entity_tag)
print("=====Print text")
for paragraph, sentence, source , entities in \
zip(paragraphs, target_sentence_list, \
source_sentence_list, source_entity_list):
print("-----")
new_words = []
indexes = range(len(source))
for i, word, entity in zip(indexes, source, entities):
new_words.append(word + "(" + str(i) + " " + entity + ")")
print(" ".join(new_words))
print("=Predict:", " ".join(paragraph[1:]))
print("=Label:", sentence)
scores.eval_show()
def main(FLAGS):
style_features_t = losses.get_style_features(FLAGS)
# Make sure the training path exists.
training_path = os.path.join(FLAGS.model_path, FLAGS.naming)
if not(os.path.exists(training_path)):
os.makedirs(training_path)
with tf.Graph().as_default():
with tf.Session() as sess:
"""Build Network"""
network_fn = nets_factory.get_network_fn(
FLAGS.loss_model,
num_classes=1,
is_training=False)
image_preprocessing_fn, image_unprocessing_fn = preprocessing_factory.get_preprocessing(
FLAGS.loss_model,
is_training=False)
processed_images = reader.image(FLAGS.batch_size, FLAGS.image_size, FLAGS.image_size,
'train2014/', image_preprocessing_fn, epochs=FLAGS.epoch)
generated = model.net(processed_images, training=True)
processed_generated = [image_preprocessing_fn(image, FLAGS.image_size, FLAGS.image_size)
for image in tf.unstack(generated, axis=0, num=FLAGS.batch_size)
]
processed_generated = tf.stack(processed_generated)
_, endpoints_dict = network_fn(tf.concat([processed_generated, processed_images], 0), spatial_squeeze=False)
# Log the structure of loss network
tf.logging.info('Loss network layers(You can define them in "content_layers" and "style_layers"):')
for key in endpoints_dict:
tf.logging.info(key)
"""Build Losses"""
content_loss = losses.content_loss(endpoints_dict, FLAGS.content_layers)
style_loss, style_loss_summary = losses.style_loss(endpoints_dict, style_features_t, FLAGS.style_layers)
tv_loss = losses.total_variation_loss(generated) # use the unprocessed image
loss = FLAGS.style_weight * style_loss + FLAGS.content_weight * content_loss + FLAGS.tv_weight * tv_loss
# Add Summary for visualization in tensorboard.
"""Add Summary"""
tf.summary.scalar('losses/content_loss', content_loss)
tf.summary.scalar('losses/style_loss', style_loss)
tf.summary.scalar('losses/regularizer_loss', tv_loss)
tf.summary.scalar('weighted_losses/weighted_content_loss', content_loss * FLAGS.content_weight)
tf.summary.scalar('weighted_losses/weighted_style_loss', style_loss * FLAGS.style_weight)
tf.summary.scalar('weighted_losses/weighted_regularizer_loss', tv_loss * FLAGS.tv_weight)
tf.summary.scalar('total_loss', loss)
for layer in FLAGS.style_layers:
tf.summary.scalar('style_losses/' + layer, style_loss_summary[layer])
tf.summary.image('generated', generated)
# tf.image_summary('processed_generated', processed_generated) # May be better?
tf.summary.image('origin', tf.stack([
image_unprocessing_fn(image) for image in tf.unstack(processed_images, axis=0, num=FLAGS.batch_size)
]))
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(training_path)
"""Prepare to Train"""
global_step = tf.Variable(0, name="global_step", trainable=False)
variable_to_train = []
for variable in tf.trainable_variables():
if not(variable.name.startswith(FLAGS.loss_model)):
variable_to_train.append(variable)
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=global_step, var_list=variable_to_train)
variables_to_restore = []
for v in tf.global_variables():
if not(v.name.startswith(FLAGS.loss_model)):
variables_to_restore.append(v)
saver = tf.train.Saver(variables_to_restore, write_version=tf.train.SaverDef.V1)
sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
# Restore variables for loss network.
init_func = utils._get_init_fn(FLAGS)
init_func(sess)
# Restore variables for training model if the checkpoint file exists.
last_file = tf.train.latest_checkpoint(training_path)
if last_file:
tf.logging.info('Restoring model from {}'.format(last_file))
saver.restore(sess, last_file)
"""Start Training"""
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
"""logging"""
# print(step)
if step % 10 == 0:
tf.logging.info('step: %d, total Loss %f, secs/step: %f' % (step, loss_t, elapsed_time))
"""summary"""
if step % 25 == 0:
tf.logging.info('adding summary...')
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
writer.flush()
"""checkpoint"""
if step % 1000 == 0:
saver.save(sess, os.path.join(training_path, 'fast-style-model.ckpt'), global_step=step)
except tf.errors.OutOfRangeError:
saver.save(sess, os.path.join(training_path, 'fast-style-model.ckpt-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
model_name = '%s_%s_%s_%s_%s_%s_%s' %(args.data_set,args.task,control_flow_p,time_p,resource_p,data_p,transition)
log_config = {"control_flow_p":control_flow_p, "time_p":time_p, "resource_p":resource_p, "data_p":data_p, "transition":transition}
# import models
checkpoint_dir=args.checkpoint_dir
if status == 'o':
model_name = 'o-%s_%s_%s_%s_%s_%s_%s_%s_%s' %(args.data_set,args.task,control_flow_p,time_p,resource_p,data_p,transition,num_epochs,batch_size)
print(model_name)
elif status == 'p':
model_name = 'p-%s_%s_%s_%s_%s_%s_%s_%s_%s' %(args.data_set,args.task,control_flow_p,time_p,resource_p,data_p,transition,num_epochs,batch_size)
print(model_name)
model = net()
model.load(checkpoint_dir,model_name=model_name)
##Mozhgan
# filename = "../sample_data/Testing/BPIC_2012_100_Testing.csv"
# print("flag: loading data")
# fg = FeatureGenerator()
# df = fg.create_initial_log(filename, log_config)
# print("done")
# num_events = len(df)
# num_cases = len(set(df["id"]))
def evaluate(opt):
_, _, TEST = maybeExtract(opt.data, opt.patch_size)
test_data, test_label = TEST[0], TEST[1]
HEIGHT = test_data.shape[1]
WIDTH = test_data.shape[2]
CHANNELS = test_data.shape[3]
N_PARALLEL_BAND = number_of_band[opt.data]
NUM_CLASS = test_label.shape[1]
graph = tf.Graph()
with graph.as_default():
# Define Model entry placeholder
img_entry = tf.placeholder(tf.float32,
shape=[None, WIDTH, HEIGHT, CHANNELS])
img_label = tf.placeholder(tf.uint8, shape=[None, NUM_CLASS])
# Get true class from one-hot encoded format
image_true_class = tf.argmax(img_label, axis=1)
# Dropout probability for the model
prob = tf.placeholder(tf.float32)
# Network model definition
model = net(img_entry, prob, HEIGHT, WIDTH, CHANNELS, N_PARALLEL_BAND,
NUM_CLASS)
# Cost Function
final_layer = model['dense3']
with tf.name_scope('loss'):
cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=final_layer, labels=img_label)
cost = tf.reduce_mean(cross_entropy)
# Optimisation function
with tf.name_scope('adam_optimizer'):
optimizer = tf.train.AdamOptimizer(
learning_rate=0.0005).minimize(cost)
# Model Performance Measure
with tf.name_scope('accuracy'):
predict_class = model['predict_class_number']
correction = tf.equal(predict_class, image_true_class)
accuracy = tf.reduce_mean(tf.cast(correction, tf.float32))
saver = tf.train.Saver()
with tf.Session(graph=graph) as session:
saver.restore(
session,
tf.train.latest_checkpoint('./Trained_model/' + str(opt.data) +
'/'))
def test(t_data, t_label, test_iterations=1, evalate=False):
assert test_data.shape[0] == test_label.shape[0]
y_predict_class = model['predict_class_number']
# OverallAccuracy, averageAccuracy and accuracyPerClass
overAllAcc, avgAcc, averageAccClass = [], [], []
for _ in range(test_iterations):
pred_class = []
for t in tqdm(t_data):
t = np.expand_dims(t, axis=0)
feed_dict_test = {img_entry: t, prob: 1.0}
prediction = session.run(y_predict_class,
feed_dict=feed_dict_test)
pred_class.append(prediction)
true_class = np.argmax(t_label, axis=1)
conMatrix = confusion_matrix(true_class, pred_class)
# Calculate recall score across each class
classArray = []
for c in range(len(conMatrix)):
recallScore = conMatrix[c][c] / sum(conMatrix[c])
classArray += [recallScore]
averageAccClass.append(classArray)
avgAcc.append(sum(classArray) / len(classArray))
overAllAcc.append(accuracy_score(true_class, pred_class))
averageAccClass = np.transpose(averageAccClass)
meanPerClass = np.mean(averageAccClass, axis=1)
showClassTable(meanPerClass, title='Class accuracy')
print('Average Accuracy: ' + str(np.mean(avgAcc)))
print('Overall Accuracy: ' + str(np.mean(overAllAcc)))
# -- Pixel-wise classification --#
def pixelClassification():
input_mat, _ = maybeDownloadOrExtract(opt.data)
input_height, input_width = input_mat.shape[
0], input_mat.shape[1]
BAND = input_mat.shape[2]
PATCH_SIZE = opt.patch_size
MEAN_ARRAY = np.ndarray(shape=(BAND, 1))
new_input_mat = []
calib_val_pad = int((PATCH_SIZE - 1) / 2)
for i in range(BAND):
MEAN_ARRAY[i] = np.mean(input_mat[:, :, i])
new_input_mat.append(
np.pad(input_mat[:, :, i],
calib_val_pad,
'constant',
constant_values=0))
new_input_mat = np.transpose(new_input_mat, (1, 2, 0))
input_mat = new_input_mat
def Patch(height_index, width_index):
transpose_array = input_mat
height_slice = slice(height_index,
height_index + PATCH_SIZE)
width_slice = slice(width_index, width_index + PATCH_SIZE)
patch = transpose_array[height_slice, width_slice, :]
mean_normalized_patch = []
for i in range(BAND):
mean_normalized_patch.append(patch[:, :, i] -
MEAN_ARRAY[i])
mean_normalized_patch = np.array(
mean_normalized_patch).astype(np.float16)
mean_normalized_patch = np.transpose(
mean_normalized_patch, (1, 2, 0))
return mean_normalized_patch
labelled_img = np.ndarray(shape=(input_height, input_width))
for i in tqdm(range(input_height - 1)):
for j in range(input_width - 1):
current_input = Patch(i, j)
current_input = np.expand_dims(current_input, axis=0)
feed_dict_test = {img_entry: current_input, prob: 1.0}
prediction = session.run(model['predict_class_number'],
feed_dict=feed_dict_test)
labelled_img[i, j] = prediction[0]
labelled_img += 1
labelled_img = np.pad(labelled_img, [(0, 1), (0, 0)],
'constant',
constant_values=(0, 0))
print(np.min(labelled_img), np.max(labelled_img),
labelled_img.shape)
GroundTruthVisualise(labelled_img, opt.data, False)
# Test and plot
test(test_data, test_label, test_iterations=1)
pixelClassification()
def train(data=data):
# Load arguments
args = parse_args()
options = vars(args)
print(json.dumps(options, ensure_ascii=False, indent=4))
# if not conf.pre_train_word_embedding:
# word2id = data.read_dictionary("train_data/word2id.pkl")
# embeddings = data.random_embedding(word2id, conf.embedding_dim)
# else:
# Dictrionaries init
word2id = data.read_dictionary("train_data/pre_trained_word2id.pkl")
# embeddings = np.load("train_data/pre_trained_embeddings.npy")
# word2id = data.read_dictionary("train_data/pre_trained_mini_word2id.pkl")
# embeddings = np.load("train_data/pre_trained_mini_embeddings.npy")
# word2id = data.read_dictionary("train_data/pre_trained_copy_mini_word2id.pkl")
# embeddings = np.load("train_data/pre_trained_copy_mini_embeddings.npy")
# word2id_output_mini = {}
# for i, k in enumerate(word2id):
# word2id_output_mini[k] = i
# if i > 9100:
# break
# word2id_output_mini["<S>"] = 1
# word2id_output_mini["<E>"] = 2
# word2id = word2id_output_mini
word2id_output = word2id.copy()
word_ori_size = len(word2id)
# word_mini_size = len(word2id_output)
# word_size = word_ori_size
# word_size = word_mini_size
word_size = 0
tag_size = 0
for k in tag2label:
if tag2label[k] > tag_size:
tag_size = tag2label[k]
tag2label[k] += args.max_length
if tag2label[k] > word_size:
word_size = tag2label[k]
# word2id_output.update(tag2label)
word2id_output = tag2label
word2id_output["<S>"] = word_size + 1
word2id_output["<E>"] = word_size + 2
word_size += 3
tag_size += 3
print("output size", word_size, tag_size)
# print(type(word2id), len(word2id))
# print(type(entity2id), len(entity2id))
# print(type(pos2id), len(pos2id))
# print(type(word2id_output), len(word2id_output))
# Load data
data_train = data_load("train_data/ace_data/train.txt",
data=data,
word2id=word2id,
entity2id=entity2id,
pos2id=pos2id,
word2id_output=word2id_output,
event_args=event_args)
data_dev = data_load("train_data/ace_data/dev.txt",
data=data,
word2id=word2id,
entity2id=entity2id,
pos2id=pos2id,
word2id_output=word2id_output,
event_args=event_args,
generate=True)
data_test = data_load("train_data/ace_data/test.txt",
data=data,
word2id=word2id,
entity2id=entity2id,
pos2id=pos2id,
word2id_output=word2id_output,
event_args=event_args,
generate=True)
if args.enable_ce:
framework.default_startup_program().random_seed = 111
# # Training process
# net = model.net(
# args.embedding_dim,
# args.encoder_size,
# args.decoder_size,
# word_ori_size,
# word_size,
# tag_size,
# False,
# beam_size=args.beam_size,
# max_length=args.max_length,
# source_entity_dim=len(entity2id),
# source_pos_dim=len(pos2id),
# embedding_entity_dim=args.embedding_entity_dim,
# embedding_pos_dim=args.embedding_pos_dim,
# end_id=word2id_output["<E>"])
# avg_cost = net.avg_cost
# feed_order = net.feeding_list
# # Test net
# net_test = model.net(
# args.embedding_dim,
# args.encoder_size,
# args.decoder_size,
# word_mini_size,
# word_size,
# True,
# beam_size=args.beam_size,
# max_length=args.max_length,
# source_entity_dim=len(entity2id),
# source_pos_dim=len(pos2id),
# embedding_entity_dim=args.embedding_entity_dim,
# embedding_pos_dim=args.embedding_pos_dim,
# end_id=word2id_output["<E>"])
# # # clone from default main program and use it as the validation program
# main_program = fluid.default_main_program()
# inference_program = fluid.default_main_program().clone(for_test=True)
# optimizer = fluid.optimizer.Adam(
# learning_rate=args.learning_rate,
# regularization=fluid.regularizer.L2DecayRegularizer(
# regularization_coeff=1e-5))
# optimizer.minimize(avg_cost, no_grad_set=net.no_grad_set)
# print("begin memory optimization ...")
# # fluid.memory_optimize(train_program)
# fluid.memory_optimize(main_program)
# print("end memory optimization ...")
# loss = avg_cost
train_program = fluid.Program()
train_startup = fluid.Program()
# if "CE_MODE_X" in os.environ:
# train_program.random_seed = 110
# train_startup.random_seed = 110
with fluid.program_guard(train_program, train_startup):
with fluid.unique_name.guard():
# Training process
net = model.net(args.embedding_dim,
args.encoder_size,
args.decoder_size,
word_ori_size,
word_size,
tag_size,
False,
beam_size=args.beam_size,
max_length=args.max_length,
source_entity_dim=len(entity2id),
source_pos_dim=len(pos2id),
embedding_entity_dim=args.embedding_entity_dim,
embedding_pos_dim=args.embedding_pos_dim,
end_id=word2id_output["<E>"])
loss = net.avg_cost
feed_order = net.feeding_list
# gradient clipping
fluid.clip.set_gradient_clip(
clip=fluid.clip.GradientClipByValue(max=1.0, min=-1.0))
optimizer = fluid.optimizer.Adam(
learning_rate=args.learning_rate,
regularization=fluid.regularizer.L2DecayRegularizer(
regularization_coeff=1e-5))
# optimizer = fluid.optimizer.Adam(
# learning_rate=fluid.layers.exponential_decay(
# learning_rate=args.learning_rate,
# decay_steps=400,
# decay_rate=0.9,
# staircase=True))
optimizer.minimize(loss)
avg_cost = loss
# print("begin memory optimization ...")
# fluid.memory_optimize(train_program)
# print("end memory optimization ...")
test_program = fluid.Program()
test_startup = fluid.Program()
# if "CE_MODE_X" in os.environ:
# test_program.random_seed = 110
# test_startup.random_seed = 110
with fluid.program_guard(test_program, test_startup):
with fluid.unique_name.guard():
# Test net
net_test = model.net(
args.embedding_dim,
args.encoder_size,
args.decoder_size,
word_ori_size,
word_size,
tag_size,
True,
beam_size=args.beam_size,
max_length=args.max_length,
source_entity_dim=len(entity2id),
source_pos_dim=len(pos2id),
embedding_entity_dim=args.embedding_entity_dim,
embedding_pos_dim=args.embedding_pos_dim,
end_id=word2id_output["<E>"])
test_program = test_program.clone(for_test=True)
main_program = train_program
inference_program = test_program
# print(type(paddle.dataset.wmt14.train(args.dict_size)))
# print(type(paddle.reader.shuffle(
# data_train, buf_size=1000)))
# print(args.enable_ce)
# for batch_id, data in enumerate(paddle.batch(
# paddle.reader.shuffle(
# paddle.dataset.wmt14.train(args.dict_size), buf_size=1000),
# batch_size=args.batch_size,
# drop_last=False)()):
# print(data)
# break
# Disable shuffle for Continuous Evaluation only
if not args.enable_ce:
train_batch_generator = paddle.batch(paddle.reader.shuffle(
data_train, buf_size=1000),
batch_size=args.batch_size,
drop_last=False)
else:
train_batch_generator = paddle.batch(data_train,
batch_size=args.batch_size,
drop_last=False)
dev_batch_generator = paddle.batch(paddle.reader.buffered(data_dev,
size=1000),
batch_size=args.batch_size,
drop_last=False)
test_batch_generator = paddle.batch(paddle.reader.buffered(data_test,
size=1000),
batch_size=args.batch_size,
drop_last=False)
# print (type(train_batch_generator))
# Init model
if args.use_gpu:
place = fluid.CUDAPlace(0)
dev_count = fluid.core.get_cuda_device_count()
else:
place = fluid.CPUPlace()
dev_count = int(os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
print("device count %d" % dev_count)
# print("theoretical memory usage: ")
# print(fluid.contrib.memory_usage(
# program=main_program, batch_size=args.batch_size))
# print("=====Init Main program")
# exe = Executor(place)
# # Init para
# exe.run(framework.default_startup_program())
# # exe = fluid.ParallelExecutor(use_cuda=args.use_gpu)
# # os.environ['CPU_NUM'] = "2"
# # exe = fluid.parallel_executor.ParallelExecutor(
# # use_cuda=args.use_gpu, num_trainers=2,
# # loss_name=avg_cost.name,
# # main_program=fluid.default_main_program())
exe = fluid.Executor(place)
print("=====Init train program")
exe.run(train_startup)
print("=====Init test program")
exe.run(test_startup)
# print("=====Init train exe")
# train_exe = fluid.ParallelExecutor(
# use_cuda=args.use_gpu, loss_name=loss.name, main_program=train_program)
# print("=====Init test exe")
# test_exe = fluid.ParallelExecutor(
# use_cuda=args.use_gpu,
# main_program=test_program,
# share_vars_from=train_exe)
## Set word emb
#print("=====Set word embedding")
#embeddings = embeddings.astype("float32")
#word_emb_param = fluid.global_scope().find_var(
# "emb").get_tensor()
#word_emb_param.set(embeddings, place)
print("=====Init Feeder")
feed_list = [
main_program.global_block().var(var_name) for var_name in feed_order
]
feed_list_test = [
inference_program.global_block().var(var_name)
for var_name in net_test.feeding_list
]
# print(feed_list)
feeder = fluid.DataFeeder(feed_list, place)
feeder_test = fluid.DataFeeder(feed_list_test, place)
# return
def validation(generater, test_scores):
# Use test set as validation each pass
test_scores.reset()
total_loss = 0.0
count = 0
# val_feed_list = [
# inference_program.global_block().var(var_name)
# for var_name in net_test.feeding_list
# ]
# val_feeder = fluid.DataFeeder(val_feed_list, place)
for batch_id, data in enumerate(generater()):
# The value of batch_size may vary in the last batch
batch_size = len(data)
# Setup initial ids and scores lod tensor
init_ids_data = np.array(
[word2id_output["<S>"] for _ in range(batch_size)],
dtype='int64')
init_scores_data = np.array([1. for _ in range(batch_size)],
dtype='float32')
init_ids_data = init_ids_data.reshape((batch_size, 1))
init_scores_data = init_scores_data.reshape((batch_size, 1))
init_recursive_seq_lens = [1] * batch_size
init_recursive_seq_lens = [
init_recursive_seq_lens, init_recursive_seq_lens
]
init_ids = fluid.create_lod_tensor(init_ids_data,
init_recursive_seq_lens, place)
init_scores = fluid.create_lod_tensor(init_scores_data,
init_recursive_seq_lens,
place)
# Feed dict for inference
# feed_dict = feeder.feed([[x[0]] for x in data])
feed_dict = feeder_test.feed(data)
feed_dict['init_ids'] = init_ids
feed_dict['init_scores'] = init_scores
val_fetch_outs = exe.run(
inference_program,
# test_program(),
feed=feed_dict,
fetch_list=[net_test.translation_ids],
return_numpy=False)
# test_scores.update(
# preds=val_fetch_outs[0],
# labels=[_[-1] for _ in data])
# print("=====Update scores")
test_scores.update(preds=val_fetch_outs[0],
labels=[_[-1] for _ in data],
words_list=[_[0] for _ in data],
for_generate=True)
# val_fetch_outs = exe.run(inference_program,
# feed=val_feeder.feed(data),
# fetch_list=[avg_cost, net.label],
# return_numpy=False)
# test_scores.update(
# preds=val_fetch_outs[1],
# labels=[_[-1] for _ in data],
# words_list=[_[0] for _ in data])
total_loss += 1.0
count += 1
# if batch_id > 0:
# break
values = test_scores.eval()
test_scores.eval_show()
return total_loss / count, values
print("=====Init scores")
id2word_output = {}
for k in word2id_output:
id2word_output[word2id_output[k]] = k
scores_train = generate_pr(word_dict=id2word_output)
scores_train.append_label(data_train)
scores_test = generate_pr(word_dict=id2word_output)
scores_test.append_label(data_test)
scores_dev = generate_pr(word_dict=id2word_output)
scores_dev.append_label(data_dev)
max_tri_f1 = 0.0
max_tri_pass = -1.0
max_arg_f1 = 0.0
max_arg_pass = -1.0
print("=====Start training")
for pass_id in range(1, args.pass_num + 1):
scores_train.reset()
pass_start_time = time.time()
words_seen = 0
for batch_id, _data in enumerate(train_batch_generator()):
batch_size = len(_data)
words_seen += len(_data) * 2
# print(_data)
# print(len(_data))
# print(sum([len(_[0]) for _ in _data]))
# # Setup initial ids and scores lod tensor
# init_ids_data = np.array([0 for _ in range(batch_size)], dtype='int64')
# init_scores_data = np.array(
# [1. for _ in range(batch_size)], dtype='float32')
# init_ids_data = init_ids_data.reshape((batch_size, 1))
# init_scores_data = init_scores_data.reshape((batch_size, 1))
# init_recursive_seq_lens = [1] * batch_size
# init_recursive_seq_lens = [
# init_recursive_seq_lens, init_recursive_seq_lens
# ]
# init_ids = fluid.create_lod_tensor(init_ids_data,
# init_recursive_seq_lens, place)
# init_scores = fluid.create_lod_tensor(init_scores_data,
# init_recursive_seq_lens, place)
# # Feed dict for inference
# # feed_dict = feeder.feed([[x[0]] for x in _data])
# feed_dict = feeder.feed(_data)
# feed_dict['init_ids'] = init_ids
# feed_dict['init_scores'] = init_scores
# avg_cost_train, preds = exe.run(
# framework.default_main_program(),
# # test_program(),
# feed=feed_dict,
# fetch_list=[avg_cost, net.predict],
# return_numpy=False)
avg_cost_train, preds = exe.run(
main_program,
# train_program(),
feed=feeder.feed(_data),
fetch_list=[avg_cost, net.label],
return_numpy=False)
# print(np.array(labels).shape)
# print(np.array(preds).tolist())
# print([_[-1] for _ in _data])
#print([_[0] for _ in _data])
avg_cost_train = np.array(avg_cost_train)
if batch_id % 10 == 0:
print('pass_id=%d, batch_id=%d, train_loss: %f' %
(pass_id, batch_id, avg_cost_train))
scores_train.update(preds=preds,
labels=[_[-1] for _ in _data],
words_list=[_[0] for _ in _data])
# This is for continuous evaluation only
# if args.enable_ce and batch_id >= 100:
# if batch_id > 0:
# break
scores_train.eval_show()
pass_end_time = time.time()
new_max_dev = False
def main(argv=None):
run_id = FLAGS.NAME if FLAGS.NAME else str(uuid.uuid4())
model_path = '%s/%s' % (FLAGS.MODEL_PATH, run_id)
if not os.path.exists(model_path):
os.makedirs(model_path)
summary_path = '%s/%s' % (FLAGS.SUMMARY_PATH, run_id)
if not os.path.exists(summary_path):
os.makedirs(summary_path)
style_paths = FLAGS.STYLE_IMAGES.split(',')
style_layers = FLAGS.STYLE_LAYERS.split(',')
content_layers = FLAGS.CONTENT_LAYERS.split(',')
style_features_t = get_style_features(style_paths, style_layers)
images = reader.image(FLAGS.BATCH_SIZE, FLAGS.IMAGE_SIZE, FLAGS.TRAIN_IMAGES_PATH)
generated = model.net(images - reader.mean_pixel, training=True)
# Put both generated and training images in same batch through VGG net for efficiency
net, _ = vgg.net(FLAGS.VGG_PATH, tf.concat(0, [generated, images]) - reader.mean_pixel)
content_loss = 0
for layer in content_layers:
generated_images, content_images = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
shape = tf.shape(generated_images)
width = shape[1]
height = shape[2]
num_filters = shape[3]
content_loss += tf.nn.l2_loss(generated_images - content_images) / tf.to_float(size)
content_loss = content_loss
style_loss = 0
for style_grams, layer in zip(style_features_t, style_layers):
generated_images, _ = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
for style_gram in style_grams:
style_loss += tf.nn.l2_loss(gram(generated_images) - style_gram) / tf.to_float(size)
style_loss = style_loss / len(style_paths)
tv_loss = total_variation_loss(generated)
loss = FLAGS.STYLE_WEIGHT * style_loss + FLAGS.CONTENT_WEIGHT * content_loss + FLAGS.TV_WEIGHT * tv_loss
global_step = tf.Variable(0, name="global_step", trainable=False)
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=global_step)
# Statistics
with tf.name_scope('losses'):
tf.scalar_summary('content loss', content_loss)
tf.scalar_summary('style loss', style_loss)
tf.scalar_summary('regularizer loss', tv_loss)
with tf.name_scope('weighted_losses'):
tf.scalar_summary('weighted content loss', content_loss * FLAGS.CONTENT_WEIGHT)
tf.scalar_summary('weighted style loss', style_loss * FLAGS.STYLE_WEIGHT)
tf.scalar_summary('weighted regularizer loss', tv_loss * FLAGS.TV_WEIGHT)
tf.scalar_summary('total loss', loss)
tf.image_summary('original', images)
tf.image_summary('generated', generated)
summary = tf.merge_all_summaries()
with tf.Session() as sess:
writer = tf.train.SummaryWriter(summary_path, sess.graph)
saver = tf.train.Saver(tf.all_variables())
file = tf.train.latest_checkpoint(model_path)
sess.run([tf.initialize_all_variables(), tf.initialize_local_variables()])
if file:
print('Restoring model from {}'.format(file))
saver.restore(sess, file)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
if step % 100 == 0:
print(step, loss_t, elapsed_time)
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
if step % 10000 == 0:
saver.save(sess, model_path + '/fast-style-model', global_step=step)
except tf.errors.OutOfRangeError:
saver.save(sess, model_path + '/fast-style-model-done')
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
import torch.nn as nn
import numpy as np
import data
import model as model
from tqdm import tqdm
import data
test1path = 'test1\\'
trainpath = 'train\\'
filename = os.listdir(test1path)
words = os.listdir(trainpath) # 按时间排序 从早到晚
words = np.array(words)
testnumber = len(filename)
category_number = len(words)
net = model.net()
if torch.cuda.is_available():
net.cuda()
net.eval()
if __name__ == '__main__':
checkpoint = model.load_checkpoint()
net.load_state_dict(checkpoint['state_dict'])
testdatas = data.loadtestdata()
testdatas.astype(np.float)
n = 0
N = 10000
batch_size = 8
pre = np.array([])
batch_site = []
def main(argv=None):
if FLAGS.CONTENT_IMAGES_PATH:
content_images = reader.image(FLAGS.BATCH_SIZE,
FLAGS.IMAGE_SIZE,
FLAGS.CONTENT_IMAGES_PATH,
epochs=1,
shuffle=False,
crop=False)
generated_images = model.net(content_images / 255.)
output_format = tf.saturate_cast(generated_images + reader.mean_pixel,
tf.uint8)
with tf.Session() as sess:
file = tf.train.latest_checkpoint(FLAGS.MODEL_PATH)
if not file:
print('Could not find trained model in {}'.format(
FLAGS.MODEL_PATH))
return
print('Using model from {}'.format(file))
saver = tf.train.Saver()
saver.restore(sess, file)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
i = 0
start_time = time.time()
try:
while not coord.should_stop():
print(i)
images_t = sess.run(output_format)
elapsed = time.time() - start_time
start_time = time.time()
print('Time for one batch: {}'.format(elapsed))
for raw_image in images_t:
i += 1
misc.imsave('out{0:04d}.png'.format(i), raw_image)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
return
if not os.path.exists(FLAGS.MODEL_PATH):
os.makedirs(FLAGS.MODEL_PATH)
style_paths = FLAGS.STYLE_IMAGES.split(',')
style_layers = FLAGS.STYLE_LAYERS.split(',')
content_layers = FLAGS.CONTENT_LAYERS.split(',')
style_features_t = get_style_features(style_paths, style_layers)
images = reader.image(FLAGS.BATCH_SIZE, FLAGS.IMAGE_SIZE,
FLAGS.TRAIN_IMAGES_PATH)
generated = model.net(images / 255.)
net, _ = vgg.net(FLAGS.VGG_PATH, tf.concat(0, [generated, images]))
content_loss = 0
for layer in content_layers:
generated_images, content_images = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
content_loss += tf.nn.l2_loss(generated_images -
content_images) / tf.to_float(size)
content_loss = content_loss / len(content_layers)
style_loss = 0
for style_gram, layer in zip(style_features_t, style_layers):
generated_images, _ = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
for style_image in style_gram:
style_loss += tf.nn.l2_loss(
tf.reduce_sum(gram(generated_images) - style_image,
0)) / tf.to_float(size)
style_loss = style_loss / len(style_layers)
loss = FLAGS.STYLE_WEIGHT * style_loss + FLAGS.CONTENT_WEIGHT * content_loss + FLAGS.TV_WEIGHT * total_variation_loss(
generated)
global_step = tf.Variable(0, name="global_step", trainable=False)
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss,
global_step=global_step)
output_format = tf.saturate_cast(
tf.concat(0, [generated, images]) + reader.mean_pixel, tf.uint8)
with tf.Session() as sess:
saver = tf.train.Saver(tf.all_variables())
file = tf.train.latest_checkpoint(FLAGS.MODEL_PATH)
if file:
print('Restoring model from {}'.format(file))
saver.restore(sess, file)
else:
print('New model initilized')
sess.run(tf.initialize_all_variables())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
if step % 100 == 0:
print(step, loss_t, elapsed_time)
output_t = sess.run(output_format)
for i, raw_image in enumerate(output_t):
misc.imsave('out{}.png'.format(i), raw_image)
if step % 10000 == 0:
saver.save(sess,
FLAGS.MODEL_PATH + '/fast-style-model',
global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
import checkpoint as cp
import match_data
import model as mdl
n_epoch = 1000
x, y, xt, yt = match_data.get_train_data()
x = torch.FloatTensor(x)
y = torch.LongTensor(y)
xt = torch.FloatTensor(xt)
yt = torch.LongTensor(yt)
x, y = Variable(x), Variable(y)
xt, yt = Variable(xt), Variable(yt)
net = mdl.net()
#optimizer = torch.optim.SGD(net.parameters(), lr=0.01, weight_decay=0.002)
optimizer = torch.optim.Adam(net.parameters(),
lr=1e-3,
betas=(0.9, 0.999),
weight_decay=0)
loss_func = torch.nn.CrossEntropyLoss()
def now():
return datetime.now().strftime('%c')
def train_one_epoch():
net.train()
def main(FLAGS):
# 得到风格特征
style_features_t = losses.get_style_features(FLAGS)
# Make sure the training path exists.
training_path = os.path.join(FLAGS.model_path, FLAGS.naming)
if not (os.path.exists(training_path)):
os.makedirs(training_path)
with tf.Graph().as_default():
with tf.Session() as sess:
"""Build Network"""
# 构造vgg网络，按照FLAGS.loss_model中的网络名字，可以在/nets/nets_factory.py 中的networks_map找到对应
network_fn = nets_factory.get_network_fn(FLAGS.loss_model,
num_classes=1,
is_training=False)
# 根据不同网络做不同的预处理
image_preprocessing_fn, image_unprocessing_fn = preprocessing_factory.get_preprocessing(
FLAGS.loss_model, is_training=False)
# 读取一个批次的数据，并且预处理
# 这里的数据你可以不用coco，可以直接给一个包含很多图片的文件夹即可
# 因为coco过于大
processed_images = reader.image(FLAGS.batch_size,
FLAGS.image_height,
FLAGS.image_width,
'F:/CASIA/train_frame/real/',
image_preprocessing_fn,
epochs=FLAGS.epoch)
# 通过生成网络，生成图片，相当于y^
generated = model.net(processed_images, training=True)
# 因为一会要把生成图片喂入到后面vgg进行计算两个损失，所以要先进行预处理
processed_generated = [
image_preprocessing_fn(image, FLAGS.image_height,
FLAGS.image_width) for image in
tf.unstack(generated, axis=0, num=FLAGS.batch_size)
]
# 因为上面是list格式，所以用tf.stack堆叠成tensor
processed_generated = tf.stack(processed_generated)
# 按照batch那一个维度，拼起来，比如原来两个是[batch_size,h,w,c]，concat后变为[2*batch_size,h,w,c]
# 这样一次前向传播把y^ 和y_c的特征都计算出来了
_, endpoints_dict = network_fn(tf.concat(
[processed_generated, processed_images], 0),
spatial_squeeze=False)
# Log the structure of loss network
tf.logging.info(
'Loss network layers(You can define them in "content_layers" and "style_layers"):'
)
for key in endpoints_dict:
tf.logging.info(key)
"""Build Losses"""
# 计算三个损失
content_loss = losses.content_loss(endpoints_dict,
FLAGS.content_layers)
style_loss, style_loss_summary = losses.style_loss(
endpoints_dict, style_features_t, FLAGS.style_layers)
tv_loss = losses.total_variation_loss(
generated) # use the unprocessed image
loss = FLAGS.style_weight * style_loss + FLAGS.content_weight * content_loss + FLAGS.tv_weight * tv_loss
# Add Summary for visualization in tensorboard.
"""Add Summary"""
# 为了tensorboard，可以忽略
tf.summary.scalar('losses/content_loss', content_loss)
tf.summary.scalar('losses/style_loss', style_loss)
tf.summary.scalar('losses/regularizer_loss', tv_loss)
tf.summary.scalar('weighted_losses/weighted_content_loss',
content_loss * FLAGS.content_weight)
tf.summary.scalar('weighted_losses/weighted_style_loss',
style_loss * FLAGS.style_weight)
tf.summary.scalar('weighted_losses/weighted_regularizer_loss',
tv_loss * FLAGS.tv_weight)
tf.summary.scalar('total_loss', loss)
for layer in FLAGS.style_layers:
tf.summary.scalar('style_losses/' + layer,
style_loss_summary[layer])
tf.summary.image('generated', generated)
# tf.image_summary('processed_generated', processed_generated) # May be better?
tf.summary.image(
'origin',
tf.stack([
image_unprocessing_fn(image) for image in tf.unstack(
processed_images, axis=0, num=FLAGS.batch_size)
]))
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(training_path)
"""Prepare to Train"""
# 步数
global_step = tf.Variable(0, name="global_step", trainable=False)
variable_to_train = []
for variable in tf.trainable_variables():
# 把非vgg网络里面的可训练变量加入variable_to_train
if not (variable.name.startswith(FLAGS.loss_model)):
variable_to_train.append(variable)
# 注意var_list
train_op = tf.train.AdamOptimizer(1e-3).minimize(
loss, global_step=global_step, var_list=variable_to_train)
variables_to_restore = []
for v in tf.global_variables():
# 把非vgg中的可存储变量加入variables_to_restore
if not (v.name.startswith(FLAGS.loss_model)):
variables_to_restore.append(v)
# 注意variables_to_restore
saver = tf.train.Saver(variables_to_restore,
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Restore variables for loss network.
# slim的，可以根据FLAGS里面配置把网络参数加载到sess这个会话里面
init_func = utils._get_init_fn(FLAGS)
init_func(sess)
# Restore variables for training model if the checkpoint file exists.
last_file = tf.train.latest_checkpoint(training_path)
if last_file:
tf.logging.info('Restoring model from {}'.format(last_file))
saver.restore(sess, last_file)
"""Start Training"""
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
"""logging"""
print(step)
if step % 10 == 0:
tf.logging.info(
'step: %d, total Loss %f, secs/step: %f' %
(step, loss_t, elapsed_time))
"""summary"""
if step % 25 == 0:
tf.logging.info('adding summary...')
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
writer.flush()
"""checkpoint"""
if step % 1000 == 0:
saver.save(sess,
os.path.join(training_path,
'fast-style-model.ckpt'),
global_step=step)
except tf.errors.OutOfRangeError:
saver.save(
sess,
os.path.join(training_path, 'fast-style-model.ckpt-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def main(_):
img_read = cv2.imread(FLAGS.image_file)
shape = img_read.shape
height = shape[0]
width = shape[1]
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
X = tf.placeholder(tf.uint8, shape=[None, None, 3], name='input')
# Read image data.
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
FLAGS.loss_model, is_training=False)
image0 = reader.get_image_from_cam(X, height, width,
image_preprocessing_fn)
#X = tf.placeholder(tf.float32, shape=[None, None, 3], name='input')
# Add batch dimension
image = tf.expand_dims(image0, 0)
#image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.cast(generated, tf.uint8)
# Remove batch dimension
generated = tf.squeeze(generated, [0])
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(),
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Use absolute path
FLAGS.model_file = os.path.abspath(FLAGS.model_file)
saver.restore(sess, FLAGS.model_file)
# Make sure 'generated' directory exists.
generated_file = 'generated/res.jpg'
if os.path.exists('generated') is False:
os.makedirs('generated')
# Generate and write image data to file.
with open(generated_file, 'wb') as img:
start_time = time.time()
img.write(
sess.run(tf.image.encode_jpeg(generated),
feed_dict={X: img_read}))
end_time = time.time()
# Generated the protobuf file.
output_graph_def = tf.graph_util.convert_variables_to_constants(
sess, sess.graph_def, output_node_names=['output'])
with tf.gfile.FastGFile('models/wave_small1.pb',
mode='wb') as f:
f.write(output_graph_def.SerializeToString())
tf.logging.info('Convert done!')
tf.logging.info('Elapsed time: %fs' % (end_time - start_time))
tf.logging.info('Done. Please check %s.' % generated_file)
def fast_style():
batch_size = 4
num_epochs = 1
style_layers = FLAGS.STYLE_LAYERS.split(',')
content_layers = FLAGS.CONTENT_LAYERS.split(',')
with h5py.File(''.join(['datasets/coco-256.h5']), 'r') as hf:
content_images = hf['images'].value
content_names = hf['filenames'].value
total_batch = int(np.floor(len(content_images) / (batch_size)))
total_loss = 0
total_content = 0
total_style = 0
total_variation = 0
style_names = [
join('styles', f) for f in listdir('styles')
if isfile(join('styles', f)) & f.lower().endswith('jpg')
]
style_holder = tf.placeholder(shape=[1, None, None, 3],
dtype=tf.float32) # Real images
content_holder = tf.placeholder(shape=[batch_size, 256, 256, 3],
dtype=tf.float32) # Random vector
# generated = neural_model.net(content_holder)
generated = [model.net(content_holder, training=True)]
style_net, _ = vgg.net(FLAGS.VGG_PATH, style_holder)
content_net, _ = vgg.net(FLAGS.VGG_PATH, content_holder)
for i in range(len(generated)):
generated_net, _ = vgg.net(FLAGS.VGG_PATH, generated[i])
content_loss = 0
for layer in content_layers:
content_vgg = content_net[layer]
generated_vgg = generated_net[layer]
size = tf.size(generated_vgg)
content_loss += tf.nn.l2_loss(generated_vgg -
content_vgg) / tf.to_float(size)
content_loss = content_loss / len(content_layers)
style_loss = 0
for layer in style_layers:
generated_vgg = generated_net[layer]
style_vgg = style_net[layer]
# size = tf.size(style_vgg)
size = tf.square(style_vgg.get_shape().as_list()[3]) * batch_size
# for style_batch in style_gram:
style_loss += tf.nn.l2_loss(gram(generated_vgg) -
gram(style_vgg)) / tf.to_float(size)
style_loss = style_loss / len(style_layers)
total_content += content_loss
total_style += style_loss
total_variation += total_variation_loss(generated[i])
total_loss = FLAGS.STYLE_WEIGHT * total_style + FLAGS.CONTENT_WEIGHT * total_content + FLAGS.TV_WEIGHT * total_variation
output_format = tf.saturate_cast(
tf.concat(0, [generated[-1], content_holder]) + mean_pixel, tf.uint8)
tvars = tf.trainable_variables()
train_op = tf.train.AdamOptimizer(1e-3)
grads = train_op.compute_gradients(total_loss, tvars)
update = train_op.apply_gradients(grads)
saver = tf.train.Saver(tf.all_variables())
sess = tf.Session()
sess.run(tf.initialize_all_variables())
sess.run(tf.initialize_local_variables())
for i in xrange(len(style_names)):
print 'style: ' + style_names[i]
# style_image = (scipy.misc.imread(style_names[i], mode='RGB') / 255.0 - 0.5) * 2.0
style_image = scipy.misc.imread(style_names[i],
mode='RGB') - mean_pixel
style_image = np.expand_dims(style_image, 0)
epoch = 0
while epoch < num_epochs:
content_iter = data_iterator(content_images, content_names,
batch_size)
for j in tqdm.tqdm(xrange(total_batch)):
content_image, content_name = content_iter.next()
content_image = np.reshape(
content_image, [batch_size, 256, 256, 3]) - mean_pixel
_, loss_t, loss_s, loss_c = sess.run(
[update, total_loss, total_style, total_content],
feed_dict={
content_holder: content_image,
style_holder: style_image
})
if j % 100 == 0:
print 'epoch: ' + str(epoch) + ' loss: ' + str(
loss_t) + ' loss_s: ' + str(
loss_s) + ' loss_c: ' + str(loss_c)
output_t = sess.run(
output_format,
feed_dict={content_holder: content_image})
for j, raw_image in enumerate(output_t):
scipy.misc.imsave('test/out%s-%s.png' % (epoch, j + 1),
raw_image)
if epoch % 1 == 0:
if not os.path.exists(FLAGS.MODEL_DIR):
os.makedirs(FLAGS.MODEL_DIR)
saver.save(
sess, FLAGS.MODEL_DIR + '/model-' +
str(style_names[i][7:-4]) + '.ckpt')
print "Saved Model"
epoch += 1
def general_nfold_cv_test(XD, XT, Y, label_row_inds, label_col_inds,
prfmeasure, FLAGS, labeled_sets, val_sets, get_rm2,
best_param_list, i):
param1value = best_param_list[0]
param2value = best_param_list[1]
param3value = best_param_list[2]
lamda = best_param_list[3]
batchsz = FLAGS.batch_size # 256
logging("---Parameter Search-----", FLAGS)
w = len(val_sets)
all_predictions = [0 for x in range(w)]
all_losses = [0 for x in range(w)]
all_auc = [0 for x in range(w)]
all_aupr = [0 for x in range(w)]
all_preaffinities = []
all_affinities = []
for foldind in range(len(val_sets)):
valinds = val_sets[foldind]
labeledinds = labeled_sets[foldind]
trrows = label_row_inds[labeledinds]
trcols = label_col_inds[labeledinds]
train_dataset = prepare_interaction_pairs(XD, XT, Y, trrows, trcols)
terows = label_row_inds[valinds]
tecols = label_col_inds[valinds]
test_dataset = prepare_interaction_pairs(XD, XT, Y, terows, tecols)
train_loader = DataLoader(dataset=train_dataset,
batch_size=batchsz,
shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batchsz)
model = net(FLAGS, param1value, param2value, param3value).cuda()
model.apply(weights_init)
rperf_list = []
for epochind in range(FLAGS.num_epoch):
model = train(train_loader, model, FLAGS, param1value, param2value,
param3value, lamda)
if (epochind + 1) % 2 == 0:
rperf, loss, rm2, auc = test(model, test_loader, FLAGS,
param1value, param2value,
param3value, lamda)
rperf_list.append(rperf)
print(
'test: epoch:{},p1:{},p2:{},p3:{},loss:{:.5f},rperf:{:.5f}, rm2:{:.5f}'
.format(epochind, param1value, param2value, param3value,
loss, rperf, rm2))
if rperf >= max(rperf_list):
torch.save(model, 'checkpoint.pth')
if rperf < max(rperf_list) - 0.1:
break
loss_func = nn.MSELoss()
affinities = []
pre_affinities = []
model = torch.load('checkpoint.pth')
model.eval()
for drug_SMILES, target_protein, affinity in test_loader:
pre_affinity, _, _, _, _, _, _, _, _ = model(
drug_SMILES, target_protein, FLAGS, param1value, param2value,
param3value)
pre_affinities += pre_affinity.cpu().detach().numpy().tolist()
affinities += affinity.cpu().detach().numpy().tolist()
pre_affinities = np.array(pre_affinities)
affinities = np.array(affinities)
if 'davis' in FLAGS.dataset_path:
pre_label = pre_affinities
label = np.int32(affinities > 7.0)
auc = roc_auc_score(label, pre_label)
aupr = get_aupr(label, pre_label)
if 'kiba' in FLAGS.dataset_path:
pre_label = pre_affinities
label = np.int32(affinities > 12.1)
auc = roc_auc_score(label, pre_label)
aupr = get_aupr(label, pre_label)
rperf = prfmeasure(affinities, pre_affinities)
rm2 = get_rm2(affinities, pre_affinities)
loss = loss_func(torch.Tensor(pre_affinities),
torch.Tensor(affinities))
print('best: p1:{},p2:{},p3:{},loss:{:.5f},rperf:{:.5f}, rm2:{:.5f}'.
format(param1value, param2value, param3value, loss, rperf, rm2))
logging(
"best: P1 = %d, P2 = %d, P3 = %d, Fold = %d, CI-i = %f, MSE = %f, auc = %f, aupr = %f"
% (param1value, param2value, param3value, foldind, rperf, loss,
auc, aupr), FLAGS)
all_predictions[
foldind] = rperf # TODO FOR EACH VAL SET allpredictions[pointer][foldind]
all_losses[foldind] = loss
all_auc[foldind] = auc
all_aupr[foldind] = aupr
all_affinities.append(affinities)
all_preaffinities.append(pre_affinities)
# save affinities and preaffinites for further analysis
np.savetxt("./result/iter" + str(i) + "affinities.txt",
np.array(all_affinities))
np.savetxt("./result/iter" + str(i) + "preaffinities.txt",
np.array(all_preaffinities))
best_param_list = [param1value, param2value, param3value, lamda]
best_perf = np.mean(all_predictions)
return best_param_list, best_perf, all_predictions, all_losses, all_auc, all_aupr
def gen_from_directory():
""" transfer images from a directory. """
im_name = tf.placeholder(dtype=tf.string)
im_format = tf.placeholder(dtype=tf.string)
content_images = reader.get_image_frame(im_name, im_format,
FLAGS.image_size)
images = tf.stack([content_images])
generated_images = model.net(images / 255., if_train=False)
ims = os.listdir(FLAGS.content)
im_nums = len(ims)
output_format = tf.saturate_cast(generated_images + reader.mean_pixel,
tf.uint8)
# Ouput path
model_path = os.path.join('models',
FLAGS.model_name + utils.get_model_suffix())
### model_p = model_p if not model_p.endswith("/") else model_p[:-1]
### model_p = os.path.split(model_p)
output_path = os.path.join("output",
FLAGS.model_name + utils.get_model_suffix())
if not os.path.exists(output_path):
os.makedirs(output_path)
with tf.Session() as sess:
file_ = tf.train.latest_checkpoint(model_path)
if not file_:
print('Could not find trained model in {}'.format(FLAGS.model))
return
print('Using model from {}'.format(file_))
# Get trained step
index = file_.rfind("-")
trained_step = file_[index:]
saver = tf.train.Saver()
saver.restore(sess, file_)
print("Transfer image:")
start_time = time.time()
# Run inference
for i in range(im_nums):
if ims[i].endswith(("png", "PNG")):
format_ = "png"
elif ims[i].endswith((
"jpeg",
"jpg",
"JPEG",
"JPG",
)):
format_ = "jpg"
else:
print("---Unsupported image format:", ims[i])
continue
images_t = sess.run(output_format,
feed_dict={
im_name: FLAGS.content + ims[i],
im_format: format_
})
elapsed = time.time() - start_time
start_time = time.time()
print('Time: {}'.format(elapsed))
format_index = ims[i].rfind('.')
images_name = ims[i][:format_index]
out_path = os.path.join(
output_path,
FLAGS.output + "-" + images_name + trained_step + '.png')
print("Save result in: ", out_path)
misc.imsave(out_path, images_t[0], format="png")
print('------------------------------------')
print('Finished!')
def uploadImage():
if request.method == "POST":
# # file = request.files['Image']
upload_base64 = request.json['Image']
# upload_base64 = upload_base64.replace('+','-').replace(r'/','_')
with open("./img/xdqtest_resize.png", 'wb') as fdecode:
decode_base64 = base64.b64decode(upload_base64)
fdecode.write(decode_base64)
modelname = request.json['modelname']
size = []
# resized image and save
with tf.Session() as sess:
image_raw_data = tf.gfile.FastGFile("./img/xdqtest_resize.png",
'rb').read()
image_decode = tf.image.decode_png(image_raw_data)
height_source, width_source, _ = sess.run(image_decode).shape
size = [height_source, width_source]
if height_source + width_source < 1000:
image_type = tf.image.convert_image_dtype(image_decode,
dtype=tf.float32)
image_resized = tf.image.resize_images(
image_type, [int(size[0] * 0.8),
int(size[1] * 0.8)],
method=1)
image_data = tf.image.convert_image_dtype(image_resized,
dtype=tf.uint8)
encode_image = tf.image.encode_png(image_data)
if os.path.exists("process") is False:
os.mkdir("process")
with tf.gfile.GFile("./process/xdqtest_resize.png",
'wb') as fsave:
fsave.write(sess.run(encode_image))
elif height_source + width_source < 1600:
image_type = tf.image.convert_image_dtype(image_decode,
dtype=tf.float32)
image_resized = tf.image.resize_images(
image_type, [int(size[0] * 0.7),
int(size[1] * 0.7)],
method=1)
image_data = tf.image.convert_image_dtype(image_resized,
dtype=tf.uint8)
encode_image = tf.image.encode_png(image_data)
if os.path.exists("process") is False:
os.mkdir("process")
with tf.gfile.GFile("./process/xdqtest_resize.png",
'wb') as fsave:
fsave.write(sess.run(encode_image))
else:
image_type = tf.image.convert_image_dtype(image_decode,
dtype=tf.float32)
image_resized = tf.image.resize_images(
image_type, [int(size[0] * 0.5),
int(size[1] * 0.5)],
method=1)
image_data = tf.image.convert_image_dtype(image_resized,
dtype=tf.uint8)
encode_image = tf.image.encode_png(image_data)
if os.path.exists("process") is False:
os.mkdir("process")
with tf.gfile.GFile("./process/xdqtest_resize.png",
'wb') as fsave:
fsave.write(sess.run(encode_image))
# return jsonify({"image_base64":upload_base64})
# base64_tensor = tf.convert_to_tensor(upload_base64, dtype=tf.string)
# img_str = tf.decode_base64(base64_tensor)
# img = tf.image.decode_image(img_str, channels=3)
# with tf.Session() as sess:
# img_value = sess.run([img])[0]
# # return jsonify({"img_value":img_value})
# # return img_value.shape
# height = img_value.shape[0]
# width = img_value.shape[1]
# print("Image value: {}".format(img_value.shape[0]))
# return "a"
# file = request.files.get("Image")
# modelname = request.form['model']
# file.headers['Access-Control-Allow-Origin'] = '*'
# modelname.headers['Access-Control-Allow-Origin'] = '*'
path = basedir + "/img/"
# file_path = path + file.filename
# file_path = path + "test.png"
# file.save(file_path)
# return str(model)
# return "Upload success"
height = 0
width = 0
# image_path = "img/"+file.filename
image_path = "./process/xdqtest_resize.png"
# return image_path
with open(image_path, 'rb') as img:
with tf.Session().as_default() as sess:
if image_path.lower().endswith('png'):
image = sess.run(tf.image.decode_png(img.read()))
else:
image = sess.run(tf.image.decode_jpeg(img.read()))
height = image.shape[0]
width = image.shape[1]
tf.logging.info("Image size: {}, {}".format(width, height))
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
# return jsonify({"height":height, "width":width})
# tf.logging.info('Image size:{},{}'.format(weight, height))
# Read image data
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
FLAGS.loss_model, is_training=False)
image = reader.get_image(image_path, height, width,
image_preprocessing_fn)
# Add batch dimension
image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.cast(generated, tf.uint8)
# Remove batch dimension
generated = tf.squeeze(generated, [0])
# Restore model variables
saver = tf.train.Saver(tf.global_variables(),
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Use absolute path
model_path = basedir + "/models/" + modelname
saver.restore(sess, model_path)
# return model_path
# Make sure 'generated' directory exists
# generated_file = 'generated/' + file.filename
generated_file = 'generated/xdqtest.png'
if os.path.exists('generated') is False:
os.makedir('generated')
# Generate and write image data to file
with open("./" + generated_file, 'wb') as img:
start_time = time.time()
img.write(sess.run(tf.image.encode_jpeg(generated)))
end_time = time.time()
# return "Done"
# recover image from source input
recover_image("./" + generated_file, size[0], size[1], sess)
# process_image = basedir + "/" + generated_file
process_image = basedir + "/" + 'resized_image/resized.png'
# Encode image to base64
with open(process_image, 'rb') as img:
image_base64 = img.read()
image_base64 = base64.b64encode(image_base64)
# response = make_response(image_base64)
# response.headers['Access-Control-Allow-Origin'] = '*'
# response.headers['Access-Control-Methods'] = 'POST'
# response.headers['Access-Control-Allow-Headers'] = 'x-requested-with, content-type'
# print(type(response))
# jsonify({"Image_base64":image_base64})
return jsonify({"Image_base64": image_base64})
def do_transfer(self):
tf.logging.set_verbosity(tf.logging.INFO)
# 获得目标图片，风格图片
target_image_path = self.target_file_name
style_reference_image_path = self.style_file_name
if not os.path.exists(target_image_path):
tku.show_message("请先选择目标图片文件！")
return
if not os.path.exists(style_reference_image_path):
tku.show_message("请先选择风格图片文件！")
return
utils.create_folder(workspace_dir)
self.final_img.set_image(target_image_path)
self.refresh()
# Get image's height and width.
height = 0
width = 0
with open(target_image_path, 'rb') as img:
with tf.Session().as_default() as sess:
# if FLAGS.image_file.lower().endswith('png'):
if target_image_path.lower().endswith('png'):
image = sess.run(tf.image.decode_png(img.read()))
else:
image = sess.run(tf.image.decode_jpeg(img.read()))
height = image.shape[0]
width = image.shape[1]
tf.logging.info('Image size: %dx%d' % (width, height))
with tf.Graph().as_default():
with tf.Session().as_default() as sess:
# Read image data.
image_preprocessing_fn, _ = preprocessing_factory.get_preprocessing(
'vgg_16', is_training=False)
# image = reader.get_image(target_image_path, int(height/2.5), int(width/2.5), image_preprocessing_fn) # gpu
image = reader.get_image(target_image_path, height, width,
image_preprocessing_fn) # cpu
# Add batch dimension
image = tf.expand_dims(image, 0)
generated = model.net(image, training=False)
generated = tf.cast(generated, tf.uint8)
# Remove batch dimension
generated = tf.squeeze(generated, [0])
# Restore model variables.
saver = tf.train.Saver(tf.global_variables(),
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
filepath, tempfilename = os.path.split(
style_reference_image_path)
style_name, extension = os.path.splitext(tempfilename)
model_name = 'models/' + style_name + '.ckpt-done'
saver.restore(sess, model_name)
self.generated_file = os.path.join(
workspace_dir,
result_prefix + utils.strftime(False) + ".jpg")
# Generate and write image data to file.
with open(self.generated_file, 'wb') as img:
start_time = time.time()
img.write(sess.run(tf.image.encode_jpeg(generated)))
end_time = time.time()
tf.logging.info('Elapsed time: %fs' %
(end_time - start_time))
tf.logging.info('Done. Please check %s.' %
self.generated_file)
self.final_img.set_image(self.generated_file)
def main(FLAGS):
style_features_t = losses.get_style_features(FLAGS) #style target的Gram
#make sure the training path exists
training_path = os.path.join(FLAGS.model_path,FLAGS.naming) #model/wave/ ；用于存放训练好的模型
if not (os.path.exists(training_path)):
os.makedirs(training_path)
with tf.Graph().as_default(): #默认计算图
with tf.Session() as sess:#没有as_default(),因此，走出with 语句，sess停止执行，不能在被用
"""build loss network"""
network_fn =nets_factory.get_network_fn(FLAGS.loss_model,num_classes=1,is_training=False) #取出loss model，且该model不用训练
#对要进入loss_model的content_image,和generated_image进行preprocessing
image_preprocessing_fn,image_unpreprocessing_fn = preprocessing_factory.get_preprocessing(FLAGS.loss_model,is_training=False) #取出用于loss_model的，对image进行preprocessing和unpreprocessing的function
processed_image = reader.image(FLAGS.batch_size,FLAGS.image_size,FLAGS.image_size,'train2014/',image_preprocessing_fn,epochs=FLAGS.epoch) #这里要preprocessing的image是一个batch，为training_data
generated = model.net(processed_images,training=True) #输入“图像生成网络”的image为经过preprocessing_image，“图像生成网络”为要训练的网络
processed_generated = [image_preprocessing_fn(image,FLAGS.image_size,FLAGS.image_size) for image in tf.unstack(generated,axis=0,num=FLAGS.batch_size)]
processed_generated = tf.stack(processed_generated)
#计算generated_image和content_image进入loss_model后，更layer的output
_,endpoints_dict= network_fn(tf.concat([processed_generated,processed_images],0),spatial_squeeze=False)#endpoints_dict中存储的是2类image各个layer的值
#log the structure of loss network
tf.logging.info('loss network layers(you can define them in "content layer" and "style layer"):')
for key in endpoints_dict:
tf.logging.info(key) #屏幕输出loss_model的各个layer name
"""build losses"""
content_loss = losses.content_loss(endpoints_dict,FLAGS.content_layers)
style_loss,style_loss_summary = losses.style_loss(endpoints_dict,style_features_t,FLAGS.style_layers)
tv_loss = losses.total_variation_loss(generated)
loss = FLAGS.style_weight * style_loss + FLAGS.content_weight * content_loss + FLAGS.tv_weight * tv_loss
# Add Summary for visualization in tensorboard
"""Add Summary"""
tf.summary.scalar('losses/content_loss',content_loss)
tf.summary.scalar('losses/style_loss',style_loss)
tf.summary.scalar('losses/regularizer_loss',tv_loss)
tf.summary.scalar('weighted_losses/weighted content_loss',content_loss * FLAGS.content_weight)
tf.summary.scalar('weighted_losses/weighted style_loss',style_loss * FLAGS.style_weight)
tf.summary.scalar('weighted_losses/weighted_regularizer_loss',tv_loss * FLAGS.tv_weight)
tf.summary.scalar('total_loss',loss)
for layer in FLAGS.style_layers:
tf.summary.scalar('style_losses/' + layer,style_loss_summary[layer])
tf.summary.image('genearted',generated)
tf.summary.image('origin',tf.stack([image_unprocessing_fn(image) for image in tf.unstack(processed_images,axis=0,num=FLAGS.batch_size)]))
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(training_path)
"""prepare to train"""
global_step = tf.Variable(0,name='global_step',trainable=False)#iteration step
variable_to_train = []#需要训练的变量
for variable in tf.trainable_variables():#在图像风格迁移网络（图像生成网络+损失网络）各参数中，找需要训练的参数
if not (variable.name.startswith(FLAGS.loss_model)):
variable_to_train.append(variable)
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss,global_step = global_step,var_list = variable_to_train) #需要放入sess.run()
variable_to_restore = []#在所有的全局变量中，找需要恢复默认设置的变量； 注意：local_variable指的是一些临时变量和中间变量，用于线程中，线程结束则消失
for v tf.global_variables():
if not (v.name.startswith(FLAGS.loss_model)):
variables_to_restore.append(v)
saver = tf.train.Saver(variables_to_restore,write_version=tf.train.SaverDef.V1)#利用saver.restore()恢复默认设置；这里的variable_to_restore，是需要save and restore的var_list
sess.run([tf.global_variables_initializer(),tf.local_variables_initializer()])#对全局变量和局部变量进行初始化操作：即恢复默认设置
#restore variables for loss model 恢复loss model中的参数
init_func = utils._get_init_fn(FLAGS)
init_func(sess)
#restore variables for training model if the checkpoint file exists. 如果training_model已有训练好的参数，将其载入
last_file = tf.train.latest_checkpoint(training_path)#将train_path中的model参数数据取出
if last_file:
tf.logging.info('restoringmodel from {}'.format(last_file))
saver.restore(sess,last_file) #那如果last_file不存在，就不执行restore操作吗？需要restore的参数只是图像生成网络吗？
"""start training"""
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():#查看线程是否停止(即：是否所有数据均运行完毕）
_,loss_t,step = sess.run([train_op,loss,global_step])
elapsed_time = time.time()
"""logging"""
#print(step)
if step % 10 == 0:
tf.logging.info('step:%d, total loss %f, secs/step: %f' % (step,loss_t,elapsed_time))
"""summary"""
if step % 25 == 0:
tf.logging.info('adding summary...')
summary_str = sess.run(summary)
writer.add_summary(summary_str,step)
writer.flush()
"""checkpoint"""
if step % 1000 == 0:
saver.save(sess,os.path.join(training_path,'fast-style-model.ckpt'),global_step=step)#保存variable_to_restore中的参数值
except tf.errors.OutOfRangeError:
saver.save(sess,os.path.join(training_path,'fast-style-model.ckpt-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()#要求停止所有线程
coord.join(threads)#将线程并入主线程，删除
def main(FLAGS):
style_features_t = losses.get_style_features(FLAGS)
# Make sure the training path exists.
training_path = os.path.join(FLAGS.model_path, FLAGS.naming)
if not (os.path.exists(training_path)):
os.makedirs(training_path)
with tf.Graph().as_default():
with tf.Session() as sess:
"""Build Network"""
# 损失网路：无需训练，定义training为FALSE
network_fn = nets_factory.get_network_fn(FLAGS.loss_model,
num_classes=1,
is_training=False)
# 损失网络中要用的图像的预处理函数
image_preprocessing_fn, image_unprocessing_fn = preprocessing_factory.get_preprocessing(
FLAGS.loss_model, is_training=False)
# 读入的训练图像
processed_images = reader.image(FLAGS.batch_size,
FLAGS.image_size,
FLAGS.image_size,
'train2014/',
image_preprocessing_fn,
epochs=FLAGS.epoch)
# 引入图像生成网络：需要训练，定义training为TRUE
generated = model.net(processed_images, training=True)
# 将生成的图像同样使用预处理生成函数进行处理，因为它同样要被送到损失网路中
processed_generated = [
image_preprocessing_fn(image, FLAGS.image_size,
FLAGS.image_size) for image in
tf.unstack(generated, axis=0, num=FLAGS.batch_size)
]
processed_generated = tf.stack(processed_generated)
# 将原始图像和生成图像送到损失网络中，此处将二者合并送入，以加快计算速度
_, endpoints_dict = network_fn(tf.concat(
[processed_generated, processed_images], 0),
spatial_squeeze=False)
# Log the structure of loss network
tf.logging.info(
'Loss network layers(You can define them in "content_layers" and "style_layers"):'
)
for key in endpoints_dict:
tf.logging.info(key)
"""Build Losses"""
# 定义内容损失
content_loss = losses.content_loss(endpoints_dict,
FLAGS.content_layers)
# 定义风格损失
style_loss, style_loss_summary = losses.style_loss(
endpoints_dict, style_features_t, FLAGS.style_layers)
# 定义tv损失
tv_loss = losses.total_variation_loss(
generated) # use the unprocessed image
# 总损失是之前的损失加权和，最后利用总损失优化网络即可
loss = FLAGS.style_weight * style_loss + FLAGS.content_weight * content_loss + FLAGS.tv_weight * tv_loss
# Add Summary for visualization in tensorboard.
"""Add Summary"""
tf.summary.scalar('losses/content_loss', content_loss)
tf.summary.scalar('losses/style_loss', style_loss)
tf.summary.scalar('losses/regularizer_loss', tv_loss)
tf.summary.scalar('weighted_losses/weighted_content_loss',
content_loss * FLAGS.content_weight)
tf.summary.scalar('weighted_losses/weighted_style_loss',
style_loss * FLAGS.style_weight)
tf.summary.scalar('weighted_losses/weighted_regularizer_loss',
tv_loss * FLAGS.tv_weight)
tf.summary.scalar('total_loss', loss)
for layer in FLAGS.style_layers:
tf.summary.scalar('style_losses/' + layer,
style_loss_summary[layer])
tf.summary.image('generated', generated)
# tf.image_summary('processed_generated', processed_generated) # May be better?
tf.summary.image(
'origin',
tf.stack([
image_unprocessing_fn(image) for image in tf.unstack(
processed_images, axis=0, num=FLAGS.batch_size)
]))
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(training_path)
"""Prepare to Train"""
global_step = tf.Variable(0, name="global_step", trainable=False)
# 找出需要训练的变量存储到checkpoint中：生成网络中的参数训练，损失网路中的参数不动
variable_to_train = []
# 使用tf.trainable_variables()找出需要训练的参量
for variable in tf.trainable_variables():
# 如果不在损失网路中，就把这些参数加入到列表中
if not (variable.name.startswith(FLAGS.loss_model)):
variable_to_train.append(variable)
# 定义训练步骤指定var_list=variable_to_train，这样不会训练损失网络
train_op = tf.train.AdamOptimizer(1e-3).minimize(
loss, global_step=global_step, var_list=variable_to_train)
# 找出需要保存的变量
variables_to_restore = []
# 使用tf.global_variables()找出所有变量
for v in tf.global_variables():
# 如果不在损失网络中就要加入列表variables_to_restore
if not (v.name.startswith(FLAGS.loss_model)):
variables_to_restore.append(v)
# 定义saver指定只会保存variables_to_restore
saver = tf.train.Saver(variables_to_restore,
write_version=tf.train.SaverDef.V1)
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
# Restore variables for loss network.
init_func = utils._get_init_fn(FLAGS)
init_func(sess)
# Restore variables for training model if the checkpoint file exists.
last_file = tf.train.latest_checkpoint(training_path)
if last_file:
tf.logging.info('Restoring model from {}'.format(last_file))
saver.restore(sess, last_file)
"""Start Training"""
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
"""logging"""
# print(step)
if step % 10 == 0:
tf.logging.info(
'step: %d, total Loss %f, secs/step: %f' %
(step, loss_t, elapsed_time))
"""summary"""
if step % 25 == 0:
tf.logging.info('adding summary...')
summary_str = sess.run(summary)
writer.add_summary(summary_str, step)
writer.flush()
"""checkpoint"""
if step % 1000 == 0:
saver.save(sess,
os.path.join(training_path,
'fast-style-model.ckpt'),
global_step=step)
except tf.errors.OutOfRangeError:
saver.save(
sess,
os.path.join(training_path, 'fast-style-model.ckpt-done'))
tf.logging.info('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def main(argv=None):
if FLAGS.CONTENT_IMAGES_PATH:
content_images = reader.image(
FLAGS.BATCH_SIZE,
FLAGS.IMAGE_SIZE,
FLAGS.CONTENT_IMAGES_PATH,
epochs=1,
shuffle=False,
crop=False)
generated_images = model.net(content_images / 255.)
output_format = tf.saturate_cast(generated_images + reader.mean_pixel, tf.uint8)
with tf.Session() as sess:
file = tf.train.latest_checkpoint(FLAGS.MODEL_PATH)
if not file:
print('Could not find trained model in {}'.format(FLAGS.MODEL_PATH))
return
print('Using model from {}'.format(file))
saver = tf.train.Saver()
saver.restore(sess, file)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
i = 0
start_time = time.time()
try:
while not coord.should_stop():
print(i)
images_t = sess.run(output_format)
elapsed = time.time() - start_time
start_time = time.time()
print('Time for one batch: {}'.format(elapsed))
for raw_image in images_t:
i += 1
misc.imsave('out{0:04d}.png'.format(i), raw_image)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
return
if not os.path.exists(FLAGS.MODEL_PATH):
os.makedirs(FLAGS.MODEL_PATH)
style_paths = FLAGS.STYLE_IMAGES.split(',')
style_layers = FLAGS.STYLE_LAYERS.split(',')
content_layers = FLAGS.CONTENT_LAYERS.split(',')
style_features_t = get_style_features(style_paths, style_layers)
images = reader.image(FLAGS.BATCH_SIZE, FLAGS.IMAGE_SIZE, FLAGS.TRAIN_IMAGES_PATH)
generated = model.net(images / 255.)
net, _ = vgg.net(FLAGS.VGG_PATH, tf.concat(0, [generated, images]))
content_loss = 0
for layer in content_layers:
generated_images, content_images = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
content_loss += tf.nn.l2_loss(generated_images - content_images) / tf.to_float(size)
content_loss = content_loss / len(content_layers)
style_loss = 0
for style_gram, layer in zip(style_features_t, style_layers):
generated_images, _ = tf.split(0, 2, net[layer])
size = tf.size(generated_images)
for style_image in style_gram:
style_loss += tf.nn.l2_loss(tf.reduce_sum(gram(generated_images) - style_image, 0)) / tf.to_float(size)
style_loss = style_loss / len(style_layers)
loss = FLAGS.STYLE_WEIGHT * style_loss + FLAGS.CONTENT_WEIGHT * content_loss + FLAGS.TV_WEIGHT * total_variation_loss(generated)
global_step = tf.Variable(0, name="global_step", trainable=False)
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=global_step)
output_format = tf.saturate_cast(tf.concat(0, [generated, images]) + reader.mean_pixel, tf.uint8)
with tf.Session() as sess:
saver = tf.train.Saver(tf.all_variables())
file = tf.train.latest_checkpoint(FLAGS.MODEL_PATH)
if file:
print('Restoring model from {}'.format(file))
saver.restore(sess, file)
else:
print('New model initilized')
sess.run(tf.initialize_all_variables())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
start_time = time.time()
try:
while not coord.should_stop():
_, loss_t, step = sess.run([train_op, loss, global_step])
elapsed_time = time.time() - start_time
start_time = time.time()
if step % 100 == 0:
print(step, loss_t, elapsed_time)
output_t = sess.run(output_format)
for i, raw_image in enumerate(output_t):
misc.imsave('out{}.png'.format(i), raw_image)
if step % 10000 == 0:
saver.save(sess, FLAGS.MODEL_PATH + '/fast-style-model', global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def perceptual_loss(net_type):
"""Compute perceptual loss of content and style
Return:
generated 前向生成网络
images 输入图片(batch based)
loss 各种loss.
"""
# Set style image
style_paths = FLAGS.style_images.split(',')
# Set style layers and content layers in vgg net
style_layers = FLAGS.style_layers.split(',')
content_layers = FLAGS.content_layers.split(',')
# Get style feature, pre calculated and save it in memory
style_features_t = get_style_features(style_paths, style_layers, net_type)
# Read images from dataset
images = reader.image(FLAGS.batch_size,
FLAGS.image_size,
FLAGS.train_images_path,
epochs=FLAGS.epoch)
# Transfer images
# 为什么要换成0-1编码?
# 这里和里面的处理对应起来, 虽然这么写很丑， 也容易忘
generated = model.net(images / 255)
# generated = model.net(tf.truncated_normal(images.get_shape(), stddev=0.3))
# Process generated and original images with vgg
net, _ = vgg.net(FLAGS.vgg_path, tf.concat([generated, images], 0),
net_type)
# Get content loss
content_loss = 0
for layer in content_layers:
# 平均分为两组，每组都是batch长度的图片组
gen_features, images_features = tf.split(net[layer],
num_or_size_splits=2,
axis=0)
size = tf.size(gen_features)
content_loss += tf.nn.l2_loss(gen_features -
images_features) / tf.to_float(size)
content_loss /= len(content_layers)
# Get Style loss
style_loss = 0
for style_gram, layer in zip(style_features_t, style_layers):
gen_features, _ = tf.split(net[layer], num_or_size_splits=2, axis=0)
size = tf.size(gen_features)
# Calculate style loss for each style image
for style_image in style_gram:
style_loss += tf.nn.l2_loss(
model.gram(gen_features, FLAGS.batch_size) -
style_image) / tf.to_float(size)
style_loss /= len(style_layers)
# Total loss
total_v_loss = total_variation_loss(generated)
loss = FLAGS.style_weight * style_loss + FLAGS.content_weight * content_loss + FLAGS.tv_weight * total_v_loss
return generated, images, content_loss, style_loss, total_v_loss, loss
