def test_pretrained(self):
kwargs = {
'n_fg_class': self.n_fg_class,
'pretrained_model': self.pretrained_model,
}
if self.pretrained_model == 'voc0712':
valid = self.n_fg_class in {None, 20}
if valid:
YOLOv2Tiny(**kwargs)
else:
with self.assertRaises(ValueError):
YOLOv2Tiny(**kwargs)
def export_onnx(input_image_path, output_path, gpu, only_output=True):
"""Export YOLOv2 Tiny model to ONNX graph
'model.onnx' file will be exported under ``output_path``.
"""
model = YOLOv2Tiny(pretrained_model='voc0712')
input_image = read_image(input_image_path)
input_image = input_image[None, :]
if gpu >= 0:
model.to_gpu()
input_image = chainer.cuda.to_gpu(input_image)
if only_output:
os.makedirs(output_path, exist_ok=True)
name = os.path.join(output_path, 'model.onnx')
export(
model, input_image, filename=name,
output_names=('locs', 'objs', 'confs'))
else:
# an input and output given by Chainer will be also emitted
# for using as test dataset
export_testcase(
model, input_image, output_path,
output_names=('locs', 'objs', 'confs'))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model', choices=('yolo_v2', 'yolo_v2_tiny', 'yolo_v3'),
default='yolo_v2')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model', default='voc0712')
parser.add_argument('image')
args = parser.parse_args()
if args.model == 'yolo_v2':
model = YOLOv2(
n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'yolo_v2_tiny':
model = YOLOv2Tiny(
n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'yolo_v3':
model = YOLOv3(
n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
img = utils.read_image(args.image, color=True)
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
vis_bbox(
img, bbox, label, score, label_names=voc_bbox_label_names)
plt.show()
def __init__(self, gpu, model, nms_thresh= 0.45, score_thresh=0.6):
self.gpu = gpu
if model == 'yolo_v2_tiny':
self.model = YOLOv2Tiny(
n_fg_class=len(voc_bbox_label_names),
pretrained_model='voc0712')
elif model == 'yolo_v3':
self.model = YOLOv3(
n_fg_class=len(voc_bbox_label_names),
pretrained_model='voc0712')
elif model == 'ssd300':
self.model = SSD300(
n_fg_class=len(voc_bbox_label_names),
pretrained_model='voc0712')
elif model == 'ssd512':
self.model = SSD512(
n_fg_class=len(voc_bbox_label_names),
pretrained_model='voc0712')
elif model == 'fasterrcnnvgg16':
self.model = FasterRCNNVGG16(
n_fg_class=len(coco_bbox_label_names),
pretrained_model='voc0712')
elif model == 'fasterrcnnfpnresnet50':
self.model = FasterRCNNFPNResNet50(
n_fg_class=len(coco_bbox_label_names),
pretrained_model='coco')
elif model == 'fasterrcnnfpnresnet101':
self.model = FasterRCNNFPNResNet101(
n_fg_class=len(coco_bbox_label_names),
pretrained_model='coco')
else:
self.model = YOLOv2(
n_fg_class=len(voc_bbox_label_names),
pretrained_model='voc0712')
#self.model.nms_thresh = nms_thresh
#self.model.score_thresh = score_thresh
if self.gpu >= 0:
chainer.cuda.get_device_from_id(self.gpu).use()
self.model.to_gpu()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model', choices=('yolo_v2', 'yolo_v2_tiny', 'yolo_v3'),
default='yolo_v2')
parser.add_argument('--n-fg-class', type=int, default=80)
parser.add_argument('darknetmodel')
parser.add_argument('output')
args = parser.parse_args()
if args.model == 'yolo_v2':
model = YOLOv2(n_fg_class=args.n_fg_class)
elif args.model == 'yolo_v2_tiny':
model = YOLOv2Tiny(n_fg_class=args.n_fg_class)
elif args.model == 'yolo_v3':
model = YOLOv3(n_fg_class=args.n_fg_class)
with chainer.using_config('train', False):
model(np.empty((1, 3, model.insize, model.insize), dtype=np.float32))
with open(args.darknetmodel, mode='rb') as f:
major = np.fromfile(f, dtype=np.int32, count=1)
minor = np.fromfile(f, dtype=np.int32, count=1)
np.fromfile(f, dtype=np.int32, count=1) # revision
if major * 10 + minor >= 2 and major < 1000 and minor < 1000:
np.fromfile(f, dtype=np.int64, count=1) # seen
else:
np.fromfile(f, dtype=np.int32, count=1) # seen
if args.model == 'yolo_v2':
load_yolo_v2(f, model)
elif args.model == 'yolo_v2_tiny':
load_yolo_v2(f, model)
elif args.model == 'yolo_v3':
load_yolo_v3(f, model)
serializers.save_npz(args.output, model)
def main():
dataset = VOCBboxDataset(year='2007', split='test') \
.slice[[29, 301, 189, 229], 'img']
models = [
('Faster R-CNN', FasterRCNNVGG16(pretrained_model='voc07')),
('SSD300', SSD300(pretrained_model='voc0712')),
('SSD512', SSD512(pretrained_model='voc0712')),
('YOLOv2', YOLOv2(pretrained_model='voc0712')),
('YOLOv2 tiny', YOLOv2Tiny(pretrained_model='voc0712')),
('YOLOv3', YOLOv3(pretrained_model='voc0712')),
]
fig = plt.figure(figsize=(30, 20))
for i, img in enumerate(dataset):
for j, (name, model) in enumerate(models):
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
ax = fig.add_subplot(
len(dataset), len(models), i * len(models) + j + 1)
vis_bbox(
img, bbox, label, score,
label_names=voc_bbox_label_names, ax=ax
)
# Set MatplotLib parameters
ax.set_aspect('equal')
if i == 0:
font = FontProperties()
font.set_family('serif')
font.set_size(35)
ax.set_title(name, y=1.03, fontproperties=font)
plt.axis('off')
plt.tight_layout()
plt.show()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('faster_rcnn', 'ssd300', 'ssd512', 'yolo_v2',
'yolo_v2_tiny', '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_v2':
if args.pretrained_model:
model = YOLOv2(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
else:
model = YOLOv2(pretrained_model='voc0712')
elif args.model == 'yolo_v2_tiny':
if args.pretrained_model:
model = YOLOv2Tiny(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
else:
model = YOLOv2(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))
def setUp(self):
self.link = YOLOv2Tiny(n_fg_class=self.n_fg_class)
self.insize = 416
self.n_bbox = 13 * 13 * 5