Commit 41b60092 authored by leswing's avatar leswing
Browse files

merge master

parents 07a6c865 67f76300

deepchem/models/tensorgraph/layers.py

+127 −0
Original line number Diff line number Diff line
@@ -1222,6 +1222,86 @@ class Conv2D(Layer): 
    return out_tensor





class Conv3D(Layer):

  """A 3D convolution on the input.



  This layer expects its input to be a five dimensional tensor of shape

  (batch size, height, width, depth, # channels).

  If there is only one channel, the fifth dimension may optionally be omitted.

  """



  def __init__(self,

               num_outputs,

               kernel_size=5,

               stride=1,

               padding='SAME',

               activation_fn=tf.nn.relu,

               normalizer_fn=None,

               scope_name=None,

               **kwargs):

    """Create a Conv3D layer.



    Parameters

    ----------

    num_outputs: int

      the number of outputs produced by the convolutional kernel

    kernel_size: int or tuple

      the width of the convolutional kernel.  This can be either a three element tuple, giving

      the kernel size along each dimension, or an integer to use the same size along both

      dimensions.

    stride: int or tuple

      the stride between applications of the convolutional kernel.  This can be either a three

      element tuple, giving the stride along each dimension, or an integer to use the same

      stride along both dimensions.

    padding: str

      the padding method to use, either 'SAME' or 'VALID'

    activation_fn: object

      the Tensorflow activation function to apply to the output

    normalizer_fn: object

      the Tensorflow normalizer function to apply to the output

    """

    self.num_outputs = num_outputs

    self.kernel_size = kernel_size

    self.stride = stride

    self.padding = padding

    self.activation_fn = activation_fn

    self.normalizer_fn = normalizer_fn

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

    if scope_name is None:

      scope_name = self.name

    self.scope_name = scope_name

    try:

      parent_shape = self.in_layers[0].shape

      strides = stride

      if isinstance(stride, int):

        strides = (stride, stride, stride)

      self._shape = (parent_shape[0], parent_shape[1] // strides[0],

                     parent_shape[2] // strides[1],

                     parent_shape[3] // strides[2], num_outputs)

    except:

      pass



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

    inputs = self._get_input_tensors(in_layers)

    parent_tensor = inputs[0]

    if len(parent_tensor.get_shape()) == 4:

      parent_tensor = tf.expand_dims(parent_tensor, 4)

    out_tensor = tf.layers.conv3d(

        parent_tensor,

        filters=self.num_outputs,

        kernel_size=self.kernel_size,

        strides=self.stride,

        padding=self.padding,

        activation=self.activation_fn,

        activity_regularizer=self.normalizer_fn,

        name=self.scope_name)

    out_tensor = out_tensor

    if set_tensors:

      self._record_variable_scope(self.scope_name)

      self.out_tensor = out_tensor

    return out_tensor





class MaxPool2D(Layer):



  def __init__(self,
@@ -1250,6 +1330,53 @@ class MaxPool2D(Layer): 
    return out_tensor





class MaxPool3D(Layer):

  """A 3D max pooling on the input.



  This layer expects its input to be a five dimensional tensor of shape

  (batch size, height, width, depth, # channels).

  """



  def __init__(self,

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

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

               padding='SAME',

               **kwargs):

    """Create a MaxPool3D layer.



    Parameters

    ----------

    ksize: list

      size of the window for each dimension of the input tensor. Must have

      length of 5 and ksize[0] = ksize[4] = 1.

    strides: list

      stride of the sliding window for each dimension of input. Must have

      length of 5 and strides[0] = strides[4] = 1.

    padding: str

      the padding method to use, either 'SAME' or 'VALID'

    """



    self.ksize = ksize

    self.strides = strides

    self.padding = padding

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

    try:

      parent_shape = self.in_layers[0].shape

      self._shape = tuple(None if p is None else p // s

                          for p, s in zip(parent_shape, strides))

    except:

      pass



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

    inputs = self._get_input_tensors(in_layers)

    in_tensor = inputs[0]

    out_tensor = tf.nn.max_pool3d(

        in_tensor, ksize=self.ksize, strides=self.strides, padding=self.padding)

    if set_tensors:

      self.out_tensor = out_tensor

    return out_tensor





class InputFifoQueue(Layer):

  """

  This Queue Is used to allow asynchronous batching of inputs

deepchem/models/tensorgraph/tests/test_layers.py

+63 −39
Original line number Diff line number Diff line 
import unittest



import numpy as np

import os

import rdkit

import tensorflow as tf

from nose.tools import assert_true

from tensorflow.python.framework import test_util

from deepchem.feat.mol_graphs import ConvMol

from deepchem.feat.mol_graphs import MultiConvMol



from deepchem.feat.graph_features import ConvMolFeaturizer

from deepchem.feat.mol_graphs import ConvMol

from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D

from deepchem.models.tensorgraph.layers import AlphaShareLayer

from deepchem.models.tensorgraph.layers import AttnLSTMEmbedding

from deepchem.models.tensorgraph.layers import BatchNorm

from deepchem.models.tensorgraph.layers import BetaShare

from deepchem.models.tensorgraph.layers import CombineMeanStd

from deepchem.models.tensorgraph.layers import Concat

from deepchem.models.tensorgraph.layers import Constant

from deepchem.models.tensorgraph.layers import Conv1D, Squeeze

from deepchem.models.tensorgraph.layers import Conv2D

from deepchem.models.tensorgraph.layers import Dense

from deepchem.models.tensorgraph.layers import Flatten

from deepchem.models.tensorgraph.layers import Reshape

from deepchem.models.tensorgraph.layers import Transpose

from deepchem.models.tensorgraph.layers import CombineMeanStd

from deepchem.models.tensorgraph.layers import Repeat

from deepchem.models.tensorgraph.layers import Gather

from deepchem.models.tensorgraph.layers import GRU

from deepchem.models.tensorgraph.layers import TimeSeriesDense

from deepchem.models.tensorgraph.layers import Gather

from deepchem.models.tensorgraph.layers import GraphConv

from deepchem.models.tensorgraph.layers import GraphGather

from deepchem.models.tensorgraph.layers import Input

from deepchem.models.tensorgraph.layers import InputFifoQueue

from deepchem.models.tensorgraph.layers import InteratomicL2Distances

from deepchem.models.tensorgraph.layers import IterRefLSTMEmbedding

from deepchem.models.tensorgraph.layers import L2Loss

from deepchem.models.tensorgraph.layers import Concat

from deepchem.models.tensorgraph.layers import Constant

from deepchem.models.tensorgraph.layers import Variable

from deepchem.models.tensorgraph.layers import Add

from deepchem.models.tensorgraph.layers import Multiply

from deepchem.models.tensorgraph.layers import LSTMStep

from deepchem.models.tensorgraph.layers import LayerSplitter

from deepchem.models.tensorgraph.layers import Log

from deepchem.models.tensorgraph.layers import InteratomicL2Distances

from deepchem.models.tensorgraph.layers import SoftMaxCrossEntropy

from deepchem.models.tensorgraph.layers import Multiply

from deepchem.models.tensorgraph.layers import ReduceMean

from deepchem.models.tensorgraph.layers import ToFloat

from deepchem.models.tensorgraph.layers import ReduceSum

from deepchem.models.tensorgraph.layers import ReduceSquareDifference

from deepchem.models.tensorgraph.layers import Conv2D

from deepchem.models.tensorgraph.layers import MaxPool2D

from deepchem.models.tensorgraph.layers import InputFifoQueue

from deepchem.models.tensorgraph.layers import GraphConv

from deepchem.models.tensorgraph.layers import GraphPool

from deepchem.models.tensorgraph.layers import GraphGather

from deepchem.models.tensorgraph.layers import BatchNorm

from deepchem.models.tensorgraph.layers import ReduceSum

from deepchem.models.tensorgraph.layers import Repeat

from deepchem.models.tensorgraph.layers import Reshape

from deepchem.models.tensorgraph.layers import SluiceLoss

from deepchem.models.tensorgraph.layers import SoftMax

from deepchem.models.tensorgraph.layers import WeightedError

from deepchem.models.tensorgraph.layers import SoftMaxCrossEntropy

from deepchem.models.tensorgraph.layers import TensorWrapper

from deepchem.models.tensorgraph.layers import TimeSeriesDense

from deepchem.models.tensorgraph.layers import ToFloat

from deepchem.models.tensorgraph.layers import Transpose

from deepchem.models.tensorgraph.layers import Variable

from deepchem.models.tensorgraph.layers import VinaFreeEnergy

from deepchem.models.tensorgraph.layers import WeightedError

from deepchem.models.tensorgraph.layers import WeightedLinearCombo

from deepchem.models.tensorgraph.layers import TensorWrapper

from deepchem.models.tensorgraph.layers import LSTMStep

from deepchem.models.tensorgraph.layers import AttnLSTMEmbedding

from deepchem.models.tensorgraph.layers import IterRefLSTMEmbedding

from deepchem.models.tensorgraph.layers import AlphaShareLayer

from deepchem.models.tensorgraph.layers import BetaShare

from deepchem.models.tensorgraph.layers import LayerSplitter

from deepchem.models.tensorgraph.layers import SluiceLoss



import deepchem as dc





class TestLayers(test_util.TensorFlowTestCase):
@@ -368,6 +360,23 @@ class TestLayers(test_util.TensorFlowTestCase): 
      out_tensor = out_tensor.eval()

      assert out_tensor.shape == (batch_size, length, width, out_channels)



  def test_conv_3D(self):

    """Test that Conv3D can be invoked."""

    length = 4

    width = 5

    depth = 6

    in_channels = 2

    out_channels = 3

    batch_size = 20

    in_tensor = np.random.rand(batch_size, length, width, depth, in_channels)

    with self.test_session() as sess:

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

      out_tensor = Conv3D(out_channels, kernel_size=1)(in_tensor)

      sess.run(tf.global_variables_initializer())

      out_tensor = out_tensor.eval()

      assert out_tensor.shape == (batch_size, length, width, depth,

                                  out_channels)



  def test_maxpool2D(self):

    """Test that MaxPool2D can be invoked."""

    length = 2
@@ -382,6 +391,21 @@ class TestLayers(test_util.TensorFlowTestCase): 
      out_tensor = out_tensor.eval()

      assert out_tensor.shape == (batch_size, 1, 1, in_channels)



  def test_max_pool_3D(self):

    """Test that MaxPool3D can be invoked."""

    length = 2

    width = 2

    depth = 2

    in_channels = 2

    batch_size = 20

    in_tensor = np.random.rand(batch_size, length, width, depth, in_channels)

    with self.test_session() as sess:

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

      out_tensor = MaxPool3D()(in_tensor)

      sess.run(tf.global_variables_initializer())

      out_tensor = out_tensor.eval()

      assert out_tensor.shape == (batch_size, 1, 1, 1, in_channels)



  def test_input_fifo_queue(self):

    """Test InputFifoQueue can be invoked."""

    batch_size = 10

deepchem/models/tensorgraph/tests/test_layers_pickle.py

+21 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ from deepchem.models.tensorgraph.layers import Feature, Conv1D, Dense, Flatten, 
    CombineMeanStd, Repeat, Gather, GRU, L2Loss, Concat, SoftMax, Constant, Variable, Add, Multiply, Log, InteratomicL2Distances, \

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

    GraphGather, BatchNorm, WeightedError, \

    Conv3D, MaxPool3D, \

    LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding

from deepchem.models.tensorgraph.graph_layers import Combine_AP, Separate_AP, \

    WeaveLayer, WeaveGather, DTNNEmbedding, DTNNGather, DTNNStep, \
@@ -255,6 +256,16 @@ def test_Conv2D_pickle(): 
  tg.save()





def test_Conv3D_pickle():

  tg = TensorGraph()

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

  layer = Conv3D(num_outputs=3, in_layers=feature)

  tg.add_output(layer)

  tg.set_loss(layer)

  tg.build()

  tg.save()





def test_MaxPool2D_pickle():

  tg = TensorGraph()

  feature = Feature(shape=(tg.batch_size, 10, 10, 10))
@@ -265,6 +276,16 @@ def test_MaxPool2D_pickle(): 
  tg.save()





def test_MaxPool3D_pickle():

  tg = TensorGraph()

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

  layer = MaxPool3D(in_layers=feature)

  tg.add_output(layer)

  tg.set_loss(layer)

  tg.build()

  tg.save()





def test_GraphConv_pickle():

  tg = TensorGraph()

  atom_features = Feature(shape=(None, 75))

CRA Git | Maintained and supported by SUSTech CRA and CCSE