[Doc/Feature] Refactor, doc update and behavior fix for graphs (#1983)

* Update graph

* Fix for dgl.graph

* from_scipy

* Replace canonical_etypes with relations

* from_networkx

* Update for hetero_from_relations

* Roll back the change of canonical_etypes to relations

* heterograph

* bipartite

* Update doc

* Fix lint

* Fix lint

* Fix test cases

* Fix

* Fix

* Fix

* Fix

* Fix

* Fix

* Update

* Fix test

* Fix

* Update

* Use DGLError

* Update

* Update

* Update

* Update

* Fix

* Fix

* Fix

* Fix

* Fix

* Fix

* Fix

* Fix

* Update

* Fix

* Update

* Fix

* Fix

* Fix

* Update

* Fix

* Update

* Fix

* Update

* Update

* Update

* Update

* Update

* Update

* Update

* Fix

* Fix

* Update

* Update

* Update

* Update

* Update

* Update

* rewrite sanity checks

* delete unnecessary checks

* Update

* Update

* Update

* Update

* Update

* Update

* Update

* Update

* Fix

* Update

* Update

* Update

* Fix

* Fix

* Fix

* Update

* Fix

* Update

* Fix

* Fix

* Update

* Fix

* Update

* Fix
Co-authored-by: xiang song(charlie.song) <classicxsong@gmail.com>
Co-authored-by: Minjie Wang <wmjlyjemaine@gmail.com>
Co-authored-by: Quan Gan <coin2028@hotmail.com>

tests/compute/test_pickle.py

@@ -141,19 +141,18 @@ def test_pickling_graph(g, idtype):
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU not implemented")
 def test_pickling_batched_heterograph():
     # copied from test_heterograph.create_test_heterograph()
-    plays_spmat = ssp.coo_matrix(([1, 1, 1, 1], ([0, 1, 2, 1], [0, 0, 1, 1])))
-    wishes_nx = nx.DiGraph()
-    wishes_nx.add_nodes_from(['u0', 'u1', 'u2'], bipartite=0)
-    wishes_nx.add_nodes_from(['g0', 'g1'], bipartite=1)
-    wishes_nx.add_edge('u0', 'g1', id=0)
-    wishes_nx.add_edge('u2', 'g0', id=1)
-
-    follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows')
-    plays_g = dgl.bipartite(plays_spmat, 'user', 'plays', 'game')
-    wishes_g = dgl.bipartite(wishes_nx, 'user', 'wishes', 'game')
-    develops_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game')
-    g = dgl.hetero_from_relations([follows_g, plays_g, wishes_g, develops_g])
-    g2 = dgl.hetero_from_relations([follows_g, plays_g, wishes_g, develops_g])
+    g = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1], [1, 2]),
+        ('user', 'plays', 'game'): ([0, 1, 2, 1], [0, 0, 1, 1]),
+        ('user', 'wishes', 'game'): ([0, 2], [1, 0]),
+        ('developer', 'develops', 'game'): ([0, 1], [0, 1])
+    })
+    g2 = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1], [1, 2]),
+        ('user', 'plays', 'game'): ([0, 1, 2, 1], [0, 0, 1, 1]),
+        ('user', 'wishes', 'game'): ([0, 2], [1, 0]),
+        ('developer', 'develops', 'game'): ([0, 1], [0, 1])
+    })
 
     g.nodes['user'].data['u_h'] = F.randn((3, 4))
     g.nodes['game'].data['g_h'] = F.randn((2, 5))
@@ -166,28 +165,6 @@ def test_pickling_batched_heterograph():
     new_bg = _reconstruct_pickle(bg)
     test_utils.check_graph_equal(bg, new_bg)
 
-@unittest.skipIf(F._default_context_str == 'gpu', reason="GPU not implemented")
-@unittest.skipIf(dgl.backend.backend_name != "pytorch", reason="Only test for pytorch format file")
-def test_pickling_heterograph_index_compatibility():
-    plays_spmat = ssp.coo_matrix(([1, 1, 1, 1], ([0, 1, 2, 1], [0, 0, 1, 1])))
-    wishes_nx = nx.DiGraph()
-    wishes_nx.add_nodes_from(['u0', 'u1', 'u2'], bipartite=0)
-    wishes_nx.add_nodes_from(['g0', 'g1'], bipartite=1)
-    wishes_nx.add_edge('u0', 'g1', id=0)
-    wishes_nx.add_edge('u2', 'g0', id=1)
-
-    follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows')
-    plays_g = dgl.bipartite(plays_spmat, 'user', 'plays', 'game')
-    wishes_g = dgl.bipartite(wishes_nx, 'user', 'wishes', 'game')
-    develops_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game')
-    g = dgl.hetero_from_relations([follows_g, plays_g, wishes_g, develops_g])
-
-    with open("tests/compute/hetero_pickle_old.pkl", "rb") as f:
-        gi = pickle.load(f)
-        f.close()
-    new_g = dgl.DGLHeteroGraph(gi, g.ntypes, g.etypes)
-    _assert_is_identical_hetero(g, new_g)
-
 if __name__ == '__main__':
     test_pickling_index()
     test_pickling_graph_index()

tests/compute/test_propagate.py

@@ -5,6 +5,10 @@ import unittest
 import utils as U
 from utils import parametrize_dtype
 
+def create_graph(idtype):
+    g = dgl.from_networkx(nx.path_graph(5), idtype=idtype, device=F.ctx())
+    return g
+
 def mfunc(edges):
     return {'m' : edges.src['x']}
 
@@ -15,7 +19,7 @@ def rfunc(nodes):
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU not implemented")
 @parametrize_dtype
 def test_prop_nodes_bfs(idtype):
-    g = dgl.graph(nx.path_graph(5), idtype=idtype, device=F.ctx())
+    g = create_graph(idtype)
     g.ndata['x'] = F.ones((5, 2))
     dgl.prop_nodes_bfs(g, 0, message_func=mfunc, reduce_func=rfunc, apply_node_func=None)
     # pull nodes using bfs order will result in a cumsum[i] + data[i] + data[i+1]
@@ -25,7 +29,7 @@ def test_prop_nodes_bfs(idtype):
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU not implemented")
 @parametrize_dtype
 def test_prop_edges_dfs(idtype):
-    g = dgl.graph(nx.path_graph(5), idtype=idtype, device=F.ctx())
+    g = create_graph(idtype)
     g.ndata['x'] = F.ones((5, 2))
     dgl.prop_edges_dfs(g, 0, message_func=mfunc, reduce_func=rfunc, apply_node_func=None)
     # snr using dfs results in a cumsum
@@ -48,7 +52,7 @@ def test_prop_edges_dfs(idtype):
 @parametrize_dtype
 def test_prop_nodes_topo(idtype):
     # bi-directional chain
-    g = dgl.graph(nx.path_graph(5), idtype=idtype, device=F.ctx())
+    g = create_graph(idtype)
     assert U.check_fail(dgl.prop_nodes_topo, g)  # has loop
 
     # tree

tests/compute/test_randomwalk.py

@@ -60,11 +60,17 @@ def test_random_walk_with_restart():
             trace_diff = np.diff(F.zerocopy_to_numpy(t), axis=-1)
             assert (trace_diff % 2 == 0).all()
 
-@parametrize_dtype
-def test_metapath_random_walk(idtype):
-    g1 = dgl.bipartite(([0, 1, 2, 3], [0, 1, 2, 3]), 'a', 'ab', 'b', idtype=idtype)
-    g2 = dgl.bipartite(([0, 0, 1, 1, 2, 2, 3, 3], [1, 3, 2, 0, 3, 1, 0, 2]), 'b', 'ba', 'a', idtype=idtype)
-    G = dgl.hetero_from_relations([g1, g2])
+def test_metapath_random_walk(idtype=F.int32):
+    g1 = dgl.heterograph({
+        ('a', 'ab', 'b'): ([0, 1, 2, 3], [0, 1, 2, 3])
+    }, idtype=idtype)
+    g2 = dgl.heterograph({
+        ('b', 'ba', 'a'): ([0, 0, 1, 1, 2, 2, 3, 3], [1, 3, 2, 0, 3, 1, 0, 2])
+    }, idtype=idtype)
+    G = dgl.heterograph({
+        ('a', 'ab', 'b'): ([0, 1, 2, 3], [0, 1, 2, 3]),
+        ('b', 'ba', 'a'): ([0, 0, 1, 1, 2, 2, 3, 3], [1, 3, 2, 0, 3, 1, 0, 2])
+    }, idtype=idtype)
     seeds = [0, 1]
     traces = dgl.contrib.sampling.metapath_random_walk(G, ['ab', 'ba'] * 4, seeds, 3)
     for seed, traces_per_seed in zip(seeds, traces):

tests/compute/test_sampling.py

@@ -23,19 +23,19 @@ def check_random_walk(g, metapath, traces, ntypes, prob=None):
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU random walk not implemented")
 def test_random_walk():
     g1 = dgl.heterograph({
-        ('user', 'follow', 'user'): [(0, 1), (1, 2), (2, 0)]
+        ('user', 'follow', 'user'): ([0, 1, 2], [1, 2, 0])
         })
     g2 = dgl.heterograph({
-        ('user', 'follow', 'user'): [(0, 1), (1, 2), (1, 3), (2, 0), (3, 0)]
+        ('user', 'follow', 'user'): ([0, 1, 1, 2, 3], [1, 2, 3, 0, 0])
         })
     g3 = dgl.heterograph({
-        ('user', 'follow', 'user'): [(0, 1), (1, 2), (2, 0)],
-        ('user', 'view', 'item'): [(0, 0), (1, 1), (2, 2)],
-        ('item', 'viewed-by', 'user'): [(0, 0), (1, 1), (2, 2)]})
+        ('user', 'follow', 'user'): ([0, 1, 2], [1, 2, 0]),
+        ('user', 'view', 'item'): ([0, 1, 2], [0, 1, 2]),
+        ('item', 'viewed-by', 'user'): ([0, 1, 2], [0, 1, 2])})
     g4 = dgl.heterograph({
-        ('user', 'follow', 'user'): [(0, 1), (1, 2), (1, 3), (2, 0), (3, 0)],
-        ('user', 'view', 'item'): [(0, 0), (0, 1), (1, 1), (2, 2), (3, 2), (3, 1)],
-        ('item', 'viewed-by', 'user'): [(0, 0), (1, 0), (1, 1), (2, 2), (2, 3), (1, 3)]})
+        ('user', 'follow', 'user'): ([0, 1, 1, 2, 3], [1, 2, 3, 0, 0]),
+        ('user', 'view', 'item'): ([0, 0, 1, 2, 3, 3], [0, 1, 1, 2, 2, 1]),
+        ('item', 'viewed-by', 'user'): ([0, 1, 1, 2, 2, 1], [0, 0, 1, 2, 3, 3])})
 
     g2.edata['p'] = F.tensor([3, 0, 3, 3, 3], dtype=F.float32)
     g2.edata['p2'] = F.tensor([[3], [0], [3], [3], [3]], dtype=F.float32)
@@ -124,8 +124,8 @@ def test_pinsage_sampling():
         assert (2, 2) in uv or (3, 2) in uv
 
     g = dgl.heterograph({
-        ('item', 'bought-by', 'user'): [(0, 0), (0, 1), (1, 0), (1, 1), (2, 2), (2, 3), (3, 2), (3, 3)],
-        ('user', 'bought', 'item'): [(0, 0), (1, 0), (0, 1), (1, 1), (2, 2), (3, 2), (2, 3), (3, 3)]})
+        ('item', 'bought-by', 'user'): ([0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 0, 1, 2, 3, 2, 3]),
+        ('user', 'bought', 'item'): ([0, 1, 0, 1, 2, 3, 2, 3], [0, 0, 1, 1, 2, 2, 3, 3])})
     sampler = dgl.sampling.PinSAGESampler(g, 'item', 'user', 4, 0.5, 3, 2)
     _test_sampler(g, sampler, 'item')
     sampler = dgl.sampling.RandomWalkNeighborSampler(g, 4, 0.5, 3, 2, ['bought-by', 'bought'])
@@ -133,13 +133,14 @@ def test_pinsage_sampling():
     sampler = dgl.sampling.RandomWalkNeighborSampler(g, 4, 0.5, 3, 2, 
         [('item', 'bought-by', 'user'), ('user', 'bought', 'item')])
     _test_sampler(g, sampler, 'item')
-    g = dgl.graph([(0, 0), (0, 1), (1, 0), (1, 1), (2, 2), (2, 3), (3, 2), (3, 3)])
+    g = dgl.graph(([0, 0, 1, 1, 2, 2, 3, 3],
+                   [0, 1, 0, 1, 2, 3, 2, 3]))
     sampler = dgl.sampling.RandomWalkNeighborSampler(g, 4, 0.5, 3, 2)
     _test_sampler(g, sampler, g.ntypes[0])
     g = dgl.heterograph({
-        ('A', 'AB', 'B'): [(0, 1), (2, 3)],
-        ('B', 'BC', 'C'): [(1, 2), (3, 1)],
-        ('C', 'CA', 'A'): [(2, 0), (1, 2)]})
+        ('A', 'AB', 'B'): ([0, 2], [1, 3]),
+        ('B', 'BC', 'C'): ([1, 3], [2, 1]),
+        ('C', 'CA', 'A'): ([2, 1], [0, 2])})
     sampler = dgl.sampling.RandomWalkNeighborSampler(g, 4, 0.5, 3, 2, ['AB', 'BC', 'CA'])
     _test_sampler(g, sampler, 'A')
 
@@ -147,68 +148,76 @@ def _gen_neighbor_sampling_test_graph(hypersparse, reverse):
     if hypersparse:
         # should crash if allocated a CSR
         card = 1 << 50
-        card2 = (1 << 50, 1 << 50)
+        num_nodes_dict = {'user': card, 'game': card, 'coin': card}
     else:
         card = None
-        card2 = None
-    
+        num_nodes_dict = None
+
     if reverse:
-        g = dgl.graph([(0,1),(0,2),(0,3),(1,0),(1,2),(1,3),(2,0)],
-                'user', 'follow', num_nodes=card)
+        g = dgl.heterograph({
+            ('user', 'follow', 'user'): ([0, 0, 0, 1, 1, 1, 2], [1, 2, 3, 0, 2, 3, 0])
+        }, {'user': card if card is not None else 4})
         g.edata['prob'] = F.tensor([.5, .5, 0., .5, .5, 0., 1.], dtype=F.float32)
-        g1 = dgl.bipartite([(0,0),(1,0),(2,1),(2,3)], 'game', 'play', 'user', num_nodes=card2)
-        g1.edata['prob'] = F.tensor([.8, .5, .5, .5], dtype=F.float32)
-        g2 = dgl.bipartite([(0,2),(1,2),(2,2),(0,1),(3,1),(0,0)], 'user', 'liked-by', 'game', num_nodes=card2)
-        g2.edata['prob'] = F.tensor([.3, .5, .2, .5, .1, .1], dtype=F.float32)
-        g3 = dgl.bipartite([(0,0),(0,1),(0,2),(0,3)], 'coin', 'flips', 'user', num_nodes=card2)
-
-        hg = dgl.hetero_from_relations([g, g1, g2, g3])
+        hg = dgl.heterograph({
+            ('user', 'follow', 'user'): ([0, 0, 0, 1, 1, 1, 2],
+                                         [1, 2, 3, 0, 2, 3, 0]),
+            ('game', 'play', 'user'): ([0, 1, 2, 2], [0, 0, 1, 3]),
+            ('user', 'liked-by', 'game'): ([0, 1, 2, 0, 3, 0], [2, 2, 2, 1, 1, 0]),
+            ('coin', 'flips', 'user'): ([0, 0, 0, 0], [0, 1, 2, 3])
+        }, num_nodes_dict)
     else:
-        g = dgl.graph([(1,0),(2,0),(3,0),(0,1),(2,1),(3,1),(0,2)],
-                'user', 'follow', num_nodes=card)
+        g = dgl.heterograph({
+            ('user', 'follow', 'user'): ([1, 2, 3, 0, 2, 3, 0], [0, 0, 0, 1, 1, 1, 2])
+        }, {'user': card if card is not None else 4})
         g.edata['prob'] = F.tensor([.5, .5, 0., .5, .5, 0., 1.], dtype=F.float32)
-        g1 = dgl.bipartite([(0,0),(0,1),(1,2),(3,2)], 'user', 'play', 'game', num_nodes=card2)
-        g1.edata['prob'] = F.tensor([.8, .5, .5, .5], dtype=F.float32)
-        g2 = dgl.bipartite([(2,0),(2,1),(2,2),(1,0),(1,3),(0,0)], 'game', 'liked-by', 'user', num_nodes=card2)
-        g2.edata['prob'] = F.tensor([.3, .5, .2, .5, .1, .1], dtype=F.float32)
-        g3 = dgl.bipartite([(0,0),(1,0),(2,0),(3,0)], 'user', 'flips', 'coin', num_nodes=card2)
+        hg = dgl.heterograph({
+            ('user', 'follow', 'user'): ([1, 2, 3, 0, 2, 3, 0],
+                                         [0, 0, 0, 1, 1, 1, 2]),
+            ('user', 'play', 'game'): ([0, 0, 1, 3], [0, 1, 2, 2]),
+            ('game', 'liked-by', 'user'): ([2, 2, 2, 1, 1, 0], [0, 1, 2, 0, 3, 0]),
+            ('user', 'flips', 'coin'): ([0, 1, 2, 3], [0, 0, 0, 0])
+        }, num_nodes_dict)
+    hg.edges['follow'].data['prob'] = F.tensor([.5, .5, 0., .5, .5, 0., 1.], dtype=F.float32)
+    hg.edges['play'].data['prob'] = F.tensor([.8, .5, .5, .5], dtype=F.float32)
+    hg.edges['liked-by'].data['prob'] = F.tensor([.3, .5, .2, .5, .1, .1], dtype=F.float32)
 
-        hg = dgl.hetero_from_relations([g, g1, g2, g3])
     return g, hg
 
 def _gen_neighbor_topk_test_graph(hypersparse, reverse):
     if hypersparse:
         # should crash if allocated a CSR
         card = 1 << 50
-        card2 = (1 << 50, 1 << 50)
     else:
         card = None
-        card2 = None
- 
+
     if reverse:
-        g = dgl.graph([(0,1),(0,2),(0,3),(1,0),(1,2),(1,3),(2,0)],
-                'user', 'follow')
+        g = dgl.heterograph({
+            ('user', 'follow', 'user'): ([0, 0, 0, 1, 1, 1, 2], [1, 2, 3, 0, 2, 3, 0])
+        })
         g.edata['weight'] = F.tensor([.5, .3, 0., -5., 22., 0., 1.], dtype=F.float32)
-        g1 = dgl.bipartite([(0,0),(1,0),(2,1),(2,3)], 'game', 'play', 'user')
-        g1.edata['weight'] = F.tensor([.8, .5, .4, .5], dtype=F.float32)
-        g2 = dgl.bipartite([(0,2),(1,2),(2,2),(0,1),(3,1),(0,0)], 'user', 'liked-by', 'game')
-        g2.edata['weight'] = F.tensor([.3, .5, .2, .5, .1, .1], dtype=F.float32)
-        g3 = dgl.bipartite([(0,0),(0,1),(0,2),(0,3)], 'coin', 'flips', 'user')
-        g3.edata['weight'] = F.tensor([10, 2, 13, -1], dtype=F.float32)
-
-        hg = dgl.hetero_from_relations([g, g1, g2, g3])
+        hg = dgl.heterograph({
+            ('user', 'follow', 'user'): ([0, 0, 0, 1, 1, 1, 2],
+                                         [1, 2, 3, 0, 2, 3, 0]),
+            ('game', 'play', 'user'): ([0, 1, 2, 2], [0, 0, 1, 3]),
+            ('user', 'liked-by', 'game'): ([0, 1, 2, 0, 3, 0], [2, 2, 2, 1, 1, 0]),
+            ('coin', 'flips', 'user'): ([0, 0, 0, 0], [0, 1, 2, 3])
+        })
     else:
-        g = dgl.graph([(1,0),(2,0),(3,0),(0,1),(2,1),(3,1),(0,2)],
-                'user', 'follow')
+        g = dgl.heterograph({
+            ('user', 'follow', 'user'): ([1, 2, 3, 0, 2, 3, 0], [0, 0, 0, 1, 1, 1, 2])
+        })
         g.edata['weight'] = F.tensor([.5, .3, 0., -5., 22., 0., 1.], dtype=F.float32)
-        g1 = dgl.bipartite([(0,0),(0,1),(1,2),(3,2)], 'user', 'play', 'game')
-        g1.edata['weight'] = F.tensor([.8, .5, .4, .5], dtype=F.float32)
-        g2 = dgl.bipartite([(2,0),(2,1),(2,2),(1,0),(1,3),(0,0)], 'game', 'liked-by', 'user')
-        g2.edata['weight'] = F.tensor([.3, .5, .2, .5, .1, .1], dtype=F.float32)
-        g3 = dgl.bipartite([(0,0),(1,0),(2,0),(3,0)], 'user', 'flips', 'coin')
-        g3.edata['weight'] = F.tensor([10, 2, 13, -1], dtype=F.float32)
-
-        hg = dgl.hetero_from_relations([g, g1, g2, g3])
+        hg = dgl.heterograph({
+            ('user', 'follow', 'user'): ([1, 2, 3, 0, 2, 3, 0],
+                                         [0, 0, 0, 1, 1, 1, 2]),
+            ('user', 'play', 'game'): ([0, 0, 1, 3], [0, 1, 2, 2]),
+            ('game', 'liked-by', 'user'): ([2, 2, 2, 1, 1, 0], [0, 1, 2, 0, 3, 0]),
+            ('user', 'flips', 'coin'): ([0, 1, 2, 3], [0, 0, 0, 0])
+        })
+    hg.edges['follow'].data['weight'] = F.tensor([.5, .3, 0., -5., 22., 0., 1.], dtype=F.float32)
+    hg.edges['play'].data['weight'] = F.tensor([.8, .5, .4, .5], dtype=F.float32)
+    hg.edges['liked-by'].data['weight'] = F.tensor([.3, .5, .2, .5, .1, .1], dtype=F.float32)
+    hg.edges['flips'].data['weight'] = F.tensor([10, 2, 13, -1], dtype=F.float32)
     return g, hg
 
 def _test_sample_neighbors(hypersparse):
@@ -541,7 +550,7 @@ def test_sample_neighbors_topk_outedge():
 
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU sample neighbors not implemented")
 def test_sample_neighbors_with_0deg():
-    g = dgl.graph([], num_nodes=5)
+    g = dgl.graph(([], []), num_nodes=5)
     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
     sg = dgl.sampling.sample_neighbors(g, F.tensor([1, 2], dtype=F.int64), 2, edge_dir='in', replace=True)

tests/compute/test_serialize.py

@@ -19,7 +19,7 @@ def generate_rand_graph(n, is_hetero):
     arr = (sp.sparse.random(n, n, density=0.1,
                             format='coo') != 0).astype(np.int64)
     if is_hetero:
-        return dgl.graph(arr)
+        return dgl.from_scipy(arr)
     else:
         return DGLGraph(arr, readonly=True)
 
@@ -218,26 +218,44 @@ def test_load_old_files2():
 
 
 def create_heterographs(idtype):
-    g_x = dgl.graph(([0, 1, 2], [1, 2, 3]), 'user',
-                    'follows', idtype=idtype)
-    g_y = dgl.graph(([0, 2], [2, 3]), 'user', 'knows', idtype=idtype).formats('csr')
-    g_x.nodes['user'].data['h'] = F.randn((4, 3))
-    g_x.edges['follows'].data['w'] = F.randn((3, 2))
-    g_y.nodes['user'].data['hh'] = F.ones((4, 5))
-    g_y.edges['knows'].data['ww'] = F.randn((2, 10))
-    g = dgl.hetero_from_relations([g_x, g_y])
+    g_x = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1, 2], [1, 2, 3])}, idtype=idtype)
+    g_y = dgl.heterograph({
+        ('user', 'knows', 'user'): ([0, 2], [2, 3])}, idtype=idtype).formats('csr')
+    g_x.ndata['h'] = F.randn((4, 3))
+    g_x.edata['w'] = F.randn((3, 2))
+    g_y.ndata['hh'] = F.ones((4, 5))
+    g_y.edata['ww'] = F.randn((2, 10))
+    g = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1, 2], [1, 2, 3]),
+        ('user', 'knows', 'user'): ([0, 2], [2, 3])
+    }, idtype=idtype)
+    g.nodes['user'].data['h'] = g_x.ndata['h']
+    g.nodes['user'].data['hh'] = g_y.ndata['hh']
+    g.edges['follows'].data['w'] = g_x.edata['w']
+    g.edges['knows'].data['ww'] = g_y.edata['ww']
     return [g, g_x, g_y]
 
 def create_heterographs2(idtype):
-    g_x = dgl.graph(([0, 1, 2], [1, 2, 3]), 'user',
-                    'follows', idtype=idtype)
-    g_y = dgl.graph(([0, 2], [2, 3]), 'user', 'knows', idtype=idtype).formats('csr')
-    g_z = dgl.bipartite(([0, 1, 3], [2, 3, 4]), 'user', 'knows', 'knowledge', idtype=idtype)
-    g_x.nodes['user'].data['h'] = F.randn((4, 3))
-    g_x.edges['follows'].data['w'] = F.randn((3, 2))
-    g_y.nodes['user'].data['hh'] = F.ones((4, 5))
-    g_y.edges['knows'].data['ww'] = F.randn((2, 10))
-    g = dgl.hetero_from_relations([g_x, g_y, g_z])
+    g_x = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1, 2], [1, 2, 3])}, idtype=idtype)
+    g_y = dgl.heterograph({
+        ('user', 'knows', 'user'): ([0, 2], [2, 3])}, idtype=idtype).formats('csr')
+    g_z = dgl.heterograph(
+        {('user', 'knows', 'knowledge'): ([0, 1, 3], [2, 3, 4])}, idtype=idtype)
+    g_x.ndata['h'] = F.randn((4, 3))
+    g_x.edata['w'] = F.randn((3, 2))
+    g_y.ndata['hh'] = F.ones((4, 5))
+    g_y.edata['ww'] = F.randn((2, 10))
+    g = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1, 2], [1, 2, 3]),
+        ('user', 'knows', 'user'): ([0, 2], [2, 3]),
+        ('user', 'knows', 'knowledge'): ([0, 1, 3], [2, 3, 4])
+    }, idtype=idtype)
+    g.nodes['user'].data['h'] = g_x.ndata['h']
+    g.edges['follows'].data['w'] = g_x.edata['w']
+    g.nodes['user'].data['hh'] = g_y.ndata['hh']
+    g.edges[('user', 'knows', 'user')].data['ww'] = g_y.edata['ww']
     return [g, g_x, g_y, g_z]
 
 def test_deserialize_old_heterograph_file():

tests/compute/test_shared_mem.py

@@ -14,18 +14,12 @@ import multiprocessing as mp
 import os
 
 def create_test_graph(idtype):
-    plays_spmat = ssp.coo_matrix(([1, 1, 1, 1], ([0, 1, 2, 1], [0, 0, 1, 1])))
-    wishes_nx = nx.DiGraph()
-    wishes_nx.add_nodes_from(['u0', 'u1', 'u2'], bipartite=0)
-    wishes_nx.add_nodes_from(['g0', 'g1'], bipartite=1)
-    wishes_nx.add_edge('u0', 'g1', id=0)
-    wishes_nx.add_edge('u2', 'g0', id=1)
-
-    follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows', idtype=idtype)
-    plays_g = dgl.bipartite(plays_spmat, 'user', 'plays', 'game', idtype=idtype)
-    wishes_g = dgl.bipartite(wishes_nx, 'user', 'wishes', 'game', idtype=idtype)
-    develops_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game', idtype=idtype)
-    g = dgl.hetero_from_relations([follows_g, plays_g, wishes_g, develops_g])
+    g = dgl.heterograph(({
+        ('user', 'follows', 'user'): ([0, 1], [1, 2]),
+        ('user', 'plays', 'game'): ([0, 1, 2, 1], [0, 0, 1, 1]),
+        ('user', 'wishes', 'game'): ([0, 2], [1, 0]),
+        ('developer', 'develops', 'game'): ([0, 1], [0, 1])
+    }), idtype=idtype)
     return g
 
 def _assert_is_identical_hetero(g, g2):

tests/compute/test_sparse.py

@@ -71,7 +71,7 @@ udf_reduce = {
 graphs = [
 #    dgl.rand_graph(30, 0),
     dgl.rand_graph(30, 100),
-    dgl.rand_bipartite(30, 40, 300)
+    dgl.rand_bipartite('_U', '_E', '_V', 30, 40, 300)
 ]
 
 spmm_shapes = [

tests/compute/test_subgraph.py

@@ -94,22 +94,12 @@ def create_test_heterograph(idtype):
     #    ('user', 'wishes', 'game'),
     #    ('developer', 'develops', 'game')])
 
-    plays_spmat = ssp.coo_matrix(([1, 1, 1, 1], ([0, 1, 2, 1], [0, 0, 1, 1])))
-    wishes_nx = nx.DiGraph()
-    wishes_nx.add_nodes_from(['u0', 'u1', 'u2'], bipartite=0)
-    wishes_nx.add_nodes_from(['g0', 'g1'], bipartite=1)
-    wishes_nx.add_edge('u0', 'g1', id=0)
-    wishes_nx.add_edge('u2', 'g0', id=1)
-
-    follows_g = dgl.graph([(0, 1), (1, 2)], 'user', 'follows', idtype=idtype, device=F.ctx())
-    plays_g = dgl.bipartite(plays_spmat, 'user', 'plays', 'game', idtype=idtype, device=F.ctx())
-    wishes_g = dgl.bipartite(wishes_nx, 'user', 'wishes', 'game', idtype=idtype, device=F.ctx())
-    develops_g = dgl.bipartite([(0, 0), (1, 1)], 'developer', 'develops', 'game', idtype=idtype, device=F.ctx())
-    assert follows_g.idtype == idtype
-    assert plays_g.idtype == idtype
-    assert wishes_g.idtype == idtype
-    assert develops_g.idtype == idtype
-    g = dgl.hetero_from_relations([follows_g, plays_g, wishes_g, develops_g])
+    g = dgl.heterograph({
+        ('user', 'follows', 'user'): ([0, 1], [1, 2]),
+        ('user', 'plays', 'game'): ([0, 1, 2, 1], [0, 0, 1, 1]),
+        ('user', 'wishes', 'game'): ([0, 2], [1, 0]),
+        ('developer', 'develops', 'game'): ([0, 1], [0, 1])
+    }, idtype=idtype, device=F.ctx())
     assert g.idtype == idtype
     assert g.device == F.ctx()
     return g
@@ -310,7 +300,7 @@ def test_subgraph1(idtype):
     if F._default_context_str != 'gpu':
         # TODO(minjie): enable this later
         for fmt in ['csr', 'csc', 'coo']:
-            g = dgl.graph([(0, 1), (1, 2)]).formats(fmt)
+            g = dgl.graph(([0, 1], [1, 2])).formats(fmt)
             sg = g.subgraph({g.ntypes[0]: [1, 0]})
             nids = F.asnumpy(sg.ndata[dgl.NID])
             assert np.array_equal(nids, np.array([1, 0]))
@@ -323,11 +313,12 @@ def test_subgraph1(idtype):
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU not implemented")
 @parametrize_dtype
 def test_in_subgraph(idtype):
-    g1 = dgl.graph([(1,0),(2,0),(3,0),(0,1),(2,1),(3,1),(0,2)], 'user', 'follow', idtype=idtype)
-    g2 = dgl.bipartite([(0,0),(0,1),(1,2),(3,2)], 'user', 'play', 'game', idtype=idtype)
-    g3 = dgl.bipartite([(2,0),(2,1),(2,2),(1,0),(1,3),(0,0)], 'game', 'liked-by', 'user', idtype=idtype)
-    g4 = dgl.bipartite([(0,0),(1,0),(2,0),(3,0)], 'user', 'flips', 'coin', idtype=idtype)
-    hg = dgl.hetero_from_relations([g1, g2, g3, g4])
+    hg = dgl.heterograph({
+        ('user', 'follow', 'user'): ([1, 2, 3, 0, 2, 3, 0], [0, 0, 0, 1, 1, 1, 2]),
+        ('user', 'play', 'game'): ([0, 0, 1, 3], [0, 1, 2, 2]),
+        ('game', 'liked-by', 'user'): ([2, 2, 2, 1, 1, 0], [0, 1, 2, 0, 3, 0]),
+        ('user', 'flips', 'coin'): ([0, 1, 2, 3], [0, 0, 0, 0])
+    }, idtype=idtype)
     subg = dgl.in_subgraph(hg, {'user' : [0,1], 'game' : 0})
     assert subg.idtype == idtype
     assert len(subg.ntypes) == 3
@@ -349,11 +340,12 @@ def test_in_subgraph(idtype):
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU not implemented")
 @parametrize_dtype
 def test_out_subgraph(idtype):
-    g1 = dgl.graph([(1,0),(2,0),(3,0),(0,1),(2,1),(3,1),(0,2)], 'user', 'follow', idtype=idtype)
-    g2 = dgl.bipartite([(0,0),(0,1),(1,2),(3,2)], 'user', 'play', 'game', idtype=idtype)
-    g3 = dgl.bipartite([(2,0),(2,1),(2,2),(1,0),(1,3),(0,0)], 'game', 'liked-by', 'user', idtype=idtype)
-    g4 = dgl.bipartite([(0,0),(1,0),(2,0),(3,0)], 'user', 'flips', 'coin', idtype=idtype)
-    hg = dgl.hetero_from_relations([g1, g2, g3, g4])
+    hg = dgl.heterograph({
+        ('user', 'follow', 'user'): ([1, 2, 3, 0, 2, 3, 0], [0, 0, 0, 1, 1, 1, 2]),
+        ('user', 'play', 'game'): ([0, 0, 1, 3], [0, 1, 2, 2]),
+        ('game', 'liked-by', 'user'): ([2, 2, 2, 1, 1, 0], [0, 1, 2, 0, 3, 0]),
+        ('user', 'flips', 'coin'): ([0, 1, 2, 3], [0, 0, 0, 0])
+    }, idtype=idtype)
     subg = dgl.out_subgraph(hg, {'user' : [0,1], 'game' : 0})
     assert subg.idtype == idtype
     assert len(subg.ntypes) == 3

tests/compute/test_traversal.py

@@ -30,7 +30,7 @@ def test_bfs(idtype, n=100):
         for u, v in edges:
             if u in layers_nx[-1]:
                 frontier.add(v)
-                edge_frontier.add(g.edge_ids(u, v))
+                edge_frontier.add(g.edge_ids(int(u), int(v)))
             else:
                 layers_nx.append(frontier)
                 edges_nx.append(edge_frontier)
@@ -43,7 +43,7 @@ def test_bfs(idtype, n=100):
         return layers_nx, edges_nx
 
     a = sp.random(n, n, 3 / n, data_rvs=lambda n: np.ones(n))
-    g = dgl.graph(a).astype(idtype)
+    g = dgl.from_scipy(a).astype(idtype)
 
     g_nx = g.to_networkx()
     src = random.choice(range(n))
@@ -53,7 +53,7 @@ def test_bfs(idtype, n=100):
     assert all(toset(x) == y for x, y in zip(layers_dgl, layers_nx))
 
     g_nx = nx.random_tree(n, seed=42)
-    g = dgl.graph(g_nx).astype(idtype)
+    g = dgl.from_networkx(g_nx).astype(idtype)
     src = 0
     _, edges_nx = _bfs_nx(g_nx, src)
     edges_dgl = dgl.bfs_edges_generator(g, src)
@@ -65,7 +65,7 @@ def test_bfs(idtype, n=100):
 def test_topological_nodes(idtype, n=100):
     a = sp.random(n, n, 3 / n, data_rvs=lambda n: np.ones(n))
     b = sp.tril(a, -1).tocoo()
-    g = dgl.graph(b).astype(idtype)
+    g = dgl.from_scipy(b).astype(idtype)
 
     layers_dgl = dgl.topological_nodes_generator(g)
 

tests/distributed/test_dist_graph_store.py

@@ -51,7 +51,7 @@ def get_local_usable_addr():
 
 def create_random_graph(n):
     arr = (spsp.random(n, n, density=0.001, format='coo', random_state=100) != 0).astype(np.int64)
-    return dgl.graph(arr)
+    return dgl.from_scipy(arr)
 
 def run_server(graph_name, server_id, server_count, num_clients, shared_mem):
     g = DistGraphServer(server_id, "kv_ip_config.txt", num_clients, server_count,

tests/distributed/test_partition.py

@@ -14,7 +14,7 @@ import random
 
 def create_random_graph(n):
     arr = (spsp.random(n, n, density=0.001, format='coo', random_state=100) != 0).astype(np.int64)
-    return dgl.graph(arr)
+    return dgl.from_scipy(arr)
 
 def check_partition(g, part_method, reshuffle):
     g.ndata['labels'] = F.arange(0, g.number_of_nodes())

tests/pytorch/test_dataloader.py

@@ -72,18 +72,19 @@ def _check_neighbor_sampling_dataloader(g, nids, dl, mode):
 
 @unittest.skipIf(F._default_context_str == 'gpu', reason="GPU sample neighbors not implemented")
 def test_neighbor_sampler_dataloader():
-    g = dgl.graph([(0,1),(0,2),(0,3),(1,3),(1,4)],
-            'user', 'follow', num_nodes=6).long()
+    g = dgl.heterograph({('user', 'follow', 'user'): ([0, 0, 0, 1, 1], [1, 2, 3, 3, 4])}, 
+                        {'user': 6}).long()
     g = dgl.to_bidirected(g)
     reverse_eids = F.tensor([5, 6, 7, 8, 9, 0, 1, 2, 3, 4], dtype=F.int64)
     g_sampler1 = dgl.dataloading.MultiLayerNeighborSampler([2, 2], return_eids=True)
     g_sampler2 = dgl.dataloading.MultiLayerFullNeighborSampler(2, return_eids=True)
 
     hg = dgl.heterograph({
-        ('user', 'follow', 'user'): [(0, 1), (0, 2), (0, 3), (1, 0), (1, 2), (1, 3), (2, 0)],
-        ('user', 'followed-by', 'user'): [(1, 0), (2, 0), (3, 0), (0, 1), (2, 1), (3, 1), (0, 2)],
-        ('user', 'play', 'game'): [(0, 0), (1, 1), (1, 2), (3, 0), (5, 2)],
-        ('game', 'played-by', 'user'): [(0, 0), (1, 1), (2, 1), (0, 3), (2, 5)]}).long()
+         ('user', 'follow', 'user'): ([0, 0, 0, 1, 1, 1, 2], [1, 2, 3, 0, 2, 3, 0]),
+         ('user', 'followed-by', 'user'): ([1, 2, 3, 0, 2, 3, 0], [0, 0, 0, 1, 1, 1, 2]),
+         ('user', 'play', 'game'): ([0, 1, 1, 3, 5], [0, 1, 2, 0, 2]),
+         ('game', 'played-by', 'user'): ([0, 1, 2, 0, 2], [0, 1, 1, 3, 5])
+    }).long()
     hg_sampler1 = dgl.dataloading.MultiLayerNeighborSampler(
         [{'play': 1, 'played-by': 1, 'follow': 2, 'followed-by': 1}] * 2, return_eids=True)
     hg_sampler2 = dgl.dataloading.MultiLayerFullNeighborSampler(2, return_eids=True)

tests/pytorch/test_ipc.py

@@ -10,7 +10,7 @@ def sub_ipc(g):
 
 @unittest.skipIf(os.name == 'nt', reason='Do not support windows yet')
 def test_torch_ipc():
-    g = dgl.graph([(0, 1), (1, 2), (2, 3)])
+    g = dgl.graph(([0, 1, 2], [1, 2, 3]))
     ctx = mp.get_context("spawn")
     p = ctx.Process(target=sub_ipc, args=(g, ))
 

tests/pytorch/test_nn.py

@@ -419,7 +419,7 @@ def test_sage_conv_bi(idtype, g, aggre_type):
 def test_sage_conv2(idtype):
     # TODO: add test for blocks
     # Test the case for graphs without edges
-    g = dgl.bipartite([], num_nodes=(5, 3))
+    g = dgl.heterograph({('_U', '_E', '_V'): ([], [])}, {'_U': 5, '_V': 3})
     g = g.astype(idtype).to(F.ctx())
     ctx = F.ctx()
     sage = nn.SAGEConv((3, 3), 2, 'gcn')
@@ -776,9 +776,9 @@ def myagg(alist, dsttype):
 @pytest.mark.parametrize('agg', ['sum', 'max', 'min', 'mean', 'stack', myagg])
 def test_hetero_conv(agg, idtype):
     g = dgl.heterograph({
-        ('user', 'follows', 'user'): [(0, 1), (0, 2), (2, 1), (1, 3)],
-        ('user', 'plays', 'game'): [(0, 0), (0, 2), (0, 3), (1, 0), (2, 2)],
-        ('store', 'sells', 'game'): [(0, 0), (0, 3), (1, 1), (1, 2)]},
+        ('user', 'follows', 'user'): ([0, 0, 2, 1], [1, 2, 1, 3]),
+        ('user', 'plays', 'game'): ([0, 0, 0, 1, 2], [0, 2, 3, 0, 2]),
+        ('store', 'sells', 'game'): ([0, 0, 1, 1], [0, 3, 1, 2])},
         idtype=idtype, device=F.ctx())
     conv = nn.HeteroGraphConv({
         'follows': nn.GraphConv(2, 3, allow_zero_in_degree=True),
@@ -789,8 +789,6 @@ def test_hetero_conv(agg, idtype):
     uf = F.randn((4, 2))
     gf = F.randn((4, 4))
     sf = F.randn((2, 3))
-    uf_dst = F.randn((4, 3))
-    gf_dst = F.randn((4, 4))
 
     h = conv(g, {'user': uf})
     assert set(h.keys()) == {'user', 'game'}
@@ -897,4 +895,4 @@ if __name__ == '__main__':
     test_dense_cheb_conv()
     test_sequential()
     test_atomic_conv()
-    test_cf_conv()
\ No newline at end of file
+    test_cf_conv()

tests/tensorflow/test_nn.py

@@ -304,7 +304,7 @@ def test_sage_conv_bi(idtype, g, aggre_type):
 @pytest.mark.parametrize('aggre_type', ['mean', 'pool', 'gcn'])
 def test_sage_conv_bi_empty(idtype, aggre_type):
     # Test the case for graphs without edges
-    g = dgl.bipartite([], num_nodes=(5, 3)).to(F.ctx())
+    g = dgl.heterograph({('_U', '_E', '_V'): ([], [])}, {'_U': 5, '_V': 3}).to(F.ctx())
     g = g.astype(idtype).to(F.ctx())
     sage = nn.SAGEConv((3, 3), 2, 'gcn')
     feat = (F.randn((5, 3)), F.randn((3, 3)))
@@ -385,9 +385,9 @@ def myagg(alist, dsttype):
 @pytest.mark.parametrize('agg', ['sum', 'max', 'min', 'mean', 'stack', myagg])
 def test_hetero_conv(agg, idtype):
     g = dgl.heterograph({
-        ('user', 'follows', 'user'): [(0, 1), (0, 2), (2, 1), (1, 3)],
-        ('user', 'plays', 'game'): [(0, 0), (0, 2), (0, 3), (1, 0), (2, 2)],
-        ('store', 'sells', 'game'): [(0, 0), (0, 3), (1, 1), (1, 2)]},
+        ('user', 'follows', 'user'): ([0, 0, 2, 1], [1, 2, 1, 3]),
+        ('user', 'plays', 'game'): ([0, 0, 0, 1, 2], [0, 2, 3, 0, 2]),
+        ('store', 'sells', 'game'): ([0, 0, 1, 1], [0, 3, 1, 2])},
         idtype=idtype, device=F.ctx())
     conv = nn.HeteroGraphConv({
         'follows': nn.GraphConv(2, 3, allow_zero_in_degree=True),

tutorials/basics/2_basics.py

@@ -135,7 +135,7 @@ g.edata['w'][th.tensor([0, 1, 2])] = th.zeros(3, 2)
 g.edata['w'][g.edge_id(1, 0)] = th.ones(1, 2)                   # edge 1 -> 0
 g.edata['w'][g.edge_ids([1, 2, 3], [0, 0, 0])] = th.ones(3, 2)  # edges [1, 2, 3] -> 0
 # Use edge broadcasting whenever applicable.
-g.edata['w'][g.edge_ids([1, 2, 3], 0)] = th.ones(3, 2)          # edges [1, 2, 3] -> 0
+g.edata['w'][g.edge_ids([1, 2, 3], [0, 0, 0])] = th.ones(3, 2)          # edges [1, 2, 3] -> 0
 
 ###############################################################################
 # After assignments, each node or edge field will be associated with a scheme