class_docstr: Pre-trained ResNetV1b Model, which produces the strides of 8
  featuremaps at conv5.
  
  Parameters
  ----------
  block : Block
      Class for the residual block. Options are BasicBlockV1, BottleneckV1.
  layers : list of int
      Numbers of layers in each block
  classes : int, default 1000
      Number of classification classes.
  dilated : bool, default False
      Applying dilation strategy to pretrained ResNet yielding a stride-8 model,
      typically used in Semantic Segmentation.
  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`.
  last_gamma : bool, default False
      Whether to initialize the gamma of the last BatchNorm layer in each bottleneck to zero.
  deep_stem : bool, default False
      Whether to replace the 7x7 conv1 with 3 3x3 convolution layers.
  avg_down : bool, default False
      Whether to use average pooling for projection skip connection between stages/downsample.
  final_drop : float, default 0.0
      Dropout ratio before the final classification layer.
  use_global_stats : bool, default False
      Whether forcing BatchNorm to use global statistics instead of minibatch statistics;
      optionally set to True if finetuning using ImageNet classification pretrained models.
  
  
  Reference:
  
      - He, Kaiming, et al. "Deep residual learning for image recognition."
      Proceedings of the IEEE conference on computer vision and pattern recognition. 2016.
  
      - Yu, Fisher, and Vladlen Koltun. "Multi-scale context aggregation by dilated convolutions."
code: def _make_layer(
      self,
      stage_index,
      block,
      planes,
      blocks,
      strides=1,
      dilation=1,
      avg_down=False,
      norm_layer=None,
      last_gamma=False,
  ):
      downsample = None
      if strides != 1 or self.inplanes != planes * block.expansion:
          downsample = nn.HybridSequential(
              prefix="down%d_" % stage_index
          )
          with downsample.name_scope():
              if avg_down:
                  if dilation == 1:
                      downsample.add(
                          nn.AvgPool2D(
                              pool_size=strides,
                              strides=strides,
                              ceil_mode=True,
                              count_include_pad=False,
                          )
                      )
                  else:
                      downsample.add(
                          nn.AvgPool2D(
                              pool_size=1,
                              strides=1,
                              ceil_mode=True,
                              count_include_pad=False,
                          )
                      )
                  downsample.add(
                      nn.Conv2D(
                          channels=planes * block.expansion,
                          kernel_size=1,
                          strides=1,
                          use_bias=False,
                      )
                  )
                  downsample.add(
                      norm_layer(
                          in_channels=planes * block.expansion,
                          **self.norm_kwargs,
                      )
                  )
              else:
                  downsample.add(
                      nn.Conv2D(
                          channels=planes * block.expansion,
                          kernel_size=1,
                          strides=strides,
                          use_bias=False,
                      )
                  )
                  downsample.add(
                      norm_layer(
                          in_channels=planes * block.expansion,
                          **self.norm_kwargs,
                      )
                  )
  
      layers = nn.HybridSequential(prefix="layers%d_" % stage_index)
      with layers.name_scope():
          if dilation in (1, 2):
              layers.add(
                  block(
                      planes,
                      strides,
                      dilation=1,
                      downsample=downsample,
                      previous_dilation=dilation,
                      norm_layer=norm_layer,
                      norm_kwargs=self.norm_kwargs,
                      last_gamma=last_gamma,
                  )
              )
          elif dilation == 4:
              layers.add(
                  block(
                      planes,
                      strides,
                      dilation=2,
                      downsample=downsample,
                      previous_dilation=dilation,
                      norm_layer=norm_layer,
                      norm_kwargs=self.norm_kwargs,
                      last_gamma=last_gamma,
                  )
              )
          else:
              raise RuntimeError(
                  "=> unknown dilation size: {}".format(dilation)
              )
  
          self.inplanes = planes * block.expansion
          for i in range(1, blocks):
              layers.add(
                  block(
                      planes,
                      dilation=dilation,
                      previous_dilation=dilation,
                      norm_layer=norm_layer,
                      norm_kwargs=self.norm_kwargs,
                      last_gamma=last_gamma,
                  )
              )
  
      return layers
  
imports: from __future__ import division
  from mxnet.context import cpu
  from mxnet.gluon.block import HybridBlock
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
label_desc: Use image node_id 2 for calling the ResNetV1b obj's underlying member method code with example usage: obj._make_layer(stage_index, block, planes, blocks, strides, dilation, avg_down, norm_layer, last_gamma) and returns: layers