def backward_G(self):
loss_app_gen = self.L1loss(self.img_gen, self.input_P2)
loss_correctness_gen = self.Correctness(self.input_P2, self.input_P1,
self.flow_fields,
self.opt.attn_layer)
self.loss_correctness_gen = loss_correctness_gen * self.opt.lambda_correct
self.loss_app_gen = loss_app_gen * self.opt.lambda_rec
base_function._freeze(self.net_D)
D_fake = self.net_D(self.img_gen)
self.loss_ad_gen = self.GANloss(D_fake, True,
False) * self.opt.lambda_g
loss_regularization = self.Regularization(self.flow_fields)
self.loss_regularization = loss_regularization * self.opt.lambda_regularization
loss_content_gen, loss_style_gen = self.Vggloss(
self.img_gen, self.input_P2)
self.loss_style_gen = loss_style_gen * self.opt.lambda_style
self.loss_content_gen = loss_content_gen * self.opt.lambda_content
total_loss = 0
for name in self.loss_names:
if name != 'dis_img_rec' and name != 'dis_img_gen':
total_loss += getattr(self, "loss_" + name)
total_loss.backward()
def backward_G(self):
"""Calculate training loss for the generator"""
# Calculate regularzation loss to make transformed feature and target image feature in the same latent space
self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization
# Calculate l1 loss
loss_app_gen = self.L1loss(self.img_gen, self.input_P2)
self.loss_app_gen = loss_app_gen * self.opt.lambda_rec
# parsing loss
label_P2 = self.label_P2.squeeze(1).long()
#print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())
self.loss_par = self.parLoss(self.parsav, label_P2) # * 20.
self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100
# Calculate GAN loss
base_function._freeze(self.net_D)
D_fake = self.net_D(self.img_gen)
self.loss_ad_gen = self.GANloss(D_fake, True,
False) * self.opt.lambda_g
# Calculate perceptual loss
loss_content_gen, loss_style_gen = self.Vggloss(
self.img_gen, self.input_P2)
self.loss_style_gen = loss_style_gen * self.opt.lambda_style
self.loss_content_gen = loss_content_gen * self.opt.lambda_content
total_loss = 0
for name in self.loss_names:
if name != 'dis_img_gen':
#print(getattr(self, "loss_" + name))
total_loss += getattr(self, "loss_" + name)
total_loss.backward()
def backward_G(self):
"""Calculate training loss for the generator"""
# Calculate l1 loss
loss_app_gen = self.L1loss(self.img_gen, self.input_P2)
self.loss_app_gen = loss_app_gen * self.opt.lambda_rec
# Calculate Sampling Correctness Loss
loss_correctness_gen = self.Correctness(self.input_P2, self.input_P1,
self.flow_fields,
self.opt.attn_layer)
self.loss_correctness_gen = loss_correctness_gen * self.opt.lambda_correct
# Calculate GAN loss
base_function._freeze(self.net_D)
D_fake = self.net_D(self.img_gen)
self.loss_ad_gen = self.GANloss(D_fake, True,
False) * self.opt.lambda_g
# Calculate regularization term
loss_regularization = self.Regularization(self.flow_fields)
self.loss_regularization = loss_regularization * self.opt.lambda_regularization
# Calculate perceptual loss
loss_content_gen, loss_style_gen = self.Vggloss(
self.img_gen, self.input_P2)
self.loss_style_gen = loss_style_gen * self.opt.lambda_style
self.loss_content_gen = loss_content_gen * self.opt.lambda_content
total_loss = 0
for name in self.loss_names:
if name != 'dis_img_gen':
total_loss += getattr(self, "loss_" + name)
total_loss.backward()
def backward_G(self):
"""Calculate training loss for the generator"""
# gen_tensor = torch.cat([v.unsqueeze(1) for v in self.img_gen], 1)
loss_style_gen, loss_content_gen, loss_app_gen = 0, 0, 0
for i in range(len(self.img_gen)):
gen = self.img_gen[i]
gt = self.P_frame_step[:, i, ...]
loss_app_gen += self.L1loss(gen, gt)
if self.opt.use_vgg_loss:
content_gen, style_gen = self.Vggloss(gen, gt)
loss_style_gen += style_gen
loss_content_gen += content_gen
self.loss_style_gen = loss_style_gen * self.opt.lambda_style
self.loss_content_gen = loss_content_gen * self.opt.lambda_content
self.loss_app_gen = loss_app_gen * self.opt.lambda_rec
loss_correctness_p, loss_regularization_p = 0, 0
loss_correctness_r, loss_regularization_r = 0, 0
for i in range(len(self.flow_fields)):
flow_field_i = self.flow_fields[i]
flow_p, flow_r = [], []
for j in range(0, len(flow_field_i), 2):
flow_p.append(flow_field_i[j])
flow_r.append(flow_field_i[j + 1])
correctness_r = self.Correctness(self.P_frame_step[:, i, ...],
self.P_reference, flow_r,
self.opt.attn_layer)
correctness_p = self.Correctness(
self.P_frame_step[:, i,
...], self.P_previous_recoder[i].detach(),
flow_p, self.opt.attn_layer)
loss_correctness_p += correctness_p
loss_correctness_r += correctness_r
if self.opt.use_affine_regularization:
loss_regularization_p += self.Regularization(flow_p)
loss_regularization_r += self.Regularization(flow_r)
self.loss_correctness_p = loss_correctness_p * self.opt.lambda_correct
self.loss_correctness_r = loss_correctness_r * self.opt.lambda_correct
self.loss_regularization_p = loss_regularization_p * self.opt.lambda_regularization
self.loss_regularization_r = loss_regularization_r * self.opt.lambda_regularization
# rec loss fake
if self.opt.use_gan:
base_function._freeze(self.net_D)
i = np.random.randint(len(self.img_gen))
fake = self.img_gen[i]
D_fake = self.net_D(fake)
self.loss_ad_gen = self.GANloss(D_fake, True,
False) * self.opt.lambda_g
##########################################################################
base_function._freeze(self.net_D_V)
i = np.random.randint(len(self.img_gen) - self.opt.frames_D_V + 1)
# fake = [self.img_gen[i]]
fake = []
for frame in range(self.opt.frames_D_V - 1):
fake.append(self.img_gen[i + frame] -
self.img_gen[i + frame + 1])
fake = torch.cat(fake, dim=1)
D_fake = self.net_D_V(fake)
self.loss_ad_gen_v = self.GANloss(D_fake, True,
False) * self.opt.lambda_g
##########################################################################
total_loss = 0
for name in self.loss_names:
if name != 'dis_img_gen_v' and name != 'dis_img_gen':
total_loss += getattr(self, "loss_" + name)
total_loss.backward()
def backward_G(self):
"""Calculate training loss for the generator"""
loss_style_gen, loss_content_gen, loss_app_gen, loss_pose=0,0,0,0
loss_mask_app_gen = 0
# Calculate the Reconstruction Loss
for i in range(len(self.img_gen)):
gen = self.img_gen[i]
gt = self.P_step[:,i,...]
loss_app_gen += self.L1loss(gen, gt)
# Add cloth mask L1 loss
# TODO: populate self.cloth_mask with the binary mask corresponding
# to each frame, and uncomment the following line.
# loss_mask_app_gen += torch.nn.L1loss(gen * self.cloth_mask, gt * self.cloth_mask)
content_gen, style_gen = self.Vggloss(gen, gt)
loss_style_gen += style_gen
loss_content_gen += content_gen
self.loss_style_gen = loss_style_gen * self.opt.lambda_style
self.loss_content_gen = loss_content_gen * self.opt.lambda_content
self.loss_app_gen = loss_app_gen * self.opt.lambda_rec
self.loss_app_gen += loss_mask_app_gen * self.opt.lambda_cloth_mask
loss_correctness_p, loss_regularization_p=0, 0
loss_correctness_r, loss_regularization_r=0, 0
# Calculate the Sampling Correctness Loss and Regularization Loss
for i in range(len(self.flow_fields)):
flow_field_i = self.flow_fields[i]
flow_p, flow_r=[],[]
for j in range(0, len(flow_field_i), 2):
flow_p.append(flow_field_i[j])
flow_r.append(flow_field_i[j+1])
mask = self.mask_step[:,i,...] if self.opt.use_mask else None
correctness_r = self.Correctness(self.P_step[:,i,...], self.ref_image,
flow_r, self.opt.attn_layer, mask)
correctness_p = self.Correctness(self.P_step[:,i,...], self.P_gt_previous_recoder[:,i,...],
flow_p, self.opt.attn_layer, mask)
loss_correctness_p += correctness_p
loss_correctness_r += correctness_r
loss_regularization_p += self.Regularization(flow_p)
loss_regularization_r += self.Regularization(flow_r)
self.loss_correctness_p = loss_correctness_p * self.opt.lambda_correct
self.loss_correctness_r = loss_correctness_r * self.opt.lambda_correct
self.loss_regularization_p = loss_regularization_p * self.opt.lambda_regularization
self.loss_regularization_r = loss_regularization_r * self.opt.lambda_regularization
# Spatial GAN Loss
base_function._freeze(self.net_D)
i = np.random.randint(len(self.img_gen))
fake = self.img_gen[i]
D_fake = self.net_D(fake)
self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g
# Temporal GAN Loss
base_function._freeze(self.net_D_V)
i = np.random.randint(len(self.img_gen)-self.opt.frames_D_V+1)
fake = []
for frame in range(self.opt.frames_D_V):
fake.append(self.img_gen[i+frame].unsqueeze(2))
fake = torch.cat(fake, dim=2)
D_fake = self.net_D_V(fake)
self.loss_ad_gen_v = self.GANloss(D_fake, True, False) * self.opt.lambda_g
total_loss = 0
for name in self.loss_names:
if name != 'dis_img_gen_v' and name != 'dis_img_gen':
total_loss += getattr(self, "loss_" + name)
total_loss.backward()