def test_generator(generator, class_label=None): noise_input = np.random.uniform(-1.0, 1.0, size=[16, 100]) step = 0 if class_label is None: num_labels = 10 noise_label = np.eye(num_labels)[np.random.choice(num_labels, 16)] else: noise_label = np.zeros((16, 10)) noise_label[:, class_label] = 1 step = class_label gan.plot_images(generator, noise_input=noise_input, noise_label=noise_label, show=True, step=step, model_name="test_outputs")
def test_generator(generator, params, latent_size=100): label, code1, code2, p1, p2 = params noise_input = np.random.uniform(-1.0, 1.0, size=[16, latent_size]) step = 0 if label is None: num_labels = 10 noise_label = np.eye(num_labels)[np.random.choice(num_labels, 16)] else: noise_label = np.zeros((16, 10)) noise_label[:, label] = 1 step = label code_std = 2 if code1 is None: noise_code1 = np.random.normal(scale=0.5, size=[16, 1]) else: if p1: a = np.linspace(-code_std, code_std, 16) a = np.reshape(a, [16, 1]) noise_code1 = np.ones((16, 1)) * a else: noise_code1 = np.ones((16, 1)) * code1 print(noise_code1) if code2 is None: noise_code2 = np.random.normal(scale=0.5, size=[16, 1]) else: if p2: a = np.linspace(-code_std, code_std, 16) a = np.reshape(a, [16, 1]) noise_code2 = np.ones((16, 1)) * a else: noise_code2 = np.ones((16, 1)) * code2 print(noise_code2) gan.plot_images(generator, noise_input=noise_input, noise_label=noise_label, noise_codes=[noise_code1, noise_code2], show=True, step=step, model_name="test_outputs")
def train(models, data, params): """Train the Discriminator and Adversarial networks Alternately train discriminator and adversarial networks by batch. Discriminator is trained first with real and fake images, corresponding one-hot labels and continuous codes. Adversarial is trained next with fake images pretending to be real, corresponding one-hot labels and continous codes. Generate sample images per save_interval. # Arguments models (Models): Generator, Discriminator, Adversarial models data (tuple): x_train, y_train data params (tuple): Network parameters """ # the GAN models generator, discriminator, adversarial = models # images and their one-hot labels x_train, y_train = data # network parameters batch_size, latent_size, train_steps, num_labels, model_name = \ params # the generator image is saved every 500 steps save_interval = 500 # noise vector to see how the generator output # evolves during training noise_input = np.random.uniform(-1.0, 1.0, size=[16, latent_size]) # random class labels and codes noise_label = np.eye(num_labels)[np.arange(0, 16) % num_labels] noise_code1 = np.random.normal(scale=0.5, size=[16, 1]) noise_code2 = np.random.normal(scale=0.5, size=[16, 1]) # number of elements in train dataset train_size = x_train.shape[0] print(model_name, "Labels for generated images: ", np.argmax(noise_label, axis=1)) for i in range(train_steps): # train the discriminator for 1 batch # 1 batch of real (label=1.0) and fake images (label=0.0) # randomly pick real images and # corresponding labels from dataset rand_indexes = np.random.randint(0, train_size, size=batch_size) real_images = x_train[rand_indexes] real_labels = y_train[rand_indexes] # random codes for real images real_code1 = np.random.normal(scale=0.5, size=[batch_size, 1]) real_code2 = np.random.normal(scale=0.5, size=[batch_size, 1]) # generate fake images, labels and codes noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) fake_labels = np.eye(num_labels)[np.random.choice( num_labels, batch_size)] fake_code1 = np.random.normal(scale=0.5, size=[batch_size, 1]) fake_code2 = np.random.normal(scale=0.5, size=[batch_size, 1]) inputs = [noise, fake_labels, fake_code1, fake_code2] fake_images = generator.predict(inputs) # real + fake images = 1 batch of train data x = np.concatenate((real_images, fake_images)) labels = np.concatenate((real_labels, fake_labels)) codes1 = np.concatenate((real_code1, fake_code1)) codes2 = np.concatenate((real_code2, fake_code2)) # label real and fake images # real images label is 1.0 y = np.ones([2 * batch_size, 1]) # fake images label is 0.0 y[batch_size:, :] = 0 # train discriminator network, # log the loss and label accuracy outputs = [y, labels, codes1, codes2] # metrics = ['loss', 'activation_1_loss', 'label_loss', # 'code1_loss', 'code2_loss', 'activation_1_acc', # 'label_acc', 'code1_acc', 'code2_acc'] # from discriminator.metrics_names metrics = discriminator.train_on_batch(x, outputs) fmt = "%d: [discriminator loss: %f, label_acc: %f]" log = fmt % (i, metrics[0], metrics[6]) # train the adversarial network for 1 batch # 1 batch of fake images with label=1.0 and # corresponding one-hot label or class + random codes # since the discriminator weights are frozen # in adversarial network only the generator is trained # generate fake images, labels and codes noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) fake_labels = np.eye(num_labels)[np.random.choice( num_labels, batch_size)] fake_code1 = np.random.normal(scale=0.5, size=[batch_size, 1]) fake_code2 = np.random.normal(scale=0.5, size=[batch_size, 1]) # label fake images as real y = np.ones([batch_size, 1]) # train the adversarial network # note that unlike in discriminator training, # we do not save the fake images in a variable # the fake images go to the discriminator # input of the adversarial for classification # log the loss and label accuracy inputs = [noise, fake_labels, fake_code1, fake_code2] outputs = [y, fake_labels, fake_code1, fake_code2] metrics = adversarial.train_on_batch(inputs, outputs) fmt = "%s [adversarial loss: %f, label_acc: %f]" log = fmt % (log, metrics[0], metrics[6]) print(log) if (i + 1) % save_interval == 0: # plot generator images on a periodic basis gan.plot_images(generator, noise_input=noise_input, noise_label=noise_label, noise_codes=[noise_code1, noise_code2], show=False, step=(i + 1), model_name=model_name) # save the model after training the generator # the trained generator can be reloaded for # future MNIST digit generation generator.save(model_name + ".h5")
def train(models, data, params): """Train the discriminator and adversarial Networks Alternately train discriminator and adversarial networks by batch. Discriminator is trained first with real and fake images and corresponding one-hot labels. Adversarial is trained next with fake images pretending to be real and corresponding one-hot labels. Generate sample images per save_interval. # Arguments models (list): Generator, Discriminator, Adversarial models data (list): x_train, y_train data params (list): Network parameters """ # the GAN models generator, discriminator, adversarial = models # images and their one-hot labels x_train, y_train = data # network parameters batch_size, latent_size, train_steps, num_labels, model_name \ = params # the generator image is saved every 500 steps save_interval = 500 # noise vector to see how the generator # output evolves during training noise_input = np.random.uniform(-1.0, 1.0, size=[16, latent_size]) # class labels are 0, 1, 2, 3, 4, 5, # 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 # the generator must produce these GANshion digits noise_label = np.eye(num_labels)[np.arange(0, 16) % num_labels] # number of elements in train dataset train_size = x_train.shape[0] print(model_name, "Labels for generated images: ", np.argmax(noise_label, axis=1)) for i in range(train_steps): # train the discriminator for 1 batch # 1 batch of real (label=1.0) and fake images (label=0.0) # randomly pick real images and # corresponding labels from dataset rand_indexes = np.random.randint(0, train_size, size=batch_size) real_images = x_train[rand_indexes] real_labels = y_train[rand_indexes] # generate fake images from noise using generator # generate noise using uniform distribution noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) # randomly pick one-hot labels fake_labels = np.eye(num_labels)[np.random.choice( num_labels, batch_size)] # generate fake images fake_images = generator.predict([noise, fake_labels]) # real + fake images = 1 batch of train data x = np.concatenate((real_images, fake_images)) # real + fake labels = 1 batch of train data labels labels = np.concatenate((real_labels, fake_labels)) # label real and fake images # real images label is 1.0 y = np.ones([2 * batch_size, 1]) # fake images label is 0.0 y[batch_size:, :] = 0 # train discriminator network, log the loss and accuracy # ['loss', 'activation_1_loss', # 'label_loss', 'activation_1_acc', 'label_acc'] metrics = discriminator.train_on_batch(x, [y, labels]) fmt = "%d: [disc loss: %f, srcloss: %f," fmt += "lblloss: %f, srcacc: %f, lblacc: %f]" log = fmt % (i, metrics[0], metrics[1], \ metrics[2], metrics[3], metrics[4]) # train the adversarial network for 1 batch # 1 batch of fake images with label=1.0 and # corresponding one-hot label or class # since the discriminator weights are frozen # in adversarial network only the generator is trained # generate noise using uniform distribution noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) # randomly pick one-hot labels fake_labels = np.eye(num_labels)[np.random.choice( num_labels, batch_size)] # label fake images as real y = np.ones([batch_size, 1]) # train the adversarial network # note that unlike in discriminator training, # we do not save the fake images in a variable # the fake images go to the discriminator input # of the adversarial for classification # log the loss and accuracy metrics = adversarial.train_on_batch([noise, fake_labels], [y, fake_labels]) fmt = "%s [advr loss: %f, srcloss: %f," fmt += "lblloss: %f, srcacc: %f, lblacc: %f]" log = fmt % (log, metrics[0], metrics[1],\ metrics[2], metrics[3], metrics[4]) print(log) if (i + 1) % save_interval == 0: # plot generator images on a periodic basis gan.plot_images(generator, noise_input=noise_input, noise_label=noise_label, show=False, step=(i + 1), model_name=model_name) # save the model after training the generator # the trained generator can be reloaded # for future GANshion digit generation generator.save(model_name + ".h5")
def train(models, x_train, params): """Train the Discriminator and Adversarial Networks Alternately train Discriminator and Adversarial networks by batch. Discriminator is trained first with properly labelled real and fake images for n_critic times. Discriminator weights are clipped as a requirement of Lipschitz constraint. Generator is trained next (via Adversarial) with fake images pretending to be real. Generate sample images per save_interval Arguments: models (list): Generator, Discriminator, Adversarial models x_train (tensor): Train images params (list) : Networks parameters """ # the GAN models generator, discriminator, adversarial = models # network parameters (batch_size, latent_size, n_critic, clip_value, train_steps, model_name) = params # the generator image is saved every 500 steps save_interval = 500 # noise vector to see how the # generator output evolves during training noise_input = np.random.uniform(-1.0, 1.0, size=[16, latent_size]) # number of elements in train dataset train_size = x_train.shape[0] # labels for real data real_labels = np.ones((batch_size, 1)) for i in range(train_steps): # train discriminator n_critic times loss = 0 acc = 0 for _ in range(n_critic): # train the discriminator for 1 batch # 1 batch of real (label=1.0) and # fake images (label=-1.0) # randomly pick real images from dataset rand_indexes = np.random.randint(0, train_size, size=batch_size) real_images = x_train[rand_indexes] # generate fake images from noise using generator # generate noise using uniform distribution noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) fake_images = generator.predict(noise) # train the discriminator network # real data label=1, fake data label=-1 # instead of 1 combined batch of real and fake images, # train with 1 batch of real data first, then 1 batch # of fake images. # this tweak prevents the gradient # from vanishing due to opposite # signs of real and fake data labels (i.e. +1 and -1) and # small magnitude of weights due to clipping. real_loss, real_acc = \ discriminator.train_on_batch(real_images, real_labels) fake_loss, fake_acc = \ discriminator.train_on_batch(fake_images, -real_labels) # accumulate average loss and accuracy loss += 0.5 * (real_loss + fake_loss) acc += 0.5 * (real_acc + fake_acc) # clip discriminator weights to satisfy Lipschitz constraint for layer in discriminator.layers: weights = layer.get_weights() weights = [ np.clip(weight, -clip_value, clip_value) for weight in weights ] layer.set_weights(weights) # average loss and accuracy per n_critic training iterations loss /= n_critic acc /= n_critic log = "%d: [discriminator loss: %f, acc: %f]" % (i, loss, acc) # train the adversarial network for 1 batch # 1 batch of fake images with label=1.0 # since the discriminator weights are frozen in # adversarial network only the generator is trained # generate noise using uniform distribution noise = np.random.uniform(-1.0, 1.0, size=[batch_size, latent_size]) # train the adversarial network # note that unlike in discriminator training, # we do not save the fake images in a variable # the fake images go to the discriminator # input of the adversarial for classification # fake images are labelled as real # log the loss and accuracy loss, acc = adversarial.train_on_batch(noise, real_labels) log = "%s [adversarial loss: %f, acc: %f]" % (log, loss, acc) print(log) if (i + 1) % save_interval == 0: # plot generator images on a periodic basis gan.plot_images(generator, noise_input=noise_input, show=False, step=(i + 1), model_name=model_name) # save the model after training the generator # the trained generator can be reloaded # for future MNIST digit generation generator.save(model_name + ".h5")