class_docstr: Bottleneck Block from `"Aggregated Residual Transformations for Deep Neural Network"
  <http://arxiv.org/abs/1611.05431>`_ paper.
  
  Parameters
  ----------
  cardinality: int
      Number of groups
  bottleneck_width: int
      Width of bottleneck block
  stride : int
      Stride size.
  downsample : bool, default False
      Whether to downsample the input.
  last_gamma : bool, default False
      Whether to initialize the gamma of the last BatchNorm layer in each bottleneck to zero.
  use_se : bool, default False
      Whether to use Squeeze-and-Excitation module
  avg_down : bool, default False
      Whether to use average pooling for projection skip connection between stages/downsample.
  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`.
  norm_kwargs : dict
      Additional `norm_layer` arguments, for example `num_devices=4`
      for :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`.
code: def __init__(
      self,
      channels,
      cardinality,
      bottleneck_width,
      stride,
      downsample=False,
      last_gamma=False,
      use_se=False,
      avg_down=False,
      norm_layer=BatchNorm,
      norm_kwargs=None,
      **kwargs,
  ):
      super(Block, self).__init__(**kwargs)
      D = int(math.floor(channels * (bottleneck_width / 64)))
      group_width = cardinality * D
  
      self.body = nn.HybridSequential(prefix="")
      self.body.add(
          nn.Conv2D(group_width, kernel_size=1, use_bias=False)
      )
      self.body.add(
          norm_layer(**({} if norm_kwargs is None else norm_kwargs))
      )
      self.body.add(nn.Activation("relu"))
      self.body.add(
          nn.Conv2D(
              group_width,
              kernel_size=3,
              strides=stride,
              padding=1,
              groups=cardinality,
              use_bias=False,
          )
      )
      self.body.add(
          norm_layer(**({} if norm_kwargs is None else norm_kwargs))
      )
      self.body.add(nn.Activation("relu"))
      self.body.add(
          nn.Conv2D(channels * 4, kernel_size=1, use_bias=False)
      )
      if last_gamma:
          self.body.add(
              norm_layer(**({} if norm_kwargs is None else norm_kwargs))
          )
      else:
          self.body.add(
              norm_layer(
                  gamma_initializer="zeros",
                  **({} if norm_kwargs is None else norm_kwargs),
              )
          )
  
      if use_se:
          self.se = nn.HybridSequential(prefix="")
          self.se.add(
              nn.Conv2D(channels // 4, kernel_size=1, padding=0)
          )
          self.se.add(nn.Activation("relu"))
          self.se.add(nn.Conv2D(channels * 4, kernel_size=1, padding=0))
          self.se.add(nn.Activation("sigmoid"))
      else:
          self.se = None
  
      if downsample:
          self.downsample = nn.HybridSequential(prefix="")
          if avg_down:
              self.downsample.add(
                  nn.AvgPool2D(
                      pool_size=stride,
                      strides=stride,
                      ceil_mode=True,
                      count_include_pad=False,
                  )
              )
              self.downsample.add(
                  nn.Conv2D(
                      channels=channels * 4,
                      kernel_size=1,
                      strides=1,
                      use_bias=False,
                  )
              )
          else:
              self.downsample.add(
                  nn.Conv2D(
                      channels * 4,
                      kernel_size=1,
                      strides=stride,
                      use_bias=False,
                  )
              )
          self.downsample.add(
              norm_layer(**({} if norm_kwargs is None else norm_kwargs))
          )
      else:
          self.downsample = None
  
imports: from __future__ import division
  import os
  import math
  from mxnet import cpu
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
  from mxnet.gluon.block import HybridBlock
label_desc: Use image node_id 1 to create a new Block object from inherited base classes: HybridBlock with example: obj = Block(channels, cardinality, bottleneck_width, stride, downsample, last_gamma, use_se, avg_down, norm_layer, norm_kwargs)