def export_sparse_encoding(self, dataset_path): """ Converts ground truth images to sparse labels and saves them to disk in PNG format. Ground truth images are only available for the training set. :param dataset_path: The root path of the dataset. :return: None """ # Load the list of image base names basenames = self.get_basenames(is_training=True, dataset_path=dataset_path) gt_path = os.path.join(dataset_path, TRAIN_GT_PATH) gt_sparse_path = os.path.join(dataset_path, GT_SPARSE_PATH) # Create sparse labels folder if not os.path.exists(gt_sparse_path): print('Creating sparse labels folder') os.makedirs(gt_sparse_path) else: print('Sparse labels folder already exists') for _, basename in basenames: gt = imread(os.path.join(gt_path, basename)) gt = colors2labels(gt, self.cmap, one_hot=False) gt = np.dstack([gt, np.copy(gt), np.copy(gt)]) imwrite(os.path.join(gt_sparse_path, basename), gt)
def export_sparse_encoding(self, filename, dataset_path): """ Converts ground truth images to sparse labels and saves them to disk in PNG format. :param filename: :param dataset_path: :return: None """ # Load the list of image base names basenames = self.get_basenames(filename, dataset_path) gt_path = os.path.join(dataset_path, 'SegmentationClass') gt_sparse_path = os.path.join(dataset_path, 'SegmentationSparseClass') # Create sparse labels folder if not os.path.exists(gt_sparse_path): print('Creating sparse labels folder') os.makedirs(gt_sparse_path) else: print('Sparse labels folder already exists') for basename in basenames: gt = imread(os.path.join(gt_path, basename + '.png')) gt = colors2labels(gt, self.cmap, one_hot=False) gt = np.dstack([gt, np.copy(gt), np.copy(gt)]) imwrite(os.path.join(gt_sparse_path, basename + '.png'), gt)
def generate_glued_pairs(id_type_list, n_generated_files, seed=None): if seed is not None: np.random.seed(seed) counter = n_generated_files while counter > 0: ind1 = np.random.randint(len(id_type_list)) ind2 = np.random.randint(len(id_type_list)) if ind1 == ind2: ind2 = (ind2 + np.random.randint( 1, len(id_type_list))) % len(id_type_list) assert id_type_list[ind1][1] == id_type_list[ind2][ 1], "Image type should be the same: %s != %s" % ( id_type_list[ind1][1], id_type_list[ind2][1]) img1 = get_image_data(*id_type_list[ind1]) img2 = get_image_data(*id_type_list[ind2]) img = create_glued_image(img1, img2) image_id = str(id_type_list[ind1][0]) + "_" + str( id_type_list[ind2][0]) image_type = 'Generated_' + id_type_list[ind1][1] filepath = get_filename(image_id, image_type) if os.path.exists(filepath): # Do not overwrite existing continue imwrite(img, image_id, image_type) counter -= 1
def predict_dataset(self, save_path, dataset_filepath, model, batch_size): """ Predicts semantic labels for all images of the speficied dataset and saves results to disk. :param save_path: The target directory. A sub-directory will be created from the current date and time. :param dataset_filepath: The filename of the TFRecordDataset to use for prediction. :param model: An instance of FCN Model. :param batch_size: The number of images per batch. :return: None """ if not os.path.exists(dataset_filepath): raise ValueError('File not found: {}'.format(dataset_filepath)) sess = tf.compat.v1.get_default_session() # Make the folder to save the predictions output_path = os.path.join(save_path, datetime.now().isoformat().split('.')[0]).split(':') output_path = output_path[0] + ':' + output_path[1] + 'H' + output_path[2] if os.path.exists(output_path): shutil.rmtree(output_path) print('Saving predictions to ' + output_path) os.makedirs(output_path) # Load the dataset and make an iterator dataset = tf.data.TFRecordDataset(dataset_filepath) dataset = dataset.map(self.parse_record) dataset = dataset.batch(batch_size) iterator = tf.compat.v1.data.make_one_shot_iterator(dataset) next_sample = iterator.get_next() idx = 0 # The image name is it's index in the TFRecordDataset while True: try: im_batch, _, shape_batch = sess.run(next_sample) # Make an array from a tuple of 3 lists each with `batch_size` elements shape_batch = np.swapaxes(np.asarray(shape_batch), 0, 1) # Returns a 1-item list containing a numpy vector of length BATCH_SIZE * N_PIXELS * N_CLASSES im_softmax = sess.run([tf.nn.softmax(model.logits)], {model.keep_prob: 1.0, model.inputs: im_batch})[0] im_softmax = im_softmax.reshape((len(im_batch), np.prod(model.image_shape), self.n_classes+1)) for i in range(len(im_batch)): # Predict pixel class and expand with a channel dimension. im_pred = np.argmax(im_softmax[i], axis=1).reshape(model.image_shape) im_pred = labels2colors(im_pred, self.cmap) im_masked = center_crop(apply_mask(im_batch[i], im_pred), shape_batch[i][:2]) imwrite(os.path.join(output_path, str(idx) + '.jpg'), im_masked) idx += 1 except tf.errors.OutOfRangeError: break
def read_filter_write(filter_type, filename_in, guidance_in, sigma_color, sigma_spatial, path_out): """Read input and guidance image, apply filter and write result.""" # get basename for output later basename = os.path.splitext(os.path.basename(filename_in))[0] # Read the images image = iu.imread(filename_in) joint = iu.imread(guidance_in) filtered = apply_filter(filter_type, image, joint, sigma_color, sigma_spatial) # save the result params = "_{}_c{}s{}".format(filter_type, sigma_color, sigma_spatial) filename = os.path.join(path_out, basename + params + '.png') iu.imwrite(filename, filtered) return filtered
def decompose_image(filename_in, path_out): """Run the intrinsic image decomposition with caffe.""" network_file = os.path.join(os.path.dirname(__file__), 'network_definition.prototxt') caffemodel = os.path.join(os.path.dirname(__file__), 'learned_weights.caffemodel') net = caffe.Net(network_file, caffe.TEST, weights=caffemodel) # print("Read file:", filename_in) image = iu.imread(filename_in) # get basename for output later basename = os.path.splitext(os.path.basename(filename_in))[0] # get result from caffe reflectance_gray = get_reflectance_caffe(net, image) # save result filename = os.path.join(path_out, basename + '-r.png') iu.imwrite(filename, reflectance_gray) # now colorize with input image again reflectance, shading = iu.colorize(reflectance_gray, image) # save color versions in sRGB filename = os.path.join(path_out, basename + '-r_colorized.png') iu.imwrite(filename, reflectance, sRGB=True) filename = os.path.join(path_out, basename + '-s_colorized.png') iu.imwrite(filename, shading, sRGB=True) return reflectance_gray
print('Copy variables from % s' % ckpt_path) # test a_list = glob('./datasets/' + dataset + '/testA/*.jpg') b_list = glob('./datasets/' + dataset + '/testB/*.jpg') a_save_dir = './test_predictions/' + dataset + '/testA/' b_save_dir = './test_predictions/' + dataset + '/testB/' utils.mkdir([a_save_dir, b_save_dir]) for i in range(len(a_list)): a_real_ipt = im.imresize(im.imread(a_list[i]), [crop_size, crop_size]) a_real_ipt.shape = 1, crop_size, crop_size, 3 a2b_opt, a2b2a_opt = sess.run([a2b, a2b2a], feed_dict={a_real: a_real_ipt}) a_img_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt), axis=0) img_name = os.path.basename(a_list[i]) im.imwrite(im.immerge(a_img_opt, 1, 3), a_save_dir + img_name) print('Save %s' % (a_save_dir + img_name)) for i in range(len(b_list)): b_real_ipt = im.imresize(im.imread(b_list[i]), [crop_size, crop_size]) b_real_ipt.shape = 1, crop_size, crop_size, 3 b2a_opt, b2a2b_opt = sess.run([b2a, b2a2b], feed_dict={b_real: b_real_ipt}) b_img_opt = np.concatenate((b_real_ipt, b2a_opt, b2a2b_opt), axis=0) img_name = os.path.basename(b_list[i]) im.imwrite(im.immerge(b_img_opt, 1, 3), b_save_dir + img_name) print('Save %s' % (b_save_dir + img_name))
def train(): epoch = 200 batch_size = 1 lr = 0.0002 crop_size = 128 load_size = 128 tar_db_a = "cameron_images.tgz" tar_db_b = "teresa_images.tgz" db_a_i = importer_tar.Importer(tar_db_a) db_b_i = importer_tar.Importer(tar_db_b) image_a_names = db_a_i.get_sorted_image_name() image_b_names = db_b_i.get_sorted_image_name() train_a_size = int(len(image_a_names) * 0.8) train_b_size = int(len(image_b_names) * 0.8) image_a_train_names = image_a_names[0:train_a_size] image_b_train_names = image_b_names[0:train_b_size] image_a_test_names = image_a_names[train_a_size:] image_b_test_names = image_b_names[train_b_size:] print("A train size:{},test size:{}".format(len(image_a_train_names), len(image_a_test_names))) print("B train size:{},test size:{}".format(len(image_b_train_names), len(image_b_test_names))) """ graph """ # models generator_a2b = partial(models.generator, scope='a2b') generator_b2a = partial(models.generator, scope='b2a') discriminator_a = partial(models.discriminator, scope='a') discriminator_b = partial(models.discriminator, scope='b') # operations a_real_in = tf.placeholder(tf.float32, shape=[None, load_size, load_size, 3], name="a_real") b_real_in = tf.placeholder(tf.float32, shape=[None, load_size, load_size, 3], name="b_real") a_real = utils.preprocess_image(a_real_in, crop_size=crop_size) b_real = utils.preprocess_image(b_real_in, crop_size=crop_size) a2b = generator_a2b(a_real) b2a = generator_b2a(b_real) b2a2b = generator_a2b(b2a) a2b2a = generator_b2a(a2b) a_logit = discriminator_a(a_real) b2a_logit = discriminator_a(b2a) b_logit = discriminator_b(b_real) a2b_logit = discriminator_b(a2b) # losses g_loss_a2b = -tf.reduce_mean(a2b_logit) g_loss_b2a = -tf.reduce_mean(b2a_logit) cyc_loss_a = tf.losses.absolute_difference(a_real, a2b2a) cyc_loss_b = tf.losses.absolute_difference(b_real, b2a2b) g_loss = g_loss_a2b + g_loss_b2a + cyc_loss_a * 10.0 + cyc_loss_b * 10.0 wd_a = tf.reduce_mean(a_logit) - tf.reduce_mean(b2a_logit) wd_b = tf.reduce_mean(b_logit) - tf.reduce_mean(a2b_logit) gp_a = gradient_penalty(a_real, b2a, discriminator_a) gp_b = gradient_penalty(b_real, a2b, discriminator_b) d_loss_a = -wd_a + 10.0 * gp_a d_loss_b = -wd_b + 10.0 * gp_b # summaries utils.summary({ g_loss_a2b: 'g_loss_a2b', g_loss_b2a: 'g_loss_b2a', cyc_loss_a: 'cyc_loss_a', cyc_loss_b: 'cyc_loss_b' }) utils.summary({d_loss_a: 'd_loss_a'}) utils.summary({d_loss_b: 'd_loss_b'}) for variable in slim.get_model_variables(): tf.summary.histogram(variable.op.name, variable) merged = tf.summary.merge_all() im1_op = tf.summary.image("real_a", a_real_in) im2_op = tf.summary.image("a2b", a2b) im3_op = tf.summary.image("b2a2b", b2a2b) im4_op = tf.summary.image("real_b", b_real_in) im5_op = tf.summary.image("b2a", b2a) im6_op = tf.summary.image("b2a2b", b2a2b) # optim t_var = tf.trainable_variables() d_a_var = [var for var in t_var if 'a_discriminator' in var.name] d_b_var = [var for var in t_var if 'b_discriminator' in var.name] g_var = [ var for var in t_var if 'a2b_generator' in var.name or 'b2a_generator' in var.name ] d_a_train_op = tf.train.AdamOptimizer(lr, beta1=0.5).minimize(d_loss_a, var_list=d_a_var) d_b_train_op = tf.train.AdamOptimizer(lr, beta1=0.5).minimize(d_loss_b, var_list=d_b_var) g_train_op = tf.train.AdamOptimizer(lr, beta1=0.5).minimize(g_loss, var_list=g_var) """ train """ ''' init ''' # session config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.allow_growth = True sess = tf.Session(config=config) # counter it_cnt, update_cnt = utils.counter() ''' summary ''' summary_writer = tf.summary.FileWriter('./outputs/summaries/', sess.graph) ''' saver ''' saver = tf.train.Saver(max_to_keep=5) ''' restore ''' ckpt_dir = './outputs/checkpoints/' utils.mkdir(ckpt_dir) try: utils.load_checkpoint(ckpt_dir, sess) except: sess.run(tf.global_variables_initializer()) '''train''' try: batch_epoch = min(train_a_size, train_b_size) // batch_size max_it = epoch * batch_epoch for it in range(sess.run(it_cnt), max_it): sess.run(update_cnt) epoch = it // batch_epoch it_epoch = it % batch_epoch + 1 # read data a_real_np = cv2.resize( db_a_i.get_image(image_a_train_names[it_epoch % batch_epoch]), (load_size, load_size)) b_real_np = cv2.resize( db_b_i.get_image(image_b_train_names[it_epoch % batch_epoch]), (load_size, load_size)) # train G sess.run(g_train_op, feed_dict={ a_real_in: [a_real_np], b_real_in: [b_real_np] }) # train discriminator sess.run([d_a_train_op, d_b_train_op], feed_dict={ a_real_in: [a_real_np], b_real_in: [b_real_np] }) # display if it % 100 == 0: # make summary summary = sess.run(merged, feed_dict={ a_real_in: [a_real_np], b_real_in: [b_real_np] }) summary_writer.add_summary(summary, it) print("Epoch: (%3d) (%5d/%5d)" % (epoch, it_epoch, batch_epoch)) # save if (it + 1) % 1000 == 0: save_path = saver.save( sess, '{}/epoch_{}_{}.ckpt'.format(ckpt_dir, epoch, it_epoch)) print('###Model saved in file: {}'.format(save_path)) # sample if (it + 1) % 1000 == 0: a_test_index = int( np.random.uniform(high=len(image_a_test_names))) b_test_index = int( np.random.uniform(high=len(image_b_test_names))) a_real_np = cv2.resize( db_a_i.get_image(image_a_test_names[a_test_index]), (load_size, load_size)) b_real_np = cv2.resize( db_b_i.get_image(image_b_test_names[b_test_index]), (load_size, load_size)) [a_opt, a2b_opt, a2b2a_opt, b_opt, b2a_opt, b2a2b_opt ] = sess.run([a_real, a2b, a2b2a, b_real, b2a, b2a2b], feed_dict={ a_real_in: [a_real_np], b_real_in: [b_real_np] }) sample_opt = np.concatenate( (a_opt, a2b_opt, a2b2a_opt, b_opt, b2a_opt, b2a2b_opt), axis=0) [im1_sum,im2_sum,im3_sum,im4_sum,im5_sum,im6_sum] = \ sess.run([im1_op,im2_op,im3_op,im4_op,im5_op,im6_op], feed_dict={a_real_in: [a_real_np], b_real_in: [b_real_np]}) summary_writer.add_summary(im1_sum, it) summary_writer.add_summary(im2_sum, it) summary_writer.add_summary(im3_sum, it) summary_writer.add_summary(im4_sum, it) summary_writer.add_summary(im5_sum, it) summary_writer.add_summary(im6_sum, it) save_dir = './outputs/sample_images_while_training/' utils.mkdir(save_dir) im.imwrite( im.immerge(sample_opt, 2, 3), '{}/epoch_{}_it_{}.jpg'.format(save_dir, epoch, it_epoch)) except: raise finally: save_path = saver.save( sess, '{}/epoch_{}_{}.ckpt'.format(ckpt_dir, epoch, it_epoch)) print('###Model saved in file: {}'.format(save_path)) sess.close()
if (it + 1) % 1000 == 0: save_path = saver.save( sess, f'{ckpt_dir}/Epoch_({epoch})_({it_epoch}of{batch_epoch}).ckpt') print(f'Model saved in file: {save_path}') if (it + 1) % 100 == 0: a_real_ipt = a_test_pool.batch() b_real_ipt = b_test_pool.batch() [a2b_opt, a2b2a_opt, b2a_opt, b2a2b_opt] = sess.run([a2b, a2b2a, b2a, b2a2b], feed_dict={ a_real: a_real_ipt, b_real: b_real_ipt }) sample_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt, b_real_ipt, b2a_opt, b2a2b_opt), axis=0) save_dir = './outputs/sample_images_while_training/' + dataset utils.mkdir(save_dir) im.imwrite( im.immerge(sample_opt, 2, 3), f'{save_dir}/Epoch_({epoch})_({it_epoch}of{batch_epoch}).jpg') except: save_path = saver.save( sess, f'{ckpt_dir}/Epoch_({epoch})_({it_epoch}of{batch_epoch}).ckpt') print(f'Model saved in file: {save_path}') sess.close()
ab_pair_test_pool = data.ImageDataPair(sess, a_test_img_paths, batch_size=3, load_size=load_size, shuffle=False, crop_size=crop_size) ab_pair_ipt = ab_pair_test_pool.batch_match() a_ipt = ab_pair_ipt[:,:,:,:3] b_ipt = ab_pair_ipt[:,:,:,3:] predict = sess.run(predict_op, feed_dict={a_real: a_ipt}) print('predict: ', predict.shape) sample_opt = a_ipt sample_opt[:,:,:,0] = 0.7*sample_opt[:,:,:,0] + 0.3* predict[:,:,:,0] im.imwrite(im.immerge(sample_opt, len(sample_opt), 1), './result.jpg') # test_img_paths = glob(input_path + '*') # for path in test_img_paths: # img = tf.read_file(path) # img = tf.image.decode_jpeg(img, channels=3) # img = tf.image.resize_images(img, load_size) # img = (img - tf.reduce_min(img)) / (tf.reduce_max(img) - tf.reduce_min(img)) # img = tf.expand_dims(img, axis=0) # img = sess.run(img) # predict_op = tf.image.resize_images(predict_op, [376, 1242]) # predict = sess.run(predict_op, feed_dict={a_real: img})
# Sample images for external evaluation (i.e. just raw single images). Note: For triplet=true, there are 2x steps involved. if args.samplingcycle > 0 and (it % args.samplingcycle == 0) and it > 0: print("Create samples for the external evaluator (aux batch {} with size {})".format(int(it/args.samplingcycle), args.online_sampling_batch_size)) for c_i in range(args.online_sampling_batch_size): fname = 'Transformed_from_%s_(%dof%d)_once.png' % (args.stage2, c_i, args.singletestN) save_single_img(a_real_ipt = b_test_pool.batch(), b_real_ipt = c_test_pool.batch(), save_dir = './aux_samples/' + args.dataset + subnet_ext_maybe+'/'+args.stage2+'/'+str(int(it)), fname=fname) # Create sample images with a-b-a structure if (it + 1) % 100 == 0: a_real_ipt = b_test_pool.batch() b_real_ipt = c_test_pool.batch() [a2b_opt, a2b2a_opt, b2a_opt, b2a2b_opt] = sess.run([a2b, a2b2a, b2a, b2a2b], feed_dict={a_real: a_real_ipt, b_real: b_real_ipt}) sample_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt, b_real_ipt, b2a_opt, b2a2b_opt), axis=0) im.imwrite(im.immerge(sample_opt, 2, 3), '%s/Epoch_(%d)_(%dof%d).png' % (online_samples_dir, epoch, it_epoch, batch_epoch)) if args.double_cycle: [a2b_opt, a2b2a_opt, b2a_opt, b2a2b_opt] = sess.run([a2b, a2b2a, b2a, b2a2b], feed_dict={a_real: a2b_opt, b_real: b2a_opt}) sample_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt, b_real_ipt, b2a_opt, b2a2b_opt), axis=0) im.imwrite(im.immerge(sample_opt, 2, 3), '%s/Epoch_(%d)_(%dof%d)_double_cycle.png' % (online_samples_dir, epoch, it_epoch, batch_epoch)) if do_save and last_it != -1: save_path = saver.save(sess, '%s/Epoch_(%d)_(%dof%d)_step_(%d).ckpt' % (ckpt_dir, epoch, it_epoch, batch_epoch,last_it)) print('Final model saved in file: % s' % save_path) elif args.chaintestdir: chaintests_N = 20 print("Run chain test on dir {} for {} times".format(args.chaintestdir, chaintests_N)) for c_i in range(chaintests_N): a_real_ipt = b_test_pool.batch()
# Inference for i in range(len(a_list)): # Define shapes for images fed to the graph a_feed = im.imresize(im.imread(a_list[i]), [crop_size, crop_size]) a_feed.shape = 1, crop_size, crop_size, 3 # Feed in images to the graph a2b_result = sess.run(a_output, feed_dict={a_input: a_feed}) print(type(a2b_result)) print(a2b_result.shape) # pickle.dump(a2b_result, open("C:/Users/ag17634/Desktop/save.p", "wb")) # Create and save the output image a_img_opt = a2b_result img_name = os.path.basename(a_list[i]) output = im.immerge(a_img_opt, 1, 1) im.imwrite(output, a_save_dir + '/' + img_name) print('Save %s' % (a_save_dir + '/' + img_name)) if i == 100: end = time.time() end2 = time.time() # print("Time to process first 100 images:", end - start) print("Time to process all %d images: %f" % (i + 1, end2 - start))
raise Exception('No checkpoint!') else: print('Copy variables from % s' % ckpt_path) # test a_list = glob('./datasets/' + dataset + '/testA/*.jpg') b_list = glob('./datasets/' + dataset + '/testB/*.jpg') a_save_dir = './test_predictions/' + dataset + '/testA/' b_save_dir = './test_predictions/' + dataset + '/testB/' utils.mkdir([a_save_dir, b_save_dir]) for i in range(len(a_list)): a_real_ipt = im.imresize(im.imread(a_list[i]), [crop_size, crop_size]) a_real_ipt.shape = 1, crop_size, crop_size, 3 a2b_opt, a2b2a_opt = sess.run([a2b, a2b2a], feed_dict={a_real: a_real_ipt}) a_img_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt), axis=0) img_name = os.path.basename(a_list[i]) im.imwrite(im.immerge(a_img_opt, 1, 3), a_save_dir + img_name) print('Save %s' % (a_save_dir + img_name)) for i in range(len(b_list)): b_real_ipt = im.imresize(im.imread(b_list[i]), [crop_size, crop_size]) b_real_ipt.shape = 1, crop_size, crop_size, 3 b2a_opt, b2a2b_opt = sess.run([b2a, b2a2b], feed_dict={b_real: b_real_ipt}) b_img_opt = np.concatenate((b_real_ipt, b2a_opt, b2a2b_opt), axis=0) img_name = os.path.basename(b_list[i]) im.imwrite(im.immerge(b_img_opt, 1, 3), b_save_dir + img_name) print('Save %s' % (b_save_dir + img_name))
epoch = it // batch_epoch it_epoch = it % batch_epoch + 1 # display if it % 1 == 0: print("Epoch: (%3d) (%5d/%5d)" % (epoch, it_epoch, batch_epoch)) # save if (it + 1) % 1000 == 0: save_path = saver.save(sess, '%s/Epoch_(%d)_(%dof%d).ckpt' % (ckpt_dir, epoch, it_epoch, batch_epoch)) print('Model saved in file: % s' % save_path) # sample if (it + 1) % 100 == 0: a_real_ipt = a_test_pool.batch() b_real_ipt = b_test_pool.batch() [a2b_opt, a2b2a_opt, b2a_opt, b2a2b_opt] = sess.run([a2b, a2b2a, b2a, b2a2b], feed_dict={a_real: a_real_ipt, b_real: b_real_ipt}) sample_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt, b_real_ipt, b2a_opt, b2a2b_opt), axis=0) save_dir = './sample_images_while_training/' + dataset utils.mkdir(save_dir + '/') im.imwrite(im.immerge(sample_opt, 2, 3), '%s/Epoch_(%d)_(%dof%d).jpg' % (save_dir, epoch, it_epoch, batch_epoch)) except Exception, e: coord.request_stop(e) finally: print("Stop threads and close session!") coord.request_stop() coord.join(threads) sess.close()
print(len(shape)) variable_parameters = 1 for dim in shape: print(dim) variable_parameters *= dim.value print(variable_parameters) total_parameters += variable_parameters print("\nTotal parameters:\n", total_parameters) # start = time.time() # Inference for i in range(len(a_list)): # Define shapes for images fed to the graph a_feed = im.imresize(im.imread(a_list[i]), [crop_size, crop_size]) a_feed.shape = 1, crop_size, crop_size, 3 # Feed in images to the graph a2b_result = sess.run(a2b, feed_dict={a_input: a_feed}) # Create and save the output image a_img_opt = np.concatenate((a_feed, a2b_result), axis=0) img_name = os.path.basename(a_list[i]) im.imwrite(im.immerge(a_img_opt, 1, 2), a_save_dir + '/' + img_name) print('Save %s' % (a_save_dir + '/' + img_name)) # if i == 100: # end = time.time() # end2 = time.time() # print("Time to process first 100 images:", end - start) # print("Time to process all %d images: %f" % (i + 1, end2 - start))
save_path = saver.save( sess, '%s/Epoch_(%d)_(%dof%d).ckpt' % (ckpt_dir, epoch, it_epoch, batch_epoch)) print('Model saved in file: % s' % save_path) # sample if (it + 1) % 100 == 0: a_real_ipt = a_test_pool.batch() b_real_ipt = b_test_pool.batch() [a2b_opt, a2b2a_opt, b2a_opt, b2a2b_opt] = sess.run([a2b, a2b2a, b2a, b2a2b], feed_dict={ a_real: a_real_ipt, b_real: b_real_ipt }) sample_opt = np.concatenate((a_real_ipt, a2b_opt, a2b2a_opt, b_real_ipt, b2a_opt, b2a2b_opt), axis=0) save_dir = './outputs/sample_images_while_training/' + dataset utils.mkdir(save_dir) im.imwrite( im.immerge(sample_opt, 2, 3), '%s/Epoch_(%d)_(%dof%d).jpg' % (save_dir, epoch, it_epoch, batch_epoch)) except: save_path = saver.save( sess, '%s/Epoch_(%d)_(%dof%d).ckpt' % (ckpt_dir, epoch, it_epoch, batch_epoch)) print('Model saved in file: % s' % save_path) sess.close()
def save_single_img(a_real_ipt, b_real_ipt, save_dir, fname, forward_mapping=True): [a2b_opt] = sess.run([a2b if forward_mapping else b2a], feed_dict={a_real: a_real_ipt, b_real: b_real_ipt}) sample_opt = np.array(a2b_opt) utils.mkdir(save_dir + '/') targetDir = '%s/%s' % (save_dir, fname) im.imwrite(im.immerge(sample_opt,1,1), targetDir)