cfg = Config(args=args.__dict__, mode='Train')
cfg.show_config()
torch.backends.cudnn.benchmark = True
train_dataset = Seg_dataset(cfg)
train_loader = data.DataLoader(train_dataset,
batch_size=cfg.bs,
shuffle=True,
num_workers=8,
pin_memory=True,
drop_last=False)
if cfg.model == 'unet':
model = UNet(input_channels=3).cuda()
model.apply(model.weights_init_normal)
else:
model = DLASeg(cfg).cuda()
model.train()
if cfg.resume:
resume_epoch = int(cfg.resume.split('.')[0].split('_')[1]) + 1
model.load_state_dict(torch.load('weights/' + cfg.resume), strict=True)
print(f'Resume training with \'{cfg.resume}\'.')
else:
resume_epoch = 0
print('Training with ImageNet pre-trained weights.')
criterion = nn.CrossEntropyLoss(ignore_index=255).cuda()
if cfg.optim == 'sgd':
optimizer = torch.optim.SGD(model.optim_parameters(),
def train(frame_num,
layer_nums,
input_channels,
output_channels,
discriminator_num_filters,
bn=False,
pretrain=False,
generator_pretrain_path=None,
discriminator_pretrain_path=None):
generator = UNet(n_channels=input_channels,
layer_nums=layer_nums,
output_channel=output_channels,
bn=bn)
discriminator = PixelDiscriminator(output_channels,
discriminator_num_filters,
use_norm=False)
generator = generator.cuda()
discriminator = discriminator.cuda()
flow_network = Network()
flow_network.load_state_dict(torch.load(lite_flow_model_path))
flow_network.cuda().eval()
adversarial_loss = Adversarial_Loss().cuda()
discriminate_loss = Discriminate_Loss().cuda()
gd_loss = Gradient_Loss(alpha, num_channels).cuda()
op_loss = Flow_Loss().cuda()
int_loss = Intensity_Loss(l_num).cuda()
step = 0
if not pretrain:
generator.apply(weights_init_normal)
discriminator.apply(weights_init_normal)
else:
assert (generator_pretrain_path != None
and discriminator_pretrain_path != None)
generator.load_state_dict(torch.load(generator_pretrain_path))
discriminator.load_state_dict(torch.load(discriminator_pretrain_path))
step = int(generator_pretrain_path.split('-')[-1])
print('pretrained model loaded!')
print('initializing the model with Generator-Unet {} layers,'
'PixelDiscriminator with filters {} '.format(
layer_nums, discriminator_num_filters))
optimizer_G = torch.optim.Adam(generator.parameters(), lr=g_lr)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=d_lr)
writer = SummaryWriter(writer_path)
dataset = img_dataset.ano_pred_Dataset(training_data_folder, frame_num)
dataset_loader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1,
drop_last=True)
test_dataset = img_dataset.ano_pred_Dataset(testing_data_folder, frame_num)
test_dataloader = DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1,
drop_last=True)
for epoch in range(epochs):
for (input, _), (test_input, _) in zip(dataset_loader,
test_dataloader):
# generator = generator.train()
# discriminator = discriminator.train()
target = input[:, -1, :, :, :].cuda()
input = input[:, :-1, ]
input_last = input[:, -1, ].cuda()
input = input.view(input.shape[0], -1, input.shape[-2],
input.shape[-1]).cuda()
test_target = test_input[:, -1, ].cuda()
test_input = test_input[:, :-1].view(test_input.shape[0], -1,
test_input.shape[-2],
test_input.shape[-1]).cuda()
#------- update optim_G --------------
G_output = generator(input)
pred_flow_esti_tensor = torch.cat([input_last, G_output], 1)
gt_flow_esti_tensor = torch.cat([input_last, target], 1)
flow_gt = batch_estimate(gt_flow_esti_tensor, flow_network)
flow_pred = batch_estimate(pred_flow_esti_tensor, flow_network)
g_adv_loss = adversarial_loss(discriminator(G_output))
g_op_loss = op_loss(flow_pred, flow_gt)
g_int_loss = int_loss(G_output, target)
g_gd_loss = gd_loss(G_output, target)
g_loss = lam_adv * g_adv_loss + lam_gd * g_gd_loss + lam_op * g_op_loss + lam_int * g_int_loss
optimizer_G.zero_grad()
g_loss.backward()
optimizer_G.step()
train_psnr = psnr_error(G_output, target)
#----------- update optim_D -------
optimizer_D.zero_grad()
d_loss = discriminate_loss(discriminator(target),
discriminator(G_output.detach()))
#d_loss.requires_grad=True
d_loss.backward()
optimizer_D.step()
#----------- cal psnr --------------
test_generator = generator.eval()
test_output = test_generator(test_input)
test_psnr = psnr_error(test_output, test_target).cuda()
if step % 10 == 0:
print("[{}/{}]: g_loss: {} d_loss {}".format(
step, epoch, g_loss, d_loss))
print('\t gd_loss {}, op_loss {}, int_loss {} ,'.format(
g_gd_loss, g_op_loss, g_int_loss))
print('\t train psnr{}，test_psnr {}'.format(
train_psnr, test_psnr))
writer.add_scalar('psnr/train_psnr',
train_psnr,
global_step=step)
writer.add_scalar('psnr/test_psnr',
test_psnr,
global_step=step)
writer.add_scalar('total_loss/g_loss',
g_loss,
global_step=step)
writer.add_scalar('total_loss/d_loss',
d_loss,
global_step=step)
writer.add_scalar('g_loss/adv_loss',
g_adv_loss,
global_step=step)
writer.add_scalar('g_loss/op_loss',
g_op_loss,
global_step=step)
writer.add_scalar('g_loss/int_loss',
g_int_loss,
global_step=step)
writer.add_scalar('g_loss/gd_loss',
g_gd_loss,
global_step=step)
writer.add_image('image/train_target',
target[0],
global_step=step)
writer.add_image('image/train_output',
G_output[0],
global_step=step)
writer.add_image('image/test_target',
test_target[0],
global_step=step)
writer.add_image('image/test_output',
test_output[0],
global_step=step)
step += 1
if step % 500 == 0:
utils.saver(generator.state_dict(),
model_generator_save_path,
step,
max_to_save=10)
utils.saver(discriminator.state_dict(),
model_discriminator_save_path,
step,
max_to_save=10)
if step >= 2000:
print('==== begin evaluate the model of {} ===='.format(
model_generator_save_path + '-' + str(step)))
auc = evaluate(frame_num=5,
layer_nums=4,
input_channels=12,
output_channels=3,
model_path=model_generator_save_path + '-' +
str(step),
evaluate_name='compute_auc')
writer.add_scalar('results/auc', auc, global_step=step)
train_cfg = update_config(args, mode='train')
train_cfg.print_cfg()
generator = UNet(input_channels=12, output_channel=3).cuda()
discriminator = PixelDiscriminator(input_nc=3).cuda()
optimizer_G = torch.optim.Adam(generator.parameters(), lr=train_cfg.g_lr)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=train_cfg.d_lr)
if train_cfg.resume:
generator.load_state_dict(torch.load(train_cfg.resume)['net_g'])
discriminator.load_state_dict(torch.load(train_cfg.resume)['net_d'])
optimizer_G.load_state_dict(torch.load(train_cfg.resume)['optimizer_g'])
optimizer_D.load_state_dict(torch.load(train_cfg.resume)['optimizer_d'])
print(f'Pre-trained generator and discriminator have been loaded.\n')
else:
generator.apply(weights_init_normal)
discriminator.apply(weights_init_normal)
print('Generator and discriminator are going to be trained from scratch.\n')
assert train_cfg.flownet in ('lite', '2sd'), 'Flow net only supports LiteFlownet or FlowNet2SD currently.'
if train_cfg.flownet == '2sd':
flow_net = FlowNet2SD()
flow_net.load_state_dict(torch.load('models/flownet2/FlowNet2-SD.pth')['state_dict'])
else:
flow_net = lite_flow.Network()
flow_net.load_state_dict(torch.load('models/liteFlownet/network-default.pytorch'))
flow_net.cuda().eval() # Use flow_net to generate optic flows, so set to eval mode.
adversarial_loss = Adversarial_Loss().cuda()
discriminate_loss = Discriminate_Loss().cuda()
