From 5b409bf7f5ea9c034c8cfb103fb4bf56166d182c Mon Sep 17 00:00:00 2001 From: "Hongzhi (Steve), Chen" Date: Fri, 24 Mar 2023 18:44:24 +0800 Subject: [PATCH] Rename_test (#5487) Co-authored-by: Ubuntu --- tests/cugraph/test_basics.py | 10 +- tests/dist/python/run_dist_objects.py | 32 +- tests/dist/test_dist_objects.py | 12 +- tests/distributed/test_dist_graph_store.py | 136 ++++--- tests/distributed/test_dist_tensor.py | 8 +- .../distributed/test_distributed_sampling.py | 28 +- tests/distributed/test_mp_dataloader.py | 8 +- tests/distributed/test_partition.py | 30 +- tests/python/common/data/test_serialize.py | 6 +- tests/python/common/function/test_basics.py | 78 ++-- tests/python/common/ops/test_edge_softmax.py | 2 +- tests/python/common/ops/test_ops.py | 14 +- tests/python/common/sampling/test_sampling.py | 116 +++--- tests/python/common/test_batch-graph.py | 16 +- tests/python/common/test_batch-heterograph.py | 62 ++- tests/python/common/test_generators.py | 4 +- .../python/common/test_heterograph-kernel.py | 6 +- tests/python/common/test_heterograph-misc.py | 8 +- .../python/common/test_heterograph-pickle.py | 4 +- .../python/common/test_heterograph-remove.py | 84 ++--- .../common/test_heterograph-shared-memory.py | 2 +- .../common/test_heterograph-specialization.py | 2 +- tests/python/common/test_heterograph.py | 354 +++++++++--------- tests/python/common/test_readout.py | 24 +- tests/python/common/test_subgraph.py | 28 +- tests/python/common/test_traversal.py | 2 +- .../common/transforms/test_functional-sort.py | 6 +- .../python/common/transforms/test_to_block.py | 10 +- .../common/transforms/test_transform.py | 306 +++++++-------- tests/python/mxnet/test_nn.py | 38 +- .../distributed/optim/test_dist_optim.py | 2 +- tests/python/pytorch/nn/test_nn.py | 92 ++--- tests/python/tensorflow/test_nn.py | 20 +- tests/tools/test_parmetis.py | 18 +- tests/utils/checks.py | 12 +- tests/utils/graph_cases.py | 20 +- 36 files changed, 784 insertions(+), 816 deletions(-) diff --git a/tests/cugraph/test_basics.py b/tests/cugraph/test_basics.py index 6c94823aec..7e5b6e4ade 100644 --- a/tests/cugraph/test_basics.py +++ b/tests/cugraph/test_basics.py @@ -15,8 +15,8 @@ def test_to_cugraph_conversion(): g = dgl.graph((F.tensor([0, 1, 2, 3]), F.tensor([1, 0, 3, 2]))).to("cuda") cugraph_g = g.to_cugraph() - assert cugraph_g.number_of_nodes() == g.number_of_nodes() - assert cugraph_g.number_of_edges() == g.number_of_edges() + assert cugraph_g.number_of_nodes() == g.num_nodes() + assert cugraph_g.number_of_edges() == g.num_edges() assert cugraph_g.has_edge(0, 1) assert cugraph_g.has_edge(1, 0) @@ -36,8 +36,8 @@ def test_from_cugraph_conversion(): g = dgl.from_cugraph(cugraph_g) assert g.device.type == "cuda" - assert g.number_of_nodes() == cugraph_g.number_of_nodes() - assert g.number_of_edges() == cugraph_g.number_of_edges() + assert g.num_nodes() == cugraph_g.number_of_nodes() + assert g.num_edges() == cugraph_g.number_of_edges() # assert reverse edges are not present assert g.has_edges_between(0, 1) @@ -55,7 +55,7 @@ def test_from_cugraph_conversion(): g = dgl.from_cugraph(cugraph_g) assert g.device.type == "cuda" - assert g.number_of_nodes() == cugraph_g.number_of_nodes() + assert g.num_nodes() == cugraph_g.number_of_nodes() # assert reverse edges are present assert g.has_edges_between(0, 1) assert g.has_edges_between(1, 0) diff --git a/tests/dist/python/run_dist_objects.py b/tests/dist/python/run_dist_objects.py index df9f6cd4b6..9dc41e28e2 100644 --- a/tests/dist/python/run_dist_objects.py +++ b/tests/dist/python/run_dist_objects.py @@ -72,7 +72,7 @@ def node_split_test(g, force_even, ntype="_N"): gpb = g.get_partition_book() selected_nodes_dist_tensor = dgl.distributed.DistTensor( - [g.number_of_nodes(ntype)], F.uint8, init_func=rand_init + [g.num_nodes(ntype)], F.uint8, init_func=rand_init ) nodes = node_split( @@ -86,9 +86,7 @@ def node_split_test(g, force_even, ntype="_N"): g.barrier() if g.rank() == 0: - batched_assert_zero( - selected_nodes_dist_tensor, g.number_of_nodes(ntype) - ) + batched_assert_zero(selected_nodes_dist_tensor, g.num_nodes(ntype)) g.barrier() @@ -97,7 +95,7 @@ def edge_split_test(g, force_even, etype="_E"): gpb = g.get_partition_book() selected_edges_dist_tensor = dgl.distributed.DistTensor( - [g.number_of_edges(etype)], F.uint8, init_func=rand_init + [g.num_edges(etype)], F.uint8, init_func=rand_init ) edges = edge_split( @@ -111,9 +109,7 @@ def edge_split_test(g, force_even, etype="_E"): g.barrier() if g.rank() == 0: - batched_assert_zero( - selected_edges_dist_tensor, g.number_of_edges(etype) - ) + batched_assert_zero(selected_edges_dist_tensor, g.num_edges(etype)) g.barrier() @@ -127,19 +123,19 @@ def test_dist_graph(g): num_nodes = part_metadata["num_nodes"] num_edges = part_metadata["num_edges"] - assert g.number_of_nodes() == num_nodes - assert g.number_of_edges() == num_edges + assert g.num_nodes() == num_nodes + assert g.num_edges() == num_edges num_nodes = {ntype: g.num_nodes(ntype) for ntype in g.ntypes} num_edges = {etype: g.num_edges(etype) for etype in g.etypes} for key, n_nodes in num_nodes.items(): - assert g.number_of_nodes(key) == n_nodes + assert g.num_nodes(key) == n_nodes node_split_test(g, force_even=False, ntype=key) node_split_test(g, force_even=True, ntype=key) for key, n_edges in num_edges.items(): - assert g.number_of_edges(key) == n_edges + assert g.num_edges(key) == n_edges edge_split_test(g, force_even=False, etype=key) edge_split_test(g, force_even=True, etype=key) @@ -156,7 +152,7 @@ def find_edges_test(g, orig_nid_map): for u_type, etype, v_type in etypes: orig_u = g.edges[etype].data["edge_u"] orig_v = g.edges[etype].data["edge_v"] - eids = F.tensor(np.random.randint(g.number_of_edges(etype), size=100)) + eids = F.tensor(np.random.randint(g.num_edges(etype), size=100)) u, v = g.find_edges(eids, etype=etype) assert F.allclose(orig_nid_map[u_type][u], orig_u[eids]) assert F.allclose(orig_nid_map[v_type][v], orig_v[eids]) @@ -172,7 +168,7 @@ def edge_subgraph_test(g, etype_eids_uv_map): sg = g.edge_subgraph(all_eids) for t in etypes: - assert sg.number_of_edges(t[1]) == len(all_eids[t]) + assert sg.num_edges(t[1]) == len(all_eids[t]) assert F.allclose(sg.edges[t].data[dgl.EID], all_eids[t]) for u_type, etype, v_type in etypes: @@ -197,7 +193,7 @@ def sample_neighbors_with_args(g, size, fanout): ) for ntype, n in num_nodes.items(): - assert sampled_graph.number_of_nodes(ntype) == n + assert sampled_graph.num_nodes(ntype) == n for t in etypes: src, dst = sampled_graph.edges(etype=t) eids = sampled_graph.edges[t].data[dgl.EID] @@ -305,7 +301,7 @@ def dist_tensor_test_persistent(data_shape): def test_dist_tensor(g): first_type = g.ntypes[0] - data_shape = (g.number_of_nodes(first_type), 2) + data_shape = (g.num_nodes(first_type), 2) dist_tensor_test_sanity(data_shape) dist_tensor_test_sanity(data_shape, name="DistTensorSanity") dist_tensor_test_destroy_recreate(data_shape, name="DistTensorRecreate") @@ -365,7 +361,7 @@ def dist_embedding_check_existing(num_nodes): def test_dist_embedding(g): - num_nodes = g.number_of_nodes(g.ntypes[0]) + num_nodes = g.num_nodes(g.ntypes[0]) dist_embedding_check_sanity(num_nodes, dgl.distributed.optim.SparseAdagrad) dist_embedding_check_sanity( num_nodes, dgl.distributed.optim.SparseAdagrad, name="SomeEmbedding" @@ -383,7 +379,7 @@ def test_dist_embedding(g): def dist_optimizer_check_store(g): - num_nodes = g.number_of_nodes(g.ntypes[0]) + num_nodes = g.num_nodes(g.ntypes[0]) rank = g.rank() try: emb = dgl.distributed.DistEmbedding( diff --git a/tests/dist/test_dist_objects.py b/tests/dist/test_dist_objects.py index 48050205e5..3de85199df 100644 --- a/tests/dist/test_dist_objects.py +++ b/tests/dist/test_dist_objects.py @@ -23,14 +23,14 @@ shared_workspace = os.environ.get( def create_graph(num_part, dist_graph_path, hetero): if not hetero: g = dgl.rand_graph(10000, 42000) - g.ndata["feat"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["feat"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["feat"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["feat"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) g.ndata["in_degrees"] = g.in_degrees() g.ndata["out_degrees"] = g.out_degrees() etype = g.etypes[0] ntype = g.ntypes[0] - edge_u, edge_v = g.find_edges(F.arange(0, g.number_of_edges(etype))) + edge_u, edge_v = g.find_edges(F.arange(0, g.num_edges(etype))) g.edges[etype].data["edge_u"] = edge_u g.edges[etype].data["edge_v"] = edge_v @@ -66,15 +66,15 @@ def create_graph(num_part, dist_graph_path, hetero): g = dgl.heterograph(edges, num_nodes) g.nodes["n1"].data["feat"] = F.unsqueeze( - F.arange(0, g.number_of_nodes("n1")), 1 + F.arange(0, g.num_nodes("n1")), 1 ) g.edges["r1"].data["feat"] = F.unsqueeze( - F.arange(0, g.number_of_edges("r1")), 1 + F.arange(0, g.num_edges("r1")), 1 ) for _, etype, _ in etypes: edge_u, edge_v = g.find_edges( - F.arange(0, g.number_of_edges(etype)), etype=etype + F.arange(0, g.num_edges(etype)), etype=etype ) g.edges[etype].data["edge_u"] = edge_u g.edges[etype].data["edge_v"] = edge_v diff --git a/tests/distributed/test_dist_graph_store.py b/tests/distributed/test_dist_graph_store.py index 942555d471..b56f247da2 100644 --- a/tests/distributed/test_dist_graph_store.py +++ b/tests/distributed/test_dist_graph_store.py @@ -81,13 +81,13 @@ def rand_init(shape, dtype): def check_dist_graph_empty(g, num_clients, num_nodes, num_edges): # Test API - assert g.number_of_nodes() == num_nodes - assert g.number_of_edges() == num_edges + assert g.num_nodes() == num_nodes + assert g.num_edges() == num_edges # Test init node data - new_shape = (g.number_of_nodes(), 2) + new_shape = (g.num_nodes(), 2) g.ndata["test1"] = dgl.distributed.DistTensor(new_shape, F.int32) - nids = F.arange(0, int(g.number_of_nodes() / 2)) + nids = F.arange(0, int(g.num_nodes() / 2)) feats = g.ndata["test1"][nids] assert np.all(F.asnumpy(feats) == 0) @@ -96,9 +96,7 @@ def check_dist_graph_empty(g, num_clients, num_nodes, num_edges): new_shape, F.float32, "test3", init_func=rand_init ) del test3 - test3 = dgl.distributed.DistTensor( - (g.number_of_nodes(), 3), F.float32, "test3" - ) + test3 = dgl.distributed.DistTensor((g.num_nodes(), 3), F.float32, "test3") del test3 # Test write data @@ -156,8 +154,8 @@ def check_server_client_empty(shared_mem, num_servers, num_clients): 0, num_servers, num_clients, - g.number_of_nodes(), - g.number_of_edges(), + g.num_nodes(), + g.num_edges(), ), ) p.start() @@ -301,8 +299,8 @@ def run_client_hierarchy( def check_dist_emb(g, num_clients, num_nodes, num_edges): # Test sparse emb try: - emb = DistEmbedding(g.number_of_nodes(), 1, "emb1", emb_init) - nids = F.arange(0, int(g.number_of_nodes())) + emb = DistEmbedding(g.num_nodes(), 1, "emb1", emb_init) + nids = F.arange(0, int(g.num_nodes())) lr = 0.001 optimizer = SparseAdagrad([emb], lr=lr) with F.record_grad(): @@ -314,13 +312,13 @@ def check_dist_emb(g, num_clients, num_nodes, num_edges): feats = emb(nids) if num_clients == 1: assert_almost_equal(F.asnumpy(feats), np.ones((len(nids), 1)) * -lr) - rest = np.setdiff1d(np.arange(g.number_of_nodes()), F.asnumpy(nids)) + rest = np.setdiff1d(np.arange(g.num_nodes()), F.asnumpy(nids)) feats1 = emb(rest) assert np.all(F.asnumpy(feats1) == np.zeros((len(rest), 1))) policy = dgl.distributed.PartitionPolicy("node", g.get_partition_book()) grad_sum = dgl.distributed.DistTensor( - (g.number_of_nodes(), 1), F.float32, "emb1_sum", policy + (g.num_nodes(), 1), F.float32, "emb1_sum", policy ) if num_clients == 1: assert np.all( @@ -329,7 +327,7 @@ def check_dist_emb(g, num_clients, num_nodes, num_edges): ) assert np.all(F.asnumpy(grad_sum[rest]) == np.zeros((len(rest), 1))) - emb = DistEmbedding(g.number_of_nodes(), 1, "emb2", emb_init) + emb = DistEmbedding(g.num_nodes(), 1, "emb2", emb_init) with F.no_grad(): feats1 = emb(nids) assert np.all(F.asnumpy(feats1) == 0) @@ -349,7 +347,7 @@ def check_dist_emb(g, num_clients, num_nodes, num_edges): assert_almost_equal( F.asnumpy(feats), np.ones((len(nids), 1)) * 1 * -lr ) - rest = np.setdiff1d(np.arange(g.number_of_nodes()), F.asnumpy(nids)) + rest = np.setdiff1d(np.arange(g.num_nodes()), F.asnumpy(nids)) feats1 = emb(rest) assert np.all(F.asnumpy(feats1) == np.zeros((len(rest), 1))) except NotImplementedError as e: @@ -361,17 +359,17 @@ def check_dist_emb(g, num_clients, num_nodes, num_edges): def check_dist_graph(g, num_clients, num_nodes, num_edges): # Test API - assert g.number_of_nodes() == num_nodes - assert g.number_of_edges() == num_edges + assert g.num_nodes() == num_nodes + assert g.num_edges() == num_edges # Test reading node data - nids = F.arange(0, int(g.number_of_nodes() / 2)) + nids = F.arange(0, int(g.num_nodes() / 2)) feats1 = g.ndata["features"][nids] feats = F.squeeze(feats1, 1) assert np.all(F.asnumpy(feats == nids)) # Test reading edge data - eids = F.arange(0, int(g.number_of_edges() / 2)) + eids = F.arange(0, int(g.num_edges() / 2)) feats1 = g.edata["features"][eids] feats = F.squeeze(feats1, 1) assert np.all(F.asnumpy(feats == eids)) @@ -382,7 +380,7 @@ def check_dist_graph(g, num_clients, num_nodes, num_edges): assert F.array_equal(sg.edata[dgl.EID], eids) # Test init node data - new_shape = (g.number_of_nodes(), 2) + new_shape = (g.num_nodes(), 2) test1 = dgl.distributed.DistTensor(new_shape, F.int32) g.ndata["test1"] = test1 feats = g.ndata["test1"][nids] @@ -406,9 +404,7 @@ def check_dist_graph(g, num_clients, num_nodes, num_edges): del test3 assert test3_name not in g._client.data_name_list() assert test3_name not in g._client.gdata_name_list() - test3 = dgl.distributed.DistTensor( - (g.number_of_nodes(), 3), F.float32, "test3" - ) + test3 = dgl.distributed.DistTensor((g.num_nodes(), 3), F.float32, "test3") del test3 # add tests for anonymous distributed tensor. @@ -432,7 +428,7 @@ def check_dist_graph(g, num_clients, num_nodes, num_edges): del test4 try: test4 = dgl.distributed.DistTensor( - (g.number_of_nodes(), 3), F.float32, "test4" + (g.num_nodes(), 3), F.float32, "test4" ) raise Exception("") except: @@ -445,19 +441,19 @@ def check_dist_graph(g, num_clients, num_nodes, num_edges): assert np.all(F.asnumpy(feats) == 1) # Test metadata operations. - assert len(g.ndata["features"]) == g.number_of_nodes() - assert g.ndata["features"].shape == (g.number_of_nodes(), 1) + assert len(g.ndata["features"]) == g.num_nodes() + assert g.ndata["features"].shape == (g.num_nodes(), 1) assert g.ndata["features"].dtype == F.int64 assert g.node_attr_schemes()["features"].dtype == F.int64 assert g.node_attr_schemes()["test1"].dtype == F.int32 assert g.node_attr_schemes()["features"].shape == (1,) - selected_nodes = np.random.randint(0, 100, size=g.number_of_nodes()) > 30 + selected_nodes = np.random.randint(0, 100, size=g.num_nodes()) > 30 # Test node split nodes = node_split(selected_nodes, g.get_partition_book()) nodes = F.asnumpy(nodes) # We only have one partition, so the local nodes are basically all nodes in the graph. - local_nids = np.arange(g.number_of_nodes()) + local_nids = np.arange(g.num_nodes()) for n in nodes: assert n in local_nids @@ -475,8 +471,8 @@ def check_dist_emb_server_client( graph_name = ( f"check_dist_emb_{shared_mem}_{num_servers}_{num_clients}_{num_groups}" ) - g.ndata["features"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["features"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["features"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["features"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) partition_graph(g, graph_name, num_parts, "/tmp/dist_graph") # let's just test on one partition for now. @@ -510,8 +506,8 @@ def check_dist_emb_server_client( 0, num_servers, num_clients, - g.number_of_nodes(), - g.number_of_edges(), + g.num_nodes(), + g.num_edges(), group_id, ), ) @@ -542,8 +538,8 @@ def check_server_client(shared_mem, num_servers, num_clients, num_groups=1): # Partition the graph num_parts = 1 graph_name = f"check_server_client_{shared_mem}_{num_servers}_{num_clients}_{num_groups}" - g.ndata["features"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["features"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["features"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["features"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) partition_graph(g, graph_name, num_parts, "/tmp/dist_graph") # let's just test on one partition for now. @@ -578,8 +574,8 @@ def check_server_client(shared_mem, num_servers, num_clients, num_groups=1): 0, num_servers, num_clients, - g.number_of_nodes(), - g.number_of_edges(), + g.num_nodes(), + g.num_edges(), group_id, ), ) @@ -609,8 +605,8 @@ def check_server_client_hierarchy(shared_mem, num_servers, num_clients): # Partition the graph num_parts = 1 graph_name = "dist_graph_test_2" - g.ndata["features"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["features"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["features"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["features"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) partition_graph( g, graph_name, @@ -634,14 +630,10 @@ def check_server_client_hierarchy(shared_mem, num_servers, num_clients): cli_ps = [] manager = mp.Manager() return_dict = manager.dict() - node_mask = np.zeros((g.number_of_nodes(),), np.int32) - edge_mask = np.zeros((g.number_of_edges(),), np.int32) - nodes = np.random.choice( - g.number_of_nodes(), g.number_of_nodes() // 10, replace=False - ) - edges = np.random.choice( - g.number_of_edges(), g.number_of_edges() // 10, replace=False - ) + node_mask = np.zeros((g.num_nodes(),), np.int32) + edge_mask = np.zeros((g.num_edges(),), np.int32) + nodes = np.random.choice(g.num_nodes(), g.num_nodes() // 10, replace=False) + edges = np.random.choice(g.num_edges(), g.num_edges() // 10, replace=False) node_mask[nodes] = 1 edge_mask[edges] = 1 nodes = np.sort(nodes) @@ -729,17 +721,17 @@ def check_dist_graph_hetero(g, num_clients, num_nodes, num_edges): # Test API for ntype in num_nodes: assert ntype in g.ntypes - assert num_nodes[ntype] == g.number_of_nodes(ntype) + assert num_nodes[ntype] == g.num_nodes(ntype) for etype in num_edges: assert etype in g.etypes - assert num_edges[etype] == g.number_of_edges(etype) + assert num_edges[etype] == g.num_edges(etype) etypes = [("n1", "r1", "n2"), ("n1", "r2", "n3"), ("n2", "r3", "n3")] for i, etype in enumerate(g.canonical_etypes): assert etype[0] == etypes[i][0] assert etype[1] == etypes[i][1] assert etype[2] == etypes[i][2] - assert g.number_of_nodes() == sum([num_nodes[ntype] for ntype in num_nodes]) - assert g.number_of_edges() == sum([num_edges[etype] for etype in num_edges]) + assert g.num_nodes() == sum([num_nodes[ntype] for ntype in num_nodes]) + assert g.num_edges() == sum([num_edges[etype] for etype in num_edges]) # Test reading node data ntype = "n1" @@ -786,7 +778,7 @@ def check_dist_graph_hetero(g, num_clients, num_nodes, num_edges): assert F.array_equal(sg.edata[dgl.EID], eids) # Test init node data - new_shape = (g.number_of_nodes("n1"), 2) + new_shape = (g.num_nodes("n1"), 2) g.nodes["n1"].data["test1"] = dgl.distributed.DistTensor(new_shape, F.int32) feats = g.nodes["n1"].data["test1"][nids] assert np.all(F.asnumpy(feats) == 0) @@ -797,7 +789,7 @@ def check_dist_graph_hetero(g, num_clients, num_nodes, num_edges): ) del test3 test3 = dgl.distributed.DistTensor( - (g.number_of_nodes("n1"), 3), F.float32, "test3" + (g.num_nodes("n1"), 3), F.float32, "test3" ) del test3 @@ -822,7 +814,7 @@ def check_dist_graph_hetero(g, num_clients, num_nodes, num_edges): del test4 try: test4 = dgl.distributed.DistTensor( - (g.number_of_nodes("n1"), 3), F.float32, "test4" + (g.num_nodes("n1"), 3), F.float32, "test4" ) raise Exception("") except: @@ -835,18 +827,16 @@ def check_dist_graph_hetero(g, num_clients, num_nodes, num_edges): assert np.all(F.asnumpy(feats) == 1) # Test metadata operations. - assert len(g.nodes["n1"].data["feat"]) == g.number_of_nodes("n1") - assert g.nodes["n1"].data["feat"].shape == (g.number_of_nodes("n1"), 1) + assert len(g.nodes["n1"].data["feat"]) == g.num_nodes("n1") + assert g.nodes["n1"].data["feat"].shape == (g.num_nodes("n1"), 1) assert g.nodes["n1"].data["feat"].dtype == F.int64 - selected_nodes = ( - np.random.randint(0, 100, size=g.number_of_nodes("n1")) > 30 - ) + selected_nodes = np.random.randint(0, 100, size=g.num_nodes("n1")) > 30 # Test node split nodes = node_split(selected_nodes, g.get_partition_book(), ntype="n1") nodes = F.asnumpy(nodes) # We only have one partition, so the local nodes are basically all nodes in the graph. - local_nids = np.arange(g.number_of_nodes("n1")) + local_nids = np.arange(g.num_nodes("n1")) for n in nodes: assert n in local_nids @@ -875,8 +865,8 @@ def check_server_client_hetero(shared_mem, num_servers, num_clients): p.start() cli_ps = [] - num_nodes = {ntype: g.number_of_nodes(ntype) for ntype in g.ntypes} - num_edges = {etype: g.number_of_edges(etype) for etype in g.etypes} + num_nodes = {ntype: g.num_nodes(ntype) for ntype in g.ntypes} + num_edges = {etype: g.num_edges(etype) for etype in g.etypes} for cli_id in range(num_clients): print("start client", cli_id) p = ctx.Process( @@ -981,8 +971,8 @@ def check_dist_optim_server_client( # Partition the graph num_parts = 1 - g.ndata["features"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["features"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["features"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["features"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) partition_graph(g, graph_name, num_parts, "/tmp/dist_graph") # let's just test on one partition for now. @@ -1048,15 +1038,15 @@ def test_standalone(): # Partition the graph num_parts = 1 graph_name = "dist_graph_test_3" - g.ndata["features"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["features"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["features"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["features"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) partition_graph(g, graph_name, num_parts, "/tmp/dist_graph") dgl.distributed.initialize("kv_ip_config.txt") dist_g = DistGraph( graph_name, part_config="/tmp/dist_graph/{}.json".format(graph_name) ) - check_dist_graph(dist_g, 1, g.number_of_nodes(), g.number_of_edges()) + check_dist_graph(dist_g, 1, g.num_nodes(), g.num_edges()) dgl.distributed.exit_client() # this is needed since there's two test here in one process @@ -1076,15 +1066,15 @@ def test_standalone_node_emb(): # Partition the graph num_parts = 1 graph_name = "dist_graph_test_3" - g.ndata["features"] = F.unsqueeze(F.arange(0, g.number_of_nodes()), 1) - g.edata["features"] = F.unsqueeze(F.arange(0, g.number_of_edges()), 1) + g.ndata["features"] = F.unsqueeze(F.arange(0, g.num_nodes()), 1) + g.edata["features"] = F.unsqueeze(F.arange(0, g.num_edges()), 1) partition_graph(g, graph_name, num_parts, "/tmp/dist_graph") dgl.distributed.initialize("kv_ip_config.txt") dist_g = DistGraph( graph_name, part_config="/tmp/dist_graph/{}.json".format(graph_name) ) - check_dist_emb(dist_g, 1, g.number_of_nodes(), g.number_of_edges()) + check_dist_emb(dist_g, 1, g.num_nodes(), g.num_edges()) dgl.distributed.exit_client() # this is needed since there's two test here in one process @@ -1110,8 +1100,8 @@ def test_split(hetero): part_method="metis", ) - node_mask = np.random.randint(0, 100, size=g.number_of_nodes(ntype)) > 30 - edge_mask = np.random.randint(0, 100, size=g.number_of_edges(etype)) > 30 + node_mask = np.random.randint(0, 100, size=g.num_nodes(ntype)) > 30 + edge_mask = np.random.randint(0, 100, size=g.num_edges(etype)) > 30 selected_nodes = np.nonzero(node_mask)[0] selected_edges = np.nonzero(edge_mask)[0] @@ -1196,8 +1186,8 @@ def test_split_even(): part_method="metis", ) - node_mask = np.random.randint(0, 100, size=g.number_of_nodes()) > 30 - edge_mask = np.random.randint(0, 100, size=g.number_of_edges()) > 30 + node_mask = np.random.randint(0, 100, size=g.num_nodes()) > 30 + edge_mask = np.random.randint(0, 100, size=g.num_edges()) > 30 selected_nodes = np.nonzero(node_mask)[0] selected_edges = np.nonzero(edge_mask)[0] all_nodes1 = [] diff --git a/tests/distributed/test_dist_tensor.py b/tests/distributed/test_dist_tensor.py index 9db905c8d2..c8ab43e5f6 100644 --- a/tests/distributed/test_dist_tensor.py +++ b/tests/distributed/test_dist_tensor.py @@ -32,12 +32,8 @@ def setup_module(): # Partition the graph. num_parts = 1 graph_name = "dist_graph_test_3" - dist_g.ndata["features"] = F.unsqueeze( - F.arange(0, dist_g.number_of_nodes()), 1 - ) - dist_g.edata["features"] = F.unsqueeze( - F.arange(0, dist_g.number_of_edges()), 1 - ) + dist_g.ndata["features"] = F.unsqueeze(F.arange(0, dist_g.num_nodes()), 1) + dist_g.edata["features"] = F.unsqueeze(F.arange(0, dist_g.num_edges()), 1) dgl.distributed.partition_graph( dist_g, graph_name, num_parts, "/tmp/dist_graph" ) diff --git a/tests/distributed/test_distributed_sampling.py b/tests/distributed/test_distributed_sampling.py index e51ac6bcf4..bb8f13577c 100644 --- a/tests/distributed/test_distributed_sampling.py +++ b/tests/distributed/test_distributed_sampling.py @@ -88,7 +88,7 @@ def start_sample_client_shuffle( src, dst = sampled_graph.edges() src = orig_nid[src] dst = orig_nid[dst] - assert sampled_graph.number_of_nodes() == g.number_of_nodes() + assert sampled_graph.num_nodes() == g.num_nodes() assert np.all(F.asnumpy(g.has_edges_between(src, dst))) eids = g.edge_ids(src, dst) eids1 = orig_eid[sampled_graph.edata[dgl.EID]] @@ -167,7 +167,7 @@ def check_rpc_sampling(tmpdir, num_server): assert p.exitcode == 0 src, dst = sampled_graph.edges() - assert sampled_graph.number_of_nodes() == g.number_of_nodes() + assert sampled_graph.num_nodes() == g.num_nodes() assert np.all(F.asnumpy(g.has_edges_between(src, dst))) eids = g.edge_ids(src, dst) assert np.array_equal( @@ -202,7 +202,7 @@ def check_rpc_find_edges_shuffle(tmpdir, num_server): time.sleep(1) pserver_list.append(p) - eids = F.tensor(np.random.randint(g.number_of_edges(), size=100)) + eids = F.tensor(np.random.randint(g.num_edges(), size=100)) u, v = g.find_edges(orig_eid[eids]) du, dv = start_find_edges_client(0, tmpdir, num_server > 1, eids) du = orig_nid[du] @@ -232,7 +232,7 @@ def create_random_hetero(dense=False, empty=False): edges[etype] = (arr.row, arr.col) g = dgl.heterograph(edges, num_nodes) g.nodes["n1"].data["feat"] = F.ones( - (g.number_of_nodes("n1"), 10), F.float32, F.cpu() + (g.num_nodes("n1"), 10), F.float32, F.cpu() ) return g @@ -332,7 +332,7 @@ def check_rpc_get_degree_shuffle(tmpdir, num_server): time.sleep(1) pserver_list.append(p) - nids = F.tensor(np.random.randint(g.number_of_nodes(), size=100)) + nids = F.tensor(np.random.randint(g.num_nodes(), size=100)) in_degs, out_degs, all_in_degs, all_out_degs = start_get_degrees_client( 0, tmpdir, num_server > 1, nids ) @@ -619,7 +619,7 @@ def check_rpc_hetero_sampling_empty_shuffle(tmpdir, num_server): p.join() assert p.exitcode == 0 - assert block.number_of_edges() == 0 + assert block.num_edges() == 0 assert len(block.etypes) == len(g.etypes) @@ -733,7 +733,7 @@ def check_rpc_hetero_etype_sampling_empty_shuffle(tmpdir, num_server): p.join() assert p.exitcode == 0 - assert block.number_of_edges() == 0 + assert block.num_edges() == 0 assert len(block.etypes) == len(g.etypes) @@ -841,7 +841,7 @@ def check_rpc_bipartite_sampling_empty(tmpdir, num_server): p.join() assert p.exitcode == 0 - assert block.number_of_edges() == 0 + assert block.num_edges() == 0 assert len(block.etypes) == len(g.etypes) @@ -943,7 +943,7 @@ def check_rpc_bipartite_etype_sampling_empty(tmpdir, num_server): assert p.exitcode == 0 assert block is not None - assert block.number_of_edges() == 0 + assert block.num_edges() == 0 assert len(block.etypes) == len(g.etypes) @@ -1071,7 +1071,7 @@ def check_standalone_sampling(tmpdir): sampled_graph = sample_neighbors(dist_graph, [0, 10, 99, 66, 1024, 2008], 3) src, dst = sampled_graph.edges() - assert sampled_graph.number_of_nodes() == g.number_of_nodes() + assert sampled_graph.num_nodes() == g.num_nodes() assert np.all(F.asnumpy(g.has_edges_between(src, dst))) eids = g.edge_ids(src, dst) assert np.array_equal( @@ -1117,7 +1117,7 @@ def check_standalone_etype_sampling(tmpdir): sampled_graph = sample_etype_neighbors(dist_graph, [0, 10, 99, 66, 1023], 3) src, dst = sampled_graph.edges() - assert sampled_graph.number_of_nodes() == hg.number_of_nodes() + assert sampled_graph.num_nodes() == hg.num_nodes() assert np.all(F.asnumpy(hg.has_edges_between(src, dst))) eids = hg.edge_ids(src, dst) assert np.array_equal( @@ -1148,7 +1148,7 @@ def check_standalone_etype_sampling_heterograph(tmpdir): ("paper", "cite", "paper"): (src, dst), ("paper", "cite-by", "paper"): (dst, src), }, - {"paper": hg.number_of_nodes()}, + {"paper": hg.num_nodes()}, ) partition_graph( new_hg, @@ -1170,7 +1170,7 @@ def check_standalone_etype_sampling_heterograph(tmpdir): assert len(src) == 10 src, dst = sampled_graph.edges(etype=("paper", "cite-by", "paper")) assert len(src) == 10 - assert sampled_graph.number_of_nodes() == new_hg.number_of_nodes() + assert sampled_graph.num_nodes() == new_hg.num_nodes() dgl.distributed.exit_client() @@ -1241,7 +1241,7 @@ def check_rpc_in_subgraph_shuffle(tmpdir, num_server): src, dst = sampled_graph.edges() src = orig_nid[src] dst = orig_nid[dst] - assert sampled_graph.number_of_nodes() == g.number_of_nodes() + assert sampled_graph.num_nodes() == g.num_nodes() assert np.all(F.asnumpy(g.has_edges_between(src, dst))) subg1 = dgl.in_subgraph(g, orig_nid[nodes]) diff --git a/tests/distributed/test_mp_dataloader.py b/tests/distributed/test_mp_dataloader.py index 858f6e5a84..8da60c6014 100644 --- a/tests/distributed/test_mp_dataloader.py +++ b/tests/distributed/test_mp_dataloader.py @@ -637,12 +637,8 @@ def create_random_hetero(): ) edges[etype] = (arr.row, arr.col) g = dgl.heterograph(edges, num_nodes) - g.nodes["n1"].data["feat"] = F.unsqueeze( - F.arange(0, g.number_of_nodes("n1")), 1 - ) - g.edges["r1"].data["feat"] = F.unsqueeze( - F.arange(0, g.number_of_edges("r1")), 1 - ) + g.nodes["n1"].data["feat"] = F.unsqueeze(F.arange(0, g.num_nodes("n1")), 1) + g.edges["r1"].data["feat"] = F.unsqueeze(F.arange(0, g.num_edges("r1")), 1) return g diff --git a/tests/distributed/test_partition.py b/tests/distributed/test_partition.py index 3094f1ba99..8209922344 100644 --- a/tests/distributed/test_partition.py +++ b/tests/distributed/test_partition.py @@ -98,18 +98,18 @@ def verify_hetero_graph(g, parts): for ntype in g.ntypes: print( "node {}: {}, {}".format( - ntype, g.number_of_nodes(ntype), num_nodes[ntype] + ntype, g.num_nodes(ntype), num_nodes[ntype] ) ) - assert g.number_of_nodes(ntype) == num_nodes[ntype] + assert g.num_nodes(ntype) == num_nodes[ntype] # Verify the number of edges are correct. for etype in g.canonical_etypes: print( "edge {}: {}, {}".format( - etype, g.number_of_edges(etype), num_edges[etype] + etype, g.num_edges(etype), num_edges[etype] ) ) - assert g.number_of_edges(etype) == num_edges[etype] + assert g.num_edges(etype) == num_edges[etype] nids = {ntype: [] for ntype in g.ntypes} eids = {etype: [] for etype in g.canonical_etypes} @@ -149,11 +149,11 @@ def verify_hetero_graph(g, parts): nids_type = F.cat(nids[ntype], 0) uniq_ids = F.unique(nids_type) # We should get all nodes. - assert len(uniq_ids) == g.number_of_nodes(ntype) + assert len(uniq_ids) == g.num_nodes(ntype) for etype in eids: eids_type = F.cat(eids[etype], 0) uniq_ids = F.unique(eids_type) - assert len(uniq_ids) == g.number_of_edges(etype) + assert len(uniq_ids) == g.num_edges(etype) # TODO(zhengda) this doesn't check 'part_id' @@ -235,9 +235,9 @@ def check_hetero_partition( assert len(orig_nids) == len(hg.ntypes) assert len(orig_eids) == len(hg.canonical_etypes) for ntype in hg.ntypes: - assert len(orig_nids[ntype]) == hg.number_of_nodes(ntype) + assert len(orig_nids[ntype]) == hg.num_nodes(ntype) for etype in hg.canonical_etypes: - assert len(orig_eids[etype]) == hg.number_of_edges(etype) + assert len(orig_eids[etype]) == hg.num_edges(etype) parts = [] shuffled_labels = [] shuffled_elabels = [] @@ -334,13 +334,9 @@ def check_partition( load_feats=True, graph_formats=None, ): - g.ndata["labels"] = F.arange(0, g.number_of_nodes()) - g.ndata["feats"] = F.tensor( - np.random.randn(g.number_of_nodes(), 10), F.float32 - ) - g.edata["feats"] = F.tensor( - np.random.randn(g.number_of_edges(), 10), F.float32 - ) + g.ndata["labels"] = F.arange(0, g.num_nodes()) + g.ndata["feats"] = F.tensor(np.random.randn(g.num_nodes(), 10), F.float32) + g.edata["feats"] = F.tensor(np.random.randn(g.num_edges(), 10), F.float32) g.update_all(fn.copy_u("feats", "msg"), fn.sum("msg", "h")) g.update_all(fn.copy_e("feats", "msg"), fn.sum("msg", "eh")) num_hops = 2 @@ -389,8 +385,8 @@ def check_partition( assert np.all(F.asnumpy(part_ids) == i) # Check the metadata - assert gpb._num_nodes() == g.number_of_nodes() - assert gpb._num_edges() == g.number_of_edges() + assert gpb._num_nodes() == g.num_nodes() + assert gpb._num_edges() == g.num_edges() assert gpb.num_partitions() == num_parts gpb_meta = gpb.metadata() diff --git a/tests/python/common/data/test_serialize.py b/tests/python/common/data/test_serialize.py index 57216bef9a..1ef8986160 100644 --- a/tests/python/common/data/test_serialize.py +++ b/tests/python/common/data/test_serialize.py @@ -30,9 +30,9 @@ def construct_graph(n, is_hetero): g_list = [] for i in range(n): g = generate_rand_graph(30, is_hetero) - g.edata["e1"] = F.randn((g.number_of_edges(), 32)) - g.edata["e2"] = F.ones((g.number_of_edges(), 32)) - g.ndata["n1"] = F.randn((g.number_of_nodes(), 64)) + g.edata["e1"] = F.randn((g.num_edges(), 32)) + g.edata["e2"] = F.ones((g.num_edges(), 32)) + g.ndata["n1"] = F.randn((g.num_nodes(), 64)) g_list.append(g) return g_list diff --git a/tests/python/common/function/test_basics.py b/tests/python/common/function/test_basics.py index b81f9b1098..06b630eac5 100644 --- a/tests/python/common/function/test_basics.py +++ b/tests/python/common/function/test_basics.py @@ -250,8 +250,8 @@ def _test_nx_conversion(): # use id feature to test non-tensor copy g = dgl.from_networkx(nxg, node_attrs=["n1"], edge_attrs=["e1", "id"]) # check graph size - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 5 + assert g.num_edges() == 4 # check number of features # test with existing dglgraph (so existing features should be cleared) assert len(g.ndata) == 1 @@ -286,8 +286,8 @@ def _test_nx_conversion(): # test with a new graph g = dgl.from_networkx(nxg, node_attrs=["n1"], edge_attrs=["e1"]) # check graph size - assert g.number_of_nodes() == 7 - assert g.number_of_edges() == 7 + assert g.num_nodes() == 7 + assert g.num_edges() == 7 # check number of features assert len(g.ndata) == 1 assert len(g.edata) == 1 @@ -310,8 +310,8 @@ def _test_nx_conversion(): d["h"] = F.tensor([u, v]) g = dgl.from_networkx(nxg, node_attrs=["h"], edge_attrs=["h"]) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 3 + assert g.num_edges() == 4 assert g.has_edge_between(0, 1) assert g.has_edge_between(1, 2) assert F.allclose(g.ndata["h"], F.tensor([[1.0], [2.0], [3.0]])) @@ -511,18 +511,18 @@ def test_repr(idtype): @parametrize_idtype def test_local_var(idtype): g = dgl.graph(([0, 1, 2, 3], [1, 2, 3, 4]), idtype=idtype, device=F.ctx()) - g.ndata["h"] = F.zeros((g.number_of_nodes(), 3)) - g.edata["w"] = F.zeros((g.number_of_edges(), 4)) + g.ndata["h"] = F.zeros((g.num_nodes(), 3)) + g.edata["w"] = F.zeros((g.num_edges(), 4)) # test override def foo(g): g = g.local_var() - g.ndata["h"] = F.ones((g.number_of_nodes(), 3)) - g.edata["w"] = F.ones((g.number_of_edges(), 4)) + g.ndata["h"] = F.ones((g.num_nodes(), 3)) + g.edata["w"] = F.ones((g.num_edges(), 4)) foo(g) - assert F.allclose(g.ndata["h"], F.zeros((g.number_of_nodes(), 3))) - assert F.allclose(g.edata["w"], F.zeros((g.number_of_edges(), 4))) + assert F.allclose(g.ndata["h"], F.zeros((g.num_nodes(), 3))) + assert F.allclose(g.edata["w"], F.zeros((g.num_edges(), 4))) # test out-place update def foo(g): @@ -531,8 +531,8 @@ def test_local_var(idtype): g.edges[[2, 3]].data["w"] = F.ones((2, 4)) foo(g) - assert F.allclose(g.ndata["h"], F.zeros((g.number_of_nodes(), 3))) - assert F.allclose(g.edata["w"], F.zeros((g.number_of_edges(), 4))) + assert F.allclose(g.ndata["h"], F.zeros((g.num_nodes(), 3))) + assert F.allclose(g.edata["w"], F.zeros((g.num_edges(), 4))) # test out-place update 2 def foo(g): @@ -541,14 +541,14 @@ def test_local_var(idtype): g.apply_edges(lambda edges: {"w": edges.data["w"] + 10}, [2, 3]) foo(g) - assert F.allclose(g.ndata["h"], F.zeros((g.number_of_nodes(), 3))) - assert F.allclose(g.edata["w"], F.zeros((g.number_of_edges(), 4))) + assert F.allclose(g.ndata["h"], F.zeros((g.num_nodes(), 3))) + assert F.allclose(g.edata["w"], F.zeros((g.num_edges(), 4))) # test auto-pop def foo(g): g = g.local_var() - g.ndata["hh"] = F.ones((g.number_of_nodes(), 3)) - g.edata["ww"] = F.ones((g.number_of_edges(), 4)) + g.ndata["hh"] = F.ones((g.num_nodes(), 3)) + g.edata["ww"] = F.ones((g.num_edges(), 4)) foo(g) assert "hh" not in g.ndata @@ -584,18 +584,18 @@ def test_local_var(idtype): @parametrize_idtype def test_local_scope(idtype): g = dgl.graph(([0, 1, 2, 3], [1, 2, 3, 4]), idtype=idtype, device=F.ctx()) - g.ndata["h"] = F.zeros((g.number_of_nodes(), 3)) - g.edata["w"] = F.zeros((g.number_of_edges(), 4)) + g.ndata["h"] = F.zeros((g.num_nodes(), 3)) + g.edata["w"] = F.zeros((g.num_edges(), 4)) # test override def foo(g): with g.local_scope(): - g.ndata["h"] = F.ones((g.number_of_nodes(), 3)) - g.edata["w"] = F.ones((g.number_of_edges(), 4)) + g.ndata["h"] = F.ones((g.num_nodes(), 3)) + g.edata["w"] = F.ones((g.num_edges(), 4)) foo(g) - assert F.allclose(g.ndata["h"], F.zeros((g.number_of_nodes(), 3))) - assert F.allclose(g.edata["w"], F.zeros((g.number_of_edges(), 4))) + assert F.allclose(g.ndata["h"], F.zeros((g.num_nodes(), 3))) + assert F.allclose(g.edata["w"], F.zeros((g.num_edges(), 4))) # test out-place update def foo(g): @@ -604,8 +604,8 @@ def test_local_scope(idtype): g.edges[[2, 3]].data["w"] = F.ones((2, 4)) foo(g) - assert F.allclose(g.ndata["h"], F.zeros((g.number_of_nodes(), 3))) - assert F.allclose(g.edata["w"], F.zeros((g.number_of_edges(), 4))) + assert F.allclose(g.ndata["h"], F.zeros((g.num_nodes(), 3))) + assert F.allclose(g.edata["w"], F.zeros((g.num_edges(), 4))) # test out-place update 2 def foo(g): @@ -614,14 +614,14 @@ def test_local_scope(idtype): g.apply_edges(lambda edges: {"w": edges.data["w"] + 10}, [2, 3]) foo(g) - assert F.allclose(g.ndata["h"], F.zeros((g.number_of_nodes(), 3))) - assert F.allclose(g.edata["w"], F.zeros((g.number_of_edges(), 4))) + assert F.allclose(g.ndata["h"], F.zeros((g.num_nodes(), 3))) + assert F.allclose(g.edata["w"], F.zeros((g.num_edges(), 4))) # test auto-pop def foo(g): with g.local_scope(): - g.ndata["hh"] = F.ones((g.number_of_nodes(), 3)) - g.edata["ww"] = F.ones((g.number_of_edges(), 4)) + g.ndata["hh"] = F.ones((g.num_nodes(), 3)) + g.edata["ww"] = F.ones((g.num_edges(), 4)) foo(g) assert "hh" not in g.ndata @@ -630,11 +630,11 @@ def test_local_scope(idtype): # test nested scope def foo(g): with g.local_scope(): - g.ndata["hh"] = F.ones((g.number_of_nodes(), 3)) - g.edata["ww"] = F.ones((g.number_of_edges(), 4)) + g.ndata["hh"] = F.ones((g.num_nodes(), 3)) + g.edata["ww"] = F.ones((g.num_edges(), 4)) with g.local_scope(): - g.ndata["hhh"] = F.ones((g.number_of_nodes(), 3)) - g.edata["www"] = F.ones((g.number_of_edges(), 4)) + g.ndata["hhh"] = F.ones((g.num_nodes(), 3)) + g.edata["www"] = F.ones((g.num_edges(), 4)) assert "hhh" not in g.ndata assert "www" not in g.edata @@ -672,7 +672,7 @@ def test_local_scope(idtype): @parametrize_idtype def test_isolated_nodes(idtype): g = dgl.graph(([0, 1], [1, 2]), num_nodes=5, idtype=idtype, device=F.ctx()) - assert g.number_of_nodes() == 5 + assert g.num_nodes() == 5 g = dgl.heterograph( {("user", "plays", "game"): ([0, 0, 1], [2, 3, 2])}, @@ -681,8 +681,8 @@ def test_isolated_nodes(idtype): device=F.ctx(), ) assert g.idtype == idtype - assert g.number_of_nodes("user") == 5 - assert g.number_of_nodes("game") == 7 + assert g.num_nodes("user") == 5 + assert g.num_nodes("game") == 7 # Test backward compatibility g = dgl.heterograph( @@ -692,8 +692,8 @@ def test_isolated_nodes(idtype): device=F.ctx(), ) assert g.idtype == idtype - assert g.number_of_nodes("user") == 5 - assert g.number_of_nodes("game") == 7 + assert g.num_nodes("user") == 5 + assert g.num_nodes("game") == 7 @parametrize_idtype diff --git a/tests/python/common/ops/test_edge_softmax.py b/tests/python/common/ops/test_edge_softmax.py index 1321b25231..1d4608238a 100644 --- a/tests/python/common/ops/test_edge_softmax.py +++ b/tests/python/common/ops/test_edge_softmax.py @@ -28,7 +28,7 @@ feat_size = 2 @parametrize_idtype def test_edge_softmax(g, norm_by, shp, idtype): g = g.astype(idtype).to(F.ctx()) - edata = F.tensor(np.random.rand(g.number_of_edges(), *shp)) + edata = F.tensor(np.random.rand(g.num_edges(), *shp)) e1 = F.attach_grad(F.clone(edata)) with F.record_grad(): diff --git a/tests/python/common/ops/test_ops.py b/tests/python/common/ops/test_ops.py index 0140b53c2f..3f98e50fe6 100644 --- a/tests/python/common/ops/test_ops.py +++ b/tests/python/common/ops/test_ops.py @@ -117,7 +117,7 @@ def test_spmm(idtype, g, shp, msg, reducer): print(g.idtype) hu = F.tensor(np.random.rand(*((g.number_of_src_nodes(),) + shp[0])) + 1) - he = F.tensor(np.random.rand(*((g.number_of_edges(),) + shp[1])) + 1) + he = F.tensor(np.random.rand(*((g.num_edges(),) + shp[1])) + 1) print("u shape: {}, e shape: {}".format(F.shape(hu), F.shape(he))) g.srcdata["x"] = F.attach_grad(F.clone(hu)) @@ -130,7 +130,7 @@ def test_spmm(idtype, g, shp, msg, reducer): v = gspmm(g, msg, reducer, u, e) if reducer in ["max", "min"]: v = F.replace_inf_with_zero(v) - if g.number_of_edges() > 0: + if g.num_edges() > 0: F.backward(F.reduce_sum(v)) if msg != "copy_rhs": grad_u = F.grad(u) @@ -139,7 +139,7 @@ def test_spmm(idtype, g, shp, msg, reducer): with F.record_grad(): g.update_all(udf_msg[msg], udf_reduce[reducer]) - if g.number_of_edges() > 0: + if g.num_edges() > 0: v1 = g.dstdata["v"] assert F.allclose(v, v1) print("forward passed") @@ -224,7 +224,7 @@ def test_sddmm(g, shp, lhs_target, rhs_target, msg, idtype): if lhs_target == rhs_target: return g = g.astype(idtype).to(F.ctx()) - if dgl.backend.backend_name == "mxnet" and g.number_of_edges() == 0: + if dgl.backend.backend_name == "mxnet" and g.num_edges() == 0: pytest.skip() # mxnet do not support zero shape tensor print(g) print(g.idtype) @@ -232,14 +232,14 @@ def test_sddmm(g, shp, lhs_target, rhs_target, msg, idtype): len_lhs = select( lhs_target, g.number_of_src_nodes(), - g.number_of_edges(), + g.num_edges(), g.number_of_dst_nodes(), ) lhs_shp = (len_lhs,) + shp[0] len_rhs = select( rhs_target, g.number_of_src_nodes(), - g.number_of_edges(), + g.num_edges(), g.number_of_dst_nodes(), ) rhs_shp = (len_rhs,) + shp[1] @@ -270,7 +270,7 @@ def test_sddmm(g, shp, lhs_target, rhs_target, msg, idtype): with F.record_grad(): g.apply_edges(udf_apply_edges[msg_func]) - if g.number_of_edges() > 0: + if g.num_edges() > 0: e1 = g.edata["m"] assert F.allclose(e, e1) print("forward passed") diff --git a/tests/python/common/sampling/test_sampling.py b/tests/python/common/sampling/test_sampling.py index a6a5c08874..4e2195a502 100644 --- a/tests/python/common/sampling/test_sampling.py +++ b/tests/python/common/sampling/test_sampling.py @@ -562,7 +562,7 @@ def _test_sample_neighbors(hypersparse, prob): subg = dgl.sampling.sample_neighbors( g, [0, 1], -1, prob=p, replace=replace ) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans, e_ans = g.in_edges([0, 1], form="all") if p is not None: @@ -579,8 +579,8 @@ def _test_sample_neighbors(hypersparse, prob): subg = dgl.sampling.sample_neighbors( g, [0, 1], 2, prob=p, replace=replace ) - assert subg.number_of_nodes() == g.number_of_nodes() - assert subg.number_of_edges() == 4 + assert subg.num_nodes() == g.num_nodes() + assert subg.num_edges() == 4 u, v = subg.edges() assert set(F.asnumpy(F.unique(v))) == {0, 1} assert F.array_equal( @@ -603,7 +603,7 @@ def _test_sample_neighbors(hypersparse, prob): subg = dgl.sampling.sample_neighbors( g, [0, 2], -1, prob=p, replace=replace ) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans, e_ans = g.in_edges([0, 2], form="all") if p is not None: @@ -620,9 +620,9 @@ def _test_sample_neighbors(hypersparse, prob): subg = dgl.sampling.sample_neighbors( g, [0, 2], 2, prob=p, replace=replace ) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() num_edges = 4 if replace else 3 - assert subg.number_of_edges() == num_edges + assert subg.num_edges() == num_edges u, v = subg.edges() assert set(F.asnumpy(F.unique(v))) == {0, 2} assert F.array_equal( @@ -646,10 +646,10 @@ def _test_sample_neighbors(hypersparse, prob): ) assert len(subg.ntypes) == 3 assert len(subg.etypes) == 4 - assert subg["follow"].number_of_edges() == 6 if p is None else 4 - assert subg["play"].number_of_edges() == 1 - assert subg["liked-by"].number_of_edges() == 4 - assert subg["flips"].number_of_edges() == 0 + assert subg["follow"].num_edges() == 6 if p is None else 4 + assert subg["play"].num_edges() == 1 + assert subg["liked-by"].num_edges() == 4 + assert subg["flips"].num_edges() == 0 for i in range(10): subg = dgl.sampling.sample_neighbors( @@ -657,10 +657,10 @@ def _test_sample_neighbors(hypersparse, prob): ) assert len(subg.ntypes) == 3 assert len(subg.etypes) == 4 - assert subg["follow"].number_of_edges() == 4 - assert subg["play"].number_of_edges() == 2 if replace else 1 - assert subg["liked-by"].number_of_edges() == 4 if replace else 3 - assert subg["flips"].number_of_edges() == 0 + assert subg["follow"].num_edges() == 4 + assert subg["play"].num_edges() == 2 if replace else 1 + assert subg["liked-by"].num_edges() == 4 if replace else 3 + assert subg["flips"].num_edges() == 0 _test3(prob, True) # w/ replacement, uniform _test3(prob, False) # w/o replacement, uniform @@ -675,10 +675,10 @@ def _test_sample_neighbors(hypersparse, prob): ) assert len(subg.ntypes) == 3 assert len(subg.etypes) == 4 - assert subg["follow"].number_of_edges() == 2 - assert subg["play"].number_of_edges() == 2 - assert subg["liked-by"].number_of_edges() == 0 - assert subg["flips"].number_of_edges() == 4 + assert subg["follow"].num_edges() == 2 + assert subg["play"].num_edges() == 2 + assert subg["liked-by"].num_edges() == 0 + assert subg["flips"].num_edges() == 4 def _test_sample_neighbors_outedge(hypersparse): @@ -688,7 +688,7 @@ def _test_sample_neighbors_outedge(hypersparse): subg = dgl.sampling.sample_neighbors( g, [0, 1], -1, prob=p, replace=replace, edge_dir="out" ) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans, e_ans = g.out_edges([0, 1], form="all") if p is not None: @@ -705,8 +705,8 @@ def _test_sample_neighbors_outedge(hypersparse): subg = dgl.sampling.sample_neighbors( g, [0, 1], 2, prob=p, replace=replace, edge_dir="out" ) - assert subg.number_of_nodes() == g.number_of_nodes() - assert subg.number_of_edges() == 4 + assert subg.num_nodes() == g.num_nodes() + assert subg.num_edges() == 4 u, v = subg.edges() assert set(F.asnumpy(F.unique(u))) == {0, 1} assert F.array_equal( @@ -731,7 +731,7 @@ def _test_sample_neighbors_outedge(hypersparse): subg = dgl.sampling.sample_neighbors( g, [0, 2], -1, prob=p, replace=replace, edge_dir="out" ) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans, e_ans = g.out_edges([0, 2], form="all") if p is not None: @@ -748,9 +748,9 @@ def _test_sample_neighbors_outedge(hypersparse): subg = dgl.sampling.sample_neighbors( g, [0, 2], 2, prob=p, replace=replace, edge_dir="out" ) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() num_edges = 4 if replace else 3 - assert subg.number_of_edges() == num_edges + assert subg.num_edges() == num_edges u, v = subg.edges() assert set(F.asnumpy(F.unique(u))) == {0, 2} assert F.array_equal( @@ -781,10 +781,10 @@ def _test_sample_neighbors_outedge(hypersparse): ) assert len(subg.ntypes) == 3 assert len(subg.etypes) == 4 - assert subg["follow"].number_of_edges() == 6 if p is None else 4 - assert subg["play"].number_of_edges() == 1 - assert subg["liked-by"].number_of_edges() == 4 - assert subg["flips"].number_of_edges() == 0 + assert subg["follow"].num_edges() == 6 if p is None else 4 + assert subg["play"].num_edges() == 1 + assert subg["liked-by"].num_edges() == 4 + assert subg["flips"].num_edges() == 0 for i in range(10): subg = dgl.sampling.sample_neighbors( @@ -797,10 +797,10 @@ def _test_sample_neighbors_outedge(hypersparse): ) assert len(subg.ntypes) == 3 assert len(subg.etypes) == 4 - assert subg["follow"].number_of_edges() == 4 - assert subg["play"].number_of_edges() == 2 if replace else 1 - assert subg["liked-by"].number_of_edges() == 4 if replace else 3 - assert subg["flips"].number_of_edges() == 0 + assert subg["follow"].num_edges() == 4 + assert subg["play"].num_edges() == 2 if replace else 1 + assert subg["liked-by"].num_edges() == 4 if replace else 3 + assert subg["flips"].num_edges() == 0 _test3(None, True) # w/ replacement, uniform _test3(None, False) # w/o replacement, uniform @@ -813,7 +813,7 @@ def _test_sample_neighbors_topk(hypersparse): def _test1(): subg = dgl.sampling.select_topk(g, -1, "weight", [0, 1]) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans = subg.in_edges([0, 1]) uv = set(zip(F.asnumpy(u), F.asnumpy(v))) @@ -821,8 +821,8 @@ def _test_sample_neighbors_topk(hypersparse): assert uv == uv_ans subg = dgl.sampling.select_topk(g, 2, "weight", [0, 1]) - assert subg.number_of_nodes() == g.number_of_nodes() - assert subg.number_of_edges() == 4 + assert subg.num_nodes() == g.num_nodes() + assert subg.num_edges() == 4 u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) assert F.array_equal(g.edge_ids(u, v), subg.edata[dgl.EID]) @@ -832,7 +832,7 @@ def _test_sample_neighbors_topk(hypersparse): def _test2(): # k > #neighbors subg = dgl.sampling.select_topk(g, -1, "weight", [0, 2]) - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans = subg.in_edges([0, 2]) uv = set(zip(F.asnumpy(u), F.asnumpy(v))) @@ -840,8 +840,8 @@ def _test_sample_neighbors_topk(hypersparse): assert uv == uv_ans subg = dgl.sampling.select_topk(g, 2, "weight", [0, 2]) - assert subg.number_of_nodes() == g.number_of_nodes() - assert subg.number_of_edges() == 3 + assert subg.num_nodes() == g.num_nodes() + assert subg.num_edges() == 3 u, v = subg.edges() assert F.array_equal(g.edge_ids(u, v), subg.edata[dgl.EID]) edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) @@ -873,7 +873,7 @@ def _test_sample_neighbors_topk(hypersparse): hg["liked-by"].edge_ids(u, v), subg["liked-by"].edata[dgl.EID] ) assert edge_set == {(2, 0), (2, 1), (1, 0)} - assert subg["flips"].number_of_edges() == 0 + assert subg["flips"].num_edges() == 0 _test3() @@ -886,10 +886,10 @@ def _test_sample_neighbors_topk(hypersparse): ) assert len(subg.ntypes) == 3 assert len(subg.etypes) == 4 - assert subg["follow"].number_of_edges() == 2 - assert subg["play"].number_of_edges() == 1 - assert subg["liked-by"].number_of_edges() == 0 - assert subg["flips"].number_of_edges() == 4 + assert subg["follow"].num_edges() == 2 + assert subg["play"].num_edges() == 1 + assert subg["liked-by"].num_edges() == 0 + assert subg["flips"].num_edges() == 4 def _test_sample_neighbors_topk_outedge(hypersparse): @@ -897,7 +897,7 @@ def _test_sample_neighbors_topk_outedge(hypersparse): def _test1(): subg = dgl.sampling.select_topk(g, -1, "weight", [0, 1], edge_dir="out") - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans = subg.out_edges([0, 1]) uv = set(zip(F.asnumpy(u), F.asnumpy(v))) @@ -905,8 +905,8 @@ def _test_sample_neighbors_topk_outedge(hypersparse): assert uv == uv_ans subg = dgl.sampling.select_topk(g, 2, "weight", [0, 1], edge_dir="out") - assert subg.number_of_nodes() == g.number_of_nodes() - assert subg.number_of_edges() == 4 + assert subg.num_nodes() == g.num_nodes() + assert subg.num_edges() == 4 u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) assert F.array_equal(g.edge_ids(u, v), subg.edata[dgl.EID]) @@ -916,7 +916,7 @@ def _test_sample_neighbors_topk_outedge(hypersparse): def _test2(): # k > #neighbors subg = dgl.sampling.select_topk(g, -1, "weight", [0, 2], edge_dir="out") - assert subg.number_of_nodes() == g.number_of_nodes() + assert subg.num_nodes() == g.num_nodes() u, v = subg.edges() u_ans, v_ans = subg.out_edges([0, 2]) uv = set(zip(F.asnumpy(u), F.asnumpy(v))) @@ -924,8 +924,8 @@ def _test_sample_neighbors_topk_outedge(hypersparse): assert uv == uv_ans subg = dgl.sampling.select_topk(g, 2, "weight", [0, 2], edge_dir="out") - assert subg.number_of_nodes() == g.number_of_nodes() - assert subg.number_of_edges() == 3 + assert subg.num_nodes() == g.num_nodes() + assert subg.num_edges() == 3 u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) assert F.array_equal(g.edge_ids(u, v), subg.edata[dgl.EID]) @@ -957,7 +957,7 @@ def _test_sample_neighbors_topk_outedge(hypersparse): hg["liked-by"].edge_ids(u, v), subg["liked-by"].edata[dgl.EID] ) assert edge_set == {(0, 2), (1, 2), (0, 1)} - assert subg["flips"].number_of_edges() == 0 + assert subg["flips"].num_edges() == 0 _test3() @@ -1011,19 +1011,19 @@ def test_sample_neighbors_with_0deg(): sg = dgl.sampling.sample_neighbors( g, F.tensor([1, 2], dtype=F.int64), 2, edge_dir="in", replace=False ) - assert sg.number_of_edges() == 0 + assert sg.num_edges() == 0 sg = dgl.sampling.sample_neighbors( g, F.tensor([1, 2], dtype=F.int64), 2, edge_dir="in", replace=True ) - assert sg.number_of_edges() == 0 + assert sg.num_edges() == 0 sg = dgl.sampling.sample_neighbors( g, F.tensor([1, 2], dtype=F.int64), 2, edge_dir="out", replace=False ) - assert sg.number_of_edges() == 0 + assert sg.num_edges() == 0 sg = dgl.sampling.sample_neighbors( g, F.tensor([1, 2], dtype=F.int64), 2, edge_dir="out", replace=True ) - assert sg.number_of_edges() == 0 + assert sg.num_edges() == 0 def create_test_graph(num_nodes, num_edges_per_node, bipartite=False): @@ -1118,7 +1118,7 @@ def test_sample_neighbors_biased_homogeneous(): check_num(subg.edges()[0], tag) u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) - assert len(edge_set) == subg.number_of_edges() + assert len(edge_set) == subg.num_edges() # inedge / with replacement for _ in range(5): @@ -1136,7 +1136,7 @@ def test_sample_neighbors_biased_homogeneous(): check_num(subg.edges()[1], tag) u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) - assert len(edge_set) == subg.number_of_edges() + assert len(edge_set) == subg.num_edges() # outedge / with replacement for _ in range(5): @@ -1175,7 +1175,7 @@ def test_sample_neighbors_biased_bipartite(): check_num(subg.edges()[0], tag) u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) - assert len(edge_set) == subg.number_of_edges() + assert len(edge_set) == subg.num_edges() # inedge / with replacement for _ in range(5): @@ -1194,7 +1194,7 @@ def test_sample_neighbors_biased_bipartite(): check_num(subg.edges()[1], tag) u, v = subg.edges() edge_set = set(zip(list(F.asnumpy(u)), list(F.asnumpy(v)))) - assert len(edge_set) == subg.number_of_edges() + assert len(edge_set) == subg.num_edges() # outedge / with replacement for _ in range(5): diff --git a/tests/python/common/test_batch-graph.py b/tests/python/common/test_batch-graph.py index 6eae29fb25..4461056ed7 100644 --- a/tests/python/common/test_batch-graph.py +++ b/tests/python/common/test_batch-graph.py @@ -53,8 +53,8 @@ def test_batch_unbatch(idtype): t2 = tree2(idtype) bg = dgl.batch([t1, t2]) - assert bg.number_of_nodes() == 10 - assert bg.number_of_edges() == 8 + assert bg.num_nodes() == 10 + assert bg.num_edges() == 8 assert bg.batch_size == 2 assert F.allclose(bg.batch_num_nodes(), F.tensor([5, 5])) assert F.allclose(bg.batch_num_edges(), F.tensor([4, 4])) @@ -72,8 +72,8 @@ def test_batch_unbatch1(idtype): t2 = tree2(idtype) b1 = dgl.batch([t1, t2]) b2 = dgl.batch([t2, b1]) - assert b2.number_of_nodes() == 15 - assert b2.number_of_edges() == 12 + assert b2.num_nodes() == 15 + assert b2.num_edges() == 12 assert b2.batch_size == 3 assert F.allclose(b2.batch_num_nodes(), F.tensor([5, 5, 5])) assert F.allclose(b2.batch_num_edges(), F.tensor([4, 4, 4])) @@ -98,10 +98,10 @@ def test_batch_unbatch_frame(idtype): """ t1 = tree1(idtype) t2 = tree2(idtype) - N1 = t1.number_of_nodes() - E1 = t1.number_of_edges() - N2 = t2.number_of_nodes() - E2 = t2.number_of_edges() + N1 = t1.num_nodes() + E1 = t1.num_edges() + N2 = t2.num_nodes() + E2 = t2.num_edges() D = 10 t1.ndata["h"] = F.randn((N1, D)) t1.edata["h"] = F.randn((E1, D)) diff --git a/tests/python/common/test_batch-heterograph.py b/tests/python/common/test_batch-heterograph.py index b35bb2c298..61c0663215 100644 --- a/tests/python/common/test_batch-heterograph.py +++ b/tests/python/common/test_batch-heterograph.py @@ -16,14 +16,14 @@ def check_equivalence_between_heterographs( assert g1.canonical_etypes == g2.canonical_etypes for nty in g1.ntypes: - assert g1.number_of_nodes(nty) == g2.number_of_nodes(nty) + assert g1.num_nodes(nty) == g2.num_nodes(nty) for ety in g1.etypes: if len(g1._etype2canonical[ety]) > 0: - assert g1.number_of_edges(ety) == g2.number_of_edges(ety) + assert g1.num_edges(ety) == g2.num_edges(ety) for ety in g1.canonical_etypes: - assert g1.number_of_edges(ety) == g2.number_of_edges(ety) + assert g1.num_edges(ety) == g2.num_edges(ety) src1, dst1, eid1 = g1.edges(etype=ety, form="all") src2, dst2, eid2 = g2.edges(etype=ety, form="all") assert F.allclose(src1, src2) @@ -32,7 +32,7 @@ def check_equivalence_between_heterographs( if node_attrs is not None: for nty in node_attrs.keys(): - if g1.number_of_nodes(nty) == 0: + if g1.num_nodes(nty) == 0: continue for feat_name in node_attrs[nty]: assert F.allclose( @@ -41,7 +41,7 @@ def check_equivalence_between_heterographs( if edge_attrs is not None: for ety in edge_attrs.keys(): - if g1.number_of_edges(ety) == 0: + if g1.num_edges(ety) == 0: continue for feat_name in edge_attrs[ety]: assert F.allclose( @@ -69,27 +69,27 @@ def test_topology(gs, idtype): for ntype in bg.ntypes: print(ntype) assert F.asnumpy(bg.batch_num_nodes(ntype)).tolist() == [ - g1.number_of_nodes(ntype), - g2.number_of_nodes(ntype), + g1.num_nodes(ntype), + g2.num_nodes(ntype), ] - assert bg.number_of_nodes(ntype) == ( - g1.number_of_nodes(ntype) + g2.number_of_nodes(ntype) + assert bg.num_nodes(ntype) == ( + g1.num_nodes(ntype) + g2.num_nodes(ntype) ) # Test number of edges for etype in bg.canonical_etypes: assert F.asnumpy(bg.batch_num_edges(etype)).tolist() == [ - g1.number_of_edges(etype), - g2.number_of_edges(etype), + g1.num_edges(etype), + g2.num_edges(etype), ] - assert bg.number_of_edges(etype) == ( - g1.number_of_edges(etype) + g2.number_of_edges(etype) + assert bg.num_edges(etype) == ( + g1.num_edges(etype) + g2.num_edges(etype) ) # Test relabeled nodes for ntype in bg.ntypes: assert list(F.asnumpy(bg.nodes(ntype))) == list( - range(bg.number_of_nodes(ntype)) + range(bg.num_nodes(ntype)) ) # Test relabeled edges @@ -160,33 +160,29 @@ def test_batching_batched(idtype): # Test number of nodes for ntype in bg2.ntypes: assert F.asnumpy(bg2.batch_num_nodes(ntype)).tolist() == [ - g1.number_of_nodes(ntype), - g2.number_of_nodes(ntype), - g3.number_of_nodes(ntype), + g1.num_nodes(ntype), + g2.num_nodes(ntype), + g3.num_nodes(ntype), ] - assert bg2.number_of_nodes(ntype) == ( - g1.number_of_nodes(ntype) - + g2.number_of_nodes(ntype) - + g3.number_of_nodes(ntype) + assert bg2.num_nodes(ntype) == ( + g1.num_nodes(ntype) + g2.num_nodes(ntype) + g3.num_nodes(ntype) ) # Test number of edges for etype in bg2.canonical_etypes: assert F.asnumpy(bg2.batch_num_edges(etype)).tolist() == [ - g1.number_of_edges(etype), - g2.number_of_edges(etype), - g3.number_of_edges(etype), + g1.num_edges(etype), + g2.num_edges(etype), + g3.num_edges(etype), ] - assert bg2.number_of_edges(etype) == ( - g1.number_of_edges(etype) - + g2.number_of_edges(etype) - + g3.number_of_edges(etype) + assert bg2.num_edges(etype) == ( + g1.num_edges(etype) + g2.num_edges(etype) + g3.num_edges(etype) ) # Test relabeled nodes for ntype in bg2.ntypes: assert list(F.asnumpy(bg2.nodes(ntype))) == list( - range(bg2.number_of_nodes(ntype)) + range(bg2.num_nodes(ntype)) ) # Test relabeled edges @@ -374,15 +370,15 @@ def test_empty_relation(idtype): # Test number of nodes for ntype in bg.ntypes: assert F.asnumpy(bg.batch_num_nodes(ntype)).tolist() == [ - g1.number_of_nodes(ntype), - g2.number_of_nodes(ntype), + g1.num_nodes(ntype), + g2.num_nodes(ntype), ] # Test number of edges for etype in bg.canonical_etypes: assert F.asnumpy(bg.batch_num_edges(etype)).tolist() == [ - g1.number_of_edges(etype), - g2.number_of_edges(etype), + g1.num_edges(etype), + g2.num_edges(etype), ] # Test features diff --git a/tests/python/common/test_generators.py b/tests/python/common/test_generators.py index 7144a6aba7..cf9a5a1aa9 100644 --- a/tests/python/common/test_generators.py +++ b/tests/python/common/test_generators.py @@ -11,8 +11,8 @@ import numpy as np ) def test_rand_graph(): g = dgl.rand_graph(10000, 100000) - assert g.number_of_nodes() == 10000 - assert g.number_of_edges() == 100000 + assert g.num_nodes() == 10000 + assert g.num_edges() == 100000 # test random seed dgl.random.seed(42) g1 = dgl.rand_graph(100, 30) diff --git a/tests/python/common/test_heterograph-kernel.py b/tests/python/common/test_heterograph-kernel.py index 019a145a17..8d0ca47b65 100644 --- a/tests/python/common/test_heterograph-kernel.py +++ b/tests/python/common/test_heterograph-kernel.py @@ -44,8 +44,8 @@ def generate_feature(g, broadcast="none", binary_op="none"): 'e', 'v', 'none' """ np.random.seed(31) - nv = g.number_of_nodes() - ne = g.number_of_edges() + nv = g.num_nodes() + ne = g.num_edges() if binary_op == "dot": if broadcast == "e": u = F.tensor(np.random.uniform(-1, 1, (nv, D1, D2, D3, D4))) @@ -401,7 +401,7 @@ def test_all_binary_builtins(): @pytest.mark.parametrize("g", get_cases(["homo-zero-degree"])) def test_mean_zero_degree(g, idtype): g = g.astype(idtype).to(F.ctx()) - g.ndata["h"] = F.ones((g.number_of_nodes(), 3)) + g.ndata["h"] = F.ones((g.num_nodes(), 3)) g.update_all(fn.copy_u("h", "m"), fn.mean("m", "x")) deg = F.asnumpy(g.in_degrees()) v = F.tensor(np.where(deg == 0)[0]) diff --git a/tests/python/common/test_heterograph-misc.py b/tests/python/common/test_heterograph-misc.py index 40e2abbfc2..52847b85c4 100644 --- a/tests/python/common/test_heterograph-misc.py +++ b/tests/python/common/test_heterograph-misc.py @@ -67,8 +67,8 @@ def gen_from_data(data, readonly, sort): def test_query(): def _test_one(g): - assert g.number_of_nodes() == 10 - assert g.number_of_edges() == 20 + assert g.num_nodes() == 10 + assert g.num_edges() == 20 for i in range(10): assert g.has_nodes(i) @@ -158,8 +158,8 @@ def test_query(): _test_one(g) def _test_csr_one(g): - assert g.number_of_nodes() == 10 - assert g.number_of_edges() == 20 + assert g.num_nodes() == 10 + assert g.num_edges() == 20 for i in range(10): assert g.has_nodes(i) diff --git a/tests/python/common/test_heterograph-pickle.py b/tests/python/common/test_heterograph-pickle.py index 65261b20eb..3bc4a5e3ee 100644 --- a/tests/python/common/test_heterograph-pickle.py +++ b/tests/python/common/test_heterograph-pickle.py @@ -21,7 +21,7 @@ from utils import ( def _assert_is_identical_nodeflow(nf1, nf2): - assert nf1.number_of_nodes() == nf2.number_of_nodes() + assert nf1.num_nodes() == nf2.num_nodes() src, dst = nf1.all_edges() src2, dst2 = nf2.all_edges() assert F.array_equal(src, src2) @@ -96,7 +96,7 @@ def test_pickling_graph_index(): gi2 = _reconstruct_pickle(gi) - assert gi2.number_of_nodes() == gi.number_of_nodes() + assert gi2.num_nodes() == gi.num_nodes() src_idx2, dst_idx2, _ = gi2.edges() assert F.array_equal(src_idx.tousertensor(), src_idx2.tousertensor()) assert F.array_equal(dst_idx.tousertensor(), dst_idx2.tousertensor()) diff --git a/tests/python/common/test_heterograph-remove.py b/tests/python/common/test_heterograph-remove.py index efa39a86bb..b7d959751c 100644 --- a/tests/python/common/test_heterograph-remove.py +++ b/tests/python/common/test_heterograph-remove.py @@ -11,26 +11,26 @@ def test_node_removal(idtype): g = g.astype(idtype).to(F.ctx()) g.add_nodes(10) g.add_edges(0, 0) - assert g.number_of_nodes() == 10 + assert g.num_nodes() == 10 g.ndata["id"] = F.arange(0, 10) # remove nodes g.remove_nodes(range(4, 7)) - assert g.number_of_nodes() == 7 + assert g.num_nodes() == 7 assert F.array_equal(g.ndata["id"], F.tensor([0, 1, 2, 3, 7, 8, 9])) assert dgl.NID not in g.ndata assert dgl.EID not in g.edata # add nodes g.add_nodes(3) - assert g.number_of_nodes() == 10 + assert g.num_nodes() == 10 assert F.array_equal( g.ndata["id"], F.tensor([0, 1, 2, 3, 7, 8, 9, 0, 0, 0]) ) # remove nodes g.remove_nodes(range(1, 4), store_ids=True) - assert g.number_of_nodes() == 7 + assert g.num_nodes() == 7 assert F.array_equal(g.ndata["id"], F.tensor([0, 7, 8, 9, 0, 0, 0])) assert dgl.NID in g.ndata assert dgl.EID in g.edata @@ -44,25 +44,25 @@ def test_multigraph_node_removal(idtype): for i in range(5): g.add_edges(i, i) g.add_edges(i, i) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 10 + assert g.num_nodes() == 5 + assert g.num_edges() == 10 # remove nodes g.remove_nodes([2, 3]) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 6 + assert g.num_nodes() == 3 + assert g.num_edges() == 6 # add nodes g.add_nodes(1) g.add_edges(1, 1) g.add_edges(1, 1) - assert g.number_of_nodes() == 4 - assert g.number_of_edges() == 8 + assert g.num_nodes() == 4 + assert g.num_edges() == 8 # remove nodes g.remove_nodes([0]) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 6 + assert g.num_nodes() == 3 + assert g.num_edges() == 6 @parametrize_idtype @@ -73,24 +73,24 @@ def test_multigraph_edge_removal(idtype): for i in range(5): g.add_edges(i, i) g.add_edges(i, i) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 10 + assert g.num_nodes() == 5 + assert g.num_edges() == 10 # remove edges g.remove_edges([2, 3]) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 8 + assert g.num_nodes() == 5 + assert g.num_edges() == 8 # add edges g.add_edges(1, 1) g.add_edges(1, 1) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 10 + assert g.num_nodes() == 5 + assert g.num_edges() == 10 # remove edges g.remove_edges([0, 1]) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 8 + assert g.num_nodes() == 5 + assert g.num_edges() == 8 @parametrize_idtype @@ -105,8 +105,8 @@ def test_edge_removal(idtype): # remove edges g.remove_edges(range(13, 20)) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 18 + assert g.num_nodes() == 5 + assert g.num_edges() == 18 assert F.array_equal( g.edata["id"], F.tensor(list(range(13)) + list(range(20, 25))) ) @@ -115,16 +115,16 @@ def test_edge_removal(idtype): # add edges g.add_edges(3, 3) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 19 + assert g.num_nodes() == 5 + assert g.num_edges() == 19 assert F.array_equal( g.edata["id"], F.tensor(list(range(13)) + list(range(20, 25)) + [0]) ) # remove edges g.remove_edges(range(2, 10), store_ids=True) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 11 + assert g.num_nodes() == 5 + assert g.num_edges() == 11 assert F.array_equal( g.edata["id"], F.tensor([0, 1, 10, 11, 12, 20, 21, 22, 23, 24, 0]) ) @@ -140,35 +140,35 @@ def test_node_and_edge_removal(idtype): for j in range(10): g.add_edges(i, j) g.edata["id"] = F.arange(0, 100) - assert g.number_of_nodes() == 10 - assert g.number_of_edges() == 100 + assert g.num_nodes() == 10 + assert g.num_edges() == 100 # remove nodes g.remove_nodes([2, 4]) - assert g.number_of_nodes() == 8 - assert g.number_of_edges() == 64 + assert g.num_nodes() == 8 + assert g.num_edges() == 64 # remove edges g.remove_edges(range(10, 20)) - assert g.number_of_nodes() == 8 - assert g.number_of_edges() == 54 + assert g.num_nodes() == 8 + assert g.num_edges() == 54 # add nodes g.add_nodes(2) - assert g.number_of_nodes() == 10 - assert g.number_of_edges() == 54 + assert g.num_nodes() == 10 + assert g.num_edges() == 54 # add edges for i in range(8, 10): for j in range(8, 10): g.add_edges(i, j) - assert g.number_of_nodes() == 10 - assert g.number_of_edges() == 58 + assert g.num_nodes() == 10 + assert g.num_edges() == 58 # remove edges g.remove_edges(range(10, 20)) - assert g.number_of_nodes() == 10 - assert g.number_of_edges() == 48 + assert g.num_nodes() == 10 + assert g.num_edges() == 48 @parametrize_idtype @@ -209,8 +209,8 @@ def test_issue1287(idtype): g.add_nodes(5) g.add_edges([0, 2, 3, 1, 1], [1, 0, 3, 1, 0]) g.remove_nodes([0, 1]) - g.ndata["h"] = F.randn((g.number_of_nodes(), 3)) - g.edata["h"] = F.randn((g.number_of_edges(), 2)) + g.ndata["h"] = F.randn((g.num_nodes(), 3)) + g.edata["h"] = F.randn((g.num_edges(), 2)) # remove edges g = dgl.DGLGraph() @@ -219,8 +219,8 @@ def test_issue1287(idtype): g.add_edges([0, 2, 3, 1, 1], [1, 0, 3, 1, 0]) g.remove_edges([0, 1]) g = g.to(F.ctx()) - g.ndata["h"] = F.randn((g.number_of_nodes(), 3)) - g.edata["h"] = F.randn((g.number_of_edges(), 2)) + g.ndata["h"] = F.randn((g.num_nodes(), 3)) + g.edata["h"] = F.randn((g.num_edges(), 2)) if __name__ == "__main__": diff --git a/tests/python/common/test_heterograph-shared-memory.py b/tests/python/common/test_heterograph-shared-memory.py index d6a66b4e93..def0408988 100644 --- a/tests/python/common/test_heterograph-shared-memory.py +++ b/tests/python/common/test_heterograph-shared-memory.py @@ -40,7 +40,7 @@ def _assert_is_identical_hetero(g, g2): # check if node ID spaces and feature spaces are equal for ntype in g.ntypes: - assert g.number_of_nodes(ntype) == g2.number_of_nodes(ntype) + assert g.num_nodes(ntype) == g2.num_nodes(ntype) # check if edge ID spaces and feature spaces are equal for etype in g.canonical_etypes: diff --git a/tests/python/common/test_heterograph-specialization.py b/tests/python/common/test_heterograph-specialization.py index b151daa485..869458a0d7 100644 --- a/tests/python/common/test_heterograph-specialization.py +++ b/tests/python/common/test_heterograph-specialization.py @@ -319,7 +319,7 @@ def test_spmv_3d_feat(idtype): a = sp.random(n, n, p, data_rvs=lambda n: np.ones(n)) g = dgl.DGLGraph(a) g = g.astype(idtype).to(F.ctx()) - m = g.number_of_edges() + m = g.num_edges() # test#1: v2v with adj data h = F.randn((n, 5, 5)) diff --git a/tests/python/common/test_heterograph.py b/tests/python/common/test_heterograph.py index 24acab345e..8ac4120897 100644 --- a/tests/python/common/test_heterograph.py +++ b/tests/python/common/test_heterograph.py @@ -408,7 +408,7 @@ def test_query(idtype): # has_nodes for ntype in ntypes: - n = g.number_of_nodes(ntype) + n = g.num_nodes(ntype) for i in range(n): assert g.has_nodes(i, ntype) assert not g.has_nodes(n, ntype) @@ -486,9 +486,9 @@ def test_query(idtype): src_count = Counter(srcs) dst_count = Counter(dsts) utype, _, vtype = g.to_canonical_etype(etype) - for i in range(g.number_of_nodes(utype)): + for i in range(g.num_nodes(utype)): assert out_degrees[i] == src_count[i] - for i in range(g.number_of_nodes(vtype)): + for i in range(g.num_nodes(vtype)): assert in_degrees[i] == dst_count[i] edges = { @@ -612,10 +612,10 @@ def _test_hypersparse(): {"user": N1, "game": N1}, device=F.ctx(), ) - assert g.number_of_nodes("user") == N1 - assert g.number_of_nodes("game") == N1 - assert g.number_of_edges("follows") == 1 - assert g.number_of_edges("plays") == 1 + assert g.num_nodes("user") == N1 + assert g.num_nodes("game") == N1 + assert g.num_edges("follows") == 1 + assert g.num_edges("plays") == 1 assert g.has_edges_between(0, 1, "follows") assert not g.has_edges_between(0, 0, "follows") @@ -935,9 +935,9 @@ def test_view1(idtype): out_degrees = F.asnumpy(g.out_degrees()) src_count = Counter(srcs) dst_count = Counter(dsts) - for i in range(g.number_of_nodes(utype)): + for i in range(g.num_nodes(utype)): assert out_degrees[i] == src_count[i] - for i in range(g.number_of_nodes(vtype)): + for i in range(g.num_nodes(vtype)): assert in_degrees[i] == dst_count[i] edges = { @@ -971,12 +971,12 @@ def test_view1(idtype): _test_query() # test features - HG.nodes["user"].data["h"] = F.ones((HG.number_of_nodes("user"), 5)) - HG.nodes["game"].data["m"] = F.ones((HG.number_of_nodes("game"), 3)) * 2 + HG.nodes["user"].data["h"] = F.ones((HG.num_nodes("user"), 5)) + HG.nodes["game"].data["m"] = F.ones((HG.num_nodes("game"), 3)) * 2 # test only one node type g = HG["follows"] - assert g.number_of_nodes() == 3 + assert g.num_nodes() == 3 # test ndata and edata f1 = F.randn((3, 6)) @@ -1284,13 +1284,13 @@ def test_convert(idtype): hg = create_test_heterograph(idtype) hs = [] for ntype in hg.ntypes: - h = F.randn((hg.number_of_nodes(ntype), 5)) + h = F.randn((hg.num_nodes(ntype), 5)) hg.nodes[ntype].data["h"] = h hs.append(h) hg.nodes["user"].data["x"] = F.randn((3, 3)) ws = [] for etype in hg.canonical_etypes: - w = F.randn((hg.number_of_edges(etype), 5)) + w = F.randn((hg.num_edges(etype), 5)) hg.edges[etype].data["w"] = w ws.append(w) hg.edges["plays"].data["x"] = F.randn((4, 3)) @@ -1308,7 +1308,7 @@ def test_convert(idtype): dst = F.asnumpy(dst) etype_id, eid = F.asnumpy(g.edata[dgl.ETYPE]), F.asnumpy(g.edata[dgl.EID]) ntype_id, nid = F.asnumpy(g.ndata[dgl.NTYPE]), F.asnumpy(g.ndata[dgl.NID]) - for i in range(g.number_of_edges()): + for i in range(g.num_edges()): srctype = hg.ntypes[ntype_id[src[i]]] dsttype = hg.ntypes[ntype_id[dst[i]]] etype = hg.etypes[etype_id[i]] @@ -1339,7 +1339,7 @@ def test_convert(idtype): assert set(hg.ntypes) == set(hg2.ntypes) assert set(hg.canonical_etypes) == set(hg2.canonical_etypes) for ntype in hg.ntypes: - assert hg.number_of_nodes(ntype) == hg2.number_of_nodes(ntype) + assert hg.num_nodes(ntype) == hg2.num_nodes(ntype) assert F.array_equal( hg.nodes[ntype].data["h"], hg2.nodes[ntype].data["h"] ) @@ -1363,12 +1363,12 @@ def test_convert(idtype): assert set(hg.canonical_etypes) == set( [("l0", "e0", "l1"), ("l1", "e1", "l2"), ("l0", "e2", "l2")] ) - assert hg.number_of_nodes("l0") == 2 - assert hg.number_of_nodes("l1") == 1 - assert hg.number_of_nodes("l2") == 1 - assert hg.number_of_edges("e0") == 2 - assert hg.number_of_edges("e1") == 1 - assert hg.number_of_edges("e2") == 1 + assert hg.num_nodes("l0") == 2 + assert hg.num_nodes("l1") == 1 + assert hg.num_nodes("l2") == 1 + assert hg.num_edges("e0") == 2 + assert hg.num_edges("e1") == 1 + assert hg.num_edges("e2") == 1 assert F.array_equal(hg.ndata[dgl.NID]["l0"], F.tensor([0, 1], F.int64)) assert F.array_equal(hg.ndata[dgl.NID]["l1"], F.tensor([2], F.int64)) assert F.array_equal(hg.ndata[dgl.NID]["l2"], F.tensor([3], F.int64)) @@ -1398,11 +1398,11 @@ def test_convert(idtype): assert set(hg.canonical_etypes) == set( [("user", "watches", "movie"), ("user", "watches", "TV")] ) - assert hg.number_of_nodes("user") == 1 - assert hg.number_of_nodes("TV") == 1 - assert hg.number_of_nodes("movie") == 1 - assert hg.number_of_edges(("user", "watches", "TV")) == 1 - assert hg.number_of_edges(("user", "watches", "movie")) == 1 + assert hg.num_nodes("user") == 1 + assert hg.num_nodes("TV") == 1 + assert hg.num_nodes("movie") == 1 + assert hg.num_edges(("user", "watches", "TV")) == 1 + assert hg.num_edges(("user", "watches", "movie")) == 1 assert len(hg.etypes) == 2 # hetero_to_homo test case 2 @@ -1415,7 +1415,7 @@ def test_convert(idtype): g = dgl.to_homogeneous(hg) assert hg.idtype == g.idtype assert hg.device == g.device - assert g.number_of_nodes() == 5 + assert g.num_nodes() == 5 # hetero_to_subgraph_to_homo hg = dgl.heterograph( @@ -1514,13 +1514,13 @@ def test_metagraph_reachable(idtype): new_g = dgl.metapath_reachable_graph(g, ["follows", "plays"]) assert new_g.idtype == idtype assert new_g.ntypes == ["game", "user"] - assert new_g.number_of_edges() == 3 + assert new_g.num_edges() == 3 assert F.asnumpy(new_g.has_edges_between([0, 0, 1], [0, 1, 1])).all() new_g = dgl.metapath_reachable_graph(g, ["follows"]) assert new_g.idtype == idtype assert new_g.ntypes == ["user"] - assert new_g.number_of_edges() == 2 + assert new_g.num_edges() == 2 assert F.asnumpy(new_g.has_edges_between([0, 1], [1, 2])).all() @@ -1560,8 +1560,8 @@ def test_subgraph_mask(idtype): assert F.array_equal( F.tensor(sg.edges["wishes"].data[dgl.EID]), F.tensor([1], idtype) ) - assert sg.number_of_nodes("developer") == 0 - assert sg.number_of_edges("develops") == 0 + assert sg.num_nodes("developer") == 0 + assert sg.num_edges("develops") == 0 assert F.array_equal( sg.nodes["user"].data["h"], g.nodes["user"].data["h"][1:3] ) @@ -1620,8 +1620,8 @@ def test_subgraph(idtype): assert F.array_equal( F.tensor(sg.edges["wishes"].data[dgl.EID]), F.tensor([1], g.idtype) ) - assert sg.number_of_nodes("developer") == 0 - assert sg.number_of_edges("develops") == 0 + assert sg.num_nodes("developer") == 0 + assert sg.num_edges("develops") == 0 assert F.array_equal( sg.nodes["user"].data["h"], g.nodes["user"].data["h"][1:3] ) @@ -1683,7 +1683,7 @@ def test_subgraph(idtype): ) else: for ntype in sg.ntypes: - assert g.number_of_nodes(ntype) == sg.number_of_nodes(ntype) + assert g.num_nodes(ntype) == sg.num_nodes(ntype) assert F.array_equal( F.tensor(sg.edges["follows"].data[dgl.EID]), F.tensor([1], g.idtype) @@ -1713,7 +1713,7 @@ def test_subgraph(idtype): ) else: for ntype in sg.ntypes: - assert g.number_of_nodes(ntype) == sg.number_of_nodes(ntype) + assert g.num_nodes(ntype) == sg.num_nodes(ntype) assert F.array_equal( F.tensor(sg.edges["plays"].data[dgl.EID]), @@ -1739,7 +1739,7 @@ def test_subgraph(idtype): assert set(sg.ntypes) == {"user", "game"} assert set(sg.etypes) == {"follows", "plays", "wishes"} for ntype in sg.ntypes: - assert sg.number_of_nodes(ntype) == g.number_of_nodes(ntype) + assert sg.num_nodes(ntype) == g.num_nodes(ntype) for etype in sg.etypes: src_sg, dst_sg = sg.all_edges(etype=etype, order="eid") src_g, dst_g = g.all_edges(etype=etype, order="eid") @@ -1768,7 +1768,7 @@ def test_subgraph(idtype): assert set(sg.ntypes) == {"developer", "game"} assert set(sg.etypes) == {"develops"} for ntype in sg.ntypes: - assert sg.number_of_nodes(ntype) == g.number_of_nodes(ntype) + assert sg.num_nodes(ntype) == g.num_nodes(ntype) for etype in sg.etypes: src_sg, dst_sg = sg.all_edges(etype=etype, order="eid") src_g, dst_g = g.all_edges(etype=etype, order="eid") @@ -2059,9 +2059,9 @@ def test_backward(idtype): @parametrize_idtype def test_empty_heterograph(idtype): def assert_empty(g): - assert g.number_of_nodes("user") == 0 - assert g.number_of_edges("plays") == 0 - assert g.number_of_nodes("game") == 0 + assert g.num_nodes("user") == 0 + assert g.num_edges("plays") == 0 + assert g.num_nodes("game") == 0 # empty src-dst pair assert_empty(dgl.heterograph({("user", "plays", "game"): ([], [])})) @@ -2071,8 +2071,8 @@ def test_empty_heterograph(idtype): ) assert g.idtype == idtype assert g.device == F.ctx() - assert g.number_of_nodes("user") == 0 - assert g.number_of_edges("follows") == 0 + assert g.num_nodes("user") == 0 + assert g.num_edges("follows") == 0 # empty relation graph with others g = dgl.heterograph( @@ -2085,11 +2085,11 @@ def test_empty_heterograph(idtype): ) assert g.idtype == idtype assert g.device == F.ctx() - assert g.number_of_nodes("user") == 0 - assert g.number_of_edges("plays") == 0 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges("develops") == 2 - assert g.number_of_nodes("developer") == 2 + assert g.num_nodes("user") == 0 + assert g.num_edges("plays") == 0 + assert g.num_nodes("game") == 2 + assert g.num_edges("develops") == 2 + assert g.num_nodes("developer") == 2 @parametrize_idtype @@ -2179,14 +2179,14 @@ def test_stack_reduce(idtype): {"plays": (mfunc, rfunc), "wishes": (mfunc, rfunc2)}, "stack" ) assert g.nodes["game"].data["y"].shape == ( - g.number_of_nodes("game"), + g.num_nodes("game"), 2, 200, ) # only one type-wise update_all, stack still adds one dimension g.multi_update_all({"plays": (mfunc, rfunc)}, "stack") assert g.nodes["game"].data["y"].shape == ( - g.number_of_nodes("game"), + g.num_nodes("game"), 1, 200, ) @@ -2200,9 +2200,9 @@ def test_isolated_ntype(idtype): idtype=idtype, device=F.ctx(), ) - assert g.number_of_nodes("A") == 3 - assert g.number_of_nodes("B") == 4 - assert g.number_of_nodes("C") == 4 + assert g.num_nodes("A") == 3 + assert g.num_nodes("B") == 4 + assert g.num_nodes("C") == 4 g = dgl.heterograph( {("A", "AC", "C"): ([0, 1, 2], [1, 2, 3])}, @@ -2210,9 +2210,9 @@ def test_isolated_ntype(idtype): idtype=idtype, device=F.ctx(), ) - assert g.number_of_nodes("A") == 3 - assert g.number_of_nodes("B") == 4 - assert g.number_of_nodes("C") == 4 + assert g.num_nodes("A") == 3 + assert g.num_nodes("B") == 4 + assert g.num_nodes("C") == 4 G = dgl.graph( ([0, 1, 2], [4, 5, 6]), num_nodes=11, idtype=idtype, device=F.ctx() @@ -2222,9 +2222,9 @@ def test_isolated_ntype(idtype): ) G.edata[dgl.ETYPE] = F.tensor([0, 0, 0], dtype=F.int64) g = dgl.to_heterogeneous(G, ["A", "B", "C"], ["AB"]) - assert g.number_of_nodes("A") == 3 - assert g.number_of_nodes("B") == 4 - assert g.number_of_nodes("C") == 4 + assert g.num_nodes("A") == 3 + assert g.num_nodes("B") == 4 + assert g.num_nodes("C") == 4 @parametrize_idtype @@ -2346,13 +2346,13 @@ def test_bipartite(idtype): assert g1.etypes == ["AB"] assert g1.srctypes == ["A"] assert g1.dsttypes == ["B"] - assert g1.number_of_nodes("A") == 2 - assert g1.number_of_nodes("B") == 6 + assert g1.num_nodes("A") == 2 + assert g1.num_nodes("B") == 6 assert g1.number_of_src_nodes("A") == 2 assert g1.number_of_src_nodes() == 2 assert g1.number_of_dst_nodes("B") == 6 assert g1.number_of_dst_nodes() == 6 - assert g1.number_of_edges() == 3 + assert g1.num_edges() == 3 g1.srcdata["h"] = F.randn((2, 5)) assert F.array_equal(g1.srcnodes["A"].data["h"], g1.srcdata["h"]) assert F.array_equal(g1.nodes["A"].data["h"], g1.srcdata["h"]) @@ -2375,9 +2375,9 @@ def test_bipartite(idtype): assert g2.is_unibipartite assert g2.srctypes == ["A"] assert set(g2.dsttypes) == {"B", "C"} - assert g2.number_of_nodes("A") == 2 - assert g2.number_of_nodes("B") == 6 - assert g2.number_of_nodes("C") == 1 + assert g2.num_nodes("A") == 2 + assert g2.num_nodes("B") == 6 + assert g2.num_nodes("C") == 1 assert g2.number_of_src_nodes("A") == 2 assert g2.number_of_src_nodes() == 2 assert g2.number_of_dst_nodes("B") == 6 @@ -2578,8 +2578,8 @@ def test_reverse(idtype): gidx = g._graph r_gidx = gidx.reverse() - assert gidx.number_of_nodes(0) == r_gidx.number_of_nodes(0) - assert gidx.number_of_edges(0) == r_gidx.number_of_edges(0) + assert gidx.num_nodes(0) == r_gidx.num_nodes(0) + assert gidx.num_edges(0) == r_gidx.num_edges(0) g_s, g_d, _ = gidx.edges(0) rg_s, rg_d, _ = r_gidx.edges(0) assert F.array_equal(g_s, rg_d) @@ -2591,8 +2591,8 @@ def test_reverse(idtype): r_gidx = gidx.reverse() assert "csr" in gidx.formats()["created"] assert "csc" in r_gidx.formats()["created"] - assert gidx.number_of_nodes(0) == r_gidx.number_of_nodes(0) - assert gidx.number_of_edges(0) == r_gidx.number_of_edges(0) + assert gidx.num_nodes(0) == r_gidx.num_nodes(0) + assert gidx.num_edges(0) == r_gidx.num_edges(0) g_s, g_d, _ = gidx.edges(0) rg_s, rg_d, _ = r_gidx.edges(0) assert F.array_equal(g_s, rg_d) @@ -2604,8 +2604,8 @@ def test_reverse(idtype): r_gidx = gidx.reverse() assert "csc" in gidx.formats()["created"] assert "csr" in r_gidx.formats()["created"] - assert gidx.number_of_nodes(0) == r_gidx.number_of_nodes(0) - assert gidx.number_of_edges(0) == r_gidx.number_of_edges(0) + assert gidx.num_nodes(0) == r_gidx.num_nodes(0) + assert gidx.num_edges(0) == r_gidx.num_edges(0) g_s, g_d, _ = gidx.edges(0) rg_s, rg_d, _ = r_gidx.edges(0) assert F.array_equal(g_s, rg_d) @@ -2636,12 +2636,12 @@ def test_reverse(idtype): assert mg.find_edge(etype) == r_mg.find_edge(etype)[::-1] # three node types and three edge types - assert gidx.number_of_nodes(0) == r_gidx.number_of_nodes(0) - assert gidx.number_of_nodes(1) == r_gidx.number_of_nodes(1) - assert gidx.number_of_nodes(2) == r_gidx.number_of_nodes(2) - assert gidx.number_of_edges(0) == r_gidx.number_of_edges(0) - assert gidx.number_of_edges(1) == r_gidx.number_of_edges(1) - assert gidx.number_of_edges(2) == r_gidx.number_of_edges(2) + assert gidx.num_nodes(0) == r_gidx.num_nodes(0) + assert gidx.num_nodes(1) == r_gidx.num_nodes(1) + assert gidx.num_nodes(2) == r_gidx.num_nodes(2) + assert gidx.num_edges(0) == r_gidx.num_edges(0) + assert gidx.num_edges(1) == r_gidx.num_edges(1) + assert gidx.num_edges(2) == r_gidx.num_edges(2) g_s, g_d, _ = gidx.edges(0) rg_s, rg_d, _ = r_gidx.edges(0) assert F.array_equal(g_s, rg_d) @@ -2662,12 +2662,12 @@ def test_reverse(idtype): # three node types and three edge types assert "csr" in gidx.formats()["created"] assert "csc" in r_gidx.formats()["created"] - assert gidx.number_of_nodes(0) == r_gidx.number_of_nodes(0) - assert gidx.number_of_nodes(1) == r_gidx.number_of_nodes(1) - assert gidx.number_of_nodes(2) == r_gidx.number_of_nodes(2) - assert gidx.number_of_edges(0) == r_gidx.number_of_edges(0) - assert gidx.number_of_edges(1) == r_gidx.number_of_edges(1) - assert gidx.number_of_edges(2) == r_gidx.number_of_edges(2) + assert gidx.num_nodes(0) == r_gidx.num_nodes(0) + assert gidx.num_nodes(1) == r_gidx.num_nodes(1) + assert gidx.num_nodes(2) == r_gidx.num_nodes(2) + assert gidx.num_edges(0) == r_gidx.num_edges(0) + assert gidx.num_edges(1) == r_gidx.num_edges(1) + assert gidx.num_edges(2) == r_gidx.num_edges(2) g_s, g_d, _ = gidx.edges(0) rg_s, rg_d, _ = r_gidx.edges(0) assert F.array_equal(g_s, rg_d) @@ -2688,12 +2688,12 @@ def test_reverse(idtype): # three node types and three edge types assert "csc" in gidx.formats()["created"] assert "csr" in r_gidx.formats()["created"] - assert gidx.number_of_nodes(0) == r_gidx.number_of_nodes(0) - assert gidx.number_of_nodes(1) == r_gidx.number_of_nodes(1) - assert gidx.number_of_nodes(2) == r_gidx.number_of_nodes(2) - assert gidx.number_of_edges(0) == r_gidx.number_of_edges(0) - assert gidx.number_of_edges(1) == r_gidx.number_of_edges(1) - assert gidx.number_of_edges(2) == r_gidx.number_of_edges(2) + assert gidx.num_nodes(0) == r_gidx.num_nodes(0) + assert gidx.num_nodes(1) == r_gidx.num_nodes(1) + assert gidx.num_nodes(2) == r_gidx.num_nodes(2) + assert gidx.num_edges(0) == r_gidx.num_edges(0) + assert gidx.num_edges(1) == r_gidx.num_edges(1) + assert gidx.num_edges(2) == r_gidx.num_edges(2) g_s, g_d, _ = gidx.edges(0) rg_s, rg_d, _ = r_gidx.edges(0) assert F.array_equal(g_s, rg_d) @@ -2715,8 +2715,8 @@ def test_clone(idtype): g.edata["h"] = F.copy_to(F.tensor([1, 1], dtype=idtype), ctx=F.ctx()) new_g = g.clone() - assert g.number_of_nodes() == new_g.number_of_nodes() - assert g.number_of_edges() == new_g.number_of_edges() + assert g.num_nodes() == new_g.num_nodes() + assert g.num_edges() == new_g.num_edges() assert g.device == new_g.device assert g.idtype == new_g.idtype assert F.array_equal(g.ndata["h"], new_g.ndata["h"]) @@ -2728,15 +2728,15 @@ def test_clone(idtype): assert F.array_equal(g.edata["h"], new_g.edata["h"]) == False # graph structure change g.add_nodes(1) - assert g.number_of_nodes() != new_g.number_of_nodes() + assert g.num_nodes() != new_g.num_nodes() new_g.add_edges(1, 1) - assert g.number_of_edges() != new_g.number_of_edges() + assert g.num_edges() != new_g.num_edges() # zero data graph g = dgl.graph(([], []), num_nodes=0, idtype=idtype, device=F.ctx()) new_g = g.clone() - assert g.number_of_nodes() == new_g.number_of_nodes() - assert g.number_of_edges() == new_g.number_of_edges() + assert g.num_nodes() == new_g.num_nodes() + assert g.num_edges() == new_g.num_edges() # heterograph g = create_test_heterograph3(idtype) @@ -2744,11 +2744,11 @@ def test_clone(idtype): F.tensor([1, 2, 3, 4], dtype=idtype), ctx=F.ctx() ) new_g = g.clone() - assert g.number_of_nodes("user") == new_g.number_of_nodes("user") - assert g.number_of_nodes("game") == new_g.number_of_nodes("game") - assert g.number_of_nodes("developer") == new_g.number_of_nodes("developer") - assert g.number_of_edges("plays") == new_g.number_of_edges("plays") - assert g.number_of_edges("develops") == new_g.number_of_edges("develops") + assert g.num_nodes("user") == new_g.num_nodes("user") + assert g.num_nodes("game") == new_g.num_nodes("game") + assert g.num_nodes("developer") == new_g.num_nodes("developer") + assert g.num_edges("plays") == new_g.num_edges("plays") + assert g.num_edges("develops") == new_g.num_edges("develops") assert F.array_equal( g.nodes["user"].data["h"], new_g.nodes["user"].data["h"] ) @@ -2793,20 +2793,20 @@ def test_add_edges(idtype): v = 1 g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 3 + assert g.num_nodes() == 3 + assert g.num_edges() == 3 u = [0] v = [1] g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 3 + assert g.num_edges() == 4 u = F.tensor(u, dtype=idtype) v = F.tensor(v, dtype=idtype) g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 5 + assert g.num_nodes() == 3 + assert g.num_edges() == 5 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 0, 0], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 1, 1, 1], dtype=idtype)) @@ -2816,8 +2816,8 @@ def test_add_edges(idtype): u = F.tensor([0, 1], dtype=idtype) v = F.tensor([2, 3], dtype=idtype) g.add_edges(u, v) - assert g.number_of_nodes() == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -2833,8 +2833,8 @@ def test_add_edges(idtype): "hh": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx()), } g.add_edges(u, v, e_feat) - assert g.number_of_nodes() == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -2851,8 +2851,8 @@ def test_add_edges(idtype): "hh": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx()), } g.add_edges(u, v, e_feat) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 2 + assert g.num_nodes() == 3 + assert g.num_edges() == 2 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([2, 2], dtype=idtype)) @@ -2869,23 +2869,23 @@ def test_add_edges(idtype): v = 1 g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 3 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 3 u = [0] v = [1] g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 4 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 4 u = F.tensor(u, dtype=idtype) v = F.tensor(v, dtype=idtype) g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 5 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 5 u, v = g.edges(form="uv") assert F.array_equal(u, F.tensor([0, 1, 0, 0, 0], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 1, 1, 1], dtype=idtype)) @@ -2900,9 +2900,9 @@ def test_add_edges(idtype): v = F.tensor([2, 3], dtype=idtype) g.add_edges(u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -2927,9 +2927,9 @@ def test_add_edges(idtype): "hh": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx()), } g.add_edges(u, v, e_feat) - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -2947,11 +2947,11 @@ def test_add_edges(idtype): u = F.tensor([0, 2], dtype=idtype) v = F.tensor([2, 3], dtype=idtype) g.add_edges(u, v, etype="plays") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_nodes("developer") == 2 - assert g.number_of_edges("plays") == 6 - assert g.number_of_edges("develops") == 2 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_nodes("developer") == 2 + assert g.num_edges("plays") == 6 + assert g.num_edges("develops") == 2 u, v = g.edges(form="uv", order="eid", etype="plays") assert F.array_equal(u, F.tensor([0, 1, 1, 2, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 0, 1, 1, 2, 3], dtype=idtype)) @@ -2973,11 +2973,11 @@ def test_add_edges(idtype): F.tensor([2, 2, 1, 1], dtype=idtype), ctx=F.ctx() ) g.add_edges(u, v, data=e_feat, etype="develops") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_nodes("developer") == 3 - assert g.number_of_edges("plays") == 6 - assert g.number_of_edges("develops") == 4 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_nodes("developer") == 3 + assert g.num_edges("plays") == 6 + assert g.num_edges("develops") == 4 u, v = g.edges(form="uv", order="eid", etype="develops") assert F.array_equal(u, F.tensor([0, 1, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 2, 3], dtype=idtype)) @@ -2998,7 +2998,7 @@ def test_add_nodes(idtype): g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) g.ndata["h"] = F.copy_to(F.tensor([1, 1, 1], dtype=idtype), ctx=F.ctx()) g.add_nodes(1) - assert g.number_of_nodes() == 4 + assert g.num_nodes() == 4 assert F.array_equal(g.ndata["h"], F.tensor([1, 1, 1, 0], dtype=idtype)) # zero node graph @@ -3007,7 +3007,7 @@ def test_add_nodes(idtype): g.add_nodes( 1, data={"h": F.copy_to(F.tensor([2], dtype=idtype), ctx=F.ctx())} ) - assert g.number_of_nodes() == 4 + assert g.num_nodes() == 4 assert F.array_equal(g.ndata["h"], F.tensor([1, 1, 1, 2], dtype=idtype)) # bipartite graph @@ -3021,12 +3021,12 @@ def test_add_nodes(idtype): data={"h": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx())}, ntype="user", ) - assert g.number_of_nodes("user") == 4 + assert g.num_nodes("user") == 4 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([0, 0, 2, 2], dtype=idtype) ) g.add_nodes(2, ntype="game") - assert g.number_of_nodes("game") == 5 + assert g.num_nodes("game") == 5 # heterogeneous graph g = create_test_heterograph3(idtype) @@ -3037,9 +3037,9 @@ def test_add_nodes(idtype): ntype="game", ) g.add_nodes(0, ntype="developer") - assert g.number_of_nodes("user") == 4 - assert g.number_of_nodes("game") == 4 - assert g.number_of_nodes("developer") == 2 + assert g.num_nodes("user") == 4 + assert g.num_nodes("game") == 4 + assert g.num_nodes("developer") == 2 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1, 1, 0], dtype=idtype) ) @@ -3058,33 +3058,33 @@ def test_remove_edges(idtype): g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) e = 0 g.remove_edges(e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) e = [0] g.remove_edges(e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) e = F.tensor([0], dtype=idtype) g.remove_edges(e) - assert g.number_of_edges() == 0 + assert g.num_edges() == 0 # has node data g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) g.ndata["h"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g.remove_edges(1) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 assert F.array_equal(g.ndata["h"], F.tensor([1, 2, 3], dtype=idtype)) # has edge data g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) g.edata["h"] = F.copy_to(F.tensor([1, 2], dtype=idtype), ctx=F.ctx()) g.remove_edges(0) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 assert F.array_equal(g.edata["h"], F.tensor([2], dtype=idtype)) # invalid eid @@ -3103,7 +3103,7 @@ def test_remove_edges(idtype): ) e = 0 g.remove_edges(e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) @@ -3114,13 +3114,13 @@ def test_remove_edges(idtype): ) e = [0] g.remove_edges(e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) e = F.tensor([0], dtype=idtype) g.remove_edges(e) - assert g.number_of_edges() == 0 + assert g.num_edges() == 0 # has data g = dgl.heterograph( @@ -3136,7 +3136,7 @@ def test_remove_edges(idtype): ) g.edata["h"] = F.copy_to(F.tensor([1, 2], dtype=idtype), ctx=F.ctx()) g.remove_edges(1) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1], dtype=idtype) ) @@ -3151,7 +3151,7 @@ def test_remove_edges(idtype): F.tensor([1, 2, 3, 4], dtype=idtype), ctx=F.ctx() ) g.remove_edges(1, etype="plays") - assert g.number_of_edges("plays") == 3 + assert g.num_edges("plays") == 3 u, v = g.edges(form="uv", order="eid", etype="plays") assert F.array_equal(u, F.tensor([0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 1], dtype=idtype)) @@ -3160,7 +3160,7 @@ def test_remove_edges(idtype): ) # remove all edges of 'develops' g.remove_edges([0, 1], etype="develops") - assert g.number_of_edges("develops") == 0 + assert g.num_edges("develops") == 0 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1, 1], dtype=idtype) ) @@ -3178,21 +3178,21 @@ def test_remove_nodes(idtype): g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) n = 0 g.remove_nodes(n) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 1 + assert g.num_nodes() == 2 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) n = [1] g.remove_nodes(n) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 0 + assert g.num_nodes() == 2 + assert g.num_edges() == 0 g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) n = F.tensor([2], dtype=idtype) g.remove_nodes(n) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 1 + assert g.num_nodes() == 2 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) @@ -3210,8 +3210,8 @@ def test_remove_nodes(idtype): g.ndata["hv"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g.edata["he"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g.remove_nodes(F.tensor([0], dtype=idtype)) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 1 + assert g.num_nodes() == 2 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) @@ -3226,9 +3226,9 @@ def test_remove_nodes(idtype): ) n = 0 g.remove_nodes(n, ntype="user") - assert g.number_of_nodes("user") == 1 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 1 + assert g.num_nodes("user") == 1 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) @@ -3239,9 +3239,9 @@ def test_remove_nodes(idtype): ) n = [1] g.remove_nodes(n, ntype="user") - assert g.number_of_nodes("user") == 1 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 1 + assert g.num_nodes("user") == 1 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) @@ -3252,9 +3252,9 @@ def test_remove_nodes(idtype): ) n = F.tensor([0], dtype=idtype) g.remove_nodes(n, ntype="game") - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges() == 2 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 2 + assert g.num_edges() == 2 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1], dtype=idtype)) @@ -3265,11 +3265,11 @@ def test_remove_nodes(idtype): F.tensor([1, 2, 3, 4], dtype=idtype), ctx=F.ctx() ) g.remove_nodes(0, ntype="game") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 1 - assert g.number_of_nodes("developer") == 2 - assert g.number_of_edges("plays") == 2 - assert g.number_of_edges("develops") == 1 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 1 + assert g.num_nodes("developer") == 2 + assert g.num_edges("plays") == 2 + assert g.num_edges("develops") == 1 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1, 1], dtype=idtype) ) diff --git a/tests/python/common/test_readout.py b/tests/python/common/test_readout.py index 94569a7099..3f0c9581e1 100644 --- a/tests/python/common/test_readout.py +++ b/tests/python/common/test_readout.py @@ -30,8 +30,8 @@ def test_sum_case1(idtype): @pytest.mark.parametrize("reducer", ["sum", "max", "mean"]) def test_reduce_readout(g, idtype, reducer): g = g.astype(idtype).to(F.ctx()) - g.ndata["h"] = F.randn((g.number_of_nodes(), 3)) - g.edata["h"] = F.randn((g.number_of_edges(), 2)) + g.ndata["h"] = F.randn((g.num_nodes(), 3)) + g.edata["h"] = F.randn((g.num_edges(), 2)) # Test.1: node readout x = dgl.readout_nodes(g, "h", op=reducer) @@ -77,10 +77,10 @@ def test_reduce_readout(g, idtype, reducer): @pytest.mark.parametrize("reducer", ["sum", "max", "mean"]) def test_weighted_reduce_readout(g, idtype, reducer): g = g.astype(idtype).to(F.ctx()) - g.ndata["h"] = F.randn((g.number_of_nodes(), 3)) - g.ndata["w"] = F.randn((g.number_of_nodes(), 1)) - g.edata["h"] = F.randn((g.number_of_edges(), 2)) - g.edata["w"] = F.randn((g.number_of_edges(), 1)) + g.ndata["h"] = F.randn((g.num_nodes(), 3)) + g.ndata["w"] = F.randn((g.num_nodes(), 1)) + g.edata["h"] = F.randn((g.num_edges(), 2)) + g.edata["w"] = F.randn((g.num_edges(), 1)) # Test.1: node readout x = dgl.readout_nodes(g, "h", "w", op=reducer) @@ -126,7 +126,7 @@ def test_weighted_reduce_readout(g, idtype, reducer): @pytest.mark.parametrize("descending", [True, False]) def test_topk(g, idtype, descending): g = g.astype(idtype).to(F.ctx()) - g.ndata["x"] = F.randn((g.number_of_nodes(), 3)) + g.ndata["x"] = F.randn((g.num_nodes(), 3)) # Test.1: to test the case where k > number of nodes. dgl.topk_nodes(g, "x", 100, sortby=-1) @@ -158,7 +158,7 @@ def test_topk(g, idtype, descending): # Test.3: sorby=None dgl.topk_nodes(g, "x", k, sortby=None) - g.edata["x"] = F.randn((g.number_of_edges(), 3)) + g.edata["x"] = F.randn((g.num_edges(), 3)) # Test.4: topk edges where k > number of edges. dgl.topk_edges(g, "x", 100, sortby=-1) @@ -192,8 +192,8 @@ def test_topk(g, idtype, descending): @pytest.mark.parametrize("g", get_cases(["homo"], exclude=["dglgraph"])) def test_softmax(g, idtype): g = g.astype(idtype).to(F.ctx()) - g.ndata["h"] = F.randn((g.number_of_nodes(), 3)) - g.edata["h"] = F.randn((g.number_of_edges(), 2)) + g.ndata["h"] = F.randn((g.num_nodes(), 3)) + g.edata["h"] = F.randn((g.num_edges(), 2)) # Test.1: node readout x = dgl.softmax_nodes(g, "h") @@ -224,7 +224,7 @@ def test_broadcast(idtype, g): for i, sg in enumerate(subg): assert F.allclose( sg.ndata["h"], - F.repeat(F.reshape(gfeat[i], (1, 3)), sg.number_of_nodes(), dim=0), + F.repeat(F.reshape(gfeat[i], (1, 3)), sg.num_nodes(), dim=0), ) # Test.1: broadcast_edges @@ -233,5 +233,5 @@ def test_broadcast(idtype, g): for i, sg in enumerate(subg): assert F.allclose( sg.edata["h"], - F.repeat(F.reshape(gfeat[i], (1, 3)), sg.number_of_edges(), dim=0), + F.repeat(F.reshape(gfeat[i], (1, 3)), sg.num_edges(), dim=0), ) diff --git a/tests/python/common/test_subgraph.py b/tests/python/common/test_subgraph.py index 6e7b6a5aaf..99e087ec89 100644 --- a/tests/python/common/test_subgraph.py +++ b/tests/python/common/test_subgraph.py @@ -43,15 +43,15 @@ def test_edge_subgraph(): sg.ndata[dgl.NID], F.tensor([0, 2, 4, 5, 1, 9], g.idtype) ) assert F.array_equal(sg.edata[dgl.EID], F.tensor(eid, g.idtype)) - sg.ndata["h"] = F.arange(0, sg.number_of_nodes()) - sg.edata["h"] = F.arange(0, sg.number_of_edges()) + sg.ndata["h"] = F.arange(0, sg.num_nodes()) + sg.edata["h"] = F.arange(0, sg.num_edges()) # relabel=False sg = g.edge_subgraph(eid, relabel_nodes=False) - assert g.number_of_nodes() == sg.number_of_nodes() + assert g.num_nodes() == sg.num_nodes() assert F.array_equal(sg.edata[dgl.EID], F.tensor(eid, g.idtype)) - sg.ndata["h"] = F.arange(0, sg.number_of_nodes()) - sg.edata["h"] = F.arange(0, sg.number_of_edges()) + sg.ndata["h"] = F.arange(0, sg.num_nodes()) + sg.edata["h"] = F.arange(0, sg.num_edges()) def test_subgraph(): @@ -192,8 +192,8 @@ def test_subgraph_mask(idtype): assert F.array_equal( F.tensor(sg.edges["wishes"].data[dgl.EID]), F.tensor([1], idtype) ) - assert sg.number_of_nodes("developer") == 0 - assert sg.number_of_edges("develops") == 0 + assert sg.num_nodes("developer") == 0 + assert sg.num_edges("develops") == 0 assert F.array_equal( sg.nodes["user"].data["h"], g.nodes["user"].data["h"][1:3] ) @@ -250,8 +250,8 @@ def test_subgraph1(idtype): assert F.array_equal( F.tensor(sg.edges["wishes"].data[dgl.EID]), F.tensor([1], g.idtype) ) - assert sg.number_of_nodes("developer") == 0 - assert sg.number_of_edges("develops") == 0 + assert sg.num_nodes("developer") == 0 + assert sg.num_edges("develops") == 0 assert F.array_equal( sg.nodes["user"].data["h"], g.nodes["user"].data["h"][1:3] ) @@ -307,7 +307,7 @@ def test_subgraph1(idtype): ) else: for ntype in sg.ntypes: - assert g.number_of_nodes(ntype) == sg.number_of_nodes(ntype) + assert g.num_nodes(ntype) == sg.num_nodes(ntype) assert F.array_equal( F.tensor(sg.edges["follows"].data[dgl.EID]), F.tensor([1], g.idtype) @@ -337,7 +337,7 @@ def test_subgraph1(idtype): ) else: for ntype in sg.ntypes: - assert g.number_of_nodes(ntype) == sg.number_of_nodes(ntype) + assert g.num_nodes(ntype) == sg.num_nodes(ntype) assert F.array_equal( F.tensor(sg.edges["plays"].data[dgl.EID]), @@ -361,7 +361,7 @@ def test_subgraph1(idtype): assert set(sg.ntypes) == {"user", "game"} assert set(sg.etypes) == {"follows", "plays", "wishes"} for ntype in sg.ntypes: - assert sg.number_of_nodes(ntype) == g.number_of_nodes(ntype) + assert sg.num_nodes(ntype) == g.num_nodes(ntype) for etype in sg.etypes: src_sg, dst_sg = sg.all_edges(etype=etype, order="eid") src_g, dst_g = g.all_edges(etype=etype, order="eid") @@ -390,7 +390,7 @@ def test_subgraph1(idtype): assert set(sg.ntypes) == {"developer", "game"} assert set(sg.etypes) == {"develops"} for ntype in sg.ntypes: - assert sg.number_of_nodes(ntype) == g.number_of_nodes(ntype) + assert sg.num_nodes(ntype) == g.num_nodes(ntype) for etype in sg.etypes: src_sg, dst_sg = sg.all_edges(etype=etype, order="eid") src_g, dst_g = g.all_edges(etype=etype, order="eid") @@ -454,7 +454,7 @@ def test_in_subgraph(idtype): hg["liked-by"].edge_ids(u, v), subg["liked-by"].edata[dgl.EID] ) assert edge_set == {(2, 0), (2, 1), (1, 0), (0, 0)} - assert subg["flips"].number_of_edges() == 0 + assert subg["flips"].num_edges() == 0 for ntype in subg.ntypes: assert dgl.NID not in subg.nodes[ntype].data diff --git a/tests/python/common/test_traversal.py b/tests/python/common/test_traversal.py index 69824b8eed..4929e19919 100644 --- a/tests/python/common/test_traversal.py +++ b/tests/python/common/test_traversal.py @@ -73,7 +73,7 @@ def test_topological_nodes(idtype, n=100): adjmat = g.adjacency_matrix(transpose=True) def tensor_topo_traverse(): - n = g.number_of_nodes() + n = g.num_nodes() mask = F.copy_to(F.ones((n, 1)), F.cpu()) degree = F.spmm(adjmat, mask) while F.reduce_sum(mask) != 0.0: diff --git a/tests/python/common/transforms/test_functional-sort.py b/tests/python/common/transforms/test_functional-sort.py index ed12df3513..e11c611156 100644 --- a/tests/python/common/transforms/test_functional-sort.py +++ b/tests/python/common/transforms/test_functional-sort.py @@ -65,7 +65,7 @@ def check_sort(spm, tag_arr=None, tag_pos=None): def test_sort_with_tag(idtype): num_nodes, num_adj, num_tags = 200, [20, 50], 5 g = create_test_heterograph(num_nodes, num_adj, idtype=idtype) - tag = F.tensor(np.random.choice(num_tags, g.number_of_nodes())) + tag = F.tensor(np.random.choice(num_tags, g.num_nodes())) src, dst = g.edges() edge_tag_dst = F.gather_row(tag, F.tensor(dst)) edge_tag_src = F.gather_row(tag, F.tensor(src)) @@ -99,8 +99,8 @@ def test_sort_with_tag_bipartite(idtype): num_nodes, num_adj, num_tags = 200, [20, 50], 5 g = create_test_heterograph(num_nodes, num_adj, idtype=idtype) g = dgl.heterograph({("_U", "_E", "_V"): g.edges()}) - utag = F.tensor(np.random.choice(num_tags, g.number_of_nodes("_U"))) - vtag = F.tensor(np.random.choice(num_tags, g.number_of_nodes("_V"))) + utag = F.tensor(np.random.choice(num_tags, g.num_nodes("_U"))) + vtag = F.tensor(np.random.choice(num_tags, g.num_nodes("_V"))) new_g = dgl.sort_csr_by_tag(g, vtag) old_csr = g.adjacency_matrix(scipy_fmt="csr") diff --git a/tests/python/common/transforms/test_to_block.py b/tests/python/common/transforms/test_to_block.py index 1e59186188..d37b067499 100644 --- a/tests/python/common/transforms/test_to_block.py +++ b/tests/python/common/transforms/test_to_block.py @@ -26,7 +26,7 @@ def test_to_block(idtype): def check(g, bg, ntype, etype, dst_nodes, include_dst_in_src=True): if dst_nodes is not None: assert F.array_equal(bg.dstnodes[ntype].data[dgl.NID], dst_nodes) - n_dst_nodes = bg.number_of_nodes("DST/" + ntype) + n_dst_nodes = bg.num_nodes("DST/" + ntype) if include_dst_in_src: assert F.array_equal( bg.srcnodes[ntype].data[dgl.NID][:n_dst_nodes], @@ -136,21 +136,21 @@ def test_to_block(idtype): bg = dgl.to_block(g_ab) assert bg.idtype == idtype - assert bg.number_of_nodes("SRC/B") == 4 + assert bg.num_nodes("SRC/B") == 4 assert F.array_equal( bg.srcnodes["B"].data[dgl.NID], bg.dstnodes["B"].data[dgl.NID] ) - assert bg.number_of_nodes("DST/A") == 0 + assert bg.num_nodes("DST/A") == 0 checkall(g_ab, bg, None) check_features(g_ab, bg) dst_nodes = {"B": F.tensor([5, 6, 3, 1], dtype=idtype)} bg = dgl.to_block(g, dst_nodes) - assert bg.number_of_nodes("SRC/B") == 4 + assert bg.num_nodes("SRC/B") == 4 assert F.array_equal( bg.srcnodes["B"].data[dgl.NID], bg.dstnodes["B"].data[dgl.NID] ) - assert bg.number_of_nodes("DST/A") == 0 + assert bg.num_nodes("DST/A") == 0 checkall(g, bg, dst_nodes) check_features(g, bg) diff --git a/tests/python/common/transforms/test_transform.py b/tests/python/common/transforms/test_transform.py index c5e41f4c3a..7958b2a418 100644 --- a/tests/python/common/transforms/test_transform.py +++ b/tests/python/common/transforms/test_transform.py @@ -132,7 +132,7 @@ def test_line_graph1(): G = dgl.DGLGraph(nx.star_graph(N)).to(F.ctx()) G.edata["h"] = F.randn((2 * N, D)) L = G.line_graph(shared=True) - assert L.number_of_nodes() == 2 * N + assert L.num_nodes() == 2 * N assert F.allclose(L.ndata["h"], G.edata["h"]) assert G.device == F.ctx() @@ -144,15 +144,15 @@ def test_line_graph2(idtype): idtype=idtype, ) lg = dgl.line_graph(g) - assert lg.number_of_nodes() == 5 - assert lg.number_of_edges() == 8 + assert lg.num_nodes() == 5 + assert lg.num_edges() == 8 row, col = lg.edges() assert np.array_equal(F.asnumpy(row), np.array([0, 0, 1, 2, 2, 3, 4, 4])) assert np.array_equal(F.asnumpy(col), np.array([3, 4, 0, 3, 4, 0, 1, 2])) lg = dgl.line_graph(g, backtracking=False) - assert lg.number_of_nodes() == 5 - assert lg.number_of_edges() == 4 + assert lg.num_nodes() == 5 + assert lg.num_edges() == 4 row, col = lg.edges() assert np.array_equal(F.asnumpy(row), np.array([0, 1, 2, 4])) assert np.array_equal(F.asnumpy(col), np.array([4, 0, 3, 1])) @@ -161,8 +161,8 @@ def test_line_graph2(idtype): idtype=idtype, ).formats("csr") lg = dgl.line_graph(g) - assert lg.number_of_nodes() == 5 - assert lg.number_of_edges() == 8 + assert lg.num_nodes() == 5 + assert lg.num_edges() == 8 row, col = lg.edges() assert np.array_equal(F.asnumpy(row), np.array([0, 0, 1, 2, 2, 3, 4, 4])) assert np.array_equal(F.asnumpy(col), np.array([3, 4, 0, 3, 4, 0, 1, 2])) @@ -172,8 +172,8 @@ def test_line_graph2(idtype): idtype=idtype, ).formats("csc") lg = dgl.line_graph(g) - assert lg.number_of_nodes() == 5 - assert lg.number_of_edges() == 8 + assert lg.num_nodes() == 5 + assert lg.num_edges() == 8 row, col, eid = lg.edges("all") row = F.asnumpy(row) col = F.asnumpy(col) @@ -187,7 +187,7 @@ def test_no_backtracking(): N = 5 G = dgl.DGLGraph(nx.star_graph(N)) L = G.line_graph(backtracking=False) - assert L.number_of_nodes() == 2 * N + assert L.num_nodes() == 2 * N for i in range(1, N): e1 = G.edge_ids(0, i) e2 = G.edge_ids(i, 0) @@ -209,8 +209,8 @@ def test_reverse(idtype): assert g.is_multigraph == rg.is_multigraph - assert g.number_of_nodes() == rg.number_of_nodes() - assert g.number_of_edges() == rg.number_of_edges() + assert g.num_nodes() == rg.num_nodes() + assert g.num_edges() == rg.num_edges() assert F.allclose( F.astype(rg.has_edges_between([1, 2, 1], [0, 1, 2]), F.float32), F.ones((3,)), @@ -225,8 +225,8 @@ def test_reverse(idtype): g.ndata["h"] = F.tensor([[0.0], [1.0], [2.0]]) g.edata["h"] = F.tensor([[3.0], [4.0], [5.0]]) g_r = dgl.reverse(g) - assert g.number_of_nodes() == g_r.number_of_nodes() - assert g.number_of_edges() == g_r.number_of_edges() + assert g.num_nodes() == g_r.num_nodes() + assert g.num_edges() == g_r.num_edges() u_g, v_g, eids_g = g.all_edges(form="all") u_rg, v_rg, eids_rg = g_r.all_edges(form="all") assert F.array_equal(u_g, v_rg) @@ -237,15 +237,15 @@ def test_reverse(idtype): # without share ndata g_r = dgl.reverse(g, copy_ndata=False) - assert g.number_of_nodes() == g_r.number_of_nodes() - assert g.number_of_edges() == g_r.number_of_edges() + assert g.num_nodes() == g_r.num_nodes() + assert g.num_edges() == g_r.num_edges() assert len(g_r.ndata) == 0 assert len(g_r.edata) == 0 # with share ndata and edata g_r = dgl.reverse(g, copy_ndata=True, copy_edata=True) - assert g.number_of_nodes() == g_r.number_of_nodes() - assert g.number_of_edges() == g_r.number_of_edges() + assert g.num_nodes() == g_r.num_nodes() + assert g.num_edges() == g_r.num_edges() assert F.array_equal(g.ndata["h"], g_r.ndata["h"]) assert F.array_equal(g.edata["h"], g_r.edata["h"]) @@ -286,9 +286,9 @@ def test_reverse(idtype): assert etype_g[0] == etype_gr[2] assert etype_g[1] == etype_gr[1] assert etype_g[2] == etype_gr[0] - assert g.number_of_edges(etype_g) == g_r.number_of_edges(etype_gr) + assert g.num_edges(etype_g) == g_r.num_edges(etype_gr) for ntype in g.ntypes: - assert g.number_of_nodes(ntype) == g_r.number_of_nodes(ntype) + assert g.num_nodes(ntype) == g_r.num_nodes(ntype) assert F.array_equal(g.nodes["user"].data["h"], g_r.nodes["user"].data["h"]) assert F.array_equal( g.nodes["user"].data["hh"], g_r.nodes["user"].data["hh"] @@ -327,9 +327,9 @@ def test_reverse(idtype): assert etype_g[0] == etype_gr[2] assert etype_g[1] == etype_gr[1] assert etype_g[2] == etype_gr[0] - assert g.number_of_edges(etype_g) == g_r.number_of_edges(etype_gr) + assert g.num_edges(etype_g) == g_r.num_edges(etype_gr) for ntype in g.ntypes: - assert g.number_of_nodes(ntype) == g_r.number_of_nodes(ntype) + assert g.num_nodes(ntype) == g_r.num_nodes(ntype) assert len(g_r.nodes["user"].data) == 0 assert len(g_r.nodes["game"].data) == 0 @@ -339,7 +339,7 @@ def test_reverse(idtype): assert etype_g[0] == etype_gr[2] assert etype_g[1] == etype_gr[1] assert etype_g[2] == etype_gr[0] - assert g.number_of_edges(etype_g) == g_r.number_of_edges(etype_gr) + assert g.num_edges(etype_g) == g_r.num_edges(etype_gr) assert F.array_equal( g.edges["follows"].data["h"], g_r.edges["follows"].data["h"] ) @@ -384,7 +384,7 @@ def test_to_bidirected(): elist.append((1, 2)) elist = set(elist) big = dgl.to_bidirected(g) - assert big.number_of_edges() == num_edges + assert big.num_edges() == num_edges src, dst = big.edges() eset = set(zip(list(F.asnumpy(src)), list(F.asnumpy(dst)))) assert eset == set(elist) @@ -404,8 +404,8 @@ def test_to_bidirected(): elist2.append((1, 0)) elist2 = set(elist2) big = dgl.to_bidirected(g) - assert big.number_of_edges("wins") == 7 - assert big.number_of_edges("follows") == 3 + assert big.num_edges("wins") == 7 + assert big.num_edges("follows") == 3 src, dst = big.edges(etype="wins") eset = set(zip(list(F.asnumpy(src)), list(F.asnumpy(dst)))) assert eset == set(elist1) @@ -528,7 +528,7 @@ def test_add_reverse_edges(): g.ndata["h"] = F.tensor([[0.0], [1.0], [2.0], [1.0], [1.0], [1.0]]) g.edata["h"] = F.tensor([[3.0], [4.0], [5.0], [6.0]]) bg = dgl.add_reverse_edges(g, copy_ndata=True, copy_edata=True) - assert g.number_of_nodes() == bg.number_of_nodes() + assert g.num_nodes() == bg.num_nodes() assert F.array_equal(g.ndata["h"], bg.ndata["h"]) assert F.array_equal( F.cat([g.edata["h"], g.edata["h"]], dim=0), bg.edata["h"] @@ -558,8 +558,8 @@ def test_add_reverse_edges(): bg = dgl.add_reverse_edges( g, copy_ndata=True, copy_edata=True, ignore_bipartite=True ) - assert g.number_of_nodes("user") == bg.number_of_nodes("user") - assert g.number_of_nodes("game") == bg.number_of_nodes("game") + assert g.num_nodes("user") == bg.num_nodes("user") + assert g.num_nodes("game") == bg.num_nodes("game") assert F.array_equal( g.nodes["game"].data["hv"], bg.nodes["game"].data["hv"] ) @@ -592,7 +592,7 @@ def test_simple_graph(): assert g.is_multigraph sg = dgl.to_simple_graph(g) assert not sg.is_multigraph - assert sg.number_of_edges() == 3 + assert sg.num_edges() == 3 src, dst = sg.edges() eset = set(zip(list(F.asnumpy(src)), list(F.asnumpy(dst)))) assert eset == set(elist) @@ -607,7 +607,7 @@ def _test_bidirected_graph(): elist.append((1, 2)) elist = set(elist) big = dgl.to_bidirected_stale(g, out_readonly) - assert big.number_of_edges() == num_edges + assert big.num_edges() == num_edges src, dst = big.edges() eset = set(zip(list(F.asnumpy(src)), list(F.asnumpy(dst)))) assert eset == set(elist) @@ -697,7 +697,7 @@ def create_large_graph(num_nodes, idtype=F.int64): @unittest.skipIf(F._default_context_str == "gpu", reason="GPU not implemented") def test_partition_with_halo(): g = create_large_graph(1000) - node_part = np.random.choice(4, g.number_of_nodes()) + node_part = np.random.choice(4, g.num_nodes()) subgs, _, _ = dgl.transforms.partition_graph_with_halo( g, node_part, 2, reshuffle=True ) @@ -739,9 +739,9 @@ def test_metis_partition(idtype): def check_metis_partition_with_constraint(g): - ntypes = np.zeros((g.number_of_nodes(),), dtype=np.int32) - ntypes[0 : int(g.number_of_nodes() / 4)] = 1 - ntypes[int(g.number_of_nodes() * 3 / 4) :] = 2 + ntypes = np.zeros((g.num_nodes(),), dtype=np.int32) + ntypes[0 : int(g.num_nodes() / 4)] = 1 + ntypes[int(g.num_nodes() * 3 / 4) :] = 2 subgs = dgl.transforms.metis_partition( g, 4, extra_cached_hops=1, balance_ntypes=ntypes ) @@ -779,8 +779,8 @@ def check_metis_partition(g, extra_hops): assert np.sum(F.asnumpy(subg.ndata["part_id"]) == part_id) == len( lnode_ids ) - assert num_inner_nodes == g.number_of_nodes() - print(g.number_of_edges() - num_inner_edges) + assert num_inner_nodes == g.num_nodes() + print(g.num_edges() - num_inner_edges) if extra_hops == 0: return @@ -791,7 +791,7 @@ def check_metis_partition(g, extra_hops): ) num_inner_nodes = 0 num_inner_edges = 0 - edge_cnts = np.zeros((g.number_of_edges(),)) + edge_cnts = np.zeros((g.num_edges(),)) if subgs is not None: for part_id, subg in subgs.items(): lnode_ids = np.nonzero(F.asnumpy(subg.ndata["inner_node"]))[0] @@ -816,7 +816,7 @@ def check_metis_partition(g, extra_hops): orig_ids = subg.ndata["orig_id"] inner_node = F.asnumpy(subg.ndata["inner_node"]) - for nid in range(subg.number_of_nodes()): + for nid in range(subg.num_nodes()): neighs = subg.predecessors(nid) old_neighs1 = F.gather_row(orig_ids, neighs) old_nid = F.asnumpy(orig_ids[nid]) @@ -830,8 +830,8 @@ def check_metis_partition(g, extra_hops): # Normally, local edges are only counted once. assert np.all(edge_cnts == 1) - assert num_inner_nodes == g.number_of_nodes() - print(g.number_of_edges() - num_inner_edges) + assert num_inner_nodes == g.num_nodes() + print(g.num_edges() - num_inner_edges) @unittest.skipIf( @@ -839,7 +839,7 @@ def check_metis_partition(g, extra_hops): ) def test_reorder_nodes(): g = create_large_graph(1000) - new_nids = np.random.permutation(g.number_of_nodes()) + new_nids = np.random.permutation(g.num_nodes()) # TODO(zhengda) we need to test both CSR and COO. new_g = dgl.partition.reorder_nodes(g, new_nids) new_in_deg = new_g.in_degrees() @@ -851,14 +851,14 @@ def test_reorder_nodes(): assert np.all(F.asnumpy(new_in_deg == new_in_deg1)) assert np.all(F.asnumpy(new_out_deg == new_out_deg1)) orig_ids = F.asnumpy(new_g.ndata["orig_id"]) - for nid in range(g.number_of_nodes()): + for nid in range(g.num_nodes()): neighs = F.asnumpy(g.successors(nid)) new_neighs1 = new_nids[neighs] new_nid = new_nids[nid] new_neighs2 = new_g.successors(new_nid) assert np.all(np.sort(new_neighs1) == np.sort(F.asnumpy(new_neighs2))) - for nid in range(new_g.number_of_nodes()): + for nid in range(new_g.num_nodes()): neighs = F.asnumpy(new_g.successors(nid)) old_neighs1 = orig_ids[neighs] old_nid = orig_ids[nid] @@ -1110,7 +1110,7 @@ def test_to_simple(idtype): sg = dgl.to_simple(g, writeback_mapping=False, copy_ndata=False) for ntype in g.ntypes: - assert g.number_of_nodes(ntype) == sg.number_of_nodes(ntype) + assert g.num_nodes(ntype) == sg.num_nodes(ntype) assert "h" not in sg.nodes["user"].data assert "hh" not in sg.nodes["user"].data @@ -1211,20 +1211,20 @@ def test_add_edges(idtype): v = 1 g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 3 + assert g.num_nodes() == 3 + assert g.num_edges() == 3 u = [0] v = [1] g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 3 + assert g.num_edges() == 4 u = F.tensor(u, dtype=idtype) v = F.tensor(v, dtype=idtype) g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 5 + assert g.num_nodes() == 3 + assert g.num_edges() == 5 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 0, 0], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 1, 1, 1], dtype=idtype)) @@ -1232,8 +1232,8 @@ def test_add_edges(idtype): g = dgl.add_edges(g, 0, []) g = dgl.add_edges(g, [], 0) assert g.device == F.ctx() - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 5 + assert g.num_nodes() == 3 + assert g.num_edges() == 5 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 0, 0], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 1, 1, 1], dtype=idtype)) @@ -1243,8 +1243,8 @@ def test_add_edges(idtype): u = F.tensor([0, 1], dtype=idtype) v = F.tensor([2, 3], dtype=idtype) g = dgl.add_edges(g, u, v) - assert g.number_of_nodes() == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -1260,8 +1260,8 @@ def test_add_edges(idtype): "hh": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx()), } g = dgl.add_edges(g, u, v, e_feat) - assert g.number_of_nodes() == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes() == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -1278,8 +1278,8 @@ def test_add_edges(idtype): "hh": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx()), } g = dgl.add_edges(g, u, v, e_feat) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 2 + assert g.num_nodes() == 3 + assert g.num_edges() == 2 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([2, 2], dtype=idtype)) @@ -1296,23 +1296,23 @@ def test_add_edges(idtype): v = 1 g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 3 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 3 u = [0] v = [1] g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 4 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 4 u = F.tensor(u, dtype=idtype) v = F.tensor(v, dtype=idtype) g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 5 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 5 u, v = g.edges(form="uv") assert F.array_equal(u, F.tensor([0, 1, 0, 0, 0], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 1, 1, 1], dtype=idtype)) @@ -1327,9 +1327,9 @@ def test_add_edges(idtype): v = F.tensor([2, 3], dtype=idtype) g = dgl.add_edges(g, u, v) assert g.device == F.ctx() - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -1354,9 +1354,9 @@ def test_add_edges(idtype): "hh": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx()), } g = dgl.add_edges(g, u, v, e_feat) - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_edges() == 4 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_edges() == 4 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([1, 2, 2, 3], dtype=idtype)) @@ -1374,11 +1374,11 @@ def test_add_edges(idtype): u = F.tensor([0, 2], dtype=idtype) v = F.tensor([2, 3], dtype=idtype) g = dgl.add_edges(g, u, v, etype="plays") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_nodes("developer") == 2 - assert g.number_of_edges("plays") == 6 - assert g.number_of_edges("develops") == 2 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_nodes("developer") == 2 + assert g.num_edges("plays") == 6 + assert g.num_edges("develops") == 2 u, v = g.edges(form="uv", order="eid", etype="plays") assert F.array_equal(u, F.tensor([0, 1, 1, 2, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 0, 1, 1, 2, 3], dtype=idtype)) @@ -1400,11 +1400,11 @@ def test_add_edges(idtype): F.tensor([2, 2, 1, 1], dtype=idtype), ctx=F.ctx() ) g = dgl.add_edges(g, u, v, data=e_feat, etype="develops") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 4 - assert g.number_of_nodes("developer") == 3 - assert g.number_of_edges("plays") == 6 - assert g.number_of_edges("develops") == 4 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 4 + assert g.num_nodes("developer") == 3 + assert g.num_edges("plays") == 6 + assert g.num_edges("develops") == 4 u, v = g.edges(form="uv", order="eid", etype="develops") assert F.array_equal(u, F.tensor([0, 1, 0, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 2, 3], dtype=idtype)) @@ -1425,8 +1425,8 @@ def test_add_nodes(idtype): g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) g.ndata["h"] = F.copy_to(F.tensor([1, 1, 1], dtype=idtype), ctx=F.ctx()) new_g = dgl.add_nodes(g, 1) - assert g.number_of_nodes() == 3 - assert new_g.number_of_nodes() == 4 + assert g.num_nodes() == 3 + assert new_g.num_nodes() == 4 assert F.array_equal(new_g.ndata["h"], F.tensor([1, 1, 1, 0], dtype=idtype)) # zero node graph @@ -1435,7 +1435,7 @@ def test_add_nodes(idtype): g = dgl.add_nodes( g, 1, data={"h": F.copy_to(F.tensor([2], dtype=idtype), ctx=F.ctx())} ) - assert g.number_of_nodes() == 4 + assert g.num_nodes() == 4 assert F.array_equal(g.ndata["h"], F.tensor([1, 1, 1, 2], dtype=idtype)) # bipartite graph @@ -1450,14 +1450,14 @@ def test_add_nodes(idtype): data={"h": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx())}, ntype="user", ) - assert g.number_of_nodes("user") == 4 - assert g.number_of_nodes("game") == 3 + assert g.num_nodes("user") == 4 + assert g.num_nodes("game") == 3 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([0, 0, 2, 2], dtype=idtype) ) g = dgl.add_nodes(g, 2, ntype="game") - assert g.number_of_nodes("user") == 4 - assert g.number_of_nodes("game") == 5 + assert g.num_nodes("user") == 4 + assert g.num_nodes("game") == 5 # heterogeneous graph g = create_test_heterograph3(idtype) @@ -1468,9 +1468,9 @@ def test_add_nodes(idtype): data={"h": F.copy_to(F.tensor([2, 2], dtype=idtype), ctx=F.ctx())}, ntype="game", ) - assert g.number_of_nodes("user") == 4 - assert g.number_of_nodes("game") == 4 - assert g.number_of_nodes("developer") == 2 + assert g.num_nodes("user") == 4 + assert g.num_nodes("game") == 4 + assert g.num_nodes("developer") == 2 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1, 1, 0], dtype=idtype) ) @@ -1485,33 +1485,33 @@ def test_remove_edges(idtype): g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) e = 0 g = dgl.remove_edges(g, e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) e = [0] g = dgl.remove_edges(g, e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) e = F.tensor([0], dtype=idtype) g = dgl.remove_edges(g, e) - assert g.number_of_edges() == 0 + assert g.num_edges() == 0 # has node data g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) g.ndata["h"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g = dgl.remove_edges(g, 1) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 assert F.array_equal(g.ndata["h"], F.tensor([1, 2, 3], dtype=idtype)) # has edge data g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) g.edata["h"] = F.copy_to(F.tensor([1, 2], dtype=idtype), ctx=F.ctx()) g = dgl.remove_edges(g, 0) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 assert F.array_equal(g.edata["h"], F.tensor([2], dtype=idtype)) # invalid eid @@ -1530,7 +1530,7 @@ def test_remove_edges(idtype): ) e = 0 g = dgl.remove_edges(g, e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) @@ -1541,13 +1541,13 @@ def test_remove_edges(idtype): ) e = [0] g = dgl.remove_edges(g, e) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) e = F.tensor([0], dtype=idtype) g = dgl.remove_edges(g, e) - assert g.number_of_edges() == 0 + assert g.num_edges() == 0 # has data g = dgl.heterograph( @@ -1563,7 +1563,7 @@ def test_remove_edges(idtype): ) g.edata["h"] = F.copy_to(F.tensor([1, 2], dtype=idtype), ctx=F.ctx()) g = dgl.remove_edges(g, 1) - assert g.number_of_edges() == 1 + assert g.num_edges() == 1 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1], dtype=idtype) ) @@ -1578,7 +1578,7 @@ def test_remove_edges(idtype): F.tensor([1, 2, 3, 4], dtype=idtype), ctx=F.ctx() ) g = dgl.remove_edges(g, 1, etype="plays") - assert g.number_of_edges("plays") == 3 + assert g.num_edges("plays") == 3 u, v = g.edges(form="uv", order="eid", etype="plays") assert F.array_equal(u, F.tensor([0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 1], dtype=idtype)) @@ -1587,7 +1587,7 @@ def test_remove_edges(idtype): ) # remove all edges of 'develops' g = dgl.remove_edges(g, [0, 1], etype="develops") - assert g.number_of_edges("develops") == 0 + assert g.num_edges("develops") == 0 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1, 1], dtype=idtype) ) @@ -1729,21 +1729,21 @@ def test_remove_nodes(idtype): g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) n = 0 g = dgl.remove_nodes(g, n) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 1 + assert g.num_nodes() == 2 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) n = [1] g = dgl.remove_nodes(g, n) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 0 + assert g.num_nodes() == 2 + assert g.num_edges() == 0 g = dgl.graph(([0, 1], [1, 2]), idtype=idtype, device=F.ctx()) n = F.tensor([2], dtype=idtype) g = dgl.remove_nodes(g, n) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 1 + assert g.num_nodes() == 2 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) @@ -1761,8 +1761,8 @@ def test_remove_nodes(idtype): g.ndata["hv"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g.edata["he"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g = dgl.remove_nodes(g, F.tensor([0], dtype=idtype)) - assert g.number_of_nodes() == 2 - assert g.number_of_edges() == 1 + assert g.num_nodes() == 2 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([1], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) @@ -1777,9 +1777,9 @@ def test_remove_nodes(idtype): ) n = 0 g = dgl.remove_nodes(g, n, ntype="user") - assert g.number_of_nodes("user") == 1 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 1 + assert g.num_nodes("user") == 1 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([2], dtype=idtype)) @@ -1790,9 +1790,9 @@ def test_remove_nodes(idtype): ) n = [1] g = dgl.remove_nodes(g, n, ntype="user") - assert g.number_of_nodes("user") == 1 - assert g.number_of_nodes("game") == 3 - assert g.number_of_edges() == 1 + assert g.num_nodes("user") == 1 + assert g.num_nodes("game") == 3 + assert g.num_edges() == 1 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0], dtype=idtype)) assert F.array_equal(v, F.tensor([1], dtype=idtype)) @@ -1803,9 +1803,9 @@ def test_remove_nodes(idtype): ) n = F.tensor([0], dtype=idtype) g = dgl.remove_nodes(g, n, ntype="game") - assert g.number_of_nodes("user") == 2 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges() == 2 + assert g.num_nodes("user") == 2 + assert g.num_nodes("game") == 2 + assert g.num_edges() == 2 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 1], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1], dtype=idtype)) @@ -1816,11 +1816,11 @@ def test_remove_nodes(idtype): F.tensor([1, 2, 3, 4], dtype=idtype), ctx=F.ctx() ) g = dgl.remove_nodes(g, 0, ntype="game") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 1 - assert g.number_of_nodes("developer") == 2 - assert g.number_of_edges("plays") == 2 - assert g.number_of_edges("develops") == 1 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 1 + assert g.num_nodes("developer") == 2 + assert g.num_edges("plays") == 2 + assert g.num_edges("develops") == 1 assert F.array_equal( g.nodes["user"].data["h"], F.tensor([1, 1, 1], dtype=idtype) ) @@ -2006,8 +2006,8 @@ def test_add_selfloop(idtype): ) g.ndata["hn"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g = dgl.add_self_loop(g) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 6 + assert g.num_nodes() == 3 + assert g.num_edges() == 6 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 0, 2, 0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([2, 1, 0, 0, 1, 2], dtype=idtype)) @@ -2036,8 +2036,8 @@ def test_add_selfloop(idtype): ) g.ndata["hn"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g = dgl.add_self_loop(g, fill_data=1) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 6 + assert g.num_nodes() == 3 + assert g.num_edges() == 6 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 0, 2, 0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([2, 1, 0, 0, 1, 2], dtype=idtype)) @@ -2059,8 +2059,8 @@ def test_add_selfloop(idtype): ) g.ndata["hn"] = F.copy_to(F.tensor([1, 2, 3], dtype=idtype), ctx=F.ctx()) g = dgl.add_self_loop(g, fill_data="sum") - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 6 + assert g.num_nodes() == 3 + assert g.num_edges() == 6 u, v = g.edges(form="uv", order="eid") assert F.array_equal(u, F.tensor([0, 0, 2, 0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([2, 1, 0, 0, 1, 2], dtype=idtype)) @@ -2101,10 +2101,10 @@ def test_add_selfloop(idtype): F.tensor([[0.0, 1.0], [1.0, 2.0]]), ctx=F.ctx() ) g = dgl.add_self_loop(g, etype="follows") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges("follows") == 5 - assert g.number_of_edges("plays") == 2 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 2 + assert g.num_edges("follows") == 5 + assert g.num_edges("plays") == 2 u, v = g.edges(form="uv", order="eid", etype="follows") assert F.array_equal(u, F.tensor([1, 2, 0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 0, 1, 2], dtype=idtype)) @@ -2125,10 +2125,10 @@ def test_add_selfloop(idtype): F.tensor([[0, 1], [1, 2]], dtype=idtype), ctx=F.ctx() ) g = dgl.add_self_loop(g, fill_data=1, etype="follows") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges("follows") == 5 - assert g.number_of_edges("plays") == 2 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 2 + assert g.num_edges("follows") == 5 + assert g.num_edges("plays") == 2 u, v = g.edges(form="uv", order="eid", etype="follows") assert F.array_equal(u, F.tensor([1, 2, 0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 0, 1, 2], dtype=idtype)) @@ -2170,10 +2170,10 @@ def test_add_selfloop(idtype): ) g.edges["plays"].data["h"] = F.copy_to(F.tensor([1.0, 2.0]), ctx=F.ctx()) g = dgl.add_self_loop(g, fill_data="mean", etype="follows") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges("follows") == 5 - assert g.number_of_edges("plays") == 2 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 2 + assert g.num_edges("follows") == 5 + assert g.num_edges("plays") == 2 u, v = g.edges(form="uv", order="eid", etype="follows") assert F.array_equal(u, F.tensor([1, 2, 0, 1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1, 0, 1, 2], dtype=idtype)) @@ -2200,8 +2200,8 @@ def test_remove_selfloop(idtype): g = dgl.graph(([0, 0, 0, 1], [1, 0, 0, 2]), idtype=idtype, device=F.ctx()) g.edata["he"] = F.copy_to(F.tensor([1, 2, 3, 4], dtype=idtype), ctx=F.ctx()) g = dgl.remove_self_loop(g) - assert g.number_of_nodes() == 3 - assert g.number_of_edges() == 2 + assert g.num_nodes() == 3 + assert g.num_edges() == 2 assert F.array_equal(g.edata["he"], F.tensor([1, 4], dtype=idtype)) # bipartite graph @@ -2220,10 +2220,10 @@ def test_remove_selfloop(idtype): g = create_test_heterograph4(idtype) g = dgl.remove_self_loop(g, etype="follows") - assert g.number_of_nodes("user") == 3 - assert g.number_of_nodes("game") == 2 - assert g.number_of_edges("follows") == 2 - assert g.number_of_edges("plays") == 2 + assert g.num_nodes("user") == 3 + assert g.num_nodes("game") == 2 + assert g.num_edges("follows") == 2 + assert g.num_edges("plays") == 2 u, v = g.edges(form="uv", order="eid", etype="follows") assert F.array_equal(u, F.tensor([1, 2], dtype=idtype)) assert F.array_equal(v, F.tensor([0, 1], dtype=idtype)) @@ -2250,8 +2250,8 @@ def test_remove_selfloop(idtype): g.set_batch_num_nodes(F.tensor([3, 2], dtype=F.int64)) g.set_batch_num_edges(F.tensor([4, 3], dtype=F.int64)) g = dgl.remove_self_loop(g) - assert g.number_of_nodes() == 5 - assert g.number_of_edges() == 3 + assert g.num_nodes() == 5 + assert g.num_edges() == 3 assert F.array_equal(g.batch_num_nodes(), F.tensor([3, 2], dtype=F.int64)) assert F.array_equal(g.batch_num_edges(), F.tensor([2, 1], dtype=F.int64)) diff --git a/tests/python/mxnet/test_nn.py b/tests/python/mxnet/test_nn.py index bc791dde70..9d8dd1826b 100644 --- a/tests/python/mxnet/test_nn.py +++ b/tests/python/mxnet/test_nn.py @@ -198,7 +198,7 @@ def test_gat_conv(g, idtype, out_dim, num_heads): h = gat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) # test residual connection gat = nn.GATConv(10, out_dim, num_heads, residual=True) @@ -222,7 +222,7 @@ def test_gat_conv_bi(g, idtype, out_dim, num_heads): h = gat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -291,7 +291,7 @@ def test_gg_conv(): # test#1: basic h0 = F.randn((20, 10)) - etypes = nd.random.randint(0, 4, g.number_of_edges()).as_in_context(ctx) + etypes = nd.random.randint(0, 4, g.num_edges()).as_in_context(ctx) h1 = gg_conv(g, h0, etypes) assert h1.shape == (20, 20) @@ -421,7 +421,7 @@ def test_dense_sage_conv(idtype, g, out_dim): F.randn((g.number_of_dst_nodes(), 5)), ) else: - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) out_sage = sage(g, feat) out_dense_sage = dense_sage(adj, feat) @@ -508,7 +508,7 @@ def test_gmm_conv(g, idtype): gmm_conv = nn.GMMConv(5, 2, 5, 3, "max") gmm_conv.initialize(ctx=ctx) h0 = F.randn((g.number_of_src_nodes(), 5)) - pseudo = F.randn((g.number_of_edges(), 5)) + pseudo = F.randn((g.num_edges(), 5)) h1 = gmm_conv(g, h0, pseudo) assert h1.shape == (g.number_of_dst_nodes(), 2) @@ -523,7 +523,7 @@ def test_gmm_conv_bi(g, idtype): # test #1: basic h0 = F.randn((g.number_of_src_nodes(), 5)) hd = F.randn((g.number_of_dst_nodes(), 4)) - pseudo = F.randn((g.number_of_edges(), 5)) + pseudo = F.randn((g.num_edges(), 5)) h1 = gmm_conv(g, (h0, hd), pseudo) assert h1.shape == (g.number_of_dst_nodes(), 2) @@ -537,7 +537,7 @@ def test_nn_conv(g, idtype): nn_conv.initialize(ctx=ctx) # test #1: basic h0 = F.randn((g.number_of_src_nodes(), 5)) - etypes = nd.random.randint(0, 4, g.number_of_edges()).as_in_context(ctx) + etypes = nd.random.randint(0, 4, g.num_edges()).as_in_context(ctx) h1 = nn_conv(g, h0, etypes) assert h1.shape == (g.number_of_dst_nodes(), 2) @@ -552,7 +552,7 @@ def test_nn_conv_bi(g, idtype): # test #1: basic h0 = F.randn((g.number_of_src_nodes(), 5)) hd = F.randn((g.number_of_dst_nodes(), 4)) - etypes = nd.random.randint(0, 4, g.number_of_edges()).as_in_context(ctx) + etypes = nd.random.randint(0, 4, g.num_edges()).as_in_context(ctx) h1 = nn_conv(g, (h0, hd), etypes) assert h1.shape == (g.number_of_dst_nodes(), 2) @@ -568,9 +568,9 @@ def test_sg_conv(out_dim): print(sgc) # test #1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = sgc(g, h0) - assert h1.shape == (g.number_of_nodes(), out_dim) + assert h1.shape == (g.num_nodes(), out_dim) def test_set2set(): @@ -582,13 +582,13 @@ def test_set2set(): print(s2s) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = s2s(g, h0) assert h1.shape[0] == 1 and h1.shape[1] == 10 and h1.ndim == 2 # test#2: batched graph bg = dgl.batch([g, g, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = s2s(bg, h0) assert h1.shape[0] == 3 and h1.shape[1] == 10 and h1.ndim == 2 @@ -601,13 +601,13 @@ def test_glob_att_pool(): gap.initialize(ctx=ctx) print(gap) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = gap(g, h0) assert h1.shape[0] == 1 and h1.shape[1] == 10 and h1.ndim == 2 # test#2: batched graph bg = dgl.batch([g, g, g, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = gap(bg, h0) assert h1.shape[0] == 4 and h1.shape[1] == 10 and h1.ndim == 2 @@ -622,7 +622,7 @@ def test_simple_pool(): print(sum_pool, avg_pool, max_pool, sort_pool) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = sum_pool(g, h0) check_close(F.squeeze(h1, 0), F.sum(h0, 0)) h1 = avg_pool(g, h0) @@ -635,7 +635,7 @@ def test_simple_pool(): # test#2: batched graph g_ = dgl.from_networkx(nx.path_graph(5)).to(F.ctx()) bg = dgl.batch([g, g_, g, g_, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = sum_pool(bg, h0) truth = mx.nd.stack( F.sum(h0[:15], 0), @@ -680,7 +680,7 @@ def test_rgcn(O): g = dgl.from_scipy(sp.sparse.random(100, 100, density=0.1)).to(F.ctx()) # 5 etypes R = 5 - for i in range(g.number_of_edges()): + for i in range(g.num_edges()): etype.append(i % 5) B = 2 I = 10 @@ -701,7 +701,7 @@ def test_rgcn(O): assert list(h_new.shape) == [100, O] # with norm - norm = nd.zeros((g.number_of_edges(), 1), ctx=ctx) + norm = nd.zeros((g.num_edges(), 1), ctx=ctx) rgc_basis = nn.RelGraphConv(I, O, R, "basis", B) rgc_basis.initialize(ctx=ctx) @@ -768,7 +768,7 @@ def test_sequential(): graph.ndata["h"] = n_feat graph.update_all(fn.copy_u("h", "m"), fn.sum("m", "h")) n_feat += graph.ndata["h"] - return n_feat.reshape(graph.number_of_nodes() // 2, 2, -1).sum(1) + return n_feat.reshape(graph.num_nodes() // 2, 2, -1).sum(1) g1 = dgl.from_networkx(nx.erdos_renyi_graph(32, 0.05)).to(F.ctx()) g2 = dgl.from_networkx(nx.erdos_renyi_graph(16, 0.2)).to(F.ctx()) diff --git a/tests/python/pytorch/distributed/optim/test_dist_optim.py b/tests/python/pytorch/distributed/optim/test_dist_optim.py index ea5b518944..b5bff5bbf1 100644 --- a/tests/python/pytorch/distributed/optim/test_dist_optim.py +++ b/tests/python/pytorch/distributed/optim/test_dist_optim.py @@ -96,7 +96,7 @@ def run_client(graph_name, cli_id, part_id, server_count): ) g = DistGraph(graph_name, gpb=gpb) policy = dgl.distributed.PartitionPolicy("node", g.get_partition_book()) - num_nodes = g.number_of_nodes() + num_nodes = g.num_nodes() emb_dim = 4 dgl_emb = DistEmbedding( num_nodes, diff --git a/tests/python/pytorch/nn/test_nn.py b/tests/python/pytorch/nn/test_nn.py index 0f9bdd0e62..cf3953de87 100644 --- a/tests/python/pytorch/nn/test_nn.py +++ b/tests/python/pytorch/nn/test_nn.py @@ -267,7 +267,7 @@ def test_set2set(): print(s2s) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = s2s(g, h0) assert h1.shape[0] == 1 and h1.shape[1] == 10 and h1.dim() == 2 @@ -275,7 +275,7 @@ def test_set2set(): g1 = dgl.DGLGraph(nx.path_graph(11)).to(F.ctx()) g2 = dgl.DGLGraph(nx.path_graph(5)).to(F.ctx()) bg = dgl.batch([g, g1, g2]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = s2s(bg, h0) assert h1.shape[0] == 3 and h1.shape[1] == 10 and h1.dim() == 2 @@ -293,13 +293,13 @@ def test_glob_att_pool(): th.save(gap, tmp_buffer) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = gap(g, h0) assert h1.shape[0] == 1 and h1.shape[1] == 10 and h1.dim() == 2 # test#2: batched graph bg = dgl.batch([g, g, g, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = gap(bg, h0) assert h1.shape[0] == 4 and h1.shape[1] == 10 and h1.dim() == 2 @@ -316,7 +316,7 @@ def test_simple_pool(): print(sum_pool, avg_pool, max_pool, sort_pool) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) sum_pool = sum_pool.to(ctx) avg_pool = avg_pool.to(ctx) max_pool = max_pool.to(ctx) @@ -333,7 +333,7 @@ def test_simple_pool(): # test#2: batched graph g_ = dgl.DGLGraph(nx.path_graph(5)).to(F.ctx()) bg = dgl.batch([g, g_, g, g_, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = sum_pool(bg, h0) truth = th.stack( [ @@ -390,7 +390,7 @@ def test_set_trans(): print(st_enc_0, st_enc_1, st_dec) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 50)) + h0 = F.randn((g.num_nodes(), 50)) h1 = st_enc_0(g, h0) assert h1.shape == h0.shape h1 = st_enc_1(g, h0) @@ -402,7 +402,7 @@ def test_set_trans(): g1 = dgl.DGLGraph(nx.path_graph(5)) g2 = dgl.DGLGraph(nx.path_graph(10)) bg = dgl.batch([g, g1, g2]) - h0 = F.randn((bg.number_of_nodes(), 50)) + h0 = F.randn((bg.num_nodes(), 50)) h1 = st_enc_0(bg, h0) assert h1.shape == h0.shape h1 = st_enc_1(bg, h0) @@ -421,14 +421,14 @@ def test_rgcn(idtype, O): g = g.astype(idtype).to(F.ctx()) # 5 etypes R = 5 - for i in range(g.number_of_edges()): + for i in range(g.num_edges()): etype.append(i % 5) B = 2 I = 10 h = th.randn((100, I)).to(ctx) r = th.tensor(etype).to(ctx) - norm = th.rand((g.number_of_edges(), 1)).to(ctx) + norm = th.rand((g.num_edges(), 1)).to(ctx) sorted_r, idx = th.sort(r) sorted_g = dgl.reorder_graph( g, @@ -482,13 +482,13 @@ def test_rgcn_default_nbasis(idtype, O): g = g.astype(idtype).to(F.ctx()) # 5 etypes R = 5 - for i in range(g.number_of_edges()): + for i in range(g.num_edges()): etype.append(i % 5) I = 10 h = th.randn((100, I)).to(ctx) r = th.tensor(etype).to(ctx) - norm = th.rand((g.number_of_edges(), 1)).to(ctx) + norm = th.rand((g.num_edges(), 1)).to(ctx) sorted_r, idx = th.sort(r) sorted_g = dgl.reorder_graph( g, @@ -552,7 +552,7 @@ def test_gat_conv(g, idtype, out_dim, num_heads): assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) # test residual connection gat = nn.GATConv(5, out_dim, num_heads, residual=True) @@ -576,7 +576,7 @@ def test_gat_conv_bi(g, idtype, out_dim, num_heads): h = gat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -598,7 +598,7 @@ def test_gatv2_conv(g, idtype, out_dim, num_heads): assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) # test residual connection gat = nn.GATConv(5, out_dim, num_heads, residual=True) @@ -622,7 +622,7 @@ def test_gatv2_conv_bi(g, idtype, out_dim, num_heads): h = gat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -640,17 +640,17 @@ def test_egat_conv(g, idtype, out_node_feats, out_edge_feats, num_heads): out_edge_feats=out_edge_feats, num_heads=num_heads, ) - nfeat = F.randn((g.number_of_nodes(), 10)) - efeat = F.randn((g.number_of_edges(), 5)) + nfeat = F.randn((g.num_nodes(), 10)) + efeat = F.randn((g.num_edges(), 5)) egat = egat.to(ctx) h, f = egat(g, nfeat, efeat) th.save(egat, tmp_buffer) - assert h.shape == (g.number_of_nodes(), num_heads, out_node_feats) - assert f.shape == (g.number_of_edges(), num_heads, out_edge_feats) + assert h.shape == (g.num_nodes(), num_heads, out_node_feats) + assert f.shape == (g.num_edges(), num_heads, out_edge_feats) _, _, attn = egat(g, nfeat, efeat, True) - assert attn.shape == (g.number_of_edges(), num_heads, 1) + assert attn.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -672,16 +672,16 @@ def test_egat_conv_bi(g, idtype, out_node_feats, out_edge_feats, num_heads): F.randn((g.number_of_src_nodes(), 10)), F.randn((g.number_of_dst_nodes(), 15)), ) - efeat = F.randn((g.number_of_edges(), 7)) + efeat = F.randn((g.num_edges(), 7)) egat = egat.to(ctx) h, f = egat(g, nfeat, efeat) th.save(egat, tmp_buffer) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_node_feats) - assert f.shape == (g.number_of_edges(), num_heads, out_edge_feats) + assert f.shape == (g.num_edges(), num_heads, out_edge_feats) _, _, attn = egat(g, nfeat, efeat, True) - assert attn.shape == (g.number_of_edges(), num_heads, 1) + assert attn.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -751,7 +751,7 @@ def test_sgc_conv(g, idtype, out_dim): # test pickle th.save(sgc, tmp_buffer) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) sgc = sgc.to(ctx) h = sgc(g, feat) @@ -772,7 +772,7 @@ def test_appnp_conv(g, idtype): ctx = F.ctx() g = g.astype(idtype).to(ctx) appnp = nn.APPNPConv(10, 0.1) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) appnp = appnp.to(ctx) # test pickle @@ -788,7 +788,7 @@ def test_appnp_conv_e_weight(g, idtype): ctx = F.ctx() g = g.astype(idtype).to(ctx) appnp = nn.APPNPConv(10, 0.1) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) eweight = F.ones((g.num_edges(),)) appnp = appnp.to(ctx) @@ -805,7 +805,7 @@ def test_gcn2conv_e_weight(g, idtype, bias): gcn2conv = nn.GCN2Conv( 5, layer=2, alpha=0.5, bias=bias, project_initial_features=True ) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) eweight = F.ones((g.num_edges(),)) gcn2conv = gcn2conv.to(ctx) res = feat @@ -819,7 +819,7 @@ def test_sgconv_e_weight(g, idtype): ctx = F.ctx() g = g.astype(idtype).to(ctx) sgconv = nn.SGConv(5, 5, 3) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) eweight = F.ones((g.num_edges(),)) sgconv = sgconv.to(ctx) h = sgconv(g, feat, edge_weight=eweight) @@ -833,7 +833,7 @@ def test_tagconv_e_weight(g, idtype): g = g.astype(idtype).to(ctx) conv = nn.TAGConv(5, 5, bias=True) conv = conv.to(ctx) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) eweight = F.ones((g.num_edges(),)) conv = conv.to(ctx) h = conv(g, feat, edge_weight=eweight) @@ -938,8 +938,8 @@ def test_gated_graph_conv(g, idtype): ctx = F.ctx() g = g.astype(idtype).to(ctx) ggconv = nn.GatedGraphConv(5, 10, 5, 3) - etypes = th.arange(g.number_of_edges()) % 3 - feat = F.randn((g.number_of_nodes(), 5)) + etypes = th.arange(g.num_edges()) % 3 + feat = F.randn((g.num_nodes(), 5)) ggconv = ggconv.to(ctx) etypes = etypes.to(ctx) @@ -954,8 +954,8 @@ def test_gated_graph_conv_one_etype(g, idtype): ctx = F.ctx() g = g.astype(idtype).to(ctx) ggconv = nn.GatedGraphConv(5, 10, 5, 1) - etypes = th.zeros(g.number_of_edges()) - feat = F.randn((g.number_of_nodes(), 5)) + etypes = th.zeros(g.num_edges()) + feat = F.randn((g.num_nodes(), 5)) ggconv = ggconv.to(ctx) etypes = etypes.to(ctx) @@ -976,7 +976,7 @@ def test_nn_conv(g, idtype): edge_func = th.nn.Linear(4, 5 * 10) nnconv = nn.NNConv(5, 10, edge_func, "mean") feat = F.randn((g.number_of_src_nodes(), 5)) - efeat = F.randn((g.number_of_edges(), 4)) + efeat = F.randn((g.num_edges(), 4)) nnconv = nnconv.to(ctx) h = nnconv(g, feat, efeat) # currently we only do shape check @@ -992,7 +992,7 @@ def test_nn_conv_bi(g, idtype): nnconv = nn.NNConv((5, 2), 10, edge_func, "mean") feat = F.randn((g.number_of_src_nodes(), 5)) feat_dst = F.randn((g.number_of_dst_nodes(), 2)) - efeat = F.randn((g.number_of_edges(), 4)) + efeat = F.randn((g.num_edges(), 4)) nnconv = nnconv.to(ctx) h = nnconv(g, (feat, feat_dst), efeat) # currently we only do shape check @@ -1005,8 +1005,8 @@ def test_gmm_conv(g, idtype): g = g.astype(idtype).to(F.ctx()) ctx = F.ctx() gmmconv = nn.GMMConv(5, 10, 3, 4, "mean") - feat = F.randn((g.number_of_nodes(), 5)) - pseudo = F.randn((g.number_of_edges(), 3)) + feat = F.randn((g.num_nodes(), 5)) + pseudo = F.randn((g.num_edges(), 3)) gmmconv = gmmconv.to(ctx) h = gmmconv(g, feat, pseudo) # currently we only do shape check @@ -1023,7 +1023,7 @@ def test_gmm_conv_bi(g, idtype): gmmconv = nn.GMMConv((5, 2), 10, 3, 4, "mean") feat = F.randn((g.number_of_src_nodes(), 5)) feat_dst = F.randn((g.number_of_dst_nodes(), 2)) - pseudo = F.randn((g.number_of_edges(), 3)) + pseudo = F.randn((g.num_edges(), 3)) gmmconv = gmmconv.to(ctx) h = gmmconv(g, (feat, feat_dst), pseudo) # currently we only do shape check @@ -1070,7 +1070,7 @@ def test_dense_sage_conv(g, idtype, out_dim): F.randn((g.number_of_dst_nodes(), 5)), ) else: - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) sage = sage.to(ctx) dense_sage = dense_sage.to(ctx) out_sage = sage(g, feat) @@ -1130,7 +1130,7 @@ def test_dotgat_conv(g, idtype, out_dim, num_heads): h = dotgat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = dotgat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -1149,7 +1149,7 @@ def test_dotgat_conv_bi(g, idtype, out_dim, num_heads): h = dotgat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = dotgat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) @pytest.mark.parametrize("out_dim", [1, 2]) @@ -1216,7 +1216,7 @@ def test_sequential(): graph.ndata["h"] = n_feat graph.update_all(fn.copy_u("h", "m"), fn.sum("m", "h")) n_feat += graph.ndata["h"] - return n_feat.view(graph.number_of_nodes() // 2, 2, -1).sum(1) + return n_feat.view(graph.num_nodes() // 2, 2, -1).sum(1) g1 = dgl.DGLGraph(nx.erdos_renyi_graph(32, 0.05)).to(F.ctx()) g2 = dgl.DGLGraph(nx.erdos_renyi_graph(16, 0.2)).to(F.ctx()) @@ -1243,8 +1243,8 @@ def test_atomic_conv(g, idtype): if F.gpu_ctx(): aconv = aconv.to(ctx) - feat = F.randn((g.number_of_nodes(), 1)) - dist = F.randn((g.number_of_edges(), 1)) + feat = F.randn((g.num_nodes(), 1)) + dist = F.randn((g.num_edges(), 1)) h = aconv(g, feat, dist) @@ -1268,7 +1268,7 @@ def test_cf_conv(g, idtype, out_dim): cfconv = cfconv.to(ctx) src_feats = F.randn((g.number_of_src_nodes(), 2)) - edge_feats = F.randn((g.number_of_edges(), 3)) + edge_feats = F.randn((g.num_edges(), 3)) h = cfconv(g, src_feats, edge_feats) # current we only do shape check assert h.shape[-1] == out_dim diff --git a/tests/python/tensorflow/test_nn.py b/tests/python/tensorflow/test_nn.py index abf9e01084..0cfd35ecbc 100644 --- a/tests/python/tensorflow/test_nn.py +++ b/tests/python/tensorflow/test_nn.py @@ -141,7 +141,7 @@ def test_simple_pool(): print(sum_pool, avg_pool, max_pool, sort_pool) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = sum_pool(g, h0) assert F.allclose(F.squeeze(h1, 0), F.sum(h0, 0)) h1 = avg_pool(g, h0) @@ -154,7 +154,7 @@ def test_simple_pool(): # test#2: batched graph g_ = dgl.DGLGraph(nx.path_graph(5)).to(F.ctx()) bg = dgl.batch([g, g_, g, g_, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = sum_pool(bg, h0) truth = tf.stack( [ @@ -205,13 +205,13 @@ def test_glob_att_pool(): print(gap) # test#1: basic - h0 = F.randn((g.number_of_nodes(), 5)) + h0 = F.randn((g.num_nodes(), 5)) h1 = gap(g, h0) assert h1.shape[0] == 1 and h1.shape[1] == 10 and h1.ndim == 2 # test#2: batched graph bg = dgl.batch([g, g, g, g]) - h0 = F.randn((bg.number_of_nodes(), 5)) + h0 = F.randn((bg.num_nodes(), 5)) h1 = gap(bg, h0) assert h1.shape[0] == 4 and h1.shape[1] == 10 and h1.ndim == 2 @@ -224,7 +224,7 @@ def test_rgcn(O): ) # 5 etypes R = 5 - for i in range(g.number_of_edges()): + for i in range(g.num_edges()): etype.append(i % 5) B = 2 I = 10 @@ -256,7 +256,7 @@ def test_rgcn(O): assert F.allclose(h_new, h_new_low) # with norm - norm = tf.zeros((g.number_of_edges(), 1)) + norm = tf.zeros((g.num_edges(), 1)) rgc_basis = nn.RelGraphConv(I, O, R, "basis", B) rgc_basis_low = nn.RelGraphConv(I, O, R, "basis", B, low_mem=True) @@ -313,7 +313,7 @@ def test_gat_conv(g, idtype, out_dim, num_heads): h = gat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) # test residual connection gat = nn.GATConv(5, out_dim, num_heads, residual=True) @@ -335,7 +335,7 @@ def test_gat_conv_bi(g, idtype, out_dim, num_heads): h = gat(g, feat) assert h.shape == (g.number_of_dst_nodes(), num_heads, out_dim) _, a = gat(g, feat, get_attention=True) - assert a.shape == (g.number_of_edges(), num_heads, 1) + assert a.shape == (g.num_edges(), num_heads, 1) @parametrize_idtype @@ -397,7 +397,7 @@ def test_sgc_conv(g, idtype, out_dim): g = g.astype(idtype).to(ctx) # not cached sgc = nn.SGConv(5, out_dim, 3) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) h = sgc(g, feat) assert h.shape[-1] == out_dim @@ -416,7 +416,7 @@ def test_appnp_conv(g, idtype): ctx = F.ctx() g = g.astype(idtype).to(ctx) appnp = nn.APPNPConv(10, 0.1) - feat = F.randn((g.number_of_nodes(), 5)) + feat = F.randn((g.num_nodes(), 5)) h = appnp(g, feat) assert h.shape[-1] == 5 diff --git a/tests/tools/test_parmetis.py b/tests/tools/test_parmetis.py index a0c0a2cfee..6f96dd60d1 100644 --- a/tests/tools/test_parmetis.py +++ b/tests/tools/test_parmetis.py @@ -119,10 +119,10 @@ def test_parmetis_postprocessing(): num_chunks = 2 g = create_chunked_dataset(root_dir, num_chunks) - num_nodes = g.number_of_nodes() - num_institutions = g.number_of_nodes("institution") - num_authors = g.number_of_nodes("author") - num_papers = g.number_of_nodes("paper") + num_nodes = g.num_nodes() + num_institutions = g.num_nodes("institution") + num_authors = g.num_nodes("author") + num_papers = g.num_nodes("paper") # Generate random parmetis partition ids for the nodes in the graph. # Replace this code with actual ParMETIS executable when it is ready @@ -192,9 +192,9 @@ def test_parmetis_wrapper(): all_ntypes = g.ntypes all_etypes = g.etypes num_constraints = len(all_ntypes) + 3 - num_institutions = g.number_of_nodes("institution") - num_authors = g.number_of_nodes("author") - num_papers = g.number_of_nodes("paper") + num_institutions = g.num_nodes("institution") + num_authors = g.num_nodes("author") + num_papers = g.num_nodes("paper") # Trigger ParMETIS. schema_file = os.path.join(root_dir, "chunked-data/metadata.json") @@ -211,8 +211,8 @@ def test_parmetis_wrapper(): f.write("127.0.0.1\n") f.write("127.0.0.1\n") - num_nodes = g.number_of_nodes() - num_edges = g.number_of_edges() + num_nodes = g.num_nodes() + num_edges = g.num_edges() stats_file = f"{graph_name}_stats.txt" with open(stats_file, "w") as f: f.write(f"{num_nodes} {num_edges} {num_constraints}") diff --git a/tests/utils/checks.py b/tests/utils/checks.py index 787db9a17d..c5d62bbfa8 100644 --- a/tests/utils/checks.py +++ b/tests/utils/checks.py @@ -21,7 +21,7 @@ def check_fail(fn, *args, **kwargs): def assert_is_identical(g, g2): - assert g.number_of_nodes() == g2.number_of_nodes() + assert g.num_nodes() == g2.num_nodes() src, dst = g.all_edges(order="eid") src2, dst2 = g2.all_edges(order="eid") assert F.array_equal(src, src2) @@ -45,7 +45,7 @@ def assert_is_identical_hetero(g, g2, ignore_internal_data=False): # check if node ID spaces and feature spaces are equal for ntype in g.ntypes: - assert g.number_of_nodes(ntype) == g2.number_of_nodes(ntype) + assert g.num_nodes(ntype) == g2.num_nodes(ntype) if ignore_internal_data: for k in list(g.nodes[ntype].data.keys()): if is_internal_column(k): @@ -91,10 +91,10 @@ def check_graph_equal(g1, g2, *, check_idtype=True, check_feature=True): assert g2.metagraph().edges(keys=True)[edges] == features for nty in g1.ntypes: - assert g1.number_of_nodes(nty) == g2.number_of_nodes(nty) + assert g1.num_nodes(nty) == g2.num_nodes(nty) assert F.allclose(g1.batch_num_nodes(nty), g2.batch_num_nodes(nty)) for ety in g1.canonical_etypes: - assert g1.number_of_edges(ety) == g2.number_of_edges(ety) + assert g1.num_edges(ety) == g2.num_edges(ety) assert F.allclose(g1.batch_num_edges(ety), g2.batch_num_edges(ety)) src1, dst1, eid1 = g1.edges(etype=ety, form="all") src2, dst2, eid2 = g2.edges(etype=ety, form="all") @@ -109,14 +109,14 @@ def check_graph_equal(g1, g2, *, check_idtype=True, check_feature=True): if check_feature: for nty in g1.ntypes: - if g1.number_of_nodes(nty) == 0: + if g1.num_nodes(nty) == 0: continue for feat_name in g1.nodes[nty].data.keys(): assert F.allclose( g1.nodes[nty].data[feat_name], g2.nodes[nty].data[feat_name] ) for ety in g1.canonical_etypes: - if g1.number_of_edges(ety) == 0: + if g1.num_edges(ety) == 0: continue for feat_name in g2.edges[ety].data.keys(): assert F.allclose( diff --git a/tests/utils/graph_cases.py b/tests/utils/graph_cases.py index a1a94c3727..01c613a77c 100644 --- a/tests/utils/graph_cases.py +++ b/tests/utils/graph_cases.py @@ -75,8 +75,8 @@ def graph1(): ), device=F.cpu(), ) - g.ndata["h"] = F.copy_to(F.randn((g.number_of_nodes(), 2)), F.cpu()) - g.edata["w"] = F.copy_to(F.randn((g.number_of_edges(), 3)), F.cpu()) + g.ndata["h"] = F.copy_to(F.randn((g.num_nodes(), 2)), F.cpu()) + g.edata["w"] = F.copy_to(F.randn((g.num_edges(), 3)), F.cpu()) return g @@ -89,10 +89,8 @@ def graph1(): ), device=F.cpu(), ) - g.ndata["h"] = F.copy_to(F.randn((g.number_of_nodes(), 2)), F.cpu()) - g.edata["scalar_w"] = F.copy_to( - F.abs(F.randn((g.number_of_edges(),))), F.cpu() - ) + g.ndata["h"] = F.copy_to(F.randn((g.num_nodes(), 2)), F.cpu()) + g.edata["scalar_w"] = F.copy_to(F.abs(F.randn((g.num_edges(),))), F.cpu()) return g @@ -129,19 +127,19 @@ def heterograph0(): device=F.cpu(), ) g.nodes["user"].data["h"] = F.copy_to( - F.randn((g.number_of_nodes("user"), 3)), F.cpu() + F.randn((g.num_nodes("user"), 3)), F.cpu() ) g.nodes["game"].data["h"] = F.copy_to( - F.randn((g.number_of_nodes("game"), 2)), F.cpu() + F.randn((g.num_nodes("game"), 2)), F.cpu() ) g.nodes["developer"].data["h"] = F.copy_to( - F.randn((g.number_of_nodes("developer"), 3)), F.cpu() + F.randn((g.num_nodes("developer"), 3)), F.cpu() ) g.edges["plays"].data["h"] = F.copy_to( - F.randn((g.number_of_edges("plays"), 1)), F.cpu() + F.randn((g.num_edges("plays"), 1)), F.cpu() ) g.edges["develops"].data["h"] = F.copy_to( - F.randn((g.number_of_edges("develops"), 5)), F.cpu() + F.randn((g.num_edges("develops"), 5)), F.cpu() ) return g