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
# load inference model fid.create_incpetion_graph(MODEL_PATH) # get tuple for jpeg encoding jpeg_tuple = fid.get_jpeg_encoder_tuple() # batch size for batched version batch_size = 500 init = tf.global_variables_initializer() 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")
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 build_model(self): # get pool_3 layer self.querry_tensor = fid.get_Fid_query_tensor(self.sess) # Learning rate self.learning_rate_d = tf.Variable(0.0, trainable=False) self.learning_rate_g = tf.Variable(0.0, trainable=False) # Placeholders if self.is_crop: image_dims = [self.output_height, self.output_width, self.c_dim] else: image_dims = [self.input_height, self.input_width, self.c_dim] self.inputs = tf.placeholder(tf.float32, [self.batch_size] + image_dims, name='real_images') self.sample_inputs = tf.placeholder(tf.float32, [self.sample_num] + image_dims, name='sample_inputs') self.z = tf.placeholder(tf.float32, [None, self.z_dim], name='z') self.z_sum = tf.summary.histogram("z", self.z) self.fid = tf.Variable(0.0, trainable=False) self.z_dist = tf.placeholder(tf.float32, [None, self.z_dim], name='z_dist') # Inputs inputs = self.inputs sample_inputs = self.sample_inputs # Discriminator and generator if self.y_dim: pass else: self.G = self.generator(self.z, batch_size=self.batch_size) self.D_real, self.D_logits_real = self.discriminator(inputs) self.sampler_dist = self.sampler_func(self.z_dist, self.batch_size_dist) self.sampler = self.sampler_func(self.z, self.batch_size) self.D_fake, self.D_logits_fake = self.discriminator(self.G, reuse=True) # Summaries self.d_real_sum = tf.summary.histogram("d_real", self.D_real) self.d_fake_sum = tf.summary.histogram("d_fake", self.D_fake) self.G_sum = tf.summary.image("G", self.G) def sigmoid_cross_entropy_with_logits(x, y): try: return tf.nn.sigmoid_cross_entropy_with_logits(logits=x, labels=y) except: return tf.nn.sigmoid_cross_entropy_with_logits(logits=x, targets=y) # Discriminator Loss Real self.d_loss_real = tf.reduce_mean( sigmoid_cross_entropy_with_logits(self.D_logits_real, tf.ones_like(self.D_real))) # Discriminator Loss Fake self.d_loss_fake = tf.reduce_mean( sigmoid_cross_entropy_with_logits(self.D_logits_fake, tf.zeros_like(self.D_fake))) # Generator Loss self.g_loss = tf.reduce_mean( sigmoid_cross_entropy_with_logits(self.D_logits_fake, tf.ones_like(self.D_fake))) self.d_loss_real_sum = tf.summary.scalar("d_loss_real", self.d_loss_real) self.d_loss_fake_sum = tf.summary.scalar("d_loss_fake", self.d_loss_fake) # Discriminator Loss Combined self.d_loss = self.d_loss_real + self.d_loss_fake self.g_loss_sum = tf.summary.scalar("g_loss", self.g_loss) self.d_loss_sum = tf.summary.scalar("d_loss", self.d_loss) self.lrate_sum_d = tf.summary.scalar('learning rate d', self.learning_rate_d) self.lrate_sum_g = tf.summary.scalar('learning rate g', self.learning_rate_g) self.fid_sum = tf.summary.scalar("FID", self.fid) self.image_enc_data = tf.placeholder(tf.uint8, [64, 64, 3]) self.encode_jpeg = tf.image.encode_jpeg(self.image_enc_data) # Variables t_vars = tf.trainable_variables() self.d_vars = [var for var in t_vars if 'd_' in var.name] self.g_vars = [var for var in t_vars if 'g_' in var.name] # Checkpoint saver self.saver = tf.train.Saver()