class_docstr: ResNext model from
  `"Aggregated Residual Transformations for Deep Neural Network"
  <http://arxiv.org/abs/1611.05431>`_ paper.
  
  Parameters
  ----------
  layers : list of int
      Numbers of layers in each block
  cardinality: int
      Number of groups
  bottleneck_width: int
      Width of bottleneck block
  classes : int, default 1000
      Number of classification classes.
  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
  deep_stem : bool, default False
      Whether to replace the 7x7 conv1 with 3 3x3 convolution layers.
  stem_width : int, default 64
      Width of the stem intermediate layer.
  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,
      layers,
      cardinality,
      bottleneck_width,
      classes=1000,
      last_gamma=False,
      use_se=False,
      deep_stem=False,
      avg_down=False,
      stem_width=64,
      norm_layer=BatchNorm,
      norm_kwargs=None,
      **kwargs,
  ):
      super(ResNext, self).__init__(**kwargs)
      self.cardinality = cardinality
      self.bottleneck_width = bottleneck_width
      channels = 64
  
      with self.name_scope():
          self.features = nn.HybridSequential(prefix="")
          if not deep_stem:
              self.features.add(
                  nn.Conv2D(
                      channels=64,
                      kernel_size=7,
                      strides=2,
                      padding=3,
                      use_bias=False,
                  )
              )
          else:
              self.features.add(
                  nn.Conv2D(
                      channels=stem_width,
                      kernel_size=3,
                      strides=2,
                      padding=1,
                      use_bias=False,
                  )
              )
              self.features.add(
                  norm_layer(
                      **({} if norm_kwargs is None else norm_kwargs)
                  )
              )
              self.features.add(nn.Activation("relu"))
              self.features.add(
                  nn.Conv2D(
                      channels=stem_width,
                      kernel_size=3,
                      strides=1,
                      padding=1,
                      use_bias=False,
                  )
              )
              self.features.add(
                  norm_layer(
                      **({} if norm_kwargs is None else norm_kwargs)
                  )
              )
              self.features.add(nn.Activation("relu"))
              self.features.add(
                  nn.Conv2D(
                      channels=stem_width * 2,
                      kernel_size=3,
                      strides=1,
                      padding=1,
                      use_bias=False,
                  )
              )
  
          self.features.add(
              norm_layer(**({} if norm_kwargs is None else norm_kwargs))
          )
          self.features.add(nn.Activation("relu"))
          self.features.add(nn.MaxPool2D(3, 2, 1))
          for i, num_layer in enumerate(layers):
              stride = 1 if i == 0 else 2
              self.features.add(
                  self._make_layer(
                      channels,
                      num_layer,
                      stride,
                      last_gamma,
                      use_se,
                      False if i == 0 else avg_down,
                      i + 1,
                      norm_layer=norm_layer,
                      norm_kwargs=norm_kwargs,
                  )
              )
              channels *= 2
          self.features.add(nn.GlobalAvgPool2D())
  
          self.output = nn.Dense(classes)
  
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 ResNext object from inherited base classes: HybridBlock with example: obj = ResNext(layers, cardinality, bottleneck_width, classes, last_gamma, use_se, deep_stem, avg_down, stem_width, norm_layer, norm_kwargs)