code: def create(
      dataset, target, features=None, distance=None, verbose=True
  ):
      """
      Create a
      :class:`~turicreate.nearest_neighbor_classifier.NearestNeighborClassifier`
      model. This model predicts the class of a query instance by finding the most
      common class among the query's nearest neighbors.
  
      Parameters
      ----------
      dataset : SFrame
          Dataset for training the model.
  
      target : str
          Name of the column containing the target variable. The values in this
          column must be of string or integer type.
  
      features : list[str], optional
          Name of the columns with features to use in comparing records. 'None'
          (the default) indicates that all columns except the target variable
          should be used. Please note: if `distance` is specified as a composite
          distance, then that parameter controls which features are used in the
          model. Each column can be one of the following types:
  
          - *Numeric*: values of numeric type integer or float.
  
          - *Array*: array of numeric (integer or float) values. Each array
            element is treated as a separate variable in the model.
  
          - *Dictionary*: key-value pairs with numeric (integer or float) values.
            Each key indicates a separate variable in the model.
  
          - *String*: string values.
  
          Please note: if `distance` is specified as a composite distance, then
          that parameter controls which features are used in the model.
  
      distance : str, function, or list[list], optional
          Function to measure the distance between any two input data rows. This
          may be one of three types:
  
          - *String*: the name of a standard distance function. One of
            'euclidean', 'squared_euclidean', 'manhattan', 'levenshtein',
            'jaccard', 'weighted_jaccard', 'cosine' or 'transformed_dot_product'.
  
          - *Function*: a function handle from the
            :mod:`~turicreate.toolkits.distances` module.
  
          - *Composite distance*: the weighted sum of several standard distance
            functions applied to various features. This is specified as a list of
            distance components, each of which is itself a list containing three
            items:
  
            1. list or tuple of feature names (str)
  
            2. standard distance name (str)
  
            3. scaling factor (int or float)
  
          For more information about Turi Create distance functions, please
          see the :py:mod:`~turicreate.toolkits.distances` module.
  
          For sparse vectors, missing keys are assumed to have value 0.0.
  
          If 'distance' is left unspecified or set to 'auto', a composite distance
          is constructed automatically based on feature types.
  
      verbose : bool, optional
          If True, print progress updates and model details.
  
      Returns
      -------
      out : NearestNeighborClassifier
          A trained model of type
          :class:`~turicreate.nearest_neighbor_classifier.NearestNeighborClassifier`.
  
      See Also
      --------
      NearestNeighborClassifier
      turicreate.toolkits.nearest_neighbors
      turicreate.toolkits.distances
  
      References
      ----------
      - `Wikipedia - nearest neighbors classifier
        <http://en.wikipedia.org/wiki/Nearest_neighbour_classifiers>`_
  
      - Hastie, T., Tibshirani, R., Friedman, J. (2009). `The Elements of
        Statistical Learning <https://web.stanford.edu/~hastie/ElemStatLearn/>`_.
        Vol. 2. New York. Springer. pp. 463-481.
  
      Examples
      --------
      >>> sf = turicreate.SFrame({'species': ['cat', 'dog', 'fossa', 'dog'],
      ...                       'height': [9, 25, 20, 23],
      ...                       'weight': [13, 28, 33, 22]})
      ...
      >>> model = turicreate.nearest_neighbor_classifier.create(sf, target='species')
  
      As with the nearest neighbors toolkit, the nearest neighbor classifier
      accepts composite distance functions.
  
      >>> my_dist = [[('height', 'weight'), 'euclidean', 2.7],
      ...            [('height', 'weight'), 'manhattan', 1.6]]
      ...
      >>> model = turicreate.nearest_neighbor_classifier.create(sf, target='species',
      ...                                                     distance=my_dist)
      """
  
      ## Set up
      ## ------
      start_time = _time.time()
  
      ## Validation and preprocessing
      ## ----------------------------
  
      ## 'dataset' must be a non-empty SFrame
      _raise_error_if_not_sframe(dataset, "dataset")
      _raise_error_if_sframe_empty(dataset, "dataset")
  
      ## 'target' must be a string, in 'dataset', and the type of the target must
      #  be string or integer.
      if (
          not isinstance(target, str)
          or target not in dataset.column_names()
      ):
          raise _ToolkitError(
              "The 'target' parameter must be the name of a "
              "column in the input dataset."
          )
  
      if (
          not dataset[target].dtype == str
          and not dataset[target].dtype == int
      ):
          raise TypeError(
              "The target column must contain integers or strings."
          )
  
      ## Warn that 'None' values in the target may lead to ambiguous predictions.
      if dataset[target].countna() > 0:
          _logging.warning(
              "Missing values detected in the target column. This "
              + "may lead to ambiguous 'None' predictions, if the "
              + "'radius' parameter is set too small in the prediction, "
              + "classification, or evaluation methods."
          )
  
      ## convert features and distance arguments into a composite distance
      ## NOTE: this is done here instead of in the nearest neighbors toolkit
      #  because the automatic distance construction may be different for the two
      #  toolkits.
      if features is None:
          _features = [x for x in dataset.column_names() if x != target]
      else:
          _features = [x for x in features if x != target]
  
      if isinstance(distance, list):
          distance = _copy.deepcopy(distance)
  
      elif hasattr(distance, "__call__") or (
          isinstance(distance, str) and not distance == "auto"
      ):
          distance = [[_features, distance, 1]]
  
      elif distance is None or distance == "auto":
          col_types = {
              k: v
              for k, v in zip(
                  dataset.column_names(), dataset.column_types()
              )
          }
          distance = _construct_auto_distance(_features, col_types)
  
      else:
          raise TypeError(
              "Input 'distance' not understood. The 'distance' "
              + "parameter must be a string or a composite distance, "
              + " or left unspecified."
          )
  
      ## Construct and query the nearest neighbors model
      ## -----------------------------------------------
      knn_model = _tc.nearest_neighbors.create(
          dataset, label=target, distance=distance, verbose=verbose
      )
  
      ## Postprocessing and formatting
      ## -----------------------------
      state = {
          "verbose": verbose,
          "distance": knn_model.distance,
          "num_distance_components": knn_model.num_distance_components,
          "num_examples": dataset.num_rows(),
          "features": knn_model.features,
          "target": target,
          "num_classes": len(dataset[target].unique()),
          "num_features": knn_model.num_features,
          "num_unpacked_features": knn_model.num_unpacked_features,
          "training_time": _time.time() - start_time,
          "_target_type": dataset[target].dtype,
      }
      model = NearestNeighborClassifier(knn_model, state)
      return model
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import time
  import copy
  import array
  import logging
  import turicreate
  from turicreate.toolkits._model import CustomModel
  from turicreate.toolkits._internal_utils import _toolkit_repr_print
  from turicreate.toolkits._internal_utils import _raise_error_if_sframe_empty
  from turicreate.toolkits._internal_utils import _raise_error_if_not_sframe
  from turicreate.toolkits._internal_utils import _raise_error_if_column_exists
  from turicreate.toolkits._internal_utils import _raise_error_evaluation_metric_is_valid
  from turicreate.toolkits._main import ToolkitError
  from turicreate.toolkits import evaluation
  from turicreate.toolkits._model import PythonProxy
label_desc: Use image node_id 3 for calling a global function with example usage: create(dataset, target, features, distance, verbose) and returns: model