Merge pull request #1339 from lilleswing/specified-id-splitter

    # Sort from largest to smallest scaffold sets

    scaffolds = {key: sorted(value) for key, value in scaffolds.items()}

    scaffold_sets = [

        scaffold_set

        for (scaffold, scaffold_set) in sorted(

        scaffold_set for (scaffold, scaffold_set) in sorted(

            scaffolds.items(), key=lambda x: (len(x[1]), x[1][0]), reverse=True)

    ]

    train_cutoff = frac_train * len(dataset)

    return train_inds, valid_inds, test_inds

class SpecifiedIndexSplitter(Splitter):

  """

  Class that splits data according to user index specification

  """

  def __init__(self, train_inds, valid_inds, test_inds, verbose=False):

    """Provide input information for splits."""

    self.train_inds = train_inds

    self.valid_inds = valid_inds

    self.test_inds = test_inds

    self.verbose = verbose

    super(SpecifiedIndexSplitter, self).__init__(verbose)

  def split(self,

            dataset,

            frac_train=.8,

            frac_valid=.1,

            frac_test=.1,

            log_every_n=1000,

            verbose=False):

    """

    Splits internal compounds into train/validation/test by user-specification.

    """

    return self.train_inds, self.valid_inds, self.test_inds

class TimeSplitterPDBbind(Splitter):

  def __init__(self, ids, year_file=None, verbose=False):

from unittest import TestCase

import deepchem

import numpy as np

from sklearn.model_selection import train_test_split

from deepchem.splits import SpecifiedIndexSplitter

class TestSpecifiedIndexSplitter(TestCase):

  def create_dataset(self):

    n_samples, n_features = 20, 10

    X = np.random.random(size=(n_samples, n_features))

    y = np.random.random(size=(n_samples, 1))

    return deepchem.data.NumpyDataset(X, y)

  def test_split(self):

    ds = self.create_dataset()

    indexes = list(range(len(ds)))

    train, test = train_test_split(indexes)

    train, valid = train_test_split(train)

    splitter = SpecifiedIndexSplitter(train, valid, test)

    train_ds, valid_ds, test_ds = splitter.train_valid_test_split(ds)

    self.assertTrue(np.all(train_ds.X == ds.X[train]))

    self.assertTrue(np.all(valid_ds.X == ds.X[valid]))

    self.assertTrue(np.all(test_ds.X == ds.X[test]))