def test_shapes(self): """Simple test that Graph topology placeholders have correct shapes.""" n_atoms = 5 n_feat = 10 batch_size = 3 max_deg = 10 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)
class SequentialGraph(object): """An analog of Keras Sequential class for Graph data. Like the Sequential class from Keras, but automatically passes topology placeholders from GraphTopology to each graph layer (from layers) added to the network. Non graph layers don't get the extra placeholders. """ def __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of features per atom. """ warnings.warn( "SequentialGraph is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.graph = tf.Graph() with self.graph.as_default(): self.graph_topology = GraphTopology(n_feat) self.output = self.graph_topology.get_atom_features_placeholder() # Keep track of the layers self.layers = [] def add(self, layer): """Adds a new layer to model.""" with self.graph.as_default(): # For graphical layers, add connectivity placeholders if type(layer).__name__ in [ 'GraphConv', 'GraphGather', 'GraphPool' ]: if (len(self.layers) > 0 and hasattr(self.layers[-1], "__name__")): assert self.layers[-1].__name__ != "GraphGather", \ 'Cannot use GraphConv or GraphGather layers after a GraphGather' self.output = layer( [self.output] + self.graph_topology.get_topology_placeholders()) else: self.output = layer(self.output) # Add layer to the layer list self.layers.append(layer) def get_graph_topology(self): return self.graph_topology def get_num_output_features(self): """Gets the output shape of the featurization layers of the network""" return self.layers[-1].output_shape[1] def return_outputs(self): return self.output def return_inputs(self): return self.graph_topology.get_input_placeholders() def get_layer(self, layer_id): return self.layers[layer_id]
def test_shapes(self): """Simple test that Graph topology placeholders have correct shapes.""" n_atoms = 5 n_feat = 10 batch_size = 3 max_deg = 10 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)
class SequentialGraph(object): """An analog of Keras Sequential class for Graph data. Like the Sequential class from Keras, but automatically passes topology placeholders from GraphTopology to each graph layer (from layers) added to the network. Non graph layers don't get the extra placeholders. """ def __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of features per atom. """ warnings.warn("SequentialGraph is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.graph = tf.Graph() with self.graph.as_default(): self.graph_topology = GraphTopology(n_feat) self.output = self.graph_topology.get_atom_features_placeholder() # Keep track of the layers self.layers = [] def add(self, layer): """Adds a new layer to model.""" with self.graph.as_default(): # For graphical layers, add connectivity placeholders if type(layer).__name__ in ['GraphConv', 'GraphGather', 'GraphPool']: if (len(self.layers) > 0 and hasattr(self.layers[-1], "__name__")): assert self.layers[-1].__name__ != "GraphGather", \ 'Cannot use GraphConv or GraphGather layers after a GraphGather' self.output = layer([self.output] + self.graph_topology.get_topology_placeholders()) else: self.output = layer(self.output) # Add layer to the layer list self.layers.append(layer) def get_graph_topology(self): return self.graph_topology def get_num_output_features(self): """Gets the output shape of the featurization layers of the network""" return self.layers[-1].output_shape[1] def return_outputs(self): return self.output def return_inputs(self): return self.graph_topology.get_input_placeholders() def get_layer(self, layer_id): return self.layers[layer_id]
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 __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of features per atom. """ warnings.warn( "SequentialGraph is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.graph = tf.Graph() with self.graph.as_default(): self.graph_topology = GraphTopology(n_feat) self.output = self.graph_topology.get_atom_features_placeholder() # Keep track of the layers self.layers = []
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 __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of features per atom. """ self.graph = tf.Graph() #with self.graph.as_default(): if 1: self.graph_topology = GraphTopology(n_feat) self.output = self.graph_topology.get_atom_features_placeholder() self.training = tf.placeholder(dtype='float32', shape=(), name='ops_training') # Keep track of the layers self.layers = [] self.add_time = 0
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 __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of atomic features. """ warnings.warn("SequentialSupportWeaveGraph is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.graph = tf.Graph() with self.graph.as_default(): # 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 __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of atomic features. """ warnings.warn( "SequentialSupportWeaveGraph is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.graph = tf.Graph() with self.graph.as_default(): # 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 __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of features per atom. """ warnings.warn("SequentialGraph is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.graph = tf.Graph() with self.graph.as_default(): self.graph_topology = GraphTopology(n_feat) self.output = self.graph_topology.get_atom_features_placeholder() # Keep track of the layers self.layers = []
predic = one_hot(np.array(predic), n_class) precision, recall, thresholds = metrics.precision_recall_curve(y_test.ravel(), predic.ravel()) micro_auprc = metrics.auc(precision, recall) except Exception: micro_auprc=0. # tp = np.sum(np.float32(np.logical_and(np.equal(predic,1), np.equal(auc_y_set, 1)))) # fp = np.sum(np.float32(np.logical_and(np.equal(predic,1), np.equal(auc_y_set, 0)))) # tn = np.sum(np.float32(np.logical_and(np.equal(predic,0), np.equal(auc_y_set, 0)))) # fn = np.sum(np.float32(np.logical_and(np.equal(predic,0), np.equal(auc_y_set, 1)))) # accuracy = scores(tp, fp, tn, fn) # print(auc_y_set) return accuracy_1,(accuracy,macro_recall,micro_recall,macro_precision,micro_precision,macro_f1,micro_f1,micro_auprc) with tf.Graph().as_default(): graphA_topology = GraphTopology(n_features, name='topology_A') graphB_topology = GraphTopology(n_features, name='topology_B') with tf.name_scope('input'): outputA = graphA_topology.get_atom_features_placeholder() outputB = graphB_topology.get_atom_features_placeholder() label_gold = tf.placeholder(dtype=tf.int32, shape=[None], name="label_placeholder") training = tf.placeholder(dtype='float32', shape=(), name='ops_training') add_time = 0 lstm = tf.contrib.rnn.BasicLSTMCell(Dense_size) hidden_state = tf.zeros([batch_size, lstm.state_size[0]]) current_state = tf.zeros([batch_size, lstm.state_size[0]]) lstm_1 = tf.contrib.rnn.BasicLSTMCell(Dense_size*2) Hidden_state = tf.zeros([batch_size, lstm_1.state_size[0]]) Current_state = tf.zeros([batch_size, lstm_1.state_size[0]])
class SequentialGraph(object): """An analog of Keras Sequential class for Graph data. Like the Sequential class from Keras, but automatically passes topology placeholders from GraphTopology to each graph layer (from layers) added to the network. Non graph layers don't get the extra placeholders. """ def __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of features per atom. """ self.graph = tf.Graph() #with self.graph.as_default(): if 1: self.graph_topology = GraphTopology(n_feat) self.output = self.graph_topology.get_atom_features_placeholder() self.training = tf.placeholder(dtype='float32', shape=(), name='ops_training') # Keep track of the layers self.layers = [] self.add_time = 0 def get_training_state(self): return self.training def add(self, layer): """Adds a new layer to model.""" #with self.graph.as_default(): if 1: # For graphical layers, add connectivity placeholders if type(layer).__name__ in [ 'GraphResBlock', 'GraphConv', 'GraphGather', 'GraphPool' ]: if (len(self.layers) > 0 and hasattr(self.layers[-1], "__name__")): assert self.layers[-1].__name__ != "GraphGather", \ 'Cannot use GraphConv or GraphGather layers after a GraphGather' self.output = layer( [self.output] + self.graph_topology.get_topology_placeholders() + [self.training] + [self.add_time]) else: self.output = layer(self.output) # Add layer to the layer list self.layers.append(layer) self.add_time = self.add_time + 1 def get_graph_topology(self): return self.graph_topology def get_num_output_features(self): """Gets the output shape of the featurization layers of the network""" return self.layers[-1].output_shape[1] def return_outputs(self): return self.output def return_inputs(self): return self.graph_topology.get_input_placeholders() def get_layer(self, layer_id): return self.layers[layer_id]
class SequentialSupportGraph(object): """An analog of Keras Sequential model for test/support models.""" def __init__(self, n_feat): """ Parameters ---------- n_feat: int Number of atomic features. """ self.graph = tf.Graph() with self.graph.as_default(): # 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 add(self, layer): """Adds a layer to both test/support stacks. Note that the layer transformation is performed independently on the test/support tensors. """ with self.graph.as_default(): self.layers.append(layer) # Update new value of x if type(layer).__name__ in ['GraphConv', 'GraphGather', 'GraphPool']: assert self.bool_pre_gather, "Cannot apply graphical layers after gather." self.test = layer([self.test] + self.test_graph_topology.topology) self.support = layer([self.support] + self.support_graph_topology.topology) else: self.test = layer(self.test) self.support = layer(self.support) if type(layer).__name__ == 'GraphGather': self.bool_pre_gather = False # Set flag to stop adding topology def add_test(self, layer): """Adds a layer to test.""" with self.graph.as_default(): self.layers.append(layer) # Update new value of x if type(layer).__name__ in ['GraphConv', 'GraphPool', 'GraphGather']: self.test = layer([self.test] + self.test_graph_topology.topology) else: self.test = layer(self.test) def add_support(self, layer): """Adds a layer to support.""" with self.graph.as_default(): self.layers.append(layer) # Update new value of x if type(layer).__name__ in ['GraphConv', 'GraphPool', 'GraphGather']: self.support = layer([self.support] + self.support_graph_topology.topology) else: self.support = layer(self.support) def join(self, layer): """Joins test and support to a two input two output layer""" with self.graph.as_default(): self.layers.append(layer) self.test, self.support = layer([self.test, self.support]) def get_test_output(self): return self.test def get_support_output(self): return self.support def return_outputs(self): return [self.test] + [self.support] def return_inputs(self): return (self.test_graph_topology.get_inputs() + self.support_graph_topology.get_inputs())
class SequentialSupportGraph(object): """An analog of Keras Sequential model for test/support models.""" 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 add(self, layer): """Adds a layer to both test/support stacks. Note that the layer transformation is performed independently on the test/support tensors. """ self.layers.append(layer) # Update new value of x if type(layer).__name__ in ['GraphConv', 'GraphGather', 'GraphPool']: assert self.bool_pre_gather, "Cannot apply graphical layers after gather." self.test = layer([self.test] + self.test_graph_topology.topology) self.support = layer([self.support] + self.support_graph_topology.topology) else: self.test = layer(self.test) self.support = layer(self.support) if type(layer).__name__ == 'GraphGather': self.bool_pre_gather = False # Set flag to stop adding topology def add_test(self, layer): """Adds a layer to test.""" self.layers.append(layer) # Update new value of x if type(layer).__name__ in ['GraphConv', 'GraphPool', 'GraphGather']: self.test = layer([self.test] + self.test_graph_topology.topology) else: self.test = layer(self.test) def add_support(self, layer): """Adds a layer to support.""" self.layers.append(layer) # Update new value of x if type(layer).__name__ in ['GraphConv', 'GraphPool', 'GraphGather']: self.support = layer([self.support] + self.support_graph_topology.topology) else: self.support = layer(self.support) def join(self, layer): """Joins test and support to a two input two output layer""" self.layers.append(layer) self.test, self.support = layer([self.test, self.support]) def get_test_output(self): return self.test def get_support_output(self): return self.support def return_outputs(self): return [self.test] + [self.support] def return_inputs(self): return (self.test_graph_topology.get_inputs() + self.support_graph_topology.get_inputs())
fp = np.sum( np.float32(np.logical_and(np.equal(predic, 1), np.equal(auc_y_set, 0)))) tn = np.sum( np.float32(np.logical_and(np.equal(predic, 0), np.equal(auc_y_set, 0)))) fn = np.sum( np.float32(np.logical_and(np.equal(predic, 0), np.equal(auc_y_set, 1)))) accuracy = scores(tp, fp, tn, fn) # print(auc_y_set) return accuracy_1, auc, accuracy with tf.Graph().as_default(): graphA_topology = GraphTopology(n_features, name='topology_A') graphB_topology = GraphTopology(n_features, name='topology_B') with tf.name_scope('input'): outputA = graphA_topology.get_atom_features_placeholder() outputB = graphB_topology.get_atom_features_placeholder() label_gold = tf.placeholder(dtype=tf.int32, shape=[None], name="label_placeholder") training = tf.placeholder(dtype='float32', shape=(), name='ops_training') add_time = 0 lstm = tf.contrib.rnn.BasicLSTMCell(Dense_size) hidden_state = tf.zeros([batch_size, lstm.state_size[0]]) current_state = tf.zeros([batch_size, lstm.state_size[0]])