def log_one_train_epoch(self, x, label, argpred, train_loss):
#show train image on tensorboard
images_inv = inv_preprocess(x.clone().cpu(), self.args.show_num_images, numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label, self.args.show_num_images)
preds_colors = decode_labels(argpred, self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image('train/'+ str(index)+'/Images', img, self.current_epoch)
self.writer.add_image('train/'+ str(index)+'/Labels', lab, self.current_epoch)
self.writer.add_image('train/'+ str(index)+'/preds', color_pred, self.current_epoch)
if self.args.class_16:
PA = self.Eval.Pixel_Accuracy()
MPA_16, MPA = self.Eval.Mean_Pixel_Accuracy()
MIoU_16, MIoU = self.Eval.Mean_Intersection_over_Union()
FWIoU_16, FWIoU = self.Eval.Frequency_Weighted_Intersection_over_Union()
else:
PA = self.Eval.Pixel_Accuracy()
MPA = self.Eval.Mean_Pixel_Accuracy()
MIoU = self.Eval.Mean_Intersection_over_Union()
FWIoU = self.Eval.Frequency_Weighted_Intersection_over_Union()
self.logger.info('\nEpoch:{}, train PA1:{}, MPA1:{}, MIoU1:{}, FWIoU1:{}'.format(self.current_epoch, PA, MPA,
MIoU, FWIoU))
self.writer.add_scalar('train_PA', PA, self.current_epoch)
self.writer.add_scalar('train_MPA', MPA, self.current_epoch)
self.writer.add_scalar('train_MIoU', MIoU, self.current_epoch)
self.writer.add_scalar('train_FWIoU', FWIoU, self.current_epoch)
tr_loss = sum(train_loss)/len(train_loss) if isinstance(train_loss, list) else train_loss
self.writer.add_scalar('train_loss', tr_loss, self.current_epoch)
tqdm.write("The average loss of train epoch-{}-:{}".format(self.current_epoch, tr_loss))
def validate(self):
self.logger.info('validating one epoch...')
self.Eval.reset()
with torch.no_grad():
tqdm_batch = tqdm(self.dataloader.val_loader,
total=self.dataloader.valid_iterations,
desc="Val Epoch-{}-".format(self.current_epoch +
1))
val_loss = []
self.model.eval()
i = 0
count = 0
for x, y, id in tqdm_batch:
i += 1
if self.cuda:
x, y = x.to(self.device), y.to(device=self.device,
dtype=torch.long)
# model
pred = self.model(x)
if isinstance(pred, tuple):
pred_2 = pred[1]
pred = pred[0]
y = torch.squeeze(y, 1)
if self.args.flip:
pred_P = F.softmax(pred, dim=1)
def flip(x, dim):
dim = x.dim() + dim if dim < 0 else dim
inds = tuple(
slice(None, None) if i != dim else x.
new(torch.arange(x.size(i) -
1, -1, -1).tolist()).long()
for i in range(x.dim()))
return x[inds]
x_flip = flip(x, -1)
pred_flip = self.model(x_flip)
if isinstance(pred_flip, tuple):
pred_flip = pred_flip[0]
pred_P_flip = F.softmax(pred_flip, dim=1)
pred_P_2 = flip(pred_P_flip, -1)
pred_c = (pred_P + pred_P_2) / 2
pred = pred_c.data.cpu().numpy()
else:
pred = pred.data.cpu().numpy()
label = y.cpu().numpy()
argpred = np.argmax(pred, axis=1)
self.Eval.add_batch(label, argpred)
if i == self.dataloader.valid_iterations:
break
if i % 20 == 0 and self.args.image_summary:
#show val result on tensorboard
images_inv = inv_preprocess(
x.clone().cpu(),
self.args.show_num_images,
numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label,
self.args.show_num_images)
preds_colors = decode_labels(argpred,
self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(
zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image('eval/' + str(index) + '/Images',
img, self.current_epoch)
self.writer.add_image('eval/' + str(index) + '/Labels',
lab, self.current_epoch)
self.writer.add_image('eval/' + str(index) + '/preds',
color_pred, self.current_epoch)
#show val result on tensorboard
if self.args.image_summary:
images_inv = inv_preprocess(
x.clone().cpu(),
self.args.show_num_images,
numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label, self.args.show_num_images)
preds_colors = decode_labels(argpred,
self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(
zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image('0Images/' + str(index), img,
self.current_epoch)
self.writer.add_image('a' + str(index) + '/Labels', lab,
self.current_epoch)
self.writer.add_image('a' + str(index) + '/preds',
color_pred, self.current_epoch)
if self.args.multi:
self.writer.add_image('a' + str(index) + '/preds_2',
preds_colors_2[index],
self.current_epoch)
self.writer.add_image('a' + str(index) + '/preds_c',
preds_colors_c[index],
self.current_epoch)
# get eval result
if self.args.class_16:
def val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA_16, MPA_13 = Eval.Mean_Pixel_Accuracy()
MIoU_16, MIoU_13 = Eval.Mean_Intersection_over_Union()
FWIoU_16, FWIoU_13 = Eval.Frequency_Weighted_Intersection_over_Union(
)
PC_16, PC_13 = Eval.Mean_Precision()
print("########## Eval{} ############".format(name))
self.logger.info(
'\nEpoch:{:.3f}, {} PA:{:.3f}, MPA_16:{:.3f}, MIoU_16:{:.3f}, FWIoU_16:{:.3f}, PC_16:{:.3f}'
.format(self.current_epoch, name, PA, MPA_16, MIoU_16,
FWIoU_16, PC_16))
self.logger.info(
'\nEpoch:{:.3f}, {} PA:{:.3f}, MPA_13:{:.3f}, MIoU_13:{:.3f}, FWIoU_13:{:.3f}, PC_13:{:.3f}'
.format(self.current_epoch, name, PA, MPA_13, MIoU_13,
FWIoU_13, PC_13))
return PA, MPA_13, MIoU_13, FWIoU_13
else:
def val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA = Eval.Mean_Pixel_Accuracy()
MIoU = Eval.Mean_Intersection_over_Union()
FWIoU = Eval.Frequency_Weighted_Intersection_over_Union()
PC = Eval.Mean_Precision()
print("########## Eval{} ############".format(name))
self.logger.info(
'\nEpoch:{:.3f}, {} PA1:{:.3f}, MPA1:{:.3f}, MIoU1:{:.3f}, FWIoU1:{:.3f}, PC:{:.3f}'
.format(self.current_epoch, name, PA, MPA, MIoU, FWIoU,
PC))
return PA, MPA, MIoU, FWIoU
PA, MPA, MIoU, FWIoU = val_info(self.Eval, "")
name_classes, mIoUs = self.Eval.Print_Every_class_Eval()
#ipdb.set_trace()
row1 = []
row2 = []
with open(args.checkpoint_dir + '/mIoU.csv', 'a') as csvFile:
writer = csv.writer(csvFile)
for ind_class in range(len(name_classes) - 1):
row1.append(name_classes[ind_class])
row2.append(round(mIoUs[ind_class] * 100, 2))
row1.extend(['mIoU'])
row2.extend([round(np.nanmean(MIoU) * 100, 2)])
#row2.extend([round(np.mean(mIoUs[[0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 15, 17, 18]]) * 100, 2)])
#row2.extend([round(np.mean(mIoUs[[0, 1, 2, 6, 7, 8, 10, 11, 12, 13, 15, 17, 18]]) * 100, 2)])
writer.writerow(row1)
writer.writerow(row2)
csvFile.close()
tqdm_batch.close()
return PA, MPA, MIoU, FWIoU
def validate(self):
self.logger.info('validating one epoch...')
self.Eval.reset()
with torch.no_grad():
tqdm_batch = tqdm(self.dataloader.val_loader, total=self.dataloader.valid_iterations, desc="Val Epoch-{}-".format(self.current_epoch + 1))
self.model.eval()
i = 0
for x, y, id in tqdm_batch:
i += 1
if self.cuda:
x, y = x.to(self.device), y.to(device=self.device, dtype=torch.long)
# model
pred = self.model(x)[0]
y = torch.squeeze(y, 1)
if self.args.flip:
pred_P = F.softmax(pred, dim=1)
def flip(x, dim):
dim = x.dim() + dim if dim < 0 else dim
inds = tuple(slice(None, None) if i != dim
else x.new(torch.arange(x.size(i)-1, -1, -1).tolist()).long()
for i in range(x.dim()))
return x[inds]
x_flip = flip(x, -1)
pred_flip = self.model(x_flip)[0]
pred_P_flip = F.softmax(pred_flip, dim=1)
pred_P_2 = flip(pred_P_flip, -1)
pred_c = (pred_P+pred_P_2)/2
pred = pred_c.data.cpu().numpy()
else:
pred = pred.data.cpu().numpy()
label = y.cpu().numpy()
argpred = np.argmax(pred, axis=1)
self.Eval.add_batch(label, argpred)
if i == self.dataloader.valid_iterations:
break
if i % 20 ==0 and self.args.image_summary:
#show val result on tensorboard
images_inv = inv_preprocess(x.clone().cpu(), self.args.show_num_images, numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label, self.args.num_classes, self.args.show_num_images)
preds_colors = decode_labels(argpred, self.args.num_classes, self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image('eval/'+ str(index)+'/Images', img, self.current_epoch)
self.writer.add_image('eval/'+ str(index)+'/Labels', lab, self.current_epoch)
self.writer.add_image('eval/'+ str(index)+'/preds', color_pred, self.current_epoch)
#show val result on tensorboard
if self.args.image_summary:
images_inv = inv_preprocess(x.clone().cpu(), self.args.show_num_images, numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label, self.args.num_classes, self.args.show_num_images)
preds_colors = decode_labels(argpred, self.args.num_classes, self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image('0Images/'+str(index), img, self.current_epoch)
self.writer.add_image('a'+str(index)+'/Labels', lab, self.current_epoch)
self.writer.add_image('a'+str(index)+'/preds', color_pred, self.current_epoch)
# get eval result
if self.args.class_16:
def val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA_16, MPA_13 = Eval.Mean_Pixel_Accuracy()
MIoU_16, MIoU_13 = Eval.Mean_Intersection_over_Union()
FWIoU_16, FWIoU_13 = Eval.Frequency_Weighted_Intersection_over_Union()
PC_16, PC_13 = Eval.Mean_Precision()
print("########## Eval{} ############".format(name))
self.logger.info('\nEpoch:{:.3f}, {} PA:{:.3f}, MPA_16:{:.3f}, MIoU_16:{:.3f}, FWIoU_16:{:.3f}, PC_16:{:.3f}'.format(self.current_epoch, name, PA, MPA_16, MIoU_16, FWIoU_16, PC_16))
self.logger.info('\nEpoch:{:.3f}, {} PA:{:.3f}, MPA_13:{:.3f}, MIoU_13:{:.3f}, FWIoU_13:{:.3f}, PC_13:{:.3f}'.format(self.current_epoch, name, PA, MPA_13, MIoU_13, FWIoU_13, PC_13))
return PA, MPA_16, MIoU_16, FWIoU_16
else:
def val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA = Eval.Mean_Pixel_Accuracy()
MIoU = Eval.Mean_Intersection_over_Union()
FWIoU = Eval.Frequency_Weighted_Intersection_over_Union()
PC = Eval.Mean_Precision()
print("########## Eval{} ############".format(name))
self.logger.info('\nEpoch:{:.3f}, {} PA1:{:.3f}, MPA1:{:.3f}, MIoU1:{:.3f}, FWIoU1:{:.3f}, PC:{:.3f}'.format(self.current_epoch, name, PA, MPA, MIoU, FWIoU, PC))
return PA, MPA, MIoU, FWIoU
PA, MPA, MIoU, FWIoU = val_info(self.Eval, "")
self.Eval.Print_Every_class_Eval()
tqdm_batch.close()
return PA, MPA, MIoU, FWIoU
def validate_source(self):
self.logger.info('\nvalidating source domain...')
self.Eval.reset()
with torch.no_grad():
tqdm_batch = tqdm(self.source_val_dataloader, total=self.dataloader.valid_iterations,
desc="Source Val Epoch-{}-".format(self.current_epoch + 1))
self.model.eval()
i = 0
for x, y, id in tqdm_batch:
# y.to(torch.long)
if self.cuda:
x, y = x.to(self.device), y.to(device=self.device, dtype=torch.long)
# model
pred = self.model(x)
if isinstance(pred, tuple):
pred_2 = pred[1]
pred = pred[0]
pred_P = F.softmax(pred, dim=1)
pred_P_2 = F.softmax(pred_2, dim=1)
y = torch.squeeze(y, 1)
pred = pred.data.cpu().numpy()
label = y.cpu().numpy()
argpred = np.argmax(pred, axis=1)
self.Eval.add_batch(label, argpred)
i += 1
if i == self.dataloader.valid_iterations:
break
#show val result on tensorboard
images_inv = inv_preprocess(x.clone().cpu(), self.args.show_num_images, numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label, self.args.show_num_images)
preds_colors = decode_labels(argpred, self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image('source_eval/'+str(index)+'/Images', img, self.current_epoch)
self.writer.add_image('source_eval/'+str(index)+'/Labels', lab, self.current_epoch)
self.writer.add_image('source_eval/'+str(index)+'/preds', color_pred, self.current_epoch)
if self.args.class_16:
def source_val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA_16, MPA_13 = Eval.Mean_Pixel_Accuracy()
MIoU_16, MIoU_13 = Eval.Mean_Intersection_over_Union()
FWIoU_16, FWIoU_13 = Eval.Frequency_Weighted_Intersection_over_Union()
PC_16, PC_13 = Eval.Mean_Precision()
print("########## Source Eval{} ############".format(name))
self.logger.info('\nEpoch:{:.3f}, source {} PA:{:.3f}, MPA_16:{:.3f}, MIoU_16:{:.3f}, FWIoU_16:{:.3f}, PC_16:{:.3f}'.format(self.current_epoch, name, PA, MPA_16,
MIoU_16, FWIoU_16, PC_16))
self.logger.info('\nEpoch:{:.3f}, source {} PA:{:.3f}, MPA_13:{:.3f}, MIoU_13:{:.3f}, FWIoU_13:{:.3f}, PC_13:{:.3f}'.format(self.current_epoch, name, PA, MPA_13,
MIoU_13, FWIoU_13, PC_13))
self.writer.add_scalar('source_PA'+name, PA, self.current_epoch)
self.writer.add_scalar('source_MPA_16'+name, MPA_16, self.current_epoch)
self.writer.add_scalar('source_MIoU_16'+name, MIoU_16, self.current_epoch)
self.writer.add_scalar('source_FWIoU_16'+name, FWIoU_16, self.current_epoch)
self.writer.add_scalar('source_MPA_13'+name, MPA_13, self.current_epoch)
self.writer.add_scalar('source_MIoU_13'+name, MIoU_13, self.current_epoch)
self.writer.add_scalar('source_FWIoU_13'+name, FWIoU_13, self.current_epoch)
return PA, MPA_13, MIoU_13, FWIoU_13
else:
def source_val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA = Eval.Mean_Pixel_Accuracy()
MIoU = Eval.Mean_Intersection_over_Union()
FWIoU = Eval.Frequency_Weighted_Intersection_over_Union()
PC = Eval.Mean_Precision()
self.writer.add_scalar('source_PA'+name, PA, self.current_epoch)
self.writer.add_scalar('source_MPA'+name, MPA, self.current_epoch)
self.writer.add_scalar('source_MIoU'+name, MIoU, self.current_epoch)
self.writer.add_scalar('source_FWIoU'+name, FWIoU, self.current_epoch)
print("########## Source Eval{} ############".format(name))
self.logger.info('\nEpoch:{:.3f}, source {} PA1:{:.3f}, MPA1:{:.3f}, MIoU1:{:.3f}, FWIoU1:{:.3f}, PC:{:.3f}'.format(self.current_epoch, name, PA, MPA,
MIoU, FWIoU, PC))
return PA, MPA, MIoU, FWIoU
PA, MPA, MIoU, FWIoU = source_val_info(self.Eval, "")
tqdm_batch.close()
is_best = MIoU > self.best_source_MIou
if is_best:
self.best_source_MIou = MIoU
self.best_source_iter = self.current_iter
self.logger.info("=>saving a new best source checkpoint...")
self.save_checkpoint(self.train_id+'source_best.pth')
else:
self.logger.info("=> The source MIoU of val does't improve.")
self.logger.info("=> The best source MIoU of val is {} at {}".format(self.best_source_MIou, self.best_source_iter))
return PA, MPA, MIoU, FWIoU
def validate(self, mode='val'):
self.logger.info('\nvalidating one epoch...')
self.Eval.reset()
with torch.no_grad():
tqdm_batch = tqdm(self.dataloader.val_loader, total=self.dataloader.valid_iterations,
desc="Val Epoch-{}-".format(self.current_epoch + 1))
if mode == 'val':
self.model.eval()
i = 0
for x, y, id in tqdm_batch:
if self.cuda:
x, y = x.to(self.device), y.to(device=self.device, dtype=torch.long)
# model
pred = self.model(x)
if isinstance(pred, tuple):
pred_2 = pred[1]
pred = pred[0]
pred_P = F.softmax(pred, dim=1)
pred_P_2 = F.softmax(pred_2, dim=1)
y = torch.squeeze(y, 1)
pred = pred.data.cpu().numpy()
label = y.cpu().numpy()
argpred = np.argmax(pred, axis=1)
self.Eval.add_batch(label, argpred)
#show val result on tensorboard
images_inv = inv_preprocess(x.clone().cpu(), self.args.show_num_images, numpy_transform=self.args.numpy_transform)
labels_colors = decode_labels(label, self.args.show_num_images)
preds_colors = decode_labels(argpred, self.args.show_num_images)
for index, (img, lab, color_pred) in enumerate(zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image(str(index)+'/Images', img, self.current_epoch)
self.writer.add_image(str(index)+'/Labels', lab, self.current_epoch)
self.writer.add_image(str(index)+'/preds', color_pred, self.current_epoch)
if self.args.class_16:
def val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA_16, MPA_13 = Eval.Mean_Pixel_Accuracy()
MIoU_16, MIoU_13 = Eval.Mean_Intersection_over_Union()
FWIoU_16, FWIoU_13 = Eval.Frequency_Weighted_Intersection_over_Union()
PC_16, PC_13 = Eval.Mean_Precision()
print("########## Eval{} ############".format(name))
self.logger.info('\nEpoch:{:.3f}, {} PA:{:.3f}, MPA_16:{:.3f}, MIoU_16:{:.3f}, FWIoU_16:{:.3f}, PC_16:{:.3f}'.format(self.current_epoch, name, PA, MPA_16,
MIoU_16, FWIoU_16, PC_16))
self.logger.info('\nEpoch:{:.3f}, {} PA:{:.3f}, MPA_13:{:.3f}, MIoU_13:{:.3f}, FWIoU_13:{:.3f}, PC_13:{:.3f}'.format(self.current_epoch, name, PA, MPA_13,
MIoU_13, FWIoU_13, PC_13))
self.writer.add_scalar('PA'+name, PA, self.current_epoch)
self.writer.add_scalar('MPA_16'+name, MPA_16, self.current_epoch)
self.writer.add_scalar('MIoU_16'+name, MIoU_16, self.current_epoch)
self.writer.add_scalar('FWIoU_16'+name, FWIoU_16, self.current_epoch)
self.writer.add_scalar('MPA_13'+name, MPA_13, self.current_epoch)
self.writer.add_scalar('MIoU_13'+name, MIoU_13, self.current_epoch)
self.writer.add_scalar('FWIoU_13'+name, FWIoU_13, self.current_epoch)
return PA, MPA_13, MIoU_13, FWIoU_13
else:
def val_info(Eval, name):
PA = Eval.Pixel_Accuracy()
MPA = Eval.Mean_Pixel_Accuracy()
MIoU = Eval.Mean_Intersection_over_Union()
FWIoU = Eval.Frequency_Weighted_Intersection_over_Union()
PC = Eval.Mean_Precision()
print("########## Eval{} ############".format(name))
self.logger.info('\nEpoch:{:.3f}, {} PA1:{:.3f}, MPA1:{:.3f}, MIoU1:{:.3f}, FWIoU1:{:.3f}, PC:{:.3f}'.format(self.current_epoch, name, PA, MPA,
MIoU, FWIoU, PC))
self.writer.add_scalar('PA'+name, PA, self.current_epoch)
self.writer.add_scalar('MPA'+name, MPA, self.current_epoch)
self.writer.add_scalar('MIoU'+name, MIoU, self.current_epoch)
self.writer.add_scalar('FWIoU'+name, FWIoU, self.current_epoch)
return PA, MPA, MIoU, FWIoU
PA, MPA, MIoU, FWIoU = val_info(self.Eval, "")
tqdm_batch.close()
return PA, MPA, MIoU, FWIoU
def validate(self, mode='target'):
"""Validate on target"""
self.logger.info('Validating')
self.evaluator.reset()
self.model.eval()
# Select dataloader
if mode == 'target':
val_loader = self.target_val_dataloader
elif mode == 'source':
val_loader = self.source_val_dataloader
else:
raise NotImplementedError()
# Loop
for val_idx, (x, y, id) in enumerate(
tqdm(val_loader, desc=f"Val Epoch {self.epoch + 1}")):
if mode == 'source' and val_idx >= self.cfg.data.source_val_iterations:
break
# Forward
x = x.to(self.device)
y = y.to(device=self.device, dtype=torch.long)
pred = self.model(x)
if isinstance(pred, tuple):
pred = pred[0]
# Convert to numpy
label = y.squeeze(dim=1).cpu().numpy()
argpred = np.argmax(pred.data.cpu().numpy(), axis=1)
# Add to evaluator
self.evaluator.add_batch(label, argpred)
# Tensorboard images
vis_imgs = 2
images_inv = inv_preprocess(x.clone().cpu(),
vis_imgs,
numpy_transform=True)
labels_colors = decode_labels(label, vis_imgs)
preds_colors = decode_labels(argpred, vis_imgs)
for index, (img, lab, predc) in enumerate(
zip(images_inv, labels_colors, preds_colors)):
self.writer.add_image(str(index) + '/images', img, self.epoch)
self.writer.add_image(str(index) + '/labels', lab, self.epoch)
self.writer.add_image(str(index) + '/preds', predc, self.epoch)
# Calculate and log
if self.cfg.data.source.kwargs.class_16:
PA = self.evaluator.Pixel_Accuracy()
MPA_16, MPA_13 = self.evaluator.Mean_Pixel_Accuracy()
MIoU_16, MIoU_13 = self.evaluator.Mean_Intersection_over_Union()
FWIoU_16, FWIoU_13 = self.evaluator.Frequency_Weighted_Intersection_over_Union(
)
PC_16, PC_13 = self.evaluator.Mean_Precision()
self.logger.info(
'Epoch:{:.3f}, PA:{:.3f}, MPA_16:{:.3f}, MIoU_16:{:.3f}, FWIoU_16:{:.3f}, PC_16:{:.3f}'
.format(self.epoch, PA, MPA_16, MIoU_16, FWIoU_16, PC_16))
self.logger.info(
'Epoch:{:.3f}, PA:{:.3f}, MPA_13:{:.3f}, MIoU_13:{:.3f}, FWIoU_13:{:.3f}, PC_13:{:.3f}'
.format(self.epoch, PA, MPA_13, MIoU_13, FWIoU_13, PC_13))
self.writer.add_scalar('PA', PA, self.epoch)
self.writer.add_scalar('MPA_16', MPA_16, self.epoch)
self.writer.add_scalar('MIoU_16', MIoU_16, self.epoch)
self.writer.add_scalar('FWIoU_16', FWIoU_16, self.epoch)
self.writer.add_scalar('MPA_13', MPA_13, self.epoch)
self.writer.add_scalar('MIoU_13', MIoU_13, self.epoch)
self.writer.add_scalar('FWIoU_13', FWIoU_13, self.epoch)
PA, MPA, MIoU, FWIoU = PA, MPA_13, MIoU_13, FWIoU_13
else:
PA = self.evaluator.Pixel_Accuracy()
MPA = self.evaluator.Mean_Pixel_Accuracy()
MIoU = self.evaluator.Mean_Intersection_over_Union()
FWIoU = self.evaluator.Frequency_Weighted_Intersection_over_Union()
PC = self.evaluator.Mean_Precision()
self.logger.info(
'Epoch:{:.3f}, PA1:{:.3f}, MPA1:{:.3f}, MIoU1:{:.3f}, FWIoU1:{:.3f}, PC:{:.3f}'
.format(self.epoch, PA, MPA, MIoU, FWIoU, PC))
self.writer.add_scalar('PA', PA, self.epoch)
self.writer.add_scalar('MPA', MPA, self.epoch)
self.writer.add_scalar('MIoU', MIoU, self.epoch)
self.writer.add_scalar('FWIoU', FWIoU, self.epoch)
return PA, MPA, MIoU, FWIoU
