def _demo(): # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.checkpoint_dir, )) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories filenames = [random.choice(prepare_dirs(delete_train_dir=False))] # Setup async input queues features, labels = srez_input.setup_inputs(sess, filenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) # Restore variables from checkpoint # saver = tf.train.Saver() # filename = 'checkpoint_new.txt' # filename = os.path.join(FLAGS.checkpoint_dir, filename) # saver.restore(sess, filename) filename = 'checkpoint_new.txt.meta' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver = tf.train.import_meta_graph(filename) saver.restore(sess, tf.train.latest_checkpoint('./')) # Execute demo train_data = TrainData(locals()) srez_demo.demo1(train_data)
def _demo(self): # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.checkpoint_dir, )) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories filenames = prepare_dirs(delete_train_dir=False) # Setup async input queues features, labels = srez_input.setup_inputs(sess, filenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) # Restore variables from checkpoint saver = tf.train.Saver() filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver.restore(sess, filename) # Execute demo srez_demo.demo1(sess)
def _demo(): # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.checkpoint_dir,)) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories filenames = prepare_dirs(delete_train_dir=False) # Setup async input queues features, labels = srez_input.setup_inputs(sess, filenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) # Restore variables from checkpoint saver = tf.train.Saver() filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver.restore(sess, filename) # Execute demo srez_demo.demo1(sess)
def srez_output(input_fn, output_fn, checkpoint_file): input_image, sz, hackfn = get_input_feature(input_fn) # dummy files to satisfy input pipeline # TODO: remove input pipeline filenames = ['/input/data/sample.jpg'] sess, summary_writer = setup_tensorflow() try: features, labels = srez_input.setup_inputs(sess, filenames, sz*4) [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) saver = tf.train.Saver() saver.restore(sess, checkpoint_file) feed_dict = {gene_minput: input_image} gene_output = sess.run(gene_moutput, feed_dict=feed_dict) gene_output = gene_output.reshape(list(gene_output.shape)[1:]) misc.toimage(gene_output, cmin=0., cmax=1.).save(output_fn) except tf.errors.CancelledError: pass finally: sess.close()
def _train(): # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories # all_filenames = prepare_dirs(delete_train_dir=True, shuffle_filename=False) filenames_input = get_filenames(dir_file=FLAGS.dataset_input, shuffle_filename=False) # if not specify use the same as input if FLAGS.dataset_output == '': FLAGS.dataset_output = FLAGS.dataset_input filenames_output = get_filenames(dir_file=FLAGS.dataset_output, shuffle_filename=False) # Separate training and test sets # train_filenames = all_filenames[:-FLAGS.test_vectors] # test_filenames = all_filenames[-FLAGS.test_vectors:] train_filenames_input = filenames_input[:-FLAGS.test_vectors] test_filenames_input = filenames_input[-FLAGS.test_vectors:] train_filenames_output = filenames_output[:-FLAGS.test_vectors] test_filenames_output = filenames_output[-FLAGS.test_vectors:] # TBD: Maybe download dataset here # Setup async input queues train_features, train_labels = srez_input.setup_inputs_one_sources(sess, train_filenames_input, train_filenames_output, image_size=FLAGS.sample_size, axis_undersample=FLAGS.axis_undersample) test_features, test_labels = srez_input.setup_inputs_one_sources(sess, test_filenames_input, test_filenames_output, image_size=FLAGS.sample_size, axis_undersample=FLAGS.axis_undersample) # sample size num_sample_train = len(train_filenames_input) num_sample_test = len(test_filenames_input) print('train on {0} samples and test on {1} samples'.format(num_sample_train, num_sample_test)) # Add some noise during training (think denoising autoencoders) noise_level = .00 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list, gene_layers, gene_mlayers] = \ srez_model.create_model(sess, noisy_train_features, train_labels) gene_loss = srez_model.create_generator_loss(disc_fake_output, gene_output, train_features, train_labels) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data, num_sample_train, num_sample_test)
def retro_infere(sess): """Generate image based on model""" # Setup async input queues filenames = tf.gfile.ListDirectory(FLAGS.source_fake_dir) filenames = sorted(filenames) filenames = [ os.path.join(FLAGS.source_dir, f) for f in filenames if f[-4:] == '.jpg' ] labelnames = tf.gfile.ListDirectory(FLAGS.source_real_dir) labelnames = sorted(labelnames) labelnames = [ os.path.join(FLAGS.source_real_dir, f) for f in labelnames if f[-4:] == '.jpg' ] features, labels = srez_input.setup_inputs(sess, filenames, labelnames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) # Restore variables from checkpoint saver = tf.train.Saver() chk_filename = 'checkpoint_new.txt' chk_filename = os.path.join(FLAGS.checkpoint_dir, chk_filename) saver.restore(sess, chk_filename) # Infere on an image feature, label = sess.run([features, labels]) feed_dict = {gene_minput: feature} gene_output = sess.run(gene_moutput, feed_dict=feed_dict) size = [label.shape[1], label.shape[2]] nearest = tf.image.resize_nearest_neighbor(feature, size) nearest = tf.maximum(tf.minimum(nearest, 1.0), 0.0) bicubic = tf.image.resize_bicubic(feature, size) bicubic = tf.maximum(tf.minimum(bicubic, 1.0), 0.0) clipped = tf.maximum(tf.minimum(gene_output, 1.0), 0.0) image = tf.concat(2, [nearest, bicubic, clipped, label]) #image = tf.concat(0, [image[0,:,:,:]]) print("There are ", len(filenames), "files") image = tf.concat(0, [image[i, :, :, :] for i in range(len(filenames))]) image = sess.run(image) res_filename = 'check_results.png' res_filename = os.path.join(FLAGS.result_dir, res_filename) scipy.misc.toimage(image, cmin=0., cmax=1.).save(res_filename) print(" Saved result")
def _train(): # Setup global tensorflow state sess = setup_tensorflow() # Prepare directories # all_filenames = prepare_dirs(delete_train_dir=True) all_filenames = prepare_dirs(delete_train_dir=False) # Separate training and test sets train_filenames = all_filenames[:-FLAGS.test_vectors] test_filenames = all_filenames[-FLAGS.test_vectors:] # TBD: Maybe download dataset here # Setup async input queues train_features, train_labels = srez_input.setup_inputs( sess, train_filenames) test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) # Add some noise during training (think denoising autoencoders) noise_level = .03 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list, dropout] = \ srez_model.create_model(sess, noisy_train_features, train_labels) gene_loss = srez_model.create_generator_loss(disc_fake_output, gene_output, train_features) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Restore variables from checkpoint if EXISTS # if tf.gfile.IsDirectory(FLAGS.checkpoint_dir): # filename = 'checkpoint_new.txt' # filename = os.path.join(FLAGS.checkpoint_dir, filename) # saver = tf.train.Saver() # if tf.gfile.Exists(filename): # saver.restore(tf.Session(), filename) # print("Restored previous checkpoint. " # "Warning, Batch number restarted.") # Train model train_data = TrainData(locals()) srez_train.train_model(train_data)
def _test16(onefilename=False): # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.checkpoint_dir, )) # Load test set if not tf.gfile.IsDirectory(FLAGS.test_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.test_dir, )) # Setup global tensorflow state sess = setup_tensorflow() # Prepare directories if os.path.isfile(onefilename): filenames = [onefilename] elif os.path.isdir(onefilename): filenames = [ os.path.join(onefilename, f) for f in os.listdir(onefilename) if os.path.isfile(os.path.join(onefilename, f)) ] # Was to check the size input. # im = Image.open(onefilename) # size = im.size # Setup async input queues test_features, test_labels = srez_input.test_inputs(sess, filenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list, dropout] = \ srez_model.create_model(sess, test_features, test_labels) # Restore variables from checkpoint saver = tf.train.Saver() filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver.restore(sess, filename) # Loop through and run/predict each picture. for file in filenames: test_features, test_labels = srez_input.test_inputs(sess, [file]) test_feature, test_label = sess.run([test_features, test_labels]) feed_dict = {gene_minput: test_label, dropout: 1.0} gene_output = sess.run(gene_moutput, feed_dict=feed_dict) srez_test.predict_one(sess, test_feature, test_label, gene_output, file)
def _evaluate(): # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.checkpoint_dir, )) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories Tfilenames = prepare_dirs(delete_train_dir=False) features, labels = srez_input.setup_inputs(sess, Tfilenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) # Restore variables from checkpoint_dir saver = tf.train.Saver() filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver.restore(sess, filename) print("RESTORE model") #region prediction test predict_restore = gene_moutput # Prepare directories filenames = prepare_dirs(delete_train_dir=False) # UPDATE: Evaluate 4 images. NEEDS to be 4. test_filenames = [ 'dataset/101287.jpg', 'dataset/101288.jpg', 'dataset/101289.jpg', 'dataset/101290.jpg' ] test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) test_img4_input, test_img4_original = sess.run( [test_features, test_labels]) test_img5 = (tf.convert_to_tensor(test_img4_input)).eval(session=sess) feed_dict = {gene_minput: test_img5} prob = sess.run(predict_restore, feed_dict) #endregion prediction test td = TrainData(locals()) srez_train._summarize_progress(td, test_img4_input, test_img4_original, prob, 69, 'out') print("Finish EVALUATING")
def _train(): # Prepare directories all_filenames = prepare_dirs(delete_train_dir=True) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() #saver = tf.train.Saver() #filename = 'checkpoint' #filename = os.path.join(FLAGS.checkpoint_dir, filename) #saver.restore(sess,tf.train.latest_checkpoint("./checkpoint/")) #print("Model restored from file: %s" % FLAGS.checkpoint_dir) # Separate training and test sets train_filenames = all_filenames[:-FLAGS.test_vectors] test_filenames = all_filenames[-FLAGS.test_vectors:] # TBD: Maybe download dataset here # Setup async input queues train_features, train_labels = srez_input.setup_inputs( sess, train_filenames) test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) # Add some noise during training (think denoising autoencoders) noise_level = .03 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, noisy_train_features, train_labels) gene_loss = srez_model.create_generator_loss(disc_fake_output, gene_output, train_features) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data)
def _train(): # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories all_filenames = prepare_dirs(delete_train_dir=True) # Separate training and test sets rn.shuffle(all_filenames) train_filenames = all_filenames[:-FLAGS.test_vectors] test_filenames = all_filenames[-FLAGS.test_vectors:] # TBD: Maybe download dataset here # Setup async input queues train_features, train_labels = srez_input.setup_inputs(sess, train_filenames, image_size=32, crop_size=128) test_features, test_labels = srez_input.setup_inputs(sess, test_filenames, image_size=32, crop_size=128) # Add some noise during training (think denoising autoencoders) noise_level = .03 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, noisy_train_features, train_labels) gene_loss = srez_model.create_generator_loss(disc_fake_output, gene_output, train_features) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data)
def _test(onefilename=False): # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.checkpoint_dir, )) # Prepare directories if onefilename: filenames = [onefilename] else: # Load test set if not tf.gfile.IsDirectory(FLAGS.test_dir): raise FileNotFoundError("Could not find folder `%s'" % (FLAGS.test_dir, )) filenames = prepare_test_dir() # Setup global tensorflow state sess = setup_tensorflow() # Setup async input queues test_features, test_labels = srez_input.test_inputs(sess, filenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list, dropout] = \ srez_model.create_model(sess, test_features, test_labels) dropout = tf.placeholder(tf.float32) # Restore variables from checkpoint saver = tf.train.Saver() filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver.restore(sess, filename) test_data = TrainData(locals()) td = test_data test_feature, test_label = sess.run([test_features, test_labels]) feed_dict = {gene_minput: test_feature, dropout: 1.0} gene_output = sess.run(gene_moutput, feed_dict=feed_dict) if onefilename: srez_test.predict_one(test_data, gene_output) else: srez_test.predict(test_data, test_feature, test_label, gene_output)
def _train(): # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories all_filenames = prepare_dirs(delete_train_dir=False) # Separate training and test sets if FLAGS.specific_test: train_filenames = all_filenames[:] test_filenames = prepare_test_dirs()[:] else: train_filenames = all_filenames[:-FLAGS.test_vectors] test_filenames = all_filenames[-FLAGS.test_vectors:] # Setup async input queues train_features, train_labels = srez_input.setup_inputs( sess, train_filenames) test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) # Add some noise during training (think denoising autoencoders) noise_level = .03 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, noisy_train_features, train_labels) gene_loss, gene_l1_loss, gene_ce_loss = srez_model.create_generator_loss( disc_fake_output, gene_output, train_features, train_labels) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(2 * FLAGS.disc_real_factor * disc_real_loss, 2 * (1 - FLAGS.disc_real_factor) * disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data)
def _train(): # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories all_filenames = prepare_dirs(delete_train_dir=True) # Separate training and test sets train_filenames = all_filenames[:-FLAGS.test_vectors] test_filenames = all_filenames[-FLAGS.test_vectors:] # TBD: Maybe download dataset here # Setup async input queues train_features, train_labels = srez_input.setup_inputs(sess, train_filenames) test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) # Add some noise during training (think denoising autoencoders) noise_level = .03 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, noisy_train_features, train_labels) gene_loss = srez_model.create_generator_loss(disc_fake_output, gene_output, train_features) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data)
def _get_inference_data(): # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Load single image to use for inference if FLAGS.infile is None: raise ValueError( 'Must specify inference input file through `--infile <filename>` command line argument' ) if not tf.gfile.Exists(FLAGS.infile) or tf.gfile.IsDirectory(FLAGS.infile): raise FileNotFoundError('File `%s` does not exist or is a directory' % (FLAGS.infile, )) filenames = [FLAGS.infile] infer_images = srez_input.setup_inputs(sess, filenames) print('Loading model...') # Create inference model infer_model = srez_model.create_model(sess, infer_images) # Load model parameters from checkpoint checkpoint = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) try: saver = tf.train.Saver() saver.restore(sess, checkpoint.model_checkpoint_path) del saver del checkpoint except: raise RuntimeError('Unable to read checkpoint from `%s`' % (FLAGS.checkpoint_dir, )) print('Done.') # Pack all for convenience infer_data = srez_utils.Container(locals()) return infer_data
def _demo2(demo_func=srez_demo.demo2): time_start = time.strftime("%Y-%m-%d-%H-%M-%S") print("START. Time is {}".format(time_start)) mkdirp(FLAGS.train_dir) parameters = save_parameters(time_start=time_start) # Load checkpoint if not tf.gfile.IsDirectory(FLAGS.checkpoint_dir): raise FileNotFoundError("Could not find folder '{}'".format( FLAGS.checkpoint_dir)) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # data directories if FLAGS.preset_files: test_filenames_input = prepare_preset_files(FLAGS.dataset, test_files, shuffle=False) test_filenames_output = prepare_preset_files(FLAGS.dataset, test_files, shuffle=False) else: test_filenames_input = get_filenames(dir_file=FLAGS.dataset, shuffle_filename=False) test_filenames_output = get_filenames(dir_file=FLAGS.dataset, shuffle_filename=False) if FLAGS.subsample_test > 0: index_sample_test_selected = random.sample( range(len(test_filenames_input)), FLAGS.subsample_test) if not FLAGS.permutation_test: index_sample_test_selected = sorted(index_sample_test_selected) test_filenames_input = [ test_filenames_input[x] for x in index_sample_test_selected ] test_filenames_output = [ test_filenames_output[x] for x in index_sample_test_selected ] # image_size if FLAGS.sample_size_y > 0: image_size = [FLAGS.sample_size, FLAGS.sample_size_y] else: image_size = [FLAGS.sample_size, FLAGS.sample_size] # get undersample mask from scipy import io as sio try: content_mask = sio.loadmat(FLAGS.sampling_pattern) key_mask = [x for x in content_mask.keys() if not x.startswith('_')] mask = content_mask[key_mask[0]] except: mask = None # Setup async input queues features, labels, masks = srez_input.setup_inputs_one_sources( sess, test_filenames_input, test_filenames_output, image_size=image_size, # undersampling axis_undersample=FLAGS.axis_undersample, r_factor=FLAGS.R_factor, r_alpha=FLAGS.R_alpha, r_seed=FLAGS.R_seed, sampling_mask=mask) # Create and initialize model [gene_minput, gene_moutput, gene_moutput_complex, gene_output, gene_output_complex, gene_var_list, gene_layers, gene_mlayers, disc_real_output, disc_fake_output, disc_moutput, disc_var_list, disc_layers, disc_mlayers] = \ srez_model.create_model(sess, features, labels, masks) # Restore variables from checkpoint saver = tf.train.Saver() filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) saver.restore(sess, filename) # Execute demo test_data = TrainData(locals()) if FLAGS.subsample_test > 0: num_sample = FLAGS.subsample_test elif FLAGS.sample_test > 0: num_sample = FLAGS.sample_test else: num_sample = FLAGS.batch_size demo_func(test_data, num_sample) time_ended = time.strftime("%Y-%m-%d-%H-%M-%S") print("ENDED. Time is {}".format(time_ended)) # Overwrite log file now that we are complete save_parameters(use_flags=False, existing=parameters, time_ended=time_ended)
def _train(): time_start = time.strftime("%Y-%m-%d-%H-%M-%S") print("START. Time is {}".format(time_start)) # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # image_size if FLAGS.sample_size_y > 0: image_size = [FLAGS.sample_size, FLAGS.sample_size_y] else: image_size = [FLAGS.sample_size, FLAGS.sample_size] # Prepare train and test directories (SEPARATE FOLDER) prepare_dirs(delete_train_dir=True, shuffle_filename=False) if FLAGS.cv_index >= 0: # Cross-validation filenames_input_train = [] filenames_output_train = [] for i in range(FLAGS.cv_groups): if i == FLAGS.cv_index: continue train_dir = os.path.join(FLAGS.dataset, str(i)) filenames = get_filenames(dir_file=train_dir, shuffle_filename=True) filenames_input_train.extend(filenames) filenames_output_train.extend(filenames) test_dir = os.path.join(FLAGS.dataset, str(FLAGS.cv_index)) filenames_input_test = get_filenames(dir_file=test_dir, shuffle_filename=True) filenames_output_test = get_filenames(dir_file=test_dir, shuffle_filename=True) else: filenames_input_train = get_filenames(dir_file=FLAGS.dataset_train, shuffle_filename=True) filenames_output_train = get_filenames(dir_file=FLAGS.dataset_train, shuffle_filename=True) filenames_input_test = get_filenames(dir_file=FLAGS.dataset_test, shuffle_filename=False) filenames_output_test = get_filenames(dir_file=FLAGS.dataset_test, shuffle_filename=False) # Record parameters parameters = save_parameters(time_start=time_start) ## Prepare directories (SAME FOLDER) #prepare_dirs(delete_train_dir=True, shuffle_filename=False) #filenames_input = get_filenames(dir_file=FLAGS.dataset_input, shuffle_filename=False) ## if not specify use the same as input #if FLAGS.dataset_output == '': #FLAGS.dataset_output = FLAGS.dataset_input #filenames_output = get_filenames(dir_file=FLAGS.dataset_output, shuffle_filename=False) # check input and output sample number matches (SEPARATE FOLDER) assert (len(filenames_input_train) == len(filenames_output_train)) num_filename_train = len(filenames_input_train) assert (len(filenames_input_test) == len(filenames_output_test)) num_filename_test = len(filenames_input_test) print(num_filename_train) print(num_filename_test) # check input and output sample number matches (SAME FOLDER) #assert(len(filenames_input)==len(filenames_output)) #num_filename_all = len(filenames_input) # Permutate train and test split (SEPARATE FOLDERS) if FLAGS.permutation_split: index_permutation_split = random.sample(num_filename_train, num_filename_train) filenames_input_train = [ filenames_input_train[x] for x in index_permutation_split ] filenames_output_train = [ filenames_output_train[x] for x in index_permutation_split ] #print(np.shape(filenames_input_train)) if FLAGS.permutation_split: index_permutation_split = random.sample(num_filename_test, num_filename_test) filenames_input_test = [ filenames_input_test[x] for x in index_permutation_split ] filenames_output_test = [ filenames_output_test[x] for x in index_permutation_split ] #print('filenames_input[:20]',filenames_input[:20]) # Permutate test split (SAME FOLDERS) #if FLAGS.permutation_split: #index_permutation_split = random.sample(num_filename_test, num_filename_test) #filenames_input_test = [filenames_input_test[x] for x in index_permutation_split] #filenames_output_test = [filenames_output_test[x] for x in index_permutation_split] #print('filenames_input[:20]',filenames_input[:20]) # Separate training and test sets (SEPARATE FOLDERS) sample_train = len(filenames_input_train ) if FLAGS.sample_train <= 0 else FLAGS.sample_train sample_test = len( filenames_input_test) if FLAGS.sample_test <= 0 else FLAGS.sample_test train_filenames_input = filenames_input_train[:sample_train] train_filenames_output = filenames_output_train[:sample_train] # TODO If separate folders, make the index `:sample_test` # Using index `-sample_test:` hacks it for a same-folder split. test_filenames_input = filenames_input_test[ -sample_test:] # filenames_input_test[:sample_test] test_filenames_output = filenames_output_test[ -sample_test:] # filenames_output_test[:sample_test] #print('test_filenames_input', test_filenames_input) #print('train_filenames_input', train_filenames_input) # Separate training and test sets (SAME FOLDERS) #train_filenames_input = filenames_input[:-FLAGS.sample_test] #train_filenames_output = filenames_output[:-FLAGS.sample_test] #test_filenames_input = filenames_input[-FLAGS.sample_test:] #test_filenames_output = filenames_output[-FLAGS.sample_test:] #print('test_filenames_input[:20]',test_filenames_input[:20]) # randomly subsample for train if FLAGS.subsample_train > 0: index_sample_train_selected = random.sample( range(len(train_filenames_input)), FLAGS.subsample_train) if not FLAGS.permutation_train: index_sample_train_selected = sorted(index_sample_train_selected) train_filenames_input = [ train_filenames_input[x] for x in index_sample_train_selected ] train_filenames_output = [ train_filenames_output[x] for x in index_sample_train_selected ] print('randomly sampled {0} from {1} train samples'.format( len(train_filenames_input), len(train_filenames_input[:FLAGS.sample_train]))) # randomly sub-sample for test if FLAGS.subsample_test > 0: index_sample_test_selected = random.sample( range(len(test_filenames_input)), FLAGS.subsample_test) if not FLAGS.permutation_test: index_sample_test_selected = sorted(index_sample_test_selected) test_filenames_input = [ test_filenames_input[x] for x in index_sample_test_selected ] test_filenames_output = [ test_filenames_output[x] for x in index_sample_test_selected ] #print('randomly sampled {0} from {1} test samples'.format(len(test_filenames_input), len(filenames_inp/.ut[:-FLAGS.sample_test]))) #print('test_filenames_input',test_filenames_input) # get undersample mask from scipy import io as sio try: content_mask = sio.loadmat(FLAGS.sampling_pattern) key_mask = [x for x in content_mask.keys() if not x.startswith('_')] mask = content_mask[key_mask[0]] except: mask = None # Setup async input queues train_features, train_labels, train_masks = srez_input.setup_inputs_one_sources( sess, train_filenames_input, train_filenames_output, image_size=image_size, # undersampling axis_undersample=FLAGS.axis_undersample, r_factor=FLAGS.R_factor, r_alpha=FLAGS.R_alpha, r_seed=FLAGS.R_seed, sampling_mask=mask) test_features, test_labels, test_masks = srez_input.setup_inputs_one_sources( sess, test_filenames_input, test_filenames_output, image_size=image_size, # undersampling axis_undersample=FLAGS.axis_undersample, r_factor=FLAGS.R_factor, r_alpha=FLAGS.R_alpha, r_seed=FLAGS.R_seed, sampling_mask=mask) print('train_features_queue', train_features.get_shape()) print('train_labels_queue', train_labels.get_shape()) print('train_masks_queue', train_masks.get_shape()) #train_masks = tf.cast(sess.run(train_masks), tf.float32) #test_masks = tf.cast(sess.run(test_masks), tf.float32) # sample train and test num_sample_train = len(train_filenames_input) num_sample_test = len(test_filenames_input) print('train on {0} samples and test on {1} samples'.format( num_sample_train, num_sample_test)) # Add some noise during training (think denoising autoencoders) noise_level = .00 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, gene_moutput, gene_moutput_complex, \ gene_output, gene_output_complex, gene_var_list, gene_layers, gene_mlayers, \ disc_real_output, disc_fake_output, disc_moutput, disc_var_list, disc_layers, disc_mlayers] = \ srez_model.create_model(sess, noisy_train_features, train_labels, train_masks, architecture=FLAGS.architecture) gene_loss, gene_dc_loss, gene_ls_loss, list_gene_losses, gene_mse_factor = srez_model.create_generator_loss( disc_fake_output, gene_output, gene_output_complex, train_features, train_labels, train_masks) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') # add gradient on disc loss disc_gradients = tf.gradients( disc_loss, [disc_fake_output, disc_real_output, gene_output]) print('disc loss gradients:', [x.shape for x in disc_gradients]) (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data, num_sample_train, num_sample_test) time_ended = time.strftime("%Y-%m-%d-%H-%M-%S") print("ENDED. Time is {}".format(time_ended)) # Overwrite log file now that we are complete save_parameters(use_flags=False, existing=parameters, time_ended=time_ended)
# Setup global tensorflow state sess, summary_writer = srez_main.setup_tensorflow() # Prepare directories filenames = srez_main.prepare_test_dirs() assert len(filenames) >= FLAGS.max_samples, "Not enough test images" # Setup async input queues features, labels = srez_input.setup_inputs(sess, filenames) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_model.create_model(sess, features, labels) # Restore variables from checkpoint saver = tf.train.Saver() ckpt_filename = 'checkpoint_new.txt' ckpt_filepath = os.path.join(FLAGS.checkpoint_dir, ckpt_filename) saver.restore(sess, ckpt_filepath) # Run inference using pretrained model feature, label = sess.run([features, labels]) feed_dict = {gene_minput: feature} gene_output = sess.run(gene_moutput, feed_dict=feed_dict) size = [label.shape[1], label.shape[2]]
def _train(): # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories all_filenames = prepare_dirs(delete_train_dir=True) # Separate training and test sets # train_filenames = all_filenames[:-FLAGS.test_vectors] # test_filenames = all_filenames[-FLAGS.test_vectors:] # We chose a pre-determined set of faces for the convenience of comparing results across models determined_test = [73883-1, 110251-1, 36510-1, 132301-1, 57264-1, 152931-1, 93861-1, 124938-1, 79512-1, 106152-1, 127384-1, 134028-1, 67874-1, 10613-1, 198694-1, 100990-1] all_filenames = np.array(all_filenames) train_filenames = list(np.delete(all_filenames, determined_test)) # test_filenames = list(all_filenames[determined_test]) # Setup async input queues train_features, train_labels = srez_input.setup_inputs(sess, train_filenames) # test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) # Test sets are stored in 'testset_label.npy' test_labels = np.load('testset_label.npy') test_labels = tf.convert_to_tensor(test_labels, dtype = tf.float32) if FLAGS.input == 'scaled': test_features = tf.image.resize_area(test_labels, [16, 16]) elif FLAGS.input == 'noise': test_features = tf.random_uniform(shape=[16, FLAGS.noise_dimension, FLAGS.noise_dimension, 3],minval= -1., maxval=1.) # Add some noise during training (think denoising autoencoders) noise_level = FLAGS.train_noise noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, gradients, disc_var_list] = \ srez_model.create_model(sess, noisy_train_features, train_labels) # >>> add summary scalars for test set max_samples = 10 # output 10 test images gene_output_clipped = tf.maximum(tf.minimum(gene_moutput, 1.0), 0.) # Calculate the L1 error between output samples and labels as a objective measure of image quality if FLAGS.input != 'noise': l1_quality = tf.reduce_sum(tf.abs(gene_output_clipped - test_labels), [1,2,3]) l1_quality = tf.reduce_mean(l1_quality[:max_samples]) mse_quality = tf.reduce_sum(tf.square(gene_output_clipped - test_labels), [1,2,3]) mse_quality = tf.reduce_mean(mse_quality[:max_samples]) tf.summary.scalar('l1_quality', l1_quality, collections=['test_scalars']) tf.summary.scalar('mse_quality', mse_quality, collections=['test_scalars']) gene_loss = srez_model.create_generator_loss(disc_fake_output, gene_output, train_features) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) # Different training objectives if FLAGS.loss_func == 'dcgan': # for DCGAN disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') elif FLAGS.loss_func == 'wgan': # for WGAN disc_loss = tf.subtract(disc_real_loss, disc_fake_loss, name='disc_loss') elif FLAGS.loss_func == 'wgangp': # for WGANGP disc_loss = tf.subtract(disc_real_loss, disc_fake_loss) slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes-1.)**2) disc_loss = tf.add(disc_loss, FLAGS.LAMBDA*gradient_penalty, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize, d_clip) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # For tensorboard tf.summary.scalar('generator_loss', gene_loss) tf.summary.scalar('discriminator_real_loss', disc_real_loss) tf.summary.scalar('discriminator_fake_loss', disc_fake_loss) tf.summary.scalar('discriminator_tot_loss', disc_loss) # Train model train_data = TrainData(locals()) srez_train.train_model(train_data)
def _train(): # Setup global tensorflow state sess, _oldwriter = setup_tensorflow() # image_size if FLAGS.sample_size_y > 0: image_size = [FLAGS.sample_size, FLAGS.sample_size_y] else: image_size = [FLAGS.sample_size, FLAGS.sample_size] # Prepare train and test directories (SEPARATE FOLDER) prepare_dirs(delete_train_dir=True, shuffle_filename=False) filenames_input_train = get_filenames(dir_file=FLAGS.dataset_train, shuffle_filename=True) filenames_output_train = get_filenames(dir_file=FLAGS.dataset_train, shuffle_filename=True) filenames_input_test = get_filenames(dir_file=FLAGS.dataset_test, shuffle_filename=False) filenames_output_test = get_filenames(dir_file=FLAGS.dataset_test, shuffle_filename=False) ## Prepare directories (SAME FOLDER) #prepare_dirs(delete_train_dir=True, shuffle_filename=False) #filenames_input = get_filenames(dir_file=FLAGS.dataset_input, shuffle_filename=False) ## if not specify use the same as input #if FLAGS.dataset_output == '': #FLAGS.dataset_output = FLAGS.dataset_input #filenames_output = get_filenames(dir_file=FLAGS.dataset_output, shuffle_filename=False) # check input and output sample number matches (SEPARATE FOLDER) assert (len(filenames_input_train) == len(filenames_output_train)) num_filename_train = len(filenames_input_train) assert (len(filenames_input_test) == len(filenames_output_test)) num_filename_test = len(filenames_input_test) #print(num_filename_train) #print(num_filename_test) #print(filenames_output_test) # check input and output sample number matches (SAME FOLDER) #assert(len(filenames_input)==len(filenames_output)) #num_filename_all = len(filenames_input) # Permutate train and test split (SEPARATE FOLDERS) if FLAGS.permutation_split: index_permutation_split = random.sample(num_filename_train, num_filename_train) filenames_input_train = [ filenames_input_train[x] for x in index_permutation_split ] filenames_output_train = [ filenames_output_train[x] for x in index_permutation_split ] #print(np.shape(filenames_input_train)) if FLAGS.permutation_split: index_permutation_split = random.sample(num_filename_test, num_filename_test) filenames_input_test = [ filenames_input_test[x] for x in index_permutation_split ] filenames_output_test = [ filenames_output_test[x] for x in index_permutation_split ] #print('filenames_input[:20]',filenames_input[:20]) # Permutate test split (SAME FOLDERS) #if FLAGS.permutation_split: #index_permutation_split = random.sample(num_filename_test, num_filename_test) #filenames_input_test = [filenames_input_test[x] for x in index_permutation_split] #filenames_output_test = [filenames_output_test[x] for x in index_permutation_split] #print('filenames_input[:20]',filenames_input[:20]) # Separate training and test sets (SEPARATE FOLDERS) train_filenames_input = filenames_input_train[:FLAGS.sample_train] train_filenames_output = filenames_output_train[:FLAGS.sample_train] test_filenames_input = filenames_input_test[:FLAGS.sample_test] test_filenames_output = filenames_output_test[:FLAGS.sample_test] #print('test_filenames_input', test_filenames_input) #print('train_filenames_input', train_filenames_input) # Separate training and test sets (SAME FOLDERS) #train_filenames_input = filenames_input[:-FLAGS.sample_test] #train_filenames_output = filenames_output[:-FLAGS.sample_test] #test_filenames_input = filenames_input[-FLAGS.sample_test:] #test_filenames_output = filenames_output[-FLAGS.sample_test:] #print('test_filenames_input[:20]',test_filenames_input[:20]) # randomly subsample for train if FLAGS.subsample_train > 0: index_sample_train_selected = random.sample( range(len(train_filenames_input)), FLAGS.subsample_train) if not FLAGS.permutation_train: index_sample_train_selected = sorted(index_sample_train_selected) train_filenames_input = [ train_filenames_input[x] for x in index_sample_train_selected ] train_filenames_output = [ train_filenames_output[x] for x in index_sample_train_selected ] print('randomly sampled {0} from {1} train samples'.format( len(train_filenames_input), len(filenames_input_train[:-FLAGS.sample_test]))) # randomly sub-sample for test if FLAGS.subsample_test > 0: index_sample_test_selected = random.sample( range(len(test_filenames_input)), FLAGS.subsample_test) print(len(test_filenames_input)) print(FLAGS.subsample_test) if not FLAGS.permutation_test: index_sample_test_selected = sorted(index_sample_test_selected) test_filenames_input = [ test_filenames_input[x] for x in index_sample_test_selected ] test_filenames_output = [ test_filenames_output[x] for x in index_sample_test_selected ] print('randomly sampled {0} from {1} test samples'.format( len(test_filenames_input), len(test_filenames_input[:-FLAGS.sample_test]))) #print('test_filenames_input',test_filenames_input) # get undersample mask from scipy import io as sio try: content_mask = sio.loadmat(FLAGS.sampling_pattern) key_mask = [x for x in content_mask.keys() if not x.startswith('_')] mask = content_mask[key_mask[0]] except: mask = None print(len(train_filenames_input)) print(len(train_filenames_output)) print(len(test_filenames_input)) print(len(test_filenames_output)) # Setup async input queues train_features, train_labels, train_masks = srez_input.setup_inputs_one_sources( sess, train_filenames_input, train_filenames_output, image_size=image_size, # undersampling axis_undersample=FLAGS.axis_undersample, r_factor=FLAGS.R_factor, r_alpha=FLAGS.R_alpha, r_seed=FLAGS.R_seed, sampling_mask=mask) test_features, test_labels, test_masks = srez_input.setup_inputs_one_sources( sess, test_filenames_input, test_filenames_output, image_size=image_size, # undersampling axis_undersample=FLAGS.axis_undersample, r_factor=FLAGS.R_factor, r_alpha=FLAGS.R_alpha, r_seed=FLAGS.R_seed, sampling_mask=mask) print('features_size', train_features.get_shape()) print('labels_size', train_labels.get_shape()) print('masks_size', train_masks.get_shape()) # sample train and test num_sample_train = len(train_filenames_input) num_sample_test = len(test_filenames_input) print('train on {0} samples and test on {1} samples'.format( num_sample_train, num_sample_test)) # Add some noise during training (think denoising autoencoders) noise_level = .00 noisy_train_features = train_features + \ tf.random_normal(train_features.get_shape(), stddev=noise_level) # Create and initialize model [gene_minput, label_minput, gene_moutput, gene_moutput_list, \ gene_output, gene_output_list, gene_var_list, gene_layers_list, gene_mlayers_list, gene_mask_list, gene_mask_list_0, \ disc_real_output, disc_fake_output, disc_var_list, train_phase,disc_layers, eta, nmse, kappa] = \ srez_model.create_model(sess, noisy_train_features, train_labels, train_masks, architecture=FLAGS.architecture) #train_phase = tf.placeholder(tf.bool, []) gene_loss, gene_dc_loss, gene_ls_loss, gene_mse_loss, list_gene_losses, gene_mse_factor = srez_model.create_generator_loss( disc_fake_output, gene_output, gene_output_list, train_features, train_labels, train_masks) disc_real_loss, disc_fake_loss = \ srez_model.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_model.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # tensorboard summary_op = tf.summary.merge_all() #restore variables from checkpoint filename = 'checkpoint_new.txt' filename = os.path.join(FLAGS.checkpoint_dir, filename) metafile = filename + '.meta' """ if tf.gfile.Exists(metafile): saver = tf.train.Saver() print("Loading checkpoint from file `%s'" % (filename,)) saver.restore(sess, filename) else: print("No checkpoint `%s', train from scratch" % (filename,)) sess.run(tf.global_variables_initializer()) """ print("No checkpoint `%s', train from scratch" % (filename, )) print( np.sum([ np.prod(v.get_shape().as_list()) for v in tf.trainable_variables() ])) sess.run(tf.global_variables_initializer()) # Train model train_data = TrainData(locals()) srez_train.train_model(sess, train_data, num_sample_train, num_sample_test)