benchmark integration

import deepchem

from deepchem.molnet.run_benchmark_models import benchmark_classification, benchmark_regression

from deepchem.molnet.check_availability import CheckFeaturizer, CheckSplit

from deepchem.molnet.preset_hyper_parameters import hps

def run_benchmark(datasets,

                  n_features=0,

                  out_path='.',

                  hyper_parameters=None,

                  hyper_param_search=False,

                  max_iter=20,

                  search_range=4,

                  test=False,

                  reload=True,

                  seed=123):

      path of result file

  hyper_parameters: dict, optional (default=None)

      hyper parameters for designated model, None = use preset values

  hyper_param_search: bool, optional(default=False)

      whether to perform hyper parameter search, using gaussian process by default

  max_iter: int, optional(default=20)

      number of optimization trials

  search_range: int(float), optional(default=4)

      optimization on [initial values / search_range,

                       initial values * search_range]

  test: boolean, optional(default=False)

      whether to evaluate on test set

  reload: boolean, optional(default=True)

    valid_score = {}

    test_score = {}

    if hyper_param_search:

      if hyper_parameters is None:

        hyper_parameters = hps[model]

      search_mode = deepchem.hyper.GaussianProcessHyperparamOpt(model)

      hyper_param_opt, _ = search_mode.hyperparam_search(

          hyper_parameters,

          train_dataset,

          valid_dataset,

          transformers,

          metric,

          n_features=n_features,

          n_tasks=len(tasks),

          max_iter=max_iter,

          search_range=search_range)

      hyper_parameters = hyper_param_opt

    if isinstance(model, str):

      if mode == 'classification':

        train_score, valid_score, test_score = benchmark_classification(