class_docstr: Single-shot Object Detection Network: https://arxiv.org/abs/1512.02325.
     with resnetv1b base model.
  
  Parameters
  ----------
  network : string or None
      Name of the base network, must be end with v1b.
  add_filters : list of int
      Number of channels for the appended layers, ignored if `network`is `None`.
  norm_layer : object
      Normalization layer used (default: :class:`mxnet.gluon.nn.BatchNorm`)
      Can be :class:`mxnet.gluon.nn.BatchNorm` or :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`.
      This will only apply to base networks that has `norm_layer` specified, will ignore if the
      base network (e.g. VGG) don't accept this argument.
  norm_kwargs : dict
      Additional `norm_layer` arguments, for example `num_devices=4`
      for :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`.
  use_bn : bool
      Whether to use BatchNorm layer after each attached convolutional layer.
  reduce_ratio : float
      Channel reduce ratio (0, 1) of the transition layer.
  min_depth : int
      Minimum channels for the transition layers.
code: def __init__(
      self,
      network,
      add_filters,
      norm_layer=BatchNorm,
      norm_kwargs=None,
      use_bn=False,
      reduce_ratio=1.0,
      min_depth=128,
      **kwargs,
  ):
      super(ResNetV1bSSD, self).__init__()
      assert network.endswith("v1b")
      if norm_kwargs is None:
          norm_kwargs = {}
      res = get_model(network, **kwargs)
      weight_init = mx.init.Xavier(
          rnd_type="gaussian", factor_type="out", magnitude=2
      )
      with self.name_scope():
          self.stage1 = HybridSequential("stage1")
          for l in [
              "conv1",
              "bn1",
              "relu",
              "maxpool",
              "layer1",
              "layer2",
          ]:
              self.stage1.add(getattr(res, l))
          self.stage2 = HybridSequential("stage2")
          self.stage2.add(res.layer3)
          # set stride from (2, 2) -> (1, 1) in first conv of layer3
          self.stage2[0][0].conv1._kwargs["stride"] = (1, 1)
          # also the residuel path
          self.stage2[0][0].downsample[0]._kwargs["stride"] = (1, 1)
          self.stage2.add(res.layer4)
          self.more_stages = HybridSequential("more_stages")
          for i, num_filter in enumerate(add_filters):
              stage = HybridSequential("more_stages_" + str(i))
              num_trans = max(
                  min_depth, int(round(num_filter * reduce_ratio))
              )
              stage.add(
                  Conv2D(
                      channels=num_trans,
                      kernel_size=1,
                      use_bias=not use_bn,
                      weight_initializer=weight_init,
                  )
              )
              if use_bn:
                  stage.add(norm_layer(**norm_kwargs))
              stage.add(Activation("relu"))
              padding = 0 if i == len(add_filters) - 1 else 1
              stage.add(
                  Conv2D(
                      channels=num_filter,
                      kernel_size=3,
                      strides=2,
                      padding=padding,
                      use_bias=not use_bn,
                      weight_initializer=weight_init,
                  )
              )
              if use_bn:
                  stage.add(norm_layer(**norm_kwargs))
              stage.add(Activation("relu"))
              self.more_stages.add(stage)
  
file_path: gluon-cv/gluoncv/model_zoo/ssd/resnet_v1b_ssd.py
imports: from __future__ import absolute_import
  import mxnet
  from mxnet.gluon import HybridBlock
  from mxnet.gluon.nn import HybridSequential, Conv2D, Activation, BatchNorm
  from ..model_zoo import get_model
label_desc: Use image node_id 1 to create a new ResNetV1bSSD object from inherited base classes: HybridBlock with example: obj = ResNetV1bSSD(network, add_filters, norm_layer, norm_kwargs, use_bn, reduce_ratio, min_depth)