def __init__(self, model, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.sample_dir = args.sample_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type self.lr = args.lrC self.momentum = args.momentum self.log_interval = 100 self.size_epoch = args.size_epoch self.gan_type = args.gan_type self.generator = model self.conditional = args.conditional self.device = args.device self.tau = args.tau self.num_examples = args.num_examples self.TrainEval = args.TrainEval self.seed = args.seed if self.conditional: self.model_name = 'C' + self.model_name # Load the generator parameters if self.gan_type != "Classifier": if self.conditional: self.generator.load() else: self.generators = self.generator.load_generators() # Load dataset self.dataset_train, self.dataset_valid, self.list_class_train, self.list_class_valid = load_dataset_full( self.dataset, self.num_examples) self.dataset_test, self.list_class_test = load_dataset_test(self.dataset, self.batch_size) # create data loader self.train_loader = get_iter_dataset(self.dataset_train) self.valid_loader = get_iter_dataset(self.dataset_valid) self.test_loader = get_iter_dataset(self.dataset_test) if self.dataset == 'mnist': self.input_size = 1 self.size = 28 elif self.dataset == 'fashion-mnist': self.input_size = 1 self.size = 28 self.Classifier = Model_Classifier(self.dataset) if self.gpu_mode: self.Classifier = self.Classifier.cuda(self.device) self.optimizer = optim.Adam(self.Classifier.parameters(), lr=self.lr, betas=(args.beta1, args.beta2))
def __init__(self, args): # parameters self.args = args self.epoch_Review = args.epoch_Review self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.sample_dir = args.sample_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type self.data_dir = args.data_dir self.gen_dir = args.gen_dir self.verbose = args.verbose self.lr = args.lrC self.momentum = args.momentum self.log_interval = 100 self.sample_num = 100 self.size_epoch = args.size_epoch self.gan_type = args.gan_type self.conditional = args.conditional self.device = args.device self.trainEval = args.trainEval self.num_task = args.num_task self.task_type = args.task_type self.context = args.context self.seed = args.seed if self.conditional: self.model_name = 'C' + self.model_name # Load the generator parameters # The reviewer evaluate generate dataset (loader train) on true data (loader test) # not sur yet if valid should be real or not (it was before) dataset_train, dataset_valid, list_class_train, list_class_valid = load_dataset_full(self.data_dir, args.dataset) dataset_test, list_class_test = load_dataset_test(self.data_dir, args.dataset, args.batch_size) # create data loader for validation and testing self.valid_loader = get_iter_dataset(dataset_valid) self.test_loader = get_iter_dataset(dataset_test) if self.dataset == 'mnist': self.input_size = 1 self.size = 28 elif self.dataset == 'fashion': self.input_size = 1 self.size = 28 elif self.dataset == 'cifar10': self.input_size = 3 self.size = 32 if self.dataset == 'mnist': self.Classifier = Mnist_Classifier(args) elif self.dataset == 'fashion': self.Classifier = Fashion_Classifier(args) elif self.dataset == 'cifar10': self.Classifier = Cifar_Classifier(args) else: print('Not implemented')
def train(self): self.G.apply(self.G.weights_init) self.D.train() for classe in range(10): self.train_hist = {} self.train_hist['D_loss'] = [] self.train_hist['G_loss'] = [] self.train_hist['per_epoch_time'] = [] self.train_hist['total_time'] = [] # self.G.apply(self.G.weights_init) does not work for instance if self.gpu_mode: self.y_real_, self.y_fake_ = Variable( torch.ones(self.batch_size, 1).cuda()), Variable( torch.zeros(self.batch_size, 1).cuda()) else: self.y_real_, self.y_fake_ = Variable( torch.ones(self.batch_size, 1)), Variable(torch.zeros(self.batch_size, 1)) self.D.train() self.data_loader_train = get_iter_dataset(self.dataset_train, self.list_class_train, self.batch_size, classe) self.data_loader_valid = get_iter_dataset(self.dataset_valid, self.list_class_valid, self.batch_size, classe) print('training class : ' + str(classe)) start_time = time.time() for epoch in range(self.epoch): self.G.train() epoch_start_time = time.time() n_batch = 0. for iter, (x_, t_) in enumerate(self.data_loader_train): n_batch += 1 z_ = torch.rand((self.batch_size, self.z_dim)) if self.gpu_mode: x_, z_ = Variable(x_.cuda()), Variable(z_.cuda()) else: x_, z_ = Variable(x_), Variable(z_) # update D network self.D_optimizer.zero_grad() D_real = self.D(x_) D_real_err = torch.mean(torch.abs(D_real - x_)) G_ = self.G(z_) D_fake = self.D(G_) D_fake_err = torch.mean(torch.abs(D_fake - G_)) D_loss = D_real_err - self.k * D_fake_err self.train_hist['D_loss'].append(D_loss.data[0]) D_loss.backward() self.D_optimizer.step() # update G network self.G_optimizer.zero_grad() G_ = self.G(z_) D_fake = self.D(G_) D_fake_err = torch.mean(torch.abs(D_fake - G_)) G_loss = D_fake_err self.train_hist['G_loss'].append(G_loss.data[0]) G_loss.backward() self.G_optimizer.step() # convergence metric temp_M = D_real_err + torch.abs(self.gamma * D_real_err - D_fake_err) # operation for updating k temp_k = self.k + self.lambda_ * (self.gamma * D_real_err - D_fake_err) temp_k = temp_k.data[0] # self.k = temp_k.data[0] self.k = min(max(temp_k, 0), 1) self.M = temp_M.data[0] if ((iter + 1) % 100) == 0: print( "classe : [%1d] Epoch: [%2d] [%4d/%4d] D_loss: %.8f, G_loss: %.8f, M: %.8f, k: %.8f" % (classe, (epoch + 1), (iter + 1), self.size_epoch, D_loss.data[0], G_loss.data[0], self.M, self.k)) self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time) self.visualize_results((epoch + 1), classe) self.save_G(classe) result_dir = self.result_dir + '/' + 'classe-' + str(classe) utils.generate_animation(result_dir + '/' + self.model_name, epoch + 1) utils.loss_plot(self.train_hist, result_dir, self.model_name) np.savetxt( os.path.join(result_dir, 'began_training_' + self.dataset + '.txt'), np.transpose([self.train_hist['G_loss']])) self.train_hist['total_time'].append(time.time() - start_time) print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']), self.epoch, self.train_hist['total_time'][0])) print("Training finish!... save training results")
def train(self): self.size_epoch = 1000 if self.gpu_mode: self.y_real_, self.y_fake_ = Variable(torch.ones(self.batch_size, 1).cuda(self.device)), Variable( torch.zeros(self.batch_size, 1).cuda(self.device)) else: self.y_real_, self.y_fake_ = Variable(torch.ones(self.batch_size, 1)), Variable( torch.zeros(self.batch_size, 1)) self.G.apply(self.G.weights_init) self.D.train() print('training start!!') start_time = time.time() for classe in range(10): self.train_hist = {} self.train_hist['D_loss'] = [] self.train_hist['G_loss'] = [] self.train_hist['per_epoch_time'] = [] self.train_hist['total_time'] = [] #self.G.apply(self.G.weights_init) does not work for instance self.data_loader_train = get_iter_dataset(self.dataset_train, self.list_class_train, self.batch_size, classe) self.data_loader_valid = get_iter_dataset(self.dataset_valid, self.list_class_valid, self.batch_size, classe) for epoch in range(self.epoch): self.G.train() epoch_start_time = time.time() for iter, (x_, t_) in enumerate(self.data_loader_train): if x_.shape[0] != self.batch_size: break z_ = torch.rand((self.batch_size, self.z_dim)) if self.gpu_mode: x_, z_ = Variable(x_.cuda(self.device)), Variable(z_.cuda(self.device)) else: x_, z_ = Variable(x_), Variable(z_) # update D network self.D_optimizer.zero_grad() D_real = self.D(x_) D_real_loss = self.BCELoss(D_real, self.y_real_) G_ = self.G(z_) D_fake = self.D(G_) D_fake_loss = self.BCELoss(D_fake, self.y_fake_) D_loss = D_real_loss + D_fake_loss self.train_hist['D_loss'].append(D_loss.data[0]) D_loss.backward() self.D_optimizer.step() # update G network self.G_optimizer.zero_grad() G_ = self.G(z_) D_fake = self.D(G_) G_loss = self.BCELoss(D_fake, self.y_real_) self.train_hist['G_loss'].append(G_loss.data[0]) G_loss.backward() self.G_optimizer.step() if ((iter + 1) % 100) == 0: print("classe : [%1d] Epoch: [%2d] [%4d/%4d] D_loss: %.8f, G_loss: %.8f" % (classe, (epoch + 1), (iter + 1), len(self.data_loader_train), D_loss.data[0], G_loss.data[0])) self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time) self.visualize_results((epoch + 1), classe) self.save_G(classe) utils.generate_animation( self.result_dir + '/' + 'classe-' + str(classe) + '/' + self.model_name, self.epoch) utils.loss_plot(self.train_hist, self.save_dir,self.model_name) self.train_hist['total_time'].append(time.time() - start_time) print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']), self.epoch, self.train_hist['total_time'][0])) print("Training finish!... save training results") self.save()
def train(self): self.G.apply(self.G.weights_init) print(' training start!! (no conditional)') start_time = time.time() for classe in range(10): self.train_hist = {} self.train_hist['D_loss'] = [] self.train_hist['G_loss'] = [] self.train_hist['per_epoch_time'] = [] self.train_hist['total_time'] = [] # self.G.apply(self.G.weights_init) does not work for instance del self.E self.E = Encoder(self.z_dim, self.dataset, self.conditional) self.E_optimizer = optim.Adam( self.E.parameters(), lr=self.lr) #, lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.E.cuda(self.device) best = 100000 self.data_loader_train = get_iter_dataset(self.dataset_train, self.list_class_train, self.batch_size, classe) self.data_loader_valid = get_iter_dataset(self.dataset_valid, self.list_class_valid, self.batch_size, classe) early_stop = 0. for epoch in range(self.epoch): epoch_start_time = time.time() # print("number of batch data") # print(len(self.data_loader_train)) self.E.train() self.G.train() sum_loss_train = 0. n_batch = 0. #for iter in range(self.size_epoch): for iter, (x_, t_) in enumerate(self.data_loader_train): n_batch += 1 #x_ = sort_utils.get_batch(list_classes, classe, self.batch_size) #x_ = torch.FloatTensor(x_) x_ = Variable(x_) if self.gpu_mode: x_ = x_.cuda(self.device) # VAE z_, mu, logvar = self.E(x_) recon_batch = self.G(z_) # train self.G_optimizer.zero_grad() self.E_optimizer.zero_grad() g_loss = self.loss_function(recon_batch, x_, mu, logvar) g_loss.backward() #retain_variables=True) sum_loss_train += g_loss.data[0] self.G_optimizer.step() self.E_optimizer.step() self.train_hist['D_loss'].append(g_loss.data[0]) self.train_hist['G_loss'].append(g_loss.data[0]) if ((iter + 1) % 100) == 0: print( "classe : [%1d] Epoch: [%2d] [%4d/%4d] G_loss: %.8f, E_loss: %.8f" % (classe, (epoch + 1), (iter + 1), self.size_epoch, g_loss.data[0], g_loss.data[0])) sum_loss_train = sum_loss_train / np.float(n_batch) sum_loss_valid = 0. n_batch = 0. n_batch = 1. self.E.eval() self.G.eval() for iter, (x_, t_) in enumerate(self.data_loader_valid): n_batch += 1 max_val, max_indice = torch.max(t_, 0) mask_idx = torch.nonzero(t_ == classe) if mask_idx.dim() == 0: continue x_ = torch.index_select(x_, 0, mask_idx[:, 0]) t_ = torch.index_select(t_, 0, mask_idx[:, 0]) if self.gpu_mode: x_ = Variable(x_.cuda(self.device), volatile=True) else: x_ = Variable(x_) # VAE z_, mu, logvar = self.E(x_) recon_batch = self.G(z_) G_loss = self.loss_function(recon_batch, x_, mu, logvar) sum_loss_valid += G_loss.data[0] sum_loss_valid = sum_loss_valid / np.float(n_batch) print( "classe : [%1d] Epoch: [%2d] Train_loss: %.8f, Valid_loss: %.8f" % (classe, (epoch + 1), sum_loss_train, sum_loss_valid)) self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time) self.visualize_results((epoch + 1), classe) if sum_loss_valid < best: best = sum_loss_valid self.save_G(classe) early_stop = 0. # We dit early stopping of the valid performance doesn't # improve anymore after 50 epochs if early_stop == 150: break else: early_stop += 1 result_dir = self.result_dir + '/' + 'classe-' + str(classe) utils.generate_animation(result_dir + '/' + self.model_name, epoch + 1) utils.loss_plot(self.train_hist, result_dir, self.model_name) np.savetxt( os.path.join(result_dir, 'vae_training_' + self.dataset + '.txt'), np.transpose([self.train_hist['G_loss']])) self.train_hist['total_time'].append(time.time() - start_time) print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']), self.epoch, self.train_hist['total_time'][0])) print("Training finish!... save training results")
def train(self): self.G.apply(self.G.weights_init) print(' training start!! (no conditional)') start_time = time.time() for classe in range(10): self.train_hist = {} self.train_hist['D_loss'] = [] self.train_hist['G_loss'] = [] self.train_hist['per_epoch_time'] = [] self.train_hist['total_time'] = [] # self.G.apply(self.G.weights_init) does not work for instance self.G.train() data_loader_train = get_iter_dataset(self.dataset_train, self.list_class_train, self.batch_size, classe) print("Classe: " + str(classe)) for epoch in range(self.epoch): epoch_start_time = time.time() for iter, (x_, t_) in enumerate(data_loader_train): if iter == data_loader_train.dataset.__len__( ) // self.batch_size: break z_ = torch.rand((self.batch_size, self.z_dim)) if self.gpu_mode: x_, z_ = Variable(x_.cuda()), Variable(z_.cuda()) else: x_, z_ = Variable(x_), Variable(z_) # update D network self.D_optimizer.zero_grad() D_real = self.D(x_) D_real_loss = -torch.mean(D_real) G_ = self.G(z_) D_fake = self.D(G_) D_fake_loss = torch.mean(D_fake) # gradient penalty if self.gpu_mode: alpha = torch.rand(x_.size()).cuda() else: alpha = torch.rand(x_.size()) x_hat = Variable(alpha * x_.data + (1 - alpha) * G_.data, requires_grad=True) pred_hat = self.D(x_hat) if self.gpu_mode: gradients = \ grad(outputs=pred_hat, inputs=x_hat, grad_outputs=torch.ones(pred_hat.size()).cuda(), create_graph=True, retain_graph=True, only_inputs=True)[0] else: gradients = grad(outputs=pred_hat, inputs=x_hat, grad_outputs=torch.ones( pred_hat.size()), create_graph=True, retain_graph=True, only_inputs=True)[0] gradient_penalty = self.lambda_ * ( (gradients.view(gradients.size()[0], -1).norm(2, 1) - 1)**2).mean() D_loss = D_real_loss + D_fake_loss + gradient_penalty D_loss.backward() self.D_optimizer.step() if ((iter + 1) % self.n_critic) == 0: # update G network self.G_optimizer.zero_grad() G_ = self.G(z_) D_fake = self.D(G_) G_loss = -torch.mean(D_fake) self.train_hist['G_loss'].append(G_loss.data[0]) G_loss.backward() self.G_optimizer.step() self.train_hist['D_loss'].append(D_loss.data[0]) if ((iter + 1) % 100) == 0: print( "classe : [%1d] Epoch: [%2d] [%4d/%4d] G_loss: %.8f, D_loss: %.8f" % (classe, (epoch + 1), (iter + 1), self.size_epoch, G_loss.data[0], D_loss.data[0])) self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time) self.visualize_results((epoch + 1), classe) self.save_G(classe) result_dir = self.result_dir + '/' + 'classe-' + str(classe) utils.generate_animation(result_dir + '/' + self.model_name, epoch + 1) utils.loss_plot(self.train_hist, result_dir, self.model_name) np.savetxt( os.path.join(result_dir, 'wgan_training_' + self.dataset + '.txt'), np.transpose([self.train_hist['G_loss']])) self.train_hist['total_time'].append(time.time() - start_time) print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']), self.epoch, self.train_hist['total_time'][0])) print("Training finish!... save training results")
def train(self): self.G.apply(self.G.weights_init) print(' training start!! (no conditional)') start_time = time.time() for classe in range(10): self.train_hist = {} self.train_hist['D_loss'] = [] self.train_hist['G_loss'] = [] self.train_hist['per_epoch_time'] = [] self.train_hist['total_time'] = [] # self.G.apply(self.G.weights_init) does not work for instance self.G.train() data_loader_train = get_iter_dataset(self.dataset_train, self.list_class_train, self.batch_size, classe) print("Classe: " + str(classe)) for epoch in range(self.epoch): epoch_start_time = time.time() for iter, (x_, t_) in enumerate(data_loader_train): z_ = torch.rand((self.batch_size, self.z_dim, 1, 1)) if self.gpu_mode: x_, z_ = Variable(x_.cuda(self.device)), Variable( z_.cuda(self.device)) else: x_, z_ = Variable(x_), Variable(z_) self.D_optimizer.zero_grad() D_real = self.D(x_) D_real_loss = -torch.mean(D_real) G_ = self.G(z_) D_fake = self.D(G_) D_fake_loss = torch.mean(D_fake) D_loss = D_real_loss + D_fake_loss D_loss.backward() self.D_optimizer.step() # clipping D for p in self.D.parameters(): p.data.clamp_(-self.c, self.c) if ((iter + 1) % self.n_critic) == 0: # update G network self.G_optimizer.zero_grad() G_ = self.G(z_) D_fake = self.D(G_) G_loss = -torch.mean(D_fake) self.train_hist['G_loss'].append(G_loss.data[0]) G_loss.backward() self.G_optimizer.step() self.train_hist['D_loss'].append(D_loss.data[0]) if ((iter + 1) % 100) == 0: print( "classe : [%1d] Epoch: [%2d] [%4d/%4d] G_loss: %.8f, D_loss: %.8f" % (classe, (epoch + 1), (iter + 1), self.size_epoch, G_loss.data[0], D_loss.data[0])) self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time) self.visualize_results((epoch + 1), classe) self.save_G(classe) result_dir = self.result_dir + '/' + 'classe-' + str(classe) utils.generate_animation(result_dir + '/' + self.model_name, epoch + 1) utils.loss_plot(self.train_hist, result_dir, self.model_name) np.savetxt( os.path.join(result_dir, 'wgan_training_' + self.dataset + '.txt'), np.transpose([self.train_hist['G_loss']])) self.train_hist['total_time'].append(time.time() - start_time) print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']), self.epoch, self.train_hist['total_time'][0])) print("Training finish!... save training results")