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, 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_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)