def test(net, epoch, dataLoader, testF, config):
net.eval()
total_mask_loss = 0.0
dataprocess = tqdm(dataLoader)
result = {"TP": {i: 0 for i in range(8)}, "TA": {i: 0 for i in range(8)}}
for batch_item in dataprocess:
image, mask = batch_item['image'], batch_item['mask']
if torch.cuda.is_available():
image, mask = image.cuda(device=device_list[0]), mask.cuda(
device=device_list[0])
out = net(image)
mask_loss = MySoftmaxCrossEntropyLoss(nbclasses=config.NUM_CLASSES)(
out, mask)
# detach（）截断梯度的作用
total_mask_loss += mask_loss.detach().item()
pred = torch.argmax(F.softmax(out, dim=1), dim=1)
# 计算iou
result = compute_iou(pred, mask, result)
dataprocess.set_description_str("epoch:{}".format(epoch))
dataprocess.set_postfix_str("mask_loss:{:.4f}".format(mask_loss))
testF.write("Epoch:{} \n".format(epoch))
# 求出每一个类别的iou
for i in range(8):
result_string = "{}: {:.4f} \n".format(
i, result["TP"][i] / result["TA"][i])
print(result_string)
# 写入log文件
testF.write(result_string)
testF.write("Epoch:{}, mask loss is {:.4f} \n".format(
epoch, total_mask_loss / len(dataLoader)))
testF.flush()
def test(net, epoch, dataLoader, testF, config):
net.eval()
total_mask_loss = 0.0
dataprocess = tqdm(dataLoader)
result = {"TP": {i:0 for i in range(8)}, "TA":{i:0 for i in range(8)}}
for batch_item in dataprocess:
image, mask = batch_item['image'], batch_item['mask']
if torch.cuda.is_available():
image, mask = image.cuda(device=device_list[0]), mask.cuda(device=device_list[0])
out = net(image)
mask_loss = loss_func(out, mask, config.NUM_CLASSES, epoch)
total_mask_loss += mask_loss.detach().item()
pred = torch.argmax(F.softmax(out, dim=1), dim=1)
result = compute_iou(pred, mask, result)
dataprocess.set_description_str("epoch:{}".format(epoch))
dataprocess.set_postfix_str("mask_loss:{:.4f}".format(mask_loss))
testF.write("Epoch:{} \n".format(epoch))
miou = 0
for i in range(8):
iou_i = result["TP"][i]/result["TA"][i]
result_string = "{}: {:.4f} \n".format(i, iou_i)
print(result_string)
testF.write(result_string)
miou += iou_i
miou /= 8
miou_string = "{}: {:.4f} \n".format('miou', miou)
print(miou_string)
testF.write(miou_string)
testF.write("Epoch:{}, mask loss is {:.4f} \n".format(epoch, total_mask_loss / len(dataLoader)))
testF.flush()
def val_epoch(net, epoch, dataLoader, valF, args):
logger.info("======start val epoch step=======")
net.eval()
total_mask_loss = 0.0
dataprocess = tqdm(dataLoader)
result = {"TP": {i: 0 for i in range(8)}, "TA": {i: 0 for i in range(8)}}
evaluator = Evaluator(args.number_class)
for batch_item in dataprocess:
image, mask = batch_item['image'], batch_item['mask']
out = net(image)
mask_loss = MySoftmaxCrossEntropyLoss(nbclasses=args.number_class)(
out, mask)
total_mask_loss += mask_loss.detach().item()
pred = torch.argmax(F.softmax(out, dim=1), dim=1)
result = compute_iou(pred, mask, result)
dataprocess.set_description_str("epoch:{}".format(epoch))
dataprocess.set_postfix_str("mask_loss:{:.4f}".format(mask_loss))
Acc = evaluator.Pixel_Accuracy()
Acc_class = evaluator.Pixel_Accuracy_Class()
mIoU = evaluator.Mean_Intersection_over_Union()
FWIoU = evaluator.Frequency_Weighted_Intersection_over_Union()
valF.write("Epoch:{}, val/mIoU is {:.4f} \n".format(epoch, mIoU))
valF.write("Epoch:{}, val/Acc is {:.4f} \n".format(epoch, Acc))
valF.write("Epoch:{}, val/Acc_class is {:.4f} \n".format(epoch, Acc_class))
valF.write("Epoch:{}, val/FWIoU is {:.4f} \n".format(epoch, FWIoU))
for i in range(8):
result_string = "{}: {:.4f} \n".format(
i, result["TP"][i] / result["TA"][i])
logger.info("val class result {}".format(result_string))
valF.write(result_string)
valF.write("Epoch:{}, mask loss is {:.4f} \n".format(
epoch, total_mask_loss / len(dataLoader)))
logger.info("Acc:{}, Acc_class:{}, mIoU:{}, fwIoU: {}".format(
Acc, Acc_class, mIoU, FWIoU))
valF.flush()
def valid(epoch, dataloader, model, criterion, optimizer):
model.eval()
total_mask_loss = 0.0
data_process = tqdm(dataloader)
result = {"TP": {i: 0 for i in range(8)}, "TA": {i: 0 for i in range(8)}}
for step, sample in enumerate(data_process):
img = sample['image']
mask = sample['label']
img = img.type(torch.FloatTensor)
if torch.cuda.is_available():
img = img.to(device)
mask = mask.to(device)
output = model(img)
loss = criterion(output, mask.long())
total_mask_loss += loss.detach().item()
pre = torch.argmax(func.softmax(output, dim=1), dim=1)
result = compute_iou(pre, mask, result)
data_process.set_description_str("epoch:{}".format(epoch))
data_process.set_postfix_str("mask_loss:{:.4f}".format(loss.item()))
from utils.label_preprocess import encode_labels, decode_label_color
from PIL import Image
import numpy as np
from utils.data_preprocess import ImageAug, DeformAug, ScaleAug
from torchvision import transforms
from utils.metric import compute_iou
'''
just for testing the function work
'''
dir = r'E:/data/Label/Label_road02/Label/Record001/Camera 5/170927_063813228_Camera_5_bin.png'
color_dir = r'E:/data/ColorImage/road02/Record001/Camera 5/170927_063813228_Camera_5.jpg'
img = Image.open(dir)
color_img = Image.open(color_dir)
gray_img = Image.open(dir)
gray_numpy = np.array(gray_img)
color_numpy = np.array(color_img)
gray_numpy = encode_labels(gray_numpy)
nof = gray_numpy == 5
print(np.sum(nof))
process = transforms.Compose(
[ImageAug(), DeformAug(), ScaleAug()]
)
result = {'TP': {i:0 for i in range(8)}, 'TA': {i:0 for i in range(8)}}
result = compute_iou(gray_numpy, gray_numpy, result)
for i in range(8):
print('{} iou is : {}'.format(i, result['TP'][i]/(result['TA'][i]+1)))
def main():
# define model
if cfg.MODEL == 'deeplabv3+':
net = Deeplabv3plus(class_num=cfg.CLASS_NUM)
else:
net = UNetv1(class_num=cfg.CLASS_NUM)
# load pretrained weights
checkpoint = torch.load(os.path.join(cfg.LOG_DIR, cfg.FINAL_WEIGHTS))
net.load_state_dict(checkpoint['state_dict'])
# use cuda if available
if torch.cuda.is_available():
net = net.cuda(device=cfg.DEVICE_LIST[0])
# set to eval
net.eval()
# create output dir
current_date = str(pd.datetime.now()).split('.')[0]
save_path = os.path.join(cfg.OUTPUT_DIR, current_date)
if not os.path.exists(save_path):
os.makedirs(save_path)
if cfg.INFER_MODE == 'eval' and cfg.SRC_IMG.endswith('.csv'):
test_dataset = LaneSegTestDataset(cfg.SRC_IMG)
eval_data_loader = DataLoader(test_dataset,
batch_size=1,
shuffle=False,
drop_last=False)
dataprocess = tqdm(eval_data_loader)
# init confusion matrix with all zeros
confusion_matrix = {
"TP": {i: 0
for i in range(8)},
"TN": {i: 0
for i in range(8)},
"FP": {i: 0
for i in range(8)},
"FN": {i: 0
for i in range(8)}
}
for data_item in dataprocess:
# get batch data
data_image, data_label, img_path = data_item['image'], \
data_item['label'],\
data_item['img_path']
if torch.cuda.is_available():
data_image, data_label = data_image.cuda(device=cfg.DEVICE_LIST[0]), \
data_label.cuda(device=cfg.DEVICE_LIST[0])
# forward to get output
data_out = net(data_image)
data_out = data_out.squeeze(0) # (8,w1,h1)
pred = torch.argmax(F.softmax(data_out, dim=0), dim=0) # (w1,h1)
# save predict label
img_name = img_path.split('/')[-1]
label_output(pred, save_path, img_name)
# update confusion matrix in eval mode
confusion_matrix = update_confusion_matrix(pred, data_label,
confusion_matrix)
# compute metric in eval mode
ious = compute_iou(confusion_matrix)
m_iou = compute_mean(ious)
precisions = compute_precision(confusion_matrix)
m_precision = compute_mean(precisions)
recalls = compute_recall(confusion_matrix)
m_recall = compute_mean(recalls)
# save eval information
with open(os.path.join(save_path, 'eval_result.txt'), 'w') as f:
f.write('inference mode: "eval" \n')
f.write('source csv file: {} \n'.format(cfg.SRC_IMG))
f.write("mean iou: {:.4f} \n".format(m_iou))
for i in range(8):
f.write("class '{}' iou : {:.4f} \n".format(i, ious[i]))
f.write("mean precision: {:.4f} \n".format(m_precision))
for i in range(8):
f.write("class '{}' precision : {:.4f} \n".format(
i, precisions[i]))
f.write("mean recall: {:.4f} \n".format(m_recall))
for i in range(8):
f.write("class '{}' recall : {:.4f} \n".format(i, recalls[i]))
elif cfg.INFER_MODE == 'test':
csv_name = 'test_mode_{}.csv'.format(current_date)
get_img_list(csv_name)
test_dataset = LaneSegTestDataset(csv_name)
eval_data_loader = DataLoader(test_dataset,
batch_size=1,
shuffle=False,
drop_last=False)
dataprocess = tqdm(eval_data_loader)
for data_item in dataprocess:
# get batch data
data_image, img_path = data_item['image'], data_item['img_path']
if torch.cuda.is_available():
data_image = data_image.cuda(device=cfg.DEVICE_LIST[0])
# forward to get output
data_out = net(data_image)
data_out = data_out.squeeze(0) # (8,w1,h1)
pred = torch.argmax(F.softmax(data_out, dim=0), dim=0) # (w1,h1)
# save predict label
img_name = img_path.split('/')[-1]
label_output(pred, save_path, img_name)
with open(os.path.join(save_path, 'test_result.txt'), 'w') as f:
f.write('inference mode: "test" \n')
f.write('source csv file: {} \n'.format(csv_name))
else:
raise ValueError(
'Please check the inference config parameters:"INFER_MODE" and "SRC_IMG"'
)
def eval_epoch(net, epoch, data_loader, eval_log):
# set to eval
net.eval()
total_loss = 0.0
data_process = tqdm(data_loader)
# init confusion matrix with all zeros
confusion_matrix = {
"TP": {i: 0
for i in range(8)},
"TN": {i: 0
for i in range(8)},
"FP": {i: 0
for i in range(8)},
"FN": {i: 0
for i in range(8)}
}
for batch_item in data_process:
# get batch data
batch_image, batch_label = batch_item['image'], batch_item['label']
if cfg.MULTI_GPU:
batch_image, batch_label = batch_image.cuda(device=cfg.DEVICE_LIST[0]), \
batch_label.cuda(device=cfg.DEVICE_LIST[0])
else:
batch_image, batch_label = batch_image.cuda(), \
batch_label.cuda()
# forward to get output
batch_out = net(batch_image)
# compute loss
# batch_loss = CrossEntropyLoss(cfg.CLASS_NUM)(batch_out, batch_label)
batch_loss = FocalLoss(cfg.CLASS_NUM)(batch_out, batch_label)
total_loss += batch_loss.detach().item()
# get prediction, shape and value type same as batch_label
pred = torch.argmax(F.softmax(batch_out, dim=1), dim=1)
# compute confusion matrix using batch data
confusion_matrix = update_confusion_matrix(pred, batch_label,
confusion_matrix)
# print batch result
data_process.set_description_str("epoch:{}".format(epoch))
data_process.set_postfix_str("batch_loss:{:.4f}".format(batch_loss))
eval_loss = total_loss / len(data_loader)
# compute metric
epoch_ious = compute_iou(confusion_matrix)
epoch_m_iou = compute_mean(epoch_ious)
epoch_precisions = compute_precision(confusion_matrix)
epoch_m_precision = compute_mean(epoch_precisions)
epoch_recalls = compute_recall(confusion_matrix)
epoch_m_recall = compute_mean(epoch_recalls)
# print eval iou every epoch
print('mean iou: {} \n'.format(epoch_m_iou))
for i in range(8):
print_string = "class '{}' iou : {:.4f} \n".format(i, epoch_ious[i])
print(print_string)
# make log string
log_values = [epoch, eval_loss, epoch_m_iou] + \
epoch_ious + [epoch_m_precision] + \
epoch_precisions + [epoch_m_recall] + epoch_recalls
log_values = [str(v) for v in log_values]
log_string = ','.join(log_values)
eval_log.write(log_string + '\n')
eval_log.flush()
