def get_iou(data_list, class_num, save_path=None):
from multiprocessing import Pool
from utils.metric import ConfusionMatrix
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
classes = np.array(('background', # always index 0
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor'))
for i, iou in enumerate(j_list):
print('class {:2d} {:12} IU {:.2f}'.format(i, classes[i], j_list[i]))
print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
for i, iou in enumerate(j_list):
f.write('class {:2d} {:12} IU {:.2f}'.format(i, classes[i], j_list[i]) + '\n')
f.write('meanIOU: ' + str(aveJ) + '\n')
def get_iou(data_list, class_num, save_path=None):
from multiprocessing import Pool
from utils.metric import ConfusionMatrix
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
classes = np.array(('background', # always index 0
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor'))
for i, iou in enumerate(j_list):
print('class {:2d} {:12} IU {:.2f}'.format(i, classes[i], j_list[i]))
print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
for i, iou in enumerate(j_list):
f.write('class {:2d} {:12} IU {:.2f}'.format(i, classes[i], j_list[i]) + '\n')
f.write('meanIOU: ' + str(aveJ) + '\n')
def get_iou(data_list, class_num, save_path=None):
from multiprocessing import Pool
from utils.metric import ConfusionMatrix
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
classes = np.array((
'background', # always index 0
'REA',
'SRF',
'PED'))
for i, iou in enumerate(j_list):
print('class {:2d} {:12} IU {:.2f}'.format(i, classes[i], j_list[i]))
print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
for i, iou in enumerate(j_list):
f.write('class {:2d} {:12} IU {:.2f}'.format(
i, classes[i], j_list[i]) + '\n')
f.write('meanIOU: ' + str(aveJ) + '\n')
def get_iou(data_list, class_num, dataset, save_path=None):
from multiprocessing import Pool
from utils.metric import ConfusionMatrix
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
classes = np.array(("road", "sidewalk", "building", "wall", "fence",
"pole", "traffic_light", "traffic_sign", "vegetation",
"terrain", "sky", "person", "rider", "car", "truck",
"bus", "train", "motorcycle", "bicycle"))
for i, iou in enumerate(j_list):
print('class {:2d} {:12} IU {:.2f}'.format(i, classes[i],
100 * j_list[i]))
print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
for i, iou in enumerate(j_list):
f.write('class {:2d} {:12} IU {:.2f}'.format(
i, classes[i], 100 * j_list[i]) + '\n')
f.write('meanIOU: ' + str(aveJ) + '\n')
return aveJ
def get_iou(data_list, class_num, dataset, save_path=None):
from multiprocessing import Pool
from utils.metric import ConfusionMatrix
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
if dataset == 'pascal_voc':
classes = np.array((
'background', # always index 0
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor'))
elif dataset == 'cityscapes':
classes = np.array(
("road", "sidewalk", "building", "wall", "fence", "pole",
"traffic_light", "traffic_sign", "vegetation", "terrain", "sky",
"person", "rider", "car", "truck", "bus", "train", "motorcycle",
"bicycle"))
for i, iou in enumerate(j_list):
print('class {:2d} {:12} IU {:.2f}'.format(i, classes[i], j_list[i]))
print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
for i, iou in enumerate(j_list):
f.write('class {:2d} {:12} IU {:.2f}'.format(
i, classes[i], j_list[i]) + '\n')
f.write('meanIOU: ' + str(aveJ) + '\n')
return aveJ
def get_iou(data_list, class_num, save_path=None):
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
#print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
f.write('meanIOU: ' + str(aveJ) + '\n')
f.write(str(j_list)+'\n')
f.write(str(M)+'\n')
return aveJ
def validate(data_loader, G, F1, F2, args):
batch_time = AverageMeter('Time', ':6.3f')
top1_1 = AverageMeter('Acc_1', ':6.2f')
top1_2 = AverageMeter('Acc_2', ':6.2f')
progress = ProgressMeter(len(data_loader),
[batch_time, top1_1, top1_2],
prefix='Test: ')
G.eval()
F1.eval()
F2.eval()
if args.per_class_eval:
classes = data_loader.dataset.classes
confmat = ConfusionMatrix(len(classes))
else:
confmat = None
with torch.no_grad():
end = time.time()
for i, (images, target) in enumerate(data_loader):
images = images.to(device)
target = target.to(device)
g = G(images)
y1, y2 = F1(g), F2(g)
acc1, = accuracy(y1, target)
acc2, = accuracy(y2, target)
if confmat:
confmat.update(target, y1.argmax(1))
top1_1.update(acc1.item(), images.size(0))
top1_2.update(acc2.item(), images.size(0))
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
progress.display(i)
print(' * Acc1 {top1_1.avg:.3f} Acc2 {top1_2.avg:.3f}'.format(top1_1=top1_1, top1_2=top1_2))
if confmat:
print(confmat.format(classes))
return top1_1.avg, top1_2.avg
def validate(dataloader, target_iter, classifier, device, args):
batch_time = AverageMeter('Time', ':6.3f')
losses = AverageMeter('Loss', ':.4e')
top1 = AverageMeter('Acc@1', ':6.2f')
top5 = AverageMeter('Acc@5', ':6.2f')
progress = ProgressMeter(len(target_iter),
[batch_time, losses, top1, top5],
prefix='Test: ')
classifier.eval()
if args.per_class_eval:
classes = dataloader.dataset.classes
confmat = ConfusionMatrix(len(classes))
else:
confmat = None
with torch.no_grad():
end = time.time()
for i, (images, target) in enumerate(dataloader):
images, target = images.to(device), target.to(device)
output, _ = classifier(images)
loss = F.cross_entropy(output, target)
acc1, acc5 = accuracy(output, target, topk=(1, 5))
if confmat:
confmat.update(target, output.argmax(1))
losses.update(loss.item(), images.size(0))
top1.update(acc1.item(), images.size(0))
top5.update(acc5.item(), images.size(0))
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
progress.display(i)
print(' * Acc@1 {top1.avg:.3f} Acc@5 {top5.avg:.3f}'.format(top1=top1,
top5=top5))
if confmat:
print(confmat.format(classes))
return top1.avg
args = parse_args()
m_list = []
data_list = []
test_ids = [i.strip() for i in open(args.test_ids) if not i.strip() == '']
for index, img_id in enumerate(test_ids):
if index % 100 == 0:
print('%d processd'%(index))
pred_img_path = os.path.join(args.pred_dir, img_id+'.png')
gt_img_path = os.path.join(args.gt_dir, img_id+'.png')
pred = cv2.imread(pred_img_path, cv2.IMREAD_GRAYSCALE)
gt = cv2.imread(gt_img_path, cv2.IMREAD_GRAYSCALE)
# show_all(gt, pred)
data_list.append([gt.flatten(), pred.flatten()])
ConfM = ConfusionMatrix(args.class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
with open(args.save_path, 'w') as f:
f.write('meanIOU: ' + str(aveJ) + '\n')
f.write(str(j_list)+'\n')
f.write(str(M)+'\n')
def evaluate(model,
dataset,
deeplabv2=True,
ignore_label=250,
save_dir=None,
pretraining='COCO'):
model.eval()
if pretraining == 'COCO':
from utils.transformsgpu import normalize_bgr as normalize
else:
from utils.transformsgpu import normalize_rgb as normalize
if dataset == 'pascal_voc':
num_classes = 21
data_loader = get_loader(dataset)
data_path = get_data_path(dataset)
test_dataset = data_loader(data_path,
split="val",
scale=False,
mirror=False,
pretraining=pretraining)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
elif dataset == 'cityscapes':
num_classes = 19
data_loader = get_loader('cityscapes')
data_path = get_data_path('cityscapes')
if deeplabv2:
data_aug = Compose([Resize_city()])
else: # for deeplabv3 oirginal resolution
data_aug = Compose([Resize_city_highres()])
test_dataset = data_loader(data_path,
is_transform=True,
split='val',
augmentations=data_aug,
pretraining=pretraining)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
print('Evaluating, found ' + str(len(testloader)) + ' images.')
confM = ConfusionMatrix(num_classes)
data_list = []
total_loss = []
for index, batch in enumerate(testloader):
image, label, size, name, _ = batch
with torch.no_grad():
interp = torch.nn.Upsample(size=(label.shape[1], label.shape[2]),
mode='bilinear',
align_corners=True)
output = model(normalize(Variable(image).cuda(), dataset))
output = interp(output)
label_cuda = Variable(label.long()).cuda()
criterion = CrossEntropy2d(ignore_label=ignore_label).cuda()
loss = criterion(output, label_cuda)
total_loss.append(loss.item())
output = output.cpu().data[0].numpy()
gt = np.asarray(label[0].numpy(), dtype=np.int)
output = np.asarray(np.argmax(output, axis=0), dtype=np.int)
data_list.append((np.reshape(gt, (-1)), np.reshape(output, (-1))))
# filename = 'output_images/' + name[0].split('/')[-1]
# cv2.imwrite(filename, output)
if (index + 1) % 100 == 0:
# print('%d processed' % (index + 1))
process_list_evaluation(confM, data_list)
data_list = []
process_list_evaluation(confM, data_list)
mIoU = get_iou(confM, dataset)
loss = np.mean(total_loss)
return mIoU, loss
interpolated_label[start_idx:end_idx] = np.argmax(
interpolated_prob, axis=-1) # (batch_size,)
interpolated_common_label = _2common(interpolated_label,
from_dataset) # (N1,)
interpolated_color = _label_to_colors_by_name(interpolated_label,
from_dataset) # (N1, 3)
interpolated_common_color = _label_to_colors_by_name(
interpolated_common_label, 'common') # (N1, 3)
del interpolated_common_label
# evaluate interpolation result if ground truth is available
raw_label_path = os.path.join(raw_folder, fname_without_ext + '.labels')
if from_dataset == to_dataset and os.path.exists(raw_label_path):
label_gt = load_labels(raw_label_path) # (N1,)
ConfusionMatrix = ConfusionMatrix(num_classes)
ConfusionMatrix.increment_from_list(label_gt.flatten(),
interpolated_label.flatten())
ConfusionMatrix.print_metrics()
label_path = os.path.join(dense_folder, fname_without_ext + '.labels')
np.savetxt(label_path, interpolated_label, fmt="%d")
del interpolated_label
print('writing labels for %s' % fname_without_ext)
# output pcd with from_dataset label
dense_pcd = open3d.geometry.PointCloud()
dense_pcd.points = open3d.utility.Vector3dVector(raw_points)
dense_pcd.colors = open3d.utility.Vector3dVector(interpolated_color)
del interpolated_color
dense_pcd_path = os.path.join(
def get_iou(args, data_list, class_num, save_path=None):
from multiprocessing import Pool
from utils.metric import ConfusionMatrix
ConfM = ConfusionMatrix(class_num)
f = ConfM.generateM
pool = Pool()
m_list = pool.map(f, data_list)
pool.close()
pool.join()
for m in m_list:
ConfM.addM(m)
aveJ, j_list, M = ConfM.jaccard()
if args.dataset == 'pascal_voc':
classes = np.array((
'background', # always index 0
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor'))
elif args.dataset == 'pascal_context':
classes = np.array(
('background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
'bus', 'car', 'cat', 'chair', 'cow', 'table', 'dog', 'horse',
'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train',
'tvmonitor', 'bag', 'bed', 'bench', 'book', 'building', 'cabinet',
'ceiling', 'cloth', 'computer', 'cup', 'door', 'fence', 'floor',
'flower', 'food', 'grass', 'ground', 'keyboard', 'light',
'mountain', 'mouse', 'curtain', 'platform', 'sign', 'plate',
'road', 'rock', 'shelves', 'sidewalk', 'sky', 'snow',
'bedclothes', 'track', 'tree', 'truck', 'wall', 'water', 'window',
'wood'))
elif args.dataset == 'cityscapes':
classes = np.array(
("road", "sidewalk", "building", "wall", "fence", "pole",
"traffic_light", "traffic_sign", "vegetation", "terrain", "sky",
"person", "rider", "car", "truck", "bus", "train", "motorcycle",
"bicycle"))
for i, iou in enumerate(j_list):
if j_list[i] > 0:
print('class {:2d} {:12} IU {:.2f}'.format(i, classes[i],
j_list[i]))
print('meanIOU: ' + str(aveJ) + '\n')
if save_path:
with open(save_path, 'w') as f:
for i, iou in enumerate(j_list):
f.write('class {:2d} {:12} IU {:.2f}'.format(
i, classes[i], j_list[i]) + '\n')
f.write('meanIOU: ' + str(aveJ) + '\n')
batch_size = flags.batch_size
if flags.from_dataset == 'semantic':
classes_in_model = 9
else:
classes_in_model = 10
# load model
resume_path = flags.resume_model
model = select_model(flags.model_name, classes_in_model, hyper_params)[0]
model = model.to(device)
print("Resuming From ", resume_path)
checkpoint = torch.load(resume_path)
saved_state_dict = checkpoint['state_dict']
model.load_state_dict(saved_state_dict)
# Process each file
cm = ConfusionMatrix(classes_in_model)
common_cm = ConfusionMatrix(6)
model = model.eval()
# for visulization in tensorboard
writer = SummaryWriter('runs/embedding_example')
global_step = 0
for file_data in dataset.list_file_data:
print("Processing {}".format(file_data.file_path_without_ext))
# Predict for num_samples times
points_collector = []
pd_labels_collector = []
pd_prob_collector = []
pd_common_labels_collector = []
# If flags.num_samples < batch_size, will predict one batch
