Commit aaeddd0e authored by Bharath Ramsundar's avatar Bharath Ramsundar
Browse files

Loading bace data

parent 104f4f4d

deepchem/datasets/bace_datasets.py

0 → 100644
+228 −0
Original line number Diff line number Diff line 
import sys

import os

import deepchem

import tempfile, shutil

from deepchem.utils.save import load_from_disk

from deepchem.splits import SpecifiedSplitter

from deepchem.featurizers.featurize import DataFeaturizer

from deepchem.datasets import Dataset

from deepchem.transformers import NormalizationTransformer

from deepchem.transformers import ClippingTransformer

from deepchem.hyperparameters import HyperparamOpt

from sklearn.ensemble import RandomForestRegressor

from deepchem.models.sklearn_models import SklearnModel

from bace_features import user_specified_features

from deepchem import metrics

from deepchem.metrics import Metric

from deepchem.utils.evaluate import Evaluator



def load_bace(mode="regression", transform=True):

  """Load BACE-1 dataset as regression/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 = "/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")

  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")





  if mode == "regression":

    bace_tasks = ["pIC50"]

  elif mode == "classification":

    bace_tasks = ["Class"]

  else:

    raise ValueError("Unknown mode %s" % mode)

  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,

      reload=reload)



  crystal_featurized_samples = featurizer.featurize(

      crystal_dataset_file, crystal_feature_dir, crystal_samples_dir,

  shard_size=2000)





  splitter = SpecifiedSplitter(verbosity=verbosity)

  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))



  if transform:

    input_transformers = [

        NormalizationTransformer(transform_X=True, dataset=train_dataset),

        ClippingTransformer(transform_X=True, dataset=train_dataset)]

    output_transformers = []

    if mode == "regression":

      output_transformers = [

        NormalizationTransformer(transform_y=True, dataset=train_dataset)]

    else:

      output_transformers = []

  else:

    input_transformers, 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)



#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)

examples/bace/bace_dnn.py

0 → 100644
+80 −0
Original line number Diff line number Diff line 
import sys

import os

import deepchem

import tempfile, shutil

import numpy as np

import numpy.random

from deepchem.utils.save import load_from_disk

from deepchem.splits import SpecifiedSplitter

from deepchem.featurizers.featurize import DataFeaturizer

from deepchem.datasets import Dataset

from deepchem.transformers import NormalizationTransformer

from deepchem.transformers import ClippingTransformer

from deepchem.hyperparameters import HyperparamOpt

from sklearn.ensemble import RandomForestClassifier

from deepchem.models.sklearn_models import SklearnModel

from bace_features import user_specified_features

from deepchem import metrics

from deepchem.metrics import Metric

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"

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

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

  = load_bace(mode=mode)



def model_builder(tasks, task_types, params_dict, model_dir, verbosity=None):

    n_estimators = params_dict["n_estimators"]

    max_features = params_dict["max_features"]

    return SklearnModel(

        tasks, task_types, params_dict, model_dir, 

        model_instance=RandomForestClassifier(n_estimators=n_estimators,

                                              max_features=max_features))



params_dict = {"activation": ["relu"],

                "momentum": [.9],

                "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],

                "nb_hidden": [1000],

                "nb_epoch": [40],

                "nesterov": [False],

                "dropout": [.5],

                "nb_layers": [1],

                "batchnorm": [False],

              }



optimizer = HyperparamOpt(SingleTaskDNN, bace_tasks,

                          {task: mode for task in bace_tasks})

                          verbosity=verbosity)

best_dnn, best_hyperparams, all_results = optimizer.hyperparam_search(

    params_dict, train_dataset, valid_dataset, transformers,

    metric=metric)



dnn_train_evaluator = Evaluator(best_dnn, train_dataset, transformers)            

dnn_train_roc_auc_score = dnn_train_evaluator.compute_model_performance(

    [metric])

print("DNN Train set ROC-AUC %s" % str(dnn_train_roc_auc_score))



dnn_valid_evaluator = Evaluator(best_dnn, valid_dataset, transformers)            

dnn_valid_roc_auc_score = dnn_valid_evaluator.compute_model_performance(

    [metric])

print("DNN Valid set ROC-AUC %s" % str(dnn_valid_roc_auc_score))

                                                                                             

dnn_test_evaluator = Evaluator(best_dnn, test_dataset, transformers)

dnn_test_roc_auc_score = dnn_test_evaluator.compute_model_performance(

    [metric])

print("DNN Test set ROC-AUC %s" % str(dnn_test_roc_auc_score))



dnn_crystal_evaluator = Evaluator(best_dnn, crystal_dataset, transformers)

dnn_crystal_roc_auc_score = dnn_crystal_evaluator.compute_model_performance(

    [metric])

print("DNN Crystal set ROC-AUC %s" % str(dnn_crystal_roc_auc_score))

examples/bace/bace_rf.py

0 → 100644
+70 −0
Original line number Diff line number Diff line 
import sys

import os

import deepchem

import tempfile, shutil

from deepchem.utils.save import load_from_disk

from deepchem.splits import SpecifiedSplitter

from deepchem.featurizers.featurize import DataFeaturizer

from deepchem.datasets import Dataset

from deepchem.transformers import NormalizationTransformer

from deepchem.transformers import ClippingTransformer

from deepchem.hyperparameters import HyperparamOpt

from sklearn.ensemble import RandomForestRegressor

from sklearn.ensemble import RandomForestClassifier

from deepchem.models.sklearn_models import SklearnModel

from bace_features import user_specified_features

from deepchem import metrics

from deepchem.metrics import Metric

from deepchem.utils.evaluate import Evaluator

from deepchem.datasets.bace_datasets import load_bace



#mode = "regression"

mode = "classification"

verbosity = "high"

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

  load_bace(mode=mode, transform=False)



if mode == "regression":

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

  model_class = RandomForestRegressor

elif mode == "classification":

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

  model_class = RandomForestClassifier

else:

  raise ValueError("Invalid mode %s" % mode)



def model_builder(tasks, task_types, params_dict, model_dir, verbosity=verbosity):

    n_estimators = params_dict["n_estimators"]

    max_features = params_dict["max_features"]

    return SklearnModel(

        tasks, task_types, params_dict, model_dir,

        model_instance=model_class(n_estimators=n_estimators,

                                   max_features=max_features))

params_dict = {

    "n_estimators": [10, 100],

    "batch_size": [None],

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

    "max_features": ["auto", "sqrt", "log2", None],

    }

optimizer = HyperparamOpt(model_builder, bace_tasks,

                          {task: mode for task in bace_tasks})

best_rf, best_rf_hyperparams, all_rf_results = optimizer.hyperparam_search(

    params_dict, train_dataset, valid_dataset, transformers,

    metric=metric)



rf_train_evaluator = Evaluator(best_rf, train_dataset, transformers)

rf_train_scores = rf_train_evaluator.compute_model_performance([metric])

print("RF Train set %s: %s" % (metric.name, str(rf_train_scores)))



rf_valid_evaluator = Evaluator(best_rf, valid_dataset, transformers)

rf_valid_r2_score = rf_valid_evaluator.compute_model_performance([metric])

print("RF Valid set %s: %s" % (metric.name, str(rf_valid_r2_score)))



rf_test_evaluator = Evaluator(best_rf, test_dataset, transformers)

rf_test_r2_score = rf_test_evaluator.compute_model_performance([metric])

print("RF Test set %s: %s" % (metric.name, str(rf_test_r2_score)))



rf_crystal_evaluator = Evaluator(best_rf, crystal_dataset, transformers)

rf_crystal_r2_score = rf_crystal_evaluator.compute_model_performance(

    [metric])

print("RF Crystal set %s: %s" % (metric.name, str(rf_crystal_r2_score)))

CRA Git | Maintained and supported by SUSTech CRA and CCSE