code: def NASNetLarge(
      input_shape=None,
      include_top=True,
      weights="imagenet",
      input_tensor=None,
      pooling=None,
      classes=1000,
      classifier_activation="softmax",
  ):
      """Instantiates a NASNet model in ImageNet mode.
  
      Reference:
      - [Learning Transferable Architectures for Scalable Image Recognition](
          https://arxiv.org/abs/1707.07012) (CVPR 2018)
  
      Optionally loads weights pre-trained on ImageNet.
      Note that the data format convention used by the model is
      the one specified in your Keras config at `~/.keras/keras.json`.
  
      Note: each Keras Application expects a specific kind of input preprocessing.
      For NASNet, call `keras.applications.nasnet.preprocess_input` on your
      inputs before passing them to the model.
  
      Args:
          input_shape: Optional shape tuple, only to be specified
              if `include_top` is False (otherwise the input shape
              has to be `(331, 331, 3)` for NASNetLarge.
              It should have exactly 3 inputs channels,
              and width and height should be no smaller than 32.
              E.g. `(224, 224, 3)` would be one valid value.
          include_top: Whether to include the fully-connected
              layer at the top of the network.
          weights: `None` (random initialization) or
              `imagenet` (ImageNet weights).  For loading `imagenet` weights,
              `input_shape` should be (331, 331, 3)
          input_tensor: Optional Keras tensor (i.e. output of
              `layers.Input()`)
              to use as image input for the model.
          pooling: Optional pooling mode for feature extraction
              when `include_top` is `False`.
              - `None` means that the output of the model
                  will be the 4D tensor output of the
                  last convolutional layer.
              - `avg` means that global average pooling
                  will be applied to the output of the
                  last convolutional layer, and thus
                  the output of the model will be a
                  2D tensor.
              - `max` means that global max pooling will
                  be applied.
          classes: Optional number of classes to classify images
              into, only to be specified if `include_top` is `True`, and
              if no `weights` argument is specified.
          classifier_activation: A `str` or callable. The activation function to
              use on the "top" layer. Ignored unless `include_top=True`. Set
              `classifier_activation=None` to return the logits of the "top"
              layer.  When loading pretrained weights, `classifier_activation`
              can only be `None` or `"softmax"`.
  
      Returns:
          A Keras model instance.
      """
      return NASNet(
          input_shape,
          penultimate_filters=4032,
          num_blocks=6,
          stem_block_filters=96,
          skip_reduction=True,
          filter_multiplier=2,
          include_top=include_top,
          weights=weights,
          input_tensor=input_tensor,
          pooling=pooling,
          classes=classes,
          default_size=331,
          classifier_activation=classifier_activation,
      )
  
file_path: keras/keras/applications/nasnet.py
imports: import warnings
  from keras import backend
  from keras import layers
  from keras.api_export import keras_export
  from keras.applications import imagenet_utils
  from keras.models import Functional
  from keras.ops import operation_utils
  from keras.utils import file_utils
label_desc: Use image node_id 3 for calling a global function with example usage: NASNetLarge(input_shape, include_top, weights, input_tensor, pooling, classes, classifier_activation) and returns: NASNet