def __init__(
        self,
        in_channels=512,
        mid_channels=512,
        ratios=[0.5, 1, 2],
        anchor_scales=[8, 16, 32],
        feat_stride=16,
        initialW=None,
        proposal_creator_params={},
    ):
        self.anchor_base = generate_anchor_base(anchor_scales=anchor_scales,
                                                ratios=ratios)
        self.feat_stride = feat_stride
        self.proposal_layer = ProposalCreator(**proposal_creator_params)

        n_anchor = self.anchor_base.shape[0]
        super(RegionProposalNetwork,
              self).__init__(conv1=L.Convolution2D(in_channels,
                                                   mid_channels,
                                                   3,
                                                   1,
                                                   1,
                                                   initialW=initialW),
                             score=L.Convolution2D(mid_channels,
                                                   n_anchor * 2,
                                                   1,
                                                   1,
                                                   0,
                                                   initialW=initialW),
                             loc=L.Convolution2D(mid_channels,
                                                 n_anchor * 4,
                                                 1,
                                                 1,
                                                 0,
                                                 initialW=initialW))
 def __init__(self,
              anchor_scales,
              feat_strides,
              in_channels=256,
              mid_channels=256,
              ratios=[0.5, 1, 2],
              initialW=None,
              proposal_creator_params=dict()):
     if len(anchor_scales) != len(feat_strides):
         raise ValueError(
             'length of anchor_scales and feat_strides should be same!')
     self.anchor_bases = [
         generate_anchor_base(anchor_scales=[s], ratios=ratios)
         for s in anchor_scales
     ]
     self.feat_strides = feat_strides
     self.proposal_layer = ProposalCreator(**proposal_creator_params)
     # note: to share conv layers, number of output channel should be same in all levels.
     # debug
     a = self.anchor_bases[0]
     for ab in self.anchor_bases[1:]:
         assert a.shape == ab.shape
     n_anchor = self.anchor_bases[0].shape[0]
     super(MultilevelRegionProposalNetwork, self).__init__()
     with self.init_scope():
         # note: according fpn paper, parameters are sharable among levels.
         self.conv = L.Convolution2D(in_channels,
                                     mid_channels,
                                     3,
                                     1,
                                     1,
                                     initialW=initialW)
         self.score = L.Convolution2D(mid_channels,
                                      n_anchor * 2,
                                      1,
                                      1,
                                      0,
                                      initialW=initialW)
         self.loc = L.Convolution2D(mid_channels,
                                    n_anchor * 4,
                                    1,
                                    1,
                                    0,
                                    initialW=initialW)
    def __init__(
            self, in_channels=512, mid_channels=512, ratios=[0.5, 1, 2],
            anchor_scales=[8, 16, 32], feat_stride=16,
            initialW=None,
            proposal_creator_params={},
    ):
        self.anchor_base = generate_anchor_base(
            anchor_scales=anchor_scales, ratios=ratios)
        self.feat_stride = feat_stride
        self.proposal_layer = ProposalCreator(**proposal_creator_params)

        n_anchor = self.anchor_base.shape[0]
        super(RegionProposalNetwork, self).__init__()
        with self.init_scope():
            self.conv1 = L.Convolution2D(
                in_channels, mid_channels, 3, 1, 1, initialW=initialW)
            self.score = L.Convolution2D(
                mid_channels, n_anchor * 2, 1, 1, 0, initialW=initialW)
            self.loc = L.Convolution2D(
                mid_channels, n_anchor * 4, 1, 1, 0, initialW=initialW)