Commit 86c70964 authored by Vignesh's avatar Vignesh
Browse files

Added test for all layers, fixed bugs along the way

parent 9d016fef

deepchem/models/layers.py

+17 −17
Original line number Diff line number Diff line
@@ -392,7 +392,7 @@ class AttnLSTMEmbedding(tf.keras.layers.Layer): 
    self.n_feat = n_feat



  def get_config(self):

    config = super(AttnLSTMEmbdding, self).get_config()

    config = super(AttnLSTMEmbedding, self).get_config()

    config['n_test'] = self.n_test

    config['n_support'] = self.n_support

    config['n_feat'] = self.n_feat
@@ -733,7 +733,7 @@ class VinaFreeEnergy(tf.keras.layers.Layer): 
    config['N_atoms'] = self.N_atoms

    config['M_nbrs'] = self.M_nbrs

    config['ndim'] = self.ndim

    config['nbr_cutoff'] = self.nbf_cutoff

    config['nbr_cutoff'] = self.nbr_cutoff

    config['start'] = self.start

    config['stop'] = self.stop

    config['stddev'] = self.stddev
@@ -864,7 +864,7 @@ class NeighborList(tf.keras.layers.Layer): 
    config['N_atoms'] = self.N_atoms

    config['M_nbrs'] = self.M_nbrs

    config['ndim'] = self.ndim

    config['nbr_cutoff'] = self.nbf_cutoff

    config['nbr_cutoff'] = self.nbr_cutoff

    config['start'] = self.start

    config['stop'] = self.stop

    return config
@@ -1970,7 +1970,7 @@ class WeaveLayer(tf.keras.layers.Layer): 
    config['n_hidden_PP'] = self.n_hidden_PP

    config['update_pair'] = self.update_pair

    config['init'] = self.init

    config['activation'] = self.activation.__name__.lower()

    config['activation'] = self.activation

    return config



  def build(self, input_shape):
@@ -2092,8 +2092,8 @@ class WeaveGather(tf.keras.layers.Layer): 
    config['batch_size'] = self.batch_size

    config['n_input'] = self.n_input

    config['gaussian_expand'] = self.gaussian_expand

    config['init'] = self.init.__name__.lower()

    config['activation'] = self.activation.__name__.lower()

    config['init'] = self.init

    config['activation'] = self.activation

    config['epsilon'] = self.epsilon

    config['momentum'] = self.momentum

    return config
@@ -2215,8 +2215,8 @@ class DTNNStep(tf.keras.layers.Layer): 
    config['n_embedding'] = self.n_embedding

    config['n_distance'] = self.n_distance

    config['n_hidden'] = self.n_hidden

    config['activation'] = self.activation.__name__.lower()

    config['init'] = self.init.__name__.lower()

    config['activation'] = self.activation

    config['init'] = self.init

    return config



  def build(self, input_shape):
@@ -2298,8 +2298,8 @@ class DTNNGather(tf.keras.layers.Layer): 
    config['n_outputs'] = self.n_outputs

    config['layer_sizes'] = self.layer_sizes

    config['output_activation'] = self.output_activation

    config['init'] = self.init.__name__.lower()

    config['activation'] = self.activation.__name__.lower()

    config['init'] = self.init

    config['activation'] = self.activation

    return config



  def build(self, input_shape):
@@ -2401,8 +2401,8 @@ class DAGLayer(tf.keras.layers.Layer): 
    config['n_atom_feat'] = self.n_atom_feat

    config['max_atoms'] = self.max_atoms

    config['layer_sizes'] = self.layer_sizes

    config['init'] = self.init.__name__.lower()

    config['activation'] = self.activation.__name__.lower()

    config['init'] = self.init

    config['activation'] = self.activation

    config['dropout'] = self.dropout

    config['batch_size'] = self.batch_size

    return config
@@ -2535,8 +2535,8 @@ class DAGGather(tf.keras.layers.Layer): 
    config['n_outputs'] = self.n_outputs

    config['max_atoms'] = self.max_atoms

    config['layer_sizes'] = self.layer_sizes

    config['init'] = self.init.__name__.lower()

    config['activation'] = self.activation.__name__.lower()

    config['init'] = self.init

    config['activation'] = self.activation

    config['dropout'] = self.dropout

    return config
@@ -2651,7 +2651,7 @@ class EdgeNetwork(tf.keras.layers.Layer): 
    config = super(EdgeNetwork, self).get_config()

    config['n_pair_features'] = self.n_pair_features

    config['n_hidden'] = self.n_hidden

    config['init'] = self.init.__name__.lower()

    config['init'] = self.init

    return config



  def build(self, input_shape):
@@ -2682,7 +2682,7 @@ class GatedRecurrentUnit(tf.keras.layers.Layer): 
  def get_config(self):

    config = super(GatedRecurrentUnit, self).get_config()

    config['n_hidden'] = self.n_hidden

    config['init'] = self.init.__name__.lower()

    config['init'] = self.init

    return config



  def build(self, input_shape):
@@ -2736,7 +2736,7 @@ class SetGather(tf.keras.layers.Layer): 
    config['M'] = self.M

    config['batch_size'] = self.batch_size

    config['n_hidden'] = self.n_hidden

    config['init'] = self.init.__name__.lower()

    config['init'] = self.init

    return config



  def build(self, input_shape):

deepchem/models/tests/test_layers_from_config.py

+449 −21
Original line number Diff line number Diff line
@@ -8,45 +8,473 @@ from tensorflow.python.eager import context 


class TestLayer(unittest.TestCase):



  def test_interatomic_l2_distance(self):

    N_atoms = 10

    M_nbrs = 15

    ndim = 20



    layer = dc.models.layers.InteratomicL2Distances(

        N_atoms=N_atoms, M_nbrs=M_nbrs, ndim=ndim)

    config = layer.get_config()

    layer_copied = dc.models.layers.InteratomicL2Distances.from_config(config)



    assert layer_copied.N_atoms == layer.N_atoms

    assert layer_copied.M_nbrs == layer.M_nbrs

    assert layer_copied.ndim == layer.ndim



  def test_graph_conv(self):

    out_channel = 10

    min_deg = 0,

    max_deg = 10,

    activation_fn = tf.nn.relu

    graph_conv = dc.models.layers.GraphConv(

    activation_fn = 'relu'



    layer = dc.models.layers.GraphConv(

        out_channel=out_channel,

        min_deg=min_deg,

        max_deg=max_deg,

        activation_fn=activation_fn)

    config = layer.get_config()

    layer_copied = dc.models.layers.GraphConv.from_config(config)



    config = graph_conv.get_config()

    graph_conv_new = dc.models.layers.GraphConv.from_config(config)



    assert graph_conv_new.out_channel == graph_conv.out_channel

    assert graph_conv_new.activation_fn == graph_conv.activation_fn

    assert graph_conv_new.max_degree == graph_conv.max_degree

    assert graph_conv_new.min_degree == graph_conv.min_degree

    assert layer_copied.out_channel == layer.out_channel

    assert layer_copied.activation_fn == layer.activation_fn

    assert layer_copied.max_degree == layer.max_degree

    assert layer_copied.min_degree == layer.min_degree



  def test_graph_gather(self):

    batch_size = 10

    activation_fn = tf.nn.relu

    graph_gather = dc.models.layers.GraphGather(

        batch_size=batch_size, activation_fn=activation_fn)

    activation_fn = 'relu'



    config = graph_gather.get_config()

    graph_gather_new = dc.models.layers.GraphGather.from_config(config)

    layer_copied = dc.models.layers.GraphGather(

        batch_size=batch_size, activation_fn=activation_fn)

    config = layer_copied.get_config()

    layer_copied = dc.models.layers.GraphGather.from_config(config)



    assert graph_gather_new.batch_size == graph_gather.batch_size

    assert graph_gather_new.activation_fn == graph_gather.activation_fn

    assert layer_copied.batch_size == layer_copied.batch_size

    assert layer_copied.activation_fn == layer_copied.activation_fn



  def test_graph_pool(self):

    min_degree = 0

    max_degree = 10

    graph_pool = dc.models.layers.GraphPool(



    layer_copied = dc.models.layers.GraphPool(

        min_degree=min_degree, max_degree=max_degree)

    config = layer_copied.get_config()

    layer_copied = dc.models.layers.GraphPool.from_config(config)



    assert layer_copied.max_degree == layer_copied.max_degree

    assert layer_copied.min_degree == layer_copied.min_degree



  def test_lstmstep(self):

    output_dim = 100

    input_dim = 50

    init_fn = 'glorot_uniform'

    inner_init_fn = 'orthogonal'

    activation_fn = 'tanh'

    inner_activation_fn = 'hard_sigmoid'



    layer = dc.models.layers.LSTMStep(output_dim, input_dim, init_fn,

                                      inner_init_fn, activation_fn,

                                      inner_activation_fn)

    config = layer.get_config()

    layer_copied = dc.models.layers.LSTMStep.from_config(config)



    assert layer_copied.output_dim == layer.output_dim

    assert layer_copied.input_dim == layer.input_dim

    assert layer_copied.init == layer.init

    assert layer_copied.inner_init == layer.inner_init

    assert layer_copied.activation == layer.activation

    assert layer_copied.inner_activation == layer.inner_activation



  def test_attn_lstm_embedding(self):

    n_test = 10

    n_support = 100

    n_feat = 20

    max_depth = 3



    layer = dc.models.layers.AttnLSTMEmbedding(n_test, n_support, n_feat,

                                               max_depth)

    config = layer.get_config()

    layer_copied = dc.models.layers.AttnLSTMEmbedding.from_config(config)



    assert layer_copied.n_test == layer.n_test

    assert layer_copied.n_support == layer.n_support

    assert layer_copied.n_feat == layer.n_feat

    assert layer_copied.max_depth == layer.max_depth



  def test_iterref_lstm_embedding(self):

    n_test = 10

    n_support = 100

    n_feat = 20

    max_depth = 3



    layer = dc.models.layers.IterRefLSTMEmbedding(n_test, n_support, n_feat,

                                                  max_depth)

    config = layer.get_config()

    layer_copied = dc.models.layers.IterRefLSTMEmbedding.from_config(config)



    assert layer_copied.n_test == layer.n_test

    assert layer_copied.n_support == layer.n_support

    assert layer_copied.n_feat == layer.n_feat

    assert layer_copied.max_depth == layer.max_depth



  def test_switched_dropout(self):

    rate = 0.1

    layer = dc.models.layers.SwitchedDropout(rate=rate)

    config = layer.get_config()

    layer_copied = dc.models.layers.SwitchedDropout.from_config(config)



    assert layer_copied.rate == layer.rate



  def test_weighted_linearcombo(self):

    std = 0.1

    layer = dc.models.layers.WeightedLinearCombo(std=std)



    config = layer.get_config()

    layer_copied = dc.models.layers.WeightedLinearCombo.from_config(config)



    assert layer_copied.std == layer.std



  def test_combine_mean_std(self):

    training_only = True

    noise_epsilon = 0.001



    layer = dc.models.layers.CombineMeanStd(training_only, noise_epsilon)

    config = layer.get_config()

    layer_copied = dc.models.layers.CombineMeanStd.from_config(config)



    assert layer_copied.training_only == layer.training_only

    assert layer_copied.noise_epsilon == layer.noise_epsilon



  def test_stack(self):

    axis = 2

    layer = dc.models.layers.Stack(axis=axis)

    config = layer.get_config()

    layer_copied = dc.models.layers.Stack.from_config(config)



    assert layer_copied.axis == layer.axis



  def test_variable(self):

    initial_value = 10

    layer = dc.models.layers.Variable(initial_value)

    config = layer.get_config()

    layer_copied = dc.models.layers.Variable.from_config(config)



    assert layer_copied.initial_value == layer.initial_value



  def test_vina_free_energy(self):

    N_atoms = 10

    M_nbrs = 15

    ndim = 20

    nbr_cutoff = 5

    start = 1

    stop = 7

    stddev = 0.3

    Nrot = 1



    layer = dc.models.layers.VinaFreeEnergy(N_atoms, M_nbrs, ndim, nbr_cutoff,

                                            start, stop, stddev, Nrot)

    config = layer.get_config()

    layer_copied = dc.models.layers.VinaFreeEnergy.from_config(config)



    assert layer_copied.N_atoms == layer.N_atoms

    assert layer_copied.M_nbrs == layer.M_nbrs

    assert layer_copied.ndim == layer.ndim

    assert layer_copied.nbr_cutoff == layer.nbr_cutoff

    assert layer_copied.start == layer.start

    assert layer_copied.stop == layer.stop

    assert layer_copied.stddev == layer.stddev

    assert layer_copied.Nrot == layer_copied.Nrot



  def test_neighbor_list(self):

    N_atoms = 10

    M_nbrs = 15

    ndim = 20

    nbr_cutoff = 5

    start = 1

    stop = 7



    layer = dc.models.layers.NeighborList(N_atoms, M_nbrs, ndim, nbr_cutoff,

                                          start, stop)

    config = layer.get_config()

    layer_copied = dc.models.layers.VinaFreeEnergy.from_config(config)



    assert layer_copied.N_atoms == layer.N_atoms

    assert layer_copied.M_nbrs == layer.M_nbrs

    assert layer_copied.ndim == layer.ndim

    assert layer_copied.nbr_cutoff == layer.nbr_cutoff

    assert layer_copied.start == layer.start

    assert layer_copied.stop == layer.stop



  def test_atomic_convolution(self):

    atom_types = None

    radial_params = list()

    boxsize = None



    layer = dc.models.layers.AtomicConvolution(atom_types, radial_params,

                                               boxsize)

    config = layer.get_config()

    layer_copied = dc.models.layers.AtomicConvolution.from_config(config)



    assert layer_copied.atom_types == layer.atom_types

    assert layer_copied.radial_params == layer.radial_params

    assert layer_copied.boxsize == layer.boxsize



  def test_ani_feat(self):

    max_atoms = 23

    radial_cutoff = 4.6

    angular_cutoff = 3.1

    radial_length = 32

    angular_length = 8

    atom_cases = [1, 6, 7, 8, 16]

    atomic_number_differentiated = True

    coordinates_in_bohr = True



    layer = dc.models.layers.ANIFeat(

        max_atoms, radial_cutoff, angular_cutoff, radial_length, angular_length,

        atom_cases, atomic_number_differentiated, coordinates_in_bohr)

    config = layer.get_config()

    layer_copied = dc.models.layers.ANIFeat.from_config(config)



    assert layer_copied.max_atoms == layer.max_atoms

    assert layer_copied.radial_cutoff == layer.radial_cutoff

    assert layer_copied.angular_cutoff == layer.angular_cutoff

    assert layer_copied.radial_length == layer.radial_length

    assert layer_copied.angular_length == layer.angular_length

    assert layer_copied.atom_cases == layer.atom_cases

    assert layer_copied.atomic_number_differentiated == layer.atomic_number_differentiated

    assert layer_copied.coordinates_in_bohr == layer.coordinates_in_bohr



  def test_graph_embed_pool(self):

    num_vertices = 100

    layer = dc.models.layers.GraphEmbedPoolLayer(num_vertices)

    config = layer.get_config()

    layer_copied = dc.models.layers.GraphEmbedPoolLayer.from_config(config)



    assert layer_copied.num_vertices == layer.num_vertices



  def test_graph_cnn(self):

    num_filters = 20

    layer = dc.models.layers.GraphCNN(num_filters)

    config = layer.get_config()

    layer_copied = dc.models.layers.GraphCNN.from_config(config)



    assert layer_copied.num_filters == layer.num_filters



  def test_highway(self):

    activation_fn = 'relu'

    biases_initializer = 'zeros'

    weights_initializer = None



    layer = dc.models.layers.Highway(activation_fn, biases_initializer,

                                     weights_initializer)

    config = layer.get_config()

    layer_copied = dc.models.layers.Highway.from_config(config)



    assert layer_copied.activation_fn == layer.activation_fn

    assert layer_copied.biases_initializer == layer.biases_initializer

    assert layer_copied.weights_initializer == layer.weights_initializer



  def test_weave(self):

    n_atom_input_feat = 75

    n_pair_input_feat = 14

    n_atom_output_feat = 50

    n_pair_output_feat = 50

    n_hidden_AA = 50

    n_hidden_PA = 50

    n_hidden_AP = 50

    n_hidden_PP = 50

    update_pair = True

    init = 'glorot_uniform'

    activation = 'relu'



    layer = dc.models.layers.WeaveLayer(

        n_atom_input_feat, n_pair_input_feat, n_atom_output_feat,

        n_pair_output_feat, n_hidden_AA, n_hidden_PA, n_hidden_AP, n_hidden_PP,

        update_pair, init, activation)

    config = layer.get_config()

    layer_copied = dc.models.layers.WeaveLayer.from_config(config)



    assert layer_copied.n_atom_input_feat == layer.n_atom_input_feat

    assert layer_copied.n_pair_input_feat == layer.n_pair_input_feat

    assert layer_copied.n_atom_output_feat == layer.n_atom_output_feat

    assert layer_copied.n_pair_output_feat == layer.n_pair_output_feat

    assert layer_copied.n_hidden_AA == layer.n_hidden_AA

    assert layer_copied.n_hidden_PA == layer.n_hidden_PA

    assert layer_copied.n_hidden_AP == layer.n_hidden_AP

    assert layer_copied.n_hidden_PP == layer.n_hidden_PP

    assert layer_copied.update_pair == layer.update_pair

    assert layer_copied.init == layer.init

    assert layer_copied.activation == layer.activation



  def test_weave_gather(self):

    batch_size = 32

    n_input = 128

    gaussian_expand = False

    init = 'glorot_uniform'

    activation = 'tanh'

    epsilon = 1e-3

    momentum = 0.99



    layer = dc.models.layers.WeaveGather(batch_size, n_input, gaussian_expand,

                                         init, activation, epsilon, momentum)

    config = layer.get_config()

    layer_copied = dc.models.layers.WeaveGather.from_config(config)



    assert layer_copied.batch_size == layer.batch_size

    assert layer_copied.n_input == layer.n_input

    assert layer_copied.gaussian_expand == layer.gaussian_expand

    assert layer_copied.init == layer.init

    assert layer_copied.activation == layer.activation

    assert layer_copied.epsilon == layer.epsilon

    assert layer_copied.momentum == layer.momentum



  def test_dtnn_embedding(self):

    n_embedding = 30

    periodic_table_length = 30

    init = 'glorot_uniform'



    layer = dc.models.layers.DTNNEmbedding(n_embedding, periodic_table_length,

                                           init)

    config = layer.get_config()

    layer_copied = dc.models.layers.DTNNEmbedding.from_config(config)



    assert layer_copied.n_embedding == layer.n_embedding

    assert layer_copied.periodic_table_length == layer.periodic_table_length

    assert layer_copied.init == layer.init



  def test_dtnn_step(self):

    n_embedding = 30

    n_distance = 100

    n_hidden = 60

    init = 'glorot_uniform'

    activation = 'tanh'



    layer = dc.models.layers.DTNNStep(n_embedding, n_distance, n_hidden, init,

                                      activation)

    config = layer.get_config()

    layer_copied = dc.models.layers.DTNNStep.from_config(config)



    assert layer_copied.n_embedding == layer.n_embedding

    assert layer_copied.n_distance == layer.n_distance

    assert layer_copied.n_hidden == layer.n_hidden

    assert layer_copied.init == layer.init

    assert layer_copied.activation == layer.activation



  def test_dtnn_gather(self):

    n_embedding = 30

    n_outputs = 100

    layer_sizes = [100]

    output_activation = True

    init = 'glorot_uniform'

    activation = 'tanh'



    layer = dc.models.layers.DTNNGather(n_embedding, n_outputs, layer_sizes,

                                        output_activation, init, activation)

    config = layer.get_config()

    layer_copied = dc.models.layers.DTNNGather.from_config(config)



    assert layer_copied.n_embedding == layer.n_embedding

    assert layer_copied.n_outputs == layer.n_outputs

    assert layer_copied.layer_sizes == layer.layer_sizes

    assert layer_copied.output_activation == layer.output_activation

    assert layer_copied.init == layer.init

    assert layer_copied.activation == layer.activation



  def test_dag(self):

    n_graph_feat = 30

    n_atom_feat = 75

    max_atoms = 50

    layer_sizes = [100]

    init = 'glorot_uniform'

    activation = 'relu'

    dropout = None

    batch_size = 64



    layer = dc.models.layers.DAGLayer(n_graph_feat, n_atom_feat, max_atoms,

                                      layer_sizes, init, activation, dropout,

                                      batch_size)

    config = layer.get_config()

    layer_copied = dc.models.layers.DAGLayer.from_config(config)



    assert layer_copied.n_graph_feat == layer.n_graph_feat

    assert layer_copied.n_atom_feat == layer.n_atom_feat

    assert layer_copied.max_atoms == layer.max_atoms

    assert layer_copied.layer_sizes == layer.layer_sizes

    assert layer_copied.init == layer.init

    assert layer_copied.activation == layer.activation

    assert layer_copied.dropout == layer.dropout

    assert layer_copied.batch_size == layer.batch_size



  def test_dag_gather(self):

    n_graph_feat = 30

    n_outputs = 30

    max_atoms = 50

    layer_sizes = [100]

    init = 'glorot_uniform'

    activation = 'relu'

    dropout = None



    layer = dc.models.layers.DAGGather(n_graph_feat, n_outputs, max_atoms,

                                       layer_sizes, init, activation, dropout)

    config = layer.get_config()

    layer_copied = dc.models.layers.DAGGather.from_config(config)



    assert layer_copied.n_graph_feat == layer.n_graph_feat

    assert layer_copied.n_outputs == layer.n_outputs

    assert layer_copied.max_atoms == layer.max_atoms

    assert layer_copied.layer_sizes == layer.layer_sizes

    assert layer_copied.init == layer.init

    assert layer_copied.activation == layer.activation

    assert layer_copied.dropout == layer.dropout



  def test_message_passing(self):

    T = 20

    message_fn = 'enn'

    update_fn = 'gru'

    n_hidden = 100

    layer = dc.models.layers.MessagePassing(T, message_fn, update_fn, n_hidden)

    config = layer.get_config()

    layer_copied = dc.models.layers.MessagePassing.from_config(config)



    assert layer_copied.T == layer.T

    assert layer_copied.message_fn == layer.message_fn

    assert layer_copied.update_fn == layer.update_fn

    assert layer_copied.n_hidden == layer.n_hidden



  def test_edge_network(self):

    n_pair_features = 8

    n_hidden = 100

    init = 'glorot_uniform'

    layer = dc.models.layers.EdgeNetwork(n_pair_features, n_hidden, init)

    config = layer.get_config()

    layer_copied = dc.models.layers.EdgeNetwork.from_config(config)



    assert layer_copied.n_pair_features == layer.n_pair_features

    assert layer_copied.n_hidden == layer.n_hidden

    assert layer_copied.init == layer.init



  def test_gru(self):

    n_hidden = 100

    init = 'glorot_uniform'

    layer = dc.models.layers.GatedRecurrentUnit(n_hidden, init)

    config = layer.get_config()

    layer_copied = dc.models.layers.GatedRecurrentUnit.from_config(config)



    assert layer_copied.n_hidden == layer.n_hidden

    assert layer_copied.init == layer.init



  def test_set_gather(self):

    M = 10

    batch_size = 16

    n_hidden = 100

    init = 'orthogonal'



    config = graph_pool.get_config()

    graph_pool_new = dc.models.layers.GraphPool.from_config(config)

    layer = dc.models.layers.SetGather(M, batch_size, n_hidden, init)

    config = layer.get_config()

    layer_copied = dc.models.layers.SetGather.from_config(config)



    assert graph_pool_new.max_degree == graph_pool.max_degree

    assert graph_pool_new.min_degree == graph_pool.min_degree
 
    assert layer_copied.M == layer.M

    assert layer_copied.batch_size == layer.batch_size

    assert layer_copied.n_hidden == layer.n_hidden

    assert layer_copied.init == layer.init

CRA Git | Maintained and supported by SUSTech CRA and CCSE