class_docstr: NASNet A model from
  `"Learning Transferable Architectures for Scalable Image Recognition"
  <https://arxiv.org/abs/1707.07012>`_ paper
  
  Parameters
  ----------
  repeat : int
      Number of cell repeats
  penultimate_filters : int
      Number of filters in the penultimate layer of the network
  stem_filters : int
      Number of filters in stem layers
  filters_multiplier : int
      The filter multiplier for stem layers
  classes: int, default 1000
      Number of classification classes
  use_aux : bool, default True
      Whether to use auxiliary classifier when training
  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`.
class_docstr_tok: ["NASNet","A","model","from","`","``","Learning","Transferable","Architectures","for","Scalable","Image","Recognition","''","<","https",":","\/\/arxiv.org\/abs\/1707.07012",">","`","_","paper","Parameters","--","--","--","--","--","repeat",":","int","Number","of","cell","repeats","penultimate_filters",":","int","Number","of","filters","in","the","penultimate","layer","of","the","network","stem_filters",":","int","Number","of","filters","in","stem","layers","filters_multiplier",":","int","The","filter","multiplier","for","stem","layers","classes",":","int",",","default","1000","Number","of","classification","classes","use_aux",":","bool",",","default","True","Whether","to","use","auxiliary","classifier","when","training","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,
      repeat=6,
      penultimate_filters=4032,
      stem_filters=96,
      filters_multiplier=2,
      classes=1000,
      use_aux=True,
      norm_layer=BatchNorm,
      norm_kwargs=None,
  ):
      super(NASNetALarge, self).__init__()
  
      filters = penultimate_filters // 24
  
      self.conv0 = nn.HybridSequential(prefix="")
      self.conv0.add(
          nn.Conv2D(
              stem_filters, 3, padding=0, strides=2, use_bias=False
          )
      )
      self.conv0.add(
          norm_layer(
              momentum=0.1,
              epsilon=0.001,
              **({} if norm_kwargs is None else norm_kwargs),
          )
      )
  
      self.cell_stem_0 = CellStem0(
          stem_filters,
          norm_layer,
          norm_kwargs,
          num_filters=filters // (filters_multiplier**2),
      )
      self.cell_stem_1 = CellStem1(
          filters // filters_multiplier, norm_layer, norm_kwargs
      )
  
      self.norm_1 = nn.HybridSequential(prefix="")
      self.norm_1.add(
          FirstCell(
              out_channels_left=filters // 2,
              out_channels_right=filters,
              norm_layer=norm_layer,
              norm_kwargs=norm_kwargs,
          )
      )
      for _ in range(repeat - 1):
          self.norm_1.add(
              NormalCell(
                  out_channels_left=filters,
                  out_channels_right=filters,
                  norm_layer=norm_layer,
                  norm_kwargs=norm_kwargs,
              )
          )
  
      self.reduction_cell_0 = ReductionCell0(
          out_channels_left=2 * filters,
          out_channels_right=2 * filters,
          norm_layer=norm_layer,
          norm_kwargs=norm_kwargs,
      )
  
      self.norm_2 = nn.HybridSequential(prefix="")
      self.norm_2.add(
          FirstCell(
              out_channels_left=filters,
              out_channels_right=2 * filters,
              norm_layer=norm_layer,
              norm_kwargs=norm_kwargs,
          )
      )
      for _ in range(repeat - 1):
          self.norm_2.add(
              NormalCell(
                  out_channels_left=2 * filters,
                  out_channels_right=2 * filters,
                  norm_layer=norm_layer,
                  norm_kwargs=norm_kwargs,
              )
          )
  
      if use_aux:
          self.out_aux = nn.HybridSequential(prefix="")
          self.out_aux.add(
              nn.Conv2D(filters // 3, kernel_size=1, use_bias=False)
          )
          self.out_aux.add(
              norm_layer(
                  epsilon=0.001,
                  **({} if norm_kwargs is None else norm_kwargs),
              )
          )
          self.out_aux.add(nn.Activation("relu"))
          self.out_aux.add(
              nn.Conv2D(2 * filters, kernel_size=5, use_bias=False)
          )
          self.out_aux.add(
              norm_layer(
                  epsilon=0.001,
                  **({} if norm_kwargs is None else norm_kwargs),
              )
          )
          self.out_aux.add(nn.Activation("relu"))
          self.out_aux.add(nn.Dense(classes))
      else:
          self.out_aux = None
  
      self.reduction_cell_1 = ReductionCell1(
          out_channels_left=4 * filters,
          out_channels_right=4 * filters,
          norm_layer=norm_layer,
          norm_kwargs=norm_kwargs,
      )
  
      self.norm_3 = nn.HybridSequential(prefix="")
      self.norm_3.add(
          FirstCell(
              out_channels_left=2 * filters,
              out_channels_right=4 * filters,
              norm_layer=norm_layer,
              norm_kwargs=norm_kwargs,
          )
      )
      for _ in range(repeat - 1):
          self.norm_3.add(
              NormalCell(
                  out_channels_left=4 * filters,
                  out_channels_right=4 * filters,
                  norm_layer=norm_layer,
                  norm_kwargs=norm_kwargs,
              )
          )
  
      self.out = nn.HybridSequential(prefix="")
      self.out.add(nn.Activation("relu"))
      self.out.add(nn.GlobalAvgPool2D())
      self.out.add(nn.Dropout(0.5))
      self.out.add(nn.Dense(classes))
  
imports: from __future__ import division
  import os
  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 NASNetALarge object from inherited base classes: HybridBlock with example: obj = NASNetALarge(repeat, penultimate_filters, stem_filters, filters_multiplier, classes, use_aux, norm_layer, norm_kwargs)