|
|
|
|
|
|
|
import time |
|
from collections import OrderedDict |
|
from options.train_options import TrainOptions |
|
from data.data_loader import CreateDataLoader |
|
from models.mapping_model import Pix2PixHDModel_Mapping |
|
import util.util as util |
|
from util.visualizer import Visualizer |
|
import os |
|
import numpy as np |
|
import torch |
|
import torchvision.utils as vutils |
|
from torch.autograd import Variable |
|
import datetime |
|
import random |
|
|
|
|
|
|
|
opt = TrainOptions().parse() |
|
visualizer = Visualizer(opt) |
|
iter_path = os.path.join(opt.checkpoints_dir, opt.name, 'iter.txt') |
|
if opt.continue_train: |
|
try: |
|
start_epoch, epoch_iter = np.loadtxt(iter_path , delimiter=',', dtype=int) |
|
except: |
|
start_epoch, epoch_iter = 1, 0 |
|
visualizer.print_save('Resuming from epoch %d at iteration %d' % (start_epoch-1, epoch_iter)) |
|
else: |
|
start_epoch, epoch_iter = 1, 0 |
|
|
|
if opt.which_epoch != "latest": |
|
start_epoch=int(opt.which_epoch) |
|
visualizer.print_save('Notice : Resuming from epoch %d at iteration %d' % (start_epoch - 1, epoch_iter)) |
|
|
|
opt.start_epoch=start_epoch |
|
|
|
|
|
data_loader = CreateDataLoader(opt) |
|
dataset = data_loader.load_data() |
|
dataset_size = len(dataset) * opt.batchSize |
|
print('#training images = %d' % dataset_size) |
|
|
|
|
|
model = Pix2PixHDModel_Mapping() |
|
model.initialize(opt) |
|
|
|
path = os.path.join(opt.checkpoints_dir, opt.name, 'model.txt') |
|
fd = open(path, 'w') |
|
|
|
if opt.use_skip_model: |
|
fd.write(str(model.mapping_net)) |
|
fd.close() |
|
else: |
|
fd.write(str(model.netG_A)) |
|
fd.write(str(model.mapping_net)) |
|
fd.close() |
|
|
|
if opt.isTrain and len(opt.gpu_ids) > 1: |
|
model = torch.nn.DataParallel(model, device_ids=opt.gpu_ids) |
|
|
|
|
|
|
|
total_steps = (start_epoch-1) * dataset_size + epoch_iter |
|
|
|
display_delta = total_steps % opt.display_freq |
|
print_delta = total_steps % opt.print_freq |
|
save_delta = total_steps % opt.save_latest_freq |
|
|
|
|
|
for epoch in range(start_epoch, opt.niter + opt.niter_decay + 1): |
|
epoch_s_t=datetime.datetime.now() |
|
epoch_start_time = time.time() |
|
if epoch != start_epoch: |
|
epoch_iter = epoch_iter % dataset_size |
|
for i, data in enumerate(dataset, start=epoch_iter): |
|
iter_start_time = time.time() |
|
total_steps += opt.batchSize |
|
epoch_iter += opt.batchSize |
|
|
|
|
|
save_fake = total_steps % opt.display_freq == display_delta |
|
|
|
|
|
|
|
losses, generated = model(Variable(data['label']), Variable(data['inst']), |
|
Variable(data['image']), Variable(data['feat']), infer=save_fake) |
|
|
|
|
|
losses = [ torch.mean(x) if not isinstance(x, int) else x for x in losses ] |
|
loss_dict = dict(zip(model.module.loss_names, losses)) |
|
|
|
|
|
loss_D = (loss_dict['D_fake'] + loss_dict['D_real']) * 0.5 |
|
loss_G = loss_dict['G_GAN'] + loss_dict.get('G_GAN_Feat',0) + loss_dict.get('G_VGG',0) + loss_dict.get('G_Feat_L2', 0) +loss_dict.get('Smooth_L1', 0)+loss_dict.get('G_Feat_L2_Stage_1',0) |
|
|
|
|
|
|
|
|
|
model.module.optimizer_mapping.zero_grad() |
|
loss_G.backward() |
|
model.module.optimizer_mapping.step() |
|
|
|
|
|
model.module.optimizer_D.zero_grad() |
|
loss_D.backward() |
|
model.module.optimizer_D.step() |
|
|
|
|
|
|
|
if i == 0 or total_steps % opt.print_freq == print_delta: |
|
errors = {k: v.data if not isinstance(v, int) else v for k, v in loss_dict.items()} |
|
t = (time.time() - iter_start_time) / opt.batchSize |
|
visualizer.print_current_errors(epoch, epoch_iter, errors, t,model.module.old_lr) |
|
visualizer.plot_current_errors(errors, total_steps) |
|
|
|
|
|
if save_fake: |
|
|
|
if not os.path.exists(opt.outputs_dir + opt.name): |
|
os.makedirs(opt.outputs_dir + opt.name) |
|
|
|
imgs_num = 5 |
|
if opt.NL_use_mask: |
|
mask=data['inst'][:imgs_num] |
|
mask=mask.repeat(1,3,1,1) |
|
imgs = torch.cat((data['label'][:imgs_num], mask,generated.data.cpu()[:imgs_num], data['image'][:imgs_num]), 0) |
|
else: |
|
imgs = torch.cat((data['label'][:imgs_num], generated.data.cpu()[:imgs_num], data['image'][:imgs_num]), 0) |
|
|
|
imgs=(imgs+1.)/2.0 |
|
|
|
try: |
|
image_grid = vutils.save_image(imgs, opt.outputs_dir + opt.name + '/' + str(epoch) + '_' + str(total_steps) + '.png', |
|
nrow=imgs_num, padding=0, normalize=True) |
|
except OSError as err: |
|
print(err) |
|
|
|
if epoch_iter >= dataset_size: |
|
break |
|
|
|
|
|
epoch_e_t=datetime.datetime.now() |
|
iter_end_time = time.time() |
|
print('End of epoch %d / %d \t Time Taken: %s' % |
|
(epoch, opt.niter + opt.niter_decay, str(epoch_e_t-epoch_s_t))) |
|
|
|
|
|
if epoch % opt.save_epoch_freq == 0: |
|
print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps)) |
|
model.module.save('latest') |
|
model.module.save(epoch) |
|
np.savetxt(iter_path, (epoch+1, 0), delimiter=',', fmt='%d') |
|
|
|
|
|
if (opt.niter_fix_global != 0) and (epoch == opt.niter_fix_global): |
|
model.module.update_fixed_params() |
|
|
|
|
|
if epoch > opt.niter: |
|
model.module.update_learning_rate() |