MaxPool2D

    return out_tensor

class MaxPool(Layer):

class MaxPool2D(Layer):

  def __init__(self,

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

    self.ksize = ksize

    self.strides = strides

    self.padding = padding

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

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

    try:

      parent_shape = self.in_layers[0].shape

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

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 MaxPool

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

      out_tensor = out_tensor.eval()

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

  def test_max_pool(self):

    """Test that MaxPool can be invoked."""

  def test_maxpool2D(self):

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

    length = 2

    width = 2

    in_channels = 2

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

    with self.test_session() as sess:

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

      out_tensor = MaxPool()(in_tensor)

      out_tensor = MaxPool2D()(in_tensor)

      sess.run(tf.global_variables_initializer())

      out_tensor = out_tensor.eval()

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

from deepchem.models import TensorGraph

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, InteratomicL2Distances, \

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

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

    GraphGather, BatchNorm, WeightedError, \

    LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding

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

  tg.save()

def test_MaxPool_pickle():

def test_MaxPool2D_pickle():

  tg = TensorGraph()

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

  layer = MaxPool(in_layers=feature)

  layer = MaxPool2D(in_layers=feature)

  tg.add_output(layer)

  tg.set_loss(layer)

  tg.build()