def construct_graph(graph_dict): return tfg.Graph( x=create_fake_node_features(graph_dict["num_nodes"]), edge_index=graph_dict["edge_index"], y=graph_dict[ "graph_label"] # graph_dict["graph_label"] is a list with one int element )
def construct_graph(graph_dict): return tfg.Graph( x=convert_node_labels_to_one_hot(graph_dict["node_labels"]), edge_index=graph_dict["edge_index"], y=graph_dict[ "graph_label"] # graph_dict["graph_label"] is a list with one int element )
def __init__(self, sess, ob_space, ac_space, n_env, n_steps, n_batch, graph): super(GATPolicy, self).__init__(sess, ob_space, ac_space, n_env, n_steps, n_batch) cluster_info = nx.get_node_attributes(graph, 'cluster') node_attr = np.zeros(shape=(len(cluster_info), 2), dtype=np.float32) for key, value in cluster_info.items( ): # Try having all 0s for not-controller node_attr[key][1] = value edge_weights = nx.get_edge_attributes(graph, 'weight') edge_attr = np.empty(shape=(len(edge_weights), ), dtype=np.float32) edges = np.array(graph.edges).T i = 0 for key, value in edge_weights.items(): assert (edges[0][i], edges[1][i]) == key edge_attr[i] = value i += 1 edges, [edge_attr] = tfg.utils.graph_utils.convert_edge_to_directed( edges, [edge_attr]) self.graph = tfg.Graph(x=node_attr, edge_index=edges, edge_weight=edge_attr) print([self.graph.x, self.graph.edge_index, self.graph.edge_weight]) print(self.graph.x.shape) print(self.graph.edge_index.shape) print(self.graph.edge_weight.shape) print(self.graph) #self.graph.x = tf.placeholder(tf.int16, shape=(len(cluster_info),)) #print(self.graph.x) self.graph.convert_data_to_tensor() gcn0 = tfg.layers.GCN(16, activation=tf.nn.relu) #gcn1 = tfg.layers.GCN(128) h = gcn0([self.graph.x, self.graph.edge_index, self.graph.edge_weight]) h = gcn1([h, self.graph.edge_index, self.graph.edge_weight], cache=self.graph.cache) print(h) self.q_values = action_out self._setup_init() def step(self, obs, state=None, mask=None, deterministic=True): q_values, actions_proba = self.sess.run( [self.q_values, self.policy_proba], {self.obs_ph: obs}) if deterministic: actions = np.argmax(q_values, axis=1) else: # Unefficient sampling # TODO: replace the loop # maybe with Gumbel-max trick ? (http://amid.fish/humble-gumbel) actions = np.zeros((len(obs), ), dtype=np.int64) for action_idx in range(len(obs)): actions[action_idx] = np.random.choice( self.n_actions, p=actions_proba[action_idx]) return actions, q_values, None
def construct_graph( graph_dict ): #构建图,将节点类别的one_hot作为节点特征(num_nodes, 37),将图的类别标签作为图的ground_truth(1,) return tfg.Graph( x=convert_node_labels_to_one_hot(graph_dict["node_labels"]), edge_index=graph_dict["edge_index"], y=graph_dict[ "graph_label"] # graph_dict["graph_label"] is a list with one int element )
def construct_graph( graph_dict ): #构建图,将节点类别的one_hot作为节点特征(num_nodes, 37),将图的类别标签作为图的ground_truth(1,) return tfg.Graph( x=keras.utils.to_categorical(graph_dict["node_labels"], num_node_labels), edge_index=graph_dict["edge_index"], y=graph_dict[ "graph_label"] # graph_dict["graph_label"] is a list with one int element )
def build_word_graph(num_words, pmi_model, embedding_size): x = tf.Variable(tf.random.truncated_normal([num_words, embedding_size], stddev=1 / np.sqrt(embedding_size)), dtype=tf.float32) edges = [] edge_weight = [] for (word0, word1) in pmi_model.pair_counter.keys(): pmi = pmi_model.transform(word0, word1) if pmi > 0: edges.append([word0, word1]) edge_weight.append(pmi) edges.append([word1, word0]) edge_weight.append(pmi) edge_index = np.array(edges).T return tfg.Graph(x=x, edge_index=edge_index, edge_weight=edge_weight)
def build_combined_graph(word_graph, sequences, embedding_size): num_words = word_graph.num_nodes x = tf.zeros([len(sequences), embedding_size], dtype=tf.float32) edges = [] edge_weight = [] for i, sequence in enumerate(sequences): doc_node_index = num_words + i for word in sequence: edges.append([doc_node_index, word]) # only directed edge edge_weight.append(1.0) # use BOW instaead of TF-IDF edge_index = np.array(edges).T x = tf.concat([word_graph.x, x], axis=0) edge_index = np.concatenate([word_graph.edge_index, edge_index], axis=1) edge_weight = np.concatenate([word_graph.edge_weight, edge_weight], axis=0) return tfg.Graph(x=x, edge_index=edge_index, edge_weight=edge_weight)
# undirected edges can be used for evaluation undirected_train_edge_index, undirected_test_edge_index, _, _ = edge_train_test_split( edge_index=graph.edge_index, test_size=0.15 ) # use negative_sampling with replace=False to create negative edges for test undirected_test_neg_edge_index = negative_sampling( num_samples=undirected_test_edge_index.shape[1], num_nodes=graph.num_nodes, edge_index=graph.edge_index, replace=False ) # for training, you should convert undirected edges to directed edges for correct GCN propagation train_graph = tfg.Graph(x=graph.x, edge_index=undirected_train_edge_index).convert_edge_to_directed() embedding_size = 16 drop_rate = 0.2 gcn0 = tfg.layers.GCN(32, activation=tf.nn.relu) gcn1 = tfg.layers.GCN(embedding_size) dropout = keras.layers.Dropout(drop_rate) def encode(graph, training=False): h = gcn0([graph.x, graph.edge_index, graph.edge_weight], cache=graph.cache) h = dropout(h, training=training) h = gcn1([h, graph.edge_index, graph.edge_weight], cache=graph.cache) return h
# Make the edge_index directed such that we can use it as the input of GCN edge_index, [edge_weight] = convert_edge_to_directed(edge_index, [edge_weight]) # We can convert these numpy array as TensorFlow Tensors and pass them to gnn functions outputs = tfg.nn.gcn( tf.Variable(x), tf.constant(edge_index), tf.constant(edge_weight), tf.Variable(tf.random.truncated_normal([20, 2])) # GCN Weight ) print(outputs) # Usually, we use a graph object to manager these information # edge_weight is optional, we can set it to None if you don't need it graph = tfg.Graph(x=x, edge_index=edge_index, edge_weight=edge_weight) # You can easily convert these numpy arrays as Tensors with the Graph Object API graph.convert_data_to_tensor() # Then, we can use them without too many manual conversion outputs = tfg.nn.gcn( graph.x, graph.edge_index, graph.edge_weight, tf.Variable(tf.random.truncated_normal([20, 2])), # GCN Weight cache=graph. cache # GCN use caches to avoid re-computing of the normed edge information ) print(outputs)
nrows=max) fingerprint = fingerprint.drop(columns=['compoundID']) reactions = np.array(reactions.T) a = np.ones(shape=reactions.shape) reactions = reactions - a reactions = pd.DataFrame(reactions, dtype=np.int64) fingerprint = np.array(fingerprint) reactions = np.array(reactions) return reactions, fingerprint reactions_all, compounds_fp = load_data(DATA_PATH, FINGERPRINT, 1000) graph = tfg.Graph(x=compounds_fp, edge_index=reactions_all) # undirected edges can be used for evaluation undirected_train_edge_index, undirected_test_edge_index, _, _ = edge_train_test_split( edge_index=graph.edge_index, test_size=0.15) # use negative_sampling with replace=False to create negative edges for test undirected_test_neg_edge_index = negative_sampling( num_samples=undirected_test_edge_index.shape[1], num_nodes=graph.num_nodes, edge_index=graph.edge_index, replace=False) # convert undirected edges to directed edges for correct GCN propagation train_graph = tfg.Graph( x=graph.x,
# coding=utf-8 import numpy as np import tf_geometric as tfg import tensorflow as tf graph = tfg.Graph( x=np.random.randn(5, 20), # 5 nodes, 20 features, edge_index=[[0, 0, 1, 3], [1, 2, 2, 1]] # 4 undirected edges ) print("Graph Desc: \n", graph) graph.convert_edge_to_directed() # pre-process edges print("Processed Graph Desc: \n", graph) print("Processed Edge Index:\n", graph.edge_index) # Multi-head Graph Attention Network (GAT) gat_layer = tfg.layers.GAT(units=4, num_heads=4, activation=tf.nn.relu) output = gat_layer([graph.x, graph.edge_index]) print("Output of GAT: \n", output)