Commit 58d3a2f4 authored by Bharath Ramsundar's avatar Bharath Ramsundar
Browse files

factors changes

parent 8b004c53

examples/factors/FACTORS_datasets.py

+57 −18
Original line number Diff line number Diff line
@@ -28,28 +28,32 @@ def remove_missing_entries(dataset): 
    ids = ids[available_rows]

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



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

def get_transformers(train_dataset):

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

  #transformers = [

  #    dc.trans.LogTransformer(transform_X=True),

  #    dc.trans.NormalizationTransformer(transform_y=True,

  #                                      dataset=train_dataset)]

  transformers = []

  return transformers



def gen_factors(FACTORS_tasks, raw_train_dir, train_dir, valid_dir, test_dir,

                shard_size=10000):

  """Load Factor datasets."""

  verbosity = "high"

  train_files = ("FACTORS_training_disguised_combined_full.csv.gz")

  valid_files = ("FACTORS_test1_disguised_combined_full.csv.gz")

  test_files = ("FACTORS_test2_disguised_combined_full.csv.gz")



  # Featurize FACTORS dataset

  print("About to featurize FACTORS dataset.")

  featurizer = dc.feat.UserDefinedFeaturizer(merck_descriptors)

  FACTORS_tasks = (['T_0000%d' % i for i in range(1, 10)]

                   + ['T_000%d' % i for i in range(10, 13)])

  featurizer = dc.feat.UserDefinedFeaturizer(factors_descriptors)



  loader = dc.load.DataLoader(

      tasks=FACTORS_tasks, id_field="Molecule",

      featurizer=featurizer, verbosity=verbosity)

  loader = dc.data.UserCSVLoader(

      tasks=FACTORS_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(
@@ -66,18 +70,53 @@ def load_factors(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()



  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_factors(shard_size):

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

  FACTORS_tasks = (['T_0000%d' % i for i in range(1, 10)]

                   + ['T_000%d' % i for i in range(10, 13)])



  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_factors(FACTORS_tasks, raw_train_dir, train_dir, valid_dir, test_dir,

                  shard_size=shard_size)



  transformers = get_transformers(raw_train_dataset)

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

examples/factors/FACTORS_rf_model.py

+54 −21
Original line number Diff line number Diff line
@@ -11,16 +11,14 @@ import tempfile 
import shutil

import deepchem as dc

from sklearn.ensemble import RandomForestRegressor

from MERCK_datasets import load_factors

from FACTORS_datasets import load_factors



###Load data###

np.random.seed(123)

shard_size = 2000

num_cores = 1

num_shards_per_batch = 4

num_trials = 5

print("About to load FACTORS data.")

FACTORS_tasks, datasets, transformers = load_factors(

    shard_size=shard_size, num_shards_per_batch=num_shards_per_batch)

FACTORS_tasks, datasets, transformers = load_factors(shard_size=shard_size)

train_dataset, valid_dataset, test_dataset = datasets



print("Number of compounds in train set")
@@ -33,30 +31,65 @@ 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),

      min_samples_split=5, n_jobs=-1)

  return dc.models.SklearnModel(sklearn_model, model_dir)

model = dc.models.SingletaskToMultitask(FACTORS_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(FACTORS_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)



print("Train scores")

print(train_scores)

  all_results.append((train_score, train_task_scores,

                      valid_score, valid_task_scores,

                      test_score, test_task_scores))



print("Validation scores")

print(valid_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("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/factors/FACTORS_tf_model.py

+62 −30
Original line number Diff line number Diff line
@@ -11,17 +11,16 @@ import tempfile 
import shutil

import numpy as np

import deepchem as dc

from MERCK_datasets import load_factors

from FACTORS_datasets import load_factors



# Set numpy seed

np.random.seed(123)



###Load data###

shard_size = 2000

num_shards_per_batch = 4

print("About to load MERCK data.")

FACTORS_tasks, datasets, transformers = load_factors(

    shard_size=shard_size, num_shards_per_batch=num_shards_per_batch)

num_trials = 1

print("About to load FACTORS data.")

FACTORS_tasks, datasets, transformers = load_factors(shard_size=shard_size)

train_dataset, valid_dataset, test_dataset = datasets



print("Number of compounds in train set")
@@ -31,17 +30,18 @@ print(len(valid_dataset)) 
print("Number of compounds in test set")

print(len(test_dataset))



all_results = []

for trial in range(num_trials):

  ###Create model###

  n_layers = 3

  nb_epoch = 125 

#nb_epoch = 100

  model = dc.models.TensorflowMultiTaskRegressor(

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

      layer_sizes=[1000]*n_layers, dropouts=[.25]*n_layers,

      weight_init_stddevs=[.02]*n_layers,

      bias_init_consts=[1.]*n_layers, learning_rate=.0003,

      penalty=.0001, penalty_type="l2", optimizer="adam", batch_size=100,

    seed=123, verbosity="high")

      seed=123)



  #Use R2 classification metric

  metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, task_averager=np.mean)
@@ -49,16 +49,48 @@ metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, task_averager=np.mean) 
  print("Training model")

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



print("Train scores")

print(train_scores)

  all_results.append((train_score, train_task_scores,

                      valid_score, valid_task_scores,

                      test_score, test_task_scores))



print("Validation scores")

print(valid_scores)

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

CRA Git | Maintained and supported by SUSTech CRA and CCSE