pdbbind fix

    Splits internal compounds randomly into train/validation/test.

    """

    np.testing.assert_almost_equal(frac_train + frac_valid + frac_test, 1.)

    if not seed is None:

      np.random.seed(seed)

    num_datapoints = len(dataset)

    train_cutoff = int(frac_train * num_datapoints)

Giving regression performances of:

    MultitaskDNN(tf_regression),

    Graph convolution regression(graphconvreg)

on datasets: delaney, nci, kaggle

on datasets: delaney, nci, kaggle, pdbbind

time estimation listed in README file

from kaggle.kaggle_datasets import load_kaggle

from delaney.delaney_datasets import load_delaney

from nci.nci_datasets import load_nci

from pdbbind.pdbbind_datasets import load_pdbbind_grid

def benchmark_loading_datasets(hyper_parameters, 

                               dataset='tox21', model='tf', split=None,

  if dataset in ['muv', 'pcba', 'tox21', 'sider', 'toxcast']:

    mode = 'classification'

  elif dataset in ['kaggle', 'delaney', 'nci']:

  elif dataset in ['kaggle', 'delaney', 'nci','pdbbind']:

    mode = 'regression'

  else:

    raise ValueError('Dataset not supported')

  if dataset in ['kaggle']:

    featurizer = None #kaggle dataset use its own features

    split = None #kaggle dataset is already splitted

  if dataset in ['pdbbind']:

    featurizer = 'grid' #pdbbind use grid featurizer

    if split in ['scaffold']:

      return #skip the scaffold splitting of pdbbind

    elif not model in ['tf_regression']:

      return

  if not split in [None, 'index','random','scaffold']:

    raise ValueError('Splitter function not supported')

  loading_functions = {'tox21': load_tox21, 'muv': load_muv,

                       'pcba': load_pcba, 'nci': load_nci,

                       'sider': load_sider, 'toxcast': load_toxcast,

                       'kaggle': load_kaggle, 'delaney': load_delaney}

                       'kaggle': load_kaggle, 'delaney': load_delaney,

                       'pdbbind': load_pdbbind_grid}

  print('-------------------------------------')

  print('Benchmark %s on dataset: %s' % (model, dataset))

  train_dataset, valid_dataset, test_dataset = all_dataset

  time_finish_loading = time.time()

  #time_finish_loading-time_start is the time(s) used for dataset loading

  if dataset in ['kaggle']:

  if dataset in ['kaggle','pdbbind']:

    n_features = train_dataset.get_data_shape()[0]

    #kaggle dataset has customized features

           'tf_regression, graphconvreg')

  parser.add_argument('-d', action='append', dest='dataset_args', default=[], 

      help='Choice of dataset: tox21, sider, muv, toxcast, pcba, ' + 

           'kaggle, delaney, nci')

           'kaggle, delaney, nci, pdbbind')

  args = parser.parse_args()

  #Datasets and models used in the benchmark test

  splitters = args.splitter_args

              'tf_regression', 'graphconvreg']

  if len(datasets) == 0:

    datasets = ['tox21', 'sider', 'muv', 'toxcast', 'pcba', 

                'delaney', 'nci', 'kaggle']

                'delaney', 'nci', 'kaggle', 'pdbbind']

  #input hyperparameters

  #tf: dropouts, learning rate, layer_sizes, weight initial stddev,penalty,

  dataset = dc.data.DiskDataset.from_numpy(X, y, w, ids, data_dir=data_dir)

  return dataset, tasks

def load_pdbbind_grid(split="index", feat="grid", subset="core"):

def load_pdbbind_grid(split="index", featurizer="grid", subset="full"):

  """Load PDBBind datasets. Does not do train/test split"""

  dataset, tasks = featurize_pdbbind(feat=feat, subset=subset)

  dataset, tasks = featurize_pdbbind(feat=featurizer, subset=subset)

  splitters = {'index': dc.splits.IndexSplitter(),

               'random': dc.splits.RandomSplitter()}