code: def create(
      input_dataset,
      target,
      feature=None,
      validation_set="auto",
      warm_start="auto",
      batch_size=256,
      max_iterations=500,
      verbose=True,
      random_seed=None,
  ):
      """
      Create a :class:`DrawingClassifier` model.
  
      Parameters
      ----------
      dataset : SFrame
          Input data. The columns named by the ``feature`` and ``target``
          parameters will be extracted for training the drawing classifier.
  
      target : string
          Name of the column containing the target variable. The values in this
          column must be of string or integer type.
  
      feature : string optional
          Name of the column containing the input drawings.
          The feature column can contain either bitmap-based drawings or
          stroke-based drawings. Bitmap-based drawing input can be a grayscale
          tc.Image of any size.
          Stroke-based drawing input must be in the following format:
          Every drawing must be represented by a list of strokes, where each
          stroke must be a list of points in the order in which they were drawn
          on the canvas.
          Each point must be a dictionary with two keys, "x" and "y", and their
          respective values must be numerical, i.e. either integer or float.
  
      validation_set : SFrame optional
          A dataset for monitoring the model's generalization performance.
          The format of this SFrame must be the same as the training set.
          By default this argument is set to 'auto' and a validation set is
          automatically sampled and used for progress printing. If
          validation_set is set to None, then no additional metrics
          are computed. The default value is 'auto'.
  
      warm_start : string optional
          A string to denote which pretrained model to use. Set to "auto"
          by default which uses a model trained on 245 of the 345 classes in the
          Quick, Draw! dataset. To disable warm start, pass in None to this
          argument. Here is a list of all the pretrained models that
          can be passed in as this argument:
          "auto": Uses quickdraw_245_v0
          "quickdraw_245_v0": Uses a model trained on 245 of the 345 classes in the
                           Quick, Draw! dataset.
          None: No Warm Start
  
      batch_size: int optional
          The number of drawings per training step. If not set, a default
          value of 256 will be used. If you are getting memory errors,
          try decreasing this value. If you have a powerful computer, increasing
          this value may improve performance.
  
      max_iterations : int optional
          The maximum number of allowed passes through the data. More passes over
          the data can result in a more accurately trained model.
  
      verbose : bool optional
          If True, print progress updates and model details.
  
      random_seed : int, optional
          The results can be reproduced when given the same seed.
  
      Returns
      -------
      out : DrawingClassifier
          A trained :class:`DrawingClassifier` model.
  
      See Also
      --------
      DrawingClassifier
  
      Examples
      --------
      .. sourcecode:: python
  
          # Train a drawing classifier model
          >>> model = turicreate.drawing_classifier.create(data)
  
          # Make predictions on the training set and as column to the SFrame
          >>> data['predictions'] = model.predict(data)
      """
  
      accepted_values_for_warm_start = [
          "auto",
          "quickdraw_245_v0",
          None,
      ]
      if warm_start is not None:
          if type(warm_start) is not str:
              raise TypeError(
                  "'warm_start' must be a string or None. "
                  + "'warm_start' can take in the following values: "
                  + str(accepted_values_for_warm_start)
              )
          if warm_start not in accepted_values_for_warm_start:
              raise _ToolkitError(
                  "Unrecognized value for 'warm_start': "
                  + warm_start
                  + ". 'warm_start' can take in the following "
                  + "values: "
                  + str(accepted_values_for_warm_start)
              )
          # Replace 'auto' with name of current default Warm Start model.
          warm_start = warm_start.replace("auto", "quickdraw_245_v0")
  
      # @TODO: Should be able to automatically choose number of iterations
      # based on data size: Tracked in Github Issue #1576
      if not isinstance(input_dataset, _tc.SFrame):
          raise TypeError('"input_dataset" must be of type SFrame.')
  
      # automatically infer feature column
      if feature is None:
          feature = _tkutl._find_only_drawing_column(input_dataset)
  
      _raise_error_if_not_drawing_classifier_input_sframe(
          input_dataset, feature, target
      )
  
      if batch_size is not None and not isinstance(batch_size, int):
          raise TypeError("'batch_size' must be an integer >= 1")
      if batch_size is not None and batch_size < 1:
          raise ValueError("'batch_size' must be >= 1")
      if max_iterations is not None and not isinstance(
          max_iterations, int
      ):
          raise TypeError("'max_iterations' must be an integer >= 1")
      if max_iterations is not None and max_iterations < 1:
          raise ValueError("'max_iterations' must be >= 1")
  
      _minimal_package_import_check(
          "turicreate.toolkits.libtctensorflow"
      )
  
      model = _tc.extensions.drawing_classifier()
      options = dict()
      options["batch_size"] = batch_size
      options["max_iterations"] = max_iterations
      options["verbose"] = verbose
      options["_show_loss"] = False
      if validation_set is None:
          validation_set = _tc.SFrame()
      if warm_start:
          # Load CoreML warmstart model
          pretrained_mlmodel = (
              _pre_trained_models.DrawingClassifierPreTrainedMLModel()
          )
          options["mlmodel_path"] = pretrained_mlmodel.get_model_path()
      if random_seed is not None:
          options["random_seed"] = random_seed
      options["warm_start"] = "" if warm_start is None else warm_start
      model.train(
          input_dataset, target, feature, validation_set, options
      )
      return DrawingClassifier(
          model_proxy=model, name="drawing_classifier"
      )
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import turicreate
  from turicreate.toolkits import _coreml_utils
  from turicreate.toolkits._model import Model
  import turicreate.toolkits._internal_utils
  from turicreate.toolkits._main import ToolkitError
  from turicreate._deps.minimal_package import _minimal_package_import_check
  from ..image_classifier._evaluation import Evaluation
  from ..None import _pre_trained_models
label_desc: Use image node_id 2 for calling a global function with example usage: create(input_dataset, target, feature, validation_set, warm_start, batch_size, max_iterations, verbose, random_seed) and returns: DrawingClassifier