UV additions

    ids = ids[available_rows]

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

def load_uv(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 remove_UV_negative_entries(dataset):

  """Remove negative entries from UV dataset.

  Negative entries are malformed for UV dataset. Remove them.

  """

  for i, (X, y, w, ids) in enumerate(dataset.itershards()):

    malformed = np.where(y <= 0) 

    y[malformed] = 0

    w[malformed] = 0

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

def gen_uv(UV_tasks, raw_train_dir, train_dir, valid_dir, test_dir,

           shard_size=10000):

  """Load UV datasets."""

  verbosity = "high"

  train_files = ("UV_training_disguised_combined_full.csv.gz")

  valid_files = ("UV_test1_disguised_combined_full.csv.gz")

  test_files = ("UV_test2_disguised_combined_full.csv.gz")

  # Featurize UV dataset

  print("About to featurize UV dataset.")

  featurizer = dc.feat.UserDefinedFeaturizer(merck_descriptors)

  UV_tasks = (['logTIC'] +

                  ['w__%d' % i for i in range(210, 401)])

  featurizer = dc.feat.UserDefinedFeaturizer(uv_descriptors)

  loader = dc.load.DataLoader(

      tasks=UV_tasks, id_field="Molecule",

      featurizer=featurizer, verbosity=verbosity)

  loader = dc.data.UserCSVLoader(

      tasks=UV_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)

  remove_missing_entries(valid_dataset)

  remove_missing_entries(test_dataset)

  print("Remove malformed datapoints from UV dataset.")

  remove_UV_negative_entries(train_dataset)

  remove_UV_negative_entries(valid_dataset)

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

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

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

  UV_tasks = (['logTIC'] +

                  ['w__%d' % i for i in range(210, 401)])

  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_uv(UV_tasks, raw_train_dir, train_dir, valid_dir, test_dir,

                  shard_size=shard_size)

  transformers = get_transformers(raw_train_dataset)

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

import shutil

import deepchem as dc

from sklearn.ensemble import RandomForestRegressor

from MERCK_datasets import load_uv

from UV_datasets import load_uv

###Load data###

np.random.seed(123)

shard_size = 2000

num_cores = 1

num_shards_per_batch = 4

num_trials = 5

print("About to load UV data.")

UV_tasks, datasets, transformers = load_uv(

    shard_size=shard_size, num_shards_per_batch=num_shards_per_batch)

UV_tasks, datasets, transformers = load_uv(shard_size=shard_size)

train_dataset, valid_dataset, test_dataset = datasets

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

print("np.amin(train_dataset.y)")

print(np.amin(train_dataset.y))

print("np.amax(train_dataset.y)")

print(np.amax(train_dataset.y))

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

print("Number of compounds in train set")

print(len(train_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(UV_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(UV_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)

"""

Script that trains Tensorflow Robust Multitask models on UV 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_uv

# Set numpy seed

np.random.seed(123)

###Load data###

shard_size = 2000

num_shards_per_batch = 4

print("About to load MERCK data.")

UV_tasks, datasets, transformers = load_uv(

    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(UV_tasks), train_dataset.get_data_shape()[0],

    layer_sizes=[500]*n_layers, bypass_layer_sizes=[40]*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)