class_docstr: Wider ResNet with pre-activation (identity mapping) blocks
  
  This variant uses down-sampling by max-pooling in the first two blocks and
   by strided convolution in the others.
  
  Parameters
  ----------
  structure : list of int
      Number of residual blocks in each of the six modules of the network.
  norm_act : callable
      Function to create normalization / activation Module.
  classes : int
      If not `0` also include global average pooling and a fully-connected layer
      with `classes` outputs at the end
      of the network.
  dilation : bool
      If `True` apply dilation to the last three modules and change the
      down-sampling factor from 32 to 8.
code: def __init__(
      self,
      structure,
      norm_act=bnrelu,
      classes=0,
      dilation=False,
      dist_bn=False,
  ):
      super(WiderResNetA2, self).__init__()
      self.dist_bn = dist_bn
  
      norm_act = bnrelu
      self.structure = structure
      self.dilation = dilation
  
      if len(structure) != 6:
          raise ValueError("Expected a structure with six values")
  
      self.mod1 = nn.HybridSequential(prefix="mod1")
      self.mod1.add(
          nn.Conv2D(
              in_channels=3,
              channels=64,
              kernel_size=3,
              strides=1,
              padding=1,
              use_bias=False,
          )
      )
  
      # Groups of residual blocks
      in_channels = 64
      channels = [
          (128, 128),
          (256, 256),
          (512, 512),
          (512, 1024),
          (512, 1024, 2048),
          (1024, 2048, 4096),
      ]
      for mod_id, num in enumerate(structure):
          # Create blocks for module
          blocks = []
          for block_id in range(num):
              if not dilation:
                  dil = 1
                  strides = (
                      2 if block_id == 0 and 2 <= mod_id <= 4 else 1
                  )
              else:
                  if mod_id == 3:
                      dil = 2
                  elif mod_id > 3:
                      dil = 4
                  else:
                      dil = 1
                  strides = 2 if block_id == 0 and mod_id == 2 else 1
  
              if mod_id == 4:
                  drop = partial(nn.Dropout, rate=0.3)
              elif mod_id == 5:
                  drop = partial(nn.Dropout, rate=0.5)
              else:
                  drop = None
  
              blocks.append(
                  (
                      "block%d" % (block_id + 1),
                      IdentityResidualBlock(
                          in_channels=in_channels,
                          channels=channels[mod_id],
                          norm_act=norm_act,
                          strides=strides,
                          dilation=dil,
                          dropout=drop,
                          dist_bn=self.dist_bn,
                      ),
                  )
              )
  
              # Update channels and p_keep
              in_channels = channels[mod_id][-1]
  
          # Create module
          if mod_id == 0:
              self.pool2 = nn.MaxPool2D(
                  pool_size=3, strides=2, padding=1
              )
              blocks_dict = OrderedDict(blocks)
              self.mod2 = nn.HybridSequential(prefix="mod2")
              for key in blocks_dict.keys():
                  self.mod2.add(blocks_dict[key])
  
          if mod_id == 1:
              self.pool3 = nn.MaxPool2D(
                  pool_size=3, strides=2, padding=1
              )
              blocks_dict = OrderedDict(blocks)
              self.mod3 = nn.HybridSequential(prefix="mod3")
              for key in blocks_dict.keys():
                  self.mod3.add(blocks_dict[key])
  
          if mod_id == 2:
              blocks_dict = OrderedDict(blocks)
              self.mod4 = nn.HybridSequential(prefix="mod4")
              for key in blocks_dict.keys():
                  self.mod4.add(blocks_dict[key])
  
          if mod_id == 3:
              blocks_dict = OrderedDict(blocks)
              self.mod5 = nn.HybridSequential(prefix="mod5")
              for key in blocks_dict.keys():
                  self.mod5.add(blocks_dict[key])
  
          if mod_id == 4:
              blocks_dict = OrderedDict(blocks)
              self.mod6 = nn.HybridSequential(prefix="mod6")
              for key in blocks_dict.keys():
                  self.mod6.add(blocks_dict[key])
  
          if mod_id == 5:
              blocks_dict = OrderedDict(blocks)
              self.mod7 = nn.HybridSequential(prefix="mod7")
              for key in blocks_dict.keys():
                  self.mod7.add(blocks_dict[key])
  
      # Pooling and predictor
      self.bn_out = norm_act(in_channels)
      if classes != 0:
          self.classifier = nn.HybridSequential(prefix="classifier")
          self.classifier.add(nn.GlobalAvgPool2D())
          self.classifier.add(
              nn.Dense(in_units=in_channels, units=classes)
          )
  
file_path: gluon-cv/gluoncv/model_zoo/wideresnet.py
imports: import sys
  from collections import OrderedDict
  from functools import partial
  from mxnet.gluon import nn
  from mxnet.gluon.nn import HybridBlock
label_desc: Use image node_id 1 to create a new WiderResNetA2 object from inherited base classes: HybridBlock with example: obj = WiderResNetA2(structure, norm_act, classes, dilation, dist_bn)