diff --git a/chainercv/experimental/links/model/fcis/fcis_resnet101.py b/chainercv/experimental/links/model/fcis/fcis_resnet101.py index cf7a7883e3..5277aad1a2 100644 --- a/chainercv/experimental/links/model/fcis/fcis_resnet101.py +++ b/chainercv/experimental/links/model/fcis/fcis_resnet101.py @@ -66,10 +66,6 @@ class FCISResNet101(FCIS): localization estimates. loc_normalize_std (tupler of four floats): Standard deviation of localization estimates. - iter2 (bool): if the value is set :obj:`True`, Position Sensitive - ROI pooling is executed twice. In the second time, Position - Sensitive ROI pooling uses improved ROIs by the localization - parameters calculated in the first time. resnet_initialW (callable): Initializer for the layers corresponding to the ResNet101 layers. rpn_initialW (callable): Initializer for Region Proposal Network @@ -79,90 +75,112 @@ class FCISResNet101(FCIS): :class:`~chainercv.links.model.faster_rcnn.ProposalCreator`. """ + _common_param = { + 'feat_stride': 16, + 'min_size': 600, + 'max_size': 1000, + 'roi_size': 21, + 'group_size': 7, + 'ratios': [0.5, 1, 2], + 'loc_normalize_mean': (0.0, 0.0, 0.0, 0.0), + 'loc_normalize_std': (0.2, 0.2, 0.5, 0.5), + 'rpn_initialW': chainer.initializers.Normal(0.01), + 'resnet_initialW': chainer.initializers.constant.Zero(), + 'head_initialW': chainer.initializers.Normal(0.01), + } + preset_params = { + 'sbd': dict({ + 'n_fg_class': 20, + 'anchor_scales': (8, 16, 32), + 'proposal_creator_params': { + 'nms_thresh': 0.7, + 'n_train_pre_nms': 6000, + 'n_train_post_nms': 300, + 'n_test_pre_nms': 6000, + 'n_test_post_nms': 300, + 'force_cpu_nms': False, + 'min_size': 16, + }}, + **_common_param), + 'coco': dict({ + 'n_fg_class': 80, + 'anchor_scales': (4, 8, 16, 32), + 'proposal_creator_params': { + 'nms_thresh': 0.7, + 'n_train_pre_nms': 6000, + 'n_train_post_nms': 300, + 'n_test_pre_nms': 6000, + 'n_test_post_nms': 300, + 'force_cpu_nms': False, + 'min_size': 2, + }}, + **_common_param), + } _models = { 'sbd': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['sbd'], 'url': 'https://chainercv-models.preferred.jp/' - 'fcis_resnet101_sbd_trained_2018_06_22.npz', - 'cv2': True + 'fcis_resnet101_sbd_trained_2018_06_22.npz', + 'cv2': True, }, 'sbd_converted': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['sbd'], 'url': 'https://chainercv-models.preferred.jp/' - 'fcis_resnet101_sbd_converted_2018_07_02.npz', - 'cv2': True + 'fcis_resnet101_sbd_converted_2018_07_02.npz', + 'cv2': True, }, 'coco': { - 'param': {'n_fg_class': 80}, + 'param': preset_params['coco'], 'url': 'https://chainercv-models.preferred.jp/' - 'fcis_resnet101_coco_trained_2019_01_30.npz', - 'cv2': True + 'fcis_resnet101_coco_trained_2019_01_30.npz', + 'cv2': True, }, 'coco_converted': { - 'param': {'n_fg_class': 80}, + 'param': preset_params['coco'], 'url': 'https://chainercv-models.preferred.jp/' - 'fcis_resnet101_coco_converted_2019_01_30.npz', - 'cv2': True - } - } - feat_stride = 16 - proposal_creator_params = { - 'nms_thresh': 0.7, - 'n_train_pre_nms': 6000, - 'n_train_post_nms': 300, - 'n_test_pre_nms': 6000, - 'n_test_post_nms': 300, - 'force_cpu_nms': False, - 'min_size': 16 + 'fcis_resnet101_coco_converted_2019_01_30.npz', + 'cv2': True, + }, } def __init__( self, n_fg_class=None, pretrained_model=None, - min_size=600, max_size=1000, - roi_size=21, group_size=7, - ratios=[0.5, 1, 2], anchor_scales=[8, 16, 32], - loc_normalize_mean=(0.0, 0.0, 0.0, 0.0), - loc_normalize_std=(0.2, 0.2, 0.5, 0.5), - iter2=True, - resnet_initialW=None, rpn_initialW=None, head_initialW=None, - proposal_creator_params=None): - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) - - if rpn_initialW is None: - rpn_initialW = chainer.initializers.Normal(0.01) - if resnet_initialW is None and pretrained_model: - resnet_initialW = chainer.initializers.constant.Zero() - if proposal_creator_params is not None: - self.proposal_creator_params = proposal_creator_params - - extractor = ResNet101Extractor( - initialW=resnet_initialW) + feat_stride=None, + min_size=None, max_size=None, + roi_size=None, group_size=None, + ratios=None, anchor_scales=None, + loc_normalize_mean=None, loc_normalize_std=None, + rpn_initialW=None, resnet_initialW=None, head_initialW=None, + proposal_creator_params=None, + ): + param, path = utils.prepare_model_param(locals(), self._models) + + extractor = ResNet101Extractor(initialW=param['resnet_initialW']) rpn = RegionProposalNetwork( 1024, 512, - ratios=ratios, - anchor_scales=anchor_scales, - feat_stride=self.feat_stride, - initialW=rpn_initialW, - proposal_creator_params=self.proposal_creator_params) + ratios=param['ratios'], + anchor_scales=param['anchor_scales'], + feat_stride=param['feat_stride'], + initialW=param['rpn_initialW'], + proposal_creator_params=param['proposal_creator_params']) head = FCISResNet101Head( param['n_fg_class'] + 1, - roi_size=roi_size, group_size=group_size, - spatial_scale=1. / self.feat_stride, - loc_normalize_mean=loc_normalize_mean, - loc_normalize_std=loc_normalize_std, - iter2=iter2, initialW=head_initialW) + roi_size=param['roi_size'], group_size=param['group_size'], + spatial_scale=1. / param['feat_stride'], + loc_normalize_mean=param['loc_normalize_mean'], + loc_normalize_std=param['loc_normalize_std'], + initialW=param['head_initialW']) - mean = np.array([123.15, 115.90, 103.06], - dtype=np.float32)[:, None, None] + mean = np.array( + [123.15, 115.90, 103.06], dtype=np.float32)[:, None, None] super(FCISResNet101, self).__init__( extractor, rpn, head, - mean, min_size, max_size, - loc_normalize_mean, loc_normalize_std) + mean, param['min_size'], param['max_size'], + param['loc_normalize_mean'], param['loc_normalize_std']) if path == 'imagenet': self._copy_imagenet_pretrained_resnet() @@ -269,10 +287,6 @@ class FCISResNet101Head(chainer.Chain): localization estimates. loc_normalize_std (tupler of four floats): Standard deviation of localization estimates. - iter2 (bool): if the value is set :obj:`True`, Position Sensitive - ROI pooling is executed twice. In the second time, Position - Sensitive ROI pooling uses improved ROIs by the localization - parameters calculated in the first time. initialW (callable): Initializer for the layers. """ @@ -282,7 +296,7 @@ def __init__( n_class, roi_size, group_size, spatial_scale, loc_normalize_mean, loc_normalize_std, - iter2, initialW=None + initialW=None ): super(FCISResNet101Head, self).__init__() @@ -295,7 +309,6 @@ def __init__( self.roi_size = roi_size self.loc_normalize_mean = loc_normalize_mean self.loc_normalize_std = loc_normalize_std - self.iter2 = iter2 with self.init_scope(): self.conv1 = L.Convolution2D( @@ -307,7 +320,8 @@ def __init__( 1024, group_size * group_size * 2 * 4, 1, 1, 0, initialW=initialW) - def forward(self, x, rois, roi_indices, img_size, gt_roi_labels=None): + def forward(self, x, rois, roi_indices, img_size, + gt_roi_labels=None, iter2=True): """Forward the chain. We assume that there are :math:`N` batches. @@ -323,6 +337,10 @@ def forward(self, x, rois, roi_indices, img_size, gt_roi_labels=None): roi_indices (array): An array containing indices of images to which bounding boxes correspond to. Its shape is :math:`(R',)`. img_size (tuple of int): A tuple containing image size. + iter2 (bool): if the value is set :obj:`True`, Position Sensitive + ROI pooling is executed twice. In the second time, Position + Sensitive ROI pooling uses improved ROIs by the localization + parameters calculated in the first time. """ h = F.relu(self.conv1(x)) @@ -332,7 +350,7 @@ def forward(self, x, rois, roi_indices, img_size, gt_roi_labels=None): # PSROI pooling and regression roi_ag_seg_scores, roi_ag_locs, roi_cls_scores = self._pool( h_cls_seg, h_ag_loc, rois, roi_indices, gt_roi_labels) - if self.iter2: + if iter2: # 2nd Iteration # get rois2 for more precise prediction roi_ag_locs = roi_ag_locs.array diff --git a/chainercv/experimental/links/model/fcis/fcis_train_chain.py b/chainercv/experimental/links/model/fcis/fcis_train_chain.py index f6f7e67dd7..14f90a2b05 100644 --- a/chainercv/experimental/links/model/fcis/fcis_train_chain.py +++ b/chainercv/experimental/links/model/fcis/fcis_train_chain.py @@ -141,7 +141,8 @@ def forward(self, imgs, masks, labels, bboxes, scale): sample_roi_index = self.xp.zeros( (len(sample_roi),), dtype=np.int32) roi_ag_seg_score, roi_ag_loc, roi_cls_score, _, _ = self.fcis.head( - roi_features, sample_roi, sample_roi_index, img_size, gt_roi_label) + roi_features, sample_roi, sample_roi_index, img_size, + gt_roi_label, iter2=False) # RPN losses gt_rpn_loc, gt_rpn_label = self.anchor_target_creator( diff --git a/chainercv/experimental/links/model/pspnet/pspnet.py b/chainercv/experimental/links/model/pspnet/pspnet.py index 6ef287d93c..654e5bcb59 100644 --- a/chainercv/experimental/links/model/pspnet/pspnet.py +++ b/chainercv/experimental/links/model/pspnet/pspnet.py @@ -52,6 +52,11 @@ def forward(self, x): class DilatedResNet(PickableSequentialChain): + preset_params = { + 'imagenet': { + 'initialW': initializers.constant.Zero(), + } + } _blocks = { 50: [3, 4, 6, 3], 101: [3, 4, 23, 3], @@ -60,6 +65,7 @@ class DilatedResNet(PickableSequentialChain): _models = { 50: { 'imagenet': { + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' 'pspnet_resnet50_imagenet_trained_2018_11_26.npz', 'cv2': True @@ -67,6 +73,7 @@ class DilatedResNet(PickableSequentialChain): }, 101: { 'imagenet': { + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' 'pspnet_resnet101_imagenet_trained_2018_11_26.npz', 'cv2': True @@ -78,10 +85,9 @@ def __init__(self, n_layer, pretrained_model=None, initialW=None): n_block = self._blocks[n_layer] - _, path = utils.prepare_pretrained_model( - {}, - pretrained_model, - self._models[n_layer]) + param, path = utils.prepare_model_param( + locals(), self._models[n_layer]) + initialW = param['initialW'] super(DilatedResNet, self).__init__() with self.init_scope(): @@ -156,23 +162,19 @@ def __init__(self, n_class=None, pretrained_model=None, else: extractor_pretrained_model = None - param, path = utils.prepare_pretrained_model( - {'n_class': n_class, 'input_size': input_size}, - pretrained_model, self._models, - default={'input_size': (713, 713)}) + param, path = utils.prepare_model_param(locals(), self._models) n_class = param['n_class'] input_size = param['input_size'] + initialW = param['initialW'] if not isinstance(input_size, (list, tuple)): input_size = (int(input_size), int(input_size)) self.input_size = input_size - if initialW is None: - if pretrained_model: - initialW = initializers.constant.Zero() - kwargs = self._extractor_kwargs - kwargs.update({'pretrained_model': extractor_pretrained_model, - 'initialW': initialW}) + kwargs.update({'pretrained_model': extractor_pretrained_model}) + if extractor_pretrained_model in self._extractor_cls.preset_params: + kwargs.update( + self._extractor_cls.preset_params[extractor_pretrained_model]) extractor = self._extractor_cls(**kwargs) extractor.pick = self._extractor_pick @@ -302,17 +304,29 @@ class PSPNetResNet101(PSPNet): """ + preset_params = { + 'cityscapes': { + 'n_class': 19, + 'input_size': (713, 713), + 'initialW': initializers.constant.Zero(), + }, + 'ade20k': { + 'n_class': 150, + 'input_size': (473, 473), + 'initialW': initializers.constant.Zero(), + }, + } _extractor_cls = DilatedResNet _extractor_kwargs = {'n_layer': 101} _extractor_pick = ('res4', 'res5') _models = { 'cityscapes': { - 'param': {'n_class': 19, 'input_size': (713, 713)}, + 'param': preset_params['cityscapes'], 'url': 'https://chainercv-models.preferred.jp/' 'pspnet_resnet101_cityscapes_trained_2018_12_19.npz', }, 'ade20k': { - 'param': {'n_class': 150, 'input_size': (473, 473)}, + 'param': preset_params['ade20k'], 'url': 'https://chainercv-models.preferred.jp/' 'pspnet_resnet101_ade20k_trained_2018_12_23.npz', }, @@ -328,17 +342,29 @@ class PSPNetResNet50(PSPNet): """ + preset_params = { + 'cityscapes': { + 'n_class': 19, + 'input_size': (713, 713), + 'initialW': initializers.constant.Zero(), + }, + 'ade20k': { + 'n_class': 150, + 'input_size': (473, 473), + 'initialW': initializers.constant.Zero(), + }, + } _extractor_cls = DilatedResNet _extractor_kwargs = {'n_layer': 50} _extractor_pick = ('res4', 'res5') _models = { 'cityscapes': { - 'param': {'n_class': 19, 'input_size': (713, 713)}, + 'param': preset_params['cityscapes'], 'url': 'https://chainercv-models.preferred.jp/' 'pspnet_resnet50_cityscapes_trained_2018_12_19.npz', }, 'ade20k': { - 'param': {'n_class': 150, 'input_size': (473, 473)}, + 'param': preset_params['ade20k'], 'url': 'https://chainercv-models.preferred.jp/' 'pspnet_resnet50_ade20k_trained_2018_12_23.npz', }, diff --git a/chainercv/experimental/links/model/yolo/yolo_v2_tiny.py b/chainercv/experimental/links/model/yolo/yolo_v2_tiny.py index 0030b7886e..c3d71ff1c5 100644 --- a/chainercv/experimental/links/model/yolo/yolo_v2_tiny.py +++ b/chainercv/experimental/links/model/yolo/yolo_v2_tiny.py @@ -77,11 +77,14 @@ class YOLOv2Tiny(YOLOv2Base): """ + preset_params = { + 'voc': {'n_fg_class': 20}, + } _extractor = DarknetExtractor _models = { 'voc0712': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'yolo_v2_tiny_voc0712_converted_2018_10_19.npz', 'cv2': True diff --git a/chainercv/links/model/deeplab/deeplab_v3_plus.py b/chainercv/links/model/deeplab/deeplab_v3_plus.py index 98c13751ad..9cba1fa679 100644 --- a/chainercv/links/model/deeplab/deeplab_v3_plus.py +++ b/chainercv/links/model/deeplab/deeplab_v3_plus.py @@ -198,64 +198,67 @@ def predict(self, imgs): class DeepLabV3plusXception65(DeepLabV3plus): - _models = { + preset_params = { 'voc': { - 'param': { - 'n_class': 21, - 'min_input_size': (513, 513), - 'scales': (1.0,), - 'flip': False, - 'extractor_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-3}, - }, - 'aspp_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, - }, - 'decoder_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, - }, + 'n_class': 21, + 'min_input_size': (513, 513), + 'scales': (1.0,), + 'flip': False, + 'extractor_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-3}, + }, + 'aspp_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, + }, + 'decoder_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, + }, + }, + 'cityscapes': { + 'n_class': 19, + 'min_input_size': (1025, 2049), + 'scales': (1.0,), + 'flip': False, + 'extractor_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-3}, + }, + 'aspp_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, + }, + 'decoder_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, + }, + }, + 'ade20k': { + 'n_class': 150, + 'min_input_size': (513, 513), + 'scales': (1.0,), + 'flip': False, + 'extractor_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-3}, + }, + 'aspp_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, + }, + 'decoder_kwargs': { + 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, }, - 'overwritable': ('scales', 'flip'), + + }, + } + _models = { + 'voc': { + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'deeplabv3plus_xception65_voc_converted_2019_02_15.npz', }, 'cityscapes': { - 'param': { - 'n_class': 19, - 'min_input_size': (1025, 2049), - 'scales': (1.0,), - 'flip': False, - 'extractor_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-3}, - }, - 'aspp_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, - }, - 'decoder_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, - }, - }, - 'overwritable': ('scales', 'flip'), + 'param': preset_params['cityscapes'], 'url': 'https://chainercv-models.preferred.jp/' 'deeplabv3plus_xception65_cityscapes_converted_2019_02_15.npz', }, 'ade20k': { - 'param': { - 'n_class': 150, - 'min_input_size': (513, 513), - 'scales': (1.0,), - 'flip': False, - 'extractor_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-3}, - }, - 'aspp_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, - }, - 'decoder_kwargs': { - 'bn_kwargs': {'decay': 0.9997, 'eps': 1e-5}, - }, - }, - 'overwritable': ('scales', 'flip'), + 'param': preset_params['ade20k'], 'url': 'https://chainercv-models.preferred.jp/' 'deeplabv3plus_xception65_ade20k_converted_2019_03_08.npz', } @@ -264,17 +267,7 @@ class DeepLabV3plusXception65(DeepLabV3plus): def __init__(self, n_class=None, pretrained_model=None, min_input_size=None, scales=None, flip=None, extractor_kwargs=None, aspp_kwargs=None, decoder_kwargs=None): - param, path = utils.prepare_pretrained_model( - {'n_class': n_class, 'min_input_size': min_input_size, - 'scales': scales, 'flip': flip, - 'extractor_kwargs': extractor_kwargs, - 'aspp_kwargs': aspp_kwargs, 'decoder_kwargs': decoder_kwargs}, - pretrained_model, self._models, - default={ - 'min_input_size': (513, 513), - 'scales': (1.0,), 'flip': False, - 'extractor_kwargs': {}, - 'aspp_kwargs': {}, 'decoder_kwargs': {}}) + param, path = utils.prepare_model_param(locals(), self._models) super(DeepLabV3plusXception65, self).__init__( Xception65(**param['extractor_kwargs']), diff --git a/chainercv/links/model/faster_rcnn/faster_rcnn_vgg.py b/chainercv/links/model/faster_rcnn/faster_rcnn_vgg.py index 492bca3a59..86bb0fb117 100644 --- a/chainercv/links/model/faster_rcnn/faster_rcnn_vgg.py +++ b/chainercv/links/model/faster_rcnn/faster_rcnn_vgg.py @@ -69,60 +69,68 @@ class FasterRCNNVGG16(FasterRCNN): """ + preset_params = { + 'voc': { + 'feat_stride': 16, + 'min_size': 600, + 'max_size': 1000, + 'ratios': [0.5, 1, 2], + 'anchor_scales': [8, 16, 32], + 'n_fg_class': 20, + 'vgg_initialW': chainer.initializers.constant.Zero(), + 'rpn_initialW': chainer.initializers.Normal(0.01), + 'loc_initialW': chainer.initializers.Normal(0.001), + 'score_initialW': chainer.initializers.Normal(0.01), + 'proposal_creator_params': {}, + }, + } _models = { 'voc07': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'faster_rcnn_vgg16_voc07_trained_2018_06_01.npz', 'cv2': True }, 'voc0712': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'faster_rcnn_vgg16_voc0712_trained_2017_07_21.npz', 'cv2': True }, } - feat_stride = 16 - - 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={}): - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) - - 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) + + def __init__( + self, + n_fg_class=None, + pretrained_model=None, + feat_stride=None, + min_size=None, max_size=None, + ratios=None, anchor_scales=None, + vgg_initialW=None, rpn_initialW=None, + loc_initialW=None, score_initialW=None, + proposal_creator_params=None + ): + param, path = utils.prepare_model_param(locals(), self._models) + + extractor = VGG16(initialW=param['vgg_initialW'], + **VGG16.preset_params['imagenet']) 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, + ratios=param['ratios'], + anchor_scales=param['anchor_scales'], + feat_stride=param['feat_stride'], + initialW=param['rpn_initialW'], + proposal_creator_params=param['proposal_creator_params'], ) head = VGG16RoIHead( param['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 + roi_size=7, spatial_scale=1. / param['feat_stride'], + vgg_initialW=param['vgg_initialW'], + loc_initialW=param['loc_initialW'], + score_initialW=param['score_initialW'], ) super(FasterRCNNVGG16, self).__init__( @@ -131,8 +139,8 @@ def __init__(self, head, mean=np.array([122.7717, 115.9465, 102.9801], dtype=np.float32)[:, None, None], - min_size=min_size, - max_size=max_size + min_size=param['min_size'], + max_size=param['max_size'] ) if path == 'imagenet': diff --git a/chainercv/links/model/fpn/faster_rcnn_fpn_resnet.py b/chainercv/links/model/fpn/faster_rcnn_fpn_resnet.py index a0fbf7aa5e..8e731e86a0 100644 --- a/chainercv/links/model/fpn/faster_rcnn_fpn_resnet.py +++ b/chainercv/links/model/fpn/faster_rcnn_fpn_resnet.py @@ -1,5 +1,7 @@ from __future__ import division +import copy + import chainer import chainer.functions as F import chainer.links as L @@ -49,10 +51,11 @@ class FasterRCNNFPNResNet(FasterRCNN): def __init__(self, n_fg_class=None, pretrained_model=None, return_values=['bboxes', 'labels', 'scores'], min_size=800, max_size=1333): - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) + param, path = utils.prepare_model_param(locals(), self._models) - base = self._base(n_class=1, arch='he') + base_param = copy.deepcopy(self._base.preset_params['imagenet']) + base_param['n_class'] = 1 + base = self._base(arch='he', **base_param) base.pick = ('res2', 'res3', 'res4', 'res5') base.pool1 = lambda x: F.max_pooling_2d( x, 3, stride=2, pad=1, cover_all=False) @@ -99,10 +102,13 @@ class FasterRCNNFPNResNet50(FasterRCNNFPNResNet): """ + preset_params = { + 'coco': {'n_fg_class': 80}, + } _base = ResNet50 _models = { 'coco': { - 'param': {'n_fg_class': 80}, + 'param': preset_params['coco'], 'url': 'https://chainercv-models.preferred.jp/' 'faster_rcnn_fpn_resnet50_coco_trained_2019_03_15.npz', 'cv2': True @@ -117,10 +123,13 @@ class FasterRCNNFPNResNet101(FasterRCNNFPNResNet): """ + preset_params = { + 'coco': {'n_fg_class': 80}, + } _base = ResNet101 _models = { 'coco': { - 'param': {'n_fg_class': 80}, + 'param': preset_params['coco'], 'url': 'https://chainercv-models.preferred.jp/' 'faster_rcnn_fpn_resnet101_coco_trained_2019_03_15.npz', 'cv2': True @@ -135,10 +144,13 @@ class MaskRCNNFPNResNet50(MaskRCNNFPNResNet): """ + preset_params = { + 'coco': {'n_fg_class': 80}, + } _base = ResNet50 _models = { 'coco': { - 'param': {'n_fg_class': 80}, + 'param': preset_params['coco'], 'url': 'https://chainercv-models.preferred.jp/' 'mask_rcnn_fpn_resnet50_coco_trained_2019_03_15.npz', 'cv2': True @@ -153,10 +165,13 @@ class MaskRCNNFPNResNet101(MaskRCNNFPNResNet): """ + preset_params = { + 'coco': {'n_fg_class': 80}, + } _base = ResNet101 _models = { 'coco': { - 'param': {'n_fg_class': 80}, + 'param': preset_params['coco'], 'url': 'https://chainercv-models.preferred.jp/' 'mask_rcnn_fpn_resnet101_coco_trained_2019_03_15.npz', 'cv2': True diff --git a/chainercv/links/model/resnet/resnet.py b/chainercv/links/model/resnet/resnet.py index 94d17564f7..0e1b0b9756 100644 --- a/chainercv/links/model/resnet/resnet.py +++ b/chainercv/links/model/resnet/resnet.py @@ -102,12 +102,13 @@ class ResNet(PickableSequentialChain): 152: [3, 8, 36, 3] } + preset_params = {'imagenet': {'n_class': 1000, 'mean': _imagenet_mean}} + _models = { 'fb': { 50: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, - 'overwritable': {'mean'}, + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' 'resnet50_imagenet_trained_2018_11_26.npz', 'cv2': True, @@ -115,8 +116,7 @@ class ResNet(PickableSequentialChain): }, 101: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, - 'overwritable': {'mean'}, + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' 'resnet101_imagenet_trained_2018_11_26.npz', 'cv2': True, @@ -124,8 +124,7 @@ class ResNet(PickableSequentialChain): }, 152: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, - 'overwritable': {'mean'}, + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' 'resnet152_imagenet_trained_2018_11_26.npz', 'cv2': True, @@ -135,27 +134,24 @@ class ResNet(PickableSequentialChain): 'he': { 50: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, - 'overwritable': {'mean'}, + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' - 'resnet50_imagenet_converted_2018_03_07.npz' + 'resnet50_imagenet_converted_2018_03_07.npz', }, }, 101: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, - 'overwritable': {'mean'}, + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' - 'resnet101_imagenet_converted_2018_03_07.npz' + 'resnet101_imagenet_converted_2018_03_07.npz', }, }, 152: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, - 'overwritable': {'mean'}, + 'param': preset_params['imagenet'], 'url': 'https://chainercv-models.preferred.jp/' - 'resnet152_imagenet_converted_2018_03_07.npz' - }, + 'resnet152_imagenet_converted_2018_03_07.npz', + } } } } @@ -164,6 +160,9 @@ def __init__(self, n_layer, n_class=None, pretrained_model=None, mean=None, initialW=None, fc_kwargs={}, arch='fb'): + param, path = utils.prepare_model_param( + locals(), self._models[arch][n_layer]) + if arch == 'fb': stride_first = False conv1_no_bias = True @@ -175,10 +174,6 @@ def __init__(self, n_layer, raise ValueError('arch is expected to be one of [\'he\', \'fb\']') blocks = self._blocks[n_layer] - param, path = utils.prepare_pretrained_model( - {'n_class': n_class, 'mean': mean}, - pretrained_model, self._models[arch][n_layer], - {'n_class': 1000, 'mean': _imagenet_mean}) self.mean = param['mean'] if initialW is None: diff --git a/chainercv/links/model/segnet/segnet_basic.py b/chainercv/links/model/segnet/segnet_basic.py index 51293f6c2c..9e7af233be 100644 --- a/chainercv/links/model/segnet/segnet_basic.py +++ b/chainercv/links/model/segnet/segnet_basic.py @@ -48,22 +48,25 @@ class SegNetBasic(chainer.Chain): """ + preset_params = { + 'camvid': { + 'n_class': 11, + 'initialW': chainer.initializers.HeNormal(), + }, + } + _models = { 'camvid': { - 'param': {'n_class': 11}, + 'param': preset_params['camvid'], 'url': 'https://chainercv-models.preferred.jp/' 'segnet_camvid_trained_2018_12_05.npz' } } def __init__(self, n_class=None, pretrained_model=None, initialW=None): - param, path = utils.prepare_pretrained_model( - {'n_class': n_class}, pretrained_model, self._models) + param, path = utils.prepare_model_param(locals(), self._models) self.n_class = param['n_class'] - if initialW is None: - initialW = chainer.initializers.HeNormal() - super(SegNetBasic, self).__init__() with self.init_scope(): self.conv1 = L.Convolution2D( diff --git a/chainercv/links/model/senet/se_resnet.py b/chainercv/links/model/senet/se_resnet.py index 2b6aca7c44..ec3c63b2dc 100644 --- a/chainercv/links/model/senet/se_resnet.py +++ b/chainercv/links/model/senet/se_resnet.py @@ -74,10 +74,12 @@ class SEResNet(PickableSequentialChain): 152: [3, 8, 36, 3] } + preset_params = {'imagenet': {'n_class': 1000, 'mean': _imagenet_mean}} + _models = { 50: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, + 'param': preset_params['imagenet'], 'overwritable': {'mean'}, 'url': 'https://chainercv-models.preferred.jp/' 'se_resnet50_imagenet_converted_2018_06_25.npz' @@ -85,7 +87,7 @@ class SEResNet(PickableSequentialChain): }, 101: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, + 'param': preset_params['imagenet'], 'overwritable': {'mean'}, 'url': 'https://chainercv-models.preferred.jp/' 'se_resnet101_imagenet_converted_2018_06_25.npz' @@ -93,7 +95,7 @@ class SEResNet(PickableSequentialChain): }, 152: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, + 'param': preset_params['imagenet'], 'overwritable': {'mean'}, 'url': 'https://chainercv-models.preferred.jp/' 'se_resnet152_imagenet_converted_2018_06_25.npz' @@ -107,10 +109,8 @@ def __init__(self, n_layer, mean=None, initialW=None, fc_kwargs={}): blocks = self._blocks[n_layer] - param, path = utils.prepare_pretrained_model( - {'n_class': n_class, 'mean': mean}, - pretrained_model, self._models[n_layer], - {'n_class': 1000, 'mean': _imagenet_mean}) + param, path = utils.prepare_model_param( + locals(), self._models[n_layer]) self.mean = param['mean'] if initialW is None: diff --git a/chainercv/links/model/senet/se_resnext.py b/chainercv/links/model/senet/se_resnext.py index dbc34e8bf8..c842d2ff3c 100644 --- a/chainercv/links/model/senet/se_resnext.py +++ b/chainercv/links/model/senet/se_resnext.py @@ -78,10 +78,12 @@ class SEResNeXt(PickableSequentialChain): 101: [3, 4, 23, 3], } + preset_params = {'imagenet': {'n_class': 1000, 'mean': _imagenet_mean}} + _models = { 50: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, + 'param': preset_params['imagenet'], 'overwritable': {'mean'}, 'url': 'https://chainercv-models.preferred.jp/' 'se_resnext50_imagenet_converted_2018_06_28.npz' @@ -89,7 +91,7 @@ class SEResNeXt(PickableSequentialChain): }, 101: { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, + 'param': preset_params['imagenet'], 'overwritable': {'mean'}, 'url': 'https://chainercv-models.preferred.jp/' 'se_resnext101_imagenet_converted_2018_06_28.npz' @@ -103,10 +105,8 @@ def __init__(self, n_layer, mean=None, initialW=None, fc_kwargs={}): blocks = self._blocks[n_layer] - param, path = utils.prepare_pretrained_model( - {'n_class': n_class, 'mean': mean}, - pretrained_model, self._models[n_layer], - {'n_class': 1000, 'mean': _imagenet_mean}) + param, path = utils.prepare_model_param( + locals(), self._models[n_layer]) self.mean = param['mean'] if initialW is None: diff --git a/chainercv/links/model/ssd/ssd_vgg16.py b/chainercv/links/model/ssd/ssd_vgg16.py index a68a18981a..bf29c44a24 100644 --- a/chainercv/links/model/ssd/ssd_vgg16.py +++ b/chainercv/links/model/ssd/ssd_vgg16.py @@ -245,14 +245,21 @@ class SSD300(SSD): """ + preset_params = { + 'voc': { + 'n_fg_class': 20, + }, + } + _models = { 'voc0712': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'ssd300_voc0712_converted_2017_06_06.npz', 'cv2': True }, 'imagenet': { + 'param': {}, 'url': 'https://chainercv-models.preferred.jp/' 'ssd_vgg16_imagenet_converted_2017_06_09.npz', 'cv2': True @@ -260,11 +267,11 @@ class SSD300(SSD): } def __init__(self, n_fg_class=None, pretrained_model=None): - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) + param, path = utils.prepare_model_param(locals(), self._models) super(SSD300, self).__init__( - extractor=VGG16Extractor300(), + extractor=VGG16Extractor300( + **VGG16Extractor300.preset_params['imagenet']), multibox=Multibox( n_class=param['n_fg_class'] + 1, aspect_ratios=((2,), (2, 3), (2, 3), (2, 3), (2,), (2,))), @@ -312,14 +319,21 @@ class SSD512(SSD): """ + preset_params = { + 'voc': { + 'n_fg_class': 20, + }, + } + _models = { 'voc0712': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'ssd512_voc0712_converted_2017_06_06.npz', 'cv2': True }, 'imagenet': { + 'param': {}, 'url': 'https://chainercv-models.preferred.jp/' 'ssd_vgg16_imagenet_converted_2017_06_09.npz', 'cv2': True @@ -327,11 +341,11 @@ class SSD512(SSD): } def __init__(self, n_fg_class=None, pretrained_model=None): - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) + param, path = utils.prepare_model_param(locals(), self._models) super(SSD512, self).__init__( - extractor=VGG16Extractor512(), + extractor=VGG16Extractor512( + **VGG16Extractor512.preset_params['imagenet']), multibox=Multibox( n_class=param['n_fg_class'] + 1, aspect_ratios=( diff --git a/chainercv/links/model/vgg/vgg16.py b/chainercv/links/model/vgg/vgg16.py index 1a49d135af..b2a583b6fe 100644 --- a/chainercv/links/model/vgg/vgg16.py +++ b/chainercv/links/model/vgg/vgg16.py @@ -87,9 +87,15 @@ class VGG16(PickableSequentialChain): """ + preset_params = { + 'imagenet': { + 'n_class': 1000, + 'mean': _imagenet_mean + }, + } _models = { 'imagenet': { - 'param': {'n_class': 1000, 'mean': _imagenet_mean}, + 'param': preset_params['imagenet'], 'overwritable': ('mean',), 'url': 'https://chainercv-models.preferred.jp/' 'vgg16_imagenet_converted_2017_07_18.npz' @@ -99,10 +105,7 @@ class VGG16(PickableSequentialChain): def __init__(self, n_class=None, pretrained_model=None, mean=None, initialW=None, initial_bias=None): - param, path = utils.prepare_pretrained_model( - {'n_class': n_class, 'mean': mean}, - pretrained_model, self._models, - {'n_class': 1000, 'mean': _imagenet_mean}) + param, path = utils.prepare_model_param(locals(), self._models) self.mean = param['mean'] if initialW is None: diff --git a/chainercv/links/model/yolo/yolo_v2.py b/chainercv/links/model/yolo/yolo_v2.py index 6d78e87270..ec37ada403 100644 --- a/chainercv/links/model/yolo/yolo_v2.py +++ b/chainercv/links/model/yolo/yolo_v2.py @@ -45,8 +45,7 @@ class YOLOv2Base(YOLOBase): def __init__(self, n_fg_class=None, pretrained_model=None): super(YOLOv2Base, self).__init__() - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) + param, path = utils.prepare_model_param(locals(), self._models) self.n_fg_class = param['n_fg_class'] self.use_preset('visualize') @@ -232,11 +231,14 @@ class YOLOv2(YOLOv2Base): """ + preset_params = { + 'voc': {'n_fg_class': 20}, + } _extractor = Darknet19Extractor _models = { 'voc0712': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'yolo_v2_voc0712_converted_2018_05_03.npz', 'cv2': True diff --git a/chainercv/links/model/yolo/yolo_v3.py b/chainercv/links/model/yolo/yolo_v3.py index e146fd4d9d..0deba3f30a 100644 --- a/chainercv/links/model/yolo/yolo_v3.py +++ b/chainercv/links/model/yolo/yolo_v3.py @@ -124,10 +124,13 @@ class YOLOv3(YOLOBase): * :obj:`None`: Do not load weights. """ + preset_params = { + 'voc': {'n_fg_class': 20}, + } _models = { 'voc0712': { - 'param': {'n_fg_class': 20}, + 'param': preset_params['voc'], 'url': 'https://chainercv-models.preferred.jp/' 'yolo_v3_voc0712_converted_2018_05_01.npz', 'cv2': True @@ -142,8 +145,7 @@ class YOLOv3(YOLOBase): def __init__(self, n_fg_class=None, pretrained_model=None): super(YOLOv3, self).__init__() - param, path = utils.prepare_pretrained_model( - {'n_fg_class': n_fg_class}, pretrained_model, self._models) + param, path = utils.prepare_model_param(locals(), self._models) self.n_fg_class = param['n_fg_class'] self.use_preset('visualize') diff --git a/chainercv/utils/__init__.py b/chainercv/utils/__init__.py index 4573ec37c6..18c37f4d5c 100644 --- a/chainercv/utils/__init__.py +++ b/chainercv/utils/__init__.py @@ -10,7 +10,7 @@ from chainercv.utils.iterator import apply_to_iterator # NOQA from chainercv.utils.iterator import ProgressHook # NOQA from chainercv.utils.iterator import unzip # NOQA -from chainercv.utils.link import prepare_pretrained_model # NOQA +from chainercv.utils.link import prepare_model_param # NOQA from chainercv.utils.mask.mask_iou import mask_iou # NOQA from chainercv.utils.mask.mask_to_bbox import mask_to_bbox # NOQA from chainercv.utils.mask.scale_mask import scale_mask # NOQA diff --git a/chainercv/utils/link.py b/chainercv/utils/link.py index 729c458fe5..bab61d96bc 100644 --- a/chainercv/utils/link.py +++ b/chainercv/utils/link.py @@ -11,48 +11,23 @@ _cv2_available = False -def prepare_pretrained_model(param, pretrained_model, models, default={}): - """Select parameters based on the existence of pretrained model. +def prepare_model_param(param, models): + """Select parameters and weights of 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`. + param (dict): A dict that contains all arguments. 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. - """ + pretrained_model = param.pop('pretrained_model', None) 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 'param' in model: + param = {k: v if v is not None else model['param'].get(k, None) + for k, v in param.items()} if model.get('cv2', False): if not _cv2_available: @@ -70,16 +45,7 @@ def prepare_pretrained_model(param, pretrained_model, models, default={}): '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)) + path = pretrained_model return param, path diff --git a/docs/source/reference/utils.rst b/docs/source/reference/utils.rst index d90db325ec..dece64b570 100644 --- a/docs/source/reference/utils.rst +++ b/docs/source/reference/utils.rst @@ -71,9 +71,9 @@ unzip Link Utilities -------------- -prepare_pretrained_model -~~~~~~~~~~~~~~~~~~~~~~~~ -.. autofunction:: prepare_pretrained_model +prepare_model_param +~~~~~~~~~~~~~~~~~~~ +.. autofunction:: prepare_model_param Mask Utilities diff --git a/examples/classification/eval_imagenet.py b/examples/classification/eval_imagenet.py index b8bc5d07ab..73858c959b 100644 --- a/examples/classification/eval_imagenet.py +++ b/examples/classification/eval_imagenet.py @@ -1,5 +1,6 @@ import argparse +import copy import numpy as np import chainer @@ -58,14 +59,14 @@ def eval_(out_values, rest_values): pretrained_model = pretrained_models.get(dataset_name, dataset_name) if crop is None: crop = models[model][3] - kwargs = { - 'n_class': len(label_names), - 'pretrained_model': pretrained_model, - } + kwargs = {'pretrained_model': pretrained_model} if model in ['resnet50', 'resnet101', 'resnet152']: if resnet_arch is None: resnet_arch = models[model][4] - kwargs.update({'arch': resnet_arch}) + kwargs['arch'] = resnet_arch + params = copy.deepcopy(cls.preset_params[dataset_name]) + params['n_class'] = len(label_names) + kwargs.update(params) extractor = cls(**kwargs) model = FeaturePredictor( extractor, crop_size=224, scale_size=256, crop=crop) diff --git a/examples/classification/train_imagenet_multi.py b/examples/classification/train_imagenet_multi.py index a5c5eaffa5..e3a720114c 100644 --- a/examples/classification/train_imagenet_multi.py +++ b/examples/classification/train_imagenet_multi.py @@ -1,5 +1,7 @@ from __future__ import division + import argparse +import copy import multiprocessing import numpy as np @@ -113,8 +115,11 @@ def main(): label_names = directory_parsing_label_names(args.train) model_cfg = model_cfgs[args.model] - extractor = model_cfg['class']( - n_class=len(label_names), **model_cfg['kwargs']) + params = copy.deepcopy(model_cfg['class'].preset_params['imagenet']) + params['n_class'] = len(label_names) + params.update(model_cfg['kwargs']) + + extractor = model_cfg['class'](**params) extractor.pick = model_cfg['score_layer_name'] model = Classifier(extractor) # Following https://arxiv.org/pdf/1706.02677.pdf, diff --git a/examples/deeplab/demo.py b/examples/deeplab/demo.py index 59eec64340..6a1c1c7906 100644 --- a/examples/deeplab/demo.py +++ b/examples/deeplab/demo.py @@ -1,5 +1,5 @@ import argparse - +import copy import matplotlib.pyplot as plt import chainer @@ -43,9 +43,10 @@ def main(): label_names = voc_semantic_segmentation_label_names colors = voc_semantic_segmentation_label_colors + params = copy.deepcopy(DeepLabV3plusXception65.preset_params[args.dataset]) + params['min_input_size'] = args.min_input_size model = DeepLabV3plusXception65( - pretrained_model=args.pretrained_model, - min_input_size=args.min_input_size) + pretrained_model=args.pretrained_model, **params) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/deeplab/tf2npz.py b/examples/deeplab/tf2npz.py index c5c868d479..7b578f9233 100644 --- a/examples/deeplab/tf2npz.py +++ b/examples/deeplab/tf2npz.py @@ -39,11 +39,17 @@ def load_param(param, weight, transpose=None): def get_model(name, task): - n_class = _n_class[task] - model = _model_class[name](n_class, min_input_size=(513, 513), - scales=(1.0,), flip=False, - extractor_kwargs={}, - aspp_kwargs={}, decoder_kwargs={}) + params = _model_class[name].preset_params[task] + params.update({ + 'n_class': _n_class[task], + 'input_size': (513, 513), + 'scales': (1.0, ), + 'flip': False, + 'extractor_kwargs': {}, + 'aspp_kwargs': {}, + 'decoder_kwargs': {}, + }) + model = _model_class[name](**params) return model diff --git a/examples/detection/eval_detection.py b/examples/detection/eval_detection.py index 9c2cca5253..baf22fbbb1 100644 --- a/examples/detection/eval_detection.py +++ b/examples/detection/eval_detection.py @@ -1,4 +1,5 @@ import argparse +import copy import chainer from chainer import iterators @@ -81,7 +82,9 @@ def eval_(out_values, rest_values): cls, pretrained_models, default_batchsize = models[model] if pretrained_model is None: pretrained_model = pretrained_models.get(dataset_name, dataset_name) - model = cls(n_fg_class=len(label_names), pretrained_model=pretrained_model) + params = copy.deepcopy(cls.preset_params[dataset_name]) + params['n_fg_class'] = len(label_names) + model = cls(pretrained_model=pretrained_model, **params) if batchsize is None: batchsize = default_batchsize diff --git a/examples/faster_rcnn/demo.py b/examples/faster_rcnn/demo.py index 10bc79c45b..f773d7a96c 100644 --- a/examples/faster_rcnn/demo.py +++ b/examples/faster_rcnn/demo.py @@ -24,8 +24,8 @@ def main(): label_names = voc_bbox_label_names model = FasterRCNNVGG16( - n_fg_class=len(label_names), - pretrained_model=args.pretrained_model) + pretrained_model=args.pretrained_model, + **FasterRCNNVGG16.preset_params[args.dataset]) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/faster_rcnn/train.py b/examples/faster_rcnn/train.py index edb3e1af65..e230a3efc3 100644 --- a/examples/faster_rcnn/train.py +++ b/examples/faster_rcnn/train.py @@ -72,8 +72,8 @@ def main(): VOCBboxDataset(year='2012', split='trainval')) test_data = VOCBboxDataset(split='test', year='2007', use_difficult=True, return_difficult=True) - faster_rcnn = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), - pretrained_model='imagenet') + faster_rcnn = FasterRCNNVGG16( + pretrained_model='imagenet', **FasterRCNNVGG16.preset_params['voc']) faster_rcnn.use_preset('evaluate') model = FasterRCNNTrainChain(faster_rcnn) if args.gpu >= 0: diff --git a/examples/fcis/demo.py b/examples/fcis/demo.py index d0c308ea61..94d018f62f 100755 --- a/examples/fcis/demo.py +++ b/examples/fcis/demo.py @@ -26,20 +26,13 @@ def main(): if args.pretrained_model is None: args.pretrained_model = 'sbd' label_names = sbd_instance_segmentation_label_names - model = FCISResNet101( - n_fg_class=len(label_names), - pretrained_model=args.pretrained_model) elif args.dataset == 'coco': if args.pretrained_model is None: args.pretrained_model = 'coco' label_names = coco_instance_segmentation_label_names - proposal_creator_params = FCISResNet101.proposal_creator_params - proposal_creator_params['min_size'] = 2 - model = FCISResNet101( - n_fg_class=len(label_names), - anchor_scales=(4, 8, 16, 32), - pretrained_model=args.pretrained_model, - proposal_creator_params=proposal_creator_params) + model = FCISResNet101( + pretrained_model=args.pretrained_model, + **FCISResNet101.preset_params[args.dataset]) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/fcis/mxnet2npz.py b/examples/fcis/mxnet2npz.py index ebedf2fa0c..63aa3203c7 100755 --- a/examples/fcis/mxnet2npz.py +++ b/examples/fcis/mxnet2npz.py @@ -18,23 +18,7 @@ def main(): '--out', '-o', type=str, default=None) args = parser.parse_args() - if args.dataset == 'sbd': - model = FCISResNet101( - n_fg_class=20, - pretrained_model=None) - elif args.dataset == 'coco': - model = FCISResNet101( - n_fg_class=80, - pretrained_model=None, - anchor_scales=[4, 8, 16, 32], - proposal_creator_params={ - 'nms_thresh': 0.7, - 'n_train_pre_nms': 6000, - 'n_train_post_nms': 300, - 'n_test_pre_nms': 6000, - 'n_test_post_nms': 300, - 'force_cpu_nms': False, - 'min_size': 2}) + model = FCISResNet101(**FCISResNet101.preset_params[args.dataset]) params = mx.nd.load(args.mxnet_param_file) print('mxnet param is loaded: {}'.format(args.mxnet_param_file)) print('start conversion') diff --git a/examples/fcis/train_coco_multi.py b/examples/fcis/train_coco_multi.py index 3a763590a2..2ed2516a4d 100755 --- a/examples/fcis/train_coco_multi.py +++ b/examples/fcis/train_coco_multi.py @@ -63,13 +63,8 @@ def main(): np.random.seed(args.seed) # model - proposal_creator_params = FCISResNet101.proposal_creator_params - proposal_creator_params['min_size'] = 2 fcis = FCISResNet101( - n_fg_class=len(coco_instance_segmentation_label_names), - anchor_scales=(4, 8, 16, 32), - pretrained_model='imagenet', iter2=False, - proposal_creator_params=proposal_creator_params) + pretrained_model='imagenet', **FCISResNet101.preset_params['coco']) fcis.use_preset('coco_evaluate') proposal_target_creator = ProposalTargetCreator() proposal_target_creator.neg_iou_thresh_lo = 0.0 diff --git a/examples/fcis/train_sbd.py b/examples/fcis/train_sbd.py index 8278dfe588..8b1bd283e7 100755 --- a/examples/fcis/train_sbd.py +++ b/examples/fcis/train_sbd.py @@ -88,8 +88,7 @@ def main(): # model fcis = FCISResNet101( - n_fg_class=len(sbd_instance_segmentation_label_names), - pretrained_model='imagenet', iter2=False) + pretrained_model='imagenet', **FCISResNet101.preset_params['sbd']) fcis.use_preset('evaluate') model = FCISTrainChain(fcis) diff --git a/examples/fcis/train_sbd_multi.py b/examples/fcis/train_sbd_multi.py index 36d5104b8c..59b84b111a 100755 --- a/examples/fcis/train_sbd_multi.py +++ b/examples/fcis/train_sbd_multi.py @@ -59,8 +59,7 @@ def main(): # model fcis = FCISResNet101( - n_fg_class=len(sbd_instance_segmentation_label_names), - pretrained_model='imagenet', iter2=False) + pretrained_model='imagenet', **FCISResNet101.preset_params['sbd']) fcis.use_preset('evaluate') model = FCISTrainChain(fcis) chainer.cuda.get_device_from_id(device).use() diff --git a/examples/fpn/demo.py b/examples/fpn/demo.py index 0e2e0e0ef4..99b6bd487b 100644 --- a/examples/fpn/demo.py +++ b/examples/fpn/demo.py @@ -49,8 +49,8 @@ def main(): elif mode == 'instance_segmentation': label_names = coco_instance_segmentation_label_names - model = cls(n_fg_class=len(label_names), - pretrained_model=args.pretrained_model) + model = cls(pretrained_model=args.pretrained_model, + **cls.preset_params[args.dataset]) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/fpn/train_multi.py b/examples/fpn/train_multi.py index e185bc3f9c..f186d574a3 100644 --- a/examples/fpn/train_multi.py +++ b/examples/fpn/train_multi.py @@ -20,12 +20,10 @@ from chainercv.links.model.fpn.misc import scale_img from chainercv import transforms -from chainercv.datasets import coco_instance_segmentation_label_names from chainercv.datasets import COCOInstanceSegmentationDataset from chainercv.links import MaskRCNNFPNResNet101 from chainercv.links import MaskRCNNFPNResNet50 -from chainercv.datasets import coco_bbox_label_names from chainercv.datasets import COCOBboxDataset from chainercv.links import FasterRCNNFPNResNet101 from chainercv.links import FasterRCNNFPNResNet50 @@ -199,23 +197,23 @@ def main(): if args.model == 'faster_rcnn_fpn_resnet50': mode = 'bbox' model = FasterRCNNFPNResNet50( - n_fg_class=len(coco_bbox_label_names), - pretrained_model='imagenet') + pretrained_model=args.pretrained_model, + **FasterRCNNFPNResNet50.preset_params['coco']) elif args.model == 'faster_rcnn_fpn_resnet101': mode = 'bbox' model = FasterRCNNFPNResNet101( - n_fg_class=len(coco_bbox_label_names), - pretrained_model='imagenet') + pretrained_model=args.pretrained_model, + **FasterRCNNFPNResNet101.preset_params['coco']) elif args.model == 'mask_rcnn_fpn_resnet50': mode = 'instance_segmentation' model = MaskRCNNFPNResNet50( - n_fg_class=len(coco_instance_segmentation_label_names), - pretrained_model='imagenet') + pretrained_model=args.pretrained_model, + **MaskRCNNFPNResNet50.preset_params['coco']) elif args.model == 'mask_rcnn_fpn_resnet101': mode = 'instance_segmentation' model = MaskRCNNFPNResNet101( - n_fg_class=len(coco_instance_segmentation_label_names), - pretrained_model='imagenet') + pretrained_model=args.pretrained_model, + **MaskRCNNFPNResNet101.preset_params['coco']) model.use_preset('evaluate') train_chain = TrainChain(model) diff --git a/examples/instance_segmentation/eval_instance_segmentation.py b/examples/instance_segmentation/eval_instance_segmentation.py index a4ebafade4..1c21c03df1 100755 --- a/examples/instance_segmentation/eval_instance_segmentation.py +++ b/examples/instance_segmentation/eval_instance_segmentation.py @@ -1,4 +1,5 @@ import argparse +import copy import chainer from chainer import iterators @@ -37,8 +38,9 @@ def setup(dataset, model_name, pretrained_model, batchsize): dataset = SBDInstanceSegmentationDataset(split='val') label_names = sbd_instance_segmentation_label_names - model = cls( - n_fg_class=len(label_names), pretrained_model=pretrained_model) + params = copy.deepcopy(cls.preset_params[dataset_name]) + params['n_fg_class'] = len(label_names) + model = cls(pretrained_model=pretrained_model, **params) model.use_preset('evaluate') def eval_(out_values, rest_values): @@ -62,18 +64,13 @@ def eval_(out_values, rest_values): split='minival', year='2014', use_crowded=True, return_crowded=True, return_area=True) label_names = coco_instance_segmentation_label_names + + params = copy.deepcopy(cls.preset_params[dataset_name]) + params['n_fg_class'] = len(label_names) + model = cls(pretrained_model=pretrained_model, **params) if model_name == 'fcis_resnet101': - proposal_creator_params = cls.proposal_creator_params - proposal_creator_params['min_size'] = 2 - model = cls( - n_fg_class=len(label_names), - anchor_scales=(4, 8, 16, 32), - pretrained_model=pretrained_model, - proposal_creator_params=proposal_creator_params) model.use_preset('coco_evaluate') else: - model = cls( - n_fg_class=len(label_names), pretrained_model=pretrained_model) model.use_preset('evaluate') def eval_(out_values, rest_values): diff --git a/examples/pspnet/caffe2npz.py b/examples/pspnet/caffe2npz.py index 2c255734c1..2f93699742 100644 --- a/examples/pspnet/caffe2npz.py +++ b/examples/pspnet/caffe2npz.py @@ -130,11 +130,9 @@ def main(): args = parser.parse_args() proto_path = 'weights/pspnet101_cityscapes_713.prototxt' - n_class = 19 - input_size = (713, 713) - model = PSPNetResNet101( - n_class, None, input_size) + model = PSPNetResNet101(**PSPNetResNet101.preset_params['cityscapes']) + input_size = PSPNetResNet101.preset_params['cityscapes']['input_size'] model(np.random.uniform(size=(1, 3) + input_size).astype(np.float32)) caffe_param = caffe_pb2.NetParameter() diff --git a/examples/pspnet/demo.py b/examples/pspnet/demo.py index e5ac8fe35a..0b5699caf8 100644 --- a/examples/pspnet/demo.py +++ b/examples/pspnet/demo.py @@ -1,8 +1,9 @@ import argparse - +import copy import matplotlib.pyplot as plt import chainer + from chainercv.datasets import ade20k_semantic_segmentation_label_colors from chainercv.datasets import ade20k_semantic_segmentation_label_names from chainercv.datasets import cityscapes_semantic_segmentation_label_colors @@ -35,9 +36,10 @@ def main(): colors = ade20k_semantic_segmentation_label_colors input_size = (args.input_size, args.input_size) + params = copy.deepcopy(PSPNetResNet101.preset_params[args.dataset]) + params['input_size'] = input_size model = PSPNetResNet101( - n_class=len(label_names), - pretrained_model=args.pretrained_model, input_size=input_size) + pretrained_model=args.pretrained_model, **params) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/pspnet/train_multi.py b/examples/pspnet/train_multi.py index e711988ff3..f574542a4d 100644 --- a/examples/pspnet/train_multi.py +++ b/examples/pspnet/train_multi.py @@ -177,18 +177,6 @@ def main(): parser.add_argument('--communicator', default='pure_nccl') args = parser.parse_args() - dataset_cfgs = { - 'ade20k': { - 'input_size': (473, 473), - 'label_names': ade20k_semantic_segmentation_label_names, - 'iteration': 150000}, - 'cityscapes': { - 'input_size': (713, 713), - 'label_names': cityscapes_semantic_segmentation_label_names, - 'iteration': 90000} - } - dataset_cfg = dataset_cfgs[args.dataset] - # https://docs.chainer.org/en/stable/chainermn/tutorial/tips_faqs.html#using-multiprocessiterator if hasattr(multiprocessing, 'set_start_method'): multiprocessing.set_start_method('forkserver') @@ -199,26 +187,20 @@ def main(): comm = chainermn.create_communicator(args.communicator) device = comm.intra_rank - n_class = len(dataset_cfg['label_names']) if args.model == 'pspnet_resnet101': model = PSPNetResNet101( - n_class, pretrained_model='imagenet', - input_size=dataset_cfg['input_size']) + pretrained_model='imagenet', + **PSPNetResNet101.preset_params[args.dataset]) elif args.model == 'pspnet_resnet50': model = PSPNetResNet50( - n_class, pretrained_model='imagenet', - input_size=dataset_cfg['input_size']) + pretrained_model='imagenet', + **PSPNetResNet101.preset_params[args.dataset]) train_chain = create_mnbn_model(TrainChain(model), comm) model = train_chain.model if device >= 0: chainer.cuda.get_device_from_id(device).use() train_chain.to_gpu() - if args.iteration is None: - n_iter = dataset_cfg['iteration'] - else: - n_iter = args.iteration - if args.dataset == 'ade20k': train = ADE20KSemanticSegmentationDataset( data_dir=args.data_dir, split='train') @@ -226,6 +208,7 @@ def main(): val = ADE20KSemanticSegmentationDataset( data_dir=args.data_dir, split='val') label_names = ade20k_semantic_segmentation_label_names + n_iter = 150000 if args.iteration is None else args.iteration elif args.dataset == 'cityscapes': train = CityscapesSemanticSegmentationDataset( args.data_dir, @@ -235,10 +218,11 @@ def main(): args.data_dir, label_resolution='fine', split='val') label_names = cityscapes_semantic_segmentation_label_names + n_iter = 90000 if args.iteration is None else args.iteration train = TransformDataset( train, ('img', 'label'), - Transform(model.mean, dataset_cfg['input_size'])) + Transform(model.mean, model.input_size)) if comm.rank == 0: indices = np.arange(len(train)) diff --git a/examples/resnet/caffe2npz.py b/examples/resnet/caffe2npz.py index 883b879d46..79d1220b57 100644 --- a/examples/resnet/caffe2npz.py +++ b/examples/resnet/caffe2npz.py @@ -108,15 +108,18 @@ def main(): caffemodel = CaffeFunction(args.caffemodel) if args.model_name == 'resnet50': - model = ResNet50(pretrained_model=None, n_class=1000, arch='he') + model = ResNet50(pretrained_model=None, arch='he', + **ResNet50.preset_params['imagenet']) 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, arch='he') + model = ResNet101(pretrained_model=None, arch='he', + **ResNet101.preset_params['imagenet']) 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, arch='he') + model = ResNet152(pretrained_model=None, arch='he', + **ResNet152.preset_params['imagenet']) model(np.zeros((1, 3, 224, 224), dtype=np.float32)) _transfer_resnet152(caffemodel, model) diff --git a/examples/segnet/demo.py b/examples/segnet/demo.py index 2586c0181b..51ecd3c795 100644 --- a/examples/segnet/demo.py +++ b/examples/segnet/demo.py @@ -28,8 +28,8 @@ def main(): colors = camvid_label_colors model = SegNetBasic( - n_class=len(label_names), - pretrained_model=args.pretrained_model) + pretrained_model=args.pretrained_model, + **SegNetBasic.preset_params[args.dataset]) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/segnet/train.py b/examples/segnet/train.py index 518f41d531..6da21ebd16 100644 --- a/examples/segnet/train.py +++ b/examples/segnet/train.py @@ -84,7 +84,8 @@ def main(): # Model class_weight = np.load(args.class_weight) - model = SegNetBasic(n_class=len(camvid_label_names)) + model = SegNetBasic( + pretrained_model=None, **SegNetBasic.preset_params['camvid']) model = PixelwiseSoftmaxClassifier( model, class_weight=class_weight) if args.gpu >= 0: diff --git a/examples/semantic_segmentation/eval_semantic_segmentation.py b/examples/semantic_segmentation/eval_semantic_segmentation.py index 04e11f2376..45c2634daa 100644 --- a/examples/semantic_segmentation/eval_semantic_segmentation.py +++ b/examples/semantic_segmentation/eval_semantic_segmentation.py @@ -1,4 +1,5 @@ import argparse +import copy import chainer from chainer import iterators @@ -63,19 +64,17 @@ def eval_(out_values, rest_values): cls, pretrained_models, default_batchsize = models[model] if pretrained_model is None: pretrained_model = pretrained_models.get(dataset_name, dataset_name) - if input_size is None: - input_size = None - else: - input_size = (input_size, input_size) - kwargs = { - 'n_class': len(label_names), 'pretrained_model': pretrained_model, } - if model in ['pspnet_resnet50', 'pspnet_resnet101']: - kwargs.update({'input_size': input_size}) - elif model == 'deeplab_v3plus_xception65': - kwargs.update({'min_input_size': input_size}) + params = copy.deepcopy(cls.preset_params[dataset_name]) + params['n_class'] = len(label_names) + if input_size is not None: + if model in ['pspnet_resnet50', 'pspnet_resnet101']: + params['input_size'] = (input_size, input_size) + elif model == 'deeplab_v3plus_xception65': + params['min_input_size'] = (input_size, input_size) + kwargs.update(params) model = cls(**kwargs) if batchsize is None: diff --git a/examples/senet/caffe2npz.py b/examples/senet/caffe2npz.py index b266ff16b6..450d6b364e 100644 --- a/examples/senet/caffe2npz.py +++ b/examples/senet/caffe2npz.py @@ -154,23 +154,28 @@ def main(): caffemodel = CaffeFunction(args.caffemodel) if args.model_name == 'se-resnet50': - model = SEResNet50(pretrained_model=None, n_class=1000) + model = SEResNet50(pretrained_model=None, + **SEResNet50.preset_params['imagenet']) model(np.zeros((1, 3, 224, 224), dtype=np.float32)) _transfer_resnet50(caffemodel, model, _load_class_indices()) elif args.model_name == 'se-resnet101': - model = SEResNet101(pretrained_model=None, n_class=1000) + model = SEResNet101(pretrained_model=None, + **SEResNet101.preset_params['imagenet']) model(np.zeros((1, 3, 224, 224), dtype=np.float32)) _transfer_resnet101(caffemodel, model, _load_class_indices()) elif args.model_name == 'se-resnet152': - model = SEResNet152(pretrained_model=None, n_class=1000) + model = SEResNet152(pretrained_model=None, + **SEResNet152.preset_params['imagenet']) model(np.zeros((1, 3, 224, 224), dtype=np.float32)) _transfer_resnet152(caffemodel, model, _load_class_indices()) elif args.model_name == 'se-resnext50': - model = SEResNeXt50(pretrained_model=None, n_class=1000) + model = SEResNeXt50(pretrained_model=None, + **SEResNeXt50.preset_params['imagenet']) model(np.zeros((1, 3, 224, 224), dtype=np.float32)) _transfer_resnet50(caffemodel, model, _load_class_indices()) elif args.model_name == 'se-resnext101': - model = SEResNeXt101(pretrained_model=None, n_class=1000) + model = SEResNeXt101(pretrained_model=None, + **SEResNeXt101.preset_params['imagenet']) model(np.zeros((1, 3, 224, 224), dtype=np.float32)) _transfer_resnet101(caffemodel, model, _load_class_indices()) diff --git a/examples/ssd/demo.py b/examples/ssd/demo.py index f0e04dd627..98cd8b753b 100644 --- a/examples/ssd/demo.py +++ b/examples/ssd/demo.py @@ -31,8 +31,8 @@ def main(): args.pretrained_model = 'voc0712' label_names = voc_bbox_label_names - model = cls(n_fg_class=len(label_names), - pretrained_model=args.pretrained_model) + model = cls(pretrained_model=args.pretrained_model, + **cls.preset_params[args.dataset]) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/examples/ssd/train.py b/examples/ssd/train.py index f5b40fb616..d412942de7 100644 --- a/examples/ssd/train.py +++ b/examples/ssd/train.py @@ -120,13 +120,11 @@ def main(): args = parser.parse_args() if args.model == 'ssd300': - model = SSD300( - n_fg_class=len(voc_bbox_label_names), - pretrained_model='imagenet') + cls = SSD300 elif args.model == 'ssd512': - model = SSD512( - n_fg_class=len(voc_bbox_label_names), - pretrained_model='imagenet') + cls = SSD512 + model = cls(pretrained_model='imagenet', + **cls.preset_params['voc']) model.use_preset('evaluate') train_chain = MultiboxTrainChain(model) diff --git a/examples/ssd/train_multi.py b/examples/ssd/train_multi.py index 61f51d9ec5..a1cf296a35 100644 --- a/examples/ssd/train_multi.py +++ b/examples/ssd/train_multi.py @@ -75,13 +75,11 @@ def main(): device = comm.intra_rank if args.model == 'ssd300': - model = SSD300( - n_fg_class=len(voc_bbox_label_names), - pretrained_model='imagenet') + cls = SSD300 elif args.model == 'ssd512': - model = SSD512( - n_fg_class=len(voc_bbox_label_names), - pretrained_model='imagenet') + cls = SSD512 + model = cls(pretrained_model='imagenet', + **cls.preset_params['voc']) model.use_preset('evaluate') train_chain = MultiboxTrainChain(model) diff --git a/examples/yolo/demo.py b/examples/yolo/demo.py index f06e043f92..593d827049 100644 --- a/examples/yolo/demo.py +++ b/examples/yolo/demo.py @@ -33,10 +33,10 @@ def main(): if args.dataset == 'voc': if args.pretrained_model is None: args.pretrained_model = 'voc0712' - label_names = voc_bbox_label_names + label_names = voc_bbox_label_name - model = cls(n_fg_class=len(label_names), - pretrained_model=args.pretrained_model) + model = cls(pretrained_model=args.pretrained_model, + **cls.preset_params[args.dataset]) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() diff --git a/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis.py b/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis.py index 02a7cd4c6a..f076585d86 100644 --- a/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis.py +++ b/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis.py @@ -37,7 +37,8 @@ def __init__(self, n_class, roi_size): self.n_class = n_class self.roi_size = roi_size - def forward(self, x, rois, roi_indices, img_size, gt_roi_label=None): + def forward(self, x, rois, roi_indices, img_size, + gt_roi_label=None, iter2=True): n_roi = len(rois) ag_locs = chainer.Variable( _random_array(self.xp, (n_roi, 2, 4))) diff --git a/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis_resnet101.py b/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis_resnet101.py index 2ab40ba9d4..243ccd3476 100644 --- a/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis_resnet101.py +++ b/tests/experimental_tests/links_tests/model_tests/fcis_tests/test_fcis_resnet101.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -15,8 +16,8 @@ @testing.parameterize( - {'train': False, 'iter2': True}, - {'train': True, 'iter2': False} + {'train': False}, + {'train': True} ) class TestFCISResNet101(unittest.TestCase): @@ -28,14 +29,12 @@ class TestFCISResNet101(unittest.TestCase): n_test_post_nms = 8 def setUp(self): - proposal_creator_params = { - 'n_train_post_nms': self.n_train_post_nms, - 'n_test_post_nms': self.n_test_post_nms, - } - self.link = FCISResNet101( - self.n_fg_class, pretrained_model=None, - iter2=self.iter2, - proposal_creator_params=proposal_creator_params) + params = copy.deepcopy(FCISResNet101.preset_params['sbd']) + params['n_fg_class'] = self.n_fg_class + proposal_creator_params = params['proposal_creator_params'] + proposal_creator_params['n_train_post_nms'] = self.n_train_post_nms + proposal_creator_params['n_test_post_nms'] = self.n_test_post_nms + self.link = FCISResNet101(pretrained_model=None, **params) def check_call(self): xp = self.link.xp @@ -52,7 +51,7 @@ def check_call(self): n_roi = roi_ag_seg_scores.shape[0] if self.train: - self.assertGreaterEqual(self.B * self.n_train_post_nms, n_roi) + self.assertGreaterEqual(self.B * self.n_train_post_nms * 2, n_roi) else: self.assertGreaterEqual(self.B * self.n_test_post_nms * 2, n_roi) @@ -96,14 +95,13 @@ class TestFCISResNet101Loss(unittest.TestCase): n_test_post_nms = 8 def setUp(self): - proposal_creator_params = { - 'n_train_post_nms': self.n_train_post_nms, - 'n_test_post_nms': self.n_test_post_nms, - } + params = copy.deepcopy(FCISResNet101.preset_params['sbd']) + params['n_fg_class'] = self.n_fg_class + proposal_creator_params = params['proposal_creator_params'] + proposal_creator_params['n_train_post_nms'] = self.n_train_post_nms + proposal_creator_params['n_test_post_nms'] = self.n_test_post_nms self.model = FCISTrainChain( - FCISResNet101( - self.n_fg_class, pretrained_model=None, iter2=False, - proposal_creator_params=proposal_creator_params)) + FCISResNet101(pretrained_model=None, **params)) self.masks = np.random.randint( 0, 2, size=(1, self.n_bbox, 600, 800)).astype(np.bool) @@ -130,7 +128,7 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ - 'n_fg_class': [None, 10, 20, 80], + 'n_fg_class': [10, 20, 80], 'anchor_scales': [(8, 16, 32), (4, 8, 16, 32)], 'pretrained_model': ['sbd', 'sbd_converted', 'coco', 'coco_converted'], })) @@ -138,24 +136,25 @@ class TestFCISResNet101Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'anchor_scales': self.anchor_scales, - 'pretrained_model': self.pretrained_model, - } + if self.pretrained_model.startswith('sbd'): + params = copy.deepcopy(FCISResNet101.preset_params['sbd']) + elif self.pretrained_model.startswith('coco'): + params = copy.deepcopy(FCISResNet101.preset_params['coco']) + params['n_fg_class'] = self.n_fg_class + params['anchor_scales'] = self.anchor_scales if self.pretrained_model.startswith('sbd'): - valid = self.n_fg_class in [None, 20] + valid = self.n_fg_class == 20 valid = valid and self.anchor_scales == (8, 16, 32) elif self.pretrained_model.startswith('coco'): - valid = self.n_fg_class in [None, 80] + valid = self.n_fg_class == 80 valid = valid and self.anchor_scales == (4, 8, 16, 32) if valid: - FCISResNet101(**kwargs) + FCISResNet101(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - FCISResNet101(**kwargs) + FCISResNet101(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/experimental_tests/links_tests/model_tests/pspnet_tests/test_pspnet.py b/tests/experimental_tests/links_tests/model_tests/pspnet_tests/test_pspnet.py index 5e184b2fe6..e0d803e5fc 100644 --- a/tests/experimental_tests/links_tests/model_tests/pspnet_tests/test_pspnet.py +++ b/tests/experimental_tests/links_tests/model_tests/pspnet_tests/test_pspnet.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -19,8 +20,10 @@ class TestPSPNetResNet(unittest.TestCase): def setUp(self): self.n_class = 10 self.input_size = (120, 160) - self.link = self.model( - n_class=self.n_class, input_size=self.input_size) + params = copy.deepcopy(self.model.preset_params['cityscapes']) + params['n_class'] = self.n_class + params['input_size'] = self.input_size + self.link = self.model(**params) def check_call(self): xp = self.link.xp @@ -58,29 +61,27 @@ def test_predict_gpu(self): @testing.parameterize(*testing.product({ 'model': [PSPNetResNet50, PSPNetResNet101], 'pretrained_model': ['cityscapes', 'ade20k', 'imagenet'], - 'n_class': [None, 19, 150], + 'n_class': [19, 150], })) class TestPSPNetResNetPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(self.model.preset_params['cityscapes']) + params['n_class'] = self.n_class if self.pretrained_model == 'cityscapes': - valid = self.n_class in {None, 19} + valid = self.n_class == 19 elif self.pretrained_model == 'ade20k': - valid = self.n_class in {None, 150} + valid = self.n_class == 150 elif self.pretrained_model == 'imagenet': - valid = self.n_class is not None + valid = True if valid: - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/experimental_tests/links_tests/model_tests/yolo_tests/test_yolo_v2_tiny.py b/tests/experimental_tests/links_tests/model_tests/yolo_tests/test_yolo_v2_tiny.py index 24c659f677..f79d8bd2bc 100644 --- a/tests/experimental_tests/links_tests/model_tests/yolo_tests/test_yolo_v2_tiny.py +++ b/tests/experimental_tests/links_tests/model_tests/yolo_tests/test_yolo_v2_tiny.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -14,7 +15,9 @@ class TestYOLOv2Tiny(unittest.TestCase): def setUp(self): - self.link = YOLOv2Tiny(n_fg_class=self.n_fg_class) + params = copy.deepcopy(YOLOv2Tiny.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + self.link = YOLOv2Tiny(**params) self.insize = 416 self.n_bbox = 13 * 13 * 5 @@ -49,26 +52,24 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ - 'n_fg_class': [None, 10, 20], + 'n_fg_class': [10, 20], 'pretrained_model': ['voc0712'], })) class TestYOLOv2TinyPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(YOLOv2Tiny.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class if self.pretrained_model == 'voc0712': - valid = self.n_fg_class in {None, 20} + valid = self.n_fg_class == 20 if valid: - YOLOv2Tiny(**kwargs) + YOLOv2Tiny(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - YOLOv2Tiny(**kwargs) + YOLOv2Tiny(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/deeplab_tests/test_deeplab_v3_plus.py b/tests/links_tests/model_tests/deeplab_tests/test_deeplab_v3_plus.py index 172238337d..8e26b02140 100644 --- a/tests/links_tests/model_tests/deeplab_tests/test_deeplab_v3_plus.py +++ b/tests/links_tests/model_tests/deeplab_tests/test_deeplab_v3_plus.py @@ -1,3 +1,4 @@ +import copy import unittest import chainer @@ -17,7 +18,9 @@ class TestDeepLabV3plusXception65(unittest.TestCase): def setUp(self): self.n_class = 10 - self.link = self.model(n_class=self.n_class) + params = copy.deepcopy(self.model.preset_params['voc']) + params['n_class'] = self.n_class + self.link = self.model(**params) def check_call(self): xp = self.link.xp @@ -54,29 +57,27 @@ def test_predict_gpu(self): @testing.parameterize(*testing.product({ 'model': [DeepLabV3plusXception65], 'pretrained_model': ['cityscapes', 'ade20k', 'voc'], - 'n_class': [None, 19, 150, 21], + 'n_class': [19, 150, 21], })) class TestDeepLabV3plusXception65Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(self.model.preset_params[self.pretrained_model]) + params['n_class'] = self.n_class if self.pretrained_model == 'cityscapes': - valid = self.n_class in {None, 19} + valid = self.n_class == 19 elif self.pretrained_model == 'ade20k': - valid = self.n_class in {None, 150} + valid = self.n_class == 150 elif self.pretrained_model == 'voc': - valid = self.n_class in {None, 21} + valid = self.n_class == 21 if valid: - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/faster_rcnn_tests/test_faster_rcnn_vgg.py b/tests/links_tests/model_tests/faster_rcnn_tests/test_faster_rcnn_vgg.py index a3c57847ab..662922f57a 100644 --- a/tests/links_tests/model_tests/faster_rcnn_tests/test_faster_rcnn_vgg.py +++ b/tests/links_tests/model_tests/faster_rcnn_tests/test_faster_rcnn_vgg.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -25,13 +26,12 @@ class TestFasterRCNNVGG16(unittest.TestCase): n_conv5_3_channel = 512 def setUp(self): - proposal_creator_params = { - 'n_train_post_nms': self.n_train_post_nms, - 'n_test_post_nms': self.n_test_post_nms - } - self.link = FasterRCNNVGG16( - self.n_fg_class, pretrained_model=None, - proposal_creator_params=proposal_creator_params) + params = copy.deepcopy(FasterRCNNVGG16.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + proposal_creator_params = params['proposal_creator_params'] + proposal_creator_params['n_train_post_nms'] = self.n_train_post_nms + proposal_creator_params['n_test_post_nms'] = self.n_test_post_nms + self.link = FasterRCNNVGG16(pretrained_model=None, **params) def check_call(self): xp = self.link.xp @@ -79,8 +79,9 @@ class TestFasterRCNNVGG16Loss(unittest.TestCase): n_fg_class = 20 def setUp(self): - faster_rcnn = FasterRCNNVGG16( - n_fg_class=self.n_fg_class, pretrained_model=False) + params = copy.deepcopy(FasterRCNNVGG16.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + faster_rcnn = FasterRCNNVGG16(pretrained_model=None, **params) self.link = FasterRCNNTrainChain(faster_rcnn) self.n_bbox = 3 @@ -114,28 +115,27 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ - 'n_fg_class': [None, 10, 20], + 'n_fg_class': [10, 20], 'pretrained_model': ['voc0712', 'imagenet'], })) class TestFasterRCNNVGG16Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'pretrained_model': self.pretrained_model, - } + params = FasterRCNNVGG16.preset_params['voc'] + params['n_fg_class'] = self.n_fg_class if self.pretrained_model == 'voc0712': - valid = self.n_fg_class in {None, 20} + valid = self.n_fg_class == 20 elif self.pretrained_model == 'imagenet': - valid = self.n_fg_class is not None + valid = True if valid: - FasterRCNNVGG16(**kwargs) + FasterRCNNVGG16(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - FasterRCNNVGG16(**kwargs) + FasterRCNNVGG16( + pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/fpn_tests/test_faster_rcnn_fpn_resnet.py b/tests/links_tests/model_tests/fpn_tests/test_faster_rcnn_fpn_resnet.py index 3ac43292fc..88d9475779 100644 --- a/tests/links_tests/model_tests/fpn_tests/test_faster_rcnn_fpn_resnet.py +++ b/tests/links_tests/model_tests/fpn_tests/test_faster_rcnn_fpn_resnet.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -19,8 +20,10 @@ class TestFasterRCNNFPNResNet(unittest.TestCase): def setUp(self): - self.link = self.model( - n_fg_class=self.n_fg_class, min_size=66) + params = copy.deepcopy(self.model.preset_params['coco']) + params['n_fg_class'] = self.n_fg_class + params['min_size'] = 66 + self.link = self.model(**params) def _check_call(self): imgs = [ @@ -46,28 +49,26 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ 'model': [FasterRCNNFPNResNet50, FasterRCNNFPNResNet101, MaskRCNNFPNResNet50, MaskRCNNFPNResNet101], - 'n_fg_class': [None, 10, 80], + 'n_fg_class': [10, 80], 'pretrained_model': ['coco', 'imagenet'], })) class TestFasterRCNNFPNResNetPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(self.model.preset_params['coco']) + params['n_fg_class'] = self.n_fg_class if self.pretrained_model == 'coco': - valid = self.n_fg_class in {None, 80} + valid = self.n_fg_class == 80 elif self.pretrained_model == 'imagenet': - valid = self.n_fg_class is not None + valid = True if valid: - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/resnet_tests/test_resnet.py b/tests/links_tests/model_tests/resnet_tests/test_resnet.py index 94abf5545a..34e9f99d46 100644 --- a/tests/links_tests/model_tests/resnet_tests/test_resnet.py +++ b/tests/links_tests/model_tests/resnet_tests/test_resnet.py @@ -1,5 +1,6 @@ import unittest +import copy import numpy as np from chainer.testing import attr @@ -34,8 +35,10 @@ class TestResNetCall(unittest.TestCase): def setUp(self): + params = copy.deepcopy(self.model_class.preset_params['imagenet']) + params['n_class'] = self.n_class self.link = self.model_class( - n_class=self.n_class, pretrained_model=None, arch=self.arch) + pretrained_model=None, arch=self.arch, **params) self.link.pick = self.pick def check_call(self): @@ -64,7 +67,7 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ 'model': [ResNet50, ResNet101, ResNet152], - 'n_class': [None, 500, 1000], + 'n_class': [500, 1000], 'pretrained_model': ['imagenet'], 'mean': [None, np.random.uniform((3, 1, 1)).astype(np.float32)], 'arch': ['he', 'fb'], @@ -73,21 +76,22 @@ class TestResNetPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - 'mean': self.mean, - 'arch': self.arch, - } + params = copy.deepcopy(self.model.preset_params[self.pretrained_model]) + params['n_class'] = self.n_class + params['mean'] = self.mean if self.pretrained_model == 'imagenet': - valid = self.n_class in {None, 1000} + valid = self.n_class == 1000 if valid: - self.model(**kwargs) + self.model( + pretrained_model=self.pretrained_model, + arch=self.arch, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model( + pretrained_model=self.pretrained_model, + arch=self.arch, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/segnet_tests/test_segnet_basic.py b/tests/links_tests/model_tests/segnet_tests/test_segnet_basic.py index 946a4b3fdc..160cbc3f3e 100644 --- a/tests/links_tests/model_tests/segnet_tests/test_segnet_basic.py +++ b/tests/links_tests/model_tests/segnet_tests/test_segnet_basic.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -17,7 +18,9 @@ class TestSegNetBasic(unittest.TestCase): def setUp(self): self.n_class = 10 - self.link = SegNetBasic(n_class=self.n_class) + params = copy.deepcopy(SegNetBasic.preset_params['camvid']) + params['n_class'] = self.n_class + self.link = SegNetBasic(**params) def check_call(self): xp = self.link.xp @@ -51,26 +54,24 @@ def test_predict_gpu(self): @testing.parameterize(*testing.product({ - 'n_class': [None, 5, 11], + 'n_class': [5, 11], 'pretrained_model': ['camvid'], })) class TestSegNetPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(SegNetBasic.preset_params['camvid']) + params['n_class'] = self.n_class if self.pretrained_model == 'camvid': - valid = self.n_class in {None, 11} + valid = self.n_class == 11 if valid: - SegNetBasic(**kwargs) + SegNetBasic(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - SegNetBasic(**kwargs) + SegNetBasic(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/senet_tests/test_se_resnet.py b/tests/links_tests/model_tests/senet_tests/test_se_resnet.py index b0e4d6f22d..3d23679e0e 100644 --- a/tests/links_tests/model_tests/senet_tests/test_se_resnet.py +++ b/tests/links_tests/model_tests/senet_tests/test_se_resnet.py @@ -1,5 +1,6 @@ import unittest +import copy import numpy as np from chainer.testing import attr @@ -30,8 +31,10 @@ class TestSEResNetCall(unittest.TestCase): def setUp(self): + params = copy.deepcopy(self.model_class.preset_params['imagenet']) + params['n_class'] = self.n_class self.link = self.model_class( - n_class=self.n_class, pretrained_model=None) + pretrained_model=None, **params) self.link.pick = self.pick def check_call(self): @@ -60,7 +63,7 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ 'model': [SEResNet50, SEResNet101, SEResNet152], - 'n_class': [None, 500, 1000], + 'n_class': [500, 1000], 'pretrained_model': ['imagenet'], 'mean': [None, np.random.uniform((3, 1, 1)).astype(np.float32)], })) @@ -68,20 +71,18 @@ class TestSEResNetPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - 'mean': self.mean, - } + params = copy.deepcopy(self.model.preset_params[self.pretrained_model]) + params['n_class'] = self.n_class + params['mean'] = self.mean if self.pretrained_model == 'imagenet': - valid = self.n_class in {None, 1000} + valid = self.n_class == 1000 if valid: - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/senet_tests/test_se_resnext.py b/tests/links_tests/model_tests/senet_tests/test_se_resnext.py index e5d7ae5022..9013fbe1d6 100644 --- a/tests/links_tests/model_tests/senet_tests/test_se_resnext.py +++ b/tests/links_tests/model_tests/senet_tests/test_se_resnext.py @@ -1,5 +1,6 @@ import unittest +import copy import numpy as np from chainer.testing import attr @@ -28,8 +29,10 @@ class TestSEResNeXtCall(unittest.TestCase): def setUp(self): + params = copy.deepcopy(self.model_class.preset_params['imagenet']) + params['n_class'] = self.n_class self.link = self.model_class( - n_class=self.n_class, pretrained_model=None) + pretrained_model=None, **params) self.link.pick = self.pick def check_call(self): @@ -58,7 +61,7 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ 'model': [SEResNeXt50, SEResNeXt101], - 'n_class': [None, 500, 1000], + 'n_class': [500, 1000], 'pretrained_model': ['imagenet'], 'mean': [None, np.random.uniform((3, 1, 1)).astype(np.float32)], })) @@ -66,20 +69,18 @@ class TestSEResNeXtPretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - 'mean': self.mean, - } + params = copy.deepcopy(self.model.preset_params[self.pretrained_model]) + params['n_class'] = self.n_class + params['mean'] = self.mean if self.pretrained_model == 'imagenet': - valid = self.n_class in {None, 1000} + valid = self.n_class == 1000 if valid: - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/ssd_tests/test_ssd_vgg16.py b/tests/links_tests/model_tests/ssd_tests/test_ssd_vgg16.py index a8659fce6f..8882b6ed15 100644 --- a/tests/links_tests/model_tests/ssd_tests/test_ssd_vgg16.py +++ b/tests/links_tests/model_tests/ssd_tests/test_ssd_vgg16.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -17,10 +18,14 @@ class TestSSDVGG16(unittest.TestCase): def setUp(self): if self.insize == 300: - self.link = SSD300(n_fg_class=self.n_fg_class) + params = copy.deepcopy(SSD300.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + self.link = SSD300(**params) self.n_bbox = 8732 elif self.insize == 512: - self.link = SSD512(n_fg_class=self.n_fg_class) + params = copy.deepcopy(SSD300.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + self.link = SSD512(**params) self.n_bbox = 24564 def _check_call(self): @@ -50,28 +55,26 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ 'model': [SSD300, SSD512], - 'n_fg_class': [None, 10, 20], + 'n_fg_class': [10, 20], 'pretrained_model': ['voc0712', 'imagenet'], })) class TestSSDVGG16Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(self.model.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class if self.pretrained_model == 'voc0712': - valid = self.n_fg_class in {None, 20} + valid = self.n_fg_class == 20 elif self.pretrained_model == 'imagenet': - valid = self.n_fg_class is not None + valid = True if valid: - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - self.model(**kwargs) + self.model(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/vgg_tests/test_vgg16.py b/tests/links_tests/model_tests/vgg_tests/test_vgg16.py index 2a0379eed5..da852b8825 100644 --- a/tests/links_tests/model_tests/vgg_tests/test_vgg16.py +++ b/tests/links_tests/model_tests/vgg_tests/test_vgg16.py @@ -1,5 +1,6 @@ import unittest +import copy import numpy as np import chainer @@ -20,9 +21,10 @@ class TestVGG16Call(unittest.TestCase): def setUp(self): + params = copy.deepcopy(VGG16.preset_params['imagenet']) + params['n_class'] = self.n_class self.link = VGG16( - n_class=self.n_class, pretrained_model=None, - initialW=Zero()) + pretrained_model=None, initialW=Zero(), **params) self.link.pick = self.pick def check_call(self): @@ -51,7 +53,7 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ - 'n_class': [None, 500, 1000], + 'n_class': [500, 1000], 'pretrained_model': ['imagenet'], 'mean': [None, np.random.uniform((3, 1, 1)).astype(np.float32)], })) @@ -59,20 +61,18 @@ class TestVGG16Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_class': self.n_class, - 'pretrained_model': self.pretrained_model, - 'mean': self.mean, - } + params = copy.deepcopy(VGG16.preset_params[self.pretrained_model]) + params['n_class'] = self.n_class + params['mean'] = self.mean if self.pretrained_model == 'imagenet': - valid = self.n_class in {None, 1000} + valid = self.n_class == 1000 if valid: - VGG16(**kwargs) + VGG16(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - VGG16(**kwargs) + VGG16(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/yolo_tests/test_yolo_v2.py b/tests/links_tests/model_tests/yolo_tests/test_yolo_v2.py index f8d1002ef4..3957d4501a 100644 --- a/tests/links_tests/model_tests/yolo_tests/test_yolo_v2.py +++ b/tests/links_tests/model_tests/yolo_tests/test_yolo_v2.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -14,7 +15,9 @@ class TestYOLOv2(unittest.TestCase): def setUp(self): - self.link = YOLOv2(n_fg_class=self.n_fg_class) + params = copy.deepcopy(YOLOv2.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + self.link = YOLOv2(**params) self.insize = 416 self.n_bbox = 13 * 13 * 5 @@ -49,26 +52,24 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ - 'n_fg_class': [None, 10, 20], + 'n_fg_class': [10, 20], 'pretrained_model': ['voc0712'], })) class TestYOLOv2Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(YOLOv2.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class if self.pretrained_model == 'voc0712': - valid = self.n_fg_class in {None, 20} + valid = self.n_fg_class == 20 if valid: - YOLOv2(**kwargs) + YOLOv2(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - YOLOv2(**kwargs) + YOLOv2(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__) diff --git a/tests/links_tests/model_tests/yolo_tests/test_yolo_v3.py b/tests/links_tests/model_tests/yolo_tests/test_yolo_v3.py index e84fc770fc..c9784556ca 100644 --- a/tests/links_tests/model_tests/yolo_tests/test_yolo_v3.py +++ b/tests/links_tests/model_tests/yolo_tests/test_yolo_v3.py @@ -1,3 +1,4 @@ +import copy import numpy as np import unittest @@ -14,7 +15,9 @@ class TestYOLOv3(unittest.TestCase): def setUp(self): - self.link = YOLOv3(n_fg_class=self.n_fg_class) + params = copy.deepcopy(YOLOv3.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class + self.link = YOLOv3(**params) self.insize = 416 self.n_bbox = (13 * 13 + 26 * 26 + 52 * 52) * 3 @@ -49,26 +52,24 @@ def test_call_gpu(self): @testing.parameterize(*testing.product({ - 'n_fg_class': [None, 10, 20], + 'n_fg_class': [10, 20], 'pretrained_model': ['voc0712'], })) class TestYOLOv3Pretrained(unittest.TestCase): @attr.slow def test_pretrained(self): - kwargs = { - 'n_fg_class': self.n_fg_class, - 'pretrained_model': self.pretrained_model, - } + params = copy.deepcopy(YOLOv3.preset_params['voc']) + params['n_fg_class'] = self.n_fg_class if self.pretrained_model == 'voc0712': - valid = self.n_fg_class in {None, 20} + valid = self.n_fg_class == 20 if valid: - YOLOv3(**kwargs) + YOLOv3(pretrained_model=self.pretrained_model, **params) else: with self.assertRaises(ValueError): - YOLOv3(**kwargs) + YOLOv3(pretrained_model=self.pretrained_model, **params) testing.run_module(__name__, __file__)