def train(**kwargs): """ Train standard DCGAN model args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ # Roll out the parameters generator = kwargs["generator"] dset = kwargs["dset"] img_dim = kwargs["img_dim"] nb_epoch = kwargs["nb_epoch"] batch_size = kwargs["batch_size"] n_batch_per_epoch = kwargs["n_batch_per_epoch"] bn_mode = kwargs["bn_mode"] noise_dim = kwargs["noise_dim"] noise_scale = kwargs["noise_scale"] lr_D = kwargs["lr_D"] lr_G = kwargs["lr_G"] opt_D = kwargs["opt_D"] opt_G = kwargs["opt_G"] clamp_lower = kwargs["clamp_lower"] clamp_upper = kwargs["clamp_upper"] image_dim_ordering = kwargs["image_dim_ordering"] epoch_size = n_batch_per_epoch * batch_size print("\nExperiment parameters:") for key in kwargs.keys(): print key, kwargs[key] print("\n") # Setup environment (logging directory etc) general_utils.setup_logging("DCGAN") # Load and normalize data X_real_train = data_utils.load_image_dataset(dset, img_dim, image_dim_ordering) # Get the full real image dimension img_dim = X_real_train.shape[-3:] # Create optimizers opt_G = data_utils.get_optimizer(opt_G, lr_G) opt_D = data_utils.get_optimizer(opt_D, lr_D) ####################### # Load models ####################### noise_dim = (noise_dim, ) if generator == "upsampling": generator_model = models.generator_upsampling(noise_dim, img_dim, bn_mode, dset=dset) else: generator_model = models.generator_deconv(noise_dim, img_dim, bn_mode, batch_size, dset=dset) discriminator_model = models.discriminator(img_dim, bn_mode, dset=dset) DCGAN_model = models.DCGAN(generator_model, discriminator_model, noise_dim, img_dim) ############################ # Compile models ############################ generator_model.compile(loss='mse', optimizer=opt_G) discriminator_model.trainable = False DCGAN_model.compile(loss=models.wasserstein, optimizer=opt_G) discriminator_model.trainable = True discriminator_model.compile(loss=models.wasserstein, optimizer=opt_D) # Global iteration counter for generator updates gen_iterations = 0 ################# # Start training ################ for e in range(nb_epoch): # Initialize progbar and batch counter progbar = generic_utils.Progbar(epoch_size) batch_counter = 1 start = time.time() while batch_counter < n_batch_per_epoch: if gen_iterations < 25 or gen_iterations % 500 == 0: disc_iterations = 100 else: disc_iterations = kwargs["disc_iterations"] ################################### # 1) Train the critic / discriminator ################################### list_disc_loss_real = [] list_disc_loss_gen = [] for disc_it in range(disc_iterations): # Clip discriminator weights for l in discriminator_model.layers: weights = l.get_weights() weights = [ np.clip(w, clamp_lower, clamp_upper) for w in weights ] l.set_weights(weights) X_real_batch = next( data_utils.gen_batch(X_real_train, batch_size)) # Create a batch to feed the discriminator model X_disc_real, X_disc_gen = data_utils.get_disc_batch( X_real_batch, generator_model, batch_counter, batch_size, noise_dim, noise_scale=noise_scale) # Update the discriminator disc_loss_real = discriminator_model.train_on_batch( X_disc_real, -np.ones(X_disc_real.shape[0])) disc_loss_gen = discriminator_model.train_on_batch( X_disc_gen, np.ones(X_disc_gen.shape[0])) list_disc_loss_real.append(disc_loss_real) list_disc_loss_gen.append(disc_loss_gen) ####################### # 2) Train the generator ####################### X_gen = X_gen = data_utils.sample_noise(noise_scale, batch_size, noise_dim) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch(X_gen, -np.ones(X_gen.shape[0])) # Unfreeze the discriminator discriminator_model.trainable = True gen_iterations += 1 batch_counter += 1 progbar.add(batch_size, values=[("Loss_D", -np.mean(list_disc_loss_real) - np.mean(list_disc_loss_gen)), ("Loss_D_real", -np.mean(list_disc_loss_real)), ("Loss_D_gen", np.mean(list_disc_loss_gen)), ("Loss_G", -gen_loss)]) # Save images for visualization ~2 times per epoch if batch_counter % (n_batch_per_epoch / 2) == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, batch_size, noise_dim, image_dim_ordering) print('\nEpoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) # Save model weights (by default, every 5 epochs) data_utils.save_model_weights(generator_model, discriminator_model, DCGAN_model, e)
def train(**kwargs): """ Train standard DCGAN model args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ # Roll out the parameters generator = kwargs["generator"] dset = kwargs["dset"] img_dim = kwargs["img_dim"] nb_epoch = kwargs["nb_epoch"] batch_size = kwargs["batch_size"] n_batch_per_epoch = kwargs["n_batch_per_epoch"] bn_mode = kwargs["bn_mode"] noise_dim = kwargs["noise_dim"] noise_scale = kwargs["noise_scale"] lr_D = kwargs["lr_D"] lr_G = kwargs["lr_G"] opt_D = kwargs["opt_D"] opt_G = kwargs["opt_G"] clamp_lower = kwargs["clamp_lower"] clamp_upper = kwargs["clamp_upper"] image_dim_ordering = kwargs["image_dim_ordering"] epoch_size = n_batch_per_epoch * batch_size print("\nExperiment parameters:") for key in kwargs.keys(): print key, kwargs[key] print("\n") # Setup environment (logging directory etc) general_utils.setup_logging("DCGAN") # Load and normalize data X_real_train = data_utils.load_image_dataset(dset, img_dim, image_dim_ordering) # Get the full real image dimension img_dim = X_real_train.shape[-3:] # Create optimizers opt_G = data_utils.get_optimizer(opt_G, lr_G) opt_D = data_utils.get_optimizer(opt_D, lr_D) ####################### # Load models ####################### noise_dim = (noise_dim,) if generator == "upsampling": generator_model = models.generator_upsampling(noise_dim, img_dim, bn_mode, dset=dset) else: generator_model = models.generator_deconv(noise_dim, img_dim, bn_mode, batch_size, dset=dset) discriminator_model = models.discriminator(img_dim, bn_mode) DCGAN_model = models.DCGAN(generator_model, discriminator_model, noise_dim, img_dim) ############################ # Compile models ############################ generator_model.compile(loss='mse', optimizer=opt_G) discriminator_model.trainable = False DCGAN_model.compile(loss=models.wasserstein, optimizer=opt_G) discriminator_model.trainable = True discriminator_model.compile(loss=models.wasserstein, optimizer=opt_D) # Global iteration counter for generator updates gen_iterations = 0 ################# # Start training ################ for e in range(nb_epoch): # Initialize progbar and batch counter progbar = generic_utils.Progbar(epoch_size) batch_counter = 1 start = time.time() while batch_counter < n_batch_per_epoch: if gen_iterations < 25 or gen_iterations % 500 == 0: disc_iterations = 100 else: disc_iterations = kwargs["disc_iterations"] ################################### # 1) Train the critic / discriminator ################################### list_disc_loss_real = [] list_disc_loss_gen = [] for disc_it in range(disc_iterations): # Clip discriminator weights for l in discriminator_model.layers: weights = l.get_weights() weights = [np.clip(w, clamp_lower, clamp_upper) for w in weights] l.set_weights(weights) X_real_batch = next(data_utils.gen_batch(X_real_train, batch_size)) # Create a batch to feed the discriminator model X_disc_real, X_disc_gen = data_utils.get_disc_batch(X_real_batch, generator_model, batch_counter, batch_size, noise_dim, noise_scale=noise_scale) # Update the discriminator disc_loss_real = discriminator_model.train_on_batch(X_disc_real, -np.ones(X_disc_real.shape[0])) disc_loss_gen = discriminator_model.train_on_batch(X_disc_gen, np.ones(X_disc_gen.shape[0])) list_disc_loss_real.append(disc_loss_real) list_disc_loss_gen.append(disc_loss_gen) ####################### # 2) Train the generator ####################### X_gen = data_utils.sample_noise(noise_scale, batch_size, noise_dim) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch(X_gen, -np.ones(X_gen.shape[0])) # Unfreeze the discriminator discriminator_model.trainable = True gen_iterations += 1 batch_counter += 1 progbar.add(batch_size, values=[("Loss_D", -np.mean(list_disc_loss_real) - np.mean(list_disc_loss_gen)), ("Loss_D_real", -np.mean(list_disc_loss_real)), ("Loss_D_gen", np.mean(list_disc_loss_gen)), ("Loss_G", -gen_loss)]) # Save images for visualization ~2 times per epoch if batch_counter % (n_batch_per_epoch / 2) == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, batch_size, noise_dim, image_dim_ordering) print('\nEpoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) # Save model weights (by default, every 5 epochs) data_utils.save_model_weights(generator_model, discriminator_model, DCGAN_model, e)
def train(**kwargs): """ Train standard DCGAN model args: **kwargs (dict) keyword arguments that specify the model hyperparameters """ # Roll out the parameters generator = kwargs["generator"] dset = kwargs["dset"] img_dim = kwargs["img_dim"] nb_epoch = kwargs["nb_epoch"] batch_size = kwargs["batch_size"] n_batch_per_epoch = kwargs["n_batch_per_epoch"] noise_dim = kwargs["noise_dim"] noise_scale = kwargs["noise_scale"] lr_D = kwargs["lr_D"] lr_G = kwargs["lr_G"] opt_D = kwargs["opt_D"] opt_G = kwargs["opt_G"] clamp_lower = kwargs["clamp_lower"] clamp_upper = kwargs["clamp_upper"] image_data_format = kwargs["image_data_format"] save_weights_every_n_epochs = kwargs["save_weights_every_n_epochs"] save_only_last_n_weights = kwargs["save_only_last_n_weights"] visualize_images_every_n_epochs = kwargs["visualize_images_every_n_epochs"] model_name = kwargs["model_name"] epoch_size = n_batch_per_epoch * batch_size print("\nExperiment parameters:") for key in kwargs.keys(): print(key, kwargs[key]) print("\n") # Setup environment (logging directory etc) general_utils.setup_logging(**kwargs) # Load and normalize data X_real_train, X_batch_gen = data_utils.load_image_dataset( dset, img_dim, image_data_format, batch_size) # Get the full real image dimension img_dim = X_real_train.shape[-3:] # Create optimizers opt_G = data_utils.get_optimizer(opt_G, lr_G) opt_D = data_utils.get_optimizer(opt_D, lr_D) ####################### # Load models ####################### noise_dim = (noise_dim, ) if generator == "upsampling": generator_model = models.generator_upsampling(noise_dim, img_dim, dset=dset) else: generator_model = models.generator_deconv(noise_dim, img_dim, batch_size, dset=dset) discriminator_model = models.discriminator(img_dim) DCGAN_model = models.DCGAN(generator_model, discriminator_model, noise_dim, img_dim) ############################ # Compile models ############################ generator_model.compile(loss='mse', optimizer=opt_G) discriminator_model.trainable = False DCGAN_model.compile(loss=models.wasserstein, optimizer=opt_G) discriminator_model.trainable = True discriminator_model.compile(loss=models.wasserstein, optimizer=opt_D) # Global iteration counter for generator updates gen_iterations = 0 disc_losses = [] disc_losses_real = [] disc_losses_gen = [] gen_losses = [] ################# # Start training ################ try: for e in range(nb_epoch): print('--------------------------------------------') print('[{0:%Y/%m/%d %H:%M:%S}] Epoch {1:d}/{2:d}\n'.format( datetime.datetime.now(), e + 1, nb_epoch)) # Initialize progbar and batch counter progbar = generic_utils.Progbar(epoch_size) batch_counter = 0 start = time.time() disc_loss_batch = 0 disc_loss_real_batch = 0 disc_loss_gen_batch = 0 gen_loss_batch = 0 for batch_counter in range(n_batch_per_epoch): if gen_iterations < 25 or gen_iterations % 500 == 0: disc_iterations = 100 else: disc_iterations = kwargs["disc_iterations"] ################################### # 1) Train the critic / discriminator ################################### list_disc_loss_real = [] list_disc_loss_gen = [] for disc_it in range(disc_iterations): # Clip discriminator weights for l in discriminator_model.layers: weights = l.get_weights() weights = [ np.clip(w, clamp_lower, clamp_upper) for w in weights ] l.set_weights(weights) X_real_batch = next( data_utils.gen_batch(X_real_train, X_batch_gen, batch_size)) # Create a batch to feed the discriminator model X_disc_real, X_disc_gen = data_utils.get_disc_batch( X_real_batch, generator_model, batch_counter, batch_size, noise_dim, noise_scale=noise_scale) # Update the discriminator disc_loss_real = discriminator_model.train_on_batch( X_disc_real, -np.ones(X_disc_real.shape[0])) disc_loss_gen = discriminator_model.train_on_batch( X_disc_gen, np.ones(X_disc_gen.shape[0])) list_disc_loss_real.append(disc_loss_real) list_disc_loss_gen.append(disc_loss_gen) ####################### # 2) Train the generator ####################### X_gen = data_utils.sample_noise(noise_scale, batch_size, noise_dim) # Freeze the discriminator discriminator_model.trainable = False gen_loss = DCGAN_model.train_on_batch(X_gen, -np.ones(X_gen.shape[0])) # Unfreeze the discriminator discriminator_model.trainable = True gen_iterations += 1 disc_loss_batch += -np.mean(list_disc_loss_real) - np.mean( list_disc_loss_gen) disc_loss_real_batch += -np.mean(list_disc_loss_real) disc_loss_gen_batch += np.mean(list_disc_loss_gen) gen_loss_batch += -gen_loss progbar.add(batch_size, values=[ ("Loss_D", -np.mean(list_disc_loss_real) - np.mean(list_disc_loss_gen)), ("Loss_D_real", -np.mean(list_disc_loss_real)), ("Loss_D_gen", np.mean(list_disc_loss_gen)), ("Loss_G", -gen_loss) ]) # # Save images for visualization ~2 times per epoch # if batch_counter % (n_batch_per_epoch / 2) == 0: # data_utils.plot_generated_batch(X_real_batch, generator_model, # batch_size, noise_dim, image_data_format) disc_losses.append(disc_loss_batch / n_batch_per_epoch) disc_losses_real.append(disc_loss_real_batch / n_batch_per_epoch) disc_losses_gen.append(disc_loss_gen_batch / n_batch_per_epoch) gen_losses.append(gen_loss_batch / n_batch_per_epoch) # Save images for visualization if (e + 1) % visualize_images_every_n_epochs == 0: data_utils.plot_generated_batch(X_real_batch, generator_model, e, batch_size, noise_dim, image_data_format, model_name) data_utils.plot_losses(disc_losses, disc_losses_real, disc_losses_gen, gen_losses, model_name) # Save model weights (by default, every 5 epochs) data_utils.save_model_weights(generator_model, discriminator_model, DCGAN_model, e, save_weights_every_n_epochs, save_only_last_n_weights, model_name) end = time.time() print('\nEpoch %s/%s END, Time: %s' % (e + 1, nb_epoch, end - start)) start = end except KeyboardInterrupt: pass gen_weights_path = '../../models/%s/generator_latest.h5' % (model_name) print("Saving", gen_weights_path) generator_model.save(gen_weights_path, overwrite=True)