code: def create(
      dataset,
      target,
      model_name,
      features=None,
      validation_set="auto",
      distributed="auto",
      verbose=True,
      seed=None,
      **kwargs,
  ):
      """
      Create a :class:`~turicreate.toolkits.SupervisedLearningModel`,
  
      This is generic function that allows you to create any model that
      implements SupervisedLearningModel This function is normally not called, call
      specific model's create function instead
  
      Parameters
      ----------
      dataset : SFrame
          Dataset for training the model.
  
      target : string
          Name of the column containing the target variable. The values in this
          column must be 0 or 1, of integer type.
  
      model_name : string
          Name of the model
  
      features : list[string], optional
          List of feature names used by feature column
  
      validation_set : SFrame, optional
          A dataset for monitoring the model's generalization performance.
          For each row of the progress table, the chosen metrics are computed
          for both the provided training dataset and the validation_set. 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'.
  
      distributed: env
          The distributed environment
  
      verbose : boolean
          whether print out messages during training
  
      seed : int, optional
          Seed for random number generation. Set this value to ensure that the
          same model is created every time.
  
      kwargs : dict
          Additional parameter options that can be passed
      """
  
      # Perform error-checking and trim inputs to specified columns
      dataset, validation_set = _validate_data(
          dataset, target, features, validation_set
      )
  
      # Sample a validation set from the training data if requested
      if isinstance(validation_set, str):
          assert validation_set == "auto"
          if dataset.num_rows() >= 100:
              if verbose:
                  print_validation_track_notification()
              dataset, validation_set = dataset.random_split(
                  0.95, seed=seed, exact=True
              )
          else:
              validation_set = _turicreate.SFrame()
      elif validation_set is None:
          validation_set = _turicreate.SFrame()
  
      # Sanitize model-specific options
      options = {k.lower(): kwargs[k] for k in kwargs}
  
      # Create a model instance and train it
      model = _turicreate.extensions.__dict__[model_name]()
      with QuietProgress(verbose):
          model.train(dataset, target, validation_set, options)
  
      return SupervisedLearningModel(model, model_name)
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import turicreate
  from turicreate.toolkits._model import Model
  from turicreate.toolkits._internal_utils import _raise_error_if_not_sframe
  from turicreate.toolkits._internal_utils import _validate_data
  from turicreate.toolkits._main import ToolkitError
  from turicreate._cython.cy_server import QuietProgress
label_desc: Use image node_id 2 for calling a global function with example usage: create(dataset, target, model_name, features, validation_set, distributed, verbose, seed) and returns: SupervisedLearningModel