def _check_pretrained_model(n_fg_class, pretrained_model, models):
if pretrained_model in models:
model = models[pretrained_model]
if n_fg_class:
if model['n_fg_class'] and not n_fg_class == model['n_fg_class']:
raise ValueError('n_fg_class should be {:d}'.format(
model['n_fg_class']))
else:
if not model['n_fg_class']:
raise ValueError('n_fg_class must be specified')
n_fg_class = model['n_fg_class']
path = download_model(model['url'])
if not _available:
warnings.warn(
'cv2 is not installed on your environment. '
'Pretrained models are trained with cv2. '
'The performace may change with Pillow backend.',
RuntimeWarning)
elif pretrained_model:
path = pretrained_model
else:
path = None
return n_fg_class, path
def _check_pretrained_model(n_fg_class, pretrained_model, models):
if pretrained_model in models:
model = models[pretrained_model]
if n_fg_class:
if model['n_fg_class'] and not n_fg_class == model['n_fg_class']:
raise ValueError(
'n_fg_class should be {:d}'.format(model['n_fg_class']))
else:
if not model['n_fg_class']:
raise ValueError('n_fg_class must be specified')
n_fg_class = model['n_fg_class']
path = download_model(model['url'])
if not _available:
warnings.warn(
'cv2 is not installed on your environment. '
'Pretrained models are trained with cv2. '
'The performace may change with Pillow backend.',
RuntimeWarning)
elif pretrained_model:
path = pretrained_model
else:
path = None
return n_fg_class, path
def __init__(self,
n_fg_class=None,
pretrained_model=None,
min_size=600,
max_size=1000,
ratios=[0.5, 1, 2],
anchor_scales=[8, 16, 32],
vgg_initialW=None,
rpn_initialW=None,
loc_initialW=None,
score_initialW=None,
proposal_creator_params={}):
if n_fg_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_fg_class needs to be supplied as an argument')
n_fg_class = self._models[pretrained_model]['n_fg_class']
if loc_initialW is None:
loc_initialW = chainer.initializers.Normal(0.001)
if score_initialW is None:
score_initialW = chainer.initializers.Normal(0.01)
if rpn_initialW is None:
rpn_initialW = chainer.initializers.Normal(0.01)
if vgg_initialW is None and pretrained_model:
vgg_initialW = chainer.initializers.constant.Zero()
extractor = VGG16FeatureExtractor(initialW=vgg_initialW)
rpn = RegionProposalNetwork(
512,
512,
ratios=ratios,
anchor_scales=anchor_scales,
feat_stride=self.feat_stride,
initialW=rpn_initialW,
proposal_creator_params=proposal_creator_params,
)
head = VGG16RoIHead(n_fg_class + 1,
roi_size=7,
spatial_scale=1. / self.feat_stride,
vgg_initialW=vgg_initialW,
loc_initialW=loc_initialW,
score_initialW=score_initialW)
super(FasterRCNNVGG16,
self).__init__(extractor,
rpn,
head,
mean=np.array([122.7717, 115.9465, 102.9801],
dtype=np.float32)[:, None, None],
min_size=min_size,
max_size=max_size)
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model == 'imagenet':
self._copy_imagenet_pretrained_vgg16()
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self,
n_class=None, pretrained_model=None, mean=None,
initialW=None, initial_bias=None):
if n_class is None:
if pretrained_model in self._models:
n_class = self._models[pretrained_model]['n_class']
else:
n_class = 1000
if mean is None:
if pretrained_model in self._models:
mean = self._models[pretrained_model]['mean']
else:
mean = _imagenet_mean
self.mean = mean
if initialW is None:
# Employ default initializers used in the original paper.
initialW = normal.Normal(0.01)
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
initialW = constant.Zero()
kwargs = {'initialW': initialW, 'initial_bias': initial_bias}
super(VGG16, self).__init__()
with self.init_scope():
self.conv1_1 = Conv2DActiv(None, 64, 3, 1, 1, **kwargs)
self.conv1_2 = Conv2DActiv(None, 64, 3, 1, 1, **kwargs)
self.pool1 = _max_pooling_2d
self.conv2_1 = Conv2DActiv(None, 128, 3, 1, 1, **kwargs)
self.conv2_2 = Conv2DActiv(None, 128, 3, 1, 1, **kwargs)
self.pool2 = _max_pooling_2d
self.conv3_1 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs)
self.conv3_2 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs)
self.conv3_3 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs)
self.pool3 = _max_pooling_2d
self.conv4_1 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv4_2 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv4_3 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.pool4 = _max_pooling_2d
self.conv5_1 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv5_2 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv5_3 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.pool5 = _max_pooling_2d
self.fc6 = Linear(None, 4096, **kwargs)
self.fc6_relu = relu
self.fc6_dropout = dropout
self.fc7 = Linear(None, 4096, **kwargs)
self.fc7_relu = relu
self.fc7_dropout = dropout
self.fc8 = Linear(None, n_class, **kwargs)
self.prob = softmax
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self,
n_class=None, pretrained_model=None, mean=None,
initialW=None, initial_bias=None):
if n_class is None:
if pretrained_model in self._models:
n_class = self._models[pretrained_model]['n_class']
else:
n_class = 1000
if mean is None:
if pretrained_model in self._models:
mean = self._models[pretrained_model]['mean']
else:
mean = _imagenet_mean
self.mean = mean
if initialW is None:
# Employ default initializers used in the original paper.
initialW = normal.Normal(0.01)
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
initialW = constant.Zero()
kwargs = {'initialW': initialW, 'initial_bias': initial_bias}
super(VGG16, self).__init__()
with self.init_scope():
self.conv1_1 = Conv2DActiv(None, 64, 3, 1, 1, **kwargs)
self.conv1_2 = Conv2DActiv(None, 64, 3, 1, 1, **kwargs)
self.pool1 = _max_pooling_2d
self.conv2_1 = Conv2DActiv(None, 128, 3, 1, 1, **kwargs)
self.conv2_2 = Conv2DActiv(None, 128, 3, 1, 1, **kwargs)
self.pool2 = _max_pooling_2d
self.conv3_1 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs)
self.conv3_2 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs)
self.conv3_3 = Conv2DActiv(None, 256, 3, 1, 1, **kwargs)
self.pool3 = _max_pooling_2d
self.conv4_1 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv4_2 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv4_3 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.pool4 = _max_pooling_2d
self.conv5_1 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv5_2 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.conv5_3 = Conv2DActiv(None, 512, 3, 1, 1, **kwargs)
self.pool5 = _max_pooling_2d
self.fc6 = Linear(None, 4096, **kwargs)
self.fc6_relu = relu
self.fc6_dropout = dropout
self.fc7 = Linear(None, 4096, **kwargs)
self.fc7_relu = relu
self.fc7_dropout = dropout
self.fc8 = Linear(None, n_class, **kwargs)
self.prob = softmax
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self, n_class=None, input_size=None, n_blocks=None,
pyramids=None, mid_stride=None, mean=None, comm=None,
pretrained_model=None, initialW=None):
super(PSPNet, self).__init__()
if pretrained_model is not None:
if 'n_class' in self._models[pretrained_model]:
n_class = self._models[pretrained_model]['n_class']
if 'input_size' in self._models[pretrained_model]:
input_size = self._models[pretrained_model]['input_size']
if 'n_blocks' in self._models[pretrained_model]:
n_blocks = self._models[pretrained_model]['n_blocks']
if 'pyramids' in self._models[pretrained_model]:
pyramids = self._models[pretrained_model]['pyramids']
if 'mid_stride' in self._models[pretrained_model]:
mid_stride = self._models[pretrained_model]['mid_stride']
if 'mean' in self._models[pretrained_model]:
mean = self._models[pretrained_model]['mean']
self._use_pretrained_model = True
chainer.config.mid_stride = mid_stride
chainer.config.comm = comm
if initialW is None:
chainer.config.initialW = chainer.initializers.HeNormal()
else:
chainer.config.initialW = initialW
if not isinstance(input_size, (list, tuple)):
input_size = (int(input_size), int(input_size))
with self.init_scope():
self.input_size = input_size
self.trunk = DilatedFCN(n_blocks=n_blocks)
# To calculate auxirally loss
if chainer.config.train:
self.cbr_aux = ConvBNReLU(None, 512, 3, 1, 1)
self.out_aux = L.Convolution2D(
512, n_class, 3, 1, 1, False, initialW)
# Main branch
feat_size = (input_size[0] // 8, input_size[1] // 8)
self.ppm = PyramidPoolingModule(2048, feat_size, pyramids)
self.cbr_main = ConvBNReLU(4096, 512, 3, 1, 1)
self.out_main = L.Convolution2D(
512, n_class, 1, 1, 0, False, initialW)
self.mean = mean
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self, n_class=None, pretrained_model=None, initialW=None):
if n_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_class needs to be supplied as an argument.')
n_class = self._models[pretrained_model]['n_class']
if initialW is None:
initialW = chainer.initializers.HeNormal()
super(SegNetBasic, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(
None, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv1_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv2 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv2_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv3 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv3_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv4 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv4_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode4 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode4_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode3 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode3_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode2 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode2_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode1 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode1_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_classifier = L.Convolution2D(
64, n_class, 1, 1, 0, initialW=initialW)
self.n_class = n_class
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self, n_class=None, pretrained_model=None, initialW=None):
if n_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_class needs to be supplied as an argument.')
n_class = self._models[pretrained_model]['n_class']
if initialW is None:
initialW = chainer.initializers.HeNormal()
super(SegNetBasic, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(
None, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv1_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv2 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv2_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv3 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv3_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv4 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv4_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode4 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode4_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode3 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode3_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode2 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode2_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_decode1 = L.Convolution2D(
64, 64, 7, 1, 3, nobias=True, initialW=initialW)
self.conv_decode1_bn = L.BatchNormalization(64, initial_beta=0.001)
self.conv_classifier = L.Convolution2D(
64, n_class, 1, 1, 0, initialW=initialW)
self.n_class = n_class
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self,
n_layer,
n_class=None,
pretrained_model=None,
mean=None,
initialW=None,
fc_kwargs={},
arch='fb'):
if arch == 'fb':
if pretrained_model == 'imagenet':
raise ValueError(
'Pretrained weights for Facebook ResNet models '
'are not supported. Please set mode to \'he\'.')
stride_first = False
conv1_no_bias = True
elif arch == 'he':
stride_first = True
conv1_no_bias = False
else:
raise ValueError('arch is expected to be one of [\'he\', \'fb\']')
_models = self._models[arch][n_layer]
blocks = self._blocks[n_layer]
if n_class is None:
if pretrained_model in _models:
n_class = _models[pretrained_model]['n_class']
else:
n_class = 1000
if mean is None:
if pretrained_model in _models:
mean = _models[pretrained_model]['mean']
else:
mean = _imagenet_mean
self.mean = mean
if initialW is None:
initialW = HeNormal(scale=1., fan_option='fan_out')
if 'initialW' not in fc_kwargs:
fc_kwargs['initialW'] = initializers.Normal(scale=0.01)
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
initialW = initializers.constant.Zero()
fc_kwargs['initialW'] = initializers.constant.Zero()
kwargs = {'initialW': initialW, 'stride_first': stride_first}
super(ResNet, self).__init__()
with self.init_scope():
self.conv1 = Conv2DBNActiv(None,
64,
7,
2,
3,
nobias=conv1_no_bias,
initialW=initialW)
self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2)
self.res2 = ResBlock(blocks[0], None, 64, 256, 1, **kwargs)
self.res3 = ResBlock(blocks[1], None, 128, 512, 2, **kwargs)
self.res4 = ResBlock(blocks[2], None, 256, 1024, 2, **kwargs)
self.res5 = ResBlock(blocks[3], None, 512, 2048, 2, **kwargs)
self.pool5 = _global_average_pooling_2d
self.fc6 = L.Linear(None, n_class, **fc_kwargs)
self.prob = F.softmax
if pretrained_model in _models:
if not _available:
warnings.warn(
'cv2 is not installed on your environment. '
'The scores of ResNets reported in the '
'README of the ChainerCV\'s classification '
'example are calculated using OpenCV as the '
'backend. With Pillow as the '
'backend, the scores would change.', RuntimeWarning)
path = download_model(_models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(
self,
n_fg_class=None,
pretrained_model=None,
min_size=600,
max_size=1000,
ratios=(0.5, 1, 2),
anchor_scales=(8, 16, 32),
vgg_initialW=None,
rpn_initialW=None,
loc_initialW=None,
score_initialW=None,
mask_initialW=None,
proposal_creator_params=None,
pooling_func=functions.roi_align_2d,
roi_size=7,
):
if n_fg_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_fg_class needs to be supplied as an argument')
n_fg_class = self._models[pretrained_model]['n_fg_class']
if loc_initialW is None:
loc_initialW = chainer.initializers.Normal(0.001)
if score_initialW is None:
score_initialW = chainer.initializers.Normal(0.01)
if mask_initialW is None:
mask_initialW = chainer.initializers.Normal(0.01)
if rpn_initialW is None:
rpn_initialW = chainer.initializers.Normal(0.01)
if vgg_initialW is None and pretrained_model:
vgg_initialW = chainer.initializers.constant.Zero()
if proposal_creator_params is None:
proposal_creator_params = dict(
n_train_pre_nms=12000,
n_train_post_nms=2000,
n_test_pre_nms=6000,
n_test_post_nms=1000,
min_size=0,
)
extractor = VGG16(initialW=vgg_initialW)
extractor.pick = 'conv5_3'
# Delete all layers after conv5_3.
extractor.remove_unused()
rpn = RegionProposalNetwork(
512,
512,
ratios=ratios,
anchor_scales=anchor_scales,
feat_stride=self.feat_stride,
initialW=rpn_initialW,
proposal_creator_params=proposal_creator_params,
)
head = VGG16RoIHead(
n_fg_class + 1,
roi_size=roi_size,
spatial_scale=1. / self.feat_stride,
vgg_initialW=vgg_initialW,
loc_initialW=loc_initialW,
score_initialW=score_initialW,
mask_initialW=mask_initialW,
pooling_func=pooling_func,
)
super(MaskRCNNVGG16,
self).__init__(extractor,
rpn,
head,
mean=np.array([122.7717, 115.9465, 102.9801],
dtype=np.float32)[:, None, None],
min_size=min_size,
max_size=max_size)
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model == 'imagenet':
self._copy_imagenet_pretrained_vgg16()
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self,
n_fg_class=None,
pretrained_model=None,
min_size=600, max_size=1000,
ratios=[0.5, 1, 2], anchor_scales=[8, 16, 32],
vgg_initialW=None, rpn_initialW=None,
loc_initialW=None, score_initialW=None,
proposal_creator_params={}
):
if n_fg_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_fg_class needs to be supplied as an argument')
n_fg_class = self._models[pretrained_model]['n_fg_class']
if loc_initialW is None:
loc_initialW = chainer.initializers.Normal(0.001)
if score_initialW is None:
score_initialW = chainer.initializers.Normal(0.01)
if rpn_initialW is None:
rpn_initialW = chainer.initializers.Normal(0.01)
if vgg_initialW is None and pretrained_model:
vgg_initialW = chainer.initializers.constant.Zero()
extractor = VGG16(initialW=vgg_initialW)
extractor.pick = 'conv5_3'
# Delete all layers after conv5_3.
extractor.remove_unused()
rpn = RegionProposalNetwork(
512, 512,
ratios=ratios,
anchor_scales=anchor_scales,
feat_stride=self.feat_stride,
initialW=rpn_initialW,
proposal_creator_params=proposal_creator_params,
)
head = VGG16RoIHead(
n_fg_class + 1,
roi_size=7, spatial_scale=1. / self.feat_stride,
vgg_initialW=vgg_initialW,
loc_initialW=loc_initialW,
score_initialW=score_initialW
)
super(FasterRCNNVGG16, self).__init__(
extractor,
rpn,
head,
mean=np.array([122.7717, 115.9465, 102.9801],
dtype=np.float32)[:, None, None],
min_size=min_size,
max_size=max_size
)
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model == 'imagenet':
self._copy_imagenet_pretrained_vgg16()
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self, n_layer,
n_class=None,
pretrained_model=None,
mean=None, initialW=None, arch='fb'):
if arch == 'fb':
if pretrained_model == 'imagenet':
raise ValueError(
'Pretrained weights for Facebook ResNet models '
'are not supported. Please set mode to \'he\'.')
stride_first = False
conv1_no_bias = True
elif arch == 'he':
stride_first = True
conv1_no_bias = False
else:
raise ValueError('arch is expected to be one of [\'he\', \'fb\']')
_models = self._models[arch][n_layer]
blocks = self._blocks[n_layer]
if n_class is None:
if pretrained_model in _models:
n_class = _models[pretrained_model]['n_class']
else:
n_class = 1000
if mean is None:
if pretrained_model in _models:
mean = _models[pretrained_model]['mean']
else:
mean = _imagenet_mean
self.mean = mean
if initialW is None:
conv_initialW = HeNormal(scale=1., fan_option='fan_out')
fc_initialW = initializers.Normal(scale=0.01)
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
initialW = initializers.constant.Zero()
kwargs = {'initialW': conv_initialW, 'stride_first': stride_first}
super(ResNet, self).__init__()
with self.init_scope():
self.conv1 = Conv2DBNActiv(None, 64, 7, 2, 3, nobias=conv1_no_bias,
initialW=conv_initialW)
self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2)
self.res2 = ResBlock(blocks[0], None, 64, 256, 1, **kwargs)
self.res3 = ResBlock(blocks[1], None, 128, 512, 2, **kwargs)
self.res4 = ResBlock(blocks[2], None, 256, 1024, 2, **kwargs)
self.res5 = ResBlock(blocks[3], None, 512, 2048, 2, **kwargs)
self.pool5 = _global_average_pooling_2d
self.fc6 = L.Linear(None, n_class, initialW=fc_initialW)
self.prob = F.softmax
if pretrained_model in _models:
if not _available:
warnings.warn('cv2 is not installed on your environment. '
'The scores of ResNets reported in the '
'README of the ChainerCV\'s classification '
'example are calculated using OpenCV as the '
'backend. With Pillow as the '
'backend, the scores would change.',
RuntimeWarning)
path = download_model(_models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def prepare_pretrained_model(param, pretrained_model, models, default={}):
"""Select parameters based on the existence of pretrained model.
Args:
param (dict): Map from the name of the parameter to values.
pretrained_model (string): Name of the pretrained weight,
path to the pretrained weight or :obj:`None`.
models (dict): Map from the name of the pretrained weight
to :obj:`model`, which is a dictionary containing the
configuration used by the selected weight.
:obj:`model` has four keys: :obj:`param`, :obj:`overwritable`,
:obj:`url` and :obj:`cv2`.
* **param** (*dict*): Parameters assigned to the pretrained \
weight.
* **overwritable** (*set*): Names of parameters that are \
overwritable (i.e., :obj:`param[key] != model['param'][key]` \
is accepted).
* **url** (*string*): Location of the pretrained weight.
* **cv2** (*bool*): If :obj:`True`, a warning is raised \
if :obj:`cv2` is not installed.
"""
if pretrained_model in models:
model = models[pretrained_model]
model_param = model.get('param', {})
overwritable = model.get('overwritable', set())
for key in param.keys():
if key not in model_param:
continue
if param[key] is None:
param[key] = model_param[key]
else:
if key not in overwritable \
and not param[key] == model_param[key]:
raise ValueError('{} must be {}'.format(
key, model_param[key]))
path = download_model(model['url'])
if model.get('cv2', False):
if not _cv2_available:
warnings.warn(
'cv2 is not installed on your environment. '
'The pretrained model is trained with cv2. '
'The performace may change with Pillow backend.',
RuntimeWarning)
if chainer.config.cv_resize_backend != 'cv2':
warnings.warn(
'Although the pretrained model is trained using cv2 as '
'the backend of resize function, the current '
'setting does not use cv2 as the backend of resize '
'function. The performance may change due to using '
'different backends. To suppress this warning, set '
'`chainer.config.cv_resize_backend = "cv2".',
RuntimeWarning)
elif pretrained_model:
path = pretrained_model
else:
path = None
for key in param.keys():
if param[key] is None:
if key in default:
param[key] = default[key]
else:
raise ValueError('{} must be specified'.format(key))
return param, path
def __init__(
self,
n_layers,
n_fg_class=None,
pretrained_model=None,
min_size=600,
max_size=1000,
ratios=[0.5, 1, 2],
anchor_scales=[8, 16, 32],
res_initialW=None,
rpn_initialW=None,
loc_initialW=None,
score_initialW=None,
proposal_creator_params=dict(),
pooling_func=F.roi_pooling_2d,
):
if n_fg_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_fg_class needs to be supplied as an argument')
n_fg_class = self._models[pretrained_model]['n_fg_class']
if loc_initialW is None:
loc_initialW = chainer.initializers.Normal(0.001)
if score_initialW is None:
score_initialW = chainer.initializers.Normal(0.01)
if rpn_initialW is None:
rpn_initialW = chainer.initializers.Normal(0.01)
if res_initialW is None and pretrained_model:
res_initialW = chainer.initializers.constant.Zero()
if n_layers == 50:
self._ResNetLayers = ResNet50Layers
elif n_layers == 101:
self._ResNetLayers = ResNet101Layers
else:
raise ValueError
class Extractor(self._ResNetLayers):
def __init__(self, *args, **kwargs):
super(Extractor, self).__init__(*args, **kwargs)
# Remove no need layers to save memory
self.res5 = chainer.Link()
self.fc6 = chainer.Link()
def __call__(self, x):
pick = 'res4'
with chainer.using_config('train', False):
feat = super(Extractor, self).__call__(x, layers=[pick])
return feat[pick]
extractor = Extractor(pretrained_model=None)
rpn = RegionProposalNetwork(
1024,
512,
ratios=ratios,
anchor_scales=anchor_scales,
feat_stride=self.feat_stride,
initialW=rpn_initialW,
proposal_creator_params=proposal_creator_params,
)
head = ResNetRoIHead(
n_fg_class + 1,
roi_size=7,
spatial_scale=1. / self.feat_stride,
res_initialW=res_initialW,
loc_initialW=loc_initialW,
score_initialW=score_initialW,
pooling_func=pooling_func,
)
super(FasterRCNNResNet,
self).__init__(extractor,
rpn,
head,
mean=np.array([123.152, 115.903, 103.063],
dtype=np.float32)[:, None, None],
min_size=min_size,
max_size=max_size)
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model == 'imagenet':
self._copy_imagenet_pretrained_resnet()
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self,
n_layers,
n_fg_class=None,
pretrained_model=None,
min_size=600, max_size=1000,
ratios=[0.5, 1, 2], anchor_scales=[4, 8, 16, 32],
res_initialW=None, rpn_initialW=None,
loc_initialW=None, score_initialW=None,
proposal_creator_params=dict(),
pooling_func=functions.roi_align_2d,
rpn_hidden=1024, roi_size=7,
):
if n_fg_class is None:
if pretrained_model not in self._models:
raise ValueError(
'The n_fg_class needs to be supplied as an argument')
n_fg_class = self._models[pretrained_model]['n_fg_class']
if loc_initialW is None:
loc_initialW = chainer.initializers.Normal(0.001)
if score_initialW is None:
score_initialW = chainer.initializers.Normal(0.01)
if rpn_initialW is None:
rpn_initialW = chainer.initializers.Normal(0.01)
if res_initialW is None and pretrained_model:
res_initialW = chainer.initializers.constant.Zero()
if n_layers == 50:
extractor = ResNet50Extractor(pretrained_model=None)
elif n_layers == 101:
extractor = ResNet101Extractor(pretrained_model=None)
else:
raise ValueError
self._n_layers = n_layers
rpn = RegionProposalNetwork(
1024, rpn_hidden,
ratios=ratios,
anchor_scales=anchor_scales,
feat_stride=self.feat_stride,
initialW=rpn_initialW,
proposal_creator_params=proposal_creator_params,
)
head = ResNetRoIHead(
n_fg_class + 1,
roi_size=roi_size,
spatial_scale=1. / self.feat_stride,
res_initialW=res_initialW,
loc_initialW=loc_initialW,
score_initialW=score_initialW,
pooling_func=pooling_func,
)
super(MaskRCNNResNet, self).__init__(
extractor,
rpn,
head,
mean=np.array([123.152, 115.903, 103.063],
dtype=np.float32)[:, None, None],
min_size=min_size,
max_size=max_size
)
if pretrained_model in self._models:
path = download_model(self._models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model == 'imagenet':
self._copy_imagenet_pretrained_resnet()
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
def __init__(self,
n_layer,
n_class=None,
pretrained_model=None,
mean=None,
initialW=None,
arch='fb'):
if arch == 'fb':
if pretrained_model == 'imagenet':
raise ValueError(
'Pretrained weights for Facebook ResNet models '
'are not supported. Please set mode to \'he\'.')
stride_first = False
conv1_no_bias = True
elif arch == 'he':
stride_first = True
conv1_no_bias = False
else:
raise ValueError('arch is expected to be one of [\'he\', \'fb\']')
_models = self._models[arch][n_layer]
blocks = self._blocks[n_layer]
if n_class is None:
if pretrained_model in _models:
n_class = _models[pretrained_model]['n_class']
else:
n_class = 1000
if mean is None:
if pretrained_model in _models:
mean = _models[pretrained_model]['mean']
else:
mean = _imagenet_mean
self.mean = mean
if initialW is None:
conv_initialW = HeNormal(scale=1., fan_option='fan_out')
fc_initialW = initializers.Normal(scale=0.01)
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
initialW = initializers.constant.Zero()
kwargs = {'initialW': conv_initialW, 'stride_first': stride_first}
super(ResNet, self).__init__()
with self.init_scope():
self.conv1 = Conv2DBNActiv(None,
64,
7,
2,
3,
nobias=conv1_no_bias,
initialW=conv_initialW)
self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2)
self.res2 = ResBlock(blocks[0], None, 64, 256, 1, **kwargs)
self.res3 = ResBlock(blocks[1], None, 128, 512, 2, **kwargs)
self.res4 = ResBlock(blocks[2], None, 256, 1024, 2, **kwargs)
self.res5 = ResBlock(blocks[3], None, 512, 2048, 2, **kwargs)
self.pool5 = _global_average_pooling_2d
self.fc6 = L.Linear(None, n_class, initialW=fc_initialW)
self.prob = F.softmax
if pretrained_model in _models:
path = download_model(_models[pretrained_model]['url'])
chainer.serializers.load_npz(path, self)
elif pretrained_model:
chainer.serializers.load_npz(pretrained_model, self)
