def single_item_recon(batch):
for item_num in range(32):
# x = train_loader[batch][item_num]
x = data_folder[opt.batch_size * batch + item_num]
x = x.view(1, 3, 64, 64)
z = learnable_z[batch][item_num].view(1, 256, 1, 1)
x = to_variable(x)
z = to_variable(z)
x_hat = generator.forward(z)
z = learnable_z[batch]
print("saving recon images in ", sample_path)
torchvision.utils.save_image(
denorm(x.data),
os.path.join(sample_path,
'real_samples-%d-%d.png' % (batch, item_num)),
nrow=8)
# save the generated images
torchvision.utils.save_image(
denorm(x_hat.data),
os.path.join(sample_path, 'recon_test-%d-%d.png' % (batch, item_num)),
nrow=8)
def test(self):
load_checkpoint(self.netG_A2B,
'./results/cyclegan/checkpoints/netG_A2B_final.pth',
self.device)
load_checkpoint(self.netG_B2A,
'./results/cyclegan/checkpoints/netG_B2A_final.pth',
self.device)
os.makedirs('./results/cyclegan/evaluation/', exist_ok=True)
self.netG_A2B.eval()
self.netG_B2A.eval()
print("=====Test Start======")
with torch.no_grad():
for iter, (real_A, real_B) in enumerate(self.testloader):
fake_A = self.netG_B2A(real_B.to(self.device))
save_image(
denorm(fake_A),
os.path.join('./results/cyclegan/evaluation',
'fake_image-{:05d}.png'.format(iter + 1)))
# Compute the Inception score
dataset = FolderDataset(
folder=os.path.join('./results/cyclegan/evaluation'))
Inception = Inception_Score(dataset)
score = Inception.compute_score(splits=1)
print('Inception Score : ', score)
def test(self):
load_checkpoint(
self.netG,
os.path.join('./results', self.type, 'checkpoints',
'netG_final.pth'), self.device)
self.netG.eval()
os.makedirs(os.path.join('./results/', self.type, 'evaluation'),
exist_ok=True)
print("=====Test Start======")
with torch.no_grad():
for iter in range(1000):
z = torch.randn(1, 256).to(self.device)
fake_img = self.netG(z)
save_image(
denorm(fake_img),
os.path.join('./results/', self.type, 'evaluation',
'fake_image-{:05d}.png'.format(iter + 1)))
# Compute the Inception score
dataset = FolderDataset(
folder=os.path.join('./results/', self.type, 'evaluation'))
Inception = Inception_Score(dataset)
score = Inception.compute_score(splits=1)
print('Inception Score : ', score)
def recon_test(iter_num):
for i, x in enumerate(train_loader):
print(i)
if i == iter_num:
x = to_variable(x)
z = to_variable(learnable_z[i])
x_hat = generator.forward(z)
print("saving recon images in ", sample_path)
torchvision.utils.save_image(denorm(x.data),
os.path.join(
sample_path,
'real_samples-%d.png' % iter_num),
nrow=8)
# save the generated images
torchvision.utils.save_image(denorm(x_hat.data),
os.path.join(
sample_path,
'recon_test-%d.png' % iter_num),
nrow=8)
break
def generate_test(iter_num):
for i in range(iter_num):
z = torch.randn(opt.batch_size, opt.z_dim, 1, 1)
z = to_variable(z)
if opt.gpu:
z.cuda()
x_hat = generator.forward(z)
print("saving generated images in ", sample_path)
# save the generated images
torchvision.utils.save_image(denorm(x_hat.data),
os.path.join(sample_path,
'generate_test-%d.png' % i),
nrow=8)
z_update_norm = z_update / norm[:, np.newaxis]
if opt.gpu:
learnable_z[i] = torch.from_numpy(z_update_norm).cuda()
else:
learnable_z[i] = torch.from_numpy(z_update_norm).cpu()
if (i + 1) % log_step == 0:
print('Epoch [%d/%d], Step[%d/%d], loss: %f, l1: %f, lap: %f'
% (epoch + 1, n_epochs, i + 1, total_step, loss.data[0], l1_loss.data[0],
lap_loss.data[0]
))
# save the real images
if (i + 1) == sample_step:
torchvision.utils.save_image(denorm(x.data),
os.path.join(sample_path,
'real_samples-%d-%d.png' % (
epoch + 1, i + 1)), nrow=4)
# save the generated images
if (i + 1) % sample_step == 0:
torchvision.utils.save_image(denorm(x_hat.data),
os.path.join(sample_path,
'fake_samples-%d-%d.png' % (
epoch + 1, i + 1)), nrow=4)
if (epoch + 1) % opt.ckpt_step == 0:
print("saving checkpoint ..")
checkpoint_path = os.path.join(model_path, 'checkpoint_%d.pth.tar' % (epoch + 1))
save_checkpoint({
def train(self, epochs: int = 100):
self.netG_A2B.to(self.device)
self.netG_B2A.to(self.device)
self.netD_A.to(self.device)
self.netD_B.to(self.device)
start_time = time.time()
print("=====Train Start======")
for epoch in range(epochs):
for iter, (real_A, real_B) in enumerate(self.trainloader):
self.netG_A2B.train()
self.netG_B2A.train()
self.netD_A.train()
self.netD_B.train()
real_A = real_A.to(self.device)
real_B = real_B.to(self.device)
real_label = torch.ones(batch_size).to(self.device)
fake_label = torch.zeros(batch_size).to(self.device)
###################################################################################
# (1) Update Generator
# Train the generator (self.netG_A2B & self.netG_B2A).
# You have to implement 3 types of loss functions ('identity loss', 'gan loss', 'cycle consistency loss')
###################################################################################
identity_loss: torch.Tensor() = None
gan_loss: torch.Tensor() = None
cycle_loss: torch.Tensor() = None
lossG: torch.Tensor() = None
### YOUR CODE HERE (~ 15 lines)
# forward network
fake_B = self.netG_A2B(real_A)
reco_A = self.netG_B2A(fake_B)
fake_A = self.netG_B2A(real_B)
reco_B = self.netG_A2B(fake_A)
# hold discriminators
for net in [self.netD_A, self.netD_B]:
if net is not None:
for param in net.parameters():
param.requires_grad = False
self.optimizerG.zero_grad()
# Identity loss
idt_A = self.netG_A2B(real_B)
loss_idt_A = self.criterion_identity(idt_A, real_B)
idt_B = self.netG_B2A(real_A)
loss_idt_B = self.criterion_identity(idt_B, real_A)
identity_loss = self.weight_idt * (loss_idt_A + loss_idt_B)
# GAN loss
preD = self.netD_A(fake_B)
loss_G_A = self.criterion_GAN(preD, real_label.expand_as(preD))
preD = self.netD_B(fake_A)
loss_G_B = self.criterion_GAN(preD, real_label.expand_as(preD))
gan_loss = self.weight_gan * (loss_G_A + loss_G_B)
# Cycle loss
loss_cycle_A = self.criterion_cycle(reco_A, real_A)
loss_cycle_B = self.criterion_cycle(reco_B, real_B)
cycle_loss = self.weight_cycle * (loss_cycle_A + loss_cycle_B)
lossG = identity_loss + gan_loss + cycle_loss
### END YOUR CODE
# Test code
# if epoch == 0 and iter == 0:
# 5.7538, 2.2067, 11.5476
# 5.4559, 2.2439, 10.9289
# test_lossG_fuction(identity_loss, gan_loss, cycle_loss)
self.optimizerG.zero_grad()
lossG.backward()
self.optimizerG.step()
###################################################################################
# (2) Update Discriminator
# Train the discrminator (self.netD_A & self.netD_B).
###################################################################################
# Discriminator A
lossD_A: torch.Tensor() = None
### YOUR CODE HERE (~ 4 lines)
# activate discriminators
for net in [self.netD_A, self.netD_B]:
if net is not None:
for param in net.parameters():
param.requires_grad = True
pred_real = self.netD_A(real_B)
lossD_A_real = self.criterion_GAN(
pred_real, real_label.expand_as(pred_real))
pred_fake = self.netD_A(fake_B.detach())
lossD_A_fake = self.criterion_GAN(
pred_fake, fake_label.expand_as(pred_fake))
lossD_A = (lossD_A_real + lossD_A_fake)
### END YOUR CODE
self.optimizerD_A.zero_grad()
lossD_A.backward()
self.optimizerD_A.step()
# Discriminator B
lossD_B: torch.Tensor() = None
### YOUR CODE HERE (~ 4 lines)
pred_real = self.netD_B(real_A)
lossD_B_real = self.criterion_GAN(
pred_real, real_label.expand_as(pred_real))
pred_fake = self.netD_B(fake_A.detach())
lossD_B_fake = self.criterion_GAN(
pred_fake, fake_label.expand_as(pred_fake))
lossD_B = (lossD_B_real + lossD_B_fake)
### END YOUR CODE
# Test code
# if epoch == 0 and iter == 0:
# test_lossD_fuction(lossD_A, lossD_B)
self.optimizerD_B.zero_grad()
lossD_B.backward()
self.optimizerD_B.step()
if (iter + 1) % 100 == 0:
end_time = time.time() - start_time
end_time = str(datetime.timedelta(seconds=end_time))[:-7]
print(
'Time [%s], Epoch [%d/%d], Step[%d/%d], lossD_A: %.4f, lossD_B: %.4f, lossG: %.4f'
% (end_time, epoch + 1, epochs, iter + 1,
len(self.trainloader), lossD_A.item(),
lossD_A.item(), lossG.item()))
# Save Images
fake_A = fake_A.reshape(fake_A.size(0), 3, 256, 256)
fake_B = fake_B.reshape(fake_B.size(0), 3, 256, 256)
save_image(
denorm(fake_B),
os.path.join('./results/cyclegan/images',
'fakeA2B-{:03d}.png'.format(epoch + 1)))
save_image(
denorm(fake_A),
os.path.join('./results/cyclegan/images',
'fakeB2A-{:03d}.png'.format(epoch + 1)))
if (epoch + 1) % 10 == 0:
save_checkpoint(
self.netG_A2B,
'./results/cyclegan/checkpoints/netG_A2B_{:02d}.pth'.
format(epoch + 1), self.device)
save_checkpoint(
self.netG_B2A,
'./results/cyclegan/checkpoints/netG_B2A_{:02d}.pth'.
format(epoch + 1), self.device)
save_checkpoint(
self.netD_A,
'./results/cyclegan/checkpoints/netD_A_{:02d}.pth'.format(
epoch + 1), self.device)
save_checkpoint(
self.netD_B,
'./results/cyclegan/checkpoints/netD_B_{:02d}.pth'.format(
epoch + 1), self.device)
# Save Checkpoints
save_checkpoint(self.netG_A2B,
'./results/cyclegan/checkpoints/netG_A2B_final.pth',
self.device)
save_checkpoint(self.netG_B2A,
'./results/cyclegan/checkpoints/netG_B2A_final.pth',
self.device)
save_checkpoint(self.netD_A,
'./results/cyclegan/checkpoints/netD_A_final.pth',
self.device)
save_checkpoint(self.netD_B,
'./results/cyclegan/checkpoints/netD_B_final.pth',
self.device)
def train():
for epoch in range(num_epoch):
self.optim_D = lr_scheduler(self.optim_D, epoch, self.lr)
self.optim_G = lr_scheduler(self.optim_G, epoch, self.lr)
for iters, (real_img, real_label) in enumerate(self.dloader):
N, C, H, W = real_img.size()
''' ------------------------------ 1. Train D ------------------------------ '''
real_img = util.var(real_img, requires_grad=False)
real_label = util.var(real_label, requires_grad=False)
# Source and classification loss with real img and real label
real_src_score, real_cls_score = self.D(real_img)
real_src_loss = -torch.mean(real_src_score)
real_cls_loss = BCE_loss(real_cls_score, real_label) / N
# Make random target label and c using real label and concat with real img
target_label = real_label[torch.randperm(real_label.size(0)).type(self.itype)]
# Source and classification loss with fake img and target label
fake_img = self.G(real_img, target_label)
fake_src_score, fake_cls_score = self.D(fake_img)
fake_src_loss = torch.mean(fake_src_score)
# Gradient Penalty
alpha = torch.rand(N, 1, 1, 1).type(self.dtype)
x_hat = util.var((alpha * real_img.data + (1 - alpha) * fake_img.data), requires_grad=True)
x_hat_score, _ = self.D(x_hat)
grad = torch.autograd.grad(outputs=x_hat_score,
inputs=x_hat,
grad_outputs=torch.ones(x_hat_score.size()).type(self.dtype),
retain_graph=True,
create_graph=True,
only_inputs=True)[0]
grad = grad.view(grad.size()[0], -1)
grad_l2norm = torch.sqrt(torch.sum(grad ** 2, dim=1))
gp_loss = self.lambda_gp * torch.mean((grad_l2norm - 1)**2)
# Total Loss and update
D_loss = real_src_loss + fake_src_loss + real_cls_loss + gp_loss
self.optim_D.zero_grad()
self.optim_G.zero_grad()
D_loss.backward()
self.optim_D.step()
''' ------------------------------ 1. Train G ------------------------------ '''
if iters % self.n_critic == 0:
# Source and classification loss with fake img and target label
fake_img = self.G(real_img, target_label)
recon_img = self.G(fake_img, real_label)
fake_src_score, fake_cls_score = self.D(fake_img)
fake_src_loss = -torch.mean(fake_src_score)
fake_cls_loss = self.BCE_loss(fake_cls_score, target_label)
recon_loss = self.lambda_recon * self.L1_loss(recon_img, real_img)
# Total loss and update
G_loss = fake_src_loss + fake_cls_loss + recon_loss
self.optim_D.zero_grad()
self.optim_G.zero_grad()
G_loss.backward()
self.optim_G.step()
if iters % self.save_every == 0:
if os.path.exists(self.result_dir) is False:
os.makedirs(self.result_dir)
if os.path.exists(self.weight_dir) is False:
os.makedirs(self.weight_dir)
# Print loss
print('[Epoch : %d / Iter : %d] : D_loss : %f, G_loss : %f, real_cls : %f, fake_cls : %f'\
%(epoch, iters, D_loss.data[0], G_loss.data[0], \
real_cls_loss.data[0], fake_cls_loss.data[0]))
# Save image
img_name = str(epoch) + '_' + str(iters) + '.png'
img_path = os.path.join(self.result_dir, img_name)
real_img = util.denorm(real_img)
fake_img = util.denorm(fake_img)
util.save_img(real_img, fake_img, img_path)
# Save weight
torch.save(self.D.state_dict(), os.path.join(self.weight_dir, 'D.pkl'))
torch.save(self.G.state_dict(), os.path.join(self.weight_dir, 'G.pkl'))
# Save weight at the end of every epoch
torch.save(self.D.state_dict(), os.path.join(self.weight_dir, 'D.pkl'))
torch.save(self.G.state_dict(), os.path.join(self.weight_dir, 'G.pkl'))
# Save weight at the end of training
torch.save(self.D.state_dict(), os.path.join(self.weight_dir, 'D.pkl'))
torch.save(self.G.state_dict(), os.path.join(self.weight_dir, 'G.pkl'))
def train(start, epoch):
last_time = time.time()
epoch_time = time.time()
print('-- Current Epoch: %d'%epoch)
adjust_learning_rate(G_A_Optimizer, epoch)
adjust_learning_rate(G_B_Optimizer, epoch)
adjust_learning_rate(D_A_Optimizer, epoch)
adjust_learning_rate(D_B_Optimizer, epoch)
for i, (a_real, b_real) in enumerate(itertools.izip(a_loader, b_loader)):
# Train Generators
a_real = Variable(a_real[0])
b_real = Variable(b_real[0])
if use_cuda:
a_real = a_real.cuda()
b_real = b_real.cuda()
a_fake = G_A(b_real)
b_fake = G_B(a_real)
a_rec = G_A(b_fake)
b_rec = G_B(a_fake)
a_fake_result = D_A(a_fake)
b_fake_result = D_B(b_fake)
real_labels = Variable(torch.ones(a_fake_result.size()))
if use_cuda:
real_labels = real_labels.cuda()
G_A_loss = MSE_Loss(a_fake_result, real_labels)
G_B_loss = MSE_Loss(b_fake_result, real_labels)
a_rec_loss = L1_Loss(a_rec, a_real)
b_rec_loss = L1_Loss(b_rec, b_real)
G_loss = G_A_loss + G_B_loss + a_rec_loss*10 + b_rec_loss*10
G_A.zero_grad()
G_B.zero_grad()
G_loss.backward()
G_A_Optimizer.step()
G_B_Optimizer.step()
# Train Discriminators
a_fake = Variable(torch.Tensor(a_fake_pool([a_fake.cpu().data.numpy()])[0]))
b_fake = Variable(torch.Tensor(b_fake_pool([b_fake.cpu().data.numpy()])[0]))
if use_cuda:
a_fake = a_fake.cuda()
b_fake = b_fake.cuda()
a_real_result = D_A(a_real)
a_fake_result = D_A(a_fake)
b_real_result = D_B(b_real)
b_fake_result = D_B(b_fake)
real_labels = Variable(torch.ones(a_real_result.size()))
fake_labels = Variable(torch.zeros(a_fake_result.size()))
if use_cuda:
real_labels = real_labels.cuda()
fake_labels = fake_labels.cuda()
D_A_real_loss = MSE_Loss(a_real_result, real_labels)
D_A_fake_loss = MSE_Loss(a_fake_result, fake_labels)
D_B_real_loss = MSE_Loss(b_real_result, real_labels)
D_B_fake_loss = MSE_Loss(b_fake_result, fake_labels)
D_A_loss = D_A_fake_loss + D_A_real_loss
D_B_loss = D_B_fake_loss + D_B_real_loss
D_A.zero_grad()
D_B.zero_grad()
D_A_loss.backward()
D_B_loss.backward()
D_A_Optimizer.step()
D_B_Optimizer.step()
# Log
if i % config.log_frequency == 0:
speed = time.time() - last_time
last_time = time.time()
format_str = ('Step: %d; Loss: G-A: %.3f, D-A: %.3f, G-B: %.3f, D-B: %.3f; Speed: %.2f sec/step')
print(format_str % (i, G_A_loss, D_A_loss, G_B_loss, D_B_loss, speed/config.log_frequency))
# Save Data
print('-- Saving parameters and sample images.')
state = {'G_A': G_A, 'G_B': G_B, 'D_A': D_A, 'D_B': D_B, 'epoch': epoch}
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
torch.save(state, './checkpoint/cyclegan.nn')
if epoch >= 10 and epoch % config.save_frequency == 0:
# Test Images
for i, (a_real_test, b_real_test) in enumerate(itertools.izip(a_test_loader, b_test_loader)):
a_real_test = Variable(a_real_test[0])
b_real_test = Variable(b_real_test[0])
if use_cuda:
a_real_test = a_real_test.cuda()
b_real_test = b_real_test.cuda()
a_fake_test = G_A(b_real_test)
b_fake_test = G_B(a_real_test)
a_rec_test = G_A(b_fake_test)
b_rec_test = G_B(a_fake_test)
test = torch.cat([a_real_test, b_fake_test, a_rec_test, b_real_test, a_fake_test, b_rec_test], dim=0)
test = util.denorm(test).data
if not os.path.isdir('result'):
os.mkdir('result')
save_image(test, 'result/test%d-epoch-%d.jpg' % (i, epoch))
else:
# Sample Image
a_fake_fixed = G_A(b_real_fixed)
b_fake_fixed = G_B(a_real_fixed)
a_rec_fixed = G_A(b_fake_fixed)
b_rec_fixed = G_B(a_fake_fixed)
sample = torch.cat([a_real_fixed, b_fake_fixed, a_rec_fixed, b_real_fixed, a_fake_fixed, b_rec_fixed], dim=0)
sample = util.denorm(sample).data
if not os.path.isdir('result'):
os.mkdir('result')
save_image(sample, 'result/sample-epoch-%d.jpg' % (epoch))
epoch_time = (time.time() - epoch_time)/60
time_remain = (epoch_time * (config.max_epoch - epoch))/60
print('-- Epoch %d completed. Epoch Time: %.2f min, Time Est: %.2f hour.' %(epoch, epoch_time, time_remain))
def train(start, epoch, config):
last_time = time.time()
epoch_time = time.time()
for idx, (image, _) in enumerate(loader):
# Discriminator
net_d.zero_grad()
real = Variable(image)
noise = Variable(torch.Tensor(config.batch_size, config.noise_dim))
noise.data.normal_(0.0, 1.0)
if use_cuda:
real = real.cuda()
noise = noise.cuda()
real_d = net_d(real)
real_label = Variable(torch.ones(real_d.size()))
if use_cuda:
real_label = real_label.cuda()
cost_d_real = bce(real_d, real_label)
#if idx % config.k_d_real == 0:
cost_d_real.backward()
fake = net_g(noise)
fake_d = net_d(fake.detach())
fake_label = Variable(torch.zeros(fake_d.size()))
if use_cuda:
fake_label = fake_label.cuda()
cost_d_fake = bce(fake_d, fake_label)
#if idx % config.k_d_fake == 0:
cost_d_fake.backward()
cost_d = cost_d_fake + cost_d_real
opt_d.step()
# Generator
net_g.zero_grad()
fake_g = net_d(fake)
real_label = Variable(torch.ones(fake_g.size()))
if use_cuda:
real_label = real_label.cuda()
cost_g = bce(fake_g, real_label)
#if idx % config.k_g == 0:
cost_g.backward()
opt_g.step()
# Log
if idx % config.log_frequency == 0:
speed = time.time() - last_time
last_time = time.time()
format_str = (
'Epoch: %d, Step: %d, G-Loss: %.3f, D-Loss: %.3f, Speed: %.2f sec/step'
)
print(format_str %
(epoch, idx, cost_g, cost_d, speed / config.log_frequency))
# Saving Data
fake_fixed = net_g(fixed)
state = {
'net_g': net_g,
'net_d': net_d,
'epoch': epoch,
}
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
torch.save(state, './checkpoint/dcgan.nn')
if (epoch > 15 and epoch % config.save_frequency == 0) or (epoch <= 15):
save_image(
util.denorm(fake_fixed).data,
'%s/fixed_%d.jpg' % (config.result_path, epoch))
save_image(
util.denorm(fake).data,
'%s/fake_%d.jpg' % (config.result_path, epoch))
print('-- Models and test images saved.')
epoch_time = (time.time() - epoch_time) / 60
time_remain = (epoch_time * (config.final_epoch - epoch)) / 60
print('-- Epoch completed. Epoch Time: %.2f min, Time Est: %.2f hour.' %
(epoch_time, time_remain))
def save_images(self, epoch, *args):
x_concat = torch.cat(args, dim=3)
sample_path = os.path.join(self.vis_dir, str(epoch).zfill(5) + '.png')
save_image(denorm(x_concat.data.cpu()), sample_path, nrow=8, padding=0)
def train(self, epochs: int = 100):
self.netG.to(self.device)
self.netD.to(self.device)
start_time = time.time()
print("=====Train Start======")
for epoch in range(epochs):
for iter, (real_img, _) in enumerate(self.trainloader):
self.netG.train()
self.netD.train()
batch_size = real_img.size(0)
real_label = torch.ones(batch_size).to(self.device)
fake_label = torch.zeros(batch_size).to(self.device)
real_img = real_img.to(self.device)
z = torch.randn(real_img.size(0), 256).to(self.device)
###################################################################################
# (1) Update Discriminator
# Compute the discriminator loss. You have to implement 4 types of loss functions ('gan', 'lsgan', 'wgan', 'wgan-gp').
# You can implement 'wgan' loss function wihtout using self.criterion.
# Note1 : Use self.criterion and self.type which is declared in the init function.
# Note2 : Use the 'detach()' function appropriately.
###################################################################################
lossD: torch.Tensor = None
### YOUR CODE HERE (~ 15 lines)
for p in self.netD.parameters():
p.requires_grad = True
if self.type == 'gan' or self.type == 'lsgan':
output_real = self.netD(real_img).view(-1)
lossD_r = self.criterion(output_real, real_label)
fake_img = self.netG(z)
output_fake = self.netD(fake_img.detach()).view(-1)
lossD_f = self.criterion(output_fake, fake_label)
lossD = self.D_weight * (lossD_r + lossD_f)
else:
lossD_r = self.netD(real_img)
lossD_r = lossD_r.mean(0).view(1)
fake_img = self.netG(z)
lossD_f = self.netD(fake_img.detach())
lossD_f = lossD_f.mean(0).view(1)
# adversarial loss
lossD = lossD_f - lossD_r
if self.type == 'wgan-gp':
alpha = torch.rand(batch_size, 1, 1, 1)
alpha = alpha.cuda() if torch.cuda.is_available(
) else alpha
gp_x = alpha * real_img + ((1 - alpha) * fake_img)
gp_x = gp_x.cuda() if torch.cuda.is_available(
) else gp_x
gp_x = torch.autograd.Variable(gp_x,
requires_grad=True)
gp_x_logit = self.netD(gp_x)
gradient_penalty = self.GP_loss(gp_x_logit, gp_x)
lossD = lossD + self.lambda_term * gradient_penalty
### END YOUR CODE
#Test code
if epoch == 0 and iter == 0:
test_lossD_function(self.type, lossD)
self.netD.zero_grad()
lossD.backward()
self.optimizerD.step()
### Clipping the weights of Discriminator
clip_value = 0.01
if self.type == 'wgan':
### YOUR CODE HERE (~2 lines)
for parm in self.netD.parameters():
parm.data.clamp_(-clip_value, clip_value)
### END YOUR CODE
###################################################################################
# (2) Update Generator
# Compute the generator loss. You have to implement 4 types of loss functions ('gan', 'lsgan', 'wgan', 'wgan-gp').
# You can implement 'wgan' and 'wgan-gp' loss functions without using self.criterion.
###################################################################################
lossG: torch.Tensor = None
### YOUR CODE HERE (~ 10 lines)
# if self.type == 'gan' or self.type == 'lsgan' or (iter+1) % self.n_critic == 0:
for p in self.netD.parameters():
p.requires_grad = False
if self.type == 'gan' or self.type == 'lsgan':
output = self.netD(fake_img).view(-1)
lossG = self.criterion(output, real_label)
else:
lossG = self.netD(fake_img).view(-1)
lossG = -lossG.mean()
### END YOUR CODE
# Test code
if epoch == 0 and iter == 0:
test_lossG_function(self.type, lossG)
self.netG.zero_grad()
lossG.backward()
self.optimizerG.step()
if (iter + 1) % 100 == 0:
end_time = time.time() - start_time
end_time = str(datetime.timedelta(seconds=end_time))[:-7]
# if self.type == 'wgan-gp':
# print('GP: %.4f' % gradient_penalty)
print(
'Time [%s], Epoch [%d/%d], Step[%d/%d], lossD: %.4f, lossG: %.4f'
% (end_time, epoch + 1, epochs, iter + 1,
len(self.trainloader), lossD.item(), lossG.item()))
# Save Images
fake_img = fake_img.reshape(fake_img.size(0), 3, 32, 32)
save_image(
denorm(fake_img),
os.path.join('./results/', self.type, 'images',
'fake_image-{:03d}.png'.format(epoch + 1)))
if (epoch + 1) % 50 == 0:
save_checkpoint(
self.netG,
os.path.join('./results', self.type, 'checkpoints',
'netG_{:02d}.pth'.format(epoch + 1)),
self.device)
save_checkpoint(
self.netD,
os.path.join('./results', self.type, 'checkpoints',
'netD_{:02d}.pth'.format(epoch + 1)),
self.device)
# Save Checkpoints
save_checkpoint(
self.netG,
os.path.join('./results', self.type, 'checkpoints',
'netG_final.pth'), self.device)
save_checkpoint(
self.netD,
os.path.join('./results', self.type, 'checkpoints',
'netD_final.pth'), self.device)
x_ = train_img[:, :, 0:img_size, :]
y_ = train_img[:, :, img_size:, :]
if img_size != opt.input_size:
x_ = util.imgs_resize(x_, opt.input_size)
y_ = util.imgs_resize(y_, opt.input_size)
x_ = util.norm(x_)
y_ = util.norm(y_)
test_img = sess.run(G, {x: x_})
num_str = test_loader.file_list[iter][:test_loader.file_list[iter].find('.'
)]
path = opt.dataset + '_results/test_results/' + num_str + '_input.png'
plt.imsave(path, (util.denorm(x_[0]) / 255))
path = opt.dataset + '_results/test_results/' + num_str + '_output.png'
plt.imsave(path, (util.denorm(test_img[0]) / 255))
path = opt.dataset + '_results/test_results/' + num_str + '_target.png'
plt.imsave(path, (util.denorm(y_[0]) / 255))
per_end_time = time.time()
per_ptime.append(per_end_time - per_start_time)
total_end_time = time.time()
total_ptime = total_end_time - total_start_time
print('total %d images generation complete!' % (iter + 1))
print(
'Avg. one image process ptime: %.2f, total %d images process ptime: %.2f' %
(np.mean(per_ptime), (iter + 1), total_ptime))
def train(self, epochs: int = 100):
self.netG_A2B.to(self.device)
self.netG_B2A.to(self.device)
self.netD_A.to(self.device)
self.netD_B.to(self.device)
start_time = time.time()
print("=====Train Start======")
for epoch in range(epochs):
for iter, (real_A, real_B) in enumerate(self.trainloader):
self.netG_A2B.train()
self.netG_B2A.train()
self.netD_A.train()
self.netD_B.train()
real_A = real_A.to(self.device)
real_B = real_B.to(self.device)
###################################################################################
# (1) Update Generator
# Train the generator (self.netG_A2B & self.netG_B2A).
# You have to implement 3 types of loss functions ('identity loss', 'gan loss', 'cycle consistency loss')
###################################################################################
identity_loss: torch.Tensor() = None
gan_loss: torch.Tensor() = None
cycle_loss: torch.Tensor() = None
lossG: torch.Tensor() = None
### YOUR CODE HERE (~ 15 lines)
### END YOUR CODE
# Test code
if epoch == 0 and iter == 0:
test_lossG_fuction(identity_loss, gan_loss, cycle_loss)
self.optimizerG.zero_grad()
lossG.backward()
self.optimizerG.step()
###################################################################################
# (2) Update Discriminator
# Train the discrminator (self.netD_A & self.netD_B).
###################################################################################
# Discriminator A
lossD_A: torch.Tensor() = None
### YOUR CODE HERE (~ 4 lines)
### END YOUR CODE
self.optimizerD_A.zero_grad()
lossD_A.backward()
self.optimizerD_A.step()
# Discriminator B
lossD_B: torch.Tensor() = None
### YOUR CODE HERE (~ 4 lines)
### END YOUR CODE
# Test code
if epoch == 0 and iter == 0:
test_lossD_fuction(lossD_A, lossD_B)
self.optimizerD_B.zero_grad()
lossD_B.backward()
self.optimizerD_B.step()
if (iter + 1) % 100 == 0:
end_time = time.time() - start_time
end_time = str(datetime.timedelta(seconds=end_time))[:-7]
print(
'Time [%s], Epoch [%d/%d], Step[%d/%d], lossD_A: %.4f, lossD_B: %.4f, lossG: %.4f'
% (end_time, epoch + 1, epochs, iter + 1,
len(self.trainloader), lossD_A.item(),
lossD_A.item(), lossG.item()))
# Save Images
fake_A = fake_A.reshape(fake_A.size(0), 3, 256, 256)
fake_B = fake_B.reshape(fake_B.size(0), 3, 256, 256)
save_image(
denorm(fake_B),
os.path.join('./results/cyclegan/images',
'fakeA2B-{:03d}.png'.format(epoch + 1)))
save_image(
denorm(fake_A),
os.path.join('./results/cyclegan/images',
'fakeB2A-{:03d}.png'.format(epoch + 1)))
if (epoch + 1) % 10 == 0:
save_checkpoint(
self.netG_A2B,
'./results/cyclegan/checkpoints/netG_A2B_{:02d}.pth'.
format(epoch + 1), self.device)
save_checkpoint(
self.netG_B2A,
'./results/cyclegan/checkpoints/netG_B2A_{:02d}.pth'.
format(epoch + 1), self.device)
save_checkpoint(
self.netD_A,
'./results/cyclegan/checkpoints/netD_A_{:02d}.pth'.format(
epoch + 1), self.device)
save_checkpoint(
self.netD_B,
'./results/cyclegan/checkpoints/netD_B_{:02d}.pth'.format(
epoch + 1), self.device)
# Save Checkpoints
save_checkpoint(self.netG_A2B,
'./results/cyclegan/checkpoints/netG_A2B_final.pth',
self.device)
save_checkpoint(self.netG_B2A,
'./results/cyclegan/checkpoints/netG_B2A_final.pth',
self.device)
save_checkpoint(self.netD_A,
'./results/cyclegan/checkpoints/netD_A_final.pth',
self.device)
save_checkpoint(self.netD_B,
'./results/cyclegan/checkpoints/netD_B_final.pth',
self.device)
def train(self, epochs: int = 100):
self.netG.to(self.device)
self.netD.to(self.device)
start_time = time.time()
print("=====Train Start======")
for epoch in range(epochs):
for iter, (real_img, _) in enumerate(self.trainloader):
self.netG.train()
self.netD.train()
batch_size = real_img.size(0)
real_label = torch.ones(batch_size).to(self.device)
fake_label = torch.zeros(batch_size).to(self.device)
real_img = real_img.to(self.device)
z = torch.randn(real_img.size(0), 256).to(self.device)
###################################################################################
# (1) Update Discriminator
# Compute the discriminator loss. You have to implement 4 types of loss functions ('gan', 'lsgan', 'wgan', 'wgan-gp').
# You can implement 'wgan' loss function wihtout using self.criterion.
# Note1 : Use self.criterion and self.type which is declared in the init function.
# Note2 : Use the 'detach()' function appropriately.
###################################################################################
lossD: torch.Tensor = None
### YOUR CODE HERE (~ 15 lines)
### END YOUR CODE
# Test code
if epoch == 0 and iter == 0:
test_lossD_function(self.type, lossD)
self.netD.zero_grad()
lossD.backward()
self.optimizerD.step()
### Clipping the weights of Discriminator
clip_value = 0.01
if self.type == 'wgan':
### YOUR CODE HERE (~2 lines)
pass
### END YOUR CODE
###################################################################################
# (2) Update Generator
# Compute the generator loss. You have to implement 4 types of loss functions ('gan', 'lsgan', 'wgan', 'wgan-gp').
# You can implement 'wgan' and 'wgan-gp' loss functions without using self.criterion.
###################################################################################
lossG: torch.Tensor = None
### YOUR CODE HERE (~ 10 lines)
### END YOUR CODE
# Test code
if epoch == 0 and iter == 0:
test_lossG_function(self.type, lossG)
self.netG.zero_grad()
lossG.backward()
self.optimizerG.step()
if (iter + 1) % 100 == 0:
end_time = time.time() - start_time
end_time = str(datetime.timedelta(seconds=end_time))[:-7]
print(
'Time [%s], Epoch [%d/%d], Step[%d/%d], lossD: %.4f, lossG: %.4f'
% (end_time, epoch + 1, epochs, iter + 1,
len(self.trainloader), lossD.item(), lossG.item()))
# Save Images
fake_img = fake_img.reshape(fake_img.size(0), 3, 32, 32)
save_image(
denorm(fake_img),
os.path.join('./results/', self.type, 'images',
'fake_image-{:03d}.png'.format(epoch + 1)))
if (epoch + 1) % 50 == 0:
save_checkpoint(
self.netG,
os.path.join('./results', self.type, 'checkpoints',
'netG_{:02d}.pth'.format(epoch + 1)),
self.device)
save_checkpoint(
self.netD,
os.path.join('./results', self.type, 'checkpoints',
'netD_{:02d}.pth'.format(epoch + 1)),
self.device)
# Save Checkpoints
save_checkpoint(
self.netG,
os.path.join('./results', self.type, 'checkpoints',
'netG_final.pth'), self.device)
save_checkpoint(
self.netD,
os.path.join('./results', self.type, 'checkpoints',
'netD_final.pth'), self.device)
