def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
parser.add_argument('--dataset', choices=('voc', ), default='voc')
parser.add_argument('image')
args = parser.parse_args()
if args.dataset == 'voc':
if args.pretrained_model is None:
args.pretrained_model = 'voc07'
label_names = voc_bbox_label_names
model = FasterRCNNVGG16(n_fg_class=len(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=label_names)
plt.show()
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}
elif self.pretrained_model == 'imagenet':
valid = self.n_fg_class is not None
if valid:
FasterRCNNVGG16(**kwargs)
else:
with self.assertRaises(ValueError):
FasterRCNNVGG16(**kwargs)
def main():
dataset = VOCBboxDataset(year='2007', split='test')
models = [
('Faster R-CNN', FasterRCNNVGG16(pretrained_model='voc07')),
('SSD300', SSD300(pretrained_model='voc0712')),
('SSD512', SSD512(pretrained_model='voc0712')),
]
indices = [29, 301, 189, 229]
fig = plt.figure(figsize=(30, 30))
for i, idx in enumerate(indices):
for j, (name, model) in enumerate(models):
img, _, _ = dataset[idx]
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
ax = fig.add_subplot(
len(indices), 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')
ax.set_title(name, fontsize=35, y=1.03, fontproperties=font)
plt.axis('off')
plt.tight_layout()
plt.show()
def main():
chainer.config.train = False
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT)
parser.add_argument('image')
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:
model.to_gpu(args.gpu)
chainer.cuda.get_device(args.gpu).use()
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=('face', ))
plot.show()
def setUp(self):
proposal_creator_params = {
'n_train_post_nms': self.n_train_post_nms,
'n_test_post_nms': self.n_test_post_nms
}
self.link = FasterRCNNVGG16(
self.n_fg_class,
pretrained_model=None,
proposal_creator_params=proposal_creator_params)
def get_detector(det_type, model_args):
if det_type == 'ssd300':
model = SSD300(**model_args)
elif det_type == 'ssd512':
model = SSD512(**model_args)
elif det_type == 'faster':
model = FasterRCNNVGG16(**model_args)
else:
raise NotImplementedError
return model
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 set_model(self, n_class=2):
"""モデルのセット
Args:
n_class (int, optional): 認識する物体クラスの数. Defaults to 2.
"""
faster_rcnn = FasterRCNNVGG16(n_fg_class=n_class, pretrained_model="imagenet")
faster_rcnn.use_preset("evaluate")
model = FasterRCNNTrainChain(faster_rcnn)
self.model = model
self.logger.info("set FasterRCNNVGG16, pretrained=imagenet")
def main():
chainer.config.train = False
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT)
parser.add_argument('image')
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)
try:
model = FasterRCNNVGG16(n_fg_class=1,
pretrained_model=args.pretrained_model)
# Workaround for the newer version of chainercv (maybe v0.7.0 and higher)
except KeyError:
if args.pretrained_model == TRAINED_MODEL_DEFAULT and \
not os.path.exists(TRAINED_MODEL_NEW):
download_model.download_model(MODEL_URL_NEW, TRAINED_MODEL_NEW)
model = FasterRCNNVGG16(n_fg_class=1,
pretrained_model=TRAINED_MODEL_NEW)
else:
model = FasterRCNNVGG16(n_fg_class=1,
pretrained_model=TRAINED_MODEL_NEW)
if args.gpu >= 0:
model.to_gpu(args.gpu)
chainer.cuda.get_device(args.gpu).use()
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=('face',))
vis_bbox(img, bbox)
print(bbox)
plot.show()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model', default='voc07')
parser.add_argument('--output-dir', '-o', default='output_img')
parser.add_argument(
'--images',
'-i',
default=
'/home/takagi.kazunari/projects/datasets/SUNRGBD_2DBB_fixed/test/image'
)
args = parser.parse_args()
dataset = SUNRGBDDataset(
"/home/takagi.kazunari/projects/datasets/SUNRGBD_2DBB_fixed")
sunrgbd_bbox_label_names = dataset.get_dataset_label()
model = FasterRCNNVGG16(n_fg_class=len(sunrgbd_bbox_label_names),
pretrained_model=args.pretrained_model)
if args.pretrained_model == 'voc07':
model = FasterRCNNVGG16(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()
f_names = glob.glob(osp.join(args.images, "*"))
for f_name in tqdm(f_names):
img = utils.read_image(osp.join(args.images, f_name), color=True)
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
out_f_name = f_name.split("/")[-1]
vis_bbox(img, bbox, label, score, label_names=sunrgbd_bbox_label_names)
plt.savefig(osp.join(args.output_dir, "res_" + out_f_name))
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=('faster_rcnn', 'ssd300', 'ssd512'),
default='ssd300')
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':
model = FasterRCNNVGG16(pretrained_model='voc07')
elif args.model == 'ssd300':
model = SSD300(pretrained_model='voc0712')
elif args.model == 'ssd512':
model = SSD512(pretrained_model='voc0712')
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)
iterator = iterators.SerialIterator(dataset,
args.batchsize,
repeat=False,
shuffle=False)
pred_bboxes, pred_labels, pred_scores, gt_values = \
apply_detection_link(model, iterator, hook=ProgressHook(len(dataset)))
gt_bboxes, gt_labels, gt_difficults = gt_values
eval_ = eval_detection_voc(pred_bboxes,
pred_labels,
pred_scores,
gt_bboxes,
gt_labels,
gt_difficults,
use_07_metric=True)
print()
print('mAP: {:f}'.format(eval_['map']))
for l, name in enumerate(voc_detection_label_names):
if l in eval_:
print('{:s}: {:f}'.format(name, eval_[l]['ap']))
else:
print('{:s}: -'.format(name))
def setUp(self):
faster_rcnn = FasterRCNNVGG16(
n_fg_class=self.n_fg_class, pretrained_model=False)
self.link = FasterRCNNTrainChain(faster_rcnn)
self.n_bbox = 3
self.bboxes = chainer.Variable(
generate_random_bbox(self.n_bbox, (600, 800), 16, 350)[np.newaxis])
_labels = np.random.randint(
0, self.n_fg_class, size=(1, self.n_bbox)).astype(np.int32)
self.labels = chainer.Variable(_labels)
_imgs = np.random.uniform(
low=-122.5, high=122.5, size=(1, 3, 600, 800)).astype(np.float32)
self.imgs = chainer.Variable(_imgs)
self.scale = chainer.Variable(np.array(1.))
def load_model(self, model_file, n_class=2):
"""Detectorモデルをロードする
Args:
model_file (str): モデルファイルパス
n_class (int, optional): 認識物体の数. Defaults to 2.
"""
_ = util.check_file(model_file)
model = FasterRCNNVGG16(n_fg_class=n_class,
pretrained_model=model_file)
if self.gpu >= 0:
chainer.cuda.get_device_from_id(self.gpu).use()
model.to_gpu()
self.logger.info(f"use GPU: {self.gpu}")
self.model = model
self.model_file = model_file
def get_faster_rcnn(n):
frc = FasterRCNNVGG16(n_fg_class=20)
model = FasterRCNNTrainChain(frc)
batchsize = 1 # only 1 is supported
K = 10
x = np.random.uniform(size=(batchsize, 3, n * 512, 512)).astype('f')
x = chainer.as_variable(x)
bbox = np.random.uniform(size=(batchsize, K, 4)).astype('f')
bbox = chainer.as_variable(bbox)
labels = np.random.randint(size=(batchsize, K), low=0, high=20)\
.astype(np.int32)
labels = chainer.as_variable(labels)
scale = np.ones((batchsize, )).astype('f')
scale = chainer.as_variable(scale)
return [x, bbox, labels, scale], model
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained_model', default='voc07')
parser.add_argument('image')
args = parser.parse_args()
model = FasterRCNNVGG16(n_fg_class=len(voc_detection_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
model.to_gpu(args.gpu)
chainer.cuda.get_device(args.gpu).use()
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_detection_label_names)
plot.show()
def main():
parser = argparse.ArgumentParser(
description='ChainerCV training example: Faster R-CNN')
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--lr', '-l', type=float, default=1e-3)
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--seed', '-s', type=int, default=0)
parser.add_argument('--step_size', '-ss', type=int, default=50000)
parser.add_argument('--iteration', '-i', type=int, default=70000)
args = parser.parse_args()
np.random.seed(args.seed)
train_data = VOCDetectionDataset(split='trainval', year='2007')
test_data = VOCDetectionDataset(split='test',
year='2007',
use_difficult=True,
return_difficult=True)
faster_rcnn = FasterRCNNVGG16(n_fg_class=len(voc_detection_label_names),
pretrained_model='imagenet')
faster_rcnn.use_preset('evaluate')
model = FasterRCNNTrainChain(faster_rcnn)
if args.gpu >= 0:
model.to_gpu(args.gpu)
chainer.cuda.get_device(args.gpu).use()
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
def transform(in_data):
img, bbox, label = in_data
_, H, W = img.shape
img = faster_rcnn.prepare(img)
_, o_H, o_W = img.shape
scale = o_H / H
bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W))
# horizontally flip
img, params = transforms.random_flip(img,
x_random=True,
return_param=True)
bbox = transforms.flip_bbox(bbox, (o_H, o_W), x_flip=params['x_flip'])
return img, bbox, label, scale
train_data = TransformDataset(train_data, transform)
train_iter = chainer.iterators.MultiprocessIterator(train_data,
batch_size=1,
n_processes=None,
shared_mem=100000000)
test_iter = chainer.iterators.SerialIterator(test_data,
batch_size=1,
repeat=False,
shuffle=False)
updater = chainer.training.updater.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = training.Trainer(updater, (args.iteration, 'iteration'),
out=args.out)
trainer.extend(extensions.snapshot_object(model.faster_rcnn,
'snapshot_model.npz'),
trigger=(args.iteration, 'iteration'))
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(args.step_size, 'iteration'))
log_interval = 20, 'iteration'
plot_interval = 3000, 'iteration'
print_interval = 20, 'iteration'
trainer.extend(chainer.training.extensions.observe_lr(),
trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'iteration',
'epoch',
'elapsed_time',
'lr',
'main/loss',
'main/roi_loc_loss',
'main/roi_cls_loss',
'main/rpn_loc_loss',
'main/rpn_cls_loss',
'validation/main/map',
]),
trigger=print_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(['main/loss'],
file_name='loss.png',
trigger=plot_interval),
trigger=plot_interval)
trainer.extend(
DetectionVOCEvaluator(test_iter,
model.faster_rcnn,
use_07_metric=True,
label_names=voc_detection_label_names),
trigger=ManualScheduleTrigger([args.step_size, args.iteration],
'iteration'),
invoke_before_training=False)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.run()
path = ''
path2 = ''
while not os.path.exists(path):
print("Please type text FilePath")
path = input(">>")
while not os.path.exists(path2):
print("Please type Output FilePath \n Default is C:\\DriveRecorder\\test")
path2 = input(">>")
if path2 == '':
path2 = r'C:\DriveRecorder\test'
break
model = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names),
pretrained_model="voc07")
chainer.cuda.get_device_from_id(0).use()
print("Runing on GPU")
model.to_gpu()
print('Initialize Complete')
while True:
f = open(path)
before = f.read()
f.close()
while True:
f = open(path)
after = f.read()
f.close()
if before != after:
def main():
bbox_label_names = ('loop')
n_itrs = 70000
n_step = 50000
np.random.seed(0)
train_data = DefectDetectionDataset(split='train')
test_data = DefectDetectionDataset(split='test')
proposal_params = {'min_size': 8}
faster_rcnn = FasterRCNNVGG16(n_fg_class=1, pretrained_model='imagenet', ratios=[0.5, 1, 2],
anchor_scales=[1, 4, 8, 16], min_size=512, max_size=1024,
proposal_creator_params=proposal_params)
faster_rcnn.use_preset('evaluate')
model = FasterRCNNTrainChain(faster_rcnn)
chainer.cuda.get_device_from_id(0).use()
model.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(lr=1e-3, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
train_data = TransformDataset(train_data, Transform(faster_rcnn))
train_iter = chainer.iterators.MultiprocessIterator(
train_data, batch_size=1, n_processes=None, shared_mem=100000000)
test_iter = chainer.iterators.SerialIterator(
test_data, batch_size=1, repeat=False, shuffle=False)
updater = chainer.training.updater.StandardUpdater(
train_iter, optimizer, device=0)
trainer = training.Trainer(
updater, (n_itrs, 'iteration'), out='result')
trainer.extend(
extensions.snapshot_object(model.faster_rcnn, 'snapshot_model_{.updater.iteration}.npz'),
trigger=(n_itrs/5, 'iteration'))
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(n_step, 'iteration'))
log_interval = 50, 'iteration'
plot_interval = 100, 'iteration'
print_interval = 20, 'iteration'
trainer.extend(chainer.training.extensions.observe_lr(),
trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport(
['iteration', 'epoch', 'elapsed_time', 'lr',
'main/loss',
'main/roi_loc_loss',
'main/roi_cls_loss',
'main/rpn_loc_loss',
'main/rpn_cls_loss',
'validation/main/map',
]), trigger=print_interval)
trainer.extend(extensions.ProgressBar(update_interval=5))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(
['main/loss'],
file_name='loss.png', trigger=plot_interval
),
trigger=plot_interval
)
trainer.extend(
DetectionVOCEvaluator(
test_iter, model.faster_rcnn, use_07_metric=True,
label_names=bbox_label_names),
trigger=ManualScheduleTrigger(
[100, 500, 1000, 5000, 10000, 20000, 40000, 60000, n_step, n_itrs], 'iteration'))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.run()
root = '../data/3Types/Data3TypesYminXminYmaxXmax'
#print(os.listdir(root))
dataset_test = MultiDefectDetectionDataset(data_dir=root, split='validation2')
bbox_label_names = ('111', 'dot','100')
# DataSet Statistics
print('total number of training images: ', len(dataset))
print('total number of test images: ', len(dataset_test))
print('type of defects: ', bbox_label_names)
# predict figures using new methods
use_gpu = False#True
proposal_params = {'min_size': 8,'nms_thresh': 0.5}
model = FasterRCNNVGG16(n_fg_class=3, pretrained_model='../BestWeight.npz', ratios=[ 0.5, 1, 1.5, 2, 2.5, 4,8,16],anchor_scales=[1, 4, 8, 16], min_size=1024, max_size=1024,proposal_creator_params=proposal_params)
if use_gpu:
chainer.cuda.get_device_from_id(0).use()
model.to_gpu()
bbox_label_names = ('111loop', 'dot', '100loop')
thetaList = [0.001,0.005,0.01,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6]
IoUList = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
for iou_i in IoUList:
os.mkdir(str(iou_i))
Plist = []
Rlist = []
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()
def main():
parser = argparse.ArgumentParser(
description='ChainerCV training example: Faster R-CNN')
parser.add_argument(
'--dataset_path',
'-path',
type=str,
default="/home/takagi.kazunari/projects/datasets/SUNRGBD_2DBB_fixed")
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--lr', '-l', type=float, default=1e-3)
parser.add_argument('--out',
'-o',
default='sunrgbd_result',
help='Output directory')
parser.add_argument('--seed', '-s', type=int, default=0)
parser.add_argument('--step_size', '-ss', type=int, default=50000)
parser.add_argument('--iteration', '-i', type=int, default=70000)
args = parser.parse_args()
np.random.seed(args.seed)
train_data = SUNRGBDDataset(args.dataset_path, mode="train")
test_data = SUNRGBDDataset(args.dataset_path, mode="test")
sunrgbd_bbox_label_names = train_data.get_dataset_label()
faster_rcnn = FasterRCNNVGG16(n_fg_class=len(sunrgbd_bbox_label_names),
pretrained_model='imagenet')
faster_rcnn.use_preset('evaluate')
model = FasterRCNNTrainChain(faster_rcnn)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005))
train_data = TransformDataset(train_data, Transform(faster_rcnn))
train_iter = chainer.iterators.MultiprocessIterator(train_data,
batch_size=1,
n_processes=None,
shared_mem=100000000)
test_iter = chainer.iterators.SerialIterator(test_data,
batch_size=1,
repeat=False,
shuffle=False)
updater = chainer.training.updaters.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
now_time = str(datetime.datetime.today()).replace(" ", "_")
save_dir = osp.join(args.out, now_time)
trainer = training.Trainer(updater, (args.iteration, 'iteration'),
out=save_dir)
#save_iteration = [i for i in range(100, args.iteration, args.step_size)]
weight_save_interval = 5000, 'iteration'
evaluation_interval = 10000, 'iteration'
trainer.extend(extensions.snapshot_object(
model.faster_rcnn, 'sunrgbd_model_{.updater.iteration}.npz'),
trigger=weight_save_interval)
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(args.step_size, 'iteration'))
log_interval = 20, 'iteration'
plot_interval = 10, 'iteration'
print_interval = 20, 'iteration'
trainer.extend(chainer.training.extensions.observe_lr(),
trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'iteration',
'epoch',
'elapsed_time',
'lr',
'main/loss',
'main/roi_loc_loss',
'main/roi_cls_loss',
'main/rpn_loc_loss',
'main/rpn_cls_loss',
'validation/main/map',
]),
trigger=print_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(['main/loss'],
file_name='loss.png',
trigger=plot_interval),
trigger=plot_interval)
#do_evaluation_iteration = [i for i in range(0, args.iteration, 500)]
trainer.extend(DetectionVOCEvaluator(test_iter,
model.faster_rcnn,
use_07_metric=True,
label_names=sunrgbd_bbox_label_names),
trigger=evaluation_interval)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.run()
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))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batchsize', type=int, default=1)
parser.add_argument('--lr', type=float, default=1e-3)
parser.add_argument('--out', default='result')
parser.add_argument('--resume')
args = parser.parse_args()
comm = chainermn.create_communicator()
device = comm.intra_rank
faster_rcnn = FasterRCNNVGG16(
n_fg_class=len(epic_kitchens_bbox_label_names),
pretrained_model='imagenet')
faster_rcnn.use_preset('evaluate')
model = FasterRCNNTrainChain(faster_rcnn)
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
train = EpicKitchensBboxDataset(year='2018', split='train')
if comm.rank == 0:
indices = np.arange(len(train))
else:
indices = None
train = TransformDataset(train, ('img', 'bbox', 'label', 'scale'),
Transform(faster_rcnn))
indices = chainermn.scatter_dataset(indices, comm, shuffle=True)
train = train.slice[indices]
train_iter = chainer.iterators.SerialIterator(train,
batch_size=args.batchsize)
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.MomentumSGD(), comm)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005))
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=device)
trainer = training.Trainer(updater, (18, 'epoch'), args.out)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=args.lr),
trigger=triggers.ManualScheduleTrigger([12, 15], 'epoch'))
if comm.rank == 0:
log_interval = 10, 'iteration'
trainer.extend(
extensions.LogReport(log_name='log.json', trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss',
'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss',
'main/rpn_cls_loss'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=1))
trainer.extend(extensions.snapshot_object(
model.faster_rcnn, 'model_iter_{.updater.iteration}.npz'),
trigger=(1, 'epoch'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--no-display', action='store_true')
parser.add_argument('--model',
choices=('ssd300', 'ssd512', 'faster-rcnn-vgg16'),
default='faster-rcnn-vgg16')
parser.add_argument('--gpu', type=int, default=0)
parser.add_argument('--pretrained_model',
choices=('voc0712', 'voc07'),
default='voc0712')
parser.add_argument('--year',
'-y',
choices=('2015', '2016', '2017'),
default='2015')
parser.add_argument('--sequence-map', '-s', default=None)
args = parser.parse_args()
if args.sequence_map is None:
if args.year == '2015':
seqmap_name = 'c2-test'
elif args.year == '2016':
seqmap_name = 'c5-test'
elif args.year == '2017':
seqmap_name = 'c9-test'
map_name, split = seqmap_name.split('-')
if split == 'test':
split = 'val'
sequences = get_sequences(split, map_name)
if args.model == 'ssd300':
detector = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'ssd512':
detector = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'faster-rcnn-vgg16':
detector = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
detector.use_preset('evaluate')
detector.score_thresh = 0.5
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
detector.to_gpu()
sort_label_names = ['person']
if not args.no_display:
plt.ion()
fig = plt.figure()
for seq in sequences:
if args.no_display:
ax = fig.add_subplot(111, aspect='equal')
dataset = MOTDataset(year=args.year, split=split, sequence=seq)
model = SORTMultiObjectTracking(detector, voc_bbox_label_names,
sort_label_names)
print('Sequence: {}'.format(seq))
cycle_times = []
for i in range(len(dataset)):
img, _, _ = dataset[i]
start_time = time.time()
bboxes, labels, scores, inst_ids = model.predict([img])
cycle_time = time.time() - start_time
cycle_times.append(cycle_time)
if args.no_display:
bbox = bboxes[0]
inst_id = inst_ids[0]
label = labels[0]
score = scores[0]
vis_tracking_bbox(img,
bbox,
inst_id,
label,
score,
label_names=voc_bbox_label_names,
ax=ax)
fig.canvas.flush_events()
plt.draw()
ax.cla()
cycle_times = np.array(cycle_times)
print('total time: {}'.format(np.sum(cycle_times)))
print('average time: {}'.format(np.average(cycle_times)))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--pretrained-model', default='imagenet')
parser.add_argument('--batch-size', type=int, default=1)
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--no-display', action='store_true')
parser.add_argument('--shuffle', action='store_true')
parser.add_argument('--save-path', type=str, default=None)
parser.add_argument('--split', choices=('train', 'val'), default='val')
parser.add_argument('--skip', action='store_true')
parser.add_argument('--score-thresh', type=float, default=0.6)
args = parser.parse_args()
model = FasterRCNNVGG16(n_fg_class=len(epic_kitchens_bbox_label_names),
pretrained_model=args.pretrained_model)
model.score_thresh = args.score_thresh
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = EpicKitchensBboxDataset(split=args.split)
dataset_iter = chainer.iterators.SerialIterator(dataset,
args.batch_size,
shuffle=args.shuffle,
repeat=False)
dataset_iter.reset()
if dataset_iter._order is None:
indices = dataset.ids
else:
indices = dataset_iter._order
for batch_data in dataset_iter:
imgs = []
for data in batch_data:
img, _, _ = data
imgs.append(img)
bboxes, labels, scores = model.predict(imgs)
base_index = dataset_iter.current_position - args.batch_size
for b_i in range(args.batch_size):
img = imgs[b_i]
bbox, label, score = bboxes[b_i], labels[b_i], scores[b_i]
if args.skip:
if len(bbox) == 0:
print('skip {}.jpg'.format(indices[base_index + b_i]))
continue
vis_bbox(img,
bbox,
label,
score,
label_names=epic_kitchens_bbox_label_names)
if args.save_path is not None:
save_path = os.path.join(thisdir, args.save_path)
if not os.path.exists(save_path):
os.makedirs(save_path)
plt.savefig(
os.path.join(
save_path,
'{}.png'.format(dataset.ids[base_index + b_i].replace(
'/', '_'))))
if not args.no_display:
plt.show()
from chainercv.extensions import DetectionVOCEvaluator
from chainercv.links import FasterRCNNVGG16
from chainercv.links.model.faster_rcnn import FasterRCNNTrainChain
from chainercv import transforms
from wider_face_dataset import WIDERFACEDataset
# dataset paths
WIDER_TRAIN_DIR = 'WIDER_train'
WIDER_TRAIN_ANNOTATION_MAT = 'wider_face_split/wider_face_train.mat'
WIDER_VAL_DIR = 'WIDER_val'
WIDER_VAL_ANNOTATION_MAT = 'wider_face_split/wider_face_val.mat'
BLACKLIST_FILE = 'blacklist.txt'
faster_rcnn = FasterRCNNVGG16(n_fg_class=1,
pretrained_model='imagenet')
#min_size=600, max_size=1000,)
def transform(in_data):
img, bbox, label = in_data
_, H, W = img.shape
img = faster_rcnn.prepare(img)
_, o_H, o_W = img.shape
scale = o_H / H
bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W))
# horizontally flip
img, params = transforms.random_flip(
img, x_random=True, return_param=True)
bbox = transforms.flip_bbox(
bbox, (o_H, o_W), x_flip=params['x_flip'])
def main():
parser = argparse.ArgumentParser(
description='ChainerCV training example: Faster R-CNN')
parser.add_argument('--dataset',
choices=('voc07', 'voc0712'),
help='The dataset to use: VOC07, VOC07+12',
default='voc07')
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--lr', '-l', type=float, default=1e-3)
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--seed', '-s', type=int, default=0)
parser.add_argument('--step_size', '-ss', type=int, default=50000)
parser.add_argument('--iteration', '-i', type=int, default=70000)
args = parser.parse_args()
np.random.seed(args.seed)
if args.dataset == 'voc07':
train_data = VOCBboxDataset(split='trainval', year='2007')
elif args.dataset == 'voc0712':
train_data = ConcatenatedDataset(
VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval'))
test_data = VOCBboxDataset(split='test',
year='2007',
use_difficult=True,
return_difficult=True)
faster_rcnn = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
faster_rcnn.use_preset('evaluate')
model = FasterRCNNTrainChain(faster_rcnn)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005))
train_data = TransformDataset(train_data, Transform(faster_rcnn))
train_iter = chainer.iterators.MultiprocessIterator(train_data,
batch_size=1,
n_processes=None,
shared_mem=100000000)
test_iter = chainer.iterators.SerialIterator(test_data,
batch_size=1,
repeat=False,
shuffle=False)
updater = chainer.training.updaters.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = training.Trainer(updater, (args.iteration, 'iteration'),
out=args.out)
trainer.extend(extensions.snapshot_object(model.faster_rcnn,
'snapshot_model.npz'),
trigger=(args.iteration, 'iteration'))
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(args.step_size, 'iteration'))
log_interval = 20, 'iteration'
plot_interval = 3000, 'iteration'
print_interval = 20, 'iteration'
trainer.extend(chainer.training.extensions.observe_lr(),
trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'iteration',
'epoch',
'elapsed_time',
'lr',
'main/loss',
'main/roi_loc_loss',
'main/roi_cls_loss',
'main/rpn_loc_loss',
'main/rpn_cls_loss',
'validation/main/map',
]),
trigger=print_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(['main/loss'],
file_name='loss.png',
trigger=plot_interval),
trigger=plot_interval)
trainer.extend(DetectionVOCEvaluator(test_iter,
model.faster_rcnn,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=ManualScheduleTrigger(
[args.step_size, args.iteration], 'iteration'))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.run()
def calc_features(img_dirs, feature_names):
"""
calculates all features given by feature_names
:param img_dirs: a list of image paths
:type img_dirs: list
:param feature_names: a list containing all feature names
:type feature_names: list
:return: dict (img_dir, features) features is also a dict (feature_name, feature vector)
:rtype: dict
"""
features = {}
dir_haarfeatures = os.path.join(os.getcwd(), 'res', 'haarcascades')
face_frontal_cascade = cv2.CascadeClassifier(os.path.join(dir_haarfeatures, 'haarcascade_frontalface_default.xml'))
face_profile_cascade = cv2.CascadeClassifier(os.path.join(dir_haarfeatures, 'haarcascade_profileface.xml'))
model = FasterRCNNVGG16(pretrained_model='voc07')
for img_dir in img_dirs:
print 'calc features for: ' + img_dir
img = read_img(img_dir)
features[img_dir] = dict() #init features dict for each image
for name in feature_names:
if TU_feature_file_exists(img_dir, name):
continue
if name == Features.Face_count or name == Features.Rot_distance or name == Features.Face_bb:
face_count, rot_distance, face_bb = face_detection(img, face_frontal_cascade, face_profile_cascade)
feature_files.save_features(img_dir, Features.Face_count, face_count)
feature_files.save_features(img_dir, Features.Rot_distance, rot_distance)
feature_files.save_features(img_dir, Features.Face_bb, face_bb)
features[img_dir][Features.Face_count] = face_count
features[img_dir][Features.Rot_distance] = rot_distance
features[img_dir][Features.Face_bb] = face_bb
elif name == Features.Face_bb_full_img:
feature = _face_bb_full_img_calculator(img, face_frontal_cascade, face_profile_cascade)
feature_files.save_features(img_dir, Features.Face_bb_full_img, feature)
features[img_dir][Features.Face_bb_full_img] = feature
elif name == Features.Face_bb_quarter_imgs:
feature = _face_bb_quarter_imgs_calculator(img, face_frontal_cascade, face_profile_cascade)
feature_files.save_features(img_dir, Features.Face_bb_quarter_imgs, feature)
features[img_dir][Features.Face_bb_quarter_imgs] = feature
elif name == Features.Face_bb_eighth_imgs:
feature = _face_bb_eighth_imgs_calculator(img, face_frontal_cascade, face_profile_cascade)
feature_files.save_features(img_dir, Features.Face_bb_eighth_imgs, feature)
features[img_dir][Features.Face_bb_eighth_imgs] = feature
elif name == Features.Tilted_edges:
feature = _img_tilted_calculator(img)
feature_files.save_features(img_dir, Features.Tilted_edges, feature)
features[img_dir][Features.Tilted_edges] = feature
elif name == Features.Edge_hist_v0:
feature = _edge_hist_dir_calculator(img, False, False)
feature_files.save_features(img_dir, Features.Edge_hist_v0, feature)
features[img_dir][Features.Edge_hist_v0] = feature
elif name == Features.Edge_hist_v1:
feature = _edge_hist_dir_calculator(img, True, True)
feature_files.save_features(img_dir, Features.Edge_hist_v1, feature)
features[img_dir][Features.Edge_hist_v1] = feature
elif name == Features.Edge_hist_v2:
feature = _edge_hist_dir_calculator(img, True, False)
feature_files.save_features(img_dir, Features.Edge_hist_v2, feature)
features[img_dir][Features.Edge_hist_v2] = feature
elif name == Features.Symmetry:
feature = _symmetry_calculator(img, model)
feature_files.save_features(img_dir, Features.Symmetry, feature)
features[img_dir][Features.Symmetry] = feature
# precalculated features
elif name == Features.Hsv_hist:
feature = load_precalc_feature(img_dir, Features.Hsv_hist)
feature_files.save_features(img_dir, Features.Hsv_hist, feature)
features[img_dir][Features.Hsv_hist] = feature
elif name == Features.DenseSIFT_L0:
feature = load_precalc_feature(img_dir, Features.DenseSIFT_L0)
feature_files.save_features(img_dir, Features.DenseSIFT_L0, feature)
features[img_dir][Features.DenseSIFT_L0] = feature
elif name == Features.DenseSIFT_L1:
feature = load_precalc_feature(img_dir, Features.DenseSIFT_L1)
feature_files.save_features(img_dir, Features.DenseSIFT_L1, feature)
features[img_dir][Features.DenseSIFT_L1] = feature
elif name == Features.DenseSIFT_L2:
feature = load_precalc_feature(img_dir, Features.DenseSIFT_L2)
feature_files.save_features(img_dir, Features.DenseSIFT_L2, feature)
features[img_dir][Features.DenseSIFT_L2] = feature
elif name == Features.Hog_L0:
feature = load_precalc_feature(img_dir, Features.Hog_L0)
feature_files.save_features(img_dir, Features.Hog_L0, feature)
features[img_dir][Features.Hog_L0] = feature
elif name == Features.Hog_L1:
feature = load_precalc_feature(img_dir, Features.Hog_L1)
feature_files.save_features(img_dir, Features.Hog_L1, feature)
features[img_dir][Features.Hog_L1] = feature
elif name == Features.Hog_L2:
feature = load_precalc_feature(img_dir, Features.Hog_L2)
feature_files.save_features(img_dir, Features.Hog_L2, feature)
features[img_dir][Features.Hog_L2] = feature
elif name == Features.Lbp_L0:
feature = load_precalc_feature(img_dir, Features.Lbp_L0)
feature_files.save_features(img_dir, Features.Lbp_L0, feature)
features[img_dir][Features.Lbp_L0] = feature
elif name == Features.Lbp_L1:
feature = load_precalc_feature(img_dir, Features.Lbp_L1)
feature_files.save_features(img_dir, Features.Lbp_L1, feature)
features[img_dir][Features.Lbp_L1] = feature
elif name == Features.Lbp_L2:
feature = load_precalc_feature(img_dir, Features.Lbp_L2)
feature_files.save_features(img_dir, Features.Lbp_L2, feature)
features[img_dir][Features.Lbp_L2] = feature
elif name == Features.Gist:
feature = load_precalc_feature(img_dir, Features.Gist)
feature_files.save_features(img_dir, Features.Gist, feature)
features[img_dir][Features.Gist] = feature
elif name == Features.CNN_fc7:
feature = load_precalc_feature(img_dir, Features.CNN_fc7)
feature_files.save_features(img_dir, Features.CNN_fc7, feature)
features[img_dir][Features.CNN_fc7] = feature
elif name == Features.CNN_prob:
feature = load_precalc_feature(img_dir, Features.CNN_prob)
feature_files.save_features(img_dir, Features.CNN_prob, feature)
features[img_dir][Features.CNN_prob] = feature
else:
raise NotImplementedError
return features
import download_model
WIDER_VAL_DIR = '/Volumes/D../image pocess/WIDER_test'
WIDER_VAL_ANNOTATION_MAT = '/Users/YEH/Downloads/chainercv-fasterrcnn-widerface-master/wider_face_split/wider_face_val.mat'
# trained model
MODELFILE = 'result/snapshot_model.npz'
mat = scipy.io.loadmat(WIDER_VAL_ANNOTATION_MAT)
#dict_keys(['pose_label_list', 'event_list', 'file_list', '__header__', '__version__', 'invalid_label_list', 'illumination_label_list', '__globals__', 'occlusion_label_list', 'face_bbx_list', 'blur_label_list', 'expression_label_list'])
if not os.path.exists(MODELFILE):
download_model.download_model('http://nixeneko.2-d.jp/hatenablog/20170724_facedetection_model/snapshot_model.npz', MODELFILE)
model = FasterRCNNVGG16(
n_fg_class=1,
pretrained_model=MODELFILE)
parser = argparse.ArgumentParser(
description='view detection test on validation dataset')
parser.add_argument('--gpu', '-g', type=int, default=-1)
args = parser.parse_args()
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu(args.gpu)
for i in range(len(mat['event_list'])):
event = mat['event_list'][i,0][0]
for j in range(len(mat['file_list'][i,0])):
file = mat['file_list'][i,0][j,0][0]