class DCGAN: def __init__(self, args): np.random.seed(int(time.time())) self.store = Store() self.visual = Visual(self.store) self.image_shape = [28, 28, 1] # 28x28 pixels and black white self.batch_size = args.batch_size self.lr = args.learning_rate self.train_epoch = args.train_epoch self.dropout_keep_probability = tf.placeholder("float") self.mnist = input_data.read_data_sets("MNIST_data/", one_hot=True, reshape=[]) self.is_training = tf.placeholder(dtype=tf.bool) self.x = tf.placeholder(tf.float32, shape=(None, 64, 64, 1), name="X_Input") self.z = tf.placeholder(tf.float32, shape=(None, 1, 1, 100), name="Z") self.G_z = define_generator(self.z, self.is_training) D_real, D_real_logits = define_discriminator(self.x, self.is_training) D_fake, D_fake_logits = define_discriminator(self.G_z, self.is_training, reuse=True) D_loss_real = init_loss(D_real_logits, tf.ones, self.batch_size) D_loss_fake = init_loss(D_fake_logits, tf.zeros, self.batch_size) self.G_loss = init_loss(D_fake_logits, tf.ones, self.batch_size) self.D_loss = D_loss_real + D_loss_fake self.sess = None def train(self): D_vars = [ var for var in tf.trainable_variables() if var.name.startswith('discriminator') ] G_vars = [ var for var in tf.trainable_variables() if var.name.startswith('generator') ] with tf.control_dependencies(tf.get_collection( tf.GraphKeys.UPDATE_OPS)): D_optim = tf.train.AdamOptimizer(self.lr, beta1=0.5).minimize( self.D_loss, var_list=D_vars) G_optim = tf.train.AdamOptimizer(self.lr, beta1=0.5).minimize( self.G_loss, var_list=G_vars) # start the session with multi GPU support configuration = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True) self.sess = tf.InteractiveSession(config=configuration) tf.global_variables_initializer().run() train_set = tf.image.resize_images(self.mnist.train.images, [64, 64]).eval() train_set = (train_set - 0.5) / 0.5 # normalization; range: -1 ~ 1 print('training start!') start_time = time.time() for epoch in range(self.train_epoch): G_losses = [] D_losses = [] epoch_start_time = time.time() iterations = self.mnist.train.num_examples // self.batch_size for iter in range(iterations): # update discriminator x_ = train_set[iter * self.batch_size:(iter + 1) * self.batch_size] z_ = np.random.normal(0, 1, (self.batch_size, 1, 1, 100)) loss_d, _ = self.sess.run([self.D_loss, D_optim], { self.x: x_, self.z: z_, self.is_training: True }) # update generator z_ = np.random.normal(0, 1, (self.batch_size, 1, 1, 100)) loss_g, _ = self.sess.run([self.G_loss, G_optim], { self.z: z_, self.x: x_, self.is_training: True }) G_losses.append(loss_g) D_losses.append(loss_d) print("Epoch " + str(epoch) + "/" + str(self.train_epoch) + " of iteration " + str(iter) + "/" + str(iterations) + " with loss_g " + str(loss_g) + " and loss_d " + str(loss_d)) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time print('[%d/%d] - ptime: %.2f loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), self.train_epoch, per_epoch_ptime, np.mean(D_losses), np.mean(G_losses))) fixed_p = root + 'Fixed_results/' + model + str(epoch + 1) + '.png' fixed_z_ = np.random.normal(0, 1, (25, 1, 1, 100)) test_images = self.sess.run(self.G_z, { self.z: fixed_z_, self.is_training: False }) self.visual.show_result(test_images, num_epoch=epoch, show=False, save=True, path=fixed_p) self.store.hist_append('D_losses', np.mean(D_losses)) self.store.hist_append('G_losses', np.mean(G_losses)) self.store.hist_append('per_epoch_ptimes', per_epoch_ptime) # let it run and save the images end_time = time.time() total_ptime = end_time - start_time self.store.hist_append('total_ptime', total_ptime) print('Avg per epoch ptime: %.2f, total %d epochs ptime: %.2f' % (np.mean(self.store.retrieve('per_epoch_ptimes')), self.train_epoch, total_ptime)) self.visual.show_train_hist(self.store.retrieve('D_losses'), self.store.retrieve('G_losses'), show=False, save=True, path=root + model + 'train_hist.png') images = [] for e in range(self.train_epoch): img_name = root + 'Fixed_results/' + model + str(e + 1) + '.png' images.append(imageio.imread(img_name)) imageio.mimsave(root + model + 'generation_animation.gif', images, fps=5) def visualize(self, layer, image_stimulation): '''Gives the model a layer and a image to check the activates against :param layer: Layer to visualize :param image_stimulation: Image to run through the models to see the activations :return: graph to display ''' #https://medium.com/@awjuliani/visualizing-neural-network-layer-activation-tensorflow-tutorial-d45f8bf7bbc4 flatten_image = np.reshape(image_stimulation, [1, 784], order='F') units = self.sess.run(layer, feed_dict={ self.x: flatten_image, self.dropout_keep_probability: 1.0 }) self.visual.plotNNFilter(units) def shutdown(self): self.sess.close()