def train(g_model, d_model, gan_model, dataset, latent_dim, cat, epochs=100, batch=64): batch_per_epoch = int(dataset.shape[0] / batch) steps = batch_per_epoch * epochs half_batch = int(batch / 2) for i in range(steps): X_real, y_real = generate_real_samples(dataset, half_batch) d_loss1 = d_model.train_on_batch(X_real, y_real) X_fake, y_fake = generate_fake_samples(g_model, latent_dim, cat, half_batch) d_loss2 = d_model.train_on_batch(X_fake, y_fake) z_input, cat_codes = generate_latent_points(latent_dim, cat, batch) y_gan = np.ones((batch, 1)) _, g_1, g_2 = gan_model.train_on_batch(z_input, [y_gan, cat_codes]) print("[INFO] {:d}, d[{:.3f}, {:.3f}], g[{:.3f}], q[{:.3f}]".format( i + 1, d_loss1, d_loss2, g_1, g_2)) if (i + 1) % (batch_per_epoch * 10) == 0: summarize_performance(i, g_model, gan_model, latent_dim, cat)
def train(generator, discriminator, gan, dataset, latent_dim, epochs=100, batch=128): batch_per_epoch = int(dataset.shape[0] / batch) half_batch = int(batch / 2) for i in range(epochs): for j in range(batch_per_epoch): X_real, y_real = generate_real_samples(dataset, half_batch) d_loss1, _ = discriminator.train_on_batch(X_real, y_real) X_fake, y_fake = generate_fake_samples(generator, latent_dim, half_batch) d_loss2, _ = discriminator.train_on_batch(X_fake, y_fake) Xgan = generate_latent_points(latent_dim, batch) ygan = np.ones((batch, 1)) g_loss = gan.train_on_batch(Xgan, ygan) print("{:d}, {:d}/{:d}, d1={:.3f}, d2={:.3f}, g={:.3f}".format( i + 1, j + 1, batch_per_epoch, d_loss1, d_loss2, g_loss)) generator.save("models/generator.h5")
def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=10, n_batch=64): # calculate number of batches per epoch batch_per_epoch = int(dataset.shape[0] / n_batch) # no of training iterations n_steps = batch_per_epoch * n_epochs # half-batch half_batch = n_batch // 2 # empty lists to store loss d1_hist, d2_hist, g_hist = list(), list(), list() # training loop for i in range(n_steps): # generate real and fake samples X_real, y_real = generate_mnist_samples(dataset, half_batch) X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch) # update discriminator d_loss1 = d_model.train_on_batch(X_real, y_real) d_loss2 = d_model.train_on_batch(X_fake, y_fake) # update generator z_input = generate_latent_points(latent_dim, n_batch) y_real2 = np.ones((n_batch, 1)) g_loss = gan_model.train_on_batch(z_input, y_real2) # print(">%d, d1=%.3f, d2=%.3f, g=%.3f" % (i+1, d_loss1, d_loss2, g_loss)) # record d1_hist.append(d_loss1) d2_hist.append(d_loss2) g_hist.append(g_loss) # evaluate if (i+1) % (batch_per_epoch * 1) == 0: log_performance(i, g_model, latent_dim) # plot plot_history(d1_hist, d2_hist, g_hist)
def train(dataset, generator, discriminator, gan_model, latent_dim=100, n_epochs=20, n_batch=25): bat_per_epo = int(dataset.shape[0] / n_batch) half_batch = int(n_batch / 2) for i in range(n_epochs): # enumerate batches over the training set for j in range(bat_per_epo): start_time = time.time() # get randomly selected 'real' samples X_real, y_real = utils.generate_real_samples(dataset, half_batch) # update discriminator model weights d_loss1, _ = discriminator.train_on_batch(X_real, y_real) # generate 'fake' examples X_fake, y_fake = utils.generate_fake_samples(generator, latent_dim, half_batch) # update discriminator model weights d_loss2, _ = discriminator.train_on_batch(X_fake, y_fake) # prepare points in latent space as input for the generator X_gan = utils.generate_latent_points(latent_dim, n_batch) # create inverted labels for the fake samples y_gan = tf.ones((n_batch, 1)) # update the generator via the discriminator's error g_loss = gan_model.train_on_batch(X_gan, y_gan) # summarize loss on this batch time_taken = time.time() - start_time print('>%d, %d/%d, d1=%.3f, d2=%.3f g=%.3f Time Taken:%.2f seconds' % (i + 1, j + 1, bat_per_epo, d_loss1, d_loss2, g_loss, time_taken)) # evaluate the model performance, sometimes if (i + 1) % 10 == 0: summarize_performance(i, generator, discriminator, dataset, latent_dim)
def train(g_model, d_model, gan_model, dataset, latent_dim, epochs=20, batch=64): batch_per_epoch = int(dataset.shape[0] / batch) steps = batch_per_epoch * epochs half_batch = int(batch / 2) d1_hist, d2_hist, g_hist = list(), list(), list() for i in range(steps): X_real, y_real = generate_real_samples(dataset, half_batch) X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch) # update discriminator model d_loss1 = d_model.train_on_batch(X_real, y_real) d_loss2 = d_model.train_on_batch(X_fake, y_fake) # update generator via discriminator's loss z_input = generate_latent_points(latent_dim, batch) y_real2 = np.ones((batch, 1)) g_loss = gan_model.train_on_batch(z_input, y_real2) print("{:d}, d1={:.3f}, d2={:.3f}, g={:.3f}".format( i + 1, d_loss1, d_loss2, g_loss)) d1_hist.append(d_loss1) d2_hist.append(d_loss2) g_hist.append(g_loss) if (i + 1) % (batch_per_epoch * 1) == 0: summarize_performance(i, g_model, latent_dim) plot_history(d1_hist, d2_hist, g_hist)
def train_step(images): noise, categorical_input, continuous_input = generate_latent_points( BATCH_SIZE, noise_dim, categorical_dim, continuous_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) disc_loss, real_loss, fake_loss, categorical_loss, continuous_loss = discriminator_loss( real_output, fake_output, categorical_input, continuous_input) gen_loss = generator_loss(fake_output, categorical_loss, continuous_loss) discriminator_loss_metric(disc_loss) generator_loss_metric(gen_loss) discriminator_real_accuracy_metric(tf.ones_like(real_output[:, 0]), real_output[:, 0]) discriminator_fake_accuracy_metric(tf.zeros_like(fake_output[:, 0]), fake_output[:, 0]) categorical_loss_metric(categorical_loss) continuous_loss_metric(continuous_loss) print( f"Losses - Disc : [{disc_loss}], Gen : [{gen_loss}], \n categorical loss : {categorical_loss}, continuous loss : {continuous_loss}" ) 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 train_gan(sw, n_class, dataloader): d_model, d_optim, d_lrdecay = define_discriminator() g_model, g_optim, g_lrdecay = define_generator() # d_model, d_optim = define_discriminator() # g_model, g_optim = define_generator() criterion = nn.BCELoss() G_losses = [] D_losses = [] global best_fid best_fid = np.inf for epoch in range(EPOCHS): D_x, D_G_z1, D_G_z2 = [], [], [] errD, errG = torch.tensor(0), torch.tensor(0) mode_loss = 0 for _, data in enumerate(dataloader): ############################ # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z))) ########################### ## Train with all-real batch d_model.zero_grad() # Format batch real_images = data[0].to(DEVICE) mini_batch_size = real_images.size(0) label = torch.full((mini_batch_size, ), REAL_LABEL, dtype=torch.float, device=DEVICE) # Forward pass real batch through D output = d_model(real_images).view(-1) # Calculate loss on all-real batch errD_real = criterion(output, label) # Calculate gradients for D in backward pass errD_real.backward() D_x.append(output.mean().item()) ## Train with all-fake batch # Generate batch of latent vectors noise = generate_latent_points(LATENT_DIM, mini_batch_size, DEVICE) # Generate fake image batch with G fake = g_model(noise) label.fill_(FAKE_LABEL) # Classify all fake batch with D output = d_model(fake.detach()).view(-1) # Calculate D's loss on the all-fake batch errD_fake = criterion(output, label) # Calculate the gradients for this batch errD_fake.backward() D_G_z1.append(output.mean().item()) # Add the gradients from the all-real and all-fake batches errD = errD_real + errD_fake # Update D d_optim.step() ############################ # (2) Update G network: maximize log(D(G(z))) ########################### g_model.zero_grad() # Format batch mini_batch_size = mini_batch_size * 2 label = torch.full((mini_batch_size, ), REAL_LABEL, dtype=torch.float, device=DEVICE) # Generate batch of latent vectors noise = generate_latent_points(LATENT_DIM, mini_batch_size, DEVICE) # Generate fake image batch with G fake = g_model(noise) # Since we just updated D, perform another forward pass of all-fake batch through D output = d_model(fake).view(-1) # Calculate mode seeking loss z1, z2, *_ = torch.split(noise, noise.size(0) // 2) f1, f2, *_ = torch.split(fake, fake.size(0) // 2) mode_loss = torch.mean(torch.abs(f2 - f1)) / torch.mean( torch.abs(z2 - z1)) mode_loss = 1 / (mode_loss + 1e-5) # Calculate G's loss based on this output errG = criterion(output, label) + (5 * mode_loss) loss_G = errG + mode_loss # Calculate gradients for G loss_G.backward() D_G_z2.append(output.mean().item()) # Update G g_optim.step() # Learning rate decay d_lrdecay.step() g_lrdecay.step() # Calculate the mean D_x = np.mean(D_x) D_G_z1 = np.mean(D_G_z1) D_G_z2 = np.mean(D_G_z2) # Output training stats LOGGER.write( '[%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f' % (epoch + 1, EPOCHS, errD.item(), errG.item(), D_x, D_G_z1, D_G_z2)) # Save Losses for plotting later G_losses.append(errG.item()) D_losses.append(errD.item()) # Check how the generator is doing by saving G's output on fixed_noise if epoch % 50 == 0: summarize_performance( epoch, sw, n_class, errD.item(), errG.item(), mode_loss, D_x, D_G_z1, g_lrdecay.get_last_lr()[-1], d_lrdecay.get_last_lr()[-1], # LR, LR, generate_test(g_model)) # generate fake samples fake_images = g_model(FIXED_NOISE_2) # saving space in the gpu for loading inception v3 g_model = g_model.to(torch.device('cpu')) d_model = d_model.to(torch.device('cpu')) #if epoch % 50 == 0: calculate_fid(fake_images, sw, epoch, n_class) calculate_target_acc(fake_images, sw, epoch, n_class) # put models back on GPU g_model = g_model.to(DEVICE) d_model = d_model.to(DEVICE) #if fid < best_fid: # best_fid = fid # # torch.save(g_model, f'models/gan/g_exp{EXPERIMENT_ID}_class{n_class}.pth') # torch.save(d_model, f'models/gan/d_exp{EXPERIMENT_ID}_class{n_class}.pth') torch.save(g_model, f'models/gan/g_exp{EXPERIMENT_ID}_class{n_class}.pth') torch.save(d_model, f'models/gan/d_exp{EXPERIMENT_ID}_class{n_class}.pth')
DEVICE = torch.device('cuda' if torch.cuda.is_available else 'cpu') # Parameters DATAROOT = 'data/vgg16/dataset_ii_sl/' WORKERS = 4 BATCH_SIZE = 16 IMAGE_SIZE = 32 LATENT_DIM = 100 LR = 0.0005 EPOCHS = 1500 D_LR_DECAY = 0.999 G_LR_DECAY = 0.999 TARGET_FID = read_stats_file('logs/cifar10_fid.npz') DATASET_FID = read_stats_file('logs/dataset_i_sl_fid.npz') FIXED_NOISE = generate_latent_points(LATENT_DIM, 20, DEVICE) FIXED_NOISE_2 = generate_latent_points(LATENT_DIM, 500, DEVICE) REAL_LABEL = 1 FAKE_LABEL = 0 LOGGER.write(f'#### Experiment {EXPERIMENT_ID} ####') LOGGER.write(f'Date: {datetime.now().strftime("%Y%m%d_%H-%M")}') LOGGER.write('\nHiperparametros') LOGGER.write(f'> Epochs: {EPOCHS}') LOGGER.write(f'> Learning Rate: {LR}') LOGGER.write(f'> Image Size: {IMAGE_SIZE}') LOGGER.write(f'> Image Size: {IMAGE_SIZE}') LOGGER.write(f'> Batch Size: {BATCH_SIZE}') LOGGER.write(f'> Latent Dimension: {LATENT_DIM}') LOGGER.write(f'> Device: {DEVICE}')
ap.add_argument("-s", "--samples", type=int, help="Number of samples to generate") ap.add_argument("-d", "--digit", type=int, help="Category control code to generate specific digit.") args = vars(ap.parse_args()) print(args) model = load_model(args["model"]) model.summary() cat = 10 # Use same latent dim as during training latent_dim = 62 # Number of samples to plot samples = args["samples"] if args["digit"] is None: z_input, _ = generate_latent_points(latent_dim, cat, samples) else: z_input, _ = generate_latent_points_with_digit(latent_dim, cat, samples, args["digit"]) X = model.predict(z_input) # scale from [-1,1] to [0,1] X = (X + 1) / 2.0 create_plot(X, samples)
from utils import generate_latent_points from utils import show_plot from keras.models import load_model model = load_model("models/generator.h5") latent_points = generate_latent_points(100, 100) X = model.predict(latent_points) show_plot(X, 10)
lr = tf.train.exponential_decay(config.INIT_LR, model.global_step, 1000, config.DECAY_RATE, staircase=True) with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='discriminator')): train_D = tf.train.AdamOptimizer(0.0002, beta1=0.5).minimize(model.loss_D, var_list=model.vars_D) with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='generator')): train_G = tf.train.AdamOptimizer(0.0002, beta1=0.5).minimize(model.loss_G, global_step=model.global_step, var_list=model.vars_G) sess_config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)) images, labels = read_images(config.PATH_DATA, "folder") num_iters = len(images) // config.BATCH_SIZE cnt = 0 length = 6 sample_noise = utils.generate_latent_points(config.LATENT_DIM, length*length) with tf.Session(config=sess_config) as sess: saver = tf.train.Saver(tf.global_variables(), max_to_keep=1000) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess.run(init) train_writer = tf.summary.FileWriter(config.PATH_TENSORBOARD, sess.graph) # Load a previous checkpoint if desired #model_checkpoint_name = config.PATH_CHECKPOINT + "/latest_model_" + config.PATH_DATA + ".ckpt" model_checkpoint_name = config.PATH_CHECKPOINT + "/model.ckpt" if config.IS_CONTINUE: print('Loaded latest model checkpoint') saver.restore(sess, model_checkpoint_name)
def train_gan(gan_model, latent_dim, n_epochs=20, n_batch=25): for i in range(n_epochs): x_gan = utils.generate_latent_points(latent_dim, n_batch) y_gan = tf.ones((n_batch, 1)) gan_model.train_on_batch(x_gan, y_gan)
sess.run(init) train_writer = tf.summary.FileWriter(config.PATH_TENSORBOARD, sess.graph) # Load a previous checkpoint if desired model_checkpoint_name = config.PATH_CHECKPOINT + "/latest_model_" + config.PATH_DATA + ".ckpt" if config.IS_CONTINUE: print('Loaded latest model checkpoint') saver.restore(sess, model_checkpoint_name) images, labels = read_images("data", "folder") #num_iters = int(np.floor(len(D.train) / config.BATCH_SIZE)) num_iters = int(np.floor(len(images) / config.BATCH_SIZE)) length = 7 valid_set = utils.generate_latent_points(100, length**2) valid_image = [] for i in range(length**2): valid_image.append(images[i]) for epoch in range(config.EPOCH): cnt = 0 st = time.time() epoch_st = time.time() #id_list = np.random.permutation(len(D.train)) for i in range(num_iters): image_batch = [] noise_batch = utils.generate_latent_points(100, config.BATCH_SIZE) #noise_batch = np.random.uniform(-1., 1., size=[config.BATCH_SIZE, 100])
LOGGER.write(f'#### Experiment {EXPERIMENT_ID} ####') LOGGER.write(f'Date: {datetime.now().strftime("%d/%m/%Y %H:%M")}') LOGGER.write('\nHiperparametros') LOGGER.write(f'> Classes: {CLASSES}') LOGGER.write(f'> Training Size: {TRAINING_SIZE}*{MULTIPLIER_TRAINING_SIZE}') LOGGER.write(f'> Device: {DEVICE}') for n in np.arange(CLASSES): LOGGER.write(f"\nLoading generator from class {n}") g_model = torch.load(f'models/gan/g_exp{EXPERIMENT_ID}_class{n}.pth') LOGGER.write(f"Generating images from class {n}") output_path = os.path.join(FAKESET, str(n)) LOGGER.write(f'> Output path: {output_path}') if not os.path.exists(output_path): os.mkdir(output_path) for i in tqdm(np.arange(MULTIPLIER_TRAINING_SIZE)): X = generate_latent_points(100, TRAINING_SIZE, DEVICE) generated = g_model(X) for id, image in enumerate(generated): new_id = (TRAINING_SIZE * i) + id save_image( (image + 1) / 2, # normalize into [0, 1] fp=os.path.join(output_path, f"{new_id}.png"))
os.makedirs(f"{args.outdir}/assets/{args.dataset}") #normalizing the images train_images = (train_images - 127.5) / 127.5 ##### DEFINE GLOBAL VARIABLES AND OBJECTS ###### BUFFER_SIZE = 600000 BATCH_SIZE = args.batch_size epochs = args.epochs noise_dim = args.noise_dim continuous_dim = 2 categorical_dim = 10 num_examples_to_generate = 100 continuous_weight = args.continuous_weight seed, _, _ = generate_latent_points( num_examples_to_generate, noise_dim, categorical_dim, continuous_dim ) # A constant sample of latent points so as to create images # Define Generator generator = make_generator_model(noise_dim) print("\nGenerator : ") print(generator.summary()) discriminator = make_discriminator_model() print("\nDiscriminator : ") print(discriminator.summary()) print("Dataset : ", args.dataset) ########################################### # Converting data to tf Dataset train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(