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")