def main(): parser = argparse.ArgumentParser() parser.add_argument('image_dir', type=str) parser.add_argument('--batch_size', '-bs', type=int, default=64) parser.add_argument('--nb_epoch', '-e', type=int, default=1000) parser.add_argument('--noise_dim', '-nd', type=int, default=100) parser.add_argument('--height', '-ht', type=int, default=128) parser.add_argument('--width', '-wd', type=int, default=128) parser.add_argument('--save_steps', '-ss', type=int, default=1) parser.add_argument('--visualize_steps', '-vs', type=int, default=1) parser.add_argument('--logdir', '-ld', type=str, default="../logs") parser.add_argument('--noise_mode', '-nm', type=str, default="uniform") parser.add_argument('--upsampling', '-up', type=str, default="deconv") parser.add_argument('--metrics', '-m', type=str, default="JSD") parser.add_argument('--lr_d', type=float, default=1e-4) parser.add_argument('--lr_g', type=float, default=1e-4) parser.add_argument('--norm_d', type=str, default=None) parser.add_argument('--norm_g', type=str, default=None) parser.add_argument('--model', type=str, default='residual') args = parser.parse_args() # output config to csv args_to_csv(os.path.join(args.logdir, 'config.csv'), args) input_shape = (args.height, args.width, 3) image_sampler = ImageSampler(args.image_dir, target_size=(args.width, args.height)) noise_sampler = NoiseSampler(args.noise_mode) if args.model == 'residual': generator = ResidualGenerator(args.noise_dim, target_size=(args.width, args.height), upsampling=args.upsampling, normalization=args.norm_g) discriminator = ResidualDiscriminator(input_shape, normalization=args.norm_d) elif args.model == 'plane': generator = Generator(args.noise_dim, upsampling=args.upsampling, normalization=args.norm_g) discriminator = Discriminator(input_shape, normalization=args.norm_d) else: raise ValueError gan = GAN(generator, discriminator, metrics=args.metrics, lr_d=args.lr_d, lr_g=args.lr_g) gan.fit(image_sampler.flow_from_directory(args.batch_size), noise_sampler, nb_epoch=args.nb_epoch, logdir=args.logdir, save_steps=args.save_steps, visualize_steps=args.visualize_steps)
def main(batch_size, file_dir): # Prepare the dataset. We use both the training & test MNIST digits. x = get_data(file_dir) gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim) gan.compile( d_optimizer=keras.optimizers.Adam(learning_rate=0.0003), g_optimizer=keras.optimizers.Adam(learning_rate=0.0003), loss_fn=keras.losses.BinaryCrossentropy(from_logits=True) ) # To limit the execution time, we only train on 100 batches. You can train on # the entire dataset. You will need about 20 epochs to get nice results. print(generator.summary()) print(discriminator.summary()) history = gan.fit(x, batch_size=batch_size, epochs=20) g_loss, d_loss = history.history['g_loss'], history.history['d_loss'] plt.plot(g_loss) plt.plot(d_loss) plt.xticks(np.arange(0, 20, step=1)) # Set label locations. plt.xlabel('epochs') plt.ylabel('loss') plt.title('Protein Structure Generation With DCGAN') # print(xticks(np.arange(0, 20, step=1))) # pred = np.stack(history.history['pred'], axis=0) # labels = np.stack(history.history['label'], axis=0) # accuracies = get_accuracies(pred, labels) # plt.plot(accuracies) plt.legend(['Generator loss', 'Discriminator loss'], loc='upper right') plt.show()
def test_gan( n_iters=1000, learning_rate=1e-4, n_mc_samples=1, scale_init=0.01, dim_z=2, ): datasets = load_data('../20150717-/mnist.pkl.gz') train_set, validate_set = datasets train_x, train_y = train_set validate_x, validate_y = validate_set xs = np.r_[train_x, validate_x] optimize_params = { 'learning_rate' : learning_rate, 'n_iters' : n_iters, 'minibatch_size': 100, 'calc_history' : 'all', 'calc_hist' : 'all', 'n_mod_history' : 100, 'n_mod_hist' : 100, 'patience' : 5000, 'patience_increase': 2, 'improvement_threshold': 0.995, } all_params = { 'hyper_params': { 'rng_seed' : 1234, 'dim_z' : dim_z, 'n_hidden' : [500, 500], 'n_mc_sampling' : n_mc_samples, 'scale_init' : scale_init, 'nonlinear_q' : 'relu', 'nonlinear_p' : 'relu', 'type_px' : 'bernoulli', 'optimizer' : 'adam', 'learning_process' : 'early_stopping' } } all_params.update({'optimize_params': optimize_params}) model = GAN(**all_params) model.fit(xs) return datasets, model
def train(dataset, epochs=30, num_images=1, latent_dim=256, learning_rate_g=0.00005, learning_rate_d=0.00005): discriminator = Discriminator().discriminator generator = Generator(latent_dim).generator gan = GAN(discriminator, generator, latent_dim) gan.compile( d_optimizer=keras.optimizers.Adam(learning_rate_d), g_optimizer=keras.optimizers.Adam(learning_rate_g), loss_function=keras.losses.BinaryCrossentropy(from_logits=True), ) gan.fit(dataset, epochs=epochs, callbacks=[GANMonitor(num_images, latent_dim)]) # gan.save("gan_model.h5") generator.save("generator_model.h5") discriminator.save("discriminator_model.h5")
images_path = glob(sys.argv[1] + "/" + sys.argv[2] + "_resized/*") d_model = build_discriminator() g_model = build_generator(latent_dim) d_model.summary() g_model.summary() gan = GAN(d_model, g_model, latent_dim) bce_loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=True, label_smoothing=0.1) d_optimizer = tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5) g_optimizer = tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5) gan.compile(d_optimizer, g_optimizer, bce_loss_fn) images_dataset = tf_dataset(images_path, batch_size) for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs)) gan.fit(images_dataset, epochs=1) g_model.save(sys.argv[1] + "/" + sys.argv[2] + "_saved_models/g_model.h5") d_model.save(sys.argv[1] + "/" + sys.argv[2] + "_saved_models/d_model.h5") noise = np.random.normal(size=(n_samples, latent_dim)) examples = g_model.predict(noise) save_plot(sys.argv[1] + "/" + sys.argv[2] + "_samples", examples, epoch, int(np.sqrt(n_samples)), IMG_CHANNEL)
from gan import Data_Manager, GAN # -------------------------------------------------------------------------------- if __name__ == '__main__': device_id = '3' device = torch.device('cpu') if torch.cuda.is_available(): device = torch.device('cuda:{}'.format(device_id)) batch_size = 64 img_size = 32 img_shape = [1, img_size, img_size] n_classes = 10 lr = 2e-4 gen_z_dim = 100 # Data Manager data_manager = Data_Manager(batch_size, img_size) # C-VAE model = GAN(data_manager=data_manager, device=device, img_shape=img_shape, epochs=1, lr=lr, gen_z_dim=gen_z_dim) model.fit()
# training config epochs = 500 batch_size = 16 # mini-batch size sample_size = 128 # number of samples to train d&g over one epoch learning_rate = {'pretrain': 1e-5, 'g': 1e-3, 'd': 1e-3} k_step = 1 # step of training discriminator over one epoch sample_rate = 50 # save result every sample_reate epochs dropout = 0 pretrain_epochs = 30 # 0 is not to do pretrain teacher_forcing_rate = 0.7 save_path = '/home/wu/projects/emo-gan/chkpt/rnngan' # load data train_data_path = "/home/wu/mounts/Emo-gesture/train_set.pkl" with open(train_data_path, 'rb') as f: data = pickle.load(f) dataset = MyDataset(data, max_len=max_len, num_joints=3, dim=dim) gan = GAN(latent_code_size, hidden_size, generator_output_size, discriminator_output_size, num_layers, bidirectional, relu_slope, dropout, max_len=300) gan.fit(dataset, epochs, batch_size, sample_size, learning_rate, k_step, sample_rate, pretrain_epochs, teacher_forcing_rate, save_path)
# coding: utf-8 from gan import GAN gan = GAN() gan.fit() gan.predict()
# delete old renders shutil.rmtree(config.render_dir) os.mkdir(config.render_dir) else: start_iter = param.start_iter model.restore_model(config.save_dir + 'model.ckpt') print 'Resuming training from iter %d' % start_iter # training for iter_no in range(start_iter, config.N_iter): for dis_iter in range(config.dis_n_iter): noise = np.random.normal(size=[config.batch_size, config.z_size], scale=0.2) data = all_pc_data.next_batch(config.batch_size)[0] model.fit(data, noise, iter_no, dis_iter) noise = np.random.normal(size=[config.batch_size, config.z_size], scale=0.2) data = all_pc_data.next_batch(config.batch_size)[0] pc_gen = model.fit(data, noise, iter_no, config.dis_n_iter) if iter_no % 1000 == 0: sio.savemat('%srender_%d.mat' % (config.render_dir, iter_no), {'X_hat': pc_gen}) # save image of point cloud if iter_no % config.renders_every_iter == 0: pc_gen = np.reshape(pc_gen[0, :], [2048, 3]) im_array = point_cloud_three_views(pc_gen) img = Image.fromarray(np.uint8(im_array * 255.0))
model = GAN(gex_size=train.shape[1], num_cells_generate=test.shape[0]) model.compile() model.build(input_shape=(model.hyperparams.batch_size, model.hyperparams.latent_dim)) # req. for subclassed models # process data for training train_tf = tf.data.Dataset.from_tensor_slices(train.X). \ cache(). \ shuffle(buffer_size=train.shape[0], seed=utils.RANDOM). \ batch(batch_size=model.hyperparams.batch_size * strategy.num_replicas_in_sync, num_parallel_calls=tf.data.AUTOTUNE). \ prefetch(buffer_size=tf.data.AUTOTUNE) train_tf_distributed = strategy.experimental_distribute_dataset(train_tf) test_tf = tf.data.Dataset.from_tensor_slices(test.X). \ cache(). \ shuffle(buffer_size=test.shape[0], seed=utils.RANDOM). \ prefetch(buffer_size=tf.data.AUTOTUNE) tb_callback = tf.keras.callbacks.TensorBoard(log_dir=utils.LOG_DIR + datetime.datetime.now().strftime("%Y%m%d-%H%M%S"), update_freq='epoch', write_graph=False, profile_batch=0) model.fit(x=train_tf_distributed, epochs=model.hyperparams.num_epochs, steps_per_epoch=int (train.shape[0] / model.hyperparams.batch_size), # steps = # batches per epoch callbacks=[tb_callback, TrainingMetrics(tb_callback), tf.keras.callbacks.ModelCheckpoint(period=100, filepath='training/model_{epoch}')]) # Save model model.save("training/model_final")
def main(num_faces, num_epochs, cuda, verbose=False): # set computation device (None/CPU if in development mode, CUDA otherwise) device = torch.device("cuda:0") if cuda else None # load faces masked_dir = "../data/masked" masked_suffix = "_Mask.jpg" unmasked_dir = "../data/unmasked" unmasked_suffix = ".png" masked_faces, unmasked_faces, idx_to_face_id = utils.load_faces( num_faces, masked_dir, masked_suffix, unmasked_dir, unmasked_suffix) if verbose: print("loaded {} faces...".format(num_faces)) # split data into training and testing sets split = int(0.8 * num_faces) train_input, train_output = ( masked_faces[:split], torch.Tensor((range(0, split))).long(), ) test_input, test_output = ( masked_faces[split:], torch.Tensor(range(split, num_faces)).long(), ) static_faces = unmasked_faces[:split] # instantiate GAN generator = Generator(learning_rate=2e-3) projector = Projector(load_path="../models/projector.pt") discriminator = Discriminator() gan = GAN(generator, projector, discriminator, device=device) if verbose: print("instantiated GAN...") # compute and store unmasked discriminator embeddings gan.compute_unmasked_embeddings(unmasked_faces) # train if verbose: print("training initiated...") gan.fit(train_input, static_faces, train_output, num_epochs=num_epochs, verbose=verbose) if verbose: print("\ntraining complete...") # save models save_dir = "../models" suffix = time.strftime("%Y%m%d_%H%M%S") gan.save(save_dir, suffix) if verbose: print("models saved under '{}/<model>_{}'...".format(save_dir, suffix)) # display sample masks and faces plt.figure() fig, axes = plt.subplots(2, 5) fig.set_figwidth(20) fig.set_figheight(7) for idx in range(5): # original image face_id = idx_to_face_id[idx] original_img = Image.open("../data/masked/{}_Mask.jpg".format(face_id)) axes[0, idx].imshow(original_img) axes[0, idx].get_xaxis().set_ticks([]) axes[0, idx].get_yaxis().set_ticks([]) # generated mask image mask = (gan.generator(torch.rand(1, 100).to(device)) if device else gan.generator()) masked_tensor = masked_faces[idx].unsqueeze(0) if device: masked_tensor = masked_tensor.to(device) masked_image = gan.project_mask(mask, masked_tensor, process=True)[0] masked_image = torch.transpose(masked_image, 0, 1) masked_image = torch.transpose(masked_image, 1, 2) masked_image = masked_image.cpu().detach().numpy() axes[1, idx].imshow(masked_image) axes[1, idx].get_xaxis().set_ticks([]) axes[1, idx].get_yaxis().set_ticks([]) plt.savefig("../figures/sample_masks.png") # evaluate accuracy train_accuracy = gan.evaluate(train_input, train_output) test_accuracy = gan.evaluate(test_input, test_output) masked_accuracy = gan.discriminator_evaluate(masked_faces, unmasked_faces) unmasked_accuracy = gan.discriminator_evaluate(unmasked_faces, unmasked_faces) print("\nfacial recognition accuracy for...") print(" random choice:\t\t{:.1f}%".format(100 / num_faces)) print(" training images:\t\t{:.1f}%".format(100 * train_accuracy)) print(" testing images:\t\t{:.1f}%".format(100 * test_accuracy)) print(" original masked images:\t{:.1f}%".format(100 * masked_accuracy)) print(" original unmasked images:\t{:.1f}%".format(100 * unmasked_accuracy)) # write results to file file_path = "../data/accuracy.txt" with open(file_path, "w") as file: file.write("facial recognition accuracy for...") file.write("\n random choice:\t\t{:.1f}%".format(100 / num_faces)) file.write("\n training images:\t\t{:.1f}%".format(100 * train_accuracy)) file.write("\n testing images:\t\t{:.1f}%".format(100 * test_accuracy)) file.write("\n original masked images:\t{:.1f}%".format( 100 * masked_accuracy)) file.write("\n original unmasked images:\t{:.1f}%".format( 100 * unmasked_accuracy)) if verbose: print("\nsaved results...") print("done:)")
create_results_dir() # load MNIST X_train = np.load('MNIST_data/mnist_train_x.npy') if args.model == 0: X_train = X_train.reshape(60000, 784) elif args.model == 1: X_train = X_train.reshape(60000, 28, 28, 1) X_train = tf.image.resize_images(X_train, [64, 64]).eval() # normalize -1 to 1 X_train = (X_train.astype(np.float32) - 127.5) / 127.5 #train model.fit(X_train) else: model.load(args.restoring_epoch) if args.model == 0: img_path = 'results/gan_genarated_image.png' img_size = (28, 28) elif args.model == 1: img_path = 'results/dcgan_genarated_image.png' img_size = (64, 64) save_results(model, args.restoring_epoch, img_path, dim=(7, 7), figsize=(7, 7), img_size=img_size)