PR [#86] dev_hc -> dev

Dev hc

autogl/module/model/dgl/topkpool.py

@@ -131,9 +131,10 @@ class Topkpool(torch.nn.Module):
         self.num_graph_features = self.args["num_graph_features"]
         self.num_layers = self.args["num_layers"]
         assert self.num_layers > 2, "Number of layers in GIN should not less than 3"
+        assert self.num_layers == len(self.args["hidden"]) + 1, "Warning: layer size does not match the length of hidden units"
 
         input_dim = self.args["features_num"]
-        hidden_dim = self.args["hidden"][0]
+        hidden = self.args["hidden"]
         final_dropout = self.args["dropout"]
         output_dim = self.args["num_class"]
 
@@ -143,12 +144,12 @@ class Topkpool(torch.nn.Module):
 
         for layer in range(self.num_layers - 1):
             if layer == 0:
-                self.gcnlayers.append(GraphConv(input_dim, hidden_dim))
+                self.gcnlayers.append(GraphConv(input_dim, hidden[layer]))
             else:
-                self.gcnlayers.append(GraphConv(hidden_dim, hidden_dim))
+                self.gcnlayers.append(GraphConv(hidden[layer-1], hidden[layer]))
 
             #self.gcnlayers.append(GraphConv(input_dim, hidden_dim))
-            self.batch_norms.append(nn.BatchNorm1d(hidden_dim))
+            self.batch_norms.append(nn.BatchNorm1d(hidden[layer]))
 
         # Linear function for graph poolings of output of each layer
         # which maps the output of different layers into a prediction score
@@ -164,7 +165,7 @@ class Topkpool(torch.nn.Module):
                     nn.Linear(input_dim * k, output_dim))
             else:
                 self.linears_prediction.append(
-                    nn.Linear(hidden_dim * k, output_dim))
+                    nn.Linear(hidden[layer-1] * k, output_dim))
 
         self.drop = nn.Dropout(final_dropout)
 

test/performance/graph_classification/dgl/model.py

@@ -167,7 +167,7 @@ def main(args):
                 device=device,
             ).from_hyper_parameter({
                 "num_layers": 5,
-                "hidden": [64],
+                "hidden": [64,64,64,64],
                 "dropout": 0.5
             }).model
 

test/performance/graph_classification/pyg/base.py

@@ -10,7 +10,7 @@ import torch.nn.functional as F
 from torch.nn import Sequential, Linear, ReLU
 import torch_geometric
 from torch_geometric.datasets import TUDataset
-if int(torch_geometric.__version__.split(",")[0]) >= 2:
+if int(torch_geometric.__version__.split(".")[0]) >= 2:
     from torch_geometric.loader import DataLoader
 else:
     from torch_geometric.data import DataLoader
@@ -18,6 +18,9 @@ from torch_geometric.nn import GINConv, global_add_pool, GraphConv, TopKPooling
 from torch_geometric.nn import global_mean_pool as gap, global_max_pool as gmp
 import logging
 
+torch.backends.cudnn.deterministic = True
+#torch.use_deterministic_algorithms(True)
+
 logging.basicConfig(level=logging.ERROR)
 
 class GIN(torch.nn.Module):
@@ -163,6 +166,10 @@ if __name__ == '__main__':
     dataids = list(range(len(dataset)))
     random.seed(args.dataset_seed)
     random.shuffle(dataids)
+    torch.manual_seed(args.dataset_seed)
+    np.random.seed(args.dataset_seed)
+    if args.device == 'cuda':
+        torch.cuda.manual_seed(args.dataset_seed)
     
     fold = int(len(dataset) * 0.1)
     train_index = dataids[:fold * 8]
@@ -177,16 +184,30 @@ if __name__ == '__main__':
 
     labels = np.array([data.y.item() for data in dataset.test_split])
 
-    train_loader = DataLoader(dataset.train_split, batch_size=args.batch_size)
-    val_loader = DataLoader(dataset.val_split, batch_size=args.batch_size)
-    test_loader = DataLoader(dataset.test_split, batch_size=args.batch_size)
-    
+    def seed_worker(worker_id):
+        #seed =  torch.initial_seed()
+        torch.manual_seed(args.dataset_seed)
+        np.random.seed(args.dataset_seed)
+        random.seed(args.dataset_seed)
+    g = torch.Generator()
+    g.manual_seed(args.dataset_seed)
+
+    train_loader = DataLoader(dataset.train_split, batch_size=args.batch_size, worker_init_fn=seed_worker, generator=g)
+    val_loader = DataLoader(dataset.val_split, batch_size=args.batch_size, worker_init_fn=seed_worker, generator=g)
+    test_loader = DataLoader(dataset.test_split, batch_size=args.batch_size, worker_init_fn=seed_worker, generator=g)
+
+    #train_loader = DataLoader(dataset.train_split, batch_size=args.batch_size, shuffle=False)
+    #val_loader = DataLoader(dataset.val_split, batch_size=args.batch_size, shuffle=False)
+    #test_loader = DataLoader(dataset.test_split, batch_size=args.batch_size, shuffle=False)
+
     accs = []
 
     for seed in tqdm(range(args.repeat)):
         torch.manual_seed(seed)
         np.random.seed(seed)
-        random.seed(seed)
+        #random.seed(seed)
+        if args.device == 'cuda':
+            torch.cuda.manual_seed(seed)
 
         if args.model == 'gin':
             model = GIN()