def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', choices=('voc', 'coco'))
parser.add_argument('--model', choices=sorted(models.keys()))
parser.add_argument('--pretrained-model')
parser.add_argument('--batchsize', type=int)
parser.add_argument('--gpu', type=int, default=-1)
args = parser.parse_args()
dataset, eval_, model, batchsize = setup(args.dataset, args.model,
args.pretrained_model,
args.batchsize)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
iterator = iterators.MultithreadIterator(dataset,
batchsize,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)))
# delete unused iterators explicitly
del in_values
eval_(out_values, rest_values)
def test(net,
test_data,
metric,
use_gpus,
calc_weight_count=False,
extended_log=False):
tic = time.time()
predictor = test_data["predictor_class"](base_model=net)
if use_gpus:
predictor.to_gpu()
if calc_weight_count:
weight_count = net.count_params()
logging.info("Model: {} trainable parameters".format(weight_count))
in_values, out_values, rest_values = apply_to_iterator(
predictor.predict,
test_data["iterator"],
hook=ProgressHook(test_data["ds_len"]))
del in_values
pred_labels, = out_values
gt_labels, = rest_values
labels = iter(gt_labels)
preds = iter(pred_labels)
for label, pred in zip(labels, preds):
metric.update(label, pred)
accuracy_msg = report_accuracy(metric=metric, extended_log=extended_log)
logging.info("Test: {}".format(accuracy_msg))
logging.info("Time cost: {:.4f} sec".format(time.time() - tic))
def test(net,
val_iterator,
val_dataset_len,
num_gpus,
calc_weight_count=False,
extended_log=False):
tic = time.time()
predictor = CIFARPredictor(base_model=net)
if num_gpus > 0:
predictor.to_gpu()
if calc_weight_count:
weight_count = net.count_params()
logging.info('Model: {} trainable parameters'.format(weight_count))
in_values, out_values, rest_values = apply_to_iterator(
predictor.predict, val_iterator, hook=ProgressHook(val_dataset_len))
del in_values
pred_probs, = out_values
gt_labels, = rest_values
y = np.array(list(pred_probs))
t = np.array(list(gt_labels))
acc_val_value = F.accuracy(y=y, t=t).data
err_val = 1.0 - acc_val_value
if extended_log:
logging.info('Test: err={err:.4f} ({err})'.format(err=err_val))
else:
logging.info('Test: err={err:.4f}'.format(err=err_val))
logging.info('Time cost: {:.4f} sec'.format(time.time() - tic))
def test(net, test_data, metric, calc_weight_count=False, extended_log=False):
tic = time.time()
predictor = Predictor(model=net, transform=None)
if calc_weight_count:
weight_count = net.count_params()
logging.info("Model: {} trainable parameters".format(weight_count))
_, out_values, rest_values = apply_to_iterator(
func=predictor,
iterator=test_data["iterator"],
hook=ProgressHook(test_data["ds_len"]))
assert (len(rest_values) == 1)
assert (len(out_values) == 1)
if False:
labels = iter(rest_values[0])
preds = iter(out_values[0])
for label, pred in zip(labels, preds):
metric.update(label, pred)
else:
import numpy as np
metric.update(labels=np.array(list(rest_values[0])),
preds=np.array(list(out_values[0])))
accuracy_msg = report_accuracy(metric=metric, extended_log=extended_log)
logging.info("Test: {}".format(accuracy_msg))
logging.info("Time cost: {:.4f} sec".format(time.time() - tic))
def main():
args = parse_args()
cfg.merge_from_file(args.config)
cfg.freeze
model = setup_model(cfg)
load_pretrained_model(cfg, args.config, model, args.pretrained_model)
dataset = setup_dataset(cfg, 'eval')
iterator = iterators.MultithreadIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
model.use_preset('evaluate')
if args.gpu >= 0:
model.to_gpu(args.gpu)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)))
# delete unused iterators explicitly
del in_values
if cfg.dataset.eval == 'COCO':
eval_coco(out_values, rest_values)
elif cfg.dataset.eval == 'VOC':
eval_voc(out_values, rest_values)
else:
raise ValueError()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--dataset', choices=('cityscapes', 'ade20k', 'camvid', 'voc'))
parser.add_argument('--model', choices=sorted(models.keys()))
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
parser.add_argument('--batchsize', type=int)
parser.add_argument('--input-size', type=int, default=None)
args = parser.parse_args()
dataset, eval_, model, batchsize = setup(
args.dataset, args.model, args.pretrained_model,
args.batchsize, args.input_size)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
iterator = iterators.SerialIterator(
dataset, batchsize, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# Delete an iterator of images to save memory usage.
del in_values
eval_(out_values, rest_values)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', choices=('sbd', 'coco'))
parser.add_argument('--model', choices=sorted(models.keys()))
parser.add_argument('--pretrained-model')
parser.add_argument('--batchsize', type=int)
args = parser.parse_args()
comm = chainermn.create_communicator('pure_nccl')
device = comm.intra_rank
dataset, label_names, eval_, model, batchsize = setup(
args.dataset, args.model, args.pretrained_model, args.batchsize)
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
if not comm.rank == 0:
apply_to_iterator(model.predict, None, comm=comm)
return
iterator = iterators.MultithreadIterator(
dataset, batchsize * comm.size, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)), comm=comm)
# delete unused iterators explicitly
del in_values
eval_(out_values, rest_values)
def eva_coco(dataset, func, limit = 1000, preset = 'evaluate'):
total = limit if limit else len(dataset)
orig_ids = dataset.ids.copy()
dataset.ids = dataset.ids[:total]
iterator = iterators.SerialIterator(dataset, 1, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(func,
iterator,
hook=ProgressHook(len(dataset)))
pred_bboxes, pred_labels, pred_scores = out_values
gt_bboxes, gt_labels, gt_areas, gt_crowdeds = rest_values
result = eval_detection_coco(pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels, gt_areas, gt_crowdeds)
keys = [
'map/iou=0.50:0.95/area=all/max_dets=100',
'map/iou=0.50/area=all/max_dets=100',
'map/iou=0.75/area=all/max_dets=100',
'map/iou=0.50:0.95/area=small/max_dets=100',
'map/iou=0.50:0.95/area=medium/max_dets=100',
'map/iou=0.50:0.95/area=large/max_dets=100',
'mar/iou=0.50:0.95/area=all/max_dets=1',
'mar/iou=0.50:0.95/area=all/max_dets=10',
'mar/iou=0.50:0.95/area=all/max_dets=100',
'mar/iou=0.50:0.95/area=small/max_dets=100',
'mar/iou=0.50:0.95/area=medium/max_dets=100',
'mar/iou=0.50:0.95/area=large/max_dets=100',
]
print('')
results = []
for key in keys:
print('{:s}: {:f}'.format(key, result[key]))
results.append(result[key])
dataset.ids = orig_ids
return results
def test_progress_hook_with_infinite_iterator(self):
iterator = SerialIterator(self.dataset, 2)
in_values, out_values, rest_values = apply_to_iterator(
self.func, iterator, hook=ProgressHook())
for _ in range(10):
next(in_values[0])
def test_progress_hook_with_infinite_iterator(self):
iterator = SerialIterator(self.dataset, 2)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
self.predict, iterator, hook=ProgressHook())
for _ in range(10):
next(imgs)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset',
choices=('cityscapes', 'ade20k', 'camvid'))
parser.add_argument('--model', choices=('pspnet_resnet101', 'segnet'))
parser.add_argument('--pretrained-model')
parser.add_argument('--input-size', type=int, default=None)
args = parser.parse_args()
comm = chainermn.create_communicator()
device = comm.intra_rank
dataset, label_names, model = get_dataset_and_model(
args.dataset, args.model, args.pretrained_model,
(args.input_size, args.input_size))
assert len(dataset) % comm.size == 0, \
"The size of the dataset should be a multiple "\
"of the number of GPUs"
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
if comm.rank == 0:
indices = np.arange(len(dataset))
else:
indices = None
indices = chainermn.scatter_dataset(indices, comm)
dataset = dataset.slice[indices]
it = iterators.SerialIterator(dataset, 1, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
it,
hook=ProgressHook(
len(dataset)))
# Delete an iterator of images to save memory usage.
del in_values
pred_labels, = out_values
gt_labels, = rest_values
confusion = calc_semantic_segmentation_confusion(pred_labels, gt_labels)
confusion = comm.allreduce(confusion)
if comm.rank == 0:
iou = calc_semantic_segmentation_iou(confusion)
pixel_accuracy = np.diag(confusion).sum() / confusion.sum()
class_accuracy = np.diag(confusion) / np.sum(confusion, axis=1)
for iu, label_name in zip(iou, label_names):
print('{:>23} : {:.4f}'.format(label_name, iu))
print('=' * 34)
print('{:>23} : {:.4f}'.format('mean IoU', np.nanmean(iou)))
print('{:>23} : {:.4f}'.format('Class average accuracy',
np.nanmean(class_accuracy)))
print('{:>23} : {:.4f}'.format('Global average accuracy',
pixel_accuracy))
def test_progress_hook(self):
iterator = SerialIterator(self.dataset, 2, repeat=False)
in_values, out_values, rest_values = apply_to_iterator(
self.func, iterator,
hook=ProgressHook(n_total=len(self.dataset)))
# consume all data
for _ in in_values[0]:
pass
def test_progress_hook(self):
iterator = SerialIterator(self.dataset, 2, repeat=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
self.predict, iterator,
hook=ProgressHook(n_total=len(self.dataset)))
# consume all data
for _ in imgs:
pass
def test(net,
val_iterator,
val_dataset_len,
num_gpus,
input_image_size=224,
resize_inv_factor=0.875,
calc_weight_count=False,
extended_log=False):
assert (resize_inv_factor > 0.0)
resize_value = int(math.ceil(float(input_image_size) / resize_inv_factor))
tic = time.time()
predictor = ImagenetPredictor(
base_model=net,
scale_size=resize_value,
crop_size=input_image_size)
if num_gpus > 0:
predictor.to_gpu()
if calc_weight_count:
weight_count = net.count_params()
logging.info('Model: {} trainable parameters'.format(weight_count))
in_values, out_values, rest_values = apply_to_iterator(
predictor.predict,
val_iterator,
hook=ProgressHook(val_dataset_len))
del in_values
pred_probs, = out_values
gt_labels, = rest_values
y = np.array(list(pred_probs))
t = np.array(list(gt_labels))
top1_acc = F.accuracy(
y=y,
t=t).data
top5_acc = top_k_accuracy(
y=y,
t=t,
k=5).data
err_top1_val = 1.0 - top1_acc
err_top5_val = 1.0 - top5_acc
if extended_log:
logging.info('Test: err-top1={top1:.4f} ({top1})\terr-top5={top5:.4f} ({top5})'.format(
top1=err_top1_val, top5=err_top5_val))
else:
logging.info('Test: err-top1={top1:.4f}\terr-top5={top5:.4f}'.format(
top1=err_top1_val, top5=err_top5_val))
logging.info('Time cost: {:.4f} sec'.format(
time.time() - tic))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--model', choices=('resnet50', 'resnet101'))
parser.add_argument(
'--mean', choices=('chainercv', 'detectron'), default='chainercv')
parser.add_argument('--batchsize', type=int, default=1)
group = parser.add_mutually_exclusive_group()
group.add_argument('--pretrained-model')
group.add_argument('--snapshot')
args = parser.parse_args()
if args.model == 'resnet50':
model = FasterRCNNFPNResNet50(n_fg_class=len(coco_bbox_label_names),
mean=args.mean)
elif args.model == 'resnet101':
model = FasterRCNNFPNResNet101(n_fg_class=len(coco_bbox_label_names),
mean=args.mean)
if args.pretrained_model:
chainer.serializers.load_npz(args.pretrained_model, model)
elif args.snapshot:
chainer.serializers.load_npz(
args.snapshot, model, path='updater/model:main/model/')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
dataset = COCOBboxDataset(
split='minival',
use_crowded=True,
return_area=True,
return_crowded=True)
iterator = iterators.MultithreadIterator(
dataset, args.batchsize, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterators explicitly
del in_values
pred_bboxes, pred_labels, pred_scores = out_values
gt_bboxes, gt_labels, gt_area, gt_crowded = rest_values
result = eval_detection_coco(
pred_bboxes, pred_labels, pred_scores,
gt_bboxes, gt_labels, gt_area, gt_crowded)
print()
for area in ('all', 'large', 'medium', 'small'):
print('mmAP ({}):'.format(area),
result['map/iou=0.50:0.95/area={}/max_dets=100'.format(area)])
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('fcis_psroi_align_resnet101', ),
default='fcis_psroi_align_resnet101')
parser.add_argument('--pretrained-model')
parser.add_argument('--iou-thresh', type=float, default=0.5)
parser.add_argument('--gpu', type=int, default=-1)
args = parser.parse_args()
if args.model == 'fcis_psroi_align_resnet101':
if args.pretrained_model:
model = FCISPSROIAlignResNet101(
n_fg_class=len(sbd_instance_segmentation_label_names),
pretrained_model=args.pretrained_model)
else:
model = FCISPSROIAlignResNet101(pretrained_model='sbd')
model.use_preset('evaluate')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = SBDInstanceSegmentationDataset(split='val')
iterator = iterators.SerialIterator(dataset,
1,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)))
# delete unused iterators explicitly
del in_values
pred_masks, pred_labels, pred_scores = out_values
gt_masks, gt_labels = rest_values
result = eval_instance_segmentation_voc(pred_masks,
pred_labels,
pred_scores,
gt_masks,
gt_labels,
args.iou_thresh,
use_07_metric=True)
print('')
print('mAP: {:f}'.format(result['map']))
for l, name in enumerate(sbd_instance_segmentation_label_names):
if result['ap'][l]:
print('{:s}: {:f}'.format(name, result['ap'][l]))
else:
print('{:s}: -'.format(name))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset',
choices=('cityscapes', 'ade20k', 'camvid', 'voc'))
parser.add_argument('--model',
choices=('pspnet_resnet101', 'segnet',
'deeplab_v3plus_xception65'))
parser.add_argument('--pretrained-model')
parser.add_argument('--input-size', type=int, default=None)
args = parser.parse_args()
comm = chainermn.create_communicator('pure_nccl')
device = comm.intra_rank
if args.input_size is None:
input_size = None
else:
input_size = (args.input_size, args.input_size)
dataset, label_names, model = get_dataset_and_model(
args.dataset, args.model, args.pretrained_model, input_size)
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
if not comm.rank == 0:
apply_to_iterator(model.predict, None, comm=comm)
return
it = iterators.MultithreadIterator(dataset,
comm.size,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
it,
hook=ProgressHook(
len(dataset)),
comm=comm)
# Delete an iterator of images to save memory usage.
del in_values
pred_labels, = out_values
gt_labels, = rest_values
result = eval_semantic_segmentation(pred_labels, gt_labels)
for iu, label_name in zip(result['iou'], label_names):
print('{:>23} : {:.4f}'.format(label_name, iu))
print('=' * 34)
print('{:>23} : {:.4f}'.format('mean IoU', result['miou']))
print('{:>23} : {:.4f}'.format('Class average accuracy',
result['mean_class_accuracy']))
print('{:>23} : {:.4f}'.format('Global average accuracy',
result['pixel_accuracy']))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--pretrained-model', default='coco')
parser.add_argument('--gpu', type=int, default=-1)
args = parser.parse_args()
model = LightHeadRCNNResNet101(
n_fg_class=len(coco_bbox_label_names),
pretrained_model=args.pretrained_model)
model.use_preset('evaluate')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = COCOBboxDataset(
split='minival', use_crowded=True,
return_crowded=True, return_area=True)
iterator = iterators.SerialIterator(
dataset, 1, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterators explicitly
del in_values
pred_bboxes, pred_labels, pred_scores = out_values
gt_bboxes, gt_labels, gt_areas, gt_crowdeds = rest_values
result = eval_detection_coco(
pred_bboxes, pred_labels, pred_scores,
gt_bboxes, gt_labels, gt_areas, gt_crowdeds)
keys = [
'map/iou=0.50:0.95/area=all/max_dets=100',
'map/iou=0.50/area=all/max_dets=100',
'map/iou=0.75/area=all/max_dets=100',
'map/iou=0.50:0.95/area=small/max_dets=100',
'map/iou=0.50:0.95/area=medium/max_dets=100',
'map/iou=0.50:0.95/area=large/max_dets=100',
'mar/iou=0.50:0.95/area=all/max_dets=1',
'mar/iou=0.50:0.95/area=all/max_dets=10',
'mar/iou=0.50:0.95/area=all/max_dets=100',
'mar/iou=0.50:0.95/area=small/max_dets=100',
'mar/iou=0.50:0.95/area=medium/max_dets=100',
'mar/iou=0.50:0.95/area=large/max_dets=100',
]
print('')
for key in keys:
print('{:s}: {:f}'.format(key, result[key]))
def main():
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('val', help='Path to root of the validation dataset')
parser.add_argument(
'--model', choices=('vgg16', 'resnet50', 'resnet101', 'resnet152'))
parser.add_argument('--pretrained_model', default='imagenet')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--crop', choices=('center', '10'), default='center')
parser.add_argument('--resnet_mode', default='he')
args = parser.parse_args()
dataset = DirectoryParsingLabelDataset(args.val)
label_names = directory_parsing_label_names(args.val)
n_class = len(label_names)
iterator = iterators.MultiprocessIterator(
dataset, args.batchsize, repeat=False, shuffle=False,
n_processes=6, shared_mem=300000000)
if args.model == 'vgg16':
extractor = VGG16(n_class, args.pretrained_model)
elif args.model == 'resnet50':
extractor = ResNet50(
n_class, args.pretrained_model, mode=args.resnet_mode)
elif args.model == 'resnet101':
extractor = ResNet101(
n_class, args.pretrained_model, mode=args.resnet_mode)
elif args.model == 'resnet152':
extractor = ResNet152(
n_class, args.pretrained_model, mode=args.resnet_mode)
model = FeaturePredictor(
extractor, crop_size=224, scale_size=256, crop=args.crop)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
print('Model has been prepared. Evaluation starts.')
in_values, out_values, rest_values = apply_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
del in_values
pred_probs, = out_values
gt_labels, = rest_values
accuracy = F.accuracy(
np.array(list(pred_probs)), np.array(list(gt_labels))).data
print()
print('Top 1 Error {}'.format(1. - accuracy))
def test(net, test_data, metric, calc_weight_count=False, extended_log=False):
"""
Main test routine.
Parameters:
----------
net : Chain
Model.
test_data : dict
Data loader.
metric : EvalMetric
Metric object instance.
calc_weight_count : bool, default False
Whether to calculate count of weights.
extended_log : bool, default False
Whether to log more precise accuracy values.
"""
tic = time.time()
predictor = Predictor(model=net, transform=None)
if calc_weight_count:
weight_count = net.count_params()
logging.info("Model: {} trainable parameters".format(weight_count))
in_values, out_values, rest_values = apply_to_iterator(
func=predictor,
iterator=test_data["iterator"],
hook=ProgressHook(test_data["ds_len"]))
assert (len(rest_values) == 1)
assert (len(out_values) == 1)
assert (len(in_values) == 1)
if True:
labels = iter(rest_values[0])
preds = iter(out_values[0])
inputs = iter(in_values[0])
for label, pred, inputi in zip(labels, preds, inputs):
metric.update(label, pred)
del label
del pred
del inputi
else:
import numpy as np
metric.update(labels=np.array(list(rest_values[0])),
preds=np.array(list(out_values[0])))
accuracy_msg = report_accuracy(metric=metric, extended_log=extended_log)
logging.info("Test: {}".format(accuracy_msg))
logging.info("Time cost: {:.4f} sec".format(time.time() - tic))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model', choices=('pspnet_resnet101',),
default='pspnet_resnet101')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
args = parser.parse_args()
if args.model == 'pspnet_resnet101':
if args.pretrained_model:
model = PSPNetResNet101(
n_class=len(cityscapes_semantic_segmentation_label_names),
pretrained_model=args.pretrained_model, input_size=(713, 713)
)
else:
model = PSPNetResNet101(pretrained_model='cityscapes')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = CityscapesSemanticSegmentationDataset(
split='val', label_resolution='fine')
it = iterators.SerialIterator(
dataset, 1, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
model.predict, it, hook=ProgressHook(len(dataset)))
# Delete an iterator of images to save memory usage.
del in_values
pred_labels, = out_values
gt_labels, = rest_values
result = eval_semantic_segmentation(pred_labels, gt_labels)
for iu, label_name in zip(
result['iou'], cityscapes_semantic_segmentation_label_names):
print('{:>23} : {:.4f}'.format(label_name, iu))
print('=' * 34)
print('{:>23} : {:.4f}'.format('mean IoU', result['miou']))
print('{:>23} : {:.4f}'.format(
'Class average accuracy', result['mean_class_accuracy']))
print('{:>23} : {:.4f}'.format(
'Global average accuracy', result['pixel_accuracy']))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model', type=str, default='camvid')
parser.add_argument('--batchsize', type=int, default=24)
args = parser.parse_args()
model = SegNetBasic(n_class=len(camvid_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model = calc_bn_statistics(model, args.batchsize)
test = CamVidDataset(split='test')
it = chainer.iterators.SerialIterator(test,
batch_size=args.batchsize,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
it,
hook=ProgressHook(
len(test)))
# Delete an iterator of images to save memory usage.
del in_values
pred_labels, = out_values
gt_labels, = rest_values
result = eval_semantic_segmentation(pred_labels, gt_labels)
for iu, label_name in zip(result['iou'], camvid_label_names):
print('{:>23} : {:.4f}'.format(label_name, iu))
print('=' * 34)
print('{:>23} : {:.4f}'.format('mean IoU', result['miou']))
print('{:>23} : {:.4f}'.format('Class average accuracy',
result['mean_class_accuracy']))
print('{:>23} : {:.4f}'.format('Global average accuracy',
result['pixel_accuracy']))
def main():
args = parse_args()
cfg.merge_from_file(args.config)
cfg.freeze
comm = chainermn.create_communicator('pure_nccl')
device = comm.intra_rank
model = setup_model(cfg)
load_pretrained_model(cfg, args.config, model, args.pretrained_model)
dataset = setup_dataset(cfg, 'eval')
model.use_preset('evaluate')
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
if not comm.rank == 0:
apply_to_iterator(model.predict, None, comm=comm)
return
iterator = iterators.MultithreadIterator(dataset,
args.batchsize * comm.size,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)),
comm=comm)
# delete unused iterators explicitly
del in_values
if cfg.dataset.eval == 'COCO':
eval_coco(out_values, rest_values)
elif cfg.dataset.eval == 'VOC':
eval_voc(out_values, rest_values)
else:
raise ValueError()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
args = parser.parse_args()
model = ResNet50(pretrained_model=args.pretrained_model,
n_class=len(voc_bbox_label_names),
arch='he')
model.pick = 'fc6'
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = VOCBboxDataset(split='test', year='2007', use_difficult=False)
dataset = TransformDataset(dataset, ('img', 'bbox'), bbox_to_multi_label)
iterator = iterators.SerialIterator(dataset,
8,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
PredictFunc(model, thresh=0),
iterator,
hook=ProgressHook(len(dataset)))
# delete unused iterators explicitly
del in_values
pred_labels, pred_scores = out_values
gt_labels, = rest_values
result = eval_multi_label_classification(pred_labels, pred_scores,
gt_labels)
print()
print('mAP: {:f}'.format(result['map']))
for l, name in enumerate(voc_bbox_label_names):
if result['ap'][l]:
print('{:s}: {:f}'.format(name, result['ap'][l]))
else:
print('{:s}: -'.format(name))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset',
choices=('cityscapes', 'ade20k', 'camvid'))
parser.add_argument('--model', choices=('pspnet_resnet101', 'segnet'))
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
parser.add_argument('--input-size', type=int, default=None)
args = parser.parse_args()
dataset, label_names, model = get_dataset_and_model(
args.dataset, args.model, args.pretrained_model,
(args.input_size, args.input_size))
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
it = iterators.SerialIterator(dataset, 1, repeat=False, shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
it,
hook=ProgressHook(
len(dataset)))
# Delete an iterator of images to save memory usage.
del in_values
pred_labels, = out_values
gt_labels, = rest_values
result = eval_semantic_segmentation(pred_labels, gt_labels)
for iu, label_name in zip(result['iou'], label_names):
print('{:>23} : {:.4f}'.format(label_name, iu))
print('=' * 34)
print('{:>23} : {:.4f}'.format('mean IoU', result['miou']))
print('{:>23} : {:.4f}'.format('Class average accuracy',
result['mean_class_accuracy']))
print('{:>23} : {:.4f}'.format('Global average accuracy',
result['pixel_accuracy']))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset',
choices=('cityscapes', 'ade20k', 'camvid', 'voc'))
parser.add_argument('--model', choices=sorted(models.keys()))
parser.add_argument('--pretrained-model')
parser.add_argument('--batchsize', type=int)
parser.add_argument('--input-size', type=int, default=None)
args = parser.parse_args()
comm = chainermn.create_communicator('pure_nccl')
device = comm.intra_rank
dataset, eval_, model, batchsize = setup(args.dataset, args.model,
args.pretrained_model,
args.batchsize, args.input_size)
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
if not comm.rank == 0:
apply_to_iterator(model.predict, None, comm=comm)
return
it = iterators.MultithreadIterator(dataset,
batchsize * comm.size,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
it,
hook=ProgressHook(
len(dataset)),
comm=comm)
# Delete an iterator of images to save memory usage.
del in_values
eval_(out_values, rest_values)
def main():
parser = argparse.ArgumentParser(
description='Evaluating convnet from ILSVRC2012 dataset')
parser.add_argument('val', help='Path to root of the validation dataset')
parser.add_argument('--model', choices=sorted(models.keys()))
parser.add_argument('--pretrained-model')
parser.add_argument('--dataset', choices=('imagenet', ))
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int)
parser.add_argument('--crop', choices=('center', '10'))
parser.add_argument('--resnet-arch')
args = parser.parse_args()
dataset, eval_, model, batchsize = setup(args.dataset, args.model,
args.pretrained_model,
args.batchsize, args.val,
args.crop, args.resnet_arch)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
iterator = iterators.MultiprocessIterator(dataset,
batchsize,
repeat=False,
shuffle=False,
n_processes=6,
shared_mem=300000000)
print('Model has been prepared. Evaluation starts.')
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)))
del in_values
eval_(out_values, rest_values)
def test(net,
test_dataset,
num_gpus,
num_classes,
calc_weight_count=False,
extended_log=False,
dataset_metainfo=None):
assert (dataset_metainfo is not None)
tic = time.time()
it = iterators.SerialIterator(
dataset=test_dataset,
batch_size=1,
repeat=False,
shuffle=False)
predictor = SegPredictor(base_model=net)
if num_gpus > 0:
predictor.to_gpu()
if calc_weight_count:
weight_count = net.count_params()
logging.info('Model: {} trainable parameters'.format(weight_count))
in_values, out_values, rest_values = apply_to_iterator(
predictor.predict,
it,
hook=ProgressHook(len(test_dataset)))
del in_values
pred_labels, = out_values
gt_labels, = rest_values
metrics = []
pix_acc_macro_average = False
metrics.append(PixelAccuracyMetric(
vague_idx=dataset_metainfo["vague_idx"],
use_vague=dataset_metainfo["use_vague"],
macro_average=pix_acc_macro_average))
mean_iou_macro_average = False
metrics.append(MeanIoUMetric(
num_classes=num_classes,
vague_idx=dataset_metainfo["vague_idx"],
use_vague=dataset_metainfo["use_vague"],
bg_idx=dataset_metainfo["background_idx"],
ignore_bg=dataset_metainfo["ignore_bg"],
macro_average=mean_iou_macro_average))
labels = iter(gt_labels)
preds = iter(pred_labels)
for label, pred in zip(labels, preds):
for metric in metrics:
metric.update(label, pred)
accuracy_info = [metric.get() for metric in metrics]
pix_acc = accuracy_info[0][1]
mean_iou = accuracy_info[1][1]
pix_macro = "macro" if pix_acc_macro_average else "micro"
iou_macro = "macro" if mean_iou_macro_average else "micro"
if extended_log:
logging.info(
"Test: {pix_macro}-pix_acc={pix_acc:.4f} ({pix_acc}), "
"{iou_macro}-mean_iou={mean_iou:.4f} ({mean_iou})".format(
pix_macro=pix_macro, pix_acc=pix_acc, iou_macro=iou_macro, mean_iou=mean_iou))
else:
logging.info("Test: {pix_macro}-pix_acc={pix_acc:.4f}, {iou_macro}-mean_iou={mean_iou:.4f}".format(
pix_macro=pix_macro, pix_acc=pix_acc, iou_macro=iou_macro, mean_iou=mean_iou))
logging.info('Time cost: {:.4f} sec'.format(
time.time() - tic))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('fcis_resnet101', ),
default='fcis_resnet101')
parser.add_argument('--pretrained-model', default=None)
parser.add_argument('--gpu', type=int, default=-1)
args = parser.parse_args()
if args.model == 'fcis_resnet101':
if args.pretrained_model is None:
args.pretrained_model = 'coco'
proposal_creator_params = FCISResNet101.proposal_creator_params
proposal_creator_params['min_size'] = 2
model = FCISResNet101(
n_fg_class=len(coco_instance_segmentation_label_names),
anchor_scales=(4, 8, 16, 32),
pretrained_model=args.pretrained_model,
proposal_creator_params=proposal_creator_params)
model.use_preset('coco_evaluate')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = COCOInstanceSegmentationDataset(split='minival',
year='2014',
use_crowded=True,
return_crowded=True,
return_area=True)
iterator = iterators.SerialIterator(dataset,
1,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)))
# delete unused iterators explicitly
del in_values
pred_masks, pred_labels, pred_scores = out_values
gt_masks, gt_labels, gt_areas, gt_crowdeds = rest_values
result = eval_instance_segmentation_coco(pred_masks, pred_labels,
pred_scores, gt_masks, gt_labels,
gt_areas, gt_crowdeds)
keys = [
'map/iou=0.50:0.95/area=all/max_dets=100',
'map/iou=0.50/area=all/max_dets=100',
'map/iou=0.75/area=all/max_dets=100',
'map/iou=0.50:0.95/area=small/max_dets=100',
'map/iou=0.50:0.95/area=medium/max_dets=100',
'map/iou=0.50:0.95/area=large/max_dets=100',
'mar/iou=0.50:0.95/area=all/max_dets=1',
'mar/iou=0.50:0.95/area=all/max_dets=10',
'mar/iou=0.50:0.95/area=all/max_dets=100',
'mar/iou=0.50:0.95/area=small/max_dets=100',
'mar/iou=0.50:0.95/area=medium/max_dets=100',
'mar/iou=0.50:0.95/area=large/max_dets=100',
]
print('')
for key in keys:
print('{:s}: {:f}'.format(key, result[key]))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('faster_rcnn', 'ssd300', 'ssd512', 'yolo_v3'),
default='ssd300')
parser.add_argument('--pretrained_model')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=32)
args = parser.parse_args()
if args.model == 'faster_rcnn':
if args.pretrained_model:
model = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
else:
model = FasterRCNNVGG16(pretrained_model='voc07')
elif args.model == 'ssd300':
if args.pretrained_model:
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
else:
model = SSD300(pretrained_model='voc0712')
elif args.model == 'ssd512':
if args.pretrained_model:
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
else:
model = SSD512(pretrained_model='voc0712')
elif args.model == 'yolo_v3':
if args.pretrained_model:
model = YOLOv3(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
else:
model = YOLOv3(pretrained_model='voc0712')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
dataset = VOCBboxDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
iterator = iterators.SerialIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(model.predict,
iterator,
hook=ProgressHook(
len(dataset)))
# delete unused iterators explicitly
del in_values
pred_bboxes, pred_labels, pred_scores = out_values
gt_bboxes, gt_labels, gt_difficults = rest_values
result = eval_detection_voc(pred_bboxes,
pred_labels,
pred_scores,
gt_bboxes,
gt_labels,
gt_difficults,
use_07_metric=True)
print()
print('mAP: {:f}'.format(result['map']))
for l, name in enumerate(voc_bbox_label_names):
if result['ap'][l]:
print('{:s}: {:f}'.format(name, result['ap'][l]))
else:
print('{:s}: -'.format(name))
