def calculate_fid(path, stats_path, inception_path, use_unbatched):
if not os.path.exists(stats_path):
raise RuntimeError("Invalid inception-statistics file")
inception_path = check_or_download_inception(inception_path)
path = pathlib.Path(path)
files = list(path.glob('*.jpg')) + list(path.glob('*.png'))
x = np.array(
[scipy.misc.imread(str(fn)).astype(np.float32) for fn in files])
fid.create_incpetion_graph(str(inception_path))
sigma, mu = fid.load_stats(stats_path)
jpeg_tuple = fid.get_jpeg_encoder_tuple()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
query_tensor = fid.get_Fid_query_tensor(sess)
if use_unbatched:
fid_value = fid.FID_unbatched(x, query_tensor, mu, sigma,
jpeg_tuple, sess)
else:
pred_array = fid.get_predictions(x,
query_tensor,
sess,
batch_size=128)
fid_value, _, _ = fid.FID(pred_array, mu, sigma, sess)
return fid_value
sess = tf.Session()
with sess.as_default():
sess.run(init)
query_tensor = fid.get_Fid_query_tensor(sess)
#
# caĺculate statistics for batch version
#
sigma_b, mu_b = fid.precalc_stats_batched( X.get_data().reshape(-1,64,64,3),
query_tensor,
sess,
batch_size=batch_size,
verbouse=True)
# save statistics of batch version
fid.save_stats(sigma_b, mu_b, "stats_b.pkl.gz")
# load saved statistics
(sigma_b_loaded, mu_b_loaded) = fid.load_stats("stats_b.pkl.gz")
#
# calculate statistic for unbatched version
#
sigma_u, mu_u = fid.precalc_stats_unbatched( X.get_data().reshape(-1,64,64,3),
query_tensor,
jpeg_tuple,
sess)
# save statistics of unbatched version
fid.save_stats(sigma_u, mu_u, "stats_u.pkl.gz")
# load statistics of unbatched version
(sigma_u_loaded, mu_u_loaded) = fid.load_stats("stats_u.pkl.gz")
input_height=64,
input_width=64,
resize_height=64,
resize_width=64,
is_crop=False,
is_grayscale=False)
X._data[i,:] = img.flatten()
print("done")
# load inference model
fid.create_incpetion_graph(MODEL_PATH)
# load precalculated statistics
sigma_trn, mu_trn = fid.load_stats(STATS_PATH)
# get jpeg encoder
jpeg_tuple = fid.get_jpeg_encoder_tuple()
n_rect = 5
alphas = [ 0.75, 0.5, 0.25, 0.0]
init = tf.global_variables_initializer()
sess = tf.Session()
with sess.as_default():
sess.run(init)
query_tensor = fid.get_Fid_query_tensor(sess)
for i,a in enumerate(alphas):
# disturbe images with implanted black rectangles
X.apply_mult_rect(n_rect, 64, 64, 3, share=a, val=X._data.min())
# propagate disturbed images through imagnet and calculate FID
def train(self):
print("load train stats..", end="")
sigma_trn, mu_trn = fid.load_stats(self.train_stats_file)
print("ok")
z_fixed = np.random.uniform(-1, 1, size=(self.batch_size, self.z_num))
x_fixed = self.get_image_from_loader()
save_image(x_fixed, '{}/x_fixed.png'.format(self.model_dir))
prev_measure = 1
measure_history = deque([0] * self.lr_update_step, self.lr_update_step)
# load inference model
fid.create_incpetion_graph(
"inception-2015-12-05/classify_image_graph_def.pb")
query_tensor = fid.get_Fid_query_tensor(self.sess)
if self.load_checkpoint:
if self.load(self.model_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
# Precallocate prediction array for kl/fid inception score
#print("preallocate %.3f GB for prediction array.." % (self.batch_size_eval * 2048 / (1024**3)), end=" ", flush=True)
pred_arr = np.ones([self.batch_size_eval, 2048])
#print("ok")
for step in trange(self.start_step, self.max_step):
# Optimize
self.sess.run([self.d_optim, self.g_optim])
# Feed dict
fetch_dict = {"measure": self.measure}
if self.update_k:
fetch_dict.update({"k_update": self.k_update})
if step % self.log_step == 0:
fetch_dict.update({
"summary": self.summary_op,
"g_loss": self.g_loss,
"d_loss": self.d_loss,
"k_t": self.k_t,
})
# Get summaries
result = self.sess.run(fetch_dict)
measure = result['measure']
measure_history.append(measure)
if step % self.log_step == 0:
self.summary_writer.add_summary(result['summary'], step)
self.summary_writer.flush()
g_loss = result['g_loss']
d_loss = result['d_loss']
k_t = result['k_t']
print("[{}/{}] Loss_D: {:.6f} Loss_G: {:.6f} measure: {:.4f}, k_t: {:.4f}". \
format(step, self.max_step, d_loss, g_loss, measure, k_t))
if step % (self.log_step * 10) == 0:
x_fake = self.generate(z_fixed, self.model_dir, idx=step)
self.autoencode(x_fixed,
self.model_dir,
idx=step,
x_fake=x_fake)
if step % self.lr_update_step == self.lr_update_step - 1:
self.sess.run([self.g_lr_update, self.d_lr_update])
# FID
if step % self.eval_step == 0:
eval_batches_num = self.batch_size_eval // self.eval_batch_size
for eval_batch in range(eval_batches_num):
print("\rFID batch %d/%d" %
(eval_batch + 1, eval_batches_num),
end="",
flush=True)
sample_z_eval = np.random.uniform(
-1, 1, size=(self.eval_batch_size, self.z_num))
samples_eval = self.generate(sample_z_eval,
self.model_dir,
save=False)
pred_array = fid.get_predictions(
samples_eval,
query_tensor,
self.sess,
batch_size=self.eval_batch_size,
verbose=False)
frm = eval_batch * self.eval_batch_size
to = frm + self.eval_batch_size
pred_arr[frm:to, :] = pred_array
print()
# calculate FID
print("FID", end=" ", flush=True)
FID, _, _ = fid.FID(pred_arr, mu_trn, sigma_trn, self.sess)
if FID is None:
FID = 500 # Something went wrong
print(FID)
self.sess.run(tf.assign(self.fid, FID))
summary_str = self.sess.run(self.fid_sum)
self.summary_writer.add_summary(summary_str, step)
def train(self, config):
"""Train DCGAN"""
print("load train stats")
sigma_trn, mu_trn = fid.load_stats(self.stats_path)
# get querry tensor
query_tensor = self.querry_tensor #fid.get_Fid_query_tensor(self.sess)
print("scan files", end=" ", flush=True)
if config.dataset == 'mnist':
data_X, data_y = self.load_mnist()
else:
data = glob(os.path.join(self.data_path, "*"))
print("%d images found" % len(data))
print("build model", end=" ", flush=True)
# Train optimizers
opt_d = tf.train.AdamOptimizer(config.learning_rate_d,
beta1=config.beta1)
opt_g = tf.train.AdamOptimizer(config.learning_rate_g,
beta1=config.beta1)
# Discriminator
grads_and_vars = opt_d.compute_gradients(self.d_loss,
var_list=self.d_vars)
grads = []
d_optim = opt_d.apply_gradients(grads_and_vars)
# Gradient summaries discriminator
sum_grad_d = []
for i, (grad, vars_) in enumerate(grads_and_vars):
grad_l2 = tf.sqrt(tf.reduce_sum(tf.square(grad)))
sum_grad_d.append(
tf.summary.scalar("grad_l2_d_%d_%s" % (i, vars_.name),
grad_l2))
# Generator
grads_and_vars = opt_g.compute_gradients(self.g_loss,
var_list=self.g_vars)
g_optim = opt_g.apply_gradients(grads_and_vars)
# Gradient summaries generator
sum_grad_g = []
for i, (grad, vars_) in enumerate(grads_and_vars):
grad_l2 = tf.sqrt(tf.reduce_sum(tf.square(grad)))
sum_grad_g.append(
tf.summary.scalar("grad_l2_g_%d_%s" % (i, vars_.name),
grad_l2))
# Init:
tf.global_variables_initializer().run()
# Summaries
self.g_sum = tf.summary.merge([
self.z_sum, self.d_fake_sum, self.G_sum, self.d_loss_fake_sum,
self.g_loss_sum, self.lrate_sum_g
] + sum_grad_g)
self.d_sum = tf.summary.merge([
self.z_sum, self.d_real_sum, self.d_loss_real_sum, self.d_loss_sum,
self.lrate_sum_d
] + sum_grad_d)
self.writer = tf.summary.FileWriter(self.log_dir, self.sess.graph)
# Z sample
sample_z = np.random.normal(0, 1.0, size=(self.sample_num, self.z_dim))
# Input samples
sample_files = data[0:self.sample_num]
sample = [
get_image(sample_file,
input_height=self.input_height,
input_width=self.input_width,
resize_height=self.output_height,
resize_width=self.output_width,
is_crop=self.is_crop,
is_grayscale=self.is_grayscale)
for sample_file in sample_files
]
if (self.is_grayscale):
sample_inputs = np.array(sample).astype(np.float32)[:, :, :, None]
else:
sample_inputs = np.array(sample).astype(np.float32)
print("ok")
start_time = time.time()
if self.load_checkpoint:
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
# Batch preparing
batch_nums = min(len(data), config.train_size) // config.batch_size
data_idx = list(range(len(data)))
counter = self.counter_start
# Loop over epochs
for epoch in xrange(config.epoch):
# Assign learning rates for d and g
lrate = config.learning_rate_d * (config.lr_decay_rate_d**epoch)
self.sess.run(tf.assign(self.learning_rate_d, lrate))
lrate = config.learning_rate_g * (config.lr_decay_rate_g**epoch)
self.sess.run(tf.assign(self.learning_rate_g, lrate))
# Shuffle the data indices
np.random.shuffle(data_idx)
# Loop over batches
for batch_idx in range(batch_nums):
# Prepare batch
idx = data_idx[batch_idx * config.batch_size:(batch_idx + 1) *
config.batch_size]
batch = [
get_image(data[i],
input_height=self.input_height,
input_width=self.input_width,
resize_height=self.output_height,
resize_width=self.output_width,
is_crop=self.is_crop,
is_grayscale=self.is_grayscale) for i in idx
]
if (self.is_grayscale):
batch_images = np.array(batch).astype(np.float32)[:, :, :,
None]
else:
batch_images = np.array(batch).astype(np.float32)
batch_z = np.random.normal(
0, 1.0,
size=(config.batch_size, self.z_dim)).astype(np.float32)
# Update D network
_, summary_str = self.sess.run([d_optim, self.d_sum],
feed_dict={
self.inputs: batch_images,
self.z: batch_z
})
if np.mod(counter, 20) == 0:
self.writer.add_summary(summary_str, counter)
# Update G network
_, summary_str = self.sess.run([g_optim, self.g_sum],
feed_dict={self.z: batch_z})
if np.mod(counter, 20) == 0:
self.writer.add_summary(summary_str, counter)
errD_fake = self.d_loss_fake.eval({self.z: batch_z})
errD_real = self.d_loss_real.eval({self.inputs: batch_images})
errG = self.g_loss.eval({self.z: batch_z})
if np.mod(counter, 100) == 0:
print("Epoch: [%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \
% (epoch, batch_idx, batch_nums, time.time() - start_time, errD_fake+errD_real, errG))
if np.mod(counter, 1000) == 0:
try:
samples, d_loss, g_loss = self.sess.run(
[self.sampler, self.d_loss, self.g_loss],
feed_dict={
self.z: sample_z,
self.inputs: sample_inputs
})
save_images(
samples, [8, 8],
'{}/train_{:02d}_{:04d}.png'.format(
config.sample_dir, epoch, batch_idx))
print("[Sample] d_loss: %.8f, g_loss: %.8f" %
(d_loss, g_loss))
except Exception as e:
print(e)
print("sample image error!")
# FID
print("samples for incept")
sample_z_dist = np.random.normal(
0, 1.0, size=(self.batch_size_dist, self.z_dim))
samples = self.sess.run(
self.sampler_dist,
feed_dict={self.z_dist: sample_z_dist})
samples = (samples + 1.) * 127.5
predictions = fid.get_predictions(
samples,
query_tensor,
self.sess,
batch_size=self.fid_batch_size,
verbose=self.fid_verbose)
FID = None
try:
FID, _, _ = fid.FID(predictions, mu_trn, sigma_trn,
self.sess)
print("FID = " + str(FID))
except Exception as e:
print(e)
FID = 500
self.sess.run(tf.assign(self.fid, FID))
summary_str = self.sess.run(self.fid_sum)
self.writer.add_summary(summary_str, counter)
# Save checkpoint
if (counter != 0) and (np.mod(counter, 2000) == 0):
self.save(config.checkpoint_dir, counter)
counter += 1