def generate(file_list, data_dir, output_dir, context_len=32, stats=None, base_model_path='./pls.model', gan_model_path='./noise_gen.model'): pulse_model = time_glot_model(timesteps=context_len) gan_model = generator() pulse_model.compile(loss='mse', optimizer="adam") gan_model.compile(loss='mse', optimizer="adam") pulse_model.load_weights(base_model_path) gan_model.load_weights(gan_model_path) for data in nc_data_provider(file_list, data_dir, input_only=True, context_len=context_len): for fname, ac_data in data.iteritems(): print fname pls_pred, _ = pulse_model.predict([ac_data]) noise = np.random.randn(pls_pred.shape[0], pls_pred.shape[1]) pls_gan, _ = gan_model.predict([pls_pred, noise]) out_file = os.path.join(args.output_dir, fname + '.pls') pls_gan.astype(np.float32).tofile(out_file) out_file = os.path.join(args.output_dir, fname + '.pls_nonoise') pls_pred.astype(np.float32).tofile(out_file)
def generate(args): # Context ctx = get_extension_context(args.context, device_id=args.device_id, type_config=args.type_config) nn.set_default_context(ctx) # Args latent = args.latent maps = args.maps batch_size = args.batch_size # Generator nn.load_parameters(args.model_load_path) z_test = nn.Variable([batch_size, latent]) x_test = generator(z_test, maps=maps, test=True, up=args.up) # Monitor monitor = Monitor(args.monitor_path) monitor_image_tile_test = MonitorImageTile("Image Tile Generated", monitor, num_images=batch_size, interval=1, normalize_method=denormalize) # Generation iteration for i in range(args.num_generation): z_test.d = np.random.randn(batch_size, latent) x_test.forward(clear_buffer=True) monitor_image_tile_test.add(i, x_test)
def test(classifier, generator, data_loader, dataset="MNIST"): """Evaluate classifier on source or target domains.""" # set eval state for Dropout and BN layers generator.eval() classifier.eval() # init loss and accuracy loss = 0 acc = 0 # set loss function criterion = nn.CrossEntropyLoss() # evaluate network for (images, labels) in data_loader: images = Variable(images, volatile=True) labels = Variable(labels.squeeze_()) if use_cuda: images = images.cuda() labels = labels.cuda() preds = classifier(generator(images)) loss += criterion(preds, labels).data[0] pred_cls = preds.data.max(1)[1] acc += pred_cls.eq(labels.data).cpu().sum() loss /= len(data_loader) acc /= len(data_loader.dataset) print("Avg Loss = {:.5f}, Avg Accuracy = {:2.5%}".format(loss, acc))
def reconstruct_time_series_monthly(images_fn, weights_fn, out_dir, time_range, application="mchrzc", ds_factor=16, n_ensemble=4, relax_lam=0.0): (gen,_) = models.generator(num_timesteps=1) init_model = models.initial_state_model() (gen_init, noise_shapes) = models.generator_initialized(gen, init_model, num_timesteps=1) gen_init.load_weights(weights_fn) t0 = time_range[0] months = [] while t0 < time_range[1]: (y,m) = (t0.year, t0.month) m += 1 if m > 12: m = 1 y += 1 t1 = datetime(y,m,1) months.append((t0,t1)) t0 = t1 (h, last_t) = (None, None) for month in months: out_fn = out_dir + "/timeseries-{}-{}{:02d}.nc".format( application,month[0].year,month[0].month) (h, last_t) = reconstruct_time_series_partial(images_fn, gen, noise_shapes, init_model, out_fn, month, h=h, last_t=last_t, application=application, ds_factor=ds_factor, n_ensemble=n_ensemble, relax_lam=relax_lam )
def sample_dcgan(side_len): """ Runs inference on the generator. :param int side_len: Side length for generator output (must match `crop_len`). """ # only need to restore the generator's variables G = generator(sample, None, side_len) sess = tf.Session() sess.run(tf.initialize_all_variables()) # apply the trained generator weights saver = tf.train.Saver() chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH) saver.restore(sess, chkpt_fname) # run a forward pass vec = np.random.normal(size=(batch_size, Z_SIZE)) result = sess.run(G, {sample: vec}) # save the result _deprocess_and_save(result, -1)
def main(): """ Inference function to generate SR images. """ nn.load_parameters(args.model) # Inference data loader inference_data = inference_data_loader(args.input_dir_lr) input_shape = [ 1, ] + list(inference_data.inputs[0].shape) output_shape = [1, input_shape[1] * 4, input_shape[2] * 4, 3] oh = input_shape[1] - input_shape[1] // 8 * 8 ow = input_shape[2] - input_shape[2] // 8 * 8 # Build the computation graph inputs_raw = nn.Variable(input_shape) pre_inputs = nn.Variable(input_shape) pre_gen = nn.Variable(output_shape) pre_warp = nn.Variable(output_shape) transposed_pre_warp = space_to_depth(pre_warp) inputs_all = F.concatenate(inputs_raw, transposed_pre_warp) with nn.parameter_scope("generator"): gen_output = generator(inputs_all, 3, args.num_resblock) outputs = (gen_output + 1) / 2 inputs_frames = F.concatenate(pre_inputs, inputs_raw) with nn.parameter_scope("fnet"): flow_lr = flow_estimator(inputs_frames) flow_lr = F.pad(flow_lr, (0, 0, 0, oh, 0, ow, 0, 0), "reflect") flow_hr = upscale_four(flow_lr * 4.0) pre_gen_warp = warp_by_flow(pre_gen, flow_hr) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) max_iter = len(inference_data.inputs) print('Frame evaluation starts!!') pre_inputs.d, pre_gen.d, pre_warp.d = 0, 0, 0 for i in range(max_iter): inputs_raw.d = np.array([inference_data.inputs[i]]).astype(np.float32) if i != 0: pre_gen_warp.forward() pre_warp.data.copy_from(pre_gen_warp.data) outputs.forward() output_frame = outputs.d if i >= 5: name, _ = os.path.splitext( os.path.basename(str(inference_data.paths_lr[i]))) filename = args.output_name + '_' + name print('saving image %s' % filename) out_path = os.path.join(args.output_dir, "%s.%s" % (filename, args.output_ext)) save_img(out_path, output_frame[0]) else: # First 5 is a hard-coded symmetric frame padding, ignored but time added! print("Warming up %d" % (5 - i)) pre_inputs.data.copy_from(inputs_raw.data) pre_gen.data.copy_from(outputs.data)
def evaluate(args): # Context ctx = get_extension_context(args.context, device_id=args.device_id, type_config=args.type_config) nn.set_default_context(ctx) # Args latent = args.latent maps = args.maps batch_size = args.batch_size image_size = args.image_size n_classes = args.n_classes not_sn = args.not_sn # Model (Inception model) from nnp file nnp = NnpLoader(args.nnp_inception_model_load_path) x, y = get_input_and_output(nnp, args.batch_size, name=args.variable_name) if args.evaluation_metric == "IS": is_model = None compute_metric = compute_inception_score if args.evaluation_metric == "FID": di = data_iterator_imagenet(args.valid_dir, args.dirname_to_label_path, batch_size=args.batch_size, ih=args.image_size, iw=args.image_size, shuffle=True, train=False, noise=False) compute_metric = functools.partial(compute_frechet_inception_distance, di=di) # Monitor monitor = Monitor(args.monitor_path) monitor_metric = MonitorSeries("{}".format(args.evaluation_metric), monitor, interval=1) # Compute the evaluation metric for all models def cmp_func(path): return int(path.split("/")[-1].strip("params_").rstrip(".h5")) model_load_path = sorted(glob.glob("{}/*.h5".format(args.model_load_path)), key=cmp_func) \ if os.path.isdir(args.model_load_path) else \ [args.model_load_path] for path in model_load_path: # Model (SAGAN) nn.load_parameters(path) z = nn.Variable([batch_size, latent]) y_fake = nn.Variable([batch_size]) x_fake = generator(z, y_fake, maps=maps, n_classes=n_classes, test=True, sn=not_sn)\ .apply(persistent=True) # Compute the evaluation metric score = compute_metric(z, y_fake, x_fake, x, y, args) itr = cmp_func(path) monitor_metric.add(itr, score)
def __generate(self, input, scale): pad_size = int(self.config["ker_size"] * self.config["num_layer"] * 0.5) paddings = tf.constant([[0, 0], [pad_size, pad_size], [pad_size, pad_size], [0, 0]]) x = tf.pad(input, paddings, "CONSTANT") return models.generator(x, input, self.config, name="scale_" + str(scale))
def init_generator(self, encoder, decoder, name=None, lr=2e-4, beta_1=.5): ''' Creates a generator. ''' generator = m.generator(encoder, decoder, img_size=self.img_size, name=name) optimizer = tf.keras.optimizers.Adam(lr, beta_1=beta_1) gradients = None return generator, optimizer, gradients
def train(epochs, batch_size, ckpt_path, imgs_path, lr, out_path): tf.keras.backend.clear_session() train_data = get_data(imgs_path, batch_size) gen = generator() disc = discriminator() print(gen.summary()) print(disc.summary()) gen_opt = Adam(learning_rate=lr, beta_1=0.5) disc_opt = Adam(learning_rate=lr, beta_1=0.5) ckpt = Checkpoint(disc=disc, gen=gen, disc_opt=disc_opt, gen_opt=gen_opt) manager = CheckpointManager(ckpt, ckpt_path, max_to_keep=3) if manager.latest_checkpoint: print("Restored from {}".format(manager.latest_checkpoint)) ckpt.restore(manager.latest_checkpoint) else: print("Initializing from scratch.") seed = tf.random.normal([16, ENCODING_SIZE], seed=1234) generate_and_save_images(gen, 0, seed, out_path) for ep in range(epochs): gen_loss = [] disc_loss_real = [] disc_loss_fake = [] print('Epoch: %d of %d' % (ep + 1, epochs)) start = time.time() for images in train_data: g_loss, d_loss_r, d_loss_f = train_step(images, gen, disc, gen_opt, disc_opt, batch_size) gen_loss.append(g_loss) disc_loss_real.append(d_loss_r) disc_loss_fake.append(d_loss_f) gen_loss = np.mean(np.asarray(gen_loss)) disc_loss_real = np.mean(np.asarray(disc_loss_real)) disc_loss_fake = np.mean(np.asarray(disc_loss_fake)) if (np.isnan(gen_loss) or np.isnan(disc_loss_real) or np.isnan(disc_loss_fake)): print("Something broke.") break manager.save() generate_and_save_images(gen, ep + 1, seed, out_path) print("Time for epoch:", time.time() - start) print("Gen loss=", gen_loss) print("Disc loss real=", disc_loss_real) print("Disc loss fake=", disc_loss_fake)
def predict(img_path): # example pathgan.predict('/root/sharedfolder/Images/P1.jpg') loss_weights = [1., 0.05] #0.05 adversarial_iteration = 2 batch_size = 40 #100 mini_batch_size = 800 #4000 G = 1 epochs = 200 n_hidden_gen = 1000 lr = 1e-4 content_loss = 'mse' lstm_activation = 'tanh' dropout = 0.1 dataset_path = '/root/sharedfolder/predict_scanpaths/finetune_saltinet_isun/input/salient360_EVAL_noTime.hdf5' model360 = 'false' weights_generator = '../weights/generator_single_weights.h5' opt = RMSprop(lr=lr, rho=0.9, epsilon=1e-08, decay=0.0) # Load image img, img_size = utils.load_image(img_path, 'small_images') # Get the model params = { 'n_hidden_gen': n_hidden_gen, 'lstm_activation': lstm_activation, 'dropout': dropout, 'optimizer': opt, 'loss': content_loss, 'weights': weights_generator, 'G': G } _, generator_parallel = models.generator(**params) # Predict with a model n_sp_per_image = 1 #provisional output = np.zeros((n_sp_per_image, 63, 4)) for i in range(n_sp_per_image): print("Calculating observer %d" % i) noise = np.random.normal(0, 3, img.shape) noisy_img = img + noise prediction = generator_parallel.predict(noisy_img) output[i] = prediction # Prepare the predictions for matlab and save it on individual files output = prepare_image(output[:, :, :]) return output
def morph(args): # Communicator and Context extension_module = "cudnn" ctx = get_extension_context(extension_module, type_config=args.type_config) nn.set_default_context(ctx) # Args latent = args.latent maps = args.maps batch_size = args.batch_size image_size = args.image_size n_classes = args.n_classes not_sn = args.not_sn threshold = args.truncation_threshold # Model nn.load_parameters(args.model_load_path) z = nn.Variable([batch_size, latent]) alpha = nn.Variable.from_numpy_array(np.zeros([1, 1])) beta = (nn.Variable.from_numpy_array(np.ones([1, 1])) - alpha) y_fake_a = nn.Variable([batch_size]) y_fake_b = nn.Variable([batch_size]) x_fake = generator(z, [y_fake_a, y_fake_b], maps=maps, n_classes=n_classes, test=True, sn=not_sn, coefs=[alpha, beta]).apply(persistent=True) b, c, h, w = x_fake.shape # Monitor monitor = Monitor(args.monitor_path) name = "Morphed Image {} {}".format(args.from_class_id, args.to_class_id) monitor_image = MonitorImage(name, monitor, interval=1, num_images=1, normalize_method=normalize_method) # Morph images = [] z_data = resample(batch_size, latent, threshold) z.d = z_data for i in range(args.n_morphs): alpha.d = 1.0 * i / args.n_morphs y_fake_a.d = generate_one_class(args.from_class_id, batch_size) y_fake_b.d = generate_one_class(args.to_class_id, batch_size) x_fake.forward(clear_buffer=True) monitor_image.add(i, x_fake.d)
def get_generator_output(conf, rnn_length, r_inputs, flow_hr, scope_name): """ Return the generated HR frames """ # list for all outputs gen_outputs = [] # for the first frame, concat with zeros input0 = F.concatenate( r_inputs[:, 0, :, :, :], F.constant(0, (conf.train.batch_size, conf.train.crop_size, conf.train.crop_size, 3 * 4 * 4))) with nn.parameter_scope(scope_name + "generator"): gen_pre_output = generator(input0, 3, conf.train.num_resblock) gen_outputs.append(gen_pre_output) # append generated HR frame-0 for frame_i in range(rnn_length - 1): cur_flow = flow_hr[:, frame_i, :, :, :] # warp the previously generated frame gen_pre_output_warp = warp_by_flow(gen_pre_output, cur_flow) gen_pre_output_warp = F.identity(deprocess(gen_pre_output_warp)) # apply space-to-depth transform gen_pre_output_warp = space_to_depth(gen_pre_output_warp) # pack it as the recurrent input inputs = F.concatenate(r_inputs[:, frame_i + 1, :, :, :], gen_pre_output_warp) # super-resolution part with nn.parameter_scope(scope_name + "generator"): gen_output = generator(inputs, 3, conf.train.num_resblock) gen_outputs.append(gen_output) gen_pre_output = gen_output # gen_outputs, a list, len = frame, shape = (batch, FLAGS.crop_size*4, FLAGS.crop_size*4, 3) gen_outputs = F.stack(*gen_outputs, axis=1) # gen_outputs, nn.Variable with shape = (batch, frame, FLAGS.crop_size*4, FLAGS.crop_size*4, 3) return gen_outputs
def train(args): train_ds, test_ds = get_data(args.img_path, args.batch) gen = generator() disc = discriminator() gen_opt = Adam(args.learning_rate, beta_1=0.5, beta_2=0.999) disc_opt = Adam(args.learning_rate, beta_1=0.5, beta_2=0.999) print(gen.summary()) print(disc.summary()) ckpt = Checkpoint(disc=disc, gen=gen, disc_opt=disc_opt, gen_opt=gen_opt) manager = CheckpointManager(ckpt, args.ckpt_path, max_to_keep=3) if args.continue_training: latest = manager.latest_checkpoint if latest: print("Restored from {}".format(latest)) ckpt.restore(latest) off = int(re.split('-', latest)[-1]) else: off = 0 print("Initializing from scratch.") for ep in range(args.epochs): for x, y in test_ds.take(1): generate_and_save_imgs(gen, ep + off, x, y, args.out_path) gen_loss = [] disc_loss = [] print('Epoch: %d of %d' % (ep + 1 + off, args.epochs + off)) start = time.time() for x, y in train_ds: g_loss, d_loss = train_step(x, y, gen, disc, gen_opt, disc_opt, args.batch) gen_loss.append(g_loss) disc_loss.append(d_loss) gen_loss = np.mean(np.asarray(gen_loss)) disc_loss = np.mean(np.asarray(disc_loss)) manager.save() print("Time for epoch:", time.time() - start) print("Gen loss=", gen_loss) print("Disc loss=", disc_loss) # Storing three different outputs after final epoch for x, y in test_ds.take(3): generate_and_save_imgs(gen, args.epochs + off, x, y, args.out_path) off += 1
def train_step(images): noise = tf.random.normal([batch_size, noise_dim]) with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: generated_images = generator(noise, training=True) real_output = discriminator(images, training=True) fake_output = discriminator(generated_images, training=True) gen_loss = generator_loss(fake_output) disc_loss = discriminator_loss(real_output, fake_output) gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables) gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables) generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables)) discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
def generate(): BATCH_SIZE = 2 GENERATOR_PARAMS = 100 opt = Adam(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=1e-08, decay=0.0) discriminator = models.discriminator() discriminator.compile(loss='binary_crossentropy', optimizer=opt) discriminator.load_weights('discriminator') generator = models.generator() generator.compile(loss='binary_crossentropy', optimizer=opt) generator.load_weights('generator') noise = np.zeros((BATCH_SIZE * 20, GENERATOR_PARAMS)) for i in range(BATCH_SIZE * 20): noise[i, :] = np.random.uniform(-1, 1, GENERATOR_PARAMS) generated_images = np.zeros((20 * BATCH_SIZE, 128, 128, 1)) for i in range(BATCH_SIZE * 20): generated_images[i, ...] = generator.predict(np.reshape( noise[i, :], (1, GENERATOR_PARAMS)), verbose=1) # d_pret = discriminator.predict(generated_images, verbose=1) # # index = np.arange(0, BATCH_SIZE * 20) # index.resize((BATCH_SIZE * 20, 1)) # pre_with_index = list(np.append(d_pret, index, axis=1)) # pre_with_index.sort(key=lambda x: x[0], reverse=True) # nice_images = np.zeros((BATCH_SIZE, 1) + (generated_images.shape[2:]), dtype=np.float32) for i in range(len(generated_images)): plt.imshow(generated_images[i, :, :, 0]) plt.axis('off') plt.savefig('E:/deep-neurons/generated-' + str(i) + '.png') plt.clf()
gif_path = args.gif save_path = args.save_path duration = args.duration dataset = args.dataset direction = args.direction crop_size = args.crop_size assert direction == 'a2b' or direction == 'b2a', 'Direction should be a2b or b2a!' """ run """ frames = [] a_reals_ipt_ori = gif_frames(Image.open(gif_path)) size_ori = a_reals_ipt_ori.shape[0:3] with tf.Session() as sess: a_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, crop_size, 3]) a2b = models.generator(a_real, direction) # retore saver = tf.train.Saver() ckpt_path = utils.load_checkpoint('./checkpoints/' + dataset, sess, saver) if ckpt_path is None: raise Exception('No checkpoint!') else: print('Copy variables from % s' % ckpt_path) a_real_ipt = np.zeros( (1, len(a_real_ipt_ori), crop_size, crop_size, crop_size, 3)) a_real_ipt[0, ...] = im.imresize(a_real_ipt_ori, [crop_size, crop_size, crop_size]) a2b_opt = sess.run(a2b, feed_dict={a_real: a_real_ipt}) a2b_opt_ori = im.imresize(a2b_opt[0, ..., 0].squeeze(), size_ori)
def train_dcgan(n_epochs, batch_size, lr_rate, crop_len, scale_len, restore, paths): """ Train DCGAN. :param int n_epochs: Total number of epochs over the input data to train for. :param int batch_size: Batch size to use for training. :param float lr_rate: Generator learning rate. :param int crop_len: Image side length to use. :param int scale_len: Amount to scale the minimum side length to (for augmentation). :param bool restore: Specifies whether or not the latest checkpoint should be used. :param list paths: List of paths to images to use for training. """ assert scale_len >= crop_len, "invalid resize or crop length" # create placeholders sample = tf.placeholder(tf.float32, shape=[batch_size, Z_SIZE], name="sample") real = tf.placeholder(tf.float32, shape=[batch_size, 64, 64, 3], name="real") is_train = tf.placeholder(tf.bool, name="is_train") # instantiate the models G = generator(sample, is_train, crop_len) D_fake = discriminator(G, is_train) tf.get_variable_scope().reuse_variables() D_real = discriminator(real, is_train) # create losses loss_G = _sigmoid_loss(D_fake, tf.ones_like(D_fake)) loss_D = _sigmoid_loss(D_fake, tf.zeros_like(D_fake)) + \ _sigmoid_loss(D_real, tf.ones_like(D_real)) # acquire tensors for generator and discriminator # trick from carpedm20's implementation on github g_vars = [var for var in tf.trainable_variables() if "g_" in var.name] d_vars = [var for var in tf.trainable_variables() if "d_" in var.name] # create optimization objectives global_step = tf.Variable(0, name="global_step", trainable=False) opt_G = tf.train.AdamOptimizer(lr_rate, beta1=0.5).minimize(loss_G, var_list=g_vars) opt_D = tf.train.AdamOptimizer(2e-4, beta1=0.5).minimize(loss_D, var_list=d_vars) # create a saver and restore variables, if necessary saver = tf.train.Saver() model_path = os.path.join(OUTPUT_PATH, CHECKPOINT_NAME) # do some initialization sess = tf.Session() sess.run(tf.initialize_all_variables()) if restore: chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH) saver.restore(sess, chkpt_fname) else: _clean_directory(OUTPUT_PATH) _clean_directory(OUTPUT_PATH) # reference vector (to examine epoch-to-epoch changes) vec_ref = np.random.normal(size=(batch_size, Z_SIZE)) # begin training n_iterations = len(paths) // batch_size for epoch in range(sess.run(global_step), n_epochs): print("------- EPOCH {0} -------".format(epoch)) random.shuffle(paths) # train the discriminator for one epoch for i in range(n_iterations): offset = (i * batch_size) % len(paths) batch_paths = paths[offset:(offset + batch_size)] imgs = _read_and_preprocess(batch_paths, scale_len, crop_len) vec = np.random.normal(size=(batch_size, Z_SIZE)) # minimize generator loss if i % TRAIN_RATIO == TRAIN_RATIO - 1: sess.run(opt_G, feed_dict={sample: vec, is_train: True}) # minimize discriminator loss sess.run(opt_D, feed_dict={ real: imgs, sample: vec, is_train: True }) # log the error if i % DISPLAY_LOSSES == 0: err_G = sess.run(loss_G, feed_dict={ sample: vec, is_train: False }) err_D = sess.run(loss_D, feed_dict={ real: imgs, sample: vec, is_train: False }) print(" Iteration {0}".format(i)) print(" generator loss = {0}".format(err_G)) print(" discriminator loss = {0}".format(err_D)) # save the model and sample results at the end of each epoch sess.run(tf.assign(global_step, epoch + 1)) saver.save(sess, model_path, global_step=global_step) batch_res = sess.run(G, {sample: vec_ref, is_train: False}) _deprocess_and_save(batch_res, epoch)
def train_dcgan(n_epochs, batch_size, lr_rate, crop_len, scale_len, restore, paths): """ Train DCGAN. :param int n_epochs: Total number of epochs over the input data to train for. :param int batch_size: Batch size to use for training. :param float lr_rate: Generator learning rate. :param int crop_len: Image side length to use. :param int scale_len: Amount to scale the minimum side length to (for augmentation). :param bool restore: Specifies whether or not the latest checkpoint should be used. :param list paths: List of paths to images to use for training. """ assert scale_len >= crop_len, "invalid resize or crop length" # create placeholders sample = tf.placeholder(tf.float32, shape=[batch_size, Z_SIZE], name="sample") real = tf.placeholder(tf.float32, shape=[batch_size, 64, 64, 3], name="real") is_train = tf.placeholder(tf.bool, name="is_train") # instantiate the models G = generator(sample, is_train, crop_len) D_fake = discriminator(G, is_train) tf.get_variable_scope().reuse_variables() D_real = discriminator(real, is_train) # create losses loss_G = _sigmoid_loss(D_fake, tf.ones_like(D_fake)) loss_D = _sigmoid_loss(D_fake, tf.zeros_like(D_fake)) + \ _sigmoid_loss(D_real, tf.ones_like(D_real)) # acquire tensors for generator and discriminator # trick from carpedm20's implementation on github g_vars = [var for var in tf.trainable_variables() if "g_" in var.name] d_vars = [var for var in tf.trainable_variables() if "d_" in var.name] # create optimization objectives global_step = tf.Variable(0, name="global_step", trainable=False) opt_G = tf.train.AdamOptimizer(lr_rate, beta1=0.5).minimize(loss_G, var_list=g_vars) opt_D = tf.train.AdamOptimizer(2e-4, beta1=0.5).minimize(loss_D, var_list=d_vars) # create a saver and restore variables, if necessary saver = tf.train.Saver() model_path = os.path.join(OUTPUT_PATH, CHECKPOINT_NAME) # do some initialization sess = tf.Session() sess.run(tf.initialize_all_variables()) if restore: chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH) saver.restore(sess, chkpt_fname) else: _clean_directory(OUTPUT_PATH) _clean_directory(OUTPUT_PATH) # reference vector (to examine epoch-to-epoch changes) vec_ref = np.random.normal(size=(batch_size, Z_SIZE)) # begin training n_iterations = len(paths) // batch_size for epoch in range(sess.run(global_step), n_epochs): print("------- EPOCH {0} -------".format(epoch)) random.shuffle(paths) # train the discriminator for one epoch for i in range(n_iterations): offset = (i * batch_size) % len(paths) batch_paths = paths[offset:(offset + batch_size)] imgs = _read_and_preprocess(batch_paths, scale_len, crop_len) vec = np.random.normal(size=(batch_size, Z_SIZE)) # minimize generator loss if i % TRAIN_RATIO == TRAIN_RATIO - 1: sess.run(opt_G, feed_dict={sample: vec, is_train: True}) # minimize discriminator loss sess.run(opt_D, feed_dict={real: imgs, sample: vec, is_train: True}) # log the error if i % DISPLAY_LOSSES == 0: err_G = sess.run(loss_G, feed_dict={sample: vec, is_train: False}) err_D = sess.run(loss_D, feed_dict={real: imgs, sample: vec, is_train: False}) print(" Iteration {0}".format(i)) print(" generator loss = {0}".format(err_G)) print(" discriminator loss = {0}".format(err_D)) # save the model and sample results at the end of each epoch sess.run(tf.assign(global_step, epoch + 1)) saver.save(sess, model_path, global_step=global_step) batch_res = sess.run(G, {sample: vec_ref, is_train: False}) _deprocess_and_save(batch_res, epoch)
def main(DATASET, data_size, num_train_epochs, num_disc_steps, num_gen_steps, batch_size, save_checkpoint_every, generate_samples_every, flip_alpha, restore = False): loader = load_Data_new.DataLoader(DATASET) # Create Placeholders for Data X = tf.placeholder(tf.float32, shape = [None, 64, 64, 3]) Z = tf.placeholder(tf.float32, shape = [None, 100]) labels_d_fake = tf.placeholder(tf.float32) labels_d_real = tf.placeholder(tf.float32) with tf.variable_scope("gen"): GZ = generator(Z) with tf.variable_scope("disc") as scope: DGZ_raw, DGZ = discriminator(GZ) scope.reuse_variables() DX_raw, DX = discriminator(X) with tf.variable_scope("loss_calculation"): # using Sigmoid Cross Entropy as loss function # discriminator tries to discriminate between X and GZ: # if input to discriminator is X then output prob should be 0 # if input to discriminator is GZ then output prob should be 1 # loss_d_fake = log(1-DGZ_raw) loss_d_fake = tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_d_fake, logits=DGZ_raw) # loss_d_real = log(DX_raw) loss_d_real = tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_d_real, logits=DX_raw) loss_g = tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(DGZ_raw), logits=DGZ_raw) # loss_disc = log(1-DGZ_raw) + log(DX_raw) loss_disc = tf.reduce_mean(loss_d_fake + loss_d_real) # gen tries to fool D # that is D should output 0 on seeing GZ # therefore we minimize DGZ-raw(to make it 0) # loss_gen = log(DGZ_raw) loss_gen = tf.reduce_mean(loss_g) GZ_summary = tf.summary.image('GZ', GZ, max_outputs = 10) DGZ_summary = tf.summary.scalar('DGZ', tf.reduce_mean(DGZ)) DX_summary = tf.summary.scalar('DX', tf.reduce_mean(DX)) loss_disc_summary = tf.summary.scalar('loss_disc', loss_disc) loss_gen_summary = tf.summary.scalar('loss_gen', loss_gen) disc_merged = tf.summary.merge([DGZ_summary, DX_summary, loss_disc_summary, GZ_summary]) gen_merged = tf.summary.merge([DGZ_summary, loss_gen_summary]) # Defined Optimizers for both Discriminator and Generator optimizer_disc = tf.train.AdamOptimizer(learning_rate=2e-4, beta1 = 0.5) train_op_disc = optimizer_disc.minimize(loss_disc, var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "disc")) optimizer_gen = tf.train.AdamOptimizer(learning_rate=2e-4, beta1 = 0.5) train_op_gen = optimizer_gen.minimize(loss_gen, var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "gen")) TAG = 'plotting-graphs_alpha_'+str(flip_alpha)+'_'+DATASET saver = tf.train.Saver(max_to_keep=2) if(DATASET != 'CELEBA'): Xsample_val_set = loader.create_sample_set(100) sess = tf.InteractiveSession() # saver = tf.train.import_meta_graph('saved_analysis_snapshots/snapshots_cifar_complete_from_60_epoch_G_twice/it_2500.ckpt.meta') # saver.restore(sess, 'saved_analysis_snapshots/snapshots_cifar_complete_from_60_epoch_G_twice/it_2500.ckpt') train_writer = tf.summary.FileWriter('logs/' + TAG, sess.graph) if(restore): snapshot_name = tf.train.latest_checkpoint('logs/' + TAG + '/') saver = tf.train.import_meta_graph(snapshot_name + '.meta') print snapshot_name start_iter = int(snapshot_name.split('-')[-1].split('.')[0]) + 1 print start_iter saver.restore(sess, snapshot_name) else: start_iter = 0 sess.run(tf.global_variables_initializer()) num_train_iter = num_train_epochs * (data_size / (batch_size * num_disc_steps)) Z_sample_all = loader.load_batch_Z(100) sum_g_loss, num_g_loss = 0, 0 sum_d_loss, num_d_loss = 0, 0 for iteration in range(start_iter, num_train_iter): for disc_step in range(num_disc_steps): X_feed = loader.load_batch_X(batch_size) Z_feed = loader.load_batch_Z(batch_size) labels_d_real_feed = np.random.choice([0, 1], size=(batch_size,), p=[flip_alpha, 1-flip_alpha]) labels_d_fake_feed = np.ones_like(labels_d_real_feed) - labels_d_real_feed _, cost_disc, DGZ_ret, DX_ret, disc_merged_ret = sess.run(fetches = [train_op_disc, loss_disc, DGZ, DX, disc_merged], feed_dict = {X:X_feed, Z:Z_feed, labels_d_fake: labels_d_fake_feed, labels_d_real:labels_d_real_feed}) sum_d_loss += cost_disc num_d_loss += 1 train_writer.add_summary(disc_merged_ret, iteration) # print ("#%d D #%d\tLossD:%f\tAvgD:%f\tDGZ:%f\tDX:%f" % ((iteration * batch_size * num_disc_steps) / data_size , iteration, cost_disc, sum_d_loss * 1.0 / num_d_loss, np.mean(DGZ_ret), np.mean(DX_ret))) for gen_step in range(num_gen_steps): Z_feed = loader.load_batch_Z(batch_size) _, cost_gen, DGZ_ret, gen_merged_ret = sess.run(fetches = [train_op_gen, loss_gen, DGZ, gen_merged], feed_dict = {Z:Z_feed}) sum_g_loss += cost_gen num_g_loss += 1 train_writer.add_summary(gen_merged_ret, iteration) # print ("#%d G #%d\tLossG:%f\tAvgG:%f\tDGZ:%f" % ((iteration * batch_size * num_disc_steps) / data_size, iteration, cost_gen, sum_g_loss * 1.0 / num_g_loss, np.mean(DGZ_ret))) print ("!%d #%d\tAvgG:%f\tAvgD:%f" % ((iteration * batch_size * num_disc_steps) / data_size, iteration, sum_g_loss * 1.0 / num_g_loss, sum_d_loss * 1.0 / num_d_loss)) if iteration % save_checkpoint_every == 0 and iteration != 0: # save_name = "snapshots/it_%d.ckpt" % iteration if not os.path.isdir('logs/' + TAG): os.makedirs('logs/' + TAG) save_name = 'logs/' + TAG + '/model.ckpt' saver.save(sess, save_name, iteration) print "Snapshot saved to %s" % save_name if iteration % generate_samples_every == 0: if not os.path.isdir('analysis/' + TAG): os.makedirs('analysis/' + TAG) X_sample_all = loader.load_batch_X(100, update_iterator = False) im_samples, im_score = sess.run(fetches=[GZ, DGZ], feed_dict={Z:Z_sample_all}) im_samples = d3_scale(im_samples, out_range=(0,255)) # print "evaluation : %d" % evaluate(Xsample_val_set, im_samples) im_samples = save_sample_images(im_samples, 100) out = sess.run(im_samples) if DATASET != 'CELEBA': out = cv2.cvtColor(out, cv2.COLOR_RGB2BGR) cv2.imwrite("analysis/"+TAG+"/generator_sample_%d.png" % iteration, out) cv2.imwrite("analysis/"+TAG+"/generator_latest.png", out) X_score = sess.run(fetches=[DX], feed_dict={X:X_sample_all}) X_samples = save_sample_images(d3_scale(X_sample_all, out_range=(0,255)), 100) out = sess.run(X_samples) if DATASET != 'CELEBA': out = cv2.cvtColor(out, cv2.COLOR_RGB2BGR) cv2.imwrite("analysis/"+TAG+"/orig_%d.png" % iteration, out) cv2.imwrite("analysis/"+TAG+"/orig_latest.png", out) print "Sample scores: \tDGZ:%f\tDX:%f" % (np.mean(im_score), np.mean(X_score)) train_writer.close() if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument("--dataset", help="dataset name", type=str, choices=['CIFAR10', 'MNIST', 'CELEBA', 'SVHN'], default='MNIST') parser.add_argument("--num_train_epochs", type=int, help="number of training epochs", default=10) parser.add_argument("--num_disc_steps", type=int, help="number of discriminator training steps", default=1) parser.add_argument("--num_gen_steps", type=int, help="number of generator training steps", default=2) parser.add_argument("--batch_size", type=int, help="batch size", default=64) parser.add_argument("--save_checkpoint_every", type=int, help="number of iterations after which a checkpoint is saved", default=250) parser.add_argument("--generate_samples_every", type=int, help="number of iterations after which a sample is generated", default=100) parser.add_argument("--flip_alpha", type=float, help="probability of flipping the label", default=0.3) args = parser.parse_args() main(args.dataset, args.data_size, args.num_train_epochs, args.num_disc_steps, args.num_gen_steps, args.batch_size, args.save_checkpoint_every, args.generate_samples_every, args.flip_alpha)
# define dataset with tf.name_scope('dataset'): test_video_clips_tensor = tf.placeholder(shape=[1, height, width, 3 * (num_his + 1)], dtype=tf.float32) test_inputs = test_video_clips_tensor[..., 0:num_his*3] test_gt = test_video_clips_tensor[..., -3:] print('test inputs = {}'.format(test_inputs)) print('test prediction gt = {}'.format(test_gt)) # define testing generator function and # in testing, only generator networks, there is no discriminator networks and flownet. with tf.variable_scope('generator', reuse=None): print('testing = {}'.format(tf.get_variable_scope().name)) test_outputs = generator(test_inputs, layers=4, output_channel=3) test_psnr_error,shape = psnr_error(gen_frames=test_outputs, gt_frames=test_gt) print(shape,[shape]) config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: # dataset data_loader = DataLoader(test_folder, height, width) # initialize weights sess.run(tf.global_variables_initializer()) print('Init global successfully!') # tf saver
def __init__(self, num_latent, num_out, batch_size, num_disc, num_channels=3, num_hidden=1024, D_weights=None, G_weights=None, name='GMAN', mixing='arithmetic', weight_type='normal', objective='original', boosting_variant=None, self_challenged=False): self.num_latent = num_latent self.side = num_out self.num_channels = num_channels self.num_hidden = num_hidden self.batch_size = batch_size self.N = num_disc self.base_prob = 0.4 self.delta_p = (0.6 - self.base_prob) / self.N self.h_adv = num_hidden self.name = name self.weight_type = weight_type self.channel_size = self.batch_size * self.N self.self_challenged = self_challenged # boosting variables self.aux_vars = [] self.aux_vars_new = [] with tf.variable_scope(self.name): # Define latent distribution self.z = tf.random_uniform(shape=[self.channel_size, 1, 1, self.num_latent], minval=-1., maxval=1., name='z') # Generate fake images self.fake = generator(self) # print(f'self.fake -> {self.fake}') if boosting_variant is None: fake_split = tf.split(axis=0, num_or_size_splits=self.N, value=self.fake, name='fake_split') else: fake_split = [self.fake] * self.N # Discriminate fake images self.Df_logits = [discriminator(self, fake_split[ind], ind, (self.base_prob + self.delta_p * (ind + 1)), reuse=False) for ind in range(self.N)] # Retrieve real images self.real = tf.placeholder(tf.float32, shape=[self.channel_size, self.side, self.side, self.num_channels], name='real') if boosting_variant is None: real_split = tf.split(axis=0, num_or_size_splits=self.N, value=self.real, name='real_split') else: real_split = [self.real] * self.N # Discriminate real images self.Dr_logits = [discriminator(self, real_split[ind], ind, (self.base_prob + self.delta_p * (ind + 1)), reuse=True) for ind in range(self.N)] # Retrieve trainable weights t_vars = tf.trainable_variables() self.G_vars = [var for var in t_vars if (self.name + '/generator') in var.name] self.D_vars = [[var for var in t_vars if ('%s/discriminator_%d' % (self.name, num)) in var.name] for num in range(self.N)] # Assign values to weights (if given) self.assign_weights = [] if D_weights is not None: for i in range(self.N): for j in range(len(self.D_vars[i])): self.assign_weights.append(tf.assign(self.D_vars[i][j], D_weights[i][j])) if G_weights is not None: for j in range(len(self.G_vars)): self.assign_weights.append(tf.assign(self.G_vars[j], G_weights[j])) # Define Discriminator losses with tf.variable_scope('D_Loss'): if boosting_variant is None: self.get_D_losses(obj=objective) else: self.get_D_boosted_losses(boosting_variant, obj=objective) # Define Generator losses with tf.variable_scope('G_Loss'): if boosting_variant is None: self.get_G_loss(mixing, obj=objective) else: self.get_G_boosted_loss(boosting_variant, mixing, obj=objective) # Add Summaries self.add_summaries() # Construct Discriminator updates self.lrd = tf.placeholder(dtype=tf.float32) self.D_optimizer = tf.train.AdamOptimizer(learning_rate=self.lrd, beta1=0.5) self.D_optim = [self.D_optimizer.minimize(D_loss, var_list=self.D_vars[ind]) for ind, D_loss in enumerate(self.D_losses)] # Construct Generator updates self.lrg = tf.placeholder(dtype=tf.float32) self.G_optimizer = tf.train.AdamOptimizer(learning_rate=self.lrg, beta1=0.5) self.G_optim = self.G_optimizer.minimize(self.G_loss, var_list=self.G_vars) self.G_grads = self.G_optimizer.compute_gradients(self.G_loss, var_list=self.G_vars) # Join all updates self.all_opt = [opt for opt in self.D_optim] self.all_opt.append(self.G_optim)
from models import generator, discriminator, GenNucleiDataset import torch G = generator() D = discriminator() G = torch.load('./app/weights/G_model.pth', map_location={'cuda:0': 'cpu'}) D = torch.load('./app/weights/D_model.pth', map_location={'cuda:0': 'cpu'}) print(G)
GAN = False encoder = False training_steps = 350 generator_model = None adversarial_model = None discriminator_model = None batch_size = 128 if GAN: for i in range(training_steps): x = X[i * batch_size:(i + 1) * batch_size, :, :] size = x.shape[0] if not discriminator_model: discriminator_model = discriminator() if not generator_model: generator_model = generator() if not adversarial_model: adversarial_model = adversarial( generator_model, discriminator_model) noise = np.random.uniform(0, 1.0, size=[batch_size, 100]) fakes = generator_model.predict(noise) x = np.concatenate((x, fakes)) x = np.expand_dims(x, axis=3) y = np.zeros([2 * batch_size, 1]) y[:batch_size, :] = 1 d_loss = discriminator_model.train_on_batch(x, y) y = np.ones([batch_size, 1]) noise = np.random.uniform(0,
lambda_D_gp = 10 lambda_cyc = 10 lambda_mask = 0.1 lambda_mask_smooth = 1e-5 # ============= placeholder ============= real_img = tf.placeholder(tf.float32, [None, 128, 128, 3], name='real_img') real_au = tf.placeholder(tf.float32, [None, 17], name='real_au') desired_au = tf.placeholder(tf.float32, [None, 17], name='desired_au') lr = tf.placeholder(tf.float32, name='lr') # ============= G & D ============= # G(Ic1, c2) * M fake_img, fake_mask = generator(real_img, desired_au, reuse=False) fake_img_masked = fake_mask * real_img + (1 - fake_mask) * fake_img # G(G(Ic1, c2)*M, c1) * M cyc_img, cyc_mask = generator(fake_img_masked, real_au, reuse=True) cyc_img_masked = cyc_mask * fake_img_masked + (1 - cyc_mask) * cyc_img # D(real_I) pred_real_img, pred_real_au = discriminator(real_img, reuse=False) # D(fake_I) pred_fake_img_masked, pred_fake_au = discriminator(fake_img_masked, reuse=True) # ============= losses ============= # G losses loss_g_fake_img_masked = -tf.reduce_mean(pred_fake_img_masked) * lambda_D_img loss_g_fake_au = l2_loss(desired_au, pred_fake_au) * lambda_D_au
epoch = args.epoch batch_size = args.batch_size lr = args.lr gpu_id = args.gpu_id """ graphs """ with tf.device('/gpu:%d' % gpu_id): ''' graph ''' # nodes a_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3]) b_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3]) a2b_sample = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3]) b2a_sample = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3]) a2b = models.generator(a_real, 'a2b') b2a = models.generator(b_real, 'b2a') b2a2b = models.generator(b2a, 'a2b', reuse=True) a2b2a = models.generator(a2b, 'b2a', reuse=True) a_dis = models.discriminator(a_real, 'a') b2a_dis = models.discriminator(b2a, 'a', reuse=True) b2a_sample_dis = models.discriminator(b2a_sample, 'a', reuse=True) b_dis = models.discriminator(b_real, 'b') a2b_dis = models.discriminator(a2b, 'b', reuse=True) a2b_sample_dis = models.discriminator(a2b_sample, 'b', reuse=True) # losses g_loss_a2b = tf.identity(ops.l2_loss(a2b_dis, tf.ones_like(a2b_dis)), name='g_loss_a2b') g_loss_b2a = tf.identity(ops.l2_loss(b2a_dis, tf.ones_like(b2a_dis)),
def generate(args): # Communicator and Context extension_module = "cudnn" ctx = get_extension_context(extension_module, type_config=args.type_config) nn.set_default_context(ctx) # Args latent = args.latent maps = args.maps batch_size = args.batch_size image_size = args.image_size n_classes = args.n_classes not_sn = args.not_sn threshold = args.truncation_threshold # Model nn.load_parameters(args.model_load_path) z = nn.Variable([batch_size, latent]) y_fake = nn.Variable([batch_size]) x_fake = generator(z, y_fake, maps=maps, n_classes=n_classes, test=True, sn=not_sn)\ .apply(persistent=True) # Generate All if args.generate_all: # Monitor monitor = Monitor(args.monitor_path) name = "Generated Image Tile All" monitor_image = MonitorImageTile(name, monitor, interval=1, num_images=args.batch_size, normalize_method=normalize_method) # Generate images for all classes for class_id in range(args.n_classes): # Generate z_data = resample(batch_size, latent, threshold) y_data = generate_one_class(class_id, batch_size) z.d = z_data y_fake.d = y_data x_fake.forward(clear_buffer=True) monitor_image.add(class_id, x_fake.d) return # Generate Indivisually monitor = Monitor(args.monitor_path) name = "Generated Image Tile {}".format( args.class_id) if args.class_id != -1 else "Generated Image Tile" monitor_image_tile = MonitorImageTile(name, monitor, interval=1, num_images=args.batch_size, normalize_method=normalize_method) name = "Generated Image {}".format( args.class_id) if args.class_id != -1 else "Generated Image" monitor_image = MonitorImage(name, monitor, interval=1, num_images=args.batch_size, normalize_method=normalize_method) z_data = resample(batch_size, latent, threshold) y_data = generate_random_class(n_classes, batch_size) if args.class_id == -1 else \ generate_one_class(args.class_id, batch_size) z.d = z_data y_fake.d = y_data x_fake.forward(clear_buffer=True) monitor_image.add(0, x_fake.d) monitor_image_tile.add(0, x_fake.d)
def train(): graph = tf.Graph() with graph.as_default(): z = tf.placeholder(tf.float32, shape=[64, 100], name='z') img_batch = read_records.read_and_decode( 'tf_records/cartoon.tfrecords', batch_size=batch_size) #generator # fake=models.generator(z, stddev=0.02, alpha=alpha, name='generator', reuse=False) # # #discriminator # dis_real=models.discriminator(img_batch , alpha=alpha, batch_size=batch_size) # dis_fake=models.discriminator(fake, alpha=alpha, reuse=True) #generator fake = models.generator(z, reuse=False) #, is_training=True #discriminator dis_real = models.discriminator(img_batch, reuse=False) #is_training=True dis_fake = models.discriminator(fake, reuse=True) #, is_training=True # #losses # gene_loss = tf.reduce_mean(tf.squared_difference(dis_fake, 0.9)) # dis_loss = (tf.reduce_mean(tf.squared_difference(dis_real, 0.9)) # + tf.reduce_mean(tf.square(dis_fake))) / 2 gene_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dis_fake) * 0.9, logits=dis_fake)) d_f_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.zeros_like(dis_fake), logits=dis_fake)) d_r_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(dis_real) * 0.9, logits=dis_real)) dis_loss = d_f_loss + d_r_loss gen_loss_sum = tf.summary.scalar("gen_loss", gene_loss) dis_loss_sum = tf.summary.scalar("dis_loss", dis_loss) merge_sum_gen = tf.summary.merge([gen_loss_sum]) merge_sum_dis = tf.summary.merge([dis_loss_sum]) #variables gene_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='generator') dis_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='discriminator') gene_opt = tf.train.AdamOptimizer( learning_rate=0.0002, beta1=0.3).minimize(gene_loss, var_list=gene_var) dis_opt = tf.train.AdamOptimizer(learning_rate=0.0002, beta1=0.3).minimize(dis_loss, var_list=dis_var) test_sample = models.generator(z, reuse=True) #, is_training=False test_out = tf.add(test_sample, 0, 'test_out') init = tf.global_variables_initializer() print('t') with tf.Session(graph=graph) as sess: sess.run(init) # 初始化全局变量 z_ipt_sample = np.random.normal(size=[batch_size, 100]) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) writer = tf.summary.FileWriter('./tensorboard', sess.graph) saver = tf.train.Saver() try: for i in range(run_nums): z_ipt = np.random.normal(size=[batch_size, 100]) #train D #_, dis_loss1 = sess.run([dis_opt,dis_loss],feed_dict={real:img_batch,z:z_ipt}) sum_dis, _, dis_loss1 = sess.run( [merge_sum_dis, dis_opt, dis_loss], feed_dict={z: z_ipt}) #train G sum_gen, _, gen_loss1 = sess.run( [merge_sum_gen, gene_opt, gene_loss], feed_dict={z: z_ipt}) if i % 400 == 0: print(i) test_sample_opt = sess.run(test_sample, feed_dict={z: z_ipt_sample}) #print(type(test_sample_opt),test_sample_opt.shape) utils.mkdir('out_cartoon') utils.imwrite(utils.immerge(test_sample_opt, 10, 10), 'out_cartoon/' + str(i) + '.jpg') # writer.add_summary(sum_dis, i) #writer.add_summary(sum_gen, i) print("train end!!!") except tf.errors.OutOfRangeError: print('out of range') finally: coord.request_stop() coord.request_stop() coord.join(threads) writer.close() saver.save(sess, "./checkpoints/DCGAN")
""" param """ parser = argparse.ArgumentParser(description='') parser.add_argument('--dataset', dest='dataset', default='horse2zebra', help='which dataset to use') parser.add_argument('--crop_size', dest='crop_size', type=int, default=256, help='then crop to this size') args = parser.parse_args() dataset = args.dataset crop_size = args.crop_size """ run """ with tf.Session() as sess: a_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3]) b_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3]) a2b = models.generator(a_real, 'a2b') b2a = models.generator(b_real, 'b2a') b2a2b = models.generator(b2a, 'a2b', reuse=True) a2b2a = models.generator(a2b, 'b2a', reuse=True) # retore saver = tf.train.Saver() ckpt_path = utils.load_checkpoint('./checkpoints/' + dataset, sess, saver) if ckpt_path is None: 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')
def run_model(mode, learning_rate=2e-4, beta1=0.5, l1_lambda=100, max_epochs=200, summary_freq=200, display_freq=50, save_freq=400, checkpoint_dir="summary/conGAN.ckpt"): if mode == "train": xs_train, ys_train = get_input("train") xs_val, ys_val = get_input("val") print("load train data successfully") print("input x shape is {}".format(xs_train.shape)) print("input y shape is {}".format(ys_train.shape)) else: xs_test, ys_test = get_input("test") print("load test data successfully") print("input x shape is {}".format(xs_test.shape)) print("input y shape is {}".format(ys_test.shape)) # build model # ----------- with tf.name_scope("input"): x = tf.placeholder(tf.float32, [None, 256, 256, 3], name="x-input") y_ = tf.placeholder(tf.float32, [None, 256, 256, 3], name="y-input") G_sample = models.generator(x) logits_fake = models.con_discriminator(x, G_sample) logits_real = models.con_discriminator(x, y_) # get loss D_loss, G_loss_gan = loss.gan_loss(logits_fake=logits_fake, logits_real=logits_real) l1_loss = loss.l1_loss(y_, G_sample) with tf.variable_scope("G_loss"): G_loss = G_loss_gan + l1_lambda * l1_loss tf.summary.scalar("D_loss", D_loss) tf.summary.scalar("G_loss", G_loss) merged = tf.summary.merge_all() # get weights list D_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "discriminator") G_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "generator") # get solver D_solver, G_solver = get_solver(learning_rate=learning_rate, beta1=beta1) # get training steps D_train_step = D_solver.minimize(D_loss, var_list=D_vars) G_train_step = G_solver.minimize(G_loss, var_list=G_vars) # ----------- # get session config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.InteractiveSession(config=config) # get saver saver = tf.train.Saver() # training phase if mode == "train": train_writer = tf.summary.FileWriter("summary/", sess.graph) # init sess.run(tf.global_variables_initializer()) # iterations for step in range(max_epochs * NUM_TRAIN_IMAGES): if step % NUM_TRAIN_IMAGES == 0: print("Epoch: {}".format(step / NUM_TRAIN_IMAGES)) mask = np.random.choice(NUM_TRAIN_IMAGES, 1) _, D_loss_curr = sess.run([D_train_step, D_loss], feed_dict={ x: xs_train[mask], y_: ys_train[mask] }) _, G_loss_curr = sess.run([G_train_step, G_loss], feed_dict={ x: xs_train[mask], y_: ys_train[mask] }) _, G_loss_curr = sess.run([G_train_step, G_loss], feed_dict={ x: xs_train[mask], y_: ys_train[mask] }) if step % display_freq == 0: print("step {}: D_loss: {}, G_loss: {}".format( step, D_loss_curr, G_loss_curr)) # save summary and checkpoint if step % summary_freq == 0: mask = np.random.choice(NUM_TRAIN_IMAGES, 30) summary = sess.run(merged, feed_dict={ x: xs_train[mask], y_: ys_train[mask] }) train_writer.add_summary(summary) saver.save(sess, checkpoint_dir) # save 5 sample images if step % save_freq == 0: samples_train = sess.run(G_sample, feed_dict={ x: xs_train[0:5], y_: ys_train[0:5] }) save_sample_img(samples_train, step=step, mode="train") samples_val = sess.run(G_sample, feed_dict={ x: xs_val[0:5], y_: ys_val[0:5] }) save_sample_img(samples_val, step=step, mode="val") # testing phase if mode == "test": saver.restore(sess, checkpoint_dir) for i in range(20): samples_test = sess.run(G_sample, feed_dict={ x: xs_test[5 * i:5 * (i + 1)], y_: ys_test[5 * i:5 * (i + 1)] }) save_sample_img(samples_test, step=i, mode="test") # close sess sess.close() return 0
def train(args): # Context ctx = get_extension_context(args.context, device_id=args.device_id, type_config=args.type_config) nn.set_default_context(ctx) # Args latent = args.latent maps = args.maps batch_size = args.batch_size image_size = args.image_size lambda_ = args.lambda_ # Model # generator loss z = nn.Variable([batch_size, latent]) x_fake = generator(z, maps=maps, up=args.up).apply(persistent=True) p_fake = discriminator(x_fake, maps=maps) loss_gen = gan_loss(p_fake).apply(persistent=True) # discriminator loss p_fake = discriminator(x_fake, maps=maps) x_real = nn.Variable([batch_size, 3, image_size, image_size]) p_real = discriminator(x_real, maps=maps) loss_dis = gan_loss(p_fake, p_real).apply(persistent=True) # gradient penalty eps = F.rand(shape=[batch_size, 1, 1, 1]) x_rmix = eps * x_real + (1.0 - eps) * x_fake p_rmix = discriminator(x_rmix, maps=maps) x_rmix.need_grad = True # Enabling gradient computation for double backward grads = nn.grad([p_rmix], [x_rmix]) l2norms = [F.sum(g**2.0, [1, 2, 3])**0.5 for g in grads] gp = sum([F.mean((l - 1.0)**2.0) for l in l2norms]) loss_dis += lambda_ * gp # generator with fixed value for test z_test = nn.Variable.from_numpy_array(np.random.randn(batch_size, latent)) x_test = generator(z_test, maps=maps, test=True, up=args.up).apply(persistent=True) # Solver solver_gen = S.Adam(args.lrg, args.beta1, args.beta2) solver_dis = S.Adam(args.lrd, args.beta1, args.beta2) with nn.parameter_scope("generator"): params_gen = nn.get_parameters() solver_gen.set_parameters(params_gen) with nn.parameter_scope("discriminator"): params_dis = nn.get_parameters() solver_dis.set_parameters(params_dis) # Monitor monitor = Monitor(args.monitor_path) monitor_loss_gen = MonitorSeries("Generator Loss", monitor, interval=10) monitor_loss_cri = MonitorSeries("Negative Critic Loss", monitor, interval=10) monitor_time = MonitorTimeElapsed("Training Time", monitor, interval=10) monitor_image_tile_train = MonitorImageTile("Image Tile Train", monitor, num_images=batch_size, interval=1, normalize_method=denormalize) monitor_image_tile_test = MonitorImageTile("Image Tile Test", monitor, num_images=batch_size, interval=1, normalize_method=denormalize) # Data Iterator di = data_iterator_cifar10(batch_size, True) # Train loop for i in range(args.max_iter): # Train discriminator x_fake.need_grad = False # no need backward to generator for _ in range(args.n_critic): solver_dis.zero_grad() x_real.d = di.next()[0] / 127.5 - 1.0 z.d = np.random.randn(batch_size, latent) loss_dis.forward(clear_no_need_grad=True) loss_dis.backward(clear_buffer=True) solver_dis.update() # Train generator x_fake.need_grad = True # need backward to generator solver_gen.zero_grad() z.d = np.random.randn(batch_size, latent) loss_gen.forward(clear_no_need_grad=True) loss_gen.backward(clear_buffer=True) solver_gen.update() # Monitor monitor_loss_gen.add(i, loss_gen.d) monitor_loss_cri.add(i, -loss_dis.d) monitor_time.add(i) # Save if i % args.save_interval == 0: monitor_image_tile_train.add(i, x_fake) monitor_image_tile_test.add(i, x_test) nn.save_parameters( os.path.join(args.monitor_path, "params_{}.h5".format(i))) # Last x_test.forward(clear_buffer=True) nn.save_parameters( os.path.join(args.monitor_path, "params_{}.h5".format(i))) monitor_image_tile_train.add(i, x_fake) monitor_image_tile_test.add(i, x_test)
import os import numpy as np import tensorflow as tf import models num_samples = 100 batch_size = 64 output_dir = 'output' checkpoint_dir = os.path.join(output_dir, 'checkpoints', 'checkpoint_4.ckpt') z = tf.placeholder(tf.float32, shape=(None, 1, 1, 100)) isTrain = tf.placeholder(dtype=tf.bool) fake_x = models.generator(z, isTrain) samples = np.random.rand(num_samples, 64, 64, 1) saver = tf.train.Saver() print('start') with tf.Session() as sess: saver.restore(sess, checkpoint_dir) for i in range(int(num_samples / batch_size)): noise = np.random.normal(0, 1, (batch_size, 1, 1, 100)) samples = sess.run(fake_x, feed_dict = {z: noise, isTrain: False}) with open(os.path.join(output_dir, 'samples', 'samples!.txt'), 'a') as f: