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():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
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 == 'ssd300':
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'ssd512':
model = SSD512(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 setUp(self):
if self.insize == 300:
self.link = SSD300(n_fg_class=self.n_fg_class)
self.n_bbox = 8732
elif self.insize == 512:
self.link = SSD512(n_fg_class=self.n_fg_class)
self.n_bbox = 24564
def main():
args = argparser()
if not os.path.isdir(args.output_dir):
os.makedirs(args.output_dir)
else:
print('output dir is exist.')
exit()
print('loading labels...')
bbox_label_names = load_bbox_label_names()
print(bbox_label_names)
print('----')
print('loading model...')
chainer.config.train = False
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'ssd512':
model = SSD512(n_fg_class=len(bbox_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
print('loading images...')
jpg_list = glob.glob(os.path.join(args.image_dir, '*.jpg'))
for i, jpg_name in enumerate(jpg_list):
print('{}/{} {}'.format(i + 1, len(jpg_list), jpg_name))
# object detection
img = utils.read_image(jpg_name, color=True)
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
str_label = [bbox_label_names[n] for n in label]
# create_output_dir and name
filename = os.path.split(jpg_name)[1]
output_dir = os.path.split(jpg_name)[0].replace(
args.image_dir, args.output_dir)
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
output_name = os.path.join(output_dir,
(os.path.splitext(filename)[0] + '.xml'))
# output xml
if args.no_copy:
full_name = os.path.abspath(jpg_name)
else:
output_jpg_name = os.path.join(output_dir, filename)
full_name = os.path.abspath(output_jpg_name)
shutil.copyfile(jpg_name, output_jpg_name)
img_size = IMAGE_SIZE(img.shape[1], img.shape[2], img.shape[0])
create_pascalVOC(full_name, img_size, str_label, bbox, output_name)
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 __init__(self, model="ssd300", gpu=-1, pretrained_model="voc0712"):
if model == "ssd300":
self.model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model=pretrained_model)
elif model == "ssd512":
self.model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model=pretrained_model)
if gpu >= 0:
chainer.cuda.get_device_from_id(gpu).use()
self.model.to_gpu()
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 runRCNN():
startTime = time.time()
#print(startTime)
# Read an RGB image and return it in CHW format.
img = read_image('sample7.jpg')
model = SSD300(pretrained_model='voc0712')
model1 = SSD512(pretrained_model='voc0712')
bboxes, labels, scores = model1.predict([img])
vis_bbox(img,
bboxes[0],
labels[0],
scores[0],
label_names=voc_bbox_label_names)
print(time.time() - startTime)
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_model(param, model_type="ssd512", gpu=-1):
if model_type == 'ssd300':
model = SSD300(n_fg_class=len(MOT16Dataset.class_map),
pretrained_model='imagenet')
elif model_type == 'ssd512':
model = SSD512(n_fg_class=len(MOT16Dataset.class_map),
pretrained_model='imagenet')
model.use_preset('evaluate')
if gpu >= 0:
chainer.cuda.get_device_from_id(gpu).use()
model.to_gpu()
serializers.load_hdf5(param, model)
return model
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained',
default='./models/model_iter_12000.npz')
args = parser.parse_args()
label_names = pose_bbox_label_names
BboxDataset = PoseBboxDataset
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(label_names),
pretrained_model=args.pretrained)
elif args.model == 'ssd512':
model = SSD512(n_fg_class=len(label_names),
pretrained_model=args.pretrained)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
for i in range(0, 10):
dataset = BboxDataset(split='test')
ori_img, ori_bbox, ori_label = dataset[i]
pred_bbox, pred_labels, pred_scores = model.predict([ori_img])
fig = plt.figure(figsize=(20, 10), dpi=80)
fig.suptitle("Original vs Prediction Annotations", fontsize=32)
ax1 = fig.add_subplot(1, 2, 1)
ax1.set_xlabel("Original", fontsize=24)
ax2 = fig.add_subplot(1, 2, 2)
ax2.set_xlabel("Prediction", fontsize=24)
vis_bbox(ori_img, ori_bbox, ori_label, label_names=label_names, ax=ax1)
vis_bbox(ori_img,
pred_bbox[0],
pred_labels[0],
pred_scores[0],
label_names=label_names,
ax=ax2)
plt.tight_layout()
plt.savefig('visualization/compare-{}.png'.format(i))
def runSSD():
aimage = 'sample7.jpg'
amodel = 'ssd300'
apretrained_model = 'voc0712'
agpu = -1
if amodel == 'ssd300':
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model=apretrained_model)
elif amodel == 'ssd512':
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model=apretrained_model)
if agpu >= 0:
chainer.cuda.get_device_from_id(agpu).use()
model.to_gpu()
img = utils.read_image(aimage, 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)
def main():
rospack = rospkg.RosPack()
jsk_perception_datasets_path = osp.join(
rospack.get_path('jsk_perception'), 'learning_datasets')
parser = argparse.ArgumentParser()
# Dataset directory
parser.add_argument('--train-dataset-dir', type=str,
default=osp.join(jsk_perception_datasets_path,
'kitchen_dataset', 'train'))
parser.add_argument('--val-dataset-dir', type=str,
default=osp.join(jsk_perception_datasets_path,
'kitchen_dataset', 'test'))
parser.add_argument('--dataset-type', type=str,
default='instance')
parser.add_argument(
'--model-name', choices=('ssd300', 'ssd512'), default='ssd512')
parser.add_argument('--gpu', type=int, default=0)
parser.add_argument('--batch-size', type=int, default=8)
parser.add_argument('--max-epoch', type=int, default=100)
parser.add_argument('--out-dir', type=str, default=None)
args = parser.parse_args()
if (args.dataset_type == 'instance'):
train_dataset = DetectionDataset(args.train_dataset_dir)
elif (args.dataset_type == 'bbox'):
train_dataset = BboxDetectionDataset(args.train_dataset_dir)
else:
print('unsuppported dataset type')
return
fg_label_names = train_dataset.fg_class_names
if args.model_name == 'ssd300':
model = SSD300(
n_fg_class=len(fg_label_names),
pretrained_model='imagenet')
elif args.model_name == 'ssd512':
model = SSD512(
n_fg_class=len(fg_label_names),
pretrained_model='imagenet')
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
train = TransformDataset(
train_dataset,
Transform(model.coder, model.insize, model.mean))
train_iter = chainer.iterators.MultiprocessIterator(train, args.batch_size)
if (args.dataset_type == 'instance'):
test_dataset = DetectionDataset(args.val_dataset_dir)
elif (args.dataset_type == 'bbox'):
test_dataset = BboxDetectionDataset(args.val_dataset_dir)
test_iter = chainer.iterators.SerialIterator(
test_dataset, args.batch_size, repeat=False, shuffle=False)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.updaters.StandardUpdater(
train_iter, optimizer, device=args.gpu)
now = datetime.datetime.now()
timestamp = now.strftime('%Y%m%d-%H%M%S')
if args.out_dir is None:
out_dir = osp.join(
rospkg.get_ros_home(), 'learning_logs', timestamp)
else:
out_dir = args.out_dir
step_epoch = [args.max_epoch * 2 // 3, args.max_epoch * 5 // 6]
trainer = training.Trainer(
updater, (args.max_epoch, 'epoch'), out_dir)
trainer.extend(
extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger(step_epoch, 'epoch'))
trainer.extend(
DetectionVOCEvaluator(
test_iter, model, use_07_metric=True,
label_names=fg_label_names),
trigger=triggers.ManualScheduleTrigger(
step_epoch + [args.max_epoch], 'epoch'))
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(
['epoch', 'iteration', 'lr',
'main/loss', 'main/loss/loc', 'main/loss/conf',
'validation/main/map']),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(
extensions.snapshot_object(
model, 'model_snapshot.npz'),
trigger=(args.max_epoch, 'epoch'))
trainer.run()
def __init__(self, opts):
self.model = SSD512(n_fg_class=opts['n_classes'],
pretrained_model=opts['pretrained_model'])
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():
chainer.config.train = False
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(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
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(voc_detection_label_names):
if ap[l]:
print('{:s}: {:f}'.format(name, ap[l]))
else:
print('{:s}: -'.format(name))
from chainercv.datasets import voc_bbox_label_names
from chainercv.links import SSD300, SSD512
def arg():
parser = argparse.ArgumentParser()
parser.add_argument('--host', default="localhost", help='sergver address')
parser.add_argument('--port', '-p', default=50080, type=int, help='port')
parser.add_argument('--gpu', '-g', default=-1, type=int, help='gpu')
return parser.parse_args()
if __name__ == '__main__':
args = arg()
# Load detection model
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model='voc0712')
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu(args.gpu)
# Setup server
detection_server = MLServer(
Servicer(
DetectionPredictor(model, chainercv_preprocess,
chainercv_postprocess_change_labels)))
# Run the server
detection_server.start(8888)
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 handler(context):
dataset_alias = context.datasets
trainval_2007_dataset_id = dataset_alias['trainval2007']
trainval_2012_dataset_id = dataset_alias['trainval2012']
test_2007_dataset_id = dataset_alias['test2007']
trainval_2007_dataset = list(
load_dataset_from_api(trainval_2007_dataset_id))
trainval_2012_dataset = list(
load_dataset_from_api(trainval_2012_dataset_id))
test_2007_dataset = list(load_dataset_from_api(test_2007_dataset_id))
if network_model == 'ssd300':
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif network_model == 'ssd512':
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
if USE_GPU >= 0:
chainer.cuda.get_device_from_id(USE_GPU).use()
model.to_gpu()
trainval_2007 = DetectionDatasetFromAPI(trainval_2007_dataset)
trainval_2012 = DetectionDatasetFromAPI(trainval_2012_dataset)
test_2007 = DetectionDatasetFromAPI(test_2007_dataset,
use_difficult=True,
return_difficult=True)
train = TransformDataset(ConcatenatedDataset(trainval_2007, trainval_2012),
Transform(model.coder, model.insize, model.mean))
train_iter = chainer.iterators.SerialIterator(train, BATCHSIZE)
test_iter = chainer.iterators.SerialIterator(test_2007,
BATCHSIZE,
repeat=False,
shuffle=False)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=USE_GPU)
trainer = training.Trainer(updater, (nb_iterations, 'iteration'),
out=ABEJA_TRAINING_RESULT_DIR)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger([80000, 100000],
'iteration'))
trainer.extend(DetectionVOCEvaluator(test_iter,
model,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=(10000, 'iteration'))
log_interval = 100, 'iteration'
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
print_entries = [
'iteration', 'main/loss', 'main/loss/loc', 'main/loss/conf',
'validation/main/map'
]
report_entries = [
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc',
'main/loss/conf', 'validation/main/map'
]
trainer.extend(Statistics(report_entries,
nb_iterations,
obs_key='iteration'),
trigger=log_interval)
trainer.extend(Tensorboard(report_entries, out_dir=log_path))
trainer.extend(extensions.PrintReport(print_entries), trigger=log_interval)
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=(nb_iterations, 'iteration'))
trainer.run()
def ssd512():
return MultiboxTrainChain(SSD512(n_fg_class=20))
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('dataset', help="path to train json file")
parser.add_argument('test_dataset', help="path to test dataset json file")
parser.add_argument(
'--dataset-root',
help=
"path to dataset root if dataset file is not already in root folder of dataset"
)
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd512')
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--gpu', type=int, nargs='*', default=[])
parser.add_argument('--out', default='result')
parser.add_argument('--resume')
parser.add_argument('--lr',
type=float,
default=0.001,
help="default learning rate")
parser.add_argument('--port',
type=int,
default=1337,
help="port for bbox sending")
parser.add_argument('--ip',
default='127.0.0.1',
help="destination ip for bbox sending")
parser.add_argument(
'--test-image',
help="path to test image that shall be displayed in bbox vis")
args = parser.parse_args()
if args.dataset_root is None:
args.dataset_root = os.path.dirname(args.dataset)
if args.model == 'ssd300':
model = SSD300(n_fg_class=1, pretrained_model='imagenet')
image_size = (300, 300)
elif args.model == 'ssd512':
model = SSD512(n_fg_class=1, pretrained_model='imagenet')
image_size = (512, 512)
else:
raise NotImplementedError("The model you want to train does not exist")
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
train = TransformDataset(
SheepDataset(args.dataset_root, args.dataset, image_size=image_size),
Transform(model.coder, model.insize, model.mean))
if len(args.gpu) > 1:
gpu_datasets = split_dataset_n_random(train, len(args.gpu))
if not len(gpu_datasets[0]) == len(gpu_datasets[-1]):
adapted_second_split = split_dataset(gpu_datasets[-1],
len(gpu_datasets[0]))[0]
gpu_datasets[-1] = adapted_second_split
else:
gpu_datasets = [train]
train_iter = [
ThreadIterator(gpu_dataset, args.batchsize)
for gpu_dataset in gpu_datasets
]
test = SheepDataset(args.dataset_root,
args.test_dataset,
image_size=image_size)
test_iter = chainer.iterators.MultithreadIterator(test,
args.batchsize,
repeat=False,
shuffle=False,
n_threads=2)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainer.optimizers.Adam(alpha=args.lr)
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
if len(args.gpu) <= 1:
updater = training.updaters.StandardUpdater(
train_iter[0],
optimizer,
device=args.gpu[0] if len(args.gpu) > 0 else -1,
)
else:
updater = training.updaters.MultiprocessParallelUpdater(
train_iter, optimizer, devices=args.gpu)
updater.setup_workers()
if len(args.gpu) > 0 and args.gpu[0] >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu[0]).use()
model.to_gpu()
trainer = training.Trainer(updater, (200, 'epoch'), args.out)
trainer.extend(DetectionVOCEvaluator(test_iter,
model,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=(1000, 'iteration'))
# build logger
# make sure to log all data necessary for prediction
log_interval = 100, 'iteration'
data_to_log = {
'image_size': image_size,
'model_type': args.model,
}
# add all command line arguments
for argument in filter(lambda x: not x.startswith('_'), dir(args)):
data_to_log[argument] = getattr(args, argument)
# create callback that logs all auxiliary data the first time things get logged
def backup_train_config(stats_cpu):
if stats_cpu['iteration'] == log_interval:
stats_cpu.update(data_to_log)
trainer.extend(
extensions.LogReport(trigger=log_interval,
postprocess=backup_train_config))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc',
'main/loss/conf', 'validation/main/map'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=(5000, 'iteration'))
if args.test_image is not None:
plot_image = train._dataset.load_image(args.test_image,
resize_to=image_size)
else:
plot_image, _, _ = train.get_example(0)
plot_image += train._transform.mean
bbox_plotter = BBOXPlotter(
plot_image,
os.path.join(args.out, 'bboxes'),
send_bboxes=True,
upstream_port=args.port,
upstream_ip=args.ip,
)
trainer.extend(bbox_plotter, trigger=(10, 'iteration'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
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()
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(epic_kitchens_bbox_label_names),
pretrained_model=args.pretrained_model)
elif args.model == 'ssd512':
model = SSD512(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()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--iteration', type=int, default=120000)
parser.add_argument('--step', type=int, nargs='*', default=[80000, 100000])
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--out', default='result')
parser.add_argument('--resume')
args = parser.parse_args()
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'ssd512':
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
train = TransformDataset(
ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval')),
Transform(model.coder, model.insize, model.mean))
train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
test = VOCBboxDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = training.Trainer(updater, (args.iteration, 'iteration'),
args.out)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger(
args.step, 'iteration'))
trainer.extend(DetectionVOCEvaluator(test_iter,
model,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=triggers.ManualScheduleTrigger(
args.step + [args.iteration], 'iteration'))
log_interval = 10, 'iteration'
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc',
'main/loss/conf', 'validation/main/map'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.snapshot(),
trigger=triggers.ManualScheduleTrigger(
args.step + [args.iteration], 'iteration'))
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=(args.iteration, 'iteration'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
parser.add_argument('--batchsize', type=int, default=32)
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
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(epic_kitchens_bbox_category_names),
pretrained_model='imagenet')
elif args.model == 'ssd512':
model = SSD512(n_fg_class=len(epic_kitchens_bbox_category_names),
pretrained_model='imagenet')
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
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', 'mb_loc', 'mb_label'),
Transform(model.coder, model.insize, model.mean))
indices = chainermn.scatter_dataset(indices, comm, shuffle=True)
train = train.slice[indices]
# http://chainermn.readthedocs.io/en/latest/tutorial/tips_faqs.html#using-multiprocessiterator
if hasattr(multiprocessing, 'set_start_method'):
multiprocessing.set_start_method('forkserver')
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize,
n_processes=2)
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.MomentumSGD(), comm)
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(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([
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc',
'main/loss/conf'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=1))
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}.npz'),
trigger=(1, 'epoch'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
def test_pretrained_n_fg_class(self):
if self.insize == 300:
link = SSD300(n_fg_class=20, pretrained_model='voc0712')
elif self.insize == 512:
link = SSD512(n_fg_class=20, pretrained_model='voc0712')
self.assertIsInstance(link, SSD)
def test_pretrained_wrong_n_fg_class(self):
with self.assertRaises(ValueError):
if self.insize == 300:
SSD300(n_fg_class=10, pretrained_model='voc0712')
elif self.insize == 512:
SSD512(n_fg_class=10, pretrained_model='voc0712')
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--labelnum', type=int, default=50)
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--out', default='result')
parser.add_argument('--resume')
parser.add_argument('--image_label',
'-il',
help='Path to training image-label list file')
parser.add_argument('--bbox', help='Path to training bbox list file')
parser.add_argument('--image_label_test',
'-ilt',
help='Path to training image-label list file')
parser.add_argument('--bbox_test', help='Path to training bbox list file')
parser.add_argument('--image_root',
'-TR',
default='.',
help='Root directory path of image files')
args = parser.parse_args()
comm = chainermn.create_communicator('naive')
if comm.mpi_comm.rank == 0:
print('==========================================')
print('Num process (COMM_WORLD): {}'.format(MPI.COMM_WORLD.Get_size()))
if args.model == 'ssd300':
model = SSD300(n_fg_class=args.labelnum, pretrained_model='imagenet')
elif args.model == 'ssd512':
model = SSD512(n_fg_class=args.labelnum, pretrained_model='imagenet')
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
from test_datasets import DeepFashionBboxDataset
if comm.rank == 0:
train = DeepFashionBboxDataset(args.bbox, args.image_label,
args.image_root)
test = DeepFashionBboxDataset(args.bbox_test, args.image_label_test,
args.image_root)
train = TransformDataset(
train, Transform(model.coder, model.insize, model.mean))
else:
train, test = None, None
train = chainermn.scatter_dataset(train, comm, shuffle=True)
test = chainermn.scatter_dataset(test, comm, shuffle=True)
train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainer.optimizers.MomentumSGD()
optimizer = chainermn.create_multi_node_optimizer(optimizer, comm)
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (120000, 'iteration'), args.out)
checkpoint_interval = (1000, 'iteration')
checkpointer = chainermn.create_multi_node_checkpointer(
name='imagenet-example', comm=comm)
checkpointer.maybe_load(trainer, optimizer)
trainer.extend(checkpointer, trigger=checkpoint_interval)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger([80000, 100000],
'iteration'))
evaluator = DetectionVOCEvaluator(test_iter,
model,
use_07_metric=True,
label_names=voc_bbox_label_names)
evaluator = chainermn.create_multi_node_evaluator(evaluator, comm)
trainer.extend(evaluator, trigger=(10000, 'iteration'))
if comm.rank == 0:
log_interval = 10, 'iteration'
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc',
'main/loss/conf', 'validation/main/map'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.snapshot(), trigger=(10000, 'iteration'))
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=(120000, 'iteration'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512'),
default='ssd300')
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--test-batchsize', type=int, default=16)
parser.add_argument('--iteration', type=int, default=120000)
parser.add_argument('--step', type=int, nargs='*', default=[80000, 100000])
parser.add_argument('--out', default='result')
parser.add_argument('--resume')
args = parser.parse_args()
comm = chainermn.create_communicator()
device = comm.intra_rank
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'ssd512':
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
model.use_preset('evaluate')
train_chain = MultiboxTrainChain(model)
chainer.cuda.get_device_from_id(device).use()
model.to_gpu()
train = TransformDataset(
ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval')),
('img', 'mb_loc', 'mb_label'),
Transform(model.coder, model.insize, model.mean))
if comm.rank == 0:
indices = np.arange(len(train))
else:
indices = None
indices = chainermn.scatter_dataset(indices, comm, shuffle=True)
train = train.slice[indices]
# http://chainermn.readthedocs.io/en/latest/tutorial/tips_faqs.html#using-multiprocessiterator
if hasattr(multiprocessing, 'set_start_method'):
multiprocessing.set_start_method('forkserver')
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize //
comm.size,
n_processes=2)
if comm.rank == 0:
test = VOCBboxDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
test_iter = chainer.iterators.SerialIterator(test,
args.test_batchsize,
repeat=False,
shuffle=False)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.MomentumSGD(), comm)
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.updaters.StandardUpdater(train_iter,
optimizer,
device=device)
trainer = training.Trainer(updater, (args.iteration, 'iteration'),
args.out)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger(
args.step, 'iteration'))
if comm.rank == 0:
trainer.extend(DetectionVOCEvaluator(test_iter,
model,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=triggers.ManualScheduleTrigger(
args.step + [args.iteration], 'iteration'))
log_interval = 10, 'iteration'
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/loc',
'main/loss/conf', 'validation/main/map'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.snapshot(),
trigger=triggers.ManualScheduleTrigger(
args.step + [args.iteration], 'iteration'))
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=(args.iteration, 'iteration'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
#from my_bbox_label_name import voc_labels
imag = sys.argv[1]
print("imag = " + imag)
voc_labels = ('rbc', 'wbc', 'platelets')
def inference(image_filename):
img = utils.read_image(image_filename, color=True)
bboxes, labels, scores = model.predict([img])
bbox, label, score = bboxes[0], labels[0], scores[0]
#fig = plt.figure(figsize=(5.12,5.12), dpi=100)
#ax = plt.subplot(1,1,1)
ax = vis_bbox(img, bbox, label, label_names=voc_labels)
ax.set_axis_off()
ax.figure.tight_layout(
) #vis_bbox(img, bbox, label, label_names=voc_labels)
plt.show()
model = SSD512(n_fg_class=len(voc_labels))
serializers.load_npz(
'C:\Python_Programs\chainer_practice\BCCD_Dataset\my_ssd_model.npz', model)
inference(imag)
