Documentation update

class Dense(Layer):

  def __init__(

      self,

      out_channels,

class Reshape(Layer):

  def __init__(self, shape, **kwargs):

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

    self._new_shape = tuple(-1 if x is None else x for x in shape)

class Squeeze(Layer):

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

    self.squeeze_dims = squeeze_dims

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

class Transpose(Layer):

  def __init__(self, perm, **kwargs):

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

    self.perm = perm

class Repeat(Layer):

  def __init__(self, n_times, **kwargs):

    self.n_times = n_times

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

class TimeSeriesDense(Layer):

  def __init__(self, out_channels, **kwargs):

    self.out_channels = out_channels

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

class Input(Layer):

  def __init__(self, shape, dtype=tf.float32, **kwargs):

    self._shape = tuple(shape)

    self.dtype = dtype

class Feature(Input):

  def __init__(self, **kwargs):

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

class Label(Input):

  def __init__(self, **kwargs):

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

class Weights(Input):

  def __init__(self, **kwargs):

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

class L1Loss(Layer):

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

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

class L2Loss(Layer):

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

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

    try:

class SoftMax(Layer):

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

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

    try:

class Concat(Layer):

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

    self.axis = axis

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

class Stack(Layer):

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

    self.axis = axis

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

class SparseSoftMaxCrossEntropy(Layer):

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

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

    try:

class SoftMaxCrossEntropy(Layer):

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

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

    try:

class ReduceMean(Layer):

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

    if axis is not None and not isinstance(axis, Sequence):

      axis = [axis]

class ToFloat(Layer):

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

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

    try:

class ReduceSum(Layer):

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

    if axis is not None and not isinstance(axis, Sequence):

      axis = [axis]

class ReduceSquareDifference(Layer):

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

    if axis is not None and not isinstance(axis, Sequence):

      axis = [axis]

class MaxPool2D(Layer):

  def __init__(self,

               ksize=[1, 2, 2, 1],

               strides=[1, 2, 2, 1],

class GraphConv(Layer):

  def __init__(self,

               out_channel,

               min_deg=0,

class GraphPool(Layer):

  def __init__(self, min_degree=0, max_degree=10, **kwargs):

    self.min_degree = min_degree

    self.max_degree = max_degree

class GraphGather(Layer):

  def __init__(self, batch_size, activation_fn=None, **kwargs):

    self.batch_size = batch_size

    self.activation_fn = activation_fn

class BatchNorm(Layer):

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

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

    try:

class BatchNormalization(Layer):

  def __init__(self,

               epsilon=1e-5,

               axis=-1,

class WeightedError(Layer):

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

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

    self._shape = tuple()

class Dropout(Layer):

  def __init__(self, dropout_prob, **kwargs):

    self.dropout_prob = dropout_prob

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

class AtomicConvolution(Layer):

  def __init__(self,

               atom_types=None,

               radial_params=list(),

class PassThroughLayer(Layer):

  """

  Layer which takes a tensor from in_tensor[0].out_tensors at an index

  """

  def __init__(self, output_num, **kwargs):

    """

    Parameters

    ----------

    output_num: int

      The index which to use as this layers out_tensor from in_layers[0]

    kwargs

    """

    self.output_num = output_num

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

    self.out_tensor = self.in_layers[0].out_tensors[self.output_num]

class GraphCNNPoolLayer(Layer):

class GraphEmbedPoolLayer(Layer):

  """

  GraphCNNPool Layer from Robust Spatial Filtering with Graph Convolutional Neural Networks

  https://arxiv.org/abs/1703.00792

  This is a learnable pool operation

  It constructs a new adjacency matrix for a graph of specified number of nodes.

  This differs from our other pool opertions which set vertices to a function value

  without altering the adjacency matrix.

  $V_{emb} = SpatialGraphCNN({V_{in}})$\\

  $V_{out} = \sigma(V_{emb})^{T} * V_{in}$

  $A_{out} = V_{emb}^{T} * A_{in} * V_{emb}$

  """

  def __init__(self, num_vertices, **kwargs):

    self.num_vertices = num_vertices

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

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

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

    """

                                     A.get_shape()[2].value, self.num_vertices))

    # We do not need the mask because every graph has self.num_vertices vertices now

    if set_tensors:

      self.out_tensor = result

      self.out_tensor = result[0]

    self.out_tensors = [result, result_A]

    return result, result_A

def GraphCNNPool(num_vertices, **kwargs):

  gcnnpool_layer = GraphCNNPoolLayer(num_vertices, **kwargs)

  gcnnpool_layer = GraphEmbedPoolLayer(num_vertices, **kwargs)

  return [PassThroughLayer(x, in_layers=gcnnpool_layer) for x in range(2)]

  """

  GraphCNN Layer from Robust Spatial Filtering with Graph Convolutional Neural Networks

  https://arxiv.org/abs/1703.00792

  Spatial-domain convolutions can be defined as

  H = h_0I + h_1A + h_2A^2 + ... + hkAk, H ∈ R**(N×N)

  We approximate it by

  H ≈ h_0I + h_1A

  We can define a convolution as applying multiple these linear filters

  over edges of different types (think up, down, left, right, diagonal in images)

  Where each edge type has its own adjacency matrix

  H ≈ h_0I + h_1A_1 + h_2A_2 + . . . h_(L−1)A_(L−1)

  V_out = \sum_{c=1}^{C} H^{c} V^{c} + b

  """

  def __init__(self, num_filters, **kwargs):

from deepchem.feat.graph_features import ConvMolFeaturizer

from deepchem.feat.mol_graphs import ConvMol

from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D, MaxPool3D, GraphCNN, GraphCNNPoolLayer

from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D, MaxPool3D, GraphCNN, GraphEmbedPoolLayer

from deepchem.models.tensorgraph.layers import AlphaShareLayer

from deepchem.models.tensorgraph.layers import AttnLSTMEmbedding

from deepchem.models.tensorgraph.layers import BatchNorm

    V = np.random.uniform(size=(10, 100, 50)).astype(np.float32)

    adjs = np.random.uniform(size=(10, 100, 5, 100)).astype(np.float32)

    with self.test_session() as sess:

      vertex_props, adjs = GraphCNNPoolLayer(num_vertices=6)(V, adjs)

      vertex_props, adjs = GraphEmbedPoolLayer(num_vertices=6)(V, adjs)

      sess.run(tf.global_variables_initializer())

      vertex_props, adjs = vertex_props.eval(), adjs.eval()

      assert vertex_props.shape == (10, 6, 50)

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

  GraphGather, BatchNorm, WeightedError, \

  Conv3D, MaxPool3D, \

  LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding, GraphCNNPoolLayer, GraphCNN

  LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding, GraphEmbedPoolLayer, GraphCNN

from deepchem.models.tensorgraph.symmetry_functions import AtomicDifferentiatedDense

def testGraphCNNPoolLayer_pickle():

  V = Feature(shape=(None, 200, 50))

  A = Feature(shape=(None, 200, 1, 200))

  gcnnpool = GraphCNNPoolLayer(32, in_layers=[V, A])

  gcnnpool = GraphEmbedPoolLayer(32, in_layers=[V, A])

  tg = TensorGraph()

  tg.add_output(gcnnpool)

  tg.set_loss(gcnnpool)