Commit 846576bf authored by Bharath Ramsundar's avatar Bharath Ramsundar
Browse files

Finalizing BACE DNN example

parent 526a8d8b

deepchem/datasets/bace_datasets.py

+7 −106
Original line number Diff line number Diff line
@@ -48,7 +48,6 @@ def load_bace(mode="regression", transform=True, split="20-80"): 
  str(crystal_dataset.shape[0]))



  #Make directories to store the raw and featurized datasets.

  #base_dir = "/scratch/users/rbharath/bace_20_80"

  base_dir = tempfile.mkdtemp()

  feature_dir = os.path.join(base_dir, "features")

  samples_dir = os.path.join(base_dir, "samples")
@@ -86,11 +85,11 @@ def load_bace(mode="regression", transform=True, split="20-80"): 
  train_samples, valid_samples, test_samples = splitter.train_valid_test_split(

      featurized_samples, train_dir, valid_dir, test_dir,

      reload=reload)

  ######################## DEBUG

  print("bace_datasets")

  print("len(train_samples), len(valid_samples), len(test_samples)")

  print(len(train_samples), len(valid_samples), len(test_samples))

  ######################## DEBUG

  ######################### DEBUG

  #print("bace_datasets")

  #print("len(train_samples), len(valid_samples), len(test_samples)")

  #print(len(train_samples), len(valid_samples), len(test_samples))

  ######################### DEBUG



  #NOTE THE RENAMING:

  if split == "20-80":
@@ -124,11 +123,8 @@ def load_bace(mode="regression", transform=True, split="20-80"): 
        ClippingTransformer(transform_X=True, dataset=train_dataset)]

    output_transformers = []

    if mode == "regression":

      ######## DEBUG (TURN ME BACK ON!)

      #output_transformers = [

      #  NormalizationTransformer(transform_y=True, dataset=train_dataset)]

      ######## DEBUG (TURN ME BACK ON!)

      output_transformers = []

      output_transformers = [

        NormalizationTransformer(transform_y=True, dataset=train_dataset)]

    else:

      output_transformers = []

  else:
@@ -146,98 +142,3 @@ def load_bace(mode="regression", transform=True, split="20-80"): 


  #return (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, transformers)

  return (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, output_transformers)
 


#def load_classification_bace():

#  """Load BACE-1 dataset as classification problem."""

#  reload = True

#  verbosity = "high"

#

#  current_dir = os.path.dirname(os.path.realpath(__file__))

#  dataset_file = os.path.join(

#      current_dir, "../../datasets/desc_canvas_aug30.csv")

#  print("dataset_file")

#  print(dataset_file)

#  dataset = load_from_disk(dataset_file)

#  num_display = 10

#  pretty_columns = (

#      "[" + ",".join(["'%s'" % column for column in

#  dataset.columns.values[:num_display]])

#      + ",...]")

#

#  crystal_dataset_file = os.path.join(

#      current_dir, "../../datasets/crystal_desc_canvas_aug30.csv")

#  crystal_dataset = load_from_disk(crystal_dataset_file)

#

#  print("Columns of dataset: %s" % pretty_columns)

#  print("Number of examples in dataset: %s" % str(dataset.shape[0]))

#  print("Number of examples in crystal dataset: %s" %

#  str(crystal_dataset.shape[0]))

#  #Make directories to store the raw and featurized datasets.

#  base_dir = tempfile.mkdtemp()

#  feature_dir = os.path.join(base_dir, "features")

#  samples_dir = os.path.join(base_dir, "samples")

#  full_dir = os.path.join(base_dir, "full_dataset")

#  train_dir = os.path.join(base_dir, "train_dataset")

#  valid_dir = os.path.join(base_dir, "valid_dataset")

#  test_dir = os.path.join(base_dir, "test_dataset")

#  model_dir = os.path.join(base_dir, "model")

#  crystal_dir = os.path.join(base_dir, "crystal")

#  crystal_feature_dir = os.path.join(base_dir, "crystal_feature")

#  crystal_samples_dir = os.path.join(base_dir, "crystal_samples")

#

#  bace_tasks = ["Class"]

#  featurizer = DataFeaturizer(tasks=bace_tasks,

#                              smiles_field="mol",

#                              id_field="CID",

#                              user_specified_features=user_specified_features,

#                              split_field="Model")

#  featurized_samples = featurizer.featurize(

#      dataset_file, feature_dir, samples_dir, shard_size=2000)

#  crystal_featurized_samples = featurizer.featurize(

#      crystal_dataset_file, crystal_feature_dir, crystal_samples_dir,

#  shard_size=2000)

#

#  train_samples, valid_samples, test_samples = splitter.train_valid_test_split(

#      featurized_samples, train_dir, valid_dir, test_dir,

#      reload=reload)

#  ##NOTE THE RENAMING:

#  valid_samples, test_samples = test_samples, valid_samples

#

#  train_dataset = Dataset(data_dir=train_dir, samples=train_samples, 

#                            featurizers=[], tasks=bace_tasks,

#                            use_user_specified_features=True)

#  valid_dataset = Dataset(data_dir=valid_dir, samples=valid_samples, 

#                            featurizers=[], tasks=bace_tasks,

#                            use_user_specified_features=True)

#  test_dataset = Dataset(data_dir=test_dir, samples=test_samples, 

#                           featurizers=[], tasks=bace_tasks,

#                           use_user_specified_features=True)

#  crystal_dataset = Dataset(data_dir=crystal_dir,

#  samples=crystal_featurized_samples, 

#                              featurizers=[], tasks=bace_tasks,

#                              use_user_specified_features=True)

#  print("Number of compounds in train set")

#  print(len(train_dataset))

#  print("Number of compounds in validation set")

#  print(len(valid_dataset))

#  print("Number of compounds in test set")

#  print(len(test_dataset))

#  print("Number of compounds in crystal set")

#  print(len(crystal_dataset))

#

#

#  input_transformers = [

#      NormalizationTransformer(transform_X=True, dataset=train_dataset),

#      ClippingTransformer(transform_X=True, dataset=train_dataset)]

#  output_transformers = []

#  transformers = input_transformers + output_transformers

#  for transformer in transformers:

#      transformer.transform(train_dataset)

#  for transformer in transformers:

#      transformer.transform(valid_dataset)

#  for transformer in transformers:

#      transformer.transform(test_dataset)

#  for transformer in transformers:

#      transformer.transform(crystal_dataset)

#

#  return (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, transformers)

deepchem/hyperparameters/__init__.py

+2 −0
Original line number Diff line number Diff line
@@ -100,6 +100,8 @@ class HyperparamOpt(object): 


    if best_model is None:

      log("No models trained correctly.", self.verbosity, "low")

      # arbitrarily return last model

      best_model, best_hyperparams = model, hyperparameter_tuple

      return best_model, best_hyperparams, all_scores

    train_csv_out = tempfile.NamedTemporaryFile()

    train_stats_out = tempfile.NamedTemporaryFile()

deepchem/models/__init__.py

+9 −11
Original line number Diff line number Diff line
@@ -144,17 +144,15 @@ class Model(object): 
    y_pred = np.vstack(y_preds)



    ################ DEBUG

    y_plain = []

    for (X_batch, y_batch, w_batch, ids_batch) in dataset.iterbatches(batch_size):

      y_pred_batch = np.reshape(self.predict_on_batch(X_batch), y_batch.shape)

      y_plain.append(y_pred_batch)

    y_plain_pred = np.vstack(y_plain)

    y = dataset.get_labels()

    import sklearn

    print("sklearn.metrics.r2_score(y, y_plain_pred)")

    print(sklearn.metrics.r2_score(y, y_plain_pred))



    

    #y_plain = []

    #for (X_batch, y_batch, w_batch, ids_batch) in dataset.iterbatches(batch_size):

    #  y_pred_batch = np.reshape(self.predict_on_batch(X_batch), y_batch.shape)

    #  y_plain.append(y_pred_batch)

    #y_plain_pred = np.vstack(y_plain)

    #y = dataset.get_labels()

    #import sklearn

    #print("sklearn.metrics.r2_score(y, y_plain_pred)")

    #print(sklearn.metrics.r2_score(y, y_plain_pred))

    ################ DEBUG

  

    # The iterbatches does padding with zero-weight examples on the last batch.

deepchem/transformers/__init__.py

+15 −15
Original line number Diff line number Diff line
@@ -107,18 +107,18 @@ class NormalizationTransformer(Transformer): 
    self.y_stds = y_stds



  def transform(self, dataset, parallel=False):

    X_means, X_stds, y_means, y_stds = dataset.get_statistics()

    ##################### DEBUG

    print("NormalizationTransformer.tranform()")

    print("y_means, y_stds")

    print(y_means, y_stds)

    #X_means, X_stds, y_means, y_stds = dataset.get_statistics()

    #print("NormalizationTransformer.tranform()")

    #print("y_means, y_stds")

    #print(y_means, y_stds)

    #import traceback

    #traceback.print_stack()

    #self.X_means = X_means 

    #self.X_stds = X_stds

    #self.y_means = y_means 

    #self.y_stds = y_stds

    ##################### DEBUG

    self.X_means = X_means 

    self.X_stds = X_stds

    self.y_means = y_means 

    self.y_stds = y_stds

    super(NormalizationTransformer, self).transform(

        dataset, parallel=parallel)
@@ -143,13 +143,13 @@ class NormalizationTransformer(Transformer): 
    """

    Undo transformation on provided data.

    """

    ###################### DEBUG

    print("NormalizationTransformer.untranform()")

    print("np.amax(z), np.amin(z)")

    print(np.amax(z), np.amin(z))

    print("self.y_stds, self.y_means")

    print(self.y_stds, self.y_means)

    ###################### DEBUG

    ####################### DEBUG

    #print("NormalizationTransformer.untranform()")

    #print("np.amax(z), np.amin(z)")

    #print(np.amax(z), np.amin(z))

    #print("self.y_stds, self.y_means")

    #print(self.y_stds, self.y_means)

    ####################### DEBUG

    if self.transform_X:

      return z * self.X_stds + self.X_means

    elif self.transform_y:

examples/bace/bace_dnn.py

+24 −16
Original line number Diff line number Diff line
@@ -20,17 +20,24 @@ from deepchem.utils.evaluate import Evaluator 
from deepchem.datasets.bace_datasets import load_bace

from deepchem.models.keras_models.fcnet import SingleTaskDNN



#reload = True

#verbosity = "high"

#mode = "classification"



def bace_dnn_model(mode="classification", verbosity="high", split="20-80"):

  bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, transformers \

    = load_bace(mode=mode, transform=True, split=split)

  (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset,

   transformers) = load_bace(mode=mode, transform=True, split=split)



  if mode == "regression":

    metric = Metric(metrics.r2_score, verbosity=verbosity)

    r2_metric = Metric(metrics.r2_score, verbosity=verbosity)

    rms_metric = Metric(metrics.rms_score, verbosity=verbosity)

    mae_metric = Metric(metrics.mae_score, verbosity=verbosity)

    all_metrics = [r2_metric, rms_metric, mae_metric]

    metric = r2_metric

  elif mode == "classification":

    metric = Metric(metrics.roc_auc_score, verbosity=verbosity)

    accuracy_metric = Metric(metrics.accuracy_score, verbosity=verbosity)

    mcc_metric = Metric(metrics.matthews_corrcoef, verbosity=verbosity)

    # Note sensitivity = recall

    recall_metric = Metric(metrics.recall_score, verbosity=verbosity)

    all_metrics = [accuracy_metric, mcc_metric, recall_metric]

    metric = accuracy_metric

  else:

    raise ValueError("Invalid mode %s" % mode)
@@ -47,13 +54,10 @@ def bace_dnn_model(mode="classification", verbosity="high", split="20-80"): 
                  "batch_size": [50],

                  "init": ["glorot_uniform"],

                  "data_shape": [train_dataset.get_data_shape()],

                  #"learning_rate": np.power(10., np.random.uniform(-5, -2, size=5)),

                  "learning_rate": [1e-3],

                  #"decay": np.power(10, np.random.uniform(-6, -4, size=5)),

                  "decay": [1e-5],

                  "learning_rate": np.power(10., np.random.uniform(-5, -3, size=4)),

                  "decay": np.power(10, np.random.uniform(-6, -4, size=4)),

                  "nb_hidden": [1000],

                  "nb_epoch": [40],

                  #"nb_epoch": [1],

                  "nesterov": [False],

                  "dropout": [.5],

                  "nb_layers": [1],
@@ -70,29 +74,33 @@ def bace_dnn_model(mode="classification", verbosity="high", split="20-80"): 
  if len(train_dataset) > 0:

    dnn_train_evaluator = Evaluator(best_dnn, train_dataset, transformers)            

    csv_out = "dnn_%s_%s_train.csv" % (mode, split)

    stats_out = "dnn_%s_%s_train_stats.txt" % (mode, split)

    dnn_train_score = dnn_train_evaluator.compute_model_performance(

        [metric], csv_out=csv_out)

        all_metrics, csv_out=csv_out, stats_out=stats_out)

    print("DNN Train set %s: %s" % (metric.name, str(dnn_train_score)))



  if len(valid_dataset) > 0:

    dnn_valid_evaluator = Evaluator(best_dnn, valid_dataset, transformers)            

    csv_out = "dnn_%s_%s_valid.csv" % (mode, split)

    stats_out = "dnn_%s_%s_valid_stats.txt" % (mode, split)

    dnn_valid_score = dnn_valid_evaluator.compute_model_performance(

        [metric], csv_out=csv_out)

        all_metrics, csv_out=csv_out, stats_out=stats_out)

    print("DNN Valid set %s: %s" % (metric.name, str(dnn_valid_score)))

                                                                                               

  if len(test_dataset) > 0:

    dnn_test_evaluator = Evaluator(best_dnn, test_dataset, transformers)

    csv_out = "dnn_%s_%s_test.csv" % (mode, split)

    stats_out = "dnn_%s_%s_test_stats.txt" % (mode, split)

    dnn_test_score = dnn_test_evaluator.compute_model_performance(

        [metric], csv_out=csv_out)

        all_metrics, csv_out=csv_out, stats_out=stats_out)

    print("DNN Test set %s: %s" % (metric.name, str(dnn_test_score)))



  if len(crystal_dataset) > 0:

    dnn_crystal_evaluator = Evaluator(best_dnn, crystal_dataset, transformers)

    csv_out = "dnn_%s_%s_crystal.csv" % (mode, split)

    stats_out = "dnn_%s_%s_crystal_stats.txt" % (mode, split)

    dnn_crystal_score = dnn_crystal_evaluator.compute_model_performance(

        [metric], csv_out=csv_out)

        all_metrics, csv_out=csv_out, stats_out=stats_out)

    print("DNN Crystal set %s: %s" % (metric.name, str(dnn_crystal_score)))



if __name__ == "__main__":

CRA Git | Maintained and supported by SUSTech CRA and CCSE