Commit 26d11c98 authored by Bharath Ramsundar's avatar Bharath Ramsundar
Browse files

Kinase changes

parent 09eee217

examples/kinase/KINASE_datasets.py

+59 −23
Original line number Diff line number Diff line
@@ -28,36 +28,38 @@ def remove_missing_entries(dataset): 
    ids = ids[available_rows]

    dataset.set_shard(i, X, y, w, ids)



def load_kinase(shard_size=10000, num_shards_per_batch=4):

def get_transformers(train_dataset):

  """Get transformers applied to datasets."""

  #transformers = []

  transformers = [

      dc.trans.LogTransformer(transform_X=True),

      dc.trans.NormalizationTransformer(transform_y=True,

                                        dataset=train_dataset)]

  return transformers



def gen_kinase(KINASE_tasks, raw_train_dir, train_dir, valid_dir, test_dir,

                shard_size=10000):

  """Load Kinase datasets."""

  verbosity = "high"

  train_files = ("KINASE_training_disguised_combined_full.csv.gz")

  valid_files = ("KINASE_test1_disguised_combined_full.csv.gz")

  test_files = ("KINASE_test2_disguised_combined_full.csv.gz")



  # Featurize Kinase dataset

  print("About to featurize KINASE dataset.")

  featurizer = dc.feat.UserDefinedFeaturizer(merck_descriptors)

  KINASE_tasks = (['T_000%d' % i for i in range(13, 100)]

                  + ['T_00%d' % i for i in range(100, 112)])

  featurizer = dc.feat.UserDefinedFeaturizer(kinase_descriptors)



  loader = dc.load.DataLoader(

      tasks=KINASE_tasks, id_field="Molecule",

      featurizer=featurizer, verbosity=verbosity)

  loader = dc.data.UserCSVLoader(

      tasks=KINASE_tasks, id_field="Molecule", featurizer=featurizer)



  train_datasets, valid_datasets, test_datasets = [], [], []

  print("Featurizing train datasets")

  train_dataset = loader.featurize(

      train_files, 

      shard_size=shard_size, num_shards_per_batch=num_shards_per_batch)

  train_dataset = loader.featurize(train_files, shard_size=shard_size)



  print("Featurizing valid datasets")

  valid_dataset = loader.featurize(

      valid_files, shard_size=shard_size)

  valid_dataset = loader.featurize(valid_files, shard_size=shard_size)



  print("Featurizing test datasets")

  test_dataset = loader.featurize(

      test_files, shard_size=shard_size)

  test_dataset = loader.featurize(test_files, shard_size=shard_size)



  print("Remove missing entries from datasets.")

  remove_missing_entries(train_dataset)
@@ -65,19 +67,53 @@ def load_kinase(shard_size=10000, num_shards_per_batch=4): 
  remove_missing_entries(test_dataset)



  print("Transforming datasets with transformers.")

  transformers = [

      dc.trans.LogTransformer(transform_X=True),

      dc.trans.NormalizationTransformer(transform_y=True,

                                        dataset=train_dataset)]

  transformers = get_transformers(train_dataset)

  raw_train_dataset = train_dataset



  for transformer in transformers:

    print("Performing transformations with %s"

          % transformer.__class__.__name__)

    for dataset in [train_dataset, valid_dataset, test_dataset]:

      print("Transforming dataset")

      transformer.transform(dataset)

    print("Transforming datasets")

    train_dataset = transformer.transform(train_dataset)

    valid_dataset = transformer.transform(valid_dataset)

    test_dataset = transformer.transform(test_dataset)



  print("Shuffling order of train dataset.")

  train_dataset.sparse_shuffle()



  return KINASE_tasks, (train_dataset, valid_dataset, test_dataset), transformers

  print("Moving directories")

  raw_train_dataset.move(raw_train_dir)

  train_dataset.move(train_dir)

  valid_dataset.move(valid_dir)

  test_dataset.move(test_dir)

  

  return (raw_train_dataset, train_dataset, valid_dataset, test_dataset)



def load_kinase(shard_size):

  """Loads kinase datasets. Generates if not stored already."""

  KINASE_tasks = (['T_000%d' % i for i in range(13, 100)]

                  + ['T_00%d' % i for i in range(100, 112)])



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

  raw_train_dir = os.path.join(current_dir, "raw_train_dir")

  train_dir = os.path.join(current_dir, "train_dir") 

  valid_dir = os.path.join(current_dir, "valid_dir") 

  test_dir = os.path.join(current_dir, "test_dir") 



  if (os.path.exists(raw_train_dir) and

      os.path.exists(train_dir) and

      os.path.exists(valid_dir) and

      os.path.exists(test_dir)):

    print("Reloading existing datasets")

    raw_train_dataset = dc.data.DiskDataset(raw_train_dir)

    train_dataset = dc.data.DiskDataset(train_dir)

    valid_dataset = dc.data.DiskDataset(valid_dir)

    test_dataset = dc.data.DiskDataset(test_dir)

  else:

    print("Featurizing datasets")

    (raw_train_dataset, train_dataset, valid_dataset, test_dataset) = \

      gen_kinase(KINASE_tasks, raw_train_dir, train_dir, valid_dir, test_dir,

                  shard_size=shard_size)



  transformers = get_transformers(raw_train_dataset)

  return KINASE_tasks, (train_dataset, valid_dataset, test_dataset), transformers

examples/kinase/KINASE_rf_model.py

+59 −22
Original line number Diff line number Diff line
@@ -11,15 +11,14 @@ import tempfile 
import shutil

import deepchem as dc

from sklearn.ensemble import RandomForestRegressor

from MERCK_datasets import load_kinase

from KINASE_datasets import load_kinase



###Load data###

np.random.seed(123)

shard_size = 2000

num_cores = 1

num_shards_per_batch = 4

num_trials = 5

print("About to load KINASE data.")

KINASE_tasks, datasets, transformers = load_kinase(

    shard_size=shard_size, num_shards_per_batch=num_shards_per_batch)

KINASE_tasks, datasets, transformers = load_kinase(shard_size=shard_size)

train_dataset, valid_dataset, test_dataset = datasets



print("Number of compounds in train set")
@@ -32,30 +31,68 @@ print(len(test_dataset)) 
num_features = train_dataset.get_data_shape()[0]

print("Num features: %d" % num_features)



metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, task_averager=np.mean)



def task_model_builder(model_dir):

  sklearn_model = RandomForestRegressor(

      n_estimators=100, max_features=int(num_features/3),

      #n_estimators=100, max_features=int(num_features/3),

      n_estimators=1, max_features=int(num_features/3),

      min_samples_split=5, n_jobs=-1)

  return dc.models.SklearnModel(sklearn_model, model_dir)

model = dc.models.SingletaskToMultitask(KINASE_tasks, task_model_builder)



###Evaluate models###

metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, task_averager=np.mean,

                           mode="regression")

all_results = []

for trial in range(num_trials):

  print("Starting trial %d" % trial)

  model = dc.models.SingletaskToMultitask(KINASE_tasks, task_model_builder)



  print("Training model")

  model.fit(train_dataset)



train_scores = model.evaluate(train_dataset, [metric], transformers)

valid_scores = model.evaluate(valid_dataset, [metric], transformers)

#Only use for final evaluation

test_scores = model.evaluate(test_dataset, [metric], transformers)

  print("Evaluating models")

  train_score, train_task_scores = model.evaluate(

      train_dataset, [metric], transformers, per_task_metrics=True)

  valid_score, valid_task_scores = model.evaluate(

      valid_dataset, [metric], transformers, per_task_metrics=True)

  test_score, test_task_scores = model.evaluate(

      test_dataset, [metric], transformers, per_task_metrics=True)



  all_results.append((train_score, train_task_scores,

                      valid_score, valid_task_scores,

                      test_score, test_task_scores))



print("Train scores")

print(train_scores)

  print("----------------------------------------------------------------")

  print("Scores for trial %d" % trial)

  print("----------------------------------------------------------------")

  print("train_task_scores")

  print(train_task_scores)

  print("Mean Train score")

  print(train_score)

  print("valid_task_scores")

  print(valid_task_scores)

  print("Mean Validation score")

  print(valid_score)

  print("test_task_scores")

  print(test_task_scores)

  print("Mean Test score")

  print(test_score)



print("Validation scores")

print(valid_scores)

print("####################################################################")



print("Test scores")

print(test_scores)
 
for trial in range(num_trials):

  (train_score, train_task_scores, valid_score, valid_task_scores,

   test_score, test_task_scores) = all_results[trial]

  print("----------------------------------------------------------------")

  print("Scores for trial %d" % trial)

  print("----------------------------------------------------------------")

  print("train_task_scores")

  print(train_task_scores)

  print("Mean Train score")

  print(train_score)

  print("valid_task_scores")

  print(valid_task_scores)

  print("Mean Validation score")

  print(valid_score)

  print("test_task_scores")

  print(test_task_scores)

  print("Mean Test score")

  print(test_score)

examples/kinase/KINASE_tf_robust.py

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

Script that trains Tensorflow Robust Multitask models on KINASE datasets.

"""



from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals



import os

import numpy as np

import tempfile

import shutil

import deepchem as dc

from MERCK_datasets import load_kinase



###Load data###

shard_size = 2000

num_shards_per_batch = 4

print("About to load MERCK data.")

KINASE_tasks, datasets, transformers = load_kinase(

    shard_size=shard_size, num_shards_per_batch=num_shards_per_batch)

train_dataset, valid_dataset, test_dataset = datasets



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



n_layers = 3

n_bypass_layers = 3

nb_epoch = 30

model = dc.models.RobustMultitaskRegressor(

    len(KINASE_tasks), train_dataset.get_data_shape()[0],

    layer_sizes=[500]*n_layers, bypass_layer_sizes=[50]*n_bypass_layers,

    dropouts=[.25]*n_layers, bypass_dropouts=[.25]*n_bypass_layers, 

    weight_init_stddevs=[.02]*n_layers, bias_init_consts=[.5]*n_layers,

    bypass_weight_init_stddevs=[.02]*n_bypass_layers,

    bypass_bias_init_consts=[.5]*n_bypass_layers,

    learning_rate=.0003, penalty=.0001, penalty_type="l2",

    optimizer="adam", batch_size=100, verbosity="high")



#Use R2 classification metric

metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, task_averager=np.mean)



print("Optimizing Hyperparameters")

model.fit(train_dataset, nb_epoch=nb_epoch)



train_scores = model.evaluate(train_dataset, [metric], transformers)

valid_scores = model.evaluate(valid_dataset, [metric], transformers)

#Only use for final evaluation

test_scores = model.evaluate(test_dataset, [metric], transformers)



print("Train scores")

print(train_scores)



print("Validation scores")

print(valid_scores)



print("Test scores")

print(test_scores)

CRA Git | Maintained and supported by SUSTech CRA and CCSE