def main(start_time): tf.enable_eager_execution() # handle arguments and config args = parse_arguments() args.start_time = start_time tf.logging.info("Args: {}".format(args)) args.second_data_dir = args.second_data_dir or args.data_dir args.input_type = "image" args.second_input_type = "patho" args.has_colored_input = True args.has_colored_second_input = False args.has_colored_target = True args.has_noise_input = False args.discriminator_classes = 1 if os.path.exists(os.path.join("output", args.eval_dir, "checkpoints")): args.output_dir = os.path.join("output", args.eval_dir) else: args.output_dir = os.path.join("old-output", args.eval_dir) args.checkpoint_dir = os.path.join(args.output_dir, "checkpoints") model = load_model(args) generator = model.get_generator() discriminator = model.get_discriminator() load_checkpoint(args, checkpoint_number=args.epoch // 25, generator=generator, discriminator=discriminator) images_per_type = 2 training_input_image_names = np.array(load_image_names(args.data_dir)) training_second_input_image_names = np.array( load_image_names(args.second_data_dir)) args.test_data_dir = args.data_dir + "-TEST" args.test_second_data_dir = args.second_data_dir + "-TEST" test_input_image_names = np.array(load_image_names(args.test_data_dir)) test_second_input_image_names = np.array( load_image_names(args.test_second_data_dir)) input_indexes = np.random.choice(min(len(training_input_image_names), len(test_input_image_names)), args.image_count * images_per_type, replace=False) for image_number in range(args.image_count): indexes = input_indexes[images_per_type * image_number:images_per_type * (image_number + 1)] generate_samples(args, generator, discriminator, training_input_image_names[indexes], training_second_input_image_names[indexes], test_input_image_names[indexes], test_second_input_image_names[indexes], image_number) tf.logging.info("Finished evaluation")
def load_data(self): image_names = load_image_names(self._config.data_dir, self._config.match_pattern) target_images = load_images(image_names, self._config.data_dir, self._config.target_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) # load/prepare test data test_target_images = None if self._config.test_data_dir: tf.logging.info("Loading test data") test_image_names = load_image_names(self._config.test_data_dir, self._config.match_pattern) test_target_images = load_images(test_image_names, self._config.test_data_dir, self._config.target_type, flip_lr=False, flip_ud=False) if self._config.test_data_percentage: tf.logging.warning( "Using the first {}% of the training data for testing".format( 100 * self._config.test_data_percentage)) split = int(len(target_images) * self._config.test_data_percentage) test_target_images = target_images[:split] target_images = target_images[split:] data_set_size = len(target_images) test_set_size = len( [] if test_target_images is None else test_target_images) # build data sets self._data_set = tf.data.Dataset.from_tensor_slices(target_images)\ .map(lambda x: (tf.random_normal([self._config.noise_dimensions]), x))\ .shuffle(data_set_size).batch(self._config.batch_size) del target_images if test_target_images is not None: self._test_data_set = tf.data.Dataset.from_tensor_slices(test_target_images)\ .map(lambda x: (tf.random_normal([self._config.noise_dimensions]), x))\ .shuffle(test_set_size).batch(self._config.batch_size) del test_target_images else: tf.logging.warning("Running evaluation without test data!") return data_set_size, test_set_size
def initialize(self, override_data_dir=None): assert self._real_activations is None data_dir = override_data_dir if override_data_dir else \ (self._config.target_data_dir if self._config.target_data_dir else self._config.data_dir) activations_file = os.path.join( "data", data_dir, "activations_{}.npz".format(self._config.extractor_name)) if os.path.exists(activations_file): tf.logging.info( "Loading activations from {}".format(activations_file)) with np.load(activations_file) as activations: self._real_activations = [ tf.convert_to_tensor(activations[f]) for f in sorted(activations.files) ] else: tf.logging.warning( "Computing activations for real images in '{}'".format( data_dir)) self._real_activations = self._get_activations_from_images( load_image_names(data_dir)) tf.logging.info( "Saving activations to {}".format(activations_file)) np.savez( activations_file, **{ "block_{}".format(i): act.numpy() for i, act in enumerate(self._real_activations) }) tf.logging.debug("Fitting PCA") self._pca = PCA(n_components=2) low_dimensional_real_activations = self._pca.fit_transform( self._real_activations[-1]) tf.logging.debug("Explained variance: {} ({:.5f})".format( self._pca.explained_variance_ratio_, np.sum(self._pca.explained_variance_ratio_))) high_dimensional_clusters = 7 tf.logging.debug( "Clustering high-dimensional activations with {} clusters".format( high_dimensional_clusters)) self._high_dimensional_kmeans = KMeans( n_clusters=high_dimensional_clusters) self._high_dimensional_kmeans.fit(self._real_activations[-1]) tf.logging.debug("Inertia: {:.1f}".format( self._high_dimensional_kmeans.inertia_)) low_dimensional_clusters = 4 tf.logging.debug( "Clustering low-dimensional activations with {} clusters".format( low_dimensional_clusters)) self._low_dimensional_kmeans = KMeans( n_clusters=low_dimensional_clusters) self._low_dimensional_kmeans.fit(low_dimensional_real_activations) tf.logging.debug("Inertia: {:.1f}".format( self._low_dimensional_kmeans.inertia_))
def compute_perceptual_scores(generator, discriminator, args): tf.logging.fatal("Computing perceptual scores") assert args.data_dir generate_samples(generator, discriminator, args, len(load_image_names(args.data_dir))) extractor = PerceptualScores(args) extractor.initialize() fid, mmd, high_dimensional, low_dimensional, _, _ = extractor.compute_scores_from_samples( ) tf.logging.warning( "Clustering scores, high-dimensional: {:.3f}; low-dimensional: {:.3f}". format(high_dimensional, low_dimensional)) tf.logging.warning("FID: {:.3f}, k-MMD: {:.3f}".format(fid, mmd)) tf.logging.info( "Perceptual scores (FID,MMD,high,low): {:.5f}, {:.5f}, {:.5f}, {:.5f}". format(fid, mmd, high_dimensional, low_dimensional))
def load_data(self): # load and prepare names input_image_names = load_image_names(self._config.data_dir, self._config.match_pattern) second_input_image_names = input_image_names if not self._config.second_data_dir else \ load_image_names(self._config.second_data_dir, self._config.match_pattern) assert not self._config.use_extra_first_inputs, "not implemented" if len(second_input_image_names) < len(input_image_names): tf.logging.warning( "There are fewer second input images; shuffling and reducing input images" ) np.random.shuffle(input_image_names) input_image_names = input_image_names[:len(second_input_image_names )] target_image_names = input_image_names if not self._config.target_data_dir else \ second_input_image_names if self._config.target_data_dir == self._config.second_data_dir else \ load_image_names(self._config.target_data_dir, self._config.match_pattern) assert len(target_image_names) >= len(input_image_names) name_size = min( min(len(input_image_names), len(second_input_image_names)), len(target_image_names)) if len(input_image_names) != len(target_image_names) or len( second_input_image_names) != len(target_image_names): tf.logging.warning( "Reducing data set to {} (input: {}, second input: {}, target: {})" .format(name_size, len(input_image_names), len(second_input_image_names), len(target_image_names))) input_image_names = input_image_names[:name_size] second_input_image_names = second_input_image_names[:name_size] tf.logging.info( "Input and target data are different; shuffling targets before reducing" ) np.random.shuffle(target_image_names) if self._config.train_disc_on_extra_targets: extra_target_image_names = target_image_names[name_size:] extra_target_image_names = extra_target_image_names[:len( input_image_names)] # select the first X extra images else: extra_target_image_names = None target_image_names = target_image_names[:name_size] else: assert not self._config.train_disc_on_extra_targets, "there are no extra targets to train on" extra_target_image_names = None # load images input_images = load_images(input_image_names, self._config.data_dir, self._config.input_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) second_input_images = load_images( second_input_image_names, self._config.second_data_dir or self._config.data_dir, self._config.second_input_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) combined_input_images = np.concatenate( [input_images, second_input_images], axis=-1) del input_images target_images = load_images(target_image_names, self._config.target_data_dir or self._config.data_dir, self._config.target_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) if extra_target_image_names: extra_target_images = load_images( extra_target_image_names, self._config.target_data_dir or self._config.data_dir, self._config.target_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) tf.logging.warning( "Adding {} extra targets for the discriminator!".format( len(extra_target_images))) self._extra_discriminator_data_set = tf.data.Dataset.from_tensor_slices(extra_target_images)\ .shuffle(len(extra_target_images)).batch(self._config.batch_size) del extra_target_images assert len(combined_input_images) == len(target_images) combined_target_images = np.concatenate( [target_images, second_input_images], axis=-1) data_set_size = len(target_images) del second_input_images del target_images # load/prepare test data test_input_images = None test_target_images = None if self._config.test_data_dir: tf.logging.info("Loading test data") test_input_image_names = load_image_names( self._config.test_data_dir, self._config.match_pattern) test_second_input_image_names = test_input_image_names if not self._config.test_second_data_dir else \ load_image_names(self._config.test_second_data_dir, self._config.match_pattern) if len(test_second_input_image_names) < len( test_input_image_names): tf.logging.warning( "TEST: There are fewer second input images; shuffling and reducing input images" ) np.random.shuffle(test_input_image_names) test_input_image_names = test_input_image_names[:len( test_second_input_image_names)] test_target_image_names = test_input_image_names if not self._config.test_target_data_dir else \ test_second_input_image_names if self._config.test_target_data_dir == self._config.test_second_data_dir else \ load_image_names(self._config.test_target_data_dir, self._config.match_pattern) assert len(test_target_image_names) >= len(test_input_image_names) name_size = min( min(len(test_input_image_names), len(test_second_input_image_names)), len(test_target_image_names)) if len(test_input_image_names) != len( test_target_image_names) or len( test_second_input_image_names) != len( test_target_image_names): tf.logging.warning( "Reducing data set to {} (input: {}, second input: {}, target: {})" .format(name_size, len(test_input_image_names), len(test_second_input_image_names), len(test_target_image_names))) test_input_image_names = test_input_image_names[:name_size] test_second_input_image_names = test_second_input_image_names[: name_size] tf.logging.info( "Input and target data are different; shuffling targets before reducing" ) np.random.shuffle(test_target_image_names) test_target_image_names = test_target_image_names[:name_size] test_input_images = load_images(test_input_image_names, self._config.test_data_dir, self._config.input_type, flip_lr=False, flip_ud=False) test_second_input_images = load_images( test_second_input_image_names, self._config.test_second_data_dir or self._config.test_data_dir, self._config.second_input_type, flip_lr=False, flip_ud=False) test_combined_input_images = np.concatenate( [test_input_images, test_second_input_images], axis=-1) del test_input_images test_target_images = load_images(test_target_image_names, self._config.test_target_data_dir or self._config.test_data_dir, self._config.target_type, flip_lr=False, flip_ud=False) test_combined_target_images = np.concatenate( [test_target_images, test_second_input_images], axis=-1) assert len(test_combined_input_images) == len(test_target_images) del test_second_input_images assert not self._config.test_data_percentage, "not implemented" test_set_size = len( [] if test_target_images is None else test_target_images) del test_target_images # set up epoch samples sample_indexes = np.random.choice(data_set_size, np.prod(self._epoch_images_shape), replace=False) self._epoch_sample_input = tf.convert_to_tensor( combined_input_images[sample_indexes]) self._epoch_sample_targets = tf.convert_to_tensor( combined_target_images[sample_indexes]) # build data sets self._data_set = tf.data.Dataset.from_tensor_slices((combined_input_images, tf.random_shuffle(combined_target_images)))\ .shuffle(data_set_size).batch(self._config.batch_size) del combined_input_images del combined_target_images if test_set_size: self._test_data_set = tf.data.Dataset.from_tensor_slices((test_combined_input_images, tf.random_shuffle(test_combined_target_images)))\ .shuffle(test_set_size).batch(self._config.batch_size) del test_combined_input_images del test_combined_target_images else: tf.logging.warning("Running evaluation without test data!") return data_set_size, test_set_size
def main(start_time): tf.enable_eager_execution() configure_logging() # handle arguments and config args = parse_arguments() args.start_time = start_time tf.logging.info("Args: {}".format(args)) args.second_data_dir = args.second_data_dir or args.data_dir args.target_data_dir = args.target_data_dir or args.data_dir args.match_pattern = None args.augmentation_flip_lr = False args.augmentation_flip_ud = False args.has_noise_input = args.input_type == "noise" args.has_colored_input = args.input_type == "image" args.has_colored_second_input = args.second_input_type == "image" args.has_colored_target = args.target_type == "image" args.discriminator_classes = 1 if os.path.exists(os.path.join("output", args.eval_dir, "checkpoints")): args.checkpoint_dir = os.path.join("output", args.eval_dir, "checkpoints") else: args.checkpoint_dir = os.path.join("old-output", args.eval_dir, "checkpoints") model = load_model(args) discriminator = model.get_discriminator() if args.evaluate_generator: generator = model.get_generator() load_checkpoint(args, checkpoint_number=(args.epoch + 24) // 25 if args.epoch else args.epoch, generator=generator, discriminator=discriminator) else: generator = None load_checkpoint(args, checkpoint_number=(args.epoch + 24) // 25 if args.epoch else args.epoch, discriminator=discriminator) # assert not (bool(args.test_data_dir) and bool(args.test_data_samples)), \ # "either use a part of the training data for test *OR* some actual test data" training_input_image_names = load_image_names(args.data_dir) training_second_input_image_names = load_image_names( args.second_data_dir) if args.second_input_type else None training_target_image_names = load_image_names(args.target_data_dir) if training_second_input_image_names is not None: if len(training_input_image_names) > len( training_second_input_image_names): tf.logging.info( "Input and second input data are different; shuffling inputs before reducing" ) np.random.shuffle(training_input_image_names) training_input_image_names = training_input_image_names[:len( training_second_input_image_names)] assert len(training_input_image_names) == len( training_second_input_image_names) assert len(training_target_image_names) == len(training_input_image_names) if args.data_dir != args.target_data_dir or args.second_data_dir != args.target_data_dir: tf.logging.info( "Input and target data are different; shuffling targets before reducing" ) np.random.shuffle(training_target_image_names) training_target_image_names = training_target_image_names[:len( training_input_image_names)] if args.compute_test_scores: if args.test_data_samples: # remove data that's not actually in the training set from the training data if args.split_data: raise NotImplementedError() tf.logging.warning( "Using the first {} unaugmented samples of the training data for testing" .format(args.test_data_samples)) test_input_image_names = training_input_image_names[:args. test_data_samples] training_input_image_names = training_input_image_names[ args.test_data_samples:] if args.second_input_type: test_second_input_image_names = training_second_input_image_names[: args . test_data_samples] training_second_input_image_names = training_second_input_image_names[ args.test_data_samples:] else: test_second_input_image_names = None test_target_image_names = training_target_image_names[:args. test_data_samples] training_target_image_names = training_target_image_names[ args.test_data_samples:] args.test_data_dir = args.data_dir args.test_second_data_dir = args.second_data_dir args.test_target_data_dir = args.target_data_dir else: args.test_data_dir = args.data_dir + "-TEST" args.test_second_data_dir = args.second_data_dir + "-TEST" args.test_target_data_dir = args.target_data_dir + "-TEST" test_input_image_names = load_image_names(args.test_data_dir) test_second_input_image_names = load_image_names( args.test_second_data_dir) if args.second_input_type else None test_target_image_names = load_image_names( args.test_target_data_dir) if test_second_input_image_names is not None: if len(test_input_image_names) > len( test_second_input_image_names): tf.logging.info( "TEST input and second input data are different; shuffling inputs before reducing" ) np.random.shuffle(test_input_image_names) test_input_image_names = test_input_image_names[:len( test_second_input_image_names)] assert len(test_input_image_names) == len( test_second_input_image_names) assert len(test_target_image_names) >= len(test_input_image_names) if args.test_data_dir != args.test_target_data_dir or args.test_second_data_dir != args.test_target_data_dir: tf.logging.info( "TEST input and target data are different; shuffling targets before reducing" ) np.random.shuffle(test_target_image_names) test_target_image_names = test_target_image_names[:len( test_input_image_names)] else: test_input_image_names = test_second_input_image_names = test_target_image_names = None if args.evaluate_discriminator: # evaluate D on real images tf.logging.warning("Evaluating D") evaluate_discriminations( args, None, discriminator, training_input_image_names, training_second_input_image_names, training_target_image_names, test_input_image_names, test_second_input_image_names, test_target_image_names) if generator: # if there's also a generator, evalaute D on generated images tf.logging.warning("Evaluating G (evaluating D on generated images)") evaluate_discriminations( args, generator, discriminator, training_input_image_names, training_second_input_image_names, training_target_image_names, test_input_image_names, test_second_input_image_names, test_target_image_names) tf.logging.info("Finished evaluation")
# parse descriptions descriptions = load_flicker8k_token(filename) # clean descriptions cleaned_descriptions = clean_descriptions(descriptions) # summarize vocabulary vocabulary = get_all_vocab(descriptions) save_descriptions(descriptions, 'descriptions.txt') ################################################################## # load training dataset (6K) filename = os.path.join(text_file_base_dir, 'Flickr_8k.trainImages.txt') train = load_image_names(filename) print('Num of data samples: %d' % len(train)) # Below path contains all the images images_dir = os.path.join(base_dir, 'data/captioning/Flicker8k_Dataset/') # Below file conatains the names of images to be used in train data train_image_txt_file = os.path.join(text_file_base_dir, 'Flickr_8k.trainImages.txt') train_image_paths = get_image_paths(images_dir, train_image_txt_file) test_image_txt_file = os.path.join(text_file_base_dir, 'Flickr_8k.testImages.txt') test_image_paths = get_image_paths(images_dir, test_image_txt_file)
def main(start_time): tf.enable_eager_execution() # handle arguments and config args = parse_arguments() args.start_time = start_time args.match_pattern = None args.batch_size = 4 args.eval_dir = os.path.join("output", args.eid) if not os.path.exists(args.eval_dir): args.eval_dir = os.path.join("old-output", args.eid) args.checkpoint_dir = os.path.join(args.eval_dir, "checkpoints") tf.logging.info("Args: {}".format(args)) if not args.noise: tf.logging.warning("Needs to be cleaned/fixed/re-implemented first") legacy(args) else: args.noise_dimensions = 100 args.has_colored_target = True image_names = load_image_names(args.data_dir) images = load_images(image_names, args.data_dir, image_subdir) targets = (tf.convert_to_tensor(images) + 1) * 127.5 model = load_model(args) generator = model.get_generator() # discriminator = model.get_discriminator() load_checkpoint(args, checkpoint_number=args.epoch // 25, generator=generator) #, discriminator=discriminator) args.rows = 4 args.columns = 2 for i in trange(args.image_count): plt.figure(figsize=(32, 32)) plt.axis("off") for j, noise in enumerate( tf.data.Dataset.from_tensor_slices( tf.random_normal( [args.rows * args.columns, args.noise_dimensions])).batch(args.batch_size)): samples = generator(noise, training=False) for k, sample in enumerate(samples): plt.subplot(args.rows, 2 * args.columns, 2 * j * args.batch_size + 2 * k + 1) Evaluation.plot_image(sample) plt.subplot(args.rows, 2 * args.columns, 2 * j * args.batch_size + 2 * k + 2) similar_sample, similarity = find_nearest_sample( (sample + 1) * 127.5, targets, args.batch_size) Evaluation.plot_image(similar_sample, similarity, denormalize=False) plt.tight_layout() figure_file = os.path.join( args.eval_dir, "nearest_samples_ssim_{:03d}.png".format(i)) plt.savefig(figure_file) plt.close() tf.logging.info("Finished generating {} images".format(args.image_count))
def main(start_time): tf.enable_eager_execution() # handle arguments and config args = parse_arguments() args.start_time = start_time args.noise_dimensions = None args.has_colored_target = False args.output_dir = os.path.join("output", args.eval_dir) if not os.path.exists(args.output_dir): args.output_dir = os.path.join("old-output", args.eval_dir) args.checkpoint_dir = os.path.join(args.output_dir, "checkpoints") tf.logging.info("Args: {}".format(args)) model = load_model(args) generator = model.get_generator() if args.cycle: tf.logging.warning("Loading second generator of CycleGAN") load_checkpoint(args, checkpoint_number=(args.epoch+24)//25, second_generator=generator) else: load_checkpoint(args, checkpoint_number=(args.epoch+24)//25, generator=generator) image_names = load_image_names(args.test_data, args.match_pattern) input_images = load_images(image_names, args.test_data, "image") target_images = load_images(image_names, args.test_data, "patho") target_data_set = tf.data.Dataset.from_tensor_slices((input_images, target_images)).batch(args.batch_size) tf.logging.info("Computing segmentation score over {} images in batches of {}".format(len(target_images), args.batch_size)) scores = list() all_tp = 0 all_fp = 0 all_fn = 0 with tqdm(total=len(target_images)) as pbar: for batch in target_data_set: inputs, targets = batch pbar.update(inputs.shape[0].value) generated_images = generator(inputs, training=False) predicted = tf.cast(generated_images >= 0, tf.uint8) actual = tf.cast(targets >= 0, tf.uint8) tp = tf.count_nonzero(predicted * actual) fp = tf.count_nonzero(predicted * (actual - 1)) fn = tf.count_nonzero((predicted - 1) * actual) all_tp += tp all_fp += fp all_fn += fn precision = tp / (tp + fp) recall = tp / (tp + fn) f1 = (2 * precision * recall / (precision + recall)).numpy() if not np.isnan(f1): scores.append(f1) precision = all_tp / (all_tp + all_fp) recall = all_tp / (all_tp + all_fn) f1 = (2 * precision * recall / (precision + recall)).numpy() tf.logging.info("Segmentation score: {:.3f} ({:.3}+-{:.3})".format(f1, np.mean(scores), np.std(scores))) tf.logging.info("TP {}, FP {}, FN {}".format(all_tp, all_fp, all_fn)) if args.score_name: with open(os.path.join(args.output_dir, args.score_name), "w") as fh: fh.write("{}\n".format(",".join([str(s) for s in scores])))
def compute_reconstruction_scores(generator, args): tf.logging.fatal("Computing reconstruction scores") image_names = load_image_names(args.data_dir) np.random.shuffle(image_names) images = load_images(image_names[:args.batch_size], args.data_dir, image_subdir) targets = tf.convert_to_tensor(images) rows = 4 columns = 3 images, titles, all_similarity_losses = ReconstructionScores( generator, targets, args.noise_dimensions).compute_scores(True) # assert len(images) == len(titles) and len(images[0]) == len(titles[0]) # for j, _ in enumerate(images): # plt.figure(figsize=(32, 32)) # subplot = 1 # for i in range(0, len(images[0]), 10): # if i == len(images[0])-1: # break # the last image is printed afterwards # plt.subplot(rows, columns, subplot) # Evaluation.plot_image(images[j][i], titles[j][i]) # subplot += 1 # plt.subplot(rows, columns, subplot) # Evaluation.plot_image(images[j][-1], "Final " + titles[j][-1]) # plt.subplot(rows, columns, subplot+1) # Evaluation.plot_image(targets[j], "Target") # plt.savefig(os.path.join(args.output_dir, "{}reconstruction_{:03d}.png".format( # "{}_".format(args.description) if args.description else "", j))) # plot for report plt.figure(figsize=(30, 4 * args.batch_size)) for j, _ in enumerate(images): epochs_to_plot = [0, 5, 10, 50, 100] for subplot, i in enumerate(epochs_to_plot): plt.subplot(args.batch_size, len(epochs_to_plot) + 1, subplot + 1 + j * (len(epochs_to_plot) + 1)) Evaluation.plot_image(images[j][i], titles[j][i]) plt.subplot(args.batch_size, len(epochs_to_plot) + 1, subplot + 2 + j * (len(epochs_to_plot) + 1)) Evaluation.plot_image(targets[j], "Target") plt.tight_layout() plt.savefig( os.path.join( args.output_dir, "{}reconstruction_report.png".format( "{}_".format(args.description) if args.description else ""))) plt.figure() last_losses = all_similarity_losses[-1].numpy() plt.title("Similarity losses, final ({} epochs): {:.5f}+-{:.5f}".format( len(all_similarity_losses), last_losses.mean(), last_losses.std())) plt.xlabel("Epochs") plt.ylabel("Similarity loss") for i in range(all_similarity_losses[0].shape[0]): plt.plot(range(1, len(all_similarity_losses) + 1), [similarity[i] for similarity in all_similarity_losses], label="Reconstruction {}".format(i + 1)) plt.legend() plt.savefig( os.path.join( args.output_dir, "{}reconstruction_loss-curves.png".format( "{}_".format(args.description) if args.description else ""))) plt.close()
def main(start_time): tf.enable_eager_execution() # handle arguments and config args = parse_arguments() args.start_time = start_time tf.logging.info("Args: {}".format(args)) assert args.input_type == "patho" assert args.target_type == "image" args.has_colored_input = args.input_type == "image" args.has_colored_target = args.target_type == "image" args.discriminator_classes = 1 args.checkpoint_dir = os.path.join("output", args.eval_dir, "checkpoints") model = load_model(args) generator = model.get_generator() discriminator = model.get_discriminator() load_checkpoint(args, checkpoint_number=args.epoch // 25, generator=generator, discriminator=discriminator) input_image_names = np.array(load_image_names(args.data_dir)) # target_image_names = input_image_names if not args.target_data_dir else \ # np.array(load_image_names(args.target_data_dir)) sample_indexes = np.random.choice(len(input_image_names), args.interpolation_pairs * 2 * args.image_count, replace=False) input_images = load_images(input_image_names[sample_indexes], args.data_dir, args.input_type) # target_images = load_images(target_image_names[sample_indexes], args.target_data_dir or args.data_dir, args.target_type) for image_number in range(args.image_count): tf.logging.info("Generating image {}/{}".format( image_number + 1, args.image_count)) plt.figure(figsize=(int(args.width / 100), int(args.height / 100))) with tqdm(total=args.interpolation_pairs * args.interpolation_steps) as pbar: for i in range(args.interpolation_pairs): index = 2 * i + 2 * image_number * args.interpolation_pairs for j in range(args.interpolation_steps): pbar.update(1) input_sample = interp_shape( input_images[index, :, :, 0], input_images[index + 1, :, :, 0], float(j) / (args.interpolation_steps - 1)) gen_input = tf.expand_dims(tf.expand_dims(input_sample, 0), -1) predictions = generator(gen_input, training=False) disc_input = tf.concat( [gen_input, predictions], axis=-1 ) if args.conditioned_discriminator else predictions classifications = discriminator(disc_input, training=False) plt.subplot(args.interpolation_pairs * 2, args.interpolation_steps, 2 * i * args.interpolation_steps + j + 1) plt.axis("off") if args.has_colored_input: plt.imshow( np.array((input_sample + 1) * 127.5, dtype=np.uint8)) else: plt.imshow(np.array((input_sample + 1) * 127.5, dtype=np.uint8), cmap="gray", vmin=0, vmax=255) plt.subplot( args.interpolation_pairs * 2, args.interpolation_steps, 2 * i * args.interpolation_steps + j + 1 + args.interpolation_steps) plt.axis("off") plt.title(np.round( logistic(classifications[0]).numpy(), 5), fontsize=20) if args.has_colored_target: plt.imshow( np.array((predictions[0] + 1) * 127.5, dtype=np.uint8)) else: plt.imshow(np.array( (predictions[0, :, :, 0] + 1) * 127.5, dtype=np.uint8), cmap="gray", vmin=0, vmax=255) plt.tight_layout() figure_file = os.path.join( "output", args.eval_dir, "noise_interpolation{}_{:03d}.png".format( "_{}".format(args.description) if args.description else "", image_number + 1)) plt.savefig(figure_file) plt.close() tf.logging.info("Finished generating {} images".format(args.image_count))
def load_data(self): # load and prepare names input_image_names = load_image_names(self._config.data_dir, self._config.match_pattern) target_image_names = input_image_names if not self._config.target_data_dir else \ load_image_names(self._config.target_data_dir, self._config.match_pattern) name_size = min(len(input_image_names), len(target_image_names)) if len(input_image_names) != len(target_image_names): tf.logging.warning( "Reducing data set to {} (input: {}, target: {})".format( name_size, len(input_image_names), len(target_image_names))) input_image_names = input_image_names[:name_size] assert self._config.data_dir == self._config.target_data_dir, "should shuffle target images before reducing" target_image_names = target_image_names[:name_size] assert not self._config.train_disc_on_extra_targets, "not implemented" # load images input_images = load_images(input_image_names, self._config.data_dir, self._config.input_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) target_images = load_images(target_image_names, self._config.target_data_dir or self._config.data_dir, self._config.target_type, flip_lr=self._config.augmentation_flip_lr, flip_ud=self._config.augmentation_flip_ud) assert len(input_images) == len(target_images) # load/prepare test data test_input_images = None test_target_images = None if self._config.test_data_dir: assert not self._config.target_data_dir, "alternative test target data currently isn't supported" tf.logging.info("Loading test data") test_input_image_names = load_image_names( self._config.test_data_dir, self._config.match_pattern) test_input_images = load_images(test_input_image_names, self._config.test_data_dir, self._config.input_type, flip_lr=False, flip_ud=False) test_target_images = load_images(test_input_image_names, self._config.test_data_dir, self._config.target_type, flip_lr=False, flip_ud=False) assert len(test_input_images) == len(test_target_images) if self._config.test_data_percentage: tf.logging.warning( "Using the first {}% of the training data for testing".format( 100 * self._config.test_data_percentage)) split = int(len(target_images) * self._config.test_data_percentage) test_input_images = input_images[:split] input_images = input_images[split:] test_target_images = target_images[:split] target_images = target_images[split:] data_set_size = len(target_images) test_set_size = len( [] if test_target_images is None else test_target_images) # set up epoch samples sample_indexes = np.random.choice(data_set_size, np.prod(self._epoch_images_shape), replace=False) self._epoch_sample_input = tf.convert_to_tensor( input_images[sample_indexes]) self._epoch_sample_targets = target_images[sample_indexes] # build data sets self._data_set = tf.data.Dataset.from_tensor_slices((input_images, target_images))\ .shuffle(data_set_size).batch(self._config.batch_size) del input_images del target_images if test_target_images is not None: self._test_data_set = tf.data.Dataset.from_tensor_slices((test_input_images, test_target_images))\ .shuffle(test_set_size).batch(self._config.batch_size) del test_input_images del test_target_images else: tf.logging.warning("Running evaluation without test data!") return data_set_size, test_set_size