def evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
annType = ['segm', 'bbox', 'keypoints']
annType = annType[1]
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
in_values, out_values, rest_values = apply_prediction_to_iterator(
target.predict, it)
# delete unused iterators explicitly
del in_values
pred_bboxes, _, pred_labels, pred_scores, pred_masks = out_values
if len(rest_values) == 3:
gt_bboxes, gt_labels, gt_difficults = rest_values
elif len(rest_values) == 2:
gt_bboxes, gt_labels = rest_values
gt_difficults = None
elif len(rest_values) == 5:
gt_bboxes, gt_labels, _, _, i = rest_values
gt_difficults = None
pred_bboxes = iter(list(pred_bboxes))
pred_labels = iter(list(pred_labels))
pred_scores = iter(list(pred_scores))
gt_bboxes = iter(list(gt_bboxes))
gt_labels = iter(list(gt_labels))
data_dict = []
for i, (pred_bbox, pred_label, pred_score) in \
enumerate(zip(pred_bboxes, pred_labels, pred_scores)):
for bbox, label, score in zip(pred_bbox, pred_label, pred_score):
A = {
"image_id": int(self.ids[i]),
"category_id": int(label),
"bbox": bbox.tolist(),
"score": float(score)
}
data_dict.append(A)
if len(data_dict) > 0:
cocoGt = self.cocoanns
cocoDt = cocoGt.loadRes(data_dict)
cocoEval = COCOeval(self.cocoanns, cocoDt, annType)
cocoEval.params.imgIds = [int(id_) for id_ in self.ids]
cocoEval.evaluate()
cocoEval.accumulate()
cocoEval.summarize()
report = {
'map': cocoEval.stats[0]
} # report COCO AP (IoU=0.5:0:95)
else:
report = {'map': 0}
observation = {}
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
def test_enet():
"""Demo ENet."""
config, img_path = parse_args()
test_data = load_dataset_test(config["dataset"])
test_iter = create_iterator_test(test_data, config['iterator'])
model = get_model(config["model"])
devices = parse_devices(config['gpus'])
if devices:
model.to_gpu(devices['main'])
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, test_iter)
del imgs
pred_labels, = pred_values
gt_labels, = gt_values
result = eval_semantic_segmentation(pred_labels, gt_labels)
for iu, label_name in zip(result['iou'], cityscapes_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():
config, args = parse_args()
model = get_model(config["model"])
if args.gpu != -1:
model.to_gpu(args.gpu)
dataset = VOCBboxDataset(
data_dir="../dataset/VOC_test/VOC2007_test",
year='2007', split='test', use_difficult=True, return_difficult=True)
iterator = iterators.SerialIterator(
dataset, args.batchsize, repeat=False, shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
gt_bboxes, gt_labels, gt_difficults = gt_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))
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():
chainer.config.train = False
parser = argparse.ArgumentParser()
parser.add_argument('--root', required=True)
parser.add_argument('--data_type', choices=opt.data_types, required=True)
parser.add_argument('--det_type',
choices=opt.detectors,
required=True,
default='ssd300')
parser.add_argument('--load', help='load original trained model')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=32)
args = parser.parse_args()
model_args = {
'n_fg_class': len(voc_bbox_label_names),
'pretrained_model': 'voc0712'
}
model = helper.get_detector(args.det_type, model_args)
if args.load:
chainer.serializers.load_npz(args.load, model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
dataset = helper.get_detection_dataset(args.data_type, 'test', args.root)
iterator = chainer.iterators.SerialIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
gt_bboxes, gt_labels = gt_values
result = eval_detection_voc(pred_bboxes,
pred_labels,
pred_scores,
gt_bboxes,
gt_labels,
use_07_metric=True)
aps = result['ap']
aps = aps[~np.isnan(aps)]
print('')
print('mAP: {:f}'.format(100.0 * result['map']))
print(aps)
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 main():
parser = argparse.ArgumentParser()
parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT)
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=32)
args = parser.parse_args()
if args.pretrained_model == TRAINED_MODEL_DEFAULT and \
not os.path.exists(TRAINED_MODEL_DEFAULT):
download_model.download_model(MODEL_URL, TRAINED_MODEL_DEFAULT)
model = FasterRCNNVGG16(n_fg_class=1,
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
#dataset = VOCDetectionDataset(
# year='2007', split='test', use_difficult=True, return_difficult=True)
dataset = WIDERFACEDataset(WIDER_VAL_DIR,
WIDER_VAL_ANNOTATION_MAT,
use_difficult=True,
return_difficult=True)
iterator = iterators.SerialIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
gt_bboxes, gt_labels, gt_difficults = gt_values
ap = eval_detection_voc_ap(pred_bboxes,
pred_labels,
pred_scores,
gt_bboxes,
gt_labels,
gt_difficults,
use_07_metric=True)
map_ = np.nanmean(ap)
print()
print('mAP: {:f}'.format(map_))
for l, name in enumerate(('face', )):
if ap[l]:
print('{:s}: {:f}'.format(name, ap[l]))
else:
print('{:s}: -'.format(name))
def evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
target.predict, it)
# delete unused iterator explicitly
del imgs
mb_boxs, mb_confs = pred_values
_, gt_labels = gt_values
report = {}
label_groups = SSDTripletLoss._get_label_groups(
self.filter_overlapping_bboxs(mb_boxs, mb_confs, gt_labels))
del label_groups[0]
self.convert_label_groups(label_groups)
if self._save:
self.plot_roc_curves(label_groups)
for label, feat_v in label_groups.items():
avg_dist = -1
if feat_v.shape[0] > 1:
distances = pdist(feat_v)
avg_dist = mean(distances)
label_name = self.label_names[label - 1]
report['main/avg_dist/{}'.format(label_name)] = avg_dist
if self._save:
tsne = TSNE(n_components=2)
tsne_pca_data = tsne.fit_transform(feat_v)
plt.scatter([x[0] for x in tsne_pca_data],
[x[1] for x in tsne_pca_data],
label=label_name)
if self._save:
plt.legend()
plt.savefig(self._save_path + '/triplet_scatter_{0}.jpg'.format(
time.strftime("%Y-%m-%d-%H:%M")))
plt.clf()
print(report)
observation = dict()
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
def evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
in_values, out_values, rest_values = apply_prediction_to_iterator(
target.predict, it)
# delete unused iterators explicitly
del in_values
pred_bboxes, _, pred_labels, pred_scores, _ = out_values
if len(rest_values) == 3:
gt_bboxes, gt_labels, gt_difficults = rest_values
elif len(rest_values) == 2:
gt_bboxes, gt_labels = rest_values
gt_difficults = None
elif len(rest_values) == 4:
gt_bboxes, gt_labels, _, _ = rest_values
gt_difficults = None
result = eval_detection_coco.eval_detection_coco(
pred_bboxes,
pred_labels,
pred_scores,
gt_bboxes,
gt_labels,
gt_difficults,
use_07_metric=self.use_07_metric)
report = {'map': result['map']}
if self.label_names is not None:
for l, label_name in enumerate(self.label_names):
try:
report['ap/{:s}'.format(label_name)] = result['ap'][l]
except IndexError:
report['ap/{:s}'.format(label_name)] = np.nan
if True:
print(report)
observation = {}
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
def evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
if self._show_progress:
it = tqdm.tqdm(it, total=len(it.dataset))
imgs, pred_values, gt_values = apply_prediction_to_iterator(
target.predict, it)
pred_bboxes, pred_masks, pred_labels, pred_scores = pred_values
if len(gt_values) == 5:
gt_bboxes, gt_labels, gt_masks, gt_crowdeds, gt_areas = gt_values
elif len(gt_values) == 3:
gt_bboxes, gt_labels, gt_masks = gt_values
gt_crowdeds = None
gt_areas = None
# evaluate
result = mrcnn.utils.eval_instseg_coco(pred_masks, pred_labels,
pred_scores, gt_masks,
gt_labels, gt_crowdeds,
gt_areas)
report = {
'map': result['map/iou=0.50:0.95/area=all/maxDets=100'],
'[email protected]': result['map/iou=0.50/area=all/maxDets=100'],
'[email protected]': result['map/iou=0.75/area=all/maxDets=100'],
}
if self.label_names is not None:
for l, label_name in enumerate(self.label_names):
try:
report['ap/{:s}'.format(label_name)] = \
result['ap/iou=0.50:0.95/area=all/maxDets=100'][l]
except IndexError:
report['ap/{:s}'.format(label_name)] = np.nan
observation = dict()
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
def evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
# set current device to devices['main']
with chainer.cuda.Device(self.device):
print(self.device)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
target.predict, it)
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
if len(gt_values) == 3:
gt_bboxes, gt_labels, gt_difficults = gt_values
elif len(gt_values) == 2:
gt_bboxes, gt_labels = gt_values
gt_difficults = None
result = eval_detection_voc(pred_bboxes,
pred_labels,
pred_scores,
gt_bboxes,
gt_labels,
gt_difficults,
use_07_metric=self.use_07_metric)
report = {'map': result['map']}
if self.label_names is not None:
for l, label_name in enumerate(self.label_names):
try:
report['ap/{:s}'.format(label_name)] = result['ap'][l]
except IndexError:
report['ap/{:s}'.format(label_name)] = np.nan
observation = dict()
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
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', ))
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')
args = parser.parse_args()
dataset = DirectoryParsingClassificationDataset(args.val)
label_names = directory_parsing_label_names(args.val)
iterator = iterators.MultiprocessIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False,
n_processes=6,
shared_mem=300000000)
if args.model == 'vgg16':
extractor = VGG16(pretrained_model=args.pretrained_model,
n_class=len(label_names))
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.')
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
del imgs
pred_probs, = pred_values
gt_probs, = gt_values
accuracy = F.accuracy(np.array(list(pred_probs)),
np.array(list(gt_probs))).data
print()
print('Top 1 Error {}'.format(1. - 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:
model.to_gpu(args.gpu)
model = calc_bn_statistics(model, args.batchsize)
chainer.config.train = False
test = CamVidDataset(split='test')
it = chainer.iterators.SerialIterator(test,
batch_size=args.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, it)
# Delete an iterator of images to save memory usage.
del imgs
pred_labels, = pred_values
gt_labels, = gt_values
confusion = calc_semantic_segmentation_confusion(pred_labels, gt_labels)
ious = calc_semantic_segmentation_iou(confusion)
pixel_accuracy = np.diag(confusion).sum() / confusion.sum()
mean_pixel_accuracy = np.mean(
np.diag(confusion) / np.sum(confusion, axis=1))
for iou, label_name in zip(ious, camvid_label_names):
print('{:>23} : {:.4f}'.format(label_name, iou))
print('=' * 34)
print('{:>23} : {:.4f}'.format('mean IoU', np.nanmean(ious)))
print('{:>23} : {:.4f}'.format('Class average accuracy',
mean_pixel_accuracy))
print('{:>23} : {:.4f}'.format('Global average accuracy', pixel_accuracy))
def test_apply_prediction_to_iterator_with_infinite_iterator(self):
def predict(imgs):
n_img = len(imgs)
return [np.random.uniform(size=(48, 64)) for _ in range(n_img)]
dataset = []
for _ in range(5):
H, W = np.random.randint(8, 16, size=2)
dataset.append(np.random.randint(0, 256, size=(3, H, W)))
iterator = SerialIterator(dataset, 2)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
predict, iterator)
for _ in range(10):
next(imgs)
for _ in range(10):
next(pred_values[0])
def evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
target.predict, it)
# delete unused iterator explicitly
sizes = [img.shape for img in imgs]
del imgs
pred_bboxes, pred_masks, pred_labels, pred_scores = pred_values
gt_bboxes, gt_masks, gt_labels = gt_values
result = eval_instance_segmentation_coco(sizes, pred_bboxes,
pred_masks, pred_labels,
pred_scores, gt_bboxes,
gt_masks, gt_labels)
report = {
'mAP[0.50:0.95]':
result['ap/iou=0.50:0.95/area=all/maxDets=100'],
'mAP[0.50:]':
result['ap/iou=0.50/area=all/maxDets=100'],
'mAP[0.50:0.95] (small)':
result['ap/iou=0.50:0.95/area=small/maxDets=100'], # NOQA
'mAP[0.50:0.95] (mid)':
result['ap/iou=0.50:0.95/area=medium/maxDets=100'], # NOQA
'mAP[0.50:0.95] (large)':
result['ap/iou=0.50:0.95/area=large/maxDets=100'], # NOQA
}
observation = dict()
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
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)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, it)
# Delete an iterator of iamges to save memory usage.
del imgs
pred_labels, = pred_values
gt_labels, = gt_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_calss_accuracy"]))
print("{:>23} : {:.4f}".format("Global average accuracy",
result["pixe;_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)
chainer.config.train = False
test = CamVidDataset(split='test')
it = chainer.iterators.SerialIterator(test,
batch_size=args.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, it)
# Delete an iterator of images to save memory usage.
del imgs
pred_labels, = pred_values
gt_labels, = gt_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 evaluate(self):
iterator = self._iterators['main']
target = self._targets['main']
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
target.predict, it)
# delete unused iterator explicitly
del imgs
pred_labels, = pred_values
gt_labels, = gt_values
result = eval_semantic_segmentation(pred_labels, gt_labels)
report = {
'miou': result['miou'],
'pixel_accuracy': result['pixel_accuracy'],
'mean_class_accuracy': result['mean_class_accuracy']
}
if self.label_names is not None:
for l, label_name in enumerate(self.label_names):
try:
report['iou/{:s}'.format(label_name)] = result['iou'][l]
report['class_accuracy/{:s}'.format(label_name)] =\
result['class_accuracy'][l]
except IndexError:
report['iou/{:s}'.format(label_name)] = np.nan
report['class_accuracy/{:s}'.format(label_name)] = np.nan
observation = dict()
with reporter.report_scope(observation):
reporter.report(report, target)
return observation
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('faster_rcnn', 'ssd300', 'ssd512'),
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=20,
pretrained_model=args.pretrained_model)
else:
model = FasterRCNNVGG16(pretrained_model='voc07')
elif args.model == 'ssd300':
if args.pretrained_model:
model = SSD300(n_fg_class=20,
pretrained_model=args.pretrained_model)
else:
model = SSD300(pretrained_model='voc0712')
elif args.model == 'ssd512':
if args.pretrained_model:
model = SSD512(n_fg_class=20,
pretrained_model=args.pretrained_model)
else:
model = SSD512(pretrained_model='voc0712')
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
dataset = VOCDetectionDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
iterator = iterators.SerialIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
gt_bboxes, gt_labels, gt_difficults = gt_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_detection_label_names):
if result['ap'][l]:
print('{:s}: {:f}'.format(name, result['ap'][l]))
else:
print('{:s}: -'.format(name))
def main():
chainer.config.train = False
parser = argparse.ArgumentParser()
parser.add_argument('--root', required=True)
parser.add_argument('--data_type', choices=opt.data_types, required=True)
parser.add_argument('--det_type',
choices=opt.detectors,
required=True,
default='ssd300')
parser.add_argument('--result', required=True)
parser.add_argument('--load', help='load original trained model')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=32)
args = parser.parse_args()
model_args = {
'n_fg_class': len(voc_bbox_label_names),
'pretrained_model': 'voc0712'
}
model = helper.get_detector(args.det_type, model_args)
if args.load:
chainer.serializers.load_npz(args.load, model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
dataset = helper.get_detection_dataset(args.data_type, 'train', args.root)
iterator = chainer.iterators.SerialIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=helper.ProgressHook(len(dataset)))
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
_, gt_labels = gt_values
ids = []
for i, (pred_b, pred_l, pred_s, gt_l) in enumerate(
zip(pred_bboxes, pred_labels, pred_scores, gt_labels)):
labels = dataset.labels
proper_dets = defaultdict(list)
name = dataset.ids[i]
cnt = 0
gt_l = set(gt_l)
for l in set(gt_l):
cnt += 1
class_indices = np.where(pred_l == l)[0]
if len(class_indices) == 0:
continue
scores = pred_s[class_indices]
ind = class_indices[np.argsort(scores)[::-1][0]] # top1
assert (l == pred_l[ind])
proper_dets[labels[l]].append(pred_b[ind][[1, 0, 3, 2]])
if cnt == 0:
continue
ids.append(dataset.ids[i] + '\n')
filename = os.path.join(args.result, 'Annotations', name + '.xml')
img_path = os.path.join(args.result, 'JPEGImages', name + '.jpg')
labeler = LabelFile(filename, img_path, dataset.actual_labels)
labeler.savePascalVocFormat(proper_dets)
txt = 'ImageSets/Main/train.txt'
with open(os.path.join(args.result, txt), 'w') as f:
f.writelines(ids)
print('Saved to {:s}'.format(args.result))
def test_apply_prediction_to_iterator(self):
if self.multi_pred_values:
def predict(imgs):
n_img = len(imgs)
return ([
np.random.uniform(size=(10, 4)) for _ in range(n_img)
], [np.random.uniform(size=10) for _ in range(n_img)],
[np.random.uniform(size=10) for _ in range(n_img)])
n_pred_values = 3
else:
def predict(imgs):
n_img = len(imgs)
return [np.random.uniform(size=(48, 64)) for _ in range(n_img)]
n_pred_values = 1
dataset_imgs = []
for _ in range(5):
H, W = np.random.randint(8, 16, size=2)
dataset_imgs.append(np.random.randint(0, 256, size=(3, H, W)))
if self.with_gt_values:
strs = ['a', 'bc', 'def', 'ghij', 'klmno']
nums = [0, 1, 2, 3, 4]
arrays = [np.random.uniform(size=10) for _ in range(5)]
dataset = chainer.datasets.TupleDataset(dataset_imgs, strs, nums,
arrays)
dataset_gt_values = (strs, nums, arrays)
else:
dataset = dataset_imgs
dataset_gt_values = tuple()
iterator = SerialIterator(dataset, 2, repeat=False, shuffle=False)
if self.with_hook:
def hook(imgs, pred_values, gt_values):
self.assertEqual(len(pred_values), n_pred_values)
for pred_vals in pred_values:
self.assertEqual(len(pred_vals), len(imgs))
self.assertEqual(len(gt_values), len(dataset_gt_values))
for gt_vals in gt_values:
self.assertEqual(len(gt_vals), len(imgs))
else:
hook = None
imgs, pred_values, gt_values = apply_prediction_to_iterator(predict,
iterator,
hook=hook)
for img, dataset_img in zip_longest(imgs, dataset_imgs):
np.testing.assert_equal(img, dataset_img)
self.assertEqual(len(pred_values), n_pred_values)
for vals in pred_values:
self.assertEqual(len(list(vals)), len(dataset_imgs))
for vals, dataset_vals in zip_longest(gt_values, dataset_gt_values):
for val, dataset_val in zip_longest(vals, dataset_vals):
if isinstance(dataset_val, np.ndarray):
np.testing.assert_equal(val, dataset_val)
else:
self.assertEqual(val, dataset_val)
def __call__(self, trainer):
iterator = self._iterators['main']
target = self._targets['main']
target.use_preset('visualize')
if hasattr(iterator, 'reset'):
iterator.reset()
it = iterator
else:
it = copy.copy(iterator)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
target.predict, it)
pred_bboxes, pred_masks, pred_labels, pred_scores = pred_values
gt_bboxes, gt_labels, gt_masks = gt_values[:3]
# visualize
vizs = []
for img, gt_bbox, gt_label, gt_mask, \
pred_bbox, pred_label, pred_mask, pred_score \
in six.moves.zip(imgs, gt_bboxes, gt_labels, gt_masks,
pred_bboxes, pred_labels, pred_masks,
pred_scores):
# organize input
img = img.transpose(1, 2, 0) # CHW -> HWC
gt_mask = gt_mask.astype(bool)
label_names = np.hstack((['__background__'], self.label_names))
n_class = len(label_names)
gt_viz = mrcnn.utils.draw_instance_bboxes(
img,
gt_bbox,
gt_label + 1,
n_class=n_class,
masks=gt_mask,
captions=label_names[gt_label + 1],
bg_class=0)
captions = []
for p_score, l_name in zip(pred_score,
label_names[pred_label + 1]):
caption = '{:s} {:.1%}'.format(l_name, p_score)
captions.append(caption)
pred_viz = mrcnn.utils.draw_instance_bboxes(img,
pred_bbox,
pred_label + 1,
n_class=n_class,
masks=pred_mask,
captions=captions,
bg_class=0)
viz = np.vstack([gt_viz, pred_viz])
vizs.append(viz)
if len(vizs) >= (self._shape[0] * self._shape[1]):
break
viz = fcn.utils.get_tile_image(vizs, tile_shape=self._shape)
file_name = osp.join(trainer.out,
self.file_name % trainer.updater.iteration)
try:
os.makedirs(osp.dirname(file_name))
except OSError:
pass
cv2.imwrite(file_name, viz[:, :, ::-1])
if self._copy_latest:
shutil.copy(file_name,
osp.join(osp.dirname(file_name), 'latest.jpg'))
target.use_preset('evaluate')
def eval(self):
pred_bboxes,pred_labels,pred_scores,gt_bboxes,gt_labels = [],[],[],[],[]
if self.loadfrom:
pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels = self.backuper.load(
self.loadfrom)
print("The lists have been loaded with {} objects.".format(
len(pred_bboxes)))
else:
if self.model == 'faster_rcnn':
if self.pretrained_model:
model = FasterRCNNVGG16(
n_fg_class=20, pretrained_model=self.pretrained_model)
else:
model = FasterRCNNVGG16(pretrained_model='voc07')
elif self.model == 'ssd300':
if self.pretrained_model:
model = SSD300(n_fg_class=20,
pretrained_model=self.pretrained_model)
else:
model = SSD300(pretrained_model='voc0712')
elif self.model == 'ssd512':
if self.pretrained_model:
model = SSD512(n_fg_class=20,
pretrained_model=self.pretrained_model)
else:
model = SSD512(pretrained_model='voc0712')
if self.gpu >= 0:
chainer.cuda.get_device_from_id(self.gpu).use()
model.to_gpu()
model.use_preset('evaluate')
# dataset = VOCBboxDataset(
# year='2007', split='test', use_difficult=True, return_difficult=True)
dataset = PTI01BboxDataset(limit=self.limit,
imagespath=self.imagespath,
labelspath=self.labelspath)
iterator = iterators.SerialIterator(dataset,
self.batchsize,
repeat=False,
shuffle=False)
imgs, pred_values, gt_values = apply_prediction_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
# delete unused iterator explicitly
del imgs
pred_bboxes, pred_labels, pred_scores = pred_values
gt_bboxes, gt_labels = gt_values
pred_bboxes = list(pred_bboxes)
pred_labels = list(pred_labels)
pred_scores = list(pred_scores)
gt_bboxes = list(gt_bboxes)
gt_labels = list(gt_labels)
self.backuper.save(
self.model, 'pti01', len(dataset),
(pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels))
if (len(gt_bboxes) == 0):
print('Warning: gt_bboxes is empty')
gt_bboxes, gt_label = [], []
# print('{} {} {} {} {}'.format(len(pred_bboxes),len(pred_labels),len(pred_scores),len(gt_bboxes),len(gt_labels)))
metrics = PTI01Metrics(
(pred_bboxes, pred_labels, pred_scores, gt_bboxes, gt_labels),
model=self.model,
metric=self.metric,
database_name='PTI01',
limit=self.limit,
plottings=self.plot)
metrics.calc()
