Merge branch 'master' into ani_trans_int

cd deepchem

bash scripts/install_deepchem_conda.sh deepchem

source activate deepchem

pip install tensorflow-gpu==1.2.1                       # If you want GPU support

pip install tensorflow-gpu==1.3.0                      # If you want GPU support

python setup.py install                                 # Manual install

nosetests -v deepchem --nologcapture                    # Run tests

```

    contact your local sysadmin to work out a custom installation. If your

    version of Linux is recent, then the following command will work:

    ```

    pip install tensorflow-gpu==1.2.1

    pip install tensorflow-gpu==1.3.0

    ```

9. `deepchem`: Clone the `deepchem` github repo:

import tempfile

import time

import shutil

from multiprocessing.dummy import Pool

__author__ = "Bharath Ramsundar"

__copyright__ = "Copyright 2016, Stanford University"

        shard_perm = np.random.permutation(num_shards)

      else:

        shard_perm = np.arange(num_shards)

      pool = Pool(1)

      next_shard = pool.apply_async(dataset.get_shard, (shard_perm[0],))

      for i in range(num_shards):

        X, y, w, ids = dataset.get_shard(shard_perm[i])

        X, y, w, ids = next_shard.get()

        if i < num_shards - 1:

          next_shard = pool.apply_async(dataset.get_shard, (shard_perm[i + 1],))

        n_samples = X.shape[0]

        # TODO(rbharath): This happens in tests sometimes, but don't understand why?

        # Handle edge case.

            (X_batch, y_batch, w_batch, ids_batch) = pad_batch(

                shard_batch_size, X_batch, y_batch, w_batch, ids_batch)

          yield (X_batch, y_batch, w_batch, ids_batch)

      pool.close()

    return iterate(self)

from deepchem.models.tensorgraph.tensor_graph import TensorGraph

from deepchem.models.tensorgraph.models.graph_models import WeaveTensorGraph, DTNNTensorGraph, DAGTensorGraph, GraphConvTensorGraph, MPNNTensorGraph

from deepchem.models.tensorgraph.models.symmetry_function_regression import BPSymmetryFunctionRegression, ANIRegression

from deepchem.models.tensorgraph.models.seqtoseq import SeqToSeq

import random

import string

from collections import Sequence

from copy import deepcopy

import tensorflow as tf

import numpy as np

    self.in_layers = in_layers

    self.op_type = "gpu"

    self.variable_scope = ''

    self.variable_values = None

    self.rnn_initial_states = []

    self.rnn_final_states = []

    self.rnn_zero_states = []

    else:

      self.variable_scope = local_scope

  def set_variable_initial_values(self, values):

    """Set the initial values of all variables.

    This takes a list, which contains the initial values to use for all of

    this layer's values (in the same order retured by

    TensorGraph.get_layer_variables()).  When this layer is used in a

    TensorGraph, it will automatically initialize each variable to the value

    specified in the list.  Note that some layers also have separate mechanisms

    for specifying variable initializers; this method overrides them. The

    purpose of this method is to let a Layer object represent a pre-trained

    layer, complete with trained values for its variables."""

    self.variable_values = values

  def set_summary(self, summary_op, summary_description=None, collections=None):

    """Annotates a tensor with a tf.summary operation

    Collects data from self.out_tensor by default but can be changed by setting

    elif self.summary_op == 'histogram':

      tf.summary.histogram(self.name, self.tb_input, self.collections)

  def copy(self, replacements={}, variables_graph=None):

    """Duplicate this Layer and all its inputs.

    This creates and returns a clone of this layer.  It also recursively calls

    copy() on all of this layer's inputs to clone the entire hierarchy of layers.

    In the process, you can optionally tell it to replace particular layers with

    specific existing ones.  For example, you can clone a stack of layers, while

    connecting the topmost ones to different inputs.

    For example, consider a stack of dense layers that depend on an input:

    >>> input = Feature(shape=(None, 100))

    >>> dense1 = Dense(100, in_layers=input)

    >>> dense2 = Dense(100, in_layers=dense1)

    >>> dense3 = Dense(100, in_layers=dense2)

    The following will clone all three dense layers, but not the input layer.

    Instead, the input to the first dense layer will be a different layer

    specified in the replacements map.

    >>> replacements = {input: new_input}

    >>> dense3_copy = dense3.copy(replacements)

    Parameters

    ----------

    replacements: map

      specifies existing layers, and the layers to replace them with (instead of

      cloning them).  This argument serves two purposes.  First, you can pass in

      a list of replacements to control which layers get cloned.  In addition,

      as each layer is cloned, it is added to this map.  On exit, it therefore

      contains a complete record of all layers that were copied, and a reference

      to the copy of each one.

    variables_graph: TensorGraph

      an optional TensorGraph from which to take variables.  If this is specified,

      the current value of each variable in each layer is recorded, and the copy

      has that value specified as its initial value.  This allows a piece of a

      pre-trained model to be copied to another model.

    """

    if self in replacements:

      return replacements[self]

    copied_inputs = [

        layer.copy(replacements, variables_graph) for layer in self.in_layers

    ]

    saved_inputs = self.in_layers

    self.in_layers = []

    saved_tensors = self.none_tensors()

    copy = deepcopy(self)

    self.in_layers = saved_inputs

    self.set_tensors(saved_tensors)

    copy.in_layers = copied_inputs

    if variables_graph is not None:

      variables = variables_graph.get_layer_variables(self)

      if len(variables) > 0:

        with variables_graph._get_tf("Graph").as_default():

          values = variables_graph.session.run(variables)

          copy.set_variable_initial_values(values)

    return copy

  def _as_graph_element(self):

    if '_as_graph_element' in dir(self.out_tensor):

      return self.out_tensor._as_graph_element()

class CombineMeanStd(Layer):

  """Generate Gaussian nose."""

  def __init__(self, in_layers=None, **kwargs):

  def __init__(self, in_layers=None, training_only=False, **kwargs):

    """Create a CombineMeanStd layer.

    This layer should have two inputs with the same shape, and its output also has the

    same shape.  Each element of the output is a Gaussian distributed random number

    whose mean is the corresponding element of the first input, and whose standard

    deviation is the corresponding element of the second input.

    Parameters

    ----------

    in_layers: list

      the input layers.  The first one specifies the mean, and the second one specifies

      the standard deviation.

    training_only: bool

      if True, noise is only generated during training.  During prediction, the output

      is simply equal to the first input (that is, the mean of the distribution used

      during training).

    """

    super(CombineMeanStd, self).__init__(in_layers, **kwargs)

    self.training_only = training_only

    try:

      self._shape = self.in_layers[0].shape

    except:

    mean_parent, std_parent = inputs[0], inputs[1]

    sample_noise = tf.random_normal(

        mean_parent.get_shape(), 0, 1, dtype=tf.float32)

    if self.training_only:

      sample_noise *= kwargs['training']

    out_tensor = mean_parent + (std_parent * sample_noise)

    if set_tensors:

      self.out_tensor = out_tensor

    return out_tensor

class StopGradient(Layer):

  """Block the flow of gradients.

  This layer copies its input directly to its output, but reports that all

  gradients of its output are zero.  This means, for example, that optimizers

  will not try to optimize anything "upstream" of this layer.

  For example, suppose you have pre-trained a stack of layers to perform a

  calculation.  You want to use the result of that calculation as the input to

  another layer, but because they are already pre-trained, you do not want the

  optimizer to modify them.  You can wrap the output in a StopGradient layer,

  then use that as the input to the next layer."""

  def __init__(self, in_layers=None, **kwargs):

    super(StopGradient, self).__init__(in_layers, **kwargs)

    try:

      self._shape = tuple(self.in_layers[0].shape)

    except:

      pass

  def create_tensor(self, in_layers=None, set_tensors=True, **kwargs):

    inputs = self._get_input_tensors(in_layers)

    if len(inputs) > 1:

      raise ValueError("Only one layer supported.")

    out_tensor = tf.stop_gradient(inputs[0])

    if set_tensors:

      self.out_tensor = out_tensor

    return out_tensor

def _max_dimension(x, y):

  if x is None:

    return y

    return out_tensor

class Exp(Layer):

  """Compute the exponential of the input."""

  def __init__(self, in_layers=None, **kwargs):

    super(Exp, self).__init__(in_layers, **kwargs)

    try:

      self._shape = self.in_layers[0].shape

    except:

      pass

  def create_tensor(self, in_layers=None, set_tensors=True, **kwargs):

    inputs = self._get_input_tensors(in_layers)

    if len(inputs) != 1:

      raise ValueError('Exp must have a single parent')

    out_tensor = tf.exp(inputs[0])

    if set_tensors:

      self.out_tensor = out_tensor

    return out_tensor

class InteratomicL2Distances(Layer):

  """Compute (squared) L2 Distances between atoms given neighbors."""

  def set_tensors(self, tensors):

    self.queue, self.out_tensor, self.out_tensors, self.close_op = tensors

  def close(self):

    self.queue.close()

class GraphConv(Layer):

import collections

import numpy as np

import six

import tensorflow as tf

          d[self.deg_adjs[i - 1]] = multiConvMol.get_deg_adjacency_lists()[i]

        yield d

  def predict_proba_on_generator(self, generator, transformers=[]):

  def predict_on_generator(self, generator, transformers=[], outputs=None):

    if not self.built:

      self.build()

    if outputs is None:

      outputs = self.outputs

    elif not isinstance(outputs, collections.Sequence):

      outputs = [outputs]

    with self._get_tf("Graph").as_default():

      # Gather results for each output

      results = [[] for out in outputs]

      for feed_dict in generator:

        feed_dict = {

            self.layers[k.name].out_tensor: v

            for k, v in six.iteritems(feed_dict)

        }

        # Recording the number of samples in the input batch

        n_samples = max(feed_dict[self.membership.out_tensor]) + 1

        feed_dict[self._training_placeholder] = 0.0

        feed_results = self.session.run(outputs, feed_dict=feed_dict)

        if len(feed_results) > 1:

          if len(transformers):

            raise ValueError("Does not support transformations "

                             "for multiple outputs.")

        elif len(feed_results) == 1:

          result = undo_transforms(feed_results[0], transformers)

          feed_results = [result]

        for ind, result in enumerate(feed_results):

          # GraphConvTensorGraph constantly outputs batch_size number of

          # results, only valid samples should be appended to final results

          results[ind].append(result[:n_samples])

      final_results = []

      for result_list in results:

        final_results.append(np.concatenate(result_list, axis=0))

      # If only one output, just return array

      if len(final_results) == 1:

        return final_results[0]

      else:

        return final_results

  def predict_proba_on_generator(self, generator, transformers=[],

                                 outputs=None):

    if not self.built:

      self.build()

    with self._get_tf("Graph").as_default():

            self.layers[k.name].out_tensor: v

            for k, v in six.iteritems(feed_dict)

        }

        n_samples = max(feed_dict[self.membership.out_tensor]) + 1

        feed_dict[self._training_placeholder] = 1.0  ##

        result = np.array(self.session.run(out_tensors, feed_dict=feed_dict))

        if len(result.shape) == 3:

          result = np.transpose(result, axes=[1, 0, 2])

        if len(transformers) > 0:

          result = undo_transforms(result, transformers)

        results.append(result)

        results.append(result[:n_samples])

      return np.concatenate(results, axis=0)

  def evaluate(self, dataset, metrics, transformers=[], per_task_metrics=False):

    return mu[:max_index + 1], sigma[:max_index + 1]

  def bayesian_predict_on_batch(self, X, transformers=[], n_passes=4):

    """

    Returns:

      mu: numpy ndarray of shape (n_samples, n_tasks)

      sigma: numpy ndarray of shape (n_samples, n_tasks)

    """

    dataset = NumpyDataset(X=X, y=None, n_tasks=len(self.outputs))

    y_ = []

    for i in range(n_passes):

      generator = self.default_generator(

          dataset, predict=True, pad_batches=True)

      y_.append(self.predict_on_generator(generator, transformers))

    # Concatenates along 0-th dimension

    y_ = np.array(y_)

    mu = np.mean(y_, axis=0)

    sigma = np.std(y_, axis=0)

    return mu, sigma

  def predict_on_smiles(self, smiles, transformers=[], untransform=False):

    """Generates predictions on a numpy array of smile strings