[Misc] Rename number_of_edges and number_of_nodes to num_edges and num_nodes in examples. (#5492)

* pytorch_example

* fix

---------
Co-authored-by: Ubuntu <ubuntu@ip-172-31-28-63.ap-northeast-1.compute.internal>

examples/pytorch/hardgat/train.py

@@ -65,7 +65,7 @@ def main(args):
     test_mask = g.ndata["test_mask"]
     num_feats = features.shape[1]
     n_classes = data.num_labels
-    n_edges = g.number_of_edges()
+    n_edges = g.num_edges()
     print(
         """----Data statistics------'
       #Edges %d
@@ -85,7 +85,7 @@ def main(args):
     # add self loop
     g = dgl.remove_self_loop(g)
     g = dgl.add_self_loop(g)
-    n_edges = g.number_of_edges()
+    n_edges = g.num_edges()
     # create model
     heads = ([args.num_heads] * args.num_layers) + [args.num_out_heads]
     model = HardGAT(

examples/pytorch/hgp_sl/layers.py

@@ -199,7 +199,7 @@ class HGPSLPool(nn.Module):
         # top-k pool first
         if e_feat is None:
             e_feat = torch.ones(
-                (graph.number_of_edges(),), dtype=feat.dtype, device=feat.device
+                (graph.num_edges(),), dtype=feat.dtype, device=feat.device
             )
         batch_num_nodes = graph.batch_num_nodes()
         x_score = self.calc_info_score(graph, feat, e_feat)

examples/pytorch/hgt/train_acm.py

@@ -120,14 +120,13 @@ for ntype in G.ntypes:
 for etype in G.etypes:
     edge_dict[etype] = len(edge_dict)
     G.edges[etype].data["id"] = (
-        torch.ones(G.number_of_edges(etype), dtype=torch.long)
-        * edge_dict[etype]
+        torch.ones(G.num_edges(etype), dtype=torch.long) * edge_dict[etype]
     )
 
 #     Random initialize input feature
 for ntype in G.ntypes:
     emb = nn.Parameter(
-        torch.Tensor(G.number_of_nodes(ntype), 256), requires_grad=False
+        torch.Tensor(G.num_nodes(ntype), 256), requires_grad=False
     )
     nn.init.xavier_uniform_(emb)
     G.nodes[ntype].data["inp"] = emb

examples/pytorch/hilander/PSS/test_subg_inat.py

@@ -132,14 +132,14 @@ dataset = LanderDataset(
     features=features, labels=labels, k=args.knn_k, levels=1, faiss_gpu=False
 )
 g = dataset.gs[0]
-g.ndata["pred_den"] = torch.zeros((g.number_of_nodes()))
-g.edata["prob_conn"] = torch.zeros((g.number_of_edges(), 2))
+g.ndata["pred_den"] = torch.zeros((g.num_nodes()))
+g.edata["prob_conn"] = torch.zeros((g.num_edges(), 2))
 global_labels = labels.copy()
-ids = np.arange(g.number_of_nodes())
+ids = np.arange(g.num_nodes())
 global_edges = ([], [])
 global_peaks = np.array([], dtype=np.long)
 global_edges_len = len(global_edges[0])
-global_num_nodes = g.number_of_nodes()
+global_num_nodes = g.num_nodes()
 
 global_densities = g.ndata["density"][:linsize]
 global_densities = np.sort(global_densities)
@@ -150,7 +150,7 @@ sampler = dgl.dataloading.MultiLayerNeighborSampler(fanouts)
 # fix the number of edges
 test_loader = dgl.dataloading.DataLoader(
     g,
-    torch.arange(g.number_of_nodes()),
+    torch.arange(g.num_nodes()),
     sampler,
     batch_size=args.batch_size,
     shuffle=False,
@@ -222,7 +222,7 @@ for level in range(args.levels):
     if level == 0:
         global_pred_densities = g.ndata["pred_den"]
         global_densities = g.ndata["density"]
-        g.edata["prob_conn"] = torch.zeros((g.number_of_edges(), 2))
+        g.edata["prob_conn"] = torch.zeros((g.num_edges(), 2))
 
     ids = ids[peaks]
     new_global_edges_len = len(global_edges[0])
@@ -258,11 +258,11 @@ for level in range(args.levels):
         cluster_features=cluster_features,
     )
     g = dataset.gs[0]
-    g.ndata["pred_den"] = torch.zeros((g.number_of_nodes()))
-    g.edata["prob_conn"] = torch.zeros((g.number_of_edges(), 2))
+    g.ndata["pred_den"] = torch.zeros((g.num_nodes()))
+    g.edata["prob_conn"] = torch.zeros((g.num_edges(), 2))
     test_loader = dgl.dataloading.DataLoader(
         g,
-        torch.arange(g.number_of_nodes()),
+        torch.arange(g.num_nodes()),
         sampler,
         batch_size=args.batch_size,
         shuffle=False,

examples/pytorch/hilander/PSS/train_subg_inat.py

@@ -119,7 +119,7 @@ def set_train_sampler_loader(g, k):
     # fix the number of edges
     train_dataloader = dgl.dataloading.DataLoader(
         g,
-        torch.arange(g.number_of_nodes()),
+        torch.arange(g.num_nodes()),
         sampler,
         batch_size=args.batch_size,
         shuffle=True,

examples/pytorch/hilander/test.py

@@ -63,10 +63,10 @@ dataset = LanderDataset(
 )
 g = dataset.gs[0].to(device)
 global_labels = labels.copy()
-ids = np.arange(g.number_of_nodes())
+ids = np.arange(g.num_nodes())
 global_edges = ([], [])
 global_edges_len = len(global_edges[0])
-global_num_nodes = g.number_of_nodes()
+global_num_nodes = g.num_nodes()
 
 ##################
 # Model Definition

examples/pytorch/hilander/test_subg.py

@@ -67,21 +67,21 @@ dataset = LanderDataset(
     faiss_gpu=args.faiss_gpu,
 )
 g = dataset.gs[0]
-g.ndata["pred_den"] = torch.zeros((g.number_of_nodes()))
-g.edata["prob_conn"] = torch.zeros((g.number_of_edges(), 2))
+g.ndata["pred_den"] = torch.zeros((g.num_nodes()))
+g.edata["prob_conn"] = torch.zeros((g.num_edges(), 2))
 global_labels = labels.copy()
-ids = np.arange(g.number_of_nodes())
+ids = np.arange(g.num_nodes())
 global_edges = ([], [])
 global_peaks = np.array([], dtype=np.long)
 global_edges_len = len(global_edges[0])
-global_num_nodes = g.number_of_nodes()
+global_num_nodes = g.num_nodes()
 
 fanouts = [args.knn_k - 1 for i in range(args.num_conv + 1)]
 sampler = dgl.dataloading.MultiLayerNeighborSampler(fanouts)
 # fix the number of edges
 test_loader = dgl.dataloading.DataLoader(
     g,
-    torch.arange(g.number_of_nodes()),
+    torch.arange(g.num_nodes()),
     sampler,
     batch_size=args.batch_size,
     shuffle=False,
@@ -183,11 +183,11 @@ for level in range(args.levels):
         cluster_features=cluster_features,
     )
     g = dataset.gs[0]
-    g.ndata["pred_den"] = torch.zeros((g.number_of_nodes()))
-    g.edata["prob_conn"] = torch.zeros((g.number_of_edges(), 2))
+    g.ndata["pred_den"] = torch.zeros((g.num_nodes()))
+    g.edata["prob_conn"] = torch.zeros((g.num_edges(), 2))
     test_loader = dgl.dataloading.DataLoader(
         g,
-        torch.arange(g.number_of_nodes()),
+        torch.arange(g.num_nodes()),
         sampler,
         batch_size=args.batch_size,
         shuffle=False,

examples/pytorch/hilander/train_subg.py

@@ -83,7 +83,7 @@ def set_train_sampler_loader(g, k):
     # fix the number of edges
     train_dataloader = dgl.dataloading.DataLoader(
         g,
-        torch.arange(g.number_of_nodes()),
+        torch.arange(g.num_nodes()),
         sampler,
         batch_size=args.batch_size,
         shuffle=True,

examples/pytorch/hilander/utils/deduce.py

@@ -97,7 +97,7 @@ def get_edge_dist(g, threshold):
 
 
 def tree_generation(ng):
-    ng.ndata["keep_eid"] = torch.zeros(ng.number_of_nodes()).long() - 1
+    ng.ndata["keep_eid"] = torch.zeros(ng.num_nodes()).long() - 1
 
     def message_func(edges):
         return {"mval": edges.data["edge_dist"], "meid": edges.data[dgl.EID]}
@@ -112,12 +112,12 @@ def tree_generation(ng):
     eids = ng.ndata["keep_eid"]
     eids = eids[eids > -1]
     edges = ng.find_edges(eids)
-    treeg = dgl.graph(edges, num_nodes=ng.number_of_nodes())
+    treeg = dgl.graph(edges, num_nodes=ng.num_nodes())
     return treeg
 
 
 def peak_propogation(treeg):
-    treeg.ndata["pred_labels"] = torch.zeros(treeg.number_of_nodes()).long() - 1
+    treeg.ndata["pred_labels"] = torch.zeros(treeg.num_nodes()).long() - 1
     peaks = torch.where(treeg.in_degrees() == 0)[0].cpu().numpy()
     treeg.ndata["pred_labels"][peaks] = torch.arange(peaks.shape[0])
 
@@ -157,7 +157,7 @@ def decode(
     ng = dgl.remove_edges(g, eids)
 
     # Tree generation
-    ng.edata[dgl.EID] = torch.arange(ng.number_of_edges())
+    ng.edata[dgl.EID] = torch.arange(ng.num_edges())
     treeg = tree_generation(ng)
     # Label propogation
     peaks, pred_labels = peak_propogation(treeg)

examples/pytorch/jtnn/jtnn/datautils.py

@@ -197,8 +197,8 @@ class JTNNCollator(object):
             tree_mess_tgt_e[i] += n_graph_nodes
             tree_mess_src_e[i] += n_tree_nodes
             tree_mess_tgt_n[i] += n_graph_nodes
-            n_graph_nodes += sum(g.number_of_nodes() for g in cand_graphs[i])
-            n_tree_nodes += mol_trees[i].graph.number_of_nodes()
+            n_graph_nodes += sum(g.num_nodes() for g in cand_graphs[i])
+            n_tree_nodes += mol_trees[i].graph.num_nodes()
             cand_batch_idx.extend([i] * len(cand_graphs[i]))
         tree_mess_tgt_e = torch.cat(tree_mess_tgt_e)
         tree_mess_src_e = torch.cat(tree_mess_src_e)

examples/pytorch/jtnn/jtnn/jtmpn.py

@@ -225,8 +225,8 @@ class DGLJTMPN(nn.Module):
             cand_graphs, backtracking=False, shared=True
         )
 
-        n_nodes = cand_graphs.number_of_nodes()
-        n_edges = cand_graphs.number_of_edges()
+        n_nodes = cand_graphs.num_nodes()
+        n_edges = cand_graphs.num_edges()
 
         cand_graphs = self.run(
             cand_graphs,
@@ -255,7 +255,7 @@ class DGLJTMPN(nn.Module):
         tree_mess_tgt_nodes,
         mol_tree_batch,
     ):
-        n_nodes = cand_graphs.number_of_nodes()
+        n_nodes = cand_graphs.num_nodes()
 
         cand_graphs.apply_edges(
             func=lambda edges: {"src_x": edges.src["x"]},
@@ -282,7 +282,7 @@ class DGLJTMPN(nn.Module):
         )
 
         cand_graphs.edata["alpha"] = cuda(
-            torch.zeros(cand_graphs.number_of_edges(), self.hidden_size)
+            torch.zeros(cand_graphs.num_edges(), self.hidden_size)
         )
         cand_graphs.ndata["alpha"] = zero_node_state
         if tree_mess_src_edges.shape[0] > 0:

examples/pytorch/jtnn/jtnn/jtnn_dec.py

@@ -126,8 +126,8 @@ class DGLJTNNDecoder(nn.Module):
             np.insert(mol_tree_batch.batch_num_nodes().cpu().numpy(), 0, 0)
         )
         root_ids = node_offset[:-1]
-        n_nodes = mol_tree_batch.number_of_nodes()
-        n_edges = mol_tree_batch.number_of_edges()
+        n_nodes = mol_tree_batch.num_nodes()
+        n_edges = mol_tree_batch.num_edges()
 
         mol_tree_batch.ndata.update(
             {

examples/pytorch/jtnn/jtnn/jtnn_enc.py

@@ -68,8 +68,8 @@ class DGLJTNNEncoder(nn.Module):
             np.insert(mol_tree_batch.batch_num_nodes().cpu().numpy(), 0, 0)
         )
         root_ids = node_offset[:-1]
-        n_nodes = mol_tree_batch.number_of_nodes()
-        n_edges = mol_tree_batch.number_of_edges()
+        n_nodes = mol_tree_batch.num_nodes()
+        n_edges = mol_tree_batch.num_edges()
 
         # Assign structure embeddings to tree nodes
         mol_tree_batch.ndata.update(

examples/pytorch/jtnn/jtnn/jtnn_vae.py

@@ -70,10 +70,10 @@ class DGLJTNNVAE(nn.Module):
             [t.graph for t in mol_batch["mol_trees"]]
         )
 
-        self.n_nodes_total += mol_graphs.number_of_nodes()
-        self.n_edges_total += mol_graphs.number_of_edges()
+        self.n_nodes_total += mol_graphs.num_nodes()
+        self.n_edges_total += mol_graphs.num_edges()
         self.n_tree_nodes_total += sum(
-            t.graph.number_of_nodes() for t in mol_batch["mol_trees"]
+            t.graph.num_nodes() for t in mol_batch["mol_trees"]
         )
         self.n_passes += 1
 

examples/pytorch/jtnn/jtnn/mol_tree_nx.py

@@ -72,7 +72,7 @@ class DGLMolTree(object):
             self.nodes_dict[i]["is_leaf"] = self.graph.out_degrees(i) == 1
 
     def treesize(self):
-        return self.graph.number_of_nodes()
+        return self.graph.num_nodes()
 
     def _recover_node(self, i, original_mol):
         node = self.nodes_dict[i]

examples/pytorch/jtnn/jtnn/mpn.py

@@ -154,8 +154,8 @@ class DGLMPN(nn.Module):
 
         mol_line_graph = line_graph(mol_graph, backtracking=False, shared=True)
 
-        n_nodes = mol_graph.number_of_nodes()
-        n_edges = mol_graph.number_of_edges()
+        n_nodes = mol_graph.num_nodes()
+        n_edges = mol_graph.num_edges()
 
         mol_graph = self.run(mol_graph, mol_line_graph)
 
@@ -170,7 +170,7 @@ class DGLMPN(nn.Module):
         return g_repr
 
     def run(self, mol_graph, mol_line_graph):
-        n_nodes = mol_graph.number_of_nodes()
+        n_nodes = mol_graph.num_nodes()
 
         mol_graph.apply_edges(
             func=lambda edges: {"src_x": edges.src["x"]},

examples/pytorch/jtnn/jtnn/nnutils.py

@@ -50,4 +50,4 @@ def tocpu(g):
     src, dst = g.edges()
     src = src.cpu()
     dst = dst.cpu()
-    return dgl.graph((src, dst), num_nodes=g.number_of_nodes())
+    return dgl.graph((src, dst), num_nodes=g.num_nodes())

examples/pytorch/metapath2vec/sampler.py

@@ -94,7 +94,7 @@ def generate_metapath():
 
     hg, author_names, conf_names, paper_names = construct_graph()
 
-    for conf_idx in tqdm.trange(hg.number_of_nodes("conf")):
+    for conf_idx in tqdm.trange(hg.num_nodes("conf")):
         traces, _ = dgl.sampling.random_walk(
             hg,
             [conf_idx] * num_walks_per_node,

examples/pytorch/model_zoo/citation_network/run.py

@@ -62,7 +62,7 @@ def main(args):
     test_mask = g.ndata["test_mask"]
     in_feats = features.shape[1]
     n_classes = data.num_labels
-    n_edges = g.number_of_edges()
+    n_edges = g.num_edges()
     print(
         """----Data statistics------'
       #Edges %d
@@ -83,7 +83,7 @@ def main(args):
     # add self loop
     if args.self_loop:
         g = g.remove_self_loop().add_self_loop()
-    n_edges = g.number_of_edges()
+    n_edges = g.num_edges()
 
     # normalization
     degs = g.in_degrees().float()

examples/pytorch/model_zoo/geometric/coordinate.py

@@ -8,7 +8,7 @@ def get_coordinates(graphs, grid_side, coarsening_levels, perm):
     rst = []
     for l in range(coarsening_levels + 1):
         xs, ys = [], []
-        for i in range(graphs[l].number_of_nodes()):
+        for i in range(graphs[l].num_nodes()):
             cnt = eps
             x_accum = 0
             y_accum = 0