code: def create(
      style_dataset,
      content_dataset,
      style_feature=None,
      content_feature=None,
      max_iterations=None,
      model="resnet-16",
      verbose=True,
      batch_size=1,
      **kwargs,
  ):
      """
      Create a :class:`StyleTransfer` model.
  
      Parameters
      ----------
      style_dataset: SFrame
          Input style images. The columns named by the ``style_feature`` parameters will
          be extracted for training the model.
  
      content_dataset : SFrame
          Input content images. The columns named by the ``content_feature`` parameters will
          be extracted for training the model.
  
      style_feature: string
          Name of the column containing the input images in style SFrame.
          'None' (the default) indicates the only image column in the style SFrame
          should be used as the feature.
  
      content_feature: string
          Name of the column containing the input images in content SFrame.
          'None' (the default) indicates the only image column in the content
          SFrame should be used as the feature.
  
      max_iterations : int
          The number of training iterations. If 'None' (the default), then it will
          be automatically determined based on the amount of data you provide.
  
      model : string optional
          Style transfer model to use:
  
              - "resnet-16" : Fast and small-sized residual network that uses
                              VGG-16 as reference network during training.
  
      batch_size : int, optional
          If you are getting memory errors, try decreasing this value. If you
          have a powerful computer, increasing this value may improve training
          throughput.
  
      verbose : bool, optional
          If True, print progress updates and model details.
  
  
      Returns
      -------
      out : StyleTransfer
          A trained :class:`StyleTransfer` model.
  
      See Also
      --------
      StyleTransfer
  
      Examples
      --------
      .. sourcecode:: python
  
          # Create datasets
          >>> content_dataset = turicreate.image_analysis.load_images('content_images/')
          >>> style_dataset = turicreate.image_analysis.load_images('style_images/')
  
          # Train a style transfer model
          >>> model = turicreate.style_transfer.create(content_dataset, style_dataset)
  
          # Stylize an image on all styles
          >>> stylized_images = model.stylize(data)
  
          # Visualize the stylized images
          >>> stylized_images.explore()
  
      """
      if not isinstance(style_dataset, _tc.SFrame):
          raise TypeError('"style_dataset" must be of type SFrame.')
      if not isinstance(content_dataset, _tc.SFrame):
          raise TypeError('"content_dataset" must be of type SFrame.')
      if len(style_dataset) == 0:
          raise _ToolkitError("style_dataset SFrame cannot be empty")
      if len(content_dataset) == 0:
          raise _ToolkitError("content_dataset SFrame cannot be empty")
      if batch_size < 1:
          raise _ToolkitError(
              "'batch_size' must be greater than or equal to 1"
          )
      if max_iterations is not None and (
          not isinstance(max_iterations, int) or max_iterations < 0
      ):
          raise _ToolkitError(
              "'max_iterations' must be an integer greater than or equal to 0"
          )
  
      if style_feature is None:
          style_feature = _tkutl._find_only_image_column(style_dataset)
  
      if content_feature is None:
          content_feature = _tkutl._find_only_image_column(
              content_dataset
          )
      if verbose:
          print(
              "Using '{}' in style_dataset as feature column and using "
              "'{}' in content_dataset as feature column".format(
                  style_feature, content_feature
              )
          )
  
      _raise_error_if_not_training_sframe(style_dataset, style_feature)
      _raise_error_if_not_training_sframe(
          content_dataset, content_feature
      )
      _tkutl._handle_missing_values(
          style_dataset, style_feature, "style_dataset"
      )
      _tkutl._handle_missing_values(
          content_dataset, content_feature, "content_dataset"
      )
  
      params = {
          "batch_size": batch_size,
          "vgg16_content_loss_layer": 2,  # conv3_3 layer
          "lr": 0.001,
          "content_loss_mult": 1.0,
          "style_loss_mult": [
              1e-4,
              1e-4,
              1e-4,
              1e-4,
          ],  # conv 1-4 layers
          "finetune_all_params": True,
          "pretrained_weights": False,
          "print_loss_breakdown": False,
          "input_shape": (256, 256),
          "training_content_loader_type": "stretch",
          "use_augmentation": False,
          "sequential_image_processing": False,
          # Only used if use_augmentaion is True
          "aug_resize": 0,
          "aug_min_object_covered": 0,
          "aug_rand_crop": 0.9,
          "aug_rand_pad": 0.9,
          "aug_rand_gray": 0.0,
          "aug_aspect_ratio": 1.25,
          "aug_hue": 0.05,
          "aug_brightness": 0.05,
          "aug_saturation": 0.05,
          "aug_contrast": 0.05,
          "aug_horizontal_flip": True,
          "aug_area_range": (0.05, 1.5),
          "aug_pca_noise": 0.0,
          "aug_max_attempts": 20,
          "aug_inter_method": 2,
          "checkpoint": False,
          "checkpoint_prefix": "style_transfer",
          "checkpoint_increment": 1000,
      }
  
      if "_advanced_parameters" in kwargs:
          # Make sure no additional parameters are provided
          new_keys = set(kwargs["_advanced_parameters"].keys())
          set_keys = set(params.keys())
          unsupported = new_keys - set_keys
          if unsupported:
              raise _ToolkitError(
                  "Unknown advanced parameters: {}".format(unsupported)
              )
  
          params.update(kwargs["_advanced_parameters"])
  
      name = "style_transfer"
  
      import turicreate as _turicreate
  
      # Imports tensorflow
      _minimal_package_import_check(
          "turicreate.toolkits.libtctensorflow"
      )
  
      model = _turicreate.extensions.style_transfer()
      pretrained_resnet_model = (
          _pre_trained_models.STYLE_TRANSFER_BASE_MODELS["resnet-16"]()
      )
      pretrained_vgg16_model = (
          _pre_trained_models.STYLE_TRANSFER_BASE_MODELS["Vgg16"]()
      )
      options = {}
      options["image_height"] = params["input_shape"][0]
      options["image_width"] = params["input_shape"][1]
      options["content_feature"] = content_feature
      options["style_feature"] = style_feature
      if verbose is not None:
          options["verbose"] = verbose
      else:
          options["verbose"] = False
      if batch_size is not None:
          options["batch_size"] = batch_size
      if max_iterations is not None:
          options["max_iterations"] = max_iterations
      options["num_styles"] = len(style_dataset)
      options[
          "resnet_mlmodel_path"
      ] = pretrained_resnet_model.get_model_path("coreml")
      options[
          "vgg_mlmodel_path"
      ] = pretrained_vgg16_model.get_model_path("coreml")
      options["pretrained_weights"] = params["pretrained_weights"]
  
      model.train(
          style_dataset[style_feature],
          content_dataset[content_feature],
          options,
      )
      return StyleTransfer(model_proxy=model, name=name)
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import turicreate.toolkits._internal_utils
  from turicreate.toolkits import _coreml_utils
  from turicreate.toolkits._internal_utils import _raise_error_if_not_sframe
  from turicreate._deps.minimal_package import _minimal_package_import_check
  from ..None import _pre_trained_models
  from turicreate.toolkits._model import Model
  from turicreate.toolkits._main import ToolkitError
  import turicreate
  from .._mps_utils import MpsStyleGraphAPI
label_desc: Use image node_id 2 for calling a global function with example usage: create(style_dataset, content_dataset, style_feature, content_feature, max_iterations, model, verbose, batch_size) and returns: StyleTransfer