Commit 4a784b76 authored by Bharath Ramsundar's avatar Bharath Ramsundar
Browse files

Committing before merge from upstream.

parent a8c65e9e

deepchem/hyperparameters/__init__.py

0 → 100644
+86 −0
Original line number Diff line number Diff line 
"""

Contains basic hyperparameter optimizations.

"""

import tempfile

import shutil



model_params = {"activation": "relu",

                "momentum": .9,

                "batch_size": 50,

                "init": "glorot_uniform",

                "data_shape": train_dataset.get_data_shape()}

lr_list = np.power(10., np.random.uniform(-5, -2, size=5))

decay_list = np.power(10, np.random.uniform(-6, -4, size=5))

nb_hidden_list = [500, 1000]

nb_epoch_list = [40]

nesterov_list = [False]

dropout_list = [0, .5]

nb_layers_list = [1]

batchnorm_list = [False]



#hyperparameters = [lr_list, decay_list, nb_layers_list,

#                   nb_hidden_list, nb_epoch_list, nesterov_list,

#                   dropout_list, batchnorm_list]

#    model_params["learning_rate"] = lr

#    model_params["decay"] = decay

#    model_params["nb_layers"] = nb_layers

#    model_params["nb_hidden"] = nb_hidden

#    model_params["nb_epoch"] = nb_epoch

#    model_params["nesterov"] = nesterov

#    model_params["dropout"] = dropout

#    model_params["batchnorm"] = batchnorm



class HyperparameterOpt(object):

  """

  Provides simple hyperparameter search capabilities.

  """



  def __init__(model_class, task_types):

    self.model_class = model_class

    self.task_types = task_types



  def hyperparam_search(params_dict, train_dataset, validation_dataset,

                        metric="r2_score"):

    """Perform hyperparams search according to params_dict.

    

    Each key to hyperparams_dict is a model_param. The values should be a list

    of potential values for that hyperparam. 

    """

    hyperparams = params_dict.keys()

    hyperparam_vals = [params_dict[hyperparam] for hyperparam in hyperparams]

    for hyperparam_list in hyperparams:

      assert isinstance(hyperparam_list, list)



    best_validation_score = -np.inf

    best_hyperparams = None

    best_model, best_model_dir = None, None

    all_scores = {}

    for ind, hyperparameter_tuple in enumerate(itertools.product(*hyperparameters)):

      for hyperparam, hyperparam_val in zip(hyperparams, hyperparameter_tuple):

        model_params[hyperparam] = hyperparam_val



      model_dir = tempfile.mkdtemp()

      model = self.model_class(task_types, model_params, verbosity=None)

      model.fit(train_dataset)

      model.save(model_dir)

    

      evaluator = Evaluator(model, valid_dataset, output_transformers)

      df, score = evaluator.compute_model_performance(

          valid_csv_out, valid_stats_out)

      valid_score = score.iloc[0][metric]

      print("Model %d, Validation set %s: %f" % (metric, ind, valid_score))

      all_scores[hyperparameter_tuple] = valid_score

    

      if valid_score > best_validation_score:

        best_validation_score = valid_score

        best_hyperparams = hyperparameter_tuple

        if best_model_dir is not None:

            shutil.rmtree(best_model_dir)

        best_model_dir = model_dir

        best_model = model

      else:

        shutil.rmtree(model_dir)



    print("Best hyperparameters: %s" % str(best_hyperparams))

    print("best_validation_score: %f" % best_validation_score)

    return best_model, best_hyperparams, all_scores

deepchem/models/__init__.py

+16 −39
Original line number Diff line number Diff line
@@ -18,8 +18,6 @@ class Model(object): 
  """

  Abstract base class for different ML models.

  """

  # List of registered models

  registered_model_classes = {}

  non_sklearn_models = ["SingleTaskDNN", "MultiTaskDNN", "DockingDNN"]

  def __init__(self, task_types, model_params, model_instance=None,

               initialize_raw_model=True, verbosity="low", **kwargs):
@@ -71,27 +69,6 @@ class Model(object): 
    """

    return os.path.join(out_dir, "model_params.joblib")



  @staticmethod

  def model_builder(model_instance, task_types, model_params,

                    initialize_raw_model=True):

    """

    Factory method that initializes model of requested type.

    """

    if model_instance.__class__ in non_sklearn_models:

      model = model_instance(task_types, model_params, initialize_raw_model)

    else:

      model = Model.registered_model_classes["SklearnModel"](model_instance, 

                                                       task_types, model_params,

                                                       initialize_raw_model)

    return model



  @staticmethod

  def register_model_type(model_class):

    """

    Registers model types in static variable for factory/dispatchers to use.

    """

    Model.registered_model_classes[model_class.__class__] = model_class



  @staticmethod

  def get_task_type(model_name):

    """
@@ -103,22 +80,22 @@ class Model(object): 
    else:

      return "regression"



  @staticmethod

  def load(model_dir):

    """Dispatcher function for loading."""

    params = load_from_disk(Model.get_params_filename(model_dir))

    model_class = params["model_class"]

    if model_class in Model.registered_model_classes:

      model = Model.registered_model_classes[model_class](

          task_types=params["task_types"],

          model_params=params["model_params"])

      model.load(model_dir)

    else:

      model = Model.registered_model_classes["SklearnModel"](model_instance=model_class,

                           task_types=params["task_types"],

                           model_params=params["model_params"])

      model.load(model_dir)

    return model

  #@staticmethod

  #def load(model_dir):

  #  """Dispatcher function for loading."""

  #  params = load_from_disk(Model.get_params_filename(model_dir))

  #  model_class = params["model_class"]

  #  if model_class in Model.registered_model_classes:

  #    model = Model.registered_model_classes[model_class](

  #        task_types=params["task_types"],

  #        model_params=params["model_params"])

  #    model.load(model_dir)

  #  else:

  #    model = Model.registered_model_classes["SklearnModel"](model_instance=model_class,

  #                         task_types=params["task_types"],

  #                         model_params=params["model_params"])

  #    model.load(model_dir)

  #  return model



  def save(self, out_dir):

    """Dispatcher function for saving."""

deepchem/models/standard.py

+0 −14
Original line number Diff line number Diff line
@@ -66,17 +66,3 @@ class SklearnModel(Model): 
  def load(self, model_dir):

    """Loads sklearn model from joblib file on disk."""

    self.raw_model = load_from_disk(Model.get_model_filename(model_dir))
 


Model.register_model_type(SklearnModel)



#TODO(enf/rbharath): deprecate the following if __init__.py functions as planned.

'''

Model.register_model_type("logistic", SklearnModel)

Model.register_model_type("rf_classifier", SklearnModel)

Model.register_model_type("rf_regressor", SklearnModel)

Model.register_model_type("linear", SklearnModel)

Model.register_model_type("ridge", SklearnModel)

Model.register_model_type("lasso", SklearnModel)

Model.register_model_type("lasso_lars", SklearnModel)

Model.register_model_type("elastic_net", SklearnModel)

'''

examples/BACE.ipynb

+105 −214

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE