def compute_output_shape(self, inputs_shape):
# Import dimensions
(max_atoms, max_degree, num_atom_features, num_bond_features,
num_samples) = mol_shapes_to_dims(mol_shapes=inputs_shape)
return (num_samples, self.fp_length)
def build(self, inputs_shape):
# Import dimensions
(max_atoms, max_degree, num_atom_features, num_bond_features,
num_samples) = mol_shapes_to_dims(mol_shapes=inputs_shape)
self.max_degree = max_degree
# Add the dense layers (that contain trainable params)
# (for each degree we convolve with a different weight matrix)
self.trainable_weights.append(self.trainable_weights)
self.inner_3D_layers = []
for degree in range(max_degree):
# Initialise inner layer, and rename it
inner_layer = self.create_inner_layer_fn()
inner_layer_type = inner_layer.__class__.__name__.lower()
inner_layer._name = self.name + '_inner_' + inner_layer_type + '_' + str(
degree)
# Initialise TimeDistributed layer wrapper in order to parallelise
# dense layer across atoms (3D)
inner_3D_layer_name = self.name + '_inner_timedistributed_' + str(
degree)
inner_3D_layer = layers.TimeDistributed(inner_layer,
name=inner_3D_layer_name)
# Build the TimeDistributed layer (which will build the Dense layer)
inner_3D_layer.build(
(None, max_atoms, num_atom_features + num_bond_features))
# Store inner_3D_layer and it's weights
self.inner_3D_layers.append(inner_3D_layer)
self._trainable_weights += inner_3D_layer.trainable_weights
def build(self, inputs_shape):
# Import dimensions
(max_atoms, max_degree, num_atom_features, num_bond_features,
num_samples) = mol_shapes_to_dims(mol_shapes=inputs_shape)
# Add the dense layer that contains the trainable parameters
# Initialise dense layer with specified params (kwargs) and name
inner_layer = self.create_inner_layer_fn()
inner_layer_type = inner_layer.__class__.__name__.lower()
inner_layer._name = self.name + '_inner_' + inner_layer_type
# Initialise TimeDistributed layer wrapper in order to parallelise
# dense layer across atoms
inner_3D_layer_name = self.name + '_inner_timedistributed'
self.inner_3D_layer = layers.TimeDistributed(inner_layer,
name=inner_3D_layer_name)
# Build the TimeDistributed layer (which will build the Dense layer)
self.inner_3D_layer.build(
(None, max_atoms, num_atom_features + num_bond_features))
# Store dense_3D_layer and it's weights
self._trainable_weights = self.inner_3D_layer.trainable_weights