def test(test_loader, data_list, model, classes, mean, std, base_size, crop_h,
crop_w, scales, gray_folder, colors):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (input, _) in enumerate(test_loader):
data_time.update(time.time() - end)
prediction = predict_whole_img(model, input)
# prediction=prediction[0].numpy()
prediction = np.argmax(prediction, axis=3)
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
for g in range(0, prediction.shape[0]):
check_makedirs(gray_folder)
gray = np.uint8(prediction[g])
image_path, _ = data_list[i * args.batch_size_gen + g]
image_name = image_path.split('/')[-1].split('.')[0]
gray_path = os.path.join(gray_folder, image_name + '.png')
cv2.imwrite(gray_path, gray)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def test(test_loader, data_list, model, cod_folder, coee_folder):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
check_makedirs(cod_folder)
check_makedirs(coee_folder)
for i, (input, _, _) in enumerate(test_loader):
data_time.update(time.time() - end)
with torch.no_grad():
cod_pred, coee_pred = model(input)
cod_pred, coee_pred = torch.sigmoid(cod_pred), torch.sigmoid(coee_pred)
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
cod = np.uint8(cod_pred.squeeze().detach().cpu().numpy() * 255)
coee = np.uint8(coee_pred.squeeze().detach().cpu().numpy() * 255)
image_path, _, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
cod_path = os.path.join(cod_folder, image_name + '.png')
coee_path = os.path.join(coee_folder, image_name + '.png')
cv2.imwrite(cod_path, cod)
cv2.imwrite(coee_path, coee)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def test(test_loader, data_list, model, classes, mean, std, base_size, crop_h,
crop_w, scales, gray_folder, color_folder, colors):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (input, _, image_paths) in enumerate(test_loader):
data_time.update(time.time() - end)
input = np.squeeze(input.numpy(), axis=0)
image = np.transpose(input, (1, 2, 0))
# print(np.amax(input), np.amin(input), np.median(input))
# print(np.amax(image), np.amin(image), np.median(image))
h, w, _ = image.shape
prediction = np.zeros((h, w, classes), dtype=float)
for scale in scales:
long_size = round(scale * base_size)
new_h = long_size
new_w = long_size
if h > w:
new_w = round(long_size / float(h) * w)
else:
new_h = round(long_size / float(w) * h)
image_scale = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
prediction += scale_process(model, image_scale, classes, crop_h,
crop_w, h, w, mean, std)
prediction /= len(scales)
prediction = np.argmax(prediction, axis=2)
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
check_makedirs(gray_folder)
check_makedirs(color_folder)
gray = np.uint8(prediction)
color = colorize(gray, colors)
image_path, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
gray_path = os.path.join(gray_folder, image_name + '.png')
color_path = os.path.join(color_folder, image_name + '.png')
cv2.imwrite(gray_path, gray)
color.save(color_path)
cv2.imwrite(color_path.replace('.png', '_RGB_scale.png'), image_scale)
# os.system('cp -r %s %s'%(image_path, color_path.replace('.png', '_RGB.png')))
image_RGB = args.read_image(image_path)
cv2.imwrite(color_path.replace('.png', '_RGB.png'), image_RGB)
print('Result saved to %s; originally from %s' %
(color_path, image_path))
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def test(test_loader, data_list, model, classes, base_size, crop_h, crop_w,
scales, binary_folder):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (input, _) in enumerate(test_loader):
data_time.update(time.time() - end)
input = np.squeeze(input.numpy(), axis=0)
image = np.transpose(input, (1, 2, 0))
h, w, _ = image.shape
prediction = np.zeros((h, w), dtype=float)
for scale in scales:
long_size = round(scale * base_size)
new_h = long_size
new_w = long_size
if h > w:
new_w = round(long_size / float(h) * w)
else:
new_h = round(long_size / float(w) * h)
image_scale = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
prediction += scale_process(model, image_scale, classes, crop_h,
crop_w, h, w)
prediction /= len(scales)
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
check_makedirs(binary_folder)
image_path, _ = data_list[i]
image_name = os.path.split(image_path)[-1]
image_name = image_name.replace('png', 'npy')
save_path = os.path.join(binary_folder, image_name)
np.save(save_path, prediction)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def ensemble(data_list,
h,
w,
ensemble_way='mean_of_mean_and_max',
threshold=0.85):
for i, (image_path, target_path) in enumerate(data_list):
image_name = os.path.split(image_path)[-1]
pred_npy_name = image_name.replace('png', 'npy')
prediction = np.zeros((h, w, args.folds * len(args.model_path)),
dtype=float)
for fold_i in range(args.folds):
for idx, model_i in enumerate(args.model_path):
single_npy_path = args.result_save_dir + 'Fold{}/epoch_{}/'.format(
fold_i, model_i) + pred_npy_name
pred_npy = np.load(single_npy_path)
prediction[:, :,
fold_i * len(args.model_path) + idx] = pred_npy
if ensemble_way == 'mean':
prediction = np.mean(prediction, axis=-1)
elif ensemble_way == 'max':
prediction = np.max(prediction, axis=-1)
elif ensemble_way == 'mean_of_mean_and_max':
mean_prediction = np.mean(prediction, axis=-1)
max_prediction = np.max(prediction, axis=-1)
final_prediction = np.zeros((h, w, 2), dtype=float)
final_prediction[:, :, 0] = mean_prediction
final_prediction[:, :, 1] = max_prediction
prediction = np.mean(final_prediction, axis=-1)
prediction_cp = prediction.copy()
prediction[(prediction_cp > threshold)
& (prediction_cp == threshold)] = 0
prediction[prediction_cp < threshold] = 255
ensemble_folder = args.result_save_dir + 'ensemble/'
check_makedirs(ensemble_folder)
binary = np.uint8(prediction)
binary_path = os.path.join(ensemble_folder, image_name)
cv2.imwrite(binary_path, binary)
logger.info('save ensemble file finish!')
def test(test_loader, data_list, model, classes, mean, std, base_size, crop_h,
crop_w, scales, gray_folder, color_folder, colors):
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (input, _) in enumerate(test_loader):
data_time.update(time.time() - end)
input = np.squeeze(input.numpy(), axis=0)
image = np.transpose(input, (1, 2, 0))
h, w, _ = image.shape
prediction = np.zeros((h, w, classes), dtype=float)
for scale in scales:
long_size = round(scale * base_size)
new_h = long_size
new_w = long_size
if h > w:
new_w = round(long_size / float(h) * w)
else:
new_h = round(long_size / float(w) * h)
image_scale = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
prediction += scale_process(model, image_scale, classes, crop_h,
crop_w, h, w, mean, std)
prediction /= len(scales)
prediction = np.argmax(prediction, axis=2)
batch_time.update(time.time() - end)
end = time.time()
check_makedirs(gray_folder)
check_makedirs(color_folder)
gray = np.uint8(prediction)
color = colorize(gray, colors)
image_path, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
gray_path = os.path.join(gray_folder, image_name + '.png')
color_path = os.path.join(color_folder, image_name + '.png')
cv2.imwrite(gray_path, gray)
color.save(color_path)
def test(test_loader, data_list, model, classes, mean, std, gray_folder,
color_folder, derain_folder, edge_folder, colors):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (_, input, _, _) in enumerate(test_loader):
data_time.update(time.time() - end)
with torch.no_grad():
derain_outs, seg_outs, edge_outs = model(input)
derain_outs = derain_outs.cpu().numpy()
seg_outs = seg_outs.cpu().numpy()
edge_outs = edge_outs.cpu().numpy()
# process derain img
derain_outs = np.transpose(derain_outs, (0, 2, 3, 1)).squeeze(axis=0)
derain_outs *= std
derain_outs += mean
derain_outs = np.clip(derain_outs, a_max=255, a_min=0)
derain_outs = derain_outs.astype('uint8')
derain_outs = cv2.cvtColor(derain_outs.astype('uint8'),
cv2.COLOR_RGB2BGR)
# process seg pred
seg_outs = np.transpose(seg_outs, (0, 2, 3, 1))
seg_outs = np.argmax(seg_outs, axis=3).squeeze(axis=0)
# process edge pred
edge_outs = np.transpose(edge_outs,
(0, 2, 3, 1)).squeeze(axis=3).squeeze(axis=0)
edge_outs = np.clip(edge_outs, a_max=1, a_min=0)
edge_outs = (edge_outs * 255).astype('uint8')
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
check_makedirs(gray_folder)
check_makedirs(color_folder)
check_makedirs(derain_folder)
check_makedirs(edge_folder)
gray = np.uint8(seg_outs)
color = colorize(gray, colors)
image_path, _, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
gray_path = os.path.join(gray_folder, image_name + '.png')
color_path = os.path.join(color_folder, image_name + '.png')
derain_path = os.path.join(derain_folder, image_name + '.png')
edge_path = os.path.join(edge_folder, image_name + '.png')
cv2.imwrite(gray_path, gray)
cv2.imwrite(derain_path, derain_outs)
cv2.imwrite(edge_path, edge_outs)
color.save(color_path)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def test(test_loader, data_list, model, classes, mean, std, base_size, crop_h,
crop_w, scales, gray_folder, color_folder, derain_folder, edge_folder,
colors):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (_, input, _, _) in enumerate(test_loader):
data_time.update(time.time() - end)
input = np.squeeze(input.numpy(), axis=0)
image = np.transpose(input, (1, 2, 0))
h, w, _ = image.shape
derain_prediction = np.zeros((h, w, 3), dtype=float)
seg_prediction = np.zeros((h, w, classes), dtype=float)
edge_prediction = np.zeros((h, w), dtype=float)
for scale in scales:
long_size = round(scale * base_size)
new_h = long_size
new_w = long_size
if h > w:
new_w = round(long_size / float(h) * w)
else:
new_h = round(long_size / float(w) * h)
image_scale = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
temp_derain_prediction, temp_seg_prediction, temp_edge_prediction = scale_process(
model, image_scale, classes, crop_h, crop_w, h, w, mean, std)
derain_prediction += temp_derain_prediction
seg_prediction += temp_seg_prediction
edge_prediction += temp_edge_prediction
derain_prediction /= len(scales)
seg_prediction /= len(scales)
edge_prediction /= len(scales)
# seg_prediction = np.argmax(seg_prediction, axis=2)
# process derain img
derain_outs = derain_prediction
derain_outs *= std
derain_outs += mean
derain_outs = np.clip(derain_outs, a_max=255, a_min=0)
derain_outs = derain_outs.astype('uint8')
derain_outs = cv2.cvtColor(derain_outs.astype('uint8'),
cv2.COLOR_RGB2BGR)
# process seg pred
seg_outs = seg_prediction
seg_outs = np.argmax(seg_outs, axis=2).squeeze()
# process edge pred
edge_outs = edge_prediction
edge_outs = np.clip(edge_outs, a_max=1, a_min=0)
edge_outs = (edge_outs * 255).astype('uint8')
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
check_makedirs(gray_folder)
check_makedirs(color_folder)
check_makedirs(derain_folder)
check_makedirs(edge_folder)
gray = np.uint8(seg_outs)
color = colorize(gray, colors)
image_path, _, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
gray_path = os.path.join(gray_folder, image_name + '.png')
color_path = os.path.join(color_folder, image_name + '.png')
derain_path = os.path.join(derain_folder, image_name + '.png')
edge_path = os.path.join(edge_folder, image_name + '.png')
cv2.imwrite(gray_path, gray)
cv2.imwrite(derain_path, derain_outs)
cv2.imwrite(edge_path, edge_outs)
color.save(color_path)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def main():
global args, logger
args = get_parser('config/cod_mgl50.yaml')
check(args)
logger = get_logger()
os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(
str(x) for x in args.test_gpu)
logger.info(args)
logger.info("=> creating model ...")
logger.info("Classes: {}".format(args.classes))
value_scale = 255
mean = [0.485, 0.456, 0.406]
mean = [item * value_scale for item in mean]
std = [0.229, 0.224, 0.225]
std = [item * value_scale for item in std]
date_str = str(datetime.datetime.now().date())
save_folder = args.save_folder + '/' + date_str
check_makedirs(save_folder)
cod_folder = os.path.join(save_folder, 'cod')
coee_folder = os.path.join(save_folder, 'coee')
test_transform = transform.Compose([
transform.Resize((args.test_h, args.test_w)),
transform.ToTensor(),
transform.Normalize(mean=mean, std=std)
])
test_data = dataset.SemData(split=args.split,
data_root=args.data_root,
data_list=args.test_list,
transform=test_transform)
index_start = args.index_start
if args.index_step == 0:
index_end = len(test_data.data_list)
else:
index_end = min(index_start + args.index_step,
len(test_data.data_list))
test_data.data_list = test_data.data_list[index_start:index_end]
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=args.test_batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if not args.has_prediction:
if args.arch == 'mgl':
from model.mglnet import MGLNet
model = MGLNet(layers=args.layers,
classes=args.classes,
zoom_factor=args.zoom_factor,
pretrained=False,
args=args)
#logger.info(model)
model = torch.nn.DataParallel(model).cuda()
cudnn.benchmark = True
if os.path.isfile(args.model_path):
logger.info("=> loading checkpoint '{}'".format(args.model_path))
checkpoint = torch.load(args.model_path, map_location='cuda:0')
model.load_state_dict(checkpoint['state_dict'], strict=False)
logger.info("=> loaded checkpoint '{}', epoch {}".format(
args.model_path, checkpoint['epoch']))
else:
raise RuntimeError("=> no checkpoint found at '{}'".format(
args.model_path))
test(test_loader, test_data.data_list, model, cod_folder, coee_folder)
if args.split != 'test':
calc_acc(test_data.data_list, cod_folder, coee_folder)
def run_test(test_loader, data_list, model, classes, mean, std, base_size,
crop_h, crop_w, scales, gray_folder, color_folder, colors,
is_flip):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
is_test = 'test' in data_list[0][0]
for i, (input, _) in enumerate(test_loader):
data_time.update(time.time() - end)
input = np.squeeze(input.numpy(), axis=0)
image = np.transpose(input, (1, 2, 0))
h, w, _ = image.shape
prediction = np.zeros((h, w, classes), dtype=float)
for scale in scales:
long_size = round(scale * base_size)
new_h = long_size
new_w = long_size
if h > w:
new_w = round(long_size / float(h) * w)
else:
new_h = round(long_size / float(w) * h)
image_scale = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR)
prediction += scale_process(model,
image_scale,
classes,
crop_h,
crop_w,
h,
w,
mean,
std,
FLIP=is_flip)
prediction /= len(scales)
prediction = np.argmax(prediction, axis=2)
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
check_makedirs(gray_folder)
check_makedirs(color_folder)
gray = np.uint8(prediction)
color = colorize(gray, colors)
image_path, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
gray_path = os.path.join(gray_folder, image_name + '.png')
color_path = os.path.join(color_folder, image_name + '.png')
if is_test:
gray_labelid = trainID2labelID(gray)
cv2.imwrite(gray_path, gray_labelid)
else:
cv2.imwrite(gray_path, gray)
color.save(color_path)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def test(test_loader,
data_list,
model,
classes,
mean,
std,
base_size,
crop_h,
crop_w,
scales,
gray_folder,
color_folder,
colors,
is_multi_patch=True,
is_med=False):
"""
crop_h, crop_w = 713, 713
"""
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
for i, (input, gt) in enumerate(test_loader):
data_time.update(time.time() - end)
input = np.squeeze(input.numpy(), axis=0)
image = np.transpose(input, (1, 2, 0))
h, w, _ = image.shape #原始图像尺寸
prediction = np.zeros((h, w, classes), dtype=float)
for scale in scales:
long_size = round(scale * base_size) # 推理中图像底板设置成2048
new_h = long_size
new_w = long_size
if h > w:
new_w = round(long_size / float(h) * w)
else:
new_h = round(long_size / float(w) * h)
image_scale = cv2.resize(image, (new_w, new_h),
interpolation=cv2.INTER_LINEAR) #
if is_multi_patch:
print('inplace multi inference with patches')
prediction += scale_process(model, image_scale, classes,
crop_h, crop_w, h, w, mean, std)
else:
print('inplane one inference')
#prediction += scale_process_direct(model, image_scale, classes, crop_h, crop_w, h, w, mean, std)
prediction += scale_process(model, image_scale, classes,
new_h + 1, new_w + 1, h, w, mean,
std)
prediction /= len(scales)
prediction = np.argmax(prediction, axis=2)
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info(
'Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(
i + 1,
len(test_loader),
data_time=data_time,
batch_time=batch_time))
_, target_path = data_list[i]
image_name = get_image_name(target_path, is_med)
# print(image_name)
check_makedirs(gray_folder)
gray = np.uint8(prediction)
gray_path = os.path.join(gray_folder, image_name)
check_makedirs(Path(gray_path).parent)
cv2.imwrite(gray_path, gray)
check_makedirs(color_folder)
color = colorize(gray, colors)
color_path = os.path.join(color_folder, image_name)
color.save(color_path)
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
def test(model, criterion, names):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
batch_time = AverageMeter()
intersection_meter = AverageMeter()
union_meter = AverageMeter()
target_meter = AverageMeter()
model.eval()
rooms = sorted(os.listdir(args.train_full_folder))
rooms_split = [
room for room in rooms if 'Area_{}'.format(args.test_area) in room
]
gt_all, pred_all = np.array([]), np.array([])
check_makedirs(args.save_folder)
pred_save, gt_save = [], []
for idx, room_name in enumerate(rooms_split):
data_room, label_room, index_room, gt = data_prepare(
os.path.join(args.train_full_folder, room_name))
batch_point = args.num_point * args.test_batch_size
batch_num = int(np.ceil(label_room.size / batch_point))
end = time.time()
output_room = np.array([])
for i in range(batch_num):
s_i, e_i = i * batch_point, min((i + 1) * batch_point,
label_room.size)
input, target, index = data_room[
s_i:e_i, :], label_room[s_i:e_i], index_room[s_i:e_i]
input = torch.from_numpy(input).float().view(
-1, args.num_point, input.shape[1])
target = torch.from_numpy(target).long().view(-1, args.num_point)
with torch.no_grad():
output = model(input.cuda())
loss = criterion(output, target.cuda()) # for reference
output = output.transpose(1, 2).contiguous().view(
-1, args.classes).data.cpu().numpy()
pred = np.argmax(output, axis=1)
intersection, union, target = intersectionAndUnion(
pred,
target.view(-1).data.cpu().numpy(), args.classes,
args.ignore_label)
accuracy = sum(intersection) / (sum(target) + 1e-10)
output_room = np.vstack([output_room, output
]) if output_room.size else output
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % args.print_freq == 0) or (i + 1 == batch_num):
logger.info(
'Test: [{}/{}]-[{}/{}] '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}) '
'Loss {loss:.4f} '
'Accuracy {accuracy:.4f} '
'Points {gt.size}.'.format(idx + 1,
len(rooms_split),
i + 1,
batch_num,
batch_time=batch_time,
loss=loss,
accuracy=accuracy,
gt=gt))
'''
unq, unq_inv, unq_cnt = np.unique(index_room, return_inverse=True, return_counts=True)
index_array = np.split(np.argsort(unq_inv), np.cumsum(unq_cnt[:-1]))
output_room = np.vstack([output_room, np.zeros((1, args.classes))])
index_array_fill = np.array(list(itertools.zip_longest(*index_array, fillvalue=output_room.shape[0] - 1))).T
pred = output_room[index_array_fill].sum(1)
pred = np.argmax(pred, axis=1)
'''
pred = np.zeros((gt.size, args.classes))
for j in range(len(index_room)):
pred[index_room[j]] += output_room[j]
pred = np.argmax(pred, axis=1)
# calculation 1: add per room predictions
intersection, union, target = intersectionAndUnion(
pred, gt, args.classes, args.ignore_label)
intersection_meter.update(intersection)
union_meter.update(union)
target_meter.update(target)
# calculation 2
pred_all = np.hstack([pred_all, pred]) if pred_all.size else pred
gt_all = np.hstack([gt_all, gt]) if gt_all.size else gt
pred_save.append(pred), gt_save.append(gt)
with open(
os.path.join(args.save_folder,
"pred_{}.pickle".format(args.test_area)),
'wb') as handle:
pickle.dump({'pred': pred_save},
handle,
protocol=pickle.HIGHEST_PROTOCOL)
with open(
os.path.join(args.save_folder,
"gt_{}.pickle".format(args.test_area)),
'wb') as handle:
pickle.dump({'gt': gt_save}, handle, protocol=pickle.HIGHEST_PROTOCOL)
# calculation 1
iou_class = intersection_meter.sum / (union_meter.sum + 1e-10)
accuracy_class = intersection_meter.sum / (target_meter.sum + 1e-10)
mIoU1 = np.mean(iou_class)
mAcc1 = np.mean(accuracy_class)
allAcc1 = sum(intersection_meter.sum) / (sum(target_meter.sum) + 1e-10)
# calculation 2
intersection, union, target = intersectionAndUnion(pred_all, gt_all,
args.classes,
args.ignore_label)
iou_class = intersection / (union + 1e-10)
accuracy_class = intersection / (target + 1e-10)
mIoU = np.mean(iou_class)
mAcc = np.mean(accuracy_class)
allAcc = sum(intersection) / (sum(target) + 1e-10)
logger.info('Val result: mIoU/mAcc/allAcc {:.4f}/{:.4f}/{:.4f}.'.format(
mIoU, mAcc, allAcc))
logger.info('Val1 result: mIoU/mAcc/allAcc {:.4f}/{:.4f}/{:.4f}.'.format(
mIoU1, mAcc1, allAcc1))
for i in range(args.classes):
logger.info(
'Class_{} Result: iou/accuracy {:.4f}/{:.4f}, name: {}.'.format(
i, iou_class[i], accuracy_class[i], names[i]))
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
return mIoU, mAcc, allAcc, pred_all
def test(test_loader, data_list, model, classes, mean, std, base_size, crop_h, crop_w, scales, gray_folder, color_folder, colors):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
data_time = AverageMeter()
batch_time = AverageMeter()
model.eval()
end = time.time()
pred_path_list = []
target_path_list = []
check_makedirs(gray_folder)
check_makedirs(color_folder)
for i, (input, target, image_paths) in tqdm(enumerate(test_loader)):
data_time.update(time.time() - end)
# input = np.squeeze(input.numpy(), axis=0)
# image = np.transpose(input, (1, 2, 0))
# # print(np.amax(input), np.amin(input), np.median(input))
# # print(np.amax(image), np.amin(image), np.median(image))
# h, w, _ = image.shape
# prediction = np.zeros((h, w, classes), dtype=float)
# for scale in scales:
# long_size = round(scale * base_size)
# new_h = long_size
# new_w = long_size
# if h > w:
# new_w = round(long_size/float(h)*w)
# else:
# new_h = round(long_size/float(w)*h)
# image_scale = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
# prediction += scale_process(model, image_scale, classes, crop_h, crop_w, h, w, mean, std)
# prediction /= len(scales)
# prediction = np.argmax(prediction, axis=2)
input = input.cuda(non_blocking=True)
output = model(input)
if args.zoom_factor != 8:
output = F.interpolate(output, size=target.size()[1:], mode='bilinear', align_corners=True)
prediction = torch.argmax(output, 1).cpu().numpy().squeeze()
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % 10 == 0) or (i + 1 == len(test_loader)):
logger.info('Test: [{}/{}] '
'Data {data_time.val:.3f} ({data_time.avg:.3f}) '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}).'.format(i + 1, len(test_loader),
data_time=data_time,
batch_time=batch_time))
gray = np.uint8(prediction)
if args.test_in_nyu_label_space:
gray = map_to_nyu(gray, args.dataset_name_pred)
gray_path = os.path.join(gray_folder, '%02d.png'%i)
pred_path_list.append(gray_path)
cv2.imwrite(gray_path, gray)
if args.test_has_gt:
target = np.uint8(target.squeeze().cpu().numpy())
if args.test_in_nyu_label_space:
target = map_to_nyu(target, args.dataset_name)
gray_target_path = os.path.join(gray_folder, '%02d_target.png'%i)
cv2.imwrite(gray_target_path, target)
target_path_list.append(gray_target_path)
if i <= 100:
color = colorize(gray, colors)
image_path, _ = data_list[i]
image_name = image_path.split('/')[-1].split('.')[0]
color_path = os.path.join(color_folder, '%02d.png'%i)
color.save(color_path)
image_RGB = args.read_image(image_path, resize_to_target_size=True)
cv2.imwrite(color_path.replace('.png', '_RGB.png'), image_RGB)
target_color = colorize(target, colors)
color_path = os.path.join(color_folder, '%02d_GT.png'%i)
target_color.save(color_path)
print('Result saved to %s; originally from %s'%(color_path, image_path))
# if i > 100:
# break
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
assert len(pred_path_list) == len(target_path_list)
return pred_path_list, target_path_list
def test(model, criterion, names):
logger.info('>>>>>>>>>>>>>>>> Start Evaluation >>>>>>>>>>>>>>>>')
batch_time = AverageMeter()
intersection_meter = AverageMeter()
union_meter = AverageMeter()
target_meter = AverageMeter()
model.eval()
data_file = os.path.join(args.data_root,
'scannet_{}.pickle'.format(args.split))
file_pickle = open(data_file, 'rb')
xyz_all = pickle.load(file_pickle, encoding='latin1')
label_all = pickle.load(file_pickle, encoding='latin1')
file_pickle.close()
gt_all, pred_all = np.array([]), np.array([])
vox_acc = []
check_makedirs(args.save_folder)
pred_save, gt_save = [], []
for idx in range(len(xyz_all)):
points, labels = xyz_all[idx], label_all[idx].astype(np.int32)
gt = labels - 1
gt[labels == 0] = 255
data_room, label_room, index_room = data_prepare(points, gt)
batch_point = args.num_point * args.test_batch_size
batch_num = int(np.ceil(label_room.size / batch_point))
end = time.time()
output_room = np.array([])
for i in range(batch_num):
s_i, e_i = i * batch_point, min((i + 1) * batch_point,
label_room.size)
input, target, index = data_room[
s_i:e_i, :], label_room[s_i:e_i], index_room[s_i:e_i]
input = torch.from_numpy(input).float().view(
-1, args.num_point, input.shape[1])
target = torch.from_numpy(target).long().view(-1, args.num_point)
with torch.no_grad():
output = model(input.cuda())
loss = criterion(output, target.cuda()) # for reference
output = output.transpose(1, 2).contiguous().view(
-1, args.classes).data.cpu().numpy()
pred = np.argmax(output, axis=1)
intersection, union, target = intersectionAndUnion(
pred,
target.view(-1).data.cpu().numpy(), args.classes,
args.ignore_label)
accuracy = sum(intersection) / (sum(target) + 1e-10)
output_room = np.vstack([output_room, output
]) if output_room.size else output
batch_time.update(time.time() - end)
end = time.time()
if ((i + 1) % args.print_freq == 0) or (i + 1 == batch_num):
logger.info(
'Test: [{}/{}]-[{}/{}] '
'Batch {batch_time.val:.3f} ({batch_time.avg:.3f}) '
'Loss {loss:.4f} '
'Accuracy {accuracy:.4f} '
'Points {gt.size}.'.format(idx + 1,
len(xyz_all),
i + 1,
batch_num,
batch_time=batch_time,
loss=loss,
accuracy=accuracy,
gt=gt))
pred = np.zeros((gt.size, args.classes))
for j in range(len(index_room)):
pred[index_room[j]] += output_room[j]
pred = np.argmax(pred, axis=1)
# calculation 1: add per room predictions
intersection, union, target = intersectionAndUnion(
pred, gt, args.classes, args.ignore_label)
intersection_meter.update(intersection)
union_meter.update(union)
target_meter.update(target)
# calculation 2
pred_all = np.hstack([pred_all, pred]) if pred_all.size else pred
gt_all = np.hstack([gt_all, gt]) if gt_all.size else gt
pred_save.append(pred), gt_save.append(gt)
# compute voxel accuracy (follow scannet, pointnet++ and pointcnn)
res = 0.0484
coord_min, coord_max = np.min(points, axis=0), np.max(points, axis=0)
nvox = np.ceil((coord_max - coord_min) / res)
vidx = np.ceil((points - coord_min) / res)
vidx = vidx[:,
0] + vidx[:, 1] * nvox[0] + vidx[:, 2] * nvox[0] * nvox[1]
uvidx, vpidx = np.unique(vidx, return_index=True)
# compute voxel label
uvlabel = np.array(gt)[vpidx]
uvpred = np.array(pred)[vpidx]
# compute voxel accuracy (ignore label 0 which is scannet unannotated)
c_accvox = np.sum(np.equal(uvpred, uvlabel))
c_ignore = np.sum(np.equal(uvlabel, 255))
vox_acc.append([c_accvox, len(uvlabel) - c_ignore])
with open(
os.path.join(args.save_folder,
"pred_{}.pickle".format(args.split)), 'wb') as handle:
pickle.dump({'pred': pred_save},
handle,
protocol=pickle.HIGHEST_PROTOCOL)
with open(
os.path.join(args.save_folder, "gt_{}.pickle".format(args.split)),
'wb') as handle:
pickle.dump({'gt': gt_save}, handle, protocol=pickle.HIGHEST_PROTOCOL)
# calculation 1
iou_class = intersection_meter.sum / (union_meter.sum + 1e-10)
accuracy_class = intersection_meter.sum / (target_meter.sum + 1e-10)
mIoU1 = np.mean(iou_class)
mAcc1 = np.mean(accuracy_class)
allAcc1 = sum(intersection_meter.sum) / (sum(target_meter.sum) + 1e-10)
# calculation 2
intersection, union, target = intersectionAndUnion(pred_all, gt_all,
args.classes,
args.ignore_label)
iou_class = intersection / (union + 1e-10)
accuracy_class = intersection / (target + 1e-10)
mIoU = np.mean(iou_class)
mAcc = np.mean(accuracy_class)
allAcc = sum(intersection) / (sum(target) + 1e-10)
# compute avg voxel acc
vox_acc = np.sum(vox_acc, 0)
voxAcc = vox_acc[0] * 1.0 / vox_acc[1]
logger.info(
'Val result: mIoU/mAcc/allAcc/voxAcc {:.4f}/{:.4f}/{:.4f}/{:.4f}.'.
format(mIoU, mAcc, allAcc, voxAcc))
logger.info(
'Val111 result: mIoU/mAcc/allAcc {:.4f}/{:.4f}/{:.4f}/{:.4f}.'.format(
mIoU1, mAcc1, allAcc1, voxAcc))
for i in range(args.classes):
logger.info(
'Class_{} Result: iou/accuracy {:.4f}/{:.4f}, name: {}.'.format(
i, iou_class[i], accuracy_class[i], names[i]))
logger.info('<<<<<<<<<<<<<<<<< End Evaluation <<<<<<<<<<<<<<<<<')
return mIoU, mAcc, allAcc, pred_all
