def define_objective(real_inputs_discrete, y, seq_length): real_inputs = real_inputs_discrete train_pred = generator(cf.BATCH_SIZE, y, seq_len=seq_length) disc_real = discriminator(real_inputs, y, seq_length, reuse=False) disc_fake = discriminator(train_pred, y, seq_length, reuse=True) disc_cost, gen_cost = loss_d_g(disc_fake, disc_real, train_pred, real_inputs, y, seq_length, discriminator) return disc_cost, gen_cost
def build_GAN(self): tower_D_grads = [] tower_G_grads = [] with tf.variable_scope(tf.get_variable_scope()): for i in range(self.num_gpus): with tf.device('/gpu:%d' % i): with tf.name_scope('%s_%d' % ("tower", i)) as scope: # Get this gpu's data image_batch, label_batch, noise_batch = self.batch_queue.dequeue( ) # Create the generator graph self.G_z = generator(noise_batch) # Create the discriminator graphs D_real, D_real_logits = discriminator(image_batch) D_fake, D_fake_logits = discriminator(self.G_z, reuse=True) self.compute_loss(self.G_z, D_real, D_real_logits, D_fake, D_fake_logits, label_batch) 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') ] tf.get_variable_scope().reuse_variables() D_grads = self.D_optim.compute_gradients( self.D_loss, var_list=D_vars) tower_D_grads.append(D_grads) G_grads = self.G_optim.compute_gradients( self.G_loss, var_list=G_vars) tower_G_grads.append(G_grads) avg_D_grads = self.average_gradients(tower_D_grads) avg_G_grads = self.average_gradients(tower_G_grads) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): self.D_train_op = self.D_optim.apply_gradients(avg_D_grads) self.G_train_op = self.G_optim.apply_gradients(avg_G_grads) self.train_op = tf.group(self.D_train_op, self.G_train_op)
def __init__(self, args): self.args = args self.device = torch.device('cuda: 0') self.device_ids = list(map(lambda x: int(x), args.gpus.split(','))) self.loader1 = get_loader(args.root1, args) self.loader2 = get_loader(args.root2, args) self.netG_A = generator(input_nc=3, output_nc=3, n_blocks=9) self.netG_B = generator(input_nc=3, output_nc=3, n_blocks=9) self.netD_A = discriminator(input_nc=3) self.netD_B = discriminator(input_nc=3) self.netG_A.to(self.device) self.netG_B.to(self.device) self.netD_A.to(self.device) self.netD_B.to(self.device) self.netG_A = nn.DataParallel(self.netG_A, device_ids=self.device_ids) self.netG_B = nn.DataParallel(self.netG_B, device_ids=self.device_ids) self.netD_A = nn.DataParallel(self.netD_A, device_ids=self.device_ids) self.netD_B = nn.DataParallel(self.netD_B, device_ids=self.device_ids) init_weights(self.netG_A) init_weights(self.netG_B) init_weights(self.netD_A) init_weights(self.netD_B) self.fake_A_pool = ImagePool(50) self.fake_B_pool = ImagePool(50) self.criterionCycle = nn.L1Loss() self.criterionGAN = LSGANLoss() self.start_epoch = 0 self.optimizer_G = torch.optim.Adam(itertools.chain( self.netG_A.parameters(), self.netG_B.parameters()), lr=self.args.lr, betas=(0.5, 0.999)) self.optimizer_D = torch.optim.Adam(itertools.chain( self.netD_A.parameters(), self.netD_B.parameters()), lr=self.args.lr, betas=(0.5, 0.999)) def lambda_rule(epoch): lr_l = 1.0 - max(0, epoch + 1 - 100) / float(100 + 1) return lr_l self.scheduler_G = lr_scheduler.LambdaLR(self.optimizer_G, lr_lambda=lambda_rule) self.scheduler_D = lr_scheduler.LambdaLR(self.optimizer_D, lr_lambda=lambda_rule) self.create_experiment() self.get_logger()
def __init__(self): self.ckpt_path = utils.CKPT_PATH self.gen = generator() self.dis = discriminator() self.gen.summary() self.dis.summary() self.gen_optimizer = tf.keras.optimizers.Adam(1e-4) self.dis_optimizer = tf.keras.optimizers.Adam(1e-4) self.init_epoch = tf.Variable(0) self.summary_writer = tf.summary.create_file_writer(utils.SUMMARY_PATH) self.ckpt = tf.train.Checkpoint(init_epoch=self.init_epoch, gen=self.gen, dis=self.dis, gen_optimizer=self.gen_optimizer, dis_optimizer=self.dis_optimizer) self.ckpt_manager = tf.train.CheckpointManager( self.ckpt, directory=self.ckpt_path, max_to_keep=3) self.gen_img_path = path.join(utils.OUTPUT_PATH, 'mnist') if not path.exists(self.gen_img_path): os.mkdir(self.gen_img_path) if not path.exists(self.ckpt_path): os.mkdir(self.ckpt_path)
def main(): train_set = MNIST('./mnist', train=True, download=True, transform=preprocess_img) train_data = DataLoader(train_set, batch_size=128, sampler=ChunkSampler(50000, 0)) val_set = MNIST('./mnist', train=True, download=True, transform=preprocess_img) val_data = DataLoader(val_set, batch_size=128, sampler=ChunkSampler(5000, 50000)) D_net = discriminator() G_net = generator() D_optim = get_optimizer(D_net) G_optim = get_optimizer(G_net) train_gan(D_DC, G_DC, D_DC_optim, G_DC_optim, discriminator_loss, generator_loss, num_epochs=5)
def train(): (X_train, y_train), (_, _) = mnist.load_data() # normalize images X_train = (X_train.astype(np.float32) - 127.5) / 127.5 X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1) # build GAN g = generator() d = discriminator() opt = Adam(lr=LR, beta_1=B1) d.trainable = True d.compile(loss='binary_crossentropy', metrics=['accuracy'], optimizer=opt) d.trainable = False dcgan = Sequential([g, d]) opt = Adam(lr=LR, beta_1=B1) dcgan.compile(loss='binary_crossentropy', metrics=['accuracy'], optimizer=opt) num_batches = int(X_train.shape[0] / BATCH_SIZE) # create directory if not os.path.exists(GENERATED_IMAGE_PATH): os.mkdir(GENERATED_IMAGE_PATH) if not os.path.exists(GENERATED_MODEL_PATH): os.mkdir(GENERATED_MODEL_PATH) print("-------------------") print("Total epoch:", NUM_EPOCH, "Number of batches:", num_batches) print("-------------------") z_pred = np.array([np.random.uniform(-1, 1, 100) for _ in range(49)]) y_g = [1] * BATCH_SIZE y_d_true = [1] * BATCH_SIZE y_d_gen = [0] * BATCH_SIZE for epoch in list(map(lambda x: x + 1, range(NUM_EPOCH))): for index in range(num_batches): X_d_true = X_train[index * BATCH_SIZE:(index + 1) * BATCH_SIZE] X_g = np.array( [np.random.normal(0, 0.5, 100) for _ in range(BATCH_SIZE)]) X_d_gen = g.predict(X_g, verbose=0) # train discriminator d_loss = d.train_on_batch(X_d_true, y_d_true) d_loss = d.train_on_batch(X_d_gen, y_d_gen) # train generator g_loss = dcgan.train_on_batch(X_g, y_g) show_progress(epoch, index, g_loss[0], d_loss[0], g_loss[1], d_loss[1]) # save generated images image = combine_images(g.predict(z_pred)) image = image * 127.5 + 127.5 Image.fromarray(image.astype(np.uint8))\ .save(GENERATED_IMAGE_PATH+"%03depoch.png" % (epoch)) print() # save models g.save(GENERATED_MODEL_PATH + 'dcgan_generator.h5') d.save(GENERATED_MODEL_PATH + 'dcgan_discriminator.h5')
def dis_update(noise, point, generator, discriminator, disopt, genopt): disopt.zero_grad() genopt.zero_grad() output = generator(noise) fake_output = discriminator(output) real_output = discriminator(point) ones = Variable( torch.FloatTensor(np.ones(real_output.size(0), dtype=np.int))) zeros = Variable( torch.FloatTensor(np.zeros(fake_output.size(0), dtype=np.int))) real_adv_loss = nn.functional.binary_cross_entropy(real_output, ones) fake_adv_loss = nn.functional.binary_cross_entropy(fake_output, zeros) adv_loss = real_adv_loss + fake_adv_loss adv_loss.backward(retain_graph=True) disopt.step()
def _build_model(self, filename_queue, config): x_ = self._im_from_tfrecords(filename_queue, config) # TODO: supervised image generation? y_ = tf.placeholder(tf.float32, [None, config.y_dim], name="y") z_ = tf.placeholder(tf.float32, [None, config.z_dim], name="z") is_training_ = tf.placeholder(tf.bool, name="is_training") G, G_end_pts = model.generator(z_, is_training_) D_real, D_real_end_pts = model.discriminator(x_, is_training_) D_fake, D_fake_end_pts = model.discriminator(G, is_training_, reuse=True) with tf.variable_scope("Loss_D"): loss_D_real = tf.losses.sigmoid_cross_entropy( multi_class_labels=tf.ones_like(D_real), logits=D_real) loss_D_fake = tf.losses.sigmoid_cross_entropy( multi_class_labels=tf.zeros_like(D_fake), logits=D_fake) loss_D = loss_D_real + loss_D_fake with tf.variable_scope("Loss_G"): loss_G = tf.losses.sigmoid_cross_entropy( multi_class_labels=tf.ones_like(D_fake), logits=D_fake) with tf.variable_scope("Optimizer_D"): vars_D = [var for var in tf.trainable_variables() \ if "discriminator" in var.name] opt_D = tf.train.AdamOptimizer(config.lr, beta1=config.beta1).minimize(loss_D, self.global_step, var_list=vars_D) with tf.variable_scope("Optimizer_G"): vars_G = [var for var in tf.trainable_variables() \ if "generator" in var.name] opt_G = tf.train.AdamOptimizer(config.lr, beta1=config.beta1).minimize(loss_G, var_list=vars_G) return {"x": x_, "y": y_, "z": z_, "is_training": is_training_, "G": G, "D_real": D_real, "D_fake": D_fake, "G_end_pts": G_end_pts, "D_real_end_pts": D_real_end_pts, "D_fake_end_pts": D_fake_end_pts, "loss_D_real": loss_D_real, "loss_D_fake": loss_D_fake, "loss_D": loss_D, "loss_G": loss_G, "opt_D": opt_D, "opt_G": opt_G}
def create_model(session, mode): m = model.discriminator(VOCAB_SIZE, UNIT_SIZE, BATCH_SIZE, MAX_LENGTH, mode) ckpt = tf.train.get_checkpoint_state('./saved_model/') if ckpt: print("Reading model from %s" % ckpt.model_checkpoint_path) m.saver.restore(session, ckpt.model_checkpoint_path) else: print("Create model with fresh parameters") session.run(tf.global_variables_initializer()) return m
def train_generator(optimizer, fake_data, loss=nn.BCELoss()): N = fake_data.size(0) # Reset gradients optimizer.zero_grad() # Sample noise and generate fake data prediction = discriminator(fake_data) # Calculate error and backpropagate error = loss(prediction, ones_target(N)) error.backward() # Update weights with gradients optimizer.step() # Return error return error
def train_discriminator(optimizer, real_data, fake_data, loss=nn.BCELoss()): N = real_data.size(0) # Reset gradients optimizer.zero_grad() # 1.1 Train on Real Data prediction_real = discriminator(real_data) # Calculate error and backpropagate error_real = loss(prediction_real, ones_target(N)) error_real.backward() # 1.2 Train on Fake Data prediction_fake = discriminator(fake_data) # Calculate error and backpropagate error_fake = loss(prediction_fake, zeros_target(N)) error_fake.backward() # 1.3 Update weights with gradients optimizer.step() # Return error and predictions for real and fake inputs return error_real + error_fake, prediction_real, prediction_fake
def gen_update(noise, generator, discriminator, genopt, disopt): genopt.zero_grad() disopt.zero_grad() output = generator(noise) real_output = discriminator(output) ones = Variable( torch.FloatTensor(np.ones(real_output.size(0), dtype=np.int))) adv_loss = nn.functional.binary_cross_entropy(real_output, ones) adv_loss.backward() genopt.step()
def forward(self, fake, real, discriminator): fake_detach = fake.detach() self.loss = 0 for _ in range(self.gan_k): d_fake = fake.detach() d_real = real if self.gan_type.find('WGAN') >= 0: loss_d = (d_fake - d_real).mean() if self.gan_type.find('GP') >= 0: epsilon = Variable(fake_detach.data.new( fake.size(0), 1, 1, 1).uniform_(), requires_grad=False) hat = fake_detach.mul(1 - epsilon) + real.mul(epsilon) hat.requires_grad = True d_hat = discriminator(hat) gradients = torch.autograd.grad(outputs=d_hat.sum(), inputs=hat, retain_graph=True, create_graph=True, only_inputs=True)[0] gradients = gradients.view(gradients.size(0), -1) gradient_norm = gradients.norm(2, dim=1) gradient_penalty = 10 * gradient_norm.sub(1).pow(2).mean() loss_d += gradient_penalty if self.gan_type == 'WGAN': for p in discriminator.parameters(): p.data.clamp_(-1, 1) self.loss /= self.gan_k d_fake_for_g = discriminator(fake) if self.gan_type.find('WGAN') >= 0: loss_g = -d_fake_for_g.mean() return loss_g, loss_d #####
def build_model(self): # Define a generator and a discriminator self.G = model.generator(images, self.g_conv_dim, self.c_dim, self.g_repeat_num) self.D = model.discriminator(images, self.image_size, self.d_conv_dim, self.c_dim, self.d_repeat_num) # Optimizers self.g_optimizer = tf.train.AdamOptimizer(self.g_lr, [self.beta1, self.beta2]) self.d_optimizer = tf.train.AdamOptimizer(self.d_lr, [self.beta1, self.beta2]) # Print networks self.print_network(self.G, 'G') self.print_network(self.D, 'D') if tf.test.is_gpu_available(cuda_only=True): self.G.cuda() self.D.cuda()
def __init__(self, n_dim=2, batch_size=100, epochs=10, log_freq=100, results_path='./results', make_gif=False): self.n_dim = n_dim self.batch_size = batch_size self.epochs = epochs self.log_freq = log_freq self.results_path = results_path self.results_img_path = results_path + "/imges" self.make_gif = make_gif if not os.path.exists(self.results_img_path): os.makedirs(self.results_img_path) if self.make_gif and not os.path.exists(self.results_path + "/gif"): os.makedirs(self.results_path + "/gif") # data load self.load_data() self.dataset_train = tf.data.Dataset.from_tensor_slices( (self.x_train, self.y_train)) self.dtrain_shuffle = self.dataset_train.shuffle( self.x_train.shape[0]).batch(self.batch_size) self.dataset_test = tf.data.Dataset.from_tensor_slices( (self.x_test, self.y_test)) self.dtest_shuffle = self.dataset_test.shuffle( self.x_test.shape[0]).batch(1000) # Models self.encoder = encoder(n_dim=self.n_dim) self.decoder = decoder() self.discriminator = discriminator() # optimizer self.ae_opt = tf.keras.optimizers.Adam(0.0001) self.gen_opt = tf.keras.optimizers.Adam(0.0001, beta_1=0, beta_2=0.9) self.disc_opt = tf.keras.optimizers.Adam(0.0001, beta_1=0, beta_2=0.9) self.loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)
def loss_d_g(disc_fake, disc_real, fake_inputs, real_inputs, y, seq_length, discriminator): disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real) gen_cost = -tf.reduce_mean(disc_fake) # WGAN lipschitz-penalty alpha = tf.random_uniform(shape=[tf.shape(real_inputs)[0], 1, 1], minval=0., maxval=1.) differences = fake_inputs - real_inputs interpolates = real_inputs + (alpha * differences) gradients = tf.gradients( discriminator(interpolates, y, seq_length, reuse=True), [interpolates, y])[0] slopes = tf.sqrt( tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2])) gradient_penalty = tf.reduce_mean((slopes - 1.)**2) disc_cost += cf.LAMBDA * gradient_penalty return disc_cost, gen_cost
def __init__(self, dataset_path, lr, vis_screen, save_path, l1_coef, l2_coef, batch_size, num_workers, epochs, gpu_id): self.generator = torch.nn.DataParallel(model.generator().cuda(), device_ids=self.gpu_id) self.discriminator = torch.nn.DataParallel( model.discriminator().cuda(), device_ids=self.gpu_id) self.discriminator.apply(Utils.weights_init) self.generator.apply(Utils.weights_init) self.dataset = Train_Dataset(dataset_path, dataset_name='Market-1501') self.noise_dim = 100 self.batch_size = batch_size self.num_workers = num_workers self.lr = lr self.beta1 = 0.5 self.num_epochs = epochs self.l1_coef = l1_coef self.l2_coef = l2_coef self.data_loader = DataLoader(self.dataset, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers) self.optimD = torch.optim.Adam(self.discriminator.parameters(), lr=self.lr, betas=(self.beta1, 0.999)) self.optimG = torch.optim.Adam(self.generator.parameters(), lr=self.lr, betas=(self.beta1, 0.999)) #self.logger = Logger(vis_screen) self.checkpoints_path = 'checkpoints' self.save_path = save_path self.gpu_id = gpu_id
def model_setup(self): ''' build the model :return: None ''' self.fake_images_A = np.zeros( (pool_size, batch_size, img_height, img_width, img_layer)) self.fake_images_B = np.zeros( (pool_size, batch_size, img_height, img_width, img_layer)) self.input_A = tf.placeholder( tf.float32, [batch_size, img_height, img_width, img_layer]) self.input_B = tf.placeholder( tf.float32, [batch_size, img_height, img_width, img_layer]) self.fake_pool_A = tf.placeholder( tf.float32, [batch_size, img_height, img_width, img_layer]) self.fake_pool_B = tf.placeholder( tf.float32, [batch_size, img_height, img_width, img_layer]) self.num_fake_inputs = 0 self.lr = tf.placeholder(tf.float32, shape=[], name="lr") with tf.variable_scope("img2img") as scope: self.scope = scope self.fake_B = generator(self.input_A, name="g_A") self.fake_A = generator(self.input_B, name="g_B") self.rec_A = discriminator(self.input_A, "d_A") self.rec_B = discriminator(self.input_B, "d_B") scope.reuse_variables() self.fake_rec_A = discriminator(self.fake_A, "d_A") self.fake_rec_B = discriminator(self.fake_B, "d_B") self.cyc_A = generator(self.fake_B, "g_B") self.cyc_B = generator(self.fake_A, "g_A") scope.reuse_variables() self.fake_pool_rec_A = discriminator(self.fake_pool_A, "d_A") self.fake_pool_rec_B = discriminator(self.fake_pool_B, "d_B")
def model_setup(self): self.input_A = tf.placeholder( tf.float32, [batch_size, img_width, img_height, img_layer], name="input_A") self.input_B = tf.placeholder( tf.float32, [batch_size, img_width, img_height, img_layer], name="input_B") self.fake_pool_A = tf.placeholder( tf.float32, [None, img_width, img_height, img_layer], name="fake_pool_A") self.fake_pool_B = tf.placeholder( tf.float32, [None, img_width, img_height, img_layer], name="fake_pool_B") self.num_fake_inputs = 0 self.lr = tf.placeholder(tf.float32, shape=[], name="lr") with tf.variable_scope("drugan") as scope: self.scope = scope self.fake_B = generator(self.input_A, name="g_A") self.fake_A = generator(self.input_B, name="g_B") self.rec_A = discriminator(self.input_A, "d_A") self.rec_B = discriminator(self.input_B, "d_B") scope.reuse_variables() self.fake_rec_A = discriminator(self.fake_A, "d_A") self.fake_rec_B = discriminator(self.fake_B, "d_B") self.cyc_A = generator(self.fake_B, "g_B") self.cyc_B = generator(self.fake_A, "g_A") scope.reuse_variables() self.fake_pool_rec_A = discriminator(self.fake_pool_A, "d_A") self.fake_pool_rec_B = discriminator(self.fake_pool_B, "d_B")
isTraining = tf.placeholder(dtype=tf.bool) batch_size = 9 learning_rate = 1e-4 epochs = 10 model = 'new_model' ndims = 128,128 train_images = np.load('./data/train.npy',mmap_mode='r')[:10000] highres = tf.placeholder(tf.float32, shape=(None, 128, 128, 3)) lowres = tf.placeholder(tf.float32, shape=(None, 64, 64, 3)) #create Networks g=generator(lowres,ndims,is_training=isTraining) d_real = discriminator(highres, is_training = isTraining) d_fake = discriminator(g, is_training = isTraining ,reuse = True) #compute Loss d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_real, labels=tf.ones_like(d_real))) d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake, labels=tf.zeros_like(d_fake))) d_loss = d_loss_real + d_loss_fake g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake, labels=tf.ones_like(d_fake))) * 0.1 + tf.reduce_mean(tf.abs(tf.subtract(g, highres))) #Variables d_training_vars = [v for v in tf.trainable_variables() if v.name.startswith('discriminator')] g_training_vars = [v for v in tf.trainable_variables() if v.name.startswith('generator')] #optimizer update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops):
def run_uda_training(log_dir, images_sd_tr, labels_sd_tr, images_sd_vl, labels_sd_vl, images_td_tr, images_td_vl): # ================================================================ # reset the graph built so far and build a new TF graph # ================================================================ tf.reset_default_graph() with tf.Graph().as_default(): # ============================ # set random seed for reproducibility # ============================ tf.random.set_random_seed(exp_config.run_num_uda) np.random.seed(exp_config.run_num_uda) # ================================================================ # create placeholders - segmentation net # ================================================================ images_sd_pl = tf.placeholder(tf.float32, shape=[exp_config.batch_size] + list(exp_config.image_size) + [1], name='images_sd') images_td_pl = tf.placeholder(tf.float32, shape=[exp_config.batch_size] + list(exp_config.image_size) + [1], name='images_td') labels_sd_pl = tf.placeholder(tf.uint8, shape=[exp_config.batch_size] + list(exp_config.image_size), name='labels_sd') training_pl = tf.placeholder(tf.bool, shape=[], name='training_or_testing') # ================================================================ # insert a normalization module in front of the segmentation network # ================================================================ images_sd_normalized, _ = model.normalize(images_sd_pl, exp_config, training_pl, scope_reuse=False) images_td_normalized, _ = model.normalize(images_td_pl, exp_config, training_pl, scope_reuse=True) # ================================================================ # get logit predictions from the segmentation network # ================================================================ predicted_seg_sd_logits, _, _ = model.predict_i2l(images_sd_normalized, exp_config, training_pl, scope_reuse=False) # ================================================================ # get all features from the segmentation network # ================================================================ seg_features_sd = model.get_all_features(images_sd_normalized, exp_config, scope_reuse=True) seg_features_td = model.get_all_features(images_td_normalized, exp_config, scope_reuse=True) # ================================================================ # resize all features to the same size # ================================================================ images_sd_features_resized = model.resize_features( [images_sd_normalized] + list(seg_features_sd), (64, 64), 'resize_sd_xfeat') images_td_features_resized = model.resize_features( [images_td_normalized] + list(seg_features_td), (64, 64), 'resize_td_xfeat') # ================================================================ # discriminator on features # ================================================================ d_logits_sd = model.discriminator(images_sd_features_resized, exp_config, training_pl, scope_name='discriminator', scope_reuse=False) d_logits_td = model.discriminator(images_td_features_resized, exp_config, training_pl, scope_name='discriminator', scope_reuse=True) # ================================================================ # add ops for calculation of the discriminator loss # ================================================================ d_loss_sd = tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.ones_like(d_logits_sd), logits=d_logits_sd) d_loss_td = tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.zeros_like(d_logits_td), logits=d_logits_td) loss_d_op = tf.reduce_mean(d_loss_sd + d_loss_td) tf.summary.scalar('tr_losses/loss_discriminator', loss_d_op) # ================================================================ # add ops for calculation of the adversarial loss that tries to get domain invariant features in the normalized image space # ================================================================ loss_g_op = model.loss_invariance(d_logits_td) tf.summary.scalar('tr_losses/loss_invariant_features', loss_g_op) # ================================================================ # add ops for calculation of the supervised segmentation loss # ================================================================ loss_seg_op = model.loss(predicted_seg_sd_logits, labels_sd_pl, nlabels=exp_config.nlabels, loss_type=exp_config.loss_type_i2l) tf.summary.scalar('tr_losses/loss_segmentation', loss_seg_op) # ================================================================ # total training loss for uda # ================================================================ loss_total_op = loss_seg_op + exp_config.lambda_uda * loss_g_op tf.summary.scalar('tr_losses/loss_total_uda', loss_total_op) # ================================================================ # merge all summaries # ================================================================ summary_scalars = tf.summary.merge_all() # ================================================================ # divide the vars into segmentation network, normalization network and the discriminator network # ================================================================ i2l_vars = [] normalization_vars = [] discriminator_vars = [] for v in tf.global_variables(): var_name = v.name if 'image_normalizer' in var_name: normalization_vars.append(v) i2l_vars.append( v ) # the normalization vars also need to be restored from the pre-trained i2l mapper elif 'i2l_mapper' in var_name: i2l_vars.append(v) elif 'discriminator' in var_name: discriminator_vars.append(v) # ================================================================ # add optimization ops # ================================================================ train_i2l_op = model.training_step( loss_total_op, i2l_vars, exp_config.optimizer_handle, learning_rate=exp_config.learning_rate) train_discriminator_op = model.training_step( loss_d_op, discriminator_vars, exp_config.optimizer_handle, learning_rate=exp_config.learning_rate) # ================================================================ # add ops for model evaluation # ================================================================ eval_loss = model.evaluation_i2l_uda_invariant_features( predicted_seg_sd_logits, labels_sd_pl, images_sd_pl, d_logits_td, nlabels=exp_config.nlabels, loss_type=exp_config.loss_type_i2l) # ================================================================ # add ops for adding image summary to tensorboard # ================================================================ summary_images = model.write_image_summary_uda_invariant_features( predicted_seg_sd_logits, labels_sd_pl, images_sd_pl, exp_config.nlabels) # ================================================================ # build the summary Tensor based on the TF collection of Summaries. # ================================================================ if exp_config.debug: print('creating summary op...') # ================================================================ # add init ops # ================================================================ init_ops = tf.global_variables_initializer() # ================================================================ # find if any vars are uninitialized # ================================================================ if exp_config.debug: logging.info( 'Adding the op to get a list of initialized variables...') uninit_vars = tf.report_uninitialized_variables() # ================================================================ # create session # ================================================================ sess = tf.Session() # ================================================================ # create a file writer object # This writes Summary protocol buffers to event files. # https://github.com/tensorflow/docs/blob/r1.12/site/en/api_docs/python/tf/summary/FileWriter.md # The FileWriter class provides a mechanism to create an event file in a given directory and add summaries and events to it. # The class updates the file contents asynchronously. # This allows a training program to call methods to add data to the file directly from the training loop, without slowing down training. # ================================================================ summary_writer = tf.summary.FileWriter(log_dir, sess.graph) # ================================================================ # create savers # ================================================================ saver = tf.train.Saver(var_list=i2l_vars) saver_lowest_loss = tf.train.Saver(var_list=i2l_vars, max_to_keep=3) # ================================================================ # summaries of the validation errors # ================================================================ vl_error_seg = tf.placeholder(tf.float32, shape=[], name='vl_error_seg') vl_error_seg_summary = tf.summary.scalar('validation/loss_seg', vl_error_seg) vl_dice = tf.placeholder(tf.float32, shape=[], name='vl_dice') vl_dice_summary = tf.summary.scalar('validation/dice', vl_dice) vl_error_invariance = tf.placeholder(tf.float32, shape=[], name='vl_error_invariance') vl_error_invariance_summary = tf.summary.scalar( 'validation/loss_invariance', vl_error_invariance) vl_error_total = tf.placeholder(tf.float32, shape=[], name='vl_error_total') vl_error_total_summary = tf.summary.scalar('validation/loss_total', vl_error_total) vl_summary = tf.summary.merge([ vl_error_seg_summary, vl_dice_summary, vl_error_invariance_summary, vl_error_total_summary ]) # ================================================================ # summaries of the training errors # ================================================================ tr_error_seg = tf.placeholder(tf.float32, shape=[], name='tr_error_seg') tr_error_seg_summary = tf.summary.scalar('training/loss_seg', tr_error_seg) tr_dice = tf.placeholder(tf.float32, shape=[], name='tr_dice') tr_dice_summary = tf.summary.scalar('training/dice', tr_dice) tr_error_invariance = tf.placeholder(tf.float32, shape=[], name='tr_error_invariance') tr_error_invariance_summary = tf.summary.scalar( 'training/loss_invariance', tr_error_invariance) tr_error_total = tf.placeholder(tf.float32, shape=[], name='tr_error_total') tr_error_total_summary = tf.summary.scalar('training/loss_total', tr_error_total) tr_summary = tf.summary.merge([ tr_error_seg_summary, tr_dice_summary, tr_error_invariance_summary, tr_error_total_summary ]) # ================================================================ # freeze the graph before execution # ================================================================ if exp_config.debug: logging.info( '============================================================') logging.info('Freezing the graph now!') tf.get_default_graph().finalize() # ================================================================ # Run the Op to initialize the variables. # ================================================================ if exp_config.debug: logging.info( '============================================================') logging.info('initializing all variables...') sess.run(init_ops) # ================================================================ # print names of uninitialized variables # ================================================================ uninit_variables = sess.run(uninit_vars) if exp_config.debug: logging.info( '============================================================') logging.info('This is the list of uninitialized variables:') for v in uninit_variables: print(v) # ================================================================ # Restore the segmentation network parameters and the pre-trained i2i mapper parameters # ================================================================ if exp_config.train_from_scratch is False: logging.info( '============================================================') path_to_model = sys_config.log_root + exp_config.expname_i2l + '/models/' checkpoint_path = utils.get_latest_model_checkpoint_path( path_to_model, 'best_dice.ckpt') logging.info('Restoring the trained parameters from %s...' % checkpoint_path) saver_lowest_loss.restore(sess, checkpoint_path) # ================================================================ # run training steps # ================================================================ step = 0 lowest_loss = 10000.0 validation_total_loss_list = [] while (step < exp_config.max_steps): # ================================================ # batches # ================================================ for batch in iterate_minibatches(images_sd=images_sd_tr, labels_sd=labels_sd_tr, images_td=images_td_tr, batch_size=exp_config.batch_size): x_sd, y_sd, x_td = batch # =========================== # define feed dict for this iteration # =========================== feed_dict = { images_sd_pl: x_sd, labels_sd_pl: y_sd, images_td_pl: x_td, training_pl: True } # ================================================ # update i2l and D successively # ================================================ sess.run(train_i2l_op, feed_dict=feed_dict) sess.run(train_discriminator_op, feed_dict=feed_dict) # =========================== # write the summaries and print an overview fairly often # =========================== if (step + 1) % exp_config.summary_writing_frequency == 0: logging.info( '============== Updating summary at step %d ' % step) summary_writer.add_summary( sess.run(summary_scalars, feed_dict=feed_dict), step) summary_writer.flush() # =========================== # Compute the loss on the entire training set # =========================== if step % exp_config.train_eval_frequency == 0: logging.info('============== Training Data Eval:') train_loss_seg, train_dice, train_loss_invariance = do_eval( sess, eval_loss, images_sd_pl, labels_sd_pl, images_td_pl, training_pl, images_sd_tr, labels_sd_tr, images_td_tr, exp_config.batch_size) # total training loss train_total_loss = train_loss_seg + exp_config.lambda_uda * train_loss_invariance # =========================== # update tensorboard summary of scalars # =========================== tr_summary_msg = sess.run(tr_summary, feed_dict={ tr_error_seg: train_loss_seg, tr_dice: train_dice, tr_error_invariance: train_loss_invariance, tr_error_total: train_total_loss }) summary_writer.add_summary(tr_summary_msg, step) # =========================== # Save a checkpoint periodically # =========================== if step % exp_config.save_frequency == 0: logging.info( '============== Periodically saving checkpoint:') checkpoint_file = os.path.join(log_dir, 'models/model.ckpt') saver.save(sess, checkpoint_file, global_step=step) # =========================== # Evaluate the model periodically on a validation set # =========================== if step % exp_config.val_eval_frequency == 0: logging.info('============== Validation Data Eval:') val_loss_seg, val_dice, val_loss_invariance = do_eval( sess, eval_loss, images_sd_pl, labels_sd_pl, images_td_pl, training_pl, images_sd_vl, labels_sd_vl, images_td_vl, exp_config.batch_size) # total val loss val_total_loss = val_loss_seg + exp_config.lambda_uda * val_loss_invariance validation_total_loss_list.append(val_total_loss) # =========================== # update tensorboard summary of scalars # =========================== vl_summary_msg = sess.run(vl_summary, feed_dict={ vl_error_seg: val_loss_seg, vl_dice: val_dice, vl_error_invariance: val_loss_invariance, vl_error_total: val_total_loss }) summary_writer.add_summary(vl_summary_msg, step) # =========================== # update tensorboard summary of images # =========================== summary_writer.add_summary( sess.run(summary_images, feed_dict={ images_sd_pl: x_sd, labels_sd_pl: y_sd, training_pl: False }), step) summary_writer.flush() # =========================== # save model if the val dice is the best yet # =========================== window_length = 5 if len(validation_total_loss_list) < window_length + 1: expo_moving_avg_loss_value = validation_total_loss_list[ -1] else: expo_moving_avg_loss_value = utils.exponential_moving_average( validation_total_loss_list, window=window_length)[-1] if expo_moving_avg_loss_value < lowest_loss: lowest_loss = val_total_loss lowest_loss_file = os.path.join( log_dir, 'models/lowest_loss.ckpt') saver_lowest_loss.save(sess, lowest_loss_file, global_step=step) logging.info( '******* SAVED MODEL at NEW BEST AVERAGE LOSS on VALIDATION SET at step %d ********' % step) # ================================================ # increment step # ================================================ step += 1 # ================================================================ # close tf session # ================================================================ sess.close() return 0
def main(trainSet,userCount,itemCount,testSet,GroundTruth,trainVector,testMaskVector,batchCount,epochCount,pro_zp): X=[] #画图数据的保存 precisionList=[] G=model.generator(itemCount) D=model.discriminator(itemCount) G = G.cuda() D = D.cuda() criterion1 = nn.BCELoss() # 二分类的交叉熵 criterion2 = nn.MSELoss() d_optimizer = torch.optim.Adam(D.parameters(), lr=0.0001) g_optimizer = torch.optim.Adam(G.parameters(), lr=0.0001) G_step=2 D_step=2 batchSize_G = 32 batchSize_D = 32 realLabel_G = Variable(torch.ones(batchSize_G)).cuda() fakeLabel_G = Variable(torch.zeros(batchSize_G)).cuda() realLabel_D = Variable(torch.ones(batchSize_D)).cuda() fakeLabel_D = Variable(torch.zeros(batchSize_D)).cuda() ZR = [] PM = [] for epoch in range(epochCount): #训练epochCount次 if(epoch%100==0): ZR = [] PM = [] for i in range(userCount): ZR.append([]) PM.append([]) ZR[i].append(np.random.choice(itemCount,pro_zp,replace=False)) PM[i].append(np.random.choice(itemCount,pro_zp,replace=False)) for step in range(D_step):#训练D #maskVector1是PM方法的体现 这里要进行优化 减少程序消耗的内存 leftIndex=random.randint(1,userCount-batchSize_D-1) realData=Variable(trainVector[leftIndex:leftIndex+batchSize_D]).cuda() #MD个数据成为待训练数据 maskVector1 = Variable(trainVector[leftIndex:leftIndex+batchSize_D]).cuda() for i in range(len(maskVector1)): maskVector1[i][PM[leftIndex+i]]=1 Condition=realData#把用户反馈数据作为他的特征 后期还要加入用户年龄、性别等信息 realData_result=D(realData,Condition) d_loss_real=criterion1(realData_result,realLabel_D) fakeData=G(realData) fakeData=fakeData*maskVector1 fakeData_result=D(fakeData,realData) d_loss_fake=criterion1(fakeData_result,fakeLabel_D) d_loss=d_loss_real+d_loss_fake d_optimizer.zero_grad() d_loss.backward() d_optimizer.step() for step in range(G_step):#训练G0 #调整maskVector2\3 leftIndex = random.randint(1, userCount - batchSize_G - 1) realData = Variable(trainVector[leftIndex:leftIndex + batchSize_G]).cuda() maskVector2 = Variable(trainVector[leftIndex:leftIndex + batchSize_G]).cuda() maskVector3 = Variable(trainVector[leftIndex:leftIndex + batchSize_G]).cuda() for i in range(len(maskVector2)): maskVector2[i][PM[i+leftIndex]] = 1 maskVector3[i][ZR[i+leftIndex]] = 1 fakeData=G(realData) fakeData=fakeData*maskVector2 g_fakeData_result=D(fakeData,realData) g_loss=criterion1(g_fakeData_result,realLabel_G)+0.03*criterion2(fakeData,maskVector3) g_optimizer.zero_grad() g_loss.backward() g_optimizer.step() if( epoch%10==0): hit=0 peopleAmount=len(GroundTruth) recommendAmount=10 index=0 for testUser in testSet.keys(): data = Variable(trainVector[testUser]).cuda() result = G(data) + Variable(testMaskVector[index]).cuda() index+=1 hit = hit + evaluation.computeTopNAccuracy(testSet[testUser], result, recommendAmount) precision=hit/(peopleAmount*recommendAmount) precisionList.append(precision) X.append(epoch) print('Epoch[{}/{}],d_loss:{:.6f},g_loss:{:.6f},precision:{}'.format(epoch, epochCount, d_loss.item(), g_loss.item(), hit/(peopleAmount*recommendAmount))) paint(X,precisionList) return precisionList
(te_data, te_label)).batch(opt.BATCH_SIZE) """ Model. """ '''create classifier''' classifier = classifier() optim = keras.optimizers.Adam(lr=opt.LR, decay=opt.DECAY) classifier.build(input_shape=(opt.BATCH_SIZE, opt.WINDOW_SIZE, opt.WINDOW_SIZE, opt.CHANNEL, 1)) classifier.summary() '''create feature generator & feature discriminator''' fea_g = generator() fea_g.build(input_shape=(opt.BATCH_SIZE, opt.DIM_Z)) fea_g.summary() fea_d = discriminator() fea_d.build(input_shape=(opt.BATCH_SIZE, 17 * 17 * 64)) fea_d.summary() d_loss, g_loss = dcgan_loss() fea_g_optim = keras.optimizers.Adam(learning_rate=opt.GAN_LR, beta_1=0.5) fea_d_optim = keras.optimizers.Adam(learning_rate=opt.GAN_LR, beta_1=0.5) """ Test Function. """ def test_func(te_data, te_label): print("Start testing using test data!") _, te_pred = classifier.predict(te_data) te_label = tf.argmax(te_label, axis=1)
def train(): ###==========LOAD DATA==========### train_img_list = sorted( tl.files.load_file_list(path=DATAPATH, regx='.*.jpg', printable=False)) train_imgs = tl.vis.read_images(train_img_list, path=DATAPATH, n_threads=16) ###==========MODEL DEFINIATION==========### z_input = tf.placeholder('float32', [batch_size, z_dim], name='Input_noise') image_groundTruth = tf.placeholder( 'float32', [batch_size, input_crop_size, input_crop_size, 3], name='GroundTruth_Image') net_g = generator(z_input, input_crop_size, is_train=True, reuse=False) net_d, logits_real = discriminator(image_groundTruth, is_train=True, reuse=False) _, logits_fake = discriminator(net_g.outputs, is_train=True, reuse=True) # Normal GAN # d_loss1 = tl.cost.sigmoid_cross_entropy(logits_real, tf.ones_like(logits_real), name='d1') # d_loss2 = tl.cost.sigmoid_cross_entropy(logits_fake, tf.zeros_like(logits_fake), name='d2') # d_loss = d_loss1 + d_loss2 # Wasserstein GAN d_loss_real = -tf.reduce_mean(logits_real) d_loss_fake = tf.reduce_mean(logits_fake) d_loss = d_loss_real + d_loss_fake em_estimate = -d_loss # g_loss = tl.cost.sigmoid_cross_entropy(logits_fake, tf.ones_like(logits_fake), name='g') g_loss = -d_loss_fake """ Gradient Penalty """ # This is borrowed from https://github.com/kodalinaveen3/DRAGAN/blob/master/DRAGAN.ipynb alpha = tf.random_uniform(shape=[batch_size, 1, 1, 1], minval=0., maxval=1.) differences = net_g.outputs - image_groundTruth # This is different from MAGAN interpolates = image_groundTruth + (alpha * differences) # _, logits_inter = discriminator_deep(interpolates, is_train = True, reuse = True) _, logits_inter = discriminator(interpolates, is_train=True, reuse=True) gradients = tf.gradients(logits_inter, [interpolates])[0] slopes = tf.sqrt( tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2, 3])) gradient_penalty = tf.reduce_mean((slopes - 1.)**2) d_loss += GP_lambd * gradient_penalty g_vars = tl.layers.get_variables_with_name('Generator', True, True) d_vars = tl.layers.get_variables_with_name('Discriminator', True, True) with tf.variable_scope('learning_rate'): lr_v = tf.Variable(lr_init, trainable=False) g_optim = tf.train.AdamOptimizer(lr_v, beta1=beta1, beta2=beta2).minimize(g_loss, var_list=g_vars) d_optim = tf.train.AdamOptimizer(lr_v, beta1=beta1, beta2=beta2).minimize(d_loss, var_list=d_vars) net_g_test = generator(z_input, input_crop_size, is_train=False, reuse=True) ###========== ==========### sess = tf.Session() tl.layers.initialize_global_variables(sess) sess.run(tf.assign(lr_v, lr_init)) ###========== Initialize ==========### ###========== Training ==========### iter = 0 step_time = 0 for epoch in range(0, nb_epochs): epoch_time = time.time() total_d_loss, total_g_loss, n_iter = 0, 0, 0 errD, EMDist = 0, 0 errG = 0 for idx in range(0, len(train_imgs), batch_size): #Throw the batch away! if (len(train_imgs) - idx < batch_size): break iter += 1 errD, EMDist, errG = 0, 0, 0 step_time = time.time() batch_z = np.random.uniform(-1, 1, [batch_size, z_dim]).astype(np.float32) batch_imgs = tl.prepro.threading_data(train_imgs[idx:idx + batch_size], fn=crop_sub_imgs_fn) # batch_imgs = tl.prepro.threading_data(train_imgs[idx:idx + batch_size], fn=check_imgs_resize) if (iter == 1): tl.vis.save_images( batch_imgs, [8, int(math.ceil(float(batch_size) / 8.0))], OUTPATH + '/Input_Sample.png') '''update D''' _errD, _EMDist, _ = sess.run([d_loss, em_estimate, d_optim], { z_input: batch_z, image_groundTruth: batch_imgs }) # errD = errD + _errD / float(d_iters) # EMDist = EMDist + _EMDist / float(d_iters) errD += _errD EMDist += _EMDist print("D", end='') sys.stdout.flush() if (iter % d_iters == 0): '''update G''' _errG, _ = sess.run([g_loss, g_optim], { z_input: batch_z, image_groundTruth: batch_imgs }) # errG = errG + _errG / float(g_iters) errG += _errG print("G", end='') sys.stdout.flush() print( "\tEpoch [%2d/%2d] %4d time: %4.4fs, d_loss: %.8f g_loss: %.8f em_estimate: %.8f" % (epoch, nb_epochs, n_iter, time.time() - step_time, errD, errG, EMDist)) n_iter += 1 log = "\n[*] Epoch: [%2d/%2d] time: %4.4fs, d_loss: %.8f g_loss: %.8f\n" % ( epoch, nb_epochs, time.time() - epoch_time, total_d_loss / n_iter, total_g_loss / n_iter) print(log) ## generate sample images if (epoch != 0) and (epoch % epochs_saveImg == 0): batch_z = np.random.uniform(-1, 1, [batch_size, z_dim]).astype(np.float32) out = sess.run(net_g_test.outputs, {z_input: batch_z}) print(">>> Saving images...") tl.vis.save_images(out, [8, int(math.ceil(float(batch_size) / 8.0))], OUTPATH + '/train_%d.png' % epoch)
def train(noise_dim, gen_lr, disc_lr, batch_size, num_epochs, save_every, tensorboard_vis): """Trains the Deep Convolutional Generative Adversarial Network (DCGAN). See https://arxiv.org/abs/1511.06434 for more details. Args: optional arguments [python train.py --help] """ # Load Dataset. logging.info('loading LFW dataset into memory') X, IMAGE_SHAPE = load_dataset(dimx=36, dimy=36) tf.reset_default_graph() try: if not tf.test.is_gpu_available(cuda_only=True): raise Exception except Exception: logging.critical('CUDA capable GPU device not found.') exit(0) logging.warn('constructing graph on GPU') with tf.device('/gpu:0'): # Define placeholders for input data. noise = tf.placeholder('float32', [None, noise_dim]) real_data = tf.placeholder('float32', [ None, ] + list(IMAGE_SHAPE)) # Create Generator and Discriminator models. logging.debug('creating generator and discriminator') g_out = generator(noise, train=True) d_probs, d_fake_logits = discriminator(g_out, train=True) d_probs2, d_real_logits = discriminator(real_data, train=True) logging.debug('defining training ops') # Define Generator(G) ops. g_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=d_fake_logits, labels=tf.ones_like(d_fake_logits))) g_optimizer = tf.train.AdamOptimizer(learning_rate=gen_lr) g_vars = get_vars_by_scope('generator') g_train_step = g_optimizer.minimize(g_loss, var_list=g_vars) # Define Discriminator(D) ops. d_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=d_real_logits, labels=tf.ones_like(d_real_logits))) d_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=d_fake_logits, labels=tf.zeros_like(d_real_logits))) d_loss = d_loss_real + d_loss_fake d_optimizer = tf.train.AdamOptimizer(learning_rate=disc_lr) d_vars = get_vars_by_scope('discriminator') d_train_step = d_optimizer.minimize(d_loss, var_list=d_vars) with tf.Session() as sess: # Init vars. sess.run(tf.global_variables_initializer()) # Start training. logging.debug('training DCGAN model') for epoch in range(num_epochs): eval_noise = sample_noise_batch(16) idx = np.random.choice(range(X.shape[0]), size=16) eval_real_data = X[idx] for X_batch in tqdm(iterate_minibatches(X, batch_size, shuffle=True), total=X.shape[0] // batch_size, desc='Epoch[{}/{}]'.format( epoch + 1, num_epochs), leave=False): sess.run([d_train_step], feed_dict={ real_data: X_batch, noise: sample_noise_batch(batch_size) }) for _ in range(2): sess.run([g_train_step], feed_dict={noise: sample_noise_batch(batch_size)}) # Evaluating model after every epoch. d_loss_iter, g_loss_iter, eval_images = sess.run( [d_loss, g_loss, g_out], feed_dict={ real_data: eval_real_data, noise: eval_noise }) # Generate images using G and save in `out/`. tl.visualize.save_images(eval_images, [4, 4], 'out/eval_{}.png'.format(epoch + 1)) logging.info( 'Epoch[{}/{}] g_loss: {:.6f} - d_loss: {:.6f}'.format( epoch + 1, num_epochs, g_loss_iter, d_loss_iter))
def main(_): assert np.sqrt( FLAGS.sample_size ) % 1 == 0., 'Flag `sample_size` needs to be a perfect square' num_tiles = int(np.sqrt(FLAGS.sample_size)) # Print flags for flag, _ in FLAGS.__flags.items(): print('"{}": {}'.format(flag, getattr(FLAGS, flag))) print("--------------------") # Configure checkpoint/samples dir tl.files.exists_or_mkdir(FLAGS.checkpoint_dir) tl.files.exists_or_mkdir(FLAGS.sample_dir) z_dim = 100 # noise dim # Construct graph on GPU with tf.device("/gpu:0"): """ Define Models """ z = tf.placeholder(tf.float32, [None, z_dim], name='z_noise') real_images = tf.placeholder( tf.float32, [None, FLAGS.output_size, FLAGS.output_size, FLAGS.c_dim], name='real_images') # Input noise into generator for training net_g = generator(z, is_train=True, reuse=False) # Input real and generated fake images into discriminator for training net_d, d_logits = discriminator(net_g.outputs, is_train=True, reuse=False) _, d2_logits = discriminator(real_images, is_train=True, reuse=True) # Input noise into generator for evaluation # set is_train to False so that BatchNormLayer behave differently net_g2 = generator(z, is_train=False, reuse=True) """ Define Training Operations """ # discriminator: real images are labelled as 1 d_loss_real = tl.cost.sigmoid_cross_entropy(d2_logits, tf.ones_like(d2_logits), name='dreal') # discriminator: images from generator (fake) are labelled as 0 d_loss_fake = tl.cost.sigmoid_cross_entropy(d_logits, tf.zeros_like(d_logits), name='dfake') # cost for updating discriminator d_loss = d_loss_real + d_loss_fake # generator: try to make the the fake images look real (1) g_loss = tl.cost.sigmoid_cross_entropy(d_logits, tf.ones_like(d_logits), name='gfake') g_vars = tl.layers.get_variables_with_name('generator', True, True) d_vars = tl.layers.get_variables_with_name('discriminator', True, True) # Define optimizers for updating discriminator and generator d_optim = tf.train.AdamOptimizer(FLAGS.learning_rate, beta1=FLAGS.beta1) \ .minimize(d_loss, var_list=d_vars) g_optim = tf.train.AdamOptimizer(FLAGS.learning_rate, beta1=FLAGS.beta1) \ .minimize(g_loss, var_list=g_vars) # Init Session sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) model_dir = "%s_%s_%s" % (FLAGS.dataset, FLAGS.batch_size, FLAGS.output_size) save_dir = os.path.join(FLAGS.checkpoint_dir, model_dir) tl.files.exists_or_mkdir(FLAGS.sample_dir) tl.files.exists_or_mkdir(save_dir) # load the latest checkpoints net_g_name = os.path.join(save_dir, 'net_g.npz') net_d_name = os.path.join(save_dir, 'net_d.npz') data_files = np.array(glob(os.path.join("./data", FLAGS.dataset, "*.jpg"))) num_files = len(data_files) # Mini-batch generator def iterate_minibatches(batch_size, shuffle=True): if shuffle: indices = np.random.permutation(num_files) for start_idx in range(0, num_files - batch_size + 1, batch_size): if shuffle: excerpt = indices[start_idx:start_idx + batch_size] else: excerpt = slice(start_idx, start_idx + batch_size) # Get real images (more image augmentation functions at [http://tensorlayer.readthedocs.io/en/latest/modules/prepro.html]) yield np.array([ get_image(file, FLAGS.image_size, is_crop=FLAGS.is_crop, resize_w=FLAGS.output_size, is_grayscale=0) for file in data_files[excerpt] ]).astype(np.float32) batch_steps = min(num_files, FLAGS.train_size) // FLAGS.batch_size # sample noise sample_seed = np.random.normal(loc=0.0, scale=1.0, size=(FLAGS.sample_size, z_dim)).astype(np.float32) """ Training models """ iter_counter = 0 for epoch in range(FLAGS.epoch): sample_images = next(iterate_minibatches(FLAGS.sample_size)) print("[*] Sample images updated!") steps = 0 for batch_images in iterate_minibatches(FLAGS.batch_size): batch_z = np.random.normal(loc=0.0, scale=1.0, size=(FLAGS.batch_size, z_dim)).astype(np.float32) start_time = time.time() # Updates the Discriminator(D) errD, _ = sess.run([d_loss, d_optim], feed_dict={ z: batch_z, real_images: batch_images }) # Updates the Generator(G) # run generator twice to make sure that d_loss does not go to zero (different from paper) for _ in range(2): errG, _ = sess.run([g_loss, g_optim], feed_dict={z: batch_z}) end_time = time.time() - start_time print("Epoch: [%2d/%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (epoch, FLAGS.epoch, steps, batch_steps, end_time, errD, errG)) iter_counter += 1 if np.mod(iter_counter, FLAGS.sample_step) == 0: # Generate images img, errD, errG = sess.run([net_g2.outputs, d_loss, g_loss], feed_dict={ z: sample_seed, real_images: sample_images }) # Visualize generated images tl.visualize.save_images( img, [num_tiles, num_tiles], './{}/train_{:02d}_{:04d}.png'.format( FLAGS.sample_dir, epoch, steps)) print("[Sample] d_loss: %.8f, g_loss: %.8f" % (errD, errG)) if np.mod(iter_counter, FLAGS.save_step) == 0: # Save current network parameters print("[*] Saving checkpoints...") tl.files.save_npz(net_g.all_params, name=net_g_name, sess=sess) tl.files.save_npz(net_d.all_params, name=net_d_name, sess=sess) print("[*] Saving checkpoints SUCCESS!") steps += 1 sess.close()
os.mkdir(data_dir) trainset = datasets.FashionMNIST(data_dir, download=True, train=True, transform=transform) trainset = datasets.FashionMNIST(data_dir, download=False, train=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True) G = generator(args) D = discriminator(args) criterion = torch.nn.BCELoss() d_optimizer = torch.optim.Adam(D.parameters(), lr=args.d_lr, betas=(args.beta, args.beta1)) g_optimizer = torch.optim.Adam(G.parameters(), lr=args.d_lr, betas=(args.beta, args.beta1)) for i in range(epochs): for idx, data in enumerate(trainloader): x = data[0].to(device) y = data[1].to(device)
def build_gan(self): # set if generator is going to use spectral norm image, pc, elev, azim = self.train_source.next_batch() elev_code = Input(shape=(1, ), name='elev_code') azim_code = Input(shape=(1, ), name='azim_code') pc_code = Input(shape=(self.pc_code_dim, ), name='pc_code') noise_code = Input(shape=(self.noise_dim, ), name='noise_code') model_name = "pc2pix" image_size = image.shape[1] if self.color: input_shape = (image_size, image_size, 3) else: input_shape = (image_size, image_size, 1) inputs = Input(shape=input_shape, name='image_input') if self.gen_spectral_normalization: optimizer = Adam(lr=4e-4, beta_1=0.0, beta_2=0.9) else: optimizer = Adam(lr=2e-4, beta_1=0.5, beta_2=0.999) # build discriminator # by default, discriminator uses SN if self.gpus <= 1: self.discriminator = model.discriminator( input_shape, pc_code_dim=self.pc_code_dim) if self.dw is not None: print("loading discriminator weights: ", self.dw) self.discriminator.load_weights(self.dw) self.discriminator_single = self.discriminator else: with tf.device("/cpu:0"): self.discriminator_single = model.discriminator( input_shape, pc_code_dim=self.pc_code_dim) if self.dw is not None: print("loading discriminator weights: ", self.dw) self.discriminator_single.load_weights(self.dw) self.discriminator = multi_gpu_model(self.discriminator_single, gpus=self.gpus) loss = ['binary_crossentropy', 'mae', self.elev_loss, self.azim_loss] loss_weights = [1., 10., 10., 10.] self.discriminator.compile(loss=loss, loss_weights=loss_weights, optimizer=optimizer) self.discriminator_single.summary() path = os.path.join(self.model_dir, "discriminator.png") plot_model(self.discriminator_single, to_file=path, show_shapes=True) # build generator # try SN to see if mode collapse is avoided if self.gpus <= 1: self.generator = model.generator( input_shape, noise_code=noise_code, pc_code=pc_code, elev_code=elev_code, azim_code=azim_code, spectral_normalization=self.gen_spectral_normalization, color=self.color) if self.gw is not None: print("loading generator weights: ", self.gw) self.generator.load_weights(self.gw) self.generator_single = self.generator else: with tf.device("/cpu:0"): self.generator_single = model.generator( input_shape, noise_code=noise_code, pc_code=pc_code, elev_code=elev_code, azim_code=azim_code, spectral_normalization=self.gen_spectral_normalization, color=self.color) if self.gw is not None: print("loading generator weights: ", self.gw) self.generator_single.load_weights(self.gw) self.generator = multi_gpu_model(self.generator_single, gpus=self.gpus) self.generator_single.summary() path = os.path.join(self.model_dir, "generator.png") plot_model(self.generator_single, to_file=path, show_shapes=True) self.discriminator.trainable = False if self.gen_spectral_normalization: optimizer = Adam(lr=1e-4, beta_1=0.0, beta_2=0.9) else: optimizer = Adam(lr=1e-4, beta_1=0.5, beta_2=0.999) if self.gpus <= 1: self.adversarial = Model( [noise_code, pc_code, elev_code, azim_code], self.discriminator( self.generator([noise_code, pc_code, elev_code, azim_code])), name=model_name) self.adversarial_single = self.adversarial else: with tf.device("/cpu:0"): self.adversarial_single = Model( [noise_code, pc_code, elev_code, azim_code], self.discriminator( self.generator( [noise_code, pc_code, elev_code, azim_code])), name=model_name) self.adversarial = multi_gpu_model(self.adversarial_single, gpus=self.gpus) self.adversarial.compile(loss=loss, loss_weights=loss_weights, optimizer=optimizer) self.adversarial_single.summary() path = os.path.join(self.model_dir, "adversarial.png") plot_model(self.adversarial_single, to_file=path, show_shapes=True) print("Using split file: ", self.split_file) print("1 epoch datalen: ", self.epoch_datalen) print("1 epoch train steps: ", self.train_steps) print("Using pc codes: ", self.pc_codes_filename)
def train(z_dim=None, model_name=None): """ Used to train the autoencoder by passing in the necessary inputs. :param train_model: True -> Train the model, False -> Load the latest trained model and show the image grid. :return: does not return anything """ X_train, y_train = datasets.create_datasets(retrain=0, task="aae_wgan_" + str(z_dim), num_aug=0) batch_size = BATCH_SIZE input_dim = X_train.shape[-1] with tf.device("/gpu:0"): sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) x_input = tf.placeholder(dtype=tf.float32, shape=[batch_size, input_dim, input_dim, 1], name='Input') x_target = tf.placeholder(dtype=tf.float32, shape=[batch_size, input_dim, input_dim, 1], name='Target') real_distribution = tf.placeholder(dtype=tf.float32, shape=[batch_size, z_dim], name='Real_distribution') decoder_input = tf.placeholder(dtype=tf.float32, shape=[1, z_dim], name='Decoder_input') encoder_output = encoder(x_input, reuse=False, is_train=True) encoder_output_test = encoder(x_input, reuse=True, is_train=False) d_fake, d_fake_logits = discriminator(encoder_output, reuse=False) d_real, d_real_logits = discriminator(real_distribution, reuse=True) d_fake_test, d_fake_logits_test = discriminator(encoder_output, reuse=True) d_real_test, d_real_logits_test = discriminator(real_distribution, reuse=True) decoder_output, std = decoder(encoder_output, reuse=False, is_train=True) encoder_output_z = encoder(decoder_output, reuse=True, is_train=False) decoder_output_test, std_ = decoder(encoder_output, reuse=True, is_train=False) encoder_output_z_test = encoder(decoder_output_test, reuse=True, is_train=False) #decoder_image = decoder(decoder_input, reuse=True, is_train=False) # Autoencoder loss # summed = tf.reduce_mean(tf.square(decoder_output-x_target),[1,2,3]) summed = tf.reduce_sum(tf.square(decoder_output - x_target), [1, 2, 3]) # sqrt_summed = summed sqrt_summed = tf.sqrt(summed + 1e-8) autoencoder_loss = tf.reduce_mean(sqrt_summed) summed_test = tf.reduce_sum(tf.square(decoder_output_test - x_target), [1, 2, 3]) # sqrt_summed_test = summed_test sqrt_summed_test = tf.sqrt(summed_test + 1e-8) autoencoder_loss_test = tf.reduce_mean(sqrt_summed_test) # l2 loss of z enc = tf.reduce_sum(tf.square(encoder_output - encoder_output_z), [1]) encoder_l2loss = tf.reduce_mean(enc) enc_test = tf.reduce_sum( tf.square(encoder_output_test - encoder_output_z_test), [1]) encoder_l2loss_test = tf.reduce_mean(enc_test) dc_loss = tf.reduce_mean(d_real_logits - d_fake_logits) dc_loss_test = tf.reduce_mean(d_real_logits_test - d_fake_logits_test) with tf.name_scope("Gradient_penalty"): eta = tf.placeholder(tf.float32, shape=[batch_size, 1], name="Eta") interp = eta * real_distribution + (1 - eta) * encoder_output _, c_interp = discriminator(interp, reuse=True) # taking the zeroth and only element because tf.gradients returns a list c_grads = tf.gradients(c_interp, interp)[0] # L2 norm, reshaping to [batch_size] slopes = tf.sqrt(tf.reduce_sum(tf.square(c_grads), axis=[1])) tf.summary.histogram("Critic gradient L2 norm", slopes) grad_penalty = tf.reduce_mean((slopes - 1)**2) lambd = 10.0 dc_loss += lambd * grad_penalty # Generator loss # generator_loss = tf.reduce_mean( # tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(d_fake), logits=d_fake_logits)) generator_loss = tf.reduce_mean(d_fake_logits) generator_loss_test = tf.reduce_mean(d_fake_logits_test) all_variables = tf.trainable_variables() dc_var = tl.layers.get_variables_with_name('Discriminator', True, True) en_var = tl.layers.get_variables_with_name('Encoder', True, True) #print en_var # dc_var = [var for var in all_variables if 'dc' in var.name] # en_var = [var for var in all_variables if 'encoder' in var.name] var_grad_autoencoder = tf.gradients(autoencoder_loss, all_variables)[0] var_grad_discriminator = tf.gradients(dc_loss, dc_var)[0] var_grad_generator = tf.gradients(generator_loss, en_var)[0] # Optimizers with tf.device("/gpu:0"): autoencoderl2_optimizer = tf.train.AdamOptimizer( learning_rate=LR, beta1=0.5, beta2=0.9).minimize(autoencoder_loss + 0.5 * encoder_l2loss) autoencoder_optimizer = tf.train.AdamOptimizer( learning_rate=LR, beta1=0.5, beta2=0.9).minimize(autoencoder_loss) discriminator_optimizer = tf.train.AdamOptimizer( learning_rate=LR, beta1=0.5, beta2=0.9).minimize(dc_loss, var_list=dc_var) generator_optimizer = tf.train.AdamOptimizer(learning_rate=LR, beta1=0.5, beta2=0.9).minimize( generator_loss, var_list=en_var) tl.layers.initialize_global_variables(sess) # Reshape immages to display them input_images = tf.reshape(x_input, [-1, input_dim, input_dim, 1]) generated_images = tf.reshape(decoder_output, [-1, input_dim, input_dim, 1]) # generated_images = tf.reshape(decoder_output, [-1, 28, 28, 1]) tensorboard_path, saved_model_path, log_path, folder_name = form_results( ) # bp() writer = tf.summary.FileWriter(logdir=tensorboard_path, graph=sess.graph) # Tensorboard visualization tf.summary.scalar(name='Autoencoder Loss', tensor=autoencoder_loss) tf.summary.scalar(name='Autoencoder Test Loss', tensor=autoencoder_loss_test) tf.summary.scalar(name='Discriminator Loss', tensor=dc_loss) tf.summary.scalar(name='Generator Loss', tensor=generator_loss) tf.summary.scalar(name='Autoencoder z Loss', tensor=encoder_l2loss) tf.summary.histogram(name='Encoder Distribution', values=encoder_output) tf.summary.histogram(name='Real Distribution', values=real_distribution) tf.summary.histogram(name='Gradient AE', values=var_grad_autoencoder) tf.summary.histogram(name='Gradient D', values=var_grad_discriminator) tf.summary.histogram(name='Gradient G', values=var_grad_generator) tf.summary.image(name='Input Images', tensor=input_images, max_outputs=10) tf.summary.image(name='Generated Images', tensor=generated_images, max_outputs=10) summary_op = tf.summary.merge_all() saver = tf.train.Saver() # Saving the model step = 0 # with tf.Session() as sess: with open(log_path + '/log.txt', 'a') as log: log.write("input_dim: {}\n".format(input_dim)) log.write("z_dim: {}\n".format(z_dim)) log.write("batch_size: {}\n".format(batch_size)) log.write("\n") for i in range(EPOCHS): b = 0 for batch in tl.iterate.minibatches(inputs=X_train, targets=np.zeros(X_train.shape), batch_size=batch_size, shuffle=True): z_real_dist = np.random.normal(0, 1, (batch_size, z_dim)) * 1. z_real_dist = z_real_dist.astype("float32") batch_x, _ = batch batch_x = batch_x[:, :, :, np.newaxis] #lambda_x = np.max(lambda_grow_max / np.float(i), lambda_grow_max) sess.run(autoencoderl2_optimizer, feed_dict={ x_input: batch_x, x_target: batch_x }) if i < 20: # sess.run(autoencoder_optimizer, feed_dict={x_input: batch_x, x_target: batch_x}) for t in range(10): for _ in range(20): eta1 = np.random.rand( batch_size, 1) # sampling from uniform distribution eta1 = eta1.astype("float32") sess.run(discriminator_optimizer, feed_dict={ x_input: batch_x, x_target: batch_x, real_distribution: z_real_dist, eta: eta1 }) else: # sess.run(autoencoderl2_optimizer, feed_dict={x_input: batch_x, x_target: batch_x}) for _ in range(20): eta1 = np.random.rand( batch_size, 1) # sampling from uniform distribution eta1 = eta1.astype("float32") sess.run(discriminator_optimizer, feed_dict={ x_input: batch_x, x_target: batch_x, real_distribution: z_real_dist, eta: eta1 }) sess.run(generator_optimizer, feed_dict={ x_input: batch_x, x_target: batch_x }) if b % 50 == 0: a_loss, e_loss, d_loss, g_loss, a_grad, d_grad, g_grad, en_output, d_real_logits_, d_fake_logits_, de_output, summary = sess.run( [ autoencoder_loss, encoder_l2loss, dc_loss, generator_loss, var_grad_autoencoder, var_grad_discriminator, var_grad_generator, encoder_output, d_real_logits, d_fake_logits, decoder_output, summary_op ], feed_dict={ x_input: batch_x, x_target: batch_x, real_distribution: z_real_dist, eta: eta1 }) print(model_name) saver.save(sess, save_path=saved_model_path, global_step=step) writer.add_summary(summary, global_step=step) print("Epoch: {}, iteration: {}".format(i, b)) print("Autoencoder Loss: {}".format(a_loss)) print("Autoencoder enc Loss: {}".format(e_loss)) print("Discriminator Loss: {}".format(d_loss)) print("Generator Loss: {}".format(g_loss)) with open(log_path + '/log.txt', 'a') as log: log.write("Epoch: {}, iteration: {}\n".format(i, b)) log.write("Autoencoder Loss: {}\n".format(a_loss)) log.write("Autoencoder enc Loss: {}\n".format(e_loss)) log.write("Discriminator Loss: {}\n".format(d_loss)) log.write("Generator Loss: {}\n".format(g_loss)) b += 1 step += 1 b = 0 for batch in tl.iterate.minibatches(inputs=y_train, targets=np.zeros(y_train.shape), batch_size=batch_size, shuffle=True): z_real_dist = np.random.normal(0, 1, (batch_size, z_dim)) * 1. z_real_dist = z_real_dist.astype("float32") batch_x, _ = batch batch_x = batch_x[:, :, :, np.newaxis] eta1 = np.random.rand(batch_size, 1) if b % 20 == 0: a_loss, e_loss, d_loss, g_loss = sess.run( [ autoencoder_loss_test, encoder_l2loss_test, dc_loss_test, generator_loss_test ], feed_dict={ x_input: batch_x, x_target: batch_x, real_distribution: z_real_dist, eta: eta1 }) print("v_Epoch: {}, iteration: {}".format(i, b)) print("v_Autoencoder Loss: {}".format(a_loss)) print("v_Autoencoder enc Loss: {}".format(e_loss)) print("v_Discriminator Loss: {}".format(d_loss)) print("v_Generator Loss: {}".format(g_loss)) with open(log_path + '/log.txt', 'a') as log: log.write("v_Epoch: {}, iteration: {}\n".format(i, b)) log.write("v_Autoencoder Loss: {}\n".format(a_loss)) log.write("v_Autoencoder enc Loss: {}\n".format(e_loss)) log.write("v_Discriminator Loss: {}\n".format(d_loss)) log.write("v_Generator Loss: {}\n".format(g_loss))
with tf.device('/cpu:0'): images, labels = train_inputs(batch_size) images_test, labels_test = test_inputs(batch_size) with tf.variable_scope('placeholder'): X = tf.placeholder(tf.float32, [None, IMAGE_SIZE, IMAGE_SIZE, 3]) z = tf.placeholder(tf.float32, [None, 100]) # noise y = tf.placeholder(name='label', dtype=tf.float32, shape=[batch_size, 10]) keep_prob = tf.placeholder(tf.float32, shape=()) is_train = tf.placeholder(tf.bool, shape=()) with tf.variable_scope('GAN'): G = generator(z, keep_prob=keep_prob, is_train=is_train) D_real, D_real_logits, flat_features = discriminator(X, keep_prob=keep_prob, is_train=is_train, reuse=False) D_fake, D_fake_logits, flat_features = discriminator(G, keep_prob=keep_prob, is_train=is_train, reuse=True) with tf.variable_scope('D_loss'): real_label = tf.concat([0.89 * y, tf.zeros([batch_size, 1])], axis=1) real_label += 0.01 * tf.ones([batch_size, 11]) fake_label = tf.concat( [tf.zeros([batch_size, 10]), tf.ones([batch_size, 1])], axis=1) d_loss_real = tf.reduce_mean(