Breaking out tests into separate files

import os

import deepchem as dc

import numpy as np

def test_DAG_transformer():

  """Tests the DAG transformer."""

  np.random.seed(123)

  n_tasks = 1

  # Load mini log-solubility dataset.

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

  featurizer = dc.feat.ConvMolFeaturizer()

  tasks = ["outcome"]

  input_file = os.path.join(current_dir,

                            "../../models/tests/example_regression.csv")

  loader = dc.data.CSVLoader(

      tasks=tasks, smiles_field="smiles", featurizer=featurizer)

  dataset = loader.create_dataset(input_file)

  transformer = dc.trans.DAGTransformer(max_atoms=50)

  dataset = transformer.transform(dataset)

  # The transformer generates n DAGs for a molecule with n

  # atoms. These are denoted the "parents"

  for idm, mol in enumerate(dataset.X):

    assert dataset.X[idm].get_num_atoms() == len(dataset.X[idm].parents)

import os

import deepchem as dc

import numpy as np

def load_gaussian_cdf_data():

  """Load example with numbers sampled from Gaussian normal distribution.

     Each feature and task is a column of values that is sampled

     from a normal distribution of mean 0, stdev 1."""

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

  features = ["feat0", "feat1"]

  featurizer = dc.feat.UserDefinedFeaturizer(features)

  tasks = ["task0", "task1"]

  input_file = os.path.join(current_dir,

                            "../../models/tests/gaussian_cdf_example.csv")

  loader = dc.data.UserCSVLoader(

      tasks=tasks, featurizer=featurizer, id_field="id")

  return loader.create_dataset(input_file)

def test_cdf_X_transformer():

  """Test CDF transformer on Gaussian normal dataset."""

  target = np.array(np.transpose(np.linspace(0., 1., 1001)))

  target = np.transpose(np.array(np.append([target], [target], axis=0)))

  gaussian_dataset = load_gaussian_cdf_data()

  bins = 1001

  cdf_transformer = dc.trans.CDFTransformer(

      transform_X=True, dataset=gaussian_dataset, bins=bins)

  X, y, w, ids = (gaussian_dataset.X, gaussian_dataset.y, gaussian_dataset.w,

                  gaussian_dataset.ids)

  gaussian_dataset = cdf_transformer.transform(gaussian_dataset)

  X_t, y_t, w_t, ids_t = (gaussian_dataset.X, gaussian_dataset.y,

                          gaussian_dataset.w, gaussian_dataset.ids)

  # Check ids are unchanged.

  for id_elt, id_t_elt in zip(ids, ids_t):

    assert id_elt == id_t_elt

  # Check y is unchanged since this is an X transformer

  np.testing.assert_allclose(y, y_t)

  # Check w is unchanged since this is an X transformer

  np.testing.assert_allclose(w, w_t)

  # Check X is now holding the proper values when sorted.

  sorted = np.sort(X_t, axis=0)

  np.testing.assert_allclose(sorted, target)

def test_cdf_1d_y_transformer():

  """Test on a synthetic dataset we sample with 1d y."""

  N = 10

  n_feat = 5

  n_bins = 100

  X = np.random.normal(size=(N, n_feat))

  y = np.random.normal(size=(N,))

  dataset = dc.data.NumpyDataset(X, y)

  cdftrans = dc.trans.CDFTransformer(

      transform_y=True, dataset=dataset, bins=n_bins)

  dataset = cdftrans.transform(dataset)

def test_cdf_y_transformer():

  """Test CDF transformer on Gaussian normal dataset."""

  target = np.array(np.transpose(np.linspace(0., 1., 1001)))

  target = np.transpose(np.array(np.append([target], [target], axis=0)))

  gaussian_dataset = load_gaussian_cdf_data()

  bins = 1001

  cdf_transformer = dc.trans.CDFTransformer(

      transform_y=True, dataset=gaussian_dataset, bins=bins)

  X, y, w, ids = (gaussian_dataset.X, gaussian_dataset.y, gaussian_dataset.w,

                  gaussian_dataset.ids)

  gaussian_dataset = cdf_transformer.transform(gaussian_dataset, bins=bins)

  X_t, y_t, w_t, ids_t = (gaussian_dataset.X, gaussian_dataset.y,

                          gaussian_dataset.w, gaussian_dataset.ids)

  # Check ids are unchanged.

  for id_elt, id_t_elt in zip(ids, ids_t):

    assert id_elt == id_t_elt

  # Check X is unchanged since this is an y transformer

  np.testing.assert_allclose(X, X_t)

  # Check w is unchanged since this is an y transformer

  np.testing.assert_allclose(w, w_t)

  # Check y is now holding the proper values when sorted.

  sorted = np.sort(y_t, axis=0)

  np.testing.assert_allclose(sorted, target)

  # Check that untransform does the right thing.

  y_restored = cdf_transformer.untransform(y_t)

  assert np.max(y_restored - y) < 1e-5

  #np.testing.assert_allclose(y_restored, y)

import deepchem as dc

import numpy as np

def test_clipping_X_transformer():

  """Test clipping transformer on X of singletask dataset."""

  n_samples = 10

  n_features = 3

  n_tasks = 1

  ids = np.arange(n_samples)

  X = np.ones((n_samples, n_features))

  target = 5. * X

  X *= 6.

  y = np.zeros((n_samples, n_tasks))

  w = np.ones((n_samples, n_tasks))

  dataset = dc.data.NumpyDataset(X, y, w, ids)

  transformer = dc.trans.ClippingTransformer(transform_X=True, x_max=5.)

  clipped_dataset = transformer.transform(dataset)

  X_t, y_t, w_t, ids_t = (clipped_dataset.X, clipped_dataset.y,

                          clipped_dataset.w, clipped_dataset.ids)

  # Check ids are unchanged.

  for id_elt, id_t_elt in zip(ids, ids_t):

    assert id_elt == id_t_elt

  # Check y is unchanged since this is an X transformer

  np.testing.assert_allclose(y, y_t)

  # Check w is unchanged since this is an X transformer

  np.testing.assert_allclose(w, w_t)

  # Check X is now holding the proper values when sorted.

  np.testing.assert_allclose(X_t, target)

def test_clipping_y_transformer():

  """Test clipping transformer on y of singletask dataset."""

  n_samples = 10

  n_features = 3

  n_tasks = 1

  ids = np.arange(n_samples)

  X = np.zeros((n_samples, n_features))

  y = np.ones((n_samples, n_tasks))

  target = 5. * y

  y *= 6.

  w = np.ones((n_samples, n_tasks))

  dataset = dc.data.NumpyDataset(X, y, w, ids)

  transformer = dc.trans.ClippingTransformer(transform_y=True, y_max=5.)

  clipped_dataset = transformer.transform(dataset)

  X_t, y_t, w_t, ids_t = (clipped_dataset.X, clipped_dataset.y,

                          clipped_dataset.w, clipped_dataset.ids)

  # Check ids are unchanged.

  for id_elt, id_t_elt in zip(ids, ids_t):

    assert id_elt == id_t_elt

  # Check X is unchanged since this is a y transformer

  np.testing.assert_allclose(X, X_t)

  # Check w is unchanged since this is a y transformer

  np.testing.assert_allclose(w, w_t)

  # Check y is now holding the proper values when sorted.

  np.testing.assert_allclose(y_t, target)

import numpy as np

import tempfile

import deepchem as dc

  assert np.sum(y_t == 0) == 4

  assert np.sum(y_t == 1) == 4

  # Check that sum of 0s equals sum of 1s in transformed for each task

  assert np.isclose(np.sum(w_task[y_task == 0]), np.sum(w_task[y_task == 1]))

  assert np.isclose(np.sum(w_t[y_t == 0]), np.sum(w_t[y_t == 1]))

def test_binary_singletask():

  """Test duplicate balancing transformer on single-task dataset."""

  n_samples = 20

  n_samples = 6

  n_features = 3

  n_tasks = 1

  n_classes = 2

  assert np.sum(y_t == 0) == 4

  assert np.sum(y_t == 1) == 4

  # Check that sum of 0s equals sum of 1s in transformed for each task

  assert np.isclose(np.sum(w_task[y_task == 0]), np.sum(w_task[y_task == 1]))

  assert np.isclose(np.sum(w_t[y_t == 0]), np.sum(w_t[y_t == 1]))

def test_multiclass_singletask():

  assert np.sum(y_t == 3) == 6

  assert np.sum(y_t == 4) == 6

  # Check that sum of all class weights is equal by comparing to 0 weight

  assert np.isclose(np.sum(w_task[y_task == 0]), np.sum(w_task[y_task == 1]))

  assert np.isclose(np.sum(w_task[y_task == 0]), np.sum(w_task[y_task == 2]))

  assert np.isclose(np.sum(w_task[y_task == 0]), np.sum(w_task[y_task == 3]))

  assert np.isclose(np.sum(w_task[y_task == 0]), np.sum(w_task[y_task == 4]))

  assert np.isclose(np.sum(w_t[y_t == 0]), np.sum(w_t[y_t == 1]))

  assert np.isclose(np.sum(w_t[y_t == 0]), np.sum(w_t[y_t == 2]))

  assert np.isclose(np.sum(w_t[y_t == 0]), np.sum(w_t[y_t == 3]))

  assert np.isclose(np.sum(w_t[y_t == 0]), np.sum(w_t[y_t == 4]))

def test_transform_to_directory():

  assert w_t.shape == (13,)

  assert ids_t.shape == (13,)

  # Check that we have 6 positives and 7 negatives

  assert np.sum(y_t == 0) == 6

  assert np.sum(y_t == 1) == 7

  assert np.sum(y_t == 0) == 7

  assert np.sum(y_t == 1) == 6

import deepchem as dc

from deepchem.molnet import load_delaney

from deepchem.trans.transformers import FeaturizationTransformer

def test_featurization_transformer():

  fp_size = 2048

  tasks, all_dataset, transformers = load_delaney('Raw')

  train = all_dataset[0]

  transformer = FeaturizationTransformer(

      dataset=train, featurizer=dc.feat.CircularFingerprint(size=fp_size))

  new_train = transformer.transform(train)

  assert new_train.y.shape == train.y.shape

  assert new_train.X.shape[-1] == fp_size