Merge branch 'master' of https://github.com/deepchem/deepchem

- [RDKit](http://www.rdkit.org/docs/Install.html)

- [simdna](https://github.com/kundajelab/simdna)

- [XGBoost](https://xgboost.readthedocs.io/en/latest/)

- [Tensorflow Probability](https://www.tensorflow.org/probability)

## Installation

"""

General API for testing dataset objects

"""

__author__ = "Bharath Ramsundar"

__copyright__ = "Copyright 2016, Stanford University"

__license__ = "MIT"

import unittest

import tempfile

import os

import shutil

import numpy as np

import deepchem as dc

def load_solubility_data():

  """Loads solubility dataset"""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = ["log-solubility"]

  task_type = "regression"

  input_file = os.path.join(current_dir, "../../models/tests/example.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

def load_butina_data():

  """Loads solubility dataset"""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = ["task"]

  # task_type = "regression"

  input_file = os.path.join(current_dir,

                            "../../models/tests/butina_example.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

def load_multitask_data():

  """Load example multitask data."""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = [

      "task0", "task1", "task2", "task3", "task4", "task5", "task6", "task7",

      "task8", "task9", "task10", "task11", "task12", "task13", "task14",

      "task15", "task16"

  ]

  input_file = os.path.join(current_dir,

                            "../../models/tests/multitask_example.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

def load_classification_data():

  """Loads classification data from example.csv"""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = ["outcome"]

  task_type = "classification"

  input_file = os.path.join(current_dir,

                            "../../models/tests/example_classification.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

def load_sparse_multitask_dataset():

  """Load sparse tox multitask data, sample dataset."""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = [

      "task1", "task2", "task3", "task4", "task5", "task6", "task7", "task8",

      "task9"

  ]

  input_file = os.path.join(current_dir,

                            "../../models/tests/sparse_multitask_example.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

def load_feat_multitask_data():

  """Load example with numerical features, tasks."""

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

  features = ["feat0", "feat1", "feat2", "feat3", "feat4", "feat5"]

  featurizer = dc.feat.UserDefinedFeaturizer(features)

  tasks = ["task0", "task1", "task2", "task3", "task4", "task5"]

  input_file = os.path.join(current_dir,

                            "../../models/tests/feat_multitask_example.csv")

  loader = dc.data.UserCSVLoader(

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

  return loader.featurize(input_file)

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.featurize(input_file)

def load_unlabelled_data():

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = []

  input_file = os.path.join(current_dir, "../../data/tests/no_labels.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

  PYTORCH_IMPORT_FAILED = True

def load_solubility_data():

  """Loads solubility dataset"""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = ["log-solubility"]

  task_type = "regression"

  input_file = os.path.join(current_dir, "../../models/tests/example.csv")

  loader = dc.data.CSVLoader(

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

  return loader.create_dataset(input_file)

def load_multitask_data():

  """Load example multitask data."""

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

  featurizer = dc.feat.CircularFingerprint(size=1024)

  tasks = [

      "task0", "task1", "task2", "task3", "task4", "task5", "task6", "task7",

      "task8", "task9", "task10", "task11", "task12", "task13", "task14",

      "task15", "task16"

  ]

  input_file = os.path.join(current_dir,

                            "../../models/tests/multitask_example.csv")

  loader = dc.data.CSVLoader(

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

  return loader.featurize(input_file)

class TestDatasets(test_util.TensorFlowTestCase):

  """

  Test basic top-level API for dataset objects.

  def test_get_task_names(self):

    """Test that get_task_names returns correct task_names"""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    assert solubility_dataset.get_task_names() == ["log-solubility"]

    multitask_dataset = dc.data.tests.load_multitask_data()

    multitask_dataset = load_multitask_data()

    assert sorted(multitask_dataset.get_task_names()) == sorted([

        "task0", "task1", "task2", "task3", "task4", "task5", "task6", "task7",

        "task8", "task9", "task10", "task11", "task12", "task13", "task14",

  def test_get_data_shape(self):

    """Test that get_data_shape returns currect data shape"""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    assert solubility_dataset.get_data_shape() == (1024,)

    multitask_dataset = dc.data.tests.load_multitask_data()

    multitask_dataset = load_multitask_data()

    assert multitask_dataset.get_data_shape() == (1024,)

  def test_len(self):

    """Test that len(dataset) works."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    assert len(solubility_dataset) == 10

  def test_reshard(self):

    """Test that resharding the dataset works."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

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

                    solubility_dataset.w, solubility_dataset.ids)

    assert solubility_dataset.get_number_shards() == 1

  def test_iterbatches(self):

    """Test that iterating over batches of data works."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    batch_size = 2

    data_shape = solubility_dataset.get_data_shape()

    tasks = solubility_dataset.get_task_names()

  def test_itersamples_disk(self):

    """Test that iterating over samples in a DiskDataset works."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    X = solubility_dataset.X

    y = solubility_dataset.y

    w = solubility_dataset.w

  def test_transform_disk(self):

    """Test that the transform() method works for DiskDatasets."""

    dataset = dc.data.tests.load_solubility_data()

    dataset = load_solubility_data()

    X = dataset.X

    y = dataset.y

    w = dataset.w

  def test_to_numpy(self):

    """Test that transformation to numpy arrays is sensible."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    data_shape = solubility_dataset.get_data_shape()

    tasks = solubility_dataset.get_task_names()

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

  def test_consistent_ordering(self):

    """Test that ordering of labels is consistent over time."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    ids1 = solubility_dataset.ids

    ids2 = solubility_dataset.ids

  def test_get_statistics(self):

    """Test statistics computation of this dataset."""

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    X, y, _, _ = (solubility_dataset.X, solubility_dataset.y,

                  solubility_dataset.w, solubility_dataset.ids)

    X_means, y_means = np.mean(X, axis=0), np.mean(y, axis=0)

    np.testing.assert_allclose(comp_y_stds, y_stds)

  def test_disk_iterate_batch_size(self):

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    X, y, _, _ = (solubility_dataset.X, solubility_dataset.y,

                  solubility_dataset.w, solubility_dataset.ids)

    batch_sizes = []

          np.sort(all_ids, axis=0), np.sort(test_ids, axis=0))

  def test_numpy_iterate_batch_size(self):

    solubility_dataset = dc.data.tests.load_solubility_data()

    solubility_dataset = load_solubility_data()

    X, y, _, _ = (solubility_dataset.X, solubility_dataset.y,

                  solubility_dataset.w, solubility_dataset.ids)

    solubility_dataset = dc.data.NumpyDataset.from_DiskDataset(

  @unittest.skipIf(PYTORCH_IMPORT_FAILED, 'PyTorch is not installed')

  def test_make_pytorch_dataset_from_disk(self):

    """Test creating a PyTorch Dataset from a DiskDataset."""

    dataset = dc.data.tests.load_solubility_data()

    dataset = load_solubility_data()

    self._validate_pytorch_dataset(dataset)

  def test_dataframe(self):

    """Test converting between Datasets and DataFrames."""

    dataset = dc.data.tests.load_solubility_data()

    dataset = load_solubility_data()

    # A round trip from Dataset to DataFrame to Dataset should produce identical arrays.

# -*- coding: utf-8 -*-

import tensorflow as tf

import tensorflow_probability as tfp

import numpy as np

import collections

from tensorflow.keras import activations, initializers, backend

class WeaveGather(tf.keras.layers.Layer):

  """Implements the weave-gathering section of weave convolutions.

  Implements the gathering layer from the following paper:

  Kearnes, Steven, et al. "Molecular graph convolutions: moving beyond

  fingerprints." Journal of computer-aided molecular design 30.8 (2016): 595-608.

  The weave gathering layer gathers	per-atom features to create a

  molecule-level fingerprint in a weave convolutional network. This layer can

  also perform Gaussian histogram expansion as detailed in the original paper.

  """

  def __init__(self,

               batch_size,

    activation: str, optional

      Activation function applied

    """

    try:

      import tensorflow_probability as tfp

    except ModuleNotFoundError:

      raise ValueError(

          "This class requires tensorflow-probability to be installed.")

    super(WeaveGather, self).__init__(**kwargs)

    self.n_input = n_input

    self.batch_size = batch_size

    return output_molecules

  def gaussian_histogram(self, x):

    import tensorflow_probability as tfp

    gaussian_memberships = [(-1.645, 0.283), (-1.080, 0.170), (-0.739, 0.134),

                            (-0.468, 0.118), (-0.228, 0.114), (0., 0.114),

                            (0.228, 0.114), (0.468, 0.118), (0.739, 0.134),

from deepchem.models.optimizers import Adam

import numpy as np

import tensorflow as tf

import tensorflow_probability as tfp

import collections

import copy

import multiprocessing

class A2CLossContinuous(object):

  """This class computes the loss function for A2C with continuous action spaces."""

  """This class computes the loss function for A2C with continuous action spaces.

  Note

  ----

  This class requires tensorflow-probability to be installed.

  """

  def __init__(self, value_weight, entropy_weight, mean_index, std_index,

               value_index):

    try:

      import tensorflow_probability as tfp

    except ModuleNotFoundError:

      raise ValueError(

          "This class requires tensorflow-probability to be installed.")

    self.value_weight = value_weight

    self.entropy_weight = entropy_weight

    self.mean_index = mean_index

    self.value_index = value_index

  def __call__(self, outputs, labels, weights):

    import tensorflow_probability as tfp

    mean = outputs[self.mean_index]

    std = outputs[self.std_index]

    value = outputs[self.value_index]

  except specifying the new goal.  It should return that list of states, and the rewards that would

  have been received for taking the specified actions from those states.  The output arrays may be

  shorter than the input ones, if the modified rollout would have terminated sooner.

  Note

  ----

  Using this class on continuous action spaces requires that `tensorflow_probability` be installed.

  """

  def __init__(self,