def test_shapes(self):
"""Simple test that Graph topology placeholders have correct shapes."""
n_atoms = 5
n_feat = 10
batch_size = 3
max_deg = 6
min_deg = 0
topology = GraphTopology(n_feat)
# Degrees from 1 to max_deg inclusive
# TODO(rbharath): Should this be 0 to max_deg inclusive?
deg_adj_lists_placeholders = topology.get_deg_adjacency_lists_placeholders(
)
assert len(deg_adj_lists_placeholders) == max_deg
for ind, deg_adj_list in enumerate(deg_adj_lists_placeholders):
deg = ind + 1
# Should have shape (?, deg)
assert deg_adj_list.get_shape()[1] == deg
# Shape of atom_features should be (?, n_feat)
atom_features = topology.get_atom_features_placeholder()
assert atom_features.get_shape()[1] == n_feat
# Shape of deg_slice placeholder should be (max_deg+1-min_deg, 2)
deg_slice = topology.get_deg_slice_placeholder()
print("deg_slice.get_shape()")
print(deg_slice.get_shape())
assert deg_slice.get_shape() == (max_deg + 1 - min_deg, 2)
def __init__(self, n_feat):
"""
Parameters
----------
n_feat: int
Number of atomic features.
"""
# Create graph topology and x
self.test_graph_topology = GraphTopology(n_feat, name='test')
self.support_graph_topology = GraphTopology(n_feat, name='support')
self.test = self.test_graph_topology.get_atom_features_placeholder()
self.support = self.support_graph_topology.get_atom_features_placeholder()
# Keep track of the layers
self.layers = []
# Whether or not we have used the GraphGather layer yet
self.bool_pre_gather = True
def test_graph_pool(self):
"""Tests that GraphPool transforms shapes correctly."""
n_atoms = 5
n_feat = 10
batch_size = 3
nb_filter = 7
with self.test_session() as sess:
graph_topology = GraphTopology(n_feat)
graph_pool_layer = GraphPool()
X = graph_topology.get_input_placeholders()
out = graph_pool_layer(X)
def __init__(self, n_feat):
"""
Parameters
----------
n_feat: int
Number of features per atom.
"""
#self.graph_topology = GraphTopology(n_atoms, n_feat)
self.graph_topology = GraphTopology(n_feat)
self.output = self.graph_topology.get_atom_features_placeholder()
# Keep track of the layers
self.layers = []
def test_graph_convolution(self):
"""Tests that Graph Convolution transforms shapes correctly."""
n_atoms = 5
n_feat = 10
nb_filter = 7
with self.test_session() as sess:
graph_topology = GraphTopology(n_feat)
graph_conv_layer = GraphConv(nb_filter)
X = graph_topology.get_input_placeholders()
out = graph_conv_layer(X)
# Output should be of shape (?, nb_filter)
assert out.get_shape()[1] == nb_filter
def test_graph_gather(self):
"""Tests that GraphGather transforms shapes correctly."""
n_atoms = 5
n_feat = 10
batch_size = 3
nb_filter = 7
with self.test_session() as sess:
graph_topology = GraphTopology(n_feat)
graph_gather_layer = GraphGather(batch_size)
X = graph_topology.get_input_placeholders()
out = graph_gather_layer(X)
# Output should be of shape (batch_size, n_feat)
assert out.get_shape() == (batch_size, n_feat)
def test_attn_lstm_embedding(self):
"""Test that attention LSTM computation works properly."""
max_depth = 5
n_test = 5
n_support = 11
n_feat = 10
nb_filter = 7
with self.test_session() as sess:
graph_topology_test = GraphTopology(n_feat)
graph_topology_support = GraphTopology(n_feat)
test = graph_topology_test.get_input_placeholders()[0]
support = graph_topology_support.get_input_placeholders()[0]
attn_embedding_layer = AttnLSTMEmbedding(n_test, n_support,
max_depth)
# Try concatenating the two lists of placeholders
feed_dict = {
test: np.zeros((n_test, n_feat)),
support: np.zeros((n_support, n_feat))
}
test_out, support_out = attn_embedding_layer([test, support])
assert test_out.get_shape() == (n_test, n_feat)
assert support_out.get_shape()[1] == (n_feat)
