def get_resnet_50(n_class):
src = ResNet50(
n_class=1000, pretrained_model='imagenet', arch='he')
dst = ResNet50(n_class=n_class, arch='he')
# initialized weights
dst(np.zeros((1, 3, 224, 224), dtype=np.float32))
ignore_names = get_shape_mismatch_names(src, dst)
src_params = {p[0]: p[1] for p in src.namedparams()}
for dst_named_param in dst.namedparams():
name = dst_named_param[0]
if name not in ignore_names:
dst_named_param[1].array[:] = src_params[name].array[:]
return dst
def main():
parser = argparse.ArgumentParser()
parser.add_argument('model_name',
choices=('resnet50', 'resnet101', 'resnet152'))
parser.add_argument('caffemodel')
parser.add_argument('output', nargs='?', default=None)
args = parser.parse_args()
caffemodel = CaffeFunction(args.caffemodel)
if args.model_name == 'resnet50':
model = ResNet50(pretrained_model=None, n_class=1000, mode='he')
model(np.zeros((1, 3, 224, 224), dtype=np.float32))
_transfer_resnet50(caffemodel, model)
elif args.model_name == 'resnet101':
model = ResNet101(pretrained_model=None, n_class=1000, mode='he')
model(np.zeros((1, 3, 224, 224), dtype=np.float32))
_transfer_resnet101(caffemodel, model)
elif args.model_name == 'resnet152':
model = ResNet152(pretrained_model=None, n_class=1000, mode='he')
model(np.zeros((1, 3, 224, 224), dtype=np.float32))
_transfer_resnet152(caffemodel, model)
if args.output is None:
output = '{}_imagenet_convert.npz'.format(args.model_name)
else:
output = args.output
chainer.serializers.save_npz(output, model)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
parser.add_argument('image')
args = parser.parse_args()
model = ResNet50(
pretrained_model=args.pretrained_model,
n_class=len(voc_bbox_label_names))
model.pick = 'fc6'
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
img = utils.read_image(args.image, color=True)
predict_func = PredictFunc(model, thresh=0.5)
labels, scores = predict_func([img])
label = labels[0]
score = scores[0]
print('predicted labels')
for lb, sc in zip(label, score):
print('names={} score={:.4f}'.format(
voc_bbox_label_names[lb], sc))
vis_image(img)
plt.show()
def main():
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('val', help='Path to root of the validation dataset')
parser.add_argument(
'--model', choices=('vgg16', 'resnet50', 'resnet101', 'resnet152'))
parser.add_argument('--pretrained_model', default='imagenet')
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--crop', choices=('center', '10'), default='center')
parser.add_argument('--resnet_mode', default='he')
args = parser.parse_args()
dataset = DirectoryParsingLabelDataset(args.val)
label_names = directory_parsing_label_names(args.val)
n_class = len(label_names)
iterator = iterators.MultiprocessIterator(
dataset, args.batchsize, repeat=False, shuffle=False,
n_processes=6, shared_mem=300000000)
if args.model == 'vgg16':
extractor = VGG16(n_class, args.pretrained_model)
elif args.model == 'resnet50':
extractor = ResNet50(
n_class, args.pretrained_model, mode=args.resnet_mode)
elif args.model == 'resnet101':
extractor = ResNet101(
n_class, args.pretrained_model, mode=args.resnet_mode)
elif args.model == 'resnet152':
extractor = ResNet152(
n_class, args.pretrained_model, mode=args.resnet_mode)
model = FeaturePredictor(
extractor, crop_size=224, scale_size=256, crop=args.crop)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
print('Model has been prepared. Evaluation starts.')
in_values, out_values, rest_values = apply_to_iterator(
model.predict, iterator, hook=ProgressHook(len(dataset)))
del in_values
pred_probs, = out_values
gt_labels, = rest_values
accuracy = F.accuracy(
np.array(list(pred_probs)), np.array(list(gt_labels))).data
print()
print('Top 1 Error {}'.format(1. - accuracy))
def test_resnet():
resnet = ResNet50()
print(resnet.layer_names)
def forward(self, x):
h = self.conv(x)
if self.activ is None:
return h
else:
return self.activ(h)
Conv2DBNActiv.forward = forward
print(resnet['conv1'])
print(resnet['res2'])
print(resnet(np.zeros((10, 3, 244, 244), dtype=np.float32)))
def get_dilated_resnet50():
imagenet_resnet = ResNet50(pretrained_model='imagenet', arch='he')
imagenet_resnet.res4.a.conv1.conv.stride = (1, 1)
imagenet_resnet.res4.a.residual_conv.conv.stride = (1, 1)
imagenet_resnet.res5.a.conv1.conv.stride = (1, 1)
imagenet_resnet.res5.a.residual_conv.conv.stride = (1, 1)
def get_dilated_cbr(prev):
new = Conv2DBNActiv(prev.conv.W.shape[1],
prev.conv.W.shape[0],
3,
1,
2,
2,
nobias=True)
new.conv.W.data[:] = prev.conv.W.data[:]
return new
imagenet_resnet.res4.a.conv2 = get_dilated_cbr(
imagenet_resnet.res4.a.conv2)
imagenet_resnet.res4.b1.conv2 = get_dilated_cbr(
imagenet_resnet.res4.b1.conv2)
imagenet_resnet.res4.b2.conv2 = get_dilated_cbr(
imagenet_resnet.res4.b2.conv2)
imagenet_resnet.res4.b3.conv2 = get_dilated_cbr(
imagenet_resnet.res4.b3.conv2)
imagenet_resnet.res4.b4.conv2 = get_dilated_cbr(
imagenet_resnet.res4.b4.conv2)
imagenet_resnet.res4.b5.conv2 = get_dilated_cbr(
imagenet_resnet.res4.b5.conv2)
imagenet_resnet.res5.a.conv2 = get_dilated_cbr(
imagenet_resnet.res5.a.conv2)
imagenet_resnet.res5.b1.conv2 = get_dilated_cbr(
imagenet_resnet.res5.b1.conv2)
imagenet_resnet.res5.b2.conv2 = get_dilated_cbr(
imagenet_resnet.res5.b2.conv2)
imagenet_resnet.pick = ['res4', 'res5']
imagenet_resnet.remove_unused()
return imagenet_resnet
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model')
args = parser.parse_args()
model = ResNet50(pretrained_model=args.pretrained_model,
n_class=len(voc_bbox_label_names),
arch='he')
model.pick = 'fc6'
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
dataset = VOCBboxDataset(split='test', year='2007', use_difficult=False)
dataset = TransformDataset(dataset, ('img', 'bbox'), bbox_to_multi_label)
iterator = iterators.SerialIterator(dataset,
8,
repeat=False,
shuffle=False)
in_values, out_values, rest_values = apply_to_iterator(
PredictFunc(model, thresh=0),
iterator,
hook=ProgressHook(len(dataset)))
# delete unused iterators explicitly
del in_values
pred_labels, pred_scores = out_values
gt_labels, = rest_values
result = eval_multi_label_classification(pred_labels, pred_scores,
gt_labels)
print()
print('mAP: {:f}'.format(result['map']))
for l, name in enumerate(voc_bbox_label_names):
if result['ap'][l]:
print('{:s}: {:f}'.format(name, result['ap'][l]))
else:
print('{:s}: -'.format(name))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model', choices=('resnet50', 'resnet101'))
parser.add_argument('--batchsize', type=int, default=16)
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 == 'resnet50':
model = FasterRCNNFPNResNet50(
n_fg_class=len(coco_bbox_label_names), mean='chainercv')
copyparams(model.extractor.base,
ResNet50(pretrained_model='imagenet', arch='he'))
elif args.model == 'resnet101':
model = FasterRCNNFPNResNet101(
n_fg_class=len(coco_bbox_label_names), mean='chainercv')
copyparams(model.extractor.base,
ResNet101(pretrained_model='imagenet', arch='he'))
model.use_preset('evaluate')
train_chain = TrainChain(model)
chainer.cuda.get_device_from_id(device).use()
train_chain.to_gpu()
train = TransformDataset(
ConcatenatedDataset(
COCOBboxDataset(split='train'),
COCOBboxDataset(split='valminusminival'),
), ('img', 'bbox', 'label'), transform)
if comm.rank == 0:
indices = np.arange(len(train))
else:
indices = None
indices = chainermn.scatter_dataset(indices, comm, shuffle=True)
train = train.slice[indices]
train_iter = chainer.iterators.MultithreadIterator(
train, args.batchsize // comm.size)
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.MomentumSGD(), comm)
optimizer.setup(train_chain)
optimizer.add_hook(WeightDecay(0.0001))
model.extractor.base.conv1.disable_update()
model.extractor.base.res2.disable_update()
for link in model.links():
if isinstance(link, L.BatchNormalization):
link.disable_update()
updater = training.updaters.StandardUpdater(
train_iter, optimizer, converter=converter, device=device)
trainer = training.Trainer(
updater, (90000 * 16 / args.batchsize, 'iteration'), args.out)
def lr_schedule(updater):
base_lr = 0.02 * args.batchsize / 16
warm_up_duration = 500
warm_up_rate = 1 / 3
iteration = updater.iteration
if iteration < warm_up_duration:
rate = warm_up_rate \
+ (1 - warm_up_rate) * iteration / warm_up_duration
elif iteration < 60000 * 16 / args.batchsize:
rate = 1
elif iteration < 80000 * 16 / args.batchsize:
rate = 0.1
else:
rate = 0.01
return base_lr * rate
trainer.extend(ManualScheduler('lr', lr_schedule))
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/rpn/loc', 'main/loss/rpn/conf',
'main/loss/head/loc', 'main/loss/head/conf']),
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=(90000 * 16 / args.batchsize, 'iteration'))
if args.resume:
serializers.load_npz(args.resume, trainer, strict=False)
trainer.run()
