Revise code structure for gcn

Author: joshchang1112

research/gnn-survey-paper/__pycache__/layers.cpython-37.pyc

@@ -2,14 +2,28 @@
 
 class GraphConvLayer(tf.keras.layers.Layer):
 
-    def __init__(self, input_dim, units):
+    def __init__(self, features):
         super(GraphConvLayer, self).__init__()
+        self.in_feat = features['input_dim']
+        self.out_feat = features['output_dim']
+        self.b = features['bias']
+
+    def build(self, input_shape):
         self.weight = self.add_weight(name="weight",
-                                      shape=(input_dim, units),
-                                      trainable=True)    
+                                      shape=(self.in_feat, self.out_feat),
+                                      initializer='random_normal',
+                                      trainable=True)
+        if self.b:
+            self.bias = self.add_weight(name="bias",
+                                        shape=(self.out_feat,),
+                                        initializer='random_normal',
+                                        trainable=True)
     def call(self, inputs):
         x, adj = inputs[0], inputs[1]
        	x = tf.matmul(adj, x)
         outputs = tf.matmul(x, self.weight)
-        return outputs 
-        
+        if self.b:
+            return self.bias + outputs
+        else:
+            return outputs
+

research/gnn-survey-paper/__pycache__/models.cpython-37.pyc

@@ -3,37 +3,42 @@
 
 class GCN(tf.keras.Model):
 
-    def __init__(self, features_dim, num_layers, hidden_dim, num_classes, dropout_rate):
+    def __init__(self, features_dim, num_layers, hidden_dim, num_classes, dropout_rate, bias=True):
         super(GCN, self).__init__()
-        
+
         self.num_layers = num_layers
+        self.bias = bias
 
         self.gc = []
-        # input layer 
+        # input layer
         single_gc = tf.keras.Sequential()
-        single_gc.add(GraphConvLayer(features_dim, hidden_dim[0]))
+        single_gc.add(GraphConvLayer({"input_dim": features_dim,
+                                      "output_dim": hidden_dim[0],
+                                      "bias": bias}))
         single_gc.add(tf.keras.layers.ReLU())
         single_gc.add(tf.keras.layers.Dropout(dropout_rate))
         self.gc.append(single_gc)
-        
+
         # hidden layers
         for i in range(0, num_layers-2):
             single_gc = tf.keras.Sequential()
-            single_gc.add(GraphConvLayer(hidden_dim[i], hidden_dim[i+1]))
+            single_gc.add(GraphConvLayer({"input_dim": hidden_dim[i],
+                                          "output_dim": hidden_dim[i+1],
+                                          "bias": bias}))
             single_gc.add(tf.keras.layers.ReLU())
             single_gc.add(tf.keras.layers.Dropout(dropout_rate))
             self.gc.append(single_gc)
-        
+
         # output layer
-        self.classifier = GraphConvLayer(hidden_dim[-1], num_classes)
-        
-    def call(self, features, adj):
+        self.classifier = GraphConvLayer({"input_dim": hidden_dim[-1],
+                                          "output_dim": num_classes,
+                                          "bias": bias})
 
+    def call(self, features, adj):
         for i in range(self.num_layers-1):
-            x = (features, adj) 
+            x = (features, adj)
             features = self.gc[i](x)
-        
+
         x = (features, adj)
         outputs = self.classifier(x)
         return outputs
-

research/gnn-survey-paper/__pycache__/utils.cpython-37.pyc

@@ -8,7 +8,7 @@
 
 from utils import load_dataset, build_model, cal_acc
 
-flags.DEFINE_string('dataset', 'cora', 
+flags.DEFINE_string('dataset', 'cora',
                     'The input dataset. Avaliable dataset now: cora')
 flags.DEFINE_string('model', 'gcn',
                     'GNN model. Available model now: gcn')
@@ -34,37 +34,37 @@ def train(model, adj, features, y_train, y_val):
         optimizer = tf.keras.optimizers.Adam(learning_rate=FLAGS.lr)
     elif FLAGS.optimizer == 'sgd':
         optimizer = tf.keras.optimizers.SGD(learning_rate=FLAGS.lr)
-    
-    
+
+
     for epoch in range(FLAGS.epochs):
         epoch_start_time = time.time()
-        
+
         with tf.GradientTape() as tape:
             output = model(features, adj)
             train_loss = loss_fn(y_train, output[:train_last_id])
         gradients = tape.gradient(train_loss, model.trainable_variables)
         optimizer.apply_gradients(zip(gradients, model.trainable_variables))
-        
+
         train_acc = cal_acc(y_train, output[:train_last_id])
-        
+
         # Evaluate
         output = model(features, adj, training=False)
         val_loss = loss_fn(y_val, output[train_last_id:val_last_id])
         val_acc = cal_acc(y_val, output[train_last_id:val_last_id])
-        
+
         print('[%03d/%03d] %.2f sec(s) Train Acc: %.3f Loss: %.6f | Val Acc: %.3f loss: %.6f' % \
              (epoch + 1, FLAGS.epochs, time.time()-epoch_start_time, \
               train_acc, train_loss, val_acc, val_loss))
 
 
 
 def main(_):
-    
+
     if FLAGS.gpu == -1:
         device = "/cpu:0"
     else:
         device = "/gpu:{}".format(FLAGS.gpu)
-    
+
     with tf.device(device):
         tf.random.set_seed(1234)
         # Load the dataset and process features and adj matrix
@@ -73,12 +73,12 @@ def main(_):
         features_dim = features.shape[1]
         num_classes = max(y_test) + 1
         print('Build model...')
-        model = build_model(FLAGS.model, features_dim, FLAGS.num_layers, 
+        model = build_model(FLAGS.model, features_dim, FLAGS.num_layers,
                             FLAGS.hidden_dim, num_classes, FLAGS.dropout)
-    
+
         print('Start Training...')
         train(model, adj, features, y_train, y_val)
-    
+
 
 if __name__ == '__main__':
     app.run(main)

research/gnn-survey-paper/layers.py

@@ -23,8 +23,8 @@ def build_model(model_name, features_dim, num_layers, hidden_dim, num_classes, d
 def cal_acc(labels, logits):
     indices = tf.math.argmax(logits, axis=1)
     acc = tf.math.reduce_mean(tf.cast(indices == labels, dtype=tf.float32))
-    return acc.numpy().item() 
- 
+    return acc.numpy().item()
+
 def encode_onehot(labels):
     # Provides a mapping from string labels to integer indices.
     label_index = {
@@ -36,7 +36,7 @@ def encode_onehot(labels):
         'Rule_Learning': 5,
         'Theory': 6,
     }
-    
+
     # Convert to onehot label
     num_classes = len(label_index)
     onehot_labels = np.zeros((len(labels), num_classes))
@@ -54,7 +54,7 @@ def normalize_adj(adj):
     return adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).tocoo()
 
 def normalize_features(features):
-    """Row-normalize feature matrix.""" 
+    """Row-normalize feature matrix."""
     rowsum = np.array(features.sum(1))
     r_inv = np.power(rowsum, -1).flatten()
     r_mat_inv = sp.diags(r_inv)
@@ -66,38 +66,38 @@ def load_dataset(dataset):
     dir_path = os.path.join('data', dataset)
     content_path = os.path.join(dir_path, "{}.content".format(dataset))
     citation_path = os.path.join(dir_path, "{}.cites".format(dataset))
-    
+
     content = np.genfromtxt(content_path, dtype=np.dtype(str))
 
     idx = np.array(content[:, 0], dtype=np.int32)
     features = sp.csr_matrix(content[:, 1:-1], dtype=np.float32)
     labels = encode_onehot(content[:, -1])
-    
-    # Dict which maps paper id to data id  
+
+    # Dict which maps paper id to data id
     idx_map = {j: i for i, j in enumerate(idx)}
     edges_unordered = np.genfromtxt(citation_path, dtype=np.int32)
     edges = np.array(list(map(idx_map.get, edges_unordered.flatten())),
                      dtype=np.int32).reshape(edges_unordered.shape)
     adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
                         shape=(labels.shape[0], labels.shape[0]),
                         dtype=np.float32)
-     
+
     # build symmetric adjacency matrix
     adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
     # Add self-connection edge
     adj = adj + sp.eye(adj.shape[0])
-    
+
     features = normalize_features(features)
     adj = normalize_adj(adj)
-    
+
     # 5% for train, 500 for validation, other for test
     train_num = int(labels.shape[0] * 0.05)
     val_num = train_num + 500
-    
+
     features = tf.convert_to_tensor(np.array(features.todense()))
     labels = tf.convert_to_tensor(np.where(labels)[1])
     adj = tf.convert_to_tensor(np.array(adj.todense()))
-    
+
     y_train = labels[:train_num]
     y_val = labels[train_num:val_num]
     y_test = labels[val_num:]