Implemented StopGradient

    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."""

  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

from deepchem.models.tensorgraph.layers import SluiceLoss

from deepchem.models.tensorgraph.layers import SoftMax

from deepchem.models.tensorgraph.layers import SoftMaxCrossEntropy

from deepchem.models.tensorgraph.layers import StopGradient

from deepchem.models.tensorgraph.layers import TensorWrapper

from deepchem.models.tensorgraph.layers import TimeSeriesDense

from deepchem.models.tensorgraph.layers import ToFloat

      sess.run(tf.global_variables_initializer())

      assert np.array_equal(value, out_tensor.eval())

  def test_stop_gradient(self):

    """Test that StopGradient can be invoked."""

    batch_size = 10

    n_features = 5

    in_tensor = np.random.rand(batch_size, n_features)

    with self.test_session() as sess:

      in_tensor = tf.convert_to_tensor(in_tensor, dtype=tf.float32)

      out_tensor = StopGradient()(in_tensor)

      assert np.array_equal(in_tensor.eval(), out_tensor.eval())

  def test_add(self):

    """Test that Add can be invoked."""

    value1 = np.random.uniform(size=(2, 3)).astype(np.float32)

  DTNNExtract, DAGLayer, DAGGather, MessagePassing, SetGather

from deepchem.models.tensorgraph.layers import Feature, Conv1D, Dense, Flatten, Reshape, Squeeze, Transpose, \

  CombineMeanStd, Repeat, Gather, GRU, L2Loss, Concat, SoftMax, \

  Constant, Variable, Add, Multiply, Log, Exp, InteratomicL2Distances, \

  Constant, Variable, StopGradient, Add, Multiply, Log, Exp, InteratomicL2Distances, \

  SoftMaxCrossEntropy, ReduceMean, ToFloat, ReduceSquareDifference, Conv2D, MaxPool2D, ReduceSum, GraphConv, GraphPool, \

  GraphGather, BatchNorm, WeightedError, \

  Conv3D, MaxPool3D, \

  tg.save()

def test_StopGradient_pickle():

  tg = TensorGraph()

  feature = Feature(shape=(tg.batch_size, 1))

  output = StopGradient(feature)

  tg.add_output(output)

  tg.set_loss(output)

  tg.build()

  tg.save()

def test_Log_pickle():

  tg = TensorGraph()

  feature = Feature(shape=(tg.batch_size, 1))