code: def auto_train(
      dataset: Union[str, pd.DataFrame, dd.core.DataFrame],
      target: str,
      time_limit_s: Union[int, float],
      output_directory: str = OUTPUT_DIR,
      tune_for_memory: bool = False,
      user_config: Dict = None,
      random_seed: int = default_random_seed,
      use_reference_config: bool = False,
      **kwargs,
  ) -> AutoTrainResults:
      """Main auto train API that first builds configs for each model type (e.g. concat, tabnet, transformer). Then
      selects model based on dataset attributes. And finally runs a hyperparameter optimization experiment.
  
      All batch and learning rate tuning is done @ training time.
  
      # Inputs
      :param dataset: (str, pd.DataFrame, dd.core.DataFrame) data source to train over.
      :param target: (str) name of target feature
      :param time_limit_s: (int, float) total time allocated to auto_train. acts
                          as the stopping parameter
      :param output_directory: (str) directory into which to write results, defaults to
                               current working directory.
      :param tune_for_memory: (bool) refine hyperopt search space for available
                              host / GPU memory
      :param user_config: (dict) override automatic selection of specified config items
      :param random_seed: (int, default: `42`) a random seed that will be used anywhere
                          there is a call to a random number generator, including
                          hyperparameter search sampling, as well as data splitting,
                          parameter initialization and training set shuffling
      :param use_reference_config: (bool) refine hyperopt search space by setting first
                                   search point from reference model config, if any
      :param kwargs: additional keyword args passed down to `ludwig.hyperopt.run.hyperopt`.
  
      # Returns
      :return: (AutoTrainResults) results containing hyperopt experiments and best model
      """
      config = create_auto_config(
          dataset,
          target,
          time_limit_s,
          tune_for_memory,
          user_config,
          random_seed,
          use_reference_config=use_reference_config,
      )
      return train_with_config(
          dataset,
          config,
          output_directory=output_directory,
          random_seed=random_seed,
          **kwargs,
      )
  
imports: import argparse
  import copy
  import logging
  import os
  import warnings
  from typing import Any, Dict, List, Optional, Union
  import numpy
  import pandas
  import yaml
  from ludwig.api import LudwigModel
  from ludwig.api_annotations import PublicAPI
  from ludwig.automl.base_config import create_default_config, DatasetInfo, get_dataset_info, get_features_config, get_reference_configs
  from ludwig.backend import Backend, initialize_backend
  from ludwig.constants import AUTO, AUTOML_DEFAULT_IMAGE_ENCODER, AUTOML_DEFAULT_TABULAR_MODEL, AUTOML_DEFAULT_TEXT_ENCODER, BINARY, CATEGORY, ENCODER, HYPEROPT, IMAGE, INPUT_FEATURES, NAME, NUMBER, OUTPUT_FEATURES, TABULAR, TEXT, TRAINER, TYPE
  from ludwig.contrib import add_contrib_callback_args
  from ludwig.data.cache.types import CacheableDataset
  from ludwig.datasets import load_dataset_uris
  from ludwig.globals import LUDWIG_VERSION
  from ludwig.hyperopt.run import hyperopt
  from ludwig.schema.model_config import ModelConfig
  from ludwig.types import ModelConfigDict
  from ludwig.utils.automl.ray_utils import _ray_init
  from ludwig.utils.automl.utils import _add_transfer_config, get_model_type, set_output_feature_metric
  from ludwig.utils.data_utils import load_dataset, use_credentials
  from ludwig.utils.defaults import default_random_seed
  from ludwig.utils.fs_utils import open_file
  from ludwig.utils.heuristics import get_auto_learning_rate
  from ludwig.utils.misc_utils import merge_dict
  from ludwig.utils.print_utils import print_ludwig
label_desc: Use image node_id 1 for calling a global function with example usage: auto_train(dataset, target, time_limit_s, output_directory, tune_for_memory, user_config, random_seed, use_reference_config) and returns: train_with_config