Loading deepchem/feat/adjacency_fingerprints.py +8 −4 Original line number Diff line number Diff line Loading @@ -134,10 +134,12 @@ def get_atom_adj_matrices(mol, return (adj_matrix.astype(np.uint8), atom_matrix.astype(np.uint8)) def featurize_mol(mol, n_atom_types, max_n_atoms, max_valence): def featurize_mol(mol, n_atom_types, max_n_atoms, max_valence, num_atoms_feature): adj_matrix, atom_matrix = get_atom_adj_matrices(mol, n_atom_types, max_n_atoms, max_valence) if num_atoms_feature: return ((adj_matrix, atom_matrix, mol.GetNumAtoms())) return ((adj_matrix, atom_matrix)) Loading @@ -147,11 +149,13 @@ class AdjacencyFingerprint(Featurizer): n_atom_types=23, max_n_atoms=200, add_hydrogens=False, max_valence=4): max_valence=4, num_atoms_feature=False): self.n_atom_types = n_atom_types self.max_n_atoms = max_n_atoms self.add_hydrogens = add_hydrogens self.max_valence = max_valence self.num_atoms_feature = num_atoms_feature def featurize(self, rdkit_mols): featurized_mols = np.empty((len(rdkit_mols)), dtype=object) Loading @@ -160,6 +164,6 @@ class AdjacencyFingerprint(Featurizer): if self.add_hydrogens: mol = Chem.AddHs(mol) featurized_mol = featurize_mol(mol, self.n_atom_types, self.max_n_atoms, self.max_valence) self.max_valence, self.num_atoms_feature) featurized_mols[idx] = featurized_mol return (featurized_mols) deepchem/models/tensorgraph/layers.py +231 −3 Original line number Diff line number Diff line Loading @@ -9,6 +9,7 @@ import tensorflow as tf import numpy as np from deepchem.nn import model_ops, initializations, regularizers, activations import math class Layer(object): Loading Loading @@ -3244,3 +3245,230 @@ class BetaShare(Layer): def set_tensors(self, tensor): self.out_tensor, self.betas = tensor class PassThroughLayer(Layer): """ Layer which takes a tensor from in_tensor[0].out_tensors at an index """ def __init__(self, output_num, **kwargs): """ Parameters ---------- output_num: int The index which to use as this layers out_tensor from in_layers[0] kwargs """ self.output_num = output_num super(PassThroughLayer, self).__init__(**kwargs) def create_tensor(self, in_layers=None, set_tensors=True, **kwargs): self.out_tensor = self.in_layers[0].out_tensors[self.output_num] class GraphEmbedPoolLayer(Layer): """ GraphCNNPool Layer from Robust Spatial Filtering with Graph Convolutional Neural Networks https://arxiv.org/abs/1703.00792 This is a learnable pool operation It constructs a new adjacency matrix for a graph of specified number of nodes. This differs from our other pool opertions which set vertices to a function value without altering the adjacency matrix. $V_{emb} = SpatialGraphCNN({V_{in}})$\\ $V_{out} = \sigma(V_{emb})^{T} * V_{in}$ $A_{out} = V_{emb}^{T} * A_{in} * V_{emb}$ """ def __init__(self, num_vertices, **kwargs): self.num_vertices = num_vertices super(GraphEmbedPoolLayer, self).__init__(**kwargs) def create_tensor(self, in_layers=None, set_tensors=True, **kwargs): """ Parameters ---------- num_filters: int Number of filters to have in the output in_layers: list of Layers or tensors [V, A, mask] V are the vertex features must be of shape (batch, vertex, channel) A are the adjacency matrixes for each graph Shape (batch, from_vertex, adj_matrix, to_vertex) mask is optional, to be used when not every graph has the same number of vertices Returns: tf.tensor Returns a tf.tensor with a graph convolution applied The shape will be (batch, vertex, self.num_filters) """ in_tensors = self._get_input_tensors(in_layers) if len(in_tensors) == 3: V, A, mask = in_tensors else: V, A = in_tensors mask = None factors = self.embedding_factors( V, self.num_vertices, name='%s_Factors' % self.name) if mask is not None: factors = tf.multiply(factors, mask) factors = self.softmax_factors(factors) result = tf.matmul(factors, V, transpose_a=True) result_A = tf.reshape(A, (tf.shape(A)[0], -1, tf.shape(A)[-1])) result_A = tf.matmul(result_A, factors) result_A = tf.reshape(result_A, (tf.shape(A)[0], tf.shape(A)[-1], -1)) result_A = tf.matmul(factors, result_A, transpose_a=True) result_A = tf.reshape(result_A, (tf.shape(A)[0], self.num_vertices, A.get_shape()[2].value, self.num_vertices)) # We do not need the mask because every graph has self.num_vertices vertices now if set_tensors: self.out_tensor = result[0] self.out_tensors = [result, result_A] return result, result_A def embedding_factors(self, V, no_filters, name="default"): no_features = V.get_shape()[-1].value W = tf.get_variable( '%s_weights' % name, [no_features, no_filters], initializer=tf.truncated_normal_initializer( stddev=1.0 / math.sqrt(no_features)), dtype=tf.float32) b = tf.get_variable( '%s_bias' % self.name, [no_filters], initializer=tf.constant_initializer(0.1), dtype=tf.float32) V_reshape = tf.reshape(V, (-1, no_features)) s = tf.slice(tf.shape(V), [0], [len(V.get_shape()) - 1]) s = tf.concat([s, tf.stack([no_filters])], 0) result = tf.reshape(tf.matmul(V_reshape, W) + b, s) return result def softmax_factors(self, V, axis=1, name=None): max_value = tf.reduce_max(V, axis=axis, keep_dims=True) exp = tf.exp(tf.subtract(V, max_value)) prob = tf.div(exp, tf.reduce_sum(exp, axis=axis, keep_dims=True)) return prob def none_tensors(self): out_tensors, out_tensor = self.out_tensors, self.out_tensor self.out_tensors = None self.out_tensor = None return out_tensors, out_tensor def set_tensors(self, tensor): self.out_tensors, self.out_tensor = tensor def GraphCNNPool(num_vertices, **kwargs): gcnnpool_layer = GraphEmbedPoolLayer(num_vertices, **kwargs) return [PassThroughLayer(x, in_layers=gcnnpool_layer) for x in range(2)] class GraphCNN(Layer): """ GraphCNN Layer from Robust Spatial Filtering with Graph Convolutional Neural Networks https://arxiv.org/abs/1703.00792 Spatial-domain convolutions can be defined as H = h_0I + h_1A + h_2A^2 + ... + hkAk, H ∈ R**(N×N) We approximate it by H ≈ h_0I + h_1A We can define a convolution as applying multiple these linear filters over edges of different types (think up, down, left, right, diagonal in images) Where each edge type has its own adjacency matrix H ≈ h_0I + h_1A_1 + h_2A_2 + . . . h_(L−1)A_(L−1) V_out = \sum_{c=1}^{C} H^{c} V^{c} + b """ def __init__(self, num_filters, **kwargs): """ Parameters ---------- num_filters: int Number of filters to have in the output in_layers: list of Layers or tensors [V, A, mask] V are the vertex features must be of shape (batch, vertex, channel) A are the adjacency matrixes for each graph Shape (batch, from_vertex, adj_matrix, to_vertex) mask is optional, to be used when not every graph has the same number of vertices Returns: tf.tensor Returns a tf.tensor with a graph convolution applied The shape will be (batch, vertex, self.num_filters) """ self.num_filters = num_filters super(GraphCNN, self).__init__(**kwargs) def create_tensor(self, in_layers=None, set_tensors=True, **kwargs): inputs = self._get_input_tensors(in_layers) if len(inputs) == 3: V, A, mask = inputs else: V, A = inputs no_A = A.get_shape()[2].value no_features = V.get_shape()[2].value W = tf.get_variable( '%s_weights' % self.name, [no_features * no_A, self.num_filters], initializer=tf.truncated_normal_initializer(stddev=math.sqrt( 1.0 / (no_features * (no_A + 1) * 1.0))), dtype=tf.float32) W_I = tf.get_variable( '%s_weights_I' % self.name, [no_features, self.num_filters], initializer=tf.truncated_normal_initializer(stddev=math.sqrt( 1.0 / (no_features * (no_A + 1) * 1.0))), dtype=tf.float32) b = tf.get_variable( '%s_bias' % self.name, [self.num_filters], initializer=tf.constant_initializer(0.1), dtype=tf.float32) n = self.graphConvolution(V, A) A_shape = tf.shape(A) n = tf.reshape(n, [-1, A_shape[1], no_A * no_features]) result = self.batch_mat_mult(n, W) + self.batch_mat_mult(V, W_I) + b if set_tensors: self.out_tensor = result return result def graphConvolution(self, V, A): no_A = A.get_shape()[2].value no_features = V.get_shape()[2].value A_shape = tf.shape(A) A_reshape = tf.reshape(A, tf.stack([-1, A_shape[1] * no_A, A_shape[1]])) n = tf.matmul(A_reshape, V) return tf.reshape(n, [-1, A_shape[1], no_A, no_features]) def batch_mat_mult(self, A, B): A_shape = tf.shape(A) A_reshape = tf.reshape(A, [-1, A_shape[-1]]) # So the Tensor has known dimensions if B.get_shape()[1] == None: axis_2 = -1 else: axis_2 = B.get_shape()[1] result = tf.matmul(A_reshape, B) result = tf.reshape(result, tf.stack([A_shape[0], A_shape[1], axis_2])) return result deepchem/models/tensorgraph/models/graph_models.py +197 −13 Original line number Diff line number Diff line import numpy as np import six import tensorflow as tf from deepchem.data import NumpyDataset from deepchem.feat.graph_features import ConvMolFeaturizer from deepchem.feat.mol_graphs import ConvMol from deepchem.metrics import to_one_hot, from_one_hot from deepchem.metrics import to_one_hot from deepchem.models.tensorgraph.graph_layers import WeaveLayer, WeaveGather, \ Combine_AP, Separate_AP, DTNNEmbedding, DTNNStep, DTNNGather, DAGLayer, \ DAGGather, DTNNExtract, MessagePassing, SetGather from deepchem.models.tensorgraph.layers import Dense, Concat, SoftMax, \ SoftMaxCrossEntropy, GraphConv, BatchNorm, \ GraphPool, GraphGather, WeightedError, Dropout, BatchNormalization, Stack GraphPool, GraphGather, WeightedError, Dropout, BatchNormalization, Stack, Layer, Flatten, GraphCNN, GraphCNNPool from deepchem.models.tensorgraph.layers import L2Loss, Label, Weights, Feature from deepchem.models.tensorgraph.tensor_graph import TensorGraph from deepchem.trans import undo_transforms from deepchem.utils.evaluate import GeneratorEvaluator from deepchem.data import NumpyDataset from deepchem.data.data_loader import featurize_smiles_np from deepchem.feat.graph_features import ConvMolFeaturizer class WeaveTensorGraph(TensorGraph): Loading Loading @@ -487,6 +484,151 @@ class DAGTensorGraph(TensorGraph): yield feed_dict class PetroskiSuchTensorGraph(TensorGraph): """ Model from Robust Spatial Filtering with Graph Convolutional Neural Networks https://arxiv.org/abs/1703.00792 """ def __init__(self, n_tasks, max_atoms=200, dropout=0.0, mode="classification", **kwargs): """ Parameters ---------- n_tasks: int Number of tasks mode: str Either "classification" or "regression" """ self.n_tasks = n_tasks self.mode = mode self.max_atoms = max_atoms self.error_bars = True if 'error_bars' in kwargs and kwargs['error_bars'] else False self.dropout = dropout kwargs['use_queue'] = False super(PetroskiSuchTensorGraph, self).__init__(**kwargs) self.build_graph() def build_graph(self): self.vertex_features = Feature(shape=(None, self.max_atoms, 75)) self.adj_matrix = Feature(shape=(None, self.max_atoms, 1, self.max_atoms)) self.mask = Feature(shape=(None, self.max_atoms, 1)) gcnn1 = BatchNorm( GraphCNN( num_filters=64, in_layers=[self.vertex_features, self.adj_matrix, self.mask])) gcnn1 = Dropout(self.dropout, in_layers=gcnn1) gcnn2 = BatchNorm( GraphCNN(num_filters=64, in_layers=[gcnn1, self.adj_matrix, self.mask])) gcnn2 = Dropout(self.dropout, in_layers=gcnn2) gc_pool, adj_matrix = GraphCNNPool( num_vertices=32, in_layers=[gcnn2, self.adj_matrix, self.mask]) gc_pool = BatchNorm(gc_pool) gc_pool = Dropout(self.dropout, in_layers=gc_pool) gcnn3 = BatchNorm(GraphCNN(num_filters=32, in_layers=[gc_pool, adj_matrix])) gcnn3 = Dropout(self.dropout, in_layers=gcnn3) gc_pool2, adj_matrix2 = GraphCNNPool( num_vertices=8, in_layers=[gcnn3, adj_matrix]) gc_pool2 = BatchNorm(gc_pool2) gc_pool2 = Dropout(self.dropout, in_layers=gc_pool2) flattened = Flatten(in_layers=gc_pool2) readout = Dense( out_channels=256, activation_fn=tf.nn.relu, in_layers=flattened) costs = [] self.my_labels = [] for task in range(self.n_tasks): if self.mode == 'classification': classification = Dense( out_channels=2, activation_fn=None, in_layers=[readout]) softmax = SoftMax(in_layers=[classification]) self.add_output(softmax) label = Label(shape=(None, 2)) self.my_labels.append(label) cost = SoftMaxCrossEntropy(in_layers=[label, classification]) costs.append(cost) if self.mode == 'regression': regression = Dense( out_channels=1, activation_fn=None, in_layers=[readout]) self.add_output(regression) label = Label(shape=(None, 1)) self.my_labels.append(label) cost = L2Loss(in_layers=[label, regression]) costs.append(cost) if self.mode == "classification": entropy = Concat(in_layers=costs, axis=-1) elif self.mode == "regression": entropy = Stack(in_layers=costs, axis=1) self.my_task_weights = Weights(shape=(None, self.n_tasks)) loss = WeightedError(in_layers=[entropy, self.my_task_weights]) self.set_loss(loss) def default_generator(self, dataset, epochs=1, predict=False, deterministic=True, pad_batches=True): for epoch in range(epochs): if not predict: print('Starting epoch %i' % epoch) for ind, (X_b, y_b, w_b, ids_b) in enumerate( dataset.iterbatches( self.batch_size, pad_batches=True, deterministic=deterministic)): d = {} for index, label in enumerate(self.my_labels): if self.mode == 'classification': d[label] = to_one_hot(y_b[:, index]) if self.mode == 'regression': d[label] = np.expand_dims(y_b[:, index], -1) d[self.my_task_weights] = w_b d[self.adj_matrix] = np.expand_dims(np.array([x[0] for x in X_b]), -2) d[self.vertex_features] = np.array([x[1] for x in X_b]) mask = np.zeros(shape=(self.batch_size, self.max_atoms, 1)) for i in range(self.batch_size): mask_size = X_b[i][2] mask[i][:mask_size][0] = 1 d[self.mask] = mask yield d def predict_proba_on_generator(self, generator, transformers=[]): if not self.built: self.build() with self._get_tf("Graph").as_default(): out_tensors = [x.out_tensor for x in self.outputs] results = [] for feed_dict in generator: feed_dict = { self.layers[k.name].out_tensor: v for k, v in six.iteritems(feed_dict) } feed_dict[self._training_placeholder] = 1.0 ## result = np.array(self.session.run(out_tensors, feed_dict=feed_dict)) if len(result.shape) == 3: result = np.transpose(result, axes=[1, 0, 2]) if len(transformers) > 0: result = undo_transforms(result, transformers) results.append(result) return np.concatenate(results, axis=0) def evaluate(self, dataset, metrics, transformers=[], per_task_metrics=False): if not self.built: self.build() return self.evaluate_generator( self.default_generator(dataset, predict=True), metrics, labels=self.my_labels, weights=[self.my_task_weights], per_task_metrics=per_task_metrics) class GraphConvTensorGraph(TensorGraph): def __init__(self, n_tasks, mode="classification", **kwargs): Loading Loading @@ -603,7 +745,48 @@ class GraphConvTensorGraph(TensorGraph): d[self.deg_adjs[i - 1]] = multiConvMol.get_deg_adjacency_lists()[i] yield d def predict_proba_on_generator(self, generator, transformers=[]): def predict_on_generator(self, generator, transformers=[], outputs=None): if not self.built: self.build() if outputs is None: outputs = self.outputs elif not isinstance(outputs, collections.Sequence): outputs = [outputs] with self._get_tf("Graph").as_default(): # Gather results for each output results = [[] for out in outputs] for feed_dict in generator: feed_dict = { self.layers[k.name].out_tensor: v for k, v in six.iteritems(feed_dict) } # Recording the number of samples in the input batch n_samples = max(feed_dict[self.membership.out_tensor]) + 1 feed_dict[self._training_placeholder] = 0.0 feed_results = self.session.run(outputs, feed_dict=feed_dict) if len(feed_results) > 1: if len(transformers): raise ValueError("Does not support transformations " "for multiple outputs.") elif len(feed_results) == 1: result = undo_transforms(feed_results[0], transformers) feed_results = [result] for ind, result in enumerate(feed_results): # GraphConvTensorGraph constantly outputs batch_size number of # results, only valid samples should be appended to final results results[ind].append(result[:n_samples]) final_results = [] for result_list in results: final_results.append(np.concatenate(result_list, axis=0)) # If only one output, just return array if len(final_results) == 1: return final_results[0] else: return final_results def predict_proba_on_generator(self, generator, transformers=[], outputs=None): if not self.built: self.build() with self._get_tf("Graph").as_default(): Loading @@ -614,13 +797,14 @@ class GraphConvTensorGraph(TensorGraph): self.layers[k.name].out_tensor: v for k, v in six.iteritems(feed_dict) } n_samples = max(feed_dict[self.membership.out_tensor]) + 1 feed_dict[self._training_placeholder] = 1.0 ## result = np.array(self.session.run(out_tensors, feed_dict=feed_dict)) if len(result.shape) == 3: result = np.transpose(result, axes=[1, 0, 2]) if len(transformers) > 0: result = undo_transforms(result, transformers) results.append(result) results.append(result[:n_samples]) return np.concatenate(results, axis=0) def evaluate(self, dataset, metrics, transformers=[], per_task_metrics=False): Loading deepchem/models/tensorgraph/tests/test_layers.py +23 −2 Original line number Diff line number Diff line Loading @@ -5,7 +5,7 @@ from tensorflow.python.framework import test_util from deepchem.feat.graph_features import ConvMolFeaturizer from deepchem.feat.mol_graphs import ConvMol from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D, MaxPool3D from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D, MaxPool3D, GraphCNN, GraphEmbedPoolLayer from deepchem.models.tensorgraph.layers import AlphaShareLayer from deepchem.models.tensorgraph.layers import AttnLSTMEmbedding from deepchem.models.tensorgraph.layers import BatchNorm Loading Loading @@ -734,3 +734,24 @@ class TestLayers(test_util.TensorFlowTestCase): output_tensor = SluiceLoss()(input1, input2) sess.run(tf.global_variables_initializer()) assert output_tensor.eval() == 40.0 def test_graphcnn(self): """ Test GraphCNN Layer From https://arxiv.org/abs/1703.00792""" V = np.random.uniform(size=(10, 100, 50)).astype(np.float32) adjs = np.random.uniform(size=(10, 100, 5, 100)).astype(np.float32) with self.test_session() as sess: out_tensor = GraphCNN(num_filters=6)(V, adjs) sess.run(tf.global_variables_initializer()) result = out_tensor.eval() assert result.shape == (10, 100, 6) def test_graphcnnpool(self): """ Test GraphCNNPool Layer From https://arxiv.org/abs/1703.00792""" V = np.random.uniform(size=(10, 100, 50)).astype(np.float32) adjs = np.random.uniform(size=(10, 100, 5, 100)).astype(np.float32) with self.test_session() as sess: vertex_props, adjs = GraphEmbedPoolLayer(num_vertices=6)(V, adjs) sess.run(tf.global_variables_initializer()) vertex_props, adjs = vertex_props.eval(), adjs.eval() assert vertex_props.shape == (10, 6, 50) assert adjs.shape == (10, 6, 5, 6) deepchem/models/tensorgraph/tests/test_layers_pickle.py +23 −1 Original line number Diff line number Diff line Loading @@ -11,7 +11,7 @@ from deepchem.models.tensorgraph.layers import Feature, Conv1D, Dense, Flatten, SoftMaxCrossEntropy, ReduceMean, ToFloat, ReduceSquareDifference, Conv2D, MaxPool2D, ReduceSum, GraphConv, GraphPool, \ GraphGather, BatchNorm, WeightedError, \ Conv3D, MaxPool3D, \ LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding, GraphEmbedPoolLayer, GraphCNN from deepchem.models.tensorgraph.symmetry_functions import AtomicDifferentiatedDense Loading Loading @@ -578,3 +578,25 @@ def test_AtomicDifferentialDense_pickle(): tg.set_loss(atomic_differential_dense) tg.build() tg.save() def testGraphCNN_pickle(): V = Feature(shape=(None, 200, 50)) A = Feature(shape=(None, 200, 1, 200)) gcnn = GraphCNN(32, in_layers=[V, A]) tg = TensorGraph() tg.add_output(gcnn) tg.set_loss(gcnn) tg.build() tg.save() def testGraphCNNPoolLayer_pickle(): V = Feature(shape=(None, 200, 50)) A = Feature(shape=(None, 200, 1, 200)) gcnnpool = GraphEmbedPoolLayer(32, in_layers=[V, A]) tg = TensorGraph() tg.add_output(gcnnpool) tg.set_loss(gcnnpool) tg.build() tg.save() Loading
deepchem/feat/adjacency_fingerprints.py +8 −4 Original line number Diff line number Diff line Loading @@ -134,10 +134,12 @@ def get_atom_adj_matrices(mol, return (adj_matrix.astype(np.uint8), atom_matrix.astype(np.uint8)) def featurize_mol(mol, n_atom_types, max_n_atoms, max_valence): def featurize_mol(mol, n_atom_types, max_n_atoms, max_valence, num_atoms_feature): adj_matrix, atom_matrix = get_atom_adj_matrices(mol, n_atom_types, max_n_atoms, max_valence) if num_atoms_feature: return ((adj_matrix, atom_matrix, mol.GetNumAtoms())) return ((adj_matrix, atom_matrix)) Loading @@ -147,11 +149,13 @@ class AdjacencyFingerprint(Featurizer): n_atom_types=23, max_n_atoms=200, add_hydrogens=False, max_valence=4): max_valence=4, num_atoms_feature=False): self.n_atom_types = n_atom_types self.max_n_atoms = max_n_atoms self.add_hydrogens = add_hydrogens self.max_valence = max_valence self.num_atoms_feature = num_atoms_feature def featurize(self, rdkit_mols): featurized_mols = np.empty((len(rdkit_mols)), dtype=object) Loading @@ -160,6 +164,6 @@ class AdjacencyFingerprint(Featurizer): if self.add_hydrogens: mol = Chem.AddHs(mol) featurized_mol = featurize_mol(mol, self.n_atom_types, self.max_n_atoms, self.max_valence) self.max_valence, self.num_atoms_feature) featurized_mols[idx] = featurized_mol return (featurized_mols)
deepchem/models/tensorgraph/layers.py +231 −3 Original line number Diff line number Diff line Loading @@ -9,6 +9,7 @@ import tensorflow as tf import numpy as np from deepchem.nn import model_ops, initializations, regularizers, activations import math class Layer(object): Loading Loading @@ -3244,3 +3245,230 @@ class BetaShare(Layer): def set_tensors(self, tensor): self.out_tensor, self.betas = tensor class PassThroughLayer(Layer): """ Layer which takes a tensor from in_tensor[0].out_tensors at an index """ def __init__(self, output_num, **kwargs): """ Parameters ---------- output_num: int The index which to use as this layers out_tensor from in_layers[0] kwargs """ self.output_num = output_num super(PassThroughLayer, self).__init__(**kwargs) def create_tensor(self, in_layers=None, set_tensors=True, **kwargs): self.out_tensor = self.in_layers[0].out_tensors[self.output_num] class GraphEmbedPoolLayer(Layer): """ GraphCNNPool Layer from Robust Spatial Filtering with Graph Convolutional Neural Networks https://arxiv.org/abs/1703.00792 This is a learnable pool operation It constructs a new adjacency matrix for a graph of specified number of nodes. This differs from our other pool opertions which set vertices to a function value without altering the adjacency matrix. $V_{emb} = SpatialGraphCNN({V_{in}})$\\ $V_{out} = \sigma(V_{emb})^{T} * V_{in}$ $A_{out} = V_{emb}^{T} * A_{in} * V_{emb}$ """ def __init__(self, num_vertices, **kwargs): self.num_vertices = num_vertices super(GraphEmbedPoolLayer, self).__init__(**kwargs) def create_tensor(self, in_layers=None, set_tensors=True, **kwargs): """ Parameters ---------- num_filters: int Number of filters to have in the output in_layers: list of Layers or tensors [V, A, mask] V are the vertex features must be of shape (batch, vertex, channel) A are the adjacency matrixes for each graph Shape (batch, from_vertex, adj_matrix, to_vertex) mask is optional, to be used when not every graph has the same number of vertices Returns: tf.tensor Returns a tf.tensor with a graph convolution applied The shape will be (batch, vertex, self.num_filters) """ in_tensors = self._get_input_tensors(in_layers) if len(in_tensors) == 3: V, A, mask = in_tensors else: V, A = in_tensors mask = None factors = self.embedding_factors( V, self.num_vertices, name='%s_Factors' % self.name) if mask is not None: factors = tf.multiply(factors, mask) factors = self.softmax_factors(factors) result = tf.matmul(factors, V, transpose_a=True) result_A = tf.reshape(A, (tf.shape(A)[0], -1, tf.shape(A)[-1])) result_A = tf.matmul(result_A, factors) result_A = tf.reshape(result_A, (tf.shape(A)[0], tf.shape(A)[-1], -1)) result_A = tf.matmul(factors, result_A, transpose_a=True) result_A = tf.reshape(result_A, (tf.shape(A)[0], self.num_vertices, A.get_shape()[2].value, self.num_vertices)) # We do not need the mask because every graph has self.num_vertices vertices now if set_tensors: self.out_tensor = result[0] self.out_tensors = [result, result_A] return result, result_A def embedding_factors(self, V, no_filters, name="default"): no_features = V.get_shape()[-1].value W = tf.get_variable( '%s_weights' % name, [no_features, no_filters], initializer=tf.truncated_normal_initializer( stddev=1.0 / math.sqrt(no_features)), dtype=tf.float32) b = tf.get_variable( '%s_bias' % self.name, [no_filters], initializer=tf.constant_initializer(0.1), dtype=tf.float32) V_reshape = tf.reshape(V, (-1, no_features)) s = tf.slice(tf.shape(V), [0], [len(V.get_shape()) - 1]) s = tf.concat([s, tf.stack([no_filters])], 0) result = tf.reshape(tf.matmul(V_reshape, W) + b, s) return result def softmax_factors(self, V, axis=1, name=None): max_value = tf.reduce_max(V, axis=axis, keep_dims=True) exp = tf.exp(tf.subtract(V, max_value)) prob = tf.div(exp, tf.reduce_sum(exp, axis=axis, keep_dims=True)) return prob def none_tensors(self): out_tensors, out_tensor = self.out_tensors, self.out_tensor self.out_tensors = None self.out_tensor = None return out_tensors, out_tensor def set_tensors(self, tensor): self.out_tensors, self.out_tensor = tensor def GraphCNNPool(num_vertices, **kwargs): gcnnpool_layer = GraphEmbedPoolLayer(num_vertices, **kwargs) return [PassThroughLayer(x, in_layers=gcnnpool_layer) for x in range(2)] class GraphCNN(Layer): """ GraphCNN Layer from Robust Spatial Filtering with Graph Convolutional Neural Networks https://arxiv.org/abs/1703.00792 Spatial-domain convolutions can be defined as H = h_0I + h_1A + h_2A^2 + ... + hkAk, H ∈ R**(N×N) We approximate it by H ≈ h_0I + h_1A We can define a convolution as applying multiple these linear filters over edges of different types (think up, down, left, right, diagonal in images) Where each edge type has its own adjacency matrix H ≈ h_0I + h_1A_1 + h_2A_2 + . . . h_(L−1)A_(L−1) V_out = \sum_{c=1}^{C} H^{c} V^{c} + b """ def __init__(self, num_filters, **kwargs): """ Parameters ---------- num_filters: int Number of filters to have in the output in_layers: list of Layers or tensors [V, A, mask] V are the vertex features must be of shape (batch, vertex, channel) A are the adjacency matrixes for each graph Shape (batch, from_vertex, adj_matrix, to_vertex) mask is optional, to be used when not every graph has the same number of vertices Returns: tf.tensor Returns a tf.tensor with a graph convolution applied The shape will be (batch, vertex, self.num_filters) """ self.num_filters = num_filters super(GraphCNN, self).__init__(**kwargs) def create_tensor(self, in_layers=None, set_tensors=True, **kwargs): inputs = self._get_input_tensors(in_layers) if len(inputs) == 3: V, A, mask = inputs else: V, A = inputs no_A = A.get_shape()[2].value no_features = V.get_shape()[2].value W = tf.get_variable( '%s_weights' % self.name, [no_features * no_A, self.num_filters], initializer=tf.truncated_normal_initializer(stddev=math.sqrt( 1.0 / (no_features * (no_A + 1) * 1.0))), dtype=tf.float32) W_I = tf.get_variable( '%s_weights_I' % self.name, [no_features, self.num_filters], initializer=tf.truncated_normal_initializer(stddev=math.sqrt( 1.0 / (no_features * (no_A + 1) * 1.0))), dtype=tf.float32) b = tf.get_variable( '%s_bias' % self.name, [self.num_filters], initializer=tf.constant_initializer(0.1), dtype=tf.float32) n = self.graphConvolution(V, A) A_shape = tf.shape(A) n = tf.reshape(n, [-1, A_shape[1], no_A * no_features]) result = self.batch_mat_mult(n, W) + self.batch_mat_mult(V, W_I) + b if set_tensors: self.out_tensor = result return result def graphConvolution(self, V, A): no_A = A.get_shape()[2].value no_features = V.get_shape()[2].value A_shape = tf.shape(A) A_reshape = tf.reshape(A, tf.stack([-1, A_shape[1] * no_A, A_shape[1]])) n = tf.matmul(A_reshape, V) return tf.reshape(n, [-1, A_shape[1], no_A, no_features]) def batch_mat_mult(self, A, B): A_shape = tf.shape(A) A_reshape = tf.reshape(A, [-1, A_shape[-1]]) # So the Tensor has known dimensions if B.get_shape()[1] == None: axis_2 = -1 else: axis_2 = B.get_shape()[1] result = tf.matmul(A_reshape, B) result = tf.reshape(result, tf.stack([A_shape[0], A_shape[1], axis_2])) return result
deepchem/models/tensorgraph/models/graph_models.py +197 −13 Original line number Diff line number Diff line import numpy as np import six import tensorflow as tf from deepchem.data import NumpyDataset from deepchem.feat.graph_features import ConvMolFeaturizer from deepchem.feat.mol_graphs import ConvMol from deepchem.metrics import to_one_hot, from_one_hot from deepchem.metrics import to_one_hot from deepchem.models.tensorgraph.graph_layers import WeaveLayer, WeaveGather, \ Combine_AP, Separate_AP, DTNNEmbedding, DTNNStep, DTNNGather, DAGLayer, \ DAGGather, DTNNExtract, MessagePassing, SetGather from deepchem.models.tensorgraph.layers import Dense, Concat, SoftMax, \ SoftMaxCrossEntropy, GraphConv, BatchNorm, \ GraphPool, GraphGather, WeightedError, Dropout, BatchNormalization, Stack GraphPool, GraphGather, WeightedError, Dropout, BatchNormalization, Stack, Layer, Flatten, GraphCNN, GraphCNNPool from deepchem.models.tensorgraph.layers import L2Loss, Label, Weights, Feature from deepchem.models.tensorgraph.tensor_graph import TensorGraph from deepchem.trans import undo_transforms from deepchem.utils.evaluate import GeneratorEvaluator from deepchem.data import NumpyDataset from deepchem.data.data_loader import featurize_smiles_np from deepchem.feat.graph_features import ConvMolFeaturizer class WeaveTensorGraph(TensorGraph): Loading Loading @@ -487,6 +484,151 @@ class DAGTensorGraph(TensorGraph): yield feed_dict class PetroskiSuchTensorGraph(TensorGraph): """ Model from Robust Spatial Filtering with Graph Convolutional Neural Networks https://arxiv.org/abs/1703.00792 """ def __init__(self, n_tasks, max_atoms=200, dropout=0.0, mode="classification", **kwargs): """ Parameters ---------- n_tasks: int Number of tasks mode: str Either "classification" or "regression" """ self.n_tasks = n_tasks self.mode = mode self.max_atoms = max_atoms self.error_bars = True if 'error_bars' in kwargs and kwargs['error_bars'] else False self.dropout = dropout kwargs['use_queue'] = False super(PetroskiSuchTensorGraph, self).__init__(**kwargs) self.build_graph() def build_graph(self): self.vertex_features = Feature(shape=(None, self.max_atoms, 75)) self.adj_matrix = Feature(shape=(None, self.max_atoms, 1, self.max_atoms)) self.mask = Feature(shape=(None, self.max_atoms, 1)) gcnn1 = BatchNorm( GraphCNN( num_filters=64, in_layers=[self.vertex_features, self.adj_matrix, self.mask])) gcnn1 = Dropout(self.dropout, in_layers=gcnn1) gcnn2 = BatchNorm( GraphCNN(num_filters=64, in_layers=[gcnn1, self.adj_matrix, self.mask])) gcnn2 = Dropout(self.dropout, in_layers=gcnn2) gc_pool, adj_matrix = GraphCNNPool( num_vertices=32, in_layers=[gcnn2, self.adj_matrix, self.mask]) gc_pool = BatchNorm(gc_pool) gc_pool = Dropout(self.dropout, in_layers=gc_pool) gcnn3 = BatchNorm(GraphCNN(num_filters=32, in_layers=[gc_pool, adj_matrix])) gcnn3 = Dropout(self.dropout, in_layers=gcnn3) gc_pool2, adj_matrix2 = GraphCNNPool( num_vertices=8, in_layers=[gcnn3, adj_matrix]) gc_pool2 = BatchNorm(gc_pool2) gc_pool2 = Dropout(self.dropout, in_layers=gc_pool2) flattened = Flatten(in_layers=gc_pool2) readout = Dense( out_channels=256, activation_fn=tf.nn.relu, in_layers=flattened) costs = [] self.my_labels = [] for task in range(self.n_tasks): if self.mode == 'classification': classification = Dense( out_channels=2, activation_fn=None, in_layers=[readout]) softmax = SoftMax(in_layers=[classification]) self.add_output(softmax) label = Label(shape=(None, 2)) self.my_labels.append(label) cost = SoftMaxCrossEntropy(in_layers=[label, classification]) costs.append(cost) if self.mode == 'regression': regression = Dense( out_channels=1, activation_fn=None, in_layers=[readout]) self.add_output(regression) label = Label(shape=(None, 1)) self.my_labels.append(label) cost = L2Loss(in_layers=[label, regression]) costs.append(cost) if self.mode == "classification": entropy = Concat(in_layers=costs, axis=-1) elif self.mode == "regression": entropy = Stack(in_layers=costs, axis=1) self.my_task_weights = Weights(shape=(None, self.n_tasks)) loss = WeightedError(in_layers=[entropy, self.my_task_weights]) self.set_loss(loss) def default_generator(self, dataset, epochs=1, predict=False, deterministic=True, pad_batches=True): for epoch in range(epochs): if not predict: print('Starting epoch %i' % epoch) for ind, (X_b, y_b, w_b, ids_b) in enumerate( dataset.iterbatches( self.batch_size, pad_batches=True, deterministic=deterministic)): d = {} for index, label in enumerate(self.my_labels): if self.mode == 'classification': d[label] = to_one_hot(y_b[:, index]) if self.mode == 'regression': d[label] = np.expand_dims(y_b[:, index], -1) d[self.my_task_weights] = w_b d[self.adj_matrix] = np.expand_dims(np.array([x[0] for x in X_b]), -2) d[self.vertex_features] = np.array([x[1] for x in X_b]) mask = np.zeros(shape=(self.batch_size, self.max_atoms, 1)) for i in range(self.batch_size): mask_size = X_b[i][2] mask[i][:mask_size][0] = 1 d[self.mask] = mask yield d def predict_proba_on_generator(self, generator, transformers=[]): if not self.built: self.build() with self._get_tf("Graph").as_default(): out_tensors = [x.out_tensor for x in self.outputs] results = [] for feed_dict in generator: feed_dict = { self.layers[k.name].out_tensor: v for k, v in six.iteritems(feed_dict) } feed_dict[self._training_placeholder] = 1.0 ## result = np.array(self.session.run(out_tensors, feed_dict=feed_dict)) if len(result.shape) == 3: result = np.transpose(result, axes=[1, 0, 2]) if len(transformers) > 0: result = undo_transforms(result, transformers) results.append(result) return np.concatenate(results, axis=0) def evaluate(self, dataset, metrics, transformers=[], per_task_metrics=False): if not self.built: self.build() return self.evaluate_generator( self.default_generator(dataset, predict=True), metrics, labels=self.my_labels, weights=[self.my_task_weights], per_task_metrics=per_task_metrics) class GraphConvTensorGraph(TensorGraph): def __init__(self, n_tasks, mode="classification", **kwargs): Loading Loading @@ -603,7 +745,48 @@ class GraphConvTensorGraph(TensorGraph): d[self.deg_adjs[i - 1]] = multiConvMol.get_deg_adjacency_lists()[i] yield d def predict_proba_on_generator(self, generator, transformers=[]): def predict_on_generator(self, generator, transformers=[], outputs=None): if not self.built: self.build() if outputs is None: outputs = self.outputs elif not isinstance(outputs, collections.Sequence): outputs = [outputs] with self._get_tf("Graph").as_default(): # Gather results for each output results = [[] for out in outputs] for feed_dict in generator: feed_dict = { self.layers[k.name].out_tensor: v for k, v in six.iteritems(feed_dict) } # Recording the number of samples in the input batch n_samples = max(feed_dict[self.membership.out_tensor]) + 1 feed_dict[self._training_placeholder] = 0.0 feed_results = self.session.run(outputs, feed_dict=feed_dict) if len(feed_results) > 1: if len(transformers): raise ValueError("Does not support transformations " "for multiple outputs.") elif len(feed_results) == 1: result = undo_transforms(feed_results[0], transformers) feed_results = [result] for ind, result in enumerate(feed_results): # GraphConvTensorGraph constantly outputs batch_size number of # results, only valid samples should be appended to final results results[ind].append(result[:n_samples]) final_results = [] for result_list in results: final_results.append(np.concatenate(result_list, axis=0)) # If only one output, just return array if len(final_results) == 1: return final_results[0] else: return final_results def predict_proba_on_generator(self, generator, transformers=[], outputs=None): if not self.built: self.build() with self._get_tf("Graph").as_default(): Loading @@ -614,13 +797,14 @@ class GraphConvTensorGraph(TensorGraph): self.layers[k.name].out_tensor: v for k, v in six.iteritems(feed_dict) } n_samples = max(feed_dict[self.membership.out_tensor]) + 1 feed_dict[self._training_placeholder] = 1.0 ## result = np.array(self.session.run(out_tensors, feed_dict=feed_dict)) if len(result.shape) == 3: result = np.transpose(result, axes=[1, 0, 2]) if len(transformers) > 0: result = undo_transforms(result, transformers) results.append(result) results.append(result[:n_samples]) return np.concatenate(results, axis=0) def evaluate(self, dataset, metrics, transformers=[], per_task_metrics=False): Loading
deepchem/models/tensorgraph/tests/test_layers.py +23 −2 Original line number Diff line number Diff line Loading @@ -5,7 +5,7 @@ from tensorflow.python.framework import test_util from deepchem.feat.graph_features import ConvMolFeaturizer from deepchem.feat.mol_graphs import ConvMol from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D, MaxPool3D from deepchem.models.tensorgraph.layers import Add, Conv3D, MaxPool2D, MaxPool3D, GraphCNN, GraphEmbedPoolLayer from deepchem.models.tensorgraph.layers import AlphaShareLayer from deepchem.models.tensorgraph.layers import AttnLSTMEmbedding from deepchem.models.tensorgraph.layers import BatchNorm Loading Loading @@ -734,3 +734,24 @@ class TestLayers(test_util.TensorFlowTestCase): output_tensor = SluiceLoss()(input1, input2) sess.run(tf.global_variables_initializer()) assert output_tensor.eval() == 40.0 def test_graphcnn(self): """ Test GraphCNN Layer From https://arxiv.org/abs/1703.00792""" V = np.random.uniform(size=(10, 100, 50)).astype(np.float32) adjs = np.random.uniform(size=(10, 100, 5, 100)).astype(np.float32) with self.test_session() as sess: out_tensor = GraphCNN(num_filters=6)(V, adjs) sess.run(tf.global_variables_initializer()) result = out_tensor.eval() assert result.shape == (10, 100, 6) def test_graphcnnpool(self): """ Test GraphCNNPool Layer From https://arxiv.org/abs/1703.00792""" V = np.random.uniform(size=(10, 100, 50)).astype(np.float32) adjs = np.random.uniform(size=(10, 100, 5, 100)).astype(np.float32) with self.test_session() as sess: vertex_props, adjs = GraphEmbedPoolLayer(num_vertices=6)(V, adjs) sess.run(tf.global_variables_initializer()) vertex_props, adjs = vertex_props.eval(), adjs.eval() assert vertex_props.shape == (10, 6, 50) assert adjs.shape == (10, 6, 5, 6)
deepchem/models/tensorgraph/tests/test_layers_pickle.py +23 −1 Original line number Diff line number Diff line Loading @@ -11,7 +11,7 @@ from deepchem.models.tensorgraph.layers import Feature, Conv1D, Dense, Flatten, SoftMaxCrossEntropy, ReduceMean, ToFloat, ReduceSquareDifference, Conv2D, MaxPool2D, ReduceSum, GraphConv, GraphPool, \ GraphGather, BatchNorm, WeightedError, \ Conv3D, MaxPool3D, \ LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding LSTMStep, AttnLSTMEmbedding, IterRefLSTMEmbedding, GraphEmbedPoolLayer, GraphCNN from deepchem.models.tensorgraph.symmetry_functions import AtomicDifferentiatedDense Loading Loading @@ -578,3 +578,25 @@ def test_AtomicDifferentialDense_pickle(): tg.set_loss(atomic_differential_dense) tg.build() tg.save() def testGraphCNN_pickle(): V = Feature(shape=(None, 200, 50)) A = Feature(shape=(None, 200, 1, 200)) gcnn = GraphCNN(32, in_layers=[V, A]) tg = TensorGraph() tg.add_output(gcnn) tg.set_loss(gcnn) tg.build() tg.save() def testGraphCNNPoolLayer_pickle(): V = Feature(shape=(None, 200, 50)) A = Feature(shape=(None, 200, 1, 200)) gcnnpool = GraphEmbedPoolLayer(32, in_layers=[V, A]) tg = TensorGraph() tg.add_output(gcnnpool) tg.set_loss(gcnnpool) tg.build() tg.save()
